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