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", __func__); 67 nfs_fattr_init(info->fattr); 68 status = rpc_call_sync(client, &msg, 0); 69 dprintk("%s: reply fsinfo: %d\n", __func__, 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", __func__, 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 struct nfs3_createdata { 252 struct rpc_message msg; 253 union { 254 struct nfs3_createargs create; 255 struct nfs3_mkdirargs mkdir; 256 struct nfs3_symlinkargs symlink; 257 struct nfs3_mknodargs mknod; 258 } arg; 259 struct nfs3_diropres res; 260 struct nfs_fh fh; 261 struct nfs_fattr fattr; 262 struct nfs_fattr dir_attr; 263 }; 264 265 static struct nfs3_createdata *nfs3_alloc_createdata(void) 266 { 267 struct nfs3_createdata *data; 268 269 data = kzalloc(sizeof(*data), GFP_KERNEL); 270 if (data != NULL) { 271 data->msg.rpc_argp = &data->arg; 272 data->msg.rpc_resp = &data->res; 273 data->res.fh = &data->fh; 274 data->res.fattr = &data->fattr; 275 data->res.dir_attr = &data->dir_attr; 276 nfs_fattr_init(data->res.fattr); 277 nfs_fattr_init(data->res.dir_attr); 278 } 279 return data; 280 } 281 282 static int nfs3_do_create(struct inode *dir, struct dentry *dentry, struct nfs3_createdata *data) 283 { 284 int status; 285 286 status = rpc_call_sync(NFS_CLIENT(dir), &data->msg, 0); 287 nfs_post_op_update_inode(dir, data->res.dir_attr); 288 if (status == 0) 289 status = nfs_instantiate(dentry, data->res.fh, data->res.fattr); 290 return status; 291 } 292 293 static void nfs3_free_createdata(struct nfs3_createdata *data) 294 { 295 kfree(data); 296 } 297 298 /* 299 * Create a regular file. 300 * For now, we don't implement O_EXCL. 301 */ 302 static int 303 nfs3_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr, 304 int flags, struct nameidata *nd) 305 { 306 struct nfs3_createdata *data; 307 mode_t mode = sattr->ia_mode; 308 int status = -ENOMEM; 309 310 dprintk("NFS call create %s\n", dentry->d_name.name); 311 312 data = nfs3_alloc_createdata(); 313 if (data == NULL) 314 goto out; 315 316 data->msg.rpc_proc = &nfs3_procedures[NFS3PROC_CREATE]; 317 data->arg.create.fh = NFS_FH(dir); 318 data->arg.create.name = dentry->d_name.name; 319 data->arg.create.len = dentry->d_name.len; 320 data->arg.create.sattr = sattr; 321 322 data->arg.create.createmode = NFS3_CREATE_UNCHECKED; 323 if (flags & O_EXCL) { 324 data->arg.create.createmode = NFS3_CREATE_EXCLUSIVE; 325 data->arg.create.verifier[0] = jiffies; 326 data->arg.create.verifier[1] = current->pid; 327 } 328 329 sattr->ia_mode &= ~current->fs->umask; 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; 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(dentry->d_inode, data->res.fattr); 372 dprintk("NFS reply setattr (post-create): %d\n", status); 373 if (status != 0) 374 goto out; 375 } 376 status = nfs3_proc_set_default_acl(dir, dentry->d_inode, mode); 377 out: 378 nfs3_free_createdata(data); 379 dprintk("NFS reply create: %d\n", status); 380 return status; 381 } 382 383 static int 384 nfs3_proc_remove(struct inode *dir, struct qstr *name) 385 { 386 struct nfs_removeargs arg = { 387 .fh = NFS_FH(dir), 388 .name.len = name->len, 389 .name.name = name->name, 390 }; 391 struct nfs_removeres res; 392 struct rpc_message msg = { 393 .rpc_proc = &nfs3_procedures[NFS3PROC_REMOVE], 394 .rpc_argp = &arg, 395 .rpc_resp = &res, 396 }; 397 int status; 398 399 dprintk("NFS call remove %s\n", name->name); 400 nfs_fattr_init(&res.dir_attr); 401 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 402 nfs_post_op_update_inode(dir, &res.dir_attr); 403 dprintk("NFS reply remove: %d\n", status); 404 return status; 405 } 406 407 static void 408 nfs3_proc_unlink_setup(struct rpc_message *msg, struct inode *dir) 409 { 410 msg->rpc_proc = &nfs3_procedures[NFS3PROC_REMOVE]; 411 } 412 413 static int 414 nfs3_proc_unlink_done(struct rpc_task *task, struct inode *dir) 415 { 416 struct nfs_removeres *res; 417 if (nfs3_async_handle_jukebox(task, dir)) 418 return 0; 419 res = task->tk_msg.rpc_resp; 420 nfs_post_op_update_inode(dir, &res->dir_attr); 421 return 1; 422 } 423 424 static int 425 nfs3_proc_rename(struct inode *old_dir, struct qstr *old_name, 426 struct inode *new_dir, struct qstr *new_name) 427 { 428 struct nfs_fattr old_dir_attr, new_dir_attr; 429 struct nfs3_renameargs arg = { 430 .fromfh = NFS_FH(old_dir), 431 .fromname = old_name->name, 432 .fromlen = old_name->len, 433 .tofh = NFS_FH(new_dir), 434 .toname = new_name->name, 435 .tolen = new_name->len 436 }; 437 struct nfs3_renameres res = { 438 .fromattr = &old_dir_attr, 439 .toattr = &new_dir_attr 440 }; 441 struct rpc_message msg = { 442 .rpc_proc = &nfs3_procedures[NFS3PROC_RENAME], 443 .rpc_argp = &arg, 444 .rpc_resp = &res, 445 }; 446 int status; 447 448 dprintk("NFS call rename %s -> %s\n", old_name->name, new_name->name); 449 nfs_fattr_init(&old_dir_attr); 450 nfs_fattr_init(&new_dir_attr); 451 status = rpc_call_sync(NFS_CLIENT(old_dir), &msg, 0); 452 nfs_post_op_update_inode(old_dir, &old_dir_attr); 453 nfs_post_op_update_inode(new_dir, &new_dir_attr); 454 dprintk("NFS reply rename: %d\n", status); 455 return status; 456 } 457 458 static int 459 nfs3_proc_link(struct inode *inode, struct inode *dir, struct qstr *name) 460 { 461 struct nfs_fattr dir_attr, fattr; 462 struct nfs3_linkargs arg = { 463 .fromfh = NFS_FH(inode), 464 .tofh = NFS_FH(dir), 465 .toname = name->name, 466 .tolen = name->len 467 }; 468 struct nfs3_linkres res = { 469 .dir_attr = &dir_attr, 470 .fattr = &fattr 471 }; 472 struct rpc_message msg = { 473 .rpc_proc = &nfs3_procedures[NFS3PROC_LINK], 474 .rpc_argp = &arg, 475 .rpc_resp = &res, 476 }; 477 int status; 478 479 dprintk("NFS call link %s\n", name->name); 480 nfs_fattr_init(&dir_attr); 481 nfs_fattr_init(&fattr); 482 status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0); 483 nfs_post_op_update_inode(dir, &dir_attr); 484 nfs_post_op_update_inode(inode, &fattr); 485 dprintk("NFS reply link: %d\n", status); 486 return status; 487 } 488 489 static int 490 nfs3_proc_symlink(struct inode *dir, struct dentry *dentry, struct page *page, 491 unsigned int len, struct iattr *sattr) 492 { 493 struct nfs3_createdata *data; 494 int status = -ENOMEM; 495 496 if (len > NFS3_MAXPATHLEN) 497 return -ENAMETOOLONG; 498 499 dprintk("NFS call symlink %s\n", dentry->d_name.name); 500 501 data = nfs3_alloc_createdata(); 502 if (data == NULL) 503 goto out; 504 data->msg.rpc_proc = &nfs3_procedures[NFS3PROC_SYMLINK]; 505 data->arg.symlink.fromfh = NFS_FH(dir); 506 data->arg.symlink.fromname = dentry->d_name.name; 507 data->arg.symlink.fromlen = dentry->d_name.len; 508 data->arg.symlink.pages = &page; 509 data->arg.symlink.pathlen = len; 510 data->arg.symlink.sattr = sattr; 511 512 status = nfs3_do_create(dir, dentry, data); 513 514 nfs3_free_createdata(data); 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 nfs3_createdata *data; 524 int mode = sattr->ia_mode; 525 int status = -ENOMEM; 526 527 dprintk("NFS call mkdir %s\n", dentry->d_name.name); 528 529 sattr->ia_mode &= ~current->fs->umask; 530 531 data = nfs3_alloc_createdata(); 532 if (data == NULL) 533 goto out; 534 535 data->msg.rpc_proc = &nfs3_procedures[NFS3PROC_MKDIR]; 536 data->arg.mkdir.fh = NFS_FH(dir); 537 data->arg.mkdir.name = dentry->d_name.name; 538 data->arg.mkdir.len = dentry->d_name.len; 539 data->arg.mkdir.sattr = sattr; 540 541 status = nfs3_do_create(dir, dentry, data); 542 if (status != 0) 543 goto out; 544 545 status = nfs3_proc_set_default_acl(dir, dentry->d_inode, mode); 546 out: 547 nfs3_free_createdata(data); 548 dprintk("NFS reply mkdir: %d\n", status); 549 return status; 550 } 551 552 static int 553 nfs3_proc_rmdir(struct inode *dir, struct qstr *name) 554 { 555 struct nfs_fattr dir_attr; 556 struct nfs3_diropargs arg = { 557 .fh = NFS_FH(dir), 558 .name = name->name, 559 .len = name->len 560 }; 561 struct rpc_message msg = { 562 .rpc_proc = &nfs3_procedures[NFS3PROC_RMDIR], 563 .rpc_argp = &arg, 564 .rpc_resp = &dir_attr, 565 }; 566 int status; 567 568 dprintk("NFS call rmdir %s\n", name->name); 569 nfs_fattr_init(&dir_attr); 570 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 571 nfs_post_op_update_inode(dir, &dir_attr); 572 dprintk("NFS reply rmdir: %d\n", status); 573 return status; 574 } 575 576 /* 577 * The READDIR implementation is somewhat hackish - we pass the user buffer 578 * to the encode function, which installs it in the receive iovec. 579 * The decode function itself doesn't perform any decoding, it just makes 580 * sure the reply is syntactically correct. 581 * 582 * Also note that this implementation handles both plain readdir and 583 * readdirplus. 584 */ 585 static int 586 nfs3_proc_readdir(struct dentry *dentry, struct rpc_cred *cred, 587 u64 cookie, struct page *page, unsigned int count, int plus) 588 { 589 struct inode *dir = dentry->d_inode; 590 struct nfs_fattr dir_attr; 591 __be32 *verf = NFS_COOKIEVERF(dir); 592 struct nfs3_readdirargs arg = { 593 .fh = NFS_FH(dir), 594 .cookie = cookie, 595 .verf = {verf[0], verf[1]}, 596 .plus = plus, 597 .count = count, 598 .pages = &page 599 }; 600 struct nfs3_readdirres res = { 601 .dir_attr = &dir_attr, 602 .verf = verf, 603 .plus = plus 604 }; 605 struct rpc_message msg = { 606 .rpc_proc = &nfs3_procedures[NFS3PROC_READDIR], 607 .rpc_argp = &arg, 608 .rpc_resp = &res, 609 .rpc_cred = cred 610 }; 611 int status; 612 613 if (plus) 614 msg.rpc_proc = &nfs3_procedures[NFS3PROC_READDIRPLUS]; 615 616 dprintk("NFS call readdir%s %d\n", 617 plus? "plus" : "", (unsigned int) cookie); 618 619 nfs_fattr_init(&dir_attr); 620 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 621 622 nfs_invalidate_atime(dir); 623 624 nfs_refresh_inode(dir, &dir_attr); 625 dprintk("NFS reply readdir: %d\n", status); 626 return status; 627 } 628 629 static int 630 nfs3_proc_mknod(struct inode *dir, struct dentry *dentry, struct iattr *sattr, 631 dev_t rdev) 632 { 633 struct nfs3_createdata *data; 634 mode_t mode = sattr->ia_mode; 635 int status = -ENOMEM; 636 637 dprintk("NFS call mknod %s %u:%u\n", dentry->d_name.name, 638 MAJOR(rdev), MINOR(rdev)); 639 640 sattr->ia_mode &= ~current->fs->umask; 641 642 data = nfs3_alloc_createdata(); 643 if (data == NULL) 644 goto out; 645 646 data->msg.rpc_proc = &nfs3_procedures[NFS3PROC_MKNOD]; 647 data->arg.mknod.fh = NFS_FH(dir); 648 data->arg.mknod.name = dentry->d_name.name; 649 data->arg.mknod.len = dentry->d_name.len; 650 data->arg.mknod.sattr = sattr; 651 data->arg.mknod.rdev = rdev; 652 653 switch (sattr->ia_mode & S_IFMT) { 654 case S_IFBLK: 655 data->arg.mknod.type = NF3BLK; 656 break; 657 case S_IFCHR: 658 data->arg.mknod.type = NF3CHR; 659 break; 660 case S_IFIFO: 661 data->arg.mknod.type = NF3FIFO; 662 break; 663 case S_IFSOCK: 664 data->arg.mknod.type = NF3SOCK; 665 break; 666 default: 667 status = -EINVAL; 668 goto out; 669 } 670 671 status = nfs3_do_create(dir, dentry, data); 672 if (status != 0) 673 goto out; 674 status = nfs3_proc_set_default_acl(dir, dentry->d_inode, mode); 675 out: 676 nfs3_free_createdata(data); 677 dprintk("NFS reply mknod: %d\n", status); 678 return status; 679 } 680 681 static int 682 nfs3_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle, 683 struct nfs_fsstat *stat) 684 { 685 struct rpc_message msg = { 686 .rpc_proc = &nfs3_procedures[NFS3PROC_FSSTAT], 687 .rpc_argp = fhandle, 688 .rpc_resp = stat, 689 }; 690 int status; 691 692 dprintk("NFS call fsstat\n"); 693 nfs_fattr_init(stat->fattr); 694 status = rpc_call_sync(server->client, &msg, 0); 695 dprintk("NFS reply statfs: %d\n", status); 696 return status; 697 } 698 699 static int 700 nfs3_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, 701 struct nfs_fsinfo *info) 702 { 703 struct rpc_message msg = { 704 .rpc_proc = &nfs3_procedures[NFS3PROC_FSINFO], 705 .rpc_argp = fhandle, 706 .rpc_resp = info, 707 }; 708 int status; 709 710 dprintk("NFS call fsinfo\n"); 711 nfs_fattr_init(info->fattr); 712 status = rpc_call_sync(server->nfs_client->cl_rpcclient, &msg, 0); 713 dprintk("NFS reply fsinfo: %d\n", status); 714 return status; 715 } 716 717 static int 718 nfs3_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle, 719 struct nfs_pathconf *info) 720 { 721 struct rpc_message msg = { 722 .rpc_proc = &nfs3_procedures[NFS3PROC_PATHCONF], 723 .rpc_argp = fhandle, 724 .rpc_resp = info, 725 }; 726 int status; 727 728 dprintk("NFS call pathconf\n"); 729 nfs_fattr_init(info->fattr); 730 status = rpc_call_sync(server->client, &msg, 0); 731 dprintk("NFS reply pathconf: %d\n", status); 732 return status; 733 } 734 735 static int nfs3_read_done(struct rpc_task *task, struct nfs_read_data *data) 736 { 737 if (nfs3_async_handle_jukebox(task, data->inode)) 738 return -EAGAIN; 739 740 nfs_invalidate_atime(data->inode); 741 nfs_refresh_inode(data->inode, &data->fattr); 742 return 0; 743 } 744 745 static void nfs3_proc_read_setup(struct nfs_read_data *data, struct rpc_message *msg) 746 { 747 msg->rpc_proc = &nfs3_procedures[NFS3PROC_READ]; 748 } 749 750 static int nfs3_write_done(struct rpc_task *task, struct nfs_write_data *data) 751 { 752 if (nfs3_async_handle_jukebox(task, data->inode)) 753 return -EAGAIN; 754 if (task->tk_status >= 0) 755 nfs_post_op_update_inode_force_wcc(data->inode, data->res.fattr); 756 return 0; 757 } 758 759 static void nfs3_proc_write_setup(struct nfs_write_data *data, struct rpc_message *msg) 760 { 761 msg->rpc_proc = &nfs3_procedures[NFS3PROC_WRITE]; 762 } 763 764 static int nfs3_commit_done(struct rpc_task *task, struct nfs_write_data *data) 765 { 766 if (nfs3_async_handle_jukebox(task, data->inode)) 767 return -EAGAIN; 768 nfs_refresh_inode(data->inode, data->res.fattr); 769 return 0; 770 } 771 772 static void nfs3_proc_commit_setup(struct nfs_write_data *data, struct rpc_message *msg) 773 { 774 msg->rpc_proc = &nfs3_procedures[NFS3PROC_COMMIT]; 775 } 776 777 static int 778 nfs3_proc_lock(struct file *filp, int cmd, struct file_lock *fl) 779 { 780 struct inode *inode = filp->f_path.dentry->d_inode; 781 782 return nlmclnt_proc(NFS_SERVER(inode)->nlm_host, cmd, fl); 783 } 784 785 const struct nfs_rpc_ops nfs_v3_clientops = { 786 .version = 3, /* protocol version */ 787 .dentry_ops = &nfs_dentry_operations, 788 .dir_inode_ops = &nfs3_dir_inode_operations, 789 .file_inode_ops = &nfs3_file_inode_operations, 790 .getroot = nfs3_proc_get_root, 791 .getattr = nfs3_proc_getattr, 792 .setattr = nfs3_proc_setattr, 793 .lookup = nfs3_proc_lookup, 794 .access = nfs3_proc_access, 795 .readlink = nfs3_proc_readlink, 796 .create = nfs3_proc_create, 797 .remove = nfs3_proc_remove, 798 .unlink_setup = nfs3_proc_unlink_setup, 799 .unlink_done = nfs3_proc_unlink_done, 800 .rename = nfs3_proc_rename, 801 .link = nfs3_proc_link, 802 .symlink = nfs3_proc_symlink, 803 .mkdir = nfs3_proc_mkdir, 804 .rmdir = nfs3_proc_rmdir, 805 .readdir = nfs3_proc_readdir, 806 .mknod = nfs3_proc_mknod, 807 .statfs = nfs3_proc_statfs, 808 .fsinfo = nfs3_proc_fsinfo, 809 .pathconf = nfs3_proc_pathconf, 810 .decode_dirent = nfs3_decode_dirent, 811 .read_setup = nfs3_proc_read_setup, 812 .read_done = nfs3_read_done, 813 .write_setup = nfs3_proc_write_setup, 814 .write_done = nfs3_write_done, 815 .commit_setup = nfs3_proc_commit_setup, 816 .commit_done = nfs3_commit_done, 817 .file_open = nfs_open, 818 .file_release = nfs_release, 819 .lock = nfs3_proc_lock, 820 .clear_acl_cache = nfs3_forget_cached_acls, 821 }; 822