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