1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright (c) 2014 Anna Schumaker <Anna.Schumaker@Netapp.com>
6 #include <linux/sunrpc/sched.h>
8 #include <linux/nfs3.h>
9 #include <linux/nfs4.h>
10 #include <linux/nfs_xdr.h>
11 #include <linux/nfs_fs.h>
16 #include "nfs4session.h"
19 #define NFSDBG_FACILITY NFSDBG_PROC
20 static int nfs42_do_offload_cancel_async(struct file *dst, nfs4_stateid *std);
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)
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,
31 .falloc_bitmask = server->cache_consistency_bitmask,
33 struct nfs42_falloc_res res = {
34 .falloc_server = server,
38 msg->rpc_argp = &args;
41 status = nfs4_set_rw_stateid(&args.falloc_stateid, lock->open_context,
46 res.falloc_fattr = nfs_alloc_fattr();
47 if (!res.falloc_fattr)
50 status = nfs4_call_sync(server->client, server, msg,
51 &args.seq_args, &res.seq_res, 0);
53 status = nfs_post_op_update_inode(inode, res.falloc_fattr);
55 kfree(res.falloc_fattr);
59 static int nfs42_proc_fallocate(struct rpc_message *msg, struct file *filep,
60 loff_t offset, loff_t len)
62 struct inode *inode = file_inode(filep);
63 struct nfs_server *server = NFS_SERVER(inode);
64 struct nfs4_exception exception = { };
65 struct nfs_lock_context *lock;
68 lock = nfs_get_lock_context(nfs_file_open_context(filep));
72 exception.inode = inode;
73 exception.state = lock->open_context->state;
75 err = nfs_sync_inode(inode);
80 err = _nfs42_proc_fallocate(msg, filep, lock, offset, len);
81 if (err == -ENOTSUPP) {
85 err = nfs4_handle_exception(server, err, &exception);
86 } while (exception.retry);
88 nfs_put_lock_context(lock);
92 int nfs42_proc_allocate(struct file *filep, loff_t offset, loff_t len)
94 struct rpc_message msg = {
95 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_ALLOCATE],
97 struct inode *inode = file_inode(filep);
100 if (!nfs_server_capable(inode, NFS_CAP_ALLOCATE))
105 err = nfs42_proc_fallocate(&msg, filep, offset, len);
106 if (err == -EOPNOTSUPP)
107 NFS_SERVER(inode)->caps &= ~NFS_CAP_ALLOCATE;
113 int nfs42_proc_deallocate(struct file *filep, loff_t offset, loff_t len)
115 struct rpc_message msg = {
116 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DEALLOCATE],
118 struct inode *inode = file_inode(filep);
121 if (!nfs_server_capable(inode, NFS_CAP_DEALLOCATE))
126 err = nfs42_proc_fallocate(&msg, filep, offset, len);
128 truncate_pagecache_range(inode, offset, (offset + len) -1);
129 if (err == -EOPNOTSUPP)
130 NFS_SERVER(inode)->caps &= ~NFS_CAP_DEALLOCATE;
136 static int handle_async_copy(struct nfs42_copy_res *res,
137 struct nfs_server *server,
140 nfs4_stateid *src_stateid)
142 struct nfs4_copy_state *copy, *tmp_copy;
143 int status = NFS4_OK;
144 bool found_pending = false;
145 struct nfs_open_context *ctx = nfs_file_open_context(dst);
147 copy = kzalloc(sizeof(struct nfs4_copy_state), GFP_NOFS);
151 spin_lock(&server->nfs_client->cl_lock);
152 list_for_each_entry(tmp_copy, &server->nfs_client->pending_cb_stateids,
154 if (memcmp(&res->write_res.stateid, &tmp_copy->stateid,
157 found_pending = true;
158 list_del(&tmp_copy->copies);
162 spin_unlock(&server->nfs_client->cl_lock);
168 memcpy(©->stateid, &res->write_res.stateid, NFS4_STATEID_SIZE);
169 init_completion(©->completion);
170 copy->parent_state = ctx->state;
172 list_add_tail(©->copies, &server->ss_copies);
173 spin_unlock(&server->nfs_client->cl_lock);
175 status = wait_for_completion_interruptible(©->completion);
176 spin_lock(&server->nfs_client->cl_lock);
177 list_del_init(©->copies);
178 spin_unlock(&server->nfs_client->cl_lock);
179 if (status == -ERESTARTSYS) {
181 } else if (copy->flags) {
186 res->write_res.count = copy->count;
187 memcpy(&res->write_res.verifier, ©->verf, sizeof(copy->verf));
188 status = -copy->error;
193 nfs42_do_offload_cancel_async(dst, ©->stateid);
198 static int process_copy_commit(struct file *dst, loff_t pos_dst,
199 struct nfs42_copy_res *res)
201 struct nfs_commitres cres;
202 int status = -ENOMEM;
204 cres.verf = kzalloc(sizeof(struct nfs_writeverf), GFP_NOFS);
208 status = nfs4_proc_commit(dst, pos_dst, res->write_res.count, &cres);
211 if (nfs_write_verifier_cmp(&res->write_res.verifier.verifier,
212 &cres.verf->verifier)) {
213 dprintk("commit verf differs from copy verf\n");
222 static ssize_t _nfs42_proc_copy(struct file *src,
223 struct nfs_lock_context *src_lock,
225 struct nfs_lock_context *dst_lock,
226 struct nfs42_copy_args *args,
227 struct nfs42_copy_res *res)
229 struct rpc_message msg = {
230 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_COPY],
234 struct inode *dst_inode = file_inode(dst);
235 struct nfs_server *server = NFS_SERVER(dst_inode);
236 loff_t pos_src = args->src_pos;
237 loff_t pos_dst = args->dst_pos;
238 size_t count = args->count;
241 status = nfs4_set_rw_stateid(&args->src_stateid, src_lock->open_context,
242 src_lock, FMODE_READ);
246 status = nfs_filemap_write_and_wait_range(file_inode(src)->i_mapping,
247 pos_src, pos_src + (loff_t)count - 1);
251 status = nfs4_set_rw_stateid(&args->dst_stateid, dst_lock->open_context,
252 dst_lock, FMODE_WRITE);
256 status = nfs_sync_inode(dst_inode);
260 res->commit_res.verf = NULL;
262 res->commit_res.verf =
263 kzalloc(sizeof(struct nfs_writeverf), GFP_NOFS);
264 if (!res->commit_res.verf)
267 set_bit(NFS_CLNT_DST_SSC_COPY_STATE,
268 &dst_lock->open_context->state->flags);
270 status = nfs4_call_sync(server->client, server, &msg,
271 &args->seq_args, &res->seq_res, 0);
272 if (status == -ENOTSUPP)
273 server->caps &= ~NFS_CAP_COPY;
278 nfs_write_verifier_cmp(&res->write_res.verifier.verifier,
279 &res->commit_res.verf->verifier)) {
284 if (!res->synchronous) {
285 status = handle_async_copy(res, server, src, dst,
291 if ((!res->synchronous || !args->sync) &&
292 res->write_res.verifier.committed != NFS_FILE_SYNC) {
293 status = process_copy_commit(dst, pos_dst, res);
298 WARN_ON_ONCE(invalidate_inode_pages2_range(dst_inode->i_mapping,
299 pos_dst >> PAGE_SHIFT,
300 (pos_dst + res->write_res.count - 1) >> PAGE_SHIFT));
302 status = res->write_res.count;
305 kfree(res->commit_res.verf);
309 ssize_t nfs42_proc_copy(struct file *src, loff_t pos_src,
310 struct file *dst, loff_t pos_dst,
313 struct nfs_server *server = NFS_SERVER(file_inode(dst));
314 struct nfs_lock_context *src_lock;
315 struct nfs_lock_context *dst_lock;
316 struct nfs42_copy_args args = {
317 .src_fh = NFS_FH(file_inode(src)),
319 .dst_fh = NFS_FH(file_inode(dst)),
324 struct nfs42_copy_res res;
325 struct nfs4_exception src_exception = {
326 .inode = file_inode(src),
327 .stateid = &args.src_stateid,
329 struct nfs4_exception dst_exception = {
330 .inode = file_inode(dst),
331 .stateid = &args.dst_stateid,
335 src_lock = nfs_get_lock_context(nfs_file_open_context(src));
336 if (IS_ERR(src_lock))
337 return PTR_ERR(src_lock);
339 src_exception.state = src_lock->open_context->state;
341 dst_lock = nfs_get_lock_context(nfs_file_open_context(dst));
342 if (IS_ERR(dst_lock)) {
343 err = PTR_ERR(dst_lock);
344 goto out_put_src_lock;
347 dst_exception.state = dst_lock->open_context->state;
350 inode_lock(file_inode(dst));
351 err = _nfs42_proc_copy(src, src_lock,
354 inode_unlock(file_inode(dst));
358 if (err == -ENOTSUPP) {
361 } else if (err == -EAGAIN) {
362 dst_exception.retry = 1;
364 } else if (err == -NFS4ERR_OFFLOAD_NO_REQS && !args.sync) {
366 dst_exception.retry = 1;
370 err2 = nfs4_handle_exception(server, err, &src_exception);
371 err = nfs4_handle_exception(server, err, &dst_exception);
374 } while (src_exception.retry || dst_exception.retry);
376 nfs_put_lock_context(dst_lock);
378 nfs_put_lock_context(src_lock);
382 struct nfs42_offloadcancel_data {
383 struct nfs_server *seq_server;
384 struct nfs42_offload_status_args args;
385 struct nfs42_offload_status_res res;
388 static void nfs42_offload_cancel_prepare(struct rpc_task *task, void *calldata)
390 struct nfs42_offloadcancel_data *data = calldata;
392 nfs4_setup_sequence(data->seq_server->nfs_client,
393 &data->args.osa_seq_args,
394 &data->res.osr_seq_res, task);
397 static void nfs42_offload_cancel_done(struct rpc_task *task, void *calldata)
399 struct nfs42_offloadcancel_data *data = calldata;
401 nfs41_sequence_done(task, &data->res.osr_seq_res);
402 if (task->tk_status &&
403 nfs4_async_handle_error(task, data->seq_server, NULL,
405 rpc_restart_call_prepare(task);
408 static void nfs42_free_offloadcancel_data(void *data)
413 static const struct rpc_call_ops nfs42_offload_cancel_ops = {
414 .rpc_call_prepare = nfs42_offload_cancel_prepare,
415 .rpc_call_done = nfs42_offload_cancel_done,
416 .rpc_release = nfs42_free_offloadcancel_data,
419 static int nfs42_do_offload_cancel_async(struct file *dst,
420 nfs4_stateid *stateid)
422 struct nfs_server *dst_server = NFS_SERVER(file_inode(dst));
423 struct nfs42_offloadcancel_data *data = NULL;
424 struct nfs_open_context *ctx = nfs_file_open_context(dst);
425 struct rpc_task *task;
426 struct rpc_message msg = {
427 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OFFLOAD_CANCEL],
428 .rpc_cred = ctx->cred,
430 struct rpc_task_setup task_setup_data = {
431 .rpc_client = dst_server->client,
433 .callback_ops = &nfs42_offload_cancel_ops,
434 .workqueue = nfsiod_workqueue,
435 .flags = RPC_TASK_ASYNC,
439 if (!(dst_server->caps & NFS_CAP_OFFLOAD_CANCEL))
442 data = kzalloc(sizeof(struct nfs42_offloadcancel_data), GFP_NOFS);
446 data->seq_server = dst_server;
447 data->args.osa_src_fh = NFS_FH(file_inode(dst));
448 memcpy(&data->args.osa_stateid, stateid,
449 sizeof(data->args.osa_stateid));
450 msg.rpc_argp = &data->args;
451 msg.rpc_resp = &data->res;
452 task_setup_data.callback_data = data;
453 nfs4_init_sequence(&data->args.osa_seq_args, &data->res.osr_seq_res,
455 task = rpc_run_task(&task_setup_data);
457 return PTR_ERR(task);
458 status = rpc_wait_for_completion_task(task);
459 if (status == -ENOTSUPP)
460 dst_server->caps &= ~NFS_CAP_OFFLOAD_CANCEL;
465 static loff_t _nfs42_proc_llseek(struct file *filep,
466 struct nfs_lock_context *lock, loff_t offset, int whence)
468 struct inode *inode = file_inode(filep);
469 struct nfs42_seek_args args = {
470 .sa_fh = NFS_FH(inode),
472 .sa_what = (whence == SEEK_HOLE) ?
473 NFS4_CONTENT_HOLE : NFS4_CONTENT_DATA,
475 struct nfs42_seek_res res;
476 struct rpc_message msg = {
477 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SEEK],
481 struct nfs_server *server = NFS_SERVER(inode);
484 if (!nfs_server_capable(inode, NFS_CAP_SEEK))
487 status = nfs4_set_rw_stateid(&args.sa_stateid, lock->open_context,
492 status = nfs_filemap_write_and_wait_range(inode->i_mapping,
497 status = nfs4_call_sync(server->client, server, &msg,
498 &args.seq_args, &res.seq_res, 0);
499 if (status == -ENOTSUPP)
500 server->caps &= ~NFS_CAP_SEEK;
504 if (whence == SEEK_DATA && res.sr_eof)
505 return -NFS4ERR_NXIO;
507 return vfs_setpos(filep, res.sr_offset, inode->i_sb->s_maxbytes);
510 loff_t nfs42_proc_llseek(struct file *filep, loff_t offset, int whence)
512 struct nfs_server *server = NFS_SERVER(file_inode(filep));
513 struct nfs4_exception exception = { };
514 struct nfs_lock_context *lock;
517 lock = nfs_get_lock_context(nfs_file_open_context(filep));
519 return PTR_ERR(lock);
521 exception.inode = file_inode(filep);
522 exception.state = lock->open_context->state;
525 err = _nfs42_proc_llseek(filep, lock, offset, whence);
528 if (err == -ENOTSUPP) {
532 err = nfs4_handle_exception(server, err, &exception);
533 } while (exception.retry);
535 nfs_put_lock_context(lock);
541 nfs42_layoutstat_prepare(struct rpc_task *task, void *calldata)
543 struct nfs42_layoutstat_data *data = calldata;
544 struct inode *inode = data->inode;
545 struct nfs_server *server = NFS_SERVER(inode);
546 struct pnfs_layout_hdr *lo;
548 spin_lock(&inode->i_lock);
549 lo = NFS_I(inode)->layout;
550 if (!pnfs_layout_is_valid(lo)) {
551 spin_unlock(&inode->i_lock);
555 nfs4_stateid_copy(&data->args.stateid, &lo->plh_stateid);
556 spin_unlock(&inode->i_lock);
557 nfs4_setup_sequence(server->nfs_client, &data->args.seq_args,
558 &data->res.seq_res, task);
562 nfs42_layoutstat_done(struct rpc_task *task, void *calldata)
564 struct nfs42_layoutstat_data *data = calldata;
565 struct inode *inode = data->inode;
566 struct pnfs_layout_hdr *lo;
568 if (!nfs4_sequence_done(task, &data->res.seq_res))
571 switch (task->tk_status) {
574 case -NFS4ERR_BADHANDLE:
576 pnfs_destroy_layout(NFS_I(inode));
578 case -NFS4ERR_EXPIRED:
579 case -NFS4ERR_ADMIN_REVOKED:
580 case -NFS4ERR_DELEG_REVOKED:
581 case -NFS4ERR_STALE_STATEID:
582 case -NFS4ERR_BAD_STATEID:
583 spin_lock(&inode->i_lock);
584 lo = NFS_I(inode)->layout;
585 if (pnfs_layout_is_valid(lo) &&
586 nfs4_stateid_match(&data->args.stateid,
591 * Mark the bad layout state as invalid, then retry
592 * with the current stateid.
594 pnfs_mark_layout_stateid_invalid(lo, &head);
595 spin_unlock(&inode->i_lock);
596 pnfs_free_lseg_list(&head);
597 nfs_commit_inode(inode, 0);
599 spin_unlock(&inode->i_lock);
601 case -NFS4ERR_OLD_STATEID:
602 spin_lock(&inode->i_lock);
603 lo = NFS_I(inode)->layout;
604 if (pnfs_layout_is_valid(lo) &&
605 nfs4_stateid_match_other(&data->args.stateid,
607 /* Do we need to delay before resending? */
608 if (!nfs4_stateid_is_newer(&lo->plh_stateid,
609 &data->args.stateid))
611 rpc_restart_call_prepare(task);
613 spin_unlock(&inode->i_lock);
617 NFS_SERVER(inode)->caps &= ~NFS_CAP_LAYOUTSTATS;
622 nfs42_layoutstat_release(void *calldata)
624 struct nfs42_layoutstat_data *data = calldata;
625 struct nfs42_layoutstat_devinfo *devinfo = data->args.devinfo;
628 for (i = 0; i < data->args.num_dev; i++) {
629 if (devinfo[i].ld_private.ops && devinfo[i].ld_private.ops->free)
630 devinfo[i].ld_private.ops->free(&devinfo[i].ld_private);
633 pnfs_put_layout_hdr(NFS_I(data->args.inode)->layout);
634 smp_mb__before_atomic();
635 clear_bit(NFS_INO_LAYOUTSTATS, &NFS_I(data->args.inode)->flags);
636 smp_mb__after_atomic();
637 nfs_iput_and_deactive(data->inode);
638 kfree(data->args.devinfo);
642 static const struct rpc_call_ops nfs42_layoutstat_ops = {
643 .rpc_call_prepare = nfs42_layoutstat_prepare,
644 .rpc_call_done = nfs42_layoutstat_done,
645 .rpc_release = nfs42_layoutstat_release,
648 int nfs42_proc_layoutstats_generic(struct nfs_server *server,
649 struct nfs42_layoutstat_data *data)
651 struct rpc_message msg = {
652 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTSTATS],
653 .rpc_argp = &data->args,
654 .rpc_resp = &data->res,
656 struct rpc_task_setup task_setup = {
657 .rpc_client = server->client,
659 .callback_ops = &nfs42_layoutstat_ops,
660 .callback_data = data,
661 .flags = RPC_TASK_ASYNC,
663 struct rpc_task *task;
665 data->inode = nfs_igrab_and_active(data->args.inode);
667 nfs42_layoutstat_release(data);
670 nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 0, 0);
671 task = rpc_run_task(&task_setup);
673 return PTR_ERR(task);
678 static int _nfs42_proc_clone(struct rpc_message *msg, struct file *src_f,
679 struct file *dst_f, struct nfs_lock_context *src_lock,
680 struct nfs_lock_context *dst_lock, loff_t src_offset,
681 loff_t dst_offset, loff_t count)
683 struct inode *src_inode = file_inode(src_f);
684 struct inode *dst_inode = file_inode(dst_f);
685 struct nfs_server *server = NFS_SERVER(dst_inode);
686 struct nfs42_clone_args args = {
687 .src_fh = NFS_FH(src_inode),
688 .dst_fh = NFS_FH(dst_inode),
689 .src_offset = src_offset,
690 .dst_offset = dst_offset,
692 .dst_bitmask = server->cache_consistency_bitmask,
694 struct nfs42_clone_res res = {
699 msg->rpc_argp = &args;
700 msg->rpc_resp = &res;
702 status = nfs4_set_rw_stateid(&args.src_stateid, src_lock->open_context,
703 src_lock, FMODE_READ);
707 status = nfs4_set_rw_stateid(&args.dst_stateid, dst_lock->open_context,
708 dst_lock, FMODE_WRITE);
712 res.dst_fattr = nfs_alloc_fattr();
716 status = nfs4_call_sync(server->client, server, msg,
717 &args.seq_args, &res.seq_res, 0);
719 status = nfs_post_op_update_inode(dst_inode, res.dst_fattr);
721 kfree(res.dst_fattr);
725 int nfs42_proc_clone(struct file *src_f, struct file *dst_f,
726 loff_t src_offset, loff_t dst_offset, loff_t count)
728 struct rpc_message msg = {
729 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CLONE],
731 struct inode *inode = file_inode(src_f);
732 struct nfs_server *server = NFS_SERVER(file_inode(src_f));
733 struct nfs_lock_context *src_lock;
734 struct nfs_lock_context *dst_lock;
735 struct nfs4_exception src_exception = { };
736 struct nfs4_exception dst_exception = { };
739 if (!nfs_server_capable(inode, NFS_CAP_CLONE))
742 src_lock = nfs_get_lock_context(nfs_file_open_context(src_f));
743 if (IS_ERR(src_lock))
744 return PTR_ERR(src_lock);
746 src_exception.inode = file_inode(src_f);
747 src_exception.state = src_lock->open_context->state;
749 dst_lock = nfs_get_lock_context(nfs_file_open_context(dst_f));
750 if (IS_ERR(dst_lock)) {
751 err = PTR_ERR(dst_lock);
752 goto out_put_src_lock;
755 dst_exception.inode = file_inode(dst_f);
756 dst_exception.state = dst_lock->open_context->state;
759 err = _nfs42_proc_clone(&msg, src_f, dst_f, src_lock, dst_lock,
760 src_offset, dst_offset, count);
761 if (err == -ENOTSUPP || err == -EOPNOTSUPP) {
762 NFS_SERVER(inode)->caps &= ~NFS_CAP_CLONE;
767 err2 = nfs4_handle_exception(server, err, &src_exception);
768 err = nfs4_handle_exception(server, err, &dst_exception);
771 } while (src_exception.retry || dst_exception.retry);
773 nfs_put_lock_context(dst_lock);
775 nfs_put_lock_context(src_lock);