4 * Copyright (C) 1992 Rick Sladkey
7 #include <linux/file.h>
8 #include <linux/falloc.h>
9 #include <linux/nfs_fs.h>
10 #include "delegation.h"
18 #ifdef CONFIG_NFS_V4_2
22 #define NFSDBG_FACILITY NFSDBG_FILE
25 nfs4_file_open(struct inode
*inode
, struct file
*filp
)
27 struct nfs_open_context
*ctx
;
28 struct dentry
*dentry
= filp
->f_path
.dentry
;
29 struct dentry
*parent
= NULL
;
31 unsigned openflags
= filp
->f_flags
;
36 * If no cached dentry exists or if it's negative, NFSv4 handled the
37 * opens in ->lookup() or ->create().
39 * We only get this far for a cached positive dentry. We skipped
40 * revalidation, so handle it here by dropping the dentry and returning
41 * -EOPENSTALE. The VFS will retry the lookup/create/open.
44 dprintk("NFS: open file(%pd2)\n", dentry
);
46 err
= nfs_check_flags(openflags
);
50 if ((openflags
& O_ACCMODE
) == 3)
53 /* We can't create new files here */
54 openflags
&= ~(O_CREAT
|O_EXCL
);
56 parent
= dget_parent(dentry
);
57 dir
= d_inode(parent
);
59 ctx
= alloc_nfs_open_context(filp
->f_path
.dentry
, filp
->f_mode
);
64 attr
.ia_valid
= ATTR_OPEN
;
65 if (openflags
& O_TRUNC
) {
66 attr
.ia_valid
|= ATTR_SIZE
;
68 nfs_sync_inode(inode
);
71 inode
= NFS_PROTO(dir
)->open_context(dir
, ctx
, openflags
, &attr
, NULL
);
85 if (inode
!= d_inode(dentry
))
88 nfs_set_verifier(dentry
, nfs_save_change_attribute(dir
));
89 nfs_file_set_open_context(filp
, ctx
);
90 nfs_fscache_open_file(inode
, filp
);
94 put_nfs_open_context(ctx
);
106 * Flush all dirty pages, and check for write errors.
109 nfs4_file_flush(struct file
*file
, fl_owner_t id
)
111 struct inode
*inode
= file_inode(file
);
113 dprintk("NFS: flush(%pD2)\n", file
);
115 nfs_inc_stats(inode
, NFSIOS_VFSFLUSH
);
116 if ((file
->f_mode
& FMODE_WRITE
) == 0)
120 * If we're holding a write delegation, then check if we're required
121 * to flush the i/o on close. If not, then just start the i/o now.
123 if (!nfs4_delegation_flush_on_close(inode
))
124 return filemap_fdatawrite(file
->f_mapping
);
126 /* Flush writes to the server and return any errors */
127 return vfs_fsync(file
, 0);
131 nfs4_file_fsync(struct file
*file
, loff_t start
, loff_t end
, int datasync
)
134 struct inode
*inode
= file_inode(file
);
136 trace_nfs_fsync_enter(inode
);
138 nfs_inode_dio_wait(inode
);
140 ret
= filemap_write_and_wait_range(inode
->i_mapping
, start
, end
);
143 mutex_lock(&inode
->i_mutex
);
144 ret
= nfs_file_fsync_commit(file
, start
, end
, datasync
);
146 ret
= pnfs_sync_inode(inode
, !!datasync
);
147 mutex_unlock(&inode
->i_mutex
);
149 * If nfs_file_fsync_commit detected a server reboot, then
150 * resend all dirty pages that might have been covered by
151 * the NFS_CONTEXT_RESEND_WRITES flag
155 } while (ret
== -EAGAIN
);
157 trace_nfs_fsync_exit(inode
, ret
);
161 #ifdef CONFIG_NFS_V4_2
162 static loff_t
nfs4_file_llseek(struct file
*filep
, loff_t offset
, int whence
)
169 ret
= nfs42_proc_llseek(filep
, offset
, whence
);
170 if (ret
!= -ENOTSUPP
)
173 return nfs_file_llseek(filep
, offset
, whence
);
177 static long nfs42_fallocate(struct file
*filep
, int mode
, loff_t offset
, loff_t len
)
179 struct inode
*inode
= file_inode(filep
);
182 if (!S_ISREG(inode
->i_mode
))
185 if ((mode
!= 0) && (mode
!= (FALLOC_FL_PUNCH_HOLE
| FALLOC_FL_KEEP_SIZE
)))
188 ret
= inode_newsize_ok(inode
, offset
+ len
);
192 if (mode
& FALLOC_FL_PUNCH_HOLE
)
193 return nfs42_proc_deallocate(filep
, offset
, len
);
194 return nfs42_proc_allocate(filep
, offset
, len
);
198 nfs42_ioctl_clone(struct file
*dst_file
, unsigned long srcfd
,
199 u64 src_off
, u64 dst_off
, u64 count
)
201 struct inode
*dst_inode
= file_inode(dst_file
);
202 struct nfs_server
*server
= NFS_SERVER(dst_inode
);
204 struct inode
*src_inode
;
205 unsigned int bs
= server
->clone_blksize
;
208 /* dst file must be opened for writing */
209 if (!(dst_file
->f_mode
& FMODE_WRITE
))
212 ret
= mnt_want_write_file(dst_file
);
216 src_file
= fdget(srcfd
);
217 if (!src_file
.file
) {
222 src_inode
= file_inode(src_file
.file
);
224 /* src and dst must be different files */
226 if (src_inode
== dst_inode
)
229 /* src file must be opened for reading */
230 if (!(src_file
.file
->f_mode
& FMODE_READ
))
233 /* src and dst must be regular files */
235 if (!S_ISREG(src_inode
->i_mode
) || !S_ISREG(dst_inode
->i_mode
))
239 if (src_file
.file
->f_path
.mnt
!= dst_file
->f_path
.mnt
||
240 src_inode
->i_sb
!= dst_inode
->i_sb
)
243 /* check alignment w.r.t. clone_blksize */
246 if (!IS_ALIGNED(src_off
, bs
) || !IS_ALIGNED(dst_off
, bs
))
248 if (!IS_ALIGNED(count
, bs
) && i_size_read(src_inode
) != (src_off
+ count
))
252 /* XXX: do we lock at all? what if server needs CB_RECALL_LAYOUT? */
253 if (dst_inode
< src_inode
) {
254 mutex_lock_nested(&dst_inode
->i_mutex
, I_MUTEX_PARENT
);
255 mutex_lock_nested(&src_inode
->i_mutex
, I_MUTEX_CHILD
);
257 mutex_lock_nested(&src_inode
->i_mutex
, I_MUTEX_PARENT
);
258 mutex_lock_nested(&dst_inode
->i_mutex
, I_MUTEX_CHILD
);
261 /* flush all pending writes on both src and dst so that server
262 * has the latest data */
263 ret
= nfs_sync_inode(src_inode
);
266 ret
= nfs_sync_inode(dst_inode
);
270 ret
= nfs42_proc_clone(src_file
.file
, dst_file
, src_off
, dst_off
, count
);
272 /* truncate inode page cache of the dst range so that future reads can fetch
273 * new data from server */
275 truncate_inode_pages_range(&dst_inode
->i_data
, dst_off
, dst_off
+ count
- 1);
278 if (dst_inode
< src_inode
) {
279 mutex_unlock(&src_inode
->i_mutex
);
280 mutex_unlock(&dst_inode
->i_mutex
);
282 mutex_unlock(&dst_inode
->i_mutex
);
283 mutex_unlock(&src_inode
->i_mutex
);
288 mnt_drop_write_file(dst_file
);
292 static long nfs42_ioctl_clone_range(struct file
*dst_file
, void __user
*argp
)
294 struct nfs_ioctl_clone_range_args args
;
296 if (copy_from_user(&args
, argp
, sizeof(args
)))
299 return nfs42_ioctl_clone(dst_file
, args
.src_fd
, args
.src_off
, args
.dst_off
, args
.count
);
302 static long nfs42_ioctl_clone(struct file
*dst_file
, unsigned long srcfd
,
303 u64 src_off
, u64 dst_off
, u64 count
)
308 static long nfs42_ioctl_clone_range(struct file
*dst_file
, void __user
*argp
)
312 #endif /* CONFIG_NFS_V4_2 */
314 long nfs4_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
316 void __user
*argp
= (void __user
*)arg
;
320 return nfs42_ioctl_clone(file
, arg
, 0, 0, 0);
321 case NFS_IOC_CLONE_RANGE
:
322 return nfs42_ioctl_clone_range(file
, argp
);
328 const struct file_operations nfs4_file_operations
= {
329 #ifdef CONFIG_NFS_V4_2
330 .llseek
= nfs4_file_llseek
,
332 .llseek
= nfs_file_llseek
,
334 .read_iter
= nfs_file_read
,
335 .write_iter
= nfs_file_write
,
336 .mmap
= nfs_file_mmap
,
337 .open
= nfs4_file_open
,
338 .flush
= nfs4_file_flush
,
339 .release
= nfs_file_release
,
340 .fsync
= nfs4_file_fsync
,
343 .splice_read
= nfs_file_splice_read
,
344 .splice_write
= iter_file_splice_write
,
345 #ifdef CONFIG_NFS_V4_2
346 .fallocate
= nfs42_fallocate
,
347 #endif /* CONFIG_NFS_V4_2 */
348 .check_flags
= nfs_check_flags
,
349 .setlease
= simple_nosetlease
,
351 .unlocked_ioctl
= nfs4_ioctl
,
353 .compat_ioctl
= nfs4_ioctl
,
354 #endif /* CONFIG_COMPAT */