aboutsummaryrefslogtreecommitdiffstats
path: root/fs
diff options
context:
space:
mode:
Diffstat (limited to 'fs')
-rw-r--r--fs/9p/v9fs_vfs.h4
-rw-r--r--fs/9p/vfs_addr.c80
-rw-r--r--fs/9p/vfs_dir.c15
-rw-r--r--fs/9p/vfs_file.c314
-rw-r--r--fs/9p/xattr.c80
-rw-r--r--fs/adfs/file.c2
-rw-r--r--fs/affs/file.c2
-rw-r--r--fs/afs/file.c2
-rw-r--r--fs/aio.c23
-rw-r--r--fs/autofs4/autofs_i.h2
-rw-r--r--fs/autofs4/waitq.c2
-rw-r--r--fs/bfs/file.c2
-rw-r--r--fs/block_dev.c2
-rw-r--r--fs/btrfs/file.c2
-rw-r--r--fs/ceph/file.c2
-rw-r--r--fs/cifs/cifsfs.c12
-rw-r--r--fs/coda/file.c38
-rw-r--r--fs/coredump.c2
-rw-r--r--fs/ecryptfs/file.c2
-rw-r--r--fs/exofs/file.c2
-rw-r--r--fs/ext2/file.c4
-rw-r--r--fs/ext3/file.c2
-rw-r--r--fs/ext4/file.c4
-rw-r--r--fs/f2fs/file.c2
-rw-r--r--fs/fat/file.c2
-rw-r--r--fs/file_table.c4
-rw-r--r--fs/fuse/cuse.c25
-rw-r--r--fs/fuse/dev.c63
-rw-r--r--fs/fuse/file.c69
-rw-r--r--fs/gfs2/file.c4
-rw-r--r--fs/hfs/inode.c2
-rw-r--r--fs/hfsplus/inode.c2
-rw-r--r--fs/hostfs/hostfs_kern.c2
-rw-r--r--fs/hpfs/file.c2
-rw-r--r--fs/hugetlbfs/inode.c91
-rw-r--r--fs/jffs2/file.c2
-rw-r--r--fs/jfs/file.c2
-rw-r--r--fs/logfs/file.c2
-rw-r--r--fs/minix/file.c2
-rw-r--r--fs/ncpfs/file.c90
-rw-r--r--fs/ncpfs/ncplib_kernel.c6
-rw-r--r--fs/ncpfs/ncplib_kernel.h2
-rw-r--r--fs/nfs/file.c2
-rw-r--r--fs/nfs/nfs4file.c2
-rw-r--r--fs/nilfs2/file.c2
-rw-r--r--fs/ntfs/file.c2
-rw-r--r--fs/ocfs2/file.c4
-rw-r--r--fs/omfs/file.c2
-rw-r--r--fs/open.c4
-rw-r--r--fs/pipe.c2
-rw-r--r--fs/ramfs/file-mmu.c2
-rw-r--r--fs/ramfs/file-nommu.c2
-rw-r--r--fs/read_write.c109
-rw-r--r--fs/reiserfs/file.c2
-rw-r--r--fs/romfs/mmap-nommu.c1
-rw-r--r--fs/sysv/file.c2
-rw-r--r--fs/ubifs/file.c2
-rw-r--r--fs/udf/file.c2
-rw-r--r--fs/ufs/file.c2
-rw-r--r--fs/xfs/xfs_file.c2
60 files changed, 300 insertions, 820 deletions
diff --git a/fs/9p/v9fs_vfs.h b/fs/9p/v9fs_vfs.h
index b83ebfbf3fdc..5a0db6dec8d1 100644
--- a/fs/9p/v9fs_vfs.h
+++ b/fs/9p/v9fs_vfs.h
@@ -68,14 +68,10 @@ int v9fs_file_open(struct inode *inode, struct file *file);
68void v9fs_inode2stat(struct inode *inode, struct p9_wstat *stat); 68void v9fs_inode2stat(struct inode *inode, struct p9_wstat *stat);
69int v9fs_uflags2omode(int uflags, int extended); 69int v9fs_uflags2omode(int uflags, int extended);
70 70
71ssize_t v9fs_file_readn(struct file *, char *, char __user *, u32, u64);
72ssize_t v9fs_fid_readn(struct p9_fid *, char *, char __user *, u32, u64);
73void v9fs_blank_wstat(struct p9_wstat *wstat); 71void v9fs_blank_wstat(struct p9_wstat *wstat);
74int v9fs_vfs_setattr_dotl(struct dentry *, struct iattr *); 72int v9fs_vfs_setattr_dotl(struct dentry *, struct iattr *);
75int v9fs_file_fsync_dotl(struct file *filp, loff_t start, loff_t end, 73int v9fs_file_fsync_dotl(struct file *filp, loff_t start, loff_t end,
76 int datasync); 74 int datasync);
77ssize_t v9fs_file_write_internal(struct inode *, struct p9_fid *,
78 const char __user *, size_t, loff_t *, int);
79int v9fs_refresh_inode(struct p9_fid *fid, struct inode *inode); 75int v9fs_refresh_inode(struct p9_fid *fid, struct inode *inode);
80int v9fs_refresh_inode_dotl(struct p9_fid *fid, struct inode *inode); 76int v9fs_refresh_inode_dotl(struct p9_fid *fid, struct inode *inode);
81static inline void v9fs_invalidate_inode_attr(struct inode *inode) 77static inline void v9fs_invalidate_inode_attr(struct inode *inode)
diff --git a/fs/9p/vfs_addr.c b/fs/9p/vfs_addr.c
index ff1a5bac4200..2e38f9a5b472 100644
--- a/fs/9p/vfs_addr.c
+++ b/fs/9p/vfs_addr.c
@@ -51,12 +51,11 @@
51 */ 51 */
52static int v9fs_fid_readpage(struct p9_fid *fid, struct page *page) 52static int v9fs_fid_readpage(struct p9_fid *fid, struct page *page)
53{ 53{
54 int retval; 54 struct inode *inode = page->mapping->host;
55 loff_t offset; 55 struct bio_vec bvec = {.bv_page = page, .bv_len = PAGE_SIZE};
56 char *buffer; 56 struct iov_iter to;
57 struct inode *inode; 57 int retval, err;
58 58
59 inode = page->mapping->host;
60 p9_debug(P9_DEBUG_VFS, "\n"); 59 p9_debug(P9_DEBUG_VFS, "\n");
61 60
62 BUG_ON(!PageLocked(page)); 61 BUG_ON(!PageLocked(page));
@@ -65,16 +64,16 @@ static int v9fs_fid_readpage(struct p9_fid *fid, struct page *page)
65 if (retval == 0) 64 if (retval == 0)
66 return retval; 65 return retval;
67 66
68 buffer = kmap(page); 67 iov_iter_bvec(&to, ITER_BVEC | READ, &bvec, 1, PAGE_SIZE);
69 offset = page_offset(page);
70 68
71 retval = v9fs_fid_readn(fid, buffer, NULL, PAGE_CACHE_SIZE, offset); 69 retval = p9_client_read(fid, page_offset(page), &to, &err);
72 if (retval < 0) { 70 if (err) {
73 v9fs_uncache_page(inode, page); 71 v9fs_uncache_page(inode, page);
72 retval = err;
74 goto done; 73 goto done;
75 } 74 }
76 75
77 memset(buffer + retval, 0, PAGE_CACHE_SIZE - retval); 76 zero_user(page, retval, PAGE_SIZE - retval);
78 flush_dcache_page(page); 77 flush_dcache_page(page);
79 SetPageUptodate(page); 78 SetPageUptodate(page);
80 79
@@ -82,7 +81,6 @@ static int v9fs_fid_readpage(struct p9_fid *fid, struct page *page)
82 retval = 0; 81 retval = 0;
83 82
84done: 83done:
85 kunmap(page);
86 unlock_page(page); 84 unlock_page(page);
87 return retval; 85 return retval;
88} 86}
@@ -161,41 +159,32 @@ static void v9fs_invalidate_page(struct page *page, unsigned int offset,
161 159
162static int v9fs_vfs_writepage_locked(struct page *page) 160static int v9fs_vfs_writepage_locked(struct page *page)
163{ 161{
164 char *buffer;
165 int retval, len;
166 loff_t offset, size;
167 mm_segment_t old_fs;
168 struct v9fs_inode *v9inode;
169 struct inode *inode = page->mapping->host; 162 struct inode *inode = page->mapping->host;
163 struct v9fs_inode *v9inode = V9FS_I(inode);
164 loff_t size = i_size_read(inode);
165 struct iov_iter from;
166 struct bio_vec bvec;
167 int err, len;
170 168
171 v9inode = V9FS_I(inode);
172 size = i_size_read(inode);
173 if (page->index == size >> PAGE_CACHE_SHIFT) 169 if (page->index == size >> PAGE_CACHE_SHIFT)
174 len = size & ~PAGE_CACHE_MASK; 170 len = size & ~PAGE_CACHE_MASK;
175 else 171 else
176 len = PAGE_CACHE_SIZE; 172 len = PAGE_CACHE_SIZE;
177 173
178 set_page_writeback(page); 174 bvec.bv_page = page;
179 175 bvec.bv_offset = 0;
180 buffer = kmap(page); 176 bvec.bv_len = len;
181 offset = page_offset(page); 177 iov_iter_bvec(&from, ITER_BVEC | WRITE, &bvec, 1, len);
182 178
183 old_fs = get_fs();
184 set_fs(get_ds());
185 /* We should have writeback_fid always set */ 179 /* We should have writeback_fid always set */
186 BUG_ON(!v9inode->writeback_fid); 180 BUG_ON(!v9inode->writeback_fid);
187 181
188 retval = v9fs_file_write_internal(inode, 182 set_page_writeback(page);
189 v9inode->writeback_fid, 183
190 (__force const char __user *)buffer, 184 p9_client_write(v9inode->writeback_fid, page_offset(page), &from, &err);
191 len, &offset, 0);
192 if (retval > 0)
193 retval = 0;
194 185
195 set_fs(old_fs);
196 kunmap(page);
197 end_page_writeback(page); 186 end_page_writeback(page);
198 return retval; 187 return err;
199} 188}
200 189
201static int v9fs_vfs_writepage(struct page *page, struct writeback_control *wbc) 190static int v9fs_vfs_writepage(struct page *page, struct writeback_control *wbc)
@@ -261,16 +250,21 @@ static int v9fs_launder_page(struct page *page)
261static ssize_t 250static ssize_t
262v9fs_direct_IO(int rw, struct kiocb *iocb, struct iov_iter *iter, loff_t pos) 251v9fs_direct_IO(int rw, struct kiocb *iocb, struct iov_iter *iter, loff_t pos)
263{ 252{
264 /* 253 struct file *file = iocb->ki_filp;
265 * FIXME 254 ssize_t n;
266 * Now that we do caching with cache mode enabled, We need 255 int err = 0;
267 * to support direct IO 256 if (rw & WRITE) {
268 */ 257 n = p9_client_write(file->private_data, pos, iter, &err);
269 p9_debug(P9_DEBUG_VFS, "v9fs_direct_IO: v9fs_direct_IO (%pD) off/no(%lld/%lu) EINVAL\n", 258 if (n) {
270 iocb->ki_filp, 259 struct inode *inode = file_inode(file);
271 (long long)pos, iter->nr_segs); 260 loff_t i_size = i_size_read(inode);
272 261 if (pos + n > i_size)
273 return -EINVAL; 262 inode_add_bytes(inode, pos + n - i_size);
263 }
264 } else {
265 n = p9_client_read(file->private_data, pos, iter, &err);
266 }
267 return n ? n : err;
274} 268}
275 269
276static int v9fs_write_begin(struct file *filp, struct address_space *mapping, 270static int v9fs_write_begin(struct file *filp, struct address_space *mapping,
diff --git a/fs/9p/vfs_dir.c b/fs/9p/vfs_dir.c
index 4f1151088ebe..76c3b1ab6361 100644
--- a/fs/9p/vfs_dir.c
+++ b/fs/9p/vfs_dir.c
@@ -33,6 +33,7 @@
33#include <linux/inet.h> 33#include <linux/inet.h>
34#include <linux/idr.h> 34#include <linux/idr.h>
35#include <linux/slab.h> 35#include <linux/slab.h>
36#include <linux/uio.h>
36#include <net/9p/9p.h> 37#include <net/9p/9p.h>
37#include <net/9p/client.h> 38#include <net/9p/client.h>
38 39
@@ -115,6 +116,7 @@ static int v9fs_dir_readdir(struct file *file, struct dir_context *ctx)
115 int buflen; 116 int buflen;
116 int reclen = 0; 117 int reclen = 0;
117 struct p9_rdir *rdir; 118 struct p9_rdir *rdir;
119 struct kvec kvec;
118 120
119 p9_debug(P9_DEBUG_VFS, "name %pD\n", file); 121 p9_debug(P9_DEBUG_VFS, "name %pD\n", file);
120 fid = file->private_data; 122 fid = file->private_data;
@@ -124,16 +126,21 @@ static int v9fs_dir_readdir(struct file *file, struct dir_context *ctx)
124 rdir = v9fs_alloc_rdir_buf(file, buflen); 126 rdir = v9fs_alloc_rdir_buf(file, buflen);
125 if (!rdir) 127 if (!rdir)
126 return -ENOMEM; 128 return -ENOMEM;
129 kvec.iov_base = rdir->buf;
130 kvec.iov_len = buflen;
127 131
128 while (1) { 132 while (1) {
129 if (rdir->tail == rdir->head) { 133 if (rdir->tail == rdir->head) {
130 err = v9fs_file_readn(file, rdir->buf, NULL, 134 struct iov_iter to;
131 buflen, ctx->pos); 135 int n;
132 if (err <= 0) 136 iov_iter_kvec(&to, READ | ITER_KVEC, &kvec, 1, buflen);
137 n = p9_client_read(file->private_data, ctx->pos, &to,
138 &err);
139 if (err)
133 return err; 140 return err;
134 141
135 rdir->head = 0; 142 rdir->head = 0;
136 rdir->tail = err; 143 rdir->tail = n;
137 } 144 }
138 while (rdir->head < rdir->tail) { 145 while (rdir->head < rdir->tail) {
139 p9stat_init(&st); 146 p9stat_init(&st);
diff --git a/fs/9p/vfs_file.c b/fs/9p/vfs_file.c
index b40133796b87..d7fcb775311e 100644
--- a/fs/9p/vfs_file.c
+++ b/fs/9p/vfs_file.c
@@ -36,6 +36,8 @@
36#include <linux/utsname.h> 36#include <linux/utsname.h>
37#include <asm/uaccess.h> 37#include <asm/uaccess.h>
38#include <linux/idr.h> 38#include <linux/idr.h>
39#include <linux/uio.h>
40#include <linux/slab.h>
39#include <net/9p/9p.h> 41#include <net/9p/9p.h>
40#include <net/9p/client.h> 42#include <net/9p/client.h>
41 43
@@ -285,6 +287,7 @@ static int v9fs_file_getlock(struct file *filp, struct file_lock *fl)
285 fl->fl_end = glock.start + glock.length - 1; 287 fl->fl_end = glock.start + glock.length - 1;
286 fl->fl_pid = glock.proc_id; 288 fl->fl_pid = glock.proc_id;
287 } 289 }
290 kfree(glock.client_id);
288 return res; 291 return res;
289} 292}
290 293
@@ -364,63 +367,6 @@ out_err:
364} 367}
365 368
366/** 369/**
367 * v9fs_fid_readn - read from a fid
368 * @fid: fid to read
369 * @data: data buffer to read data into
370 * @udata: user data buffer to read data into
371 * @count: size of buffer
372 * @offset: offset at which to read data
373 *
374 */
375ssize_t
376v9fs_fid_readn(struct p9_fid *fid, char *data, char __user *udata, u32 count,
377 u64 offset)
378{
379 int n, total, size;
380
381 p9_debug(P9_DEBUG_VFS, "fid %d offset %llu count %d\n",
382 fid->fid, (long long unsigned)offset, count);
383 n = 0;
384 total = 0;
385 size = fid->iounit ? fid->iounit : fid->clnt->msize - P9_IOHDRSZ;
386 do {
387 n = p9_client_read(fid, data, udata, offset, count);
388 if (n <= 0)
389 break;
390
391 if (data)
392 data += n;
393 if (udata)
394 udata += n;
395
396 offset += n;
397 count -= n;
398 total += n;
399 } while (count > 0 && n == size);
400
401 if (n < 0)
402 total = n;
403
404 return total;
405}
406
407/**
408 * v9fs_file_readn - read from a file
409 * @filp: file pointer to read
410 * @data: data buffer to read data into
411 * @udata: user data buffer to read data into
412 * @count: size of buffer
413 * @offset: offset at which to read data
414 *
415 */
416ssize_t
417v9fs_file_readn(struct file *filp, char *data, char __user *udata, u32 count,
418 u64 offset)
419{
420 return v9fs_fid_readn(filp->private_data, data, udata, count, offset);
421}
422
423/**
424 * v9fs_file_read - read from a file 370 * v9fs_file_read - read from a file
425 * @filp: file pointer to read 371 * @filp: file pointer to read
426 * @udata: user data buffer to read data into 372 * @udata: user data buffer to read data into
@@ -430,69 +376,22 @@ v9fs_file_readn(struct file *filp, char *data, char __user *udata, u32 count,
430 */ 376 */
431 377
432static ssize_t 378static ssize_t
433v9fs_file_read(struct file *filp, char __user *udata, size_t count, 379v9fs_file_read_iter(struct kiocb *iocb, struct iov_iter *to)
434 loff_t * offset)
435{ 380{
436 int ret; 381 struct p9_fid *fid = iocb->ki_filp->private_data;
437 struct p9_fid *fid; 382 int ret, err;
438 size_t size;
439 383
440 p9_debug(P9_DEBUG_VFS, "count %zu offset %lld\n", count, *offset); 384 p9_debug(P9_DEBUG_VFS, "count %zu offset %lld\n",
441 fid = filp->private_data; 385 iov_iter_count(to), iocb->ki_pos);
442 386
443 size = fid->iounit ? fid->iounit : fid->clnt->msize - P9_IOHDRSZ; 387 ret = p9_client_read(fid, iocb->ki_pos, to, &err);
444 if (count > size) 388 if (!ret)
445 ret = v9fs_file_readn(filp, NULL, udata, count, *offset); 389 return err;
446 else
447 ret = p9_client_read(fid, NULL, udata, *offset, count);
448
449 if (ret > 0)
450 *offset += ret;
451 390
391 iocb->ki_pos += ret;
452 return ret; 392 return ret;
453} 393}
454 394
455ssize_t
456v9fs_file_write_internal(struct inode *inode, struct p9_fid *fid,
457 const char __user *data, size_t count,
458 loff_t *offset, int invalidate)
459{
460 int n;
461 loff_t i_size;
462 size_t total = 0;
463 loff_t origin = *offset;
464 unsigned long pg_start, pg_end;
465
466 p9_debug(P9_DEBUG_VFS, "data %p count %d offset %x\n",
467 data, (int)count, (int)*offset);
468
469 do {
470 n = p9_client_write(fid, NULL, data+total, origin+total, count);
471 if (n <= 0)
472 break;
473 count -= n;
474 total += n;
475 } while (count > 0);
476
477 if (invalidate && (total > 0)) {
478 pg_start = origin >> PAGE_CACHE_SHIFT;
479 pg_end = (origin + total - 1) >> PAGE_CACHE_SHIFT;
480 if (inode->i_mapping && inode->i_mapping->nrpages)
481 invalidate_inode_pages2_range(inode->i_mapping,
482 pg_start, pg_end);
483 *offset += total;
484 i_size = i_size_read(inode);
485 if (*offset > i_size) {
486 inode_add_bytes(inode, *offset - i_size);
487 i_size_write(inode, *offset);
488 }
489 }
490 if (n < 0)
491 return n;
492
493 return total;
494}
495
496/** 395/**
497 * v9fs_file_write - write to a file 396 * v9fs_file_write - write to a file
498 * @filp: file pointer to write 397 * @filp: file pointer to write
@@ -502,35 +401,45 @@ v9fs_file_write_internal(struct inode *inode, struct p9_fid *fid,
502 * 401 *
503 */ 402 */
504static ssize_t 403static ssize_t
505v9fs_file_write(struct file *filp, const char __user * data, 404v9fs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
506 size_t count, loff_t *offset)
507{ 405{
406 struct file *file = iocb->ki_filp;
508 ssize_t retval = 0; 407 ssize_t retval = 0;
509 loff_t origin = *offset; 408 loff_t origin = iocb->ki_pos;
409 size_t count = iov_iter_count(from);
410 int err = 0;
510 411
511 412 retval = generic_write_checks(file, &origin, &count, 0);
512 retval = generic_write_checks(filp, &origin, &count, 0);
513 if (retval) 413 if (retval)
514 goto out; 414 return retval;
415
416 iov_iter_truncate(from, count);
515 417
516 retval = -EINVAL;
517 if ((ssize_t) count < 0)
518 goto out;
519 retval = 0;
520 if (!count) 418 if (!count)
521 goto out; 419 return 0;
522 420
523 retval = v9fs_file_write_internal(file_inode(filp), 421 retval = p9_client_write(file->private_data, origin, from, &err);
524 filp->private_data, 422 if (retval > 0) {
525 data, count, &origin, 1); 423 struct inode *inode = file_inode(file);
526 /* update offset on successful write */ 424 loff_t i_size;
527 if (retval > 0) 425 unsigned long pg_start, pg_end;
528 *offset = origin; 426 pg_start = origin >> PAGE_CACHE_SHIFT;
529out: 427 pg_end = (origin + retval - 1) >> PAGE_CACHE_SHIFT;
530 return retval; 428 if (inode->i_mapping && inode->i_mapping->nrpages)
429 invalidate_inode_pages2_range(inode->i_mapping,
430 pg_start, pg_end);
431 origin += retval;
432 i_size = i_size_read(inode);
433 iocb->ki_pos = origin;
434 if (origin > i_size) {
435 inode_add_bytes(inode, origin - i_size);
436 i_size_write(inode, origin);
437 }
438 return retval;
439 }
440 return err;
531} 441}
532 442
533
534static int v9fs_file_fsync(struct file *filp, loff_t start, loff_t end, 443static int v9fs_file_fsync(struct file *filp, loff_t start, loff_t end,
535 int datasync) 444 int datasync)
536{ 445{
@@ -657,44 +566,6 @@ out_unlock:
657 return VM_FAULT_NOPAGE; 566 return VM_FAULT_NOPAGE;
658} 567}
659 568
660static ssize_t
661v9fs_direct_read(struct file *filp, char __user *udata, size_t count,
662 loff_t *offsetp)
663{
664 loff_t size, offset;
665 struct inode *inode;
666 struct address_space *mapping;
667
668 offset = *offsetp;
669 mapping = filp->f_mapping;
670 inode = mapping->host;
671 if (!count)
672 return 0;
673 size = i_size_read(inode);
674 if (offset < size)
675 filemap_write_and_wait_range(mapping, offset,
676 offset + count - 1);
677
678 return v9fs_file_read(filp, udata, count, offsetp);
679}
680
681/**
682 * v9fs_cached_file_read - read from a file
683 * @filp: file pointer to read
684 * @data: user data buffer to read data into
685 * @count: size of buffer
686 * @offset: offset at which to read data
687 *
688 */
689static ssize_t
690v9fs_cached_file_read(struct file *filp, char __user *data, size_t count,
691 loff_t *offset)
692{
693 if (filp->f_flags & O_DIRECT)
694 return v9fs_direct_read(filp, data, count, offset);
695 return new_sync_read(filp, data, count, offset);
696}
697
698/** 569/**
699 * v9fs_mmap_file_read - read from a file 570 * v9fs_mmap_file_read - read from a file
700 * @filp: file pointer to read 571 * @filp: file pointer to read
@@ -704,84 +575,12 @@ v9fs_cached_file_read(struct file *filp, char __user *data, size_t count,
704 * 575 *
705 */ 576 */
706static ssize_t 577static ssize_t
707v9fs_mmap_file_read(struct file *filp, char __user *data, size_t count, 578v9fs_mmap_file_read_iter(struct kiocb *iocb, struct iov_iter *to)
708 loff_t *offset)
709{ 579{
710 /* TODO: Check if there are dirty pages */ 580 /* TODO: Check if there are dirty pages */
711 return v9fs_file_read(filp, data, count, offset); 581 return v9fs_file_read_iter(iocb, to);
712} 582}
713 583
714static ssize_t
715v9fs_direct_write(struct file *filp, const char __user * data,
716 size_t count, loff_t *offsetp)
717{
718 loff_t offset;
719 ssize_t retval;
720 struct inode *inode;
721 struct address_space *mapping;
722
723 offset = *offsetp;
724 mapping = filp->f_mapping;
725 inode = mapping->host;
726 if (!count)
727 return 0;
728
729 mutex_lock(&inode->i_mutex);
730 retval = filemap_write_and_wait_range(mapping, offset,
731 offset + count - 1);
732 if (retval)
733 goto err_out;
734 /*
735 * After a write we want buffered reads to be sure to go to disk to get
736 * the new data. We invalidate clean cached page from the region we're
737 * about to write. We do this *before* the write so that if we fail
738 * here we fall back to buffered write
739 */
740 if (mapping->nrpages) {
741 pgoff_t pg_start = offset >> PAGE_CACHE_SHIFT;
742 pgoff_t pg_end = (offset + count - 1) >> PAGE_CACHE_SHIFT;
743
744 retval = invalidate_inode_pages2_range(mapping,
745 pg_start, pg_end);
746 /*
747 * If a page can not be invalidated, fall back
748 * to buffered write.
749 */
750 if (retval) {
751 if (retval == -EBUSY)
752 goto buff_write;
753 goto err_out;
754 }
755 }
756 retval = v9fs_file_write(filp, data, count, offsetp);
757err_out:
758 mutex_unlock(&inode->i_mutex);
759 return retval;
760
761buff_write:
762 mutex_unlock(&inode->i_mutex);
763 return new_sync_write(filp, data, count, offsetp);
764}
765
766/**
767 * v9fs_cached_file_write - write to a file
768 * @filp: file pointer to write
769 * @data: data buffer to write data from
770 * @count: size of buffer
771 * @offset: offset at which to write data
772 *
773 */
774static ssize_t
775v9fs_cached_file_write(struct file *filp, const char __user * data,
776 size_t count, loff_t *offset)
777{
778
779 if (filp->f_flags & O_DIRECT)
780 return v9fs_direct_write(filp, data, count, offset);
781 return new_sync_write(filp, data, count, offset);
782}
783
784
785/** 584/**
786 * v9fs_mmap_file_write - write to a file 585 * v9fs_mmap_file_write - write to a file
787 * @filp: file pointer to write 586 * @filp: file pointer to write
@@ -791,14 +590,13 @@ v9fs_cached_file_write(struct file *filp, const char __user * data,
791 * 590 *
792 */ 591 */
793static ssize_t 592static ssize_t
794v9fs_mmap_file_write(struct file *filp, const char __user *data, 593v9fs_mmap_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
795 size_t count, loff_t *offset)
796{ 594{
797 /* 595 /*
798 * TODO: invalidate mmaps on filp's inode between 596 * TODO: invalidate mmaps on filp's inode between
799 * offset and offset+count 597 * offset and offset+count
800 */ 598 */
801 return v9fs_file_write(filp, data, count, offset); 599 return v9fs_file_write_iter(iocb, from);
802} 600}
803 601
804static void v9fs_mmap_vm_close(struct vm_area_struct *vma) 602static void v9fs_mmap_vm_close(struct vm_area_struct *vma)
@@ -843,8 +641,6 @@ static const struct vm_operations_struct v9fs_mmap_file_vm_ops = {
843 641
844const struct file_operations v9fs_cached_file_operations = { 642const struct file_operations v9fs_cached_file_operations = {
845 .llseek = generic_file_llseek, 643 .llseek = generic_file_llseek,
846 .read = v9fs_cached_file_read,
847 .write = v9fs_cached_file_write,
848 .read_iter = generic_file_read_iter, 644 .read_iter = generic_file_read_iter,
849 .write_iter = generic_file_write_iter, 645 .write_iter = generic_file_write_iter,
850 .open = v9fs_file_open, 646 .open = v9fs_file_open,
@@ -856,8 +652,6 @@ const struct file_operations v9fs_cached_file_operations = {
856 652
857const struct file_operations v9fs_cached_file_operations_dotl = { 653const struct file_operations v9fs_cached_file_operations_dotl = {
858 .llseek = generic_file_llseek, 654 .llseek = generic_file_llseek,
859 .read = v9fs_cached_file_read,
860 .write = v9fs_cached_file_write,
861 .read_iter = generic_file_read_iter, 655 .read_iter = generic_file_read_iter,
862 .write_iter = generic_file_write_iter, 656 .write_iter = generic_file_write_iter,
863 .open = v9fs_file_open, 657 .open = v9fs_file_open,
@@ -870,8 +664,8 @@ const struct file_operations v9fs_cached_file_operations_dotl = {
870 664
871const struct file_operations v9fs_file_operations = { 665const struct file_operations v9fs_file_operations = {
872 .llseek = generic_file_llseek, 666 .llseek = generic_file_llseek,
873 .read = v9fs_file_read, 667 .read_iter = v9fs_file_read_iter,
874 .write = v9fs_file_write, 668 .write_iter = v9fs_file_write_iter,
875 .open = v9fs_file_open, 669 .open = v9fs_file_open,
876 .release = v9fs_dir_release, 670 .release = v9fs_dir_release,
877 .lock = v9fs_file_lock, 671 .lock = v9fs_file_lock,
@@ -881,8 +675,8 @@ const struct file_operations v9fs_file_operations = {
881 675
882const struct file_operations v9fs_file_operations_dotl = { 676const struct file_operations v9fs_file_operations_dotl = {
883 .llseek = generic_file_llseek, 677 .llseek = generic_file_llseek,
884 .read = v9fs_file_read, 678 .read_iter = v9fs_file_read_iter,
885 .write = v9fs_file_write, 679 .write_iter = v9fs_file_write_iter,
886 .open = v9fs_file_open, 680 .open = v9fs_file_open,
887 .release = v9fs_dir_release, 681 .release = v9fs_dir_release,
888 .lock = v9fs_file_lock_dotl, 682 .lock = v9fs_file_lock_dotl,
@@ -893,8 +687,8 @@ const struct file_operations v9fs_file_operations_dotl = {
893 687
894const struct file_operations v9fs_mmap_file_operations = { 688const struct file_operations v9fs_mmap_file_operations = {
895 .llseek = generic_file_llseek, 689 .llseek = generic_file_llseek,
896 .read = v9fs_mmap_file_read, 690 .read_iter = v9fs_mmap_file_read_iter,
897 .write = v9fs_mmap_file_write, 691 .write_iter = v9fs_mmap_file_write_iter,
898 .open = v9fs_file_open, 692 .open = v9fs_file_open,
899 .release = v9fs_dir_release, 693 .release = v9fs_dir_release,
900 .lock = v9fs_file_lock, 694 .lock = v9fs_file_lock,
@@ -904,8 +698,8 @@ const struct file_operations v9fs_mmap_file_operations = {
904 698
905const struct file_operations v9fs_mmap_file_operations_dotl = { 699const struct file_operations v9fs_mmap_file_operations_dotl = {
906 .llseek = generic_file_llseek, 700 .llseek = generic_file_llseek,
907 .read = v9fs_mmap_file_read, 701 .read_iter = v9fs_mmap_file_read_iter,
908 .write = v9fs_mmap_file_write, 702 .write_iter = v9fs_mmap_file_write_iter,
909 .open = v9fs_file_open, 703 .open = v9fs_file_open,
910 .release = v9fs_dir_release, 704 .release = v9fs_dir_release,
911 .lock = v9fs_file_lock_dotl, 705 .lock = v9fs_file_lock_dotl,
diff --git a/fs/9p/xattr.c b/fs/9p/xattr.c
index f95e01e058e4..0cf44b6cccd6 100644
--- a/fs/9p/xattr.c
+++ b/fs/9p/xattr.c
@@ -15,6 +15,7 @@
15#include <linux/module.h> 15#include <linux/module.h>
16#include <linux/fs.h> 16#include <linux/fs.h>
17#include <linux/sched.h> 17#include <linux/sched.h>
18#include <linux/uio.h>
18#include <net/9p/9p.h> 19#include <net/9p/9p.h>
19#include <net/9p/client.h> 20#include <net/9p/client.h>
20 21
@@ -25,50 +26,34 @@ ssize_t v9fs_fid_xattr_get(struct p9_fid *fid, const char *name,
25 void *buffer, size_t buffer_size) 26 void *buffer, size_t buffer_size)
26{ 27{
27 ssize_t retval; 28 ssize_t retval;
28 int msize, read_count; 29 u64 attr_size;
29 u64 offset = 0, attr_size;
30 struct p9_fid *attr_fid; 30 struct p9_fid *attr_fid;
31 struct kvec kvec = {.iov_base = buffer, .iov_len = buffer_size};
32 struct iov_iter to;
33 int err;
34
35 iov_iter_kvec(&to, READ | ITER_KVEC, &kvec, 1, buffer_size);
31 36
32 attr_fid = p9_client_xattrwalk(fid, name, &attr_size); 37 attr_fid = p9_client_xattrwalk(fid, name, &attr_size);
33 if (IS_ERR(attr_fid)) { 38 if (IS_ERR(attr_fid)) {
34 retval = PTR_ERR(attr_fid); 39 retval = PTR_ERR(attr_fid);
35 p9_debug(P9_DEBUG_VFS, "p9_client_attrwalk failed %zd\n", 40 p9_debug(P9_DEBUG_VFS, "p9_client_attrwalk failed %zd\n",
36 retval); 41 retval);
37 attr_fid = NULL; 42 return retval;
38 goto error;
39 }
40 if (!buffer_size) {
41 /* request to get the attr_size */
42 retval = attr_size;
43 goto error;
44 } 43 }
45 if (attr_size > buffer_size) { 44 if (attr_size > buffer_size) {
46 retval = -ERANGE; 45 if (!buffer_size) /* request to get the attr_size */
47 goto error; 46 retval = attr_size;
48 }
49 msize = attr_fid->clnt->msize;
50 while (attr_size) {
51 if (attr_size > (msize - P9_IOHDRSZ))
52 read_count = msize - P9_IOHDRSZ;
53 else 47 else
54 read_count = attr_size; 48 retval = -ERANGE;
55 read_count = p9_client_read(attr_fid, ((char *)buffer)+offset, 49 } else {
56 NULL, offset, read_count); 50 iov_iter_truncate(&to, attr_size);
57 if (read_count < 0) { 51 retval = p9_client_read(attr_fid, 0, &to, &err);
58 /* error in xattr read */ 52 if (err)
59 retval = read_count; 53 retval = err;
60 goto error;
61 }
62 offset += read_count;
63 attr_size -= read_count;
64 } 54 }
65 /* Total read xattr bytes */ 55 p9_client_clunk(attr_fid);
66 retval = offset;
67error:
68 if (attr_fid)
69 p9_client_clunk(attr_fid);
70 return retval; 56 return retval;
71
72} 57}
73 58
74 59
@@ -120,8 +105,11 @@ int v9fs_xattr_set(struct dentry *dentry, const char *name,
120int v9fs_fid_xattr_set(struct p9_fid *fid, const char *name, 105int v9fs_fid_xattr_set(struct p9_fid *fid, const char *name,
121 const void *value, size_t value_len, int flags) 106 const void *value, size_t value_len, int flags)
122{ 107{
123 u64 offset = 0; 108 struct kvec kvec = {.iov_base = (void *)value, .iov_len = value_len};
124 int retval, msize, write_count; 109 struct iov_iter from;
110 int retval;
111
112 iov_iter_kvec(&from, WRITE | ITER_KVEC, &kvec, 1, value_len);
125 113
126 p9_debug(P9_DEBUG_VFS, "name = %s value_len = %zu flags = %d\n", 114 p9_debug(P9_DEBUG_VFS, "name = %s value_len = %zu flags = %d\n",
127 name, value_len, flags); 115 name, value_len, flags);
@@ -135,29 +123,11 @@ int v9fs_fid_xattr_set(struct p9_fid *fid, const char *name,
135 * On success fid points to xattr 123 * On success fid points to xattr
136 */ 124 */
137 retval = p9_client_xattrcreate(fid, name, value_len, flags); 125 retval = p9_client_xattrcreate(fid, name, value_len, flags);
138 if (retval < 0) { 126 if (retval < 0)
139 p9_debug(P9_DEBUG_VFS, "p9_client_xattrcreate failed %d\n", 127 p9_debug(P9_DEBUG_VFS, "p9_client_xattrcreate failed %d\n",
140 retval); 128 retval);
141 goto err; 129 else
142 } 130 p9_client_write(fid, 0, &from, &retval);
143 msize = fid->clnt->msize;
144 while (value_len) {
145 if (value_len > (msize - P9_IOHDRSZ))
146 write_count = msize - P9_IOHDRSZ;
147 else
148 write_count = value_len;
149 write_count = p9_client_write(fid, ((char *)value)+offset,
150 NULL, offset, write_count);
151 if (write_count < 0) {
152 /* error in xattr write */
153 retval = write_count;
154 goto err;
155 }
156 offset += write_count;
157 value_len -= write_count;
158 }
159 retval = 0;
160err:
161 p9_client_clunk(fid); 131 p9_client_clunk(fid);
162 return retval; 132 return retval;
163} 133}
diff --git a/fs/adfs/file.c b/fs/adfs/file.c
index 07c9edce5aa7..46c0d5671cd5 100644
--- a/fs/adfs/file.c
+++ b/fs/adfs/file.c
@@ -23,11 +23,9 @@
23 23
24const struct file_operations adfs_file_operations = { 24const struct file_operations adfs_file_operations = {
25 .llseek = generic_file_llseek, 25 .llseek = generic_file_llseek,
26 .read = new_sync_read,
27 .read_iter = generic_file_read_iter, 26 .read_iter = generic_file_read_iter,
28 .mmap = generic_file_mmap, 27 .mmap = generic_file_mmap,
29 .fsync = generic_file_fsync, 28 .fsync = generic_file_fsync,
30 .write = new_sync_write,
31 .write_iter = generic_file_write_iter, 29 .write_iter = generic_file_write_iter,
32 .splice_read = generic_file_splice_read, 30 .splice_read = generic_file_splice_read,
33}; 31};
diff --git a/fs/affs/file.c b/fs/affs/file.c
index 3aa7eb66547e..7c1a3d4c19c2 100644
--- a/fs/affs/file.c
+++ b/fs/affs/file.c
@@ -969,9 +969,7 @@ int affs_file_fsync(struct file *filp, loff_t start, loff_t end, int datasync)
969} 969}
970const struct file_operations affs_file_operations = { 970const struct file_operations affs_file_operations = {
971 .llseek = generic_file_llseek, 971 .llseek = generic_file_llseek,
972 .read = new_sync_read,
973 .read_iter = generic_file_read_iter, 972 .read_iter = generic_file_read_iter,
974 .write = new_sync_write,
975 .write_iter = generic_file_write_iter, 973 .write_iter = generic_file_write_iter,
976 .mmap = generic_file_mmap, 974 .mmap = generic_file_mmap,
977 .open = affs_file_open, 975 .open = affs_file_open,
diff --git a/fs/afs/file.c b/fs/afs/file.c
index 932ce07948b3..999bc3caec92 100644
--- a/fs/afs/file.c
+++ b/fs/afs/file.c
@@ -31,8 +31,6 @@ const struct file_operations afs_file_operations = {
31 .open = afs_open, 31 .open = afs_open,
32 .release = afs_release, 32 .release = afs_release,
33 .llseek = generic_file_llseek, 33 .llseek = generic_file_llseek,
34 .read = new_sync_read,
35 .write = new_sync_write,
36 .read_iter = generic_file_read_iter, 34 .read_iter = generic_file_read_iter,
37 .write_iter = afs_file_write, 35 .write_iter = afs_file_write,
38 .mmap = generic_file_readonly_mmap, 36 .mmap = generic_file_readonly_mmap,
diff --git a/fs/aio.c b/fs/aio.c
index 1ab60010cf6c..5785c4b58fea 100644
--- a/fs/aio.c
+++ b/fs/aio.c
@@ -692,8 +692,7 @@ static struct kioctx *ioctx_alloc(unsigned nr_events)
692 nr_events *= 2; 692 nr_events *= 2;
693 693
694 /* Prevent overflows */ 694 /* Prevent overflows */
695 if ((nr_events > (0x10000000U / sizeof(struct io_event))) || 695 if (nr_events > (0x10000000U / sizeof(struct io_event))) {
696 (nr_events > (0x10000000U / sizeof(struct kiocb)))) {
697 pr_debug("ENOMEM: nr_events too high\n"); 696 pr_debug("ENOMEM: nr_events too high\n");
698 return ERR_PTR(-EINVAL); 697 return ERR_PTR(-EINVAL);
699 } 698 }
@@ -1356,8 +1355,6 @@ SYSCALL_DEFINE1(io_destroy, aio_context_t, ctx)
1356 return -EINVAL; 1355 return -EINVAL;
1357} 1356}
1358 1357
1359typedef ssize_t (aio_rw_op)(struct kiocb *, const struct iovec *,
1360 unsigned long, loff_t);
1361typedef ssize_t (rw_iter_op)(struct kiocb *, struct iov_iter *); 1358typedef ssize_t (rw_iter_op)(struct kiocb *, struct iov_iter *);
1362 1359
1363static int aio_setup_vectored_rw(int rw, char __user *buf, size_t len, 1360static int aio_setup_vectored_rw(int rw, char __user *buf, size_t len,
@@ -1386,7 +1383,6 @@ static ssize_t aio_run_iocb(struct kiocb *req, unsigned opcode,
1386 ssize_t ret; 1383 ssize_t ret;
1387 int rw; 1384 int rw;
1388 fmode_t mode; 1385 fmode_t mode;
1389 aio_rw_op *rw_op;
1390 rw_iter_op *iter_op; 1386 rw_iter_op *iter_op;
1391 struct iovec inline_vecs[UIO_FASTIOV], *iovec = inline_vecs; 1387 struct iovec inline_vecs[UIO_FASTIOV], *iovec = inline_vecs;
1392 struct iov_iter iter; 1388 struct iov_iter iter;
@@ -1396,7 +1392,6 @@ static ssize_t aio_run_iocb(struct kiocb *req, unsigned opcode,
1396 case IOCB_CMD_PREADV: 1392 case IOCB_CMD_PREADV:
1397 mode = FMODE_READ; 1393 mode = FMODE_READ;
1398 rw = READ; 1394 rw = READ;
1399 rw_op = file->f_op->aio_read;
1400 iter_op = file->f_op->read_iter; 1395 iter_op = file->f_op->read_iter;
1401 goto rw_common; 1396 goto rw_common;
1402 1397
@@ -1404,14 +1399,13 @@ static ssize_t aio_run_iocb(struct kiocb *req, unsigned opcode,
1404 case IOCB_CMD_PWRITEV: 1399 case IOCB_CMD_PWRITEV:
1405 mode = FMODE_WRITE; 1400 mode = FMODE_WRITE;
1406 rw = WRITE; 1401 rw = WRITE;
1407 rw_op = file->f_op->aio_write;
1408 iter_op = file->f_op->write_iter; 1402 iter_op = file->f_op->write_iter;
1409 goto rw_common; 1403 goto rw_common;
1410rw_common: 1404rw_common:
1411 if (unlikely(!(file->f_mode & mode))) 1405 if (unlikely(!(file->f_mode & mode)))
1412 return -EBADF; 1406 return -EBADF;
1413 1407
1414 if (!rw_op && !iter_op) 1408 if (!iter_op)
1415 return -EINVAL; 1409 return -EINVAL;
1416 1410
1417 if (opcode == IOCB_CMD_PREADV || opcode == IOCB_CMD_PWRITEV) 1411 if (opcode == IOCB_CMD_PREADV || opcode == IOCB_CMD_PWRITEV)
@@ -1431,21 +1425,10 @@ rw_common:
1431 1425
1432 len = ret; 1426 len = ret;
1433 1427
1434 /* XXX: move/kill - rw_verify_area()? */
1435 /* This matches the pread()/pwrite() logic */
1436 if (req->ki_pos < 0) {
1437 ret = -EINVAL;
1438 break;
1439 }
1440
1441 if (rw == WRITE) 1428 if (rw == WRITE)
1442 file_start_write(file); 1429 file_start_write(file);
1443 1430
1444 if (iter_op) { 1431 ret = iter_op(req, &iter);
1445 ret = iter_op(req, &iter);
1446 } else {
1447 ret = rw_op(req, iter.iov, iter.nr_segs, req->ki_pos);
1448 }
1449 1432
1450 if (rw == WRITE) 1433 if (rw == WRITE)
1451 file_end_write(file); 1434 file_end_write(file);
diff --git a/fs/autofs4/autofs_i.h b/fs/autofs4/autofs_i.h
index 8e98cf954bab..d10e619632ab 100644
--- a/fs/autofs4/autofs_i.h
+++ b/fs/autofs4/autofs_i.h
@@ -213,7 +213,7 @@ void autofs4_clean_ino(struct autofs_info *);
213 213
214static inline int autofs_prepare_pipe(struct file *pipe) 214static inline int autofs_prepare_pipe(struct file *pipe)
215{ 215{
216 if (!pipe->f_op->write) 216 if (!(pipe->f_mode & FMODE_CAN_WRITE))
217 return -EINVAL; 217 return -EINVAL;
218 if (!S_ISFIFO(file_inode(pipe)->i_mode)) 218 if (!S_ISFIFO(file_inode(pipe)->i_mode))
219 return -EINVAL; 219 return -EINVAL;
diff --git a/fs/autofs4/waitq.c b/fs/autofs4/waitq.c
index 116fd38ee472..2ad05ab93db8 100644
--- a/fs/autofs4/waitq.c
+++ b/fs/autofs4/waitq.c
@@ -70,7 +70,7 @@ static int autofs4_write(struct autofs_sb_info *sbi,
70 70
71 mutex_lock(&sbi->pipe_mutex); 71 mutex_lock(&sbi->pipe_mutex);
72 while (bytes && 72 while (bytes &&
73 (wr = file->f_op->write(file,data,bytes,&file->f_pos)) > 0) { 73 (wr = __vfs_write(file,data,bytes,&file->f_pos)) > 0) {
74 data += wr; 74 data += wr;
75 bytes -= wr; 75 bytes -= wr;
76 } 76 }
diff --git a/fs/bfs/file.c b/fs/bfs/file.c
index e7f88ace1a25..97f1b5160155 100644
--- a/fs/bfs/file.c
+++ b/fs/bfs/file.c
@@ -23,9 +23,7 @@
23 23
24const struct file_operations bfs_file_operations = { 24const struct file_operations bfs_file_operations = {
25 .llseek = generic_file_llseek, 25 .llseek = generic_file_llseek,
26 .read = new_sync_read,
27 .read_iter = generic_file_read_iter, 26 .read_iter = generic_file_read_iter,
28 .write = new_sync_write,
29 .write_iter = generic_file_write_iter, 27 .write_iter = generic_file_write_iter,
30 .mmap = generic_file_mmap, 28 .mmap = generic_file_mmap,
31 .splice_read = generic_file_splice_read, 29 .splice_read = generic_file_splice_read,
diff --git a/fs/block_dev.c b/fs/block_dev.c
index 2e522aed6584..b5e87896f517 100644
--- a/fs/block_dev.c
+++ b/fs/block_dev.c
@@ -1659,8 +1659,6 @@ const struct file_operations def_blk_fops = {
1659 .open = blkdev_open, 1659 .open = blkdev_open,
1660 .release = blkdev_close, 1660 .release = blkdev_close,
1661 .llseek = block_llseek, 1661 .llseek = block_llseek,
1662 .read = new_sync_read,
1663 .write = new_sync_write,
1664 .read_iter = blkdev_read_iter, 1662 .read_iter = blkdev_read_iter,
1665 .write_iter = blkdev_write_iter, 1663 .write_iter = blkdev_write_iter,
1666 .mmap = generic_file_mmap, 1664 .mmap = generic_file_mmap,
diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index aee18f84e315..cdc801c85105 100644
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -2806,8 +2806,6 @@ out:
2806 2806
2807const struct file_operations btrfs_file_operations = { 2807const struct file_operations btrfs_file_operations = {
2808 .llseek = btrfs_file_llseek, 2808 .llseek = btrfs_file_llseek,
2809 .read = new_sync_read,
2810 .write = new_sync_write,
2811 .read_iter = generic_file_read_iter, 2809 .read_iter = generic_file_read_iter,
2812 .splice_read = generic_file_splice_read, 2810 .splice_read = generic_file_splice_read,
2813 .write_iter = btrfs_file_write_iter, 2811 .write_iter = btrfs_file_write_iter,
diff --git a/fs/ceph/file.c b/fs/ceph/file.c
index 139f2fea91a0..56237ea5fc22 100644
--- a/fs/ceph/file.c
+++ b/fs/ceph/file.c
@@ -1331,8 +1331,6 @@ const struct file_operations ceph_file_fops = {
1331 .open = ceph_open, 1331 .open = ceph_open,
1332 .release = ceph_release, 1332 .release = ceph_release,
1333 .llseek = ceph_llseek, 1333 .llseek = ceph_llseek,
1334 .read = new_sync_read,
1335 .write = new_sync_write,
1336 .read_iter = ceph_read_iter, 1334 .read_iter = ceph_read_iter,
1337 .write_iter = ceph_write_iter, 1335 .write_iter = ceph_write_iter,
1338 .mmap = ceph_mmap, 1336 .mmap = ceph_mmap,
diff --git a/fs/cifs/cifsfs.c b/fs/cifs/cifsfs.c
index d72fe37f5420..eaab4b2a0595 100644
--- a/fs/cifs/cifsfs.c
+++ b/fs/cifs/cifsfs.c
@@ -906,8 +906,6 @@ const struct inode_operations cifs_symlink_inode_ops = {
906}; 906};
907 907
908const struct file_operations cifs_file_ops = { 908const struct file_operations cifs_file_ops = {
909 .read = new_sync_read,
910 .write = new_sync_write,
911 .read_iter = cifs_loose_read_iter, 909 .read_iter = cifs_loose_read_iter,
912 .write_iter = cifs_file_write_iter, 910 .write_iter = cifs_file_write_iter,
913 .open = cifs_open, 911 .open = cifs_open,
@@ -926,8 +924,6 @@ const struct file_operations cifs_file_ops = {
926}; 924};
927 925
928const struct file_operations cifs_file_strict_ops = { 926const struct file_operations cifs_file_strict_ops = {
929 .read = new_sync_read,
930 .write = new_sync_write,
931 .read_iter = cifs_strict_readv, 927 .read_iter = cifs_strict_readv,
932 .write_iter = cifs_strict_writev, 928 .write_iter = cifs_strict_writev,
933 .open = cifs_open, 929 .open = cifs_open,
@@ -947,8 +943,6 @@ const struct file_operations cifs_file_strict_ops = {
947 943
948const struct file_operations cifs_file_direct_ops = { 944const struct file_operations cifs_file_direct_ops = {
949 /* BB reevaluate whether they can be done with directio, no cache */ 945 /* BB reevaluate whether they can be done with directio, no cache */
950 .read = new_sync_read,
951 .write = new_sync_write,
952 .read_iter = cifs_user_readv, 946 .read_iter = cifs_user_readv,
953 .write_iter = cifs_user_writev, 947 .write_iter = cifs_user_writev,
954 .open = cifs_open, 948 .open = cifs_open,
@@ -967,8 +961,6 @@ const struct file_operations cifs_file_direct_ops = {
967}; 961};
968 962
969const struct file_operations cifs_file_nobrl_ops = { 963const struct file_operations cifs_file_nobrl_ops = {
970 .read = new_sync_read,
971 .write = new_sync_write,
972 .read_iter = cifs_loose_read_iter, 964 .read_iter = cifs_loose_read_iter,
973 .write_iter = cifs_file_write_iter, 965 .write_iter = cifs_file_write_iter,
974 .open = cifs_open, 966 .open = cifs_open,
@@ -986,8 +978,6 @@ const struct file_operations cifs_file_nobrl_ops = {
986}; 978};
987 979
988const struct file_operations cifs_file_strict_nobrl_ops = { 980const struct file_operations cifs_file_strict_nobrl_ops = {
989 .read = new_sync_read,
990 .write = new_sync_write,
991 .read_iter = cifs_strict_readv, 981 .read_iter = cifs_strict_readv,
992 .write_iter = cifs_strict_writev, 982 .write_iter = cifs_strict_writev,
993 .open = cifs_open, 983 .open = cifs_open,
@@ -1006,8 +996,6 @@ const struct file_operations cifs_file_strict_nobrl_ops = {
1006 996
1007const struct file_operations cifs_file_direct_nobrl_ops = { 997const struct file_operations cifs_file_direct_nobrl_ops = {
1008 /* BB reevaluate whether they can be done with directio, no cache */ 998 /* BB reevaluate whether they can be done with directio, no cache */
1009 .read = new_sync_read,
1010 .write = new_sync_write,
1011 .read_iter = cifs_user_readv, 999 .read_iter = cifs_user_readv,
1012 .write_iter = cifs_user_writev, 1000 .write_iter = cifs_user_writev,
1013 .open = cifs_open, 1001 .open = cifs_open,
diff --git a/fs/coda/file.c b/fs/coda/file.c
index d244d743a232..1da3805f3ddc 100644
--- a/fs/coda/file.c
+++ b/fs/coda/file.c
@@ -27,19 +27,14 @@
27#include "coda_int.h" 27#include "coda_int.h"
28 28
29static ssize_t 29static ssize_t
30coda_file_read(struct file *coda_file, char __user *buf, size_t count, loff_t *ppos) 30coda_file_read_iter(struct kiocb *iocb, struct iov_iter *to)
31{ 31{
32 struct coda_file_info *cfi; 32 struct file *coda_file = iocb->ki_filp;
33 struct file *host_file; 33 struct coda_file_info *cfi = CODA_FTOC(coda_file);
34 34
35 cfi = CODA_FTOC(coda_file);
36 BUG_ON(!cfi || cfi->cfi_magic != CODA_MAGIC); 35 BUG_ON(!cfi || cfi->cfi_magic != CODA_MAGIC);
37 host_file = cfi->cfi_container;
38 36
39 if (!host_file->f_op->read) 37 return vfs_iter_read(cfi->cfi_container, to, &iocb->ki_pos);
40 return -EINVAL;
41
42 return host_file->f_op->read(host_file, buf, count, ppos);
43} 38}
44 39
45static ssize_t 40static ssize_t
@@ -64,32 +59,25 @@ coda_file_splice_read(struct file *coda_file, loff_t *ppos,
64} 59}
65 60
66static ssize_t 61static ssize_t
67coda_file_write(struct file *coda_file, const char __user *buf, size_t count, loff_t *ppos) 62coda_file_write_iter(struct kiocb *iocb, struct iov_iter *to)
68{ 63{
69 struct inode *host_inode, *coda_inode = file_inode(coda_file); 64 struct file *coda_file = iocb->ki_filp;
70 struct coda_file_info *cfi; 65 struct inode *coda_inode = file_inode(coda_file);
66 struct coda_file_info *cfi = CODA_FTOC(coda_file);
71 struct file *host_file; 67 struct file *host_file;
72 ssize_t ret; 68 ssize_t ret;
73 69
74 cfi = CODA_FTOC(coda_file);
75 BUG_ON(!cfi || cfi->cfi_magic != CODA_MAGIC); 70 BUG_ON(!cfi || cfi->cfi_magic != CODA_MAGIC);
76 host_file = cfi->cfi_container;
77
78 if (!host_file->f_op->write)
79 return -EINVAL;
80 71
81 host_inode = file_inode(host_file); 72 host_file = cfi->cfi_container;
82 file_start_write(host_file); 73 file_start_write(host_file);
83 mutex_lock(&coda_inode->i_mutex); 74 mutex_lock(&coda_inode->i_mutex);
84 75 ret = vfs_iter_write(cfi->cfi_container, to, &iocb->ki_pos);
85 ret = host_file->f_op->write(host_file, buf, count, ppos); 76 coda_inode->i_size = file_inode(host_file)->i_size;
86
87 coda_inode->i_size = host_inode->i_size;
88 coda_inode->i_blocks = (coda_inode->i_size + 511) >> 9; 77 coda_inode->i_blocks = (coda_inode->i_size + 511) >> 9;
89 coda_inode->i_mtime = coda_inode->i_ctime = CURRENT_TIME_SEC; 78 coda_inode->i_mtime = coda_inode->i_ctime = CURRENT_TIME_SEC;
90 mutex_unlock(&coda_inode->i_mutex); 79 mutex_unlock(&coda_inode->i_mutex);
91 file_end_write(host_file); 80 file_end_write(host_file);
92
93 return ret; 81 return ret;
94} 82}
95 83
@@ -231,8 +219,8 @@ int coda_fsync(struct file *coda_file, loff_t start, loff_t end, int datasync)
231 219
232const struct file_operations coda_file_operations = { 220const struct file_operations coda_file_operations = {
233 .llseek = generic_file_llseek, 221 .llseek = generic_file_llseek,
234 .read = coda_file_read, 222 .read_iter = coda_file_read_iter,
235 .write = coda_file_write, 223 .write_iter = coda_file_write_iter,
236 .mmap = coda_file_mmap, 224 .mmap = coda_file_mmap,
237 .open = coda_open, 225 .open = coda_open,
238 .release = coda_release, 226 .release = coda_release,
diff --git a/fs/coredump.c b/fs/coredump.c
index f319926ddf8c..bbbe139ab280 100644
--- a/fs/coredump.c
+++ b/fs/coredump.c
@@ -657,7 +657,7 @@ void do_coredump(const siginfo_t *siginfo)
657 */ 657 */
658 if (!uid_eq(inode->i_uid, current_fsuid())) 658 if (!uid_eq(inode->i_uid, current_fsuid()))
659 goto close_fail; 659 goto close_fail;
660 if (!cprm.file->f_op->write) 660 if (!(cprm.file->f_mode & FMODE_CAN_WRITE))
661 goto close_fail; 661 goto close_fail;
662 if (do_truncate(cprm.file->f_path.dentry, 0, 0, cprm.file)) 662 if (do_truncate(cprm.file->f_path.dentry, 0, 0, cprm.file))
663 goto close_fail; 663 goto close_fail;
diff --git a/fs/ecryptfs/file.c b/fs/ecryptfs/file.c
index 79675089443d..a65786e26b05 100644
--- a/fs/ecryptfs/file.c
+++ b/fs/ecryptfs/file.c
@@ -358,9 +358,7 @@ const struct file_operations ecryptfs_dir_fops = {
358 358
359const struct file_operations ecryptfs_main_fops = { 359const struct file_operations ecryptfs_main_fops = {
360 .llseek = generic_file_llseek, 360 .llseek = generic_file_llseek,
361 .read = new_sync_read,
362 .read_iter = ecryptfs_read_update_atime, 361 .read_iter = ecryptfs_read_update_atime,
363 .write = new_sync_write,
364 .write_iter = generic_file_write_iter, 362 .write_iter = generic_file_write_iter,
365 .iterate = ecryptfs_readdir, 363 .iterate = ecryptfs_readdir,
366 .unlocked_ioctl = ecryptfs_unlocked_ioctl, 364 .unlocked_ioctl = ecryptfs_unlocked_ioctl,
diff --git a/fs/exofs/file.c b/fs/exofs/file.c
index 1a376b42d305..906de66e8e7e 100644
--- a/fs/exofs/file.c
+++ b/fs/exofs/file.c
@@ -67,8 +67,6 @@ static int exofs_flush(struct file *file, fl_owner_t id)
67 67
68const struct file_operations exofs_file_operations = { 68const struct file_operations exofs_file_operations = {
69 .llseek = generic_file_llseek, 69 .llseek = generic_file_llseek,
70 .read = new_sync_read,
71 .write = new_sync_write,
72 .read_iter = generic_file_read_iter, 70 .read_iter = generic_file_read_iter,
73 .write_iter = generic_file_write_iter, 71 .write_iter = generic_file_write_iter,
74 .mmap = generic_file_mmap, 72 .mmap = generic_file_mmap,
diff --git a/fs/ext2/file.c b/fs/ext2/file.c
index e31701713516..ef04fdb57dbf 100644
--- a/fs/ext2/file.c
+++ b/fs/ext2/file.c
@@ -92,8 +92,6 @@ int ext2_fsync(struct file *file, loff_t start, loff_t end, int datasync)
92 */ 92 */
93const struct file_operations ext2_file_operations = { 93const struct file_operations ext2_file_operations = {
94 .llseek = generic_file_llseek, 94 .llseek = generic_file_llseek,
95 .read = new_sync_read,
96 .write = new_sync_write,
97 .read_iter = generic_file_read_iter, 95 .read_iter = generic_file_read_iter,
98 .write_iter = generic_file_write_iter, 96 .write_iter = generic_file_write_iter,
99 .unlocked_ioctl = ext2_ioctl, 97 .unlocked_ioctl = ext2_ioctl,
@@ -111,8 +109,6 @@ const struct file_operations ext2_file_operations = {
111#ifdef CONFIG_FS_DAX 109#ifdef CONFIG_FS_DAX
112const struct file_operations ext2_dax_file_operations = { 110const struct file_operations ext2_dax_file_operations = {
113 .llseek = generic_file_llseek, 111 .llseek = generic_file_llseek,
114 .read = new_sync_read,
115 .write = new_sync_write,
116 .read_iter = generic_file_read_iter, 112 .read_iter = generic_file_read_iter,
117 .write_iter = generic_file_write_iter, 113 .write_iter = generic_file_write_iter,
118 .unlocked_ioctl = ext2_ioctl, 114 .unlocked_ioctl = ext2_ioctl,
diff --git a/fs/ext3/file.c b/fs/ext3/file.c
index a062fa1e1b11..3b8f650de22c 100644
--- a/fs/ext3/file.c
+++ b/fs/ext3/file.c
@@ -50,8 +50,6 @@ static int ext3_release_file (struct inode * inode, struct file * filp)
50 50
51const struct file_operations ext3_file_operations = { 51const struct file_operations ext3_file_operations = {
52 .llseek = generic_file_llseek, 52 .llseek = generic_file_llseek,
53 .read = new_sync_read,
54 .write = new_sync_write,
55 .read_iter = generic_file_read_iter, 53 .read_iter = generic_file_read_iter,
56 .write_iter = generic_file_write_iter, 54 .write_iter = generic_file_write_iter,
57 .unlocked_ioctl = ext3_ioctl, 55 .unlocked_ioctl = ext3_ioctl,
diff --git a/fs/ext4/file.c b/fs/ext4/file.c
index 598abbbe6786..9ad03036d9f5 100644
--- a/fs/ext4/file.c
+++ b/fs/ext4/file.c
@@ -607,8 +607,6 @@ loff_t ext4_llseek(struct file *file, loff_t offset, int whence)
607 607
608const struct file_operations ext4_file_operations = { 608const struct file_operations ext4_file_operations = {
609 .llseek = ext4_llseek, 609 .llseek = ext4_llseek,
610 .read = new_sync_read,
611 .write = new_sync_write,
612 .read_iter = generic_file_read_iter, 610 .read_iter = generic_file_read_iter,
613 .write_iter = ext4_file_write_iter, 611 .write_iter = ext4_file_write_iter,
614 .unlocked_ioctl = ext4_ioctl, 612 .unlocked_ioctl = ext4_ioctl,
@@ -627,8 +625,6 @@ const struct file_operations ext4_file_operations = {
627#ifdef CONFIG_FS_DAX 625#ifdef CONFIG_FS_DAX
628const struct file_operations ext4_dax_file_operations = { 626const struct file_operations ext4_dax_file_operations = {
629 .llseek = ext4_llseek, 627 .llseek = ext4_llseek,
630 .read = new_sync_read,
631 .write = new_sync_write,
632 .read_iter = generic_file_read_iter, 628 .read_iter = generic_file_read_iter,
633 .write_iter = ext4_file_write_iter, 629 .write_iter = ext4_file_write_iter,
634 .unlocked_ioctl = ext4_ioctl, 630 .unlocked_ioctl = ext4_ioctl,
diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index 98dac27bc3f7..df6a0596eccf 100644
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -1104,8 +1104,6 @@ long f2fs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
1104 1104
1105const struct file_operations f2fs_file_operations = { 1105const struct file_operations f2fs_file_operations = {
1106 .llseek = f2fs_llseek, 1106 .llseek = f2fs_llseek,
1107 .read = new_sync_read,
1108 .write = new_sync_write,
1109 .read_iter = generic_file_read_iter, 1107 .read_iter = generic_file_read_iter,
1110 .write_iter = generic_file_write_iter, 1108 .write_iter = generic_file_write_iter,
1111 .open = generic_file_open, 1109 .open = generic_file_open,
diff --git a/fs/fat/file.c b/fs/fat/file.c
index 8429c68e3057..1e98d333879f 100644
--- a/fs/fat/file.c
+++ b/fs/fat/file.c
@@ -170,8 +170,6 @@ int fat_file_fsync(struct file *filp, loff_t start, loff_t end, int datasync)
170 170
171const struct file_operations fat_file_operations = { 171const struct file_operations fat_file_operations = {
172 .llseek = generic_file_llseek, 172 .llseek = generic_file_llseek,
173 .read = new_sync_read,
174 .write = new_sync_write,
175 .read_iter = generic_file_read_iter, 173 .read_iter = generic_file_read_iter,
176 .write_iter = generic_file_write_iter, 174 .write_iter = generic_file_write_iter,
177 .mmap = generic_file_mmap, 175 .mmap = generic_file_mmap,
diff --git a/fs/file_table.c b/fs/file_table.c
index 3f85411b03ce..294174dcc226 100644
--- a/fs/file_table.c
+++ b/fs/file_table.c
@@ -168,10 +168,10 @@ struct file *alloc_file(struct path *path, fmode_t mode,
168 file->f_inode = path->dentry->d_inode; 168 file->f_inode = path->dentry->d_inode;
169 file->f_mapping = path->dentry->d_inode->i_mapping; 169 file->f_mapping = path->dentry->d_inode->i_mapping;
170 if ((mode & FMODE_READ) && 170 if ((mode & FMODE_READ) &&
171 likely(fop->read || fop->aio_read || fop->read_iter)) 171 likely(fop->read || fop->read_iter))
172 mode |= FMODE_CAN_READ; 172 mode |= FMODE_CAN_READ;
173 if ((mode & FMODE_WRITE) && 173 if ((mode & FMODE_WRITE) &&
174 likely(fop->write || fop->aio_write || fop->write_iter)) 174 likely(fop->write || fop->write_iter))
175 mode |= FMODE_CAN_WRITE; 175 mode |= FMODE_CAN_WRITE;
176 file->f_mode = mode; 176 file->f_mode = mode;
177 file->f_op = fop; 177 file->f_op = fop;
diff --git a/fs/fuse/cuse.c b/fs/fuse/cuse.c
index b3fa05032234..e5bbf748b698 100644
--- a/fs/fuse/cuse.c
+++ b/fs/fuse/cuse.c
@@ -88,32 +88,23 @@ static struct list_head *cuse_conntbl_head(dev_t devt)
88 * FUSE file. 88 * FUSE file.
89 */ 89 */
90 90
91static ssize_t cuse_read(struct file *file, char __user *buf, size_t count, 91static ssize_t cuse_read_iter(struct kiocb *kiocb, struct iov_iter *to)
92 loff_t *ppos)
93{ 92{
93 struct fuse_io_priv io = { .async = 0, .file = kiocb->ki_filp };
94 loff_t pos = 0; 94 loff_t pos = 0;
95 struct iovec iov = { .iov_base = buf, .iov_len = count };
96 struct fuse_io_priv io = { .async = 0, .file = file };
97 struct iov_iter ii;
98 iov_iter_init(&ii, READ, &iov, 1, count);
99 95
100 return fuse_direct_io(&io, &ii, &pos, FUSE_DIO_CUSE); 96 return fuse_direct_io(&io, to, &pos, FUSE_DIO_CUSE);
101} 97}
102 98
103static ssize_t cuse_write(struct file *file, const char __user *buf, 99static ssize_t cuse_write_iter(struct kiocb *kiocb, struct iov_iter *from)
104 size_t count, loff_t *ppos)
105{ 100{
101 struct fuse_io_priv io = { .async = 0, .file = kiocb->ki_filp };
106 loff_t pos = 0; 102 loff_t pos = 0;
107 struct iovec iov = { .iov_base = (void __user *)buf, .iov_len = count };
108 struct fuse_io_priv io = { .async = 0, .file = file };
109 struct iov_iter ii;
110 iov_iter_init(&ii, WRITE, &iov, 1, count);
111
112 /* 103 /*
113 * No locking or generic_write_checks(), the server is 104 * No locking or generic_write_checks(), the server is
114 * responsible for locking and sanity checks. 105 * responsible for locking and sanity checks.
115 */ 106 */
116 return fuse_direct_io(&io, &ii, &pos, 107 return fuse_direct_io(&io, from, &pos,
117 FUSE_DIO_WRITE | FUSE_DIO_CUSE); 108 FUSE_DIO_WRITE | FUSE_DIO_CUSE);
118} 109}
119 110
@@ -186,8 +177,8 @@ static long cuse_file_compat_ioctl(struct file *file, unsigned int cmd,
186 177
187static const struct file_operations cuse_frontend_fops = { 178static const struct file_operations cuse_frontend_fops = {
188 .owner = THIS_MODULE, 179 .owner = THIS_MODULE,
189 .read = cuse_read, 180 .read_iter = cuse_read_iter,
190 .write = cuse_write, 181 .write_iter = cuse_write_iter,
191 .open = cuse_open, 182 .open = cuse_open,
192 .release = cuse_release, 183 .release = cuse_release,
193 .unlocked_ioctl = cuse_file_ioctl, 184 .unlocked_ioctl = cuse_file_ioctl,
diff --git a/fs/fuse/dev.c b/fs/fuse/dev.c
index 95a2797eef66..c8b68ab2e574 100644
--- a/fs/fuse/dev.c
+++ b/fs/fuse/dev.c
@@ -710,28 +710,26 @@ struct fuse_copy_state {
710 struct fuse_conn *fc; 710 struct fuse_conn *fc;
711 int write; 711 int write;
712 struct fuse_req *req; 712 struct fuse_req *req;
713 const struct iovec *iov; 713 struct iov_iter *iter;
714 struct pipe_buffer *pipebufs; 714 struct pipe_buffer *pipebufs;
715 struct pipe_buffer *currbuf; 715 struct pipe_buffer *currbuf;
716 struct pipe_inode_info *pipe; 716 struct pipe_inode_info *pipe;
717 unsigned long nr_segs; 717 unsigned long nr_segs;
718 unsigned long seglen;
719 unsigned long addr;
720 struct page *pg; 718 struct page *pg;
721 unsigned len; 719 unsigned len;
722 unsigned offset; 720 unsigned offset;
723 unsigned move_pages:1; 721 unsigned move_pages:1;
724}; 722};
725 723
726static void fuse_copy_init(struct fuse_copy_state *cs, struct fuse_conn *fc, 724static void fuse_copy_init(struct fuse_copy_state *cs,
725 struct fuse_conn *fc,
727 int write, 726 int write,
728 const struct iovec *iov, unsigned long nr_segs) 727 struct iov_iter *iter)
729{ 728{
730 memset(cs, 0, sizeof(*cs)); 729 memset(cs, 0, sizeof(*cs));
731 cs->fc = fc; 730 cs->fc = fc;
732 cs->write = write; 731 cs->write = write;
733 cs->iov = iov; 732 cs->iter = iter;
734 cs->nr_segs = nr_segs;
735} 733}
736 734
737/* Unmap and put previous page of userspace buffer */ 735/* Unmap and put previous page of userspace buffer */
@@ -799,22 +797,16 @@ static int fuse_copy_fill(struct fuse_copy_state *cs)
799 cs->nr_segs++; 797 cs->nr_segs++;
800 } 798 }
801 } else { 799 } else {
802 if (!cs->seglen) { 800 size_t off;
803 BUG_ON(!cs->nr_segs); 801 err = iov_iter_get_pages(cs->iter, &page, PAGE_SIZE, 1, &off);
804 cs->seglen = cs->iov[0].iov_len;
805 cs->addr = (unsigned long) cs->iov[0].iov_base;
806 cs->iov++;
807 cs->nr_segs--;
808 }
809 err = get_user_pages_fast(cs->addr, 1, cs->write, &page);
810 if (err < 0) 802 if (err < 0)
811 return err; 803 return err;
812 BUG_ON(err != 1); 804 BUG_ON(!err);
805 cs->len = err;
806 cs->offset = off;
813 cs->pg = page; 807 cs->pg = page;
814 cs->offset = cs->addr % PAGE_SIZE; 808 cs->offset = off;
815 cs->len = min(PAGE_SIZE - cs->offset, cs->seglen); 809 iov_iter_advance(cs->iter, err);
816 cs->seglen -= cs->len;
817 cs->addr += cs->len;
818 } 810 }
819 811
820 return lock_request(cs->fc, cs->req); 812 return lock_request(cs->fc, cs->req);
@@ -1363,8 +1355,7 @@ static int fuse_dev_open(struct inode *inode, struct file *file)
1363 return 0; 1355 return 0;
1364} 1356}
1365 1357
1366static ssize_t fuse_dev_read(struct kiocb *iocb, const struct iovec *iov, 1358static ssize_t fuse_dev_read(struct kiocb *iocb, struct iov_iter *to)
1367 unsigned long nr_segs, loff_t pos)
1368{ 1359{
1369 struct fuse_copy_state cs; 1360 struct fuse_copy_state cs;
1370 struct file *file = iocb->ki_filp; 1361 struct file *file = iocb->ki_filp;
@@ -1372,9 +1363,12 @@ static ssize_t fuse_dev_read(struct kiocb *iocb, const struct iovec *iov,
1372 if (!fc) 1363 if (!fc)
1373 return -EPERM; 1364 return -EPERM;
1374 1365
1375 fuse_copy_init(&cs, fc, 1, iov, nr_segs); 1366 if (!iter_is_iovec(to))
1367 return -EINVAL;
1376 1368
1377 return fuse_dev_do_read(fc, file, &cs, iov_length(iov, nr_segs)); 1369 fuse_copy_init(&cs, fc, 1, to);
1370
1371 return fuse_dev_do_read(fc, file, &cs, iov_iter_count(to));
1378} 1372}
1379 1373
1380static ssize_t fuse_dev_splice_read(struct file *in, loff_t *ppos, 1374static ssize_t fuse_dev_splice_read(struct file *in, loff_t *ppos,
@@ -1394,7 +1388,7 @@ static ssize_t fuse_dev_splice_read(struct file *in, loff_t *ppos,
1394 if (!bufs) 1388 if (!bufs)
1395 return -ENOMEM; 1389 return -ENOMEM;
1396 1390
1397 fuse_copy_init(&cs, fc, 1, NULL, 0); 1391 fuse_copy_init(&cs, fc, 1, NULL);
1398 cs.pipebufs = bufs; 1392 cs.pipebufs = bufs;
1399 cs.pipe = pipe; 1393 cs.pipe = pipe;
1400 ret = fuse_dev_do_read(fc, in, &cs, len); 1394 ret = fuse_dev_do_read(fc, in, &cs, len);
@@ -1970,17 +1964,19 @@ static ssize_t fuse_dev_do_write(struct fuse_conn *fc,
1970 return err; 1964 return err;
1971} 1965}
1972 1966
1973static ssize_t fuse_dev_write(struct kiocb *iocb, const struct iovec *iov, 1967static ssize_t fuse_dev_write(struct kiocb *iocb, struct iov_iter *from)
1974 unsigned long nr_segs, loff_t pos)
1975{ 1968{
1976 struct fuse_copy_state cs; 1969 struct fuse_copy_state cs;
1977 struct fuse_conn *fc = fuse_get_conn(iocb->ki_filp); 1970 struct fuse_conn *fc = fuse_get_conn(iocb->ki_filp);
1978 if (!fc) 1971 if (!fc)
1979 return -EPERM; 1972 return -EPERM;
1980 1973
1981 fuse_copy_init(&cs, fc, 0, iov, nr_segs); 1974 if (!iter_is_iovec(from))
1975 return -EINVAL;
1976
1977 fuse_copy_init(&cs, fc, 0, from);
1982 1978
1983 return fuse_dev_do_write(fc, &cs, iov_length(iov, nr_segs)); 1979 return fuse_dev_do_write(fc, &cs, iov_iter_count(from));
1984} 1980}
1985 1981
1986static ssize_t fuse_dev_splice_write(struct pipe_inode_info *pipe, 1982static ssize_t fuse_dev_splice_write(struct pipe_inode_info *pipe,
@@ -2043,8 +2039,9 @@ static ssize_t fuse_dev_splice_write(struct pipe_inode_info *pipe,
2043 } 2039 }
2044 pipe_unlock(pipe); 2040 pipe_unlock(pipe);
2045 2041
2046 fuse_copy_init(&cs, fc, 0, NULL, nbuf); 2042 fuse_copy_init(&cs, fc, 0, NULL);
2047 cs.pipebufs = bufs; 2043 cs.pipebufs = bufs;
2044 cs.nr_segs = nbuf;
2048 cs.pipe = pipe; 2045 cs.pipe = pipe;
2049 2046
2050 if (flags & SPLICE_F_MOVE) 2047 if (flags & SPLICE_F_MOVE)
@@ -2232,11 +2229,9 @@ const struct file_operations fuse_dev_operations = {
2232 .owner = THIS_MODULE, 2229 .owner = THIS_MODULE,
2233 .open = fuse_dev_open, 2230 .open = fuse_dev_open,
2234 .llseek = no_llseek, 2231 .llseek = no_llseek,
2235 .read = do_sync_read, 2232 .read_iter = fuse_dev_read,
2236 .aio_read = fuse_dev_read,
2237 .splice_read = fuse_dev_splice_read, 2233 .splice_read = fuse_dev_splice_read,
2238 .write = do_sync_write, 2234 .write_iter = fuse_dev_write,
2239 .aio_write = fuse_dev_write,
2240 .splice_write = fuse_dev_splice_write, 2235 .splice_write = fuse_dev_splice_write,
2241 .poll = fuse_dev_poll, 2236 .poll = fuse_dev_poll,
2242 .release = fuse_dev_release, 2237 .release = fuse_dev_release,
diff --git a/fs/fuse/file.c b/fs/fuse/file.c
index ff102cbf16ea..e1afdd7abf90 100644
--- a/fs/fuse/file.c
+++ b/fs/fuse/file.c
@@ -1401,55 +1401,33 @@ static ssize_t __fuse_direct_read(struct fuse_io_priv *io,
1401 return res; 1401 return res;
1402} 1402}
1403 1403
1404static ssize_t fuse_direct_read(struct file *file, char __user *buf, 1404static ssize_t fuse_direct_read_iter(struct kiocb *iocb, struct iov_iter *to)
1405 size_t count, loff_t *ppos)
1406{ 1405{
1407 struct fuse_io_priv io = { .async = 0, .file = file }; 1406 struct fuse_io_priv io = { .async = 0, .file = iocb->ki_filp };
1408 struct iovec iov = { .iov_base = buf, .iov_len = count }; 1407 return __fuse_direct_read(&io, to, &iocb->ki_pos);
1409 struct iov_iter ii;
1410 iov_iter_init(&ii, READ, &iov, 1, count);
1411 return __fuse_direct_read(&io, &ii, ppos);
1412} 1408}
1413 1409
1414static ssize_t __fuse_direct_write(struct fuse_io_priv *io, 1410static ssize_t fuse_direct_write_iter(struct kiocb *iocb, struct iov_iter *from)
1415 struct iov_iter *iter,
1416 loff_t *ppos)
1417{ 1411{
1418 struct file *file = io->file; 1412 struct file *file = iocb->ki_filp;
1419 struct inode *inode = file_inode(file);
1420 size_t count = iov_iter_count(iter);
1421 ssize_t res;
1422
1423
1424 res = generic_write_checks(file, ppos, &count, 0);
1425 if (!res) {
1426 iov_iter_truncate(iter, count);
1427 res = fuse_direct_io(io, iter, ppos, FUSE_DIO_WRITE);
1428 }
1429
1430 fuse_invalidate_attr(inode);
1431
1432 return res;
1433}
1434
1435static ssize_t fuse_direct_write(struct file *file, const char __user *buf,
1436 size_t count, loff_t *ppos)
1437{
1438 struct iovec iov = { .iov_base = (void __user *)buf, .iov_len = count };
1439 struct inode *inode = file_inode(file); 1413 struct inode *inode = file_inode(file);
1440 ssize_t res;
1441 struct fuse_io_priv io = { .async = 0, .file = file }; 1414 struct fuse_io_priv io = { .async = 0, .file = file };
1442 struct iov_iter ii; 1415 size_t count = iov_iter_count(from);
1443 iov_iter_init(&ii, WRITE, &iov, 1, count); 1416 ssize_t res;
1444 1417
1445 if (is_bad_inode(inode)) 1418 if (is_bad_inode(inode))
1446 return -EIO; 1419 return -EIO;
1447 1420
1448 /* Don't allow parallel writes to the same file */ 1421 /* Don't allow parallel writes to the same file */
1449 mutex_lock(&inode->i_mutex); 1422 mutex_lock(&inode->i_mutex);
1450 res = __fuse_direct_write(&io, &ii, ppos); 1423 res = generic_write_checks(file, &iocb->ki_pos, &count, 0);
1424 if (!res) {
1425 iov_iter_truncate(from, count);
1426 res = fuse_direct_io(&io, from, &iocb->ki_pos, FUSE_DIO_WRITE);
1427 }
1428 fuse_invalidate_attr(inode);
1451 if (res > 0) 1429 if (res > 0)
1452 fuse_write_update_size(inode, *ppos); 1430 fuse_write_update_size(inode, iocb->ki_pos);
1453 mutex_unlock(&inode->i_mutex); 1431 mutex_unlock(&inode->i_mutex);
1454 1432
1455 return res; 1433 return res;
@@ -2862,10 +2840,17 @@ fuse_direct_IO(int rw, struct kiocb *iocb, struct iov_iter *iter,
2862 if (io->async && is_sync_kiocb(iocb)) 2840 if (io->async && is_sync_kiocb(iocb))
2863 io->done = &wait; 2841 io->done = &wait;
2864 2842
2865 if (rw == WRITE) 2843 if (rw == WRITE) {
2866 ret = __fuse_direct_write(io, iter, &pos); 2844 ret = generic_write_checks(file, &pos, &count, 0);
2867 else 2845 if (!ret) {
2846 iov_iter_truncate(iter, count);
2847 ret = fuse_direct_io(io, iter, &pos, FUSE_DIO_WRITE);
2848 }
2849
2850 fuse_invalidate_attr(inode);
2851 } else {
2868 ret = __fuse_direct_read(io, iter, &pos); 2852 ret = __fuse_direct_read(io, iter, &pos);
2853 }
2869 2854
2870 if (io->async) { 2855 if (io->async) {
2871 fuse_aio_complete(io, ret < 0 ? ret : 0, -1); 2856 fuse_aio_complete(io, ret < 0 ? ret : 0, -1);
@@ -2968,9 +2953,7 @@ out:
2968 2953
2969static const struct file_operations fuse_file_operations = { 2954static const struct file_operations fuse_file_operations = {
2970 .llseek = fuse_file_llseek, 2955 .llseek = fuse_file_llseek,
2971 .read = new_sync_read,
2972 .read_iter = fuse_file_read_iter, 2956 .read_iter = fuse_file_read_iter,
2973 .write = new_sync_write,
2974 .write_iter = fuse_file_write_iter, 2957 .write_iter = fuse_file_write_iter,
2975 .mmap = fuse_file_mmap, 2958 .mmap = fuse_file_mmap,
2976 .open = fuse_open, 2959 .open = fuse_open,
@@ -2988,8 +2971,8 @@ static const struct file_operations fuse_file_operations = {
2988 2971
2989static const struct file_operations fuse_direct_io_file_operations = { 2972static const struct file_operations fuse_direct_io_file_operations = {
2990 .llseek = fuse_file_llseek, 2973 .llseek = fuse_file_llseek,
2991 .read = fuse_direct_read, 2974 .read_iter = fuse_direct_read_iter,
2992 .write = fuse_direct_write, 2975 .write_iter = fuse_direct_write_iter,
2993 .mmap = fuse_direct_mmap, 2976 .mmap = fuse_direct_mmap,
2994 .open = fuse_open, 2977 .open = fuse_open,
2995 .flush = fuse_flush, 2978 .flush = fuse_flush,
diff --git a/fs/gfs2/file.c b/fs/gfs2/file.c
index 8ec43ab5babf..207eb4a8135e 100644
--- a/fs/gfs2/file.c
+++ b/fs/gfs2/file.c
@@ -1105,9 +1105,7 @@ static int gfs2_flock(struct file *file, int cmd, struct file_lock *fl)
1105 1105
1106const struct file_operations gfs2_file_fops = { 1106const struct file_operations gfs2_file_fops = {
1107 .llseek = gfs2_llseek, 1107 .llseek = gfs2_llseek,
1108 .read = new_sync_read,
1109 .read_iter = generic_file_read_iter, 1108 .read_iter = generic_file_read_iter,
1110 .write = new_sync_write,
1111 .write_iter = gfs2_file_write_iter, 1109 .write_iter = gfs2_file_write_iter,
1112 .unlocked_ioctl = gfs2_ioctl, 1110 .unlocked_ioctl = gfs2_ioctl,
1113 .mmap = gfs2_mmap, 1111 .mmap = gfs2_mmap,
@@ -1137,9 +1135,7 @@ const struct file_operations gfs2_dir_fops = {
1137 1135
1138const struct file_operations gfs2_file_fops_nolock = { 1136const struct file_operations gfs2_file_fops_nolock = {
1139 .llseek = gfs2_llseek, 1137 .llseek = gfs2_llseek,
1140 .read = new_sync_read,
1141 .read_iter = generic_file_read_iter, 1138 .read_iter = generic_file_read_iter,
1142 .write = new_sync_write,
1143 .write_iter = gfs2_file_write_iter, 1139 .write_iter = gfs2_file_write_iter,
1144 .unlocked_ioctl = gfs2_ioctl, 1140 .unlocked_ioctl = gfs2_ioctl,
1145 .mmap = gfs2_mmap, 1141 .mmap = gfs2_mmap,
diff --git a/fs/hfs/inode.c b/fs/hfs/inode.c
index 98d4ea45bb70..9337065bcc67 100644
--- a/fs/hfs/inode.c
+++ b/fs/hfs/inode.c
@@ -674,9 +674,7 @@ static int hfs_file_fsync(struct file *filp, loff_t start, loff_t end,
674 674
675static const struct file_operations hfs_file_operations = { 675static const struct file_operations hfs_file_operations = {
676 .llseek = generic_file_llseek, 676 .llseek = generic_file_llseek,
677 .read = new_sync_read,
678 .read_iter = generic_file_read_iter, 677 .read_iter = generic_file_read_iter,
679 .write = new_sync_write,
680 .write_iter = generic_file_write_iter, 678 .write_iter = generic_file_write_iter,
681 .mmap = generic_file_mmap, 679 .mmap = generic_file_mmap,
682 .splice_read = generic_file_splice_read, 680 .splice_read = generic_file_splice_read,
diff --git a/fs/hfsplus/inode.c b/fs/hfsplus/inode.c
index f541196d4ee9..5f86cadb0542 100644
--- a/fs/hfsplus/inode.c
+++ b/fs/hfsplus/inode.c
@@ -341,9 +341,7 @@ static const struct inode_operations hfsplus_file_inode_operations = {
341 341
342static const struct file_operations hfsplus_file_operations = { 342static const struct file_operations hfsplus_file_operations = {
343 .llseek = generic_file_llseek, 343 .llseek = generic_file_llseek,
344 .read = new_sync_read,
345 .read_iter = generic_file_read_iter, 344 .read_iter = generic_file_read_iter,
346 .write = new_sync_write,
347 .write_iter = generic_file_write_iter, 345 .write_iter = generic_file_write_iter,
348 .mmap = generic_file_mmap, 346 .mmap = generic_file_mmap,
349 .splice_read = generic_file_splice_read, 347 .splice_read = generic_file_splice_read,
diff --git a/fs/hostfs/hostfs_kern.c b/fs/hostfs/hostfs_kern.c
index fd62cae0fdcb..e021188ca110 100644
--- a/fs/hostfs/hostfs_kern.c
+++ b/fs/hostfs/hostfs_kern.c
@@ -378,11 +378,9 @@ static int hostfs_fsync(struct file *file, loff_t start, loff_t end,
378 378
379static const struct file_operations hostfs_file_fops = { 379static const struct file_operations hostfs_file_fops = {
380 .llseek = generic_file_llseek, 380 .llseek = generic_file_llseek,
381 .read = new_sync_read,
382 .splice_read = generic_file_splice_read, 381 .splice_read = generic_file_splice_read,
383 .read_iter = generic_file_read_iter, 382 .read_iter = generic_file_read_iter,
384 .write_iter = generic_file_write_iter, 383 .write_iter = generic_file_write_iter,
385 .write = new_sync_write,
386 .mmap = generic_file_mmap, 384 .mmap = generic_file_mmap,
387 .open = hostfs_file_open, 385 .open = hostfs_file_open,
388 .release = hostfs_file_release, 386 .release = hostfs_file_release,
diff --git a/fs/hpfs/file.c b/fs/hpfs/file.c
index 7f54e5f76cec..6d8cfe9b52d6 100644
--- a/fs/hpfs/file.c
+++ b/fs/hpfs/file.c
@@ -197,9 +197,7 @@ const struct address_space_operations hpfs_aops = {
197const struct file_operations hpfs_file_ops = 197const struct file_operations hpfs_file_ops =
198{ 198{
199 .llseek = generic_file_llseek, 199 .llseek = generic_file_llseek,
200 .read = new_sync_read,
201 .read_iter = generic_file_read_iter, 200 .read_iter = generic_file_read_iter,
202 .write = new_sync_write,
203 .write_iter = generic_file_write_iter, 201 .write_iter = generic_file_write_iter,
204 .mmap = generic_file_mmap, 202 .mmap = generic_file_mmap,
205 .release = hpfs_file_release, 203 .release = hpfs_file_release,
diff --git a/fs/hugetlbfs/inode.c b/fs/hugetlbfs/inode.c
index db76cec3ce21..45e34908bdb5 100644
--- a/fs/hugetlbfs/inode.c
+++ b/fs/hugetlbfs/inode.c
@@ -34,6 +34,7 @@
34#include <linux/security.h> 34#include <linux/security.h>
35#include <linux/magic.h> 35#include <linux/magic.h>
36#include <linux/migrate.h> 36#include <linux/migrate.h>
37#include <linux/uio.h>
37 38
38#include <asm/uaccess.h> 39#include <asm/uaccess.h>
39 40
@@ -179,42 +180,33 @@ hugetlb_get_unmapped_area(struct file *file, unsigned long addr,
179} 180}
180#endif 181#endif
181 182
182static int 183static size_t
183hugetlbfs_read_actor(struct page *page, unsigned long offset, 184hugetlbfs_read_actor(struct page *page, unsigned long offset,
184 char __user *buf, unsigned long count, 185 struct iov_iter *to, unsigned long size)
185 unsigned long size)
186{ 186{
187 char *kaddr; 187 size_t copied = 0;
188 unsigned long left, copied = 0;
189 int i, chunksize; 188 int i, chunksize;
190 189
191 if (size > count)
192 size = count;
193
194 /* Find which 4k chunk and offset with in that chunk */ 190 /* Find which 4k chunk and offset with in that chunk */
195 i = offset >> PAGE_CACHE_SHIFT; 191 i = offset >> PAGE_CACHE_SHIFT;
196 offset = offset & ~PAGE_CACHE_MASK; 192 offset = offset & ~PAGE_CACHE_MASK;
197 193
198 while (size) { 194 while (size) {
195 size_t n;
199 chunksize = PAGE_CACHE_SIZE; 196 chunksize = PAGE_CACHE_SIZE;
200 if (offset) 197 if (offset)
201 chunksize -= offset; 198 chunksize -= offset;
202 if (chunksize > size) 199 if (chunksize > size)
203 chunksize = size; 200 chunksize = size;
204 kaddr = kmap(&page[i]); 201 n = copy_page_to_iter(&page[i], offset, chunksize, to);
205 left = __copy_to_user(buf, kaddr + offset, chunksize); 202 copied += n;
206 kunmap(&page[i]); 203 if (n != chunksize)
207 if (left) { 204 return copied;
208 copied += (chunksize - left);
209 break;
210 }
211 offset = 0; 205 offset = 0;
212 size -= chunksize; 206 size -= chunksize;
213 buf += chunksize;
214 copied += chunksize;
215 i++; 207 i++;
216 } 208 }
217 return copied ? copied : -EFAULT; 209 return copied;
218} 210}
219 211
220/* 212/*
@@ -222,39 +214,34 @@ hugetlbfs_read_actor(struct page *page, unsigned long offset,
222 * data. Its *very* similar to do_generic_mapping_read(), we can't use that 214 * data. Its *very* similar to do_generic_mapping_read(), we can't use that
223 * since it has PAGE_CACHE_SIZE assumptions. 215 * since it has PAGE_CACHE_SIZE assumptions.
224 */ 216 */
225static ssize_t hugetlbfs_read(struct file *filp, char __user *buf, 217static ssize_t hugetlbfs_read_iter(struct kiocb *iocb, struct iov_iter *to)
226 size_t len, loff_t *ppos)
227{ 218{
228 struct hstate *h = hstate_file(filp); 219 struct file *file = iocb->ki_filp;
229 struct address_space *mapping = filp->f_mapping; 220 struct hstate *h = hstate_file(file);
221 struct address_space *mapping = file->f_mapping;
230 struct inode *inode = mapping->host; 222 struct inode *inode = mapping->host;
231 unsigned long index = *ppos >> huge_page_shift(h); 223 unsigned long index = iocb->ki_pos >> huge_page_shift(h);
232 unsigned long offset = *ppos & ~huge_page_mask(h); 224 unsigned long offset = iocb->ki_pos & ~huge_page_mask(h);
233 unsigned long end_index; 225 unsigned long end_index;
234 loff_t isize; 226 loff_t isize;
235 ssize_t retval = 0; 227 ssize_t retval = 0;
236 228
237 /* validate length */ 229 while (iov_iter_count(to)) {
238 if (len == 0)
239 goto out;
240
241 for (;;) {
242 struct page *page; 230 struct page *page;
243 unsigned long nr, ret; 231 size_t nr, copied;
244 int ra;
245 232
246 /* nr is the maximum number of bytes to copy from this page */ 233 /* nr is the maximum number of bytes to copy from this page */
247 nr = huge_page_size(h); 234 nr = huge_page_size(h);
248 isize = i_size_read(inode); 235 isize = i_size_read(inode);
249 if (!isize) 236 if (!isize)
250 goto out; 237 break;
251 end_index = (isize - 1) >> huge_page_shift(h); 238 end_index = (isize - 1) >> huge_page_shift(h);
252 if (index >= end_index) { 239 if (index > end_index)
253 if (index > end_index) 240 break;
254 goto out; 241 if (index == end_index) {
255 nr = ((isize - 1) & ~huge_page_mask(h)) + 1; 242 nr = ((isize - 1) & ~huge_page_mask(h)) + 1;
256 if (nr <= offset) 243 if (nr <= offset)
257 goto out; 244 break;
258 } 245 }
259 nr = nr - offset; 246 nr = nr - offset;
260 247
@@ -265,39 +252,27 @@ static ssize_t hugetlbfs_read(struct file *filp, char __user *buf,
265 * We have a HOLE, zero out the user-buffer for the 252 * We have a HOLE, zero out the user-buffer for the
266 * length of the hole or request. 253 * length of the hole or request.
267 */ 254 */
268 ret = len < nr ? len : nr; 255 copied = iov_iter_zero(nr, to);
269 if (clear_user(buf, ret))
270 ra = -EFAULT;
271 else
272 ra = 0;
273 } else { 256 } else {
274 unlock_page(page); 257 unlock_page(page);
275 258
276 /* 259 /*
277 * We have the page, copy it to user space buffer. 260 * We have the page, copy it to user space buffer.
278 */ 261 */
279 ra = hugetlbfs_read_actor(page, offset, buf, len, nr); 262 copied = hugetlbfs_read_actor(page, offset, to, nr);
280 ret = ra;
281 page_cache_release(page); 263 page_cache_release(page);
282 } 264 }
283 if (ra < 0) { 265 offset += copied;
284 if (retval == 0) 266 retval += copied;
285 retval = ra; 267 if (copied != nr && iov_iter_count(to)) {
286 goto out; 268 if (!retval)
269 retval = -EFAULT;
270 break;
287 } 271 }
288
289 offset += ret;
290 retval += ret;
291 len -= ret;
292 index += offset >> huge_page_shift(h); 272 index += offset >> huge_page_shift(h);
293 offset &= ~huge_page_mask(h); 273 offset &= ~huge_page_mask(h);
294
295 /* short read or no more work */
296 if ((ret != nr) || (len == 0))
297 break;
298 } 274 }
299out: 275 iocb->ki_pos = ((loff_t)index << huge_page_shift(h)) + offset;
300 *ppos = ((loff_t)index << huge_page_shift(h)) + offset;
301 return retval; 276 return retval;
302} 277}
303 278
@@ -721,7 +696,7 @@ static void init_once(void *foo)
721} 696}
722 697
723const struct file_operations hugetlbfs_file_operations = { 698const struct file_operations hugetlbfs_file_operations = {
724 .read = hugetlbfs_read, 699 .read_iter = hugetlbfs_read_iter,
725 .mmap = hugetlbfs_file_mmap, 700 .mmap = hugetlbfs_file_mmap,
726 .fsync = noop_fsync, 701 .fsync = noop_fsync,
727 .get_unmapped_area = hugetlb_get_unmapped_area, 702 .get_unmapped_area = hugetlb_get_unmapped_area,
diff --git a/fs/jffs2/file.c b/fs/jffs2/file.c
index 64989ca9ba90..f509f62e12f6 100644
--- a/fs/jffs2/file.c
+++ b/fs/jffs2/file.c
@@ -51,9 +51,7 @@ const struct file_operations jffs2_file_operations =
51{ 51{
52 .llseek = generic_file_llseek, 52 .llseek = generic_file_llseek,
53 .open = generic_file_open, 53 .open = generic_file_open,
54 .read = new_sync_read,
55 .read_iter = generic_file_read_iter, 54 .read_iter = generic_file_read_iter,
56 .write = new_sync_write,
57 .write_iter = generic_file_write_iter, 55 .write_iter = generic_file_write_iter,
58 .unlocked_ioctl=jffs2_ioctl, 56 .unlocked_ioctl=jffs2_ioctl,
59 .mmap = generic_file_readonly_mmap, 57 .mmap = generic_file_readonly_mmap,
diff --git a/fs/jfs/file.c b/fs/jfs/file.c
index 10815f8dfd8b..ae46788b9723 100644
--- a/fs/jfs/file.c
+++ b/fs/jfs/file.c
@@ -151,8 +151,6 @@ const struct inode_operations jfs_file_inode_operations = {
151const struct file_operations jfs_file_operations = { 151const struct file_operations jfs_file_operations = {
152 .open = jfs_open, 152 .open = jfs_open,
153 .llseek = generic_file_llseek, 153 .llseek = generic_file_llseek,
154 .write = new_sync_write,
155 .read = new_sync_read,
156 .read_iter = generic_file_read_iter, 154 .read_iter = generic_file_read_iter,
157 .write_iter = generic_file_write_iter, 155 .write_iter = generic_file_write_iter,
158 .mmap = generic_file_mmap, 156 .mmap = generic_file_mmap,
diff --git a/fs/logfs/file.c b/fs/logfs/file.c
index 8538752df2f6..b2c13f739ffa 100644
--- a/fs/logfs/file.c
+++ b/fs/logfs/file.c
@@ -271,8 +271,6 @@ const struct file_operations logfs_reg_fops = {
271 .llseek = generic_file_llseek, 271 .llseek = generic_file_llseek,
272 .mmap = generic_file_readonly_mmap, 272 .mmap = generic_file_readonly_mmap,
273 .open = generic_file_open, 273 .open = generic_file_open,
274 .read = new_sync_read,
275 .write = new_sync_write,
276}; 274};
277 275
278const struct address_space_operations logfs_reg_aops = { 276const struct address_space_operations logfs_reg_aops = {
diff --git a/fs/minix/file.c b/fs/minix/file.c
index a967de085ac0..6d63e27ec961 100644
--- a/fs/minix/file.c
+++ b/fs/minix/file.c
@@ -14,9 +14,7 @@
14 */ 14 */
15const struct file_operations minix_file_operations = { 15const struct file_operations minix_file_operations = {
16 .llseek = generic_file_llseek, 16 .llseek = generic_file_llseek,
17 .read = new_sync_read,
18 .read_iter = generic_file_read_iter, 17 .read_iter = generic_file_read_iter,
19 .write = new_sync_write,
20 .write_iter = generic_file_write_iter, 18 .write_iter = generic_file_write_iter,
21 .mmap = generic_file_mmap, 19 .mmap = generic_file_mmap,
22 .fsync = generic_file_fsync, 20 .fsync = generic_file_fsync,
diff --git a/fs/ncpfs/file.c b/fs/ncpfs/file.c
index 1dd7007f974d..479bf8db264e 100644
--- a/fs/ncpfs/file.c
+++ b/fs/ncpfs/file.c
@@ -98,30 +98,24 @@ out:
98} 98}
99 99
100static ssize_t 100static ssize_t
101ncp_file_read(struct file *file, char __user *buf, size_t count, loff_t *ppos) 101ncp_file_read_iter(struct kiocb *iocb, struct iov_iter *to)
102{ 102{
103 struct file *file = iocb->ki_filp;
103 struct inode *inode = file_inode(file); 104 struct inode *inode = file_inode(file);
104 size_t already_read = 0; 105 size_t already_read = 0;
105 off_t pos; 106 off_t pos = iocb->ki_pos;
106 size_t bufsize; 107 size_t bufsize;
107 int error; 108 int error;
108 void* freepage; 109 void *freepage;
109 size_t freelen; 110 size_t freelen;
110 111
111 ncp_dbg(1, "enter %pD2\n", file); 112 ncp_dbg(1, "enter %pD2\n", file);
112 113
113 pos = *ppos; 114 if (!iov_iter_count(to))
114
115 if ((ssize_t) count < 0) {
116 return -EINVAL;
117 }
118 if (!count)
119 return 0; 115 return 0;
120 if (pos > inode->i_sb->s_maxbytes) 116 if (pos > inode->i_sb->s_maxbytes)
121 return 0; 117 return 0;
122 if (pos + count > inode->i_sb->s_maxbytes) { 118 iov_iter_truncate(to, inode->i_sb->s_maxbytes - pos);
123 count = inode->i_sb->s_maxbytes - pos;
124 }
125 119
126 error = ncp_make_open(inode, O_RDONLY); 120 error = ncp_make_open(inode, O_RDONLY);
127 if (error) { 121 if (error) {
@@ -138,31 +132,29 @@ ncp_file_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
138 goto outrel; 132 goto outrel;
139 error = 0; 133 error = 0;
140 /* First read in as much as possible for each bufsize. */ 134 /* First read in as much as possible for each bufsize. */
141 while (already_read < count) { 135 while (iov_iter_count(to)) {
142 int read_this_time; 136 int read_this_time;
143 size_t to_read = min_t(unsigned int, 137 size_t to_read = min_t(size_t,
144 bufsize - (pos % bufsize), 138 bufsize - (pos % bufsize),
145 count - already_read); 139 iov_iter_count(to));
146 140
147 error = ncp_read_bounce(NCP_SERVER(inode), 141 error = ncp_read_bounce(NCP_SERVER(inode),
148 NCP_FINFO(inode)->file_handle, 142 NCP_FINFO(inode)->file_handle,
149 pos, to_read, buf, &read_this_time, 143 pos, to_read, to, &read_this_time,
150 freepage, freelen); 144 freepage, freelen);
151 if (error) { 145 if (error) {
152 error = -EIO; /* NW errno -> Linux errno */ 146 error = -EIO; /* NW errno -> Linux errno */
153 break; 147 break;
154 } 148 }
155 pos += read_this_time; 149 pos += read_this_time;
156 buf += read_this_time;
157 already_read += read_this_time; 150 already_read += read_this_time;
158 151
159 if (read_this_time != to_read) { 152 if (read_this_time != to_read)
160 break; 153 break;
161 }
162 } 154 }
163 vfree(freepage); 155 vfree(freepage);
164 156
165 *ppos = pos; 157 iocb->ki_pos = pos;
166 158
167 file_accessed(file); 159 file_accessed(file);
168 160
@@ -173,42 +165,26 @@ outrel:
173} 165}
174 166
175static ssize_t 167static ssize_t
176ncp_file_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos) 168ncp_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
177{ 169{
170 struct file *file = iocb->ki_filp;
178 struct inode *inode = file_inode(file); 171 struct inode *inode = file_inode(file);
179 size_t already_written = 0; 172 size_t already_written = 0;
180 off_t pos; 173 loff_t pos = iocb->ki_pos;
174 size_t count = iov_iter_count(from);
181 size_t bufsize; 175 size_t bufsize;
182 int errno; 176 int errno;
183 void* bouncebuffer; 177 void *bouncebuffer;
184 178
185 ncp_dbg(1, "enter %pD2\n", file); 179 ncp_dbg(1, "enter %pD2\n", file);
186 if ((ssize_t) count < 0) 180 errno = generic_write_checks(file, &pos, &count, 0);
187 return -EINVAL; 181 if (errno)
188 pos = *ppos; 182 return errno;
189 if (file->f_flags & O_APPEND) { 183 iov_iter_truncate(from, count);
190 pos = i_size_read(inode);
191 }
192
193 if (pos + count > MAX_NON_LFS && !(file->f_flags&O_LARGEFILE)) {
194 if (pos >= MAX_NON_LFS) {
195 return -EFBIG;
196 }
197 if (count > MAX_NON_LFS - (u32)pos) {
198 count = MAX_NON_LFS - (u32)pos;
199 }
200 }
201 if (pos >= inode->i_sb->s_maxbytes) {
202 if (count || pos > inode->i_sb->s_maxbytes) {
203 return -EFBIG;
204 }
205 }
206 if (pos + count > inode->i_sb->s_maxbytes) {
207 count = inode->i_sb->s_maxbytes - pos;
208 }
209 184
210 if (!count) 185 if (!count)
211 return 0; 186 return 0;
187
212 errno = ncp_make_open(inode, O_WRONLY); 188 errno = ncp_make_open(inode, O_WRONLY);
213 if (errno) { 189 if (errno) {
214 ncp_dbg(1, "open failed, error=%d\n", errno); 190 ncp_dbg(1, "open failed, error=%d\n", errno);
@@ -216,8 +192,6 @@ ncp_file_write(struct file *file, const char __user *buf, size_t count, loff_t *
216 } 192 }
217 bufsize = NCP_SERVER(inode)->buffer_size; 193 bufsize = NCP_SERVER(inode)->buffer_size;
218 194
219 already_written = 0;
220
221 errno = file_update_time(file); 195 errno = file_update_time(file);
222 if (errno) 196 if (errno)
223 goto outrel; 197 goto outrel;
@@ -227,13 +201,13 @@ ncp_file_write(struct file *file, const char __user *buf, size_t count, loff_t *
227 errno = -EIO; /* -ENOMEM */ 201 errno = -EIO; /* -ENOMEM */
228 goto outrel; 202 goto outrel;
229 } 203 }
230 while (already_written < count) { 204 while (iov_iter_count(from)) {
231 int written_this_time; 205 int written_this_time;
232 size_t to_write = min_t(unsigned int, 206 size_t to_write = min_t(size_t,
233 bufsize - (pos % bufsize), 207 bufsize - ((off_t)pos % bufsize),
234 count - already_written); 208 iov_iter_count(from));
235 209
236 if (copy_from_user(bouncebuffer, buf, to_write)) { 210 if (copy_from_iter(bouncebuffer, to_write, from) != to_write) {
237 errno = -EFAULT; 211 errno = -EFAULT;
238 break; 212 break;
239 } 213 }
@@ -244,16 +218,14 @@ ncp_file_write(struct file *file, const char __user *buf, size_t count, loff_t *
244 break; 218 break;
245 } 219 }
246 pos += written_this_time; 220 pos += written_this_time;
247 buf += written_this_time;
248 already_written += written_this_time; 221 already_written += written_this_time;
249 222
250 if (written_this_time != to_write) { 223 if (written_this_time != to_write)
251 break; 224 break;
252 }
253 } 225 }
254 vfree(bouncebuffer); 226 vfree(bouncebuffer);
255 227
256 *ppos = pos; 228 iocb->ki_pos = pos;
257 229
258 if (pos > i_size_read(inode)) { 230 if (pos > i_size_read(inode)) {
259 mutex_lock(&inode->i_mutex); 231 mutex_lock(&inode->i_mutex);
@@ -277,8 +249,8 @@ static int ncp_release(struct inode *inode, struct file *file) {
277const struct file_operations ncp_file_operations = 249const struct file_operations ncp_file_operations =
278{ 250{
279 .llseek = generic_file_llseek, 251 .llseek = generic_file_llseek,
280 .read = ncp_file_read, 252 .read_iter = ncp_file_read_iter,
281 .write = ncp_file_write, 253 .write_iter = ncp_file_write_iter,
282 .unlocked_ioctl = ncp_ioctl, 254 .unlocked_ioctl = ncp_ioctl,
283#ifdef CONFIG_COMPAT 255#ifdef CONFIG_COMPAT
284 .compat_ioctl = ncp_compat_ioctl, 256 .compat_ioctl = ncp_compat_ioctl,
diff --git a/fs/ncpfs/ncplib_kernel.c b/fs/ncpfs/ncplib_kernel.c
index 482387532f54..2b502a0d7941 100644
--- a/fs/ncpfs/ncplib_kernel.c
+++ b/fs/ncpfs/ncplib_kernel.c
@@ -1001,8 +1001,8 @@ out:
1001 */ 1001 */
1002int 1002int
1003ncp_read_bounce(struct ncp_server *server, const char *file_id, 1003ncp_read_bounce(struct ncp_server *server, const char *file_id,
1004 __u32 offset, __u16 to_read, char __user *target, int *bytes_read, 1004 __u32 offset, __u16 to_read, struct iov_iter *to,
1005 void* bounce, __u32 bufsize) 1005 int *bytes_read, void *bounce, __u32 bufsize)
1006{ 1006{
1007 int result; 1007 int result;
1008 1008
@@ -1025,7 +1025,7 @@ ncp_read_bounce(struct ncp_server *server, const char *file_id,
1025 (offset & 1); 1025 (offset & 1);
1026 *bytes_read = len; 1026 *bytes_read = len;
1027 result = 0; 1027 result = 0;
1028 if (copy_to_user(target, source, len)) 1028 if (copy_to_iter(source, len, to) != len)
1029 result = -EFAULT; 1029 result = -EFAULT;
1030 } 1030 }
1031 } 1031 }
diff --git a/fs/ncpfs/ncplib_kernel.h b/fs/ncpfs/ncplib_kernel.h
index 250e443a07f3..5233fbc1747a 100644
--- a/fs/ncpfs/ncplib_kernel.h
+++ b/fs/ncpfs/ncplib_kernel.h
@@ -53,7 +53,7 @@ static inline int ncp_read_bounce_size(__u32 size) {
53 return sizeof(struct ncp_reply_header) + 2 + 2 + size + 8; 53 return sizeof(struct ncp_reply_header) + 2 + 2 + size + 8;
54}; 54};
55int ncp_read_bounce(struct ncp_server *, const char *, __u32, __u16, 55int ncp_read_bounce(struct ncp_server *, const char *, __u32, __u16,
56 char __user *, int *, void* bounce, __u32 bouncelen); 56 struct iov_iter *, int *, void *bounce, __u32 bouncelen);
57int ncp_read_kernel(struct ncp_server *, const char *, __u32, __u16, 57int ncp_read_kernel(struct ncp_server *, const char *, __u32, __u16,
58 char *, int *); 58 char *, int *);
59int ncp_write_kernel(struct ncp_server *, const char *, __u32, __u16, 59int ncp_write_kernel(struct ncp_server *, const char *, __u32, __u16,
diff --git a/fs/nfs/file.c b/fs/nfs/file.c
index 37b15582e0de..f6a3adedf027 100644
--- a/fs/nfs/file.c
+++ b/fs/nfs/file.c
@@ -926,8 +926,6 @@ EXPORT_SYMBOL_GPL(nfs_flock);
926 926
927const struct file_operations nfs_file_operations = { 927const struct file_operations nfs_file_operations = {
928 .llseek = nfs_file_llseek, 928 .llseek = nfs_file_llseek,
929 .read = new_sync_read,
930 .write = new_sync_write,
931 .read_iter = nfs_file_read, 929 .read_iter = nfs_file_read,
932 .write_iter = nfs_file_write, 930 .write_iter = nfs_file_write,
933 .mmap = nfs_file_mmap, 931 .mmap = nfs_file_mmap,
diff --git a/fs/nfs/nfs4file.c b/fs/nfs/nfs4file.c
index 8b46389c4c5b..0181cde1d102 100644
--- a/fs/nfs/nfs4file.c
+++ b/fs/nfs/nfs4file.c
@@ -170,8 +170,6 @@ const struct file_operations nfs4_file_operations = {
170#else 170#else
171 .llseek = nfs_file_llseek, 171 .llseek = nfs_file_llseek,
172#endif 172#endif
173 .read = new_sync_read,
174 .write = new_sync_write,
175 .read_iter = nfs_file_read, 173 .read_iter = nfs_file_read,
176 .write_iter = nfs_file_write, 174 .write_iter = nfs_file_write,
177 .mmap = nfs_file_mmap, 175 .mmap = nfs_file_mmap,
diff --git a/fs/nilfs2/file.c b/fs/nilfs2/file.c
index a8c728acb7a8..54575e3cc1a2 100644
--- a/fs/nilfs2/file.c
+++ b/fs/nilfs2/file.c
@@ -143,8 +143,6 @@ static int nilfs_file_mmap(struct file *file, struct vm_area_struct *vma)
143 */ 143 */
144const struct file_operations nilfs_file_operations = { 144const struct file_operations nilfs_file_operations = {
145 .llseek = generic_file_llseek, 145 .llseek = generic_file_llseek,
146 .read = new_sync_read,
147 .write = new_sync_write,
148 .read_iter = generic_file_read_iter, 146 .read_iter = generic_file_read_iter,
149 .write_iter = generic_file_write_iter, 147 .write_iter = generic_file_write_iter,
150 .unlocked_ioctl = nilfs_ioctl, 148 .unlocked_ioctl = nilfs_ioctl,
diff --git a/fs/ntfs/file.c b/fs/ntfs/file.c
index c1da78dad1af..840e95e3f1d2 100644
--- a/fs/ntfs/file.c
+++ b/fs/ntfs/file.c
@@ -2048,10 +2048,8 @@ static int ntfs_file_fsync(struct file *filp, loff_t start, loff_t end,
2048 2048
2049const struct file_operations ntfs_file_ops = { 2049const struct file_operations ntfs_file_ops = {
2050 .llseek = generic_file_llseek, 2050 .llseek = generic_file_llseek,
2051 .read = new_sync_read,
2052 .read_iter = generic_file_read_iter, 2051 .read_iter = generic_file_read_iter,
2053#ifdef NTFS_RW 2052#ifdef NTFS_RW
2054 .write = new_sync_write,
2055 .write_iter = ntfs_file_write_iter, 2053 .write_iter = ntfs_file_write_iter,
2056 .fsync = ntfs_file_fsync, 2054 .fsync = ntfs_file_fsync,
2057#endif /* NTFS_RW */ 2055#endif /* NTFS_RW */
diff --git a/fs/ocfs2/file.c b/fs/ocfs2/file.c
index 91f03ce98108..8c48e989beba 100644
--- a/fs/ocfs2/file.c
+++ b/fs/ocfs2/file.c
@@ -2681,8 +2681,6 @@ const struct inode_operations ocfs2_special_file_iops = {
2681 */ 2681 */
2682const struct file_operations ocfs2_fops = { 2682const struct file_operations ocfs2_fops = {
2683 .llseek = ocfs2_file_llseek, 2683 .llseek = ocfs2_file_llseek,
2684 .read = new_sync_read,
2685 .write = new_sync_write,
2686 .mmap = ocfs2_mmap, 2684 .mmap = ocfs2_mmap,
2687 .fsync = ocfs2_sync_file, 2685 .fsync = ocfs2_sync_file,
2688 .release = ocfs2_file_release, 2686 .release = ocfs2_file_release,
@@ -2729,8 +2727,6 @@ const struct file_operations ocfs2_dops = {
2729 */ 2727 */
2730const struct file_operations ocfs2_fops_no_plocks = { 2728const struct file_operations ocfs2_fops_no_plocks = {
2731 .llseek = ocfs2_file_llseek, 2729 .llseek = ocfs2_file_llseek,
2732 .read = new_sync_read,
2733 .write = new_sync_write,
2734 .mmap = ocfs2_mmap, 2730 .mmap = ocfs2_mmap,
2735 .fsync = ocfs2_sync_file, 2731 .fsync = ocfs2_sync_file,
2736 .release = ocfs2_file_release, 2732 .release = ocfs2_file_release,
diff --git a/fs/omfs/file.c b/fs/omfs/file.c
index 902e88527fce..f993be7f2156 100644
--- a/fs/omfs/file.c
+++ b/fs/omfs/file.c
@@ -337,8 +337,6 @@ static sector_t omfs_bmap(struct address_space *mapping, sector_t block)
337 337
338const struct file_operations omfs_file_operations = { 338const struct file_operations omfs_file_operations = {
339 .llseek = generic_file_llseek, 339 .llseek = generic_file_llseek,
340 .read = new_sync_read,
341 .write = new_sync_write,
342 .read_iter = generic_file_read_iter, 340 .read_iter = generic_file_read_iter,
343 .write_iter = generic_file_write_iter, 341 .write_iter = generic_file_write_iter,
344 .mmap = generic_file_mmap, 342 .mmap = generic_file_mmap,
diff --git a/fs/open.c b/fs/open.c
index 6a83c47d5904..6796f04d6032 100644
--- a/fs/open.c
+++ b/fs/open.c
@@ -734,10 +734,10 @@ static int do_dentry_open(struct file *f,
734 if ((f->f_mode & (FMODE_READ | FMODE_WRITE)) == FMODE_READ) 734 if ((f->f_mode & (FMODE_READ | FMODE_WRITE)) == FMODE_READ)
735 i_readcount_inc(inode); 735 i_readcount_inc(inode);
736 if ((f->f_mode & FMODE_READ) && 736 if ((f->f_mode & FMODE_READ) &&
737 likely(f->f_op->read || f->f_op->aio_read || f->f_op->read_iter)) 737 likely(f->f_op->read || f->f_op->read_iter))
738 f->f_mode |= FMODE_CAN_READ; 738 f->f_mode |= FMODE_CAN_READ;
739 if ((f->f_mode & FMODE_WRITE) && 739 if ((f->f_mode & FMODE_WRITE) &&
740 likely(f->f_op->write || f->f_op->aio_write || f->f_op->write_iter)) 740 likely(f->f_op->write || f->f_op->write_iter))
741 f->f_mode |= FMODE_CAN_WRITE; 741 f->f_mode |= FMODE_CAN_WRITE;
742 742
743 f->f_flags &= ~(O_CREAT | O_EXCL | O_NOCTTY | O_TRUNC); 743 f->f_flags &= ~(O_CREAT | O_EXCL | O_NOCTTY | O_TRUNC);
diff --git a/fs/pipe.c b/fs/pipe.c
index 2d084f2d0b83..822da5b7cff0 100644
--- a/fs/pipe.c
+++ b/fs/pipe.c
@@ -946,9 +946,7 @@ err:
946const struct file_operations pipefifo_fops = { 946const struct file_operations pipefifo_fops = {
947 .open = fifo_open, 947 .open = fifo_open,
948 .llseek = no_llseek, 948 .llseek = no_llseek,
949 .read = new_sync_read,
950 .read_iter = pipe_read, 949 .read_iter = pipe_read,
951 .write = new_sync_write,
952 .write_iter = pipe_write, 950 .write_iter = pipe_write,
953 .poll = pipe_poll, 951 .poll = pipe_poll,
954 .unlocked_ioctl = pipe_ioctl, 952 .unlocked_ioctl = pipe_ioctl,
diff --git a/fs/ramfs/file-mmu.c b/fs/ramfs/file-mmu.c
index 4f56de822d2f..183a212694bf 100644
--- a/fs/ramfs/file-mmu.c
+++ b/fs/ramfs/file-mmu.c
@@ -31,9 +31,7 @@
31#include "internal.h" 31#include "internal.h"
32 32
33const struct file_operations ramfs_file_operations = { 33const struct file_operations ramfs_file_operations = {
34 .read = new_sync_read,
35 .read_iter = generic_file_read_iter, 34 .read_iter = generic_file_read_iter,
36 .write = new_sync_write,
37 .write_iter = generic_file_write_iter, 35 .write_iter = generic_file_write_iter,
38 .mmap = generic_file_mmap, 36 .mmap = generic_file_mmap,
39 .fsync = noop_fsync, 37 .fsync = noop_fsync,
diff --git a/fs/ramfs/file-nommu.c b/fs/ramfs/file-nommu.c
index f6ab41b39612..0b38befa69f3 100644
--- a/fs/ramfs/file-nommu.c
+++ b/fs/ramfs/file-nommu.c
@@ -44,9 +44,7 @@ const struct file_operations ramfs_file_operations = {
44 .mmap_capabilities = ramfs_mmap_capabilities, 44 .mmap_capabilities = ramfs_mmap_capabilities,
45 .mmap = ramfs_nommu_mmap, 45 .mmap = ramfs_nommu_mmap,
46 .get_unmapped_area = ramfs_nommu_get_unmapped_area, 46 .get_unmapped_area = ramfs_nommu_get_unmapped_area,
47 .read = new_sync_read,
48 .read_iter = generic_file_read_iter, 47 .read_iter = generic_file_read_iter,
49 .write = new_sync_write,
50 .write_iter = generic_file_write_iter, 48 .write_iter = generic_file_write_iter,
51 .fsync = noop_fsync, 49 .fsync = noop_fsync,
52 .splice_read = generic_file_splice_read, 50 .splice_read = generic_file_splice_read,
diff --git a/fs/read_write.c b/fs/read_write.c
index 69128b378646..45d583c33879 100644
--- a/fs/read_write.c
+++ b/fs/read_write.c
@@ -22,13 +22,10 @@
22#include <asm/unistd.h> 22#include <asm/unistd.h>
23 23
24typedef ssize_t (*io_fn_t)(struct file *, char __user *, size_t, loff_t *); 24typedef ssize_t (*io_fn_t)(struct file *, char __user *, size_t, loff_t *);
25typedef ssize_t (*iov_fn_t)(struct kiocb *, const struct iovec *,
26 unsigned long, loff_t);
27typedef ssize_t (*iter_fn_t)(struct kiocb *, struct iov_iter *); 25typedef ssize_t (*iter_fn_t)(struct kiocb *, struct iov_iter *);
28 26
29const struct file_operations generic_ro_fops = { 27const struct file_operations generic_ro_fops = {
30 .llseek = generic_file_llseek, 28 .llseek = generic_file_llseek,
31 .read = new_sync_read,
32 .read_iter = generic_file_read_iter, 29 .read_iter = generic_file_read_iter,
33 .mmap = generic_file_readonly_mmap, 30 .mmap = generic_file_readonly_mmap,
34 .splice_read = generic_file_splice_read, 31 .splice_read = generic_file_splice_read,
@@ -411,24 +408,7 @@ int rw_verify_area(int read_write, struct file *file, const loff_t *ppos, size_t
411 return count > MAX_RW_COUNT ? MAX_RW_COUNT : count; 408 return count > MAX_RW_COUNT ? MAX_RW_COUNT : count;
412} 409}
413 410
414ssize_t do_sync_read(struct file *filp, char __user *buf, size_t len, loff_t *ppos) 411static ssize_t new_sync_read(struct file *filp, char __user *buf, size_t len, loff_t *ppos)
415{
416 struct iovec iov = { .iov_base = buf, .iov_len = len };
417 struct kiocb kiocb;
418 ssize_t ret;
419
420 init_sync_kiocb(&kiocb, filp);
421 kiocb.ki_pos = *ppos;
422
423 ret = filp->f_op->aio_read(&kiocb, &iov, 1, kiocb.ki_pos);
424 BUG_ON(ret == -EIOCBQUEUED);
425 *ppos = kiocb.ki_pos;
426 return ret;
427}
428
429EXPORT_SYMBOL(do_sync_read);
430
431ssize_t new_sync_read(struct file *filp, char __user *buf, size_t len, loff_t *ppos)
432{ 412{
433 struct iovec iov = { .iov_base = buf, .iov_len = len }; 413 struct iovec iov = { .iov_base = buf, .iov_len = len };
434 struct kiocb kiocb; 414 struct kiocb kiocb;
@@ -445,24 +425,17 @@ ssize_t new_sync_read(struct file *filp, char __user *buf, size_t len, loff_t *p
445 return ret; 425 return ret;
446} 426}
447 427
448EXPORT_SYMBOL(new_sync_read);
449
450ssize_t __vfs_read(struct file *file, char __user *buf, size_t count, 428ssize_t __vfs_read(struct file *file, char __user *buf, size_t count,
451 loff_t *pos) 429 loff_t *pos)
452{ 430{
453 ssize_t ret;
454
455 if (file->f_op->read) 431 if (file->f_op->read)
456 ret = file->f_op->read(file, buf, count, pos); 432 return file->f_op->read(file, buf, count, pos);
457 else if (file->f_op->aio_read)
458 ret = do_sync_read(file, buf, count, pos);
459 else if (file->f_op->read_iter) 433 else if (file->f_op->read_iter)
460 ret = new_sync_read(file, buf, count, pos); 434 return new_sync_read(file, buf, count, pos);
461 else 435 else
462 ret = -EINVAL; 436 return -EINVAL;
463
464 return ret;
465} 437}
438EXPORT_SYMBOL(__vfs_read);
466 439
467ssize_t vfs_read(struct file *file, char __user *buf, size_t count, loff_t *pos) 440ssize_t vfs_read(struct file *file, char __user *buf, size_t count, loff_t *pos)
468{ 441{
@@ -491,24 +464,7 @@ ssize_t vfs_read(struct file *file, char __user *buf, size_t count, loff_t *pos)
491 464
492EXPORT_SYMBOL(vfs_read); 465EXPORT_SYMBOL(vfs_read);
493 466
494ssize_t do_sync_write(struct file *filp, const char __user *buf, size_t len, loff_t *ppos) 467static ssize_t new_sync_write(struct file *filp, const char __user *buf, size_t len, loff_t *ppos)
495{
496 struct iovec iov = { .iov_base = (void __user *)buf, .iov_len = len };
497 struct kiocb kiocb;
498 ssize_t ret;
499
500 init_sync_kiocb(&kiocb, filp);
501 kiocb.ki_pos = *ppos;
502
503 ret = filp->f_op->aio_write(&kiocb, &iov, 1, kiocb.ki_pos);
504 BUG_ON(ret == -EIOCBQUEUED);
505 *ppos = kiocb.ki_pos;
506 return ret;
507}
508
509EXPORT_SYMBOL(do_sync_write);
510
511ssize_t new_sync_write(struct file *filp, const char __user *buf, size_t len, loff_t *ppos)
512{ 468{
513 struct iovec iov = { .iov_base = (void __user *)buf, .iov_len = len }; 469 struct iovec iov = { .iov_base = (void __user *)buf, .iov_len = len };
514 struct kiocb kiocb; 470 struct kiocb kiocb;
@@ -525,7 +481,17 @@ ssize_t new_sync_write(struct file *filp, const char __user *buf, size_t len, lo
525 return ret; 481 return ret;
526} 482}
527 483
528EXPORT_SYMBOL(new_sync_write); 484ssize_t __vfs_write(struct file *file, const char __user *p, size_t count,
485 loff_t *pos)
486{
487 if (file->f_op->write)
488 return file->f_op->write(file, p, count, pos);
489 else if (file->f_op->write_iter)
490 return new_sync_write(file, p, count, pos);
491 else
492 return -EINVAL;
493}
494EXPORT_SYMBOL(__vfs_write);
529 495
530ssize_t __kernel_write(struct file *file, const char *buf, size_t count, loff_t *pos) 496ssize_t __kernel_write(struct file *file, const char *buf, size_t count, loff_t *pos)
531{ 497{
@@ -541,12 +507,7 @@ ssize_t __kernel_write(struct file *file, const char *buf, size_t count, loff_t
541 p = (__force const char __user *)buf; 507 p = (__force const char __user *)buf;
542 if (count > MAX_RW_COUNT) 508 if (count > MAX_RW_COUNT)
543 count = MAX_RW_COUNT; 509 count = MAX_RW_COUNT;
544 if (file->f_op->write) 510 ret = __vfs_write(file, p, count, pos);
545 ret = file->f_op->write(file, p, count, pos);
546 else if (file->f_op->aio_write)
547 ret = do_sync_write(file, p, count, pos);
548 else
549 ret = new_sync_write(file, p, count, pos);
550 set_fs(old_fs); 511 set_fs(old_fs);
551 if (ret > 0) { 512 if (ret > 0) {
552 fsnotify_modify(file); 513 fsnotify_modify(file);
@@ -573,12 +534,7 @@ ssize_t vfs_write(struct file *file, const char __user *buf, size_t count, loff_
573 if (ret >= 0) { 534 if (ret >= 0) {
574 count = ret; 535 count = ret;
575 file_start_write(file); 536 file_start_write(file);
576 if (file->f_op->write) 537 ret = __vfs_write(file, buf, count, pos);
577 ret = file->f_op->write(file, buf, count, pos);
578 else if (file->f_op->aio_write)
579 ret = do_sync_write(file, buf, count, pos);
580 else
581 ret = new_sync_write(file, buf, count, pos);
582 if (ret > 0) { 538 if (ret > 0) {
583 fsnotify_modify(file); 539 fsnotify_modify(file);
584 add_wchar(current, ret); 540 add_wchar(current, ret);
@@ -710,21 +666,6 @@ static ssize_t do_iter_readv_writev(struct file *filp, struct iov_iter *iter,
710 return ret; 666 return ret;
711} 667}
712 668
713static ssize_t do_sync_readv_writev(struct file *filp, struct iov_iter *iter,
714 loff_t *ppos, iov_fn_t fn)
715{
716 struct kiocb kiocb;
717 ssize_t ret;
718
719 init_sync_kiocb(&kiocb, filp);
720 kiocb.ki_pos = *ppos;
721
722 ret = fn(&kiocb, iter->iov, iter->nr_segs, kiocb.ki_pos);
723 BUG_ON(ret == -EIOCBQUEUED);
724 *ppos = kiocb.ki_pos;
725 return ret;
726}
727
728/* Do it by hand, with file-ops */ 669/* Do it by hand, with file-ops */
729static ssize_t do_loop_readv_writev(struct file *filp, struct iov_iter *iter, 670static ssize_t do_loop_readv_writev(struct file *filp, struct iov_iter *iter,
730 loff_t *ppos, io_fn_t fn) 671 loff_t *ppos, io_fn_t fn)
@@ -839,7 +780,6 @@ static ssize_t do_readv_writev(int type, struct file *file,
839 struct iov_iter iter; 780 struct iov_iter iter;
840 ssize_t ret; 781 ssize_t ret;
841 io_fn_t fn; 782 io_fn_t fn;
842 iov_fn_t fnv;
843 iter_fn_t iter_fn; 783 iter_fn_t iter_fn;
844 784
845 ret = import_iovec(type, uvector, nr_segs, 785 ret = import_iovec(type, uvector, nr_segs,
@@ -854,22 +794,17 @@ static ssize_t do_readv_writev(int type, struct file *file,
854 if (ret < 0) 794 if (ret < 0)
855 goto out; 795 goto out;
856 796
857 fnv = NULL;
858 if (type == READ) { 797 if (type == READ) {
859 fn = file->f_op->read; 798 fn = file->f_op->read;
860 fnv = file->f_op->aio_read;
861 iter_fn = file->f_op->read_iter; 799 iter_fn = file->f_op->read_iter;
862 } else { 800 } else {
863 fn = (io_fn_t)file->f_op->write; 801 fn = (io_fn_t)file->f_op->write;
864 fnv = file->f_op->aio_write;
865 iter_fn = file->f_op->write_iter; 802 iter_fn = file->f_op->write_iter;
866 file_start_write(file); 803 file_start_write(file);
867 } 804 }
868 805
869 if (iter_fn) 806 if (iter_fn)
870 ret = do_iter_readv_writev(file, &iter, pos, iter_fn); 807 ret = do_iter_readv_writev(file, &iter, pos, iter_fn);
871 else if (fnv)
872 ret = do_sync_readv_writev(file, &iter, pos, fnv);
873 else 808 else
874 ret = do_loop_readv_writev(file, &iter, pos, fn); 809 ret = do_loop_readv_writev(file, &iter, pos, fn);
875 810
@@ -1019,7 +954,6 @@ static ssize_t compat_do_readv_writev(int type, struct file *file,
1019 struct iov_iter iter; 954 struct iov_iter iter;
1020 ssize_t ret; 955 ssize_t ret;
1021 io_fn_t fn; 956 io_fn_t fn;
1022 iov_fn_t fnv;
1023 iter_fn_t iter_fn; 957 iter_fn_t iter_fn;
1024 958
1025 ret = compat_import_iovec(type, uvector, nr_segs, 959 ret = compat_import_iovec(type, uvector, nr_segs,
@@ -1034,22 +968,17 @@ static ssize_t compat_do_readv_writev(int type, struct file *file,
1034 if (ret < 0) 968 if (ret < 0)
1035 goto out; 969 goto out;
1036 970
1037 fnv = NULL;
1038 if (type == READ) { 971 if (type == READ) {
1039 fn = file->f_op->read; 972 fn = file->f_op->read;
1040 fnv = file->f_op->aio_read;
1041 iter_fn = file->f_op->read_iter; 973 iter_fn = file->f_op->read_iter;
1042 } else { 974 } else {
1043 fn = (io_fn_t)file->f_op->write; 975 fn = (io_fn_t)file->f_op->write;
1044 fnv = file->f_op->aio_write;
1045 iter_fn = file->f_op->write_iter; 976 iter_fn = file->f_op->write_iter;
1046 file_start_write(file); 977 file_start_write(file);
1047 } 978 }
1048 979
1049 if (iter_fn) 980 if (iter_fn)
1050 ret = do_iter_readv_writev(file, &iter, pos, iter_fn); 981 ret = do_iter_readv_writev(file, &iter, pos, iter_fn);
1051 else if (fnv)
1052 ret = do_sync_readv_writev(file, &iter, pos, fnv);
1053 else 982 else
1054 ret = do_loop_readv_writev(file, &iter, pos, fn); 983 ret = do_loop_readv_writev(file, &iter, pos, fn);
1055 984
diff --git a/fs/reiserfs/file.c b/fs/reiserfs/file.c
index 751dd3f4346b..96a1bcf33db4 100644
--- a/fs/reiserfs/file.c
+++ b/fs/reiserfs/file.c
@@ -243,8 +243,6 @@ drop_write_lock:
243} 243}
244 244
245const struct file_operations reiserfs_file_operations = { 245const struct file_operations reiserfs_file_operations = {
246 .read = new_sync_read,
247 .write = new_sync_write,
248 .unlocked_ioctl = reiserfs_ioctl, 246 .unlocked_ioctl = reiserfs_ioctl,
249#ifdef CONFIG_COMPAT 247#ifdef CONFIG_COMPAT
250 .compat_ioctl = reiserfs_compat_ioctl, 248 .compat_ioctl = reiserfs_compat_ioctl,
diff --git a/fs/romfs/mmap-nommu.c b/fs/romfs/mmap-nommu.c
index 7da9e2153953..1118a0dc6b45 100644
--- a/fs/romfs/mmap-nommu.c
+++ b/fs/romfs/mmap-nommu.c
@@ -81,7 +81,6 @@ static unsigned romfs_mmap_capabilities(struct file *file)
81 81
82const struct file_operations romfs_ro_fops = { 82const struct file_operations romfs_ro_fops = {
83 .llseek = generic_file_llseek, 83 .llseek = generic_file_llseek,
84 .read = new_sync_read,
85 .read_iter = generic_file_read_iter, 84 .read_iter = generic_file_read_iter,
86 .splice_read = generic_file_splice_read, 85 .splice_read = generic_file_splice_read,
87 .mmap = romfs_mmap, 86 .mmap = romfs_mmap,
diff --git a/fs/sysv/file.c b/fs/sysv/file.c
index b00811c75b24..a48e30410ad1 100644
--- a/fs/sysv/file.c
+++ b/fs/sysv/file.c
@@ -21,9 +21,7 @@
21 */ 21 */
22const struct file_operations sysv_file_operations = { 22const struct file_operations sysv_file_operations = {
23 .llseek = generic_file_llseek, 23 .llseek = generic_file_llseek,
24 .read = new_sync_read,
25 .read_iter = generic_file_read_iter, 24 .read_iter = generic_file_read_iter,
26 .write = new_sync_write,
27 .write_iter = generic_file_write_iter, 25 .write_iter = generic_file_write_iter,
28 .mmap = generic_file_mmap, 26 .mmap = generic_file_mmap,
29 .fsync = generic_file_fsync, 27 .fsync = generic_file_fsync,
diff --git a/fs/ubifs/file.c b/fs/ubifs/file.c
index c3d15fe83403..475b15635f11 100644
--- a/fs/ubifs/file.c
+++ b/fs/ubifs/file.c
@@ -1580,8 +1580,6 @@ const struct inode_operations ubifs_symlink_inode_operations = {
1580 1580
1581const struct file_operations ubifs_file_operations = { 1581const struct file_operations ubifs_file_operations = {
1582 .llseek = generic_file_llseek, 1582 .llseek = generic_file_llseek,
1583 .read = new_sync_read,
1584 .write = new_sync_write,
1585 .read_iter = generic_file_read_iter, 1583 .read_iter = generic_file_read_iter,
1586 .write_iter = ubifs_write_iter, 1584 .write_iter = ubifs_write_iter,
1587 .mmap = ubifs_file_mmap, 1585 .mmap = ubifs_file_mmap,
diff --git a/fs/udf/file.c b/fs/udf/file.c
index 7f885cc8b0b7..74050bff64f4 100644
--- a/fs/udf/file.c
+++ b/fs/udf/file.c
@@ -240,12 +240,10 @@ static int udf_release_file(struct inode *inode, struct file *filp)
240} 240}
241 241
242const struct file_operations udf_file_operations = { 242const struct file_operations udf_file_operations = {
243 .read = new_sync_read,
244 .read_iter = generic_file_read_iter, 243 .read_iter = generic_file_read_iter,
245 .unlocked_ioctl = udf_ioctl, 244 .unlocked_ioctl = udf_ioctl,
246 .open = generic_file_open, 245 .open = generic_file_open,
247 .mmap = generic_file_mmap, 246 .mmap = generic_file_mmap,
248 .write = new_sync_write,
249 .write_iter = udf_file_write_iter, 247 .write_iter = udf_file_write_iter,
250 .release = udf_release_file, 248 .release = udf_release_file,
251 .fsync = generic_file_fsync, 249 .fsync = generic_file_fsync,
diff --git a/fs/ufs/file.c b/fs/ufs/file.c
index c84ec010a676..042ddbf110cc 100644
--- a/fs/ufs/file.c
+++ b/fs/ufs/file.c
@@ -35,9 +35,7 @@
35 35
36const struct file_operations ufs_file_operations = { 36const struct file_operations ufs_file_operations = {
37 .llseek = generic_file_llseek, 37 .llseek = generic_file_llseek,
38 .read = new_sync_read,
39 .read_iter = generic_file_read_iter, 38 .read_iter = generic_file_read_iter,
40 .write = new_sync_write,
41 .write_iter = generic_file_write_iter, 39 .write_iter = generic_file_write_iter,
42 .mmap = generic_file_mmap, 40 .mmap = generic_file_mmap,
43 .open = generic_file_open, 41 .open = generic_file_open,
diff --git a/fs/xfs/xfs_file.c b/fs/xfs/xfs_file.c
index f44212fae653..44856c3b9617 100644
--- a/fs/xfs/xfs_file.c
+++ b/fs/xfs/xfs_file.c
@@ -1386,8 +1386,6 @@ xfs_file_llseek(
1386 1386
1387const struct file_operations xfs_file_operations = { 1387const struct file_operations xfs_file_operations = {
1388 .llseek = xfs_file_llseek, 1388 .llseek = xfs_file_llseek,
1389 .read = new_sync_read,
1390 .write = new_sync_write,
1391 .read_iter = xfs_file_read_iter, 1389 .read_iter = xfs_file_read_iter,
1392 .write_iter = xfs_file_write_iter, 1390 .write_iter = xfs_file_write_iter,
1393 .splice_read = xfs_file_splice_read, 1391 .splice_read = xfs_file_splice_read,
generated by cgit v1.2.2 (git 2.25.0) at 2025-02-23 06:00:16 -0500