NFS: Remove nfs_readpage_sync()
[linux-2.6.git] / 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_get_root/nfs_get_sb
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->nfs_client->cl_rpcclient != server->client)
94                 status = do_proc_get_root(server->nfs_client->cl_rpcclient, 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 /*
257  * Create a regular file.
258  * For now, we don't implement O_EXCL.
259  */
260 static int
261 nfs3_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
262                  int flags, struct nameidata *nd)
263 {
264         struct nfs_fh           fhandle;
265         struct nfs_fattr        fattr;
266         struct nfs_fattr        dir_attr;
267         struct nfs3_createargs  arg = {
268                 .fh             = NFS_FH(dir),
269                 .name           = dentry->d_name.name,
270                 .len            = dentry->d_name.len,
271                 .sattr          = sattr,
272         };
273         struct nfs3_diropres    res = {
274                 .dir_attr       = &dir_attr,
275                 .fh             = &fhandle,
276                 .fattr          = &fattr
277         };
278         struct rpc_message msg = {
279                 .rpc_proc       = &nfs3_procedures[NFS3PROC_CREATE],
280                 .rpc_argp       = &arg,
281                 .rpc_resp       = &res,
282         };
283         mode_t mode = sattr->ia_mode;
284         int status;
285
286         dprintk("NFS call  create %s\n", dentry->d_name.name);
287         arg.createmode = NFS3_CREATE_UNCHECKED;
288         if (flags & O_EXCL) {
289                 arg.createmode  = NFS3_CREATE_EXCLUSIVE;
290                 arg.verifier[0] = jiffies;
291                 arg.verifier[1] = current->pid;
292         }
293
294         sattr->ia_mode &= ~current->fs->umask;
295
296 again:
297         nfs_fattr_init(&dir_attr);
298         nfs_fattr_init(&fattr);
299         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
300         nfs_refresh_inode(dir, &dir_attr);
301
302         /* If the server doesn't support the exclusive creation semantics,
303          * try again with simple 'guarded' mode. */
304         if (status == -ENOTSUPP) {
305                 switch (arg.createmode) {
306                         case NFS3_CREATE_EXCLUSIVE:
307                                 arg.createmode = NFS3_CREATE_GUARDED;
308                                 break;
309
310                         case NFS3_CREATE_GUARDED:
311                                 arg.createmode = NFS3_CREATE_UNCHECKED;
312                                 break;
313
314                         case NFS3_CREATE_UNCHECKED:
315                                 goto out;
316                 }
317                 goto again;
318         }
319
320         if (status == 0)
321                 status = nfs_instantiate(dentry, &fhandle, &fattr);
322         if (status != 0)
323                 goto out;
324
325         /* When we created the file with exclusive semantics, make
326          * sure we set the attributes afterwards. */
327         if (arg.createmode == NFS3_CREATE_EXCLUSIVE) {
328                 dprintk("NFS call  setattr (post-create)\n");
329
330                 if (!(sattr->ia_valid & ATTR_ATIME_SET))
331                         sattr->ia_valid |= ATTR_ATIME;
332                 if (!(sattr->ia_valid & ATTR_MTIME_SET))
333                         sattr->ia_valid |= ATTR_MTIME;
334
335                 /* Note: we could use a guarded setattr here, but I'm
336                  * not sure this buys us anything (and I'd have
337                  * to revamp the NFSv3 XDR code) */
338                 status = nfs3_proc_setattr(dentry, &fattr, sattr);
339                 if (status == 0)
340                         nfs_setattr_update_inode(dentry->d_inode, sattr);
341                 nfs_refresh_inode(dentry->d_inode, &fattr);
342                 dprintk("NFS reply setattr (post-create): %d\n", status);
343         }
344         if (status != 0)
345                 goto out;
346         status = nfs3_proc_set_default_acl(dir, dentry->d_inode, mode);
347 out:
348         dprintk("NFS reply create: %d\n", status);
349         return status;
350 }
351
352 static int
353 nfs3_proc_remove(struct inode *dir, struct qstr *name)
354 {
355         struct nfs_fattr        dir_attr;
356         struct nfs3_diropargs   arg = {
357                 .fh             = NFS_FH(dir),
358                 .name           = name->name,
359                 .len            = name->len
360         };
361         struct rpc_message      msg = {
362                 .rpc_proc       = &nfs3_procedures[NFS3PROC_REMOVE],
363                 .rpc_argp       = &arg,
364                 .rpc_resp       = &dir_attr,
365         };
366         int                     status;
367
368         dprintk("NFS call  remove %s\n", name->name);
369         nfs_fattr_init(&dir_attr);
370         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
371         nfs_post_op_update_inode(dir, &dir_attr);
372         dprintk("NFS reply remove: %d\n", status);
373         return status;
374 }
375
376 static int
377 nfs3_proc_unlink_setup(struct rpc_message *msg, struct dentry *dir, struct qstr *name)
378 {
379         struct unlinkxdr {
380                 struct nfs3_diropargs arg;
381                 struct nfs_fattr res;
382         } *ptr;
383
384         ptr = kmalloc(sizeof(*ptr), GFP_KERNEL);
385         if (!ptr)
386                 return -ENOMEM;
387         ptr->arg.fh = NFS_FH(dir->d_inode);
388         ptr->arg.name = name->name;
389         ptr->arg.len = name->len;
390         nfs_fattr_init(&ptr->res);
391         msg->rpc_proc = &nfs3_procedures[NFS3PROC_REMOVE];
392         msg->rpc_argp = &ptr->arg;
393         msg->rpc_resp = &ptr->res;
394         return 0;
395 }
396
397 static int
398 nfs3_proc_unlink_done(struct dentry *dir, struct rpc_task *task)
399 {
400         struct rpc_message *msg = &task->tk_msg;
401         struct nfs_fattr        *dir_attr;
402
403         if (nfs3_async_handle_jukebox(task, dir->d_inode))
404                 return 1;
405         if (msg->rpc_argp) {
406                 dir_attr = (struct nfs_fattr*)msg->rpc_resp;
407                 nfs_post_op_update_inode(dir->d_inode, dir_attr);
408                 kfree(msg->rpc_argp);
409         }
410         return 0;
411 }
412
413 static int
414 nfs3_proc_rename(struct inode *old_dir, struct qstr *old_name,
415                  struct inode *new_dir, struct qstr *new_name)
416 {
417         struct nfs_fattr        old_dir_attr, new_dir_attr;
418         struct nfs3_renameargs  arg = {
419                 .fromfh         = NFS_FH(old_dir),
420                 .fromname       = old_name->name,
421                 .fromlen        = old_name->len,
422                 .tofh           = NFS_FH(new_dir),
423                 .toname         = new_name->name,
424                 .tolen          = new_name->len
425         };
426         struct nfs3_renameres   res = {
427                 .fromattr       = &old_dir_attr,
428                 .toattr         = &new_dir_attr
429         };
430         struct rpc_message msg = {
431                 .rpc_proc       = &nfs3_procedures[NFS3PROC_RENAME],
432                 .rpc_argp       = &arg,
433                 .rpc_resp       = &res,
434         };
435         int                     status;
436
437         dprintk("NFS call  rename %s -> %s\n", old_name->name, new_name->name);
438         nfs_fattr_init(&old_dir_attr);
439         nfs_fattr_init(&new_dir_attr);
440         status = rpc_call_sync(NFS_CLIENT(old_dir), &msg, 0);
441         nfs_post_op_update_inode(old_dir, &old_dir_attr);
442         nfs_post_op_update_inode(new_dir, &new_dir_attr);
443         dprintk("NFS reply rename: %d\n", status);
444         return status;
445 }
446
447 static int
448 nfs3_proc_link(struct inode *inode, struct inode *dir, struct qstr *name)
449 {
450         struct nfs_fattr        dir_attr, fattr;
451         struct nfs3_linkargs    arg = {
452                 .fromfh         = NFS_FH(inode),
453                 .tofh           = NFS_FH(dir),
454                 .toname         = name->name,
455                 .tolen          = name->len
456         };
457         struct nfs3_linkres     res = {
458                 .dir_attr       = &dir_attr,
459                 .fattr          = &fattr
460         };
461         struct rpc_message msg = {
462                 .rpc_proc       = &nfs3_procedures[NFS3PROC_LINK],
463                 .rpc_argp       = &arg,
464                 .rpc_resp       = &res,
465         };
466         int                     status;
467
468         dprintk("NFS call  link %s\n", name->name);
469         nfs_fattr_init(&dir_attr);
470         nfs_fattr_init(&fattr);
471         status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
472         nfs_post_op_update_inode(dir, &dir_attr);
473         nfs_post_op_update_inode(inode, &fattr);
474         dprintk("NFS reply link: %d\n", status);
475         return status;
476 }
477
478 static int
479 nfs3_proc_symlink(struct inode *dir, struct dentry *dentry, struct page *page,
480                   unsigned int len, struct iattr *sattr)
481 {
482         struct nfs_fh fhandle;
483         struct nfs_fattr fattr, dir_attr;
484         struct nfs3_symlinkargs arg = {
485                 .fromfh         = NFS_FH(dir),
486                 .fromname       = dentry->d_name.name,
487                 .fromlen        = dentry->d_name.len,
488                 .pages          = &page,
489                 .pathlen        = len,
490                 .sattr          = sattr
491         };
492         struct nfs3_diropres    res = {
493                 .dir_attr       = &dir_attr,
494                 .fh             = &fhandle,
495                 .fattr          = &fattr
496         };
497         struct rpc_message msg = {
498                 .rpc_proc       = &nfs3_procedures[NFS3PROC_SYMLINK],
499                 .rpc_argp       = &arg,
500                 .rpc_resp       = &res,
501         };
502         int                     status;
503
504         if (len > NFS3_MAXPATHLEN)
505                 return -ENAMETOOLONG;
506
507         dprintk("NFS call  symlink %s\n", dentry->d_name.name);
508
509         nfs_fattr_init(&dir_attr);
510         nfs_fattr_init(&fattr);
511         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
512         nfs_post_op_update_inode(dir, &dir_attr);
513         if (status != 0)
514                 goto out;
515         status = nfs_instantiate(dentry, &fhandle, &fattr);
516 out:
517         dprintk("NFS reply symlink: %d\n", status);
518         return status;
519 }
520
521 static int
522 nfs3_proc_mkdir(struct inode *dir, struct dentry *dentry, struct iattr *sattr)
523 {
524         struct nfs_fh fhandle;
525         struct nfs_fattr fattr, dir_attr;
526         struct nfs3_mkdirargs   arg = {
527                 .fh             = NFS_FH(dir),
528                 .name           = dentry->d_name.name,
529                 .len            = dentry->d_name.len,
530                 .sattr          = sattr
531         };
532         struct nfs3_diropres    res = {
533                 .dir_attr       = &dir_attr,
534                 .fh             = &fhandle,
535                 .fattr          = &fattr
536         };
537         struct rpc_message msg = {
538                 .rpc_proc       = &nfs3_procedures[NFS3PROC_MKDIR],
539                 .rpc_argp       = &arg,
540                 .rpc_resp       = &res,
541         };
542         int mode = sattr->ia_mode;
543         int status;
544
545         dprintk("NFS call  mkdir %s\n", dentry->d_name.name);
546
547         sattr->ia_mode &= ~current->fs->umask;
548
549         nfs_fattr_init(&dir_attr);
550         nfs_fattr_init(&fattr);
551         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
552         nfs_post_op_update_inode(dir, &dir_attr);
553         if (status != 0)
554                 goto out;
555         status = nfs_instantiate(dentry, &fhandle, &fattr);
556         if (status != 0)
557                 goto out;
558         status = nfs3_proc_set_default_acl(dir, dentry->d_inode, mode);
559 out:
560         dprintk("NFS reply mkdir: %d\n", status);
561         return status;
562 }
563
564 static int
565 nfs3_proc_rmdir(struct inode *dir, struct qstr *name)
566 {
567         struct nfs_fattr        dir_attr;
568         struct nfs3_diropargs   arg = {
569                 .fh             = NFS_FH(dir),
570                 .name           = name->name,
571                 .len            = name->len
572         };
573         struct rpc_message msg = {
574                 .rpc_proc       = &nfs3_procedures[NFS3PROC_RMDIR],
575                 .rpc_argp       = &arg,
576                 .rpc_resp       = &dir_attr,
577         };
578         int                     status;
579
580         dprintk("NFS call  rmdir %s\n", name->name);
581         nfs_fattr_init(&dir_attr);
582         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
583         nfs_post_op_update_inode(dir, &dir_attr);
584         dprintk("NFS reply rmdir: %d\n", status);
585         return status;
586 }
587
588 /*
589  * The READDIR implementation is somewhat hackish - we pass the user buffer
590  * to the encode function, which installs it in the receive iovec.
591  * The decode function itself doesn't perform any decoding, it just makes
592  * sure the reply is syntactically correct.
593  *
594  * Also note that this implementation handles both plain readdir and
595  * readdirplus.
596  */
597 static int
598 nfs3_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
599                   u64 cookie, struct page *page, unsigned int count, int plus)
600 {
601         struct inode            *dir = dentry->d_inode;
602         struct nfs_fattr        dir_attr;
603         __be32                  *verf = NFS_COOKIEVERF(dir);
604         struct nfs3_readdirargs arg = {
605                 .fh             = NFS_FH(dir),
606                 .cookie         = cookie,
607                 .verf           = {verf[0], verf[1]},
608                 .plus           = plus,
609                 .count          = count,
610                 .pages          = &page
611         };
612         struct nfs3_readdirres  res = {
613                 .dir_attr       = &dir_attr,
614                 .verf           = verf,
615                 .plus           = plus
616         };
617         struct rpc_message      msg = {
618                 .rpc_proc       = &nfs3_procedures[NFS3PROC_READDIR],
619                 .rpc_argp       = &arg,
620                 .rpc_resp       = &res,
621                 .rpc_cred       = cred
622         };
623         int                     status;
624
625         if (plus)
626                 msg.rpc_proc = &nfs3_procedures[NFS3PROC_READDIRPLUS];
627
628         dprintk("NFS call  readdir%s %d\n",
629                         plus? "plus" : "", (unsigned int) cookie);
630
631         nfs_fattr_init(&dir_attr);
632         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
633         nfs_refresh_inode(dir, &dir_attr);
634         dprintk("NFS reply readdir: %d\n", status);
635         return status;
636 }
637
638 static int
639 nfs3_proc_mknod(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
640                 dev_t rdev)
641 {
642         struct nfs_fh fh;
643         struct nfs_fattr fattr, dir_attr;
644         struct nfs3_mknodargs   arg = {
645                 .fh             = NFS_FH(dir),
646                 .name           = dentry->d_name.name,
647                 .len            = dentry->d_name.len,
648                 .sattr          = sattr,
649                 .rdev           = rdev
650         };
651         struct nfs3_diropres    res = {
652                 .dir_attr       = &dir_attr,
653                 .fh             = &fh,
654                 .fattr          = &fattr
655         };
656         struct rpc_message msg = {
657                 .rpc_proc       = &nfs3_procedures[NFS3PROC_MKNOD],
658                 .rpc_argp       = &arg,
659                 .rpc_resp       = &res,
660         };
661         mode_t mode = sattr->ia_mode;
662         int status;
663
664         switch (sattr->ia_mode & S_IFMT) {
665         case S_IFBLK:   arg.type = NF3BLK;  break;
666         case S_IFCHR:   arg.type = NF3CHR;  break;
667         case S_IFIFO:   arg.type = NF3FIFO; break;
668         case S_IFSOCK:  arg.type = NF3SOCK; break;
669         default:        return -EINVAL;
670         }
671
672         dprintk("NFS call  mknod %s %u:%u\n", dentry->d_name.name,
673                         MAJOR(rdev), MINOR(rdev));
674
675         sattr->ia_mode &= ~current->fs->umask;
676
677         nfs_fattr_init(&dir_attr);
678         nfs_fattr_init(&fattr);
679         status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
680         nfs_post_op_update_inode(dir, &dir_attr);
681         if (status != 0)
682                 goto out;
683         status = nfs_instantiate(dentry, &fh, &fattr);
684         if (status != 0)
685                 goto out;
686         status = nfs3_proc_set_default_acl(dir, dentry->d_inode, mode);
687 out:
688         dprintk("NFS reply mknod: %d\n", status);
689         return status;
690 }
691
692 static int
693 nfs3_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle,
694                  struct nfs_fsstat *stat)
695 {
696         struct rpc_message msg = {
697                 .rpc_proc       = &nfs3_procedures[NFS3PROC_FSSTAT],
698                 .rpc_argp       = fhandle,
699                 .rpc_resp       = stat,
700         };
701         int     status;
702
703         dprintk("NFS call  fsstat\n");
704         nfs_fattr_init(stat->fattr);
705         status = rpc_call_sync(server->client, &msg, 0);
706         dprintk("NFS reply statfs: %d\n", status);
707         return status;
708 }
709
710 static int
711 nfs3_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle,
712                  struct nfs_fsinfo *info)
713 {
714         struct rpc_message msg = {
715                 .rpc_proc       = &nfs3_procedures[NFS3PROC_FSINFO],
716                 .rpc_argp       = fhandle,
717                 .rpc_resp       = info,
718         };
719         int     status;
720
721         dprintk("NFS call  fsinfo\n");
722         nfs_fattr_init(info->fattr);
723         status = rpc_call_sync(server->nfs_client->cl_rpcclient, &msg, 0);
724         dprintk("NFS reply fsinfo: %d\n", status);
725         return status;
726 }
727
728 static int
729 nfs3_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
730                    struct nfs_pathconf *info)
731 {
732         struct rpc_message msg = {
733                 .rpc_proc       = &nfs3_procedures[NFS3PROC_PATHCONF],
734                 .rpc_argp       = fhandle,
735                 .rpc_resp       = info,
736         };
737         int     status;
738
739         dprintk("NFS call  pathconf\n");
740         nfs_fattr_init(info->fattr);
741         status = rpc_call_sync(server->client, &msg, 0);
742         dprintk("NFS reply pathconf: %d\n", status);
743         return status;
744 }
745
746 static int nfs3_read_done(struct rpc_task *task, struct nfs_read_data *data)
747 {
748         if (nfs3_async_handle_jukebox(task, data->inode))
749                 return -EAGAIN;
750         /* Call back common NFS readpage processing */
751         if (task->tk_status >= 0)
752                 nfs_refresh_inode(data->inode, &data->fattr);
753         return 0;
754 }
755
756 static void nfs3_proc_read_setup(struct nfs_read_data *data)
757 {
758         struct rpc_message      msg = {
759                 .rpc_proc       = &nfs3_procedures[NFS3PROC_READ],
760                 .rpc_argp       = &data->args,
761                 .rpc_resp       = &data->res,
762                 .rpc_cred       = data->cred,
763         };
764
765         rpc_call_setup(&data->task, &msg, 0);
766 }
767
768 static int nfs3_write_done(struct rpc_task *task, struct nfs_write_data *data)
769 {
770         if (nfs3_async_handle_jukebox(task, data->inode))
771                 return -EAGAIN;
772         if (task->tk_status >= 0)
773                 nfs_post_op_update_inode(data->inode, data->res.fattr);
774         return 0;
775 }
776
777 static void nfs3_proc_write_setup(struct nfs_write_data *data, int how)
778 {
779         struct rpc_message      msg = {
780                 .rpc_proc       = &nfs3_procedures[NFS3PROC_WRITE],
781                 .rpc_argp       = &data->args,
782                 .rpc_resp       = &data->res,
783                 .rpc_cred       = data->cred,
784         };
785
786         data->args.stable = NFS_UNSTABLE;
787         if (how & FLUSH_STABLE) {
788                 data->args.stable = NFS_FILE_SYNC;
789                 if (NFS_I(data->inode)->ncommit)
790                         data->args.stable = NFS_DATA_SYNC;
791         }
792
793         /* Finalize the task. */
794         rpc_call_setup(&data->task, &msg, 0);
795 }
796
797 static int nfs3_commit_done(struct rpc_task *task, struct nfs_write_data *data)
798 {
799         if (nfs3_async_handle_jukebox(task, data->inode))
800                 return -EAGAIN;
801         if (task->tk_status >= 0)
802                 nfs_post_op_update_inode(data->inode, data->res.fattr);
803         return 0;
804 }
805
806 static void nfs3_proc_commit_setup(struct nfs_write_data *data, int how)
807 {
808         struct rpc_message      msg = {
809                 .rpc_proc       = &nfs3_procedures[NFS3PROC_COMMIT],
810                 .rpc_argp       = &data->args,
811                 .rpc_resp       = &data->res,
812                 .rpc_cred       = data->cred,
813         };
814
815         rpc_call_setup(&data->task, &msg, 0);
816 }
817
818 static int
819 nfs3_proc_lock(struct file *filp, int cmd, struct file_lock *fl)
820 {
821         return nlmclnt_proc(filp->f_path.dentry->d_inode, cmd, fl);
822 }
823
824 const struct nfs_rpc_ops nfs_v3_clientops = {
825         .version        = 3,                    /* protocol version */
826         .dentry_ops     = &nfs_dentry_operations,
827         .dir_inode_ops  = &nfs3_dir_inode_operations,
828         .file_inode_ops = &nfs3_file_inode_operations,
829         .getroot        = nfs3_proc_get_root,
830         .getattr        = nfs3_proc_getattr,
831         .setattr        = nfs3_proc_setattr,
832         .lookup         = nfs3_proc_lookup,
833         .access         = nfs3_proc_access,
834         .readlink       = nfs3_proc_readlink,
835         .create         = nfs3_proc_create,
836         .remove         = nfs3_proc_remove,
837         .unlink_setup   = nfs3_proc_unlink_setup,
838         .unlink_done    = nfs3_proc_unlink_done,
839         .rename         = nfs3_proc_rename,
840         .link           = nfs3_proc_link,
841         .symlink        = nfs3_proc_symlink,
842         .mkdir          = nfs3_proc_mkdir,
843         .rmdir          = nfs3_proc_rmdir,
844         .readdir        = nfs3_proc_readdir,
845         .mknod          = nfs3_proc_mknod,
846         .statfs         = nfs3_proc_statfs,
847         .fsinfo         = nfs3_proc_fsinfo,
848         .pathconf       = nfs3_proc_pathconf,
849         .decode_dirent  = nfs3_decode_dirent,
850         .read_setup     = nfs3_proc_read_setup,
851         .read_done      = nfs3_read_done,
852         .write_setup    = nfs3_proc_write_setup,
853         .write_done     = nfs3_write_done,
854         .commit_setup   = nfs3_proc_commit_setup,
855         .commit_done    = nfs3_commit_done,
856         .file_open      = nfs_open,
857         .file_release   = nfs_release,
858         .lock           = nfs3_proc_lock,
859         .clear_acl_cache = nfs3_forget_cached_acls,
860 };