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 unsigned short task_flags = 0; 112 113 /* Is this is an attribute revalidation, subject to softreval? */ 114 if (inode && (server->flags & NFS_MOUNT_SOFTREVAL)) 115 task_flags |= RPC_TASK_TIMEOUT; 116 117 dprintk("NFS call getattr\n"); 118 nfs_fattr_init(fattr); 119 status = rpc_call_sync(server->client, &msg, task_flags); 120 dprintk("NFS reply getattr: %d\n", status); 121 return status; 122 } 123 124 static int 125 nfs_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr, 126 struct iattr *sattr) 127 { 128 struct inode *inode = d_inode(dentry); 129 struct nfs_sattrargs arg = { 130 .fh = NFS_FH(inode), 131 .sattr = sattr 132 }; 133 struct rpc_message msg = { 134 .rpc_proc = &nfs_procedures[NFSPROC_SETATTR], 135 .rpc_argp = &arg, 136 .rpc_resp = fattr, 137 }; 138 int status; 139 140 /* Mask out the non-modebit related stuff from attr->ia_mode */ 141 sattr->ia_mode &= S_IALLUGO; 142 143 dprintk("NFS call setattr\n"); 144 if (sattr->ia_valid & ATTR_FILE) 145 msg.rpc_cred = nfs_file_cred(sattr->ia_file); 146 nfs_fattr_init(fattr); 147 status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0); 148 if (status == 0) 149 nfs_setattr_update_inode(inode, sattr, fattr); 150 dprintk("NFS reply setattr: %d\n", status); 151 return status; 152 } 153 154 static int 155 nfs_proc_lookup(struct inode *dir, struct dentry *dentry, 156 struct nfs_fh *fhandle, struct nfs_fattr *fattr, 157 struct nfs4_label *label) 158 { 159 struct nfs_diropargs arg = { 160 .fh = NFS_FH(dir), 161 .name = dentry->d_name.name, 162 .len = dentry->d_name.len 163 }; 164 struct nfs_diropok res = { 165 .fh = fhandle, 166 .fattr = fattr 167 }; 168 struct rpc_message msg = { 169 .rpc_proc = &nfs_procedures[NFSPROC_LOOKUP], 170 .rpc_argp = &arg, 171 .rpc_resp = &res, 172 }; 173 int status; 174 unsigned short task_flags = 0; 175 176 /* Is this is an attribute revalidation, subject to softreval? */ 177 if (nfs_lookup_is_soft_revalidate(dentry)) 178 task_flags |= RPC_TASK_TIMEOUT; 179 180 dprintk("NFS call lookup %pd2\n", dentry); 181 nfs_fattr_init(fattr); 182 status = rpc_call_sync(NFS_CLIENT(dir), &msg, task_flags); 183 dprintk("NFS reply lookup: %d\n", status); 184 return status; 185 } 186 187 static int nfs_proc_readlink(struct inode *inode, struct page *page, 188 unsigned int pgbase, unsigned int pglen) 189 { 190 struct nfs_readlinkargs args = { 191 .fh = NFS_FH(inode), 192 .pgbase = pgbase, 193 .pglen = pglen, 194 .pages = &page 195 }; 196 struct rpc_message msg = { 197 .rpc_proc = &nfs_procedures[NFSPROC_READLINK], 198 .rpc_argp = &args, 199 }; 200 int status; 201 202 dprintk("NFS call readlink\n"); 203 status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0); 204 dprintk("NFS reply readlink: %d\n", status); 205 return status; 206 } 207 208 struct nfs_createdata { 209 struct nfs_createargs arg; 210 struct nfs_diropok res; 211 struct nfs_fh fhandle; 212 struct nfs_fattr fattr; 213 }; 214 215 static struct nfs_createdata *nfs_alloc_createdata(struct inode *dir, 216 struct dentry *dentry, struct iattr *sattr) 217 { 218 struct nfs_createdata *data; 219 220 data = kmalloc(sizeof(*data), GFP_KERNEL); 221 222 if (data != NULL) { 223 data->arg.fh = NFS_FH(dir); 224 data->arg.name = dentry->d_name.name; 225 data->arg.len = dentry->d_name.len; 226 data->arg.sattr = sattr; 227 nfs_fattr_init(&data->fattr); 228 data->fhandle.size = 0; 229 data->res.fh = &data->fhandle; 230 data->res.fattr = &data->fattr; 231 } 232 return data; 233 }; 234 235 static void nfs_free_createdata(const struct nfs_createdata *data) 236 { 237 kfree(data); 238 } 239 240 static int 241 nfs_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr, 242 int flags) 243 { 244 struct nfs_createdata *data; 245 struct rpc_message msg = { 246 .rpc_proc = &nfs_procedures[NFSPROC_CREATE], 247 }; 248 int status = -ENOMEM; 249 250 dprintk("NFS call create %pd\n", dentry); 251 data = nfs_alloc_createdata(dir, dentry, sattr); 252 if (data == NULL) 253 goto out; 254 msg.rpc_argp = &data->arg; 255 msg.rpc_resp = &data->res; 256 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 257 nfs_mark_for_revalidate(dir); 258 if (status == 0) 259 status = nfs_instantiate(dentry, data->res.fh, data->res.fattr, NULL); 260 nfs_free_createdata(data); 261 out: 262 dprintk("NFS reply create: %d\n", status); 263 return status; 264 } 265 266 /* 267 * In NFSv2, mknod is grafted onto the create call. 268 */ 269 static int 270 nfs_proc_mknod(struct inode *dir, struct dentry *dentry, struct iattr *sattr, 271 dev_t rdev) 272 { 273 struct nfs_createdata *data; 274 struct rpc_message msg = { 275 .rpc_proc = &nfs_procedures[NFSPROC_CREATE], 276 }; 277 umode_t mode; 278 int status = -ENOMEM; 279 280 dprintk("NFS call mknod %pd\n", dentry); 281 282 mode = sattr->ia_mode; 283 if (S_ISFIFO(mode)) { 284 sattr->ia_mode = (mode & ~S_IFMT) | S_IFCHR; 285 sattr->ia_valid &= ~ATTR_SIZE; 286 } else if (S_ISCHR(mode) || S_ISBLK(mode)) { 287 sattr->ia_valid |= ATTR_SIZE; 288 sattr->ia_size = new_encode_dev(rdev);/* get out your barf bag */ 289 } 290 291 data = nfs_alloc_createdata(dir, dentry, sattr); 292 if (data == NULL) 293 goto out; 294 msg.rpc_argp = &data->arg; 295 msg.rpc_resp = &data->res; 296 297 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 298 nfs_mark_for_revalidate(dir); 299 300 if (status == -EINVAL && S_ISFIFO(mode)) { 301 sattr->ia_mode = mode; 302 nfs_fattr_init(data->res.fattr); 303 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 304 } 305 if (status == 0) 306 status = nfs_instantiate(dentry, data->res.fh, data->res.fattr, NULL); 307 nfs_free_createdata(data); 308 out: 309 dprintk("NFS reply mknod: %d\n", status); 310 return status; 311 } 312 313 static int 314 nfs_proc_remove(struct inode *dir, struct dentry *dentry) 315 { 316 struct nfs_removeargs arg = { 317 .fh = NFS_FH(dir), 318 .name = dentry->d_name, 319 }; 320 struct rpc_message msg = { 321 .rpc_proc = &nfs_procedures[NFSPROC_REMOVE], 322 .rpc_argp = &arg, 323 }; 324 int status; 325 326 dprintk("NFS call remove %pd2\n",dentry); 327 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 328 nfs_mark_for_revalidate(dir); 329 330 dprintk("NFS reply remove: %d\n", status); 331 return status; 332 } 333 334 static void 335 nfs_proc_unlink_setup(struct rpc_message *msg, 336 struct dentry *dentry, 337 struct inode *inode) 338 { 339 msg->rpc_proc = &nfs_procedures[NFSPROC_REMOVE]; 340 } 341 342 static void nfs_proc_unlink_rpc_prepare(struct rpc_task *task, struct nfs_unlinkdata *data) 343 { 344 rpc_call_start(task); 345 } 346 347 static int nfs_proc_unlink_done(struct rpc_task *task, struct inode *dir) 348 { 349 nfs_mark_for_revalidate(dir); 350 return 1; 351 } 352 353 static void 354 nfs_proc_rename_setup(struct rpc_message *msg, 355 struct dentry *old_dentry, 356 struct dentry *new_dentry) 357 { 358 msg->rpc_proc = &nfs_procedures[NFSPROC_RENAME]; 359 } 360 361 static void nfs_proc_rename_rpc_prepare(struct rpc_task *task, struct nfs_renamedata *data) 362 { 363 rpc_call_start(task); 364 } 365 366 static int 367 nfs_proc_rename_done(struct rpc_task *task, struct inode *old_dir, 368 struct inode *new_dir) 369 { 370 nfs_mark_for_revalidate(old_dir); 371 nfs_mark_for_revalidate(new_dir); 372 return 1; 373 } 374 375 static int 376 nfs_proc_link(struct inode *inode, struct inode *dir, const struct qstr *name) 377 { 378 struct nfs_linkargs arg = { 379 .fromfh = NFS_FH(inode), 380 .tofh = NFS_FH(dir), 381 .toname = name->name, 382 .tolen = name->len 383 }; 384 struct rpc_message msg = { 385 .rpc_proc = &nfs_procedures[NFSPROC_LINK], 386 .rpc_argp = &arg, 387 }; 388 int status; 389 390 dprintk("NFS call link %s\n", name->name); 391 status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0); 392 nfs_mark_for_revalidate(inode); 393 nfs_mark_for_revalidate(dir); 394 dprintk("NFS reply link: %d\n", status); 395 return status; 396 } 397 398 static int 399 nfs_proc_symlink(struct inode *dir, struct dentry *dentry, struct page *page, 400 unsigned int len, struct iattr *sattr) 401 { 402 struct nfs_fh *fh; 403 struct nfs_fattr *fattr; 404 struct nfs_symlinkargs arg = { 405 .fromfh = NFS_FH(dir), 406 .fromname = dentry->d_name.name, 407 .fromlen = dentry->d_name.len, 408 .pages = &page, 409 .pathlen = len, 410 .sattr = sattr 411 }; 412 struct rpc_message msg = { 413 .rpc_proc = &nfs_procedures[NFSPROC_SYMLINK], 414 .rpc_argp = &arg, 415 }; 416 int status = -ENAMETOOLONG; 417 418 dprintk("NFS call symlink %pd\n", dentry); 419 420 if (len > NFS2_MAXPATHLEN) 421 goto out; 422 423 fh = nfs_alloc_fhandle(); 424 fattr = nfs_alloc_fattr(); 425 status = -ENOMEM; 426 if (fh == NULL || fattr == NULL) 427 goto out_free; 428 429 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 430 nfs_mark_for_revalidate(dir); 431 432 /* 433 * V2 SYMLINK requests don't return any attributes. Setting the 434 * filehandle size to zero indicates to nfs_instantiate that it 435 * should fill in the data with a LOOKUP call on the wire. 436 */ 437 if (status == 0) 438 status = nfs_instantiate(dentry, fh, fattr, NULL); 439 440 out_free: 441 nfs_free_fattr(fattr); 442 nfs_free_fhandle(fh); 443 out: 444 dprintk("NFS reply symlink: %d\n", status); 445 return status; 446 } 447 448 static int 449 nfs_proc_mkdir(struct inode *dir, struct dentry *dentry, struct iattr *sattr) 450 { 451 struct nfs_createdata *data; 452 struct rpc_message msg = { 453 .rpc_proc = &nfs_procedures[NFSPROC_MKDIR], 454 }; 455 int status = -ENOMEM; 456 457 dprintk("NFS call mkdir %pd\n", dentry); 458 data = nfs_alloc_createdata(dir, dentry, sattr); 459 if (data == NULL) 460 goto out; 461 msg.rpc_argp = &data->arg; 462 msg.rpc_resp = &data->res; 463 464 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 465 nfs_mark_for_revalidate(dir); 466 if (status == 0) 467 status = nfs_instantiate(dentry, data->res.fh, data->res.fattr, NULL); 468 nfs_free_createdata(data); 469 out: 470 dprintk("NFS reply mkdir: %d\n", status); 471 return status; 472 } 473 474 static int 475 nfs_proc_rmdir(struct inode *dir, const struct qstr *name) 476 { 477 struct nfs_diropargs arg = { 478 .fh = NFS_FH(dir), 479 .name = name->name, 480 .len = name->len 481 }; 482 struct rpc_message msg = { 483 .rpc_proc = &nfs_procedures[NFSPROC_RMDIR], 484 .rpc_argp = &arg, 485 }; 486 int status; 487 488 dprintk("NFS call rmdir %s\n", name->name); 489 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 490 nfs_mark_for_revalidate(dir); 491 dprintk("NFS reply rmdir: %d\n", status); 492 return status; 493 } 494 495 /* 496 * The READDIR implementation is somewhat hackish - we pass a temporary 497 * buffer to the encode function, which installs it in the receive 498 * the receive iovec. The decode function just parses the reply to make 499 * sure it is syntactically correct; the entries itself are decoded 500 * from nfs_readdir by calling the decode_entry function directly. 501 */ 502 static int nfs_proc_readdir(struct nfs_readdir_arg *nr_arg, 503 struct nfs_readdir_res *nr_res) 504 { 505 struct inode *dir = d_inode(nr_arg->dentry); 506 struct nfs_readdirargs arg = { 507 .fh = NFS_FH(dir), 508 .cookie = nr_arg->cookie, 509 .count = nr_arg->page_len, 510 .pages = nr_arg->pages, 511 }; 512 struct rpc_message msg = { 513 .rpc_proc = &nfs_procedures[NFSPROC_READDIR], 514 .rpc_argp = &arg, 515 .rpc_cred = nr_arg->cred, 516 }; 517 int status; 518 519 dprintk("NFS call readdir %llu\n", (unsigned long long)nr_arg->cookie); 520 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); 521 nr_res->verf[0] = nr_res->verf[1] = 0; 522 523 nfs_invalidate_atime(dir); 524 525 dprintk("NFS reply readdir: %d\n", status); 526 return status; 527 } 528 529 static int 530 nfs_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle, 531 struct nfs_fsstat *stat) 532 { 533 struct nfs2_fsstat fsinfo; 534 struct rpc_message msg = { 535 .rpc_proc = &nfs_procedures[NFSPROC_STATFS], 536 .rpc_argp = fhandle, 537 .rpc_resp = &fsinfo, 538 }; 539 int status; 540 541 dprintk("NFS call statfs\n"); 542 nfs_fattr_init(stat->fattr); 543 status = rpc_call_sync(server->client, &msg, 0); 544 dprintk("NFS reply statfs: %d\n", status); 545 if (status) 546 goto out; 547 stat->tbytes = (u64)fsinfo.blocks * fsinfo.bsize; 548 stat->fbytes = (u64)fsinfo.bfree * fsinfo.bsize; 549 stat->abytes = (u64)fsinfo.bavail * fsinfo.bsize; 550 stat->tfiles = 0; 551 stat->ffiles = 0; 552 stat->afiles = 0; 553 out: 554 return status; 555 } 556 557 static int 558 nfs_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, 559 struct nfs_fsinfo *info) 560 { 561 struct nfs2_fsstat fsinfo; 562 struct rpc_message msg = { 563 .rpc_proc = &nfs_procedures[NFSPROC_STATFS], 564 .rpc_argp = fhandle, 565 .rpc_resp = &fsinfo, 566 }; 567 int status; 568 569 dprintk("NFS call fsinfo\n"); 570 nfs_fattr_init(info->fattr); 571 status = rpc_call_sync(server->client, &msg, 0); 572 dprintk("NFS reply fsinfo: %d\n", status); 573 if (status) 574 goto out; 575 info->rtmax = NFS_MAXDATA; 576 info->rtpref = fsinfo.tsize; 577 info->rtmult = fsinfo.bsize; 578 info->wtmax = NFS_MAXDATA; 579 info->wtpref = fsinfo.tsize; 580 info->wtmult = fsinfo.bsize; 581 info->dtpref = fsinfo.tsize; 582 info->maxfilesize = 0x7FFFFFFF; 583 info->lease_time = 0; 584 out: 585 return status; 586 } 587 588 static int 589 nfs_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle, 590 struct nfs_pathconf *info) 591 { 592 info->max_link = 0; 593 info->max_namelen = NFS2_MAXNAMLEN; 594 return 0; 595 } 596 597 static int nfs_read_done(struct rpc_task *task, struct nfs_pgio_header *hdr) 598 { 599 struct inode *inode = hdr->inode; 600 601 nfs_invalidate_atime(inode); 602 if (task->tk_status >= 0) { 603 nfs_refresh_inode(inode, hdr->res.fattr); 604 /* Emulate the eof flag, which isn't normally needed in NFSv2 605 * as it is guaranteed to always return the file attributes 606 */ 607 if ((hdr->res.count == 0 && hdr->args.count > 0) || 608 hdr->args.offset + hdr->res.count >= hdr->res.fattr->size) 609 hdr->res.eof = 1; 610 } 611 return 0; 612 } 613 614 static void nfs_proc_read_setup(struct nfs_pgio_header *hdr, 615 struct rpc_message *msg) 616 { 617 msg->rpc_proc = &nfs_procedures[NFSPROC_READ]; 618 } 619 620 static int nfs_proc_pgio_rpc_prepare(struct rpc_task *task, 621 struct nfs_pgio_header *hdr) 622 { 623 rpc_call_start(task); 624 return 0; 625 } 626 627 static int nfs_write_done(struct rpc_task *task, struct nfs_pgio_header *hdr) 628 { 629 if (task->tk_status >= 0) { 630 hdr->res.count = hdr->args.count; 631 nfs_writeback_update_inode(hdr); 632 } 633 return 0; 634 } 635 636 static void nfs_proc_write_setup(struct nfs_pgio_header *hdr, 637 struct rpc_message *msg, 638 struct rpc_clnt **clnt) 639 { 640 /* Note: NFSv2 ignores @stable and always uses NFS_FILE_SYNC */ 641 hdr->args.stable = NFS_FILE_SYNC; 642 msg->rpc_proc = &nfs_procedures[NFSPROC_WRITE]; 643 } 644 645 static void nfs_proc_commit_rpc_prepare(struct rpc_task *task, struct nfs_commit_data *data) 646 { 647 BUG(); 648 } 649 650 static void 651 nfs_proc_commit_setup(struct nfs_commit_data *data, struct rpc_message *msg, 652 struct rpc_clnt **clnt) 653 { 654 BUG(); 655 } 656 657 static int 658 nfs_proc_lock(struct file *filp, int cmd, struct file_lock *fl) 659 { 660 struct inode *inode = file_inode(filp); 661 662 return nlmclnt_proc(NFS_SERVER(inode)->nlm_host, cmd, fl, NULL); 663 } 664 665 /* Helper functions for NFS lock bounds checking */ 666 #define NFS_LOCK32_OFFSET_MAX ((__s32)0x7fffffffUL) 667 static int nfs_lock_check_bounds(const struct file_lock *fl) 668 { 669 __s32 start, end; 670 671 start = (__s32)fl->fl_start; 672 if ((loff_t)start != fl->fl_start) 673 goto out_einval; 674 675 if (fl->fl_end != OFFSET_MAX) { 676 end = (__s32)fl->fl_end; 677 if ((loff_t)end != fl->fl_end) 678 goto out_einval; 679 } else 680 end = NFS_LOCK32_OFFSET_MAX; 681 682 if (start < 0 || start > end) 683 goto out_einval; 684 return 0; 685 out_einval: 686 return -EINVAL; 687 } 688 689 static int nfs_have_delegation(struct inode *inode, fmode_t flags) 690 { 691 return 0; 692 } 693 694 static const struct inode_operations nfs_dir_inode_operations = { 695 .create = nfs_create, 696 .lookup = nfs_lookup, 697 .link = nfs_link, 698 .unlink = nfs_unlink, 699 .symlink = nfs_symlink, 700 .mkdir = nfs_mkdir, 701 .rmdir = nfs_rmdir, 702 .mknod = nfs_mknod, 703 .rename = nfs_rename, 704 .permission = nfs_permission, 705 .getattr = nfs_getattr, 706 .setattr = nfs_setattr, 707 }; 708 709 static const struct inode_operations nfs_file_inode_operations = { 710 .permission = nfs_permission, 711 .getattr = nfs_getattr, 712 .setattr = nfs_setattr, 713 }; 714 715 const struct nfs_rpc_ops nfs_v2_clientops = { 716 .version = 2, /* protocol version */ 717 .dentry_ops = &nfs_dentry_operations, 718 .dir_inode_ops = &nfs_dir_inode_operations, 719 .file_inode_ops = &nfs_file_inode_operations, 720 .file_ops = &nfs_file_operations, 721 .getroot = nfs_proc_get_root, 722 .submount = nfs_submount, 723 .try_get_tree = nfs_try_get_tree, 724 .getattr = nfs_proc_getattr, 725 .setattr = nfs_proc_setattr, 726 .lookup = nfs_proc_lookup, 727 .access = NULL, /* access */ 728 .readlink = nfs_proc_readlink, 729 .create = nfs_proc_create, 730 .remove = nfs_proc_remove, 731 .unlink_setup = nfs_proc_unlink_setup, 732 .unlink_rpc_prepare = nfs_proc_unlink_rpc_prepare, 733 .unlink_done = nfs_proc_unlink_done, 734 .rename_setup = nfs_proc_rename_setup, 735 .rename_rpc_prepare = nfs_proc_rename_rpc_prepare, 736 .rename_done = nfs_proc_rename_done, 737 .link = nfs_proc_link, 738 .symlink = nfs_proc_symlink, 739 .mkdir = nfs_proc_mkdir, 740 .rmdir = nfs_proc_rmdir, 741 .readdir = nfs_proc_readdir, 742 .mknod = nfs_proc_mknod, 743 .statfs = nfs_proc_statfs, 744 .fsinfo = nfs_proc_fsinfo, 745 .pathconf = nfs_proc_pathconf, 746 .decode_dirent = nfs2_decode_dirent, 747 .pgio_rpc_prepare = nfs_proc_pgio_rpc_prepare, 748 .read_setup = nfs_proc_read_setup, 749 .read_done = nfs_read_done, 750 .write_setup = nfs_proc_write_setup, 751 .write_done = nfs_write_done, 752 .commit_setup = nfs_proc_commit_setup, 753 .commit_rpc_prepare = nfs_proc_commit_rpc_prepare, 754 .lock = nfs_proc_lock, 755 .lock_check_bounds = nfs_lock_check_bounds, 756 .close_context = nfs_close_context, 757 .have_delegation = nfs_have_delegation, 758 .alloc_client = nfs_alloc_client, 759 .init_client = nfs_init_client, 760 .free_client = nfs_free_client, 761 .create_server = nfs_create_server, 762 .clone_server = nfs_clone_server, 763 }; 764