1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Copyright (c) 2014 Anna Schumaker <Anna.Schumaker@Netapp.com>
4 */
5 #include <linux/fs.h>
6 #include <linux/sunrpc/addr.h>
7 #include <linux/sunrpc/sched.h>
8 #include <linux/nfs.h>
9 #include <linux/nfs3.h>
10 #include <linux/nfs4.h>
11 #include <linux/nfs_xdr.h>
12 #include <linux/nfs_fs.h>
13 #include "nfs4_fs.h"
14 #include "nfs42.h"
15 #include "iostat.h"
16 #include "pnfs.h"
17 #include "nfs4session.h"
18 #include "internal.h"
19 #include "delegation.h"
20 #include "nfs4trace.h"
21
22 #define NFSDBG_FACILITY NFSDBG_PROC
23 static int nfs42_do_offload_cancel_async(struct file *dst, nfs4_stateid *std);
24 static int nfs42_proc_offload_status(struct file *file, nfs4_stateid *stateid,
25 u64 *copied);
26
nfs42_set_netaddr(struct file * filep,struct nfs42_netaddr * naddr)27 static void nfs42_set_netaddr(struct file *filep, struct nfs42_netaddr *naddr)
28 {
29 struct nfs_client *clp = (NFS_SERVER(file_inode(filep)))->nfs_client;
30 unsigned short port = 2049;
31
32 rcu_read_lock();
33 naddr->netid_len = scnprintf(naddr->netid,
34 sizeof(naddr->netid), "%s",
35 rpc_peeraddr2str(clp->cl_rpcclient,
36 RPC_DISPLAY_NETID));
37 naddr->addr_len = scnprintf(naddr->addr,
38 sizeof(naddr->addr),
39 "%s.%u.%u",
40 rpc_peeraddr2str(clp->cl_rpcclient,
41 RPC_DISPLAY_ADDR),
42 port >> 8, port & 255);
43 rcu_read_unlock();
44 }
45
_nfs42_proc_fallocate(struct rpc_message * msg,struct file * filep,struct nfs_lock_context * lock,loff_t offset,loff_t len)46 static int _nfs42_proc_fallocate(struct rpc_message *msg, struct file *filep,
47 struct nfs_lock_context *lock, loff_t offset, loff_t len)
48 {
49 struct inode *inode = file_inode(filep);
50 struct nfs_server *server = NFS_SERVER(inode);
51 u32 bitmask[NFS_BITMASK_SZ];
52 struct nfs42_falloc_args args = {
53 .falloc_fh = NFS_FH(inode),
54 .falloc_offset = offset,
55 .falloc_length = len,
56 .falloc_bitmask = bitmask,
57 };
58 struct nfs42_falloc_res res = {
59 .falloc_server = server,
60 };
61 int status;
62
63 msg->rpc_argp = &args;
64 msg->rpc_resp = &res;
65
66 status = nfs4_set_rw_stateid(&args.falloc_stateid, lock->open_context,
67 lock, FMODE_WRITE);
68 if (status) {
69 if (status == -EAGAIN)
70 status = -NFS4ERR_BAD_STATEID;
71 return status;
72 }
73
74 nfs4_bitmask_set(bitmask, server->cache_consistency_bitmask, inode,
75 NFS_INO_INVALID_BLOCKS);
76
77 res.falloc_fattr = nfs_alloc_fattr();
78 if (!res.falloc_fattr)
79 return -ENOMEM;
80
81 status = nfs4_call_sync(server->client, server, msg,
82 &args.seq_args, &res.seq_res, 0);
83 if (status == 0) {
84 if (nfs_should_remove_suid(inode)) {
85 spin_lock(&inode->i_lock);
86 nfs_set_cache_invalid(inode,
87 NFS_INO_REVAL_FORCED | NFS_INO_INVALID_MODE);
88 spin_unlock(&inode->i_lock);
89 }
90 status = nfs_post_op_update_inode_force_wcc(inode,
91 res.falloc_fattr);
92 }
93 if (msg->rpc_proc == &nfs4_procedures[NFSPROC4_CLNT_ALLOCATE])
94 trace_nfs4_fallocate(inode, &args, status);
95 else
96 trace_nfs4_deallocate(inode, &args, status);
97 kfree(res.falloc_fattr);
98 return status;
99 }
100
nfs42_proc_fallocate(struct rpc_message * msg,struct file * filep,loff_t offset,loff_t len)101 static int nfs42_proc_fallocate(struct rpc_message *msg, struct file *filep,
102 loff_t offset, loff_t len)
103 {
104 struct inode *inode = file_inode(filep);
105 struct nfs_server *server = NFS_SERVER(inode);
106 struct nfs4_exception exception = { };
107 struct nfs_lock_context *lock;
108 int err;
109
110 lock = nfs_get_lock_context(nfs_file_open_context(filep));
111 if (IS_ERR(lock))
112 return PTR_ERR(lock);
113
114 exception.inode = inode;
115 exception.state = lock->open_context->state;
116
117 err = nfs_sync_inode(inode);
118 if (err)
119 goto out;
120
121 do {
122 err = _nfs42_proc_fallocate(msg, filep, lock, offset, len);
123 if (err == -ENOTSUPP) {
124 err = -EOPNOTSUPP;
125 break;
126 }
127 err = nfs4_handle_exception(server, err, &exception);
128 } while (exception.retry);
129 out:
130 nfs_put_lock_context(lock);
131 return err;
132 }
133
nfs42_proc_allocate(struct file * filep,loff_t offset,loff_t len)134 int nfs42_proc_allocate(struct file *filep, loff_t offset, loff_t len)
135 {
136 struct rpc_message msg = {
137 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_ALLOCATE],
138 };
139 struct inode *inode = file_inode(filep);
140 loff_t oldsize;
141 int err;
142
143 if (!nfs_server_capable(inode, NFS_CAP_ALLOCATE))
144 return -EOPNOTSUPP;
145
146 err = nfs_start_io_write(inode);
147 if (err)
148 return err;
149
150 oldsize = i_size_read(inode);
151
152 err = nfs42_proc_fallocate(&msg, filep, offset, len);
153
154 if (err == 0)
155 nfs_truncate_last_folio(inode->i_mapping, oldsize,
156 offset + len);
157 else if (err == -EOPNOTSUPP)
158 NFS_SERVER(inode)->caps &= ~(NFS_CAP_ALLOCATE |
159 NFS_CAP_ZERO_RANGE);
160
161 nfs_end_io_write(inode);
162 return err;
163 }
164
nfs42_proc_deallocate(struct file * filep,loff_t offset,loff_t len)165 int nfs42_proc_deallocate(struct file *filep, loff_t offset, loff_t len)
166 {
167 struct rpc_message msg = {
168 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DEALLOCATE],
169 };
170 struct inode *inode = file_inode(filep);
171 int err;
172
173 if (!nfs_server_capable(inode, NFS_CAP_DEALLOCATE))
174 return -EOPNOTSUPP;
175
176 err = nfs_start_io_write(inode);
177 if (err)
178 return err;
179
180 err = nfs42_proc_fallocate(&msg, filep, offset, len);
181 if (err == 0)
182 truncate_pagecache_range(inode, offset, (offset + len) -1);
183 if (err == -EOPNOTSUPP)
184 NFS_SERVER(inode)->caps &= ~(NFS_CAP_DEALLOCATE |
185 NFS_CAP_ZERO_RANGE);
186
187 nfs_end_io_write(inode);
188 return err;
189 }
190
nfs42_proc_zero_range(struct file * filep,loff_t offset,loff_t len)191 int nfs42_proc_zero_range(struct file *filep, loff_t offset, loff_t len)
192 {
193 struct rpc_message msg = {
194 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_ZERO_RANGE],
195 };
196 struct inode *inode = file_inode(filep);
197 loff_t oldsize;
198 int err;
199
200 if (!nfs_server_capable(inode, NFS_CAP_ZERO_RANGE))
201 return -EOPNOTSUPP;
202
203 err = nfs_start_io_write(inode);
204 if (err)
205 return err;
206
207 oldsize = i_size_read(inode);
208 err = nfs42_proc_fallocate(&msg, filep, offset, len);
209 if (err == 0) {
210 nfs_truncate_last_folio(inode->i_mapping, oldsize,
211 offset + len);
212 truncate_pagecache_range(inode, offset, (offset + len) -1);
213 } else if (err == -EOPNOTSUPP)
214 NFS_SERVER(inode)->caps &= ~NFS_CAP_ZERO_RANGE;
215
216 nfs_end_io_write(inode);
217 return err;
218 }
219
nfs4_copy_dequeue_callback(struct nfs_server * dst_server,struct nfs_server * src_server,struct nfs4_copy_state * copy)220 static void nfs4_copy_dequeue_callback(struct nfs_server *dst_server,
221 struct nfs_server *src_server,
222 struct nfs4_copy_state *copy)
223 {
224 spin_lock(&dst_server->nfs_client->cl_lock);
225 list_del_init(©->copies);
226 spin_unlock(&dst_server->nfs_client->cl_lock);
227 if (dst_server != src_server) {
228 spin_lock(&src_server->nfs_client->cl_lock);
229 list_del_init(©->src_copies);
230 spin_unlock(&src_server->nfs_client->cl_lock);
231 }
232 }
233
handle_async_copy(struct nfs42_copy_res * res,struct nfs_server * dst_server,struct nfs_server * src_server,struct file * src,struct file * dst,nfs4_stateid * src_stateid,bool * restart)234 static int handle_async_copy(struct nfs42_copy_res *res,
235 struct nfs_server *dst_server,
236 struct nfs_server *src_server,
237 struct file *src,
238 struct file *dst,
239 nfs4_stateid *src_stateid,
240 bool *restart)
241 {
242 struct nfs4_copy_state *copy, *tmp_copy = NULL, *iter;
243 struct nfs_open_context *dst_ctx = nfs_file_open_context(dst);
244 struct nfs_open_context *src_ctx = nfs_file_open_context(src);
245 struct nfs_client *clp = dst_server->nfs_client;
246 unsigned long timeout = 3 * HZ;
247 int status = NFS4_OK;
248 u64 copied;
249
250 copy = kzalloc_obj(struct nfs4_copy_state);
251 if (!copy)
252 return -ENOMEM;
253
254 spin_lock(&dst_server->nfs_client->cl_lock);
255 list_for_each_entry(iter,
256 &dst_server->nfs_client->pending_cb_stateids,
257 copies) {
258 if (memcmp(&res->write_res.stateid, &iter->stateid,
259 NFS4_STATEID_SIZE))
260 continue;
261 tmp_copy = iter;
262 list_del(&iter->copies);
263 break;
264 }
265 if (tmp_copy) {
266 spin_unlock(&dst_server->nfs_client->cl_lock);
267 kfree(copy);
268 copy = tmp_copy;
269 goto out;
270 }
271
272 memcpy(©->stateid, &res->write_res.stateid, NFS4_STATEID_SIZE);
273 init_completion(©->completion);
274 copy->parent_dst_state = dst_ctx->state;
275 copy->parent_src_state = src_ctx->state;
276
277 list_add_tail(©->copies, &dst_server->ss_copies);
278 spin_unlock(&dst_server->nfs_client->cl_lock);
279
280 if (dst_server != src_server) {
281 spin_lock(&src_server->nfs_client->cl_lock);
282 list_add_tail(©->src_copies, &src_server->ss_src_copies);
283 spin_unlock(&src_server->nfs_client->cl_lock);
284 }
285
286 wait:
287 status = wait_for_completion_interruptible_timeout(©->completion,
288 timeout);
289 if (!status)
290 goto timeout;
291 nfs4_copy_dequeue_callback(dst_server, src_server, copy);
292 if (status == -ERESTARTSYS) {
293 goto out_cancel;
294 } else if (copy->flags || copy->error == NFS4ERR_PARTNER_NO_AUTH) {
295 status = -EAGAIN;
296 *restart = true;
297 goto out_cancel;
298 }
299 out:
300 res->write_res.count = copy->count;
301 /* Copy out the updated write verifier provided by CB_OFFLOAD. */
302 memcpy(&res->write_res.verifier, ©->verf, sizeof(copy->verf));
303 status = -copy->error;
304
305 out_free:
306 kfree(copy);
307 return status;
308 out_cancel:
309 nfs42_do_offload_cancel_async(dst, ©->stateid);
310 if (!nfs42_files_from_same_server(src, dst))
311 nfs42_do_offload_cancel_async(src, src_stateid);
312 goto out_free;
313 timeout:
314 timeout <<= 1;
315 if (timeout > (clp->cl_lease_time >> 1))
316 timeout = clp->cl_lease_time >> 1;
317 status = nfs42_proc_offload_status(dst, ©->stateid, &copied);
318 if (status == -EINPROGRESS)
319 goto wait;
320 nfs4_copy_dequeue_callback(dst_server, src_server, copy);
321 switch (status) {
322 case 0:
323 /* The server recognized the copy stateid, so it hasn't
324 * rebooted. Don't overwrite the verifier returned in the
325 * COPY result. */
326 res->write_res.count = copied;
327 goto out_free;
328 case -EREMOTEIO:
329 /* COPY operation failed on the server. */
330 status = -EOPNOTSUPP;
331 res->write_res.count = copied;
332 goto out_free;
333 case -EBADF:
334 /* Server did not recognize the copy stateid. It has
335 * probably restarted and lost the plot. */
336 res->write_res.count = 0;
337 status = -EOPNOTSUPP;
338 break;
339 case -EOPNOTSUPP:
340 /* RFC 7862 REQUIREs server to support OFFLOAD_STATUS when
341 * it has signed up for an async COPY, so server is not
342 * spec-compliant. */
343 res->write_res.count = 0;
344 }
345 goto out_free;
346 }
347
process_copy_commit(struct file * dst,loff_t pos_dst,struct nfs42_copy_res * res)348 static int process_copy_commit(struct file *dst, loff_t pos_dst,
349 struct nfs42_copy_res *res)
350 {
351 struct nfs_commitres cres;
352 int status = -ENOMEM;
353
354 cres.verf = kzalloc_obj(struct nfs_writeverf);
355 if (!cres.verf)
356 goto out;
357
358 status = nfs4_proc_commit(dst, pos_dst, res->write_res.count, &cres);
359 if (status)
360 goto out_free;
361 if (nfs_write_verifier_cmp(&res->write_res.verifier.verifier,
362 &cres.verf->verifier)) {
363 dprintk("commit verf differs from copy verf\n");
364 status = -EAGAIN;
365 }
366 out_free:
367 kfree(cres.verf);
368 out:
369 return status;
370 }
371
372 /**
373 * nfs42_copy_dest_done - perform inode cache updates after clone/copy offload
374 * @file: pointer to destination file
375 * @pos: destination offset
376 * @len: copy length
377 * @oldsize: length of the file prior to clone/copy
378 *
379 * Punch a hole in the inode page cache, so that the NFS client will
380 * know to retrieve new data.
381 * Update the file size if necessary, and then mark the inode as having
382 * invalid cached values for change attribute, ctime, mtime and space used.
383 */
nfs42_copy_dest_done(struct file * file,loff_t pos,loff_t len,loff_t oldsize)384 static void nfs42_copy_dest_done(struct file *file, loff_t pos, loff_t len,
385 loff_t oldsize)
386 {
387 struct inode *inode = file_inode(file);
388 struct address_space *mapping = file->f_mapping;
389 loff_t newsize = pos + len;
390 loff_t end = newsize - 1;
391
392 nfs_truncate_last_folio(mapping, oldsize, pos);
393 WARN_ON_ONCE(invalidate_inode_pages2_range(mapping, pos >> PAGE_SHIFT,
394 end >> PAGE_SHIFT));
395
396 spin_lock(&inode->i_lock);
397 if (newsize > i_size_read(inode))
398 i_size_write(inode, newsize);
399 nfs_set_cache_invalid(inode, NFS_INO_INVALID_CHANGE |
400 NFS_INO_INVALID_CTIME |
401 NFS_INO_INVALID_MTIME |
402 NFS_INO_INVALID_BLOCKS);
403 spin_unlock(&inode->i_lock);
404 }
405
_nfs42_proc_copy(struct file * src,struct nfs_lock_context * src_lock,struct file * dst,struct nfs_lock_context * dst_lock,struct nfs42_copy_args * args,struct nfs42_copy_res * res,struct nl4_server * nss,nfs4_stateid * cnr_stateid,bool * restart)406 static ssize_t _nfs42_proc_copy(struct file *src,
407 struct nfs_lock_context *src_lock,
408 struct file *dst,
409 struct nfs_lock_context *dst_lock,
410 struct nfs42_copy_args *args,
411 struct nfs42_copy_res *res,
412 struct nl4_server *nss,
413 nfs4_stateid *cnr_stateid,
414 bool *restart)
415 {
416 struct rpc_message msg = {
417 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_COPY],
418 .rpc_argp = args,
419 .rpc_resp = res,
420 };
421 struct inode *dst_inode = file_inode(dst);
422 struct inode *src_inode = file_inode(src);
423 struct nfs_server *dst_server = NFS_SERVER(dst_inode);
424 struct nfs_server *src_server = NFS_SERVER(src_inode);
425 loff_t pos_src = args->src_pos;
426 loff_t pos_dst = args->dst_pos;
427 loff_t oldsize_dst;
428 size_t count = args->count;
429 ssize_t status;
430
431 if (nss) {
432 args->cp_src = nss;
433 nfs4_stateid_copy(&args->src_stateid, cnr_stateid);
434 } else {
435 status = nfs4_set_rw_stateid(&args->src_stateid,
436 src_lock->open_context, src_lock, FMODE_READ);
437 if (status) {
438 if (status == -EAGAIN)
439 status = -NFS4ERR_BAD_STATEID;
440 return status;
441 }
442 }
443 status = nfs_filemap_write_and_wait_range(src->f_mapping,
444 pos_src, pos_src + (loff_t)count - 1);
445 if (status)
446 return status;
447
448 status = nfs4_set_rw_stateid(&args->dst_stateid, dst_lock->open_context,
449 dst_lock, FMODE_WRITE);
450 if (status) {
451 if (status == -EAGAIN)
452 status = -NFS4ERR_BAD_STATEID;
453 return status;
454 }
455
456 nfs_file_block_o_direct(NFS_I(dst_inode));
457 status = nfs_sync_inode(dst_inode);
458 if (status)
459 return status;
460
461 res->commit_res.verf = NULL;
462 if (args->sync) {
463 res->commit_res.verf =
464 kzalloc_obj(struct nfs_writeverf);
465 if (!res->commit_res.verf)
466 return -ENOMEM;
467 }
468 set_bit(NFS_CLNT_SRC_SSC_COPY_STATE,
469 &src_lock->open_context->state->flags);
470 set_bit(NFS_CLNT_DST_SSC_COPY_STATE,
471 &dst_lock->open_context->state->flags);
472 oldsize_dst = i_size_read(dst_inode);
473
474 status = nfs4_call_sync(dst_server->client, dst_server, &msg,
475 &args->seq_args, &res->seq_res, 0);
476 trace_nfs4_copy(src_inode, dst_inode, args, res, nss, status);
477 if (status == -ENOTSUPP)
478 dst_server->caps &= ~NFS_CAP_COPY;
479 if (status)
480 goto out;
481
482 if (args->sync &&
483 nfs_write_verifier_cmp(&res->write_res.verifier.verifier,
484 &res->commit_res.verf->verifier)) {
485 status = -EAGAIN;
486 goto out;
487 }
488
489 if (!res->synchronous) {
490 status = handle_async_copy(res, dst_server, src_server, src,
491 dst, &args->src_stateid, restart);
492 if (status)
493 goto out;
494 }
495
496 if ((!res->synchronous || !args->sync) &&
497 res->write_res.verifier.committed != NFS_FILE_SYNC) {
498 status = process_copy_commit(dst, pos_dst, res);
499 if (status)
500 goto out;
501 }
502
503 nfs42_copy_dest_done(dst, pos_dst, res->write_res.count, oldsize_dst);
504 nfs_invalidate_atime(src_inode);
505 status = res->write_res.count;
506 out:
507 if (args->sync)
508 kfree(res->commit_res.verf);
509 return status;
510 }
511
nfs42_proc_copy(struct file * src,loff_t pos_src,struct file * dst,loff_t pos_dst,size_t count,struct nl4_server * nss,nfs4_stateid * cnr_stateid,bool sync)512 ssize_t nfs42_proc_copy(struct file *src, loff_t pos_src,
513 struct file *dst, loff_t pos_dst, size_t count,
514 struct nl4_server *nss,
515 nfs4_stateid *cnr_stateid, bool sync)
516 {
517 struct nfs_server *server = NFS_SERVER(file_inode(dst));
518 struct nfs_lock_context *src_lock;
519 struct nfs_lock_context *dst_lock;
520 struct nfs42_copy_args args = {
521 .src_fh = NFS_FH(file_inode(src)),
522 .src_pos = pos_src,
523 .dst_fh = NFS_FH(file_inode(dst)),
524 .dst_pos = pos_dst,
525 .count = count,
526 .sync = sync,
527 };
528 struct nfs42_copy_res res;
529 struct nfs4_exception src_exception = {
530 .inode = file_inode(src),
531 .stateid = &args.src_stateid,
532 };
533 struct nfs4_exception dst_exception = {
534 .inode = file_inode(dst),
535 .stateid = &args.dst_stateid,
536 };
537 ssize_t err, err2;
538 bool restart = false;
539
540 src_lock = nfs_get_lock_context(nfs_file_open_context(src));
541 if (IS_ERR(src_lock))
542 return PTR_ERR(src_lock);
543
544 src_exception.state = src_lock->open_context->state;
545
546 dst_lock = nfs_get_lock_context(nfs_file_open_context(dst));
547 if (IS_ERR(dst_lock)) {
548 err = PTR_ERR(dst_lock);
549 goto out_put_src_lock;
550 }
551
552 dst_exception.state = dst_lock->open_context->state;
553
554 do {
555 inode_lock(file_inode(dst));
556 err = _nfs42_proc_copy(src, src_lock,
557 dst, dst_lock,
558 &args, &res,
559 nss, cnr_stateid, &restart);
560 inode_unlock(file_inode(dst));
561
562 if (err >= 0)
563 break;
564 if ((err == -ENOTSUPP ||
565 err == -NFS4ERR_OFFLOAD_DENIED) &&
566 nfs42_files_from_same_server(src, dst)) {
567 err = -EOPNOTSUPP;
568 break;
569 } else if (err == -EAGAIN) {
570 if (!restart) {
571 dst_exception.retry = 1;
572 continue;
573 }
574 break;
575 } else if (err == -NFS4ERR_OFFLOAD_NO_REQS &&
576 args.sync != res.synchronous) {
577 args.sync = res.synchronous;
578 dst_exception.retry = 1;
579 continue;
580 } else if ((err == -ESTALE ||
581 err == -NFS4ERR_OFFLOAD_DENIED ||
582 err == -ENOTSUPP) &&
583 !nfs42_files_from_same_server(src, dst)) {
584 nfs42_do_offload_cancel_async(src, &args.src_stateid);
585 err = -EOPNOTSUPP;
586 break;
587 }
588
589 err2 = nfs4_handle_exception(server, err, &src_exception);
590 err = nfs4_handle_exception(server, err, &dst_exception);
591 if (!err)
592 err = err2;
593 } while (src_exception.retry || dst_exception.retry);
594
595 nfs_put_lock_context(dst_lock);
596 out_put_src_lock:
597 nfs_put_lock_context(src_lock);
598 return err;
599 }
600
601 struct nfs42_offload_data {
602 struct nfs_server *seq_server;
603 struct nfs42_offload_status_args args;
604 struct nfs42_offload_status_res res;
605 };
606
nfs42_offload_prepare(struct rpc_task * task,void * calldata)607 static void nfs42_offload_prepare(struct rpc_task *task, void *calldata)
608 {
609 struct nfs42_offload_data *data = calldata;
610
611 nfs4_setup_sequence(data->seq_server->nfs_client,
612 &data->args.osa_seq_args,
613 &data->res.osr_seq_res, task);
614 }
615
nfs42_offload_cancel_done(struct rpc_task * task,void * calldata)616 static void nfs42_offload_cancel_done(struct rpc_task *task, void *calldata)
617 {
618 struct nfs42_offload_data *data = calldata;
619
620 trace_nfs4_offload_cancel(&data->args, task->tk_status);
621 nfs41_sequence_done(task, &data->res.osr_seq_res);
622 if (task->tk_status &&
623 nfs4_async_handle_error(task, data->seq_server, NULL,
624 NULL) == -EAGAIN)
625 rpc_restart_call_prepare(task);
626 }
627
nfs42_offload_release(void * data)628 static void nfs42_offload_release(void *data)
629 {
630 kfree(data);
631 }
632
633 static const struct rpc_call_ops nfs42_offload_cancel_ops = {
634 .rpc_call_prepare = nfs42_offload_prepare,
635 .rpc_call_done = nfs42_offload_cancel_done,
636 .rpc_release = nfs42_offload_release,
637 };
638
nfs42_do_offload_cancel_async(struct file * dst,nfs4_stateid * stateid)639 static int nfs42_do_offload_cancel_async(struct file *dst,
640 nfs4_stateid *stateid)
641 {
642 struct nfs_server *dst_server = NFS_SERVER(file_inode(dst));
643 struct nfs42_offload_data *data = NULL;
644 struct nfs_open_context *ctx = nfs_file_open_context(dst);
645 struct rpc_task *task;
646 struct rpc_message msg = {
647 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OFFLOAD_CANCEL],
648 .rpc_cred = ctx->cred,
649 };
650 struct rpc_task_setup task_setup_data = {
651 .rpc_client = dst_server->client,
652 .rpc_message = &msg,
653 .callback_ops = &nfs42_offload_cancel_ops,
654 .workqueue = nfsiod_workqueue,
655 .flags = RPC_TASK_ASYNC | RPC_TASK_MOVEABLE,
656 };
657 int status;
658
659 if (!(dst_server->caps & NFS_CAP_OFFLOAD_CANCEL))
660 return -EOPNOTSUPP;
661
662 data = kzalloc_obj(struct nfs42_offload_data);
663 if (data == NULL)
664 return -ENOMEM;
665
666 data->seq_server = dst_server;
667 data->args.osa_src_fh = NFS_FH(file_inode(dst));
668 memcpy(&data->args.osa_stateid, stateid,
669 sizeof(data->args.osa_stateid));
670 msg.rpc_argp = &data->args;
671 msg.rpc_resp = &data->res;
672 task_setup_data.callback_data = data;
673 nfs4_init_sequence(dst_server->nfs_client, &data->args.osa_seq_args,
674 &data->res.osr_seq_res, 1, 0);
675 task = rpc_run_task(&task_setup_data);
676 if (IS_ERR(task))
677 return PTR_ERR(task);
678 status = rpc_wait_for_completion_task(task);
679 if (status == -ENOTSUPP)
680 dst_server->caps &= ~NFS_CAP_OFFLOAD_CANCEL;
681 rpc_put_task(task);
682 return status;
683 }
684
685 static int
_nfs42_proc_offload_status(struct nfs_server * server,struct file * file,struct nfs42_offload_data * data)686 _nfs42_proc_offload_status(struct nfs_server *server, struct file *file,
687 struct nfs42_offload_data *data)
688 {
689 struct nfs_open_context *ctx = nfs_file_open_context(file);
690 struct rpc_message msg = {
691 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OFFLOAD_STATUS],
692 .rpc_argp = &data->args,
693 .rpc_resp = &data->res,
694 .rpc_cred = ctx->cred,
695 };
696 int status;
697
698 status = nfs4_call_sync(server->client, server, &msg,
699 &data->args.osa_seq_args,
700 &data->res.osr_seq_res, 1);
701 trace_nfs4_offload_status(&data->args, status);
702 switch (status) {
703 case 0:
704 break;
705
706 case -NFS4ERR_ADMIN_REVOKED:
707 case -NFS4ERR_BAD_STATEID:
708 case -NFS4ERR_OLD_STATEID:
709 /*
710 * Server does not recognize the COPY stateid. CB_OFFLOAD
711 * could have purged it, or server might have rebooted.
712 * Since COPY stateids don't have an associated inode,
713 * avoid triggering state recovery.
714 */
715 status = -EBADF;
716 break;
717 case -NFS4ERR_NOTSUPP:
718 case -ENOTSUPP:
719 case -EOPNOTSUPP:
720 server->caps &= ~NFS_CAP_OFFLOAD_STATUS;
721 status = -EOPNOTSUPP;
722 break;
723 }
724
725 return status;
726 }
727
728 /**
729 * nfs42_proc_offload_status - Poll completion status of an async copy operation
730 * @dst: handle of file being copied into
731 * @stateid: copy stateid (from async COPY result)
732 * @copied: OUT: number of bytes copied so far
733 *
734 * Return values:
735 * %0: Server returned an NFS4_OK completion status
736 * %-EINPROGRESS: Server returned no completion status
737 * %-EREMOTEIO: Server returned an error completion status
738 * %-EBADF: Server did not recognize the copy stateid
739 * %-EOPNOTSUPP: Server does not support OFFLOAD_STATUS
740 * %-ERESTARTSYS: Wait interrupted by signal
741 *
742 * Other negative errnos indicate the client could not complete the
743 * request.
744 */
745 static int
nfs42_proc_offload_status(struct file * dst,nfs4_stateid * stateid,u64 * copied)746 nfs42_proc_offload_status(struct file *dst, nfs4_stateid *stateid, u64 *copied)
747 {
748 struct inode *inode = file_inode(dst);
749 struct nfs_server *server = NFS_SERVER(inode);
750 struct nfs4_exception exception = {
751 .inode = inode,
752 };
753 struct nfs42_offload_data *data;
754 int status;
755
756 if (!(server->caps & NFS_CAP_OFFLOAD_STATUS))
757 return -EOPNOTSUPP;
758
759 data = kzalloc_obj(*data);
760 if (!data)
761 return -ENOMEM;
762 data->seq_server = server;
763 data->args.osa_src_fh = NFS_FH(inode);
764 memcpy(&data->args.osa_stateid, stateid,
765 sizeof(data->args.osa_stateid));
766 exception.stateid = &data->args.osa_stateid;
767 do {
768 status = _nfs42_proc_offload_status(server, dst, data);
769 if (status == -EOPNOTSUPP)
770 goto out;
771 status = nfs4_handle_exception(server, status, &exception);
772 } while (exception.retry);
773 if (status)
774 goto out;
775
776 *copied = data->res.osr_count;
777 if (!data->res.complete_count)
778 status = -EINPROGRESS;
779 else if (data->res.osr_complete != NFS_OK)
780 status = -EREMOTEIO;
781
782 out:
783 kfree(data);
784 return status;
785 }
786
_nfs42_proc_copy_notify(struct file * src,struct file * dst,struct nfs42_copy_notify_args * args,struct nfs42_copy_notify_res * res)787 static int _nfs42_proc_copy_notify(struct file *src, struct file *dst,
788 struct nfs42_copy_notify_args *args,
789 struct nfs42_copy_notify_res *res)
790 {
791 struct nfs_server *src_server = NFS_SERVER(file_inode(src));
792 struct rpc_message msg = {
793 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_COPY_NOTIFY],
794 .rpc_argp = args,
795 .rpc_resp = res,
796 };
797 int status;
798 struct nfs_open_context *ctx;
799 struct nfs_lock_context *l_ctx;
800
801 ctx = get_nfs_open_context(nfs_file_open_context(src));
802 l_ctx = nfs_get_lock_context(ctx);
803 if (IS_ERR(l_ctx)) {
804 status = PTR_ERR(l_ctx);
805 goto out;
806 }
807
808 status = nfs4_set_rw_stateid(&args->cna_src_stateid, ctx, l_ctx,
809 FMODE_READ);
810 nfs_put_lock_context(l_ctx);
811 if (status) {
812 if (status == -EAGAIN)
813 status = -NFS4ERR_BAD_STATEID;
814 goto out;
815 }
816
817 status = nfs4_call_sync(src_server->client, src_server, &msg,
818 &args->cna_seq_args, &res->cnr_seq_res, 0);
819 trace_nfs4_copy_notify(file_inode(src), args, res, status);
820 if (status == -ENOTSUPP)
821 src_server->caps &= ~NFS_CAP_COPY_NOTIFY;
822
823 out:
824 put_nfs_open_context(nfs_file_open_context(src));
825 return status;
826 }
827
nfs42_proc_copy_notify(struct file * src,struct file * dst,struct nfs42_copy_notify_res * res)828 int nfs42_proc_copy_notify(struct file *src, struct file *dst,
829 struct nfs42_copy_notify_res *res)
830 {
831 struct nfs_server *src_server = NFS_SERVER(file_inode(src));
832 struct nfs42_copy_notify_args *args;
833 struct nfs4_exception exception = {
834 .inode = file_inode(src),
835 };
836 int status;
837
838 if (!(src_server->caps & NFS_CAP_COPY_NOTIFY))
839 return -EOPNOTSUPP;
840
841 args = kzalloc_obj(struct nfs42_copy_notify_args);
842 if (args == NULL)
843 return -ENOMEM;
844
845 args->cna_src_fh = NFS_FH(file_inode(src)),
846 args->cna_dst.nl4_type = NL4_NETADDR;
847 nfs42_set_netaddr(dst, &args->cna_dst.u.nl4_addr);
848 exception.stateid = &args->cna_src_stateid;
849
850 do {
851 status = _nfs42_proc_copy_notify(src, dst, args, res);
852 if (status == -ENOTSUPP) {
853 status = -EOPNOTSUPP;
854 goto out;
855 }
856 status = nfs4_handle_exception(src_server, status, &exception);
857 } while (exception.retry);
858
859 out:
860 kfree(args);
861 return status;
862 }
863
_nfs42_proc_llseek(struct file * filep,struct nfs_lock_context * lock,loff_t offset,int whence)864 static loff_t _nfs42_proc_llseek(struct file *filep,
865 struct nfs_lock_context *lock, loff_t offset, int whence)
866 {
867 struct inode *inode = file_inode(filep);
868 struct nfs42_seek_args args = {
869 .sa_fh = NFS_FH(inode),
870 .sa_offset = offset,
871 .sa_what = (whence == SEEK_HOLE) ?
872 NFS4_CONTENT_HOLE : NFS4_CONTENT_DATA,
873 };
874 struct nfs42_seek_res res;
875 struct rpc_message msg = {
876 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SEEK],
877 .rpc_argp = &args,
878 .rpc_resp = &res,
879 };
880 struct nfs_server *server = NFS_SERVER(inode);
881 int status;
882
883 if (!nfs_server_capable(inode, NFS_CAP_SEEK))
884 return -ENOTSUPP;
885
886 status = nfs4_set_rw_stateid(&args.sa_stateid, lock->open_context,
887 lock, FMODE_READ);
888 if (status) {
889 if (status == -EAGAIN)
890 status = -NFS4ERR_BAD_STATEID;
891 return status;
892 }
893
894 status = nfs_filemap_write_and_wait_range(inode->i_mapping,
895 offset, LLONG_MAX);
896 if (status)
897 return status;
898
899 status = nfs4_call_sync(server->client, server, &msg,
900 &args.seq_args, &res.seq_res, 0);
901 trace_nfs4_llseek(inode, &args, &res, status);
902 if (status == -ENOTSUPP)
903 server->caps &= ~NFS_CAP_SEEK;
904 if (status)
905 return status;
906
907 if (whence == SEEK_DATA && res.sr_eof)
908 return -NFS4ERR_NXIO;
909 else
910 return vfs_setpos(filep, res.sr_offset, inode->i_sb->s_maxbytes);
911 }
912
nfs42_proc_llseek(struct file * filep,loff_t offset,int whence)913 loff_t nfs42_proc_llseek(struct file *filep, loff_t offset, int whence)
914 {
915 struct nfs_server *server = NFS_SERVER(file_inode(filep));
916 struct nfs4_exception exception = { };
917 struct nfs_lock_context *lock;
918 loff_t err;
919
920 lock = nfs_get_lock_context(nfs_file_open_context(filep));
921 if (IS_ERR(lock))
922 return PTR_ERR(lock);
923
924 exception.inode = file_inode(filep);
925 exception.state = lock->open_context->state;
926
927 do {
928 err = _nfs42_proc_llseek(filep, lock, offset, whence);
929 if (err >= 0)
930 break;
931 if (err == -ENOTSUPP) {
932 err = -EOPNOTSUPP;
933 break;
934 }
935 err = nfs4_handle_exception(server, err, &exception);
936 } while (exception.retry);
937
938 nfs_put_lock_context(lock);
939 return err;
940 }
941
942
943 static void
nfs42_layoutstat_prepare(struct rpc_task * task,void * calldata)944 nfs42_layoutstat_prepare(struct rpc_task *task, void *calldata)
945 {
946 struct nfs42_layoutstat_data *data = calldata;
947 struct inode *inode = data->inode;
948 struct nfs_server *server = NFS_SERVER(inode);
949 struct pnfs_layout_hdr *lo;
950
951 spin_lock(&inode->i_lock);
952 lo = NFS_I(inode)->layout;
953 if (!pnfs_layout_is_valid(lo)) {
954 spin_unlock(&inode->i_lock);
955 rpc_exit(task, 0);
956 return;
957 }
958 nfs4_stateid_copy(&data->args.stateid, &lo->plh_stateid);
959 spin_unlock(&inode->i_lock);
960 nfs4_setup_sequence(server->nfs_client, &data->args.seq_args,
961 &data->res.seq_res, task);
962 }
963
964 static void
nfs42_layoutstat_done(struct rpc_task * task,void * calldata)965 nfs42_layoutstat_done(struct rpc_task *task, void *calldata)
966 {
967 struct nfs42_layoutstat_data *data = calldata;
968 struct inode *inode = data->inode;
969 struct pnfs_layout_hdr *lo;
970
971 if (!nfs4_sequence_done(task, &data->res.seq_res))
972 return;
973
974 switch (task->tk_status) {
975 case 0:
976 return;
977 case -NFS4ERR_BADHANDLE:
978 case -ESTALE:
979 pnfs_destroy_layout(NFS_I(inode));
980 break;
981 case -NFS4ERR_EXPIRED:
982 case -NFS4ERR_ADMIN_REVOKED:
983 case -NFS4ERR_DELEG_REVOKED:
984 case -NFS4ERR_STALE_STATEID:
985 case -NFS4ERR_BAD_STATEID:
986 spin_lock(&inode->i_lock);
987 lo = NFS_I(inode)->layout;
988 if (pnfs_layout_is_valid(lo) &&
989 nfs4_stateid_match(&data->args.stateid,
990 &lo->plh_stateid)) {
991 LIST_HEAD(head);
992
993 /*
994 * Mark the bad layout state as invalid, then retry
995 * with the current stateid.
996 */
997 pnfs_mark_layout_stateid_invalid(lo, &head);
998 spin_unlock(&inode->i_lock);
999 pnfs_free_lseg_list(&head);
1000 nfs_commit_inode(inode, 0);
1001 } else
1002 spin_unlock(&inode->i_lock);
1003 break;
1004 case -NFS4ERR_OLD_STATEID:
1005 spin_lock(&inode->i_lock);
1006 lo = NFS_I(inode)->layout;
1007 if (pnfs_layout_is_valid(lo) &&
1008 nfs4_stateid_match_other(&data->args.stateid,
1009 &lo->plh_stateid)) {
1010 /* Do we need to delay before resending? */
1011 if (!nfs4_stateid_is_newer(&lo->plh_stateid,
1012 &data->args.stateid))
1013 rpc_delay(task, HZ);
1014 rpc_restart_call_prepare(task);
1015 }
1016 spin_unlock(&inode->i_lock);
1017 break;
1018 case -ENOTSUPP:
1019 case -EOPNOTSUPP:
1020 NFS_SERVER(inode)->caps &= ~NFS_CAP_LAYOUTSTATS;
1021 }
1022
1023 trace_nfs4_layoutstats(inode, &data->args.stateid, task->tk_status);
1024 }
1025
1026 static void
nfs42_layoutstat_release(void * calldata)1027 nfs42_layoutstat_release(void *calldata)
1028 {
1029 struct nfs42_layoutstat_data *data = calldata;
1030 struct nfs42_layoutstat_devinfo *devinfo = data->args.devinfo;
1031 int i;
1032
1033 for (i = 0; i < data->args.num_dev; i++) {
1034 if (devinfo[i].ld_private.ops && devinfo[i].ld_private.ops->free)
1035 devinfo[i].ld_private.ops->free(&devinfo[i].ld_private);
1036 }
1037
1038 pnfs_put_layout_hdr(NFS_I(data->args.inode)->layout);
1039 smp_mb__before_atomic();
1040 clear_bit(NFS_INO_LAYOUTSTATS, &NFS_I(data->args.inode)->flags);
1041 smp_mb__after_atomic();
1042 nfs_iput_and_deactive(data->inode);
1043 kfree(data->args.devinfo);
1044 kfree(data);
1045 }
1046
1047 static const struct rpc_call_ops nfs42_layoutstat_ops = {
1048 .rpc_call_prepare = nfs42_layoutstat_prepare,
1049 .rpc_call_done = nfs42_layoutstat_done,
1050 .rpc_release = nfs42_layoutstat_release,
1051 };
1052
nfs42_proc_layoutstats_generic(struct nfs_server * server,struct nfs42_layoutstat_data * data)1053 int nfs42_proc_layoutstats_generic(struct nfs_server *server,
1054 struct nfs42_layoutstat_data *data)
1055 {
1056 struct rpc_message msg = {
1057 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTSTATS],
1058 .rpc_argp = &data->args,
1059 .rpc_resp = &data->res,
1060 };
1061 struct rpc_task_setup task_setup = {
1062 .rpc_client = server->client,
1063 .rpc_message = &msg,
1064 .callback_ops = &nfs42_layoutstat_ops,
1065 .callback_data = data,
1066 .flags = RPC_TASK_ASYNC | RPC_TASK_MOVEABLE,
1067 };
1068 struct rpc_task *task;
1069
1070 data->inode = nfs_igrab_and_active(data->args.inode);
1071 if (!data->inode) {
1072 nfs42_layoutstat_release(data);
1073 return -EAGAIN;
1074 }
1075 nfs4_init_sequence(server->nfs_client, &data->args.seq_args,
1076 &data->res.seq_res, 0, 0);
1077 task = rpc_run_task(&task_setup);
1078 if (IS_ERR(task))
1079 return PTR_ERR(task);
1080 rpc_put_task(task);
1081 return 0;
1082 }
1083
1084 static struct nfs42_layouterror_data *
nfs42_alloc_layouterror_data(struct pnfs_layout_segment * lseg,gfp_t gfp_flags)1085 nfs42_alloc_layouterror_data(struct pnfs_layout_segment *lseg, gfp_t gfp_flags)
1086 {
1087 struct nfs42_layouterror_data *data;
1088 struct inode *inode = lseg->pls_layout->plh_inode;
1089
1090 data = kzalloc_obj(*data, gfp_flags);
1091 if (data) {
1092 data->args.inode = data->inode = nfs_igrab_and_active(inode);
1093 if (data->inode) {
1094 data->lseg = pnfs_get_lseg(lseg);
1095 if (data->lseg)
1096 return data;
1097 nfs_iput_and_deactive(data->inode);
1098 }
1099 kfree(data);
1100 }
1101 return NULL;
1102 }
1103
1104 static void
nfs42_free_layouterror_data(struct nfs42_layouterror_data * data)1105 nfs42_free_layouterror_data(struct nfs42_layouterror_data *data)
1106 {
1107 pnfs_put_lseg(data->lseg);
1108 nfs_iput_and_deactive(data->inode);
1109 kfree(data);
1110 }
1111
1112 static void
nfs42_layouterror_prepare(struct rpc_task * task,void * calldata)1113 nfs42_layouterror_prepare(struct rpc_task *task, void *calldata)
1114 {
1115 struct nfs42_layouterror_data *data = calldata;
1116 struct inode *inode = data->inode;
1117 struct nfs_server *server = NFS_SERVER(inode);
1118 struct pnfs_layout_hdr *lo = data->lseg->pls_layout;
1119 unsigned i;
1120
1121 spin_lock(&inode->i_lock);
1122 if (!pnfs_layout_is_valid(lo)) {
1123 spin_unlock(&inode->i_lock);
1124 rpc_exit(task, 0);
1125 return;
1126 }
1127 for (i = 0; i < data->args.num_errors; i++)
1128 nfs4_stateid_copy(&data->args.errors[i].stateid,
1129 &lo->plh_stateid);
1130 spin_unlock(&inode->i_lock);
1131 nfs4_setup_sequence(server->nfs_client, &data->args.seq_args,
1132 &data->res.seq_res, task);
1133 }
1134
1135 static void
nfs42_layouterror_done(struct rpc_task * task,void * calldata)1136 nfs42_layouterror_done(struct rpc_task *task, void *calldata)
1137 {
1138 struct nfs42_layouterror_data *data = calldata;
1139 struct inode *inode = data->inode;
1140 struct pnfs_layout_hdr *lo = data->lseg->pls_layout;
1141
1142 if (!nfs4_sequence_done(task, &data->res.seq_res))
1143 return;
1144
1145 switch (task->tk_status) {
1146 case 0:
1147 return;
1148 case -NFS4ERR_BADHANDLE:
1149 case -ESTALE:
1150 pnfs_destroy_layout(NFS_I(inode));
1151 break;
1152 case -NFS4ERR_EXPIRED:
1153 case -NFS4ERR_ADMIN_REVOKED:
1154 case -NFS4ERR_DELEG_REVOKED:
1155 case -NFS4ERR_STALE_STATEID:
1156 case -NFS4ERR_BAD_STATEID:
1157 spin_lock(&inode->i_lock);
1158 if (pnfs_layout_is_valid(lo) &&
1159 nfs4_stateid_match(&data->args.errors[0].stateid,
1160 &lo->plh_stateid)) {
1161 LIST_HEAD(head);
1162
1163 /*
1164 * Mark the bad layout state as invalid, then retry
1165 * with the current stateid.
1166 */
1167 pnfs_mark_layout_stateid_invalid(lo, &head);
1168 spin_unlock(&inode->i_lock);
1169 pnfs_free_lseg_list(&head);
1170 nfs_commit_inode(inode, 0);
1171 } else
1172 spin_unlock(&inode->i_lock);
1173 break;
1174 case -NFS4ERR_OLD_STATEID:
1175 spin_lock(&inode->i_lock);
1176 if (pnfs_layout_is_valid(lo) &&
1177 nfs4_stateid_match_other(&data->args.errors[0].stateid,
1178 &lo->plh_stateid)) {
1179 /* Do we need to delay before resending? */
1180 if (!nfs4_stateid_is_newer(&lo->plh_stateid,
1181 &data->args.errors[0].stateid))
1182 rpc_delay(task, HZ);
1183 rpc_restart_call_prepare(task);
1184 }
1185 spin_unlock(&inode->i_lock);
1186 break;
1187 case -ENOTSUPP:
1188 case -EOPNOTSUPP:
1189 NFS_SERVER(inode)->caps &= ~NFS_CAP_LAYOUTERROR;
1190 }
1191
1192 trace_nfs4_layouterror(inode, &data->args.errors[0].stateid,
1193 task->tk_status);
1194 }
1195
1196 static void
nfs42_layouterror_release(void * calldata)1197 nfs42_layouterror_release(void *calldata)
1198 {
1199 struct nfs42_layouterror_data *data = calldata;
1200
1201 nfs42_free_layouterror_data(data);
1202 }
1203
1204 static const struct rpc_call_ops nfs42_layouterror_ops = {
1205 .rpc_call_prepare = nfs42_layouterror_prepare,
1206 .rpc_call_done = nfs42_layouterror_done,
1207 .rpc_release = nfs42_layouterror_release,
1208 };
1209
nfs42_proc_layouterror(struct pnfs_layout_segment * lseg,const struct nfs42_layout_error * errors,size_t n)1210 int nfs42_proc_layouterror(struct pnfs_layout_segment *lseg,
1211 const struct nfs42_layout_error *errors, size_t n)
1212 {
1213 struct inode *inode = lseg->pls_layout->plh_inode;
1214 struct nfs_server *server = NFS_SERVER(inode);
1215 struct nfs42_layouterror_data *data;
1216 struct rpc_task *task;
1217 struct rpc_message msg = {
1218 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTERROR],
1219 };
1220 struct rpc_task_setup task_setup = {
1221 .rpc_message = &msg,
1222 .callback_ops = &nfs42_layouterror_ops,
1223 .flags = RPC_TASK_ASYNC | RPC_TASK_MOVEABLE,
1224 };
1225 unsigned int i;
1226
1227 if (!nfs_server_capable(inode, NFS_CAP_LAYOUTERROR))
1228 return -EOPNOTSUPP;
1229 if (n > NFS42_LAYOUTERROR_MAX)
1230 return -EINVAL;
1231 data = nfs42_alloc_layouterror_data(lseg, nfs_io_gfp_mask());
1232 if (!data)
1233 return -ENOMEM;
1234 for (i = 0; i < n; i++) {
1235 data->args.errors[i] = errors[i];
1236 data->args.num_errors++;
1237 data->res.num_errors++;
1238 }
1239 msg.rpc_argp = &data->args;
1240 msg.rpc_resp = &data->res;
1241 task_setup.callback_data = data;
1242 task_setup.rpc_client = server->client;
1243 nfs4_init_sequence(server->nfs_client, &data->args.seq_args,
1244 &data->res.seq_res, 0, 0);
1245 task = rpc_run_task(&task_setup);
1246 if (IS_ERR(task))
1247 return PTR_ERR(task);
1248 rpc_put_task(task);
1249 return 0;
1250 }
1251 EXPORT_SYMBOL_GPL(nfs42_proc_layouterror);
1252
_nfs42_proc_clone(struct rpc_message * msg,struct file * src_f,struct file * dst_f,struct nfs_lock_context * src_lock,struct nfs_lock_context * dst_lock,loff_t src_offset,loff_t dst_offset,loff_t count)1253 static int _nfs42_proc_clone(struct rpc_message *msg, struct file *src_f,
1254 struct file *dst_f, struct nfs_lock_context *src_lock,
1255 struct nfs_lock_context *dst_lock, loff_t src_offset,
1256 loff_t dst_offset, loff_t count)
1257 {
1258 struct inode *src_inode = file_inode(src_f);
1259 struct inode *dst_inode = file_inode(dst_f);
1260 struct nfs_server *server = NFS_SERVER(dst_inode);
1261 __u32 dst_bitmask[NFS_BITMASK_SZ];
1262 struct nfs42_clone_args args = {
1263 .src_fh = NFS_FH(src_inode),
1264 .dst_fh = NFS_FH(dst_inode),
1265 .src_offset = src_offset,
1266 .dst_offset = dst_offset,
1267 .count = count,
1268 .dst_bitmask = dst_bitmask,
1269 };
1270 struct nfs42_clone_res res = {
1271 .server = server,
1272 };
1273 loff_t oldsize_dst = i_size_read(dst_inode);
1274 int status;
1275
1276 msg->rpc_argp = &args;
1277 msg->rpc_resp = &res;
1278
1279 status = nfs4_set_rw_stateid(&args.src_stateid, src_lock->open_context,
1280 src_lock, FMODE_READ);
1281 if (status) {
1282 if (status == -EAGAIN)
1283 status = -NFS4ERR_BAD_STATEID;
1284 return status;
1285 }
1286 status = nfs4_set_rw_stateid(&args.dst_stateid, dst_lock->open_context,
1287 dst_lock, FMODE_WRITE);
1288 if (status) {
1289 if (status == -EAGAIN)
1290 status = -NFS4ERR_BAD_STATEID;
1291 return status;
1292 }
1293
1294 res.dst_fattr = nfs_alloc_fattr();
1295 if (!res.dst_fattr)
1296 return -ENOMEM;
1297
1298 nfs4_bitmask_set(dst_bitmask, server->cache_consistency_bitmask,
1299 dst_inode, NFS_INO_INVALID_BLOCKS);
1300
1301 status = nfs4_call_sync(server->client, server, msg,
1302 &args.seq_args, &res.seq_res, 0);
1303 trace_nfs4_clone(src_inode, dst_inode, &args, status);
1304 if (status == 0) {
1305 /* a zero-length count means clone to EOF in src */
1306 if (count == 0 && res.dst_fattr->valid & NFS_ATTR_FATTR_SIZE)
1307 count = nfs_size_to_loff_t(res.dst_fattr->size) - dst_offset;
1308 nfs42_copy_dest_done(dst_f, dst_offset, count, oldsize_dst);
1309 status = nfs_post_op_update_inode(dst_inode, res.dst_fattr);
1310 }
1311
1312 kfree(res.dst_fattr);
1313 return status;
1314 }
1315
nfs42_proc_clone(struct file * src_f,struct file * dst_f,loff_t src_offset,loff_t dst_offset,loff_t count)1316 int nfs42_proc_clone(struct file *src_f, struct file *dst_f,
1317 loff_t src_offset, loff_t dst_offset, loff_t count)
1318 {
1319 struct rpc_message msg = {
1320 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CLONE],
1321 };
1322 struct inode *inode = file_inode(src_f);
1323 struct nfs_server *server = NFS_SERVER(file_inode(src_f));
1324 struct nfs_lock_context *src_lock;
1325 struct nfs_lock_context *dst_lock;
1326 struct nfs4_exception src_exception = { };
1327 struct nfs4_exception dst_exception = { };
1328 int err, err2;
1329
1330 if (!nfs_server_capable(inode, NFS_CAP_CLONE))
1331 return -EOPNOTSUPP;
1332
1333 src_lock = nfs_get_lock_context(nfs_file_open_context(src_f));
1334 if (IS_ERR(src_lock))
1335 return PTR_ERR(src_lock);
1336
1337 src_exception.inode = file_inode(src_f);
1338 src_exception.state = src_lock->open_context->state;
1339
1340 dst_lock = nfs_get_lock_context(nfs_file_open_context(dst_f));
1341 if (IS_ERR(dst_lock)) {
1342 err = PTR_ERR(dst_lock);
1343 goto out_put_src_lock;
1344 }
1345
1346 dst_exception.inode = file_inode(dst_f);
1347 dst_exception.state = dst_lock->open_context->state;
1348
1349 do {
1350 err = _nfs42_proc_clone(&msg, src_f, dst_f, src_lock, dst_lock,
1351 src_offset, dst_offset, count);
1352 if (err == -ENOTSUPP || err == -EOPNOTSUPP) {
1353 NFS_SERVER(inode)->caps &= ~NFS_CAP_CLONE;
1354 err = -EOPNOTSUPP;
1355 break;
1356 }
1357
1358 err2 = nfs4_handle_exception(server, err, &src_exception);
1359 err = nfs4_handle_exception(server, err, &dst_exception);
1360 if (!err)
1361 err = err2;
1362 } while (src_exception.retry || dst_exception.retry);
1363
1364 nfs_put_lock_context(dst_lock);
1365 out_put_src_lock:
1366 nfs_put_lock_context(src_lock);
1367 return err;
1368 }
1369
1370 #define NFS4XATTR_MAXPAGES DIV_ROUND_UP(XATTR_SIZE_MAX, PAGE_SIZE)
1371
_nfs42_proc_removexattr(struct inode * inode,const char * name)1372 static int _nfs42_proc_removexattr(struct inode *inode, const char *name)
1373 {
1374 struct nfs_server *server = NFS_SERVER(inode);
1375 struct nfs42_removexattrargs args = {
1376 .fh = NFS_FH(inode),
1377 .xattr_name = name,
1378 };
1379 struct nfs42_removexattrres res;
1380 struct rpc_message msg = {
1381 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVEXATTR],
1382 .rpc_argp = &args,
1383 .rpc_resp = &res,
1384 };
1385 int ret;
1386 unsigned long timestamp = jiffies;
1387
1388 ret = nfs4_call_sync(server->client, server, &msg, &args.seq_args,
1389 &res.seq_res, 1);
1390 trace_nfs4_removexattr(inode, name, ret);
1391 if (!ret)
1392 nfs4_update_changeattr(inode, &res.cinfo, timestamp, 0);
1393
1394 return ret;
1395 }
1396
_nfs42_proc_setxattr(struct inode * inode,const char * name,const void * buf,size_t buflen,int flags)1397 static int _nfs42_proc_setxattr(struct inode *inode, const char *name,
1398 const void *buf, size_t buflen, int flags)
1399 {
1400 struct nfs_server *server = NFS_SERVER(inode);
1401 __u32 bitmask[NFS_BITMASK_SZ];
1402 struct page *pages[NFS4XATTR_MAXPAGES];
1403 struct nfs42_setxattrargs arg = {
1404 .fh = NFS_FH(inode),
1405 .bitmask = bitmask,
1406 .xattr_pages = pages,
1407 .xattr_len = buflen,
1408 .xattr_name = name,
1409 .xattr_flags = flags,
1410 };
1411 struct nfs42_setxattrres res = {
1412 .server = server,
1413 };
1414 struct rpc_message msg = {
1415 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETXATTR],
1416 .rpc_argp = &arg,
1417 .rpc_resp = &res,
1418 };
1419 int ret, np;
1420 unsigned long timestamp = jiffies;
1421
1422 if (buflen > server->sxasize)
1423 return -ERANGE;
1424
1425 res.fattr = nfs_alloc_fattr();
1426 if (!res.fattr)
1427 return -ENOMEM;
1428
1429 if (buflen > 0) {
1430 np = nfs4_buf_to_pages_noslab(buf, buflen, arg.xattr_pages);
1431 if (np < 0) {
1432 ret = np;
1433 goto out;
1434 }
1435 } else
1436 np = 0;
1437
1438 nfs4_bitmask_set(bitmask, server->cache_consistency_bitmask,
1439 inode, NFS_INO_INVALID_CHANGE);
1440
1441 ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args,
1442 &res.seq_res, 1);
1443 trace_nfs4_setxattr(inode, name, ret);
1444
1445 for (; np > 0; np--)
1446 put_page(pages[np - 1]);
1447
1448 if (!ret) {
1449 nfs4_update_changeattr(inode, &res.cinfo, timestamp, 0);
1450 ret = nfs_post_op_update_inode(inode, res.fattr);
1451 }
1452
1453 out:
1454 kfree(res.fattr);
1455 return ret;
1456 }
1457
_nfs42_proc_getxattr(struct inode * inode,const char * name,void * buf,size_t buflen,struct page ** pages,size_t plen)1458 static ssize_t _nfs42_proc_getxattr(struct inode *inode, const char *name,
1459 void *buf, size_t buflen, struct page **pages,
1460 size_t plen)
1461 {
1462 struct nfs_server *server = NFS_SERVER(inode);
1463 struct nfs42_getxattrargs arg = {
1464 .fh = NFS_FH(inode),
1465 .xattr_name = name,
1466 };
1467 struct nfs42_getxattrres res;
1468 struct rpc_message msg = {
1469 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETXATTR],
1470 .rpc_argp = &arg,
1471 .rpc_resp = &res,
1472 };
1473 ssize_t ret;
1474
1475 arg.xattr_len = plen;
1476 arg.xattr_pages = pages;
1477
1478 ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args,
1479 &res.seq_res, 0);
1480 trace_nfs4_getxattr(inode, name, ret);
1481 if (ret < 0)
1482 return ret;
1483
1484 /*
1485 * Normally, the caching is done one layer up, but for successful
1486 * RPCS, always cache the result here, even if the caller was
1487 * just querying the length, or if the reply was too big for
1488 * the caller. This avoids a second RPC in the case of the
1489 * common query-alloc-retrieve cycle for xattrs.
1490 *
1491 * Note that xattr_len is always capped to XATTR_SIZE_MAX.
1492 */
1493
1494 nfs4_xattr_cache_add(inode, name, NULL, pages, res.xattr_len);
1495
1496 if (buflen) {
1497 if (res.xattr_len > buflen)
1498 return -ERANGE;
1499 _copy_from_pages(buf, pages, 0, res.xattr_len);
1500 }
1501
1502 return res.xattr_len;
1503 }
1504
_nfs42_proc_listxattrs(struct inode * inode,void * buf,size_t buflen,u64 * cookiep,bool * eofp)1505 static ssize_t _nfs42_proc_listxattrs(struct inode *inode, void *buf,
1506 size_t buflen, u64 *cookiep, bool *eofp)
1507 {
1508 struct nfs_server *server = NFS_SERVER(inode);
1509 struct page **pages;
1510 struct nfs42_listxattrsargs arg = {
1511 .fh = NFS_FH(inode),
1512 .cookie = *cookiep,
1513 };
1514 struct nfs42_listxattrsres res = {
1515 .eof = false,
1516 .xattr_buf = buf,
1517 .xattr_len = buflen,
1518 };
1519 struct rpc_message msg = {
1520 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LISTXATTRS],
1521 .rpc_argp = &arg,
1522 .rpc_resp = &res,
1523 };
1524 u32 xdrlen;
1525 int ret, np, i;
1526
1527
1528 ret = -ENOMEM;
1529 res.scratch = folio_alloc(GFP_KERNEL, 0);
1530 if (!res.scratch)
1531 goto out;
1532
1533 xdrlen = nfs42_listxattr_xdrsize(buflen);
1534 if (xdrlen > server->lxasize)
1535 xdrlen = server->lxasize;
1536 np = xdrlen / PAGE_SIZE + 1;
1537
1538 pages = kzalloc_objs(struct page *, np);
1539 if (!pages)
1540 goto out_free_scratch;
1541 for (i = 0; i < np; i++) {
1542 pages[i] = alloc_page(GFP_KERNEL);
1543 if (!pages[i])
1544 goto out_free_pages;
1545 }
1546
1547 arg.xattr_pages = pages;
1548 arg.count = xdrlen;
1549
1550 ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args,
1551 &res.seq_res, 0);
1552 trace_nfs4_listxattr(inode, ret);
1553
1554 if (ret >= 0) {
1555 ret = res.copied;
1556 *cookiep = res.cookie;
1557 *eofp = res.eof;
1558 }
1559
1560 out_free_pages:
1561 while (--np >= 0) {
1562 if (pages[np])
1563 __free_page(pages[np]);
1564 }
1565 kfree(pages);
1566 out_free_scratch:
1567 folio_put(res.scratch);
1568 out:
1569 return ret;
1570
1571 }
1572
nfs42_proc_getxattr(struct inode * inode,const char * name,void * buf,size_t buflen)1573 ssize_t nfs42_proc_getxattr(struct inode *inode, const char *name,
1574 void *buf, size_t buflen)
1575 {
1576 struct nfs4_exception exception = { };
1577 ssize_t err, np, i;
1578 struct page **pages;
1579
1580 np = nfs_page_array_len(0, buflen ?: XATTR_SIZE_MAX);
1581 pages = kmalloc_objs(*pages, np);
1582 if (!pages)
1583 return -ENOMEM;
1584
1585 for (i = 0; i < np; i++) {
1586 pages[i] = alloc_page(GFP_KERNEL);
1587 if (!pages[i]) {
1588 err = -ENOMEM;
1589 goto out;
1590 }
1591 }
1592
1593 /*
1594 * The GETXATTR op has no length field in the call, and the
1595 * xattr data is at the end of the reply.
1596 *
1597 * There is no downside in using the page-aligned length. It will
1598 * allow receiving and caching xattrs that are too large for the
1599 * caller but still fit in the page-rounded value.
1600 */
1601 do {
1602 err = _nfs42_proc_getxattr(inode, name, buf, buflen,
1603 pages, np * PAGE_SIZE);
1604 if (err >= 0)
1605 break;
1606 err = nfs4_handle_exception(NFS_SERVER(inode), err,
1607 &exception);
1608 } while (exception.retry);
1609
1610 out:
1611 while (--i >= 0)
1612 __free_page(pages[i]);
1613 kfree(pages);
1614
1615 return err;
1616 }
1617
nfs42_proc_setxattr(struct inode * inode,const char * name,const void * buf,size_t buflen,int flags)1618 int nfs42_proc_setxattr(struct inode *inode, const char *name,
1619 const void *buf, size_t buflen, int flags)
1620 {
1621 struct nfs4_exception exception = { };
1622 int err;
1623
1624 do {
1625 err = _nfs42_proc_setxattr(inode, name, buf, buflen, flags);
1626 if (!err)
1627 break;
1628 err = nfs4_handle_exception(NFS_SERVER(inode), err,
1629 &exception);
1630 } while (exception.retry);
1631
1632 return err;
1633 }
1634
nfs42_proc_listxattrs(struct inode * inode,void * buf,size_t buflen,u64 * cookiep,bool * eofp)1635 ssize_t nfs42_proc_listxattrs(struct inode *inode, void *buf,
1636 size_t buflen, u64 *cookiep, bool *eofp)
1637 {
1638 struct nfs4_exception exception = { };
1639 ssize_t err;
1640
1641 do {
1642 err = _nfs42_proc_listxattrs(inode, buf, buflen,
1643 cookiep, eofp);
1644 if (err >= 0)
1645 break;
1646 err = nfs4_handle_exception(NFS_SERVER(inode), err,
1647 &exception);
1648 } while (exception.retry);
1649
1650 return err;
1651 }
1652
nfs42_proc_removexattr(struct inode * inode,const char * name)1653 int nfs42_proc_removexattr(struct inode *inode, const char *name)
1654 {
1655 struct nfs4_exception exception = { };
1656 int err;
1657
1658 do {
1659 err = _nfs42_proc_removexattr(inode, name);
1660 if (!err)
1661 break;
1662 err = nfs4_handle_exception(NFS_SERVER(inode), err,
1663 &exception);
1664 } while (exception.retry);
1665
1666 return err;
1667 }
1668