+2 -2

drivers/block/loop.c

reviewed

··· 445 445 cmd->iocb.ki_ioprio = IOPRIO_PRIO_VALUE(IOPRIO_CLASS_NONE, 0); 446 446 447 447 if (rw == ITER_SOURCE) 448 448 - ret = call_write_iter(file, &cmd->iocb, &iter); 448 448 + ret = file->f_op->write_iter(&cmd->iocb, &iter); 449 449 else 450 450 - ret = call_read_iter(file, &cmd->iocb, &iter); 450 450 + ret = file->f_op->read_iter(&cmd->iocb, &iter); 451 451 452 452 lo_rw_aio_do_completion(cmd); 453 453

+2 -2

drivers/target/target_core_file.c

reviewed

··· 299 299 aio_cmd->iocb.ki_flags |= IOCB_DSYNC; 300 300 301 301 if (is_write) 302 302 - ret = call_write_iter(file, &aio_cmd->iocb, &iter); 302 302 + ret = file->f_op->write_iter(&aio_cmd->iocb, &iter); 303 303 else 304 304 - ret = call_read_iter(file, &aio_cmd->iocb, &iter); 304 304 + ret = file->f_op->read_iter(&aio_cmd->iocb, &iter); 305 305 306 306 if (ret != -EIOCBQUEUED) 307 307 cmd_rw_aio_complete(&aio_cmd->iocb, ret);

+2 -2

fs/aio.c

reviewed

··· 1608 1608 return ret; 1609 1609 ret = rw_verify_area(READ, file, &req->ki_pos, iov_iter_count(&iter)); 1610 1610 if (!ret) 1611 1611 - aio_rw_done(req, call_read_iter(file, req, &iter)); 1611 1611 + aio_rw_done(req, file->f_op->read_iter(req, &iter)); 1612 1612 kfree(iovec); 1613 1613 return ret; 1614 1614 } ··· 1639 1639 if (S_ISREG(file_inode(file)->i_mode)) 1640 1640 kiocb_start_write(req); 1641 1641 req->ki_flags |= IOCB_WRITE; 1642 1642 - aio_rw_done(req, call_write_iter(file, req, &iter)); 1642 1642 + aio_rw_done(req, file->f_op->write_iter(req, &iter)); 1643 1643 } 1644 1644 kfree(iovec); 1645 1645 return ret;

+1 -2

fs/cachefiles/namei.c

reviewed

··· 563 563 */ 564 564 path.mnt = cache->mnt; 565 565 path.dentry = dentry; 566 566 - file = kernel_file_open(&path, O_RDWR | O_LARGEFILE | O_DIRECT, 567 567 - d_backing_inode(dentry), cache->cache_cred); 566 566 + file = kernel_file_open(&path, O_RDWR | O_LARGEFILE | O_DIRECT, cache->cache_cred); 568 567 if (IS_ERR(file)) { 569 568 trace_cachefiles_vfs_error(object, d_backing_inode(dentry), 570 569 PTR_ERR(file),

+8 -11

fs/file.c

reviewed

··· 271 271 __clear_bit(fd / BITS_PER_LONG, fdt->full_fds_bits); 272 272 } 273 273 274 274 + static inline bool fd_is_open(unsigned int fd, const struct fdtable *fdt) 275 275 + { 276 276 + return test_bit(fd, fdt->open_fds); 277 277 + } 278 278 + 274 279 static unsigned int count_open_files(struct fdtable *fdt) 275 280 { 276 281 unsigned int size = fdt->max_fds; ··· 920 915 struct file __rcu *file; 921 916 922 917 file = __get_file_rcu(f); 923 923 - if (unlikely(!file)) 924 924 - return NULL; 925 925 - 926 926 - if (unlikely(IS_ERR(file))) 927 927 - continue; 928 928 - 929 929 - return file; 918 918 + if (!IS_ERR(file)) 919 919 + return file; 930 920 } 931 921 } 932 922 EXPORT_SYMBOL_GPL(get_file_rcu); ··· 1219 1219 1220 1220 bool get_close_on_exec(unsigned int fd) 1221 1221 { 1222 1222 - struct files_struct *files = current->files; 1223 1223 - struct fdtable *fdt; 1224 1222 bool res; 1225 1223 rcu_read_lock(); 1226 1226 - fdt = files_fdtable(files); 1227 1227 - res = close_on_exec(fd, fdt); 1224 1224 + res = close_on_exec(fd, current->files); 1228 1225 rcu_read_unlock(); 1229 1226 return res; 1230 1227 }

+5 -6

fs/open.c

reviewed

··· 902 902 } 903 903 904 904 static int do_dentry_open(struct file *f, 905 905 - struct inode *inode, 906 905 int (*open)(struct inode *, struct file *)) 907 906 { 908 907 static const struct file_operations empty_fops = {}; 908 908 + struct inode *inode = f->f_path.dentry->d_inode; 909 909 int error; 910 910 911 911 path_get(&f->f_path); ··· 1047 1047 BUG_ON(file->f_mode & FMODE_OPENED); /* once it's opened, it's opened */ 1048 1048 1049 1049 file->f_path.dentry = dentry; 1050 1050 - return do_dentry_open(file, d_backing_inode(dentry), open); 1050 1050 + return do_dentry_open(file, open); 1051 1051 } 1052 1052 EXPORT_SYMBOL(finish_open); 1053 1053 ··· 1086 1086 int vfs_open(const struct path *path, struct file *file) 1087 1087 { 1088 1088 file->f_path = *path; 1089 1089 - return do_dentry_open(file, d_backing_inode(path->dentry), NULL); 1089 1089 + return do_dentry_open(file, NULL); 1090 1090 } 1091 1091 1092 1092 struct file *dentry_open(const struct path *path, int flags, ··· 1155 1155 * kernel_file_open - open a file for kernel internal use 1156 1156 * @path: path of the file to open 1157 1157 * @flags: open flags 1158 1158 - * @inode: the inode 1159 1158 * @cred: credentials for open 1160 1159 * 1161 1160 * Open a file for use by in-kernel consumers. The file is not accounted ··· 1164 1165 * Return: Opened file on success, an error pointer on failure. 1165 1166 */ 1166 1167 struct file *kernel_file_open(const struct path *path, int flags, 1167 1167 - struct inode *inode, const struct cred *cred) 1168 1168 + const struct cred *cred) 1168 1169 { 1169 1170 struct file *f; 1170 1171 int error; ··· 1174 1175 return f; 1175 1176 1176 1177 f->f_path = *path; 1177 1177 - error = do_dentry_open(f, inode, NULL); 1178 1178 + error = do_dentry_open(f, NULL); 1178 1179 if (error) { 1179 1180 fput(f); 1180 1181 f = ERR_PTR(error);

+1 -1

fs/overlayfs/util.c

reviewed

··· 1376 1376 * If this inode was not yet opened, the verity info hasn't been 1377 1377 * loaded yet, so we need to do that here to force it into memory. 1378 1378 */ 1379 1379 - filp = kernel_file_open(datapath, O_RDONLY, inode, current_cred()); 1379 1379 + filp = kernel_file_open(datapath, O_RDONLY, current_cred()); 1380 1380 if (IS_ERR(filp)) 1381 1381 return PTR_ERR(filp); 1382 1382 fput(filp);

+1 -3

fs/proc/fd.c

reviewed

··· 39 39 spin_lock(&files->file_lock); 40 40 file = files_lookup_fd_locked(files, fd); 41 41 if (file) { 42 42 - struct fdtable *fdt = files_fdtable(files); 43 43 - 44 42 f_flags = file->f_flags; 45 45 - if (close_on_exec(fd, fdt)) 43 43 + if (close_on_exec(fd, files)) 46 44 f_flags |= O_CLOEXEC; 47 45 48 46 get_file(file);

+6 -6

fs/read_write.c

reviewed

··· 392 392 kiocb.ki_pos = (ppos ? *ppos : 0); 393 393 iov_iter_ubuf(&iter, ITER_DEST, buf, len); 394 394 395 395 - ret = call_read_iter(filp, &kiocb, &iter); 395 395 + ret = filp->f_op->read_iter(&kiocb, &iter); 396 396 BUG_ON(ret == -EIOCBQUEUED); 397 397 if (ppos) 398 398 *ppos = kiocb.ki_pos; ··· 494 494 kiocb.ki_pos = (ppos ? *ppos : 0); 495 495 iov_iter_ubuf(&iter, ITER_SOURCE, (void __user *)buf, len); 496 496 497 497 - ret = call_write_iter(filp, &kiocb, &iter); 497 497 + ret = filp->f_op->write_iter(&kiocb, &iter); 498 498 BUG_ON(ret == -EIOCBQUEUED); 499 499 if (ret > 0 && ppos) 500 500 *ppos = kiocb.ki_pos; ··· 736 736 kiocb.ki_pos = (ppos ? *ppos : 0); 737 737 738 738 if (type == READ) 739 739 - ret = call_read_iter(filp, &kiocb, iter); 739 739 + ret = filp->f_op->read_iter(&kiocb, iter); 740 740 else 741 741 - ret = call_write_iter(filp, &kiocb, iter); 741 741 + ret = filp->f_op->write_iter(&kiocb, iter); 742 742 BUG_ON(ret == -EIOCBQUEUED); 743 743 if (ppos) 744 744 *ppos = kiocb.ki_pos; ··· 799 799 if (ret < 0) 800 800 return ret; 801 801 802 802 - ret = call_read_iter(file, iocb, iter); 802 802 + ret = file->f_op->read_iter(iocb, iter); 803 803 out: 804 804 if (ret >= 0) 805 805 fsnotify_access(file); ··· 860 860 return ret; 861 861 862 862 kiocb_start_write(iocb); 863 863 - ret = call_write_iter(file, iocb, iter); 863 863 + ret = file->f_op->write_iter(iocb, iter); 864 864 if (ret != -EIOCBQUEUED) 865 865 kiocb_end_write(iocb); 866 866 if (ret > 0)

+2 -2

fs/splice.c

reviewed

··· 362 362 iov_iter_bvec(&to, ITER_DEST, bv, npages, len); 363 363 init_sync_kiocb(&kiocb, in); 364 364 kiocb.ki_pos = *ppos; 365 365 - ret = call_read_iter(in, &kiocb, &to); 365 365 + ret = in->f_op->read_iter(&kiocb, &to); 366 366 367 367 if (ret > 0) { 368 368 keep = DIV_ROUND_UP(ret, PAGE_SIZE); ··· 740 740 iov_iter_bvec(&from, ITER_SOURCE, array, n, sd.total_len - left); 741 741 init_sync_kiocb(&kiocb, out); 742 742 kiocb.ki_pos = sd.pos; 743 743 - ret = call_write_iter(out, &kiocb, &from); 743 743 + ret = out->f_op->write_iter(&kiocb, &from); 744 744 sd.pos = kiocb.ki_pos; 745 745 if (ret <= 0) 746 746 break;

+5 -10

include/linux/fdtable.h

reviewed

··· 33 33 struct rcu_head rcu; 34 34 }; 35 35 36 36 - static inline bool close_on_exec(unsigned int fd, const struct fdtable *fdt) 37 37 - { 38 38 - return test_bit(fd, fdt->close_on_exec); 39 39 - } 40 40 - 41 41 - static inline bool fd_is_open(unsigned int fd, const struct fdtable *fdt) 42 42 - { 43 43 - return test_bit(fd, fdt->open_fds); 44 44 - } 45 45 - 46 36 /* 47 37 * Open file table structure 48 38 */ ··· 96 106 struct file *lookup_fdget_rcu(unsigned int fd); 97 107 struct file *task_lookup_fdget_rcu(struct task_struct *task, unsigned int fd); 98 108 struct file *task_lookup_next_fdget_rcu(struct task_struct *task, unsigned int *fd); 109 109 + 110 110 + static inline bool close_on_exec(unsigned int fd, const struct files_struct *files) 111 111 + { 112 112 + return test_bit(fd, files_fdtable(files)->close_on_exec); 113 113 + } 99 114 100 115 struct task_struct; 101 116

+1 -13

include/linux/fs.h

reviewed

··· 1899 1899 umode_t mode, int open_flag, 1900 1900 const struct cred *cred); 1901 1901 struct file *kernel_file_open(const struct path *path, int flags, 1902 1902 - struct inode *inode, const struct cred *cred); 1902 1902 + const struct cred *cred); 1903 1903 1904 1904 int vfs_mkobj(struct dentry *, umode_t, 1905 1905 int (*f)(struct dentry *, umode_t, void *), ··· 2101 2101 int (*fileattr_get)(struct dentry *dentry, struct fileattr *fa); 2102 2102 struct offset_ctx *(*get_offset_ctx)(struct inode *inode); 2103 2103 } ____cacheline_aligned; 2104 2104 - 2105 2105 - static inline ssize_t call_read_iter(struct file *file, struct kiocb *kio, 2106 2106 - struct iov_iter *iter) 2107 2107 - { 2108 2108 - return file->f_op->read_iter(kio, iter); 2109 2109 - } 2110 2110 - 2111 2111 - static inline ssize_t call_write_iter(struct file *file, struct kiocb *kio, 2112 2112 - struct iov_iter *iter) 2113 2113 - { 2114 2114 - return file->f_op->write_iter(kio, iter); 2115 2115 - } 2116 2104 2117 2105 static inline int call_mmap(struct file *file, struct vm_area_struct *vma) 2118 2106 {

+2 -2

io_uring/rw.c

reviewed

··· 759 759 struct file *file = rw->kiocb.ki_filp; 760 760 761 761 if (likely(file->f_op->read_iter)) 762 762 - return call_read_iter(file, &rw->kiocb, iter); 762 762 + return file->f_op->read_iter(&rw->kiocb, iter); 763 763 else if (file->f_op->read) 764 764 return loop_rw_iter(READ, rw, iter); 765 765 else ··· 1046 1046 kiocb->ki_flags |= IOCB_WRITE; 1047 1047 1048 1048 if (likely(req->file->f_op->write_iter)) 1049 1049 - ret2 = call_write_iter(req->file, kiocb, &io->iter); 1049 1049 + ret2 = req->file->f_op->write_iter(kiocb, &io->iter); 1050 1050 else if (req->file->f_op->write) 1051 1051 ret2 = loop_rw_iter(WRITE, rw, &io->iter); 1052 1052 else