1 /* 2 * linux/fs/nfs/nfs3proc.c 3 * 4 * Client-side NFSv3 procedures stubs. 5 * 6 * Copyright (C) 1997, Olaf Kirch 7 */ 8 9 #include <linux/mm.h> 10 #include <linux/utsname.h> 11 #include <linux/errno.h> 12 #include <linux/string.h> 13 #include <linux/sunrpc/clnt.h> 14 #include <linux/nfs.h> 15 #include <linux/nfs3.h> 16 #include <linux/nfs_fs.h> 17 #include <linux/nfs_page.h> 18 #include <linux/lockd/bind.h> 19 #include <linux/nfs_mount.h> 20 21 #include "iostat.h" 22 #include "internal.h" 23 24 #define NFSDBG_FACILITY NFSDBG_PROC 25 26 /* A wrapper to handle the EJUKEBOX error message */ 27 static int 28 nfs3_rpc_wrapper(struct rpc_clnt *clnt, struct rpc_message *msg, int flags) 29 { 30 int res; 31 do { 32 res = rpc_call_sync(clnt, msg, flags); 33 if (res != -EJUKEBOX) 34 break; 35 schedule_timeout_killable(NFS_JUKEBOX_RETRY_TIME); 36 res = -ERESTARTSYS; 37 } while (!fatal_signal_pending(current)); 38 return res; 39 } 40 41 #define rpc_call_sync(clnt, msg, flags) nfs3_rpc_wrapper(clnt, msg, flags) 42 43 static int 44 nfs3_async_handle_jukebox(struct rpc_task *task, struct inode *inode) 45 { 46 if (task->tk_status != -EJUKEBOX) 47 return 0; 48 nfs_inc_stats(inode, NFSIOS_DELAY); 49 task->tk_status = 0; 50 rpc_restart_call(task); 51 rpc_delay(task, NFS_JUKEBOX_RETRY_TIME); 52 return 1; 53 } 54 55 static int 56 do_proc_get_root(struct rpc_clnt *client, struct nfs_fh *fhandle, 57 struct nfs_fsinfo *info) 58 { 59 struct rpc_message msg = { 60 .rpc_proc = &nfs3_procedures[NFS3PROC_FSINFO], 61 .rpc_argp = fhandle, 62 .rpc_resp = info, 63 }; 64 int status; 65 66 dprintk("%s: call fsinfo\n", __FUNCTION__); 67 nfs_fattr_init(info->fattr); 68 status = rpc_call_sync(client, &msg, 0); 69 dprintk("%s: reply fsinfo: %d\n", __FUNCTION__, status); 70 if (!(info->fattr->valid & NFS_ATTR_FATTR)) { 71 msg.rpc_proc = &nfs3_procedures[NFS3PROC_GETATTR]; 72 msg.rpc_resp = info->fattr; 73 status = rpc_call_sync(client, &msg, 0); 74 dprintk("%s: reply getattr: %d\n", __FUNCTION__, status); 75 } 76 return status; 77 } 78 79 /* 80 * Bare-bones access to getattr: this is for nfs_get_root/nfs_get_sb 81 */ 82 static int 83 nfs3_proc_get_root(struct nfs_server *server, struct nfs_fh *fhandle, 84 struct nfs_fsinfo *info) 85 { 86 int status; 87 88 status = do_proc_get_root(server->client, fhandle, info); 89 if (status && server->nfs_client->cl_rpcclient != server->client) 90 status = do_proc_get_root(server->nfs_client->cl_rpcclient, fhandle, info); 91 return status; 92 } 93 94 /* 95 * One function for each procedure in the NFS protocol. 96 */ 97 static int 98 nfs3_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, 99 struct nfs_fattr *fattr) 100 { 101 struct rpc_message msg = { 102 .rpc_proc = &nfs3_procedures[NFS3PROC_GETATTR], 103 .rpc_argp = fhandle, 104 .rpc_resp = fattr, 105 }; 106 int status; 107 108 dprintk("NFS call getattr\n"); 109 nfs_fattr_init(fattr); 110 status = rpc_call_sync(server->client, &msg, 0); 111 dprintk("NFS reply getattr: %d\n", status); 112 return status; 113 } 114 115 static int 116 nfs3_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr, 117 struct iattr *sattr) 118 { 119 struct inode *inode = dentry->d_inode; 120 struct nfs3_sattrargs arg = { 121 .fh = NFS_FH(inode), 122 .sattr = sattr, 123 }; 124 struct rpc_message msg = { 125 .rpc_proc = &nfs3_procedures[NFS3PROC_SETATTR], 126 .rpc_argp = &arg, 127 .rpc_resp = fattr, 128 }; 129 int status; 130 131 dprintk("NFS call setattr\n"); 132 nfs_fattr_init(fattr); 133 status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0); 134 if (status == 0) 135 nfs_setattr_update_inode(inode, sattr); 136 dprintk("NFS reply setattr: %d\n", status); 137 return status; 138 } 139 140 static int 141 nfs3_proc_lookup(struct inode *dir, struct qstr *name, 142 struct nfs_fh *fhandle, struct nfs_fattr *fattr) 143 { 144 struct nfs_fattr dir_attr; 145 struct nfs3_diropargs arg = { 146 .fh = NFS_FH(dir), 147 .name = name->name, 148 .len = name->len 149 }; 150 struct nfs3_diropres res = { 151 .dir_attr = &dir_attr, 152 .fh = fhandle, 153 .fattr = fattr 154 }; 155 struct rpc_message msg = { 156 .rpc_proc = &nfs3_procedures[NFS3PROC_LOOKUP], 157 .rpc_argp = &arg, 158 .rpc_resp = &res, 159 }; 160 int status; 161 162 dprintk("NFS call lookup %s\n", name->name); 163 nfs_fattr_init(&dir_attr); 164 nfs_fattr_init(fattr); 165 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 166 nfs_refresh_inode(dir, &dir_attr); 167 if (status >= 0 && !(fattr->valid & NFS_ATTR_FATTR)) { 168 msg.rpc_proc = &nfs3_procedures[NFS3PROC_GETATTR]; 169 msg.rpc_argp = fhandle; 170 msg.rpc_resp = fattr; 171 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 172 } 173 dprintk("NFS reply lookup: %d\n", status); 174 return status; 175 } 176 177 static int nfs3_proc_access(struct inode *inode, struct nfs_access_entry *entry) 178 { 179 struct nfs_fattr fattr; 180 struct nfs3_accessargs arg = { 181 .fh = NFS_FH(inode), 182 }; 183 struct nfs3_accessres res = { 184 .fattr = &fattr, 185 }; 186 struct rpc_message msg = { 187 .rpc_proc = &nfs3_procedures[NFS3PROC_ACCESS], 188 .rpc_argp = &arg, 189 .rpc_resp = &res, 190 .rpc_cred = entry->cred, 191 }; 192 int mode = entry->mask; 193 int status; 194 195 dprintk("NFS call access\n"); 196 197 if (mode & MAY_READ) 198 arg.access |= NFS3_ACCESS_READ; 199 if (S_ISDIR(inode->i_mode)) { 200 if (mode & MAY_WRITE) 201 arg.access |= NFS3_ACCESS_MODIFY | NFS3_ACCESS_EXTEND | NFS3_ACCESS_DELETE; 202 if (mode & MAY_EXEC) 203 arg.access |= NFS3_ACCESS_LOOKUP; 204 } else { 205 if (mode & MAY_WRITE) 206 arg.access |= NFS3_ACCESS_MODIFY | NFS3_ACCESS_EXTEND; 207 if (mode & MAY_EXEC) 208 arg.access |= NFS3_ACCESS_EXECUTE; 209 } 210 nfs_fattr_init(&fattr); 211 status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0); 212 nfs_refresh_inode(inode, &fattr); 213 if (status == 0) { 214 entry->mask = 0; 215 if (res.access & NFS3_ACCESS_READ) 216 entry->mask |= MAY_READ; 217 if (res.access & (NFS3_ACCESS_MODIFY | NFS3_ACCESS_EXTEND | NFS3_ACCESS_DELETE)) 218 entry->mask |= MAY_WRITE; 219 if (res.access & (NFS3_ACCESS_LOOKUP|NFS3_ACCESS_EXECUTE)) 220 entry->mask |= MAY_EXEC; 221 } 222 dprintk("NFS reply access: %d\n", status); 223 return status; 224 } 225 226 static int nfs3_proc_readlink(struct inode *inode, struct page *page, 227 unsigned int pgbase, unsigned int pglen) 228 { 229 struct nfs_fattr fattr; 230 struct nfs3_readlinkargs args = { 231 .fh = NFS_FH(inode), 232 .pgbase = pgbase, 233 .pglen = pglen, 234 .pages = &page 235 }; 236 struct rpc_message msg = { 237 .rpc_proc = &nfs3_procedures[NFS3PROC_READLINK], 238 .rpc_argp = &args, 239 .rpc_resp = &fattr, 240 }; 241 int status; 242 243 dprintk("NFS call readlink\n"); 244 nfs_fattr_init(&fattr); 245 status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0); 246 nfs_refresh_inode(inode, &fattr); 247 dprintk("NFS reply readlink: %d\n", status); 248 return status; 249 } 250 251 /* 252 * Create a regular file. 253 * For now, we don't implement O_EXCL. 254 */ 255 static int 256 nfs3_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr, 257 int flags, struct nameidata *nd) 258 { 259 struct nfs_fh fhandle; 260 struct nfs_fattr fattr; 261 struct nfs_fattr dir_attr; 262 struct nfs3_createargs arg = { 263 .fh = NFS_FH(dir), 264 .name = dentry->d_name.name, 265 .len = dentry->d_name.len, 266 .sattr = sattr, 267 }; 268 struct nfs3_diropres res = { 269 .dir_attr = &dir_attr, 270 .fh = &fhandle, 271 .fattr = &fattr 272 }; 273 struct rpc_message msg = { 274 .rpc_proc = &nfs3_procedures[NFS3PROC_CREATE], 275 .rpc_argp = &arg, 276 .rpc_resp = &res, 277 }; 278 mode_t mode = sattr->ia_mode; 279 int status; 280 281 dprintk("NFS call create %s\n", dentry->d_name.name); 282 arg.createmode = NFS3_CREATE_UNCHECKED; 283 if (flags & O_EXCL) { 284 arg.createmode = NFS3_CREATE_EXCLUSIVE; 285 arg.verifier[0] = jiffies; 286 arg.verifier[1] = current->pid; 287 } 288 289 sattr->ia_mode &= ~current->fs->umask; 290 291 again: 292 nfs_fattr_init(&dir_attr); 293 nfs_fattr_init(&fattr); 294 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 295 nfs_refresh_inode(dir, &dir_attr); 296 297 /* If the server doesn't support the exclusive creation semantics, 298 * try again with simple 'guarded' mode. */ 299 if (status == -ENOTSUPP) { 300 switch (arg.createmode) { 301 case NFS3_CREATE_EXCLUSIVE: 302 arg.createmode = NFS3_CREATE_GUARDED; 303 break; 304 305 case NFS3_CREATE_GUARDED: 306 arg.createmode = NFS3_CREATE_UNCHECKED; 307 break; 308 309 case NFS3_CREATE_UNCHECKED: 310 goto out; 311 } 312 goto again; 313 } 314 315 if (status == 0) 316 status = nfs_instantiate(dentry, &fhandle, &fattr); 317 if (status != 0) 318 goto out; 319 320 /* When we created the file with exclusive semantics, make 321 * sure we set the attributes afterwards. */ 322 if (arg.createmode == NFS3_CREATE_EXCLUSIVE) { 323 dprintk("NFS call setattr (post-create)\n"); 324 325 if (!(sattr->ia_valid & ATTR_ATIME_SET)) 326 sattr->ia_valid |= ATTR_ATIME; 327 if (!(sattr->ia_valid & ATTR_MTIME_SET)) 328 sattr->ia_valid |= ATTR_MTIME; 329 330 /* Note: we could use a guarded setattr here, but I'm 331 * not sure this buys us anything (and I'd have 332 * to revamp the NFSv3 XDR code) */ 333 status = nfs3_proc_setattr(dentry, &fattr, sattr); 334 nfs_post_op_update_inode(dentry->d_inode, &fattr); 335 dprintk("NFS reply setattr (post-create): %d\n", status); 336 } 337 if (status != 0) 338 goto out; 339 status = nfs3_proc_set_default_acl(dir, dentry->d_inode, mode); 340 out: 341 dprintk("NFS reply create: %d\n", status); 342 return status; 343 } 344 345 static int 346 nfs3_proc_remove(struct inode *dir, struct qstr *name) 347 { 348 struct nfs_removeargs arg = { 349 .fh = NFS_FH(dir), 350 .name.len = name->len, 351 .name.name = name->name, 352 }; 353 struct nfs_removeres res; 354 struct rpc_message msg = { 355 .rpc_proc = &nfs3_procedures[NFS3PROC_REMOVE], 356 .rpc_argp = &arg, 357 .rpc_resp = &res, 358 }; 359 int status; 360 361 dprintk("NFS call remove %s\n", name->name); 362 nfs_fattr_init(&res.dir_attr); 363 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 364 nfs_post_op_update_inode(dir, &res.dir_attr); 365 dprintk("NFS reply remove: %d\n", status); 366 return status; 367 } 368 369 static void 370 nfs3_proc_unlink_setup(struct rpc_message *msg, struct inode *dir) 371 { 372 msg->rpc_proc = &nfs3_procedures[NFS3PROC_REMOVE]; 373 } 374 375 static int 376 nfs3_proc_unlink_done(struct rpc_task *task, struct inode *dir) 377 { 378 struct nfs_removeres *res; 379 if (nfs3_async_handle_jukebox(task, dir)) 380 return 0; 381 res = task->tk_msg.rpc_resp; 382 nfs_post_op_update_inode(dir, &res->dir_attr); 383 return 1; 384 } 385 386 static int 387 nfs3_proc_rename(struct inode *old_dir, struct qstr *old_name, 388 struct inode *new_dir, struct qstr *new_name) 389 { 390 struct nfs_fattr old_dir_attr, new_dir_attr; 391 struct nfs3_renameargs arg = { 392 .fromfh = NFS_FH(old_dir), 393 .fromname = old_name->name, 394 .fromlen = old_name->len, 395 .tofh = NFS_FH(new_dir), 396 .toname = new_name->name, 397 .tolen = new_name->len 398 }; 399 struct nfs3_renameres res = { 400 .fromattr = &old_dir_attr, 401 .toattr = &new_dir_attr 402 }; 403 struct rpc_message msg = { 404 .rpc_proc = &nfs3_procedures[NFS3PROC_RENAME], 405 .rpc_argp = &arg, 406 .rpc_resp = &res, 407 }; 408 int status; 409 410 dprintk("NFS call rename %s -> %s\n", old_name->name, new_name->name); 411 nfs_fattr_init(&old_dir_attr); 412 nfs_fattr_init(&new_dir_attr); 413 status = rpc_call_sync(NFS_CLIENT(old_dir), &msg, 0); 414 nfs_post_op_update_inode(old_dir, &old_dir_attr); 415 nfs_post_op_update_inode(new_dir, &new_dir_attr); 416 dprintk("NFS reply rename: %d\n", status); 417 return status; 418 } 419 420 static int 421 nfs3_proc_link(struct inode *inode, struct inode *dir, struct qstr *name) 422 { 423 struct nfs_fattr dir_attr, fattr; 424 struct nfs3_linkargs arg = { 425 .fromfh = NFS_FH(inode), 426 .tofh = NFS_FH(dir), 427 .toname = name->name, 428 .tolen = name->len 429 }; 430 struct nfs3_linkres res = { 431 .dir_attr = &dir_attr, 432 .fattr = &fattr 433 }; 434 struct rpc_message msg = { 435 .rpc_proc = &nfs3_procedures[NFS3PROC_LINK], 436 .rpc_argp = &arg, 437 .rpc_resp = &res, 438 }; 439 int status; 440 441 dprintk("NFS call link %s\n", name->name); 442 nfs_fattr_init(&dir_attr); 443 nfs_fattr_init(&fattr); 444 status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0); 445 nfs_post_op_update_inode(dir, &dir_attr); 446 nfs_post_op_update_inode(inode, &fattr); 447 dprintk("NFS reply link: %d\n", status); 448 return status; 449 } 450 451 static int 452 nfs3_proc_symlink(struct inode *dir, struct dentry *dentry, struct page *page, 453 unsigned int len, struct iattr *sattr) 454 { 455 struct nfs_fh fhandle; 456 struct nfs_fattr fattr, dir_attr; 457 struct nfs3_symlinkargs arg = { 458 .fromfh = NFS_FH(dir), 459 .fromname = dentry->d_name.name, 460 .fromlen = dentry->d_name.len, 461 .pages = &page, 462 .pathlen = len, 463 .sattr = sattr 464 }; 465 struct nfs3_diropres res = { 466 .dir_attr = &dir_attr, 467 .fh = &fhandle, 468 .fattr = &fattr 469 }; 470 struct rpc_message msg = { 471 .rpc_proc = &nfs3_procedures[NFS3PROC_SYMLINK], 472 .rpc_argp = &arg, 473 .rpc_resp = &res, 474 }; 475 int status; 476 477 if (len > NFS3_MAXPATHLEN) 478 return -ENAMETOOLONG; 479 480 dprintk("NFS call symlink %s\n", dentry->d_name.name); 481 482 nfs_fattr_init(&dir_attr); 483 nfs_fattr_init(&fattr); 484 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 485 nfs_post_op_update_inode(dir, &dir_attr); 486 if (status != 0) 487 goto out; 488 status = nfs_instantiate(dentry, &fhandle, &fattr); 489 out: 490 dprintk("NFS reply symlink: %d\n", status); 491 return status; 492 } 493 494 static int 495 nfs3_proc_mkdir(struct inode *dir, struct dentry *dentry, struct iattr *sattr) 496 { 497 struct nfs_fh fhandle; 498 struct nfs_fattr fattr, dir_attr; 499 struct nfs3_mkdirargs arg = { 500 .fh = NFS_FH(dir), 501 .name = dentry->d_name.name, 502 .len = dentry->d_name.len, 503 .sattr = sattr 504 }; 505 struct nfs3_diropres res = { 506 .dir_attr = &dir_attr, 507 .fh = &fhandle, 508 .fattr = &fattr 509 }; 510 struct rpc_message msg = { 511 .rpc_proc = &nfs3_procedures[NFS3PROC_MKDIR], 512 .rpc_argp = &arg, 513 .rpc_resp = &res, 514 }; 515 int mode = sattr->ia_mode; 516 int status; 517 518 dprintk("NFS call mkdir %s\n", dentry->d_name.name); 519 520 sattr->ia_mode &= ~current->fs->umask; 521 522 nfs_fattr_init(&dir_attr); 523 nfs_fattr_init(&fattr); 524 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 525 nfs_post_op_update_inode(dir, &dir_attr); 526 if (status != 0) 527 goto out; 528 status = nfs_instantiate(dentry, &fhandle, &fattr); 529 if (status != 0) 530 goto out; 531 status = nfs3_proc_set_default_acl(dir, dentry->d_inode, mode); 532 out: 533 dprintk("NFS reply mkdir: %d\n", status); 534 return status; 535 } 536 537 static int 538 nfs3_proc_rmdir(struct inode *dir, struct qstr *name) 539 { 540 struct nfs_fattr dir_attr; 541 struct nfs3_diropargs arg = { 542 .fh = NFS_FH(dir), 543 .name = name->name, 544 .len = name->len 545 }; 546 struct rpc_message msg = { 547 .rpc_proc = &nfs3_procedures[NFS3PROC_RMDIR], 548 .rpc_argp = &arg, 549 .rpc_resp = &dir_attr, 550 }; 551 int status; 552 553 dprintk("NFS call rmdir %s\n", name->name); 554 nfs_fattr_init(&dir_attr); 555 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 556 nfs_post_op_update_inode(dir, &dir_attr); 557 dprintk("NFS reply rmdir: %d\n", status); 558 return status; 559 } 560 561 /* 562 * The READDIR implementation is somewhat hackish - we pass the user buffer 563 * to the encode function, which installs it in the receive iovec. 564 * The decode function itself doesn't perform any decoding, it just makes 565 * sure the reply is syntactically correct. 566 * 567 * Also note that this implementation handles both plain readdir and 568 * readdirplus. 569 */ 570 static int 571 nfs3_proc_readdir(struct dentry *dentry, struct rpc_cred *cred, 572 u64 cookie, struct page *page, unsigned int count, int plus) 573 { 574 struct inode *dir = dentry->d_inode; 575 struct nfs_fattr dir_attr; 576 __be32 *verf = NFS_COOKIEVERF(dir); 577 struct nfs3_readdirargs arg = { 578 .fh = NFS_FH(dir), 579 .cookie = cookie, 580 .verf = {verf[0], verf[1]}, 581 .plus = plus, 582 .count = count, 583 .pages = &page 584 }; 585 struct nfs3_readdirres res = { 586 .dir_attr = &dir_attr, 587 .verf = verf, 588 .plus = plus 589 }; 590 struct rpc_message msg = { 591 .rpc_proc = &nfs3_procedures[NFS3PROC_READDIR], 592 .rpc_argp = &arg, 593 .rpc_resp = &res, 594 .rpc_cred = cred 595 }; 596 int status; 597 598 if (plus) 599 msg.rpc_proc = &nfs3_procedures[NFS3PROC_READDIRPLUS]; 600 601 dprintk("NFS call readdir%s %d\n", 602 plus? "plus" : "", (unsigned int) cookie); 603 604 nfs_fattr_init(&dir_attr); 605 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 606 607 nfs_invalidate_atime(dir); 608 609 nfs_refresh_inode(dir, &dir_attr); 610 dprintk("NFS reply readdir: %d\n", status); 611 return status; 612 } 613 614 static int 615 nfs3_proc_mknod(struct inode *dir, struct dentry *dentry, struct iattr *sattr, 616 dev_t rdev) 617 { 618 struct nfs_fh fh; 619 struct nfs_fattr fattr, dir_attr; 620 struct nfs3_mknodargs arg = { 621 .fh = NFS_FH(dir), 622 .name = dentry->d_name.name, 623 .len = dentry->d_name.len, 624 .sattr = sattr, 625 .rdev = rdev 626 }; 627 struct nfs3_diropres res = { 628 .dir_attr = &dir_attr, 629 .fh = &fh, 630 .fattr = &fattr 631 }; 632 struct rpc_message msg = { 633 .rpc_proc = &nfs3_procedures[NFS3PROC_MKNOD], 634 .rpc_argp = &arg, 635 .rpc_resp = &res, 636 }; 637 mode_t mode = sattr->ia_mode; 638 int status; 639 640 switch (sattr->ia_mode & S_IFMT) { 641 case S_IFBLK: arg.type = NF3BLK; break; 642 case S_IFCHR: arg.type = NF3CHR; break; 643 case S_IFIFO: arg.type = NF3FIFO; break; 644 case S_IFSOCK: arg.type = NF3SOCK; break; 645 default: return -EINVAL; 646 } 647 648 dprintk("NFS call mknod %s %u:%u\n", dentry->d_name.name, 649 MAJOR(rdev), MINOR(rdev)); 650 651 sattr->ia_mode &= ~current->fs->umask; 652 653 nfs_fattr_init(&dir_attr); 654 nfs_fattr_init(&fattr); 655 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 656 nfs_post_op_update_inode(dir, &dir_attr); 657 if (status != 0) 658 goto out; 659 status = nfs_instantiate(dentry, &fh, &fattr); 660 if (status != 0) 661 goto out; 662 status = nfs3_proc_set_default_acl(dir, dentry->d_inode, mode); 663 out: 664 dprintk("NFS reply mknod: %d\n", status); 665 return status; 666 } 667 668 static int 669 nfs3_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle, 670 struct nfs_fsstat *stat) 671 { 672 struct rpc_message msg = { 673 .rpc_proc = &nfs3_procedures[NFS3PROC_FSSTAT], 674 .rpc_argp = fhandle, 675 .rpc_resp = stat, 676 }; 677 int status; 678 679 dprintk("NFS call fsstat\n"); 680 nfs_fattr_init(stat->fattr); 681 status = rpc_call_sync(server->client, &msg, 0); 682 dprintk("NFS reply statfs: %d\n", status); 683 return status; 684 } 685 686 static int 687 nfs3_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, 688 struct nfs_fsinfo *info) 689 { 690 struct rpc_message msg = { 691 .rpc_proc = &nfs3_procedures[NFS3PROC_FSINFO], 692 .rpc_argp = fhandle, 693 .rpc_resp = info, 694 }; 695 int status; 696 697 dprintk("NFS call fsinfo\n"); 698 nfs_fattr_init(info->fattr); 699 status = rpc_call_sync(server->nfs_client->cl_rpcclient, &msg, 0); 700 dprintk("NFS reply fsinfo: %d\n", status); 701 return status; 702 } 703 704 static int 705 nfs3_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle, 706 struct nfs_pathconf *info) 707 { 708 struct rpc_message msg = { 709 .rpc_proc = &nfs3_procedures[NFS3PROC_PATHCONF], 710 .rpc_argp = fhandle, 711 .rpc_resp = info, 712 }; 713 int status; 714 715 dprintk("NFS call pathconf\n"); 716 nfs_fattr_init(info->fattr); 717 status = rpc_call_sync(server->client, &msg, 0); 718 dprintk("NFS reply pathconf: %d\n", status); 719 return status; 720 } 721 722 static int nfs3_read_done(struct rpc_task *task, struct nfs_read_data *data) 723 { 724 if (nfs3_async_handle_jukebox(task, data->inode)) 725 return -EAGAIN; 726 727 nfs_invalidate_atime(data->inode); 728 nfs_refresh_inode(data->inode, &data->fattr); 729 return 0; 730 } 731 732 static void nfs3_proc_read_setup(struct nfs_read_data *data, struct rpc_message *msg) 733 { 734 msg->rpc_proc = &nfs3_procedures[NFS3PROC_READ]; 735 } 736 737 static int nfs3_write_done(struct rpc_task *task, struct nfs_write_data *data) 738 { 739 if (nfs3_async_handle_jukebox(task, data->inode)) 740 return -EAGAIN; 741 if (task->tk_status >= 0) 742 nfs_post_op_update_inode_force_wcc(data->inode, data->res.fattr); 743 return 0; 744 } 745 746 static void nfs3_proc_write_setup(struct nfs_write_data *data, struct rpc_message *msg) 747 { 748 msg->rpc_proc = &nfs3_procedures[NFS3PROC_WRITE]; 749 } 750 751 static int nfs3_commit_done(struct rpc_task *task, struct nfs_write_data *data) 752 { 753 if (nfs3_async_handle_jukebox(task, data->inode)) 754 return -EAGAIN; 755 nfs_refresh_inode(data->inode, data->res.fattr); 756 return 0; 757 } 758 759 static void nfs3_proc_commit_setup(struct nfs_write_data *data, struct rpc_message *msg) 760 { 761 msg->rpc_proc = &nfs3_procedures[NFS3PROC_COMMIT]; 762 } 763 764 static int 765 nfs3_proc_lock(struct file *filp, int cmd, struct file_lock *fl) 766 { 767 struct inode *inode = filp->f_path.dentry->d_inode; 768 769 return nlmclnt_proc(NFS_SERVER(inode)->nlm_host, cmd, fl); 770 } 771 772 const struct nfs_rpc_ops nfs_v3_clientops = { 773 .version = 3, /* protocol version */ 774 .dentry_ops = &nfs_dentry_operations, 775 .dir_inode_ops = &nfs3_dir_inode_operations, 776 .file_inode_ops = &nfs3_file_inode_operations, 777 .getroot = nfs3_proc_get_root, 778 .getattr = nfs3_proc_getattr, 779 .setattr = nfs3_proc_setattr, 780 .lookup = nfs3_proc_lookup, 781 .access = nfs3_proc_access, 782 .readlink = nfs3_proc_readlink, 783 .create = nfs3_proc_create, 784 .remove = nfs3_proc_remove, 785 .unlink_setup = nfs3_proc_unlink_setup, 786 .unlink_done = nfs3_proc_unlink_done, 787 .rename = nfs3_proc_rename, 788 .link = nfs3_proc_link, 789 .symlink = nfs3_proc_symlink, 790 .mkdir = nfs3_proc_mkdir, 791 .rmdir = nfs3_proc_rmdir, 792 .readdir = nfs3_proc_readdir, 793 .mknod = nfs3_proc_mknod, 794 .statfs = nfs3_proc_statfs, 795 .fsinfo = nfs3_proc_fsinfo, 796 .pathconf = nfs3_proc_pathconf, 797 .decode_dirent = nfs3_decode_dirent, 798 .read_setup = nfs3_proc_read_setup, 799 .read_done = nfs3_read_done, 800 .write_setup = nfs3_proc_write_setup, 801 .write_done = nfs3_write_done, 802 .commit_setup = nfs3_proc_commit_setup, 803 .commit_done = nfs3_commit_done, 804 .file_open = nfs_open, 805 .file_release = nfs_release, 806 .lock = nfs3_proc_lock, 807 .clear_acl_cache = nfs3_forget_cached_acls, 808 }; 809