clean up kernel_{read,write} & friends v2
Subsystems (11)
Hi Al,
this series fixes a few issues and cleans up the helpers that read from or write to kernel space buffers, and ensures that we don't change the address limit if we are using the ->read_iter and ->write_iter methods that don't need the changed address limit.
Changes since v1:
- __kernel_write must not take sb_writers
- unexported __kernel_write
PATCH 1/14 cachefiles: switch to kernel_write
__kernel_write doesn't take a sb_writers references, which we need here.
--- fs/cachefiles/rdwr.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
fs/cachefiles/rdwr.c +1 -1
@@ -937,7 +937,7 @@ int cachefiles_write_page(struct fscache_storage *op, struct page *page) } data =kmap (page); - ret =__kernel_write (file, data, len, &pos); + ret =kernel_write (file, data, len, &pos);kunmap (page);fput (file);if (ret != len)
Signature · 1 line
2.26.2
Re: [PATCH 01/14] cachefiles: switch to kernel_write
Quoted 3 lines · Christoph Hellwig
__kernel_writedoesn't take asb_writersreferences, which we need here.Signed-off-by Christoph Hellwig <[email protected]>
PATCH 2/14 autofs: switch to kernel_write
In reply to Christoph HellwigWhile pipes don't really need sb_writers projection, __kernel_write is an interface better kept private, and the additional rw_verify_area does not hurt here.
--- fs/autofs/waitq.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
fs/autofs/waitq.c +1 -1
@@ -53,7 +53,7 @@ static int autofs_write(struct autofs_sb_info *sbi,mutex_lock (&sbi->pipe_mutex);while (bytes) { - wr =__kernel_write (file, data, bytes, &file->f_pos); + wr =kernel_write (file, data, bytes, &file->f_pos);if (wr <=0 )break ; data += wr;
Signature · 1 line
2.26.2
Re: [PATCH 02/14] autofs: switch to kernel_write
Quoted 7 lines · Christoph Hellwig
While pipes don't really need
sb_writersprojection,__kernel_writeis an
interface better kept private, and the additionalrw_verify_areadoes not
hurt here.Signed-off-by Christoph Hellwig <[email protected]>
Right, should be fine AFAICS.
Quoted 17 lines
--- fs/autofs/waitq.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)fs/autofs/waitq.c +1
-1@@ -53,7 +53,7 @@ static int autofs_write(struct autofs_sb_info *sbi,mutex_lock (&sbi->pipe_mutex);while (bytes) { - wr =__kernel_write (file, data, bytes, &file->f_pos); + wr =kernel_write (file, data, bytes, &file->f_pos);if (wr <=0 )break ; data += wr;
PATCH 3/14 bpfilter: switch to kernel_write
In reply to Christoph HellwigWhile pipes don't really need sb_writers projection, __kernel_write is an interface better kept private, and the additional rw_verify_area does not hurt here.
--- net/bpfilter/bpfilter_kern.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
net/bpfilter/bpfilter_kern.c +1 -1
@@ -50,7 +50,7 @@ static int __bpfilter_process_sockopt(struct sock *sk, int optname, req.len = optlen;if (!bpfilter_ops.info.pid) goto out; - n =__kernel_write (bpfilter_ops.info.pipe_to_umh, &req,sizeof (req), + n =kernel_write (bpfilter_ops.info.pipe_to_umh, &req,sizeof (req), &pos);if (n !=sizeof (req)) {pr_err ("write fail %zd\n" , n);
Signature · 1 line
2.26.2
PATCH 4/14 fs: unexport __kernel_write
In reply to Christoph HellwigThis is a very special interface that skips sb_writes protection, and not used by modules anymore.
--- fs/read_write.c | 1 - 1 file changed, 1 deletion(-)
fs/read_write.c +0 -1
@@ -522,7 +522,6 @@ ssize_t __kernel_write(struct file *file, const void *buf, size_t count, loff_tinc_syscw (current);return ret; } -EXPORT_SYMBOL (__kernel_write);ssize_t kernel_write (struct file *file,const void *buf,size_t count,loff_t *pos)
Signature · 1 line
2.26.2
PATCH 5/14 fs: check FMODE_WRITE in __kernel_write
In reply to Christoph HellwigWe still need to check if the fѕ is open write, even for the low-level helper.
--- fs/read_write.c | 2 ++ 1 file changed, 2 insertions(+)
fs/read_write.c +2 -0
@@ -505,6 +505,8 @@ ssize_t __kernel_write(struct file *file, const void *buf, size_t count, loff_tconst char __user *p;ssize_t ret; +if (!(file->f_mode &FMODE_WRITE )) +return -EBADF ;if (!(file->f_mode &FMODE_CAN_WRITE ))return -EINVAL ;
Signature · 1 line
2.26.2
PATCH 6/14 fs: remove the call_{read,write}_iter functions
In reply to Christoph HellwigJust open coding the methods calls is a lot easier to follow.
--- drivers/block/loop.c | 4 ++-- drivers/target/target_core_file.c | 4 ++-- fs/aio.c | 4 ++-- fs/io_uring.c | 4 ++-- fs/read_write.c | 12 ++++++------ fs/splice.c | 2 +- include/linux/fs.h | 12 ------------ 7 files changed, 15 insertions(+), 27 deletions(-)
drivers/block/loop.c +2 -2
@@ -572,9 +572,9 @@ static int lo_rw_aio(struct loop_device *lo, struct loop_cmd *cmd,kthread_associate_blkcg (cmd->css);if (rw ==WRITE ) - ret =call_write_iter (file, &cmd->iocb, &iter); + ret = file->f_op->write_iter (&cmd->iocb, &iter);else - ret =call_read_iter (file, &cmd->iocb, &iter); + ret = file->f_op->read_iter (&cmd->iocb, &iter);lo_rw_aio_do_completion (cmd);kthread_associate_blkcg (NULL );
drivers/target/target_core_file.c +2 -2
@@ -303,9 +303,9 @@ fd_execute_rw_aio(struct se_cmd *cmd, struct scatterlist *sgl, u32 sgl_nents, aio_cmd->iocb.ki_flags |=IOCB_DSYNC ;if (is_write) - ret =call_write_iter (file, &aio_cmd->iocb, &iter); + ret = file->f_op->write_iter (&aio_cmd->iocb, &iter);else - ret =call_read_iter (file, &aio_cmd->iocb, &iter); + ret = file->f_op->read_iter (&aio_cmd->iocb, &iter);kfree (bvec);
fs/aio.c +2 -2
@@ -1540,7 +1540,7 @@ static int aio_read(struct kiocb *req, const struct iocb *iocb,return ret; ret =rw_verify_area (READ , file, &req->ki_pos,iov_iter_count (&iter));if (!ret) -aio_rw_done (req,call_read_iter (file, req, &iter)); +aio_rw_done (req, file->f_op->read_iter (req, &iter));kfree (iovec);return ret; }
@@ -1580,7 +1580,7 @@ static int aio_write(struct kiocb *req, const struct iocb *iocb,__sb_writers_release (file_inode (file)->i_sb,SB_FREEZE_WRITE ); } req->ki_flags |=IOCB_WRITE ; -aio_rw_done (req,call_write_iter (file, req, &iter)); +aio_rw_done (req, file->f_op->write_iter (req, &iter)); }kfree (iovec);return ret;
fs/io_uring.c +2 -2
@@ -2582,7 +2582,7 @@ static int io_read(struct io_kiocb *req, bool force_nonblock)ssize_t ret2;if (req->file->f_op->read_iter) - ret2 =call_read_iter (req->file, kiocb, &iter); + ret2 = req->file->f_op->read_iter (kiocb, &iter);else ret2 =loop_rw_iter (READ , req->file, kiocb, &iter);
@@ -2697,7 +2697,7 @@ static int io_write(struct io_kiocb *req, bool force_nonblock) current->signal->rlim[RLIMIT_FSIZE ].rlim_cur = req->fsize;if (req->file->f_op->write_iter) - ret2 =call_write_iter (req->file, kiocb, &iter); + ret2 = req->file->f_op->write_iter (kiocb, &iter);else ret2 =loop_rw_iter (WRITE , req->file, kiocb, &iter);
fs/read_write.c +6 -6
@@ -412,7 +412,7 @@ static ssize_t new_sync_read(struct file *filp, char __user *buf, size_t len, lo kiocb.ki_pos = (ppos ? *ppos :0 );iov_iter_init (&iter,READ , &iov,1 , len); - ret =call_read_iter (filp, &kiocb, &iter); + ret = filp->f_op->read_iter (&kiocb, &iter);BUG_ON (ret == -EIOCBQUEUED );if (ppos) *ppos = kiocb.ki_pos;
@@ -481,7 +481,7 @@ static ssize_t new_sync_write(struct file *filp, const char __user *buf, size_t kiocb.ki_pos = (ppos ? *ppos :0 );iov_iter_init (&iter,WRITE , &iov,1 , len); - ret =call_write_iter (filp, &kiocb, &iter); + ret = filp->f_op->write_iter (&kiocb, &iter);BUG_ON (ret == -EIOCBQUEUED );if (ret >0 && ppos) *ppos = kiocb.ki_pos;
@@ -690,9 +690,9 @@ static ssize_t do_iter_readv_writev(struct file *filp, struct iov_iter *iter, kiocb.ki_pos = (ppos ? *ppos :0 );if (type ==READ ) - ret =call_read_iter (filp, &kiocb, iter); + ret = filp->f_op->read_iter (&kiocb, iter);else - ret =call_write_iter (filp, &kiocb, iter); + ret = filp->f_op->write_iter (&kiocb, iter);BUG_ON (ret == -EIOCBQUEUED );if (ppos) *ppos = kiocb.ki_pos;
@@ -961,7 +961,7 @@ ssize_t vfs_iocb_iter_read(struct file *file, struct kiocb *iocb,if (ret <0 )return ret; - ret =call_read_iter (file, iocb, iter); + ret = file->f_op->read_iter (iocb, iter); out:if (ret >=0 )fsnotify_access (file);
@@ -1025,7 +1025,7 @@ ssize_t vfs_iocb_iter_write(struct file *file, struct kiocb *iocb,if (ret <0 )return ret; - ret =call_write_iter (file, iocb, iter); + ret = file->f_op->write_iter (iocb, iter);if (ret >0 )fsnotify_modify (file);
fs/splice.c +1 -1
@@ -310,7 +310,7 @@ ssize_t generic_file_splice_read(struct file *in, loff_t *ppos, i_head = to.head;init_sync_kiocb (&kiocb, in); kiocb.ki_pos = *ppos; - ret =call_read_iter (in, &kiocb, &to); + ret = in->f_op->read_iter (&kiocb, &to);if (ret >0 ) { *ppos = kiocb.ki_pos;file_accessed (in);
include/linux/fs.h +0 -12
@@ -1895,18 +1895,6 @@ struct inode_operations {int (*set_acl)(struct inode *,struct posix_acl *,int ); }____cacheline_aligned ; -static inline ssize_t call_read_iter (struct file *file,struct kiocb *kio, -struct iov_iter *iter) -{ -return file->f_op->read_iter (kio, iter); -} - -static inline ssize_t call_write_iter (struct file *file,struct kiocb *kio, -struct iov_iter *iter) -{ -return file->f_op->write_iter (kio, iter); -} -static inline int call_mmap (struct file *file,struct vm_area_struct *vma) {return file->f_op->mmap (file, vma);
Signature · 1 line
2.26.2
PATCH 7/14 fs: implement kernel_write using __kernel_write
In reply to Christoph HellwigConsolidate the two in-kernel write helpers to make upcoming changes easier. The only difference are the missing call to rw_verify_area in kernel_write, and an access_ok check that doesn't make sense for kernel buffers to start with.
--- fs/read_write.c | 17 +++++++++-------- 1 file changed, 9 insertions(+), 8 deletions(-)
fs/read_write.c +9 -8
@@ -499,6 +499,7 @@ static ssize_t __vfs_write(struct file *file, const char __user *p,return -EINVAL ; } +/* caller is responsible for file_start_write/file_end_write */ ssize_t __kernel_write (struct file *file,const void *buf,size_t count,loff_t *pos) {mm_segment_t old_fs;
@@ -528,16 +529,16 @@ ssize_t __kernel_write(struct file *file, const void *buf, size_t count, loff_tssize_t kernel_write (struct file *file,const void *buf,size_t count,loff_t *pos) { -mm_segment_t old_fs; -ssize_t res; +ssize_t ret; - old_fs =get_fs (); -set_fs (KERNEL_DS ); -/* The cast to a user pointer is valid due to the set_fs() */ - res =vfs_write (file, (__force const char __user *)buf, count, pos); -set_fs (old_fs); + ret =rw_verify_area (WRITE , file, pos, count); +if (ret) +return ret; -return res; +file_start_write (file); + ret =__kernel_write (file, buf, count, pos); +file_end_write (file); +return ret; }EXPORT_SYMBOL (kernel_write);
Signature · 1 line
2.26.2
PATCH 8/14 fs: remove __vfs_write
In reply to Christoph HellwigFold it into the two callers.
--- fs/read_write.c | 46 ++++++++++++++++++++++------------------------ 1 file changed, 22 insertions(+), 24 deletions(-)
fs/read_write.c +22 -24
@@ -488,17 +488,6 @@ static ssize_t new_sync_write(struct file *filp, const char __user *buf, size_treturn ret; } -static ssize_t __vfs_write (struct file *file,const char __user *p, -size_t count,loff_t *pos) -{ -if (file->f_op->write) -return file->f_op->write (file, p, count, pos); -else if (file->f_op->write_iter) -return new_sync_write (file, p, count, pos); -else -return -EINVAL ; -} -/* caller is responsible for file_start_write/file_end_write */ ssize_t __kernel_write (struct file *file,const void *buf,size_t count,loff_t *pos) {
@@ -516,7 +505,12 @@ ssize_t __kernel_write(struct file *file, const void *buf, size_t count, loff_t p = (__force const char __user *)buf;if (count >MAX_RW_COUNT ) count =MAX_RW_COUNT ; - ret =__vfs_write (file, p, count, pos); +if (file->f_op->write) + ret = file->f_op->write (file, p, count, pos); +else if (file->f_op->write_iter) + ret =new_sync_write (file, p, count, pos); +else + ret = -EINVAL ;set_fs (old_fs);if (ret >0 ) {fsnotify_modify (file);
@@ -554,19 +548,23 @@ ssize_t vfs_write(struct file *file, const char __user *buf, size_t count, loff_return -EFAULT ; ret =rw_verify_area (WRITE , file, pos, count); -if (!ret) { -if (count >MAX_RW_COUNT ) - count =MAX_RW_COUNT ; -file_start_write (file); - ret =__vfs_write (file, buf, count, pos); -if (ret >0 ) { -fsnotify_modify (file); -add_wchar (current, ret); - } -inc_syscw (current); -file_end_write (file); +if (ret) +return ret; +if (count >MAX_RW_COUNT ) + count =MAX_RW_COUNT ; +file_start_write (file); +if (file->f_op->write) + ret = file->f_op->write (file, buf, count, pos); +else if (file->f_op->write_iter) + ret =new_sync_write (file, buf, count, pos); +else + ret = -EINVAL ; +if (ret >0 ) { +fsnotify_modify (file); +add_wchar (current, ret); } - +inc_syscw (current); +file_end_write (file);return ret; }
Signature · 1 line
2.26.2
PATCH 9/14 fs: don't change the address limit for ->write_iter in __kernel_write
In reply to Christoph HellwigIf we write to a file that implements ->write_iter there is no need to change the address limit if we send a kvec down. Implement that case, and prefer it over using plain ->write with a changed address limit if available.
--- fs/read_write.c | 34 ++++++++++++++++++++++------------ 1 file changed, 22 insertions(+), 12 deletions(-)
fs/read_write.c +22 -12
@@ -489,10 +489,9 @@ static ssize_t new_sync_write(struct file *filp, const char __user *buf, size_t }/* caller is responsible for file_start_write/file_end_write */ -ssize_t __kernel_write (struct file *file,const void *buf,size_t count,loff_t *pos) +ssize_t __kernel_write (struct file *file,const void *buf,size_t count, +loff_t *pos) { -mm_segment_t old_fs; -const char __user *p;ssize_t ret;if (!(file->f_mode &FMODE_WRITE ))
@@ -500,18 +499,29 @@ ssize_t __kernel_write(struct file *file, const void *buf, size_t count, loff_tif (!(file->f_mode &FMODE_CAN_WRITE ))return -EINVAL ; - old_fs =get_fs (); -set_fs (KERNEL_DS ); - p = (__force const char __user *)buf;if (count >MAX_RW_COUNT ) count =MAX_RW_COUNT ; -if (file->f_op->write) - ret = file->f_op->write (file, p, count, pos); -else if (file->f_op->write_iter) - ret =new_sync_write (file, p, count, pos); -else +if (file->f_op->write_iter) { +struct kvec iov = { .iov_base = (void *)buf, .iov_len = count }; +struct kiocb kiocb; +struct iov_iter iter; + +init_sync_kiocb (&kiocb, file); + kiocb.ki_pos = *pos; +iov_iter_kvec (&iter,WRITE , &iov,1 , count); + ret = file->f_op->write_iter (&kiocb, &iter); +if (ret >0 ) + *pos = kiocb.ki_pos; + }else if (file->f_op->write) { +mm_segment_t old_fs =get_fs (); + +set_fs (KERNEL_DS ); + ret = file->f_op->write (file, (__force const char __user *)buf, + count, pos); +set_fs (old_fs); + }else { ret = -EINVAL ; -set_fs (old_fs); + }if (ret >0 ) {fsnotify_modify (file);add_wchar (current, ret);
Signature · 1 line
2.26.2
PATCH 10/14 fs: add a __kernel_read helper
In reply to Christoph HellwigThis is the counterpart to __kernel_write, and skip the rw_verify_area call compared to kernel_read.
--- fs/read_write.c | 21 +++++++++++++++++++++ include/linux/fs.h | 1 + 2 files changed, 22 insertions(+)
fs/read_write.c +21 -0
@@ -430,6 +430,27 @@ ssize_t __vfs_read(struct file *file, char __user *buf, size_t count,return -EINVAL ; } +ssize_t __kernel_read (struct file *file,void *buf,size_t count,loff_t *pos) +{ +mm_segment_t old_fs =get_fs (); +ssize_t ret; + +if (!(file->f_mode &FMODE_CAN_READ )) +return -EINVAL ; + +if (count >MAX_RW_COUNT ) + count =MAX_RW_COUNT ; +set_fs (KERNEL_DS ); + ret =__vfs_read (file, (void __user *)buf, count, pos); +set_fs (old_fs); +if (ret >0 ) { +fsnotify_access (file); +add_rchar (current, ret); + } +inc_syscr (current); +return ret; +} +ssize_t kernel_read (struct file *file,void *buf,size_t count,loff_t *pos) {mm_segment_t old_fs;
include/linux/fs.h +1 -0
@@ -3011,6 +3011,7 @@ extern int kernel_read_file_from_path_initns(const char *, void **, loff_t *, loextern int kernel_read_file_from_fd (int ,void **,loff_t *,loff_t ,enum kernel_read_file_id );extern ssize_t kernel_read (struct file *,void *,size_t ,loff_t *); +ssize_t __kernel_read (struct file *file,void *buf,size_t count,loff_t *pos);extern ssize_t kernel_write (struct file *,const void *,size_t ,loff_t *);extern ssize_t __kernel_write (struct file *,const void *,size_t ,loff_t *);extern struct file *open_exec (const char *);
Signature · 1 line
2.26.2
PATCH 11/14 integrity/ima: switch to using __kernel_read
In reply to Christoph Hellwig__kernel_read has a bunch of additional sanity checks, and this moves the set_fs out of non-core code.
--- security/integrity/iint.c | 14 +------------- 1 file changed, 1 insertion(+), 13 deletions(-)
security/integrity/iint.c +1 -13
@@ -188,19 +188,7 @@ DEFINE_LSM(integrity) = {int integrity_kernel_read (struct file *file,loff_t offset,void *addr,unsigned long count) { -mm_segment_t old_fs; -char __user *buf = (char __user *)addr; -ssize_t ret; - -if (!(file->f_mode &FMODE_READ )) -return -EBADF ; - - old_fs =get_fs (); -set_fs (KERNEL_DS ); - ret =__vfs_read (file, buf, count, &offset); -set_fs (old_fs); - -return ret; +return __kernel_read (file, addr, count, &offset); }/*
Signature · 1 line
2.26.2
PATCH 12/14 fs: implement kernel_read using __kernel_read
In reply to Christoph HellwigConsolidate the two in-kernel read helpers to make upcoming changes easier. The only difference are the missing call to rw_verify_area in kernel_read, and an access_ok check that doesn't make sense for kernel buffers to start with.
--- fs/read_write.c | 13 +++++-------- 1 file changed, 5 insertions(+), 8 deletions(-)
fs/read_write.c +5 -8
@@ -453,15 +453,12 @@ ssize_t __kernel_read(struct file *file, void *buf, size_t count, loff_t *pos)ssize_t kernel_read (struct file *file,void *buf,size_t count,loff_t *pos) { -mm_segment_t old_fs; -ssize_t result; +ssize_t ret; - old_fs =get_fs (); -set_fs (KERNEL_DS ); -/* The cast to a user pointer is valid due to the set_fs() */ - result =vfs_read (file, (void __user *)buf, count, pos); -set_fs (old_fs); -return result; + ret =rw_verify_area (READ , file, pos, count); +if (ret) +return ret; +return __kernel_read (file, buf, count, pos); }EXPORT_SYMBOL (kernel_read);
Signature · 1 line
2.26.2
PATCH 13/14 fs: remove __vfs_read
In reply to Christoph HellwigFold it into the two callers.
--- fs/read_write.c | 43 +++++++++++++++++++++---------------------- include/linux/fs.h | 1 - 2 files changed, 21 insertions(+), 23 deletions(-)
fs/read_write.c +21 -22
@@ -419,17 +419,6 @@ static ssize_t new_sync_read(struct file *filp, char __user *buf, size_t len, loreturn ret; } -ssize_t __vfs_read (struct file *file,char __user *buf,size_t count, -loff_t *pos) -{ -if (file->f_op->read) -return file->f_op->read (file, buf, count, pos); -else if (file->f_op->read_iter) -return new_sync_read (file, buf, count, pos); -else -return -EINVAL ; -} -ssize_t __kernel_read (struct file *file,void *buf,size_t count,loff_t *pos) {mm_segment_t old_fs =get_fs ();
@@ -441,7 +430,12 @@ ssize_t __kernel_read(struct file *file, void *buf, size_t count, loff_t *pos)if (count >MAX_RW_COUNT ) count =MAX_RW_COUNT ;set_fs (KERNEL_DS ); - ret =__vfs_read (file, (void __user *)buf, count, pos); +if (file->f_op->read) + ret = file->f_op->read (file, (void __user *)buf, count, pos); +else if (file->f_op->read_iter) + ret =new_sync_read (file, (void __user *)buf, count, pos); +else + ret = -EINVAL ;set_fs (old_fs);if (ret >0 ) {fsnotify_access (file);
@@ -474,17 +468,22 @@ ssize_t vfs_read(struct file *file, char __user *buf, size_t count, loff_t *pos)return -EFAULT ; ret =rw_verify_area (READ , file, pos, count); -if (!ret) { -if (count >MAX_RW_COUNT ) - count =MAX_RW_COUNT ; - ret =__vfs_read (file, buf, count, pos); -if (ret >0 ) { -fsnotify_access (file); -add_rchar (current, ret); - } -inc_syscr (current); - } +if (ret) +return ret; +if (count >MAX_RW_COUNT ) + count =MAX_RW_COUNT ; +if (file->f_op->read) + ret = file->f_op->read (file, buf, count, pos); +else if (file->f_op->read_iter) + ret =new_sync_read (file, buf, count, pos); +else + ret = -EINVAL ; +if (ret >0 ) { +fsnotify_access (file); +add_rchar (current, ret); + } +inc_syscr (current);return ret; }
include/linux/fs.h +0 -1
@@ -1905,7 +1905,6 @@ ssize_t rw_copy_check_uvector(int type, const struct iovec __user * uvector,struct iovec *fast_pointer, struct iovec **ret_pointer); -extern ssize_t __vfs_read (struct file *,char __user *,size_t ,loff_t *);extern ssize_t vfs_read (struct file *,char __user *,size_t ,loff_t *);extern ssize_t vfs_write (struct file *,const char __user *,size_t ,loff_t *); extern ssize_t vfs_readv(struct file *, const struct iovec __user *,
Signature · 1 line
2.26.2
PATCH 14/14 fs: don't change the address limit for ->read_iter in __kernel_read
In reply to Christoph HellwigIf we read to a file that implements ->read_iter there is no need to change the address limit if we send a kvec down. Implement that case, and prefer it over using plain ->read with a changed address limit if available.
--- fs/read_write.c | 24 +++++++++++++++++------- 1 file changed, 17 insertions(+), 7 deletions(-)
fs/read_write.c +17 -7
@@ -421,7 +421,6 @@ static ssize_t new_sync_read(struct file *filp, char __user *buf, size_t len, lossize_t __kernel_read (struct file *file,void *buf,size_t count,loff_t *pos) { -mm_segment_t old_fs =get_fs ();ssize_t ret;if (!(file->f_mode &FMODE_CAN_READ ))
@@ -429,14 +428,25 @@ ssize_t __kernel_read(struct file *file, void *buf, size_t count, loff_t *pos)if (count >MAX_RW_COUNT ) count =MAX_RW_COUNT ; -set_fs (KERNEL_DS ); -if (file->f_op->read) +if (file->f_op->read_iter) { +struct kvec iov = { .iov_base = buf, .iov_len = count }; +struct kiocb kiocb; +struct iov_iter iter; + +init_sync_kiocb (&kiocb, file); + kiocb.ki_pos = *pos; +iov_iter_kvec (&iter,READ , &iov,1 , count); + ret = file->f_op->read_iter (&kiocb, &iter); + *pos = kiocb.ki_pos; + }else if (file->f_op->read) { +mm_segment_t old_fs =get_fs (); + +set_fs (KERNEL_DS ); ret = file->f_op->read (file, (void __user *)buf, count, pos); -else if (file->f_op->read_iter) - ret =new_sync_read (file, (void __user *)buf, count, pos); -else +set_fs (old_fs); + }else { ret = -EINVAL ; -set_fs (old_fs); + }if (ret >0 ) {fsnotify_access (file);add_rchar (current, ret);
Signature · 1 line
2.26.2
A message that is not in the archive (sent off-list or not yet received): [email protected]
Re: [PATCH 09/14] fs: don't change the address limit for ->write_iter in __kernel_write
Quoted 10 lines · Hillf Danton
Quoted 10 lines
(quoted diff) +10
-0+ if (file->f_op->write_iter) { + struct kvec iov = { .iov_base = (void *)buf, .iov_len = count }; + struct kiocb kiocb; + struct iov_iter iter; + + init_sync_kiocb(&kiocb, file); + kiocb.ki_pos = *pos; + iov_iter_kvec(&iter, WRITE, &iov, 1, count); + ret = file->f_op->write_iter(&kiocb, &iter); + if (ret > 0)
Quoted 8 lines
Review
Quoted 5 lines
(quoted diff) +5
-0+ *pos = kiocb.ki_pos; + } else if (file->f_op->write) { + mm_segment_t old_fs = get_fs(); + + set_fs(KERNEL_DS);Would you please shed light on who need it if a workqueue worker does not, given the access to buf?
Can you rephrase the question, I unfortunately do not understand it at all as-is.
ping?
Quoted 10 lines · Christoph Hellwig
Hi Al,
this series fixes a few issues and cleans up the helpers that read from or write to kernel space buffers, and ensures that we don't change the address limit if we are using the ->read_iter and ->write_iter methods that don't need the changed address limit.
Changes since v1:
-__kernel_writemust not takesb_writers
- unexported__kernel_write
---end quoted text---