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