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