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