1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * linux/fs/nfs/file.c 4 * 5 * Copyright (C) 1992 Rick Sladkey 6 */ 7 #include <linux/fs.h> 8 #include <linux/file.h> 9 #include <linux/falloc.h> 10 #include <linux/nfs_fs.h> 11 #include <uapi/linux/btrfs.h> /* BTRFS_IOC_CLONE/BTRFS_IOC_CLONE_RANGE */ 12 #include "delegation.h" 13 #include "internal.h" 14 #include "iostat.h" 15 #include "fscache.h" 16 #include "pnfs.h" 17 18 #include "nfstrace.h" 19 20 #ifdef CONFIG_NFS_V4_2 21 #include "nfs42.h" 22 #endif 23 24 #define NFSDBG_FACILITY NFSDBG_FILE 25 26 static int 27 nfs4_file_open(struct inode *inode, struct file *filp) 28 { 29 struct nfs_open_context *ctx; 30 struct dentry *dentry = file_dentry(filp); 31 struct dentry *parent = NULL; 32 struct inode *dir; 33 unsigned openflags = filp->f_flags; 34 struct iattr attr; 35 int err; 36 37 /* 38 * If no cached dentry exists or if it's negative, NFSv4 handled the 39 * opens in ->lookup() or ->create(). 40 * 41 * We only get this far for a cached positive dentry. We skipped 42 * revalidation, so handle it here by dropping the dentry and returning 43 * -EOPENSTALE. The VFS will retry the lookup/create/open. 44 */ 45 46 dprintk("NFS: open file(%pd2)\n", dentry); 47 48 err = nfs_check_flags(openflags); 49 if (err) 50 return err; 51 52 if ((openflags & O_ACCMODE) == 3) 53 openflags--; 54 55 /* We can't create new files here */ 56 openflags &= ~(O_CREAT|O_EXCL); 57 58 parent = dget_parent(dentry); 59 dir = d_inode(parent); 60 61 ctx = alloc_nfs_open_context(file_dentry(filp), filp->f_mode, filp); 62 err = PTR_ERR(ctx); 63 if (IS_ERR(ctx)) 64 goto out; 65 66 attr.ia_valid = ATTR_OPEN; 67 if (openflags & O_TRUNC) { 68 attr.ia_valid |= ATTR_SIZE; 69 attr.ia_size = 0; 70 filemap_write_and_wait(inode->i_mapping); 71 } 72 73 inode = NFS_PROTO(dir)->open_context(dir, ctx, openflags, &attr, NULL); 74 if (IS_ERR(inode)) { 75 err = PTR_ERR(inode); 76 switch (err) { 77 case -EPERM: 78 case -EACCES: 79 case -EDQUOT: 80 case -ENOSPC: 81 case -EROFS: 82 goto out_put_ctx; 83 default: 84 goto out_drop; 85 } 86 } 87 if (inode != d_inode(dentry)) 88 goto out_drop; 89 90 nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 91 nfs_file_set_open_context(filp, ctx); 92 nfs_fscache_open_file(inode, filp); 93 err = 0; 94 95 out_put_ctx: 96 put_nfs_open_context(ctx); 97 out: 98 dput(parent); 99 return err; 100 101 out_drop: 102 d_drop(dentry); 103 err = -EOPENSTALE; 104 goto out_put_ctx; 105 } 106 107 /* 108 * Flush all dirty pages, and check for write errors. 109 */ 110 static int 111 nfs4_file_flush(struct file *file, fl_owner_t id) 112 { 113 struct inode *inode = file_inode(file); 114 115 dprintk("NFS: flush(%pD2)\n", file); 116 117 nfs_inc_stats(inode, NFSIOS_VFSFLUSH); 118 if ((file->f_mode & FMODE_WRITE) == 0) 119 return 0; 120 121 /* 122 * If we're holding a write delegation, then check if we're required 123 * to flush the i/o on close. If not, then just start the i/o now. 124 */ 125 if (!nfs4_delegation_flush_on_close(inode)) 126 return filemap_fdatawrite(file->f_mapping); 127 128 /* Flush writes to the server and return any errors */ 129 return vfs_fsync(file, 0); 130 } 131 132 #ifdef CONFIG_NFS_V4_2 133 static ssize_t nfs4_copy_file_range(struct file *file_in, loff_t pos_in, 134 struct file *file_out, loff_t pos_out, 135 size_t count, unsigned int flags) 136 { 137 if (file_inode(file_in) == file_inode(file_out)) 138 return -EINVAL; 139 140 return nfs42_proc_copy(file_in, pos_in, file_out, pos_out, count); 141 } 142 143 static loff_t nfs4_file_llseek(struct file *filep, loff_t offset, int whence) 144 { 145 loff_t ret; 146 147 switch (whence) { 148 case SEEK_HOLE: 149 case SEEK_DATA: 150 ret = nfs42_proc_llseek(filep, offset, whence); 151 if (ret != -ENOTSUPP) 152 return ret; 153 default: 154 return nfs_file_llseek(filep, offset, whence); 155 } 156 } 157 158 static long nfs42_fallocate(struct file *filep, int mode, loff_t offset, loff_t len) 159 { 160 struct inode *inode = file_inode(filep); 161 long ret; 162 163 if (!S_ISREG(inode->i_mode)) 164 return -EOPNOTSUPP; 165 166 if ((mode != 0) && (mode != (FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE))) 167 return -EOPNOTSUPP; 168 169 ret = inode_newsize_ok(inode, offset + len); 170 if (ret < 0) 171 return ret; 172 173 if (mode & FALLOC_FL_PUNCH_HOLE) 174 return nfs42_proc_deallocate(filep, offset, len); 175 return nfs42_proc_allocate(filep, offset, len); 176 } 177 178 static int nfs42_clone_file_range(struct file *src_file, loff_t src_off, 179 struct file *dst_file, loff_t dst_off, u64 count) 180 { 181 struct inode *dst_inode = file_inode(dst_file); 182 struct nfs_server *server = NFS_SERVER(dst_inode); 183 struct inode *src_inode = file_inode(src_file); 184 unsigned int bs = server->clone_blksize; 185 bool same_inode = false; 186 int ret; 187 188 /* check alignment w.r.t. clone_blksize */ 189 ret = -EINVAL; 190 if (bs) { 191 if (!IS_ALIGNED(src_off, bs) || !IS_ALIGNED(dst_off, bs)) 192 goto out; 193 if (!IS_ALIGNED(count, bs) && i_size_read(src_inode) != (src_off + count)) 194 goto out; 195 } 196 197 if (src_inode == dst_inode) 198 same_inode = true; 199 200 /* XXX: do we lock at all? what if server needs CB_RECALL_LAYOUT? */ 201 if (same_inode) { 202 inode_lock(src_inode); 203 } else if (dst_inode < src_inode) { 204 inode_lock_nested(dst_inode, I_MUTEX_PARENT); 205 inode_lock_nested(src_inode, I_MUTEX_CHILD); 206 } else { 207 inode_lock_nested(src_inode, I_MUTEX_PARENT); 208 inode_lock_nested(dst_inode, I_MUTEX_CHILD); 209 } 210 211 /* flush all pending writes on both src and dst so that server 212 * has the latest data */ 213 ret = nfs_sync_inode(src_inode); 214 if (ret) 215 goto out_unlock; 216 ret = nfs_sync_inode(dst_inode); 217 if (ret) 218 goto out_unlock; 219 220 ret = nfs42_proc_clone(src_file, dst_file, src_off, dst_off, count); 221 222 /* truncate inode page cache of the dst range so that future reads can fetch 223 * new data from server */ 224 if (!ret) 225 truncate_inode_pages_range(&dst_inode->i_data, dst_off, dst_off + count - 1); 226 227 out_unlock: 228 if (same_inode) { 229 inode_unlock(src_inode); 230 } else if (dst_inode < src_inode) { 231 inode_unlock(src_inode); 232 inode_unlock(dst_inode); 233 } else { 234 inode_unlock(dst_inode); 235 inode_unlock(src_inode); 236 } 237 out: 238 return ret; 239 } 240 #endif /* CONFIG_NFS_V4_2 */ 241 242 const struct file_operations nfs4_file_operations = { 243 .read_iter = nfs_file_read, 244 .write_iter = nfs_file_write, 245 .mmap = nfs_file_mmap, 246 .open = nfs4_file_open, 247 .flush = nfs4_file_flush, 248 .release = nfs_file_release, 249 .fsync = nfs_file_fsync, 250 .lock = nfs_lock, 251 .flock = nfs_flock, 252 .splice_read = generic_file_splice_read, 253 .splice_write = iter_file_splice_write, 254 .check_flags = nfs_check_flags, 255 .setlease = simple_nosetlease, 256 #ifdef CONFIG_NFS_V4_2 257 .copy_file_range = nfs4_copy_file_range, 258 .llseek = nfs4_file_llseek, 259 .fallocate = nfs42_fallocate, 260 .clone_file_range = nfs42_clone_file_range, 261 #else 262 .llseek = nfs_file_llseek, 263 #endif 264 }; 265