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 nfs_update_delegated_mtime(inode);
405 }
406
_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)407 static ssize_t _nfs42_proc_copy(struct file *src,
408 struct nfs_lock_context *src_lock,
409 struct file *dst,
410 struct nfs_lock_context *dst_lock,
411 struct nfs42_copy_args *args,
412 struct nfs42_copy_res *res,
413 struct nl4_server *nss,
414 nfs4_stateid *cnr_stateid,
415 bool *restart)
416 {
417 struct rpc_message msg = {
418 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_COPY],
419 .rpc_argp = args,
420 .rpc_resp = res,
421 };
422 struct inode *dst_inode = file_inode(dst);
423 struct inode *src_inode = file_inode(src);
424 struct nfs_server *dst_server = NFS_SERVER(dst_inode);
425 struct nfs_server *src_server = NFS_SERVER(src_inode);
426 loff_t pos_src = args->src_pos;
427 loff_t pos_dst = args->dst_pos;
428 loff_t oldsize_dst;
429 size_t count = args->count;
430 ssize_t status;
431
432 if (nss) {
433 args->cp_src = nss;
434 nfs4_stateid_copy(&args->src_stateid, cnr_stateid);
435 } else {
436 status = nfs4_set_rw_stateid(&args->src_stateid,
437 src_lock->open_context, src_lock, FMODE_READ);
438 if (status) {
439 if (status == -EAGAIN)
440 status = -NFS4ERR_BAD_STATEID;
441 return status;
442 }
443 }
444 status = nfs_filemap_write_and_wait_range(src->f_mapping,
445 pos_src, pos_src + (loff_t)count - 1);
446 if (status)
447 return status;
448
449 status = nfs4_set_rw_stateid(&args->dst_stateid, dst_lock->open_context,
450 dst_lock, FMODE_WRITE);
451 if (status) {
452 if (status == -EAGAIN)
453 status = -NFS4ERR_BAD_STATEID;
454 return status;
455 }
456
457 nfs_file_block_o_direct(NFS_I(dst_inode));
458 status = nfs_sync_inode(dst_inode);
459 if (status)
460 return status;
461
462 res->commit_res.verf = NULL;
463 if (args->sync) {
464 res->commit_res.verf =
465 kzalloc_obj(struct nfs_writeverf);
466 if (!res->commit_res.verf)
467 return -ENOMEM;
468 }
469 set_bit(NFS_CLNT_SRC_SSC_COPY_STATE,
470 &src_lock->open_context->state->flags);
471 set_bit(NFS_CLNT_DST_SSC_COPY_STATE,
472 &dst_lock->open_context->state->flags);
473 oldsize_dst = i_size_read(dst_inode);
474
475 status = nfs4_call_sync(dst_server->client, dst_server, &msg,
476 &args->seq_args, &res->seq_res, 0);
477 trace_nfs4_copy(src_inode, dst_inode, args, res, nss, status);
478 if (status == -ENOTSUPP)
479 dst_server->caps &= ~NFS_CAP_COPY;
480 if (status)
481 goto out;
482
483 if (args->sync &&
484 nfs_write_verifier_cmp(&res->write_res.verifier.verifier,
485 &res->commit_res.verf->verifier)) {
486 status = -EAGAIN;
487 goto out;
488 }
489
490 if (!res->synchronous) {
491 status = handle_async_copy(res, dst_server, src_server, src,
492 dst, &args->src_stateid, restart);
493 if (status)
494 goto out;
495 }
496
497 if ((!res->synchronous || !args->sync) &&
498 res->write_res.verifier.committed != NFS_FILE_SYNC) {
499 status = process_copy_commit(dst, pos_dst, res);
500 if (status)
501 goto out;
502 }
503
504 nfs42_copy_dest_done(dst, pos_dst, res->write_res.count, oldsize_dst);
505 nfs_invalidate_atime(src_inode);
506 status = res->write_res.count;
507 out:
508 if (args->sync)
509 kfree(res->commit_res.verf);
510 return status;
511 }
512
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)513 ssize_t nfs42_proc_copy(struct file *src, loff_t pos_src,
514 struct file *dst, loff_t pos_dst, size_t count,
515 struct nl4_server *nss,
516 nfs4_stateid *cnr_stateid, bool sync)
517 {
518 struct nfs_server *server = NFS_SERVER(file_inode(dst));
519 struct nfs_lock_context *src_lock;
520 struct nfs_lock_context *dst_lock;
521 struct nfs42_copy_args args = {
522 .src_fh = NFS_FH(file_inode(src)),
523 .src_pos = pos_src,
524 .dst_fh = NFS_FH(file_inode(dst)),
525 .dst_pos = pos_dst,
526 .count = count,
527 .sync = sync,
528 };
529 struct nfs42_copy_res res;
530 struct nfs4_exception src_exception = {
531 .inode = file_inode(src),
532 .stateid = &args.src_stateid,
533 };
534 struct nfs4_exception dst_exception = {
535 .inode = file_inode(dst),
536 .stateid = &args.dst_stateid,
537 };
538 ssize_t err, err2;
539 bool restart = false;
540
541 src_lock = nfs_get_lock_context(nfs_file_open_context(src));
542 if (IS_ERR(src_lock))
543 return PTR_ERR(src_lock);
544
545 src_exception.state = src_lock->open_context->state;
546
547 dst_lock = nfs_get_lock_context(nfs_file_open_context(dst));
548 if (IS_ERR(dst_lock)) {
549 err = PTR_ERR(dst_lock);
550 goto out_put_src_lock;
551 }
552
553 dst_exception.state = dst_lock->open_context->state;
554
555 do {
556 inode_lock(file_inode(dst));
557 err = _nfs42_proc_copy(src, src_lock,
558 dst, dst_lock,
559 &args, &res,
560 nss, cnr_stateid, &restart);
561 inode_unlock(file_inode(dst));
562
563 if (err >= 0)
564 break;
565 if ((err == -ENOTSUPP ||
566 err == -NFS4ERR_OFFLOAD_DENIED) &&
567 nfs42_files_from_same_server(src, dst)) {
568 err = -EOPNOTSUPP;
569 break;
570 } else if (err == -EAGAIN) {
571 if (!restart) {
572 dst_exception.retry = 1;
573 continue;
574 }
575 break;
576 } else if (err == -NFS4ERR_OFFLOAD_NO_REQS &&
577 args.sync != res.synchronous) {
578 args.sync = res.synchronous;
579 dst_exception.retry = 1;
580 continue;
581 } else if ((err == -ESTALE ||
582 err == -NFS4ERR_OFFLOAD_DENIED ||
583 err == -ENOTSUPP) &&
584 !nfs42_files_from_same_server(src, dst)) {
585 nfs42_do_offload_cancel_async(src, &args.src_stateid);
586 err = -EOPNOTSUPP;
587 break;
588 }
589
590 err2 = nfs4_handle_exception(server, err, &src_exception);
591 err = nfs4_handle_exception(server, err, &dst_exception);
592 if (!err)
593 err = err2;
594 } while (src_exception.retry || dst_exception.retry);
595
596 nfs_put_lock_context(dst_lock);
597 out_put_src_lock:
598 nfs_put_lock_context(src_lock);
599 return err;
600 }
601
602 struct nfs42_offload_data {
603 struct nfs_server *seq_server;
604 struct nfs42_offload_status_args args;
605 struct nfs42_offload_status_res res;
606 };
607
nfs42_offload_prepare(struct rpc_task * task,void * calldata)608 static void nfs42_offload_prepare(struct rpc_task *task, void *calldata)
609 {
610 struct nfs42_offload_data *data = calldata;
611
612 nfs4_setup_sequence(data->seq_server->nfs_client,
613 &data->args.osa_seq_args,
614 &data->res.osr_seq_res, task);
615 }
616
nfs42_offload_cancel_done(struct rpc_task * task,void * calldata)617 static void nfs42_offload_cancel_done(struct rpc_task *task, void *calldata)
618 {
619 struct nfs42_offload_data *data = calldata;
620
621 trace_nfs4_offload_cancel(&data->args, task->tk_status);
622 nfs41_sequence_done(task, &data->res.osr_seq_res);
623 if (task->tk_status &&
624 nfs4_async_handle_error(task, data->seq_server, NULL,
625 NULL) == -EAGAIN)
626 rpc_restart_call_prepare(task);
627 }
628
nfs42_offload_release(void * data)629 static void nfs42_offload_release(void *data)
630 {
631 kfree(data);
632 }
633
634 static const struct rpc_call_ops nfs42_offload_cancel_ops = {
635 .rpc_call_prepare = nfs42_offload_prepare,
636 .rpc_call_done = nfs42_offload_cancel_done,
637 .rpc_release = nfs42_offload_release,
638 };
639
nfs42_do_offload_cancel_async(struct file * dst,nfs4_stateid * stateid)640 static int nfs42_do_offload_cancel_async(struct file *dst,
641 nfs4_stateid *stateid)
642 {
643 struct nfs_server *dst_server = NFS_SERVER(file_inode(dst));
644 struct nfs42_offload_data *data = NULL;
645 struct nfs_open_context *ctx = nfs_file_open_context(dst);
646 struct rpc_task *task;
647 struct rpc_message msg = {
648 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OFFLOAD_CANCEL],
649 .rpc_cred = ctx->cred,
650 };
651 struct rpc_task_setup task_setup_data = {
652 .rpc_client = dst_server->client,
653 .rpc_message = &msg,
654 .callback_ops = &nfs42_offload_cancel_ops,
655 .workqueue = nfsiod_workqueue,
656 .flags = RPC_TASK_ASYNC | RPC_TASK_MOVEABLE,
657 };
658 int status;
659
660 if (!(dst_server->caps & NFS_CAP_OFFLOAD_CANCEL))
661 return -EOPNOTSUPP;
662
663 data = kzalloc_obj(struct nfs42_offload_data);
664 if (data == NULL)
665 return -ENOMEM;
666
667 data->seq_server = dst_server;
668 data->args.osa_src_fh = NFS_FH(file_inode(dst));
669 memcpy(&data->args.osa_stateid, stateid,
670 sizeof(data->args.osa_stateid));
671 msg.rpc_argp = &data->args;
672 msg.rpc_resp = &data->res;
673 task_setup_data.callback_data = data;
674 nfs4_init_sequence(dst_server->nfs_client, &data->args.osa_seq_args,
675 &data->res.osr_seq_res, 1, 0);
676 task = rpc_run_task(&task_setup_data);
677 if (IS_ERR(task))
678 return PTR_ERR(task);
679 status = rpc_wait_for_completion_task(task);
680 if (status == -ENOTSUPP)
681 dst_server->caps &= ~NFS_CAP_OFFLOAD_CANCEL;
682 rpc_put_task(task);
683 return status;
684 }
685
686 static int
_nfs42_proc_offload_status(struct nfs_server * server,struct file * file,struct nfs42_offload_data * data)687 _nfs42_proc_offload_status(struct nfs_server *server, struct file *file,
688 struct nfs42_offload_data *data)
689 {
690 struct nfs_open_context *ctx = nfs_file_open_context(file);
691 struct rpc_message msg = {
692 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OFFLOAD_STATUS],
693 .rpc_argp = &data->args,
694 .rpc_resp = &data->res,
695 .rpc_cred = ctx->cred,
696 };
697 int status;
698
699 status = nfs4_call_sync(server->client, server, &msg,
700 &data->args.osa_seq_args,
701 &data->res.osr_seq_res, 1);
702 trace_nfs4_offload_status(&data->args, status);
703 switch (status) {
704 case 0:
705 break;
706
707 case -NFS4ERR_ADMIN_REVOKED:
708 case -NFS4ERR_BAD_STATEID:
709 case -NFS4ERR_OLD_STATEID:
710 /*
711 * Server does not recognize the COPY stateid. CB_OFFLOAD
712 * could have purged it, or server might have rebooted.
713 * Since COPY stateids don't have an associated inode,
714 * avoid triggering state recovery.
715 */
716 status = -EBADF;
717 break;
718 case -NFS4ERR_NOTSUPP:
719 case -ENOTSUPP:
720 case -EOPNOTSUPP:
721 server->caps &= ~NFS_CAP_OFFLOAD_STATUS;
722 status = -EOPNOTSUPP;
723 break;
724 }
725
726 return status;
727 }
728
729 /**
730 * nfs42_proc_offload_status - Poll completion status of an async copy operation
731 * @dst: handle of file being copied into
732 * @stateid: copy stateid (from async COPY result)
733 * @copied: OUT: number of bytes copied so far
734 *
735 * Return values:
736 * %0: Server returned an NFS4_OK completion status
737 * %-EINPROGRESS: Server returned no completion status
738 * %-EREMOTEIO: Server returned an error completion status
739 * %-EBADF: Server did not recognize the copy stateid
740 * %-EOPNOTSUPP: Server does not support OFFLOAD_STATUS
741 * %-ERESTARTSYS: Wait interrupted by signal
742 *
743 * Other negative errnos indicate the client could not complete the
744 * request.
745 */
746 static int
nfs42_proc_offload_status(struct file * dst,nfs4_stateid * stateid,u64 * copied)747 nfs42_proc_offload_status(struct file *dst, nfs4_stateid *stateid, u64 *copied)
748 {
749 struct inode *inode = file_inode(dst);
750 struct nfs_server *server = NFS_SERVER(inode);
751 struct nfs4_exception exception = {
752 .inode = inode,
753 };
754 struct nfs42_offload_data *data;
755 int status;
756
757 if (!(server->caps & NFS_CAP_OFFLOAD_STATUS))
758 return -EOPNOTSUPP;
759
760 data = kzalloc_obj(*data);
761 if (!data)
762 return -ENOMEM;
763 data->seq_server = server;
764 data->args.osa_src_fh = NFS_FH(inode);
765 memcpy(&data->args.osa_stateid, stateid,
766 sizeof(data->args.osa_stateid));
767 exception.stateid = &data->args.osa_stateid;
768 do {
769 status = _nfs42_proc_offload_status(server, dst, data);
770 if (status == -EOPNOTSUPP)
771 goto out;
772 status = nfs4_handle_exception(server, status, &exception);
773 } while (exception.retry);
774 if (status)
775 goto out;
776
777 *copied = data->res.osr_count;
778 if (!data->res.complete_count)
779 status = -EINPROGRESS;
780 else if (data->res.osr_complete != NFS_OK)
781 status = -EREMOTEIO;
782
783 out:
784 kfree(data);
785 return status;
786 }
787
_nfs42_proc_copy_notify(struct file * src,struct file * dst,struct nfs42_copy_notify_args * args,struct nfs42_copy_notify_res * res)788 static int _nfs42_proc_copy_notify(struct file *src, struct file *dst,
789 struct nfs42_copy_notify_args *args,
790 struct nfs42_copy_notify_res *res)
791 {
792 struct nfs_server *src_server = NFS_SERVER(file_inode(src));
793 struct rpc_message msg = {
794 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_COPY_NOTIFY],
795 .rpc_argp = args,
796 .rpc_resp = res,
797 };
798 int status;
799 struct nfs_open_context *ctx;
800 struct nfs_lock_context *l_ctx;
801
802 ctx = get_nfs_open_context(nfs_file_open_context(src));
803 l_ctx = nfs_get_lock_context(ctx);
804 if (IS_ERR(l_ctx)) {
805 status = PTR_ERR(l_ctx);
806 goto out;
807 }
808
809 status = nfs4_set_rw_stateid(&args->cna_src_stateid, ctx, l_ctx,
810 FMODE_READ);
811 nfs_put_lock_context(l_ctx);
812 if (status) {
813 if (status == -EAGAIN)
814 status = -NFS4ERR_BAD_STATEID;
815 goto out;
816 }
817
818 status = nfs4_call_sync(src_server->client, src_server, &msg,
819 &args->cna_seq_args, &res->cnr_seq_res, 0);
820 trace_nfs4_copy_notify(file_inode(src), args, res, status);
821 if (status == -ENOTSUPP)
822 src_server->caps &= ~NFS_CAP_COPY_NOTIFY;
823
824 out:
825 put_nfs_open_context(nfs_file_open_context(src));
826 return status;
827 }
828
nfs42_proc_copy_notify(struct file * src,struct file * dst,struct nfs42_copy_notify_res * res)829 int nfs42_proc_copy_notify(struct file *src, struct file *dst,
830 struct nfs42_copy_notify_res *res)
831 {
832 struct nfs_server *src_server = NFS_SERVER(file_inode(src));
833 struct nfs42_copy_notify_args *args;
834 struct nfs4_exception exception = {
835 .inode = file_inode(src),
836 };
837 int status;
838
839 if (!(src_server->caps & NFS_CAP_COPY_NOTIFY))
840 return -EOPNOTSUPP;
841
842 args = kzalloc_obj(struct nfs42_copy_notify_args);
843 if (args == NULL)
844 return -ENOMEM;
845
846 args->cna_src_fh = NFS_FH(file_inode(src)),
847 args->cna_dst.nl4_type = NL4_NETADDR;
848 nfs42_set_netaddr(dst, &args->cna_dst.u.nl4_addr);
849 exception.stateid = &args->cna_src_stateid;
850
851 do {
852 status = _nfs42_proc_copy_notify(src, dst, args, res);
853 if (status == -ENOTSUPP) {
854 status = -EOPNOTSUPP;
855 goto out;
856 }
857 status = nfs4_handle_exception(src_server, status, &exception);
858 } while (exception.retry);
859
860 out:
861 kfree(args);
862 return status;
863 }
864
_nfs42_proc_llseek(struct file * filep,struct nfs_lock_context * lock,loff_t offset,int whence)865 static loff_t _nfs42_proc_llseek(struct file *filep,
866 struct nfs_lock_context *lock, loff_t offset, int whence)
867 {
868 struct inode *inode = file_inode(filep);
869 struct nfs42_seek_args args = {
870 .sa_fh = NFS_FH(inode),
871 .sa_offset = offset,
872 .sa_what = (whence == SEEK_HOLE) ?
873 NFS4_CONTENT_HOLE : NFS4_CONTENT_DATA,
874 };
875 struct nfs42_seek_res res;
876 struct rpc_message msg = {
877 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SEEK],
878 .rpc_argp = &args,
879 .rpc_resp = &res,
880 };
881 struct nfs_server *server = NFS_SERVER(inode);
882 int status;
883
884 if (!nfs_server_capable(inode, NFS_CAP_SEEK))
885 return -ENOTSUPP;
886
887 status = nfs4_set_rw_stateid(&args.sa_stateid, lock->open_context,
888 lock, FMODE_READ);
889 if (status) {
890 if (status == -EAGAIN)
891 status = -NFS4ERR_BAD_STATEID;
892 return status;
893 }
894
895 status = nfs_filemap_write_and_wait_range(inode->i_mapping,
896 offset, LLONG_MAX);
897 if (status)
898 return status;
899
900 status = nfs4_call_sync(server->client, server, &msg,
901 &args.seq_args, &res.seq_res, 0);
902 trace_nfs4_llseek(inode, &args, &res, status);
903 if (status == -ENOTSUPP)
904 server->caps &= ~NFS_CAP_SEEK;
905 if (status)
906 return status;
907
908 if (whence == SEEK_DATA && res.sr_eof)
909 return -NFS4ERR_NXIO;
910 else
911 return vfs_setpos(filep, res.sr_offset, inode->i_sb->s_maxbytes);
912 }
913
nfs42_proc_llseek(struct file * filep,loff_t offset,int whence)914 loff_t nfs42_proc_llseek(struct file *filep, loff_t offset, int whence)
915 {
916 struct nfs_server *server = NFS_SERVER(file_inode(filep));
917 struct nfs4_exception exception = { };
918 struct nfs_lock_context *lock;
919 loff_t err;
920
921 lock = nfs_get_lock_context(nfs_file_open_context(filep));
922 if (IS_ERR(lock))
923 return PTR_ERR(lock);
924
925 exception.inode = file_inode(filep);
926 exception.state = lock->open_context->state;
927
928 do {
929 err = _nfs42_proc_llseek(filep, lock, offset, whence);
930 if (err >= 0)
931 break;
932 if (err == -ENOTSUPP) {
933 err = -EOPNOTSUPP;
934 break;
935 }
936 err = nfs4_handle_exception(server, err, &exception);
937 } while (exception.retry);
938
939 nfs_put_lock_context(lock);
940 return err;
941 }
942
943
944 static void
nfs42_layoutstat_prepare(struct rpc_task * task,void * calldata)945 nfs42_layoutstat_prepare(struct rpc_task *task, void *calldata)
946 {
947 struct nfs42_layoutstat_data *data = calldata;
948 struct inode *inode = data->inode;
949 struct nfs_server *server = NFS_SERVER(inode);
950 struct pnfs_layout_hdr *lo;
951
952 spin_lock(&inode->i_lock);
953 lo = NFS_I(inode)->layout;
954 if (!pnfs_layout_is_valid(lo)) {
955 spin_unlock(&inode->i_lock);
956 rpc_exit(task, 0);
957 return;
958 }
959 nfs4_stateid_copy(&data->args.stateid, &lo->plh_stateid);
960 spin_unlock(&inode->i_lock);
961 nfs4_setup_sequence(server->nfs_client, &data->args.seq_args,
962 &data->res.seq_res, task);
963 }
964
965 static void
nfs42_layoutstat_done(struct rpc_task * task,void * calldata)966 nfs42_layoutstat_done(struct rpc_task *task, void *calldata)
967 {
968 struct nfs42_layoutstat_data *data = calldata;
969 struct inode *inode = data->inode;
970 struct pnfs_layout_hdr *lo;
971
972 if (!nfs4_sequence_done(task, &data->res.seq_res))
973 return;
974
975 switch (task->tk_status) {
976 case 0:
977 return;
978 case -NFS4ERR_BADHANDLE:
979 case -ESTALE:
980 pnfs_destroy_layout(NFS_I(inode));
981 break;
982 case -NFS4ERR_EXPIRED:
983 case -NFS4ERR_ADMIN_REVOKED:
984 case -NFS4ERR_DELEG_REVOKED:
985 case -NFS4ERR_STALE_STATEID:
986 case -NFS4ERR_BAD_STATEID:
987 spin_lock(&inode->i_lock);
988 lo = NFS_I(inode)->layout;
989 if (pnfs_layout_is_valid(lo) &&
990 nfs4_stateid_match(&data->args.stateid,
991 &lo->plh_stateid)) {
992 LIST_HEAD(head);
993
994 /*
995 * Mark the bad layout state as invalid, then retry
996 * with the current stateid.
997 */
998 pnfs_mark_layout_stateid_invalid(lo, &head);
999 spin_unlock(&inode->i_lock);
1000 pnfs_free_lseg_list(&head);
1001 nfs_commit_inode(inode, 0);
1002 } else
1003 spin_unlock(&inode->i_lock);
1004 break;
1005 case -NFS4ERR_OLD_STATEID:
1006 spin_lock(&inode->i_lock);
1007 lo = NFS_I(inode)->layout;
1008 if (pnfs_layout_is_valid(lo) &&
1009 nfs4_stateid_match_other(&data->args.stateid,
1010 &lo->plh_stateid)) {
1011 /* Do we need to delay before resending? */
1012 if (!nfs4_stateid_is_newer(&lo->plh_stateid,
1013 &data->args.stateid))
1014 rpc_delay(task, HZ);
1015 rpc_restart_call_prepare(task);
1016 }
1017 spin_unlock(&inode->i_lock);
1018 break;
1019 case -ENOTSUPP:
1020 case -EOPNOTSUPP:
1021 NFS_SERVER(inode)->caps &= ~NFS_CAP_LAYOUTSTATS;
1022 }
1023
1024 trace_nfs4_layoutstats(inode, &data->args.stateid, task->tk_status);
1025 }
1026
1027 static void
nfs42_layoutstat_release(void * calldata)1028 nfs42_layoutstat_release(void *calldata)
1029 {
1030 struct nfs42_layoutstat_data *data = calldata;
1031 struct nfs42_layoutstat_devinfo *devinfo = data->args.devinfo;
1032 int i;
1033
1034 for (i = 0; i < data->args.num_dev; i++) {
1035 if (devinfo[i].ld_private.ops && devinfo[i].ld_private.ops->free)
1036 devinfo[i].ld_private.ops->free(&devinfo[i].ld_private);
1037 }
1038
1039 pnfs_put_layout_hdr(NFS_I(data->args.inode)->layout);
1040 smp_mb__before_atomic();
1041 clear_bit(NFS_INO_LAYOUTSTATS, &NFS_I(data->args.inode)->flags);
1042 smp_mb__after_atomic();
1043 nfs_iput_and_deactive(data->inode);
1044 kfree(data->args.devinfo);
1045 kfree(data);
1046 }
1047
1048 static const struct rpc_call_ops nfs42_layoutstat_ops = {
1049 .rpc_call_prepare = nfs42_layoutstat_prepare,
1050 .rpc_call_done = nfs42_layoutstat_done,
1051 .rpc_release = nfs42_layoutstat_release,
1052 };
1053
nfs42_proc_layoutstats_generic(struct nfs_server * server,struct nfs42_layoutstat_data * data)1054 int nfs42_proc_layoutstats_generic(struct nfs_server *server,
1055 struct nfs42_layoutstat_data *data)
1056 {
1057 struct rpc_message msg = {
1058 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTSTATS],
1059 .rpc_argp = &data->args,
1060 .rpc_resp = &data->res,
1061 };
1062 struct rpc_task_setup task_setup = {
1063 .rpc_client = server->client,
1064 .rpc_message = &msg,
1065 .callback_ops = &nfs42_layoutstat_ops,
1066 .callback_data = data,
1067 .flags = RPC_TASK_ASYNC | RPC_TASK_MOVEABLE,
1068 };
1069 struct rpc_task *task;
1070
1071 data->inode = nfs_igrab_and_active(data->args.inode);
1072 if (!data->inode) {
1073 nfs42_layoutstat_release(data);
1074 return -EAGAIN;
1075 }
1076 nfs4_init_sequence(server->nfs_client, &data->args.seq_args,
1077 &data->res.seq_res, 0, 0);
1078 task = rpc_run_task(&task_setup);
1079 if (IS_ERR(task))
1080 return PTR_ERR(task);
1081 rpc_put_task(task);
1082 return 0;
1083 }
1084
1085 static struct nfs42_layouterror_data *
nfs42_alloc_layouterror_data(struct pnfs_layout_segment * lseg,gfp_t gfp_flags)1086 nfs42_alloc_layouterror_data(struct pnfs_layout_segment *lseg, gfp_t gfp_flags)
1087 {
1088 struct nfs42_layouterror_data *data;
1089 struct inode *inode = lseg->pls_layout->plh_inode;
1090
1091 data = kzalloc_obj(*data, gfp_flags);
1092 if (data) {
1093 data->args.inode = data->inode = nfs_igrab_and_active(inode);
1094 if (data->inode) {
1095 data->lseg = pnfs_get_lseg(lseg);
1096 if (data->lseg)
1097 return data;
1098 nfs_iput_and_deactive(data->inode);
1099 }
1100 kfree(data);
1101 }
1102 return NULL;
1103 }
1104
1105 static void
nfs42_free_layouterror_data(struct nfs42_layouterror_data * data)1106 nfs42_free_layouterror_data(struct nfs42_layouterror_data *data)
1107 {
1108 pnfs_put_lseg(data->lseg);
1109 nfs_iput_and_deactive(data->inode);
1110 kfree(data);
1111 }
1112
1113 static void
nfs42_layouterror_prepare(struct rpc_task * task,void * calldata)1114 nfs42_layouterror_prepare(struct rpc_task *task, void *calldata)
1115 {
1116 struct nfs42_layouterror_data *data = calldata;
1117 struct inode *inode = data->inode;
1118 struct nfs_server *server = NFS_SERVER(inode);
1119 struct pnfs_layout_hdr *lo = data->lseg->pls_layout;
1120 unsigned i;
1121
1122 spin_lock(&inode->i_lock);
1123 if (!pnfs_layout_is_valid(lo)) {
1124 spin_unlock(&inode->i_lock);
1125 rpc_exit(task, 0);
1126 return;
1127 }
1128 for (i = 0; i < data->args.num_errors; i++)
1129 nfs4_stateid_copy(&data->args.errors[i].stateid,
1130 &lo->plh_stateid);
1131 spin_unlock(&inode->i_lock);
1132 nfs4_setup_sequence(server->nfs_client, &data->args.seq_args,
1133 &data->res.seq_res, task);
1134 }
1135
1136 static void
nfs42_layouterror_done(struct rpc_task * task,void * calldata)1137 nfs42_layouterror_done(struct rpc_task *task, void *calldata)
1138 {
1139 struct nfs42_layouterror_data *data = calldata;
1140 struct inode *inode = data->inode;
1141 struct pnfs_layout_hdr *lo = data->lseg->pls_layout;
1142
1143 if (!nfs4_sequence_done(task, &data->res.seq_res))
1144 return;
1145
1146 switch (task->tk_status) {
1147 case 0:
1148 return;
1149 case -NFS4ERR_BADHANDLE:
1150 case -ESTALE:
1151 pnfs_destroy_layout(NFS_I(inode));
1152 break;
1153 case -NFS4ERR_EXPIRED:
1154 case -NFS4ERR_ADMIN_REVOKED:
1155 case -NFS4ERR_DELEG_REVOKED:
1156 case -NFS4ERR_STALE_STATEID:
1157 case -NFS4ERR_BAD_STATEID:
1158 spin_lock(&inode->i_lock);
1159 if (pnfs_layout_is_valid(lo) &&
1160 nfs4_stateid_match(&data->args.errors[0].stateid,
1161 &lo->plh_stateid)) {
1162 LIST_HEAD(head);
1163
1164 /*
1165 * Mark the bad layout state as invalid, then retry
1166 * with the current stateid.
1167 */
1168 pnfs_mark_layout_stateid_invalid(lo, &head);
1169 spin_unlock(&inode->i_lock);
1170 pnfs_free_lseg_list(&head);
1171 nfs_commit_inode(inode, 0);
1172 } else
1173 spin_unlock(&inode->i_lock);
1174 break;
1175 case -NFS4ERR_OLD_STATEID:
1176 spin_lock(&inode->i_lock);
1177 if (pnfs_layout_is_valid(lo) &&
1178 nfs4_stateid_match_other(&data->args.errors[0].stateid,
1179 &lo->plh_stateid)) {
1180 /* Do we need to delay before resending? */
1181 if (!nfs4_stateid_is_newer(&lo->plh_stateid,
1182 &data->args.errors[0].stateid))
1183 rpc_delay(task, HZ);
1184 rpc_restart_call_prepare(task);
1185 }
1186 spin_unlock(&inode->i_lock);
1187 break;
1188 case -ENOTSUPP:
1189 case -EOPNOTSUPP:
1190 NFS_SERVER(inode)->caps &= ~NFS_CAP_LAYOUTERROR;
1191 }
1192
1193 trace_nfs4_layouterror(inode, &data->args.errors[0].stateid,
1194 task->tk_status);
1195 }
1196
1197 static void
nfs42_layouterror_release(void * calldata)1198 nfs42_layouterror_release(void *calldata)
1199 {
1200 struct nfs42_layouterror_data *data = calldata;
1201
1202 nfs42_free_layouterror_data(data);
1203 }
1204
1205 static const struct rpc_call_ops nfs42_layouterror_ops = {
1206 .rpc_call_prepare = nfs42_layouterror_prepare,
1207 .rpc_call_done = nfs42_layouterror_done,
1208 .rpc_release = nfs42_layouterror_release,
1209 };
1210
nfs42_proc_layouterror(struct pnfs_layout_segment * lseg,const struct nfs42_layout_error * errors,size_t n)1211 int nfs42_proc_layouterror(struct pnfs_layout_segment *lseg,
1212 const struct nfs42_layout_error *errors, size_t n)
1213 {
1214 struct inode *inode = lseg->pls_layout->plh_inode;
1215 struct nfs_server *server = NFS_SERVER(inode);
1216 struct nfs42_layouterror_data *data;
1217 struct rpc_task *task;
1218 struct rpc_message msg = {
1219 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTERROR],
1220 };
1221 struct rpc_task_setup task_setup = {
1222 .rpc_message = &msg,
1223 .callback_ops = &nfs42_layouterror_ops,
1224 .flags = RPC_TASK_ASYNC | RPC_TASK_MOVEABLE,
1225 };
1226 unsigned int i;
1227
1228 if (!nfs_server_capable(inode, NFS_CAP_LAYOUTERROR))
1229 return -EOPNOTSUPP;
1230 if (n > NFS42_LAYOUTERROR_MAX)
1231 return -EINVAL;
1232 data = nfs42_alloc_layouterror_data(lseg, nfs_io_gfp_mask());
1233 if (!data)
1234 return -ENOMEM;
1235 for (i = 0; i < n; i++) {
1236 data->args.errors[i] = errors[i];
1237 data->args.num_errors++;
1238 data->res.num_errors++;
1239 }
1240 msg.rpc_argp = &data->args;
1241 msg.rpc_resp = &data->res;
1242 task_setup.callback_data = data;
1243 task_setup.rpc_client = server->client;
1244 nfs4_init_sequence(server->nfs_client, &data->args.seq_args,
1245 &data->res.seq_res, 0, 0);
1246 task = rpc_run_task(&task_setup);
1247 if (IS_ERR(task))
1248 return PTR_ERR(task);
1249 rpc_put_task(task);
1250 return 0;
1251 }
1252 EXPORT_SYMBOL_GPL(nfs42_proc_layouterror);
1253
_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)1254 static int _nfs42_proc_clone(struct rpc_message *msg, struct file *src_f,
1255 struct file *dst_f, struct nfs_lock_context *src_lock,
1256 struct nfs_lock_context *dst_lock, loff_t src_offset,
1257 loff_t dst_offset, loff_t count)
1258 {
1259 struct inode *src_inode = file_inode(src_f);
1260 struct inode *dst_inode = file_inode(dst_f);
1261 struct nfs_server *server = NFS_SERVER(dst_inode);
1262 __u32 dst_bitmask[NFS_BITMASK_SZ];
1263 struct nfs42_clone_args args = {
1264 .src_fh = NFS_FH(src_inode),
1265 .dst_fh = NFS_FH(dst_inode),
1266 .src_offset = src_offset,
1267 .dst_offset = dst_offset,
1268 .count = count,
1269 .dst_bitmask = dst_bitmask,
1270 };
1271 struct nfs42_clone_res res = {
1272 .server = server,
1273 };
1274 loff_t oldsize_dst = i_size_read(dst_inode);
1275 int status;
1276
1277 msg->rpc_argp = &args;
1278 msg->rpc_resp = &res;
1279
1280 status = nfs4_set_rw_stateid(&args.src_stateid, src_lock->open_context,
1281 src_lock, FMODE_READ);
1282 if (status) {
1283 if (status == -EAGAIN)
1284 status = -NFS4ERR_BAD_STATEID;
1285 return status;
1286 }
1287 status = nfs4_set_rw_stateid(&args.dst_stateid, dst_lock->open_context,
1288 dst_lock, FMODE_WRITE);
1289 if (status) {
1290 if (status == -EAGAIN)
1291 status = -NFS4ERR_BAD_STATEID;
1292 return status;
1293 }
1294
1295 res.dst_fattr = nfs_alloc_fattr();
1296 if (!res.dst_fattr)
1297 return -ENOMEM;
1298
1299 nfs4_bitmask_set(dst_bitmask, server->cache_consistency_bitmask,
1300 dst_inode, NFS_INO_INVALID_BLOCKS);
1301
1302 status = nfs4_call_sync(server->client, server, msg,
1303 &args.seq_args, &res.seq_res, 0);
1304 trace_nfs4_clone(src_inode, dst_inode, &args, status);
1305 if (status == 0) {
1306 /* a zero-length count means clone to EOF in src */
1307 if (count == 0 && res.dst_fattr->valid & NFS_ATTR_FATTR_SIZE)
1308 count = nfs_size_to_loff_t(res.dst_fattr->size) - dst_offset;
1309 nfs42_copy_dest_done(dst_f, dst_offset, count, oldsize_dst);
1310 status = nfs_post_op_update_inode(dst_inode, res.dst_fattr);
1311 }
1312
1313 kfree(res.dst_fattr);
1314 return status;
1315 }
1316
nfs42_proc_clone(struct file * src_f,struct file * dst_f,loff_t src_offset,loff_t dst_offset,loff_t count)1317 int nfs42_proc_clone(struct file *src_f, struct file *dst_f,
1318 loff_t src_offset, loff_t dst_offset, loff_t count)
1319 {
1320 struct rpc_message msg = {
1321 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CLONE],
1322 };
1323 struct inode *inode = file_inode(src_f);
1324 struct nfs_server *server = NFS_SERVER(file_inode(src_f));
1325 struct nfs_lock_context *src_lock;
1326 struct nfs_lock_context *dst_lock;
1327 struct nfs4_exception src_exception = { };
1328 struct nfs4_exception dst_exception = { };
1329 int err, err2;
1330
1331 if (!nfs_server_capable(inode, NFS_CAP_CLONE))
1332 return -EOPNOTSUPP;
1333
1334 src_lock = nfs_get_lock_context(nfs_file_open_context(src_f));
1335 if (IS_ERR(src_lock))
1336 return PTR_ERR(src_lock);
1337
1338 src_exception.inode = file_inode(src_f);
1339 src_exception.state = src_lock->open_context->state;
1340
1341 dst_lock = nfs_get_lock_context(nfs_file_open_context(dst_f));
1342 if (IS_ERR(dst_lock)) {
1343 err = PTR_ERR(dst_lock);
1344 goto out_put_src_lock;
1345 }
1346
1347 dst_exception.inode = file_inode(dst_f);
1348 dst_exception.state = dst_lock->open_context->state;
1349
1350 do {
1351 err = _nfs42_proc_clone(&msg, src_f, dst_f, src_lock, dst_lock,
1352 src_offset, dst_offset, count);
1353 if (err == -ENOTSUPP || err == -EOPNOTSUPP) {
1354 NFS_SERVER(inode)->caps &= ~NFS_CAP_CLONE;
1355 err = -EOPNOTSUPP;
1356 break;
1357 }
1358
1359 err2 = nfs4_handle_exception(server, err, &src_exception);
1360 err = nfs4_handle_exception(server, err, &dst_exception);
1361 if (!err)
1362 err = err2;
1363 } while (src_exception.retry || dst_exception.retry);
1364
1365 nfs_put_lock_context(dst_lock);
1366 out_put_src_lock:
1367 nfs_put_lock_context(src_lock);
1368 return err;
1369 }
1370
1371 #define NFS4XATTR_MAXPAGES DIV_ROUND_UP(XATTR_SIZE_MAX, PAGE_SIZE)
1372
_nfs42_proc_removexattr(struct inode * inode,const char * name)1373 static int _nfs42_proc_removexattr(struct inode *inode, const char *name)
1374 {
1375 struct nfs_server *server = NFS_SERVER(inode);
1376 __u32 bitmask[NFS_BITMASK_SZ];
1377 struct nfs42_removexattrargs args = {
1378 .fh = NFS_FH(inode),
1379 .bitmask = bitmask,
1380 .xattr_name = name,
1381 };
1382 struct nfs42_removexattrres res = {
1383 .server = server,
1384 };
1385 struct rpc_message msg = {
1386 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVEXATTR],
1387 .rpc_argp = &args,
1388 .rpc_resp = &res,
1389 };
1390 int ret;
1391 unsigned long timestamp = jiffies;
1392
1393 res.fattr = nfs_alloc_fattr();
1394 if (!res.fattr)
1395 return -ENOMEM;
1396
1397 nfs4_bitmask_set(bitmask, server->cache_consistency_bitmask,
1398 inode, NFS_INO_INVALID_CHANGE);
1399
1400 ret = nfs4_call_sync(server->client, server, &msg, &args.seq_args,
1401 &res.seq_res, 1);
1402 trace_nfs4_removexattr(inode, name, ret);
1403 if (!ret) {
1404 nfs4_update_changeattr(inode, &res.cinfo, timestamp, 0);
1405 ret = nfs_post_op_update_inode(inode, res.fattr);
1406 }
1407
1408 kfree(res.fattr);
1409 return ret;
1410 }
1411
_nfs42_proc_setxattr(struct inode * inode,const char * name,const void * buf,size_t buflen,int flags)1412 static int _nfs42_proc_setxattr(struct inode *inode, const char *name,
1413 const void *buf, size_t buflen, int flags)
1414 {
1415 struct nfs_server *server = NFS_SERVER(inode);
1416 __u32 bitmask[NFS_BITMASK_SZ];
1417 struct page *pages[NFS4XATTR_MAXPAGES];
1418 struct nfs42_setxattrargs arg = {
1419 .fh = NFS_FH(inode),
1420 .bitmask = bitmask,
1421 .xattr_pages = pages,
1422 .xattr_len = buflen,
1423 .xattr_name = name,
1424 .xattr_flags = flags,
1425 };
1426 struct nfs42_setxattrres res = {
1427 .server = server,
1428 };
1429 struct rpc_message msg = {
1430 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETXATTR],
1431 .rpc_argp = &arg,
1432 .rpc_resp = &res,
1433 };
1434 int ret, np;
1435 unsigned long timestamp = jiffies;
1436
1437 if (buflen > server->sxasize)
1438 return -ERANGE;
1439
1440 res.fattr = nfs_alloc_fattr();
1441 if (!res.fattr)
1442 return -ENOMEM;
1443
1444 if (buflen > 0) {
1445 np = nfs4_buf_to_pages_noslab(buf, buflen, arg.xattr_pages);
1446 if (np < 0) {
1447 ret = np;
1448 goto out;
1449 }
1450 } else
1451 np = 0;
1452
1453 nfs4_bitmask_set(bitmask, server->cache_consistency_bitmask,
1454 inode, NFS_INO_INVALID_CHANGE);
1455
1456 ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args,
1457 &res.seq_res, 1);
1458 trace_nfs4_setxattr(inode, name, ret);
1459
1460 for (; np > 0; np--)
1461 put_page(pages[np - 1]);
1462
1463 if (!ret) {
1464 nfs4_update_changeattr(inode, &res.cinfo, timestamp, 0);
1465 ret = nfs_post_op_update_inode(inode, res.fattr);
1466 }
1467
1468 out:
1469 kfree(res.fattr);
1470 return ret;
1471 }
1472
_nfs42_proc_getxattr(struct inode * inode,const char * name,void * buf,size_t buflen,struct page ** pages,size_t plen)1473 static ssize_t _nfs42_proc_getxattr(struct inode *inode, const char *name,
1474 void *buf, size_t buflen, struct page **pages,
1475 size_t plen)
1476 {
1477 struct nfs_server *server = NFS_SERVER(inode);
1478 struct nfs42_getxattrargs arg = {
1479 .fh = NFS_FH(inode),
1480 .xattr_name = name,
1481 };
1482 struct nfs42_getxattrres res;
1483 struct rpc_message msg = {
1484 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETXATTR],
1485 .rpc_argp = &arg,
1486 .rpc_resp = &res,
1487 };
1488 ssize_t ret;
1489
1490 arg.xattr_len = plen;
1491 arg.xattr_pages = pages;
1492
1493 ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args,
1494 &res.seq_res, 0);
1495 trace_nfs4_getxattr(inode, name, ret);
1496 if (ret < 0)
1497 return ret;
1498
1499 /*
1500 * Normally, the caching is done one layer up, but for successful
1501 * RPCS, always cache the result here, even if the caller was
1502 * just querying the length, or if the reply was too big for
1503 * the caller. This avoids a second RPC in the case of the
1504 * common query-alloc-retrieve cycle for xattrs.
1505 *
1506 * Note that xattr_len is always capped to XATTR_SIZE_MAX.
1507 */
1508
1509 nfs4_xattr_cache_add(inode, name, NULL, pages, res.xattr_len);
1510
1511 if (buflen) {
1512 if (res.xattr_len > buflen)
1513 return -ERANGE;
1514 _copy_from_pages(buf, pages, 0, res.xattr_len);
1515 }
1516
1517 return res.xattr_len;
1518 }
1519
_nfs42_proc_listxattrs(struct inode * inode,void * buf,size_t buflen,u64 * cookiep,bool * eofp)1520 static ssize_t _nfs42_proc_listxattrs(struct inode *inode, void *buf,
1521 size_t buflen, u64 *cookiep, bool *eofp)
1522 {
1523 struct nfs_server *server = NFS_SERVER(inode);
1524 struct page **pages;
1525 struct nfs42_listxattrsargs arg = {
1526 .fh = NFS_FH(inode),
1527 .cookie = *cookiep,
1528 };
1529 struct nfs42_listxattrsres res = {
1530 .eof = false,
1531 .xattr_buf = buf,
1532 .xattr_len = buflen,
1533 };
1534 struct rpc_message msg = {
1535 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LISTXATTRS],
1536 .rpc_argp = &arg,
1537 .rpc_resp = &res,
1538 };
1539 u32 xdrlen;
1540 int ret, np, i;
1541
1542
1543 ret = -ENOMEM;
1544 res.scratch = folio_alloc(GFP_KERNEL, 0);
1545 if (!res.scratch)
1546 goto out;
1547
1548 xdrlen = nfs42_listxattr_xdrsize(buflen);
1549 if (xdrlen > server->lxasize)
1550 xdrlen = server->lxasize;
1551 np = xdrlen / PAGE_SIZE + 1;
1552
1553 pages = kzalloc_objs(struct page *, np);
1554 if (!pages)
1555 goto out_free_scratch;
1556 for (i = 0; i < np; i++) {
1557 pages[i] = alloc_page(GFP_KERNEL);
1558 if (!pages[i])
1559 goto out_free_pages;
1560 }
1561
1562 arg.xattr_pages = pages;
1563 arg.count = xdrlen;
1564
1565 ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args,
1566 &res.seq_res, 0);
1567 trace_nfs4_listxattr(inode, ret);
1568
1569 if (ret >= 0) {
1570 ret = res.copied;
1571 *cookiep = res.cookie;
1572 *eofp = res.eof;
1573 }
1574
1575 out_free_pages:
1576 while (--np >= 0) {
1577 if (pages[np])
1578 __free_page(pages[np]);
1579 }
1580 kfree(pages);
1581 out_free_scratch:
1582 folio_put(res.scratch);
1583 out:
1584 return ret;
1585
1586 }
1587
nfs42_proc_getxattr(struct inode * inode,const char * name,void * buf,size_t buflen)1588 ssize_t nfs42_proc_getxattr(struct inode *inode, const char *name,
1589 void *buf, size_t buflen)
1590 {
1591 struct nfs4_exception exception = { };
1592 ssize_t err, np, i;
1593 struct page **pages;
1594
1595 np = nfs_page_array_len(0, buflen ?: XATTR_SIZE_MAX);
1596 pages = kmalloc_objs(*pages, np);
1597 if (!pages)
1598 return -ENOMEM;
1599
1600 for (i = 0; i < np; i++) {
1601 pages[i] = alloc_page(GFP_KERNEL);
1602 if (!pages[i]) {
1603 err = -ENOMEM;
1604 goto out;
1605 }
1606 }
1607
1608 /*
1609 * The GETXATTR op has no length field in the call, and the
1610 * xattr data is at the end of the reply.
1611 *
1612 * There is no downside in using the page-aligned length. It will
1613 * allow receiving and caching xattrs that are too large for the
1614 * caller but still fit in the page-rounded value.
1615 */
1616 do {
1617 err = _nfs42_proc_getxattr(inode, name, buf, buflen,
1618 pages, np * PAGE_SIZE);
1619 if (err >= 0)
1620 break;
1621 err = nfs4_handle_exception(NFS_SERVER(inode), err,
1622 &exception);
1623 } while (exception.retry);
1624
1625 out:
1626 while (--i >= 0)
1627 __free_page(pages[i]);
1628 kfree(pages);
1629
1630 return err;
1631 }
1632
nfs42_proc_setxattr(struct inode * inode,const char * name,const void * buf,size_t buflen,int flags)1633 int nfs42_proc_setxattr(struct inode *inode, const char *name,
1634 const void *buf, size_t buflen, int flags)
1635 {
1636 struct nfs4_exception exception = { };
1637 int err;
1638
1639 do {
1640 err = _nfs42_proc_setxattr(inode, name, buf, buflen, flags);
1641 if (!err)
1642 break;
1643 err = nfs4_handle_exception(NFS_SERVER(inode), err,
1644 &exception);
1645 } while (exception.retry);
1646
1647 return err;
1648 }
1649
nfs42_proc_listxattrs(struct inode * inode,void * buf,size_t buflen,u64 * cookiep,bool * eofp)1650 ssize_t nfs42_proc_listxattrs(struct inode *inode, void *buf,
1651 size_t buflen, u64 *cookiep, bool *eofp)
1652 {
1653 struct nfs4_exception exception = { };
1654 ssize_t err;
1655
1656 do {
1657 err = _nfs42_proc_listxattrs(inode, buf, buflen,
1658 cookiep, eofp);
1659 if (err >= 0)
1660 break;
1661 err = nfs4_handle_exception(NFS_SERVER(inode), err,
1662 &exception);
1663 } while (exception.retry);
1664
1665 return err;
1666 }
1667
nfs42_proc_removexattr(struct inode * inode,const char * name)1668 int nfs42_proc_removexattr(struct inode *inode, const char *name)
1669 {
1670 struct nfs4_exception exception = { };
1671 int err;
1672
1673 do {
1674 err = _nfs42_proc_removexattr(inode, name);
1675 if (!err)
1676 break;
1677 err = nfs4_handle_exception(NFS_SERVER(inode), err,
1678 &exception);
1679 } while (exception.retry);
1680
1681 return err;
1682 }
1683