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