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