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