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/sched.h>
7 #include <linux/nfs.h>
8 #include <linux/nfs3.h>
9 #include <linux/nfs4.h>
10 #include <linux/nfs_xdr.h>
11 #include <linux/nfs_fs.h>
12 #include "nfs4_fs.h"
13 #include "nfs42.h"
14 #include "iostat.h"
15 #include "pnfs.h"
16 #include "nfs4session.h"
17 #include "internal.h"
18
19 #define NFSDBG_FACILITY NFSDBG_PROC
20 static int nfs42_do_offload_cancel_async(struct file *dst, nfs4_stateid *std);
21
_nfs42_proc_fallocate(struct rpc_message * msg,struct file * filep,struct nfs_lock_context * lock,loff_t offset,loff_t len)22 static int _nfs42_proc_fallocate(struct rpc_message *msg, struct file *filep,
23 struct nfs_lock_context *lock, loff_t offset, loff_t len)
24 {
25 struct inode *inode = file_inode(filep);
26 struct nfs_server *server = NFS_SERVER(inode);
27 struct nfs42_falloc_args args = {
28 .falloc_fh = NFS_FH(inode),
29 .falloc_offset = offset,
30 .falloc_length = len,
31 .falloc_bitmask = server->cache_consistency_bitmask,
32 };
33 struct nfs42_falloc_res res = {
34 .falloc_server = server,
35 };
36 int status;
37
38 msg->rpc_argp = &args;
39 msg->rpc_resp = &res;
40
41 status = nfs4_set_rw_stateid(&args.falloc_stateid, lock->open_context,
42 lock, FMODE_WRITE);
43 if (status)
44 return status;
45
46 res.falloc_fattr = nfs_alloc_fattr();
47 if (!res.falloc_fattr)
48 return -ENOMEM;
49
50 status = nfs4_call_sync(server->client, server, msg,
51 &args.seq_args, &res.seq_res, 0);
52 if (status == 0)
53 status = nfs_post_op_update_inode(inode, res.falloc_fattr);
54
55 kfree(res.falloc_fattr);
56 return status;
57 }
58
nfs42_proc_fallocate(struct rpc_message * msg,struct file * filep,loff_t offset,loff_t len)59 static int nfs42_proc_fallocate(struct rpc_message *msg, struct file *filep,
60 loff_t offset, loff_t len)
61 {
62 struct nfs_server *server = NFS_SERVER(file_inode(filep));
63 struct nfs4_exception exception = { };
64 struct nfs_lock_context *lock;
65 int err;
66
67 lock = nfs_get_lock_context(nfs_file_open_context(filep));
68 if (IS_ERR(lock))
69 return PTR_ERR(lock);
70
71 exception.inode = file_inode(filep);
72 exception.state = lock->open_context->state;
73
74 do {
75 err = _nfs42_proc_fallocate(msg, filep, lock, offset, len);
76 if (err == -ENOTSUPP) {
77 err = -EOPNOTSUPP;
78 break;
79 }
80 err = nfs4_handle_exception(server, err, &exception);
81 } while (exception.retry);
82
83 nfs_put_lock_context(lock);
84 return err;
85 }
86
nfs42_proc_allocate(struct file * filep,loff_t offset,loff_t len)87 int nfs42_proc_allocate(struct file *filep, loff_t offset, loff_t len)
88 {
89 struct rpc_message msg = {
90 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_ALLOCATE],
91 };
92 struct inode *inode = file_inode(filep);
93 int err;
94
95 if (!nfs_server_capable(inode, NFS_CAP_ALLOCATE))
96 return -EOPNOTSUPP;
97
98 inode_lock(inode);
99
100 err = nfs42_proc_fallocate(&msg, filep, offset, len);
101 if (err == -EOPNOTSUPP)
102 NFS_SERVER(inode)->caps &= ~NFS_CAP_ALLOCATE;
103
104 inode_unlock(inode);
105 return err;
106 }
107
nfs42_proc_deallocate(struct file * filep,loff_t offset,loff_t len)108 int nfs42_proc_deallocate(struct file *filep, loff_t offset, loff_t len)
109 {
110 struct rpc_message msg = {
111 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DEALLOCATE],
112 };
113 struct inode *inode = file_inode(filep);
114 int err;
115
116 if (!nfs_server_capable(inode, NFS_CAP_DEALLOCATE))
117 return -EOPNOTSUPP;
118
119 inode_lock(inode);
120 err = nfs_sync_inode(inode);
121 if (err)
122 goto out_unlock;
123
124 err = nfs42_proc_fallocate(&msg, filep, offset, len);
125 if (err == 0)
126 truncate_pagecache_range(inode, offset, (offset + len) -1);
127 if (err == -EOPNOTSUPP)
128 NFS_SERVER(inode)->caps &= ~NFS_CAP_DEALLOCATE;
129 out_unlock:
130 inode_unlock(inode);
131 return err;
132 }
133
handle_async_copy(struct nfs42_copy_res * res,struct nfs_server * server,struct file * src,struct file * dst,nfs4_stateid * src_stateid)134 static int handle_async_copy(struct nfs42_copy_res *res,
135 struct nfs_server *server,
136 struct file *src,
137 struct file *dst,
138 nfs4_stateid *src_stateid)
139 {
140 struct nfs4_copy_state *copy;
141 int status = NFS4_OK;
142 bool found_pending = false;
143 struct nfs_open_context *ctx = nfs_file_open_context(dst);
144
145 spin_lock(&server->nfs_client->cl_lock);
146 list_for_each_entry(copy, &server->nfs_client->pending_cb_stateids,
147 copies) {
148 if (memcmp(&res->write_res.stateid, ©->stateid,
149 NFS4_STATEID_SIZE))
150 continue;
151 found_pending = true;
152 list_del(©->copies);
153 break;
154 }
155 if (found_pending) {
156 spin_unlock(&server->nfs_client->cl_lock);
157 goto out;
158 }
159
160 copy = kzalloc(sizeof(struct nfs4_copy_state), GFP_NOFS);
161 if (!copy) {
162 spin_unlock(&server->nfs_client->cl_lock);
163 return -ENOMEM;
164 }
165 memcpy(©->stateid, &res->write_res.stateid, NFS4_STATEID_SIZE);
166 init_completion(©->completion);
167 copy->parent_state = ctx->state;
168
169 list_add_tail(©->copies, &server->ss_copies);
170 spin_unlock(&server->nfs_client->cl_lock);
171
172 status = wait_for_completion_interruptible(©->completion);
173 spin_lock(&server->nfs_client->cl_lock);
174 list_del_init(©->copies);
175 spin_unlock(&server->nfs_client->cl_lock);
176 if (status == -ERESTARTSYS) {
177 goto out_cancel;
178 } else if (copy->flags) {
179 status = -EAGAIN;
180 goto out_cancel;
181 }
182 out:
183 res->write_res.count = copy->count;
184 memcpy(&res->write_res.verifier, ©->verf, sizeof(copy->verf));
185 status = -copy->error;
186
187 kfree(copy);
188 return status;
189 out_cancel:
190 nfs42_do_offload_cancel_async(dst, ©->stateid);
191 kfree(copy);
192 return status;
193 }
194
process_copy_commit(struct file * dst,loff_t pos_dst,struct nfs42_copy_res * res)195 static int process_copy_commit(struct file *dst, loff_t pos_dst,
196 struct nfs42_copy_res *res)
197 {
198 struct nfs_commitres cres;
199 int status = -ENOMEM;
200
201 cres.verf = kzalloc(sizeof(struct nfs_writeverf), GFP_NOFS);
202 if (!cres.verf)
203 goto out;
204
205 status = nfs4_proc_commit(dst, pos_dst, res->write_res.count, &cres);
206 if (status)
207 goto out_free;
208 if (nfs_write_verifier_cmp(&res->write_res.verifier.verifier,
209 &cres.verf->verifier)) {
210 dprintk("commit verf differs from copy verf\n");
211 status = -EAGAIN;
212 }
213 out_free:
214 kfree(cres.verf);
215 out:
216 return status;
217 }
218
_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)219 static ssize_t _nfs42_proc_copy(struct file *src,
220 struct nfs_lock_context *src_lock,
221 struct file *dst,
222 struct nfs_lock_context *dst_lock,
223 struct nfs42_copy_args *args,
224 struct nfs42_copy_res *res)
225 {
226 struct rpc_message msg = {
227 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_COPY],
228 .rpc_argp = args,
229 .rpc_resp = res,
230 };
231 struct inode *dst_inode = file_inode(dst);
232 struct nfs_server *server = NFS_SERVER(dst_inode);
233 loff_t pos_src = args->src_pos;
234 loff_t pos_dst = args->dst_pos;
235 size_t count = args->count;
236 ssize_t status;
237
238 status = nfs4_set_rw_stateid(&args->src_stateid, src_lock->open_context,
239 src_lock, FMODE_READ);
240 if (status)
241 return status;
242
243 status = nfs_filemap_write_and_wait_range(file_inode(src)->i_mapping,
244 pos_src, pos_src + (loff_t)count - 1);
245 if (status)
246 return status;
247
248 status = nfs4_set_rw_stateid(&args->dst_stateid, dst_lock->open_context,
249 dst_lock, FMODE_WRITE);
250 if (status)
251 return status;
252
253 status = nfs_sync_inode(dst_inode);
254 if (status)
255 return status;
256
257 res->commit_res.verf = NULL;
258 if (args->sync) {
259 res->commit_res.verf =
260 kzalloc(sizeof(struct nfs_writeverf), GFP_NOFS);
261 if (!res->commit_res.verf)
262 return -ENOMEM;
263 }
264 set_bit(NFS_CLNT_DST_SSC_COPY_STATE,
265 &dst_lock->open_context->state->flags);
266
267 status = nfs4_call_sync(server->client, server, &msg,
268 &args->seq_args, &res->seq_res, 0);
269 if (status == -ENOTSUPP)
270 server->caps &= ~NFS_CAP_COPY;
271 if (status)
272 goto out;
273
274 if (args->sync &&
275 nfs_write_verifier_cmp(&res->write_res.verifier.verifier,
276 &res->commit_res.verf->verifier)) {
277 status = -EAGAIN;
278 goto out;
279 }
280
281 if (!res->synchronous) {
282 status = handle_async_copy(res, server, src, dst,
283 &args->src_stateid);
284 if (status)
285 return status;
286 }
287
288 if ((!res->synchronous || !args->sync) &&
289 res->write_res.verifier.committed != NFS_FILE_SYNC) {
290 status = process_copy_commit(dst, pos_dst, res);
291 if (status)
292 return status;
293 }
294
295 truncate_pagecache_range(dst_inode, pos_dst,
296 pos_dst + res->write_res.count);
297
298 status = res->write_res.count;
299 out:
300 if (args->sync)
301 kfree(res->commit_res.verf);
302 return status;
303 }
304
nfs42_proc_copy(struct file * src,loff_t pos_src,struct file * dst,loff_t pos_dst,size_t count)305 ssize_t nfs42_proc_copy(struct file *src, loff_t pos_src,
306 struct file *dst, loff_t pos_dst,
307 size_t count)
308 {
309 struct nfs_server *server = NFS_SERVER(file_inode(dst));
310 struct nfs_lock_context *src_lock;
311 struct nfs_lock_context *dst_lock;
312 struct nfs42_copy_args args = {
313 .src_fh = NFS_FH(file_inode(src)),
314 .src_pos = pos_src,
315 .dst_fh = NFS_FH(file_inode(dst)),
316 .dst_pos = pos_dst,
317 .count = count,
318 .sync = false,
319 };
320 struct nfs42_copy_res res;
321 struct nfs4_exception src_exception = {
322 .inode = file_inode(src),
323 .stateid = &args.src_stateid,
324 };
325 struct nfs4_exception dst_exception = {
326 .inode = file_inode(dst),
327 .stateid = &args.dst_stateid,
328 };
329 ssize_t err, err2;
330
331 if (!nfs_server_capable(file_inode(dst), NFS_CAP_COPY))
332 return -EOPNOTSUPP;
333
334 src_lock = nfs_get_lock_context(nfs_file_open_context(src));
335 if (IS_ERR(src_lock))
336 return PTR_ERR(src_lock);
337
338 src_exception.state = src_lock->open_context->state;
339
340 dst_lock = nfs_get_lock_context(nfs_file_open_context(dst));
341 if (IS_ERR(dst_lock)) {
342 err = PTR_ERR(dst_lock);
343 goto out_put_src_lock;
344 }
345
346 dst_exception.state = dst_lock->open_context->state;
347
348 do {
349 inode_lock(file_inode(dst));
350 err = _nfs42_proc_copy(src, src_lock,
351 dst, dst_lock,
352 &args, &res);
353 inode_unlock(file_inode(dst));
354
355 if (err >= 0)
356 break;
357 if (err == -ENOTSUPP) {
358 err = -EOPNOTSUPP;
359 break;
360 } else if (err == -EAGAIN) {
361 dst_exception.retry = 1;
362 continue;
363 } else if (err == -NFS4ERR_OFFLOAD_NO_REQS && !args.sync) {
364 args.sync = true;
365 dst_exception.retry = 1;
366 continue;
367 }
368
369 err2 = nfs4_handle_exception(server, err, &src_exception);
370 err = nfs4_handle_exception(server, err, &dst_exception);
371 if (!err)
372 err = err2;
373 } while (src_exception.retry || dst_exception.retry);
374
375 nfs_put_lock_context(dst_lock);
376 out_put_src_lock:
377 nfs_put_lock_context(src_lock);
378 return err;
379 }
380
381 struct nfs42_offloadcancel_data {
382 struct nfs_server *seq_server;
383 struct nfs42_offload_status_args args;
384 struct nfs42_offload_status_res res;
385 };
386
nfs42_offload_cancel_prepare(struct rpc_task * task,void * calldata)387 static void nfs42_offload_cancel_prepare(struct rpc_task *task, void *calldata)
388 {
389 struct nfs42_offloadcancel_data *data = calldata;
390
391 nfs4_setup_sequence(data->seq_server->nfs_client,
392 &data->args.osa_seq_args,
393 &data->res.osr_seq_res, task);
394 }
395
nfs42_offload_cancel_done(struct rpc_task * task,void * calldata)396 static void nfs42_offload_cancel_done(struct rpc_task *task, void *calldata)
397 {
398 struct nfs42_offloadcancel_data *data = calldata;
399
400 nfs41_sequence_done(task, &data->res.osr_seq_res);
401 if (task->tk_status &&
402 nfs4_async_handle_error(task, data->seq_server, NULL,
403 NULL) == -EAGAIN)
404 rpc_restart_call_prepare(task);
405 }
406
nfs42_free_offloadcancel_data(void * data)407 static void nfs42_free_offloadcancel_data(void *data)
408 {
409 kfree(data);
410 }
411
412 static const struct rpc_call_ops nfs42_offload_cancel_ops = {
413 .rpc_call_prepare = nfs42_offload_cancel_prepare,
414 .rpc_call_done = nfs42_offload_cancel_done,
415 .rpc_release = nfs42_free_offloadcancel_data,
416 };
417
nfs42_do_offload_cancel_async(struct file * dst,nfs4_stateid * stateid)418 static int nfs42_do_offload_cancel_async(struct file *dst,
419 nfs4_stateid *stateid)
420 {
421 struct nfs_server *dst_server = NFS_SERVER(file_inode(dst));
422 struct nfs42_offloadcancel_data *data = NULL;
423 struct nfs_open_context *ctx = nfs_file_open_context(dst);
424 struct rpc_task *task;
425 struct rpc_message msg = {
426 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OFFLOAD_CANCEL],
427 .rpc_cred = ctx->cred,
428 };
429 struct rpc_task_setup task_setup_data = {
430 .rpc_client = dst_server->client,
431 .rpc_message = &msg,
432 .callback_ops = &nfs42_offload_cancel_ops,
433 .workqueue = nfsiod_workqueue,
434 .flags = RPC_TASK_ASYNC,
435 };
436 int status;
437
438 if (!(dst_server->caps & NFS_CAP_OFFLOAD_CANCEL))
439 return -EOPNOTSUPP;
440
441 data = kzalloc(sizeof(struct nfs42_offloadcancel_data), GFP_NOFS);
442 if (data == NULL)
443 return -ENOMEM;
444
445 data->seq_server = dst_server;
446 data->args.osa_src_fh = NFS_FH(file_inode(dst));
447 memcpy(&data->args.osa_stateid, stateid,
448 sizeof(data->args.osa_stateid));
449 msg.rpc_argp = &data->args;
450 msg.rpc_resp = &data->res;
451 task_setup_data.callback_data = data;
452 nfs4_init_sequence(&data->args.osa_seq_args, &data->res.osr_seq_res,
453 1, 0);
454 task = rpc_run_task(&task_setup_data);
455 if (IS_ERR(task))
456 return PTR_ERR(task);
457 status = rpc_wait_for_completion_task(task);
458 if (status == -ENOTSUPP)
459 dst_server->caps &= ~NFS_CAP_OFFLOAD_CANCEL;
460 rpc_put_task(task);
461 return status;
462 }
463
_nfs42_proc_llseek(struct file * filep,struct nfs_lock_context * lock,loff_t offset,int whence)464 static loff_t _nfs42_proc_llseek(struct file *filep,
465 struct nfs_lock_context *lock, loff_t offset, int whence)
466 {
467 struct inode *inode = file_inode(filep);
468 struct nfs42_seek_args args = {
469 .sa_fh = NFS_FH(inode),
470 .sa_offset = offset,
471 .sa_what = (whence == SEEK_HOLE) ?
472 NFS4_CONTENT_HOLE : NFS4_CONTENT_DATA,
473 };
474 struct nfs42_seek_res res;
475 struct rpc_message msg = {
476 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SEEK],
477 .rpc_argp = &args,
478 .rpc_resp = &res,
479 };
480 struct nfs_server *server = NFS_SERVER(inode);
481 int status;
482
483 if (!nfs_server_capable(inode, NFS_CAP_SEEK))
484 return -ENOTSUPP;
485
486 status = nfs4_set_rw_stateid(&args.sa_stateid, lock->open_context,
487 lock, FMODE_READ);
488 if (status)
489 return status;
490
491 status = nfs_filemap_write_and_wait_range(inode->i_mapping,
492 offset, LLONG_MAX);
493 if (status)
494 return status;
495
496 status = nfs4_call_sync(server->client, server, &msg,
497 &args.seq_args, &res.seq_res, 0);
498 if (status == -ENOTSUPP)
499 server->caps &= ~NFS_CAP_SEEK;
500 if (status)
501 return status;
502
503 return vfs_setpos(filep, res.sr_offset, inode->i_sb->s_maxbytes);
504 }
505
nfs42_proc_llseek(struct file * filep,loff_t offset,int whence)506 loff_t nfs42_proc_llseek(struct file *filep, loff_t offset, int whence)
507 {
508 struct nfs_server *server = NFS_SERVER(file_inode(filep));
509 struct nfs4_exception exception = { };
510 struct nfs_lock_context *lock;
511 loff_t err;
512
513 lock = nfs_get_lock_context(nfs_file_open_context(filep));
514 if (IS_ERR(lock))
515 return PTR_ERR(lock);
516
517 exception.inode = file_inode(filep);
518 exception.state = lock->open_context->state;
519
520 do {
521 err = _nfs42_proc_llseek(filep, lock, offset, whence);
522 if (err >= 0)
523 break;
524 if (err == -ENOTSUPP) {
525 err = -EOPNOTSUPP;
526 break;
527 }
528 err = nfs4_handle_exception(server, err, &exception);
529 } while (exception.retry);
530
531 nfs_put_lock_context(lock);
532 return err;
533 }
534
535
536 static void
nfs42_layoutstat_prepare(struct rpc_task * task,void * calldata)537 nfs42_layoutstat_prepare(struct rpc_task *task, void *calldata)
538 {
539 struct nfs42_layoutstat_data *data = calldata;
540 struct inode *inode = data->inode;
541 struct nfs_server *server = NFS_SERVER(inode);
542 struct pnfs_layout_hdr *lo;
543
544 spin_lock(&inode->i_lock);
545 lo = NFS_I(inode)->layout;
546 if (!pnfs_layout_is_valid(lo)) {
547 spin_unlock(&inode->i_lock);
548 rpc_exit(task, 0);
549 return;
550 }
551 nfs4_stateid_copy(&data->args.stateid, &lo->plh_stateid);
552 spin_unlock(&inode->i_lock);
553 nfs4_setup_sequence(server->nfs_client, &data->args.seq_args,
554 &data->res.seq_res, task);
555 }
556
557 static void
nfs42_layoutstat_done(struct rpc_task * task,void * calldata)558 nfs42_layoutstat_done(struct rpc_task *task, void *calldata)
559 {
560 struct nfs42_layoutstat_data *data = calldata;
561 struct inode *inode = data->inode;
562 struct pnfs_layout_hdr *lo;
563
564 if (!nfs4_sequence_done(task, &data->res.seq_res))
565 return;
566
567 switch (task->tk_status) {
568 case 0:
569 break;
570 case -NFS4ERR_BADHANDLE:
571 case -ESTALE:
572 pnfs_destroy_layout(NFS_I(inode));
573 break;
574 case -NFS4ERR_EXPIRED:
575 case -NFS4ERR_ADMIN_REVOKED:
576 case -NFS4ERR_DELEG_REVOKED:
577 case -NFS4ERR_STALE_STATEID:
578 case -NFS4ERR_BAD_STATEID:
579 spin_lock(&inode->i_lock);
580 lo = NFS_I(inode)->layout;
581 if (pnfs_layout_is_valid(lo) &&
582 nfs4_stateid_match(&data->args.stateid,
583 &lo->plh_stateid)) {
584 LIST_HEAD(head);
585
586 /*
587 * Mark the bad layout state as invalid, then retry
588 * with the current stateid.
589 */
590 pnfs_mark_layout_stateid_invalid(lo, &head);
591 spin_unlock(&inode->i_lock);
592 pnfs_free_lseg_list(&head);
593 nfs_commit_inode(inode, 0);
594 } else
595 spin_unlock(&inode->i_lock);
596 break;
597 case -NFS4ERR_OLD_STATEID:
598 spin_lock(&inode->i_lock);
599 lo = NFS_I(inode)->layout;
600 if (pnfs_layout_is_valid(lo) &&
601 nfs4_stateid_match_other(&data->args.stateid,
602 &lo->plh_stateid)) {
603 /* Do we need to delay before resending? */
604 if (!nfs4_stateid_is_newer(&lo->plh_stateid,
605 &data->args.stateid))
606 rpc_delay(task, HZ);
607 rpc_restart_call_prepare(task);
608 }
609 spin_unlock(&inode->i_lock);
610 break;
611 case -ENOTSUPP:
612 case -EOPNOTSUPP:
613 NFS_SERVER(inode)->caps &= ~NFS_CAP_LAYOUTSTATS;
614 }
615 }
616
617 static void
nfs42_layoutstat_release(void * calldata)618 nfs42_layoutstat_release(void *calldata)
619 {
620 struct nfs42_layoutstat_data *data = calldata;
621 struct nfs42_layoutstat_devinfo *devinfo = data->args.devinfo;
622 int i;
623
624 for (i = 0; i < data->args.num_dev; i++) {
625 if (devinfo[i].ld_private.ops && devinfo[i].ld_private.ops->free)
626 devinfo[i].ld_private.ops->free(&devinfo[i].ld_private);
627 }
628
629 pnfs_put_layout_hdr(NFS_I(data->args.inode)->layout);
630 smp_mb__before_atomic();
631 clear_bit(NFS_INO_LAYOUTSTATS, &NFS_I(data->args.inode)->flags);
632 smp_mb__after_atomic();
633 nfs_iput_and_deactive(data->inode);
634 kfree(data->args.devinfo);
635 kfree(data);
636 }
637
638 static const struct rpc_call_ops nfs42_layoutstat_ops = {
639 .rpc_call_prepare = nfs42_layoutstat_prepare,
640 .rpc_call_done = nfs42_layoutstat_done,
641 .rpc_release = nfs42_layoutstat_release,
642 };
643
nfs42_proc_layoutstats_generic(struct nfs_server * server,struct nfs42_layoutstat_data * data)644 int nfs42_proc_layoutstats_generic(struct nfs_server *server,
645 struct nfs42_layoutstat_data *data)
646 {
647 struct rpc_message msg = {
648 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTSTATS],
649 .rpc_argp = &data->args,
650 .rpc_resp = &data->res,
651 };
652 struct rpc_task_setup task_setup = {
653 .rpc_client = server->client,
654 .rpc_message = &msg,
655 .callback_ops = &nfs42_layoutstat_ops,
656 .callback_data = data,
657 .flags = RPC_TASK_ASYNC,
658 };
659 struct rpc_task *task;
660
661 data->inode = nfs_igrab_and_active(data->args.inode);
662 if (!data->inode) {
663 nfs42_layoutstat_release(data);
664 return -EAGAIN;
665 }
666 nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 0, 0);
667 task = rpc_run_task(&task_setup);
668 if (IS_ERR(task))
669 return PTR_ERR(task);
670 rpc_put_task(task);
671 return 0;
672 }
673
_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)674 static int _nfs42_proc_clone(struct rpc_message *msg, struct file *src_f,
675 struct file *dst_f, struct nfs_lock_context *src_lock,
676 struct nfs_lock_context *dst_lock, loff_t src_offset,
677 loff_t dst_offset, loff_t count)
678 {
679 struct inode *src_inode = file_inode(src_f);
680 struct inode *dst_inode = file_inode(dst_f);
681 struct nfs_server *server = NFS_SERVER(dst_inode);
682 struct nfs42_clone_args args = {
683 .src_fh = NFS_FH(src_inode),
684 .dst_fh = NFS_FH(dst_inode),
685 .src_offset = src_offset,
686 .dst_offset = dst_offset,
687 .count = count,
688 .dst_bitmask = server->cache_consistency_bitmask,
689 };
690 struct nfs42_clone_res res = {
691 .server = server,
692 };
693 int status;
694
695 msg->rpc_argp = &args;
696 msg->rpc_resp = &res;
697
698 status = nfs4_set_rw_stateid(&args.src_stateid, src_lock->open_context,
699 src_lock, FMODE_READ);
700 if (status)
701 return status;
702
703 status = nfs4_set_rw_stateid(&args.dst_stateid, dst_lock->open_context,
704 dst_lock, FMODE_WRITE);
705 if (status)
706 return status;
707
708 res.dst_fattr = nfs_alloc_fattr();
709 if (!res.dst_fattr)
710 return -ENOMEM;
711
712 status = nfs4_call_sync(server->client, server, msg,
713 &args.seq_args, &res.seq_res, 0);
714 if (status == 0)
715 status = nfs_post_op_update_inode(dst_inode, res.dst_fattr);
716
717 kfree(res.dst_fattr);
718 return status;
719 }
720
nfs42_proc_clone(struct file * src_f,struct file * dst_f,loff_t src_offset,loff_t dst_offset,loff_t count)721 int nfs42_proc_clone(struct file *src_f, struct file *dst_f,
722 loff_t src_offset, loff_t dst_offset, loff_t count)
723 {
724 struct rpc_message msg = {
725 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CLONE],
726 };
727 struct inode *inode = file_inode(src_f);
728 struct nfs_server *server = NFS_SERVER(file_inode(src_f));
729 struct nfs_lock_context *src_lock;
730 struct nfs_lock_context *dst_lock;
731 struct nfs4_exception src_exception = { };
732 struct nfs4_exception dst_exception = { };
733 int err, err2;
734
735 if (!nfs_server_capable(inode, NFS_CAP_CLONE))
736 return -EOPNOTSUPP;
737
738 src_lock = nfs_get_lock_context(nfs_file_open_context(src_f));
739 if (IS_ERR(src_lock))
740 return PTR_ERR(src_lock);
741
742 src_exception.inode = file_inode(src_f);
743 src_exception.state = src_lock->open_context->state;
744
745 dst_lock = nfs_get_lock_context(nfs_file_open_context(dst_f));
746 if (IS_ERR(dst_lock)) {
747 err = PTR_ERR(dst_lock);
748 goto out_put_src_lock;
749 }
750
751 dst_exception.inode = file_inode(dst_f);
752 dst_exception.state = dst_lock->open_context->state;
753
754 do {
755 err = _nfs42_proc_clone(&msg, src_f, dst_f, src_lock, dst_lock,
756 src_offset, dst_offset, count);
757 if (err == -ENOTSUPP || err == -EOPNOTSUPP) {
758 NFS_SERVER(inode)->caps &= ~NFS_CAP_CLONE;
759 err = -EOPNOTSUPP;
760 break;
761 }
762
763 err2 = nfs4_handle_exception(server, err, &src_exception);
764 err = nfs4_handle_exception(server, err, &dst_exception);
765 if (!err)
766 err = err2;
767 } while (src_exception.retry || dst_exception.retry);
768
769 nfs_put_lock_context(dst_lock);
770 out_put_src_lock:
771 nfs_put_lock_context(src_lock);
772 return err;
773 }
774
