linux/fs/nfs/proc.c
<<
>>
Prefs
   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 */
  52static int
  53nfs_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 */
  99static int
 100nfs_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
 117static int
 118nfs_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
 119                 struct iattr *sattr)
 120{
 121        struct inode *inode = d_inode(dentry);
 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
 147static int
 148nfs_proc_lookup(struct inode *dir, const 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
 175static 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
 196struct nfs_createdata {
 197        struct nfs_createargs arg;
 198        struct nfs_diropok res;
 199        struct nfs_fh fhandle;
 200        struct nfs_fattr fattr;
 201};
 202
 203static 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
 223static void nfs_free_createdata(const struct nfs_createdata *data)
 224{
 225        kfree(data);
 226}
 227
 228static int
 229nfs_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);
 249out:
 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 */
 257static int
 258nfs_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);
 296out:
 297        dprintk("NFS reply mknod: %d\n", status);
 298        return status;
 299}
 300  
 301static int
 302nfs_proc_remove(struct inode *dir, const 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
 322static void
 323nfs_proc_unlink_setup(struct rpc_message *msg, struct inode *dir)
 324{
 325        msg->rpc_proc = &nfs_procedures[NFSPROC_REMOVE];
 326}
 327
 328static void nfs_proc_unlink_rpc_prepare(struct rpc_task *task, struct nfs_unlinkdata *data)
 329{
 330        rpc_call_start(task);
 331}
 332
 333static int nfs_proc_unlink_done(struct rpc_task *task, struct inode *dir)
 334{
 335        nfs_mark_for_revalidate(dir);
 336        return 1;
 337}
 338
 339static void
 340nfs_proc_rename_setup(struct rpc_message *msg, struct inode *dir)
 341{
 342        msg->rpc_proc = &nfs_procedures[NFSPROC_RENAME];
 343}
 344
 345static void nfs_proc_rename_rpc_prepare(struct rpc_task *task, struct nfs_renamedata *data)
 346{
 347        rpc_call_start(task);
 348}
 349
 350static int
 351nfs_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
 359static int
 360nfs_proc_link(struct inode *inode, struct inode *dir, const 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
 382static int
 383nfs_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
 424out_free:
 425        nfs_free_fattr(fattr);
 426        nfs_free_fhandle(fh);
 427out:
 428        dprintk("NFS reply symlink: %d\n", status);
 429        return status;
 430}
 431
 432static int
 433nfs_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);
 453out:
 454        dprintk("NFS reply mkdir: %d\n", status);
 455        return status;
 456}
 457
 458static int
 459nfs_proc_rmdir(struct inode *dir, const 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 */
 486static int
 487nfs_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 = d_inode(dentry);
 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
 513static int
 514nfs_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;
 537out:
 538        return status;
 539}
 540
 541static int
 542nfs_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;
 568out:
 569        return status;
 570}
 571
 572static int
 573nfs_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
 581static 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
 597static 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
 603static 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
 610static 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
 617static 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
 625static void nfs_proc_commit_rpc_prepare(struct rpc_task *task, struct nfs_commit_data *data)
 626{
 627        BUG();
 628}
 629
 630static void
 631nfs_proc_commit_setup(struct nfs_commit_data *data, struct rpc_message *msg)
 632{
 633        BUG();
 634}
 635
 636static int
 637nfs_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)
 646static 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;
 664out_einval:
 665        return -EINVAL;
 666}
 667
 668static int nfs_have_delegation(struct inode *inode, fmode_t flags)
 669{
 670        return 0;
 671}
 672
 673static int nfs_return_delegation(struct inode *inode)
 674{
 675        nfs_wb_all(inode);
 676        return 0;
 677}
 678
 679static 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
 694static const struct inode_operations nfs_file_inode_operations = {
 695        .permission     = nfs_permission,
 696        .getattr        = nfs_getattr,
 697        .setattr        = nfs_setattr,
 698};
 699
 700const 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