1 /* 2 * linux/fs/nfs/proc.c 3 * 4 * Copyright (C) 1992, 1993, 1994 Rick Sladkey 5 * 6 * OS-independent nfs remote procedure call functions 7 * 8 * Tuned by Alan Cox <A.Cox@swansea.ac.uk> for >3K buffers 9 * so at last we can have decent(ish) throughput off a 10 * Sun server. 11 * 12 * Coding optimized and cleaned up by Florian La Roche. 13 * Note: Error returns are optimized for NFS_OK, which isn't translated via 14 * nfs_stat_to_errno(), but happens to be already the right return code. 15 * 16 * Also, the code currently doesn't check the size of the packet, when 17 * it decodes the packet. 18 * 19 * Feel free to fix it and mail me the diffs if it worries you. 20 * 21 * Completely rewritten to support the new RPC call interface; 22 * rewrote and moved the entire XDR stuff to xdr.c 23 * --Olaf Kirch June 1996 24 * 25 * The code below initializes all auto variables explicitly, otherwise 26 * it will fail to work as a module (gcc generates a memset call for an 27 * incomplete struct). 28 */ 29 30 #include <linux/types.h> 31 #include <linux/param.h> 32 #include <linux/time.h> 33 #include <linux/mm.h> 34 #include <linux/errno.h> 35 #include <linux/string.h> 36 #include <linux/in.h> 37 #include <linux/pagemap.h> 38 #include <linux/sunrpc/clnt.h> 39 #include <linux/nfs.h> 40 #include <linux/nfs2.h> 41 #include <linux/nfs_fs.h> 42 #include <linux/nfs_page.h> 43 #include <linux/lockd/bind.h> 44 #include <linux/freezer.h> 45 #include "internal.h" 46 47 #define NFSDBG_FACILITY NFSDBG_PROC 48 49 /* 50 * Bare-bones access to getattr: this is for nfs_read_super. 51 */ 52 static int 53 nfs_proc_get_root(struct nfs_server *server, struct nfs_fh *fhandle, 54 struct nfs_fsinfo *info) 55 { 56 struct nfs_fattr *fattr = info->fattr; 57 struct nfs2_fsstat fsinfo; 58 struct rpc_message msg = { 59 .rpc_proc = &nfs_procedures[NFSPROC_GETATTR], 60 .rpc_argp = fhandle, 61 .rpc_resp = fattr, 62 }; 63 int status; 64 65 dprintk("%s: call getattr\n", __func__); 66 nfs_fattr_init(fattr); 67 status = rpc_call_sync(server->client, &msg, 0); 68 /* Retry with default authentication if different */ 69 if (status && server->nfs_client->cl_rpcclient != server->client) 70 status = rpc_call_sync(server->nfs_client->cl_rpcclient, &msg, 0); 71 dprintk("%s: reply getattr: %d\n", __func__, status); 72 if (status) 73 return status; 74 dprintk("%s: call statfs\n", __func__); 75 msg.rpc_proc = &nfs_procedures[NFSPROC_STATFS]; 76 msg.rpc_resp = &fsinfo; 77 status = rpc_call_sync(server->client, &msg, 0); 78 /* Retry with default authentication if different */ 79 if (status && server->nfs_client->cl_rpcclient != server->client) 80 status = rpc_call_sync(server->nfs_client->cl_rpcclient, &msg, 0); 81 dprintk("%s: reply statfs: %d\n", __func__, status); 82 if (status) 83 return status; 84 info->rtmax = NFS_MAXDATA; 85 info->rtpref = fsinfo.tsize; 86 info->rtmult = fsinfo.bsize; 87 info->wtmax = NFS_MAXDATA; 88 info->wtpref = fsinfo.tsize; 89 info->wtmult = fsinfo.bsize; 90 info->dtpref = fsinfo.tsize; 91 info->maxfilesize = 0x7FFFFFFF; 92 info->lease_time = 0; 93 return 0; 94 } 95 96 /* 97 * One function for each procedure in the NFS protocol. 98 */ 99 static int 100 nfs_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 = &nfs_procedures[NFSPROC_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 nfs_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr, 119 struct iattr *sattr) 120 { 121 struct inode *inode = dentry->d_inode; 122 struct nfs_sattrargs arg = { 123 .fh = NFS_FH(inode), 124 .sattr = sattr 125 }; 126 struct rpc_message msg = { 127 .rpc_proc = &nfs_procedures[NFSPROC_SETATTR], 128 .rpc_argp = &arg, 129 .rpc_resp = fattr, 130 }; 131 int status; 132 133 /* Mask out the non-modebit related stuff from attr->ia_mode */ 134 sattr->ia_mode &= S_IALLUGO; 135 136 dprintk("NFS call setattr\n"); 137 if (sattr->ia_valid & ATTR_FILE) 138 msg.rpc_cred = nfs_file_cred(sattr->ia_file); 139 nfs_fattr_init(fattr); 140 status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0); 141 if (status == 0) 142 nfs_setattr_update_inode(inode, sattr, fattr); 143 dprintk("NFS reply setattr: %d\n", status); 144 return status; 145 } 146 147 static int 148 nfs_proc_lookup(struct inode *dir, struct qstr *name, 149 struct nfs_fh *fhandle, struct nfs_fattr *fattr, 150 struct nfs4_label *label) 151 { 152 struct nfs_diropargs arg = { 153 .fh = NFS_FH(dir), 154 .name = name->name, 155 .len = name->len 156 }; 157 struct nfs_diropok res = { 158 .fh = fhandle, 159 .fattr = fattr 160 }; 161 struct rpc_message msg = { 162 .rpc_proc = &nfs_procedures[NFSPROC_LOOKUP], 163 .rpc_argp = &arg, 164 .rpc_resp = &res, 165 }; 166 int status; 167 168 dprintk("NFS call lookup %s\n", name->name); 169 nfs_fattr_init(fattr); 170 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 171 dprintk("NFS reply lookup: %d\n", status); 172 return status; 173 } 174 175 static int nfs_proc_readlink(struct inode *inode, struct page *page, 176 unsigned int pgbase, unsigned int pglen) 177 { 178 struct nfs_readlinkargs args = { 179 .fh = NFS_FH(inode), 180 .pgbase = pgbase, 181 .pglen = pglen, 182 .pages = &page 183 }; 184 struct rpc_message msg = { 185 .rpc_proc = &nfs_procedures[NFSPROC_READLINK], 186 .rpc_argp = &args, 187 }; 188 int status; 189 190 dprintk("NFS call readlink\n"); 191 status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0); 192 dprintk("NFS reply readlink: %d\n", status); 193 return status; 194 } 195 196 struct nfs_createdata { 197 struct nfs_createargs arg; 198 struct nfs_diropok res; 199 struct nfs_fh fhandle; 200 struct nfs_fattr fattr; 201 }; 202 203 static struct nfs_createdata *nfs_alloc_createdata(struct inode *dir, 204 struct dentry *dentry, struct iattr *sattr) 205 { 206 struct nfs_createdata *data; 207 208 data = kmalloc(sizeof(*data), GFP_KERNEL); 209 210 if (data != NULL) { 211 data->arg.fh = NFS_FH(dir); 212 data->arg.name = dentry->d_name.name; 213 data->arg.len = dentry->d_name.len; 214 data->arg.sattr = sattr; 215 nfs_fattr_init(&data->fattr); 216 data->fhandle.size = 0; 217 data->res.fh = &data->fhandle; 218 data->res.fattr = &data->fattr; 219 } 220 return data; 221 }; 222 223 static void nfs_free_createdata(const struct nfs_createdata *data) 224 { 225 kfree(data); 226 } 227 228 static int 229 nfs_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr, 230 int flags) 231 { 232 struct nfs_createdata *data; 233 struct rpc_message msg = { 234 .rpc_proc = &nfs_procedures[NFSPROC_CREATE], 235 }; 236 int status = -ENOMEM; 237 238 dprintk("NFS call create %pd\n", dentry); 239 data = nfs_alloc_createdata(dir, dentry, sattr); 240 if (data == NULL) 241 goto out; 242 msg.rpc_argp = &data->arg; 243 msg.rpc_resp = &data->res; 244 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 245 nfs_mark_for_revalidate(dir); 246 if (status == 0) 247 status = nfs_instantiate(dentry, data->res.fh, data->res.fattr, NULL); 248 nfs_free_createdata(data); 249 out: 250 dprintk("NFS reply create: %d\n", status); 251 return status; 252 } 253 254 /* 255 * In NFSv2, mknod is grafted onto the create call. 256 */ 257 static int 258 nfs_proc_mknod(struct inode *dir, struct dentry *dentry, struct iattr *sattr, 259 dev_t rdev) 260 { 261 struct nfs_createdata *data; 262 struct rpc_message msg = { 263 .rpc_proc = &nfs_procedures[NFSPROC_CREATE], 264 }; 265 umode_t mode; 266 int status = -ENOMEM; 267 268 dprintk("NFS call mknod %pd\n", dentry); 269 270 mode = sattr->ia_mode; 271 if (S_ISFIFO(mode)) { 272 sattr->ia_mode = (mode & ~S_IFMT) | S_IFCHR; 273 sattr->ia_valid &= ~ATTR_SIZE; 274 } else if (S_ISCHR(mode) || S_ISBLK(mode)) { 275 sattr->ia_valid |= ATTR_SIZE; 276 sattr->ia_size = new_encode_dev(rdev);/* get out your barf bag */ 277 } 278 279 data = nfs_alloc_createdata(dir, dentry, sattr); 280 if (data == NULL) 281 goto out; 282 msg.rpc_argp = &data->arg; 283 msg.rpc_resp = &data->res; 284 285 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 286 nfs_mark_for_revalidate(dir); 287 288 if (status == -EINVAL && S_ISFIFO(mode)) { 289 sattr->ia_mode = mode; 290 nfs_fattr_init(data->res.fattr); 291 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 292 } 293 if (status == 0) 294 status = nfs_instantiate(dentry, data->res.fh, data->res.fattr, NULL); 295 nfs_free_createdata(data); 296 out: 297 dprintk("NFS reply mknod: %d\n", status); 298 return status; 299 } 300 301 static int 302 nfs_proc_remove(struct inode *dir, struct qstr *name) 303 { 304 struct nfs_removeargs arg = { 305 .fh = NFS_FH(dir), 306 .name = *name, 307 }; 308 struct rpc_message msg = { 309 .rpc_proc = &nfs_procedures[NFSPROC_REMOVE], 310 .rpc_argp = &arg, 311 }; 312 int status; 313 314 dprintk("NFS call remove %s\n", name->name); 315 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 316 nfs_mark_for_revalidate(dir); 317 318 dprintk("NFS reply remove: %d\n", status); 319 return status; 320 } 321 322 static void 323 nfs_proc_unlink_setup(struct rpc_message *msg, struct inode *dir) 324 { 325 msg->rpc_proc = &nfs_procedures[NFSPROC_REMOVE]; 326 } 327 328 static void nfs_proc_unlink_rpc_prepare(struct rpc_task *task, struct nfs_unlinkdata *data) 329 { 330 rpc_call_start(task); 331 } 332 333 static int nfs_proc_unlink_done(struct rpc_task *task, struct inode *dir) 334 { 335 nfs_mark_for_revalidate(dir); 336 return 1; 337 } 338 339 static void 340 nfs_proc_rename_setup(struct rpc_message *msg, struct inode *dir) 341 { 342 msg->rpc_proc = &nfs_procedures[NFSPROC_RENAME]; 343 } 344 345 static void nfs_proc_rename_rpc_prepare(struct rpc_task *task, struct nfs_renamedata *data) 346 { 347 rpc_call_start(task); 348 } 349 350 static int 351 nfs_proc_rename_done(struct rpc_task *task, struct inode *old_dir, 352 struct inode *new_dir) 353 { 354 nfs_mark_for_revalidate(old_dir); 355 nfs_mark_for_revalidate(new_dir); 356 return 1; 357 } 358 359 static int 360 nfs_proc_link(struct inode *inode, struct inode *dir, struct qstr *name) 361 { 362 struct nfs_linkargs arg = { 363 .fromfh = NFS_FH(inode), 364 .tofh = NFS_FH(dir), 365 .toname = name->name, 366 .tolen = name->len 367 }; 368 struct rpc_message msg = { 369 .rpc_proc = &nfs_procedures[NFSPROC_LINK], 370 .rpc_argp = &arg, 371 }; 372 int status; 373 374 dprintk("NFS call link %s\n", name->name); 375 status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0); 376 nfs_mark_for_revalidate(inode); 377 nfs_mark_for_revalidate(dir); 378 dprintk("NFS reply link: %d\n", status); 379 return status; 380 } 381 382 static int 383 nfs_proc_symlink(struct inode *dir, struct dentry *dentry, struct page *page, 384 unsigned int len, struct iattr *sattr) 385 { 386 struct nfs_fh *fh; 387 struct nfs_fattr *fattr; 388 struct nfs_symlinkargs arg = { 389 .fromfh = NFS_FH(dir), 390 .fromname = dentry->d_name.name, 391 .fromlen = dentry->d_name.len, 392 .pages = &page, 393 .pathlen = len, 394 .sattr = sattr 395 }; 396 struct rpc_message msg = { 397 .rpc_proc = &nfs_procedures[NFSPROC_SYMLINK], 398 .rpc_argp = &arg, 399 }; 400 int status = -ENAMETOOLONG; 401 402 dprintk("NFS call symlink %pd\n", dentry); 403 404 if (len > NFS2_MAXPATHLEN) 405 goto out; 406 407 fh = nfs_alloc_fhandle(); 408 fattr = nfs_alloc_fattr(); 409 status = -ENOMEM; 410 if (fh == NULL || fattr == NULL) 411 goto out_free; 412 413 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 414 nfs_mark_for_revalidate(dir); 415 416 /* 417 * V2 SYMLINK requests don't return any attributes. Setting the 418 * filehandle size to zero indicates to nfs_instantiate that it 419 * should fill in the data with a LOOKUP call on the wire. 420 */ 421 if (status == 0) 422 status = nfs_instantiate(dentry, fh, fattr, NULL); 423 424 out_free: 425 nfs_free_fattr(fattr); 426 nfs_free_fhandle(fh); 427 out: 428 dprintk("NFS reply symlink: %d\n", status); 429 return status; 430 } 431 432 static int 433 nfs_proc_mkdir(struct inode *dir, struct dentry *dentry, struct iattr *sattr) 434 { 435 struct nfs_createdata *data; 436 struct rpc_message msg = { 437 .rpc_proc = &nfs_procedures[NFSPROC_MKDIR], 438 }; 439 int status = -ENOMEM; 440 441 dprintk("NFS call mkdir %pd\n", dentry); 442 data = nfs_alloc_createdata(dir, dentry, sattr); 443 if (data == NULL) 444 goto out; 445 msg.rpc_argp = &data->arg; 446 msg.rpc_resp = &data->res; 447 448 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 449 nfs_mark_for_revalidate(dir); 450 if (status == 0) 451 status = nfs_instantiate(dentry, data->res.fh, data->res.fattr, NULL); 452 nfs_free_createdata(data); 453 out: 454 dprintk("NFS reply mkdir: %d\n", status); 455 return status; 456 } 457 458 static int 459 nfs_proc_rmdir(struct inode *dir, struct qstr *name) 460 { 461 struct nfs_diropargs arg = { 462 .fh = NFS_FH(dir), 463 .name = name->name, 464 .len = name->len 465 }; 466 struct rpc_message msg = { 467 .rpc_proc = &nfs_procedures[NFSPROC_RMDIR], 468 .rpc_argp = &arg, 469 }; 470 int status; 471 472 dprintk("NFS call rmdir %s\n", name->name); 473 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 474 nfs_mark_for_revalidate(dir); 475 dprintk("NFS reply rmdir: %d\n", status); 476 return status; 477 } 478 479 /* 480 * The READDIR implementation is somewhat hackish - we pass a temporary 481 * buffer to the encode function, which installs it in the receive 482 * the receive iovec. The decode function just parses the reply to make 483 * sure it is syntactically correct; the entries itself are decoded 484 * from nfs_readdir by calling the decode_entry function directly. 485 */ 486 static int 487 nfs_proc_readdir(struct dentry *dentry, struct rpc_cred *cred, 488 u64 cookie, struct page **pages, unsigned int count, int plus) 489 { 490 struct inode *dir = dentry->d_inode; 491 struct nfs_readdirargs arg = { 492 .fh = NFS_FH(dir), 493 .cookie = cookie, 494 .count = count, 495 .pages = pages, 496 }; 497 struct rpc_message msg = { 498 .rpc_proc = &nfs_procedures[NFSPROC_READDIR], 499 .rpc_argp = &arg, 500 .rpc_cred = cred, 501 }; 502 int status; 503 504 dprintk("NFS call readdir %d\n", (unsigned int)cookie); 505 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 506 507 nfs_invalidate_atime(dir); 508 509 dprintk("NFS reply readdir: %d\n", status); 510 return status; 511 } 512 513 static int 514 nfs_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle, 515 struct nfs_fsstat *stat) 516 { 517 struct nfs2_fsstat fsinfo; 518 struct rpc_message msg = { 519 .rpc_proc = &nfs_procedures[NFSPROC_STATFS], 520 .rpc_argp = fhandle, 521 .rpc_resp = &fsinfo, 522 }; 523 int status; 524 525 dprintk("NFS call statfs\n"); 526 nfs_fattr_init(stat->fattr); 527 status = rpc_call_sync(server->client, &msg, 0); 528 dprintk("NFS reply statfs: %d\n", status); 529 if (status) 530 goto out; 531 stat->tbytes = (u64)fsinfo.blocks * fsinfo.bsize; 532 stat->fbytes = (u64)fsinfo.bfree * fsinfo.bsize; 533 stat->abytes = (u64)fsinfo.bavail * fsinfo.bsize; 534 stat->tfiles = 0; 535 stat->ffiles = 0; 536 stat->afiles = 0; 537 out: 538 return status; 539 } 540 541 static int 542 nfs_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, 543 struct nfs_fsinfo *info) 544 { 545 struct nfs2_fsstat fsinfo; 546 struct rpc_message msg = { 547 .rpc_proc = &nfs_procedures[NFSPROC_STATFS], 548 .rpc_argp = fhandle, 549 .rpc_resp = &fsinfo, 550 }; 551 int status; 552 553 dprintk("NFS call fsinfo\n"); 554 nfs_fattr_init(info->fattr); 555 status = rpc_call_sync(server->client, &msg, 0); 556 dprintk("NFS reply fsinfo: %d\n", status); 557 if (status) 558 goto out; 559 info->rtmax = NFS_MAXDATA; 560 info->rtpref = fsinfo.tsize; 561 info->rtmult = fsinfo.bsize; 562 info->wtmax = NFS_MAXDATA; 563 info->wtpref = fsinfo.tsize; 564 info->wtmult = fsinfo.bsize; 565 info->dtpref = fsinfo.tsize; 566 info->maxfilesize = 0x7FFFFFFF; 567 info->lease_time = 0; 568 out: 569 return status; 570 } 571 572 static int 573 nfs_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle, 574 struct nfs_pathconf *info) 575 { 576 info->max_link = 0; 577 info->max_namelen = NFS2_MAXNAMLEN; 578 return 0; 579 } 580 581 static int nfs_read_done(struct rpc_task *task, struct nfs_pgio_header *hdr) 582 { 583 struct inode *inode = hdr->inode; 584 585 nfs_invalidate_atime(inode); 586 if (task->tk_status >= 0) { 587 nfs_refresh_inode(inode, hdr->res.fattr); 588 /* Emulate the eof flag, which isn't normally needed in NFSv2 589 * as it is guaranteed to always return the file attributes 590 */ 591 if (hdr->args.offset + hdr->res.count >= hdr->res.fattr->size) 592 hdr->res.eof = 1; 593 } 594 return 0; 595 } 596 597 static void nfs_proc_read_setup(struct nfs_pgio_header *hdr, 598 struct rpc_message *msg) 599 { 600 msg->rpc_proc = &nfs_procedures[NFSPROC_READ]; 601 } 602 603 static int nfs_proc_pgio_rpc_prepare(struct rpc_task *task, 604 struct nfs_pgio_header *hdr) 605 { 606 rpc_call_start(task); 607 return 0; 608 } 609 610 static int nfs_write_done(struct rpc_task *task, struct nfs_pgio_header *hdr) 611 { 612 if (task->tk_status >= 0) 613 nfs_writeback_update_inode(hdr); 614 return 0; 615 } 616 617 static void nfs_proc_write_setup(struct nfs_pgio_header *hdr, 618 struct rpc_message *msg) 619 { 620 /* Note: NFSv2 ignores @stable and always uses NFS_FILE_SYNC */ 621 hdr->args.stable = NFS_FILE_SYNC; 622 msg->rpc_proc = &nfs_procedures[NFSPROC_WRITE]; 623 } 624 625 static void nfs_proc_commit_rpc_prepare(struct rpc_task *task, struct nfs_commit_data *data) 626 { 627 BUG(); 628 } 629 630 static void 631 nfs_proc_commit_setup(struct nfs_commit_data *data, struct rpc_message *msg) 632 { 633 BUG(); 634 } 635 636 static int 637 nfs_proc_lock(struct file *filp, int cmd, struct file_lock *fl) 638 { 639 struct inode *inode = file_inode(filp); 640 641 return nlmclnt_proc(NFS_SERVER(inode)->nlm_host, cmd, fl); 642 } 643 644 /* Helper functions for NFS lock bounds checking */ 645 #define NFS_LOCK32_OFFSET_MAX ((__s32)0x7fffffffUL) 646 static int nfs_lock_check_bounds(const struct file_lock *fl) 647 { 648 __s32 start, end; 649 650 start = (__s32)fl->fl_start; 651 if ((loff_t)start != fl->fl_start) 652 goto out_einval; 653 654 if (fl->fl_end != OFFSET_MAX) { 655 end = (__s32)fl->fl_end; 656 if ((loff_t)end != fl->fl_end) 657 goto out_einval; 658 } else 659 end = NFS_LOCK32_OFFSET_MAX; 660 661 if (start < 0 || start > end) 662 goto out_einval; 663 return 0; 664 out_einval: 665 return -EINVAL; 666 } 667 668 static int nfs_have_delegation(struct inode *inode, fmode_t flags) 669 { 670 return 0; 671 } 672 673 static int nfs_return_delegation(struct inode *inode) 674 { 675 nfs_wb_all(inode); 676 return 0; 677 } 678 679 static const struct inode_operations nfs_dir_inode_operations = { 680 .create = nfs_create, 681 .lookup = nfs_lookup, 682 .link = nfs_link, 683 .unlink = nfs_unlink, 684 .symlink = nfs_symlink, 685 .mkdir = nfs_mkdir, 686 .rmdir = nfs_rmdir, 687 .mknod = nfs_mknod, 688 .rename = nfs_rename, 689 .permission = nfs_permission, 690 .getattr = nfs_getattr, 691 .setattr = nfs_setattr, 692 }; 693 694 static const struct inode_operations nfs_file_inode_operations = { 695 .permission = nfs_permission, 696 .getattr = nfs_getattr, 697 .setattr = nfs_setattr, 698 }; 699 700 const struct nfs_rpc_ops nfs_v2_clientops = { 701 .version = 2, /* protocol version */ 702 .dentry_ops = &nfs_dentry_operations, 703 .dir_inode_ops = &nfs_dir_inode_operations, 704 .file_inode_ops = &nfs_file_inode_operations, 705 .file_ops = &nfs_file_operations, 706 .getroot = nfs_proc_get_root, 707 .submount = nfs_submount, 708 .try_mount = nfs_try_mount, 709 .getattr = nfs_proc_getattr, 710 .setattr = nfs_proc_setattr, 711 .lookup = nfs_proc_lookup, 712 .access = NULL, /* access */ 713 .readlink = nfs_proc_readlink, 714 .create = nfs_proc_create, 715 .remove = nfs_proc_remove, 716 .unlink_setup = nfs_proc_unlink_setup, 717 .unlink_rpc_prepare = nfs_proc_unlink_rpc_prepare, 718 .unlink_done = nfs_proc_unlink_done, 719 .rename_setup = nfs_proc_rename_setup, 720 .rename_rpc_prepare = nfs_proc_rename_rpc_prepare, 721 .rename_done = nfs_proc_rename_done, 722 .link = nfs_proc_link, 723 .symlink = nfs_proc_symlink, 724 .mkdir = nfs_proc_mkdir, 725 .rmdir = nfs_proc_rmdir, 726 .readdir = nfs_proc_readdir, 727 .mknod = nfs_proc_mknod, 728 .statfs = nfs_proc_statfs, 729 .fsinfo = nfs_proc_fsinfo, 730 .pathconf = nfs_proc_pathconf, 731 .decode_dirent = nfs2_decode_dirent, 732 .pgio_rpc_prepare = nfs_proc_pgio_rpc_prepare, 733 .read_setup = nfs_proc_read_setup, 734 .read_done = nfs_read_done, 735 .write_setup = nfs_proc_write_setup, 736 .write_done = nfs_write_done, 737 .commit_setup = nfs_proc_commit_setup, 738 .commit_rpc_prepare = nfs_proc_commit_rpc_prepare, 739 .lock = nfs_proc_lock, 740 .lock_check_bounds = nfs_lock_check_bounds, 741 .close_context = nfs_close_context, 742 .have_delegation = nfs_have_delegation, 743 .return_delegation = nfs_return_delegation, 744 .alloc_client = nfs_alloc_client, 745 .init_client = nfs_init_client, 746 .free_client = nfs_free_client, 747 .create_server = nfs_create_server, 748 .clone_server = nfs_clone_server, 749 }; 750