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/mount.h>
11 #include <linux/nfs_fs.h>
12 #include <linux/nfs_ssc.h>
13 #include "delegation.h"
14 #include "internal.h"
15 #include "iostat.h"
16 #include "fscache.h"
17 #include "pnfs.h"
18
19 #include "nfstrace.h"
20
21 #ifdef CONFIG_NFS_V4_2
22 #include "nfs42.h"
23 #endif
24
25 #define NFSDBG_FACILITY NFSDBG_FILE
26
27 static int
nfs4_file_open(struct inode * inode,struct file * filp)28 nfs4_file_open(struct inode *inode, struct file *filp)
29 {
30 struct nfs_open_context *ctx;
31 struct dentry *dentry = file_dentry(filp);
32 struct dentry *parent = NULL;
33 struct inode *dir;
34 unsigned openflags = filp->f_flags;
35 fmode_t f_mode;
36 struct iattr attr;
37 int err;
38
39 /*
40 * If no cached dentry exists or if it's negative, NFSv4 handled the
41 * opens in ->lookup() or ->create().
42 *
43 * We only get this far for a cached positive dentry. We skipped
44 * revalidation, so handle it here by dropping the dentry and returning
45 * -EOPENSTALE. The VFS will retry the lookup/create/open.
46 */
47
48 dprintk("NFS: open file(%pd2)\n", dentry);
49
50 err = nfs_check_flags(openflags);
51 if (err)
52 return err;
53
54 f_mode = filp->f_mode;
55 if ((openflags & O_ACCMODE) == 3)
56 f_mode |= flags_to_mode(openflags);
57
58 /* We can't create new files here */
59 openflags &= ~(O_CREAT|O_EXCL);
60
61 parent = dget_parent(dentry);
62 dir = d_inode(parent);
63
64 ctx = alloc_nfs_open_context(file_dentry(filp), f_mode, filp);
65 err = PTR_ERR(ctx);
66 if (IS_ERR(ctx))
67 goto out;
68
69 attr.ia_valid = ATTR_OPEN;
70 if (openflags & O_TRUNC) {
71 attr.ia_valid |= ATTR_SIZE;
72 attr.ia_size = 0;
73 filemap_write_and_wait(inode->i_mapping);
74 }
75
76 inode = NFS_PROTO(dir)->open_context(dir, ctx, openflags, &attr, NULL);
77 if (IS_ERR(inode)) {
78 err = PTR_ERR(inode);
79 switch (err) {
80 default:
81 goto out_put_ctx;
82 case -ENOENT:
83 case -ESTALE:
84 case -EISDIR:
85 case -ENOTDIR:
86 case -ELOOP:
87 goto out_drop;
88 }
89 }
90 if (inode != d_inode(dentry))
91 goto out_drop;
92
93 nfs_file_set_open_context(filp, ctx);
94 nfs_fscache_open_file(inode, filp);
95 err = 0;
96 filp->f_mode |= FMODE_CAN_ODIRECT;
97
98 out_put_ctx:
99 put_nfs_open_context(ctx);
100 out:
101 dput(parent);
102 return err;
103
104 out_drop:
105 d_drop(dentry);
106 err = -EOPENSTALE;
107 goto out_put_ctx;
108 }
109
110 /*
111 * Flush all dirty pages, and check for write errors.
112 */
113 static int
nfs4_file_flush(struct file * file,fl_owner_t id)114 nfs4_file_flush(struct file *file, fl_owner_t id)
115 {
116 struct inode *inode = file_inode(file);
117 errseq_t since;
118
119 dprintk("NFS: flush(%pD2)\n", file);
120
121 nfs_inc_stats(inode, NFSIOS_VFSFLUSH);
122 if ((file->f_mode & FMODE_WRITE) == 0)
123 return 0;
124
125 /*
126 * If we're holding a write delegation, then check if we're required
127 * to flush the i/o on close. If not, then just start the i/o now.
128 */
129 if (!nfs4_delegation_flush_on_close(inode))
130 return filemap_fdatawrite(file->f_mapping);
131
132 /* Flush writes to the server and return any errors */
133 since = filemap_sample_wb_err(file->f_mapping);
134 nfs_wb_all(inode);
135 return filemap_check_wb_err(file->f_mapping, since);
136 }
137
138 #ifdef CONFIG_NFS_V4_2
__nfs4_copy_file_range(struct file * file_in,loff_t pos_in,struct file * file_out,loff_t pos_out,size_t count,unsigned int flags)139 static ssize_t __nfs4_copy_file_range(struct file *file_in, loff_t pos_in,
140 struct file *file_out, loff_t pos_out,
141 size_t count, unsigned int flags)
142 {
143 struct nfs42_copy_notify_res *cn_resp = NULL;
144 struct nl4_server *nss = NULL;
145 nfs4_stateid *cnrs = NULL;
146 ssize_t ret;
147 bool sync = false;
148
149 /* Only offload copy if superblock is the same */
150 if (file_in->f_op != &nfs4_file_operations)
151 return -EXDEV;
152 if (!nfs_server_capable(file_inode(file_out), NFS_CAP_COPY) ||
153 !nfs_server_capable(file_inode(file_in), NFS_CAP_COPY))
154 return -EOPNOTSUPP;
155 if (file_inode(file_in) == file_inode(file_out))
156 return -EOPNOTSUPP;
157 /* if the copy size if smaller than 2 RPC payloads, make it
158 * synchronous
159 */
160 if (count <= 2 * NFS_SERVER(file_inode(file_in))->rsize)
161 sync = true;
162 retry:
163 if (!nfs42_files_from_same_server(file_in, file_out)) {
164 /*
165 * for inter copy, if copy size is too small
166 * then fallback to generic copy.
167 */
168 if (sync)
169 return -EOPNOTSUPP;
170 cn_resp = kzalloc(sizeof(struct nfs42_copy_notify_res),
171 GFP_KERNEL);
172 if (unlikely(cn_resp == NULL))
173 return -ENOMEM;
174
175 ret = nfs42_proc_copy_notify(file_in, file_out, cn_resp);
176 if (ret) {
177 ret = -EOPNOTSUPP;
178 goto out;
179 }
180 nss = &cn_resp->cnr_src;
181 cnrs = &cn_resp->cnr_stateid;
182 }
183 ret = nfs42_proc_copy(file_in, pos_in, file_out, pos_out, count,
184 nss, cnrs, sync);
185 out:
186 kfree(cn_resp);
187
188 if (ret == -EAGAIN)
189 goto retry;
190 return ret;
191 }
192
nfs4_copy_file_range(struct file * file_in,loff_t pos_in,struct file * file_out,loff_t pos_out,size_t count,unsigned int flags)193 static ssize_t nfs4_copy_file_range(struct file *file_in, loff_t pos_in,
194 struct file *file_out, loff_t pos_out,
195 size_t count, unsigned int flags)
196 {
197 ssize_t ret;
198
199 ret = __nfs4_copy_file_range(file_in, pos_in, file_out, pos_out, count,
200 flags);
201 if (ret == -EOPNOTSUPP || ret == -EXDEV)
202 ret = generic_copy_file_range(file_in, pos_in, file_out,
203 pos_out, count, flags);
204 return ret;
205 }
206
nfs4_file_llseek(struct file * filep,loff_t offset,int whence)207 static loff_t nfs4_file_llseek(struct file *filep, loff_t offset, int whence)
208 {
209 loff_t ret;
210
211 switch (whence) {
212 case SEEK_HOLE:
213 case SEEK_DATA:
214 ret = nfs42_proc_llseek(filep, offset, whence);
215 if (ret != -EOPNOTSUPP)
216 return ret;
217 fallthrough;
218 default:
219 return nfs_file_llseek(filep, offset, whence);
220 }
221 }
222
nfs42_fallocate(struct file * filep,int mode,loff_t offset,loff_t len)223 static long nfs42_fallocate(struct file *filep, int mode, loff_t offset, loff_t len)
224 {
225 struct inode *inode = file_inode(filep);
226 long ret;
227
228 if (!S_ISREG(inode->i_mode))
229 return -EOPNOTSUPP;
230
231 if ((mode != 0) && (mode != (FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE)))
232 return -EOPNOTSUPP;
233
234 ret = inode_newsize_ok(inode, offset + len);
235 if (ret < 0)
236 return ret;
237
238 if (mode & FALLOC_FL_PUNCH_HOLE)
239 return nfs42_proc_deallocate(filep, offset, len);
240 return nfs42_proc_allocate(filep, offset, len);
241 }
242
nfs42_remap_file_range(struct file * src_file,loff_t src_off,struct file * dst_file,loff_t dst_off,loff_t count,unsigned int remap_flags)243 static loff_t nfs42_remap_file_range(struct file *src_file, loff_t src_off,
244 struct file *dst_file, loff_t dst_off, loff_t count,
245 unsigned int remap_flags)
246 {
247 struct inode *dst_inode = file_inode(dst_file);
248 struct nfs_server *server = NFS_SERVER(dst_inode);
249 struct inode *src_inode = file_inode(src_file);
250 unsigned int bs = server->clone_blksize;
251 bool same_inode = false;
252 int ret;
253
254 /* NFS does not support deduplication. */
255 if (remap_flags & REMAP_FILE_DEDUP)
256 return -EOPNOTSUPP;
257
258 if (remap_flags & ~REMAP_FILE_ADVISORY)
259 return -EINVAL;
260
261 if (IS_SWAPFILE(dst_inode) || IS_SWAPFILE(src_inode))
262 return -ETXTBSY;
263
264 /* check alignment w.r.t. clone_blksize */
265 ret = -EINVAL;
266 if (bs) {
267 if (!IS_ALIGNED(src_off, bs) || !IS_ALIGNED(dst_off, bs))
268 goto out;
269 if (!IS_ALIGNED(count, bs) && i_size_read(src_inode) != (src_off + count))
270 goto out;
271 }
272
273 if (src_inode == dst_inode)
274 same_inode = true;
275
276 /* XXX: do we lock at all? what if server needs CB_RECALL_LAYOUT? */
277 if (same_inode) {
278 inode_lock(src_inode);
279 } else if (dst_inode < src_inode) {
280 inode_lock_nested(dst_inode, I_MUTEX_PARENT);
281 inode_lock_nested(src_inode, I_MUTEX_CHILD);
282 } else {
283 inode_lock_nested(src_inode, I_MUTEX_PARENT);
284 inode_lock_nested(dst_inode, I_MUTEX_CHILD);
285 }
286
287 /* flush all pending writes on both src and dst so that server
288 * has the latest data */
289 ret = nfs_sync_inode(src_inode);
290 if (ret)
291 goto out_unlock;
292 ret = nfs_sync_inode(dst_inode);
293 if (ret)
294 goto out_unlock;
295
296 ret = nfs42_proc_clone(src_file, dst_file, src_off, dst_off, count);
297
298 /* truncate inode page cache of the dst range so that future reads can fetch
299 * new data from server */
300 if (!ret)
301 truncate_inode_pages_range(&dst_inode->i_data, dst_off, dst_off + count - 1);
302
303 out_unlock:
304 if (same_inode) {
305 inode_unlock(src_inode);
306 } else if (dst_inode < src_inode) {
307 inode_unlock(src_inode);
308 inode_unlock(dst_inode);
309 } else {
310 inode_unlock(dst_inode);
311 inode_unlock(src_inode);
312 }
313 out:
314 return ret < 0 ? ret : count;
315 }
316
317 static int read_name_gen = 1;
318 #define SSC_READ_NAME_BODY "ssc_read_%d"
319
__nfs42_ssc_open(struct vfsmount * ss_mnt,struct nfs_fh * src_fh,nfs4_stateid * stateid)320 static struct file *__nfs42_ssc_open(struct vfsmount *ss_mnt,
321 struct nfs_fh *src_fh, nfs4_stateid *stateid)
322 {
323 struct nfs_fattr *fattr = nfs_alloc_fattr();
324 struct file *filep, *res;
325 struct nfs_server *server;
326 struct inode *r_ino = NULL;
327 struct nfs_open_context *ctx;
328 struct nfs4_state_owner *sp;
329 char *read_name = NULL;
330 int len, status = 0;
331
332 server = NFS_SB(ss_mnt->mnt_sb);
333
334 if (!fattr)
335 return ERR_PTR(-ENOMEM);
336
337 status = nfs4_proc_getattr(server, src_fh, fattr, NULL);
338 if (status < 0) {
339 res = ERR_PTR(status);
340 goto out;
341 }
342
343 if (!S_ISREG(fattr->mode)) {
344 res = ERR_PTR(-EBADF);
345 goto out;
346 }
347
348 res = ERR_PTR(-ENOMEM);
349 len = strlen(SSC_READ_NAME_BODY) + 16;
350 read_name = kzalloc(len, GFP_KERNEL);
351 if (read_name == NULL)
352 goto out;
353 snprintf(read_name, len, SSC_READ_NAME_BODY, read_name_gen++);
354
355 r_ino = nfs_fhget(ss_mnt->mnt_sb, src_fh, fattr);
356 if (IS_ERR(r_ino)) {
357 res = ERR_CAST(r_ino);
358 goto out_free_name;
359 }
360
361 filep = alloc_file_pseudo(r_ino, ss_mnt, read_name, O_RDONLY,
362 r_ino->i_fop);
363 if (IS_ERR(filep)) {
364 res = ERR_CAST(filep);
365 iput(r_ino);
366 goto out_free_name;
367 }
368
369 ctx = alloc_nfs_open_context(filep->f_path.dentry, filep->f_mode,
370 filep);
371 if (IS_ERR(ctx)) {
372 res = ERR_CAST(ctx);
373 goto out_filep;
374 }
375
376 res = ERR_PTR(-EINVAL);
377 sp = nfs4_get_state_owner(server, ctx->cred, GFP_KERNEL);
378 if (sp == NULL)
379 goto out_ctx;
380
381 ctx->state = nfs4_get_open_state(r_ino, sp);
382 if (ctx->state == NULL)
383 goto out_stateowner;
384
385 set_bit(NFS_SRV_SSC_COPY_STATE, &ctx->state->flags);
386 memcpy(&ctx->state->open_stateid.other, &stateid->other,
387 NFS4_STATEID_OTHER_SIZE);
388 update_open_stateid(ctx->state, stateid, NULL, filep->f_mode);
389 set_bit(NFS_OPEN_STATE, &ctx->state->flags);
390
391 nfs_file_set_open_context(filep, ctx);
392 put_nfs_open_context(ctx);
393
394 file_ra_state_init(&filep->f_ra, filep->f_mapping->host->i_mapping);
395 res = filep;
396 out_free_name:
397 kfree(read_name);
398 out:
399 nfs_free_fattr(fattr);
400 return res;
401 out_stateowner:
402 nfs4_put_state_owner(sp);
403 out_ctx:
404 put_nfs_open_context(ctx);
405 out_filep:
406 fput(filep);
407 goto out_free_name;
408 }
409
__nfs42_ssc_close(struct file * filep)410 static void __nfs42_ssc_close(struct file *filep)
411 {
412 struct nfs_open_context *ctx = nfs_file_open_context(filep);
413
414 ctx->state->flags = 0;
415 }
416
417 static const struct nfs4_ssc_client_ops nfs4_ssc_clnt_ops_tbl = {
418 .sco_open = __nfs42_ssc_open,
419 .sco_close = __nfs42_ssc_close,
420 };
421
422 /**
423 * nfs42_ssc_register_ops - Wrapper to register NFS_V4 ops in nfs_common
424 *
425 * Return values:
426 * None
427 */
nfs42_ssc_register_ops(void)428 void nfs42_ssc_register_ops(void)
429 {
430 nfs42_ssc_register(&nfs4_ssc_clnt_ops_tbl);
431 }
432
433 /**
434 * nfs42_ssc_unregister_ops - wrapper to un-register NFS_V4 ops in nfs_common
435 *
436 * Return values:
437 * None.
438 */
nfs42_ssc_unregister_ops(void)439 void nfs42_ssc_unregister_ops(void)
440 {
441 nfs42_ssc_unregister(&nfs4_ssc_clnt_ops_tbl);
442 }
443 #endif /* CONFIG_NFS_V4_2 */
444
nfs4_setlease(struct file * file,long arg,struct file_lock ** lease,void ** priv)445 static int nfs4_setlease(struct file *file, long arg, struct file_lock **lease,
446 void **priv)
447 {
448 return nfs4_proc_setlease(file, arg, lease, priv);
449 }
450
451 const struct file_operations nfs4_file_operations = {
452 .read_iter = nfs_file_read,
453 .write_iter = nfs_file_write,
454 .mmap = nfs_file_mmap,
455 .open = nfs4_file_open,
456 .flush = nfs4_file_flush,
457 .release = nfs_file_release,
458 .fsync = nfs_file_fsync,
459 .lock = nfs_lock,
460 .flock = nfs_flock,
461 .splice_read = generic_file_splice_read,
462 .splice_write = iter_file_splice_write,
463 .check_flags = nfs_check_flags,
464 .setlease = nfs4_setlease,
465 #ifdef CONFIG_NFS_V4_2
466 .copy_file_range = nfs4_copy_file_range,
467 .llseek = nfs4_file_llseek,
468 .fallocate = nfs42_fallocate,
469 .remap_file_range = nfs42_remap_file_range,
470 #else
471 .llseek = nfs_file_llseek,
472 #endif
473 };
474