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)); 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, 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, dentry->d_name.name, 206 dentry->d_name.len, fhandle, fattr, 207 task_flags); 208 } 209 210 static int nfs3_proc_lookupp(struct inode *inode, struct nfs_fh *fhandle, 211 struct nfs_fattr *fattr) 212 { 213 const char dotdot[] = ".."; 214 const size_t len = strlen(dotdot); 215 unsigned short task_flags = 0; 216 217 if (NFS_SERVER(inode)->flags & NFS_MOUNT_SOFTREVAL) 218 task_flags |= RPC_TASK_TIMEOUT; 219 220 return __nfs3_proc_lookup(inode, dotdot, len, fhandle, fattr, 221 task_flags); 222 } 223 224 static int nfs3_proc_access(struct inode *inode, struct nfs_access_entry *entry, 225 const struct cred *cred) 226 { 227 struct nfs3_accessargs arg = { 228 .fh = NFS_FH(inode), 229 .access = entry->mask, 230 }; 231 struct nfs3_accessres res; 232 struct rpc_message msg = { 233 .rpc_proc = &nfs3_procedures[NFS3PROC_ACCESS], 234 .rpc_argp = &arg, 235 .rpc_resp = &res, 236 .rpc_cred = cred, 237 }; 238 int status = -ENOMEM; 239 240 dprintk("NFS call access\n"); 241 res.fattr = nfs_alloc_fattr(); 242 if (res.fattr == NULL) 243 goto out; 244 245 status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0); 246 nfs_refresh_inode(inode, res.fattr); 247 if (status == 0) 248 nfs_access_set_mask(entry, res.access); 249 nfs_free_fattr(res.fattr); 250 out: 251 dprintk("NFS reply access: %d\n", status); 252 return status; 253 } 254 255 static int nfs3_proc_readlink(struct inode *inode, struct page *page, 256 unsigned int pgbase, unsigned int pglen) 257 { 258 struct nfs_fattr *fattr; 259 struct nfs3_readlinkargs args = { 260 .fh = NFS_FH(inode), 261 .pgbase = pgbase, 262 .pglen = pglen, 263 .pages = &page 264 }; 265 struct rpc_message msg = { 266 .rpc_proc = &nfs3_procedures[NFS3PROC_READLINK], 267 .rpc_argp = &args, 268 }; 269 int status = -ENOMEM; 270 271 dprintk("NFS call readlink\n"); 272 fattr = nfs_alloc_fattr(); 273 if (fattr == NULL) 274 goto out; 275 msg.rpc_resp = fattr; 276 277 status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0); 278 nfs_refresh_inode(inode, fattr); 279 nfs_free_fattr(fattr); 280 out: 281 dprintk("NFS reply readlink: %d\n", status); 282 return status; 283 } 284 285 struct nfs3_createdata { 286 struct rpc_message msg; 287 union { 288 struct nfs3_createargs create; 289 struct nfs3_mkdirargs mkdir; 290 struct nfs3_symlinkargs symlink; 291 struct nfs3_mknodargs mknod; 292 } arg; 293 struct nfs3_diropres res; 294 struct nfs_fh fh; 295 struct nfs_fattr fattr; 296 struct nfs_fattr dir_attr; 297 }; 298 299 static struct nfs3_createdata *nfs3_alloc_createdata(void) 300 { 301 struct nfs3_createdata *data; 302 303 data = kzalloc(sizeof(*data), GFP_KERNEL); 304 if (data != NULL) { 305 data->msg.rpc_argp = &data->arg; 306 data->msg.rpc_resp = &data->res; 307 data->res.fh = &data->fh; 308 data->res.fattr = &data->fattr; 309 data->res.dir_attr = &data->dir_attr; 310 nfs_fattr_init(data->res.fattr); 311 nfs_fattr_init(data->res.dir_attr); 312 } 313 return data; 314 } 315 316 static struct dentry * 317 nfs3_do_create(struct inode *dir, struct dentry *dentry, struct nfs3_createdata *data) 318 { 319 int status; 320 321 status = rpc_call_sync(NFS_CLIENT(dir), &data->msg, 0); 322 nfs_post_op_update_inode(dir, data->res.dir_attr); 323 if (status != 0) 324 return ERR_PTR(status); 325 326 return nfs_add_or_obtain(dentry, data->res.fh, data->res.fattr); 327 } 328 329 static void nfs3_free_createdata(struct nfs3_createdata *data) 330 { 331 kfree(data); 332 } 333 334 /* 335 * Create a regular file. 336 */ 337 static int 338 nfs3_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr, 339 int flags) 340 { 341 struct posix_acl *default_acl, *acl; 342 struct nfs3_createdata *data; 343 struct dentry *d_alias; 344 int status = -ENOMEM; 345 346 dprintk("NFS call create %pd\n", dentry); 347 348 data = nfs3_alloc_createdata(); 349 if (data == NULL) 350 goto out; 351 352 data->msg.rpc_proc = &nfs3_procedures[NFS3PROC_CREATE]; 353 data->arg.create.fh = NFS_FH(dir); 354 data->arg.create.name = dentry->d_name.name; 355 data->arg.create.len = dentry->d_name.len; 356 data->arg.create.sattr = sattr; 357 358 data->arg.create.createmode = NFS3_CREATE_UNCHECKED; 359 if (flags & O_EXCL) { 360 data->arg.create.createmode = NFS3_CREATE_EXCLUSIVE; 361 data->arg.create.verifier[0] = cpu_to_be32(jiffies); 362 data->arg.create.verifier[1] = cpu_to_be32(current->pid); 363 } 364 365 status = posix_acl_create(dir, &sattr->ia_mode, &default_acl, &acl); 366 if (status) 367 goto out; 368 369 for (;;) { 370 d_alias = nfs3_do_create(dir, dentry, data); 371 status = PTR_ERR_OR_ZERO(d_alias); 372 373 if (status != -ENOTSUPP) 374 break; 375 /* If the server doesn't support the exclusive creation 376 * semantics, try again with simple 'guarded' mode. */ 377 switch (data->arg.create.createmode) { 378 case NFS3_CREATE_EXCLUSIVE: 379 data->arg.create.createmode = NFS3_CREATE_GUARDED; 380 break; 381 382 case NFS3_CREATE_GUARDED: 383 data->arg.create.createmode = NFS3_CREATE_UNCHECKED; 384 break; 385 386 case NFS3_CREATE_UNCHECKED: 387 goto out_release_acls; 388 } 389 nfs_fattr_init(data->res.dir_attr); 390 nfs_fattr_init(data->res.fattr); 391 } 392 393 if (status != 0) 394 goto out_release_acls; 395 396 if (d_alias) 397 dentry = d_alias; 398 399 /* When we created the file with exclusive semantics, make 400 * sure we set the attributes afterwards. */ 401 if (data->arg.create.createmode == NFS3_CREATE_EXCLUSIVE) { 402 dprintk("NFS call setattr (post-create)\n"); 403 404 if (!(sattr->ia_valid & ATTR_ATIME_SET)) 405 sattr->ia_valid |= ATTR_ATIME; 406 if (!(sattr->ia_valid & ATTR_MTIME_SET)) 407 sattr->ia_valid |= ATTR_MTIME; 408 409 /* Note: we could use a guarded setattr here, but I'm 410 * not sure this buys us anything (and I'd have 411 * to revamp the NFSv3 XDR code) */ 412 status = nfs3_proc_setattr(dentry, data->res.fattr, sattr); 413 nfs_post_op_update_inode(d_inode(dentry), data->res.fattr); 414 dprintk("NFS reply setattr (post-create): %d\n", status); 415 if (status != 0) 416 goto out_dput; 417 } 418 419 status = nfs3_proc_setacls(d_inode(dentry), acl, default_acl); 420 421 out_dput: 422 dput(d_alias); 423 out_release_acls: 424 posix_acl_release(acl); 425 posix_acl_release(default_acl); 426 out: 427 nfs3_free_createdata(data); 428 dprintk("NFS reply create: %d\n", status); 429 return status; 430 } 431 432 static int 433 nfs3_proc_remove(struct inode *dir, struct dentry *dentry) 434 { 435 struct nfs_removeargs arg = { 436 .fh = NFS_FH(dir), 437 .name = dentry->d_name, 438 }; 439 struct nfs_removeres res; 440 struct rpc_message msg = { 441 .rpc_proc = &nfs3_procedures[NFS3PROC_REMOVE], 442 .rpc_argp = &arg, 443 .rpc_resp = &res, 444 }; 445 int status = -ENOMEM; 446 447 dprintk("NFS call remove %pd2\n", dentry); 448 res.dir_attr = nfs_alloc_fattr(); 449 if (res.dir_attr == NULL) 450 goto out; 451 452 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 453 nfs_post_op_update_inode(dir, res.dir_attr); 454 nfs_free_fattr(res.dir_attr); 455 out: 456 dprintk("NFS reply remove: %d\n", status); 457 return status; 458 } 459 460 static void 461 nfs3_proc_unlink_setup(struct rpc_message *msg, 462 struct dentry *dentry, 463 struct inode *inode) 464 { 465 msg->rpc_proc = &nfs3_procedures[NFS3PROC_REMOVE]; 466 } 467 468 static void nfs3_proc_unlink_rpc_prepare(struct rpc_task *task, struct nfs_unlinkdata *data) 469 { 470 rpc_call_start(task); 471 } 472 473 static int 474 nfs3_proc_unlink_done(struct rpc_task *task, struct inode *dir) 475 { 476 struct nfs_removeres *res; 477 if (nfs3_async_handle_jukebox(task, dir)) 478 return 0; 479 res = task->tk_msg.rpc_resp; 480 nfs_post_op_update_inode(dir, res->dir_attr); 481 return 1; 482 } 483 484 static void 485 nfs3_proc_rename_setup(struct rpc_message *msg, 486 struct dentry *old_dentry, 487 struct dentry *new_dentry) 488 { 489 msg->rpc_proc = &nfs3_procedures[NFS3PROC_RENAME]; 490 } 491 492 static void nfs3_proc_rename_rpc_prepare(struct rpc_task *task, struct nfs_renamedata *data) 493 { 494 rpc_call_start(task); 495 } 496 497 static int 498 nfs3_proc_rename_done(struct rpc_task *task, struct inode *old_dir, 499 struct inode *new_dir) 500 { 501 struct nfs_renameres *res; 502 503 if (nfs3_async_handle_jukebox(task, old_dir)) 504 return 0; 505 res = task->tk_msg.rpc_resp; 506 507 nfs_post_op_update_inode(old_dir, res->old_fattr); 508 nfs_post_op_update_inode(new_dir, res->new_fattr); 509 return 1; 510 } 511 512 static int 513 nfs3_proc_link(struct inode *inode, struct inode *dir, const struct qstr *name) 514 { 515 struct nfs3_linkargs arg = { 516 .fromfh = NFS_FH(inode), 517 .tofh = NFS_FH(dir), 518 .toname = name->name, 519 .tolen = name->len 520 }; 521 struct nfs3_linkres res; 522 struct rpc_message msg = { 523 .rpc_proc = &nfs3_procedures[NFS3PROC_LINK], 524 .rpc_argp = &arg, 525 .rpc_resp = &res, 526 }; 527 int status = -ENOMEM; 528 529 dprintk("NFS call link %s\n", name->name); 530 res.fattr = nfs_alloc_fattr(); 531 res.dir_attr = nfs_alloc_fattr(); 532 if (res.fattr == NULL || res.dir_attr == NULL) 533 goto out; 534 535 status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0); 536 nfs_post_op_update_inode(dir, res.dir_attr); 537 nfs_post_op_update_inode(inode, res.fattr); 538 out: 539 nfs_free_fattr(res.dir_attr); 540 nfs_free_fattr(res.fattr); 541 dprintk("NFS reply link: %d\n", status); 542 return status; 543 } 544 545 static int 546 nfs3_proc_symlink(struct inode *dir, struct dentry *dentry, struct page *page, 547 unsigned int len, struct iattr *sattr) 548 { 549 struct nfs3_createdata *data; 550 struct dentry *d_alias; 551 int status = -ENOMEM; 552 553 if (len > NFS3_MAXPATHLEN) 554 return -ENAMETOOLONG; 555 556 dprintk("NFS call symlink %pd\n", dentry); 557 558 data = nfs3_alloc_createdata(); 559 if (data == NULL) 560 goto out; 561 data->msg.rpc_proc = &nfs3_procedures[NFS3PROC_SYMLINK]; 562 data->arg.symlink.fromfh = NFS_FH(dir); 563 data->arg.symlink.fromname = dentry->d_name.name; 564 data->arg.symlink.fromlen = dentry->d_name.len; 565 data->arg.symlink.pages = &page; 566 data->arg.symlink.pathlen = len; 567 data->arg.symlink.sattr = sattr; 568 569 d_alias = nfs3_do_create(dir, dentry, data); 570 status = PTR_ERR_OR_ZERO(d_alias); 571 572 if (status == 0) 573 dput(d_alias); 574 575 nfs3_free_createdata(data); 576 out: 577 dprintk("NFS reply symlink: %d\n", status); 578 return status; 579 } 580 581 static int 582 nfs3_proc_mkdir(struct inode *dir, struct dentry *dentry, struct iattr *sattr) 583 { 584 struct posix_acl *default_acl, *acl; 585 struct nfs3_createdata *data; 586 struct dentry *d_alias; 587 int status = -ENOMEM; 588 589 dprintk("NFS call mkdir %pd\n", dentry); 590 591 data = nfs3_alloc_createdata(); 592 if (data == NULL) 593 goto out; 594 595 status = posix_acl_create(dir, &sattr->ia_mode, &default_acl, &acl); 596 if (status) 597 goto out; 598 599 data->msg.rpc_proc = &nfs3_procedures[NFS3PROC_MKDIR]; 600 data->arg.mkdir.fh = NFS_FH(dir); 601 data->arg.mkdir.name = dentry->d_name.name; 602 data->arg.mkdir.len = dentry->d_name.len; 603 data->arg.mkdir.sattr = sattr; 604 605 d_alias = nfs3_do_create(dir, dentry, data); 606 status = PTR_ERR_OR_ZERO(d_alias); 607 608 if (status != 0) 609 goto out_release_acls; 610 611 if (d_alias) 612 dentry = d_alias; 613 614 status = nfs3_proc_setacls(d_inode(dentry), acl, default_acl); 615 616 dput(d_alias); 617 out_release_acls: 618 posix_acl_release(acl); 619 posix_acl_release(default_acl); 620 out: 621 nfs3_free_createdata(data); 622 dprintk("NFS reply mkdir: %d\n", status); 623 return status; 624 } 625 626 static int 627 nfs3_proc_rmdir(struct inode *dir, const struct qstr *name) 628 { 629 struct nfs_fattr *dir_attr; 630 struct nfs3_diropargs arg = { 631 .fh = NFS_FH(dir), 632 .name = name->name, 633 .len = name->len 634 }; 635 struct rpc_message msg = { 636 .rpc_proc = &nfs3_procedures[NFS3PROC_RMDIR], 637 .rpc_argp = &arg, 638 }; 639 int status = -ENOMEM; 640 641 dprintk("NFS call rmdir %s\n", name->name); 642 dir_attr = nfs_alloc_fattr(); 643 if (dir_attr == NULL) 644 goto out; 645 646 msg.rpc_resp = dir_attr; 647 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 648 nfs_post_op_update_inode(dir, dir_attr); 649 nfs_free_fattr(dir_attr); 650 out: 651 dprintk("NFS reply rmdir: %d\n", status); 652 return status; 653 } 654 655 /* 656 * The READDIR implementation is somewhat hackish - we pass the user buffer 657 * to the encode function, which installs it in the receive iovec. 658 * The decode function itself doesn't perform any decoding, it just makes 659 * sure the reply is syntactically correct. 660 * 661 * Also note that this implementation handles both plain readdir and 662 * readdirplus. 663 */ 664 static int nfs3_proc_readdir(struct nfs_readdir_arg *nr_arg, 665 struct nfs_readdir_res *nr_res) 666 { 667 struct inode *dir = d_inode(nr_arg->dentry); 668 struct nfs3_readdirargs arg = { 669 .fh = NFS_FH(dir), 670 .cookie = nr_arg->cookie, 671 .plus = nr_arg->plus, 672 .count = nr_arg->page_len, 673 .pages = nr_arg->pages 674 }; 675 struct nfs3_readdirres res = { 676 .verf = nr_res->verf, 677 .plus = nr_arg->plus, 678 }; 679 struct rpc_message msg = { 680 .rpc_proc = &nfs3_procedures[NFS3PROC_READDIR], 681 .rpc_argp = &arg, 682 .rpc_resp = &res, 683 .rpc_cred = nr_arg->cred, 684 }; 685 int status = -ENOMEM; 686 687 if (nr_arg->plus) 688 msg.rpc_proc = &nfs3_procedures[NFS3PROC_READDIRPLUS]; 689 if (arg.cookie) 690 memcpy(arg.verf, nr_arg->verf, sizeof(arg.verf)); 691 692 dprintk("NFS call readdir%s %llu\n", nr_arg->plus ? "plus" : "", 693 (unsigned long long)nr_arg->cookie); 694 695 res.dir_attr = nfs_alloc_fattr(); 696 if (res.dir_attr == NULL) 697 goto out; 698 699 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 700 701 nfs_invalidate_atime(dir); 702 nfs_refresh_inode(dir, res.dir_attr); 703 704 nfs_free_fattr(res.dir_attr); 705 out: 706 dprintk("NFS reply readdir%s: %d\n", nr_arg->plus ? "plus" : "", 707 status); 708 return status; 709 } 710 711 static int 712 nfs3_proc_mknod(struct inode *dir, struct dentry *dentry, struct iattr *sattr, 713 dev_t rdev) 714 { 715 struct posix_acl *default_acl, *acl; 716 struct nfs3_createdata *data; 717 struct dentry *d_alias; 718 int status = -ENOMEM; 719 720 dprintk("NFS call mknod %pd %u:%u\n", dentry, 721 MAJOR(rdev), MINOR(rdev)); 722 723 data = nfs3_alloc_createdata(); 724 if (data == NULL) 725 goto out; 726 727 status = posix_acl_create(dir, &sattr->ia_mode, &default_acl, &acl); 728 if (status) 729 goto out; 730 731 data->msg.rpc_proc = &nfs3_procedures[NFS3PROC_MKNOD]; 732 data->arg.mknod.fh = NFS_FH(dir); 733 data->arg.mknod.name = dentry->d_name.name; 734 data->arg.mknod.len = dentry->d_name.len; 735 data->arg.mknod.sattr = sattr; 736 data->arg.mknod.rdev = rdev; 737 738 switch (sattr->ia_mode & S_IFMT) { 739 case S_IFBLK: 740 data->arg.mknod.type = NF3BLK; 741 break; 742 case S_IFCHR: 743 data->arg.mknod.type = NF3CHR; 744 break; 745 case S_IFIFO: 746 data->arg.mknod.type = NF3FIFO; 747 break; 748 case S_IFSOCK: 749 data->arg.mknod.type = NF3SOCK; 750 break; 751 default: 752 status = -EINVAL; 753 goto out_release_acls; 754 } 755 756 d_alias = nfs3_do_create(dir, dentry, data); 757 status = PTR_ERR_OR_ZERO(d_alias); 758 if (status != 0) 759 goto out_release_acls; 760 761 if (d_alias) 762 dentry = d_alias; 763 764 status = nfs3_proc_setacls(d_inode(dentry), acl, default_acl); 765 766 dput(d_alias); 767 out_release_acls: 768 posix_acl_release(acl); 769 posix_acl_release(default_acl); 770 out: 771 nfs3_free_createdata(data); 772 dprintk("NFS reply mknod: %d\n", status); 773 return status; 774 } 775 776 static int 777 nfs3_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle, 778 struct nfs_fsstat *stat) 779 { 780 struct rpc_message msg = { 781 .rpc_proc = &nfs3_procedures[NFS3PROC_FSSTAT], 782 .rpc_argp = fhandle, 783 .rpc_resp = stat, 784 }; 785 int status; 786 787 dprintk("NFS call fsstat\n"); 788 nfs_fattr_init(stat->fattr); 789 status = rpc_call_sync(server->client, &msg, 0); 790 dprintk("NFS reply fsstat: %d\n", status); 791 return status; 792 } 793 794 static int 795 do_proc_fsinfo(struct rpc_clnt *client, struct nfs_fh *fhandle, 796 struct nfs_fsinfo *info) 797 { 798 struct rpc_message msg = { 799 .rpc_proc = &nfs3_procedures[NFS3PROC_FSINFO], 800 .rpc_argp = fhandle, 801 .rpc_resp = info, 802 }; 803 int status; 804 805 dprintk("NFS call fsinfo\n"); 806 nfs_fattr_init(info->fattr); 807 status = rpc_call_sync(client, &msg, 0); 808 dprintk("NFS reply fsinfo: %d\n", status); 809 return status; 810 } 811 812 /* 813 * Bare-bones access to fsinfo: this is for nfs_get_root/nfs_get_sb via 814 * nfs_create_server 815 */ 816 static int 817 nfs3_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, 818 struct nfs_fsinfo *info) 819 { 820 int status; 821 822 status = do_proc_fsinfo(server->client, fhandle, info); 823 if (status && server->nfs_client->cl_rpcclient != server->client) 824 status = do_proc_fsinfo(server->nfs_client->cl_rpcclient, fhandle, info); 825 return status; 826 } 827 828 static int 829 nfs3_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle, 830 struct nfs_pathconf *info) 831 { 832 struct rpc_message msg = { 833 .rpc_proc = &nfs3_procedures[NFS3PROC_PATHCONF], 834 .rpc_argp = fhandle, 835 .rpc_resp = info, 836 }; 837 int status; 838 839 dprintk("NFS call pathconf\n"); 840 nfs_fattr_init(info->fattr); 841 status = rpc_call_sync(server->client, &msg, 0); 842 dprintk("NFS reply pathconf: %d\n", status); 843 return status; 844 } 845 846 static int nfs3_read_done(struct rpc_task *task, struct nfs_pgio_header *hdr) 847 { 848 struct inode *inode = hdr->inode; 849 struct nfs_server *server = NFS_SERVER(inode); 850 851 if (hdr->pgio_done_cb != NULL) 852 return hdr->pgio_done_cb(task, hdr); 853 854 if (nfs3_async_handle_jukebox(task, inode)) 855 return -EAGAIN; 856 857 if (task->tk_status >= 0 && !server->read_hdrsize) 858 cmpxchg(&server->read_hdrsize, 0, hdr->res.replen); 859 860 nfs_invalidate_atime(inode); 861 nfs_refresh_inode(inode, &hdr->fattr); 862 return 0; 863 } 864 865 static void nfs3_proc_read_setup(struct nfs_pgio_header *hdr, 866 struct rpc_message *msg) 867 { 868 msg->rpc_proc = &nfs3_procedures[NFS3PROC_READ]; 869 hdr->args.replen = NFS_SERVER(hdr->inode)->read_hdrsize; 870 } 871 872 static int nfs3_proc_pgio_rpc_prepare(struct rpc_task *task, 873 struct nfs_pgio_header *hdr) 874 { 875 rpc_call_start(task); 876 return 0; 877 } 878 879 static int nfs3_write_done(struct rpc_task *task, struct nfs_pgio_header *hdr) 880 { 881 struct inode *inode = hdr->inode; 882 883 if (hdr->pgio_done_cb != NULL) 884 return hdr->pgio_done_cb(task, hdr); 885 886 if (nfs3_async_handle_jukebox(task, inode)) 887 return -EAGAIN; 888 if (task->tk_status >= 0) 889 nfs_writeback_update_inode(hdr); 890 return 0; 891 } 892 893 static void nfs3_proc_write_setup(struct nfs_pgio_header *hdr, 894 struct rpc_message *msg, 895 struct rpc_clnt **clnt) 896 { 897 msg->rpc_proc = &nfs3_procedures[NFS3PROC_WRITE]; 898 } 899 900 static void nfs3_proc_commit_rpc_prepare(struct rpc_task *task, struct nfs_commit_data *data) 901 { 902 rpc_call_start(task); 903 } 904 905 static int nfs3_commit_done(struct rpc_task *task, struct nfs_commit_data *data) 906 { 907 if (data->commit_done_cb != NULL) 908 return data->commit_done_cb(task, data); 909 910 if (nfs3_async_handle_jukebox(task, data->inode)) 911 return -EAGAIN; 912 nfs_refresh_inode(data->inode, data->res.fattr); 913 return 0; 914 } 915 916 static void nfs3_proc_commit_setup(struct nfs_commit_data *data, struct rpc_message *msg, 917 struct rpc_clnt **clnt) 918 { 919 msg->rpc_proc = &nfs3_procedures[NFS3PROC_COMMIT]; 920 } 921 922 static void nfs3_nlm_alloc_call(void *data) 923 { 924 struct nfs_lock_context *l_ctx = data; 925 if (l_ctx && test_bit(NFS_CONTEXT_UNLOCK, &l_ctx->open_context->flags)) { 926 get_nfs_open_context(l_ctx->open_context); 927 nfs_get_lock_context(l_ctx->open_context); 928 } 929 } 930 931 static bool nfs3_nlm_unlock_prepare(struct rpc_task *task, void *data) 932 { 933 struct nfs_lock_context *l_ctx = data; 934 if (l_ctx && test_bit(NFS_CONTEXT_UNLOCK, &l_ctx->open_context->flags)) 935 return nfs_async_iocounter_wait(task, l_ctx); 936 return false; 937 938 } 939 940 static void nfs3_nlm_release_call(void *data) 941 { 942 struct nfs_lock_context *l_ctx = data; 943 struct nfs_open_context *ctx; 944 if (l_ctx && test_bit(NFS_CONTEXT_UNLOCK, &l_ctx->open_context->flags)) { 945 ctx = l_ctx->open_context; 946 nfs_put_lock_context(l_ctx); 947 put_nfs_open_context(ctx); 948 } 949 } 950 951 static const struct nlmclnt_operations nlmclnt_fl_close_lock_ops = { 952 .nlmclnt_alloc_call = nfs3_nlm_alloc_call, 953 .nlmclnt_unlock_prepare = nfs3_nlm_unlock_prepare, 954 .nlmclnt_release_call = nfs3_nlm_release_call, 955 }; 956 957 static int 958 nfs3_proc_lock(struct file *filp, int cmd, struct file_lock *fl) 959 { 960 struct inode *inode = file_inode(filp); 961 struct nfs_lock_context *l_ctx = NULL; 962 struct nfs_open_context *ctx = nfs_file_open_context(filp); 963 int status; 964 965 if (fl->fl_flags & FL_CLOSE) { 966 l_ctx = nfs_get_lock_context(ctx); 967 if (IS_ERR(l_ctx)) 968 l_ctx = NULL; 969 else 970 set_bit(NFS_CONTEXT_UNLOCK, &ctx->flags); 971 } 972 973 status = nlmclnt_proc(NFS_SERVER(inode)->nlm_host, cmd, fl, l_ctx); 974 975 if (l_ctx) 976 nfs_put_lock_context(l_ctx); 977 978 return status; 979 } 980 981 static int nfs3_have_delegation(struct inode *inode, fmode_t flags) 982 { 983 return 0; 984 } 985 986 static const struct inode_operations nfs3_dir_inode_operations = { 987 .create = nfs_create, 988 .lookup = nfs_lookup, 989 .link = nfs_link, 990 .unlink = nfs_unlink, 991 .symlink = nfs_symlink, 992 .mkdir = nfs_mkdir, 993 .rmdir = nfs_rmdir, 994 .mknod = nfs_mknod, 995 .rename = nfs_rename, 996 .permission = nfs_permission, 997 .getattr = nfs_getattr, 998 .setattr = nfs_setattr, 999 #ifdef CONFIG_NFS_V3_ACL 1000 .listxattr = nfs3_listxattr, 1001 .get_inode_acl = nfs3_get_acl, 1002 .set_acl = nfs3_set_acl, 1003 #endif 1004 }; 1005 1006 static const struct inode_operations nfs3_file_inode_operations = { 1007 .permission = nfs_permission, 1008 .getattr = nfs_getattr, 1009 .setattr = nfs_setattr, 1010 #ifdef CONFIG_NFS_V3_ACL 1011 .listxattr = nfs3_listxattr, 1012 .get_inode_acl = nfs3_get_acl, 1013 .set_acl = nfs3_set_acl, 1014 #endif 1015 }; 1016 1017 const struct nfs_rpc_ops nfs_v3_clientops = { 1018 .version = 3, /* protocol version */ 1019 .dentry_ops = &nfs_dentry_operations, 1020 .dir_inode_ops = &nfs3_dir_inode_operations, 1021 .file_inode_ops = &nfs3_file_inode_operations, 1022 .file_ops = &nfs_file_operations, 1023 .nlmclnt_ops = &nlmclnt_fl_close_lock_ops, 1024 .getroot = nfs3_proc_get_root, 1025 .submount = nfs_submount, 1026 .try_get_tree = nfs_try_get_tree, 1027 .getattr = nfs3_proc_getattr, 1028 .setattr = nfs3_proc_setattr, 1029 .lookup = nfs3_proc_lookup, 1030 .lookupp = nfs3_proc_lookupp, 1031 .access = nfs3_proc_access, 1032 .readlink = nfs3_proc_readlink, 1033 .create = nfs3_proc_create, 1034 .remove = nfs3_proc_remove, 1035 .unlink_setup = nfs3_proc_unlink_setup, 1036 .unlink_rpc_prepare = nfs3_proc_unlink_rpc_prepare, 1037 .unlink_done = nfs3_proc_unlink_done, 1038 .rename_setup = nfs3_proc_rename_setup, 1039 .rename_rpc_prepare = nfs3_proc_rename_rpc_prepare, 1040 .rename_done = nfs3_proc_rename_done, 1041 .link = nfs3_proc_link, 1042 .symlink = nfs3_proc_symlink, 1043 .mkdir = nfs3_proc_mkdir, 1044 .rmdir = nfs3_proc_rmdir, 1045 .readdir = nfs3_proc_readdir, 1046 .mknod = nfs3_proc_mknod, 1047 .statfs = nfs3_proc_statfs, 1048 .fsinfo = nfs3_proc_fsinfo, 1049 .pathconf = nfs3_proc_pathconf, 1050 .decode_dirent = nfs3_decode_dirent, 1051 .pgio_rpc_prepare = nfs3_proc_pgio_rpc_prepare, 1052 .read_setup = nfs3_proc_read_setup, 1053 .read_done = nfs3_read_done, 1054 .write_setup = nfs3_proc_write_setup, 1055 .write_done = nfs3_write_done, 1056 .commit_setup = nfs3_proc_commit_setup, 1057 .commit_rpc_prepare = nfs3_proc_commit_rpc_prepare, 1058 .commit_done = nfs3_commit_done, 1059 .lock = nfs3_proc_lock, 1060 .clear_acl_cache = forget_all_cached_acls, 1061 .close_context = nfs_close_context, 1062 .have_delegation = nfs3_have_delegation, 1063 .alloc_client = nfs_alloc_client, 1064 .init_client = nfs_init_client, 1065 .free_client = nfs_free_client, 1066 .create_server = nfs3_create_server, 1067 .clone_server = nfs3_clone_server, 1068 }; 1069