virtio-fs: Create a read-write mapping only if needed
v2 cover virtio-fs: Create a read-write mapping only if needed
This is V2 of patches.
Changes since V1:
- Fixed the issue of dropping lock (liu bo)
- Mapping could already be made writable by another thread after dropping read lock and acquiring write-lock. So check for that.
Do not always create a read-write mapping. Create it read-write only if caller asked for it. Otherwise create a read-only mapping and upgrade it to read-write later when needed.
Vivek Goyal (3):
fuse: Get rid of file parameter from setup mapping
fuse: Move new mapping setup code in a function
fuse: Add logic to upgrade a read-only mapping to read-write
fs/fuse/file.c | 253 +++++++++++++++++++++++++++++------------------ fs/fuse/fuse_i.h | 3 + 2 files changed, 162 insertions(+), 94 deletions(-)
Signature · 1 line
2.17.2
PATCH v2 1/3 fuse: Get rid of file parameter from setup mapping
There is only one caller of fuse_setup_one_mapping() and that passes file argument as NULL. So get rid of this parameter as there are no callers.
--- fs/fuse/file.c | 30 +++++++----------------------- 1 file changed, 7 insertions(+), 23 deletions(-)
fs/fuse/file.c +7 -23
@@ -264,41 +264,26 @@ static void dmap_add_to_free_pool(struct fuse_conn *fc, }/* offset passed in should be aligned to FUSE_DAX_MEM_RANGE_SZ */ -static int fuse_setup_one_mapping (struct inode *inode, -struct file *file,loff_t offset, -struct fuse_dax_mapping *dmap) +static int fuse_setup_one_mapping (struct inode *inode,loff_t offset, +struct fuse_dax_mapping *dmap) {struct fuse_conn *fc =get_fuse_conn (inode);struct fuse_inode *fi =get_fuse_inode (inode); -struct fuse_file *ff =NULL ;struct fuse_setupmapping_in inarg;FUSE_ARGS (args);ssize_t err; -if (file) - ff = file->private_data; -WARN_ON (offset %FUSE_DAX_MEM_RANGE_SZ );WARN_ON (fc->nr_free_ranges <0 );/* Ask fuse daemon to setup mapping */ memset (&inarg,0 ,sizeof (inarg)); inarg.foffset = offset; -if (ff) - inarg.fh = ff->fh; -else - inarg.fh =-1 ; + inarg.fh =-1 ; inarg.moffset = dmap->window_offset; inarg.len =FUSE_DAX_MEM_RANGE_SZ ; -if (file) { - inarg.flags |= (file->f_mode &FMODE_WRITE ) ? -FUSE_SETUPMAPPING_FLAG_WRITE :0 ; - inarg.flags |= (file->f_mode &FMODE_READ ) ? -FUSE_SETUPMAPPING_FLAG_READ :0 ; - }else { - inarg.flags |=FUSE_SETUPMAPPING_FLAG_READ ; - inarg.flags |=FUSE_SETUPMAPPING_FLAG_WRITE ; - } + inarg.flags |=FUSE_SETUPMAPPING_FLAG_READ ; + inarg.flags |=FUSE_SETUPMAPPING_FLAG_WRITE ; args.in.h.opcode =FUSE_SETUPMAPPING ; args.in.h.nodeid = fi->nodeid; args.in.numargs =1 ;
@@ -1985,9 +1970,8 @@ static int fuse_iomap_begin(struct inode *inode, loff_t pos, loff_t length, }/* Setup one mapping */ - ret =fuse_setup_one_mapping (inode,NULL , -ALIGN_DOWN (pos,FUSE_DAX_MEM_RANGE_SZ ), - alloc_dmap); + ret =fuse_setup_one_mapping (inode, +ALIGN_DOWN (pos,FUSE_DAX_MEM_RANGE_SZ ), alloc_dmap);if (ret <0 ) {printk ("fuse_setup_one_mapping() failed. err=%d" " pos=0x%llx\n" , ret, pos);
Signature · 1 line
2.17.2
PATCH v2 2/3 fuse: Move new mapping setup code in a function
In reply to Vivek GoyalMove new mapping setup code in a separate function. More code will come in fuse_iomap_begin() and its becoming too big.
--- fs/fuse/file.c | 116 +++++++++++++++++++++++++++---------------------- 1 file changed, 64 insertions(+), 52 deletions(-)
fs/fuse/file.c +64 -52
@@ -1882,6 +1882,67 @@ static void fuse_fill_iomap(struct inode *inode, loff_t pos, loff_t length, } } +static int iomap_begin_setup_new_mapping (struct inode *inode,loff_t pos, +loff_t length,unsigned flags, +struct iomap *iomap) +{ +struct fuse_inode *fi =get_fuse_inode (inode); +struct fuse_conn *fc =get_fuse_conn (inode); +struct fuse_dax_mapping *dmap, *alloc_dmap =NULL ; +int ret; + +/* Can't do reclaim in fault path yet due to lock ordering. +* Read path takes shared inode lock and that's not sufficient +* for inline range reclaim. Caller needs to drop lock, wait +* and retry. +*/ +if (flags &IOMAP_FAULT || !(flags &IOMAP_WRITE )) { + alloc_dmap =alloc_dax_mapping (fc); +if (!alloc_dmap) +return -ENOSPC ; + }else { + alloc_dmap =alloc_dax_mapping_reclaim (fc, inode); +if (IS_ERR (alloc_dmap)) +return PTR_ERR (alloc_dmap); + } + +/* If we are here, we should have memory allocated */ +if (WARN_ON (!alloc_dmap)) +return -EBUSY ; + +/* +* Drop read lock and take write lock so that only one +* caller can try to setup mapping and other waits +*/ +down_write (&fi->i_dmap_sem); +/* +* We dropped lock. Check again if somebody else setup +* mapping already. +*/ + dmap =fuse_dax_interval_tree_iter_first (&fi->dmap_tree, pos, + pos); +if (dmap) { +fuse_fill_iomap (inode, pos, length, iomap, dmap, flags); +dmap_add_to_free_pool (fc, alloc_dmap); +up_write (&fi->i_dmap_sem); +return 0 ; + } + +/* Setup one mapping */ + ret =fuse_setup_one_mapping (inode, +ALIGN_DOWN (pos,FUSE_DAX_MEM_RANGE_SZ ), alloc_dmap); +if (ret <0 ) { +printk ("fuse_setup_one_mapping() failed. err=%d" +" pos=0x%llx\n" , ret, pos); +dmap_add_to_free_pool (fc, alloc_dmap); +up_write (&fi->i_dmap_sem); +return ret; + } +fuse_fill_iomap (inode, pos, length, iomap, alloc_dmap, flags); +up_write (&fi->i_dmap_sem); +return 0 ; +} +/* This is just for DAX and the mapping is ephemeral, do not use it for other * purposes since there is no block device with a permanent mapping. */
@@ -1890,8 +1951,7 @@ static int fuse_iomap_begin(struct inode *inode, loff_t pos, loff_t length, {struct fuse_inode *fi =get_fuse_inode (inode);struct fuse_conn *fc =get_fuse_conn (inode); -struct fuse_dax_mapping *dmap, *alloc_dmap =NULL ; -int ret; +struct fuse_dax_mapping *dmap;/* We don't support FIEMAP */ BUG_ON (flags &IOMAP_REPORT );
@@ -1932,56 +1992,8 @@ static int fuse_iomap_begin(struct inode *inode, loff_t pos, loff_t length,if (pos >=i_size_read (inode)) goto iomap_hole; -/* Can't do reclaim in fault path yet due to lock ordering. -* Read path takes shared inode lock and that's not sufficient -* for inline range reclaim. Caller needs to drop lock, wait -* and retry. -*/ -if (flags &IOMAP_FAULT || !(flags &IOMAP_WRITE )) { - alloc_dmap =alloc_dax_mapping (fc); -if (!alloc_dmap) -return -ENOSPC ; - }else { - alloc_dmap =alloc_dax_mapping_reclaim (fc, inode); -if (IS_ERR (alloc_dmap)) -return PTR_ERR (alloc_dmap); - } - -/* If we are here, we should have memory allocated */ -if (WARN_ON (!alloc_dmap)) -return -EBUSY ; - -/* -* Drop read lock and take write lock so that only one -* caller can try to setup mapping and other waits -*/ -down_write (&fi->i_dmap_sem); -/* -* We dropped lock. Check again if somebody else setup -* mapping already. -*/ - dmap =fuse_dax_interval_tree_iter_first (&fi->dmap_tree, pos, - pos); -if (dmap) { -fuse_fill_iomap (inode, pos, length, iomap, dmap, flags); -dmap_add_to_free_pool (fc, alloc_dmap); -up_write (&fi->i_dmap_sem); -return 0 ; - } - -/* Setup one mapping */ - ret =fuse_setup_one_mapping (inode, -ALIGN_DOWN (pos,FUSE_DAX_MEM_RANGE_SZ ), alloc_dmap); -if (ret <0 ) { -printk ("fuse_setup_one_mapping() failed. err=%d" -" pos=0x%llx\n" , ret, pos); -dmap_add_to_free_pool (fc, alloc_dmap); -up_write (&fi->i_dmap_sem); -return ret; - } -fuse_fill_iomap (inode, pos, length, iomap, alloc_dmap, flags); -up_write (&fi->i_dmap_sem); -return 0 ; +return iomap_begin_setup_new_mapping (inode, pos, length, flags, + iomap); }/*
Signature · 1 line
2.17.2
PATCH v2 3/3 fuse: Add logic to upgrade a read-only mapping to read-write
In reply to Vivek GoyalDo not always map a dax mapping read-write. There are use cases like executing a file where we want to map file read-only. virtio-fs dir on host might be backed by overlayfs. We don't want to open file read-write on overlayfs otherwise it will unnecessariliy be copied-up nullyifying the advantages of sharing page cache between vms for unmodified files.
Hence, create a read-only mapping if user did not ask for writable mapping. Later upgrade it to read-write mapping when users requests it.
--- fs/fuse/file.c | 121 +++++++++++++++++++++++++++++++++++++---------- fs/fuse/fuse_i.h | 3 ++ 2 files changed, 98 insertions(+), 26 deletions(-)
fs/fuse/file.c +95 -26
@@ -265,7 +265,8 @@ static void dmap_add_to_free_pool(struct fuse_conn *fc,/* offset passed in should be aligned to FUSE_DAX_MEM_RANGE_SZ */ static int fuse_setup_one_mapping (struct inode *inode,loff_t offset, -struct fuse_dax_mapping *dmap) +struct fuse_dax_mapping *dmap,bool writable, +bool upgrade) {struct fuse_conn *fc =get_fuse_conn (inode);struct fuse_inode *fi =get_fuse_inode (inode);
@@ -283,7 +284,8 @@ static int fuse_setup_one_mapping(struct inode *inode, loff_t offset, inarg.moffset = dmap->window_offset; inarg.len =FUSE_DAX_MEM_RANGE_SZ ; inarg.flags |=FUSE_SETUPMAPPING_FLAG_READ ; - inarg.flags |=FUSE_SETUPMAPPING_FLAG_WRITE ; +if (writable) + inarg.flags |=FUSE_SETUPMAPPING_FLAG_WRITE ; args.in.h.opcode =FUSE_SETUPMAPPING ; args.in.h.nodeid = fi->nodeid; args.in.numargs =1 ;
@@ -296,26 +298,30 @@ static int fuse_setup_one_mapping(struct inode *inode, loff_t offset,return err; } -pr_debug ("fuse_setup_one_mapping() succeeded. offset=0x%llx err=%zd\n" , offset, err); +pr_debug ("fuse_setup_one_mapping() succeeded. offset=0x%llx writable=%d" +" err=%zd\n" , offset, writable, err); -/* -* We don't take a refernce on inode. inode is valid right now and -* when inode is going away, cleanup logic should first cleanup -* dmap entries. -* -* TODO: Do we need to ensure that we are holding inode lock -* as well. -*/ - dmap->inode = inode; - dmap->start = offset; - dmap->end = offset +FUSE_DAX_MEM_RANGE_SZ -1 ; -/* Protected by fi->i_dmap_sem */ -fuse_dax_interval_tree_insert (dmap, &fi->dmap_tree); - fi->nr_dmaps++; -spin_lock (&fc->lock); -list_add_tail (&dmap->busy_list, &fc->busy_ranges); - fc->nr_busy_ranges++; -spin_unlock (&fc->lock); + dmap->writable = writable; +if (!upgrade) { +/* +* We don't take a refernce on inode. inode is valid right now +* and when inode is going away, cleanup logic should first +* cleanup dmap entries. +* +* TODO: Do we need to ensure that we are holding inode lock +* as well. +*/ + dmap->inode = inode; + dmap->start = offset; + dmap->end = offset +FUSE_DAX_MEM_RANGE_SZ -1 ; +/* Protected by fi->i_dmap_sem */ +fuse_dax_interval_tree_insert (dmap, &fi->dmap_tree); + fi->nr_dmaps++; +spin_lock (&fc->lock); +list_add_tail (&dmap->busy_list, &fc->busy_ranges); + fc->nr_busy_ranges++; +spin_unlock (&fc->lock); + }return 0 ; }
@@ -1890,6 +1896,7 @@ static int iomap_begin_setup_new_mapping(struct inode *inode, loff_t pos,struct fuse_conn *fc =get_fuse_conn (inode);struct fuse_dax_mapping *dmap, *alloc_dmap =NULL ;int ret; +bool writable = flags &IOMAP_WRITE ;/* Can't do reclaim in fault path yet due to lock ordering. * Read path takes shared inode lock and that's not sufficient
@@ -1930,10 +1937,11 @@ static int iomap_begin_setup_new_mapping(struct inode *inode, loff_t pos,/* Setup one mapping */ ret =fuse_setup_one_mapping (inode, -ALIGN_DOWN (pos,FUSE_DAX_MEM_RANGE_SZ ), alloc_dmap); +ALIGN_DOWN (pos,FUSE_DAX_MEM_RANGE_SZ ), + alloc_dmap, writable, false);if (ret <0 ) {printk ("fuse_setup_one_mapping() failed. err=%d" -" pos=0x%llx\n" , ret, pos); +" pos=0x%llx, writable=%d\n" , ret, pos, writable);dmap_add_to_free_pool (fc, alloc_dmap);up_write (&fi->i_dmap_sem);return ret;
@@ -1943,6 +1951,52 @@ static int iomap_begin_setup_new_mapping(struct inode *inode, loff_t pos,return 0 ; } +static int iomap_begin_upgrade_mapping (struct inode *inode,loff_t pos, +loff_t length,unsigned flags, +struct iomap *iomap) +{ +struct fuse_inode *fi =get_fuse_inode (inode); +struct fuse_dax_mapping *dmap; +int ret; + +/* +* Take exclusive lock so that only one caller can try to setup +* mapping and others wait. +*/ +down_write (&fi->i_dmap_sem); + dmap =fuse_dax_interval_tree_iter_first (&fi->dmap_tree, pos, pos); + +/* We are holding either inode lock or i_mmap_sem, and that should +* ensure that dmap can't reclaimed or truncated and it should still +* be there in tree despite the fact we dropped and re-acquired the +* lock. +*/ + ret = -EIO ; +if (WARN_ON (!dmap)) + goto out_err; + +/* Maybe another thread already upgraded mapping while we were not +* holding lock. +*/ +if (dmap->writable) + goto out_fill_iomap; + + ret =fuse_setup_one_mapping (inode, +ALIGN_DOWN (pos,FUSE_DAX_MEM_RANGE_SZ ), + dmap, true, true); +if (ret <0 ) { +printk ("fuse_setup_one_mapping() failed. err=%d pos=0x%llx\n" , + ret, pos); + goto out_err; + } + +out_fill_iomap: +fuse_fill_iomap (inode, pos, length, iomap, dmap, flags); +out_err: +up_write (&fi->i_dmap_sem); +return ret; +} +/* This is just for DAX and the mapping is ephemeral, do not use it for other * purposes since there is no block device with a permanent mapping. */
@@ -1952,6 +2006,7 @@ static int fuse_iomap_begin(struct inode *inode, loff_t pos, loff_t length,struct fuse_inode *fi =get_fuse_inode (inode);struct fuse_conn *fc =get_fuse_conn (inode);struct fuse_dax_mapping *dmap; +bool writable = flags &IOMAP_WRITE ;/* We don't support FIEMAP */ BUG_ON (flags &IOMAP_REPORT );
@@ -1982,9 +2037,23 @@ static int fuse_iomap_begin(struct inode *inode, loff_t pos, loff_t length, dmap =fuse_dax_interval_tree_iter_first (&fi->dmap_tree, pos, pos);if (dmap) { -fuse_fill_iomap (inode, pos, length, iomap, dmap, flags); -up_read (&fi->i_dmap_sem); -return 0 ; +if (writable && !dmap->writable) { +/* Upgrade read-only mapping to read-write. This will +* require exclusive i_dmap_sem lock as we don't want +* two threads to be trying to this simultaneously +* for same dmap. So drop shared lock and acquire +* exclusive lock. +*/ +up_read (&fi->i_dmap_sem); +pr_debug ("%s: Upgrading mapping at offset 0x%llx" +" length 0x%llx\n" , __func__, pos, length); +return iomap_begin_upgrade_mapping (inode, pos, length, + flags, iomap); + }else { +fuse_fill_iomap (inode, pos, length, iomap, dmap, flags); +up_read (&fi->i_dmap_sem); +return 0 ; + } }else {up_read (&fi->i_dmap_sem); pr_debug("%s: no mapping at offset 0x%llx length 0x%llx\n",
fs/fuse/fuse_i.h +3 -0
@@ -134,6 +134,9 @@ struct fuse_dax_mapping {/** Length of mapping, in bytes */ loff_t length; + +/* Is this mapping read-only or read-write */ +bool writable; };/** FUSE inode */
Signature · 1 line
2.17.2
Re: [Virtio-fs] [PATCH 3/3] fuse: Add logic to upgrade a read-only mapping to read-write
Hi Vivek,
Shall we downgrade dax mapping from rw to read-only, if current user open with O_RDONLY, and last user opened with O_RDWR? This will minimize the access authority.
I wonder if my concern is necessary. And if it will cause frequent dax mapping?
Thanks,
Jun
Quoted 214 lines · Vivek Goyal
Do not always map a dax mapping read-write. There are use cases like executing a file where we want to map file read-only. virtio-fs dir on host might be backed by overlayfs. We don't want to open file read-write on overlayfs otherwise it will unnecessariliy be copied-up nullyifying the advantages of sharing page cache between vms for unmodified files.
Hence, create a read-only mapping if user did not ask for writable mapping. Later upgrade it to read-write mapping when users requests it.
Signed-off-by Vivek Goyal <[email protected]>--- fs/fuse/file.c | 121 +++++++++++++++++++++++++++++++++++++---------- fs/fuse/fuse_i.h | 3 ++ 2 files changed, 98 insertions(+), 26 deletions(-)fs/fuse/file.c +95
-26@@ -265,7 +265,8 @@ static void dmap_add_to_free_pool(struct fuse_conn *fc,/* offset passed in should be aligned to FUSE_DAX_MEM_RANGE_SZ */ static int fuse_setup_one_mapping (struct inode *inode,loff_t offset, -struct fuse_dax_mapping *dmap) +struct fuse_dax_mapping *dmap,bool writable, +bool upgrade) {struct fuse_conn *fc =get_fuse_conn (inode);struct fuse_inode *fi =get_fuse_inode (inode);@@ -283,7 +284,8 @@ static int fuse_setup_one_mapping(struct inode *inode, loff_t offset, inarg.moffset = dmap->window_offset; inarg.len =FUSE_DAX_MEM_RANGE_SZ ; inarg.flags |=FUSE_SETUPMAPPING_FLAG_READ ; - inarg.flags |=FUSE_SETUPMAPPING_FLAG_WRITE ; +if (writable) + inarg.flags |=FUSE_SETUPMAPPING_FLAG_WRITE ; args.in.h.opcode =FUSE_SETUPMAPPING ; args.in.h.nodeid = fi->nodeid; args.in.numargs =1 ;@@ -296,26 +298,30 @@ static int fuse_setup_one_mapping(struct inode *inode, loff_t offset,return err; } -pr_debug ("fuse_setup_one_mapping() succeeded. offset=0x%llx err=%zd\n" , offset, err); +pr_debug ("fuse_setup_one_mapping() succeeded. offset=0x%llx writable=%d" +" err=%zd\n" , offset, writable, err); -/* -* We don't take a refernce on inode. inode is valid right now and -* when inode is going away, cleanup logic should first cleanup -* dmap entries. -* -* TODO: Do we need to ensure that we are holding inode lock -* as well. -*/ - dmap->inode = inode; - dmap->start = offset; - dmap->end = offset +FUSE_DAX_MEM_RANGE_SZ -1 ; -/* Protected by fi->i_dmap_sem */ -fuse_dax_interval_tree_insert (dmap, &fi->dmap_tree); - fi->nr_dmaps++; -spin_lock (&fc->lock); -list_add_tail (&dmap->busy_list, &fc->busy_ranges); - fc->nr_busy_ranges++; -spin_unlock (&fc->lock); + dmap->writable = writable; +if (!upgrade) { +/* +* We don't take a refernce on inode. inode is valid right now +* and when inode is going away, cleanup logic should first +* cleanup dmap entries. +* +* TODO: Do we need to ensure that we are holding inode lock +* as well. +*/ + dmap->inode = inode; + dmap->start = offset; + dmap->end = offset +FUSE_DAX_MEM_RANGE_SZ -1 ; +/* Protected by fi->i_dmap_sem */ +fuse_dax_interval_tree_insert (dmap, &fi->dmap_tree); + fi->nr_dmaps++; +spin_lock (&fc->lock); +list_add_tail (&dmap->busy_list, &fc->busy_ranges); + fc->nr_busy_ranges++; +spin_unlock (&fc->lock); + }return 0 ; }@@ -1890,6 +1896,7 @@ static int iomap_begin_setup_new_mapping(struct inode *inode, loff_t pos,struct fuse_conn *fc =get_fuse_conn (inode);struct fuse_dax_mapping *dmap, *alloc_dmap =NULL ;int ret; +bool writable = flags &IOMAP_WRITE ;/* Can't do reclaim in fault path yet due to lock ordering. * Read path takes shared inode lock and that's not sufficient @@ -1930,10 +1937,11 @@ static int iomap_begin_setup_new_mapping(struct inode *inode, loff_t pos,/* Setup one mapping */ ret =fuse_setup_one_mapping (inode, -ALIGN_DOWN (pos,FUSE_DAX_MEM_RANGE_SZ ), alloc_dmap); +ALIGN_DOWN (pos,FUSE_DAX_MEM_RANGE_SZ ), + alloc_dmap, writable, false);if (ret <0 ) {printk ("fuse_setup_one_mapping() failed. err=%d" -" pos=0x%llx\n" , ret, pos); +" pos=0x%llx, writable=%d\n" , ret, pos, writable);dmap_add_to_free_pool (fc, alloc_dmap);up_write (&fi->i_dmap_sem);return ret;@@ -1943,6 +1951,52 @@ static int iomap_begin_setup_new_mapping(struct inode *inode, loff_t pos,return 0 ; } +static int iomap_begin_upgrade_mapping (struct inode *inode,loff_t pos, +loff_t length,unsigned flags, +struct iomap *iomap) +{ +struct fuse_inode *fi =get_fuse_inode (inode); +struct fuse_dax_mapping *dmap; +int ret; + +/* +* Take exclusive lock so that only one caller can try to setup +* mapping and others wait. +*/ +down_write (&fi->i_dmap_sem); + dmap =fuse_dax_interval_tree_iter_first (&fi->dmap_tree, pos, pos); + +/* We are holding either inode lock or i_mmap_sem, and that should +* ensure that dmap can't reclaimed or truncated and it should still +* be there in tree despite the fact we dropped and re-acquired the +* lock. +*/ + ret = -EIO ; +if (WARN_ON (!dmap)) + goto out_err; + +/* Maybe another thread already upgraded mapping while we were not +* holding lock. +*/ +if (dmap->writable) + goto out_fill_iomap; + + ret =fuse_setup_one_mapping (inode, +ALIGN_DOWN (pos,FUSE_DAX_MEM_RANGE_SZ ), + dmap, true, true); +if (ret <0 ) { +printk ("fuse_setup_one_mapping() failed. err=%d pos=0x%llx\n" , + ret, pos); + goto out_err; + } + +out_fill_iomap: +fuse_fill_iomap (inode, pos, length, iomap, dmap, flags); +out_err: +up_write (&fi->i_dmap_sem); +return ret; +} +/* This is just for DAX and the mapping is ephemeral, do not use it for other * purposes since there is no block device with a permanent mapping. */ @@ -1952,6 +2006,7 @@ static int fuse_iomap_begin(struct inode *inode, loff_t pos, loff_t length,struct fuse_inode *fi =get_fuse_inode (inode);struct fuse_conn *fc =get_fuse_conn (inode);struct fuse_dax_mapping *dmap; +bool writable = flags &IOMAP_WRITE ;/* We don't support FIEMAP */ BUG_ON (flags &IOMAP_REPORT );@@ -1982,9 +2037,23 @@ static int fuse_iomap_begin(struct inode *inode, loff_t pos, loff_t length, dmap =fuse_dax_interval_tree_iter_first (&fi->dmap_tree, pos, pos);if (dmap) { -fuse_fill_iomap (inode, pos, length, iomap, dmap, flags); -up_read (&fi->i_dmap_sem); -return 0 ; +if (writable && !dmap->writable) { +/* Upgrade read-only mapping to read-write. This will +* require exclusive i_dmap_sem lock as we don't want +* two threads to be trying to this simultaneously +* for same dmap. So drop shared lock and acquire +* exclusive lock. +*/ +up_read (&fi->i_dmap_sem); +pr_debug ("%s: Upgrading mapping at offset 0x%llx" +" length 0x%llx\n" , __func__, pos, length); +return iomap_begin_upgrade_mapping (inode, pos, length, + flags, iomap); + }else { +fuse_fill_iomap (inode, pos, length, iomap, dmap, flags); +up_read (&fi->i_dmap_sem); +return 0 ; + } }else {up_read (&fi->i_dmap_sem); pr_debug("%s: no mapping at offset 0x%llx length 0x%llx\n",fs/fuse/fuse_i.h +3
-0@@ -134,6 +134,9 @@ struct fuse_dax_mapping {/** Length of mapping, in bytes */ loff_t length; + +/* Is this mapping read-only or read-write */ +bool writable; };/** FUSE inode */
Re: [Virtio-fs] [PATCH 3/3] fuse: Add logic to upgrade a read-only mapping to read-write
Quoted 8 lines · piaojun
Hi Vivek,
Shall we downgrade dax mapping from rw to read-only, if current user open with
O_RDONLY, and last user opened withO_RDWR? This will minimize the access authority.I wonder if my concern is necessary. And if it will cause frequent dax mapping?
There is a chance that memory mapping will be reclaimed and setup as read-only again.
I will not worry about this at this point of time.
Thanks
Vivek
Quoted 219 lines
Thanks,
JunQuoted 214 lines · Vivek Goyal
Do not always map a dax mapping read-write. There are use cases like executing a file where we want to map file read-only. virtio-fs dir on host might be backed by overlayfs. We don't want to open file read-write on overlayfs otherwise it will unnecessariliy be copied-up nullyifying the advantages of sharing page cache between vms for unmodified files.
Hence, create a read-only mapping if user did not ask for writable mapping. Later upgrade it to read-write mapping when users requests it.
Signed-off-by Vivek Goyal <[email protected]>--- fs/fuse/file.c | 121 +++++++++++++++++++++++++++++++++++++---------- fs/fuse/fuse_i.h | 3 ++ 2 files changed, 98 insertions(+), 26 deletions(-)fs/fuse/file.c +95
-26@@ -265,7 +265,8 @@ static void dmap_add_to_free_pool(struct fuse_conn *fc,/* offset passed in should be aligned to FUSE_DAX_MEM_RANGE_SZ */ static int fuse_setup_one_mapping (struct inode *inode,loff_t offset, -struct fuse_dax_mapping *dmap) +struct fuse_dax_mapping *dmap,bool writable, +bool upgrade) {struct fuse_conn *fc =get_fuse_conn (inode);struct fuse_inode *fi =get_fuse_inode (inode);@@ -283,7 +284,8 @@ static int fuse_setup_one_mapping(struct inode *inode, loff_t offset, inarg.moffset = dmap->window_offset; inarg.len =FUSE_DAX_MEM_RANGE_SZ ; inarg.flags |=FUSE_SETUPMAPPING_FLAG_READ ; - inarg.flags |=FUSE_SETUPMAPPING_FLAG_WRITE ; +if (writable) + inarg.flags |=FUSE_SETUPMAPPING_FLAG_WRITE ; args.in.h.opcode =FUSE_SETUPMAPPING ; args.in.h.nodeid = fi->nodeid; args.in.numargs =1 ;@@ -296,26 +298,30 @@ static int fuse_setup_one_mapping(struct inode *inode, loff_t offset,return err; } -pr_debug ("fuse_setup_one_mapping() succeeded. offset=0x%llx err=%zd\n" , offset, err); +pr_debug ("fuse_setup_one_mapping() succeeded. offset=0x%llx writable=%d" +" err=%zd\n" , offset, writable, err); -/* -* We don't take a refernce on inode. inode is valid right now and -* when inode is going away, cleanup logic should first cleanup -* dmap entries. -* -* TODO: Do we need to ensure that we are holding inode lock -* as well. -*/ - dmap->inode = inode; - dmap->start = offset; - dmap->end = offset +FUSE_DAX_MEM_RANGE_SZ -1 ; -/* Protected by fi->i_dmap_sem */ -fuse_dax_interval_tree_insert (dmap, &fi->dmap_tree); - fi->nr_dmaps++; -spin_lock (&fc->lock); -list_add_tail (&dmap->busy_list, &fc->busy_ranges); - fc->nr_busy_ranges++; -spin_unlock (&fc->lock); + dmap->writable = writable; +if (!upgrade) { +/* +* We don't take a refernce on inode. inode is valid right now +* and when inode is going away, cleanup logic should first +* cleanup dmap entries. +* +* TODO: Do we need to ensure that we are holding inode lock +* as well. +*/ + dmap->inode = inode; + dmap->start = offset; + dmap->end = offset +FUSE_DAX_MEM_RANGE_SZ -1 ; +/* Protected by fi->i_dmap_sem */ +fuse_dax_interval_tree_insert (dmap, &fi->dmap_tree); + fi->nr_dmaps++; +spin_lock (&fc->lock); +list_add_tail (&dmap->busy_list, &fc->busy_ranges); + fc->nr_busy_ranges++; +spin_unlock (&fc->lock); + }return 0 ; }@@ -1890,6 +1896,7 @@ static int iomap_begin_setup_new_mapping(struct inode *inode, loff_t pos,struct fuse_conn *fc =get_fuse_conn (inode);struct fuse_dax_mapping *dmap, *alloc_dmap =NULL ;int ret; +bool writable = flags &IOMAP_WRITE ;/* Can't do reclaim in fault path yet due to lock ordering. * Read path takes shared inode lock and that's not sufficient @@ -1930,10 +1937,11 @@ static int iomap_begin_setup_new_mapping(struct inode *inode, loff_t pos,/* Setup one mapping */ ret =fuse_setup_one_mapping (inode, -ALIGN_DOWN (pos,FUSE_DAX_MEM_RANGE_SZ ), alloc_dmap); +ALIGN_DOWN (pos,FUSE_DAX_MEM_RANGE_SZ ), + alloc_dmap, writable, false);if (ret <0 ) {printk ("fuse_setup_one_mapping() failed. err=%d" -" pos=0x%llx\n" , ret, pos); +" pos=0x%llx, writable=%d\n" , ret, pos, writable);dmap_add_to_free_pool (fc, alloc_dmap);up_write (&fi->i_dmap_sem);return ret;@@ -1943,6 +1951,52 @@ static int iomap_begin_setup_new_mapping(struct inode *inode, loff_t pos,return 0 ; } +static int iomap_begin_upgrade_mapping (struct inode *inode,loff_t pos, +loff_t length,unsigned flags, +struct iomap *iomap) +{ +struct fuse_inode *fi =get_fuse_inode (inode); +struct fuse_dax_mapping *dmap; +int ret; + +/* +* Take exclusive lock so that only one caller can try to setup +* mapping and others wait. +*/ +down_write (&fi->i_dmap_sem); + dmap =fuse_dax_interval_tree_iter_first (&fi->dmap_tree, pos, pos); + +/* We are holding either inode lock or i_mmap_sem, and that should +* ensure that dmap can't reclaimed or truncated and it should still +* be there in tree despite the fact we dropped and re-acquired the +* lock. +*/ + ret = -EIO ; +if (WARN_ON (!dmap)) + goto out_err; + +/* Maybe another thread already upgraded mapping while we were not +* holding lock. +*/ +if (dmap->writable) + goto out_fill_iomap; + + ret =fuse_setup_one_mapping (inode, +ALIGN_DOWN (pos,FUSE_DAX_MEM_RANGE_SZ ), + dmap, true, true); +if (ret <0 ) { +printk ("fuse_setup_one_mapping() failed. err=%d pos=0x%llx\n" , + ret, pos); + goto out_err; + } + +out_fill_iomap: +fuse_fill_iomap (inode, pos, length, iomap, dmap, flags); +out_err: +up_write (&fi->i_dmap_sem); +return ret; +} +/* This is just for DAX and the mapping is ephemeral, do not use it for other * purposes since there is no block device with a permanent mapping. */ @@ -1952,6 +2006,7 @@ static int fuse_iomap_begin(struct inode *inode, loff_t pos, loff_t length,struct fuse_inode *fi =get_fuse_inode (inode);struct fuse_conn *fc =get_fuse_conn (inode);struct fuse_dax_mapping *dmap; +bool writable = flags &IOMAP_WRITE ;/* We don't support FIEMAP */ BUG_ON (flags &IOMAP_REPORT );@@ -1982,9 +2037,23 @@ static int fuse_iomap_begin(struct inode *inode, loff_t pos, loff_t length, dmap =fuse_dax_interval_tree_iter_first (&fi->dmap_tree, pos, pos);if (dmap) { -fuse_fill_iomap (inode, pos, length, iomap, dmap, flags); -up_read (&fi->i_dmap_sem); -return 0 ; +if (writable && !dmap->writable) { +/* Upgrade read-only mapping to read-write. This will +* require exclusive i_dmap_sem lock as we don't want +* two threads to be trying to this simultaneously +* for same dmap. So drop shared lock and acquire +* exclusive lock. +*/ +up_read (&fi->i_dmap_sem); +pr_debug ("%s: Upgrading mapping at offset 0x%llx" +" length 0x%llx\n" , __func__, pos, length); +return iomap_begin_upgrade_mapping (inode, pos, length, + flags, iomap); + }else { +fuse_fill_iomap (inode, pos, length, iomap, dmap, flags); +up_read (&fi->i_dmap_sem); +return 0 ; + } }else {up_read (&fi->i_dmap_sem); pr_debug("%s: no mapping at offset 0x%llx length 0x%llx\n",fs/fuse/fuse_i.h +3
-0@@ -134,6 +134,9 @@ struct fuse_dax_mapping {/** Length of mapping, in bytes */ loff_t length; + +/* Is this mapping read-only or read-write */ +bool writable; };/** FUSE inode */
Re: [Virtio-fs] [PATCH 3/3] fuse: Add logic to upgrade a read-only mapping to read-write
Hi Vivek,
Quoted 7 lines · Vivek Goyal
Quoted 6 lines · piaojun
Hi Vivek,
Shall we downgrade dax mapping from rw to read-only, if current user open with
O_RDONLY, and last user opened withO_RDWR? This will minimize the access authority.
Quoted 5 lines
Quoted 2 lines
I wonder if my concern is necessary. And if it will cause frequent dax mapping?
There is a chance that memory mapping will be reclaimed and setup as read-only again.
I got it, and thanks for your reply.
Thanks,
Jun
Quoted 227 lines
I will not worry about this at this point of time.
Thanks
VivekQuoted 217 lines
Thanks,
JunQuoted 212 lines · Vivek Goyal
Do not always map a dax mapping read-write. There are use cases like executing a file where we want to map file read-only. virtio-fs dir on host might be backed by overlayfs. We don't want to open file read-write on overlayfs otherwise it will unnecessariliy be copied-up nullyifying the advantages of sharing page cache between vms for unmodified files.
Hence, create a read-only mapping if user did not ask for writable mapping. Later upgrade it to read-write mapping when users requests it.
Signed-off-by Vivek Goyal <[email protected]>--- fs/fuse/file.c | 121 +++++++++++++++++++++++++++++++++++++---------- fs/fuse/fuse_i.h | 3 ++ 2 files changed, 98 insertions(+), 26 deletions(-)fs/fuse/file.c +95
-26@@ -265,7 +265,8 @@ static void dmap_add_to_free_pool(struct fuse_conn *fc,/* offset passed in should be aligned to FUSE_DAX_MEM_RANGE_SZ */ static int fuse_setup_one_mapping (struct inode *inode,loff_t offset, -struct fuse_dax_mapping *dmap) +struct fuse_dax_mapping *dmap,bool writable, +bool upgrade) {struct fuse_conn *fc =get_fuse_conn (inode);struct fuse_inode *fi =get_fuse_inode (inode);@@ -283,7 +284,8 @@ static int fuse_setup_one_mapping(struct inode *inode, loff_t offset, inarg.moffset = dmap->window_offset; inarg.len =FUSE_DAX_MEM_RANGE_SZ ; inarg.flags |=FUSE_SETUPMAPPING_FLAG_READ ; - inarg.flags |=FUSE_SETUPMAPPING_FLAG_WRITE ; +if (writable) + inarg.flags |=FUSE_SETUPMAPPING_FLAG_WRITE ; args.in.h.opcode =FUSE_SETUPMAPPING ; args.in.h.nodeid = fi->nodeid; args.in.numargs =1 ;@@ -296,26 +298,30 @@ static int fuse_setup_one_mapping(struct inode *inode, loff_t offset,return err; } -pr_debug ("fuse_setup_one_mapping() succeeded. offset=0x%llx err=%zd\n" , offset, err); +pr_debug ("fuse_setup_one_mapping() succeeded. offset=0x%llx writable=%d" +" err=%zd\n" , offset, writable, err); -/* -* We don't take a refernce on inode. inode is valid right now and -* when inode is going away, cleanup logic should first cleanup -* dmap entries. -* -* TODO: Do we need to ensure that we are holding inode lock -* as well. -*/ - dmap->inode = inode; - dmap->start = offset; - dmap->end = offset +FUSE_DAX_MEM_RANGE_SZ -1 ; -/* Protected by fi->i_dmap_sem */ -fuse_dax_interval_tree_insert (dmap, &fi->dmap_tree); - fi->nr_dmaps++; -spin_lock (&fc->lock); -list_add_tail (&dmap->busy_list, &fc->busy_ranges); - fc->nr_busy_ranges++; -spin_unlock (&fc->lock); + dmap->writable = writable; +if (!upgrade) { +/* +* We don't take a refernce on inode. inode is valid right now +* and when inode is going away, cleanup logic should first +* cleanup dmap entries. +* +* TODO: Do we need to ensure that we are holding inode lock +* as well. +*/ + dmap->inode = inode; + dmap->start = offset; + dmap->end = offset +FUSE_DAX_MEM_RANGE_SZ -1 ; +/* Protected by fi->i_dmap_sem */ +fuse_dax_interval_tree_insert (dmap, &fi->dmap_tree); + fi->nr_dmaps++; +spin_lock (&fc->lock); +list_add_tail (&dmap->busy_list, &fc->busy_ranges); + fc->nr_busy_ranges++; +spin_unlock (&fc->lock); + }return 0 ; }@@ -1890,6 +1896,7 @@ static int iomap_begin_setup_new_mapping(struct inode *inode, loff_t pos,struct fuse_conn *fc =get_fuse_conn (inode);struct fuse_dax_mapping *dmap, *alloc_dmap =NULL ;int ret; +bool writable = flags &IOMAP_WRITE ;/* Can't do reclaim in fault path yet due to lock ordering. * Read path takes shared inode lock and that's not sufficient @@ -1930,10 +1937,11 @@ static int iomap_begin_setup_new_mapping(struct inode *inode, loff_t pos,/* Setup one mapping */ ret =fuse_setup_one_mapping (inode, -ALIGN_DOWN (pos,FUSE_DAX_MEM_RANGE_SZ ), alloc_dmap); +ALIGN_DOWN (pos,FUSE_DAX_MEM_RANGE_SZ ), + alloc_dmap, writable, false);if (ret <0 ) {printk ("fuse_setup_one_mapping() failed. err=%d" -" pos=0x%llx\n" , ret, pos); +" pos=0x%llx, writable=%d\n" , ret, pos, writable);dmap_add_to_free_pool (fc, alloc_dmap);up_write (&fi->i_dmap_sem);return ret;@@ -1943,6 +1951,52 @@ static int iomap_begin_setup_new_mapping(struct inode *inode, loff_t pos,return 0 ; } +static int iomap_begin_upgrade_mapping (struct inode *inode,loff_t pos, +loff_t length,unsigned flags, +struct iomap *iomap) +{ +struct fuse_inode *fi =get_fuse_inode (inode); +struct fuse_dax_mapping *dmap; +int ret; + +/* +* Take exclusive lock so that only one caller can try to setup +* mapping and others wait. +*/ +down_write (&fi->i_dmap_sem); + dmap =fuse_dax_interval_tree_iter_first (&fi->dmap_tree, pos, pos); + +/* We are holding either inode lock or i_mmap_sem, and that should +* ensure that dmap can't reclaimed or truncated and it should still +* be there in tree despite the fact we dropped and re-acquired the +* lock. +*/ + ret = -EIO ; +if (WARN_ON (!dmap)) + goto out_err; + +/* Maybe another thread already upgraded mapping while we were not +* holding lock. +*/ +if (dmap->writable) + goto out_fill_iomap; + + ret =fuse_setup_one_mapping (inode, +ALIGN_DOWN (pos,FUSE_DAX_MEM_RANGE_SZ ), + dmap, true, true); +if (ret <0 ) { +printk ("fuse_setup_one_mapping() failed. err=%d pos=0x%llx\n" , + ret, pos); + goto out_err; + } + +out_fill_iomap: +fuse_fill_iomap (inode, pos, length, iomap, dmap, flags); +out_err: +up_write (&fi->i_dmap_sem); +return ret; +} +/* This is just for DAX and the mapping is ephemeral, do not use it for other * purposes since there is no block device with a permanent mapping. */ @@ -1952,6 +2006,7 @@ static int fuse_iomap_begin(struct inode *inode, loff_t pos, loff_t length,struct fuse_inode *fi =get_fuse_inode (inode);struct fuse_conn *fc =get_fuse_conn (inode);struct fuse_dax_mapping *dmap; +bool writable = flags &IOMAP_WRITE ;/* We don't support FIEMAP */ BUG_ON (flags &IOMAP_REPORT );@@ -1982,9 +2037,23 @@ static int fuse_iomap_begin(struct inode *inode, loff_t pos, loff_t length, dmap =fuse_dax_interval_tree_iter_first (&fi->dmap_tree, pos, pos);if (dmap) { -fuse_fill_iomap (inode, pos, length, iomap, dmap, flags); -up_read (&fi->i_dmap_sem); -return 0 ; +if (writable && !dmap->writable) { +/* Upgrade read-only mapping to read-write. This will +* require exclusive i_dmap_sem lock as we don't want +* two threads to be trying to this simultaneously +* for same dmap. So drop shared lock and acquire +* exclusive lock. +*/ +up_read (&fi->i_dmap_sem); +pr_debug ("%s: Upgrading mapping at offset 0x%llx" +" length 0x%llx\n" , __func__, pos, length); +return iomap_begin_upgrade_mapping (inode, pos, length, + flags, iomap); + }else { +fuse_fill_iomap (inode, pos, length, iomap, dmap, flags); +up_read (&fi->i_dmap_sem); +return 0 ; + } }else {up_read (&fi->i_dmap_sem); pr_debug("%s: no mapping at offset 0x%llx length 0x%llx\n",fs/fuse/fuse_i.h +3
-0@@ -134,6 +134,9 @@ struct fuse_dax_mapping {/** Length of mapping, in bytes */ loff_t length; + +/* Is this mapping read-only or read-write */ +bool writable; };Quoted 2 lines
fs/fuse/fuse_i.h struct fuse_dax_mapping { · line 142
Quoted 2 lines
fs/fuse/fuse_i.h +0
-0/** FUSE inode */ .