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_link(struct inode *inode, struct inode *dir, struct qstr *name) 483 { 484 struct nfs3_linkargs arg = { 485 .fromfh = NFS_FH(inode), 486 .tofh = NFS_FH(dir), 487 .toname = name->name, 488 .tolen = name->len 489 }; 490 struct nfs3_linkres res; 491 struct rpc_message msg = { 492 .rpc_proc = &nfs3_procedures[NFS3PROC_LINK], 493 .rpc_argp = &arg, 494 .rpc_resp = &res, 495 }; 496 int status = -ENOMEM; 497 498 dprintk("NFS call link %s\n", name->name); 499 res.fattr = nfs_alloc_fattr(); 500 res.dir_attr = nfs_alloc_fattr(); 501 if (res.fattr == NULL || res.dir_attr == NULL) 502 goto out; 503 504 status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0); 505 nfs_post_op_update_inode(dir, res.dir_attr); 506 nfs_post_op_update_inode(inode, res.fattr); 507 out: 508 nfs_free_fattr(res.dir_attr); 509 nfs_free_fattr(res.fattr); 510 dprintk("NFS reply link: %d\n", status); 511 return status; 512 } 513 514 static int 515 nfs3_proc_symlink(struct inode *dir, struct dentry *dentry, struct page *page, 516 unsigned int len, struct iattr *sattr) 517 { 518 struct nfs3_createdata *data; 519 int status = -ENOMEM; 520 521 if (len > NFS3_MAXPATHLEN) 522 return -ENAMETOOLONG; 523 524 dprintk("NFS call symlink %pd\n", dentry); 525 526 data = nfs3_alloc_createdata(); 527 if (data == NULL) 528 goto out; 529 data->msg.rpc_proc = &nfs3_procedures[NFS3PROC_SYMLINK]; 530 data->arg.symlink.fromfh = NFS_FH(dir); 531 data->arg.symlink.fromname = dentry->d_name.name; 532 data->arg.symlink.fromlen = dentry->d_name.len; 533 data->arg.symlink.pages = &page; 534 data->arg.symlink.pathlen = len; 535 data->arg.symlink.sattr = sattr; 536 537 status = nfs3_do_create(dir, dentry, data); 538 539 nfs3_free_createdata(data); 540 out: 541 dprintk("NFS reply symlink: %d\n", status); 542 return status; 543 } 544 545 static int 546 nfs3_proc_mkdir(struct inode *dir, struct dentry *dentry, struct iattr *sattr) 547 { 548 struct posix_acl *default_acl, *acl; 549 struct nfs3_createdata *data; 550 int status = -ENOMEM; 551 552 dprintk("NFS call mkdir %pd\n", dentry); 553 554 data = nfs3_alloc_createdata(); 555 if (data == NULL) 556 goto out; 557 558 status = posix_acl_create(dir, &sattr->ia_mode, &default_acl, &acl); 559 if (status) 560 goto out; 561 562 data->msg.rpc_proc = &nfs3_procedures[NFS3PROC_MKDIR]; 563 data->arg.mkdir.fh = NFS_FH(dir); 564 data->arg.mkdir.name = dentry->d_name.name; 565 data->arg.mkdir.len = dentry->d_name.len; 566 data->arg.mkdir.sattr = sattr; 567 568 status = nfs3_do_create(dir, dentry, data); 569 if (status != 0) 570 goto out_release_acls; 571 572 status = nfs3_proc_setacls(dentry->d_inode, acl, default_acl); 573 574 out_release_acls: 575 posix_acl_release(acl); 576 posix_acl_release(default_acl); 577 out: 578 nfs3_free_createdata(data); 579 dprintk("NFS reply mkdir: %d\n", status); 580 return status; 581 } 582 583 static int 584 nfs3_proc_rmdir(struct inode *dir, struct qstr *name) 585 { 586 struct nfs_fattr *dir_attr; 587 struct nfs3_diropargs arg = { 588 .fh = NFS_FH(dir), 589 .name = name->name, 590 .len = name->len 591 }; 592 struct rpc_message msg = { 593 .rpc_proc = &nfs3_procedures[NFS3PROC_RMDIR], 594 .rpc_argp = &arg, 595 }; 596 int status = -ENOMEM; 597 598 dprintk("NFS call rmdir %s\n", name->name); 599 dir_attr = nfs_alloc_fattr(); 600 if (dir_attr == NULL) 601 goto out; 602 603 msg.rpc_resp = dir_attr; 604 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 605 nfs_post_op_update_inode(dir, dir_attr); 606 nfs_free_fattr(dir_attr); 607 out: 608 dprintk("NFS reply rmdir: %d\n", status); 609 return status; 610 } 611 612 /* 613 * The READDIR implementation is somewhat hackish - we pass the user buffer 614 * to the encode function, which installs it in the receive iovec. 615 * The decode function itself doesn't perform any decoding, it just makes 616 * sure the reply is syntactically correct. 617 * 618 * Also note that this implementation handles both plain readdir and 619 * readdirplus. 620 */ 621 static int 622 nfs3_proc_readdir(struct dentry *dentry, struct rpc_cred *cred, 623 u64 cookie, struct page **pages, unsigned int count, int plus) 624 { 625 struct inode *dir = dentry->d_inode; 626 __be32 *verf = NFS_I(dir)->cookieverf; 627 struct nfs3_readdirargs arg = { 628 .fh = NFS_FH(dir), 629 .cookie = cookie, 630 .verf = {verf[0], verf[1]}, 631 .plus = plus, 632 .count = count, 633 .pages = pages 634 }; 635 struct nfs3_readdirres res = { 636 .verf = verf, 637 .plus = plus 638 }; 639 struct rpc_message msg = { 640 .rpc_proc = &nfs3_procedures[NFS3PROC_READDIR], 641 .rpc_argp = &arg, 642 .rpc_resp = &res, 643 .rpc_cred = cred 644 }; 645 int status = -ENOMEM; 646 647 if (plus) 648 msg.rpc_proc = &nfs3_procedures[NFS3PROC_READDIRPLUS]; 649 650 dprintk("NFS call readdir%s %d\n", 651 plus? "plus" : "", (unsigned int) cookie); 652 653 res.dir_attr = nfs_alloc_fattr(); 654 if (res.dir_attr == NULL) 655 goto out; 656 657 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 658 659 nfs_invalidate_atime(dir); 660 nfs_refresh_inode(dir, res.dir_attr); 661 662 nfs_free_fattr(res.dir_attr); 663 out: 664 dprintk("NFS reply readdir%s: %d\n", 665 plus? "plus" : "", status); 666 return status; 667 } 668 669 static int 670 nfs3_proc_mknod(struct inode *dir, struct dentry *dentry, struct iattr *sattr, 671 dev_t rdev) 672 { 673 struct posix_acl *default_acl, *acl; 674 struct nfs3_createdata *data; 675 int status = -ENOMEM; 676 677 dprintk("NFS call mknod %pd %u:%u\n", dentry, 678 MAJOR(rdev), MINOR(rdev)); 679 680 data = nfs3_alloc_createdata(); 681 if (data == NULL) 682 goto out; 683 684 status = posix_acl_create(dir, &sattr->ia_mode, &default_acl, &acl); 685 if (status) 686 goto out; 687 688 data->msg.rpc_proc = &nfs3_procedures[NFS3PROC_MKNOD]; 689 data->arg.mknod.fh = NFS_FH(dir); 690 data->arg.mknod.name = dentry->d_name.name; 691 data->arg.mknod.len = dentry->d_name.len; 692 data->arg.mknod.sattr = sattr; 693 data->arg.mknod.rdev = rdev; 694 695 switch (sattr->ia_mode & S_IFMT) { 696 case S_IFBLK: 697 data->arg.mknod.type = NF3BLK; 698 break; 699 case S_IFCHR: 700 data->arg.mknod.type = NF3CHR; 701 break; 702 case S_IFIFO: 703 data->arg.mknod.type = NF3FIFO; 704 break; 705 case S_IFSOCK: 706 data->arg.mknod.type = NF3SOCK; 707 break; 708 default: 709 status = -EINVAL; 710 goto out; 711 } 712 713 status = nfs3_do_create(dir, dentry, data); 714 if (status != 0) 715 goto out_release_acls; 716 717 status = nfs3_proc_setacls(dentry->d_inode, acl, default_acl); 718 719 out_release_acls: 720 posix_acl_release(acl); 721 posix_acl_release(default_acl); 722 out: 723 nfs3_free_createdata(data); 724 dprintk("NFS reply mknod: %d\n", status); 725 return status; 726 } 727 728 static int 729 nfs3_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle, 730 struct nfs_fsstat *stat) 731 { 732 struct rpc_message msg = { 733 .rpc_proc = &nfs3_procedures[NFS3PROC_FSSTAT], 734 .rpc_argp = fhandle, 735 .rpc_resp = stat, 736 }; 737 int status; 738 739 dprintk("NFS call fsstat\n"); 740 nfs_fattr_init(stat->fattr); 741 status = rpc_call_sync(server->client, &msg, 0); 742 dprintk("NFS reply fsstat: %d\n", status); 743 return status; 744 } 745 746 static int 747 do_proc_fsinfo(struct rpc_clnt *client, struct nfs_fh *fhandle, 748 struct nfs_fsinfo *info) 749 { 750 struct rpc_message msg = { 751 .rpc_proc = &nfs3_procedures[NFS3PROC_FSINFO], 752 .rpc_argp = fhandle, 753 .rpc_resp = info, 754 }; 755 int status; 756 757 dprintk("NFS call fsinfo\n"); 758 nfs_fattr_init(info->fattr); 759 status = rpc_call_sync(client, &msg, 0); 760 dprintk("NFS reply fsinfo: %d\n", status); 761 return status; 762 } 763 764 /* 765 * Bare-bones access to fsinfo: this is for nfs_get_root/nfs_get_sb via 766 * nfs_create_server 767 */ 768 static int 769 nfs3_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, 770 struct nfs_fsinfo *info) 771 { 772 int status; 773 774 status = do_proc_fsinfo(server->client, fhandle, info); 775 if (status && server->nfs_client->cl_rpcclient != server->client) 776 status = do_proc_fsinfo(server->nfs_client->cl_rpcclient, fhandle, info); 777 return status; 778 } 779 780 static int 781 nfs3_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle, 782 struct nfs_pathconf *info) 783 { 784 struct rpc_message msg = { 785 .rpc_proc = &nfs3_procedures[NFS3PROC_PATHCONF], 786 .rpc_argp = fhandle, 787 .rpc_resp = info, 788 }; 789 int status; 790 791 dprintk("NFS call pathconf\n"); 792 nfs_fattr_init(info->fattr); 793 status = rpc_call_sync(server->client, &msg, 0); 794 dprintk("NFS reply pathconf: %d\n", status); 795 return status; 796 } 797 798 static int nfs3_read_done(struct rpc_task *task, struct nfs_pgio_data *data) 799 { 800 struct inode *inode = data->header->inode; 801 802 if (nfs3_async_handle_jukebox(task, inode)) 803 return -EAGAIN; 804 805 nfs_invalidate_atime(inode); 806 nfs_refresh_inode(inode, &data->fattr); 807 return 0; 808 } 809 810 static void nfs3_proc_read_setup(struct nfs_pgio_data *data, struct rpc_message *msg) 811 { 812 msg->rpc_proc = &nfs3_procedures[NFS3PROC_READ]; 813 } 814 815 static int nfs3_proc_pgio_rpc_prepare(struct rpc_task *task, struct nfs_pgio_data *data) 816 { 817 rpc_call_start(task); 818 return 0; 819 } 820 821 static int nfs3_write_done(struct rpc_task *task, struct nfs_pgio_data *data) 822 { 823 struct inode *inode = data->header->inode; 824 825 if (nfs3_async_handle_jukebox(task, inode)) 826 return -EAGAIN; 827 if (task->tk_status >= 0) 828 nfs_post_op_update_inode_force_wcc(inode, data->res.fattr); 829 return 0; 830 } 831 832 static void nfs3_proc_write_setup(struct nfs_pgio_data *data, struct rpc_message *msg) 833 { 834 msg->rpc_proc = &nfs3_procedures[NFS3PROC_WRITE]; 835 } 836 837 static void nfs3_proc_commit_rpc_prepare(struct rpc_task *task, struct nfs_commit_data *data) 838 { 839 rpc_call_start(task); 840 } 841 842 static int nfs3_commit_done(struct rpc_task *task, struct nfs_commit_data *data) 843 { 844 if (nfs3_async_handle_jukebox(task, data->inode)) 845 return -EAGAIN; 846 nfs_refresh_inode(data->inode, data->res.fattr); 847 return 0; 848 } 849 850 static void nfs3_proc_commit_setup(struct nfs_commit_data *data, struct rpc_message *msg) 851 { 852 msg->rpc_proc = &nfs3_procedures[NFS3PROC_COMMIT]; 853 } 854 855 static int 856 nfs3_proc_lock(struct file *filp, int cmd, struct file_lock *fl) 857 { 858 struct inode *inode = file_inode(filp); 859 860 return nlmclnt_proc(NFS_SERVER(inode)->nlm_host, cmd, fl); 861 } 862 863 static int nfs3_have_delegation(struct inode *inode, fmode_t flags) 864 { 865 return 0; 866 } 867 868 static int nfs3_return_delegation(struct inode *inode) 869 { 870 nfs_wb_all(inode); 871 return 0; 872 } 873 874 static const struct inode_operations nfs3_dir_inode_operations = { 875 .create = nfs_create, 876 .lookup = nfs_lookup, 877 .link = nfs_link, 878 .unlink = nfs_unlink, 879 .symlink = nfs_symlink, 880 .mkdir = nfs_mkdir, 881 .rmdir = nfs_rmdir, 882 .mknod = nfs_mknod, 883 .rename = nfs_rename, 884 .permission = nfs_permission, 885 .getattr = nfs_getattr, 886 .setattr = nfs_setattr, 887 #ifdef CONFIG_NFS_V3_ACL 888 .listxattr = generic_listxattr, 889 .getxattr = generic_getxattr, 890 .setxattr = generic_setxattr, 891 .removexattr = generic_removexattr, 892 .get_acl = nfs3_get_acl, 893 .set_acl = nfs3_set_acl, 894 #endif 895 }; 896 897 static const struct inode_operations nfs3_file_inode_operations = { 898 .permission = nfs_permission, 899 .getattr = nfs_getattr, 900 .setattr = nfs_setattr, 901 #ifdef CONFIG_NFS_V3_ACL 902 .listxattr = generic_listxattr, 903 .getxattr = generic_getxattr, 904 .setxattr = generic_setxattr, 905 .removexattr = generic_removexattr, 906 .get_acl = nfs3_get_acl, 907 .set_acl = nfs3_set_acl, 908 #endif 909 }; 910 911 const struct nfs_rpc_ops nfs_v3_clientops = { 912 .version = 3, /* protocol version */ 913 .dentry_ops = &nfs_dentry_operations, 914 .dir_inode_ops = &nfs3_dir_inode_operations, 915 .file_inode_ops = &nfs3_file_inode_operations, 916 .file_ops = &nfs_file_operations, 917 .getroot = nfs3_proc_get_root, 918 .submount = nfs_submount, 919 .try_mount = nfs_try_mount, 920 .getattr = nfs3_proc_getattr, 921 .setattr = nfs3_proc_setattr, 922 .lookup = nfs3_proc_lookup, 923 .access = nfs3_proc_access, 924 .readlink = nfs3_proc_readlink, 925 .create = nfs3_proc_create, 926 .remove = nfs3_proc_remove, 927 .unlink_setup = nfs3_proc_unlink_setup, 928 .unlink_rpc_prepare = nfs3_proc_unlink_rpc_prepare, 929 .unlink_done = nfs3_proc_unlink_done, 930 .rename_setup = nfs3_proc_rename_setup, 931 .rename_rpc_prepare = nfs3_proc_rename_rpc_prepare, 932 .rename_done = nfs3_proc_rename_done, 933 .link = nfs3_proc_link, 934 .symlink = nfs3_proc_symlink, 935 .mkdir = nfs3_proc_mkdir, 936 .rmdir = nfs3_proc_rmdir, 937 .readdir = nfs3_proc_readdir, 938 .mknod = nfs3_proc_mknod, 939 .statfs = nfs3_proc_statfs, 940 .fsinfo = nfs3_proc_fsinfo, 941 .pathconf = nfs3_proc_pathconf, 942 .decode_dirent = nfs3_decode_dirent, 943 .pgio_rpc_prepare = nfs3_proc_pgio_rpc_prepare, 944 .read_setup = nfs3_proc_read_setup, 945 .read_done = nfs3_read_done, 946 .write_setup = nfs3_proc_write_setup, 947 .write_done = nfs3_write_done, 948 .commit_setup = nfs3_proc_commit_setup, 949 .commit_rpc_prepare = nfs3_proc_commit_rpc_prepare, 950 .commit_done = nfs3_commit_done, 951 .lock = nfs3_proc_lock, 952 .clear_acl_cache = forget_all_cached_acls, 953 .close_context = nfs_close_context, 954 .have_delegation = nfs3_have_delegation, 955 .return_delegation = nfs3_return_delegation, 956 .alloc_client = nfs_alloc_client, 957 .init_client = nfs_init_client, 958 .free_client = nfs_free_client, 959 .create_server = nfs3_create_server, 960 .clone_server = nfs3_clone_server, 961 }; 962