vfs: Non-blockling buffered fs read (page cache only)

New syscalls that take an flag argument. This change does not add any specific flags.

Signed-off-by Milosz Tanski <[email protected]>

Reviewed-by Christoph Hellwig <[email protected]>

---
 fs/read_write.c                   | 172 ++++++++++++++++++++++++++++++--------
 include/linux/compat.h            |   6 ++
 include/linux/syscalls.h          |   6 ++
 include/uapi/asm-generic/unistd.h |   6 +-
 mm/filemap.c                      |   5 +-
 5 files changed, 156 insertions(+), 39 deletions(-)

fs/read_write.c +136 -36

index 94b2d34..b1b4bc8 100644
@@ -866,6 +866,8 @@ ssize_t vfs_readv(struct file *file, const struct iovec __user *vec,
 		return -EBADF;
 	if (!(file->f_mode & FMODE_CAN_READ))
 		return -EINVAL;
+	if (flags & ~0)
+		return -EINVAL;
 
 	return do_readv_writev(READ, file, vec, vlen, pos, flags);
 }

@@ -879,21 +881,23 @@ ssize_t vfs_writev(struct file *file, const struct iovec __user *vec,
 		return -EBADF;
 	if (!(file->f_mode & FMODE_CAN_WRITE))
 		return -EINVAL;
+	if (flags & ~0)
+		return -EINVAL;
 
 	return do_readv_writev(WRITE, file, vec, vlen, pos, flags);
 }
 
 EXPORT_SYMBOL(vfs_writev);
 
-SYSCALL_DEFINE3(readv, unsigned long, fd, const struct iovec __user *, vec,
-		unsigned long, vlen)
+static ssize_t do_readv(unsigned long fd, const struct iovec __user *vec,
+			unsigned long vlen, int flags)
 {
 	struct fd f = fdget_pos(fd);
 	ssize_t ret = -EBADF;
 
 	if (f.file) {
 		loff_t pos = file_pos_read(f.file);
-		ret = vfs_readv(f.file, vec, vlen, &pos, 0);
+		ret = vfs_readv(f.file, vec, vlen, &pos, flags);
 		if (ret >= 0)
 			file_pos_write(f.file, pos);
 		fdput_pos(f);

@@ -905,15 +909,15 @@ SYSCALL_DEFINE3(readv, unsigned long, fd, const struct iovec __user *, vec,
 	return ret;
 }
 
-SYSCALL_DEFINE3(writev, unsigned long, fd, const struct iovec __user *, vec,
-		unsigned long, vlen)
+static ssize_t do_writev(unsigned long fd, const struct iovec __user *vec,
+			 unsigned long vlen, int flags)
 {
 	struct fd f = fdget_pos(fd);
 	ssize_t ret = -EBADF;
 
 	if (f.file) {
 		loff_t pos = file_pos_read(f.file);
-		ret = vfs_writev(f.file, vec, vlen, &pos, 0);
+		ret = vfs_writev(f.file, vec, vlen, &pos, flags);
 		if (ret >= 0)
 			file_pos_write(f.file, pos);
 		fdput_pos(f);

@@ -931,10 +935,9 @@ static inline loff_t pos_from_hilo(unsigned long high, unsigned long low)
 	return (((loff_t)high << HALF_LONG_BITS) << HALF_LONG_BITS) | low;
 }
 
-SYSCALL_DEFINE5(preadv, unsigned long, fd, const struct iovec __user *, vec,
-		unsigned long, vlen, unsigned long, pos_l, unsigned long, pos_h)
+static ssize_t do_preadv(unsigned long fd, const struct iovec __user *vec,
+			 unsigned long vlen, loff_t pos, int flags)
 {
-	loff_t pos = pos_from_hilo(pos_h, pos_l);
 	struct fd f;
 	ssize_t ret = -EBADF;
 

@@ -945,7 +948,7 @@ SYSCALL_DEFINE5(preadv, unsigned long, fd, const struct iovec __user *, vec,
 	if (f.file) {
 		ret = -ESPIPE;
 		if (f.file->f_mode & FMODE_PREAD)
-			ret = vfs_readv(f.file, vec, vlen, &pos, 0);
+			ret = vfs_readv(f.file, vec, vlen, &pos, flags);
 		fdput(f);
 	}
 

@@ -955,10 +958,9 @@ SYSCALL_DEFINE5(preadv, unsigned long, fd, const struct iovec __user *, vec,
 	return ret;
 }
 
-SYSCALL_DEFINE5(pwritev, unsigned long, fd, const struct iovec __user *, vec,
-		unsigned long, vlen, unsigned long, pos_l, unsigned long, pos_h)
+static ssize_t do_pwritev(unsigned long fd, const struct iovec __user *vec,
+			  unsigned long vlen, loff_t pos, int flags)
 {
-	loff_t pos = pos_from_hilo(pos_h, pos_l);
 	struct fd f;
 	ssize_t ret = -EBADF;
 

@@ -969,7 +971,7 @@ SYSCALL_DEFINE5(pwritev, unsigned long, fd, const struct iovec __user *, vec,
 	if (f.file) {
 		ret = -ESPIPE;
 		if (f.file->f_mode & FMODE_PWRITE)
-			ret = vfs_writev(f.file, vec, vlen, &pos, 0);
+			ret = vfs_writev(f.file, vec, vlen, &pos, flags);
 		fdput(f);
 	}
 

@@ -979,11 +981,63 @@ SYSCALL_DEFINE5(pwritev, unsigned long, fd, const struct iovec __user *, vec,
 	return ret;
 }
 
+SYSCALL_DEFINE3(readv, unsigned long, fd, const struct iovec __user *, vec,
+		unsigned long, vlen)
+{
+	return do_readv(fd, vec, vlen, 0);
+}
+
+SYSCALL_DEFINE3(writev, unsigned long, fd, const struct iovec __user *, vec,
+		unsigned long, vlen)
+{
+	return do_writev(fd, vec, vlen, 0);
+}
+
+SYSCALL_DEFINE5(preadv, unsigned long, fd, const struct iovec __user *, vec,
+		unsigned long, vlen, unsigned long, pos_l, unsigned long, pos_h)
+{
+	loff_t pos = pos_from_hilo(pos_h, pos_l);
+
+	return do_preadv(fd, vec, vlen, pos, 0);
+}
+
+SYSCALL_DEFINE6(preadv2, unsigned long, fd, const struct iovec __user *, vec,
+		unsigned long, vlen, unsigned long, pos_l, unsigned long, pos_h,
+		int, flags)
+{
+	loff_t pos = pos_from_hilo(pos_h, pos_l);
+
+	if (pos == -1)
+		return do_readv(fd, vec, vlen, flags);
+
+	return do_preadv(fd, vec, vlen, pos, flags);
+}
+
+SYSCALL_DEFINE5(pwritev, unsigned long, fd, const struct iovec __user *, vec,
+		unsigned long, vlen, unsigned long, pos_l, unsigned long, pos_h)
+{
+	loff_t pos = pos_from_hilo(pos_h, pos_l);
+
+	return do_pwritev(fd, vec, vlen, pos, 0);
+}
+
+SYSCALL_DEFINE6(pwritev2, unsigned long, fd, const struct iovec __user *, vec,
+		unsigned long, vlen, unsigned long, pos_l, unsigned long, pos_h,
+		int, flags)
+{
+	loff_t pos = pos_from_hilo(pos_h, pos_l);
+
+	if (pos == -1)
+		return do_writev(fd, vec, vlen, flags);
+
+	return do_pwritev(fd, vec, vlen, pos, flags);
+}
+
 #ifdef CONFIG_COMPAT
 
 static ssize_t compat_do_readv_writev(int type, struct file *file,
 			       const struct compat_iovec __user *uvector,
-			       unsigned long nr_segs, loff_t *pos)
+			       unsigned long nr_segs, loff_t *pos, int flags)
 {
 	compat_ssize_t tot_len;
 	struct iovec iovstack[UIO_FASTIOV];

@@ -1017,7 +1071,7 @@ static ssize_t compat_do_readv_writev(int type, struct file *file,
 
 	if (iter_fn)
 		ret = do_iter_readv_writev(file, type, iov, nr_segs, tot_len,
-						pos, iter_fn, 0);
+						pos, iter_fn, flags);
 	else if (fnv)
 		ret = do_sync_readv_writev(file, iov, nr_segs, tot_len,
 						pos, fnv);

@@ -1041,7 +1095,7 @@ out:
 
 static size_t compat_readv(struct file *file,
 			   const struct compat_iovec __user *vec,
-			   unsigned long vlen, loff_t *pos)
+			   unsigned long vlen, loff_t *pos, int flags)
 {
 	ssize_t ret = -EBADF;
 

@@ -1051,8 +1105,10 @@ static size_t compat_readv(struct file *file,
 	ret = -EINVAL;
 	if (!(file->f_mode & FMODE_CAN_READ))
 		goto out;
+	if (flags & ~0)
+		goto out;
 
-	ret = compat_do_readv_writev(READ, file, vec, vlen, pos);
+	ret = compat_do_readv_writev(READ, file, vec, vlen, pos, flags);
 
 out:
 	if (ret > 0)

@@ -1061,9 +1117,9 @@ out:
 	return ret;
 }
 
-COMPAT_SYSCALL_DEFINE3(readv, compat_ulong_t, fd,
-		const struct compat_iovec __user *,vec,
-		compat_ulong_t, vlen)
+static size_t __compat_sys_readv(compat_ulong_t fd,
+				 const struct compat_iovec __user *vec,
+				 compat_ulong_t vlen, int flags)
 {
 	struct fd f = fdget_pos(fd);
 	ssize_t ret;

@@ -1072,16 +1128,24 @@ COMPAT_SYSCALL_DEFINE3(readv, compat_ulong_t, fd,
 	if (!f.file)
 		return -EBADF;
 	pos = f.file->f_pos;
-	ret = compat_readv(f.file, vec, vlen, &pos);
+	ret = compat_readv(f.file, vec, vlen, &pos, flags);
 	if (ret >= 0)
 		f.file->f_pos = pos;
 	fdput_pos(f);
 	return ret;
+
+}
+
+COMPAT_SYSCALL_DEFINE3(readv, compat_ulong_t, fd,
+		const struct compat_iovec __user *,vec,
+		compat_ulong_t, vlen)
+{
+	return __compat_sys_readv(fd, vec, vlen, 0);
 }
 
 static long __compat_sys_preadv64(unsigned long fd,
 				  const struct compat_iovec __user *vec,
-				  unsigned long vlen, loff_t pos)
+				  unsigned long vlen, loff_t pos, int flags)
 {
 	struct fd f;
 	ssize_t ret;

@@ -1093,7 +1157,7 @@ static long __compat_sys_preadv64(unsigned long fd,
 		return -EBADF;
 	ret = -ESPIPE;
 	if (f.file->f_mode & FMODE_PREAD)
-		ret = compat_readv(f.file, vec, vlen, &pos);
+		ret = compat_readv(f.file, vec, vlen, &pos, flags);
 	fdput(f);
 	return ret;
 }

@@ -1103,7 +1167,7 @@ COMPAT_SYSCALL_DEFINE4(preadv64, unsigned long, fd,
 		const struct compat_iovec __user *,vec,
 		unsigned long, vlen, loff_t, pos)
 {
-	return __compat_sys_preadv64(fd, vec, vlen, pos);
+	return __compat_sys_preadv64(fd, vec, vlen, pos, 0);
 }
 #endif
 

@@ -1113,12 +1177,25 @@ COMPAT_SYSCALL_DEFINE5(preadv, compat_ulong_t, fd,
 {
 	loff_t pos = ((loff_t)pos_high << 32) | pos_low;
 
-	return __compat_sys_preadv64(fd, vec, vlen, pos);
+	return __compat_sys_preadv64(fd, vec, vlen, pos, 0);
+}
+
+COMPAT_SYSCALL_DEFINE6(preadv2, compat_ulong_t, fd,
+		const struct compat_iovec __user *,vec,
+		compat_ulong_t, vlen, u32, pos_low, u32, pos_high,
+		int, flags)
+{
+	loff_t pos = ((loff_t)pos_high << 32) | pos_low;
+
+	if (pos == -1)
+		return __compat_sys_readv(fd, vec, vlen, flags);
+
+	return __compat_sys_preadv64(fd, vec, vlen, pos, flags);
 }
 
 static size_t compat_writev(struct file *file,
 			    const struct compat_iovec __user *vec,
-			    unsigned long vlen, loff_t *pos)
+			    unsigned long vlen, loff_t *pos, int flags)
 {
 	ssize_t ret = -EBADF;
 

@@ -1128,8 +1205,10 @@ static size_t compat_writev(struct file *file,
 	ret = -EINVAL;
 	if (!(file->f_mode & FMODE_CAN_WRITE))
 		goto out;
+	if (flags & ~0)
+		goto out;
 
-	ret = compat_do_readv_writev(WRITE, file, vec, vlen, pos);
+	ret = compat_do_readv_writev(WRITE, file, vec, vlen, pos, flags);
 
 out:
 	if (ret > 0)

@@ -1138,9 +1217,9 @@ out:
 	return ret;
 }
 
-COMPAT_SYSCALL_DEFINE3(writev, compat_ulong_t, fd,
-		const struct compat_iovec __user *, vec,
-		compat_ulong_t, vlen)
+static size_t __compat_sys_writev(compat_ulong_t fd,
+				  const struct compat_iovec __user* vec,
+				  compat_ulong_t vlen, int flags)
 {
 	struct fd f = fdget_pos(fd);
 	ssize_t ret;

@@ -1149,28 +1228,36 @@ COMPAT_SYSCALL_DEFINE3(writev, compat_ulong_t, fd,
 	if (!f.file)
 		return -EBADF;
 	pos = f.file->f_pos;
-	ret = compat_writev(f.file, vec, vlen, &pos);
+	ret = compat_writev(f.file, vec, vlen, &pos, flags);
 	if (ret >= 0)
 		f.file->f_pos = pos;
 	fdput_pos(f);
 	return ret;
 }
 
+COMPAT_SYSCALL_DEFINE3(writev, compat_ulong_t, fd,
+		const struct compat_iovec __user *, vec,
+		compat_ulong_t, vlen)
+{
+	return __compat_sys_writev(fd, vec, vlen, 0);
+}
+
 static long __compat_sys_pwritev64(unsigned long fd,
 				   const struct compat_iovec __user *vec,
-				   unsigned long vlen, loff_t pos)
+				   unsigned long vlen, loff_t pos, int flags)
 {
 	struct fd f;
 	ssize_t ret;
 
 	if (pos < 0)
 		return -EINVAL;
+
 	f = fdget(fd);
 	if (!f.file)
 		return -EBADF;
 	ret = -ESPIPE;
 	if (f.file->f_mode & FMODE_PWRITE)
-		ret = compat_writev(f.file, vec, vlen, &pos);
+		ret = compat_writev(f.file, vec, vlen, &pos, flags);
 	fdput(f);
 	return ret;
 }

@@ -1180,7 +1267,7 @@ COMPAT_SYSCALL_DEFINE4(pwritev64, unsigned long, fd,
 		const struct compat_iovec __user *,vec,
 		unsigned long, vlen, loff_t, pos)
 {
-	return __compat_sys_pwritev64(fd, vec, vlen, pos);
+	return __compat_sys_pwritev64(fd, vec, vlen, pos, 0);
 }
 #endif
 

@@ -1190,8 +1277,21 @@ COMPAT_SYSCALL_DEFINE5(pwritev, compat_ulong_t, fd,
 {
 	loff_t pos = ((loff_t)pos_high << 32) | pos_low;
 
-	return __compat_sys_pwritev64(fd, vec, vlen, pos);
+	return __compat_sys_pwritev64(fd, vec, vlen, pos, 0);
+}
+
+COMPAT_SYSCALL_DEFINE6(pwritev2, compat_ulong_t, fd,
+		const struct compat_iovec __user *,vec,
+		compat_ulong_t, vlen, u32, pos_low, u32, pos_high, int, flags)
+{
+	loff_t pos = ((loff_t)pos_high << 32) | pos_low;
+
+	if (pos == -1)
+		return __compat_sys_writev(fd, vec, vlen, flags);
+
+	return __compat_sys_pwritev64(fd, vec, vlen, pos, flags);
 }
+
 #endif
 
 static ssize_t do_sendfile(int out_fd, int in_fd, loff_t *ppos,

include/linux/compat.h +6 -0

index e649426..63a94e2 100644
@@ -340,6 +340,12 @@ asmlinkage ssize_t compat_sys_preadv(compat_ulong_t fd,
 asmlinkage ssize_t compat_sys_pwritev(compat_ulong_t fd,
 		const struct compat_iovec __user *vec,
 		compat_ulong_t vlen, u32 pos_low, u32 pos_high);
+asmlinkage ssize_t compat_sys_preadv2(compat_ulong_t fd,
+		const struct compat_iovec __user *vec,
+		compat_ulong_t vlen, u32 pos_low, u32 pos_high, int flags);
+asmlinkage ssize_t compat_sys_pwritev2(compat_ulong_t fd,
+		const struct compat_iovec __user *vec,
+		compat_ulong_t vlen, u32 pos_low, u32 pos_high, int flags);
 
 #ifdef __ARCH_WANT_COMPAT_SYS_PREADV64
 asmlinkage long compat_sys_preadv64(unsigned long fd,

include/linux/syscalls.h +6 -0

index bda9b81..cedc22e 100644
@@ -571,8 +571,14 @@ asmlinkage long sys_pwrite64(unsigned int fd, const char __user *buf,
 			     size_t count, loff_t pos);
 asmlinkage long sys_preadv(unsigned long fd, const struct iovec __user *vec,
 			   unsigned long vlen, unsigned long pos_l, unsigned long pos_h);
+asmlinkage long sys_preadv2(unsigned long fd, const struct iovec __user *vec,
+			    unsigned long vlen, unsigned long pos_l, unsigned long pos_h,
+			    int flags);
 asmlinkage long sys_pwritev(unsigned long fd, const struct iovec __user *vec,
 			    unsigned long vlen, unsigned long pos_l, unsigned long pos_h);
+asmlinkage long sys_pwritev2(unsigned long fd, const struct iovec __user *vec,
+			    unsigned long vlen, unsigned long pos_l, unsigned long pos_h,
+			    int flags);
 asmlinkage long sys_getcwd(char __user *buf, unsigned long size);
 asmlinkage long sys_mkdir(const char __user *pathname, umode_t mode);
 asmlinkage long sys_chdir(const char __user *filename);

include/uapi/asm-generic/unistd.h +5 -1

index 22749c1..9406018 100644
@@ -213,6 +213,10 @@ __SC_COMP(__NR_pwrite64, sys_pwrite64, compat_sys_pwrite64)
 __SC_COMP(__NR_preadv, sys_preadv, compat_sys_preadv)
 #define __NR_pwritev 70
 __SC_COMP(__NR_pwritev, sys_pwritev, compat_sys_pwritev)
+#define __NR_preadv2 281
+__SC_COMP(__NR_preadv2, sys_preadv2, compat_sys_preadv2)
+#define __NR_pwritev2 282
+__SC_COMP(__NR_pwritev2, sys_pwritev2, compat_sys_pwritev2)
 
 /* fs/sendfile.c */
 #define __NR3264_sendfile 71

@@ -709,7 +713,7 @@ __SYSCALL(__NR_memfd_create, sys_memfd_create)
 __SYSCALL(__NR_bpf, sys_bpf)
 
 #undef __NR_syscalls
-#define __NR_syscalls 281
+#define __NR_syscalls 283
 
 /*
  * All syscalls below here should go away really,

mm/filemap.c +2 -1

index 14b4642..530c263 100644
@@ -1457,6 +1457,7 @@ static void shrink_readahead_size_eio(struct file *filp,
  * @ppos:	current file position
  * @iter:	data destination
  * @written:	already copied
+ * @flags:	optional flags
  *
  * This is a generic file read routine, and uses the
  * mapping->a_ops->readpage() function for the actual low-level stuff.

@@ -1465,7 +1466,7 @@ static void shrink_readahead_size_eio(struct file *filp,
  * of the logic when it comes to error handling etc.
  */
 static ssize_t do_generic_file_read(struct file *filp, loff_t *ppos,
-		struct iov_iter *iter, ssize_t written)
+		struct iov_iter *iter, ssize_t written, int flags)
 {
 	struct address_space *mapping = filp->f_mapping;
 	struct inode *inode = mapping->host;

New syscalls that take an flag argument. This change does not add any specific
flags.

Signed-off-by Milosz Tanski <[email protected]>

Reviewed-by Christoph Hellwig <[email protected]>

---
 fs/read_write.c                   | 172
++++++++++++++++++++++++++++++--------
 include/linux/compat.h            |   6 ++
 include/linux/syscalls.h          |   6 ++
 include/uapi/asm-generic/unistd.h |   6 +-
 mm/filemap.c                      |   5 +-
 5 files changed, 156 insertions(+), 39 deletions(-)

fs/read_write.c +2 -0

index 94b2d34..b1b4bc8 100644
@@ -866,6 +866,8 @@ ssize_t vfs_readv(struct file *file, const struct
 iovec __user *vec,
                return -EBADF;
        if (!(file->f_mode & FMODE_CAN_READ))
                return -EINVAL;
+       if (flags & ~0)
+               return -EINVAL;
 
        return do_readv_writev(READ, file, vec, vlen, pos, flags);

}

fs/read_write.c +5 -3

@@ -879,21 +881,23 @@ ssize_t vfs_writev(struct file *file, const struct
 iovec __user *vec,
                return -EBADF;
        if (!(file->f_mode & FMODE_CAN_WRITE))
                return -EINVAL;
+       if (flags & ~0)
+               return -EINVAL;
 
        return do_readv_writev(WRITE, file, vec, vlen, pos, flags);
 }
 
 EXPORT_SYMBOL(vfs_writev);
 
-SYSCALL_DEFINE3(readv, unsigned long, fd, const struct iovec __user *,
 vec,
-               unsigned long, vlen)
+static ssize_t do_readv(unsigned long fd, const struct iovec __user *vec,
+                       unsigned long vlen, int flags)
 {
        struct fd f = fdget_pos(fd);
        ssize_t ret = -EBADF;
 
        if (f.file) {
                loff_t pos = file_pos_read(f.file);
-               ret = vfs_readv(f.file, vec, vlen, &pos, 0);
+               ret = vfs_readv(f.file, vec, vlen, &pos, flags);
                if (ret >= 0)

                        file_pos_write(f.file, pos);
                fdput_pos(f);

fs/read_write.c +3 -3

@@ -905,15 +909,15 @@ SYSCALL_DEFINE3(readv, unsigned long, fd, const
 struct iovec __user *, vec,
        return ret;
 }
 
-SYSCALL_DEFINE3(writev, unsigned long, fd, const struct iovec __user *,
 vec,
-               unsigned long, vlen)
+static ssize_t do_writev(unsigned long fd, const struct iovec __user *vec,
+                        unsigned long vlen, int flags)
 {
        struct fd f = fdget_pos(fd);
        ssize_t ret = -EBADF;
 
        if (f.file) {
                loff_t pos = file_pos_read(f.file);
-               ret = vfs_writev(f.file, vec, vlen, &pos, 0);
+               ret = vfs_writev(f.file, vec, vlen, &pos, flags);
                if (ret >= 0)

                        file_pos_write(f.file, pos);
                fdput_pos(f);

fs/read_write.c +2 -3

@@ -931,10 +935,9 @@ static inline loff_t pos_from_hilo(unsigned long
 high, unsigned long low)
        return (((loff_t)high << HALF_LONG_BITS) << HALF_LONG_BITS) | low;
 }
 
-SYSCALL_DEFINE5(preadv, unsigned long, fd, const struct iovec __user *,
 vec,
-               unsigned long, vlen, unsigned long, pos_l, unsigned long,
 pos_h)
+static ssize_t do_preadv(unsigned long fd, const struct iovec __user *vec,
+                        unsigned long vlen, loff_t pos, int flags)
 {
-       loff_t pos = pos_from_hilo(pos_h, pos_l);

        struct fd f;
        ssize_t ret = -EBADF;

fs/read_write.c +38 -5

@@ -945,7 +948,7 @@ SYSCALL_DEFINE5(preadv, unsigned long, fd, const
 struct iovec __user *, vec,
        if (f.file) {
                ret = -ESPIPE;
                if (f.file->f_mode & FMODE_PREAD)
-                       ret = vfs_readv(f.file, vec, vlen, &pos, 0);
+                       ret = vfs_readv(f.file, vec, vlen, &pos, flags);
                fdput(f);
        }

@@ -955,10 +958,9 @@ SYSCALL_DEFINE5(preadv, unsigned long, fd, const
 struct iovec __user *, vec,
        return ret;
 }
 
-SYSCALL_DEFINE5(pwritev, unsigned long, fd, const struct iovec __user *,
 vec,
-               unsigned long, vlen, unsigned long, pos_l, unsigned long,
 pos_h)
+static ssize_t do_pwritev(unsigned long fd, const struct iovec __user
 *vec,
+                         unsigned long vlen, loff_t pos, int flags)
 {
-       loff_t pos = pos_from_hilo(pos_h, pos_l);
        struct fd f;
        ssize_t ret = -EBADF;

@@ -969,7 +971,7 @@ SYSCALL_DEFINE5(pwritev, unsigned long, fd, const
 struct iovec __user *, vec,
        if (f.file) {
                ret = -ESPIPE;
                if (f.file->f_mode & FMODE_PWRITE)
-                       ret = vfs_writev(f.file, vec, vlen, &pos, 0);
+                       ret = vfs_writev(f.file, vec, vlen, &pos, flags);
                fdput(f);
        }

@@ -979,11 +981,63 @@ SYSCALL_DEFINE5(pwritev, unsigned long, fd, const
 struct iovec __user *, vec,
        return ret;
 }
 
+SYSCALL_DEFINE3(readv, unsigned long, fd, const struct iovec __user *,
 vec,
+               unsigned long, vlen)
+{
+       return do_readv(fd, vec, vlen, 0);
+}
+
+SYSCALL_DEFINE3(writev, unsigned long, fd, const struct iovec __user *,
 vec,
+               unsigned long, vlen)
+{
+       return do_writev(fd, vec, vlen, 0);
+}
+
+SYSCALL_DEFINE5(preadv, unsigned long, fd, const struct iovec __user *,
 vec,
+               unsigned long, vlen, unsigned long, pos_l, unsigned long,
 pos_h)
+{
+       loff_t pos = pos_from_hilo(pos_h, pos_l);
+
+       return do_preadv(fd, vec, vlen, pos, 0);
+}
+
+SYSCALL_DEFINE6(preadv2, unsigned long, fd, const struct iovec __user *,
 vec,
+               unsigned long, vlen, unsigned long, pos_l, unsigned long,
 pos_h,
+               int, flags)
+{
+       loff_t pos = pos_from_hilo(pos_h, pos_l);
+
+       if (pos == -1)
+               return do_readv(fd, vec, vlen, flags);
+
+       return do_preadv(fd, vec, vlen, pos, flags);
+}
+
+SYSCALL_DEFINE5(pwritev, unsigned long, fd, const struct iovec __user *,
 vec,
+               unsigned long, vlen, unsigned long, pos_l, unsigned long,

pos_h)

fs/read_write.c +7 -0

+{
+       loff_t pos = pos_from_hilo(pos_h, pos_l);
+
+       return do_pwritev(fd, vec, vlen, pos, 0);
+}
+
+SYSCALL_DEFINE6(pwritev2, unsigned long, fd, const struct iovec __user *,

vec,
+ unsigned long, vlen, unsigned long, pos_l, unsigned long,
pos_h,

fs/read_write.c +11 -1

+               int, flags)
+{
+       loff_t pos = pos_from_hilo(pos_h, pos_l);
+
+       if (pos == -1)
+               return do_writev(fd, vec, vlen, flags);
+
+       return do_pwritev(fd, vec, vlen, pos, flags);
+}
+
 #ifdef CONFIG_COMPAT
 
 static ssize_t compat_do_readv_writev(int type, struct file *file,
                               const struct compat_iovec __user *uvector,
-                              unsigned long nr_segs, loff_t *pos)
+                              unsigned long nr_segs, loff_t *pos, int

flags)

 {
        compat_ssize_t tot_len;
        struct iovec iovstack[UIO_FASTIOV];

fs/read_write.c +1 -1

@@ -1017,7 +1071,7 @@ static ssize_t compat_do_readv_writev(int type,
 struct file *file,
 
        if (iter_fn)
                ret = do_iter_readv_writev(file, type, iov, nr_segs,
 tot_len,
-                                               pos, iter_fn, 0);
+                                               pos, iter_fn, flags);
        else if (fnv)

ret = do_sync_readv_writev(file, iov, nr_segs, tot_len,
pos, fnv);

fs/read_write.c +17 -7

@@ -1041,7 +1095,7 @@ out:
 
 static size_t compat_readv(struct file *file,
                           const struct compat_iovec __user *vec,
-                          unsigned long vlen, loff_t *pos)
+                          unsigned long vlen, loff_t *pos, int flags)
 {
        ssize_t ret = -EBADF;
 

@@ -1051,8 +1105,10 @@ static size_t compat_readv(struct file *file,
        ret = -EINVAL;
        if (!(file->f_mode & FMODE_CAN_READ))
                goto out;
+       if (flags & ~0)
+               goto out;
 
-       ret = compat_do_readv_writev(READ, file, vec, vlen, pos);
+       ret = compat_do_readv_writev(READ, file, vec, vlen, pos, flags);
 
 out:
        if (ret > 0)

@@ -1061,9 +1117,9 @@ out:
        return ret;
 }
 
-COMPAT_SYSCALL_DEFINE3(readv, compat_ulong_t, fd,
-               const struct compat_iovec __user *,vec,
-               compat_ulong_t, vlen)
+static size_t __compat_sys_readv(compat_ulong_t fd,
+                                const struct compat_iovec __user *vec,
+                                compat_ulong_t vlen, int flags)
 {
        struct fd f = fdget_pos(fd);
        ssize_t ret;

@@ -1072,16 +1128,24 @@ COMPAT_SYSCALL_DEFINE3(readv, compat_ulong_t, fd,
        if (!f.file)
                return -EBADF;
        pos = f.file->f_pos;
-       ret = compat_readv(f.file, vec, vlen, &pos);
+       ret = compat_readv(f.file, vec, vlen, &pos, flags);
        if (ret >= 0)
                f.file->f_pos = pos;
        fdput_pos(f);
        return ret;
+
+}
+
+COMPAT_SYSCALL_DEFINE3(readv, compat_ulong_t, fd,
+               const struct compat_iovec __user *,vec,
+               compat_ulong_t, vlen)
+{
+       return __compat_sys_readv(fd, vec, vlen, 0);
 }
 
 static long __compat_sys_preadv64(unsigned long fd,
                                  const struct compat_iovec __user *vec,
-                                 unsigned long vlen, loff_t pos)
+                                 unsigned long vlen, loff_t pos, int
 flags)
 {
        struct fd f;

        ssize_t ret;

fs/read_write.c +34 -11

@@ -1093,7 +1157,7 @@ static long __compat_sys_preadv64(unsigned long fd,
                return -EBADF;
        ret = -ESPIPE;
        if (f.file->f_mode & FMODE_PREAD)
-               ret = compat_readv(f.file, vec, vlen, &pos);
+               ret = compat_readv(f.file, vec, vlen, &pos, flags);
        fdput(f);
        return ret;
 }

@@ -1103,7 +1167,7 @@ COMPAT_SYSCALL_DEFINE4(preadv64, unsigned long, fd,
                const struct compat_iovec __user *,vec,
                unsigned long, vlen, loff_t, pos)
 {
-       return __compat_sys_preadv64(fd, vec, vlen, pos);
+       return __compat_sys_preadv64(fd, vec, vlen, pos, 0);
 }
 #endif
 

@@ -1113,12 +1177,25 @@ COMPAT_SYSCALL_DEFINE5(preadv, compat_ulong_t, fd,
 {
        loff_t pos = ((loff_t)pos_high << 32) | pos_low;
 
-       return __compat_sys_preadv64(fd, vec, vlen, pos);
+       return __compat_sys_preadv64(fd, vec, vlen, pos, 0);
+}
+
+COMPAT_SYSCALL_DEFINE6(preadv2, compat_ulong_t, fd,
+               const struct compat_iovec __user *,vec,
+               compat_ulong_t, vlen, u32, pos_low, u32, pos_high,
+               int, flags)
+{
+       loff_t pos = ((loff_t)pos_high << 32) | pos_low;
+
+       if (pos == -1)
+               return __compat_sys_readv(fd, vec, vlen, flags);
+
+       return __compat_sys_preadv64(fd, vec, vlen, pos, flags);
 }
 
 static size_t compat_writev(struct file *file,
                            const struct compat_iovec __user *vec,
-                           unsigned long vlen, loff_t *pos)
+                           unsigned long vlen, loff_t *pos, int flags)
 {
        ssize_t ret = -EBADF;
 

@@ -1128,8 +1205,10 @@ static size_t compat_writev(struct file *file,
        ret = -EINVAL;
        if (!(file->f_mode & FMODE_CAN_WRITE))
                goto out;
+       if (flags & ~0)
+               goto out;
 
-       ret = compat_do_readv_writev(WRITE, file, vec, vlen, pos);
+       ret = compat_do_readv_writev(WRITE, file, vec, vlen, pos, flags);
 
 out:
        if (ret > 0)

@@ -1138,9 +1217,9 @@ out:
        return ret;
 }
 
-COMPAT_SYSCALL_DEFINE3(writev, compat_ulong_t, fd,
-               const struct compat_iovec __user *, vec,
-               compat_ulong_t, vlen)
+static size_t __compat_sys_writev(compat_ulong_t fd,
+                                 const struct compat_iovec __user* vec,
+                                 compat_ulong_t vlen, int flags)
 {
        struct fd f = fdget_pos(fd);
        ssize_t ret;

@@ -1149,28 +1228,36 @@ COMPAT_SYSCALL_DEFINE3(writev, compat_ulong_t, fd,
        if (!f.file)
                return -EBADF;
        pos = f.file->f_pos;
-       ret = compat_writev(f.file, vec, vlen, &pos);
+       ret = compat_writev(f.file, vec, vlen, &pos, flags);
        if (ret >= 0)
                f.file->f_pos = pos;
        fdput_pos(f);
        return ret;
 }
 
+COMPAT_SYSCALL_DEFINE3(writev, compat_ulong_t, fd,
+               const struct compat_iovec __user *, vec,
+               compat_ulong_t, vlen)
+{
+       return __compat_sys_writev(fd, vec, vlen, 0);
+}
+
 static long __compat_sys_pwritev64(unsigned long fd,
                                   const struct compat_iovec __user *vec,
-                                  unsigned long vlen, loff_t pos)
+                                  unsigned long vlen, loff_t pos, int
 flags)
 {
        struct fd f;
        ssize_t ret;
 
        if (pos < 0)
                return -EINVAL;
+
        f = fdget(fd);
        if (!f.file)
                return -EBADF;
        ret = -ESPIPE;
        if (f.file->f_mode & FMODE_PWRITE)
-               ret = compat_writev(f.file, vec, vlen, &pos);
+               ret = compat_writev(f.file, vec, vlen, &pos, flags);
        fdput(f);
        return ret;

}

fs/read_write.c +15 -2

@@ -1180,7 +1267,7 @@ COMPAT_SYSCALL_DEFINE4(pwritev64, unsigned long, fd,
                const struct compat_iovec __user *,vec,
                unsigned long, vlen, loff_t, pos)
 {
-       return __compat_sys_pwritev64(fd, vec, vlen, pos);
+       return __compat_sys_pwritev64(fd, vec, vlen, pos, 0);
 }
 #endif
 

@@ -1190,8 +1277,21 @@ COMPAT_SYSCALL_DEFINE5(pwritev, compat_ulong_t, fd,
 {
        loff_t pos = ((loff_t)pos_high << 32) | pos_low;
 
-       return __compat_sys_pwritev64(fd, vec, vlen, pos);
+       return __compat_sys_pwritev64(fd, vec, vlen, pos, 0);
+}
+
+COMPAT_SYSCALL_DEFINE6(pwritev2, compat_ulong_t, fd,
+               const struct compat_iovec __user *,vec,
+               compat_ulong_t, vlen, u32, pos_low, u32, pos_high, int,
 flags)
+{
+       loff_t pos = ((loff_t)pos_high << 32) | pos_low;
+
+       if (pos == -1)
+               return __compat_sys_writev(fd, vec, vlen, flags);
+
+       return __compat_sys_pwritev64(fd, vec, vlen, pos, flags);
 }
+
 #endif
 

static ssize_t do_sendfile(int out_fd, int in_fd, loff_t *ppos,

include/linux/compat.h +6 -0

index e649426..63a94e2 100644
@@ -340,6 +340,12 @@ asmlinkage ssize_t compat_sys_preadv(compat_ulong_t
 fd,
 asmlinkage ssize_t compat_sys_pwritev(compat_ulong_t fd,
                const struct compat_iovec __user *vec,
                compat_ulong_t vlen, u32 pos_low, u32 pos_high);
+asmlinkage ssize_t compat_sys_preadv2(compat_ulong_t fd,
+               const struct compat_iovec __user *vec,
+               compat_ulong_t vlen, u32 pos_low, u32 pos_high, int flags);
+asmlinkage ssize_t compat_sys_pwritev2(compat_ulong_t fd,
+               const struct compat_iovec __user *vec,
+               compat_ulong_t vlen, u32 pos_low, u32 pos_high, int flags);
 
 #ifdef __ARCH_WANT_COMPAT_SYS_PREADV64

asmlinkage long compat_sys_preadv64(unsigned long fd,

include/linux/syscalls.h +3 -0

index bda9b81..cedc22e 100644
@@ -571,8 +571,14 @@ asmlinkage long sys_pwrite64(unsigned int fd, const
 char __user *buf,
                             size_t count, loff_t pos);
 asmlinkage long sys_preadv(unsigned long fd, const struct iovec __user
 *vec,
                           unsigned long vlen, unsigned long pos_l,
 unsigned long pos_h);
+asmlinkage long sys_preadv2(unsigned long fd, const struct iovec __user
 *vec,
+                           unsigned long vlen, unsigned long pos_l,
 unsigned long pos_h,
+                           int flags);
 asmlinkage long sys_pwritev(unsigned long fd, const struct iovec __user

*vec,
unsigned long vlen, unsigned long pos_l,
unsigned long pos_h);
+asmlinkage long sys_pwritev2(unsigned long fd, const struct iovec __user *vec,
+ unsigned long vlen, unsigned long pos_l,
unsigned long pos_h,

include/linux/syscalls.h +1 -0

+                           int flags);
 asmlinkage long sys_getcwd(char __user *buf, unsigned long size);
 asmlinkage long sys_mkdir(const char __user *pathname, umode_t mode);
 asmlinkage long sys_chdir(const char __user *filename);

include/uapi/asm-generic/unistd.h +4 -0

index 22749c1..9406018 100644
@@ -213,6 +213,10 @@ __SC_COMP(__NR_pwrite64, sys_pwrite64,
 compat_sys_pwrite64)
 __SC_COMP(__NR_preadv, sys_preadv, compat_sys_preadv)
 #define __NR_pwritev 70
 __SC_COMP(__NR_pwritev, sys_pwritev, compat_sys_pwritev)
+#define __NR_preadv2 281
+__SC_COMP(__NR_preadv2, sys_preadv2, compat_sys_preadv2)
+#define __NR_pwritev2 282
+__SC_COMP(__NR_pwritev2, sys_pwritev2, compat_sys_pwritev2)
 
 /* fs/sendfile.c */

#define __NR3264_sendfile 71

include/uapi/asm-generic/unistd.h +1 -1

@@ -709,7 +713,7 @@ __SYSCALL(__NR_memfd_create, sys_memfd_create)
 __SYSCALL(__NR_bpf, sys_bpf)
 
 #undef __NR_syscalls
-#define __NR_syscalls 281
+#define __NR_syscalls 283
 
 /*
  * All syscalls below here should go away really,

mm/filemap.c +1 -0

index 14b4642..530c263 100644
@@ -1457,6 +1457,7 @@ static void shrink_readahead_size_eio(struct file
 *filp,
  * @ppos:      current file position
  * @iter:      data destination
  * @written:   already copied
+ * @flags:     optional flags
  *
  * This is a generic file read routine, and uses the

* mapping->a_ops->readpage() function for the actual low-level stuff.

mm/filemap.c +1 -1

@@ -1465,7 +1466,7 @@ static void shrink_readahead_size_eio(struct file
 *filp,
  * of the logic when it comes to error handling etc.
  */
 static ssize_t do_generic_file_read(struct file *filp, loff_t *ppos,
-               struct iov_iter *iter, ssize_t written)
+               struct iov_iter *iter, ssize_t written, int flags)
 {
        struct address_space *mapping = filp->f_mapping;

        struct inode *inode = mapping->host;

mm/filemap.c +1 -1

@@ -1735,7 +1736,7 @@ generic_file_read_iter(struct kiocb *iocb, struct
 iov_iter *iter)
                }
        }
 
-       retval = do_generic_file_read(file, ppos, iter, retval);
+       retval = do_generic_file_read(file, ppos, iter, retval,
 iocb->ki_rwflags);
 out:

        return retval;

}
--
1.9.1

--
To unsubscribe from this list: send the line "unsubscribe linux-fsdevel" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html

This patcheset introduces an ability to perform a non-blocking read from regular files in buffered IO mode. This works by only for those filesystems that have data in the page cache.

It does this by introducing new syscalls new syscalls preadv2/pwritev2. These new syscalls behave like the network sendmsg, recvmsg syscalls that accept an extra flag argument (RWF_NONBLOCK).

It's a very common patern today (samba, libuv, etc..) use a large threadpool to perform buffered IO operations. They submit the work form another thread that performs network IO and epoll or other threads that perform CPU work. This leads to increased latency for processing, esp. in the case of data that's already cached in the page cache.

With the new interface the applications will now be able to fetch the data in their network / cpu bound thread(s) and only defer to a threadpool if it's not there. In our own application (VLDB) we've observed a decrease in latency for "fast" request by avoiding unnecessary queuing and having to swap out current tasks in IO bound work threads.

Quoted 14 lines · Milosz Tanski

This patcheset introduces an ability to perform a non-blocking read from regular files in buffered IO mode. This works by only for those filesystems that have data in the page cache.

It does this by introducing new syscalls new syscalls preadv2/pwritev2. These new syscalls behave like the network sendmsg, recvmsg syscalls that accept an extra flag argument (RWF_NONBLOCK).

It's a very common patern today (samba, libuv, etc..) use a large threadpool to perform buffered IO operations. They submit the work form another thread that performs network IO and epoll or other threads that perform CPU work. This leads to increased latency for processing, esp. in the case of data that's already cached in the page cache.

Quoted 5 lines

With the new interface the applications will now be able to fetch the data in their network / cpu bound thread(s) and only defer to a threadpool if it's not there. In our own application (VLDB) we've observed a decrease in latency for "fast" request by avoiding unnecessary queuing and having to swap out current tasks in IO bound work threads.

Can you write a test (or set of) for fstests that exercises this new functionality? I'm not worried about performance, just correctness....

Cheers,

Dave.

--
Dave Chinner
[email protected]

Quoted 3 lines

Can you write a test (or set of) for fstests that exercises this new functionality? I'm not worried about performance, just correctness....

Sure thing. Can you point me at the fstests repo? A quick google search reveals lots of projects named fstests, most of them abandoned.

Quoted 6 lines · Milosz Tanski

Quoted 3 lines

Can you write a test (or set of) for fstests that exercises this new functionality? I'm not worried about performance, just correctness....

Sure thing. Can you point me at the fstests repo? A quick google search reveals lots of projects named fstests, most of them abandoned.

I think he's referring to xfstests. Still, I think that's the wrong place for functional testing. ltp would be better, imo.

Quoted 6 lines · Jeff Moyer

Quoted 4 lines · Milosz Tanski

Quoted 3 lines

Can you write a test (or set of) for fstests that exercises this new functionality? I'm not worried about performance, just correctness....

Quoted 5 lines

Quoted 2 lines

Sure thing. Can you point me at the fstests repo? A quick google search reveals lots of projects named fstests, most of them abandoned.

I think he's referring to xfstests. Still, I think that's the wrong place for functional testing. ltp would be better, imo.

I don't follow. Can you explain why is xfstests be the wrong place to exercise this functionality and what makes ltp a better choice?

I think he's referring to xfstests. Still, I think that's the wrong place for functional testing. ltp would be better, imo.

Quoted 3 lines · Jeff Moyer

I think he's referring to xfstests. Still, I think that's the wrong place for functional testing. ltp would be better, imo.

I disagree; xfstests is the right place for adding these tests, because these patches seem to require fs-specific support, and file system developers are already using xfstests when checking for regressions. Using xfstests is already part of most of the file system developers' workflow; ltp is not.

So if you want to make sure we notice regressions, it really needs to go into xfstests. If you insist on putting it in ltp, then one of us will then have to make a copy of the tests and put it in xfstests.

Quoted 21 lines · Dave Chinner

Quoted 19 lines · Milosz Tanski

This patcheset introduces an ability to perform a non-blocking read from regular files in buffered IO mode. This works by only for those filesystems that have data in the page cache.

It does this by introducing new syscalls new syscalls preadv2/pwritev2. These new syscalls behave like the network sendmsg, recvmsg syscalls that accept an extra flag argument (RWF_NONBLOCK).

It's a very common patern today (samba, libuv, etc..) use a large threadpool to perform buffered IO operations. They submit the work form another thread that performs network IO and epoll or other threads that perform CPU work. This leads to increased latency for processing, esp. in the case of data that's already cached in the page cache.

With the new interface the applications will now be able to fetch the data in their network / cpu bound thread(s) and only defer to a threadpool if it's not there. In our own application (VLDB) we've observed a decrease in latency for "fast" request by avoiding unnecessary queuing and having to swap out current tasks in IO bound work threads.

Quoted 3 lines

Can you write a test (or set of) for fstests that exercises this new functionality? I'm not worried about performance, just correctness....

Sure thing. Can you point me at the fstests repo? A quick google search reveals lots of projects named fstests, most of them abandoned.

Quoted 14 lines · Milosz Tanski

This patcheset introduces an ability to perform a non-blocking read from regular files in buffered IO mode. This works by only for those filesystems that have data in the page cache.

It does this by introducing new syscalls new syscalls preadv2/pwritev2. These new syscalls behave like the network sendmsg, recvmsg syscalls that accept an extra flag argument (RWF_NONBLOCK).

It's a very common patern today (samba, libuv, etc..) use a large threadpool to perform buffered IO operations. They submit the work form another thread that performs network IO and epoll or other threads that perform CPU work. This leads to increased latency for processing, esp. in the case of data that's already cached in the page cache.

Quoted 5 lines

With the new interface the applications will now be able to fetch the data in their network / cpu bound thread(s) and only defer to a threadpool if it's not there. In our own application (VLDB) we've observed a decrease in latency for "fast" request by avoiding unnecessary queuing and having to swap out current tasks in IO bound work threads.

Can you write a test (or set of) for fstests that exercises this new functionality? I'm not worried about performance, just correctness....

Quoted 3 lines

Can you write a test (or set of) for fstests that exercises this new functionality? I'm not worried about performance, just correctness....

On the subject of testing, I added support to trinity (attached, untested). That did raise one question. Do we expect applications to #include <linux/fs.h> to get the RWF_NONBLOCK definition?

Quoted 4 lines · Jeff Moyer

Quoted 3 lines

Can you write a test (or set of) for fstests that exercises this new functionality? I'm not worried about performance, just correctness....

Quoted 3 lines

On the subject of testing, I added support to trinity (attached, untested). That did raise one question. Do we expect applications to #include <linux/fs.h> to get the RWF_NONBLOCK definition?

Trinity will at least need an addition to include/compat.h for older headers that won't have the definition. Looks ok otherwise.

Also, I usually sit on stuff like this until the syscall numbers are in Linus tree. This is 3.19 stuff I presume ?
istr akpm picked up execveat recently, so if that goes in first, we'll need to respin this anyway..

Quoted 6 lines · Dave Jones

Quoted 4 lines · Jeff Moyer

Quoted 3 lines

Can you write a test (or set of) for fstests that exercises this new functionality? I'm not worried about performance, just correctness....

Quoted 6 lines

Quoted 3 lines

On the subject of testing, I added support to trinity (attached, untested). That did raise one question. Do we expect applications to #include <linux/fs.h> to get the RWF_NONBLOCK definition?

Trinity will at least need an addition to include/compat.h for older headers that won't have the definition. Looks ok otherwise.

OK, I'll add that.

Quoted 4 lines

Also, I usually sit on stuff like this until the syscall numbers are in Linus tree. This is 3.19 stuff I presume ?
istr akpm picked up execveat recently, so if that goes in first, we'll need to respin this anyway..

Sure. I just wanted to test with trinity *before* it makes it into the kernel. Crazy, I know. ;-)

Cheers,
Jeff

Quoted 7 lines · Jeff Moyer

Quoted 3 lines

Can you write a test (or set of) for fstests that exercises this new functionality? I'm not worried about performance, just correctness....

On the subject of testing, I added support to trinity (attached, untested). That did raise one question. Do we expect applications to #include <linux/fs.h> to get the RWF_NONBLOCK definition?

Trinity will at least need an addition to include/compat.h for older headers that won't have the definition. Looks ok otherwise.

Also, I usually sit on stuff like this until the syscall numbers are in Linus tree. This is 3.19 stuff I presume ?
istr akpm picked up execveat recently, so if that goes in first, we'll need to respin this anyway..

On a unrelated note I just back to figuring out how to add this to xfstests. I got busy with other things the last few days. I'm still not quite sure how to write a test using the framework, the documentation (README) seams very XFS specific and otherwise the test seam to be be split between many different files / directories / C code / shell code. I might be me being slow... but it's just not obvious for me how to glue the whole thing together.

This patcheset introduces an ability to perform a non-blocking read from regular files in buffered IO mode. This works by only for those filesystems that have data in the page cache.

It does this by introducing new syscalls new syscalls preadv2/pwritev2. These new syscalls behave like the network sendmsg, recvmsg syscalls that accept an extra flag argument (RWF_NONBLOCK).

It's a very common patern today (samba, libuv, etc..) use a large threadpool to perform buffered IO operations. They submit the work form another thread that performs network IO and epoll or other threads that perform CPU work. This leads to increased latency for processing, esp. in the case of data that's already cached in the page cache.

With the new interface the applications will now be able to fetch the data in their network / cpu bound thread(s) and only defer to a threadpool if it's not there. In our own application (VLDB) we've observed a decrease in latency for "fast" request by avoiding unnecessary queuing and having to swap out current tasks in IO bound work threads.

Version 6 highlight:
- Compat syscall flag checks, per. Jeff.
- Minor stylistic suggestions.

Version 5 highlight:
- XFS support for RWF_NONBLOCK. from Christoph.
- RWF_DSYNC flag and support for pwritev2, from Christoph.
- Implemented compat syscalls, per. Jeff.
- Missing nfs, ceph changes from older patchset.

Version 4 highlight:
- Updated for 3.18-rc1.
- Performance data from our application.
- First stab at man page with Jeff's help. Patch is in-reply to.

RFC Version 3 highlights:
- Down to 2 syscalls from 4; can user fp or argument position.
- RWF_NONBLOCK value flag is not the same O_NONBLOCK, per Jeff.

RFC Version 2 highlights:
- Put the flags argument into kiocb (less noise), per. Al Viro
- O_DIRECT checking early in the process, per. Jeff Moyer
- Resolved duplicate (c&p) code in syscall code, per. Jeff
- Included perf data in thread cover letter, per. Jeff
- Created a new flag (not O_NONBLOCK) for readv2, perf Jeff

Some perf data generated using fio comparing the posix aio engine to a version of the posix AIO engine that attempts to performs "fast" reads before submitting the operations to the queue. This workflow is on ext4 partition on raid0 (test / build-rig.) Simulating our database access patern workload using 16kb read accesses. Our database uses a home-spun posix aio like queue (samba does the same thing.)

f1: ~73% rand read over mostly cached data (zipf med-size dataset)
f2: ~18% rand read over mostly un-cached data (uniform large-dataset)
f3: ~9% seq-read over large dataset

before:

f1:

    bw (KB  /s): min=   11, max= 9088, per=0.56%, avg=969.54, stdev=827.99
    lat (msec) : 50=0.01%, 100=1.06%, 250=5.88%, 500=4.08%, 750=12.48%
    lat (msec) : 1000=17.27%, 2000=49.86%, >=2000=9.42%
f2:
    bw (KB  /s): min=    2, max= 1882, per=0.16%, avg=273.28, stdev=220.26
    lat (msec) : 250=5.65%, 500=3.31%, 750=15.64%, 1000=24.59%, 2000=46.56%
    lat (msec) : >=2000=4.33%
f3:
    bw (KB  /s): min=    0, max=265568, per=99.95%, avg=174575.10,
                 stdev=34526.89
    lat (usec) : 2=0.01%, 4=0.01%, 10=0.02%, 20=0.27%, 50=10.82%
    lat (usec) : 100=50.34%, 250=5.05%, 500=7.12%, 750=6.60%, 1000=4.55%
    lat (msec) : 2=8.73%, 4=3.49%, 10=1.83%, 20=0.89%, 50=0.22%
    lat (msec) : 100=0.05%, 250=0.02%, 500=0.01%
total:
   READ: io=102365MB, aggrb=174669KB/s, minb=240KB/s, maxb=173599KB/s,
         mint=600001msec, maxt=600113msec

after (with fast read using preadv2 before submit):

f1:

    bw (KB  /s): min=    3, max=14897, per=1.28%, avg=2276.69, stdev=2930.39
    lat (usec) : 2=70.63%, 4=0.01%
    lat (msec) : 250=0.20%, 500=2.26%, 750=1.18%, 2000=0.22%, >=2000=25.53%
f2:
    bw (KB  /s): min=    2, max= 2362, per=0.14%, avg=249.83, stdev=222.00
    lat (msec) : 250=6.35%, 500=1.78%, 750=9.29%, 1000=20.49%, 2000=52.18%
    lat (msec) : >=2000=9.99%
f3:
    bw (KB  /s): min=    1, max=245448, per=100.00%, avg=177366.50,
                 stdev=35995.60
    lat (usec) : 2=64.04%, 4=0.01%, 10=0.01%, 20=0.06%, 50=0.43%
    lat (usec) : 100=0.20%, 250=1.27%, 500=2.93%, 750=3.93%, 1000=7.35%
    lat (msec) : 2=14.27%, 4=2.88%, 10=1.54%, 20=0.81%, 50=0.22%
    lat (msec) : 100=0.05%, 250=0.02%
total:
   READ: io=103941MB, aggrb=177339KB/s, minb=213KB/s, maxb=176375KB/s,
         mint=600020msec, maxt=600178msec

Interpreting the results you can see total bandwidth stays the same but overall request latency is decreased in f1 (random, mostly cached) and f3 (sequential) workloads. There is a slight bump in latency for since it's random data that's

unlikely to be cached but we're always trying "fast read".

In our application we have starting keeping track of "fast read" hits/misses and for files / requests that have a lot hit ratio we don't do "fast reads" mostly getting rid of extra latency in the uncached cases. In our real world work load we were able to reduce average response time by 20 to 30% (depends on amount of IO done by request).

I've performed other benchmarks and I have no observed any perf regressions in any of the normal (old) code paths.

I have co-developed these changes with Christoph Hellwig.

Quoted 8 lines · On Mon, 10 Nov 2014 11:40:23 -0500 Milosz Tanski <[email protected]> wrote:

This patcheset introduces an ability to perform a non-blocking read from regular files in buffered IO mode. This works by only for those filesystems that have data in the page cache.

It does this by introducing new syscalls new syscalls preadv2/pwritev2. These new syscalls behave like the network sendmsg, recvmsg syscalls that accept an extra flag argument (RWF_NONBLOCK).

Quoted 5 lines

It's a very common patern today (samba, libuv, etc..) use a large threadpool to perform buffered IO operations. They submit the work form another thread that performs network IO and epoll or other threads that perform CPU work. This leads to increased latency for processing, esp. in the case of data that's already cached in the page cache.

It would be extremely useful if we could get input from the developers of "samba, libuv, etc.." about this. Do they think it will be useful, will they actually use it, can they identify any shortcomings, etc.

Because it would be terrible if we were to merge this then discover that major applications either don't use it, or require userspace-visible changes.

Ideally, someone would whip up pread2() support into those apps and report on the result.

Quoted 6 lines

With the new interface the applications will now be able to fetch the data in their network / cpu bound thread(s) and only defer to a threadpool if it's not there. In our own application (VLDB) we've observed a decrease in latency for "fast" request by avoiding unnecessary queuing and having to swap out current tasks in IO bound work threads.

I haven't read the patches yet, but I'm scratching my head over pwritev2(). There's much talk and testing results here about preadv2(), but nothing about how pwritev() works, what its semantics are, testing results, etc.

Quoted 11 lines

Version 6 highlight:
- Compat syscall flag checks, per. Jeff.
- Minor stylistic suggestions.

Version 5 highlight:
- XFS support for RWF_NONBLOCK. from Christoph.
- RWF_DSYNC flag and support for pwritev2, from Christoph.
- Implemented compat syscalls, per. Jeff.
- Missing nfs, ceph changes from older patchset.

Quoted 4 lines

Version 4 highlight:
- Updated for 3.18-rc1.
- Performance data from our application.
- First stab at man page with Jeff's help. Patch is in-reply to.

I can't find that manpage. It is important. Please include it in the patch series.

I'm particularly interested in details regarding

- behaviour and userspace return values when data is not found in pagecache

- how it handles partially uptodate pages (blocksize < pagesize). For both reads and writes. This sort of thing gets intricate so let's spell the design out with great specificity.

- behaviour at EOF.

- details regarding handling of file holes.

Quoted 66 lines

RFC Version 3 highlights:
- Down to 2 syscalls from 4; can user fp or argument position.
- RWF_NONBLOCK value flag is not the same O_NONBLOCK, per Jeff.

RFC Version 2 highlights:
- Put the flags argument into kiocb (less noise), per. Al Viro
- O_DIRECT checking early in the process, per. Jeff Moyer
- Resolved duplicate (c&p) code in syscall code, per. Jeff
- Included perf data in thread cover letter, per. Jeff
- Created a new flag (not O_NONBLOCK) for readv2, perf Jeff

Some perf data generated using fio comparing the posix aio engine to a version of the posix AIO engine that attempts to performs "fast" reads before submitting the operations to the queue. This workflow is on ext4 partition on raid0 (test / build-rig.) Simulating our database access patern workload using 16kb read accesses. Our database uses a home-spun posix aio like queue (samba does the same thing.)

f1: ~73% rand read over mostly cached data (zipf med-size dataset)
f2: ~18% rand read over mostly un-cached data (uniform large-dataset)
f3: ~9% seq-read over large dataset

before:

f1:

    bw (KB  /s): min=   11, max= 9088, per=0.56%, avg=969.54, stdev=827.99
    lat (msec) : 50=0.01%, 100=1.06%, 250=5.88%, 500=4.08%, 750=12.48%
    lat (msec) : 1000=17.27%, 2000=49.86%, >=2000=9.42%
f2:
    bw (KB  /s): min=    2, max= 1882, per=0.16%, avg=273.28, stdev=220.26
    lat (msec) : 250=5.65%, 500=3.31%, 750=15.64%, 1000=24.59%, 2000=46.56%
    lat (msec) : >=2000=4.33%
f3:
    bw (KB  /s): min=    0, max=265568, per=99.95%, avg=174575.10,
                 stdev=34526.89
    lat (usec) : 2=0.01%, 4=0.01%, 10=0.02%, 20=0.27%, 50=10.82%
    lat (usec) : 100=50.34%, 250=5.05%, 500=7.12%, 750=6.60%, 1000=4.55%
    lat (msec) : 2=8.73%, 4=3.49%, 10=1.83%, 20=0.89%, 50=0.22%
    lat (msec) : 100=0.05%, 250=0.02%, 500=0.01%
total:
   READ: io=102365MB, aggrb=174669KB/s, minb=240KB/s, maxb=173599KB/s,
         mint=600001msec, maxt=600113msec

after (with fast read using preadv2 before submit):

f1:

    bw (KB  /s): min=    3, max=14897, per=1.28%, avg=2276.69, stdev=2930.39
    lat (usec) : 2=70.63%, 4=0.01%
    lat (msec) : 250=0.20%, 500=2.26%, 750=1.18%, 2000=0.22%, >=2000=25.53%
f2:
    bw (KB  /s): min=    2, max= 2362, per=0.14%, avg=249.83, stdev=222.00
    lat (msec) : 250=6.35%, 500=1.78%, 750=9.29%, 1000=20.49%, 2000=52.18%
    lat (msec) : >=2000=9.99%
f3:
    bw (KB  /s): min=    1, max=245448, per=100.00%, avg=177366.50,
                 stdev=35995.60
    lat (usec) : 2=64.04%, 4=0.01%, 10=0.01%, 20=0.06%, 50=0.43%
    lat (usec) : 100=0.20%, 250=1.27%, 500=2.93%, 750=3.93%, 1000=7.35%
    lat (msec) : 2=14.27%, 4=2.88%, 10=1.54%, 20=0.81%, 50=0.22%
    lat (msec) : 100=0.05%, 250=0.02%
total:
   READ: io=103941MB, aggrb=177339KB/s, minb=213KB/s, maxb=176375KB/s,
         mint=600020msec, maxt=600178msec

Quoted 3 lines

Interpreting the results you can see total bandwidth stays the same but overall request latency is decreased in f1 (random, mostly cached) and f3 (sequential) workloads. There is a slight bump in latency for since it's random data that's

s/for/for f2/

Quoted 8 lines

unlikely to be cached but we're always trying "fast read".

In our application we have starting keeping track of "fast read" hits/misses and for files / requests that have a lot hit ratio we don't do "fast reads" mostly getting rid of extra latency in the uncached cases. In our real world work load we were able to reduce average response time by 20 to 30% (depends on amount of IO done by request).

Quoted 5 lines

I've performed other benchmarks and I have no observed any perf regressions in any of the normal (old) code paths.

I have co-developed these changes with Christoph Hellwig.

There have been several incomplete attempts to implement fincore(). If we were to complete those attempts, preadv2() could be implemented using fincore()+pread(). Plus we get fincore(), which is useful for other (but probably similar) reasons. Probably fincore()+pwrite() could be used to implement pwritev2(), but I don't know what pwritev2() does yet.

Implementing fincore() is more flexible, requires less code and is less likely to have bugs. So why not go that way? Yes, it's more CPU intensive, but how much? Is the difference sufficient to justify the preadv2()/pwritev2() approach?

Quoted 11 lines

There have been several incomplete attempts to implement fincore(). If we were to complete those attempts, preadv2() could be implemented using fincore()+pread(). Plus we get fincore(), which is useful for other (but probably similar) reasons. Probably fincore()+pwrite() could be used to implement pwritev2(), but I don't know what pwritev2() does yet.

Implementing fincore() is more flexible, requires less code and is less likely to have bugs. So why not go that way? Yes, it's more CPU intensive, but how much? Is the difference sufficient to justify the preadv2()/pwritev2() approach?

I would like to see a fincore() functionality (for other reasons) I don't think it does the job here. fincore() + preadv() is inherently racy as there's no guarantee that the data becomes uncached between the two calls.

This may not matter in some cases, but in others (ones that I'm trying to solve) it will introduce unexpected latency.

There's no overlap between prwritev2 and fincore() functionality.

The question is whether a simpler approach such as fincore() will be sufficient.

Quoted 12 lines · On Tue, 2 Dec 2014 17:17:42 -0500 Milosz Tanski <[email protected]> wrote:

Quoted 11 lines

There have been several incomplete attempts to implement fincore(). If we were to complete those attempts, preadv2() could be implemented using fincore()+pread(). Plus we get fincore(), which is useful for other (but probably similar) reasons. Probably fincore()+pwrite() could be used to implement pwritev2(), but I don't know what pwritev2() does yet.

Implementing fincore() is more flexible, requires less code and is less likely to have bugs. So why not go that way? Yes, it's more CPU intensive, but how much? Is the difference sufficient to justify the preadv2()/pwritev2() approach?

Quoted 4 lines

I would like to see a fincore() functionality (for other reasons) I don't think it does the job here. fincore() + preadv() is inherently racy as there's no guarantee that the data becomes uncached between the two calls.

There will always be holes. For example find_get_page() could block on lock_page() while some other process is doing IO. page_cache_async_readahead() does lots of memory allocation which can get blocked for long periods in the page allocator. page_cache_async_readahead() can block on synchronous metadata reads, etc.

The question is whether a simpler approach such as fincore() will be sufficient.

Quoted 2 lines

This may not matter in some cases, but in others (ones that I'm trying to solve) it will introduce unexpected latency.

Details?

Quoted 3 lines

There's no overlap between prwritev2 and fincore() functionality.

Do we actually need pwritev2()? What's the justification for that?

Please let's examine the alternative(s) seriously. It would be mistake to add preadv2/pwritev2 if fincore+pread would have sufficed.

Quoted 20 lines · Andrew Morton

Quoted 12 lines · On Tue, 2 Dec 2014 17:17:42 -0500 Milosz Tanski…

Quoted 11 lines

There have been several incomplete attempts to implement fincore(). If we were to complete those attempts, preadv2() could be implemented using fincore()+pread(). Plus we get fincore(), which is useful for other (but probably similar) reasons. Probably fincore()+pwrite() could be used to implement pwritev2(), but I don't know what pwritev2() does yet.

Implementing fincore() is more flexible, requires less code and is less likely to have bugs. So why not go that way? Yes, it's more CPU intensive, but how much? Is the difference sufficient to justify the preadv2()/pwritev2() approach?

Quoted 4 lines

I would like to see a fincore() functionality (for other reasons) I don't think it does the job here. fincore() + preadv() is inherently racy as there's no guarantee that the data becomes uncached between the two calls.

Quoted 6 lines

There will always be holes. For example find_get_page() could block on lock_page() while some other process is doing IO. page_cache_async_readahead() does lots of memory allocation which can get blocked for long periods in the page allocator. page_cache_async_readahead() can block on synchronous metadata reads, etc.

Andrew I think it would helpful if you did read through the patches. The first 3 are somewhat uninteresting as it's just wiring up the new syscalls and plumbing the flag argument through. The core of the RWF_NONBLOCK is patch 4: https://lkml.org/lkml/2014/11/10/463 and if you strip away the fs specific changes the core of it is very simple.

The core is mostly contained in do_generic_file_read() in filemap.c, and is very short and easy to understand. It boils down to we read as much data as we can given what's in the page cache. There's no fallback to diskio for readpage() in case of missing pages and we bail before any calls to page_cache_async_readahead(). And to the best of my knowledge lock_page() does not lock the page, all it does is call pagecache_get_page() without the FGP_LOCK flag.

I've spent time a decent amount of time looking at this to make sure we cover all our major bases. It's possible I missed something but the biggest offenders should be covered and if I missed something I'd love to cover that as well.

Quoted 5 lines

Quoted 3 lines

There's no overlap between prwritev2 and fincore() functionality.

Do we actually need pwritev2()? What's the justification for that?

I'm okay with splitting up the pwritev2 and preadv2 into two independent patchsets to be considered on their own merits.

Quoted 5 lines

Please let's examine the alternative(s) seriously. It would be mistake to add preadv2/pwritev2 if fincore+pread would have sufficed.

What the motivation for my change and also approach is a very common
pattern to async buffered disk IO in userspace server applications. It comes down to having one thread to handle the network and a thread pool to perform IO requests. Why a threadpool and not something like a sendfile() for reads? Many non-trivial applications perform additional processing (ssl, checksuming, transformation). Unfortunately this has a inherent increase in average latency due to increased synchronization penalties (enqueue and notify) but primarily due to fast requests (already in cache) behind stuck behind slow request.

Here's the illustration of the common architecture:
http://i.imgur.com/f8Pla7j.png. In fact, most apps are even simpler where they replace the request queue, task worker with a single thread doing network IO using epoll or such.

preadv2 with RWF_NONBLOCK is analogous to the kernel recvmsg() with the MSG_NOWAIT flag. It's really frustrating that such capacity doesn't exist today. As with the user space application design we can skip the io threadpool and decrease average request latency in many common workloads (linear reads or zipf data accesses).

preadv2 with RWF_NONBLOCK as implemented does not suffer the same eviction races as fincore + pread because it's not implemented as two syscalls. It also has a much lower surface of possible blocking / locking then fincore + pread because it cannot fallback to reading from disk, it does not trigger read-ahead, and does not wait for page lock.

I can see all that, but it's handwaving. Yes, preadv2() will perform better in some circumstances than fincore+pread. But how much better? Enough to justify this approach, or not?

Alas, the only way to really settle that is to implement fincore() and to subject it to a decent amount of realistic quantitative testing.

Ho hum.

Could you please hunt down some libuv developers, see if we can solicit some quality input from them? As I said, we really don't want to merge this then find that people don't use it for some reason, or that it needs changes.

Quoted 7 lines · Andrew Morton

I can see all that, but it's handwaving. Yes, preadv2() will perform better in some circumstances than fincore+pread. But how much better? Enough to justify this approach, or not?

Alas, the only way to really settle that is to implement fincore() and to subject it to a decent amount of realistic quantitative testing.

Quoted 6 lines

Ho hum.

Could you please hunt down some libuv developers, see if we can solicit some quality input from them? As I said, we really don't want to merge this then find that people don't use it for some reason, or that it needs changes.

All I can say from a Samba perspective is that none of the ARM based Storage boxes I have seen so far do AIO because of the base footprint for every read. For sequential reads kernel-level readahead could kick in properly and we should be able to give them the best of both worlds:
No context switches in the default case but also good parallel behaviour for other workloads. The most important benchmark for those guys is to read a DVD image, whether it makes sense or not.