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