Quantcast

[PATCH] allow parallel writes to a file when "overwriting"

classic Classic list List threaded Threaded
6 messages Options
Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

[PATCH] allow parallel writes to a file when "overwriting"

Charles Hardin
---
To anyone interested.

We were doing some tests and found out that we weren't seeing
any parallel writes on a file that had been fallocated which
seemed odd - sure enough, the kernel didn't allow parallel
writes.

So, I wrote up this patch as a reference change to try it out
and we got some better results. I do not make any claims that
this is the "right" thing to do since this is not how the
kernel was setup - but, it does appear to work for us.

If anyone wants to use this, fix it, upstream it - you are more
then welcome. I only put this out here as an RFC.
---


fuse: when overwriting a file don't hold the inode lock

file overwrites can just be marked as direct io to the
filesystem and avoid the serializing all writes in parallel.

however, appends will change the file size and still need
to be serialized.

Signed-off-by: Charles Hardin <[hidden email]>
---
 fs/fuse/dir.c  |  1 +
 fs/fuse/file.c | 26 +++++++++++++++++++++++---
 2 files changed, 24 insertions(+), 3 deletions(-)

diff --git a/fs/fuse/dir.c b/fs/fuse/dir.c
index c47b778..1eaddb5 100644
--- a/fs/fuse/dir.c
+++ b/fs/fuse/dir.c
@@ -1623,6 +1623,7 @@ int fuse_do_setattr(struct inode *inode, struct iattr *attr,
 
  if (is_truncate) {
  fuse_set_nowrite(inode);
+ inode_dio_wait(inode);
  set_bit(FUSE_I_SIZE_UNSTABLE, &fi->state);
  if (trust_local_cmtime && attr->ia_size != inode->i_size)
  attr->ia_valid |= ATTR_MTIME | ATTR_CTIME;
diff --git a/fs/fuse/file.c b/fs/fuse/file.c
index 3988b43..5a60191 100644
--- a/fs/fuse/file.c
+++ b/fs/fuse/file.c
@@ -1428,20 +1428,40 @@ static ssize_t fuse_direct_write_iter(struct kiocb *iocb, struct iov_iter *from)
  struct inode *inode = file_inode(file);
  struct fuse_io_priv io = FUSE_IO_PRIV_SYNC(file);
  ssize_t res;
+ bool overwrite;
 
  if (is_bad_inode(inode))
  return -EIO;
 
- /* Don't allow parallel writes to the same file */
+ /* Don't allow parallel writes to the same file unless overwriting */
  inode_lock(inode);
  res = generic_write_checks(iocb, from);
- if (res > 0)
- res = fuse_direct_io(&io, from, &iocb->ki_pos, FUSE_DIO_WRITE);
+ if (res <= 0) {
+ inode_unlock(inode);
+ goto out;
+ }
+
+ overwrite = false;
+ if ((iocb->ki_pos + iov_iter_count(from)) <= inode->i_size) {
+ /* overwrite can release the inode lock */
+ overwrite = true;
+ inode_dio_begin(inode);
+ inode_unlock(inode);
+ }
+
+ res = fuse_direct_io(&io, from, &iocb->ki_pos, FUSE_DIO_WRITE);
  fuse_invalidate_attr(inode);
+
+ if (overwrite) {
+ inode_dio_end(inode);
+ inode_lock(inode);
+ }
+
  if (res > 0)
  fuse_write_update_size(inode, iocb->ki_pos);
  inode_unlock(inode);
 
+out:
  return res;
 }
 
--
1.9.1


------------------------------------------------------------------------------
Check out the vibrant tech community on one of the world's most
engaging tech sites, SlashDot.org! http://sdm.link/slashdot
--
fuse-devel mailing list
To unsubscribe or subscribe, visit https://lists.sourceforge.net/lists/listinfo/fuse-devel
Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

Re: [PATCH] allow parallel writes to a file when "overwriting"

Maxim Patlasov-3
Hi Charles,

Just of curiosity, why FOPEN_DIRECT_IO is better than O_DIRECT for your
needs?

Thanks,
Maxim

On 12/13/2016 10:13 AM, Charles Hardin wrote:

> ---
> To anyone interested.
>
> We were doing some tests and found out that we weren't seeing
> any parallel writes on a file that had been fallocated which
> seemed odd - sure enough, the kernel didn't allow parallel
> writes.
>
> So, I wrote up this patch as a reference change to try it out
> and we got some better results. I do not make any claims that
> this is the "right" thing to do since this is not how the
> kernel was setup - but, it does appear to work for us.
>
> If anyone wants to use this, fix it, upstream it - you are more
> then welcome. I only put this out here as an RFC.
> ---
>
>
> fuse: when overwriting a file don't hold the inode lock
>
> file overwrites can just be marked as direct io to the
> filesystem and avoid the serializing all writes in parallel.
>
> however, appends will change the file size and still need
> to be serialized.
>
> Signed-off-by: Charles Hardin <[hidden email]>
> ---
>   fs/fuse/dir.c  |  1 +
>   fs/fuse/file.c | 26 +++++++++++++++++++++++---
>   2 files changed, 24 insertions(+), 3 deletions(-)
>
> diff --git a/fs/fuse/dir.c b/fs/fuse/dir.c
> index c47b778..1eaddb5 100644
> --- a/fs/fuse/dir.c
> +++ b/fs/fuse/dir.c
> @@ -1623,6 +1623,7 @@ int fuse_do_setattr(struct inode *inode, struct iattr *attr,
>  
>   if (is_truncate) {
>   fuse_set_nowrite(inode);
> + inode_dio_wait(inode);
>   set_bit(FUSE_I_SIZE_UNSTABLE, &fi->state);
>   if (trust_local_cmtime && attr->ia_size != inode->i_size)
>   attr->ia_valid |= ATTR_MTIME | ATTR_CTIME;
> diff --git a/fs/fuse/file.c b/fs/fuse/file.c
> index 3988b43..5a60191 100644
> --- a/fs/fuse/file.c
> +++ b/fs/fuse/file.c
> @@ -1428,20 +1428,40 @@ static ssize_t fuse_direct_write_iter(struct kiocb *iocb, struct iov_iter *from)
>   struct inode *inode = file_inode(file);
>   struct fuse_io_priv io = FUSE_IO_PRIV_SYNC(file);
>   ssize_t res;
> + bool overwrite;
>  
>   if (is_bad_inode(inode))
>   return -EIO;
>  
> - /* Don't allow parallel writes to the same file */
> + /* Don't allow parallel writes to the same file unless overwriting */
>   inode_lock(inode);
>   res = generic_write_checks(iocb, from);
> - if (res > 0)
> - res = fuse_direct_io(&io, from, &iocb->ki_pos, FUSE_DIO_WRITE);
> + if (res <= 0) {
> + inode_unlock(inode);
> + goto out;
> + }
> +
> + overwrite = false;
> + if ((iocb->ki_pos + iov_iter_count(from)) <= inode->i_size) {
> + /* overwrite can release the inode lock */
> + overwrite = true;
> + inode_dio_begin(inode);
> + inode_unlock(inode);
> + }
> +
> + res = fuse_direct_io(&io, from, &iocb->ki_pos, FUSE_DIO_WRITE);
>   fuse_invalidate_attr(inode);
> +
> + if (overwrite) {
> + inode_dio_end(inode);
> + inode_lock(inode);
> + }
> +
>   if (res > 0)
>   fuse_write_update_size(inode, iocb->ki_pos);
>   inode_unlock(inode);
>  
> +out:
>   return res;
>   }
>  


------------------------------------------------------------------------------
Check out the vibrant tech community on one of the world's most
engaging tech sites, SlashDot.org! http://sdm.link/slashdot
--
fuse-devel mailing list
To unsubscribe or subscribe, visit https://lists.sourceforge.net/lists/listinfo/fuse-devel
Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

Re: [PATCH] allow parallel writes to a file when "overwriting"

Nikolaus Rath
In reply to this post by Charles Hardin
Hi Charles,

Thanks for sharing the patch! Note, however, that this mailing list is
primarily about *libfuse*, the userspace library. Discussions about the
fuse kernel module (for which you wrote the patch) are very welcome, but
the chances that they will make it into the kernel from here is
generally slim.

The FUSE kernel module is maintained in the mainline linux kernel, so
the best way to get patches in is to cross-post to the Linux kernel
mailing lists, e.g. [linux-kernel](http://vger.kernel.org/vger-lists.html#linux-kernel)
or [linux-fsdevel](http://vger.kernel.org/vger-lists.html#linux-fsdevel).

Best,
-Nikolaus

On Dec 13 2016, Charles Hardin <[hidden email]> wrote:

> ---
> To anyone interested.
>
> We were doing some tests and found out that we weren't seeing
> any parallel writes on a file that had been fallocated which
> seemed odd - sure enough, the kernel didn't allow parallel
> writes.
>
> So, I wrote up this patch as a reference change to try it out
> and we got some better results. I do not make any claims that
> this is the "right" thing to do since this is not how the
> kernel was setup - but, it does appear to work for us.
>
> If anyone wants to use this, fix it, upstream it - you are more
> then welcome. I only put this out here as an RFC.
> ---
>
>
> fuse: when overwriting a file don't hold the inode lock
>
> file overwrites can just be marked as direct io to the
> filesystem and avoid the serializing all writes in parallel.
>
> however, appends will change the file size and still need
> to be serialized.
>
> Signed-off-by: Charles Hardin <[hidden email]>
> ---
>  fs/fuse/dir.c  |  1 +
>  fs/fuse/file.c | 26 +++++++++++++++++++++++---
>  2 files changed, 24 insertions(+), 3 deletions(-)
>
> diff --git a/fs/fuse/dir.c b/fs/fuse/dir.c
> index c47b778..1eaddb5 100644
> --- a/fs/fuse/dir.c
> +++ b/fs/fuse/dir.c
> @@ -1623,6 +1623,7 @@ int fuse_do_setattr(struct inode *inode, struct iattr *attr,
>  
>   if (is_truncate) {
>   fuse_set_nowrite(inode);
> + inode_dio_wait(inode);
>   set_bit(FUSE_I_SIZE_UNSTABLE, &fi->state);
>   if (trust_local_cmtime && attr->ia_size != inode->i_size)
>   attr->ia_valid |= ATTR_MTIME | ATTR_CTIME;
> diff --git a/fs/fuse/file.c b/fs/fuse/file.c
> index 3988b43..5a60191 100644
> --- a/fs/fuse/file.c
> +++ b/fs/fuse/file.c
> @@ -1428,20 +1428,40 @@ static ssize_t fuse_direct_write_iter(struct kiocb *iocb, struct iov_iter *from)
>   struct inode *inode = file_inode(file);
>   struct fuse_io_priv io = FUSE_IO_PRIV_SYNC(file);
>   ssize_t res;
> + bool overwrite;
>  
>   if (is_bad_inode(inode))
>   return -EIO;
>  
> - /* Don't allow parallel writes to the same file */
> + /* Don't allow parallel writes to the same file unless overwriting */
>   inode_lock(inode);
>   res = generic_write_checks(iocb, from);
> - if (res > 0)
> - res = fuse_direct_io(&io, from, &iocb->ki_pos, FUSE_DIO_WRITE);
> + if (res <= 0) {
> + inode_unlock(inode);
> + goto out;
> + }
> +
> + overwrite = false;
> + if ((iocb->ki_pos + iov_iter_count(from)) <= inode->i_size) {
> + /* overwrite can release the inode lock */
> + overwrite = true;
> + inode_dio_begin(inode);
> + inode_unlock(inode);
> + }
> +
> + res = fuse_direct_io(&io, from, &iocb->ki_pos, FUSE_DIO_WRITE);
>   fuse_invalidate_attr(inode);
> +
> + if (overwrite) {
> + inode_dio_end(inode);
> + inode_lock(inode);
> + }
> +
>   if (res > 0)
>   fuse_write_update_size(inode, iocb->ki_pos);
>   inode_unlock(inode);
>  
> +out:
>   return res;
>  }
>  
> --
>
> 1.9.1
>
>
> ------------------------------------------------------------------------------
> Check out the vibrant tech community on one of the world's most
> engaging tech sites, SlashDot.org! http://sdm.link/slashdot
> --
> fuse-devel mailing list
> To unsubscribe or subscribe, visit https://lists.sourceforge.net/lists/listinfo/fuse-devel
>


--
GPG encrypted emails preferred. Key id: 0xD113FCAC3C4E599F
Fingerprint: ED31 791B 2C5C 1613 AF38 8B8A D113 FCAC 3C4E 599F

             »Time flies like an arrow, fruit flies like a Banana.«

------------------------------------------------------------------------------
Check out the vibrant tech community on one of the world's most
engaging tech sites, SlashDot.org! http://sdm.link/slashdot
--
fuse-devel mailing list
To unsubscribe or subscribe, visit https://lists.sourceforge.net/lists/listinfo/fuse-devel
Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

Re: [PATCH] allow parallel writes to a file when "overwriting"

Charles Hardin
In reply to this post by Maxim Patlasov-3
Because our frontend is “unaligned” and written to pwrite/pread semantics using
front side buffered io and a thread pool - we’ve used both samba and ganesha
and other workload frontends.

Sure, I looked at rewriting the frontside to be O_DIRECT (the caller) but that was
too much work and past my threshold of apathy and unless I misunderstood the
calling convention - O_DIRECT on samba/ganesha wouldn’t give me multiple
writes (unless we used libaio/O_DIRECT) and bypassed the file operations
structures in the kernel and that is “really” past my threshold of apathy.

On the backside (our FUSE) we already have a big cache for other reasons and
we didn’t find a writeback cache as useful as just getting multiple writes pumped
into the FUSE stack and populating our cache we already maintain.

In the end, you might be able to solve this with other means - but, I did this in a
weekend to track it down and it worked for what we needed.

I saw no technical reason to not allow mutliple overwrites in parallel from the kernel
and so posted a patch.

Like I said - I am not trying to prove anything beyond if anyone else finds this
useful or relevant - hopefully it helps or doesn’t.

Regards,
Charles

> On Dec 13, 2016, at 11:26 AM, Maxim Patlasov <[hidden email]> wrote:
>
> Hi Charles,
>
> Just of curiosity, why FOPEN_DIRECT_IO is better than O_DIRECT for your needs?
>
> Thanks,
> Maxim
>
> On 12/13/2016 10:13 AM, Charles Hardin wrote:
>> ---
>> To anyone interested.
>>
>> We were doing some tests and found out that we weren't seeing
>> any parallel writes on a file that had been fallocated which
>> seemed odd - sure enough, the kernel didn't allow parallel
>> writes.
>>
>> So, I wrote up this patch as a reference change to try it out
>> and we got some better results. I do not make any claims that
>> this is the "right" thing to do since this is not how the
>> kernel was setup - but, it does appear to work for us.
>>
>> If anyone wants to use this, fix it, upstream it - you are more
>> then welcome. I only put this out here as an RFC.
>> ---
>>
>>
>> fuse: when overwriting a file don't hold the inode lock
>>
>> file overwrites can just be marked as direct io to the
>> filesystem and avoid the serializing all writes in parallel.
>>
>> however, appends will change the file size and still need
>> to be serialized.
>>
>> Signed-off-by: Charles Hardin <[hidden email]>
>> ---
>>  fs/fuse/dir.c  |  1 +
>>  fs/fuse/file.c | 26 +++++++++++++++++++++++---
>>  2 files changed, 24 insertions(+), 3 deletions(-)
>>
>> diff --git a/fs/fuse/dir.c b/fs/fuse/dir.c
>> index c47b778..1eaddb5 100644
>> --- a/fs/fuse/dir.c
>> +++ b/fs/fuse/dir.c
>> @@ -1623,6 +1623,7 @@ int fuse_do_setattr(struct inode *inode, struct iattr *attr,
>>     if (is_truncate) {
>>   fuse_set_nowrite(inode);
>> + inode_dio_wait(inode);
>>   set_bit(FUSE_I_SIZE_UNSTABLE, &fi->state);
>>   if (trust_local_cmtime && attr->ia_size != inode->i_size)
>>   attr->ia_valid |= ATTR_MTIME | ATTR_CTIME;
>> diff --git a/fs/fuse/file.c b/fs/fuse/file.c
>> index 3988b43..5a60191 100644
>> --- a/fs/fuse/file.c
>> +++ b/fs/fuse/file.c
>> @@ -1428,20 +1428,40 @@ static ssize_t fuse_direct_write_iter(struct kiocb *iocb, struct iov_iter *from)
>>   struct inode *inode = file_inode(file);
>>   struct fuse_io_priv io = FUSE_IO_PRIV_SYNC(file);
>>   ssize_t res;
>> + bool overwrite;
>>     if (is_bad_inode(inode))
>>   return -EIO;
>>  - /* Don't allow parallel writes to the same file */
>> + /* Don't allow parallel writes to the same file unless overwriting */
>>   inode_lock(inode);
>>   res = generic_write_checks(iocb, from);
>> - if (res > 0)
>> - res = fuse_direct_io(&io, from, &iocb->ki_pos, FUSE_DIO_WRITE);
>> + if (res <= 0) {
>> + inode_unlock(inode);
>> + goto out;
>> + }
>> +
>> + overwrite = false;
>> + if ((iocb->ki_pos + iov_iter_count(from)) <= inode->i_size) {
>> + /* overwrite can release the inode lock */
>> + overwrite = true;
>> + inode_dio_begin(inode);
>> + inode_unlock(inode);
>> + }
>> +
>> + res = fuse_direct_io(&io, from, &iocb->ki_pos, FUSE_DIO_WRITE);
>>   fuse_invalidate_attr(inode);
>> +
>> + if (overwrite) {
>> + inode_dio_end(inode);
>> + inode_lock(inode);
>> + }
>> +
>>   if (res > 0)
>>   fuse_write_update_size(inode, iocb->ki_pos);
>>   inode_unlock(inode);
>>  +out:
>>   return res;
>>  }
>>  
>


------------------------------------------------------------------------------
Check out the vibrant tech community on one of the world's most
engaging tech sites, SlashDot.org! http://sdm.link/slashdot
--
fuse-devel mailing list
To unsubscribe or subscribe, visit https://lists.sourceforge.net/lists/listinfo/fuse-devel
Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

Re: [PATCH] allow parallel writes to a file when "overwriting"

Maxim Patlasov-3
OK, thank you for explanation. It would be interesting to compare the
performance of your frontend in two configurations:

1) FOPEN_DIRECT_IO + your patch

2) no FOPEN_DIRECT_IO, no patch, let frontend do ordinary buffered
read/writes, but limiting fuse page cache by "echo 1 >
/sys/class/bdi/m:n/max_ratio"



On 12/13/2016 12:35 PM, Charles Hardin wrote:

> Because our frontend is “unaligned” and written to pwrite/pread semantics using
> front side buffered io and a thread pool - we’ve used both samba and ganesha
> and other workload frontends.
>
> Sure, I looked at rewriting the frontside to be O_DIRECT (the caller) but that was
> too much work and past my threshold of apathy and unless I misunderstood the
> calling convention - O_DIRECT on samba/ganesha wouldn’t give me multiple
> writes (unless we used libaio/O_DIRECT) and bypassed the file operations
> structures in the kernel and that is “really” past my threshold of apathy.
>
> On the backside (our FUSE) we already have a big cache for other reasons and
> we didn’t find a writeback cache as useful as just getting multiple writes pumped
> into the FUSE stack and populating our cache we already maintain.
>
> In the end, you might be able to solve this with other means - but, I did this in a
> weekend to track it down and it worked for what we needed.
>
> I saw no technical reason to not allow mutliple overwrites in parallel from the kernel
> and so posted a patch.
>
> Like I said - I am not trying to prove anything beyond if anyone else finds this
> useful or relevant - hopefully it helps or doesn’t.
>
> Regards,
> Charles
>
>> On Dec 13, 2016, at 11:26 AM, Maxim Patlasov <[hidden email]> wrote:
>>
>> Hi Charles,
>>
>> Just of curiosity, why FOPEN_DIRECT_IO is better than O_DIRECT for your needs?
>>
>> Thanks,
>> Maxim
>>
>> On 12/13/2016 10:13 AM, Charles Hardin wrote:
>>> ---
>>> To anyone interested.
>>>
>>> We were doing some tests and found out that we weren't seeing
>>> any parallel writes on a file that had been fallocated which
>>> seemed odd - sure enough, the kernel didn't allow parallel
>>> writes.
>>>
>>> So, I wrote up this patch as a reference change to try it out
>>> and we got some better results. I do not make any claims that
>>> this is the "right" thing to do since this is not how the
>>> kernel was setup - but, it does appear to work for us.
>>>
>>> If anyone wants to use this, fix it, upstream it - you are more
>>> then welcome. I only put this out here as an RFC.
>>> ---
>>>
>>>
>>> fuse: when overwriting a file don't hold the inode lock
>>>
>>> file overwrites can just be marked as direct io to the
>>> filesystem and avoid the serializing all writes in parallel.
>>>
>>> however, appends will change the file size and still need
>>> to be serialized.
>>>
>>> Signed-off-by: Charles Hardin <[hidden email]>
>>> ---
>>>   fs/fuse/dir.c  |  1 +
>>>   fs/fuse/file.c | 26 +++++++++++++++++++++++---
>>>   2 files changed, 24 insertions(+), 3 deletions(-)
>>>
>>> diff --git a/fs/fuse/dir.c b/fs/fuse/dir.c
>>> index c47b778..1eaddb5 100644
>>> --- a/fs/fuse/dir.c
>>> +++ b/fs/fuse/dir.c
>>> @@ -1623,6 +1623,7 @@ int fuse_do_setattr(struct inode *inode, struct iattr *attr,
>>>     if (is_truncate) {
>>>   fuse_set_nowrite(inode);
>>> + inode_dio_wait(inode);
>>>   set_bit(FUSE_I_SIZE_UNSTABLE, &fi->state);
>>>   if (trust_local_cmtime && attr->ia_size != inode->i_size)
>>>   attr->ia_valid |= ATTR_MTIME | ATTR_CTIME;
>>> diff --git a/fs/fuse/file.c b/fs/fuse/file.c
>>> index 3988b43..5a60191 100644
>>> --- a/fs/fuse/file.c
>>> +++ b/fs/fuse/file.c
>>> @@ -1428,20 +1428,40 @@ static ssize_t fuse_direct_write_iter(struct kiocb *iocb, struct iov_iter *from)
>>>   struct inode *inode = file_inode(file);
>>>   struct fuse_io_priv io = FUSE_IO_PRIV_SYNC(file);
>>>   ssize_t res;
>>> + bool overwrite;
>>>     if (is_bad_inode(inode))
>>>   return -EIO;
>>>   - /* Don't allow parallel writes to the same file */
>>> + /* Don't allow parallel writes to the same file unless overwriting */
>>>   inode_lock(inode);
>>>   res = generic_write_checks(iocb, from);
>>> - if (res > 0)
>>> - res = fuse_direct_io(&io, from, &iocb->ki_pos, FUSE_DIO_WRITE);
>>> + if (res <= 0) {
>>> + inode_unlock(inode);
>>> + goto out;
>>> + }
>>> +
>>> + overwrite = false;
>>> + if ((iocb->ki_pos + iov_iter_count(from)) <= inode->i_size) {
>>> + /* overwrite can release the inode lock */
>>> + overwrite = true;
>>> + inode_dio_begin(inode);
>>> + inode_unlock(inode);
>>> + }
>>> +
>>> + res = fuse_direct_io(&io, from, &iocb->ki_pos, FUSE_DIO_WRITE);
>>>   fuse_invalidate_attr(inode);
>>> +
>>> + if (overwrite) {
>>> + inode_dio_end(inode);
>>> + inode_lock(inode);
>>> + }
>>> +
>>>   if (res > 0)
>>>   fuse_write_update_size(inode, iocb->ki_pos);
>>>   inode_unlock(inode);
>>>   +out:
>>>   return res;
>>>   }
>>>  


------------------------------------------------------------------------------
Check out the vibrant tech community on one of the world's most
engaging tech sites, SlashDot.org! http://sdm.link/slashdot
--
fuse-devel mailing list
To unsubscribe or subscribe, visit https://lists.sourceforge.net/lists/listinfo/fuse-devel
Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

Re: [PATCH] allow parallel writes to a file when "overwriting"

Miklos Szeredi
In reply to this post by Nikolaus Rath
On Tue, Dec 13, 2016 at 9:32 PM, Nikolaus Rath <[hidden email]> wrote:

> Hi Charles,
>
> Thanks for sharing the patch! Note, however, that this mailing list is
> primarily about *libfuse*, the userspace library. Discussions about the
> fuse kernel module (for which you wrote the patch) are very welcome, but
> the chances that they will make it into the kernel from here is
> generally slim.
>
> The FUSE kernel module is maintained in the mainline linux kernel, so
> the best way to get patches in is to cross-post to the Linux kernel
> mailing lists, e.g. [linux-kernel](http://vger.kernel.org/vger-lists.html#linux-kernel)
> or [linux-fsdevel](http://vger.kernel.org/vger-lists.html#linux-fsdevel).

Just sending to the mailing list might not be enough.  The maintainer
(me in this case) should also be copied.

For more information see Documentation/SubmittingPatches in the linux
kernel source tree.

Thanks,
Miklos

------------------------------------------------------------------------------
Check out the vibrant tech community on one of the world's most
engaging tech sites, SlashDot.org! http://sdm.link/slashdot
--
fuse-devel mailing list
To unsubscribe or subscribe, visit https://lists.sourceforge.net/lists/listinfo/fuse-devel
Loading...