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 (!(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 rpc_clnt *clnt, 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, struct nfs_open_context *ctx) 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.len = name->len, 402 .name.name = name->name, 403 }; 404 struct nfs_removeres res; 405 struct rpc_message msg = { 406 .rpc_proc = &nfs3_procedures[NFS3PROC_REMOVE], 407 .rpc_argp = &arg, 408 .rpc_resp = &res, 409 }; 410 int status = -ENOMEM; 411 412 dprintk("NFS call remove %s\n", name->name); 413 res.dir_attr = nfs_alloc_fattr(); 414 if (res.dir_attr == NULL) 415 goto out; 416 417 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 418 nfs_post_op_update_inode(dir, res.dir_attr); 419 nfs_free_fattr(res.dir_attr); 420 out: 421 dprintk("NFS reply remove: %d\n", status); 422 return status; 423 } 424 425 static void 426 nfs3_proc_unlink_setup(struct rpc_message *msg, struct inode *dir) 427 { 428 msg->rpc_proc = &nfs3_procedures[NFS3PROC_REMOVE]; 429 } 430 431 static int 432 nfs3_proc_unlink_done(struct rpc_task *task, struct inode *dir) 433 { 434 struct nfs_removeres *res; 435 if (nfs3_async_handle_jukebox(task, dir)) 436 return 0; 437 res = task->tk_msg.rpc_resp; 438 nfs_post_op_update_inode(dir, res->dir_attr); 439 return 1; 440 } 441 442 static void 443 nfs3_proc_rename_setup(struct rpc_message *msg, struct inode *dir) 444 { 445 msg->rpc_proc = &nfs3_procedures[NFS3PROC_RENAME]; 446 } 447 448 static int 449 nfs3_proc_rename_done(struct rpc_task *task, struct inode *old_dir, 450 struct inode *new_dir) 451 { 452 struct nfs_renameres *res; 453 454 if (nfs3_async_handle_jukebox(task, old_dir)) 455 return 0; 456 res = task->tk_msg.rpc_resp; 457 458 nfs_post_op_update_inode(old_dir, res->old_fattr); 459 nfs_post_op_update_inode(new_dir, res->new_fattr); 460 return 1; 461 } 462 463 static int 464 nfs3_proc_rename(struct inode *old_dir, struct qstr *old_name, 465 struct inode *new_dir, struct qstr *new_name) 466 { 467 struct nfs_renameargs arg = { 468 .old_dir = NFS_FH(old_dir), 469 .old_name = old_name, 470 .new_dir = NFS_FH(new_dir), 471 .new_name = new_name, 472 }; 473 struct nfs_renameres res; 474 struct rpc_message msg = { 475 .rpc_proc = &nfs3_procedures[NFS3PROC_RENAME], 476 .rpc_argp = &arg, 477 .rpc_resp = &res, 478 }; 479 int status = -ENOMEM; 480 481 dprintk("NFS call rename %s -> %s\n", old_name->name, new_name->name); 482 483 res.old_fattr = nfs_alloc_fattr(); 484 res.new_fattr = nfs_alloc_fattr(); 485 if (res.old_fattr == NULL || res.new_fattr == NULL) 486 goto out; 487 488 status = rpc_call_sync(NFS_CLIENT(old_dir), &msg, 0); 489 nfs_post_op_update_inode(old_dir, res.old_fattr); 490 nfs_post_op_update_inode(new_dir, res.new_fattr); 491 out: 492 nfs_free_fattr(res.old_fattr); 493 nfs_free_fattr(res.new_fattr); 494 dprintk("NFS reply rename: %d\n", status); 495 return status; 496 } 497 498 static int 499 nfs3_proc_link(struct inode *inode, struct inode *dir, struct qstr *name) 500 { 501 struct nfs3_linkargs arg = { 502 .fromfh = NFS_FH(inode), 503 .tofh = NFS_FH(dir), 504 .toname = name->name, 505 .tolen = name->len 506 }; 507 struct nfs3_linkres res; 508 struct rpc_message msg = { 509 .rpc_proc = &nfs3_procedures[NFS3PROC_LINK], 510 .rpc_argp = &arg, 511 .rpc_resp = &res, 512 }; 513 int status = -ENOMEM; 514 515 dprintk("NFS call link %s\n", name->name); 516 res.fattr = nfs_alloc_fattr(); 517 res.dir_attr = nfs_alloc_fattr(); 518 if (res.fattr == NULL || res.dir_attr == NULL) 519 goto out; 520 521 status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0); 522 nfs_post_op_update_inode(dir, res.dir_attr); 523 nfs_post_op_update_inode(inode, res.fattr); 524 out: 525 nfs_free_fattr(res.dir_attr); 526 nfs_free_fattr(res.fattr); 527 dprintk("NFS reply link: %d\n", status); 528 return status; 529 } 530 531 static int 532 nfs3_proc_symlink(struct inode *dir, struct dentry *dentry, struct page *page, 533 unsigned int len, struct iattr *sattr) 534 { 535 struct nfs3_createdata *data; 536 int status = -ENOMEM; 537 538 if (len > NFS3_MAXPATHLEN) 539 return -ENAMETOOLONG; 540 541 dprintk("NFS call symlink %s\n", dentry->d_name.name); 542 543 data = nfs3_alloc_createdata(); 544 if (data == NULL) 545 goto out; 546 data->msg.rpc_proc = &nfs3_procedures[NFS3PROC_SYMLINK]; 547 data->arg.symlink.fromfh = NFS_FH(dir); 548 data->arg.symlink.fromname = dentry->d_name.name; 549 data->arg.symlink.fromlen = dentry->d_name.len; 550 data->arg.symlink.pages = &page; 551 data->arg.symlink.pathlen = len; 552 data->arg.symlink.sattr = sattr; 553 554 status = nfs3_do_create(dir, dentry, data); 555 556 nfs3_free_createdata(data); 557 out: 558 dprintk("NFS reply symlink: %d\n", status); 559 return status; 560 } 561 562 static int 563 nfs3_proc_mkdir(struct inode *dir, struct dentry *dentry, struct iattr *sattr) 564 { 565 struct nfs3_createdata *data; 566 umode_t mode = sattr->ia_mode; 567 int status = -ENOMEM; 568 569 dprintk("NFS call mkdir %s\n", dentry->d_name.name); 570 571 sattr->ia_mode &= ~current_umask(); 572 573 data = nfs3_alloc_createdata(); 574 if (data == NULL) 575 goto out; 576 577 data->msg.rpc_proc = &nfs3_procedures[NFS3PROC_MKDIR]; 578 data->arg.mkdir.fh = NFS_FH(dir); 579 data->arg.mkdir.name = dentry->d_name.name; 580 data->arg.mkdir.len = dentry->d_name.len; 581 data->arg.mkdir.sattr = sattr; 582 583 status = nfs3_do_create(dir, dentry, data); 584 if (status != 0) 585 goto out; 586 587 status = nfs3_proc_set_default_acl(dir, dentry->d_inode, mode); 588 out: 589 nfs3_free_createdata(data); 590 dprintk("NFS reply mkdir: %d\n", status); 591 return status; 592 } 593 594 static int 595 nfs3_proc_rmdir(struct inode *dir, struct qstr *name) 596 { 597 struct nfs_fattr *dir_attr; 598 struct nfs3_diropargs arg = { 599 .fh = NFS_FH(dir), 600 .name = name->name, 601 .len = name->len 602 }; 603 struct rpc_message msg = { 604 .rpc_proc = &nfs3_procedures[NFS3PROC_RMDIR], 605 .rpc_argp = &arg, 606 }; 607 int status = -ENOMEM; 608 609 dprintk("NFS call rmdir %s\n", name->name); 610 dir_attr = nfs_alloc_fattr(); 611 if (dir_attr == NULL) 612 goto out; 613 614 msg.rpc_resp = dir_attr; 615 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 616 nfs_post_op_update_inode(dir, dir_attr); 617 nfs_free_fattr(dir_attr); 618 out: 619 dprintk("NFS reply rmdir: %d\n", status); 620 return status; 621 } 622 623 /* 624 * The READDIR implementation is somewhat hackish - we pass the user buffer 625 * to the encode function, which installs it in the receive iovec. 626 * The decode function itself doesn't perform any decoding, it just makes 627 * sure the reply is syntactically correct. 628 * 629 * Also note that this implementation handles both plain readdir and 630 * readdirplus. 631 */ 632 static int 633 nfs3_proc_readdir(struct dentry *dentry, struct rpc_cred *cred, 634 u64 cookie, struct page **pages, unsigned int count, int plus) 635 { 636 struct inode *dir = dentry->d_inode; 637 __be32 *verf = NFS_COOKIEVERF(dir); 638 struct nfs3_readdirargs arg = { 639 .fh = NFS_FH(dir), 640 .cookie = cookie, 641 .verf = {verf[0], verf[1]}, 642 .plus = plus, 643 .count = count, 644 .pages = pages 645 }; 646 struct nfs3_readdirres res = { 647 .verf = verf, 648 .plus = plus 649 }; 650 struct rpc_message msg = { 651 .rpc_proc = &nfs3_procedures[NFS3PROC_READDIR], 652 .rpc_argp = &arg, 653 .rpc_resp = &res, 654 .rpc_cred = cred 655 }; 656 int status = -ENOMEM; 657 658 if (plus) 659 msg.rpc_proc = &nfs3_procedures[NFS3PROC_READDIRPLUS]; 660 661 dprintk("NFS call readdir%s %d\n", 662 plus? "plus" : "", (unsigned int) cookie); 663 664 res.dir_attr = nfs_alloc_fattr(); 665 if (res.dir_attr == NULL) 666 goto out; 667 668 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 669 670 nfs_invalidate_atime(dir); 671 nfs_refresh_inode(dir, res.dir_attr); 672 673 nfs_free_fattr(res.dir_attr); 674 out: 675 dprintk("NFS reply readdir%s: %d\n", 676 plus? "plus" : "", status); 677 return status; 678 } 679 680 static int 681 nfs3_proc_mknod(struct inode *dir, struct dentry *dentry, struct iattr *sattr, 682 dev_t rdev) 683 { 684 struct nfs3_createdata *data; 685 umode_t mode = sattr->ia_mode; 686 int status = -ENOMEM; 687 688 dprintk("NFS call mknod %s %u:%u\n", dentry->d_name.name, 689 MAJOR(rdev), MINOR(rdev)); 690 691 sattr->ia_mode &= ~current_umask(); 692 693 data = nfs3_alloc_createdata(); 694 if (data == NULL) 695 goto out; 696 697 data->msg.rpc_proc = &nfs3_procedures[NFS3PROC_MKNOD]; 698 data->arg.mknod.fh = NFS_FH(dir); 699 data->arg.mknod.name = dentry->d_name.name; 700 data->arg.mknod.len = dentry->d_name.len; 701 data->arg.mknod.sattr = sattr; 702 data->arg.mknod.rdev = rdev; 703 704 switch (sattr->ia_mode & S_IFMT) { 705 case S_IFBLK: 706 data->arg.mknod.type = NF3BLK; 707 break; 708 case S_IFCHR: 709 data->arg.mknod.type = NF3CHR; 710 break; 711 case S_IFIFO: 712 data->arg.mknod.type = NF3FIFO; 713 break; 714 case S_IFSOCK: 715 data->arg.mknod.type = NF3SOCK; 716 break; 717 default: 718 status = -EINVAL; 719 goto out; 720 } 721 722 status = nfs3_do_create(dir, dentry, data); 723 if (status != 0) 724 goto out; 725 status = nfs3_proc_set_default_acl(dir, dentry->d_inode, mode); 726 out: 727 nfs3_free_createdata(data); 728 dprintk("NFS reply mknod: %d\n", status); 729 return status; 730 } 731 732 static int 733 nfs3_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle, 734 struct nfs_fsstat *stat) 735 { 736 struct rpc_message msg = { 737 .rpc_proc = &nfs3_procedures[NFS3PROC_FSSTAT], 738 .rpc_argp = fhandle, 739 .rpc_resp = stat, 740 }; 741 int status; 742 743 dprintk("NFS call fsstat\n"); 744 nfs_fattr_init(stat->fattr); 745 status = rpc_call_sync(server->client, &msg, 0); 746 dprintk("NFS reply fsstat: %d\n", status); 747 return status; 748 } 749 750 static int 751 do_proc_fsinfo(struct rpc_clnt *client, struct nfs_fh *fhandle, 752 struct nfs_fsinfo *info) 753 { 754 struct rpc_message msg = { 755 .rpc_proc = &nfs3_procedures[NFS3PROC_FSINFO], 756 .rpc_argp = fhandle, 757 .rpc_resp = info, 758 }; 759 int status; 760 761 dprintk("NFS call fsinfo\n"); 762 nfs_fattr_init(info->fattr); 763 status = rpc_call_sync(client, &msg, 0); 764 dprintk("NFS reply fsinfo: %d\n", status); 765 return status; 766 } 767 768 /* 769 * Bare-bones access to fsinfo: this is for nfs_get_root/nfs_get_sb via 770 * nfs_create_server 771 */ 772 static int 773 nfs3_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, 774 struct nfs_fsinfo *info) 775 { 776 int status; 777 778 status = do_proc_fsinfo(server->client, fhandle, info); 779 if (status && server->nfs_client->cl_rpcclient != server->client) 780 status = do_proc_fsinfo(server->nfs_client->cl_rpcclient, fhandle, info); 781 return status; 782 } 783 784 static int 785 nfs3_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle, 786 struct nfs_pathconf *info) 787 { 788 struct rpc_message msg = { 789 .rpc_proc = &nfs3_procedures[NFS3PROC_PATHCONF], 790 .rpc_argp = fhandle, 791 .rpc_resp = info, 792 }; 793 int status; 794 795 dprintk("NFS call pathconf\n"); 796 nfs_fattr_init(info->fattr); 797 status = rpc_call_sync(server->client, &msg, 0); 798 dprintk("NFS reply pathconf: %d\n", status); 799 return status; 800 } 801 802 static int nfs3_read_done(struct rpc_task *task, struct nfs_read_data *data) 803 { 804 if (nfs3_async_handle_jukebox(task, data->inode)) 805 return -EAGAIN; 806 807 nfs_invalidate_atime(data->inode); 808 nfs_refresh_inode(data->inode, &data->fattr); 809 return 0; 810 } 811 812 static void nfs3_proc_read_setup(struct nfs_read_data *data, struct rpc_message *msg) 813 { 814 msg->rpc_proc = &nfs3_procedures[NFS3PROC_READ]; 815 } 816 817 static int nfs3_write_done(struct rpc_task *task, struct nfs_write_data *data) 818 { 819 if (nfs3_async_handle_jukebox(task, data->inode)) 820 return -EAGAIN; 821 if (task->tk_status >= 0) 822 nfs_post_op_update_inode_force_wcc(data->inode, data->res.fattr); 823 return 0; 824 } 825 826 static void nfs3_proc_write_setup(struct nfs_write_data *data, struct rpc_message *msg) 827 { 828 msg->rpc_proc = &nfs3_procedures[NFS3PROC_WRITE]; 829 } 830 831 static int nfs3_commit_done(struct rpc_task *task, struct nfs_write_data *data) 832 { 833 if (nfs3_async_handle_jukebox(task, data->inode)) 834 return -EAGAIN; 835 nfs_refresh_inode(data->inode, data->res.fattr); 836 return 0; 837 } 838 839 static void nfs3_proc_commit_setup(struct nfs_write_data *data, struct rpc_message *msg) 840 { 841 msg->rpc_proc = &nfs3_procedures[NFS3PROC_COMMIT]; 842 } 843 844 static int 845 nfs3_proc_lock(struct file *filp, int cmd, struct file_lock *fl) 846 { 847 struct inode *inode = filp->f_path.dentry->d_inode; 848 849 return nlmclnt_proc(NFS_SERVER(inode)->nlm_host, cmd, fl); 850 } 851 852 const struct nfs_rpc_ops nfs_v3_clientops = { 853 .version = 3, /* protocol version */ 854 .dentry_ops = &nfs_dentry_operations, 855 .dir_inode_ops = &nfs3_dir_inode_operations, 856 .file_inode_ops = &nfs3_file_inode_operations, 857 .file_ops = &nfs_file_operations, 858 .getroot = nfs3_proc_get_root, 859 .getattr = nfs3_proc_getattr, 860 .setattr = nfs3_proc_setattr, 861 .lookup = nfs3_proc_lookup, 862 .access = nfs3_proc_access, 863 .readlink = nfs3_proc_readlink, 864 .create = nfs3_proc_create, 865 .remove = nfs3_proc_remove, 866 .unlink_setup = nfs3_proc_unlink_setup, 867 .unlink_done = nfs3_proc_unlink_done, 868 .rename = nfs3_proc_rename, 869 .rename_setup = nfs3_proc_rename_setup, 870 .rename_done = nfs3_proc_rename_done, 871 .link = nfs3_proc_link, 872 .symlink = nfs3_proc_symlink, 873 .mkdir = nfs3_proc_mkdir, 874 .rmdir = nfs3_proc_rmdir, 875 .readdir = nfs3_proc_readdir, 876 .mknod = nfs3_proc_mknod, 877 .statfs = nfs3_proc_statfs, 878 .fsinfo = nfs3_proc_fsinfo, 879 .pathconf = nfs3_proc_pathconf, 880 .decode_dirent = nfs3_decode_dirent, 881 .read_setup = nfs3_proc_read_setup, 882 .read_done = nfs3_read_done, 883 .write_setup = nfs3_proc_write_setup, 884 .write_done = nfs3_write_done, 885 .commit_setup = nfs3_proc_commit_setup, 886 .commit_done = nfs3_commit_done, 887 .lock = nfs3_proc_lock, 888 .clear_acl_cache = nfs3_forget_cached_acls, 889 .close_context = nfs_close_context, 890 .init_client = nfs_init_client, 891 }; 892