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