1 // SPDX-License-Identifier: GPL-2.0
5 * Copyright (C) 1992 Rick Sladkey
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"
20 #ifdef CONFIG_NFS_V4_2
24 #define NFSDBG_FACILITY NFSDBG_FILE
27 nfs4_file_open(struct inode
*inode
, struct file
*filp
)
29 struct nfs_open_context
*ctx
;
30 struct dentry
*dentry
= file_dentry(filp
);
31 struct dentry
*parent
= NULL
;
33 unsigned openflags
= filp
->f_flags
;
38 * If no cached dentry exists or if it's negative, NFSv4 handled the
39 * opens in ->lookup() or ->create().
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.
46 dprintk("NFS: open file(%pd2)\n", dentry
);
48 err
= nfs_check_flags(openflags
);
52 if ((openflags
& O_ACCMODE
) == 3)
53 return nfs_open(inode
, filp
);
55 /* We can't create new files here */
56 openflags
&= ~(O_CREAT
|O_EXCL
);
58 parent
= dget_parent(dentry
);
59 dir
= d_inode(parent
);
61 ctx
= alloc_nfs_open_context(file_dentry(filp
), filp
->f_mode
, filp
);
66 attr
.ia_valid
= ATTR_OPEN
;
67 if (openflags
& O_TRUNC
) {
68 attr
.ia_valid
|= ATTR_SIZE
;
70 filemap_write_and_wait(inode
->i_mapping
);
73 inode
= NFS_PROTO(dir
)->open_context(dir
, ctx
, openflags
, &attr
, NULL
);
87 if (inode
!= d_inode(dentry
))
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
);
96 put_nfs_open_context(ctx
);
108 * Flush all dirty pages, and check for write errors.
111 nfs4_file_flush(struct file
*file
, fl_owner_t id
)
113 struct inode
*inode
= file_inode(file
);
115 dprintk("NFS: flush(%pD2)\n", file
);
117 nfs_inc_stats(inode
, NFSIOS_VFSFLUSH
);
118 if ((file
->f_mode
& FMODE_WRITE
) == 0)
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.
125 if (!nfs4_delegation_flush_on_close(inode
))
126 return filemap_fdatawrite(file
->f_mapping
);
128 /* Flush writes to the server and return any errors */
129 return vfs_fsync(file
, 0);
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
)
137 if (!nfs_server_capable(file_inode(file_out
), NFS_CAP_COPY
))
139 if (file_inode(file_in
) == file_inode(file_out
))
142 return nfs42_proc_copy(file_in
, pos_in
, file_out
, pos_out
, count
);
145 static loff_t
nfs4_file_llseek(struct file
*filep
, loff_t offset
, int whence
)
152 ret
= nfs42_proc_llseek(filep
, offset
, whence
);
153 if (ret
!= -ENOTSUPP
)
156 return nfs_file_llseek(filep
, offset
, whence
);
160 static long nfs42_fallocate(struct file
*filep
, int mode
, loff_t offset
, loff_t len
)
162 struct inode
*inode
= file_inode(filep
);
165 if (!S_ISREG(inode
->i_mode
))
168 if ((mode
!= 0) && (mode
!= (FALLOC_FL_PUNCH_HOLE
| FALLOC_FL_KEEP_SIZE
)))
171 ret
= inode_newsize_ok(inode
, offset
+ len
);
175 if (mode
& FALLOC_FL_PUNCH_HOLE
)
176 return nfs42_proc_deallocate(filep
, offset
, len
);
177 return nfs42_proc_allocate(filep
, offset
, len
);
180 static int nfs42_clone_file_range(struct file
*src_file
, loff_t src_off
,
181 struct file
*dst_file
, loff_t dst_off
, u64 count
)
183 struct inode
*dst_inode
= file_inode(dst_file
);
184 struct nfs_server
*server
= NFS_SERVER(dst_inode
);
185 struct inode
*src_inode
= file_inode(src_file
);
186 unsigned int bs
= server
->clone_blksize
;
187 bool same_inode
= false;
190 /* check alignment w.r.t. clone_blksize */
193 if (!IS_ALIGNED(src_off
, bs
) || !IS_ALIGNED(dst_off
, bs
))
195 if (!IS_ALIGNED(count
, bs
) && i_size_read(src_inode
) != (src_off
+ count
))
199 if (src_inode
== dst_inode
)
202 /* XXX: do we lock at all? what if server needs CB_RECALL_LAYOUT? */
204 inode_lock(src_inode
);
205 } else if (dst_inode
< src_inode
) {
206 inode_lock_nested(dst_inode
, I_MUTEX_PARENT
);
207 inode_lock_nested(src_inode
, I_MUTEX_CHILD
);
209 inode_lock_nested(src_inode
, I_MUTEX_PARENT
);
210 inode_lock_nested(dst_inode
, I_MUTEX_CHILD
);
213 /* flush all pending writes on both src and dst so that server
214 * has the latest data */
215 ret
= nfs_sync_inode(src_inode
);
218 ret
= nfs_sync_inode(dst_inode
);
222 ret
= nfs42_proc_clone(src_file
, dst_file
, src_off
, dst_off
, count
);
224 /* truncate inode page cache of the dst range so that future reads can fetch
225 * new data from server */
227 truncate_inode_pages_range(&dst_inode
->i_data
, dst_off
, dst_off
+ count
- 1);
231 inode_unlock(src_inode
);
232 } else if (dst_inode
< src_inode
) {
233 inode_unlock(src_inode
);
234 inode_unlock(dst_inode
);
236 inode_unlock(dst_inode
);
237 inode_unlock(src_inode
);
242 #endif /* CONFIG_NFS_V4_2 */
244 const struct file_operations nfs4_file_operations
= {
245 .read_iter
= nfs_file_read
,
246 .write_iter
= nfs_file_write
,
247 .mmap
= nfs_file_mmap
,
248 .open
= nfs4_file_open
,
249 .flush
= nfs4_file_flush
,
250 .release
= nfs_file_release
,
251 .fsync
= nfs_file_fsync
,
254 .splice_read
= generic_file_splice_read
,
255 .splice_write
= iter_file_splice_write
,
256 .check_flags
= nfs_check_flags
,
257 .setlease
= simple_nosetlease
,
258 #ifdef CONFIG_NFS_V4_2
259 .copy_file_range
= nfs4_copy_file_range
,
260 .llseek
= nfs4_file_llseek
,
261 .fallocate
= nfs42_fallocate
,
262 .clone_file_range
= nfs42_clone_file_range
,
264 .llseek
= nfs_file_llseek
,