FUSE: Allow non-extending parallel direct writes
Subsystems (2)
v3 cover FUSE: Allow non-extending parallel direct writes
It is observed that currently in Fuse, for direct writes, we hold inode lock for the full duration of the request. As a result, only one direct write request can proceed on the same file. This, I think is due to various reasons such as serialization needed by USER space fuse implementations/file size issues/write failures.
This patch allows parallel writes to proceed on the same file by by holding shared lock on the non-extending writes and exlusive lock on extending writes.
For measuring performance, I carried out test on these changes over example/passthrough.c (part of libfuse) by setting direct-io and parallel_direct_writes flags on the file.
Note that we disabled write to underlying file system from passthrough as we wanted to check gain for Fuse only. Fio was used to test the impact of these changes on File-per-job and Single shared File. CPU binding was performed on passthrough process only.
Job file for SSF:
[global]
directory=/tmp/dest
filename=ssf
size=100g
blocksize=1m
ioengine=sync
group_reporting=1
fallocate=none
runtime=60
stonewall
[write]
rw=randwrite:256
rw_sequencer=sequential
fsync_on_close=1
Job file for file-per-job:
[sequential-write]
rw=write
size=100G
directory=/tmp/dest/group_reporting
name=sequential-write-direct
bs=1M
runtime=60
Results:
unpatched=================
File per job
Fri May 6 09:36:52 EDT 2022
numjobs: 1 WRITE: bw=3441MiB/s (3608MB/s), 3441MiB/s-3441MiB/s (3608MB/s-3608MB/s), io=100GiB (107GB), run=29762-29762msec
numjobs: 2 WRITE: bw=8174MiB/s (8571MB/s), 8174MiB/s-8174MiB/s (8571MB/s-8571MB/s), io=200GiB (215GB), run=25054-25054msec
numjobs: 4 WRITE: bw=14.9GiB/s (15.0GB/s), 14.9GiB/s-14.9GiB/s (15.0GB/s-15.0GB/s), io=400GiB (429GB), run=26900-26900msec
numjobs: 8 WRITE: bw=23.4GiB/s (25.2GB/s), 23.4GiB/s-23.4GiB/s (25.2GB/s-25.2GB/s), io=800GiB (859GB), run=34115-34115msec
numjobs: 16 WRITE: bw=24.5GiB/s (26.3GB/s), 24.5GiB/s-24.5GiB/s (26.3GB/s-26.3GB/s), io=1469GiB (1577GB), run=60001-60001msec
numjobs: 32 WRITE: bw=20.5GiB/s (21.0GB/s), 20.5GiB/s-20.5GiB/s (21.0GB/s-21.0GB/s), io=1229GiB (1320GB), run=60003-60003msec
SSF
Fri May 6 09:46:38 EDT 2022
numjobs: 1 WRITE: bw=3624MiB/s (3800MB/s), 3624MiB/s-3624MiB/s (3800MB/s-3800MB/s), io=100GiB (107GB), run=28258-28258msec
numjobs: 2 WRITE: bw=5801MiB/s (6083MB/s), 5801MiB/s-5801MiB/s (6083MB/s-6083MB/s), io=200GiB (215GB), run=35302-35302msec
numjobs: 4 WRITE: bw=4794MiB/s (5027MB/s), 4794MiB/s-4794MiB/s (5027MB/s-5027MB/s), io=281GiB (302GB), run=60001-60001msec
numjobs: 8 WRITE: bw=3946MiB/s (4137MB/s), 3946MiB/s-3946MiB/s (4137MB/s-4137MB/s), io=231GiB (248GB), run=60003-60003msec
numjobs: 16 WRITE: bw=4040MiB/s (4236MB/s), 4040MiB/s-4040MiB/s (4236MB/s-4236MB/s), io=237GiB (254GB), run=60006-60006msec
numjobs: 32 WRITE: bw=2822MiB/s (2959MB/s), 2822MiB/s-2822MiB/s (2959MB/s-2959MB/s), io=165GiB (178GB), run=60013-60013msec
Patched=====
File per job
Fri May 6 10:05:46 EDT 2022
numjobs: 1 WRITE: bw=3193MiB/s (3348MB/s), 3193MiB/s-3193MiB/s (3348MB/s-3348MB/s), io=100GiB (107GB), run=32068-32068msec
numjobs: 2 WRITE: bw=9084MiB/s (9525MB/s), 9084MiB/s-9084MiB/s (9525MB/s-9525MB/s), io=200GiB (215GB), run=22545-22545msec
numjobs: 4 WRITE: bw=14.8GiB/s (15.9GB/s), 14.8GiB/s-14.8GiB/s (15.9GB/s-15.9GB/s), io=400GiB (429GB), run=26986-26986msec
numjobs: 8 WRITE: bw=24.5GiB/s (26.3GB/s), 24.5GiB/s-24.5GiB/s (26.3GB/s-26.3GB/s), io=800GiB (859GB), run=32624-32624msec
numjobs: 16 WRITE: bw=24.2GiB/s (25.0GB/s), 24.2GiB/s-24.2GiB/s (25.0GB/s-25.0GB/s), io=1451GiB (1558GB), run=60001-60001msec
numjobs: 32 WRITE: bw=19.3GiB/s (20.8GB/s), 19.3GiB/s-19.3GiB/s (20.8GB/s-20.8GB/s), io=1160GiB (1245GB), run=60002-60002msec
SSF
Fri May 6 09:58:33 EDT 2022
numjobs: 1 WRITE: bw=3137MiB/s (3289MB/s), 3137MiB/s-3137MiB/s (3289MB/s-3289MB/s), io=100GiB (107GB), run=32646-32646msec
numjobs: 2 WRITE: bw=7736MiB/s (8111MB/s), 7736MiB/s-7736MiB/s (8111MB/s-8111MB/s), io=200GiB (215GB), run=26475-26475msec
numjobs: 4 WRITE: bw=14.4GiB/s (15.4GB/s), 14.4GiB/s-14.4GiB/s (15.4GB/s-15.4GB/s), io=400GiB (429GB), run=27869-27869msec
numjobs: 8 WRITE: bw=22.6GiB/s (24.3GB/s), 22.6GiB/s-22.6GiB/s (24.3GB/s-24.3GB/s), io=800GiB (859GB), run=35340-35340msec
numjobs: 16 WRITE: bw=25.6GiB/s (27.5GB/s), 25.6GiB/s-25.6GiB/s (27.5GB/s-27.5GB/s), io=1535GiB (1648GB), run=60001-60001msec
numjobs: 32 WRITE: bw=20.2GiB/s (21.7GB/s), 20.2GiB/s-20.2GiB/s (21.7GB/s-21.7GB/s), io=1211GiB (1300GB), run=60003-60003msec
SSF gain in percentage:-
For 1 fio thread: +0%
For 2 fio threads: +0%
For 4 fio threads: +42%
For 8 fio threads: +246.8%
For 16 fio threads: +549%
For 32 fio threads: +630.33%
Dharmendra Singh (1):
Allow non-extending parallel direct writes on the same file.
fs/fuse/file.c | 33 ++++++++++++++++++++++++++++++--- include/uapi/linux/fuse.h | 2 ++ 2 files changed, 32 insertions(+), 3 deletions(-)
---
v3: Addressed all comments.
---
PATCH v3 1/1 FUSE: Allow non-extending parallel direct writes on the same file.
From: Dharmendra Singh <[email protected]>
In general, as of now, in FUSE, direct writes on the same file are serialized over inode lock i.e we hold inode lock for the full duration of the write request. I could not found in fuse code a comment which clearly explains why this exclusive lock is taken for direct writes. Our guess is some USER space fuse implementations might be relying on this lock for seralization and also it protects for the issues arising due to file size assumption or write failures. This patch relaxes this exclusive lock in some cases of direct writes.
With these changes, we allows non-extending parallel direct writes on the same file with the help of a flag called FOPEN_PARALLEL_WRITES. If this flag is set on the file (flag is passed from libfuse to fuse kernel as part of file open/create), we do not take exclusive lock instead use shared lock so that all non-extending writes can run in parallel.
Best practise would be to enable parallel direct writes of all kinds including extending writes as well but we see some issues such as when one write completes and other fails, how we should truncate(if needed) the file if underlying file system does not support holes (For file systems which supports holes, there might be a possibility of enabling parallel writes for all cases).
FUSE implementations which rely on this inode lock for serialisation can continue to do so and this is default behaviour i.e no parallel direct writes.
--- fs/fuse/file.c | 33 ++++++++++++++++++++++++++++++--- include/uapi/linux/fuse.h | 2 ++ 2 files changed, 32 insertions(+), 3 deletions(-)
fs/fuse/file.c +30 -3
@@ -1541,14 +1541,37 @@ static ssize_t fuse_direct_read_iter(struct kiocb *iocb, struct iov_iter *to)return res; } +static bool fuse_direct_write_extending_i_size (struct kiocb *iocb, +struct iov_iter *iter) +{ +struct inode *inode =file_inode (iocb->ki_filp); + +return (iocb->ki_flags &IOCB_APPEND || + iocb->ki_pos +iov_iter_count (iter) >i_size_read (inode)); +} +static ssize_t fuse_direct_write_iter (struct kiocb *iocb,struct iov_iter *from) {struct inode *inode =file_inode (iocb->ki_filp); +struct file *file = iocb->ki_filp; +struct fuse_file *ff = file->private_data;struct fuse_io_priv io =FUSE_IO_PRIV_SYNC (iocb);ssize_t res; +bool exclusive_lock = !(ff->open_flags &FOPEN_PARALLEL_WRITES ) || +fuse_direct_write_extending_i_size (iocb, from); + +/* +* Take exclusive lock if +* - parallel writes are disabled. +* - parallel writes are enabled and i_size is being extended +* Take shared lock if +* - parallel writes are enabled but i_size does not extend. +*/ +if (exclusive_lock) +inode_lock (inode); +else +inode_lock_shared (inode); -/* Don't allow parallel writes to the same file */ -inode_lock (inode); res =generic_write_checks (iocb, from);if (res >0 ) {if (!is_sync_kiocb (iocb) && iocb->ki_flags &IOCB_DIRECT ) {
@@ -1559,7 +1582,10 @@ static ssize_t fuse_direct_write_iter(struct kiocb *iocb, struct iov_iter *from)fuse_write_update_attr (inode, iocb->ki_pos, res); } } -inode_unlock (inode); +if (exclusive_lock) +inode_unlock (inode); +else +inode_unlock_shared (inode);return res; }
@@ -2901,6 +2927,7 @@ fuse_direct_IO(struct kiocb *iocb, struct iov_iter *iter)if (iov_iter_rw (iter) ==WRITE ) {fuse_write_update_attr (inode, pos, ret); +/* For extending writes we already hold exclusive lock */ if (ret <0 && offset + count > i_size)fuse_do_truncate (file); }
include/uapi/linux/fuse.h +2 -0
@@ -301,6 +301,7 @@ struct fuse_file_lock {* FOPEN_CACHE_DIR: allow caching this directory * FOPEN_STREAM: the file is stream-like (no file position at all) * FOPEN_NOFLUSH: don't flush data cache on close (unless FUSE_WRITEBACK_CACHE) +* FOPEN_PARALLEL_WRITES: Allow concurrent writes on the same inode */ #define FOPEN_DIRECT_IO (1 << 0)#define FOPEN_KEEP_CACHE (1 << 1)
@@ -308,6 +309,7 @@ struct fuse_file_lock {#define FOPEN_CACHE_DIR (1 << 3)#define FOPEN_STREAM (1 << 4)#define FOPEN_NOFLUSH (1 << 5) +#define FOPEN_PARALLEL_WRITES (1 << 6)/** * INIT request/reply flags
Signature · 1 line
2.17.1
Re: [PATCH v3 1/1] FUSE: Allow non-extending parallel direct writes on the same file.
Quoted 41 lines · Dharmendra Singh
From: Dharmendra Singh <[email protected]>
In general, as of now, in FUSE, direct writes on the same file are serialized over inode lock i.e we hold inode lock for the full duration of the write request. I could not found in fuse code a comment which clearly explains why this exclusive lock is taken for direct writes. Our guess is some USER space fuse implementations might be relying on this lock for seralization and also it protects for the issues arising due to file size assumption or write failures. This patch relaxes this exclusive lock in some cases of direct writes.
With these changes, we allows non-extending parallel direct writes on the same file with the help of a flag called
FOPEN_PARALLEL_WRITES. If this flag is set on the file (flag is passed from libfuse to fuse kernel as part of file open/create), we do not take exclusive lock instead use shared lock so that all non-extending writes can run in parallel.Best practise would be to enable parallel direct writes of all kinds including extending writes as well but we see some issues such as when one write completes and other fails, how we should truncate(if needed) the file if underlying file system does not support holes (For file systems which supports holes, there might be a possibility of enabling parallel writes for all cases).
FUSE implementations which rely on this inode lock for serialisation can continue to do so and this is default behaviour i.e no parallel direct writes.
Signed-off-by Dharmendra Singh <[email protected]>Signed-off-by Bernd Schubert <[email protected]>--- fs/fuse/file.c | 33 ++++++++++++++++++++++++++++++--- include/uapi/linux/fuse.h | 2 ++ 2 files changed, 32 insertions(+), 3 deletions(-)fs/fuse/file.c +0
-0@@ -1541,14 +1541,37 @@ static ssize_t fuse_direct_read_iter(struct kiocb *iocb, struct iov_iter *to)return res;
fs/fuse/file.c static ssize_t fuse_direct_read_iter(struct kiocb *iocb, struct iov_iter *to) · line 1551
Quoted 10 lines
fs/fuse/file.c +8
-0} +static bool fuse_direct_write_extending_i_size (struct kiocb *iocb, +struct iov_iter *iter) +{ +struct inode *inode =file_inode (iocb->ki_filp); + +return (iocb->ki_flags &IOCB_APPEND || + iocb->ki_pos +iov_iter_count (iter) >i_size_read (inode)); +}
Hi Dharmendra,
I have a question. What makes i_size stable. This is being read outside the inode_lock(). Can it race with truncate. I mean we checked i_size and decided to take shared lock. In the mean time another thread truncated the file and now our decision to take shared lock is wrong as file will be extended due to direct write?
Thanks
Vivek
Quoted 71 lines
fs/fuse/file.c +22
-3+static ssize_t fuse_direct_write_iter (struct kiocb *iocb,struct iov_iter *from) {struct inode *inode =file_inode (iocb->ki_filp); +struct file *file = iocb->ki_filp; +struct fuse_file *ff = file->private_data;struct fuse_io_priv io =FUSE_IO_PRIV_SYNC (iocb);ssize_t res; +bool exclusive_lock = !(ff->open_flags &FOPEN_PARALLEL_WRITES ) || +fuse_direct_write_extending_i_size (iocb, from); + +/* +* Take exclusive lock if +* - parallel writes are disabled. +* - parallel writes are enabled and i_size is being extended +* Take shared lock if +* - parallel writes are enabled but i_size does not extend. +*/ +if (exclusive_lock) +inode_lock (inode); +else +inode_lock_shared (inode); -/* Don't allow parallel writes to the same file */ -inode_lock (inode); res =generic_write_checks (iocb, from);if (res >0 ) {if (!is_sync_kiocb (iocb) && iocb->ki_flags &IOCB_DIRECT ) {@@ -1559,7 +1582,10 @@ static ssize_t fuse_direct_write_iter(struct kiocb *iocb, struct iov_iter *from)fuse_write_update_attr (inode, iocb->ki_pos, res); } } -inode_unlock (inode); +if (exclusive_lock) +inode_unlock (inode); +else +inode_unlock_shared (inode);return res; }@@ -2901,6 +2927,7 @@ fuse_direct_IO(struct kiocb *iocb, struct iov_iter *iter)if (iov_iter_rw (iter) ==WRITE ) {fuse_write_update_attr (inode, pos, ret); +/* For extending writes we already hold exclusive lock */ if (ret <0 && offset + count > i_size)fuse_do_truncate (file); }include/uapi/linux/fuse.h +2
-0@@ -301,6 +301,7 @@ struct fuse_file_lock {* FOPEN_CACHE_DIR: allow caching this directory * FOPEN_STREAM: the file is stream-like (no file position at all) * FOPEN_NOFLUSH: don't flush data cache on close (unless FUSE_WRITEBACK_CACHE) +* FOPEN_PARALLEL_WRITES: Allow concurrent writes on the same inode */ #define FOPEN_DIRECT_IO (1 << 0)#define FOPEN_KEEP_CACHE (1 << 1)@@ -308,6 +309,7 @@ struct fuse_file_lock {#define FOPEN_CACHE_DIR (1 << 3)#define FOPEN_STREAM (1 << 4)#define FOPEN_NOFLUSH (1 << 5) +#define FOPEN_PARALLEL_WRITES (1 << 6)/** * INIT request/reply flags Signature · 1 line
2.17.1
Re: [PATCH v3 1/1] FUSE: Allow non-extending parallel direct writes on the same file.
Quoted 55 lines · Vivek Goyal
Quoted 41 lines · Dharmendra Singh
From: Dharmendra Singh <[email protected]>
In general, as of now, in FUSE, direct writes on the same file are serialized over inode lock i.e we hold inode lock for the full duration of the write request. I could not found in fuse code a comment which clearly explains why this exclusive lock is taken for direct writes. Our guess is some USER space fuse implementations might be relying on this lock for seralization and also it protects for the issues arising due to file size assumption or write failures. This patch relaxes this exclusive lock in some cases of direct writes.
With these changes, we allows non-extending parallel direct writes on the same file with the help of a flag called
FOPEN_PARALLEL_WRITES. If this flag is set on the file (flag is passed from libfuse to fuse kernel as part of file open/create), we do not take exclusive lock instead use shared lock so that all non-extending writes can run in parallel.Best practise would be to enable parallel direct writes of all kinds including extending writes as well but we see some issues such as when one write completes and other fails, how we should truncate(if needed) the file if underlying file system does not support holes (For file systems which supports holes, there might be a possibility of enabling parallel writes for all cases).
FUSE implementations which rely on this inode lock for serialisation can continue to do so and this is default behaviour i.e no parallel direct writes.
Signed-off-by Dharmendra Singh <[email protected]>Signed-off-by Bernd Schubert <[email protected]>--- fs/fuse/file.c | 33 ++++++++++++++++++++++++++++++--- include/uapi/linux/fuse.h | 2 ++ 2 files changed, 32 insertions(+), 3 deletions(-)fs/fuse/file.c +0
-0@@ -1541,14 +1541,37 @@ static ssize_t fuse_direct_read_iter(struct kiocb *iocb, struct iov_iter *to)return res;fs/fuse/file.c static ssize_t fuse_direct_read_iter(struct kiocb *iocb, struct iov_iter *to) · line 1551
Quoted 10 lines
fs/fuse/file.c +8
-0} +static bool fuse_direct_write_extending_i_size (struct kiocb *iocb, +struct iov_iter *iter) +{ +struct inode *inode =file_inode (iocb->ki_filp); + +return (iocb->ki_flags &IOCB_APPEND || + iocb->ki_pos +iov_iter_count (iter) >i_size_read (inode)); +}Hi Dharmendra,
Quoted 5 lines
I have a question. What makes
i_sizestable. This is being read outside theinode_lock(). Can it race with truncate. I mean we checkedi_sizeand decided to take shared lock. In the mean time another thread truncated the file and now our decision to take shared lock is wrong as file will be extended due to direct write?
Oh right, good catch! I guess we need to take a shared lock first, read the size and if it is an extending lock need to unlock/switch to an excluding lock. Theoretically could be a loop, but I guess that would be overkill.
Thanks for your review!
Cheers,
Bernd
Re: [PATCH v3 1/1] FUSE: Allow non-extending parallel direct writes on the same file.
Quoted 63 lines · Bernd Schubert
Quoted 54 lines · Vivek Goyal
Quoted 40 lines · Dharmendra Singh
From: Dharmendra Singh <[email protected]>
In general, as of now, in FUSE, direct writes on the same file are serialized over inode lock i.e we hold inode lock for the full duration of the write request. I could not found in fuse code a comment which clearly explains why this exclusive lock is taken for direct writes. Our guess is some USER space fuse implementations might be relying on this lock for seralization and also it protects for the issues arising due to file size assumption or write failures. This patch relaxes this exclusive lock in some cases of direct writes.
With these changes, we allows non-extending parallel direct writes on the same file with the help of a flag called
FOPEN_PARALLEL_WRITES. If this flag is set on the file (flag is passed from libfuse to fuse kernel as part of file open/create), we do not take exclusive lock instead use shared lock so that all non-extending writes can run in parallel.Best practise would be to enable parallel direct writes of all kinds including extending writes as well but we see some issues such as when one write completes and other fails, how we should truncate(if needed) the file if underlying file system does not support holes (For file systems which supports holes, there might be a possibility of enabling parallel writes for all cases).
FUSE implementations which rely on this inode lock for serialisation can continue to do so and this is default behaviour i.e no parallel direct writes.
Signed-off-by Dharmendra Singh <[email protected]>Signed-off-by Bernd Schubert <[email protected]>--- fs/fuse/file.c | 33 ++++++++++++++++++++++++++++++--- include/uapi/linux/fuse.h | 2 ++ 2 files changed, 32 insertions(+), 3 deletions(-)fs/fuse/file.c +0
-0fs/fuse/file.c static ssize_t fuse_direct_read_iter(struct kiocb *iocb, struct iov_iter *to) · line 1550
Quoted 10 lines
fs/fuse/file.c +8
-0@@ -1541,14 +1541,37 @@ static ssize_t fuse_direct_read_iter(struct kiocb *iocb, struct iov_iter *to)return res; } +static bool fuse_direct_write_extending_i_size (struct kiocb *iocb, +struct iov_iter *iter) +{ +struct inode *inode =file_inode (iocb->ki_filp); + +return (iocb->ki_flags &IOCB_APPEND || + iocb->ki_pos +iov_iter_count (iter) >i_size_read (inode)); +}Hi Dharmendra,
Quoted 5 lines
I have a question. What makes
i_sizestable. This is being read outside theinode_lock(). Can it race with truncate. I mean we checkedi_sizeand decided to take shared lock. In the mean time another thread truncated the file and now our decision to take shared lock is wrong as file will be extended due to direct write?
Quoted 3 lines
Oh right, good catch! I guess we need to take a shared lock first, read the size and if it is an extending lock need to unlock/switch to an excluding lock. Theoretically could be a loop, but I guess that would be overkill.
Another possibility is that we need to check again after taking shared lock if our decision to take shared lock was correct or not. If in unlikely case something changed, then drop shared lock and go back to exclusive lock, or drop the shared lock and re-evaluate which lock to take.
Thanks
Vivek
Quoted 7 lines
Thanks for your review!
Cheers,
Bernd
Re: [PATCH v3 1/1] FUSE: Allow non-extending parallel direct writes on the same file.
In reply to Dharmendra SinghQuoted 10 lines · Dharmendra Singh
From: Dharmendra Singh <[email protected]>
In general, as of now, in FUSE, direct writes on the same file are serialized over inode lock i.e we hold inode lock for the full duration of the write request. I could not found in fuse code a comment which clearly explains why this exclusive lock is taken for direct writes. Our guess is some USER space fuse implementations might be relying on this lock for seralization and also it protects for the issues arising due to file size assumption or write failures. This patch relaxes this exclusive lock in some cases of direct writes.
I have this question as well. My understanding was that in general, reads can do shared lock while writes have to take exclusive lock. And I assumed that extends to both buffered as well as direct writes.
I would also like to understand what's the fundamental restriction and why O_DIRECT is special that this restriction does not apply.
Is any other file system doing this as well?
If fuse server dir is shared with other fuse clients, it is possible that i_size in this client is stale. Will that be a problem. I guess if that's the problem then, even a single write will be a problem because two fuse clients might be trying to write.
Just trying to make sure that it is safe to allow parallel direct writes.
Thanks
Vivek
Quoted 112 lines
With these changes, we allows non-extending parallel direct writes on the same file with the help of a flag called
FOPEN_PARALLEL_WRITES. If this flag is set on the file (flag is passed from libfuse to fuse kernel as part of file open/create), we do not take exclusive lock instead use shared lock so that all non-extending writes can run in parallel.Best practise would be to enable parallel direct writes of all kinds including extending writes as well but we see some issues such as when one write completes and other fails, how we should truncate(if needed) the file if underlying file system does not support holes (For file systems which supports holes, there might be a possibility of enabling parallel writes for all cases).
FUSE implementations which rely on this inode lock for serialisation can continue to do so and this is default behaviour i.e no parallel direct writes.
Signed-off-by Dharmendra Singh <[email protected]>Signed-off-by Bernd Schubert <[email protected]>--- fs/fuse/file.c | 33 ++++++++++++++++++++++++++++++--- include/uapi/linux/fuse.h | 2 ++ 2 files changed, 32 insertions(+), 3 deletions(-)fs/fuse/file.c +30
-3@@ -1541,14 +1541,37 @@ static ssize_t fuse_direct_read_iter(struct kiocb *iocb, struct iov_iter *to)return res; } +static bool fuse_direct_write_extending_i_size (struct kiocb *iocb, +struct iov_iter *iter) +{ +struct inode *inode =file_inode (iocb->ki_filp); + +return (iocb->ki_flags &IOCB_APPEND || + iocb->ki_pos +iov_iter_count (iter) >i_size_read (inode)); +} +static ssize_t fuse_direct_write_iter (struct kiocb *iocb,struct iov_iter *from) {struct inode *inode =file_inode (iocb->ki_filp); +struct file *file = iocb->ki_filp; +struct fuse_file *ff = file->private_data;struct fuse_io_priv io =FUSE_IO_PRIV_SYNC (iocb);ssize_t res; +bool exclusive_lock = !(ff->open_flags &FOPEN_PARALLEL_WRITES ) || +fuse_direct_write_extending_i_size (iocb, from); + +/* +* Take exclusive lock if +* - parallel writes are disabled. +* - parallel writes are enabled and i_size is being extended +* Take shared lock if +* - parallel writes are enabled but i_size does not extend. +*/ +if (exclusive_lock) +inode_lock (inode); +else +inode_lock_shared (inode); -/* Don't allow parallel writes to the same file */ -inode_lock (inode); res =generic_write_checks (iocb, from);if (res >0 ) {if (!is_sync_kiocb (iocb) && iocb->ki_flags &IOCB_DIRECT ) {@@ -1559,7 +1582,10 @@ static ssize_t fuse_direct_write_iter(struct kiocb *iocb, struct iov_iter *from)fuse_write_update_attr (inode, iocb->ki_pos, res); } } -inode_unlock (inode); +if (exclusive_lock) +inode_unlock (inode); +else +inode_unlock_shared (inode);return res; }@@ -2901,6 +2927,7 @@ fuse_direct_IO(struct kiocb *iocb, struct iov_iter *iter)if (iov_iter_rw (iter) ==WRITE ) {fuse_write_update_attr (inode, pos, ret); +/* For extending writes we already hold exclusive lock */ if (ret <0 && offset + count > i_size)fuse_do_truncate (file); }include/uapi/linux/fuse.h +2
-0@@ -301,6 +301,7 @@ struct fuse_file_lock {* FOPEN_CACHE_DIR: allow caching this directory * FOPEN_STREAM: the file is stream-like (no file position at all) * FOPEN_NOFLUSH: don't flush data cache on close (unless FUSE_WRITEBACK_CACHE) +* FOPEN_PARALLEL_WRITES: Allow concurrent writes on the same inode */ #define FOPEN_DIRECT_IO (1 << 0)#define FOPEN_KEEP_CACHE (1 << 1)@@ -308,6 +309,7 @@ struct fuse_file_lock {#define FOPEN_CACHE_DIR (1 << 3)#define FOPEN_STREAM (1 << 4)#define FOPEN_NOFLUSH (1 << 5) +#define FOPEN_PARALLEL_WRITES (1 << 6)/** * INIT request/reply flags Signature · 1 line
2.17.1
Re: [PATCH v3 1/1] FUSE: Allow non-extending parallel direct writes on the same file.
Quoted 22 lines · Vivek Goyal
Quoted 10 lines · Dharmendra Singh
From: Dharmendra Singh <[email protected]>
In general, as of now, in FUSE, direct writes on the same file are serialized over inode lock i.e we hold inode lock for the full duration of the write request. I could not found in fuse code a comment which clearly explains why this exclusive lock is taken for direct writes. Our guess is some USER space fuse implementations might be relying on this lock for seralization and also it protects for the issues arising due to file size assumption or write failures. This patch relaxes this exclusive lock in some cases of direct writes.
I have this question as well. My understanding was that in general, reads can do shared lock while writes have to take exclusive lock. And I assumed that extends to both buffered as well as direct writes.
I would also like to understand what's the fundamental restriction and why
O_DIRECTis special that this restriction does not apply.Is any other file system doing this as well?
Quoted 7 lines
If fuse server dir is shared with other fuse clients, it is possible that
i_sizein this client is stale. Will that be a problem. I guess if that's the problem then, even a single write will be a problem because two fuse clients might be trying to write.Just trying to make sure that it is safe to allow parallel direct writes.
I think missing in this series is to add a comment when this lock is needed at all. Our network file system is log structured - any parallel writes to the same file from different remote clients are handled through addition of fragments on the network server side - lockless safe due to byte level accuracy. With the exception of conflicting writes - last client wins - application is then doing 'silly' things - locking would not help either. And random parallel writes from the same (network) client are even an ideal case for us, as that is handled through shared blocks for different fragments (file offset + len). So for us shared writes are totally safe.
When Dharmendra and I discussed about the lock we came up with a few write error handling cases where that lock might be needed - I guess that should be added as comment.
Re: [PATCH v3 1/1] FUSE: Allow non-extending parallel direct writes on the same file.
Quoted 43 lines · Bernd Schubert
Quoted 22 lines · Vivek Goyal
Quoted 10 lines · Dharmendra Singh
From: Dharmendra Singh <[email protected]>
In general, as of now, in FUSE, direct writes on the same file are serialized over inode lock i.e we hold inode lock for the full duration of the write request. I could not found in fuse code a comment which clearly explains why this exclusive lock is taken for direct writes. Our guess is some USER space fuse implementations might be relying on this lock for seralization and also it protects for the issues arising due to file size assumption or write failures. This patch relaxes this exclusive lock in some cases of direct writes.
I have this question as well. My understanding was that in general, reads can do shared lock while writes have to take exclusive lock. And I assumed that extends to both buffered as well as direct writes.
I would also like to understand what's the fundamental restriction and why
O_DIRECTis special that this restriction does not apply.Is any other file system doing this as well?
Quoted 7 lines
If fuse server dir is shared with other fuse clients, it is possible that
i_sizein this client is stale. Will that be a problem. I guess if that's the problem then, even a single write will be a problem because two fuse clients might be trying to write.Just trying to make sure that it is safe to allow parallel direct writes.
I think missing in this series is to add a comment when this lock is needed at all. Our network file system is log structured - any parallel writes to the same file from different remote clients are handled through addition of fragments on the network server side - lockless safe due to byte level accuracy. With the exception of conflicting writes - last client wins - application is then doing 'silly' things - locking would not help either. And random parallel writes from the same (network) client are even an ideal case for us, as that is handled through shared blocks for different fragments (file offset + len). So for us shared writes are totally safe.
Quoted 3 lines
When Dharmendra and I discussed about the lock we came up with a few write error handling cases where that lock might be needed - I guess that should be added as comment.
Right, please add the changelogs to make thought process clear.
So there are no restrictions on the fuse client side from parallelism point of view on direct write path?
Why file extending writes are not safe? Is this a restriction from fuse client point of view or just being safe from server point of view. If fuse user space is talking to another filesystem, I guess then it is not problem because that filesystem will take care of locking as needed.
I see ext4 is allowing parallel direct writes for certain cases. And where they can't allow it, they have documented it in comments. (ext4_dio_write_checks()). I think we need similar rationalization, especially from fuse client's perspective and have comments in code and specify when it is ok to have parallel direct writes and when it is not ok and why. This will help people when they are looking at the code later.
Thanks
Vivek