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