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