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(©->stateid, &res->write_res.stateid, NFS4_STATEID_SIZE); 195 init_completion(©->completion); 196 copy->parent_dst_state = dst_ctx->state; 197 copy->parent_src_state = src_ctx->state; 198 199 list_add_tail(©->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(©->src_copies, &src_server->ss_copies); 205 spin_unlock(&src_server->nfs_client->cl_lock); 206 } 207 208 status = wait_for_completion_interruptible(©->completion); 209 spin_lock(&dst_server->nfs_client->cl_lock); 210 list_del_init(©->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(©->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, ©->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, ©->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 } 1091