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