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 if (status == 0) 339 nfs_setattr_update_inode(dentry->d_inode, sattr); 340 nfs_refresh_inode(dentry->d_inode, &fattr); 341 dprintk("NFS reply setattr (post-create): %d\n", status); 342 } 343 if (status != 0) 344 goto out; 345 status = nfs3_proc_set_default_acl(dir, dentry->d_inode, mode); 346 out: 347 dprintk("NFS reply create: %d\n", status); 348 return status; 349 } 350 351 static int 352 nfs3_proc_remove(struct inode *dir, struct qstr *name) 353 { 354 struct nfs_fattr dir_attr; 355 struct nfs3_diropargs arg = { 356 .fh = NFS_FH(dir), 357 .name = name->name, 358 .len = name->len 359 }; 360 struct rpc_message msg = { 361 .rpc_proc = &nfs3_procedures[NFS3PROC_REMOVE], 362 .rpc_argp = &arg, 363 .rpc_resp = &dir_attr, 364 }; 365 int status; 366 367 dprintk("NFS call remove %s\n", name->name); 368 nfs_fattr_init(&dir_attr); 369 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 370 nfs_post_op_update_inode(dir, &dir_attr); 371 dprintk("NFS reply remove: %d\n", status); 372 return status; 373 } 374 375 static int 376 nfs3_proc_unlink_setup(struct rpc_message *msg, struct dentry *dir, struct qstr *name) 377 { 378 struct unlinkxdr { 379 struct nfs3_diropargs arg; 380 struct nfs_fattr res; 381 } *ptr; 382 383 ptr = kmalloc(sizeof(*ptr), GFP_KERNEL); 384 if (!ptr) 385 return -ENOMEM; 386 ptr->arg.fh = NFS_FH(dir->d_inode); 387 ptr->arg.name = name->name; 388 ptr->arg.len = name->len; 389 nfs_fattr_init(&ptr->res); 390 msg->rpc_proc = &nfs3_procedures[NFS3PROC_REMOVE]; 391 msg->rpc_argp = &ptr->arg; 392 msg->rpc_resp = &ptr->res; 393 return 0; 394 } 395 396 static int 397 nfs3_proc_unlink_done(struct dentry *dir, struct rpc_task *task) 398 { 399 struct rpc_message *msg = &task->tk_msg; 400 struct nfs_fattr *dir_attr; 401 402 if (nfs3_async_handle_jukebox(task, dir->d_inode)) 403 return 1; 404 if (msg->rpc_argp) { 405 dir_attr = (struct nfs_fattr*)msg->rpc_resp; 406 nfs_post_op_update_inode(dir->d_inode, dir_attr); 407 kfree(msg->rpc_argp); 408 } 409 return 0; 410 } 411 412 static int 413 nfs3_proc_rename(struct inode *old_dir, struct qstr *old_name, 414 struct inode *new_dir, struct qstr *new_name) 415 { 416 struct nfs_fattr old_dir_attr, new_dir_attr; 417 struct nfs3_renameargs arg = { 418 .fromfh = NFS_FH(old_dir), 419 .fromname = old_name->name, 420 .fromlen = old_name->len, 421 .tofh = NFS_FH(new_dir), 422 .toname = new_name->name, 423 .tolen = new_name->len 424 }; 425 struct nfs3_renameres res = { 426 .fromattr = &old_dir_attr, 427 .toattr = &new_dir_attr 428 }; 429 struct rpc_message msg = { 430 .rpc_proc = &nfs3_procedures[NFS3PROC_RENAME], 431 .rpc_argp = &arg, 432 .rpc_resp = &res, 433 }; 434 int status; 435 436 dprintk("NFS call rename %s -> %s\n", old_name->name, new_name->name); 437 nfs_fattr_init(&old_dir_attr); 438 nfs_fattr_init(&new_dir_attr); 439 status = rpc_call_sync(NFS_CLIENT(old_dir), &msg, 0); 440 nfs_post_op_update_inode(old_dir, &old_dir_attr); 441 nfs_post_op_update_inode(new_dir, &new_dir_attr); 442 dprintk("NFS reply rename: %d\n", status); 443 return status; 444 } 445 446 static int 447 nfs3_proc_link(struct inode *inode, struct inode *dir, struct qstr *name) 448 { 449 struct nfs_fattr dir_attr, fattr; 450 struct nfs3_linkargs arg = { 451 .fromfh = NFS_FH(inode), 452 .tofh = NFS_FH(dir), 453 .toname = name->name, 454 .tolen = name->len 455 }; 456 struct nfs3_linkres res = { 457 .dir_attr = &dir_attr, 458 .fattr = &fattr 459 }; 460 struct rpc_message msg = { 461 .rpc_proc = &nfs3_procedures[NFS3PROC_LINK], 462 .rpc_argp = &arg, 463 .rpc_resp = &res, 464 }; 465 int status; 466 467 dprintk("NFS call link %s\n", name->name); 468 nfs_fattr_init(&dir_attr); 469 nfs_fattr_init(&fattr); 470 status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0); 471 nfs_post_op_update_inode(dir, &dir_attr); 472 nfs_post_op_update_inode(inode, &fattr); 473 dprintk("NFS reply link: %d\n", status); 474 return status; 475 } 476 477 static int 478 nfs3_proc_symlink(struct inode *dir, struct dentry *dentry, struct page *page, 479 unsigned int len, struct iattr *sattr) 480 { 481 struct nfs_fh fhandle; 482 struct nfs_fattr fattr, dir_attr; 483 struct nfs3_symlinkargs arg = { 484 .fromfh = NFS_FH(dir), 485 .fromname = dentry->d_name.name, 486 .fromlen = dentry->d_name.len, 487 .pages = &page, 488 .pathlen = len, 489 .sattr = sattr 490 }; 491 struct nfs3_diropres res = { 492 .dir_attr = &dir_attr, 493 .fh = &fhandle, 494 .fattr = &fattr 495 }; 496 struct rpc_message msg = { 497 .rpc_proc = &nfs3_procedures[NFS3PROC_SYMLINK], 498 .rpc_argp = &arg, 499 .rpc_resp = &res, 500 }; 501 int status; 502 503 if (len > NFS3_MAXPATHLEN) 504 return -ENAMETOOLONG; 505 506 dprintk("NFS call symlink %s\n", dentry->d_name.name); 507 508 nfs_fattr_init(&dir_attr); 509 nfs_fattr_init(&fattr); 510 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 511 nfs_post_op_update_inode(dir, &dir_attr); 512 if (status != 0) 513 goto out; 514 status = nfs_instantiate(dentry, &fhandle, &fattr); 515 out: 516 dprintk("NFS reply symlink: %d\n", status); 517 return status; 518 } 519 520 static int 521 nfs3_proc_mkdir(struct inode *dir, struct dentry *dentry, struct iattr *sattr) 522 { 523 struct nfs_fh fhandle; 524 struct nfs_fattr fattr, dir_attr; 525 struct nfs3_mkdirargs arg = { 526 .fh = NFS_FH(dir), 527 .name = dentry->d_name.name, 528 .len = dentry->d_name.len, 529 .sattr = sattr 530 }; 531 struct nfs3_diropres res = { 532 .dir_attr = &dir_attr, 533 .fh = &fhandle, 534 .fattr = &fattr 535 }; 536 struct rpc_message msg = { 537 .rpc_proc = &nfs3_procedures[NFS3PROC_MKDIR], 538 .rpc_argp = &arg, 539 .rpc_resp = &res, 540 }; 541 int mode = sattr->ia_mode; 542 int status; 543 544 dprintk("NFS call mkdir %s\n", dentry->d_name.name); 545 546 sattr->ia_mode &= ~current->fs->umask; 547 548 nfs_fattr_init(&dir_attr); 549 nfs_fattr_init(&fattr); 550 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 551 nfs_post_op_update_inode(dir, &dir_attr); 552 if (status != 0) 553 goto out; 554 status = nfs_instantiate(dentry, &fhandle, &fattr); 555 if (status != 0) 556 goto out; 557 status = nfs3_proc_set_default_acl(dir, dentry->d_inode, mode); 558 out: 559 dprintk("NFS reply mkdir: %d\n", status); 560 return status; 561 } 562 563 static int 564 nfs3_proc_rmdir(struct inode *dir, struct qstr *name) 565 { 566 struct nfs_fattr dir_attr; 567 struct nfs3_diropargs arg = { 568 .fh = NFS_FH(dir), 569 .name = name->name, 570 .len = name->len 571 }; 572 struct rpc_message msg = { 573 .rpc_proc = &nfs3_procedures[NFS3PROC_RMDIR], 574 .rpc_argp = &arg, 575 .rpc_resp = &dir_attr, 576 }; 577 int status; 578 579 dprintk("NFS call rmdir %s\n", name->name); 580 nfs_fattr_init(&dir_attr); 581 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 582 nfs_post_op_update_inode(dir, &dir_attr); 583 dprintk("NFS reply rmdir: %d\n", status); 584 return status; 585 } 586 587 /* 588 * The READDIR implementation is somewhat hackish - we pass the user buffer 589 * to the encode function, which installs it in the receive iovec. 590 * The decode function itself doesn't perform any decoding, it just makes 591 * sure the reply is syntactically correct. 592 * 593 * Also note that this implementation handles both plain readdir and 594 * readdirplus. 595 */ 596 static int 597 nfs3_proc_readdir(struct dentry *dentry, struct rpc_cred *cred, 598 u64 cookie, struct page *page, unsigned int count, int plus) 599 { 600 struct inode *dir = dentry->d_inode; 601 struct nfs_fattr dir_attr; 602 __be32 *verf = NFS_COOKIEVERF(dir); 603 struct nfs3_readdirargs arg = { 604 .fh = NFS_FH(dir), 605 .cookie = cookie, 606 .verf = {verf[0], verf[1]}, 607 .plus = plus, 608 .count = count, 609 .pages = &page 610 }; 611 struct nfs3_readdirres res = { 612 .dir_attr = &dir_attr, 613 .verf = verf, 614 .plus = plus 615 }; 616 struct rpc_message msg = { 617 .rpc_proc = &nfs3_procedures[NFS3PROC_READDIR], 618 .rpc_argp = &arg, 619 .rpc_resp = &res, 620 .rpc_cred = cred 621 }; 622 int status; 623 624 if (plus) 625 msg.rpc_proc = &nfs3_procedures[NFS3PROC_READDIRPLUS]; 626 627 dprintk("NFS call readdir%s %d\n", 628 plus? "plus" : "", (unsigned int) cookie); 629 630 nfs_fattr_init(&dir_attr); 631 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 632 nfs_refresh_inode(dir, &dir_attr); 633 dprintk("NFS reply readdir: %d\n", status); 634 return status; 635 } 636 637 static int 638 nfs3_proc_mknod(struct inode *dir, struct dentry *dentry, struct iattr *sattr, 639 dev_t rdev) 640 { 641 struct nfs_fh fh; 642 struct nfs_fattr fattr, dir_attr; 643 struct nfs3_mknodargs arg = { 644 .fh = NFS_FH(dir), 645 .name = dentry->d_name.name, 646 .len = dentry->d_name.len, 647 .sattr = sattr, 648 .rdev = rdev 649 }; 650 struct nfs3_diropres res = { 651 .dir_attr = &dir_attr, 652 .fh = &fh, 653 .fattr = &fattr 654 }; 655 struct rpc_message msg = { 656 .rpc_proc = &nfs3_procedures[NFS3PROC_MKNOD], 657 .rpc_argp = &arg, 658 .rpc_resp = &res, 659 }; 660 mode_t mode = sattr->ia_mode; 661 int status; 662 663 switch (sattr->ia_mode & S_IFMT) { 664 case S_IFBLK: arg.type = NF3BLK; break; 665 case S_IFCHR: arg.type = NF3CHR; break; 666 case S_IFIFO: arg.type = NF3FIFO; break; 667 case S_IFSOCK: arg.type = NF3SOCK; break; 668 default: return -EINVAL; 669 } 670 671 dprintk("NFS call mknod %s %u:%u\n", dentry->d_name.name, 672 MAJOR(rdev), MINOR(rdev)); 673 674 sattr->ia_mode &= ~current->fs->umask; 675 676 nfs_fattr_init(&dir_attr); 677 nfs_fattr_init(&fattr); 678 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 679 nfs_post_op_update_inode(dir, &dir_attr); 680 if (status != 0) 681 goto out; 682 status = nfs_instantiate(dentry, &fh, &fattr); 683 if (status != 0) 684 goto out; 685 status = nfs3_proc_set_default_acl(dir, dentry->d_inode, mode); 686 out: 687 dprintk("NFS reply mknod: %d\n", status); 688 return status; 689 } 690 691 static int 692 nfs3_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle, 693 struct nfs_fsstat *stat) 694 { 695 struct rpc_message msg = { 696 .rpc_proc = &nfs3_procedures[NFS3PROC_FSSTAT], 697 .rpc_argp = fhandle, 698 .rpc_resp = stat, 699 }; 700 int status; 701 702 dprintk("NFS call fsstat\n"); 703 nfs_fattr_init(stat->fattr); 704 status = rpc_call_sync(server->client, &msg, 0); 705 dprintk("NFS reply statfs: %d\n", status); 706 return status; 707 } 708 709 static int 710 nfs3_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, 711 struct nfs_fsinfo *info) 712 { 713 struct rpc_message msg = { 714 .rpc_proc = &nfs3_procedures[NFS3PROC_FSINFO], 715 .rpc_argp = fhandle, 716 .rpc_resp = info, 717 }; 718 int status; 719 720 dprintk("NFS call fsinfo\n"); 721 nfs_fattr_init(info->fattr); 722 status = rpc_call_sync(server->nfs_client->cl_rpcclient, &msg, 0); 723 dprintk("NFS reply fsinfo: %d\n", status); 724 return status; 725 } 726 727 static int 728 nfs3_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle, 729 struct nfs_pathconf *info) 730 { 731 struct rpc_message msg = { 732 .rpc_proc = &nfs3_procedures[NFS3PROC_PATHCONF], 733 .rpc_argp = fhandle, 734 .rpc_resp = info, 735 }; 736 int status; 737 738 dprintk("NFS call pathconf\n"); 739 nfs_fattr_init(info->fattr); 740 status = rpc_call_sync(server->client, &msg, 0); 741 dprintk("NFS reply pathconf: %d\n", status); 742 return status; 743 } 744 745 static int nfs3_read_done(struct rpc_task *task, struct nfs_read_data *data) 746 { 747 if (nfs3_async_handle_jukebox(task, data->inode)) 748 return -EAGAIN; 749 /* Call back common NFS readpage processing */ 750 if (task->tk_status >= 0) 751 nfs_refresh_inode(data->inode, &data->fattr); 752 return 0; 753 } 754 755 static void nfs3_proc_read_setup(struct nfs_read_data *data) 756 { 757 struct rpc_message msg = { 758 .rpc_proc = &nfs3_procedures[NFS3PROC_READ], 759 .rpc_argp = &data->args, 760 .rpc_resp = &data->res, 761 .rpc_cred = data->cred, 762 }; 763 764 rpc_call_setup(&data->task, &msg, 0); 765 } 766 767 static int nfs3_write_done(struct rpc_task *task, struct nfs_write_data *data) 768 { 769 if (nfs3_async_handle_jukebox(task, data->inode)) 770 return -EAGAIN; 771 if (task->tk_status >= 0) 772 nfs_post_op_update_inode(data->inode, data->res.fattr); 773 return 0; 774 } 775 776 static void nfs3_proc_write_setup(struct nfs_write_data *data, int how) 777 { 778 struct rpc_message msg = { 779 .rpc_proc = &nfs3_procedures[NFS3PROC_WRITE], 780 .rpc_argp = &data->args, 781 .rpc_resp = &data->res, 782 .rpc_cred = data->cred, 783 }; 784 785 data->args.stable = NFS_UNSTABLE; 786 if (how & FLUSH_STABLE) { 787 data->args.stable = NFS_FILE_SYNC; 788 if (NFS_I(data->inode)->ncommit) 789 data->args.stable = NFS_DATA_SYNC; 790 } 791 792 /* Finalize the task. */ 793 rpc_call_setup(&data->task, &msg, 0); 794 } 795 796 static int nfs3_commit_done(struct rpc_task *task, struct nfs_write_data *data) 797 { 798 if (nfs3_async_handle_jukebox(task, data->inode)) 799 return -EAGAIN; 800 if (task->tk_status >= 0) 801 nfs_post_op_update_inode(data->inode, data->res.fattr); 802 return 0; 803 } 804 805 static void nfs3_proc_commit_setup(struct nfs_write_data *data, int how) 806 { 807 struct rpc_message msg = { 808 .rpc_proc = &nfs3_procedures[NFS3PROC_COMMIT], 809 .rpc_argp = &data->args, 810 .rpc_resp = &data->res, 811 .rpc_cred = data->cred, 812 }; 813 814 rpc_call_setup(&data->task, &msg, 0); 815 } 816 817 static int 818 nfs3_proc_lock(struct file *filp, int cmd, struct file_lock *fl) 819 { 820 return nlmclnt_proc(filp->f_path.dentry->d_inode, cmd, fl); 821 } 822 823 const struct nfs_rpc_ops nfs_v3_clientops = { 824 .version = 3, /* protocol version */ 825 .dentry_ops = &nfs_dentry_operations, 826 .dir_inode_ops = &nfs3_dir_inode_operations, 827 .file_inode_ops = &nfs3_file_inode_operations, 828 .getroot = nfs3_proc_get_root, 829 .getattr = nfs3_proc_getattr, 830 .setattr = nfs3_proc_setattr, 831 .lookup = nfs3_proc_lookup, 832 .access = nfs3_proc_access, 833 .readlink = nfs3_proc_readlink, 834 .create = nfs3_proc_create, 835 .remove = nfs3_proc_remove, 836 .unlink_setup = nfs3_proc_unlink_setup, 837 .unlink_done = nfs3_proc_unlink_done, 838 .rename = nfs3_proc_rename, 839 .link = nfs3_proc_link, 840 .symlink = nfs3_proc_symlink, 841 .mkdir = nfs3_proc_mkdir, 842 .rmdir = nfs3_proc_rmdir, 843 .readdir = nfs3_proc_readdir, 844 .mknod = nfs3_proc_mknod, 845 .statfs = nfs3_proc_statfs, 846 .fsinfo = nfs3_proc_fsinfo, 847 .pathconf = nfs3_proc_pathconf, 848 .decode_dirent = nfs3_decode_dirent, 849 .read_setup = nfs3_proc_read_setup, 850 .read_done = nfs3_read_done, 851 .write_setup = nfs3_proc_write_setup, 852 .write_done = nfs3_write_done, 853 .commit_setup = nfs3_proc_commit_setup, 854 .commit_done = nfs3_commit_done, 855 .file_open = nfs_open, 856 .file_release = nfs_release, 857 .lock = nfs3_proc_lock, 858 .clear_acl_cache = nfs3_forget_cached_acls, 859 }; 860