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