1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * linux/fs/nfs/nfs3proc.c 4 * 5 * Client-side NFSv3 procedures stubs. 6 * 7 * Copyright (C) 1997, Olaf Kirch 8 */ 9 10 #include <linux/mm.h> 11 #include <linux/errno.h> 12 #include <linux/string.h> 13 #include <linux/sunrpc/clnt.h> 14 #include <linux/slab.h> 15 #include <linux/nfs.h> 16 #include <linux/nfs3.h> 17 #include <linux/nfs_fs.h> 18 #include <linux/nfs_page.h> 19 #include <linux/lockd/bind.h> 20 #include <linux/nfs_mount.h> 21 #include <linux/freezer.h> 22 #include <linux/xattr.h> 23 24 #include "iostat.h" 25 #include "internal.h" 26 #include "nfs3_fs.h" 27 28 #define NFSDBG_FACILITY NFSDBG_PROC 29 30 /* A wrapper to handle the EJUKEBOX error messages */ 31 static int 32 nfs3_rpc_wrapper(struct rpc_clnt *clnt, struct rpc_message *msg, int flags) 33 { 34 int res; 35 do { 36 res = rpc_call_sync(clnt, msg, flags); 37 if (res != -EJUKEBOX) 38 break; 39 __set_current_state(TASK_KILLABLE|TASK_FREEZABLE_UNSAFE); 40 schedule_timeout(NFS_JUKEBOX_RETRY_TIME); 41 res = -ERESTARTSYS; 42 } while (!fatal_signal_pending(current) && !nfs_current_task_exiting()); 43 return res; 44 } 45 46 #define rpc_call_sync(clnt, msg, flags) nfs3_rpc_wrapper(clnt, msg, flags) 47 48 static int 49 nfs3_async_handle_jukebox(struct rpc_task *task, struct inode *inode) 50 { 51 if (task->tk_status != -EJUKEBOX) 52 return 0; 53 nfs_inc_stats(inode, NFSIOS_DELAY); 54 task->tk_status = 0; 55 rpc_restart_call(task); 56 rpc_delay(task, NFS_JUKEBOX_RETRY_TIME); 57 return 1; 58 } 59 60 static int 61 do_proc_get_root(struct rpc_clnt *client, struct nfs_fh *fhandle, 62 struct nfs_fsinfo *info) 63 { 64 struct rpc_message msg = { 65 .rpc_proc = &nfs3_procedures[NFS3PROC_FSINFO], 66 .rpc_argp = fhandle, 67 .rpc_resp = info, 68 }; 69 int status; 70 71 dprintk("%s: call fsinfo\n", __func__); 72 nfs_fattr_init(info->fattr); 73 status = rpc_call_sync(client, &msg, 0); 74 dprintk("%s: reply fsinfo: %d\n", __func__, status); 75 if (status == 0 && !(info->fattr->valid & NFS_ATTR_FATTR)) { 76 msg.rpc_proc = &nfs3_procedures[NFS3PROC_GETATTR]; 77 msg.rpc_resp = info->fattr; 78 status = rpc_call_sync(client, &msg, 0); 79 dprintk("%s: reply getattr: %d\n", __func__, status); 80 } 81 return status; 82 } 83 84 /* 85 * Bare-bones access to getattr: this is for nfs_get_root/nfs_get_sb 86 */ 87 static int 88 nfs3_proc_get_root(struct nfs_server *server, struct nfs_fh *fhandle, 89 struct nfs_fsinfo *info) 90 { 91 int status; 92 93 status = do_proc_get_root(server->client, fhandle, info); 94 if (status && server->nfs_client->cl_rpcclient != server->client) 95 status = do_proc_get_root(server->nfs_client->cl_rpcclient, fhandle, info); 96 return status; 97 } 98 99 /* 100 * One function for each procedure in the NFS protocol. 101 */ 102 static int 103 nfs3_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, 104 struct nfs_fattr *fattr, struct inode *inode) 105 { 106 struct rpc_message msg = { 107 .rpc_proc = &nfs3_procedures[NFS3PROC_GETATTR], 108 .rpc_argp = fhandle, 109 .rpc_resp = fattr, 110 }; 111 int status; 112 unsigned short task_flags = 0; 113 114 /* Is this is an attribute revalidation, subject to softreval? */ 115 if (inode && (server->flags & NFS_MOUNT_SOFTREVAL)) 116 task_flags |= RPC_TASK_TIMEOUT; 117 118 dprintk("NFS call getattr\n"); 119 nfs_fattr_init(fattr); 120 status = rpc_call_sync(server->client, &msg, task_flags); 121 dprintk("NFS reply getattr: %d\n", status); 122 return status; 123 } 124 125 static int 126 nfs3_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr, 127 struct iattr *sattr) 128 { 129 struct inode *inode = d_inode(dentry); 130 struct nfs3_sattrargs arg = { 131 .fh = NFS_FH(inode), 132 .sattr = sattr, 133 }; 134 struct rpc_message msg = { 135 .rpc_proc = &nfs3_procedures[NFS3PROC_SETATTR], 136 .rpc_argp = &arg, 137 .rpc_resp = fattr, 138 }; 139 int status; 140 141 dprintk("NFS call setattr\n"); 142 if (sattr->ia_valid & ATTR_FILE) 143 msg.rpc_cred = nfs_file_cred(sattr->ia_file); 144 nfs_fattr_init(fattr); 145 status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0); 146 if (status == 0) { 147 nfs_setattr_update_inode(inode, sattr, fattr); 148 if (NFS_I(inode)->cache_validity & NFS_INO_INVALID_ACL) 149 nfs_zap_acl_cache(inode); 150 } 151 dprintk("NFS reply setattr: %d\n", status); 152 return status; 153 } 154 155 static int 156 __nfs3_proc_lookup(struct inode *dir, const char *name, size_t len, 157 struct nfs_fh *fhandle, struct nfs_fattr *fattr, 158 unsigned short task_flags) 159 { 160 struct nfs3_diropargs arg = { 161 .fh = NFS_FH(dir), 162 .name = name, 163 .len = len 164 }; 165 struct nfs3_diropres res = { 166 .fh = fhandle, 167 .fattr = fattr 168 }; 169 struct rpc_message msg = { 170 .rpc_proc = &nfs3_procedures[NFS3PROC_LOOKUP], 171 .rpc_argp = &arg, 172 .rpc_resp = &res, 173 }; 174 int status; 175 176 res.dir_attr = nfs_alloc_fattr(); 177 if (res.dir_attr == NULL) 178 return -ENOMEM; 179 180 nfs_fattr_init(fattr); 181 status = rpc_call_sync(NFS_CLIENT(dir), &msg, task_flags); 182 nfs_refresh_inode(dir, res.dir_attr); 183 if (status >= 0 && !(fattr->valid & NFS_ATTR_FATTR)) { 184 msg.rpc_proc = &nfs3_procedures[NFS3PROC_GETATTR]; 185 msg.rpc_argp = fhandle; 186 msg.rpc_resp = fattr; 187 status = rpc_call_sync(NFS_CLIENT(dir), &msg, task_flags); 188 } 189 nfs_free_fattr(res.dir_attr); 190 dprintk("NFS reply lookup: %d\n", status); 191 return status; 192 } 193 194 static int 195 nfs3_proc_lookup(struct inode *dir, struct dentry *dentry, const struct qstr *name, 196 struct nfs_fh *fhandle, struct nfs_fattr *fattr) 197 { 198 unsigned short task_flags = 0; 199 200 /* Is this is an attribute revalidation, subject to softreval? */ 201 if (nfs_lookup_is_soft_revalidate(dentry)) 202 task_flags |= RPC_TASK_TIMEOUT; 203 204 dprintk("NFS call lookup %pd2\n", dentry); 205 return __nfs3_proc_lookup(dir, name->name, name->len, fhandle, fattr, 206 task_flags); 207 } 208 209 static int nfs3_proc_lookupp(struct inode *inode, struct nfs_fh *fhandle, 210 struct nfs_fattr *fattr) 211 { 212 const char dotdot[] = ".."; 213 const size_t len = strlen(dotdot); 214 unsigned short task_flags = 0; 215 216 if (NFS_SERVER(inode)->flags & NFS_MOUNT_SOFTREVAL) 217 task_flags |= RPC_TASK_TIMEOUT; 218 219 return __nfs3_proc_lookup(inode, dotdot, len, fhandle, fattr, 220 task_flags); 221 } 222 223 static int nfs3_proc_access(struct inode *inode, struct nfs_access_entry *entry, 224 const struct cred *cred) 225 { 226 struct nfs3_accessargs arg = { 227 .fh = NFS_FH(inode), 228 .access = entry->mask, 229 }; 230 struct nfs3_accessres res; 231 struct rpc_message msg = { 232 .rpc_proc = &nfs3_procedures[NFS3PROC_ACCESS], 233 .rpc_argp = &arg, 234 .rpc_resp = &res, 235 .rpc_cred = cred, 236 }; 237 int status = -ENOMEM; 238 239 dprintk("NFS call access\n"); 240 res.fattr = nfs_alloc_fattr(); 241 if (res.fattr == NULL) 242 goto out; 243 244 status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0); 245 nfs_refresh_inode(inode, res.fattr); 246 if (status == 0) 247 nfs_access_set_mask(entry, res.access); 248 nfs_free_fattr(res.fattr); 249 out: 250 dprintk("NFS reply access: %d\n", status); 251 return status; 252 } 253 254 static int nfs3_proc_readlink(struct inode *inode, struct page *page, 255 unsigned int pgbase, unsigned int pglen) 256 { 257 struct nfs_fattr *fattr; 258 struct nfs3_readlinkargs args = { 259 .fh = NFS_FH(inode), 260 .pgbase = pgbase, 261 .pglen = pglen, 262 .pages = &page 263 }; 264 struct rpc_message msg = { 265 .rpc_proc = &nfs3_procedures[NFS3PROC_READLINK], 266 .rpc_argp = &args, 267 }; 268 int status = -ENOMEM; 269 270 dprintk("NFS call readlink\n"); 271 fattr = nfs_alloc_fattr(); 272 if (fattr == NULL) 273 goto out; 274 msg.rpc_resp = fattr; 275 276 status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0); 277 nfs_refresh_inode(inode, fattr); 278 nfs_free_fattr(fattr); 279 out: 280 dprintk("NFS reply readlink: %d\n", status); 281 return status; 282 } 283 284 struct nfs3_createdata { 285 struct rpc_message msg; 286 union { 287 struct nfs3_createargs create; 288 struct nfs3_mkdirargs mkdir; 289 struct nfs3_symlinkargs symlink; 290 struct nfs3_mknodargs mknod; 291 } arg; 292 struct nfs3_diropres res; 293 struct nfs_fh fh; 294 struct nfs_fattr fattr; 295 struct nfs_fattr dir_attr; 296 }; 297 298 static struct nfs3_createdata *nfs3_alloc_createdata(void) 299 { 300 struct nfs3_createdata *data; 301 302 data = kzalloc_obj(*data); 303 if (data != NULL) { 304 data->msg.rpc_argp = &data->arg; 305 data->msg.rpc_resp = &data->res; 306 data->res.fh = &data->fh; 307 data->res.fattr = &data->fattr; 308 data->res.dir_attr = &data->dir_attr; 309 nfs_fattr_init(data->res.fattr); 310 nfs_fattr_init(data->res.dir_attr); 311 } 312 return data; 313 } 314 315 static struct dentry * 316 nfs3_do_create(struct inode *dir, struct dentry *dentry, struct nfs3_createdata *data) 317 { 318 int status; 319 320 status = rpc_call_sync(NFS_CLIENT(dir), &data->msg, 0); 321 nfs_post_op_update_inode(dir, data->res.dir_attr); 322 if (status != 0) 323 return ERR_PTR(status); 324 325 return nfs_add_or_obtain(dentry, data->res.fh, data->res.fattr); 326 } 327 328 static void nfs3_free_createdata(struct nfs3_createdata *data) 329 { 330 kfree(data); 331 } 332 333 /* 334 * Create a regular file. 335 */ 336 static int 337 nfs3_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr, 338 int flags) 339 { 340 struct posix_acl *default_acl, *acl; 341 struct nfs3_createdata *data; 342 struct dentry *d_alias; 343 int status = -ENOMEM; 344 345 dprintk("NFS call create %pd\n", dentry); 346 347 data = nfs3_alloc_createdata(); 348 if (data == NULL) 349 goto out; 350 351 data->msg.rpc_proc = &nfs3_procedures[NFS3PROC_CREATE]; 352 data->arg.create.fh = NFS_FH(dir); 353 data->arg.create.name = dentry->d_name.name; 354 data->arg.create.len = dentry->d_name.len; 355 data->arg.create.sattr = sattr; 356 357 data->arg.create.createmode = NFS3_CREATE_UNCHECKED; 358 if (flags & O_EXCL) { 359 data->arg.create.createmode = NFS3_CREATE_EXCLUSIVE; 360 data->arg.create.verifier[0] = cpu_to_be32(jiffies); 361 data->arg.create.verifier[1] = cpu_to_be32(current->pid); 362 } 363 364 status = posix_acl_create(dir, &sattr->ia_mode, &default_acl, &acl); 365 if (status) 366 goto out; 367 368 for (;;) { 369 d_alias = nfs3_do_create(dir, dentry, data); 370 status = PTR_ERR_OR_ZERO(d_alias); 371 372 if (status != -ENOTSUPP) 373 break; 374 /* If the server doesn't support the exclusive creation 375 * semantics, try again with simple 'guarded' mode. */ 376 switch (data->arg.create.createmode) { 377 case NFS3_CREATE_EXCLUSIVE: 378 data->arg.create.createmode = NFS3_CREATE_GUARDED; 379 break; 380 381 case NFS3_CREATE_GUARDED: 382 data->arg.create.createmode = NFS3_CREATE_UNCHECKED; 383 break; 384 385 case NFS3_CREATE_UNCHECKED: 386 goto out_release_acls; 387 } 388 nfs_fattr_init(data->res.dir_attr); 389 nfs_fattr_init(data->res.fattr); 390 } 391 392 if (status != 0) 393 goto out_release_acls; 394 395 if (d_alias) { 396 if (d_is_dir(d_alias)) { 397 status = -EISDIR; 398 goto out_dput; 399 } 400 dentry = d_alias; 401 } 402 403 /* When we created the file with exclusive semantics, make 404 * sure we set the attributes afterwards. */ 405 if (data->arg.create.createmode == NFS3_CREATE_EXCLUSIVE) { 406 dprintk("NFS call setattr (post-create)\n"); 407 408 if (!(sattr->ia_valid & ATTR_ATIME_SET)) 409 sattr->ia_valid |= ATTR_ATIME; 410 if (!(sattr->ia_valid & ATTR_MTIME_SET)) 411 sattr->ia_valid |= ATTR_MTIME; 412 413 /* Note: we could use a guarded setattr here, but I'm 414 * not sure this buys us anything (and I'd have 415 * to revamp the NFSv3 XDR code) */ 416 status = nfs3_proc_setattr(dentry, data->res.fattr, sattr); 417 nfs_post_op_update_inode(d_inode(dentry), data->res.fattr); 418 dprintk("NFS reply setattr (post-create): %d\n", status); 419 if (status != 0) 420 goto out_dput; 421 } 422 423 status = nfs3_proc_setacls(d_inode(dentry), acl, default_acl); 424 425 out_dput: 426 dput(d_alias); 427 out_release_acls: 428 posix_acl_release(acl); 429 posix_acl_release(default_acl); 430 out: 431 nfs3_free_createdata(data); 432 dprintk("NFS reply create: %d\n", status); 433 return status; 434 } 435 436 static int 437 nfs3_proc_remove(struct inode *dir, struct dentry *dentry) 438 { 439 struct nfs_removeargs arg = { 440 .fh = NFS_FH(dir), 441 .name = dentry->d_name, 442 }; 443 struct nfs_removeres res; 444 struct rpc_message msg = { 445 .rpc_proc = &nfs3_procedures[NFS3PROC_REMOVE], 446 .rpc_argp = &arg, 447 .rpc_resp = &res, 448 }; 449 int status = -ENOMEM; 450 451 dprintk("NFS call remove %pd2\n", dentry); 452 res.dir_attr = nfs_alloc_fattr(); 453 if (res.dir_attr == NULL) 454 goto out; 455 456 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 457 nfs_post_op_update_inode(dir, res.dir_attr); 458 nfs_free_fattr(res.dir_attr); 459 out: 460 dprintk("NFS reply remove: %d\n", status); 461 return status; 462 } 463 464 static void 465 nfs3_proc_unlink_setup(struct rpc_message *msg, 466 struct dentry *dentry, 467 struct inode *inode) 468 { 469 msg->rpc_proc = &nfs3_procedures[NFS3PROC_REMOVE]; 470 } 471 472 static void nfs3_proc_unlink_rpc_prepare(struct rpc_task *task, struct nfs_unlinkdata *data) 473 { 474 rpc_call_start(task); 475 } 476 477 static int 478 nfs3_proc_unlink_done(struct rpc_task *task, struct inode *dir) 479 { 480 struct nfs_removeres *res; 481 if (nfs3_async_handle_jukebox(task, dir)) 482 return 0; 483 res = task->tk_msg.rpc_resp; 484 nfs_post_op_update_inode(dir, res->dir_attr); 485 return 1; 486 } 487 488 static void 489 nfs3_proc_rename_setup(struct rpc_message *msg, 490 struct dentry *old_dentry, 491 struct dentry *new_dentry, 492 struct inode *same_parent) 493 { 494 msg->rpc_proc = &nfs3_procedures[NFS3PROC_RENAME]; 495 } 496 497 static void nfs3_proc_rename_rpc_prepare(struct rpc_task *task, struct nfs_renamedata *data) 498 { 499 rpc_call_start(task); 500 } 501 502 static int 503 nfs3_proc_rename_done(struct rpc_task *task, struct inode *old_dir, 504 struct inode *new_dir) 505 { 506 struct nfs_renameres *res; 507 508 if (nfs3_async_handle_jukebox(task, old_dir)) 509 return 0; 510 res = task->tk_msg.rpc_resp; 511 512 nfs_post_op_update_inode(old_dir, res->old_fattr); 513 nfs_post_op_update_inode(new_dir, res->new_fattr); 514 return 1; 515 } 516 517 static int 518 nfs3_proc_link(struct inode *inode, struct inode *dir, const struct qstr *name) 519 { 520 struct nfs3_linkargs arg = { 521 .fromfh = NFS_FH(inode), 522 .tofh = NFS_FH(dir), 523 .toname = name->name, 524 .tolen = name->len 525 }; 526 struct nfs3_linkres res; 527 struct rpc_message msg = { 528 .rpc_proc = &nfs3_procedures[NFS3PROC_LINK], 529 .rpc_argp = &arg, 530 .rpc_resp = &res, 531 }; 532 int status = -ENOMEM; 533 534 dprintk("NFS call link %s\n", name->name); 535 res.fattr = nfs_alloc_fattr(); 536 res.dir_attr = nfs_alloc_fattr(); 537 if (res.fattr == NULL || res.dir_attr == NULL) 538 goto out; 539 540 status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0); 541 nfs_post_op_update_inode(dir, res.dir_attr); 542 nfs_post_op_update_inode(inode, res.fattr); 543 out: 544 nfs_free_fattr(res.dir_attr); 545 nfs_free_fattr(res.fattr); 546 dprintk("NFS reply link: %d\n", status); 547 return status; 548 } 549 550 static int 551 nfs3_proc_symlink(struct inode *dir, struct dentry *dentry, struct folio *folio, 552 unsigned int len, struct iattr *sattr) 553 { 554 struct page *page = &folio->page; 555 struct nfs3_createdata *data; 556 struct dentry *d_alias; 557 int status = -ENOMEM; 558 559 if (len > NFS3_MAXPATHLEN) 560 return -ENAMETOOLONG; 561 562 dprintk("NFS call symlink %pd\n", dentry); 563 564 data = nfs3_alloc_createdata(); 565 if (data == NULL) 566 goto out; 567 data->msg.rpc_proc = &nfs3_procedures[NFS3PROC_SYMLINK]; 568 data->arg.symlink.fromfh = NFS_FH(dir); 569 data->arg.symlink.fromname = dentry->d_name.name; 570 data->arg.symlink.fromlen = dentry->d_name.len; 571 data->arg.symlink.pages = &page; 572 data->arg.symlink.pathlen = len; 573 data->arg.symlink.sattr = sattr; 574 575 d_alias = nfs3_do_create(dir, dentry, data); 576 status = PTR_ERR_OR_ZERO(d_alias); 577 578 if (status == 0) 579 dput(d_alias); 580 581 nfs3_free_createdata(data); 582 out: 583 dprintk("NFS reply symlink: %d\n", status); 584 return status; 585 } 586 587 static struct dentry * 588 nfs3_proc_mkdir(struct inode *dir, struct dentry *dentry, struct iattr *sattr) 589 { 590 struct posix_acl *default_acl, *acl; 591 struct nfs3_createdata *data; 592 struct dentry *ret = ERR_PTR(-ENOMEM); 593 int status; 594 595 dprintk("NFS call mkdir %pd\n", dentry); 596 597 data = nfs3_alloc_createdata(); 598 if (data == NULL) 599 goto out; 600 601 ret = ERR_PTR(posix_acl_create(dir, &sattr->ia_mode, 602 &default_acl, &acl)); 603 if (IS_ERR(ret)) 604 goto out; 605 606 data->msg.rpc_proc = &nfs3_procedures[NFS3PROC_MKDIR]; 607 data->arg.mkdir.fh = NFS_FH(dir); 608 data->arg.mkdir.name = dentry->d_name.name; 609 data->arg.mkdir.len = dentry->d_name.len; 610 data->arg.mkdir.sattr = sattr; 611 612 ret = nfs3_do_create(dir, dentry, data); 613 614 if (IS_ERR(ret)) 615 goto out_release_acls; 616 617 if (ret) 618 dentry = ret; 619 620 status = nfs3_proc_setacls(d_inode(dentry), acl, default_acl); 621 if (status) { 622 dput(ret); 623 ret = ERR_PTR(status); 624 } 625 626 out_release_acls: 627 posix_acl_release(acl); 628 posix_acl_release(default_acl); 629 out: 630 nfs3_free_createdata(data); 631 dprintk("NFS reply mkdir: %d\n", PTR_ERR_OR_ZERO(ret)); 632 return ret; 633 } 634 635 static int 636 nfs3_proc_rmdir(struct inode *dir, const struct qstr *name) 637 { 638 struct nfs_fattr *dir_attr; 639 struct nfs3_diropargs arg = { 640 .fh = NFS_FH(dir), 641 .name = name->name, 642 .len = name->len 643 }; 644 struct rpc_message msg = { 645 .rpc_proc = &nfs3_procedures[NFS3PROC_RMDIR], 646 .rpc_argp = &arg, 647 }; 648 int status = -ENOMEM; 649 650 dprintk("NFS call rmdir %s\n", name->name); 651 dir_attr = nfs_alloc_fattr(); 652 if (dir_attr == NULL) 653 goto out; 654 655 msg.rpc_resp = dir_attr; 656 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 657 nfs_post_op_update_inode(dir, dir_attr); 658 nfs_free_fattr(dir_attr); 659 out: 660 dprintk("NFS reply rmdir: %d\n", status); 661 return status; 662 } 663 664 /* 665 * The READDIR implementation is somewhat hackish - we pass the user buffer 666 * to the encode function, which installs it in the receive iovec. 667 * The decode function itself doesn't perform any decoding, it just makes 668 * sure the reply is syntactically correct. 669 * 670 * Also note that this implementation handles both plain readdir and 671 * readdirplus. 672 */ 673 static int nfs3_proc_readdir(struct nfs_readdir_arg *nr_arg, 674 struct nfs_readdir_res *nr_res) 675 { 676 struct inode *dir = d_inode(nr_arg->dentry); 677 struct nfs3_readdirargs arg = { 678 .fh = NFS_FH(dir), 679 .cookie = nr_arg->cookie, 680 .plus = nr_arg->plus, 681 .count = nr_arg->page_len, 682 .pages = nr_arg->pages 683 }; 684 struct nfs3_readdirres res = { 685 .verf = nr_res->verf, 686 .plus = nr_arg->plus, 687 }; 688 struct rpc_message msg = { 689 .rpc_proc = &nfs3_procedures[NFS3PROC_READDIR], 690 .rpc_argp = &arg, 691 .rpc_resp = &res, 692 .rpc_cred = nr_arg->cred, 693 }; 694 int status = -ENOMEM; 695 696 if (nr_arg->plus) 697 msg.rpc_proc = &nfs3_procedures[NFS3PROC_READDIRPLUS]; 698 if (arg.cookie) 699 memcpy(arg.verf, nr_arg->verf, sizeof(arg.verf)); 700 701 dprintk("NFS call readdir%s %llu\n", nr_arg->plus ? "plus" : "", 702 (unsigned long long)nr_arg->cookie); 703 704 res.dir_attr = nfs_alloc_fattr(); 705 if (res.dir_attr == NULL) 706 goto out; 707 708 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 709 710 nfs_invalidate_atime(dir); 711 nfs_refresh_inode(dir, res.dir_attr); 712 713 nfs_free_fattr(res.dir_attr); 714 out: 715 dprintk("NFS reply readdir%s: %d\n", nr_arg->plus ? "plus" : "", 716 status); 717 return status; 718 } 719 720 static int 721 nfs3_proc_mknod(struct inode *dir, struct dentry *dentry, struct iattr *sattr, 722 dev_t rdev) 723 { 724 struct posix_acl *default_acl, *acl; 725 struct nfs3_createdata *data; 726 struct dentry *d_alias; 727 int status = -ENOMEM; 728 729 dprintk("NFS call mknod %pd %u:%u\n", dentry, 730 MAJOR(rdev), MINOR(rdev)); 731 732 data = nfs3_alloc_createdata(); 733 if (data == NULL) 734 goto out; 735 736 status = posix_acl_create(dir, &sattr->ia_mode, &default_acl, &acl); 737 if (status) 738 goto out; 739 740 data->msg.rpc_proc = &nfs3_procedures[NFS3PROC_MKNOD]; 741 data->arg.mknod.fh = NFS_FH(dir); 742 data->arg.mknod.name = dentry->d_name.name; 743 data->arg.mknod.len = dentry->d_name.len; 744 data->arg.mknod.sattr = sattr; 745 data->arg.mknod.rdev = rdev; 746 747 switch (sattr->ia_mode & S_IFMT) { 748 case S_IFBLK: 749 data->arg.mknod.type = NF3BLK; 750 break; 751 case S_IFCHR: 752 data->arg.mknod.type = NF3CHR; 753 break; 754 case S_IFIFO: 755 data->arg.mknod.type = NF3FIFO; 756 break; 757 case S_IFSOCK: 758 data->arg.mknod.type = NF3SOCK; 759 break; 760 default: 761 status = -EINVAL; 762 goto out_release_acls; 763 } 764 765 d_alias = nfs3_do_create(dir, dentry, data); 766 status = PTR_ERR_OR_ZERO(d_alias); 767 if (status != 0) 768 goto out_release_acls; 769 770 if (d_alias) 771 dentry = d_alias; 772 773 status = nfs3_proc_setacls(d_inode(dentry), acl, default_acl); 774 775 dput(d_alias); 776 out_release_acls: 777 posix_acl_release(acl); 778 posix_acl_release(default_acl); 779 out: 780 nfs3_free_createdata(data); 781 dprintk("NFS reply mknod: %d\n", status); 782 return status; 783 } 784 785 static int 786 nfs3_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle, 787 struct nfs_fsstat *stat) 788 { 789 struct rpc_message msg = { 790 .rpc_proc = &nfs3_procedures[NFS3PROC_FSSTAT], 791 .rpc_argp = fhandle, 792 .rpc_resp = stat, 793 }; 794 int status; 795 796 dprintk("NFS call fsstat\n"); 797 nfs_fattr_init(stat->fattr); 798 status = rpc_call_sync(server->client, &msg, 0); 799 dprintk("NFS reply fsstat: %d\n", status); 800 return status; 801 } 802 803 static int 804 do_proc_fsinfo(struct rpc_clnt *client, struct nfs_fh *fhandle, 805 struct nfs_fsinfo *info) 806 { 807 struct rpc_message msg = { 808 .rpc_proc = &nfs3_procedures[NFS3PROC_FSINFO], 809 .rpc_argp = fhandle, 810 .rpc_resp = info, 811 }; 812 int status; 813 814 dprintk("NFS call fsinfo\n"); 815 nfs_fattr_init(info->fattr); 816 status = rpc_call_sync(client, &msg, 0); 817 dprintk("NFS reply fsinfo: %d\n", status); 818 return status; 819 } 820 821 /* 822 * Bare-bones access to fsinfo: this is for nfs_get_root/nfs_get_sb via 823 * nfs_create_server 824 */ 825 static int 826 nfs3_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, 827 struct nfs_fsinfo *info) 828 { 829 int status; 830 831 status = do_proc_fsinfo(server->client, fhandle, info); 832 if (status && server->nfs_client->cl_rpcclient != server->client) 833 status = do_proc_fsinfo(server->nfs_client->cl_rpcclient, fhandle, info); 834 return status; 835 } 836 837 static int 838 nfs3_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle, 839 struct nfs_pathconf *info) 840 { 841 struct rpc_message msg = { 842 .rpc_proc = &nfs3_procedures[NFS3PROC_PATHCONF], 843 .rpc_argp = fhandle, 844 .rpc_resp = info, 845 }; 846 int status; 847 848 dprintk("NFS call pathconf\n"); 849 nfs_fattr_init(info->fattr); 850 status = rpc_call_sync(server->client, &msg, 0); 851 dprintk("NFS reply pathconf: %d\n", status); 852 return status; 853 } 854 855 #if IS_ENABLED(CONFIG_NFS_LOCALIO) 856 857 static unsigned nfs3_localio_probe_throttle __read_mostly = 0; 858 module_param(nfs3_localio_probe_throttle, uint, 0644); 859 MODULE_PARM_DESC(nfs3_localio_probe_throttle, 860 "Probe for NFSv3 LOCALIO every N IO requests. Must be power-of-2, defaults to 0 (probing disabled)."); 861 862 static void nfs3_localio_probe(struct nfs_server *server) 863 { 864 struct nfs_client *clp = server->nfs_client; 865 866 /* Throttled to reduce nfs_local_probe_async() frequency */ 867 if (!nfs3_localio_probe_throttle || nfs_server_is_local(clp)) 868 return; 869 870 /* 871 * Try (re)enabling LOCALIO if isn't enabled -- admin deems 872 * it worthwhile to periodically check if LOCALIO possible by 873 * setting the 'nfs3_localio_probe_throttle' module parameter. 874 * 875 * This is useful if LOCALIO was previously enabled, but was 876 * disabled due to server restart, and IO has successfully 877 * completed in terms of normal RPC. 878 */ 879 if ((clp->cl_uuid.nfs3_localio_probe_count++ & 880 (nfs3_localio_probe_throttle - 1)) == 0) { 881 if (!nfs_server_is_local(clp)) 882 nfs_local_probe_async(clp); 883 } 884 } 885 886 #else 887 static void nfs3_localio_probe(struct nfs_server *server) {} 888 #endif 889 890 static int nfs3_read_done(struct rpc_task *task, struct nfs_pgio_header *hdr) 891 { 892 struct inode *inode = hdr->inode; 893 struct nfs_server *server = NFS_SERVER(inode); 894 895 if (hdr->pgio_done_cb != NULL) 896 return hdr->pgio_done_cb(task, hdr); 897 898 if (nfs3_async_handle_jukebox(task, inode)) 899 return -EAGAIN; 900 901 if (task->tk_status >= 0) { 902 if (!server->read_hdrsize) 903 cmpxchg(&server->read_hdrsize, 0, hdr->res.replen); 904 nfs3_localio_probe(server); 905 } 906 907 nfs_invalidate_atime(inode); 908 nfs_refresh_inode(inode, &hdr->fattr); 909 return 0; 910 } 911 912 static void nfs3_proc_read_setup(struct nfs_pgio_header *hdr, 913 struct rpc_message *msg) 914 { 915 msg->rpc_proc = &nfs3_procedures[NFS3PROC_READ]; 916 hdr->args.replen = NFS_SERVER(hdr->inode)->read_hdrsize; 917 } 918 919 static int nfs3_proc_pgio_rpc_prepare(struct rpc_task *task, 920 struct nfs_pgio_header *hdr) 921 { 922 rpc_call_start(task); 923 return 0; 924 } 925 926 static int nfs3_write_done(struct rpc_task *task, struct nfs_pgio_header *hdr) 927 { 928 struct inode *inode = hdr->inode; 929 930 if (hdr->pgio_done_cb != NULL) 931 return hdr->pgio_done_cb(task, hdr); 932 933 if (nfs3_async_handle_jukebox(task, inode)) 934 return -EAGAIN; 935 if (task->tk_status >= 0) { 936 nfs_writeback_update_inode(hdr); 937 nfs3_localio_probe(NFS_SERVER(inode)); 938 } 939 return 0; 940 } 941 942 static void nfs3_proc_write_setup(struct nfs_pgio_header *hdr, 943 struct rpc_message *msg, 944 struct rpc_clnt **clnt) 945 { 946 msg->rpc_proc = &nfs3_procedures[NFS3PROC_WRITE]; 947 } 948 949 static void nfs3_proc_commit_rpc_prepare(struct rpc_task *task, struct nfs_commit_data *data) 950 { 951 rpc_call_start(task); 952 } 953 954 static int nfs3_commit_done(struct rpc_task *task, struct nfs_commit_data *data) 955 { 956 if (data->commit_done_cb != NULL) 957 return data->commit_done_cb(task, data); 958 959 if (nfs3_async_handle_jukebox(task, data->inode)) 960 return -EAGAIN; 961 nfs_refresh_inode(data->inode, data->res.fattr); 962 return 0; 963 } 964 965 static void nfs3_proc_commit_setup(struct nfs_commit_data *data, struct rpc_message *msg, 966 struct rpc_clnt **clnt) 967 { 968 msg->rpc_proc = &nfs3_procedures[NFS3PROC_COMMIT]; 969 } 970 971 static void nfs3_nlm_alloc_call(void *data) 972 { 973 struct nfs_lock_context *l_ctx = data; 974 if (l_ctx && test_bit(NFS_CONTEXT_UNLOCK, &l_ctx->open_context->flags)) { 975 get_nfs_open_context(l_ctx->open_context); 976 nfs_get_lock_context(l_ctx->open_context); 977 } 978 } 979 980 static bool nfs3_nlm_unlock_prepare(struct rpc_task *task, void *data) 981 { 982 struct nfs_lock_context *l_ctx = data; 983 if (l_ctx && test_bit(NFS_CONTEXT_UNLOCK, &l_ctx->open_context->flags)) 984 return nfs_async_iocounter_wait(task, l_ctx); 985 return false; 986 987 } 988 989 static void nfs3_nlm_release_call(void *data) 990 { 991 struct nfs_lock_context *l_ctx = data; 992 struct nfs_open_context *ctx; 993 if (l_ctx && test_bit(NFS_CONTEXT_UNLOCK, &l_ctx->open_context->flags)) { 994 ctx = l_ctx->open_context; 995 nfs_put_lock_context(l_ctx); 996 put_nfs_open_context(ctx); 997 } 998 } 999 1000 static const struct nlmclnt_operations nlmclnt_fl_close_lock_ops = { 1001 .nlmclnt_alloc_call = nfs3_nlm_alloc_call, 1002 .nlmclnt_unlock_prepare = nfs3_nlm_unlock_prepare, 1003 .nlmclnt_release_call = nfs3_nlm_release_call, 1004 }; 1005 1006 static int 1007 nfs3_proc_lock(struct file *filp, int cmd, struct file_lock *fl) 1008 { 1009 struct inode *inode = file_inode(filp); 1010 struct nfs_lock_context *l_ctx = NULL; 1011 struct nfs_open_context *ctx = nfs_file_open_context(filp); 1012 int status; 1013 1014 if (fl->c.flc_flags & FL_CLOSE) { 1015 l_ctx = nfs_get_lock_context(ctx); 1016 if (IS_ERR(l_ctx)) 1017 l_ctx = NULL; 1018 else 1019 set_bit(NFS_CONTEXT_UNLOCK, &ctx->flags); 1020 } 1021 1022 status = nlmclnt_proc(NFS_SERVER(inode)->nlm_host, cmd, fl, l_ctx); 1023 1024 if (l_ctx) 1025 nfs_put_lock_context(l_ctx); 1026 1027 return status; 1028 } 1029 1030 static int nfs3_have_delegation(struct inode *inode, fmode_t type, int flags) 1031 { 1032 return 0; 1033 } 1034 1035 static void nfs3_return_delegation(struct inode *inode) 1036 { 1037 if (S_ISREG(inode->i_mode)) 1038 nfs_wb_all(inode); 1039 } 1040 1041 static const struct inode_operations nfs3_dir_inode_operations = { 1042 .create = nfs_create, 1043 .atomic_open = nfs_atomic_open_v23, 1044 .lookup = nfs_lookup, 1045 .link = nfs_link, 1046 .unlink = nfs_unlink, 1047 .symlink = nfs_symlink, 1048 .mkdir = nfs_mkdir, 1049 .rmdir = nfs_rmdir, 1050 .mknod = nfs_mknod, 1051 .rename = nfs_rename, 1052 .permission = nfs_permission, 1053 .getattr = nfs_getattr, 1054 .setattr = nfs_setattr, 1055 #ifdef CONFIG_NFS_V3_ACL 1056 .listxattr = nfs3_listxattr, 1057 .get_inode_acl = nfs3_get_acl, 1058 .set_acl = nfs3_set_acl, 1059 #endif 1060 }; 1061 1062 static const struct inode_operations nfs3_file_inode_operations = { 1063 .permission = nfs_permission, 1064 .getattr = nfs_getattr, 1065 .setattr = nfs_setattr, 1066 #ifdef CONFIG_NFS_V3_ACL 1067 .listxattr = nfs3_listxattr, 1068 .get_inode_acl = nfs3_get_acl, 1069 .set_acl = nfs3_set_acl, 1070 #endif 1071 }; 1072 1073 const struct nfs_rpc_ops nfs_v3_clientops = { 1074 .version = 3, /* protocol version */ 1075 .dentry_ops = &nfs_dentry_operations, 1076 .dir_inode_ops = &nfs3_dir_inode_operations, 1077 .file_inode_ops = &nfs3_file_inode_operations, 1078 .file_ops = &nfs_file_operations, 1079 .nlmclnt_ops = &nlmclnt_fl_close_lock_ops, 1080 .getroot = nfs3_proc_get_root, 1081 .submount = nfs_submount, 1082 .try_get_tree = nfs_try_get_tree, 1083 .getattr = nfs3_proc_getattr, 1084 .setattr = nfs3_proc_setattr, 1085 .lookup = nfs3_proc_lookup, 1086 .lookupp = nfs3_proc_lookupp, 1087 .access = nfs3_proc_access, 1088 .readlink = nfs3_proc_readlink, 1089 .create = nfs3_proc_create, 1090 .remove = nfs3_proc_remove, 1091 .unlink_setup = nfs3_proc_unlink_setup, 1092 .unlink_rpc_prepare = nfs3_proc_unlink_rpc_prepare, 1093 .unlink_done = nfs3_proc_unlink_done, 1094 .rename_setup = nfs3_proc_rename_setup, 1095 .rename_rpc_prepare = nfs3_proc_rename_rpc_prepare, 1096 .rename_done = nfs3_proc_rename_done, 1097 .link = nfs3_proc_link, 1098 .symlink = nfs3_proc_symlink, 1099 .mkdir = nfs3_proc_mkdir, 1100 .rmdir = nfs3_proc_rmdir, 1101 .readdir = nfs3_proc_readdir, 1102 .mknod = nfs3_proc_mknod, 1103 .statfs = nfs3_proc_statfs, 1104 .fsinfo = nfs3_proc_fsinfo, 1105 .pathconf = nfs3_proc_pathconf, 1106 .decode_dirent = nfs3_decode_dirent, 1107 .pgio_rpc_prepare = nfs3_proc_pgio_rpc_prepare, 1108 .read_setup = nfs3_proc_read_setup, 1109 .read_done = nfs3_read_done, 1110 .write_setup = nfs3_proc_write_setup, 1111 .write_done = nfs3_write_done, 1112 .commit_setup = nfs3_proc_commit_setup, 1113 .commit_rpc_prepare = nfs3_proc_commit_rpc_prepare, 1114 .commit_done = nfs3_commit_done, 1115 .lock = nfs3_proc_lock, 1116 .clear_acl_cache = forget_all_cached_acls, 1117 .close_context = nfs_close_context, 1118 .have_delegation = nfs3_have_delegation, 1119 .return_delegation = nfs3_return_delegation, 1120 .alloc_client = nfs_alloc_client, 1121 .init_client = nfs_init_client, 1122 .free_client = nfs_free_client, 1123 .create_server = nfs3_create_server, 1124 .clone_server = nfs3_clone_server, 1125 }; 1126