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