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/slab.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 #include <linux/freezer.h> 21 #include <linux/xattr.h> 22 23 #include "iostat.h" 24 #include "internal.h" 25 26 #define NFSDBG_FACILITY NFSDBG_PROC 27 28 /* A wrapper to handle the EJUKEBOX error messages */ 29 static int 30 nfs3_rpc_wrapper(struct rpc_clnt *clnt, struct rpc_message *msg, int flags) 31 { 32 int res; 33 do { 34 res = rpc_call_sync(clnt, msg, flags); 35 if (res != -EJUKEBOX) 36 break; 37 freezable_schedule_timeout_killable_unsafe(NFS_JUKEBOX_RETRY_TIME); 38 res = -ERESTARTSYS; 39 } while (!fatal_signal_pending(current)); 40 return res; 41 } 42 43 #define rpc_call_sync(clnt, msg, flags) nfs3_rpc_wrapper(clnt, msg, flags) 44 45 static int 46 nfs3_async_handle_jukebox(struct rpc_task *task, struct inode *inode) 47 { 48 if (task->tk_status != -EJUKEBOX) 49 return 0; 50 if (task->tk_status == -EJUKEBOX) 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", __func__); 70 nfs_fattr_init(info->fattr); 71 status = rpc_call_sync(client, &msg, 0); 72 dprintk("%s: reply fsinfo: %d\n", __func__, status); 73 if (status == 0 && !(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", __func__, 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, struct nfs4_label *label) 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 if (sattr->ia_valid & ATTR_FILE) 136 msg.rpc_cred = nfs_file_cred(sattr->ia_file); 137 nfs_fattr_init(fattr); 138 status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0); 139 if (status == 0) 140 nfs_setattr_update_inode(inode, sattr); 141 dprintk("NFS reply setattr: %d\n", status); 142 return status; 143 } 144 145 static int 146 nfs3_proc_lookup(struct inode *dir, struct qstr *name, 147 struct nfs_fh *fhandle, struct nfs_fattr *fattr, 148 struct nfs4_label *label) 149 { 150 struct nfs3_diropargs arg = { 151 .fh = NFS_FH(dir), 152 .name = name->name, 153 .len = name->len 154 }; 155 struct nfs3_diropres res = { 156 .fh = fhandle, 157 .fattr = fattr 158 }; 159 struct rpc_message msg = { 160 .rpc_proc = &nfs3_procedures[NFS3PROC_LOOKUP], 161 .rpc_argp = &arg, 162 .rpc_resp = &res, 163 }; 164 int status; 165 166 dprintk("NFS call lookup %s\n", name->name); 167 res.dir_attr = nfs_alloc_fattr(); 168 if (res.dir_attr == NULL) 169 return -ENOMEM; 170 171 nfs_fattr_init(fattr); 172 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 173 nfs_refresh_inode(dir, res.dir_attr); 174 if (status >= 0 && !(fattr->valid & NFS_ATTR_FATTR)) { 175 msg.rpc_proc = &nfs3_procedures[NFS3PROC_GETATTR]; 176 msg.rpc_argp = fhandle; 177 msg.rpc_resp = fattr; 178 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 179 } 180 nfs_free_fattr(res.dir_attr); 181 dprintk("NFS reply lookup: %d\n", status); 182 return status; 183 } 184 185 static int nfs3_proc_access(struct inode *inode, struct nfs_access_entry *entry) 186 { 187 struct nfs3_accessargs arg = { 188 .fh = NFS_FH(inode), 189 }; 190 struct nfs3_accessres res; 191 struct rpc_message msg = { 192 .rpc_proc = &nfs3_procedures[NFS3PROC_ACCESS], 193 .rpc_argp = &arg, 194 .rpc_resp = &res, 195 .rpc_cred = entry->cred, 196 }; 197 int mode = entry->mask; 198 int status = -ENOMEM; 199 200 dprintk("NFS call access\n"); 201 202 if (mode & MAY_READ) 203 arg.access |= NFS3_ACCESS_READ; 204 if (S_ISDIR(inode->i_mode)) { 205 if (mode & MAY_WRITE) 206 arg.access |= NFS3_ACCESS_MODIFY | NFS3_ACCESS_EXTEND | NFS3_ACCESS_DELETE; 207 if (mode & MAY_EXEC) 208 arg.access |= NFS3_ACCESS_LOOKUP; 209 } else { 210 if (mode & MAY_WRITE) 211 arg.access |= NFS3_ACCESS_MODIFY | NFS3_ACCESS_EXTEND; 212 if (mode & MAY_EXEC) 213 arg.access |= NFS3_ACCESS_EXECUTE; 214 } 215 216 res.fattr = nfs_alloc_fattr(); 217 if (res.fattr == NULL) 218 goto out; 219 220 status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0); 221 nfs_refresh_inode(inode, res.fattr); 222 if (status == 0) { 223 entry->mask = 0; 224 if (res.access & NFS3_ACCESS_READ) 225 entry->mask |= MAY_READ; 226 if (res.access & (NFS3_ACCESS_MODIFY | NFS3_ACCESS_EXTEND | NFS3_ACCESS_DELETE)) 227 entry->mask |= MAY_WRITE; 228 if (res.access & (NFS3_ACCESS_LOOKUP|NFS3_ACCESS_EXECUTE)) 229 entry->mask |= MAY_EXEC; 230 } 231 nfs_free_fattr(res.fattr); 232 out: 233 dprintk("NFS reply access: %d\n", status); 234 return status; 235 } 236 237 static int nfs3_proc_readlink(struct inode *inode, struct page *page, 238 unsigned int pgbase, unsigned int pglen) 239 { 240 struct nfs_fattr *fattr; 241 struct nfs3_readlinkargs args = { 242 .fh = NFS_FH(inode), 243 .pgbase = pgbase, 244 .pglen = pglen, 245 .pages = &page 246 }; 247 struct rpc_message msg = { 248 .rpc_proc = &nfs3_procedures[NFS3PROC_READLINK], 249 .rpc_argp = &args, 250 }; 251 int status = -ENOMEM; 252 253 dprintk("NFS call readlink\n"); 254 fattr = nfs_alloc_fattr(); 255 if (fattr == NULL) 256 goto out; 257 msg.rpc_resp = fattr; 258 259 status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0); 260 nfs_refresh_inode(inode, fattr); 261 nfs_free_fattr(fattr); 262 out: 263 dprintk("NFS reply readlink: %d\n", status); 264 return status; 265 } 266 267 struct nfs3_createdata { 268 struct rpc_message msg; 269 union { 270 struct nfs3_createargs create; 271 struct nfs3_mkdirargs mkdir; 272 struct nfs3_symlinkargs symlink; 273 struct nfs3_mknodargs mknod; 274 } arg; 275 struct nfs3_diropres res; 276 struct nfs_fh fh; 277 struct nfs_fattr fattr; 278 struct nfs_fattr dir_attr; 279 }; 280 281 static struct nfs3_createdata *nfs3_alloc_createdata(void) 282 { 283 struct nfs3_createdata *data; 284 285 data = kzalloc(sizeof(*data), GFP_KERNEL); 286 if (data != NULL) { 287 data->msg.rpc_argp = &data->arg; 288 data->msg.rpc_resp = &data->res; 289 data->res.fh = &data->fh; 290 data->res.fattr = &data->fattr; 291 data->res.dir_attr = &data->dir_attr; 292 nfs_fattr_init(data->res.fattr); 293 nfs_fattr_init(data->res.dir_attr); 294 } 295 return data; 296 } 297 298 static int nfs3_do_create(struct inode *dir, struct dentry *dentry, struct nfs3_createdata *data) 299 { 300 int status; 301 302 status = rpc_call_sync(NFS_CLIENT(dir), &data->msg, 0); 303 nfs_post_op_update_inode(dir, data->res.dir_attr); 304 if (status == 0) 305 status = nfs_instantiate(dentry, data->res.fh, data->res.fattr, NULL); 306 return status; 307 } 308 309 static void nfs3_free_createdata(struct nfs3_createdata *data) 310 { 311 kfree(data); 312 } 313 314 /* 315 * Create a regular file. 316 */ 317 static int 318 nfs3_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr, 319 int flags) 320 { 321 struct posix_acl *default_acl, *acl; 322 struct nfs3_createdata *data; 323 int status = -ENOMEM; 324 325 dprintk("NFS call create %pd\n", dentry); 326 327 data = nfs3_alloc_createdata(); 328 if (data == NULL) 329 goto out; 330 331 data->msg.rpc_proc = &nfs3_procedures[NFS3PROC_CREATE]; 332 data->arg.create.fh = NFS_FH(dir); 333 data->arg.create.name = dentry->d_name.name; 334 data->arg.create.len = dentry->d_name.len; 335 data->arg.create.sattr = sattr; 336 337 data->arg.create.createmode = NFS3_CREATE_UNCHECKED; 338 if (flags & O_EXCL) { 339 data->arg.create.createmode = NFS3_CREATE_EXCLUSIVE; 340 data->arg.create.verifier[0] = cpu_to_be32(jiffies); 341 data->arg.create.verifier[1] = cpu_to_be32(current->pid); 342 } 343 344 status = posix_acl_create(dir, &sattr->ia_mode, &default_acl, &acl); 345 if (status) 346 goto out; 347 348 for (;;) { 349 status = nfs3_do_create(dir, dentry, data); 350 351 if (status != -ENOTSUPP) 352 break; 353 /* If the server doesn't support the exclusive creation 354 * semantics, try again with simple 'guarded' mode. */ 355 switch (data->arg.create.createmode) { 356 case NFS3_CREATE_EXCLUSIVE: 357 data->arg.create.createmode = NFS3_CREATE_GUARDED; 358 break; 359 360 case NFS3_CREATE_GUARDED: 361 data->arg.create.createmode = NFS3_CREATE_UNCHECKED; 362 break; 363 364 case NFS3_CREATE_UNCHECKED: 365 goto out; 366 } 367 nfs_fattr_init(data->res.dir_attr); 368 nfs_fattr_init(data->res.fattr); 369 } 370 371 if (status != 0) 372 goto out_release_acls; 373 374 /* When we created the file with exclusive semantics, make 375 * sure we set the attributes afterwards. */ 376 if (data->arg.create.createmode == NFS3_CREATE_EXCLUSIVE) { 377 dprintk("NFS call setattr (post-create)\n"); 378 379 if (!(sattr->ia_valid & ATTR_ATIME_SET)) 380 sattr->ia_valid |= ATTR_ATIME; 381 if (!(sattr->ia_valid & ATTR_MTIME_SET)) 382 sattr->ia_valid |= ATTR_MTIME; 383 384 /* Note: we could use a guarded setattr here, but I'm 385 * not sure this buys us anything (and I'd have 386 * to revamp the NFSv3 XDR code) */ 387 status = nfs3_proc_setattr(dentry, data->res.fattr, sattr); 388 nfs_post_op_update_inode(dentry->d_inode, data->res.fattr); 389 dprintk("NFS reply setattr (post-create): %d\n", status); 390 if (status != 0) 391 goto out_release_acls; 392 } 393 394 status = nfs3_proc_setacls(dentry->d_inode, acl, default_acl); 395 396 out_release_acls: 397 posix_acl_release(acl); 398 posix_acl_release(default_acl); 399 out: 400 nfs3_free_createdata(data); 401 dprintk("NFS reply create: %d\n", status); 402 return status; 403 } 404 405 static int 406 nfs3_proc_remove(struct inode *dir, struct qstr *name) 407 { 408 struct nfs_removeargs arg = { 409 .fh = NFS_FH(dir), 410 .name = *name, 411 }; 412 struct nfs_removeres res; 413 struct rpc_message msg = { 414 .rpc_proc = &nfs3_procedures[NFS3PROC_REMOVE], 415 .rpc_argp = &arg, 416 .rpc_resp = &res, 417 }; 418 int status = -ENOMEM; 419 420 dprintk("NFS call remove %s\n", name->name); 421 res.dir_attr = nfs_alloc_fattr(); 422 if (res.dir_attr == NULL) 423 goto out; 424 425 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 426 nfs_post_op_update_inode(dir, res.dir_attr); 427 nfs_free_fattr(res.dir_attr); 428 out: 429 dprintk("NFS reply remove: %d\n", status); 430 return status; 431 } 432 433 static void 434 nfs3_proc_unlink_setup(struct rpc_message *msg, struct inode *dir) 435 { 436 msg->rpc_proc = &nfs3_procedures[NFS3PROC_REMOVE]; 437 } 438 439 static void nfs3_proc_unlink_rpc_prepare(struct rpc_task *task, struct nfs_unlinkdata *data) 440 { 441 rpc_call_start(task); 442 } 443 444 static int 445 nfs3_proc_unlink_done(struct rpc_task *task, struct inode *dir) 446 { 447 struct nfs_removeres *res; 448 if (nfs3_async_handle_jukebox(task, dir)) 449 return 0; 450 res = task->tk_msg.rpc_resp; 451 nfs_post_op_update_inode(dir, res->dir_attr); 452 return 1; 453 } 454 455 static void 456 nfs3_proc_rename_setup(struct rpc_message *msg, struct inode *dir) 457 { 458 msg->rpc_proc = &nfs3_procedures[NFS3PROC_RENAME]; 459 } 460 461 static void nfs3_proc_rename_rpc_prepare(struct rpc_task *task, struct nfs_renamedata *data) 462 { 463 rpc_call_start(task); 464 } 465 466 static int 467 nfs3_proc_rename_done(struct rpc_task *task, struct inode *old_dir, 468 struct inode *new_dir) 469 { 470 struct nfs_renameres *res; 471 472 if (nfs3_async_handle_jukebox(task, old_dir)) 473 return 0; 474 res = task->tk_msg.rpc_resp; 475 476 nfs_post_op_update_inode(old_dir, res->old_fattr); 477 nfs_post_op_update_inode(new_dir, res->new_fattr); 478 return 1; 479 } 480 481 static int 482 nfs3_proc_rename(struct inode *old_dir, struct qstr *old_name, 483 struct inode *new_dir, struct qstr *new_name) 484 { 485 struct nfs_renameargs arg = { 486 .old_dir = NFS_FH(old_dir), 487 .old_name = old_name, 488 .new_dir = NFS_FH(new_dir), 489 .new_name = new_name, 490 }; 491 struct nfs_renameres res; 492 struct rpc_message msg = { 493 .rpc_proc = &nfs3_procedures[NFS3PROC_RENAME], 494 .rpc_argp = &arg, 495 .rpc_resp = &res, 496 }; 497 int status = -ENOMEM; 498 499 dprintk("NFS call rename %s -> %s\n", old_name->name, new_name->name); 500 501 res.old_fattr = nfs_alloc_fattr(); 502 res.new_fattr = nfs_alloc_fattr(); 503 if (res.old_fattr == NULL || res.new_fattr == NULL) 504 goto out; 505 506 status = rpc_call_sync(NFS_CLIENT(old_dir), &msg, 0); 507 nfs_post_op_update_inode(old_dir, res.old_fattr); 508 nfs_post_op_update_inode(new_dir, res.new_fattr); 509 out: 510 nfs_free_fattr(res.old_fattr); 511 nfs_free_fattr(res.new_fattr); 512 dprintk("NFS reply rename: %d\n", status); 513 return status; 514 } 515 516 static int 517 nfs3_proc_link(struct inode *inode, struct inode *dir, struct qstr *name) 518 { 519 struct nfs3_linkargs arg = { 520 .fromfh = NFS_FH(inode), 521 .tofh = NFS_FH(dir), 522 .toname = name->name, 523 .tolen = name->len 524 }; 525 struct nfs3_linkres res; 526 struct rpc_message msg = { 527 .rpc_proc = &nfs3_procedures[NFS3PROC_LINK], 528 .rpc_argp = &arg, 529 .rpc_resp = &res, 530 }; 531 int status = -ENOMEM; 532 533 dprintk("NFS call link %s\n", name->name); 534 res.fattr = nfs_alloc_fattr(); 535 res.dir_attr = nfs_alloc_fattr(); 536 if (res.fattr == NULL || res.dir_attr == NULL) 537 goto out; 538 539 status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0); 540 nfs_post_op_update_inode(dir, res.dir_attr); 541 nfs_post_op_update_inode(inode, res.fattr); 542 out: 543 nfs_free_fattr(res.dir_attr); 544 nfs_free_fattr(res.fattr); 545 dprintk("NFS reply link: %d\n", status); 546 return status; 547 } 548 549 static int 550 nfs3_proc_symlink(struct inode *dir, struct dentry *dentry, struct page *page, 551 unsigned int len, struct iattr *sattr) 552 { 553 struct nfs3_createdata *data; 554 int status = -ENOMEM; 555 556 if (len > NFS3_MAXPATHLEN) 557 return -ENAMETOOLONG; 558 559 dprintk("NFS call symlink %pd\n", dentry); 560 561 data = nfs3_alloc_createdata(); 562 if (data == NULL) 563 goto out; 564 data->msg.rpc_proc = &nfs3_procedures[NFS3PROC_SYMLINK]; 565 data->arg.symlink.fromfh = NFS_FH(dir); 566 data->arg.symlink.fromname = dentry->d_name.name; 567 data->arg.symlink.fromlen = dentry->d_name.len; 568 data->arg.symlink.pages = &page; 569 data->arg.symlink.pathlen = len; 570 data->arg.symlink.sattr = sattr; 571 572 status = nfs3_do_create(dir, dentry, data); 573 574 nfs3_free_createdata(data); 575 out: 576 dprintk("NFS reply symlink: %d\n", status); 577 return status; 578 } 579 580 static int 581 nfs3_proc_mkdir(struct inode *dir, struct dentry *dentry, struct iattr *sattr) 582 { 583 struct posix_acl *default_acl, *acl; 584 struct nfs3_createdata *data; 585 int status = -ENOMEM; 586 587 dprintk("NFS call mkdir %pd\n", dentry); 588 589 data = nfs3_alloc_createdata(); 590 if (data == NULL) 591 goto out; 592 593 status = posix_acl_create(dir, &sattr->ia_mode, &default_acl, &acl); 594 if (status) 595 goto out; 596 597 data->msg.rpc_proc = &nfs3_procedures[NFS3PROC_MKDIR]; 598 data->arg.mkdir.fh = NFS_FH(dir); 599 data->arg.mkdir.name = dentry->d_name.name; 600 data->arg.mkdir.len = dentry->d_name.len; 601 data->arg.mkdir.sattr = sattr; 602 603 status = nfs3_do_create(dir, dentry, data); 604 if (status != 0) 605 goto out_release_acls; 606 607 status = nfs3_proc_setacls(dentry->d_inode, acl, default_acl); 608 609 out_release_acls: 610 posix_acl_release(acl); 611 posix_acl_release(default_acl); 612 out: 613 nfs3_free_createdata(data); 614 dprintk("NFS reply mkdir: %d\n", status); 615 return status; 616 } 617 618 static int 619 nfs3_proc_rmdir(struct inode *dir, struct qstr *name) 620 { 621 struct nfs_fattr *dir_attr; 622 struct nfs3_diropargs arg = { 623 .fh = NFS_FH(dir), 624 .name = name->name, 625 .len = name->len 626 }; 627 struct rpc_message msg = { 628 .rpc_proc = &nfs3_procedures[NFS3PROC_RMDIR], 629 .rpc_argp = &arg, 630 }; 631 int status = -ENOMEM; 632 633 dprintk("NFS call rmdir %s\n", name->name); 634 dir_attr = nfs_alloc_fattr(); 635 if (dir_attr == NULL) 636 goto out; 637 638 msg.rpc_resp = dir_attr; 639 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 640 nfs_post_op_update_inode(dir, dir_attr); 641 nfs_free_fattr(dir_attr); 642 out: 643 dprintk("NFS reply rmdir: %d\n", status); 644 return status; 645 } 646 647 /* 648 * The READDIR implementation is somewhat hackish - we pass the user buffer 649 * to the encode function, which installs it in the receive iovec. 650 * The decode function itself doesn't perform any decoding, it just makes 651 * sure the reply is syntactically correct. 652 * 653 * Also note that this implementation handles both plain readdir and 654 * readdirplus. 655 */ 656 static int 657 nfs3_proc_readdir(struct dentry *dentry, struct rpc_cred *cred, 658 u64 cookie, struct page **pages, unsigned int count, int plus) 659 { 660 struct inode *dir = dentry->d_inode; 661 __be32 *verf = NFS_I(dir)->cookieverf; 662 struct nfs3_readdirargs arg = { 663 .fh = NFS_FH(dir), 664 .cookie = cookie, 665 .verf = {verf[0], verf[1]}, 666 .plus = plus, 667 .count = count, 668 .pages = pages 669 }; 670 struct nfs3_readdirres res = { 671 .verf = verf, 672 .plus = plus 673 }; 674 struct rpc_message msg = { 675 .rpc_proc = &nfs3_procedures[NFS3PROC_READDIR], 676 .rpc_argp = &arg, 677 .rpc_resp = &res, 678 .rpc_cred = cred 679 }; 680 int status = -ENOMEM; 681 682 if (plus) 683 msg.rpc_proc = &nfs3_procedures[NFS3PROC_READDIRPLUS]; 684 685 dprintk("NFS call readdir%s %d\n", 686 plus? "plus" : "", (unsigned int) cookie); 687 688 res.dir_attr = nfs_alloc_fattr(); 689 if (res.dir_attr == NULL) 690 goto out; 691 692 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 693 694 nfs_invalidate_atime(dir); 695 nfs_refresh_inode(dir, res.dir_attr); 696 697 nfs_free_fattr(res.dir_attr); 698 out: 699 dprintk("NFS reply readdir%s: %d\n", 700 plus? "plus" : "", status); 701 return status; 702 } 703 704 static int 705 nfs3_proc_mknod(struct inode *dir, struct dentry *dentry, struct iattr *sattr, 706 dev_t rdev) 707 { 708 struct posix_acl *default_acl, *acl; 709 struct nfs3_createdata *data; 710 int status = -ENOMEM; 711 712 dprintk("NFS call mknod %pd %u:%u\n", dentry, 713 MAJOR(rdev), MINOR(rdev)); 714 715 data = nfs3_alloc_createdata(); 716 if (data == NULL) 717 goto out; 718 719 status = posix_acl_create(dir, &sattr->ia_mode, &default_acl, &acl); 720 if (status) 721 goto out; 722 723 data->msg.rpc_proc = &nfs3_procedures[NFS3PROC_MKNOD]; 724 data->arg.mknod.fh = NFS_FH(dir); 725 data->arg.mknod.name = dentry->d_name.name; 726 data->arg.mknod.len = dentry->d_name.len; 727 data->arg.mknod.sattr = sattr; 728 data->arg.mknod.rdev = rdev; 729 730 switch (sattr->ia_mode & S_IFMT) { 731 case S_IFBLK: 732 data->arg.mknod.type = NF3BLK; 733 break; 734 case S_IFCHR: 735 data->arg.mknod.type = NF3CHR; 736 break; 737 case S_IFIFO: 738 data->arg.mknod.type = NF3FIFO; 739 break; 740 case S_IFSOCK: 741 data->arg.mknod.type = NF3SOCK; 742 break; 743 default: 744 status = -EINVAL; 745 goto out; 746 } 747 748 status = nfs3_do_create(dir, dentry, data); 749 if (status != 0) 750 goto out_release_acls; 751 752 status = nfs3_proc_setacls(dentry->d_inode, acl, default_acl); 753 754 out_release_acls: 755 posix_acl_release(acl); 756 posix_acl_release(default_acl); 757 out: 758 nfs3_free_createdata(data); 759 dprintk("NFS reply mknod: %d\n", status); 760 return status; 761 } 762 763 static int 764 nfs3_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle, 765 struct nfs_fsstat *stat) 766 { 767 struct rpc_message msg = { 768 .rpc_proc = &nfs3_procedures[NFS3PROC_FSSTAT], 769 .rpc_argp = fhandle, 770 .rpc_resp = stat, 771 }; 772 int status; 773 774 dprintk("NFS call fsstat\n"); 775 nfs_fattr_init(stat->fattr); 776 status = rpc_call_sync(server->client, &msg, 0); 777 dprintk("NFS reply fsstat: %d\n", status); 778 return status; 779 } 780 781 static int 782 do_proc_fsinfo(struct rpc_clnt *client, struct nfs_fh *fhandle, 783 struct nfs_fsinfo *info) 784 { 785 struct rpc_message msg = { 786 .rpc_proc = &nfs3_procedures[NFS3PROC_FSINFO], 787 .rpc_argp = fhandle, 788 .rpc_resp = info, 789 }; 790 int status; 791 792 dprintk("NFS call fsinfo\n"); 793 nfs_fattr_init(info->fattr); 794 status = rpc_call_sync(client, &msg, 0); 795 dprintk("NFS reply fsinfo: %d\n", status); 796 return status; 797 } 798 799 /* 800 * Bare-bones access to fsinfo: this is for nfs_get_root/nfs_get_sb via 801 * nfs_create_server 802 */ 803 static int 804 nfs3_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, 805 struct nfs_fsinfo *info) 806 { 807 int status; 808 809 status = do_proc_fsinfo(server->client, fhandle, info); 810 if (status && server->nfs_client->cl_rpcclient != server->client) 811 status = do_proc_fsinfo(server->nfs_client->cl_rpcclient, fhandle, info); 812 return status; 813 } 814 815 static int 816 nfs3_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle, 817 struct nfs_pathconf *info) 818 { 819 struct rpc_message msg = { 820 .rpc_proc = &nfs3_procedures[NFS3PROC_PATHCONF], 821 .rpc_argp = fhandle, 822 .rpc_resp = info, 823 }; 824 int status; 825 826 dprintk("NFS call pathconf\n"); 827 nfs_fattr_init(info->fattr); 828 status = rpc_call_sync(server->client, &msg, 0); 829 dprintk("NFS reply pathconf: %d\n", status); 830 return status; 831 } 832 833 static int nfs3_read_done(struct rpc_task *task, struct nfs_read_data *data) 834 { 835 struct inode *inode = data->header->inode; 836 837 if (nfs3_async_handle_jukebox(task, inode)) 838 return -EAGAIN; 839 840 nfs_invalidate_atime(inode); 841 nfs_refresh_inode(inode, &data->fattr); 842 return 0; 843 } 844 845 static void nfs3_proc_read_setup(struct nfs_read_data *data, struct rpc_message *msg) 846 { 847 msg->rpc_proc = &nfs3_procedures[NFS3PROC_READ]; 848 } 849 850 static int nfs3_proc_read_rpc_prepare(struct rpc_task *task, struct nfs_read_data *data) 851 { 852 rpc_call_start(task); 853 return 0; 854 } 855 856 static int nfs3_write_done(struct rpc_task *task, struct nfs_write_data *data) 857 { 858 struct inode *inode = data->header->inode; 859 860 if (nfs3_async_handle_jukebox(task, inode)) 861 return -EAGAIN; 862 if (task->tk_status >= 0) 863 nfs_post_op_update_inode_force_wcc(inode, data->res.fattr); 864 return 0; 865 } 866 867 static void nfs3_proc_write_setup(struct nfs_write_data *data, struct rpc_message *msg) 868 { 869 msg->rpc_proc = &nfs3_procedures[NFS3PROC_WRITE]; 870 } 871 872 static int nfs3_proc_write_rpc_prepare(struct rpc_task *task, struct nfs_write_data *data) 873 { 874 rpc_call_start(task); 875 return 0; 876 } 877 878 static void nfs3_proc_commit_rpc_prepare(struct rpc_task *task, struct nfs_commit_data *data) 879 { 880 rpc_call_start(task); 881 } 882 883 static int nfs3_commit_done(struct rpc_task *task, struct nfs_commit_data *data) 884 { 885 if (nfs3_async_handle_jukebox(task, data->inode)) 886 return -EAGAIN; 887 nfs_refresh_inode(data->inode, data->res.fattr); 888 return 0; 889 } 890 891 static void nfs3_proc_commit_setup(struct nfs_commit_data *data, struct rpc_message *msg) 892 { 893 msg->rpc_proc = &nfs3_procedures[NFS3PROC_COMMIT]; 894 } 895 896 static int 897 nfs3_proc_lock(struct file *filp, int cmd, struct file_lock *fl) 898 { 899 struct inode *inode = file_inode(filp); 900 901 return nlmclnt_proc(NFS_SERVER(inode)->nlm_host, cmd, fl); 902 } 903 904 static int nfs3_have_delegation(struct inode *inode, fmode_t flags) 905 { 906 return 0; 907 } 908 909 static int nfs3_return_delegation(struct inode *inode) 910 { 911 nfs_wb_all(inode); 912 return 0; 913 } 914 915 static const struct inode_operations nfs3_dir_inode_operations = { 916 .create = nfs_create, 917 .lookup = nfs_lookup, 918 .link = nfs_link, 919 .unlink = nfs_unlink, 920 .symlink = nfs_symlink, 921 .mkdir = nfs_mkdir, 922 .rmdir = nfs_rmdir, 923 .mknod = nfs_mknod, 924 .rename = nfs_rename, 925 .permission = nfs_permission, 926 .getattr = nfs_getattr, 927 .setattr = nfs_setattr, 928 #ifdef CONFIG_NFS_V3_ACL 929 .listxattr = generic_listxattr, 930 .getxattr = generic_getxattr, 931 .setxattr = generic_setxattr, 932 .removexattr = generic_removexattr, 933 .get_acl = nfs3_get_acl, 934 .set_acl = nfs3_set_acl, 935 #endif 936 }; 937 938 static const struct inode_operations nfs3_file_inode_operations = { 939 .permission = nfs_permission, 940 .getattr = nfs_getattr, 941 .setattr = nfs_setattr, 942 #ifdef CONFIG_NFS_V3_ACL 943 .listxattr = generic_listxattr, 944 .getxattr = generic_getxattr, 945 .setxattr = generic_setxattr, 946 .removexattr = generic_removexattr, 947 .get_acl = nfs3_get_acl, 948 .set_acl = nfs3_set_acl, 949 #endif 950 }; 951 952 const struct nfs_rpc_ops nfs_v3_clientops = { 953 .version = 3, /* protocol version */ 954 .dentry_ops = &nfs_dentry_operations, 955 .dir_inode_ops = &nfs3_dir_inode_operations, 956 .file_inode_ops = &nfs3_file_inode_operations, 957 .file_ops = &nfs_file_operations, 958 .getroot = nfs3_proc_get_root, 959 .submount = nfs_submount, 960 .try_mount = nfs_try_mount, 961 .getattr = nfs3_proc_getattr, 962 .setattr = nfs3_proc_setattr, 963 .lookup = nfs3_proc_lookup, 964 .access = nfs3_proc_access, 965 .readlink = nfs3_proc_readlink, 966 .create = nfs3_proc_create, 967 .remove = nfs3_proc_remove, 968 .unlink_setup = nfs3_proc_unlink_setup, 969 .unlink_rpc_prepare = nfs3_proc_unlink_rpc_prepare, 970 .unlink_done = nfs3_proc_unlink_done, 971 .rename = nfs3_proc_rename, 972 .rename_setup = nfs3_proc_rename_setup, 973 .rename_rpc_prepare = nfs3_proc_rename_rpc_prepare, 974 .rename_done = nfs3_proc_rename_done, 975 .link = nfs3_proc_link, 976 .symlink = nfs3_proc_symlink, 977 .mkdir = nfs3_proc_mkdir, 978 .rmdir = nfs3_proc_rmdir, 979 .readdir = nfs3_proc_readdir, 980 .mknod = nfs3_proc_mknod, 981 .statfs = nfs3_proc_statfs, 982 .fsinfo = nfs3_proc_fsinfo, 983 .pathconf = nfs3_proc_pathconf, 984 .decode_dirent = nfs3_decode_dirent, 985 .read_setup = nfs3_proc_read_setup, 986 .read_pageio_init = nfs_pageio_init_read, 987 .read_rpc_prepare = nfs3_proc_read_rpc_prepare, 988 .read_done = nfs3_read_done, 989 .write_setup = nfs3_proc_write_setup, 990 .write_pageio_init = nfs_pageio_init_write, 991 .write_rpc_prepare = nfs3_proc_write_rpc_prepare, 992 .write_done = nfs3_write_done, 993 .commit_setup = nfs3_proc_commit_setup, 994 .commit_rpc_prepare = nfs3_proc_commit_rpc_prepare, 995 .commit_done = nfs3_commit_done, 996 .lock = nfs3_proc_lock, 997 .clear_acl_cache = forget_all_cached_acls, 998 .close_context = nfs_close_context, 999 .have_delegation = nfs3_have_delegation, 1000 .return_delegation = nfs3_return_delegation, 1001 .alloc_client = nfs_alloc_client, 1002 .init_client = nfs_init_client, 1003 .free_client = nfs_free_client, 1004 .create_server = nfs3_create_server, 1005 .clone_server = nfs3_clone_server, 1006 }; 1007