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