?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
spi: efm32: Convert to use GPIO descriptors
[linux/fpc-iii.git] / fs / nfs / nfs42proc.c
blobe2ae54b35dfe1ff5da1bd1d656327b7b245e2cda
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
21 #define NFSDBG_FACILITY NFSDBG_PROC
22 static int nfs42_do_offload_cancel_async(struct file *dst, nfs4_stateid *std);
23
24 static void nfs42_set_netaddr(struct file *filep, struct nfs42_netaddr *naddr)
25 {
26 struct nfs_client *clp = (NFS_SERVER(file_inode(filep)))->nfs_client;
27 unsigned short port = 2049;
28
29 rcu_read_lock();
30 naddr->netid_len = scnprintf(naddr->netid,
31 sizeof(naddr->netid), "%s",
32 rpc_peeraddr2str(clp->cl_rpcclient,
33 RPC_DISPLAY_NETID));
34 naddr->addr_len = scnprintf(naddr->addr,
35 sizeof(naddr->addr),
36 "%s.%u.%u",
37 rpc_peeraddr2str(clp->cl_rpcclient,
38 RPC_DISPLAY_ADDR),
39 port >> 8, port & 255);
40 rcu_read_unlock();
41 }
42
43 static int _nfs42_proc_fallocate(struct rpc_message *msg, struct file *filep,
44 struct nfs_lock_context *lock, loff_t offset, loff_t len)
45 {
46 struct inode *inode = file_inode(filep);
47 struct nfs_server *server = NFS_SERVER(inode);
48 struct nfs42_falloc_args args = {
49 .falloc_fh = NFS_FH(inode),
50 .falloc_offset = offset,
51 .falloc_length = len,
52 .falloc_bitmask = nfs4_fattr_bitmap,
53 };
54 struct nfs42_falloc_res res = {
55 .falloc_server = server,
56 };
57 int status;
58
59 msg->rpc_argp = &args;
60 msg->rpc_resp = &res;
61
62 status = nfs4_set_rw_stateid(&args.falloc_stateid, lock->open_context,
63 lock, FMODE_WRITE);
64 if (status) {
65 if (status == -EAGAIN)
66 status = -NFS4ERR_BAD_STATEID;
67 return status;
68 }
69
70 res.falloc_fattr = nfs_alloc_fattr();
71 if (!res.falloc_fattr)
72 return -ENOMEM;
73
74 status = nfs4_call_sync(server->client, server, msg,
75 &args.seq_args, &res.seq_res, 0);
76 if (status == 0)
77 status = nfs_post_op_update_inode(inode, res.falloc_fattr);
78
79 kfree(res.falloc_fattr);
80 return status;
81 }
82
83 static int nfs42_proc_fallocate(struct rpc_message *msg, struct file *filep,
84 loff_t offset, loff_t len)
85 {
86 struct nfs_server *server = NFS_SERVER(file_inode(filep));
87 struct nfs4_exception exception = { };
88 struct nfs_lock_context *lock;
89 int err;
90
91 lock = nfs_get_lock_context(nfs_file_open_context(filep));
92 if (IS_ERR(lock))
93 return PTR_ERR(lock);
94
95 exception.inode = file_inode(filep);
96 exception.state = lock->open_context->state;
97
98 do {
99 err = _nfs42_proc_fallocate(msg, filep, lock, offset, len);
100 if (err == -ENOTSUPP) {
101 err = -EOPNOTSUPP;
102 break;
103 }
104 err = nfs4_handle_exception(server, err, &exception);
105 } while (exception.retry);
106
107 nfs_put_lock_context(lock);
108 return err;
109 }
110
111 int nfs42_proc_allocate(struct file *filep, loff_t offset, loff_t len)
112 {
113 struct rpc_message msg = {
114 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_ALLOCATE],
115 };
116 struct inode *inode = file_inode(filep);
117 int err;
118
119 if (!nfs_server_capable(inode, NFS_CAP_ALLOCATE))
120 return -EOPNOTSUPP;
121
122 inode_lock(inode);
123
124 err = nfs42_proc_fallocate(&msg, filep, offset, len);
125 if (err == -EOPNOTSUPP)
126 NFS_SERVER(inode)->caps &= ~NFS_CAP_ALLOCATE;
127
128 inode_unlock(inode);
129 return err;
130 }
131
132 int nfs42_proc_deallocate(struct file *filep, loff_t offset, loff_t len)
133 {
134 struct rpc_message msg = {
135 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DEALLOCATE],
136 };
137 struct inode *inode = file_inode(filep);
138 int err;
139
140 if (!nfs_server_capable(inode, NFS_CAP_DEALLOCATE))
141 return -EOPNOTSUPP;
142
143 inode_lock(inode);
144 err = nfs_sync_inode(inode);
145 if (err)
146 goto out_unlock;
147
148 err = nfs42_proc_fallocate(&msg, filep, offset, len);
149 if (err == 0)
150 truncate_pagecache_range(inode, offset, (offset + len) -1);
151 if (err == -EOPNOTSUPP)
152 NFS_SERVER(inode)->caps &= ~NFS_CAP_DEALLOCATE;
153 out_unlock:
154 inode_unlock(inode);
155 return err;
156 }
157
158 static int handle_async_copy(struct nfs42_copy_res *res,
159 struct nfs_server *dst_server,
160 struct nfs_server *src_server,
161 struct file *src,
162 struct file *dst,
163 nfs4_stateid *src_stateid,
164 bool *restart)
165 {
166 struct nfs4_copy_state *copy, *tmp_copy;
167 int status = NFS4_OK;
168 bool found_pending = false;
169 struct nfs_open_context *dst_ctx = nfs_file_open_context(dst);
170 struct nfs_open_context *src_ctx = nfs_file_open_context(src);
171
172 copy = kzalloc(sizeof(struct nfs4_copy_state), GFP_NOFS);
173 if (!copy)
174 return -ENOMEM;
175
176 spin_lock(&dst_server->nfs_client->cl_lock);
177 list_for_each_entry(tmp_copy,
178 &dst_server->nfs_client->pending_cb_stateids,
179 copies) {
180 if (memcmp(&res->write_res.stateid, &tmp_copy->stateid,
181 NFS4_STATEID_SIZE))
182 continue;
183 found_pending = true;
184 list_del(&tmp_copy->copies);
185 break;
186 }
187 if (found_pending) {
188 spin_unlock(&dst_server->nfs_client->cl_lock);
189 kfree(copy);
190 copy = tmp_copy;
191 goto out;
192 }
193
194 memcpy(&copy->stateid, &res->write_res.stateid, NFS4_STATEID_SIZE);
195 init_completion(&copy->completion);
196 copy->parent_dst_state = dst_ctx->state;
197 copy->parent_src_state = src_ctx->state;
198
199 list_add_tail(&copy->copies, &dst_server->ss_copies);
200 spin_unlock(&dst_server->nfs_client->cl_lock);
201
202 if (dst_server != src_server) {
203 spin_lock(&src_server->nfs_client->cl_lock);
204 list_add_tail(&copy->src_copies, &src_server->ss_copies);
205 spin_unlock(&src_server->nfs_client->cl_lock);
206 }
207
208 status = wait_for_completion_interruptible(&copy->completion);
209 spin_lock(&dst_server->nfs_client->cl_lock);
210 list_del_init(&copy->copies);
211 spin_unlock(&dst_server->nfs_client->cl_lock);
212 if (dst_server != src_server) {
213 spin_lock(&src_server->nfs_client->cl_lock);
214 list_del_init(&copy->src_copies);
215 spin_unlock(&src_server->nfs_client->cl_lock);
216 }
217 if (status == -ERESTARTSYS) {
218 goto out_cancel;
219 } else if (copy->flags || copy->error == NFS4ERR_PARTNER_NO_AUTH) {
220 status = -EAGAIN;
221 *restart = true;
222 goto out_cancel;
223 }
224 out:
225 res->write_res.count = copy->count;
226 memcpy(&res->write_res.verifier, &copy->verf, sizeof(copy->verf));
227 status = -copy->error;
228
229 out_free:
230 kfree(copy);
231 return status;
232 out_cancel:
233 nfs42_do_offload_cancel_async(dst, &copy->stateid);
234 if (!nfs42_files_from_same_server(src, dst))
235 nfs42_do_offload_cancel_async(src, src_stateid);
236 goto out_free;
237 }
238
239 static int process_copy_commit(struct file *dst, loff_t pos_dst,
240 struct nfs42_copy_res *res)
241 {
242 struct nfs_commitres cres;
243 int status = -ENOMEM;
244
245 cres.verf = kzalloc(sizeof(struct nfs_writeverf), GFP_NOFS);
246 if (!cres.verf)
247 goto out;
248
249 status = nfs4_proc_commit(dst, pos_dst, res->write_res.count, &cres);
250 if (status)
251 goto out_free;
252 if (nfs_write_verifier_cmp(&res->write_res.verifier.verifier,
253 &cres.verf->verifier)) {
254 dprintk("commit verf differs from copy verf\n");
255 status = -EAGAIN;
256 }
257 out_free:
258 kfree(cres.verf);
259 out:
260 return status;
261 }
262
263 static ssize_t _nfs42_proc_copy(struct file *src,
264 struct nfs_lock_context *src_lock,
265 struct file *dst,
266 struct nfs_lock_context *dst_lock,
267 struct nfs42_copy_args *args,
268 struct nfs42_copy_res *res,
269 struct nl4_server *nss,
270 nfs4_stateid *cnr_stateid,
271 bool *restart)
272 {
273 struct rpc_message msg = {
274 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_COPY],
275 .rpc_argp = args,
276 .rpc_resp = res,
277 };
278 struct inode *dst_inode = file_inode(dst);
279 struct inode *src_inode = file_inode(src);
280 struct nfs_server *dst_server = NFS_SERVER(dst_inode);
281 struct nfs_server *src_server = NFS_SERVER(src_inode);
282 loff_t pos_src = args->src_pos;
283 loff_t pos_dst = args->dst_pos;
284 size_t count = args->count;
285 ssize_t status;
286
287 if (nss) {
288 args->cp_src = nss;
289 nfs4_stateid_copy(&args->src_stateid, cnr_stateid);
290 } else {
291 status = nfs4_set_rw_stateid(&args->src_stateid,
292 src_lock->open_context, src_lock, FMODE_READ);
293 if (status) {
294 if (status == -EAGAIN)
295 status = -NFS4ERR_BAD_STATEID;
296 return status;
297 }
298 }
299 status = nfs_filemap_write_and_wait_range(file_inode(src)->i_mapping,
300 pos_src, pos_src + (loff_t)count - 1);
301 if (status)
302 return status;
303
304 status = nfs4_set_rw_stateid(&args->dst_stateid, dst_lock->open_context,
305 dst_lock, FMODE_WRITE);
306 if (status) {
307 if (status == -EAGAIN)
308 status = -NFS4ERR_BAD_STATEID;
309 return status;
310 }
311
312 status = nfs_sync_inode(dst_inode);
313 if (status)
314 return status;
315
316 res->commit_res.verf = NULL;
317 if (args->sync) {
318 res->commit_res.verf =
319 kzalloc(sizeof(struct nfs_writeverf), GFP_NOFS);
320 if (!res->commit_res.verf)
321 return -ENOMEM;
322 }
323 set_bit(NFS_CLNT_SRC_SSC_COPY_STATE,
324 &src_lock->open_context->state->flags);
325 set_bit(NFS_CLNT_DST_SSC_COPY_STATE,
326 &dst_lock->open_context->state->flags);
327
328 status = nfs4_call_sync(dst_server->client, dst_server, &msg,
329 &args->seq_args, &res->seq_res, 0);
330 if (status == -ENOTSUPP)
331 dst_server->caps &= ~NFS_CAP_COPY;
332 if (status)
333 goto out;
334
335 if (args->sync &&
336 nfs_write_verifier_cmp(&res->write_res.verifier.verifier,
337 &res->commit_res.verf->verifier)) {
338 status = -EAGAIN;
339 goto out;
340 }
341
342 if (!res->synchronous) {
343 status = handle_async_copy(res, dst_server, src_server, src,
344 dst, &args->src_stateid, restart);
345 if (status)
346 goto out;
347 }
348
349 if ((!res->synchronous || !args->sync) &&
350 res->write_res.verifier.committed != NFS_FILE_SYNC) {
351 status = process_copy_commit(dst, pos_dst, res);
352 if (status)
353 goto out;
354 }
355
356 truncate_pagecache_range(dst_inode, pos_dst,
357 pos_dst + res->write_res.count);
358
359 status = res->write_res.count;
360 out:
361 if (args->sync)
362 kfree(res->commit_res.verf);
363 return status;
364 }
365
366 ssize_t nfs42_proc_copy(struct file *src, loff_t pos_src,
367 struct file *dst, loff_t pos_dst, size_t count,
368 struct nl4_server *nss,
369 nfs4_stateid *cnr_stateid, bool sync)
370 {
371 struct nfs_server *server = NFS_SERVER(file_inode(dst));
372 struct nfs_lock_context *src_lock;
373 struct nfs_lock_context *dst_lock;
374 struct nfs42_copy_args args = {
375 .src_fh = NFS_FH(file_inode(src)),
376 .src_pos = pos_src,
377 .dst_fh = NFS_FH(file_inode(dst)),
378 .dst_pos = pos_dst,
379 .count = count,
380 .sync = sync,
381 };
382 struct nfs42_copy_res res;
383 struct nfs4_exception src_exception = {
384 .inode = file_inode(src),
385 .stateid = &args.src_stateid,
386 };
387 struct nfs4_exception dst_exception = {
388 .inode = file_inode(dst),
389 .stateid = &args.dst_stateid,
390 };
391 ssize_t err, err2;
392 bool restart = false;
393
394 src_lock = nfs_get_lock_context(nfs_file_open_context(src));
395 if (IS_ERR(src_lock))
396 return PTR_ERR(src_lock);
397
398 src_exception.state = src_lock->open_context->state;
399
400 dst_lock = nfs_get_lock_context(nfs_file_open_context(dst));
401 if (IS_ERR(dst_lock)) {
402 err = PTR_ERR(dst_lock);
403 goto out_put_src_lock;
404 }
405
406 dst_exception.state = dst_lock->open_context->state;
407
408 do {
409 inode_lock(file_inode(dst));
410 err = _nfs42_proc_copy(src, src_lock,
411 dst, dst_lock,
412 &args, &res,
413 nss, cnr_stateid, &restart);
414 inode_unlock(file_inode(dst));
415
416 if (err >= 0)
417 break;
418 if (err == -ENOTSUPP &&
419 nfs42_files_from_same_server(src, dst)) {
420 err = -EOPNOTSUPP;
421 break;
422 } else if (err == -EAGAIN) {
423 if (!restart) {
424 dst_exception.retry = 1;
425 continue;
426 }
427 break;
428 } else if (err == -NFS4ERR_OFFLOAD_NO_REQS && !args.sync) {
429 args.sync = true;
430 dst_exception.retry = 1;
431 continue;
432 } else if ((err == -ESTALE ||
433 err == -NFS4ERR_OFFLOAD_DENIED ||
434 err == -ENOTSUPP) &&
435 !nfs42_files_from_same_server(src, dst)) {
436 nfs42_do_offload_cancel_async(src, &args.src_stateid);
437 err = -EOPNOTSUPP;
438 break;
439 }
440
441 err2 = nfs4_handle_exception(server, err, &src_exception);
442 err = nfs4_handle_exception(server, err, &dst_exception);
443 if (!err)
444 err = err2;
445 } while (src_exception.retry || dst_exception.retry);
446
447 nfs_put_lock_context(dst_lock);
448 out_put_src_lock:
449 nfs_put_lock_context(src_lock);
450 return err;
451 }
452
453 struct nfs42_offloadcancel_data {
454 struct nfs_server *seq_server;
455 struct nfs42_offload_status_args args;
456 struct nfs42_offload_status_res res;
457 };
458
459 static void nfs42_offload_cancel_prepare(struct rpc_task *task, void *calldata)
460 {
461 struct nfs42_offloadcancel_data *data = calldata;
462
463 nfs4_setup_sequence(data->seq_server->nfs_client,
464 &data->args.osa_seq_args,
465 &data->res.osr_seq_res, task);
466 }
467
468 static void nfs42_offload_cancel_done(struct rpc_task *task, void *calldata)
469 {
470 struct nfs42_offloadcancel_data *data = calldata;
471
472 nfs41_sequence_done(task, &data->res.osr_seq_res);
473 if (task->tk_status &&
474 nfs4_async_handle_error(task, data->seq_server, NULL,
475 NULL) == -EAGAIN)
476 rpc_restart_call_prepare(task);
477 }
478
479 static void nfs42_free_offloadcancel_data(void *data)
480 {
481 kfree(data);
482 }
483
484 static const struct rpc_call_ops nfs42_offload_cancel_ops = {
485 .rpc_call_prepare = nfs42_offload_cancel_prepare,
486 .rpc_call_done = nfs42_offload_cancel_done,
487 .rpc_release = nfs42_free_offloadcancel_data,
488 };
489
490 static int nfs42_do_offload_cancel_async(struct file *dst,
491 nfs4_stateid *stateid)
492 {
493 struct nfs_server *dst_server = NFS_SERVER(file_inode(dst));
494 struct nfs42_offloadcancel_data *data = NULL;
495 struct nfs_open_context *ctx = nfs_file_open_context(dst);
496 struct rpc_task *task;
497 struct rpc_message msg = {
498 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OFFLOAD_CANCEL],
499 .rpc_cred = ctx->cred,
500 };
501 struct rpc_task_setup task_setup_data = {
502 .rpc_client = dst_server->client,
503 .rpc_message = &msg,
504 .callback_ops = &nfs42_offload_cancel_ops,
505 .workqueue = nfsiod_workqueue,
506 .flags = RPC_TASK_ASYNC,
507 };
508 int status;
509
510 if (!(dst_server->caps & NFS_CAP_OFFLOAD_CANCEL))
511 return -EOPNOTSUPP;
512
513 data = kzalloc(sizeof(struct nfs42_offloadcancel_data), GFP_NOFS);
514 if (data == NULL)
515 return -ENOMEM;
516
517 data->seq_server = dst_server;
518 data->args.osa_src_fh = NFS_FH(file_inode(dst));
519 memcpy(&data->args.osa_stateid, stateid,
520 sizeof(data->args.osa_stateid));
521 msg.rpc_argp = &data->args;
522 msg.rpc_resp = &data->res;
523 task_setup_data.callback_data = data;
524 nfs4_init_sequence(&data->args.osa_seq_args, &data->res.osr_seq_res,
525 1, 0);
526 task = rpc_run_task(&task_setup_data);
527 if (IS_ERR(task))
528 return PTR_ERR(task);
529 status = rpc_wait_for_completion_task(task);
530 if (status == -ENOTSUPP)
531 dst_server->caps &= ~NFS_CAP_OFFLOAD_CANCEL;
532 rpc_put_task(task);
533 return status;
534 }
535
536 static int _nfs42_proc_copy_notify(struct file *src, struct file *dst,
537 struct nfs42_copy_notify_args *args,
538 struct nfs42_copy_notify_res *res)
539 {
540 struct nfs_server *src_server = NFS_SERVER(file_inode(src));
541 struct rpc_message msg = {
542 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_COPY_NOTIFY],
543 .rpc_argp = args,
544 .rpc_resp = res,
545 };
546 int status;
547 struct nfs_open_context *ctx;
548 struct nfs_lock_context *l_ctx;
549
550 ctx = get_nfs_open_context(nfs_file_open_context(src));
551 l_ctx = nfs_get_lock_context(ctx);
552 if (IS_ERR(l_ctx))
553 return PTR_ERR(l_ctx);
554
555 status = nfs4_set_rw_stateid(&args->cna_src_stateid, ctx, l_ctx,
556 FMODE_READ);
557 nfs_put_lock_context(l_ctx);
558 if (status) {
559 if (status == -EAGAIN)
560 status = -NFS4ERR_BAD_STATEID;
561 return status;
562 }
563
564 status = nfs4_call_sync(src_server->client, src_server, &msg,
565 &args->cna_seq_args, &res->cnr_seq_res, 0);
566 if (status == -ENOTSUPP)
567 src_server->caps &= ~NFS_CAP_COPY_NOTIFY;
568
569 put_nfs_open_context(nfs_file_open_context(src));
570 return status;
571 }
572
573 int nfs42_proc_copy_notify(struct file *src, struct file *dst,
574 struct nfs42_copy_notify_res *res)
575 {
576 struct nfs_server *src_server = NFS_SERVER(file_inode(src));
577 struct nfs42_copy_notify_args *args;
578 struct nfs4_exception exception = {
579 .inode = file_inode(src),
580 };
581 int status;
582
583 if (!(src_server->caps & NFS_CAP_COPY_NOTIFY))
584 return -EOPNOTSUPP;
585
586 args = kzalloc(sizeof(struct nfs42_copy_notify_args), GFP_NOFS);
587 if (args == NULL)
588 return -ENOMEM;
589
590 args->cna_src_fh = NFS_FH(file_inode(src)),
591 args->cna_dst.nl4_type = NL4_NETADDR;
592 nfs42_set_netaddr(dst, &args->cna_dst.u.nl4_addr);
593 exception.stateid = &args->cna_src_stateid;
594
595 do {
596 status = _nfs42_proc_copy_notify(src, dst, args, res);
597 if (status == -ENOTSUPP) {
598 status = -EOPNOTSUPP;
599 goto out;
600 }
601 status = nfs4_handle_exception(src_server, status, &exception);
602 } while (exception.retry);
603
604 out:
605 kfree(args);
606 return status;
607 }
608
609 static loff_t _nfs42_proc_llseek(struct file *filep,
610 struct nfs_lock_context *lock, loff_t offset, int whence)
611 {
612 struct inode *inode = file_inode(filep);
613 struct nfs42_seek_args args = {
614 .sa_fh = NFS_FH(inode),
615 .sa_offset = offset,
616 .sa_what = (whence == SEEK_HOLE) ?
617 NFS4_CONTENT_HOLE : NFS4_CONTENT_DATA,
618 };
619 struct nfs42_seek_res res;
620 struct rpc_message msg = {
621 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SEEK],
622 .rpc_argp = &args,
623 .rpc_resp = &res,
624 };
625 struct nfs_server *server = NFS_SERVER(inode);
626 int status;
627
628 if (!nfs_server_capable(inode, NFS_CAP_SEEK))
629 return -ENOTSUPP;
630
631 status = nfs4_set_rw_stateid(&args.sa_stateid, lock->open_context,
632 lock, FMODE_READ);
633 if (status) {
634 if (status == -EAGAIN)
635 status = -NFS4ERR_BAD_STATEID;
636 return status;
637 }
638
639 status = nfs_filemap_write_and_wait_range(inode->i_mapping,
640 offset, LLONG_MAX);
641 if (status)
642 return status;
643
644 status = nfs4_call_sync(server->client, server, &msg,
645 &args.seq_args, &res.seq_res, 0);
646 if (status == -ENOTSUPP)
647 server->caps &= ~NFS_CAP_SEEK;
648 if (status)
649 return status;
650
651 return vfs_setpos(filep, res.sr_offset, inode->i_sb->s_maxbytes);
652 }
653
654 loff_t nfs42_proc_llseek(struct file *filep, loff_t offset, int whence)
655 {
656 struct nfs_server *server = NFS_SERVER(file_inode(filep));
657 struct nfs4_exception exception = { };
658 struct nfs_lock_context *lock;
659 loff_t err;
660
661 lock = nfs_get_lock_context(nfs_file_open_context(filep));
662 if (IS_ERR(lock))
663 return PTR_ERR(lock);
664
665 exception.inode = file_inode(filep);
666 exception.state = lock->open_context->state;
667
668 do {
669 err = _nfs42_proc_llseek(filep, lock, offset, whence);
670 if (err >= 0)
671 break;
672 if (err == -ENOTSUPP) {
673 err = -EOPNOTSUPP;
674 break;
675 }
676 err = nfs4_handle_exception(server, err, &exception);
677 } while (exception.retry);
678
679 nfs_put_lock_context(lock);
680 return err;
681 }
682
683
684 static void
685 nfs42_layoutstat_prepare(struct rpc_task *task, void *calldata)
686 {
687 struct nfs42_layoutstat_data *data = calldata;
688 struct inode *inode = data->inode;
689 struct nfs_server *server = NFS_SERVER(inode);
690 struct pnfs_layout_hdr *lo;
691
692 spin_lock(&inode->i_lock);
693 lo = NFS_I(inode)->layout;
694 if (!pnfs_layout_is_valid(lo)) {
695 spin_unlock(&inode->i_lock);
696 rpc_exit(task, 0);
697 return;
698 }
699 nfs4_stateid_copy(&data->args.stateid, &lo->plh_stateid);
700 spin_unlock(&inode->i_lock);
701 nfs4_setup_sequence(server->nfs_client, &data->args.seq_args,
702 &data->res.seq_res, task);
703 }
704
705 static void
706 nfs42_layoutstat_done(struct rpc_task *task, void *calldata)
707 {
708 struct nfs42_layoutstat_data *data = calldata;
709 struct inode *inode = data->inode;
710 struct pnfs_layout_hdr *lo;
711
712 if (!nfs4_sequence_done(task, &data->res.seq_res))
713 return;
714
715 switch (task->tk_status) {
716 case 0:
717 break;
718 case -NFS4ERR_BADHANDLE:
719 case -ESTALE:
720 pnfs_destroy_layout(NFS_I(inode));
721 break;
722 case -NFS4ERR_EXPIRED:
723 case -NFS4ERR_ADMIN_REVOKED:
724 case -NFS4ERR_DELEG_REVOKED:
725 case -NFS4ERR_STALE_STATEID:
726 case -NFS4ERR_BAD_STATEID:
727 spin_lock(&inode->i_lock);
728 lo = NFS_I(inode)->layout;
729 if (pnfs_layout_is_valid(lo) &&
730 nfs4_stateid_match(&data->args.stateid,
731 &lo->plh_stateid)) {
732 LIST_HEAD(head);
733
734 /*
735 * Mark the bad layout state as invalid, then retry
736 * with the current stateid.
737 */
738 pnfs_mark_layout_stateid_invalid(lo, &head);
739 spin_unlock(&inode->i_lock);
740 pnfs_free_lseg_list(&head);
741 nfs_commit_inode(inode, 0);
742 } else
743 spin_unlock(&inode->i_lock);
744 break;
745 case -NFS4ERR_OLD_STATEID:
746 spin_lock(&inode->i_lock);
747 lo = NFS_I(inode)->layout;
748 if (pnfs_layout_is_valid(lo) &&
749 nfs4_stateid_match_other(&data->args.stateid,
750 &lo->plh_stateid)) {
751 /* Do we need to delay before resending? */
752 if (!nfs4_stateid_is_newer(&lo->plh_stateid,
753 &data->args.stateid))
754 rpc_delay(task, HZ);
755 rpc_restart_call_prepare(task);
756 }
757 spin_unlock(&inode->i_lock);
758 break;
759 case -ENOTSUPP:
760 case -EOPNOTSUPP:
761 NFS_SERVER(inode)->caps &= ~NFS_CAP_LAYOUTSTATS;
762 }
763 }
764
765 static void
766 nfs42_layoutstat_release(void *calldata)
767 {
768 struct nfs42_layoutstat_data *data = calldata;
769 struct nfs42_layoutstat_devinfo *devinfo = data->args.devinfo;
770 int i;
771
772 for (i = 0; i < data->args.num_dev; i++) {
773 if (devinfo[i].ld_private.ops && devinfo[i].ld_private.ops->free)
774 devinfo[i].ld_private.ops->free(&devinfo[i].ld_private);
775 }
776
777 pnfs_put_layout_hdr(NFS_I(data->args.inode)->layout);
778 smp_mb__before_atomic();
779 clear_bit(NFS_INO_LAYOUTSTATS, &NFS_I(data->args.inode)->flags);
780 smp_mb__after_atomic();
781 nfs_iput_and_deactive(data->inode);
782 kfree(data->args.devinfo);
783 kfree(data);
784 }
785
786 static const struct rpc_call_ops nfs42_layoutstat_ops = {
787 .rpc_call_prepare = nfs42_layoutstat_prepare,
788 .rpc_call_done = nfs42_layoutstat_done,
789 .rpc_release = nfs42_layoutstat_release,
790 };
791
792 int nfs42_proc_layoutstats_generic(struct nfs_server *server,
793 struct nfs42_layoutstat_data *data)
794 {
795 struct rpc_message msg = {
796 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTSTATS],
797 .rpc_argp = &data->args,
798 .rpc_resp = &data->res,
799 };
800 struct rpc_task_setup task_setup = {
801 .rpc_client = server->client,
802 .rpc_message = &msg,
803 .callback_ops = &nfs42_layoutstat_ops,
804 .callback_data = data,
805 .flags = RPC_TASK_ASYNC,
806 };
807 struct rpc_task *task;
808
809 data->inode = nfs_igrab_and_active(data->args.inode);
810 if (!data->inode) {
811 nfs42_layoutstat_release(data);
812 return -EAGAIN;
813 }
814 nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 0, 0);
815 task = rpc_run_task(&task_setup);
816 if (IS_ERR(task))
817 return PTR_ERR(task);
818 rpc_put_task(task);
819 return 0;
820 }
821
822 static struct nfs42_layouterror_data *
823 nfs42_alloc_layouterror_data(struct pnfs_layout_segment *lseg, gfp_t gfp_flags)
824 {
825 struct nfs42_layouterror_data *data;
826 struct inode *inode = lseg->pls_layout->plh_inode;
827
828 data = kzalloc(sizeof(*data), gfp_flags);
829 if (data) {
830 data->args.inode = data->inode = nfs_igrab_and_active(inode);
831 if (data->inode) {
832 data->lseg = pnfs_get_lseg(lseg);
833 if (data->lseg)
834 return data;
835 nfs_iput_and_deactive(data->inode);
836 }
837 kfree(data);
838 }
839 return NULL;
840 }
841
842 static void
843 nfs42_free_layouterror_data(struct nfs42_layouterror_data *data)
844 {
845 pnfs_put_lseg(data->lseg);
846 nfs_iput_and_deactive(data->inode);
847 kfree(data);
848 }
849
850 static void
851 nfs42_layouterror_prepare(struct rpc_task *task, void *calldata)
852 {
853 struct nfs42_layouterror_data *data = calldata;
854 struct inode *inode = data->inode;
855 struct nfs_server *server = NFS_SERVER(inode);
856 struct pnfs_layout_hdr *lo = data->lseg->pls_layout;
857 unsigned i;
858
859 spin_lock(&inode->i_lock);
860 if (!pnfs_layout_is_valid(lo)) {
861 spin_unlock(&inode->i_lock);
862 rpc_exit(task, 0);
863 return;
864 }
865 for (i = 0; i < data->args.num_errors; i++)
866 nfs4_stateid_copy(&data->args.errors[i].stateid,
867 &lo->plh_stateid);
868 spin_unlock(&inode->i_lock);
869 nfs4_setup_sequence(server->nfs_client, &data->args.seq_args,
870 &data->res.seq_res, task);
871 }
872
873 static void
874 nfs42_layouterror_done(struct rpc_task *task, void *calldata)
875 {
876 struct nfs42_layouterror_data *data = calldata;
877 struct inode *inode = data->inode;
878 struct pnfs_layout_hdr *lo = data->lseg->pls_layout;
879
880 if (!nfs4_sequence_done(task, &data->res.seq_res))
881 return;
882
883 switch (task->tk_status) {
884 case 0:
885 break;
886 case -NFS4ERR_BADHANDLE:
887 case -ESTALE:
888 pnfs_destroy_layout(NFS_I(inode));
889 break;
890 case -NFS4ERR_EXPIRED:
891 case -NFS4ERR_ADMIN_REVOKED:
892 case -NFS4ERR_DELEG_REVOKED:
893 case -NFS4ERR_STALE_STATEID:
894 case -NFS4ERR_BAD_STATEID:
895 spin_lock(&inode->i_lock);
896 if (pnfs_layout_is_valid(lo) &&
897 nfs4_stateid_match(&data->args.errors[0].stateid,
898 &lo->plh_stateid)) {
899 LIST_HEAD(head);
900
901 /*
902 * Mark the bad layout state as invalid, then retry
903 * with the current stateid.
904 */
905 pnfs_mark_layout_stateid_invalid(lo, &head);
906 spin_unlock(&inode->i_lock);
907 pnfs_free_lseg_list(&head);
908 nfs_commit_inode(inode, 0);
909 } else
910 spin_unlock(&inode->i_lock);
911 break;
912 case -NFS4ERR_OLD_STATEID:
913 spin_lock(&inode->i_lock);
914 if (pnfs_layout_is_valid(lo) &&
915 nfs4_stateid_match_other(&data->args.errors[0].stateid,
916 &lo->plh_stateid)) {
917 /* Do we need to delay before resending? */
918 if (!nfs4_stateid_is_newer(&lo->plh_stateid,
919 &data->args.errors[0].stateid))
920 rpc_delay(task, HZ);
921 rpc_restart_call_prepare(task);
922 }
923 spin_unlock(&inode->i_lock);
924 break;
925 case -ENOTSUPP:
926 case -EOPNOTSUPP:
927 NFS_SERVER(inode)->caps &= ~NFS_CAP_LAYOUTERROR;
928 }
929 }
930
931 static void
932 nfs42_layouterror_release(void *calldata)
933 {
934 struct nfs42_layouterror_data *data = calldata;
935
936 nfs42_free_layouterror_data(data);
937 }
938
939 static const struct rpc_call_ops nfs42_layouterror_ops = {
940 .rpc_call_prepare = nfs42_layouterror_prepare,
941 .rpc_call_done = nfs42_layouterror_done,
942 .rpc_release = nfs42_layouterror_release,
943 };
944
945 int nfs42_proc_layouterror(struct pnfs_layout_segment *lseg,
946 const struct nfs42_layout_error *errors, size_t n)
947 {
948 struct inode *inode = lseg->pls_layout->plh_inode;
949 struct nfs42_layouterror_data *data;
950 struct rpc_task *task;
951 struct rpc_message msg = {
952 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTERROR],
953 };
954 struct rpc_task_setup task_setup = {
955 .rpc_message = &msg,
956 .callback_ops = &nfs42_layouterror_ops,
957 .flags = RPC_TASK_ASYNC,
958 };
959 unsigned int i;
960
961 if (!nfs_server_capable(inode, NFS_CAP_LAYOUTERROR))
962 return -EOPNOTSUPP;
963 if (n > NFS42_LAYOUTERROR_MAX)
964 return -EINVAL;
965 data = nfs42_alloc_layouterror_data(lseg, GFP_NOFS);
966 if (!data)
967 return -ENOMEM;
968 for (i = 0; i < n; i++) {
969 data->args.errors[i] = errors[i];
970 data->args.num_errors++;
971 data->res.num_errors++;
972 }
973 msg.rpc_argp = &data->args;
974 msg.rpc_resp = &data->res;
975 task_setup.callback_data = data;
976 task_setup.rpc_client = NFS_SERVER(inode)->client;
977 nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 0, 0);
978 task = rpc_run_task(&task_setup);
979 if (IS_ERR(task))
980 return PTR_ERR(task);
981 rpc_put_task(task);
982 return 0;
983 }
984 EXPORT_SYMBOL_GPL(nfs42_proc_layouterror);
985
986 static int _nfs42_proc_clone(struct rpc_message *msg, struct file *src_f,
987 struct file *dst_f, struct nfs_lock_context *src_lock,
988 struct nfs_lock_context *dst_lock, loff_t src_offset,
989 loff_t dst_offset, loff_t count)
990 {
991 struct inode *src_inode = file_inode(src_f);
992 struct inode *dst_inode = file_inode(dst_f);
993 struct nfs_server *server = NFS_SERVER(dst_inode);
994 struct nfs42_clone_args args = {
995 .src_fh = NFS_FH(src_inode),
996 .dst_fh = NFS_FH(dst_inode),
997 .src_offset = src_offset,
998 .dst_offset = dst_offset,
999 .count = count,
1000 .dst_bitmask = server->cache_consistency_bitmask,
1001 };
1002 struct nfs42_clone_res res = {
1003 .server = server,
1004 };
1005 int status;
1006
1007 msg->rpc_argp = &args;
1008 msg->rpc_resp = &res;
1009
1010 status = nfs4_set_rw_stateid(&args.src_stateid, src_lock->open_context,
1011 src_lock, FMODE_READ);
1012 if (status) {
1013 if (status == -EAGAIN)
1014 status = -NFS4ERR_BAD_STATEID;
1015 return status;
1016 }
1017 status = nfs4_set_rw_stateid(&args.dst_stateid, dst_lock->open_context,
1018 dst_lock, FMODE_WRITE);
1019 if (status) {
1020 if (status == -EAGAIN)
1021 status = -NFS4ERR_BAD_STATEID;
1022 return status;
1023 }
1024
1025 res.dst_fattr = nfs_alloc_fattr();
1026 if (!res.dst_fattr)
1027 return -ENOMEM;
1028
1029 status = nfs4_call_sync(server->client, server, msg,
1030 &args.seq_args, &res.seq_res, 0);
1031 if (status == 0)
1032 status = nfs_post_op_update_inode(dst_inode, res.dst_fattr);
1033
1034 kfree(res.dst_fattr);
1035 return status;
1036 }
1037
1038 int nfs42_proc_clone(struct file *src_f, struct file *dst_f,
1039 loff_t src_offset, loff_t dst_offset, loff_t count)
1040 {
1041 struct rpc_message msg = {
1042 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CLONE],
1043 };
1044 struct inode *inode = file_inode(src_f);
1045 struct nfs_server *server = NFS_SERVER(file_inode(src_f));
1046 struct nfs_lock_context *src_lock;
1047 struct nfs_lock_context *dst_lock;
1048 struct nfs4_exception src_exception = { };
1049 struct nfs4_exception dst_exception = { };
1050 int err, err2;
1051
1052 if (!nfs_server_capable(inode, NFS_CAP_CLONE))
1053 return -EOPNOTSUPP;
1054
1055 src_lock = nfs_get_lock_context(nfs_file_open_context(src_f));
1056 if (IS_ERR(src_lock))
1057 return PTR_ERR(src_lock);
1058
1059 src_exception.inode = file_inode(src_f);
1060 src_exception.state = src_lock->open_context->state;
1061
1062 dst_lock = nfs_get_lock_context(nfs_file_open_context(dst_f));
1063 if (IS_ERR(dst_lock)) {
1064 err = PTR_ERR(dst_lock);
1065 goto out_put_src_lock;
1066 }
1067
1068 dst_exception.inode = file_inode(dst_f);
1069 dst_exception.state = dst_lock->open_context->state;
1070
1071 do {
1072 err = _nfs42_proc_clone(&msg, src_f, dst_f, src_lock, dst_lock,
1073 src_offset, dst_offset, count);
1074 if (err == -ENOTSUPP || err == -EOPNOTSUPP) {
1075 NFS_SERVER(inode)->caps &= ~NFS_CAP_CLONE;
1076 err = -EOPNOTSUPP;
1077 break;
1078 }
1079
1080 err2 = nfs4_handle_exception(server, err, &src_exception);
1081 err = nfs4_handle_exception(server, err, &dst_exception);
1082 if (!err)
1083 err = err2;
1084 } while (src_exception.retry || dst_exception.retry);
1085
1086 nfs_put_lock_context(dst_lock);
1087 out_put_src_lock:
1088 nfs_put_lock_context(src_lock);
1089 return err;
1090 }
Linux with added FPC-III support