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