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