Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input
[linux-2.6] / fs / nfs / nfs3proc.c
1 /*
2  *  linux/fs/nfs/nfs3proc.c
3  *
4  *  Client-side NFSv3 procedures stubs.
5  *
6  *  Copyright (C) 1997, Olaf Kirch
7  */
8
9 #include <linux/mm.h>
10 #include <linux/utsname.h>
11 #include <linux/errno.h>
12 #include <linux/string.h>
13 #include <linux/sunrpc/clnt.h>
14 #include <linux/nfs.h>
15 #include <linux/nfs3.h>
16 #include <linux/nfs_fs.h>
17 #include <linux/nfs_page.h>
18 #include <linux/lockd/bind.h>
19 #include <linux/nfs_mount.h>
20
21 #include "iostat.h"
22 #include "internal.h"
23
24 #define NFSDBG_FACILITY         NFSDBG_PROC
25
26 /* A wrapper to handle the EJUKEBOX error message */
27 static int
28 nfs3_rpc_wrapper(struct rpc_clnt *clnt, struct rpc_message *msg, int flags)
29 {
30         sigset_t oldset;
31         int res;
32         rpc_clnt_sigmask(clnt, &oldset);
33         do {
34                 res = rpc_call_sync(clnt, msg, flags);
35                 if (res != -EJUKEBOX)
36                         break;
37                 schedule_timeout_interruptible(NFS_JUKEBOX_RETRY_TIME);
38                 res = -ERESTARTSYS;
39         } while (!signalled());
40         rpc_clnt_sigunmask(clnt, &oldset);
41         return res;
42 }
43
44 #define rpc_call_sync(clnt, msg, flags) nfs3_rpc_wrapper(clnt, msg, flags)
45
46 static int
47 nfs3_async_handle_jukebox(struct rpc_task *task, struct inode *inode)
48 {
49         if (task->tk_status != -EJUKEBOX)
50                 return 0;
51         nfs_inc_stats(inode, NFSIOS_DELAY);
52         task->tk_status = 0;
53         rpc_restart_call(task);
54         rpc_delay(task, NFS_JUKEBOX_RETRY_TIME);
55         return 1;
56 }
57
58 static int
59 do_proc_get_root(struct rpc_clnt *client, struct nfs_fh *fhandle,
60                  struct nfs_fsinfo *info)
61 {
62         struct rpc_message msg = {
63                 .rpc_proc       = &nfs3_procedures[NFS3PROC_FSINFO],
64                 .rpc_argp       = fhandle,
65                 .rpc_resp       = info,
66         };
67         int     status;
68
69         dprintk("%s: call  fsinfo\n", __FUNCTION__);
70         nfs_fattr_init(info->fattr);
71         status = rpc_call_sync(client, &msg, 0);
72         dprintk("%s: reply fsinfo: %d\n", __FUNCTION__, status);
73         if (!(info->fattr->valid & NFS_ATTR_FATTR)) {
74                 msg.rpc_proc = &nfs3_procedures[NFS3PROC_GETATTR];
75                 msg.rpc_resp = info->fattr;
76                 status = rpc_call_sync(client, &msg, 0);
77                 dprintk("%s: reply getattr: %d\n", __FUNCTION__, status);
78         }
79         return status;
80 }
81
82 /*
83  * Bare-bones access to getattr: this is for nfs_get_root/nfs_get_sb
84  */
85 static int
86 nfs3_proc_get_root(struct nfs_server *server, struct nfs_fh *fhandle,
87                    struct nfs_fsinfo *info)
88 {
89         int     status;
90
91         status = do_proc_get_root(server->client, fhandle, info);
92         if (status && server->nfs_client->cl_rpcclient != server->client)
93                 status = do_proc_get_root(server->nfs_client->cl_rpcclient, fhandle, info);
94         return status;
95 }
96
97 /*
98  * One function for each procedure in the NFS protocol.
99  */
100 static int
101 nfs3_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
102                 struct nfs_fattr *fattr)
103 {
104         struct rpc_message msg = {
105                 .rpc_proc       = &nfs3_procedures[NFS3PROC_GETATTR],
106                 .rpc_argp       = fhandle,
107                 .rpc_resp       = fattr,
108         };
109         int     status;
110
111         dprintk("NFS call  getattr\n");
112         nfs_fattr_init(fattr);
113         status = rpc_call_sync(server->client, &msg, 0);
114         dprintk("NFS reply getattr: %d\n", status);
115         return status;
116 }
117
118 static int
119 nfs3_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
120                         struct iattr *sattr)
121 {
122         struct inode *inode = dentry->d_inode;
123         struct nfs3_sattrargs   arg = {
124                 .fh             = NFS_FH(inode),
125                 .sattr          = sattr,
126         };
127         struct rpc_message msg = {
128                 .rpc_proc       = &nfs3_procedures[NFS3PROC_SETATTR],
129                 .rpc_argp       = &arg,
130                 .rpc_resp       = fattr,
131         };
132         int     status;
133
134         dprintk("NFS call  setattr\n");
135         nfs_fattr_init(fattr);
136         status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
137         if (status == 0)
138                 nfs_setattr_update_inode(inode, sattr);
139         dprintk("NFS reply setattr: %d\n", status);
140         return status;
141 }
142
143 static int
144 nfs3_proc_lookup(struct inode *dir, struct qstr *name,
145                  struct nfs_fh *fhandle, struct nfs_fattr *fattr)
146 {
147         struct nfs_fattr        dir_attr;
148         struct nfs3_diropargs   arg = {
149                 .fh             = NFS_FH(dir),
150                 .name           = name->name,
151                 .len            = name->len
152         };
153         struct nfs3_diropres    res = {
154                 .dir_attr       = &dir_attr,
155                 .fh             = fhandle,
156                 .fattr          = fattr
157         };
158         struct rpc_message msg = {
159                 .rpc_proc       = &nfs3_procedures[NFS3PROC_LOOKUP],
160                 .rpc_argp       = &arg,
161                 .rpc_resp       = &res,
162         };
163         int                     status;
164
165         dprintk("NFS call  lookup %s\n", name->name);
166         nfs_fattr_init(&dir_attr);
167         nfs_fattr_init(fattr);
168         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
169         if (status >= 0 && !(fattr->valid & NFS_ATTR_FATTR)) {
170                 msg.rpc_proc = &nfs3_procedures[NFS3PROC_GETATTR];
171                 msg.rpc_argp = fhandle;
172                 msg.rpc_resp = fattr;
173                 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
174         }
175         dprintk("NFS reply lookup: %d\n", status);
176         if (status >= 0)
177                 status = nfs_refresh_inode(dir, &dir_attr);
178         return status;
179 }
180
181 static int nfs3_proc_access(struct inode *inode, struct nfs_access_entry *entry)
182 {
183         struct nfs_fattr        fattr;
184         struct nfs3_accessargs  arg = {
185                 .fh             = NFS_FH(inode),
186         };
187         struct nfs3_accessres   res = {
188                 .fattr          = &fattr,
189         };
190         struct rpc_message msg = {
191                 .rpc_proc       = &nfs3_procedures[NFS3PROC_ACCESS],
192                 .rpc_argp       = &arg,
193                 .rpc_resp       = &res,
194                 .rpc_cred       = entry->cred,
195         };
196         int mode = entry->mask;
197         int status;
198
199         dprintk("NFS call  access\n");
200
201         if (mode & MAY_READ)
202                 arg.access |= NFS3_ACCESS_READ;
203         if (S_ISDIR(inode->i_mode)) {
204                 if (mode & MAY_WRITE)
205                         arg.access |= NFS3_ACCESS_MODIFY | NFS3_ACCESS_EXTEND | NFS3_ACCESS_DELETE;
206                 if (mode & MAY_EXEC)
207                         arg.access |= NFS3_ACCESS_LOOKUP;
208         } else {
209                 if (mode & MAY_WRITE)
210                         arg.access |= NFS3_ACCESS_MODIFY | NFS3_ACCESS_EXTEND;
211                 if (mode & MAY_EXEC)
212                         arg.access |= NFS3_ACCESS_EXECUTE;
213         }
214         nfs_fattr_init(&fattr);
215         status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
216         nfs_refresh_inode(inode, &fattr);
217         if (status == 0) {
218                 entry->mask = 0;
219                 if (res.access & NFS3_ACCESS_READ)
220                         entry->mask |= MAY_READ;
221                 if (res.access & (NFS3_ACCESS_MODIFY | NFS3_ACCESS_EXTEND | NFS3_ACCESS_DELETE))
222                         entry->mask |= MAY_WRITE;
223                 if (res.access & (NFS3_ACCESS_LOOKUP|NFS3_ACCESS_EXECUTE))
224                         entry->mask |= MAY_EXEC;
225         }
226         dprintk("NFS reply access: %d\n", status);
227         return status;
228 }
229
230 static int nfs3_proc_readlink(struct inode *inode, struct page *page,
231                 unsigned int pgbase, unsigned int pglen)
232 {
233         struct nfs_fattr        fattr;
234         struct nfs3_readlinkargs args = {
235                 .fh             = NFS_FH(inode),
236                 .pgbase         = pgbase,
237                 .pglen          = pglen,
238                 .pages          = &page
239         };
240         struct rpc_message msg = {
241                 .rpc_proc       = &nfs3_procedures[NFS3PROC_READLINK],
242                 .rpc_argp       = &args,
243                 .rpc_resp       = &fattr,
244         };
245         int                     status;
246
247         dprintk("NFS call  readlink\n");
248         nfs_fattr_init(&fattr);
249         status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
250         nfs_refresh_inode(inode, &fattr);
251         dprintk("NFS reply readlink: %d\n", status);
252         return status;
253 }
254
255 /*
256  * Create a regular file.
257  * For now, we don't implement O_EXCL.
258  */
259 static int
260 nfs3_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
261                  int flags, struct nameidata *nd)
262 {
263         struct nfs_fh           fhandle;
264         struct nfs_fattr        fattr;
265         struct nfs_fattr        dir_attr;
266         struct nfs3_createargs  arg = {
267                 .fh             = NFS_FH(dir),
268                 .name           = dentry->d_name.name,
269                 .len            = dentry->d_name.len,
270                 .sattr          = sattr,
271         };
272         struct nfs3_diropres    res = {
273                 .dir_attr       = &dir_attr,
274                 .fh             = &fhandle,
275                 .fattr          = &fattr
276         };
277         struct rpc_message msg = {
278                 .rpc_proc       = &nfs3_procedures[NFS3PROC_CREATE],
279                 .rpc_argp       = &arg,
280                 .rpc_resp       = &res,
281         };
282         mode_t mode = sattr->ia_mode;
283         int status;
284
285         dprintk("NFS call  create %s\n", dentry->d_name.name);
286         arg.createmode = NFS3_CREATE_UNCHECKED;
287         if (flags & O_EXCL) {
288                 arg.createmode  = NFS3_CREATE_EXCLUSIVE;
289                 arg.verifier[0] = jiffies;
290                 arg.verifier[1] = current->pid;
291         }
292
293         sattr->ia_mode &= ~current->fs->umask;
294
295 again:
296         nfs_fattr_init(&dir_attr);
297         nfs_fattr_init(&fattr);
298         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
299         nfs_refresh_inode(dir, &dir_attr);
300
301         /* If the server doesn't support the exclusive creation semantics,
302          * try again with simple 'guarded' mode. */
303         if (status == -ENOTSUPP) {
304                 switch (arg.createmode) {
305                         case NFS3_CREATE_EXCLUSIVE:
306                                 arg.createmode = NFS3_CREATE_GUARDED;
307                                 break;
308
309                         case NFS3_CREATE_GUARDED:
310                                 arg.createmode = NFS3_CREATE_UNCHECKED;
311                                 break;
312
313                         case NFS3_CREATE_UNCHECKED:
314                                 goto out;
315                 }
316                 goto again;
317         }
318
319         if (status == 0)
320                 status = nfs_instantiate(dentry, &fhandle, &fattr);
321         if (status != 0)
322                 goto out;
323
324         /* When we created the file with exclusive semantics, make
325          * sure we set the attributes afterwards. */
326         if (arg.createmode == NFS3_CREATE_EXCLUSIVE) {
327                 dprintk("NFS call  setattr (post-create)\n");
328
329                 if (!(sattr->ia_valid & ATTR_ATIME_SET))
330                         sattr->ia_valid |= ATTR_ATIME;
331                 if (!(sattr->ia_valid & ATTR_MTIME_SET))
332                         sattr->ia_valid |= ATTR_MTIME;
333
334                 /* Note: we could use a guarded setattr here, but I'm
335                  * not sure this buys us anything (and I'd have
336                  * to revamp the NFSv3 XDR code) */
337                 status = nfs3_proc_setattr(dentry, &fattr, sattr);
338                 nfs_post_op_update_inode(dentry->d_inode, &fattr);
339                 dprintk("NFS reply setattr (post-create): %d\n", status);
340         }
341         if (status != 0)
342                 goto out;
343         status = nfs3_proc_set_default_acl(dir, dentry->d_inode, mode);
344 out:
345         dprintk("NFS reply create: %d\n", status);
346         return status;
347 }
348
349 static int
350 nfs3_proc_remove(struct inode *dir, struct qstr *name)
351 {
352         struct nfs_removeargs arg = {
353                 .fh = NFS_FH(dir),
354                 .name.len = name->len,
355                 .name.name = name->name,
356         };
357         struct nfs_removeres res;
358         struct rpc_message msg = {
359                 .rpc_proc = &nfs3_procedures[NFS3PROC_REMOVE],
360                 .rpc_argp = &arg,
361                 .rpc_resp = &res,
362         };
363         int                     status;
364
365         dprintk("NFS call  remove %s\n", name->name);
366         nfs_fattr_init(&res.dir_attr);
367         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
368         nfs_post_op_update_inode(dir, &res.dir_attr);
369         dprintk("NFS reply remove: %d\n", status);
370         return status;
371 }
372
373 static void
374 nfs3_proc_unlink_setup(struct rpc_message *msg, struct inode *dir)
375 {
376         msg->rpc_proc = &nfs3_procedures[NFS3PROC_REMOVE];
377 }
378
379 static int
380 nfs3_proc_unlink_done(struct rpc_task *task, struct inode *dir)
381 {
382         struct nfs_removeres *res;
383         if (nfs3_async_handle_jukebox(task, dir))
384                 return 0;
385         res = task->tk_msg.rpc_resp;
386         nfs_post_op_update_inode(dir, &res->dir_attr);
387         return 1;
388 }
389
390 static int
391 nfs3_proc_rename(struct inode *old_dir, struct qstr *old_name,
392                  struct inode *new_dir, struct qstr *new_name)
393 {
394         struct nfs_fattr        old_dir_attr, new_dir_attr;
395         struct nfs3_renameargs  arg = {
396                 .fromfh         = NFS_FH(old_dir),
397                 .fromname       = old_name->name,
398                 .fromlen        = old_name->len,
399                 .tofh           = NFS_FH(new_dir),
400                 .toname         = new_name->name,
401                 .tolen          = new_name->len
402         };
403         struct nfs3_renameres   res = {
404                 .fromattr       = &old_dir_attr,
405                 .toattr         = &new_dir_attr
406         };
407         struct rpc_message msg = {
408                 .rpc_proc       = &nfs3_procedures[NFS3PROC_RENAME],
409                 .rpc_argp       = &arg,
410                 .rpc_resp       = &res,
411         };
412         int                     status;
413
414         dprintk("NFS call  rename %s -> %s\n", old_name->name, new_name->name);
415         nfs_fattr_init(&old_dir_attr);
416         nfs_fattr_init(&new_dir_attr);
417         status = rpc_call_sync(NFS_CLIENT(old_dir), &msg, 0);
418         nfs_post_op_update_inode(old_dir, &old_dir_attr);
419         nfs_post_op_update_inode(new_dir, &new_dir_attr);
420         dprintk("NFS reply rename: %d\n", status);
421         return status;
422 }
423
424 static int
425 nfs3_proc_link(struct inode *inode, struct inode *dir, struct qstr *name)
426 {
427         struct nfs_fattr        dir_attr, fattr;
428         struct nfs3_linkargs    arg = {
429                 .fromfh         = NFS_FH(inode),
430                 .tofh           = NFS_FH(dir),
431                 .toname         = name->name,
432                 .tolen          = name->len
433         };
434         struct nfs3_linkres     res = {
435                 .dir_attr       = &dir_attr,
436                 .fattr          = &fattr
437         };
438         struct rpc_message msg = {
439                 .rpc_proc       = &nfs3_procedures[NFS3PROC_LINK],
440                 .rpc_argp       = &arg,
441                 .rpc_resp       = &res,
442         };
443         int                     status;
444
445         dprintk("NFS call  link %s\n", name->name);
446         nfs_fattr_init(&dir_attr);
447         nfs_fattr_init(&fattr);
448         status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
449         nfs_post_op_update_inode(dir, &dir_attr);
450         nfs_post_op_update_inode(inode, &fattr);
451         dprintk("NFS reply link: %d\n", status);
452         return status;
453 }
454
455 static int
456 nfs3_proc_symlink(struct inode *dir, struct dentry *dentry, struct page *page,
457                   unsigned int len, struct iattr *sattr)
458 {
459         struct nfs_fh fhandle;
460         struct nfs_fattr fattr, dir_attr;
461         struct nfs3_symlinkargs arg = {
462                 .fromfh         = NFS_FH(dir),
463                 .fromname       = dentry->d_name.name,
464                 .fromlen        = dentry->d_name.len,
465                 .pages          = &page,
466                 .pathlen        = len,
467                 .sattr          = sattr
468         };
469         struct nfs3_diropres    res = {
470                 .dir_attr       = &dir_attr,
471                 .fh             = &fhandle,
472                 .fattr          = &fattr
473         };
474         struct rpc_message msg = {
475                 .rpc_proc       = &nfs3_procedures[NFS3PROC_SYMLINK],
476                 .rpc_argp       = &arg,
477                 .rpc_resp       = &res,
478         };
479         int                     status;
480
481         if (len > NFS3_MAXPATHLEN)
482                 return -ENAMETOOLONG;
483
484         dprintk("NFS call  symlink %s\n", dentry->d_name.name);
485
486         nfs_fattr_init(&dir_attr);
487         nfs_fattr_init(&fattr);
488         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
489         nfs_post_op_update_inode(dir, &dir_attr);
490         if (status != 0)
491                 goto out;
492         status = nfs_instantiate(dentry, &fhandle, &fattr);
493 out:
494         dprintk("NFS reply symlink: %d\n", status);
495         return status;
496 }
497
498 static int
499 nfs3_proc_mkdir(struct inode *dir, struct dentry *dentry, struct iattr *sattr)
500 {
501         struct nfs_fh fhandle;
502         struct nfs_fattr fattr, dir_attr;
503         struct nfs3_mkdirargs   arg = {
504                 .fh             = NFS_FH(dir),
505                 .name           = dentry->d_name.name,
506                 .len            = dentry->d_name.len,
507                 .sattr          = sattr
508         };
509         struct nfs3_diropres    res = {
510                 .dir_attr       = &dir_attr,
511                 .fh             = &fhandle,
512                 .fattr          = &fattr
513         };
514         struct rpc_message msg = {
515                 .rpc_proc       = &nfs3_procedures[NFS3PROC_MKDIR],
516                 .rpc_argp       = &arg,
517                 .rpc_resp       = &res,
518         };
519         int mode = sattr->ia_mode;
520         int status;
521
522         dprintk("NFS call  mkdir %s\n", dentry->d_name.name);
523
524         sattr->ia_mode &= ~current->fs->umask;
525
526         nfs_fattr_init(&dir_attr);
527         nfs_fattr_init(&fattr);
528         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
529         nfs_post_op_update_inode(dir, &dir_attr);
530         if (status != 0)
531                 goto out;
532         status = nfs_instantiate(dentry, &fhandle, &fattr);
533         if (status != 0)
534                 goto out;
535         status = nfs3_proc_set_default_acl(dir, dentry->d_inode, mode);
536 out:
537         dprintk("NFS reply mkdir: %d\n", status);
538         return status;
539 }
540
541 static int
542 nfs3_proc_rmdir(struct inode *dir, struct qstr *name)
543 {
544         struct nfs_fattr        dir_attr;
545         struct nfs3_diropargs   arg = {
546                 .fh             = NFS_FH(dir),
547                 .name           = name->name,
548                 .len            = name->len
549         };
550         struct rpc_message msg = {
551                 .rpc_proc       = &nfs3_procedures[NFS3PROC_RMDIR],
552                 .rpc_argp       = &arg,
553                 .rpc_resp       = &dir_attr,
554         };
555         int                     status;
556
557         dprintk("NFS call  rmdir %s\n", name->name);
558         nfs_fattr_init(&dir_attr);
559         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
560         nfs_post_op_update_inode(dir, &dir_attr);
561         dprintk("NFS reply rmdir: %d\n", status);
562         return status;
563 }
564
565 /*
566  * The READDIR implementation is somewhat hackish - we pass the user buffer
567  * to the encode function, which installs it in the receive iovec.
568  * The decode function itself doesn't perform any decoding, it just makes
569  * sure the reply is syntactically correct.
570  *
571  * Also note that this implementation handles both plain readdir and
572  * readdirplus.
573  */
574 static int
575 nfs3_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
576                   u64 cookie, struct page *page, unsigned int count, int plus)
577 {
578         struct inode            *dir = dentry->d_inode;
579         struct nfs_fattr        dir_attr;
580         __be32                  *verf = NFS_COOKIEVERF(dir);
581         struct nfs3_readdirargs arg = {
582                 .fh             = NFS_FH(dir),
583                 .cookie         = cookie,
584                 .verf           = {verf[0], verf[1]},
585                 .plus           = plus,
586                 .count          = count,
587                 .pages          = &page
588         };
589         struct nfs3_readdirres  res = {
590                 .dir_attr       = &dir_attr,
591                 .verf           = verf,
592                 .plus           = plus
593         };
594         struct rpc_message      msg = {
595                 .rpc_proc       = &nfs3_procedures[NFS3PROC_READDIR],
596                 .rpc_argp       = &arg,
597                 .rpc_resp       = &res,
598                 .rpc_cred       = cred
599         };
600         int                     status;
601
602         if (plus)
603                 msg.rpc_proc = &nfs3_procedures[NFS3PROC_READDIRPLUS];
604
605         dprintk("NFS call  readdir%s %d\n",
606                         plus? "plus" : "", (unsigned int) cookie);
607
608         nfs_fattr_init(&dir_attr);
609         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
610         nfs_refresh_inode(dir, &dir_attr);
611         dprintk("NFS reply readdir: %d\n", status);
612         return status;
613 }
614
615 static int
616 nfs3_proc_mknod(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
617                 dev_t rdev)
618 {
619         struct nfs_fh fh;
620         struct nfs_fattr fattr, dir_attr;
621         struct nfs3_mknodargs   arg = {
622                 .fh             = NFS_FH(dir),
623                 .name           = dentry->d_name.name,
624                 .len            = dentry->d_name.len,
625                 .sattr          = sattr,
626                 .rdev           = rdev
627         };
628         struct nfs3_diropres    res = {
629                 .dir_attr       = &dir_attr,
630                 .fh             = &fh,
631                 .fattr          = &fattr
632         };
633         struct rpc_message msg = {
634                 .rpc_proc       = &nfs3_procedures[NFS3PROC_MKNOD],
635                 .rpc_argp       = &arg,
636                 .rpc_resp       = &res,
637         };
638         mode_t mode = sattr->ia_mode;
639         int status;
640
641         switch (sattr->ia_mode & S_IFMT) {
642         case S_IFBLK:   arg.type = NF3BLK;  break;
643         case S_IFCHR:   arg.type = NF3CHR;  break;
644         case S_IFIFO:   arg.type = NF3FIFO; break;
645         case S_IFSOCK:  arg.type = NF3SOCK; break;
646         default:        return -EINVAL;
647         }
648
649         dprintk("NFS call  mknod %s %u:%u\n", dentry->d_name.name,
650                         MAJOR(rdev), MINOR(rdev));
651
652         sattr->ia_mode &= ~current->fs->umask;
653
654         nfs_fattr_init(&dir_attr);
655         nfs_fattr_init(&fattr);
656         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
657         nfs_post_op_update_inode(dir, &dir_attr);
658         if (status != 0)
659                 goto out;
660         status = nfs_instantiate(dentry, &fh, &fattr);
661         if (status != 0)
662                 goto out;
663         status = nfs3_proc_set_default_acl(dir, dentry->d_inode, mode);
664 out:
665         dprintk("NFS reply mknod: %d\n", status);
666         return status;
667 }
668
669 static int
670 nfs3_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle,
671                  struct nfs_fsstat *stat)
672 {
673         struct rpc_message msg = {
674                 .rpc_proc       = &nfs3_procedures[NFS3PROC_FSSTAT],
675                 .rpc_argp       = fhandle,
676                 .rpc_resp       = stat,
677         };
678         int     status;
679
680         dprintk("NFS call  fsstat\n");
681         nfs_fattr_init(stat->fattr);
682         status = rpc_call_sync(server->client, &msg, 0);
683         dprintk("NFS reply statfs: %d\n", status);
684         return status;
685 }
686
687 static int
688 nfs3_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle,
689                  struct nfs_fsinfo *info)
690 {
691         struct rpc_message msg = {
692                 .rpc_proc       = &nfs3_procedures[NFS3PROC_FSINFO],
693                 .rpc_argp       = fhandle,
694                 .rpc_resp       = info,
695         };
696         int     status;
697
698         dprintk("NFS call  fsinfo\n");
699         nfs_fattr_init(info->fattr);
700         status = rpc_call_sync(server->nfs_client->cl_rpcclient, &msg, 0);
701         dprintk("NFS reply fsinfo: %d\n", status);
702         return status;
703 }
704
705 static int
706 nfs3_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
707                    struct nfs_pathconf *info)
708 {
709         struct rpc_message msg = {
710                 .rpc_proc       = &nfs3_procedures[NFS3PROC_PATHCONF],
711                 .rpc_argp       = fhandle,
712                 .rpc_resp       = info,
713         };
714         int     status;
715
716         dprintk("NFS call  pathconf\n");
717         nfs_fattr_init(info->fattr);
718         status = rpc_call_sync(server->client, &msg, 0);
719         dprintk("NFS reply pathconf: %d\n", status);
720         return status;
721 }
722
723 static int nfs3_read_done(struct rpc_task *task, struct nfs_read_data *data)
724 {
725         if (nfs3_async_handle_jukebox(task, data->inode))
726                 return -EAGAIN;
727         /* Call back common NFS readpage processing */
728         if (task->tk_status >= 0)
729                 nfs_refresh_inode(data->inode, &data->fattr);
730         return 0;
731 }
732
733 static void nfs3_proc_read_setup(struct nfs_read_data *data)
734 {
735         struct rpc_message      msg = {
736                 .rpc_proc       = &nfs3_procedures[NFS3PROC_READ],
737                 .rpc_argp       = &data->args,
738                 .rpc_resp       = &data->res,
739                 .rpc_cred       = data->cred,
740         };
741
742         rpc_call_setup(&data->task, &msg, 0);
743 }
744
745 static int nfs3_write_done(struct rpc_task *task, struct nfs_write_data *data)
746 {
747         if (nfs3_async_handle_jukebox(task, data->inode))
748                 return -EAGAIN;
749         if (task->tk_status >= 0)
750                 nfs_post_op_update_inode(data->inode, data->res.fattr);
751         return 0;
752 }
753
754 static void nfs3_proc_write_setup(struct nfs_write_data *data, int how)
755 {
756         struct rpc_message      msg = {
757                 .rpc_proc       = &nfs3_procedures[NFS3PROC_WRITE],
758                 .rpc_argp       = &data->args,
759                 .rpc_resp       = &data->res,
760                 .rpc_cred       = data->cred,
761         };
762
763         data->args.stable = NFS_UNSTABLE;
764         if (how & FLUSH_STABLE) {
765                 data->args.stable = NFS_FILE_SYNC;
766                 if (NFS_I(data->inode)->ncommit)
767                         data->args.stable = NFS_DATA_SYNC;
768         }
769
770         /* Finalize the task. */
771         rpc_call_setup(&data->task, &msg, 0);
772 }
773
774 static int nfs3_commit_done(struct rpc_task *task, struct nfs_write_data *data)
775 {
776         if (nfs3_async_handle_jukebox(task, data->inode))
777                 return -EAGAIN;
778         if (task->tk_status >= 0)
779                 nfs_post_op_update_inode(data->inode, data->res.fattr);
780         return 0;
781 }
782
783 static void nfs3_proc_commit_setup(struct nfs_write_data *data, int how)
784 {
785         struct rpc_message      msg = {
786                 .rpc_proc       = &nfs3_procedures[NFS3PROC_COMMIT],
787                 .rpc_argp       = &data->args,
788                 .rpc_resp       = &data->res,
789                 .rpc_cred       = data->cred,
790         };
791
792         rpc_call_setup(&data->task, &msg, 0);
793 }
794
795 static int
796 nfs3_proc_lock(struct file *filp, int cmd, struct file_lock *fl)
797 {
798         return nlmclnt_proc(filp->f_path.dentry->d_inode, cmd, fl);
799 }
800
801 const struct nfs_rpc_ops nfs_v3_clientops = {
802         .version        = 3,                    /* protocol version */
803         .dentry_ops     = &nfs_dentry_operations,
804         .dir_inode_ops  = &nfs3_dir_inode_operations,
805         .file_inode_ops = &nfs3_file_inode_operations,
806         .getroot        = nfs3_proc_get_root,
807         .getattr        = nfs3_proc_getattr,
808         .setattr        = nfs3_proc_setattr,
809         .lookup         = nfs3_proc_lookup,
810         .access         = nfs3_proc_access,
811         .readlink       = nfs3_proc_readlink,
812         .create         = nfs3_proc_create,
813         .remove         = nfs3_proc_remove,
814         .unlink_setup   = nfs3_proc_unlink_setup,
815         .unlink_done    = nfs3_proc_unlink_done,
816         .rename         = nfs3_proc_rename,
817         .link           = nfs3_proc_link,
818         .symlink        = nfs3_proc_symlink,
819         .mkdir          = nfs3_proc_mkdir,
820         .rmdir          = nfs3_proc_rmdir,
821         .readdir        = nfs3_proc_readdir,
822         .mknod          = nfs3_proc_mknod,
823         .statfs         = nfs3_proc_statfs,
824         .fsinfo         = nfs3_proc_fsinfo,
825         .pathconf       = nfs3_proc_pathconf,
826         .decode_dirent  = nfs3_decode_dirent,
827         .read_setup     = nfs3_proc_read_setup,
828         .read_done      = nfs3_read_done,
829         .write_setup    = nfs3_proc_write_setup,
830         .write_done     = nfs3_write_done,
831         .commit_setup   = nfs3_proc_commit_setup,
832         .commit_done    = nfs3_commit_done,
833         .file_open      = nfs_open,
834         .file_release   = nfs_release,
835         .lock           = nfs3_proc_lock,
836         .clear_acl_cache = nfs3_forget_cached_acls,
837 };