iov_iter: Use I/O direction from kiocb, iomap & request rather than iov_iter
Subsystems (40)
David Howells
maintainercover iov_iter: Use I/O direction from kiocb, iomap & request rather than iov_iter
Hi Jens, Christoph,
Here are some patches to switch from using the I/O direction indication in the iov_iter struct to using the I/O direction flags to be found in the kiocb struct, the iomap_iter struct and the request struct. The iterator's I/O direction is then only used in some internal checks.
The patches also add direction flags into iov_iter_extract_pages() so that it can perform some checks. New constants are defined rather than using READ and WRITE so that a check can be made that one of them is specified. The problem with the READ constant is that it is zero and is thus the same as no direction being specified - but if we're modifying the buffer contents (ie. reading into it), we need to know to set FOLL_WRITE. Granted this would be the default if unspecified, but it seems better that this case should be explicit.
There are also patches to make 9P and SCSI use iov_iter_extract_pages().
I've pushed the patches here also:
https://git.kernel.org/pub/scm/linux/kernel/git/dhowells/linux-fs.git/log/?h=iov-extract
David
David Howells (11):
iov_iter: Fix comment refs to iov_iter_get_pages/pages_alloc()
vfs: Set IOCB_WRITE in iocbs that we're going to write from
vfs: Use init_kiocb() to initialise new IOCBs
iov_iter: Use IOCB_WRITE rather than iterator direction
iov_iter: Use IOMAP_WRITE rather than iterator direction
iov_iter: Use op_is_write() rather than iterator direction
cifs: Drop the check using iov_iter_rw()
iov_iter: Drop iov_iter_rw() and fold in last user
iov_iter: Use I/O dir flags with iov_iter_extract_pages() 9p: Pin pages rather than ref'ing if appropriate
scsi: Use extract_iter_to_sg()
block/bio.c | 6 ++ block/blk-map.c | 5 +- block/fops.c | 8 +-- crypto/af_alg.c | 5 +- crypto/algif_hash.c | 3 +- drivers/block/loop.c | 11 ++-- drivers/nvme/target/io-cmd-file.c | 5 +- drivers/target/target_core_file.c | 2 +- drivers/vhost/scsi.c | 79 ++++++++------------------ fs/9p/vfs_addr.c | 2 +- fs/affs/file.c | 4 +- fs/aio.c | 9 ++- fs/btrfs/ioctl.c | 4 +- fs/cachefiles/io.c | 10 ++-- fs/ceph/file.c | 6 +- fs/dax.c | 6 +- fs/direct-io.c | 28 ++++++---- fs/exfat/inode.c | 6 +- fs/ext2/inode.c | 2 +- fs/f2fs/file.c | 10 ++-- fs/fat/inode.c | 4 +- fs/fuse/dax.c | 2 +- fs/fuse/file.c | 8 +-- fs/hfs/inode.c | 2 +- fs/hfsplus/inode.c | 2 +- fs/iomap/direct-io.c | 4 +- fs/jfs/inode.c | 2 +- fs/nfs/direct.c | 2 +- fs/nilfs2/inode.c | 2 +- fs/ntfs3/inode.c | 2 +- fs/ocfs2/aops.c | 2 +- fs/orangefs/inode.c | 2 +- fs/read_write.c | 10 ++-- fs/reiserfs/inode.c | 2 +- fs/seq_file.c | 2 +- fs/smb/client/smbdirect.c | 9 --- fs/splice.c | 2 +- fs/udf/inode.c | 2 +- include/linux/bio.h | 18 +++++- include/linux/fs.h | 16 +++++- include/linux/mm_types.h | 2 +- include/linux/uio.h | 10 ++-- io_uring/rw.c | 10 ++-- lib/iov_iter.c | 14 ++++- lib/scatterlist.c | 12 +++- mm/filemap.c | 2 +- mm/page_io.c | 4 +- net/9p/trans_common.c | 8 +-- net/9p/trans_common.h | 2 +- net/9p/trans_virtio.c | 92 ++++++++++--------------------- 50 files changed, 221 insertions(+), 241 deletions(-)
David Howells
maintainerRFC PATCH 1/11 iov_iter: Fix comment refs to iov_iter_get_pages/pages_alloc()
Fix references to iov_iter_get_pages/pages_alloc() in comments to refer to the *2 interfaces instead.
--- fs/ceph/file.c | 4 ++-- include/linux/mm_types.h | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-)
fs/ceph/file.c +2 -2
@@ -75,7 +75,7 @@ static __le32 ceph_flags_sys2wire(u32 flags)*/ /* -* How many pages to get in one call to iov_iter_get_pages(). This +* How many pages to get in one call to iov_iter_get_pages2(). This * determines the size of the on-stack array used as a buffer. */ #define ITER_GET_BVECS_PAGES 64
@@ -115,7 +115,7 @@ static ssize_t __iter_get_bvecs(struct iov_iter *iter, size_t maxsize, }/* -* iov_iter_get_pages() only considers one iov_iter segment, no matter +* iov_iter_get_pages2() only considers one iov_iter segment, no matter * what maxsize or maxpages are given. For ITER_BVEC that is a single * page. *
include/linux/mm_types.h +1 -1
@@ -1249,7 +1249,7 @@ enum {/* * FOLL_LONGTERM indicates that the page will be held for an indefinite * time period _often_ under userspace control. This is in contrast to -* iov_iter_get_pages(), whose usages are transient. +* iov_iter_get_pages2(), whose usages are transient. */ FOLL_LONGTERM = 1 << 8,/* split huge pmd before returning */
Re: [RFC PATCH 01/11] iov_iter: Fix comment refs to iov_iter_get_pages/pages_alloc()
include/linux/mm_types.h enum { · line 1253
Quoted 6 lines · David Howells
include/linux/mm_types.h +1
-1/* * FOLL_LONGTERM indicates that the page will be held for an indefinite * time period _often_ under userspace control. This is in contrast to -* iov_iter_get_pages(), whose usages are transient. +* iov_iter_get_pages2(), whose usages are transient. */
I don't think this should refer to iov_iter_get_pages* at all. The flag should document that actual get/pin_user interfaces and not refer to a (deprecated) interface built on top of it.
David Howells
maintainerRFC PATCH 2/11 vfs: Set IOCB_WRITE in iocbs that we're going to write from
In reply to David HowellsIOCB_WRITE is set by aio, io_uring and cachefiles before submitting a write operation to the VFS, but it isn't set by, say, the write() system call.
Fix this by adding an extra argument to init_sync_kiocb() to indicate the direction and setting that to READ or WRITE, which will cause IOCB_WRITE to be set as appropriate.
Whilst we're at it, rename init_sync_kiocb() to init_kiocb().
This will allow drivers to use IOCB_WRITE instead of the iterator data source to determine the I/O direction.
--- fs/btrfs/ioctl.c | 4 ++-- fs/read_write.c | 10 +++++----- fs/seq_file.c | 2 +- fs/splice.c | 2 +- include/linux/fs.h | 6 +++++- mm/filemap.c | 2 +- mm/page_io.c | 4 ++-- 7 files changed, 17 insertions(+), 13 deletions(-)
fs/btrfs/ioctl.c +2 -2
@@ -4422,7 +4422,7 @@ static int btrfs_ioctl_encoded_read(struct file *file, void __user *argp,if (ret <0 ) goto out_iov; -init_sync_kiocb (&kiocb, file); +init_kiocb (&kiocb, file,READ ); kiocb.ki_pos = pos; ret =btrfs_encoded_read (&kiocb, &iter, &args);
@@ -4523,7 +4523,7 @@ static int btrfs_ioctl_encoded_write(struct file *file, void __user *argp, boolif (ret <0 ) goto out_end_write; -init_sync_kiocb (&kiocb, file); +init_kiocb (&kiocb, file,WRITE ); ret =kiocb_set_rw_flags (&kiocb,0 );if (ret) goto out_end_write;
fs/read_write.c +5 -5
@@ -382,7 +382,7 @@ static ssize_t new_sync_read(struct file *filp, char __user *buf, size_t len, lostruct iov_iter iter;ssize_t ret; -init_sync_kiocb (&kiocb, filp); +init_kiocb (&kiocb, filp,READ ); kiocb.ki_pos = (ppos ? *ppos :0 );iov_iter_ubuf (&iter,ITER_DEST , buf, len);
@@ -422,7 +422,7 @@ ssize_t __kernel_read(struct file *file, void *buf, size_t count, loff_t *pos)if (unlikely (!file->f_op->read_iter || file->f_op->read))return warn_unsupported (file,"read" ); -init_sync_kiocb (&kiocb, file); +init_kiocb (&kiocb, file,READ ); kiocb.ki_pos = pos ? *pos :0 ;iov_iter_kvec (&iter,ITER_DEST , &iov,1 , iov.iov_len); ret = file->f_op->read_iter (&kiocb, &iter);
@@ -484,7 +484,7 @@ static ssize_t new_sync_write(struct file *filp, const char __user *buf, size_tstruct iov_iter iter;ssize_t ret; -init_sync_kiocb (&kiocb, filp); +init_kiocb (&kiocb, filp,WRITE ); kiocb.ki_pos = (ppos ? *ppos :0 );iov_iter_ubuf (&iter,ITER_SOURCE , (void __user *)buf, len);
@@ -512,7 +512,7 @@ ssize_t __kernel_write_iter(struct file *file, struct iov_iter *from, loff_t *poif (unlikely (!file->f_op->write_iter || file->f_op->write))return warn_unsupported (file,"write" ); -init_sync_kiocb (&kiocb, file); +init_kiocb (&kiocb, file,WRITE ); kiocb.ki_pos = pos ? *pos :0 ; ret = file->f_op->write_iter (&kiocb, from);if (ret >0 ) {
@@ -723,7 +723,7 @@ static ssize_t do_iter_readv_writev(struct file *filp, struct iov_iter *iter,struct kiocb kiocb;ssize_t ret; -init_sync_kiocb (&kiocb, filp); +init_kiocb (&kiocb, filp, type); ret =kiocb_set_rw_flags (&kiocb, flags);if (ret)return ret;
fs/seq_file.c +1 -1
@@ -155,7 +155,7 @@ ssize_t seq_read(struct file *file, char __user *buf, size_t size, loff_t *ppos)struct iov_iter iter;ssize_t ret; -init_sync_kiocb (&kiocb, file); +init_kiocb (&kiocb, file,READ );iov_iter_init (&iter,ITER_DEST , &iov,1 , size); kiocb.ki_pos = *ppos;
fs/splice.c +1 -1
@@ -362,7 +362,7 @@ ssize_t copy_splice_read(struct file *in, loff_t *ppos,/* Do the I/O */ iov_iter_bvec (&to,ITER_DEST , bv, npages, len); -init_sync_kiocb (&kiocb, in); +init_kiocb (&kiocb, in,READ ); kiocb.ki_pos = *ppos; ret =call_read_iter (in, &kiocb, &to);
include/linux/fs.h +5 -1
@@ -2017,13 +2017,17 @@ static inline bool HAS_UNMAPPED_ID(struct mnt_idmap *idmap, !vfsgid_valid (i_gid_into_vfsgid (idmap, inode)); } -static inline void init_sync_kiocb (struct kiocb *kiocb,struct file *filp) +static inline void init_kiocb (struct kiocb *kiocb,struct file *filp, +unsigned int rw) { *kiocb = (struct kiocb ) { .ki_filp = filp, .ki_flags = filp->f_iocb_flags, .ki_ioprio =get_current_ioprio (), }; + +if (rw ==WRITE ) + kiocb->ki_flags |=IOCB_WRITE ; } static inline void kiocb_clone(struct kiocb *kiocb, struct kiocb *kiocb_src,
mm/filemap.c +1 -1
@@ -2905,7 +2905,7 @@ ssize_t filemap_splice_read(struct file *in, loff_t *ppos,if (unlikely (*ppos >= in->f_mapping->host->i_sb->s_maxbytes))return 0 ; -init_sync_kiocb (&iocb, in); +init_kiocb (&iocb, in,READ ); iocb.ki_pos = *ppos;/* Work out how much data we can actually add into the pipe */
mm/page_io.c +2 -2
@@ -312,7 +312,7 @@ static void swap_writepage_fs(struct page *page, struct writeback_control *wbc) }if (!sio) { sio =mempool_alloc (sio_pool,GFP_NOIO ); -init_sync_kiocb (&sio->iocb, swap_file); +init_kiocb (&sio->iocb, swap_file,WRITE ); sio->iocb.ki_complete = sio_write_complete; sio->iocb.ki_pos = pos; sio->pages =0 ;
@@ -443,7 +443,7 @@ static void swap_readpage_fs(struct page *page, }if (!sio) { sio =mempool_alloc (sio_pool,GFP_KERNEL ); -init_sync_kiocb (&sio->iocb, sis->swap_file); +init_kiocb (&sio->iocb, sis->swap_file,READ ); sio->iocb.ki_pos = pos; sio->iocb.ki_complete = sio_read_complete; sio->pages =0 ;
Re: [RFC PATCH 02/11] vfs: Set IOCB_WRITE in iocbs that we're going to write from
Looks good:
David Howells
maintainerRFC PATCH 3/11 vfs: Use init_kiocb() to initialise new IOCBs
In reply to David HowellsA number of places that generate kiocbs didn't use init_sync_kiocb() to initialise the new kiocb. Fix these to always use init_kiocb().
Note that aio and io_uring pass information in through ki_filp through an overlaid union before I can call init_kiocb(), so that gets reinitialised. I don't think it clobbers anything else.
After this point, IOCB_WRITE is only set by init_kiocb().
--- drivers/block/loop.c | 11 ++++++----- drivers/nvme/target/io-cmd-file.c | 5 +++-- drivers/target/target_core_file.c | 2 +- fs/aio.c | 9 ++++----- fs/cachefiles/io.c | 10 ++++------ io_uring/rw.c | 10 +++++----- 6 files changed, 23 insertions(+), 24 deletions(-)
drivers/block/loop.c +6 -5
@@ -439,16 +439,17 @@ static int lo_rw_aio(struct loop_device *lo, struct loop_cmd *cmd, }atomic_set (&cmd->ref,2 ); -iov_iter_bvec (&iter, rw, bvec, nr_bvec,blk_rq_bytes (rq)); +iov_iter_bvec (&iter, rw ==WRITE ?ITER_SOURCE :ITER_DEST , + bvec, nr_bvec,blk_rq_bytes (rq)); iter.iov_offset = offset; +init_kiocb (&cmd->iocb, file, rw); cmd->iocb.ki_pos = pos; - cmd->iocb.ki_filp = file; cmd->iocb.ki_complete = lo_rw_aio_complete; cmd->iocb.ki_flags =IOCB_DIRECT ; cmd->iocb.ki_ioprio =IOPRIO_PRIO_VALUE (IOPRIO_CLASS_NONE ,0 ); -if (rw ==ITER_SOURCE ) +if (rw ==WRITE ) ret =call_write_iter (file, &cmd->iocb, &iter);else ret =call_read_iter (file, &cmd->iocb, &iter);
@@ -490,12 +491,12 @@ static int do_req_filebacked(struct loop_device *lo, struct request *rq)return lo_fallocate (lo, rq, pos,FALLOC_FL_PUNCH_HOLE );case REQ_OP_WRITE :if (cmd->use_aio) -return lo_rw_aio (lo, cmd, pos,ITER_SOURCE ); +return lo_rw_aio (lo, cmd, pos,WRITE );else return lo_write_simple (lo, rq, pos);case REQ_OP_READ :if (cmd->use_aio) -return lo_rw_aio (lo, cmd, pos,ITER_DEST ); +return lo_rw_aio (lo, cmd, pos,READ );else return lo_read_simple (lo, rq, pos);default :
drivers/nvme/target/io-cmd-file.c +3 -2
@@ -85,17 +85,18 @@ static ssize_t nvmet_file_submit_bvec(struct nvmet_req *req, loff_t pos,if (req->cmd->rw.control &cpu_to_le16 (NVME_RW_FUA )) ki_flags |=IOCB_DSYNC ; call_iter = req->ns->file->f_op->write_iter; +init_kiocb (iocb, req->ns->file,WRITE ); rw =ITER_SOURCE ; }else { call_iter = req->ns->file->f_op->read_iter; +init_kiocb (iocb, req->ns->file,READ ); rw =ITER_DEST ; }iov_iter_bvec (&iter, rw, req->f.bvec, nr_segs, count); + iocb->ki_flags |= ki_flags; iocb->ki_pos = pos; - iocb->ki_filp = req->ns->file; - iocb->ki_flags = ki_flags | iocb->ki_filp->f_iocb_flags;return call_iter (iocb, &iter); }
drivers/target/target_core_file.c +1 -1
@@ -287,11 +287,11 @@ fd_execute_rw_aio(struct se_cmd *cmd, struct scatterlist *sgl, u32 sgl_nents, }iov_iter_bvec (&iter, is_write, aio_cmd->bvecs, sgl_nents, len); +init_kiocb (&aio_cmd->iocb, file, is_write); aio_cmd->cmd = cmd; aio_cmd->len = len; aio_cmd->iocb.ki_pos = cmd->t_task_lba * dev->dev_attrib.block_size; - aio_cmd->iocb.ki_filp = file; aio_cmd->iocb.ki_complete = cmd_rw_aio_complete; aio_cmd->iocb.ki_flags =IOCB_DIRECT ;
fs/aio.c +4 -5
@@ -1461,14 +1461,14 @@ static void aio_complete_rw(struct kiocb *kiocb, long res)iocb_put (iocb); } -static int aio_prep_rw (struct kiocb *req,const struct iocb *iocb) +static int aio_prep_rw (struct kiocb *req,const struct iocb *iocb,int rw) {int ret; +init_kiocb (req, req->ki_filp, rw); req->ki_complete = aio_complete_rw; req->private =NULL ; req->ki_pos = iocb->aio_offset; - req->ki_flags = req->ki_filp->f_iocb_flags;if (iocb->aio_flags &IOCB_FLAG_RESFD ) req->ki_flags |=IOCB_EVENTFD ;if (iocb->aio_flags &IOCB_FLAG_IOPRIO ) {
@@ -1539,7 +1539,7 @@ static int aio_read(struct kiocb *req, const struct iocb *iocb,struct file *file;int ret; - ret =aio_prep_rw (req, iocb); + ret =aio_prep_rw (req, iocb,READ );if (ret)return ret; file = req->ki_filp;
@@ -1566,7 +1566,7 @@ static int aio_write(struct kiocb *req, const struct iocb *iocb,struct file *file;int ret; - ret =aio_prep_rw (req, iocb); + ret =aio_prep_rw (req, iocb,WRITE );if (ret)return ret; file = req->ki_filp;
@@ -1592,7 +1592,6 @@ static int aio_write(struct kiocb *req, const struct iocb *iocb,sb_start_write (file_inode (file)->i_sb);__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)); }kfree (iovec);
fs/cachefiles/io.c +4 -6
@@ -134,11 +134,10 @@ static int cachefiles_read(struct netfs_cache_resources *cres,if (!ki) goto presubmission_error; +init_kiocb (&ki->iocb, file,READ );refcount_set (&ki->ki_refcnt,2 ); - ki->iocb.ki_filp = file; + ki->iocb.ki_flags |=IOCB_DIRECT ; ki->iocb.ki_pos = start_pos + skipped; - ki->iocb.ki_flags =IOCB_DIRECT ; - ki->iocb.ki_ioprio =get_current_ioprio (); ki->skipped = skipped; ki->object = object; ki->inval_counter = cres->inval_counter;
@@ -306,10 +305,9 @@ int __cachefiles_write(struct cachefiles_object *object, }refcount_set (&ki->ki_refcnt,2 ); - ki->iocb.ki_filp = file; +init_kiocb (&ki->iocb, file,WRITE ); ki->iocb.ki_pos = start_pos; - ki->iocb.ki_flags =IOCB_DIRECT |IOCB_WRITE ; - ki->iocb.ki_ioprio =get_current_ioprio (); + ki->iocb.ki_flags |=IOCB_DIRECT ; ki->object = object; ki->start = start_pos; ki->len = len;
io_uring/rw.c +5 -5
@@ -655,12 +655,13 @@ static bool need_complete_io(struct io_kiocb *req)S_ISBLK (file_inode (req->file)->i_mode); } -static int io_rw_init_file (struct io_kiocb *req,fmode_t mode) +static int io_rw_init_file (struct io_kiocb *req,unsigned int io_direction) { struct io_rw *rw = io_kiocb_to_cmd(req, struct io_rw);struct kiocb *kiocb = &rw->kiocb;struct io_ring_ctx *ctx = req->ctx;struct file *file = req->file; +fmode_t mode = (io_direction ==WRITE ) ?FMODE_WRITE :FMODE_READ ;int ret;if (unlikely (!file || !(file->f_mode & mode)))
@@ -669,7 +670,7 @@ static int io_rw_init_file(struct io_kiocb *req, fmode_t mode)if (!(req->flags &REQ_F_FIXED_FILE )) req->flags |=io_file_get_flags (file); - kiocb->ki_flags = file->f_iocb_flags; +init_kiocb (kiocb, file, io_direction); ret =kiocb_set_rw_flags (kiocb, rw->flags);if (unlikely (ret))return ret;
@@ -738,7 +739,7 @@ int io_read(struct io_kiocb *req, unsigned int issue_flags)iov_iter_restore (&s->iter, &s->iter_state); iovec =NULL ; } - ret =io_rw_init_file (req,FMODE_READ ); + ret =io_rw_init_file (req,READ );if (unlikely (ret)) {kfree (iovec);return ret;
@@ -870,7 +871,7 @@ int io_write(struct io_kiocb *req, unsigned int issue_flags)iov_iter_restore (&s->iter, &s->iter_state); iovec =NULL ; } - ret =io_rw_init_file (req,FMODE_WRITE ); + ret =io_rw_init_file (req,WRITE );if (unlikely (ret)) {kfree (iovec);return ret;
@@ -914,7 +915,6 @@ int io_write(struct io_kiocb *req, unsigned int issue_flags)__sb_writers_release (file_inode (req->file)->i_sb,SB_FREEZE_WRITE ); } - kiocb->ki_flags |=IOCB_WRITE ;if (likely (req->file->f_op->write_iter)) ret2 =call_write_iter (req->file, kiocb, &s->iter);
Jens Axboe
maintainerRe: [RFC PATCH 03/11] vfs: Use init_kiocb() to initialise new IOCBs
Quoted 9 lines · David Howells
io_uring/rw.c +0
-1@@ -655,12 +655,13 @@ static bool need_complete_io(struct io_kiocb *req)S_ISBLK (file_inode (req->file)->i_mode); } -static int io_rw_init_file (struct io_kiocb *req,fmode_t mode)
io_uring/rw.c static bool need_complete_io(struct io_kiocb *req) · line 667
Quoted 10 lines
io_uring/rw.c +2
-0+static int io_rw_init_file (struct io_kiocb *req,unsigned int io_direction) { struct io_rw *rw = io_kiocb_to_cmd(req, struct io_rw);struct kiocb *kiocb = &rw->kiocb;struct io_ring_ctx *ctx = req->ctx;struct file *file = req->file; +fmode_t mode = (io_direction ==WRITE ) ?FMODE_WRITE :FMODE_READ ;int ret;if (unlikely (!file || !(file->f_mode & mode)))
Not ideal to add a branch here, probably better to just pass in both?
Quoted 11 lines
io_uring/rw.c +1
-1@@ -870,7 +871,7 @@ int io_write(struct io_kiocb *req, unsigned int issue_flags)iov_iter_restore (&s->iter, &s->iter_state); iovec =NULL ; } - ret =io_rw_init_file (req,FMODE_WRITE ); + ret =io_rw_init_file (req,WRITE );if (unlikely (ret)) {kfree (iovec);return ret;
io_uring/rw.c int io_write(struct io_kiocb *req, unsigned int issue_flags) · line 920
Quoted 7 lines
io_uring/rw.c +0
-1@@ -914,7 +915,6 @@ int io_write(struct io_kiocb *req, unsigned int issue_flags)__sb_writers_release (file_inode (req->file)->i_sb,SB_FREEZE_WRITE ); } - kiocb->ki_flags |=IOCB_WRITE ;if (likely (req->file->f_op->write_iter)) ret2 =call_write_iter (req->file, kiocb, &s->iter);
One concern here is that we're using IOCB_WRITE here to tell if sb_start_write() has been done or not, and hence whether kiocb_end_write() needs to be called. You know set it earlier, which means if we get a failure if we need to setup async data, then we know have IOCB_WRITE set at that point even though we did not call sb_start_write().
Signature · 1 line
Jens Axboe
David Howells
maintainerRe: [RFC PATCH 03/11] vfs: Use init_kiocb() to initialise new IOCBs
Quoted 6 lines · Jens Axboe
One concern here is that we're using
IOCB_WRITEhere to tell ifsb_start_write()has been done or not, and hence whetherkiocb_end_write()needs to be called. You know set it earlier, which means if we get a failure if we need to setup async data, then we know haveIOCB_WRITEset at that point even though we did not callsb_start_write().
Hmmm... It's set earlier in a number of places anyway - __cachefiles_write() for example.
Btw, can you please put some comments on the IOCB_* constants? I have to guess at what they mean and how they're meant to be used. Or better still, get Christoph to write Documentation/core-api/iocb.rst describing the API? ;-)
David
Jens Axboe
maintainerRe: [RFC PATCH 03/11] vfs: Use init_kiocb() to initialise new IOCBs
Quoted 11 lines · David Howells
Quoted 6 lines · Jens Axboe
One concern here is that we're using
IOCB_WRITEhere to tell ifsb_start_write()has been done or not, and hence whetherkiocb_end_write()needs to be called. You know set it earlier, which means if we get a failure if we need to setup async data, then we know haveIOCB_WRITEset at that point even though we did not callsb_start_write().Hmmm... It's set earlier in a number of places anyway -
__cachefiles_write()for example.
Not sure how that's relevant, that's a private kiocb and not related to the private one that io_uring uses?
Quoted 4 lines
Btw, can you please put some comments on the IOCB_* constants? I have to guess at what they mean and how they're meant to be used. Or better still, get Christoph to write
Documentation/core-api/iocb.rstdescribing the API? ;-)
The ones I have added do have comments, mostly, though it's not a lot of commentary for sure... Which ones are confusing and need better comments? Would be happy to do that. I do think the comments belong in there rather than have a separate doc for the kiocb. Though one thing that's confusing is the ki_private ownership. You'd think it belongs to the owner of the kiocb, but nope, it has random uses in iomap and ocfs2 at least.
Signature · 1 line
Jens Axboe
Re: [RFC PATCH 03/11] vfs: Use init_kiocb() to initialise new IOCBs
In reply to David HowellsQuoted 8 lines · David Howells
A number of places that generate kiocbs didn't use
init_sync_kiocb()to initialise the new kiocb. Fix these to always useinit_kiocb().Note that aio and
io_uringpass information in throughki_filpthrough an overlaid union before I can callinit_kiocb(), so that gets reinitialised. I don't think it clobbers anything else.After this point,
IOCB_WRITEis only set byinit_kiocb().
Nothing in this patch touches the VFS, so the subject line is wrong. And I think we're better off splitting it into one per subsystem, which also allows documenting the exact changes.
Which includes now setting the flags from f_iocb_flags and setting and I/O priority. Please explain why this is harmless or even useful.
drivers/block/loop.c static int lo_rw_aio(struct loop_device *lo, struct loop_cmd *cmd, · line 443
Quoted 11 lines
drivers/block/loop.c +2
-1@@ -439,16 +439,17 @@ static int lo_rw_aio(struct loop_device *lo, struct loop_cmd *cmd, }atomic_set (&cmd->ref,2 ); -iov_iter_bvec (&iter, rw, bvec, nr_bvec,blk_rq_bytes (rq)); +iov_iter_bvec (&iter, rw ==WRITE ?ITER_SOURCE :ITER_DEST , + bvec, nr_bvec,blk_rq_bytes (rq));
Given the cover letter I expect this is going to go away, but the changes would probably a lot more readable if you had a helper to convert from READ/WRITE to the iter flags inbetween.
Or maybe do it the other way - add a helper to init the
drivers/block/loop.c static int do_req_filebacked(struct loop_device *lo, struct request *rq) · line 499
Quoted 12 lines
drivers/block/loop.c +2
-2@@ -490,12 +491,12 @@ static int do_req_filebacked(struct loop_device *lo, struct request *rq)return lo_fallocate (lo, rq, pos,FALLOC_FL_PUNCH_HOLE );case REQ_OP_WRITE :if (cmd->use_aio) -return lo_rw_aio (lo, cmd, pos,ITER_SOURCE ); +return lo_rw_aio (lo, cmd, pos,WRITE );else return lo_write_simple (lo, rq, pos);case REQ_OP_READ :if (cmd->use_aio) -return lo_rw_aio (lo, cmd, pos,ITER_DEST ); +return lo_rw_aio (lo, cmd, pos,READ );
I don't think there is any need to pass the rw argument at all, lo_rw_aio can just do an op_is_write(req_op(rq))
drivers/block/loop.c
Quoted 11 lines
drivers/block/loop.c +1
-1-static int io_rw_init_file (struct io_kiocb *req,fmode_t mode) +static int io_rw_init_file (struct io_kiocb *req,unsigned int io_direction) { struct io_rw *rw = io_kiocb_to_cmd(req, struct io_rw);drivers/block/loop.c +1
-0struct kiocb *kiocb = &rw->kiocb;struct io_ring_ctx *ctx = req->ctx;struct file *file = req->file; +fmode_t mode = (io_direction ==WRITE ) ?FMODE_WRITE :FMODE_READ ;int ret;if (unlikely (!file || !(file->f_mode & mode)))
I'd just move this check into the two callers, that way you can hard code the mode instead of adding a conversion.
David Howells
maintainerRFC PATCH 4/11 iov_iter: Use IOCB_WRITE rather than iterator direction
In reply to David HowellsIf a kiocb is available, use the IOCB_WRITE flag instead of the iterator direction.
--- block/fops.c | 8 ++++---- fs/9p/vfs_addr.c | 2 +- fs/affs/file.c | 4 ++-- fs/ceph/file.c | 2 +- fs/dax.c | 2 +- fs/direct-io.c | 22 +++++++++++----------- fs/exfat/inode.c | 6 +++--- fs/ext2/inode.c | 2 +- fs/f2fs/file.c | 10 +++++----- fs/fat/inode.c | 4 ++-- fs/fuse/dax.c | 2 +- fs/fuse/file.c | 8 ++++---- fs/hfs/inode.c | 2 +- fs/hfsplus/inode.c | 2 +- fs/iomap/direct-io.c | 2 +- fs/jfs/inode.c | 2 +- fs/nfs/direct.c | 2 +- fs/nilfs2/inode.c | 2 +- fs/ntfs3/inode.c | 2 +- fs/ocfs2/aops.c | 2 +- fs/orangefs/inode.c | 2 +- fs/reiserfs/inode.c | 2 +- fs/udf/inode.c | 2 +- include/linux/fs.h | 10 ++++++++++ 24 files changed, 57 insertions(+), 47 deletions(-)
block/fops.c +4 -4
@@ -73,7 +73,7 @@ static ssize_t __blkdev_direct_IO_simple(struct kiocb *iocb,return -ENOMEM ; } -if (iov_iter_rw (iter) ==READ ) { +if (iocb_is_read (iocb)) {bio_init (&bio, bdev, vecs, nr_pages,REQ_OP_READ );if (user_backed_iter (iter)) should_dirty = true;
@@ -88,7 +88,7 @@ static ssize_t __blkdev_direct_IO_simple(struct kiocb *iocb, goto out; ret = bio.bi_iter.bi_size; -if (iov_iter_rw (iter) ==WRITE ) +if (iocb_is_write (iocb))task_io_account_write (ret);if (iocb->ki_flags &IOCB_NOWAIT )
@@ -174,7 +174,7 @@ static ssize_t __blkdev_direct_IO(struct kiocb *iocb, struct iov_iter *iter,struct blk_plug plug;struct blkdev_dio *dio;struct bio *bio; -bool is_read = (iov_iter_rw (iter) ==READ ), is_sync; +bool is_read =iocb_is_read (iocb), is_sync;blk_opf_t opf = is_read ?REQ_OP_READ :dio_bio_write_op (iocb);loff_t pos = iocb->ki_pos;int ret =0 ;
@@ -311,7 +311,7 @@ static ssize_t __blkdev_direct_IO_async(struct kiocb *iocb, unsigned int nr_pages) {struct block_device *bdev =I_BDEV (iocb->ki_filp->f_mapping->host); -bool is_read =iov_iter_rw (iter) ==READ ; +bool is_read =iocb_is_read (iocb);blk_opf_t opf = is_read ?REQ_OP_READ :dio_bio_write_op (iocb);struct blkdev_dio *dio;struct bio *bio;
fs/9p/vfs_addr.c +1 -1
@@ -257,7 +257,7 @@ v9fs_direct_IO(struct kiocb *iocb, struct iov_iter *iter)ssize_t n;int err =0 ; -if (iov_iter_rw (iter) ==WRITE ) { +if (iocb_is_write (iocb)) { n =p9_client_write (file->private_data, pos, iter, &err);if (n) {struct inode *inode =file_inode (file);
fs/affs/file.c +2 -2
@@ -400,7 +400,7 @@ affs_direct_IO(struct kiocb *iocb, struct iov_iter *iter)loff_t offset = iocb->ki_pos;ssize_t ret; -if (iov_iter_rw (iter) ==WRITE ) { +if (iocb_is_write (iocb)) {loff_t size = offset + count;if (AFFS_I (inode)->mmu_private < size)
@@ -408,7 +408,7 @@ affs_direct_IO(struct kiocb *iocb, struct iov_iter *iter) } ret =blockdev_direct_IO (iocb, inode, iter, affs_get_block); -if (ret <0 &&iov_iter_rw (iter) ==WRITE ) +if (ret <0 &&iocb_is_write (iocb))affs_write_failed (mapping, offset + count);return ret; }
fs/ceph/file.c +1 -1
@@ -1280,7 +1280,7 @@ ceph_direct_read_write(struct kiocb *iocb, struct iov_iter *iter,struct timespec64 mtime =current_time (inode);size_t count =iov_iter_count (iter);loff_t pos = iocb->ki_pos; -bool write =iov_iter_rw (iter) ==WRITE ; +bool write =iocb_is_write (iocb);bool should_dirty = !write &&user_backed_iter (iter);if (write &&ceph_snap (file_inode (file)) !=CEPH_NOSNAP )
fs/dax.c +1 -1
@@ -1573,7 +1573,7 @@ dax_iomap_rw(struct kiocb *iocb, struct iov_iter *iter,if (!iomi.len)return 0 ; -if (iov_iter_rw (iter) ==WRITE ) { +if (iocb_is_write (iocb)) {lockdep_assert_held_write (&iomi.inode->i_rwsem); iomi.flags |=IOMAP_WRITE ; }else {
fs/direct-io.c +11 -11
@@ -1125,7 +1125,7 @@ ssize_t __blockdev_direct_IO(struct kiocb *iocb, struct inode *inode,*/ /* watch out for a 0 len io from a tricksy fs */ -if (iov_iter_rw (iter) ==READ && !count) +if (iocb_is_read (iocb) && !count)return 0 ; dio =kmem_cache_alloc (dio_cache,GFP_KERNEL );
@@ -1139,7 +1139,7 @@ ssize_t __blockdev_direct_IO(struct kiocb *iocb, struct inode *inode,memset (dio,0 , offsetof(struct dio , pages)); dio->flags = flags; -if (dio->flags &DIO_LOCKING &&iov_iter_rw (iter) ==READ ) { +if (dio->flags &DIO_LOCKING &&iocb_is_read (iocb)) {/* will be released by direct_io_worker */ inode_lock (inode); }
@@ -1147,7 +1147,7 @@ ssize_t __blockdev_direct_IO(struct kiocb *iocb, struct inode *inode,/* Once we sampled i_size check for reads beyond EOF */ dio->i_size =i_size_read (inode); -if (iov_iter_rw (iter) ==READ && offset >= dio->i_size) { +if (iocb_is_read (iocb) && offset >= dio->i_size) { retval =0 ; goto fail_dio; }
@@ -1160,7 +1160,7 @@ ssize_t __blockdev_direct_IO(struct kiocb *iocb, struct inode *inode, goto fail_dio; } -if (dio->flags &DIO_LOCKING &&iov_iter_rw (iter) ==READ ) { +if (dio->flags &DIO_LOCKING &&iocb_is_read (iocb)) {struct address_space *mapping = iocb->ki_filp->f_mapping; retval =filemap_write_and_wait_range (mapping, offset, end -1 );
@@ -1176,13 +1176,13 @@ ssize_t __blockdev_direct_IO(struct kiocb *iocb, struct inode *inode,*/ if (is_sync_kiocb (iocb)) dio->is_async = false; -else if (iov_iter_rw (iter) ==WRITE && end >i_size_read (inode)) +else if (iocb_is_write (iocb) && end >i_size_read (inode)) dio->is_async = false;else dio->is_async = true; dio->inode = inode; -if (iov_iter_rw (iter) ==WRITE ) { +if (iocb_is_write (iocb)) { dio->opf =REQ_OP_WRITE |REQ_SYNC |REQ_IDLE ;if (iocb->ki_flags &IOCB_NOWAIT ) dio->opf |=REQ_NOWAIT ;
@@ -1194,7 +1194,7 @@ ssize_t __blockdev_direct_IO(struct kiocb *iocb, struct inode *inode,* For AIO O_(D)SYNC writes we need to defer completions to a workqueue * so that we can call ->fsync. */ -if (dio->is_async &&iov_iter_rw (iter) ==WRITE ) { +if (dio->is_async &&iocb_is_write (iocb)) { retval =0 ;if (iocb_is_dsync (iocb)) retval =dio_set_defer_completion (dio);
@@ -1230,7 +1230,7 @@ ssize_t __blockdev_direct_IO(struct kiocb *iocb, struct inode *inode,spin_lock_init (&dio->bio_lock); dio->refcount =1 ; - dio->should_dirty =user_backed_iter (iter) &&iov_iter_rw (iter) ==READ ; + dio->should_dirty =user_backed_iter (iter) &&iocb_is_read (iocb); sdio.iter = iter; sdio.final_block_in_request = end >> blkbits;
@@ -1287,7 +1287,7 @@ ssize_t __blockdev_direct_IO(struct kiocb *iocb, struct inode *inode,* we can let i_mutex go now that its achieved its purpose * of protecting us from looking up uninitialized blocks. */ -if (iov_iter_rw (iter) ==READ && (dio->flags &DIO_LOCKING )) +if (iocb_is_read (iocb) && (dio->flags &DIO_LOCKING ))inode_unlock (dio->inode);/*
@@ -1299,7 +1299,7 @@ ssize_t __blockdev_direct_IO(struct kiocb *iocb, struct inode *inode,*/ BUG_ON (retval == -EIOCBQUEUED );if (dio->is_async && retval ==0 && dio->result && - (iov_iter_rw (iter) ==READ || dio->result == count)) + (iocb_is_read (iocb) || dio->result == count)) retval = -EIOCBQUEUED ;else dio_await_completion (dio);
@@ -1312,7 +1312,7 @@ ssize_t __blockdev_direct_IO(struct kiocb *iocb, struct inode *inode,return retval; fail_dio: -if (dio->flags &DIO_LOCKING &&iov_iter_rw (iter) ==READ ) +if (dio->flags &DIO_LOCKING &&iocb_is_read (iocb))inode_unlock (inode);kmem_cache_free (dio_cache, dio);
fs/exfat/inode.c +3 -3
@@ -411,10 +411,10 @@ static ssize_t exfat_direct_IO(struct kiocb *iocb, struct iov_iter *iter)struct address_space *mapping = iocb->ki_filp->f_mapping;struct inode *inode = mapping->host;loff_t size = iocb->ki_pos +iov_iter_count (iter); -int rw =iov_iter_rw (iter); +bool writing =iocb_is_write (iocb);ssize_t ret; -if (rw ==WRITE ) { +if (writing) {/* * FIXME: blockdev_direct_IO() doesn't use ->write_begin(), * so we need to update the ->i_size_aligned to block boundary.
@@ -433,7 +433,7 @@ static ssize_t exfat_direct_IO(struct kiocb *iocb, struct iov_iter *iter)* condition of exfat_get_block() and ->truncate(). */ ret =blockdev_direct_IO (iocb, inode, iter, exfat_get_block); -if (ret <0 && (rw &WRITE )) +if (ret <0 && writing)exfat_write_failed (mapping, size);return ret; }
fs/ext2/inode.c +1 -1
@@ -919,7 +919,7 @@ ext2_direct_IO(struct kiocb *iocb, struct iov_iter *iter)ssize_t ret; ret =blockdev_direct_IO (iocb, inode, iter, ext2_get_block); -if (ret <0 &&iov_iter_rw (iter) ==WRITE ) +if (ret <0 &&iocb_is_write (iocb))ext2_write_failed (mapping, offset + count);return ret; }
fs/f2fs/file.c +5 -5
@@ -805,7 +805,7 @@ int f2fs_truncate(struct inode *inode)return 0 ; } -static bool f2fs_force_buffered_io (struct inode *inode,int rw) +static bool f2fs_force_buffered_io (struct inode *inode,bool writing) {struct f2fs_sb_info *sbi =F2FS_I_SB (inode);
@@ -823,9 +823,9 @@ static bool f2fs_force_buffered_io(struct inode *inode, int rw)* for blkzoned device, fallback direct IO to buffered IO, so * all IOs can be serialized by log-structured write. */ -if (f2fs_sb_has_blkzoned (sbi) && (rw ==WRITE )) +if (f2fs_sb_has_blkzoned (sbi) && writing)return true; -if (f2fs_lfs_mode (sbi) && rw ==WRITE &&F2FS_IO_ALIGNED (sbi)) +if (f2fs_lfs_mode (sbi) && writing &&F2FS_IO_ALIGNED (sbi))return true;if (is_sbi_flag_set (sbi,SBI_CP_DISABLED ))return true;
@@ -861,7 +861,7 @@ int f2fs_getattr(struct mnt_idmap *idmap, const struct path *path,unsigned int bsize =i_blocksize (inode); stat->result_mask |=STATX_DIOALIGN ; -if (!f2fs_force_buffered_io (inode,WRITE )) { +if (!f2fs_force_buffered_io (inode, true)) { stat->dio_mem_align = bsize; stat->dio_offset_align = bsize; }
@@ -4280,7 +4280,7 @@ static bool f2fs_should_use_dio(struct inode *inode, struct kiocb *iocb,if (!(iocb->ki_flags &IOCB_DIRECT ))return false; -if (f2fs_force_buffered_io (inode,iov_iter_rw (iter))) +if (f2fs_force_buffered_io (inode,iocb_is_write (iocb)))return false;/*
fs/fat/inode.c +2 -2
@@ -261,7 +261,7 @@ static ssize_t fat_direct_IO(struct kiocb *iocb, struct iov_iter *iter)loff_t offset = iocb->ki_pos;ssize_t ret; -if (iov_iter_rw (iter) ==WRITE ) { +if (iocb_is_write (iocb)) {/* * FIXME: blockdev_direct_IO() doesn't use ->write_begin(), * so we need to update the ->mmu_private to block boundary.
@@ -281,7 +281,7 @@ static ssize_t fat_direct_IO(struct kiocb *iocb, struct iov_iter *iter)* condition of fat_get_block() and ->truncate(). */ ret =blockdev_direct_IO (iocb, inode, iter, fat_get_block); -if (ret <0 &&iov_iter_rw (iter) ==WRITE ) +if (ret <0 &&iocb_is_write (iocb))fat_write_failed (mapping, offset + count);return ret;
fs/fuse/dax.c +1 -1
@@ -720,7 +720,7 @@ static bool file_extending_write(struct kiocb *iocb, struct iov_iter *from) {struct inode *inode =file_inode (iocb->ki_filp); -return (iov_iter_rw (from) ==WRITE && +return (iocb_is_write (iocb) && ((iocb->ki_pos) >=i_size_read (inode) || (iocb->ki_pos +iov_iter_count (from) >i_size_read (inode)))); }
fs/fuse/file.c +4 -4
@@ -2911,7 +2911,7 @@ fuse_direct_IO(struct kiocb *iocb, struct iov_iter *iter) inode = file->f_mapping->host; i_size =i_size_read (inode); -if ((iov_iter_rw (iter) ==READ ) && (offset >= i_size)) +if (iocb_is_read (iocb) && (offset >= i_size))return 0 ; io =kmalloc (sizeof (struct fuse_io_priv ),GFP_KERNEL );
@@ -2923,7 +2923,7 @@ fuse_direct_IO(struct kiocb *iocb, struct iov_iter *iter) io->bytes =-1 ; io->size =0 ; io->offset = offset; - io->write = (iov_iter_rw (iter) ==WRITE ); + io->write =iocb_is_write (iocb); io->err =0 ;/* * By default, we want to optimize all I/Os with async request
@@ -2956,7 +2956,7 @@ fuse_direct_IO(struct kiocb *iocb, struct iov_iter *iter) io->done = &wait; } -if (iov_iter_rw (iter) ==WRITE ) { +if (iocb_is_write (iocb)) { ret =fuse_direct_io (io, iter, &pos,FUSE_DIO_WRITE );fuse_invalidate_attr_mask (inode,FUSE_STATX_MODSIZE ); }else {
@@ -2979,7 +2979,7 @@ fuse_direct_IO(struct kiocb *iocb, struct iov_iter *iter)kref_put (&io->refcnt, fuse_io_release); -if (iov_iter_rw (iter) ==WRITE ) { +if (iocb_is_write (iocb)) {fuse_write_update_attr (inode, pos, ret);/* For extending writes we already hold exclusive lock */ if (ret <0 && offset + count > i_size)
fs/hfs/inode.c +1 -1
@@ -141,7 +141,7 @@ static ssize_t hfs_direct_IO(struct kiocb *iocb, struct iov_iter *iter)* In case of error extending write may have instantiated a few * blocks outside i_size. Trim these off again. */ -if (unlikely (iov_iter_rw (iter) ==WRITE && ret <0 )) { +if (unlikely (iocb_is_write (iocb) && ret <0 )) {loff_t isize =i_size_read (inode);loff_t end = iocb->ki_pos + count;
fs/hfsplus/inode.c +1 -1
@@ -138,7 +138,7 @@ static ssize_t hfsplus_direct_IO(struct kiocb *iocb, struct iov_iter *iter)* In case of error extending write may have instantiated a few * blocks outside i_size. Trim these off again. */ -if (unlikely (iov_iter_rw (iter) ==WRITE && ret <0 )) { +if (unlikely (iocb_is_write (iocb) && ret <0 )) {loff_t isize =i_size_read (inode);loff_t end = iocb->ki_pos + count;
fs/iomap/direct-io.c +1 -1
@@ -510,7 +510,7 @@ __iomap_dio_rw(struct kiocb *iocb, struct iov_iter *iter,if (iocb->ki_flags &IOCB_NOWAIT ) iomi.flags |=IOMAP_NOWAIT ; -if (iov_iter_rw (iter) ==READ ) { +if (iocb_is_read (iocb)) {if (iomi.pos >= dio->i_size) goto out_free_dio;
fs/jfs/inode.c +1 -1
@@ -334,7 +334,7 @@ static ssize_t jfs_direct_IO(struct kiocb *iocb, struct iov_iter *iter)* In case of error extending write may have instantiated a few * blocks outside i_size. Trim these off again. */ -if (unlikely (iov_iter_rw (iter) ==WRITE && ret <0 )) { +if (unlikely (iocb_is_write (iocb) && ret <0 )) {loff_t isize =i_size_read (inode);loff_t end = iocb->ki_pos + count;
fs/nfs/direct.c +1 -1
@@ -133,7 +133,7 @@ int nfs_swap_rw(struct kiocb *iocb, struct iov_iter *iter)VM_BUG_ON (iov_iter_count (iter) !=PAGE_SIZE ); -if (iov_iter_rw (iter) ==READ ) +if (iocb_is_read (iocb)) ret =nfs_file_direct_read (iocb, iter, true);else ret =nfs_file_direct_write (iocb, iter, true);
fs/nilfs2/inode.c +1 -1
@@ -289,7 +289,7 @@ nilfs_direct_IO(struct kiocb *iocb, struct iov_iter *iter) {struct inode *inode =file_inode (iocb->ki_filp); -if (iov_iter_rw (iter) ==WRITE ) +if (iocb_is_write (iocb))return 0 ;/* Needs synchronization with the cleaner */
fs/ntfs3/inode.c +1 -1
@@ -774,7 +774,7 @@ static ssize_t ntfs_direct_IO(struct kiocb *iocb, struct iov_iter *iter)struct ntfs_inode *ni =ntfs_i (inode);loff_t vbo = iocb->ki_pos;loff_t end; -int wr =iov_iter_rw (iter) &WRITE ; +bool wr =iocb_is_write (iocb);size_t iter_count =iov_iter_count (iter);loff_t valid;ssize_t ret;
fs/ocfs2/aops.c +1 -1
@@ -2456,7 +2456,7 @@ static ssize_t ocfs2_direct_IO(struct kiocb *iocb, struct iov_iter *iter) !ocfs2_supports_append_dio(osb))return 0 ; -if (iov_iter_rw (iter) ==READ ) +if (iocb_is_read (iocb)) get_block = ocfs2_lock_get_block;else get_block = ocfs2_dio_wr_get_block;
fs/orangefs/inode.c +1 -1
@@ -513,7 +513,7 @@ static ssize_t orangefs_direct_IO(struct kiocb *iocb,*/ struct file *file = iocb->ki_filp;loff_t pos = iocb->ki_pos; -enum ORANGEFS_io_type type =iov_iter_rw (iter) ==WRITE ? +enum ORANGEFS_io_type type =iocb_is_write (iocb) ?ORANGEFS_IO_WRITE :ORANGEFS_IO_READ ;loff_t *offset = &pos;struct inode *inode = file->f_mapping->host;
fs/reiserfs/inode.c +1 -1
@@ -3248,7 +3248,7 @@ static ssize_t reiserfs_direct_IO(struct kiocb *iocb, struct iov_iter *iter)* In case of error extending write may have instantiated a few * blocks outside i_size. Trim these off again. */ -if (unlikely (iov_iter_rw (iter) ==WRITE && ret <0 )) { +if (unlikely (iocb_is_write (iocb) && ret <0 )) {loff_t isize =i_size_read (inode);loff_t end = iocb->ki_pos + count;
fs/udf/inode.c +1 -1
@@ -311,7 +311,7 @@ static ssize_t udf_direct_IO(struct kiocb *iocb, struct iov_iter *iter)if (UDF_I (inode)->i_alloc_type ==ICBTAG_FLAG_AD_IN_ICB )return 0 ; ret =blockdev_direct_IO (iocb, inode, iter, udf_get_block); -if (unlikely (ret <0 &&iov_iter_rw (iter) ==WRITE )) +if (unlikely (ret <0 &&iocb_is_write (iocb)))udf_write_failed (mapping, iocb->ki_pos + count);return ret; }
include/linux/fs.h +10 -0
@@ -368,6 +368,16 @@ static inline bool is_sync_kiocb(struct kiocb *kiocb)return kiocb->ki_complete ==NULL ; } +static inline bool iocb_is_write (const struct kiocb *kiocb) +{ +return kiocb->ki_flags &IOCB_WRITE ; +} + +static inline bool iocb_is_read (const struct kiocb *kiocb) +{ +return !iocb_is_write (kiocb); +} +struct address_space_operations {int (*writepage)(struct page *page,struct writeback_control *wbc);int (*read_folio)(struct file *,struct folio *);
David Howells
maintainerRFC PATCH 5/11 iov_iter: Use IOMAP_WRITE rather than iterator direction
In reply to David HowellsIf an iomap_iter is available, use the IOMAP_WRITE flag instead of the iterator direction.
--- fs/dax.c | 4 ++-- fs/iomap/direct-io.c | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-)
fs/dax.c +2 -2
@@ -1438,7 +1438,7 @@ static loff_t dax_iomap_iter(const struct iomap_iter *iomi,loff_t pos = iomi->pos;struct dax_device *dax_dev = iomap->dax_dev;loff_t end = pos + length, done =0 ; -bool write =iov_iter_rw (iter) ==WRITE ; +bool write = iomi->flags &IOMAP_WRITE ;bool cow = write && iomap->flags &IOMAP_F_SHARED ;ssize_t ret =0 ;size_t xfer;
@@ -1498,7 +1498,7 @@ static loff_t dax_iomap_iter(const struct iomap_iter *iomi, map_len =dax_direct_access (dax_dev, pgoff,PHYS_PFN (size),DAX_ACCESS , &kaddr,NULL ); -if (map_len == -EIO &&iov_iter_rw (iter) ==WRITE ) { +if (map_len == -EIO && write) { map_len =dax_direct_access (dax_dev, pgoff,PHYS_PFN (size),DAX_RECOVERY_WRITE , &kaddr,NULL );
fs/iomap/direct-io.c +1 -1
@@ -587,7 +587,7 @@ __iomap_dio_rw(struct kiocb *iocb, struct iov_iter *iter,* Revert iter to a state corresponding to that as some callers (such * as the splice code) rely on it. */ -if (iov_iter_rw (iter) ==READ && iomi.pos >= dio->i_size) +if (!(iomi.flags &IOMAP_WRITE ) && iomi.pos >= dio->i_size)iov_iter_revert (iter, iomi.pos - dio->i_size);if (ret == -EFAULT && dio->size && (dio_flags &IOMAP_DIO_PARTIAL )) {
Re: [RFC PATCH 05/11] iov_iter: Use IOMAP_WRITE rather than iterator direction
Quoted 2 lines · David Howells
If an
iomap_iteris available, use theIOMAP_WRITEflag instead of the iterator direction.
This is really two patches, one for dax and one for iomap, and not one for the iov_iter code.
David Howells
maintainerRFC PATCH 6/11 iov_iter: Use op_is_write() rather than iterator direction
In reply to David HowellsIf a request struct is available, use op_is_write() instead of the iterator direction.
--- block/blk-map.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
block/blk-map.c +1 -1
@@ -205,7 +205,7 @@ static int bio_copy_user_iov(struct request *rq, struct rq_map_data *map_data,/* * success */ -if ((iov_iter_rw (iter) ==WRITE && +if ((op_is_write (rq->cmd_flags) && (!map_data || !map_data->null_mapped)) || (map_data && map_data->from_user)) { ret =bio_copy_from_iter (bio, iter);
Re: [RFC PATCH 06/11] iov_iter: Use op_is_write() rather than iterator direction
Quoted 2 lines · David Howells
If a request struct is available, use
op_is_write()instead of the iterator direction.
s/iov_iter/block/ in the subject.
David Howells
maintainerRFC PATCH 7/11 cifs: Drop the check using iov_iter_rw()
In reply to David Howellssmbd_recv() has a check that the iterator is the correct direction. Drop this check as we're getting rid of iov_iter_rw().
--- fs/smb/client/smbdirect.c | 9 --------- 1 file changed, 9 deletions(-)
fs/smb/client/smbdirect.c +0 -9
@@ -1906,14 +1906,6 @@ int smbd_recv(struct smbd_connection *info, struct msghdr *msg)unsigned int to_read, page_offset;int rc; -if (iov_iter_rw (&msg->msg_iter) ==WRITE ) { -/* It's a bug in upper layer to get there */ -cifs_dbg (VFS ,"Invalid msg iter dir %u\n" , -iov_iter_rw (&msg->msg_iter)); - rc = -EINVAL ; - goto out; - } -switch (iov_iter_type (&msg->msg_iter)) {case ITER_KVEC : buf = msg->msg_iter.kvec->iov_base;
@@ -1935,7 +1927,6 @@ int smbd_recv(struct smbd_connection *info, struct msghdr *msg) rc = -EINVAL ; } -out:/* SMBDirect will read it all or nothing */ if (rc >0 ) msg->msg_iter.count =0 ;
David Howells
maintainerRFC PATCH 8/11 iov_iter: Drop iov_iter_rw() and fold in last user
In reply to David HowellsDrop the last usage of iov_iter_rw() into __iov_iter_get_pages_alloc().
--- include/linux/uio.h | 5 ----- lib/iov_iter.c | 2 +- 2 files changed, 1 insertion(+), 6 deletions(-)
include/linux/uio.h +0 -5
@@ -136,11 +136,6 @@ static inline bool iov_iter_is_xarray(const struct iov_iter *i)return iov_iter_type (i) ==ITER_XARRAY ; } -static inline unsigned char iov_iter_rw (const struct iov_iter *i) -{ -return i->data_source ?WRITE :READ ; -} -static inline bool user_backed_iter (const struct iov_iter *i) {return i->user_backed;
lib/iov_iter.c +1 -1
@@ -1097,7 +1097,7 @@ static ssize_t __iov_iter_get_pages_alloc(struct iov_iter *i,unsigned long addr;int res; -if (iov_iter_rw (i) !=WRITE ) +if (i->data_source ==ITER_SOURCE ) gup_flags |=FOLL_WRITE ;if (i->nofault) gup_flags |=FOLL_NOFAULT ;
Re: [RFC PATCH 08/11] iov_iter: Drop iov_iter_rw() and fold in last user
Quoted 1 line · David Howells
Drop the last usage of
iov_iter_rw()into__iov_iter_get_pages_alloc().
Well, if we can't just drop this check entirely, the rest of the prep work is just churn and not actually very useful. Shouldn't we go all the way and kill ITER_DEST/SOURCE?
David Howells
maintainerRFC PATCH 9/11 iov_iter: Use I/O dir flags with iov_iter_extract_pages()
In reply to David HowellsDefine flags to pass into iov_iter_extract_pages() to indicate I/O direction. A warning is issued and the function fails if neither or both flags are set. The flag is also checked against the iterator's data_source flag.
Also make extract_iter_to_sg() check the flags and propagate them to iov_iter_extract_pages().
Finally, make the callers pass the flags into iov_iter_extract_pages() and extract_iter_to_sg().
--- block/bio.c | 6 ++++++ block/blk-map.c | 3 +++ crypto/af_alg.c | 5 +++-- crypto/algif_hash.c | 3 ++- fs/direct-io.c | 6 +++++- include/linux/bio.h | 18 ++++++++++++++++-- include/linux/uio.h | 5 ++++- lib/iov_iter.c | 12 ++++++++++-- lib/scatterlist.c | 12 ++++++++++-- 9 files changed, 59 insertions(+), 11 deletions(-)
block/bio.c +6 -0
@@ -1242,6 +1242,8 @@ static int bio_iov_add_zone_append_page(struct bio *bio, struct page *page,* will have to be cleaned up in the way indicated by the BIO_PAGE_PINNED flag. * For a multi-segment *iter, this function only adds pages from the next * non-empty segment of the iov iterator. +* +* The I/O direction is determined from the bio operation type. */ static int __bio_iov_iter_get_pages (struct bio *bio,struct iov_iter *iter) {
@@ -1263,6 +1265,8 @@ static int __bio_iov_iter_get_pages(struct bio *bio, struct iov_iter *iter)BUILD_BUG_ON (PAGE_PTRS_PER_BVEC <2 ); pages += entries_left * (PAGE_PTRS_PER_BVEC -1 ); + extraction_flags |=bio_is_write (bio) ?WRITE_FROM_ITER :READ_INTO_ITER ; +if (bio->bi_bdev &&blk_queue_pci_p2pdma (bio->bi_bdev->bd_disk->queue)) extraction_flags |=ITER_ALLOW_P2PDMA ;
@@ -1332,6 +1336,8 @@ static int __bio_iov_iter_get_pages(struct bio *bio, struct iov_iter *iter)* fit into the bio, or are requested in @iter, whatever is smaller. If * MM encounters an error pinning the requested pages, it stops. Error * is returned only if 0 pages could be pinned. +* +* The bio operation indicates the data direction. */ int bio_iov_iter_get_pages (struct bio *bio,struct iov_iter *iter) {
block/blk-map.c +3 -0
@@ -279,6 +279,9 @@ static int bio_map_user_iov(struct request *rq, struct iov_iter *iter,if (bio ==NULL )return -ENOMEM ; + extraction_flags |= +bio_is_write (bio) ?WRITE_FROM_ITER :READ_INTO_ITER ; +if (blk_queue_pci_p2pdma (rq->q)) extraction_flags |=ITER_ALLOW_P2PDMA ;if (iov_iter_extract_will_pin (iter))
crypto/af_alg.c +3 -2
@@ -1042,7 +1042,8 @@ int af_alg_sendmsg(struct socket *sock, struct msghdr *msg, size_t size, }; plen =extract_iter_to_sg (&msg->msg_iter, len, &sgtable, -MAX_SGL_ENTS - sgl->cur,0 ); +MAX_SGL_ENTS - sgl->cur, +WRITE_FROM_ITER );if (plen <0 ) { err = plen; goto unlock;
@@ -1247,7 +1248,7 @@ int af_alg_get_rsgl(struct sock *sk, struct msghdr *msg, int flags,sg_init_table (rsgl->sgl.sgt.sgl,ALG_MAX_PAGES ); err =extract_iter_to_sg (&msg->msg_iter, seglen, &rsgl->sgl.sgt, -ALG_MAX_PAGES ,0 ); +ALG_MAX_PAGES ,READ_INTO_ITER );if (err <0 ) { rsgl->sg_num_bytes =0 ;return err;
crypto/algif_hash.c +2 -1
@@ -115,7 +115,8 @@ static int hash_sendmsg(struct socket *sock, struct msghdr *msg, ctx->sgl.need_unpin =iov_iter_extract_will_pin (&msg->msg_iter); err =extract_iter_to_sg (&msg->msg_iter,LONG_MAX , - &ctx->sgl.sgt, npages,0 ); + &ctx->sgl.sgt, npages, +WRITE_FROM_ITER );if (err <0 ) goto unlock_free; len = err;
fs/direct-io.c +5 -1
@@ -168,10 +168,14 @@ static inline int dio_refill_pages(struct dio *dio, struct dio_submit *sdio) {struct page **pages = dio->pages;const enum req_op dio_op = dio->opf &REQ_OP_MASK ; +unsigned int extraction_flags;ssize_t ret; + extraction_flags = +op_is_write (dio_op) ?WRITE_FROM_ITER :READ_INTO_ITER ; + ret =iov_iter_extract_pages (sdio->iter, &pages,LONG_MAX , -DIO_PAGES ,0 , &sdio->from); +DIO_PAGES , extraction_flags, &sdio->from);if (ret <0 && sdio->blocks_available && dio_op ==REQ_OP_WRITE ) {/*
include/linux/bio.h +16 -2
@@ -42,11 +42,25 @@ static inline unsigned int bio_max_segs(unsigned int nr_segs)#define bio_sectors (bio) bvec_iter_sectors((bio)->bi_iter)#define bio_end_sector (bio) bvec_iter_end_sector((bio)->bi_iter) +/** +* bio_is_write - Query if the I/O direction is towards the disk +* @bio: The bio to query +* +* Return true if this is some sort of write operation - ie. the data is going +* towards the disk. +*/ +static inline bool bio_is_write (const struct bio *bio) +{ +return op_is_write (bio_op (bio)); +} +/* * Return the data direction, READ or WRITE. */ -#define bio_data_dir (bio) \ - (op_is_write(bio_op(bio)) ? WRITE : READ) +static inline int bio_data_dir (const struct bio *bio) +{ +return bio_is_write (bio) ?WRITE :READ ; +}/* * Check whether this bio carries any data or not. A NULL bio is allowed.
include/linux/uio.h +4 -1
@@ -379,8 +379,11 @@ static inline void iov_iter_ubuf(struct iov_iter *i, unsigned int direction, }; }/* Flags for iov_iter_get/extract_pages*() */ +/* Indicate if we are going to be writing from the buffer or reading into it. */ +#define WRITE_FROM_ITER ((__force iov_iter_extraction_t)0x01) // == WRITE +#define READ_INTO_ITER ((__force iov_iter_extraction_t)0x02)/* Allow P2PDMA on the extracted pages */ -#define ITER_ALLOW_P2PDMA ((__force iov_iter_extraction_t)0x01) +#define ITER_ALLOW_P2PDMA ((__force iov_iter_extraction_t)0x04) ssize_t iov_iter_extract_pages(struct iov_iter *i, struct page ***pages, size_t maxsize, unsigned int maxpages,
lib/iov_iter.c +10 -2
@@ -1791,8 +1791,10 @@ static ssize_t iov_iter_extract_user_pages(struct iov_iter *i,* that the caller allocated a page list at least @maxpages in size and this * will be filled in. * -* @extraction_flags can have ITER_ALLOW_P2PDMA set to request peer-to-peer DMA -* be allowed on the pages extracted. +* @extraction_flags should have either WRITE_FROM_ITER or READ_INTO_ITER to +* indicate the direction the data is intended to flow to/from the buffer and +* can have ITER_ALLOW_P2PDMA set to request peer-to-peer DMA be allowed on the +* pages extracted. * * The iov_iter_extract_will_pin() function can be used to query how cleanup * should be performed.
@@ -1823,6 +1825,12 @@ ssize_t iov_iter_extract_pages(struct iov_iter *i,iov_iter_extraction_t extraction_flags, size_t *offset0) { + unsigned int dir = extraction_flags & (READ_INTO_ITER | WRITE_FROM_ITER); + +if (WARN_ON_ONCE (dir !=READ_INTO_ITER && dir !=WRITE_FROM_ITER ) || +WARN_ON_ONCE ((dir &WRITE ) != i->data_source)) +return -EFAULT ; + maxsize =min_t (size_t,min_t (size_t, maxsize, i->count),MAX_RW_COUNT );if (!maxsize)return 0 ;
lib/scatterlist.c +10 -2
@@ -1326,8 +1326,10 @@ static ssize_t extract_xarray_to_sg(struct iov_iter *iter,* * No end mark is placed on the scatterlist; that's left to the caller. * -* @extraction_flags can have ITER_ALLOW_P2PDMA set to request peer-to-peer DMA -* be allowed on the pages extracted. +* @extraction_flags should have either WRITE_FROM_ITER or READ_INTO_ITER to +* indicate the direction the data is intended to flow to/from the buffer and +* can have ITER_ALLOW_P2PDMA set to request peer-to-peer DMA be allowed on the +* pages extracted. * * If successful, @sgtable->nents is updated to include the number of elements * added and the number of bytes added is returned. @sgtable->orig_nents is
@@ -1340,6 +1342,12 @@ ssize_t extract_iter_to_sg(struct iov_iter *iter, size_t maxsize, struct sg_table *sgtable, unsigned int sg_max, iov_iter_extraction_t extraction_flags) { + unsigned int dir = extraction_flags & (READ_INTO_ITER | WRITE_FROM_ITER); + +if (WARN_ON_ONCE (dir !=READ_INTO_ITER && dir !=WRITE_FROM_ITER ) || +WARN_ON_ONCE ((dir &WRITE ) != iter->data_source)) +return -EFAULT ; +if (maxsize ==0 )return 0 ;
David Howells
maintainerRFC PATCH 10/11 9p: Pin pages rather than ref'ing if appropriate
In reply to David HowellsConvert the 9p filesystem to use iov_iter_extract_pages() instead of iov_iter_get_pages(). This will pin pages or leave them unaltered rather than getting a ref on them as appropriate to the iterator.
The pages need to be pinned for DIO-read rather than having refs taken on them to prevent VM copy-on-write from malfunctioning during a concurrent fork() (the result of the I/O would otherwise end up only visible to the child process and not the parent).
--- net/9p/trans_common.c | 8 ++-- net/9p/trans_common.h | 2 +- net/9p/trans_virtio.c | 92 ++++++++++++++----------------------------- 3 files changed, 34 insertions(+), 68 deletions(-)
net/9p/trans_common.c +4 -4
@@ -9,16 +9,16 @@#include "trans_common.h" /** -* p9_release_pages - Release pages after the transaction. +* p9_unpin_pages - Unpin pages after the transaction. * @pages: array of pages to be put * @nr_pages: size of array */ -void p9_release_pages (struct page **pages,int nr_pages) +void p9_unpin_pages (struct page **pages,int nr_pages) {int i;for (i =0 ; i < nr_pages; i++)if (pages[i]) -put_page (pages[i]); +unpin_user_page (pages[i]); } -EXPORT_SYMBOL (p9_release_pages); +EXPORT_SYMBOL (p9_unpin_pages);
net/9p/trans_common.h +1 -1
@@ -4,4 +4,4 @@* Author Venkateswararao Jujjuri <[email protected]> */ -void p9_release_pages (struct page **pages,int nr_pages); +void p9_unpin_pages (struct page **pages,int nr_pages);
net/9p/trans_virtio.c +29 -63
134 lines not on this page · raw message
David Howells
maintainerRFC PATCH 11/11 scsi: Use extract_iter_to_sg()
In reply to David HowellsUse extract_iter_to_sg() to build a scatterlist from an iterator.
--- drivers/vhost/scsi.c | 79 +++++++++++++------------------------------- 1 file changed, 23 insertions(+), 56 deletions(-)
drivers/vhost/scsi.c +23 -56
@@ -75,6 +75,9 @@ struct vhost_scsi_cmd {u32 tvc_prot_sgl_count;/* Saved unpacked SCSI LUN for vhost_scsi_target_queue_cmd() */ u32 tvc_lun; +/* Cleanup modes for scatterlists */ +unsigned int tvc_need_unpin; +unsigned int tvc_prot_need_unpin;/* Pointer to the SGL formatted memory from virtio-scsi */ struct scatterlist *tvc_sgl;struct scatterlist *tvc_prot_sgl;
@@ -327,14 +330,13 @@ static void vhost_scsi_release_cmd_res(struct se_cmd *se_cmd)struct vhost_scsi_inflight *inflight = tv_cmd->inflight;int i; -if (tv_cmd->tvc_sgl_count) { +if (tv_cmd->tvc_need_unpin && tv_cmd->tvc_sgl_count)for (i =0 ; i < tv_cmd->tvc_sgl_count; i++) -put_page (sg_page (&tv_cmd->tvc_sgl[i])); - } -if (tv_cmd->tvc_prot_sgl_count) { +unpin_user_page (sg_page (&tv_cmd->tvc_sgl[i])); + +if (tv_cmd->tvc_prot_need_unpin && tv_cmd->tvc_prot_sgl_count)for (i =0 ; i < tv_cmd->tvc_prot_sgl_count; i++) -put_page (sg_page (&tv_cmd->tvc_prot_sgl[i])); - } +unpin_user_page (sg_page (&tv_cmd->tvc_prot_sgl[i]));sbitmap_clear_bit (&svq->scsi_tags, se_cmd->map_tag);vhost_scsi_put_inflight (inflight);
@@ -606,38 +608,6 @@ vhost_scsi_get_cmd(struct vhost_virtqueue *vq, struct vhost_scsi_tpg *tpg,return cmd; } -/* -* Map a user memory range into a scatterlist -* -* Returns the number of scatterlist entries used or -errno on error. -*/ -static int -vhost_scsi_map_to_sgl (struct vhost_scsi_cmd *cmd, -struct iov_iter *iter, -struct scatterlist *sgl, -bool write) -{ -struct page **pages = cmd->tvc_upages; -struct scatterlist *sg = sgl; -ssize_t bytes; -size_t offset; -unsigned int npages =0 ; - - bytes =iov_iter_get_pages2 (iter, pages,LONG_MAX , -VHOST_SCSI_PREALLOC_UPAGES , &offset); -/* No pages were pinned */ -if (bytes <=0 ) -return bytes <0 ? bytes : -EFAULT ; - -while (bytes) { -unsigned n =min_t (unsigned,PAGE_SIZE - offset, bytes); -sg_set_page (sg++, pages[npages++], n, offset); - bytes -= n; - offset =0 ; - } -return npages; -} -static int vhost_scsi_calc_sgls (struct iov_iter *iter,size_t bytes,int max_sgls) {
@@ -661,24 +631,19 @@ vhost_scsi_calc_sgls(struct iov_iter *iter, size_t bytes, int max_sgls)static int vhost_scsi_iov_to_sgl (struct vhost_scsi_cmd *cmd,bool write,struct iov_iter *iter, -struct scatterlist *sg,int sg_count) +struct scatterlist *sg,int sg_count, +unsigned int *need_unpin) { -struct scatterlist *p = sg; -int ret; +struct sg_table sgt = { .sgl = sg }; +ssize_t ret; -while (iov_iter_count (iter)) { - ret =vhost_scsi_map_to_sgl (cmd, iter, sg, write); -if (ret <0 ) { -while (p < sg) { -struct page *page =sg_page (p++); -if (page) -put_page (page); - } -return ret; - } - sg += ret; - } -return 0 ; + ret =extract_iter_to_sg (iter,LONG_MAX , &sgt, sg_count, + write ?WRITE_FROM_ITER :READ_INTO_ITER ); +if (ret >0 ) +sg_mark_end (sg + sgt.nents -1 ); + + *need_unpin =iov_iter_extract_will_pin (iter); +return ret; } static int
@@ -702,7 +667,8 @@ vhost_scsi_mapal(struct vhost_scsi_cmd *cmd, ret =vhost_scsi_iov_to_sgl (cmd, write, prot_iter, cmd->tvc_prot_sgl, - cmd->tvc_prot_sgl_count); + cmd->tvc_prot_sgl_count, + &cmd->tvc_prot_need_unpin);if (ret <0 ) { cmd->tvc_prot_sgl_count =0 ;return ret;
@@ -719,7 +685,8 @@ vhost_scsi_mapal(struct vhost_scsi_cmd *cmd, cmd->tvc_sgl, cmd->tvc_sgl_count); ret =vhost_scsi_iov_to_sgl (cmd, write, data_iter, - cmd->tvc_sgl, cmd->tvc_sgl_count); + cmd->tvc_sgl, cmd->tvc_sgl_count, + &cmd->tvc_need_unpin);if (ret <0 ) { cmd->tvc_sgl_count =0 ;return ret;