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