2 * linux/fs/nfs/nfs3proc.c
4 * Client-side NFSv3 procedures stubs.
6 * Copyright (C) 1997, Olaf Kirch
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>
25 #define NFSDBG_FACILITY NFSDBG_PROC
27 /* A wrapper to handle the EJUKEBOX error messages */
29 nfs3_rpc_wrapper(struct rpc_clnt
*clnt
, struct rpc_message
*msg
, int flags
)
33 res
= rpc_call_sync(clnt
, msg
, flags
);
36 freezable_schedule_timeout_killable_unsafe(NFS_JUKEBOX_RETRY_TIME
);
38 } while (!fatal_signal_pending(current
));
42 #define rpc_call_sync(clnt, msg, flags) nfs3_rpc_wrapper(clnt, msg, flags)
45 nfs3_async_handle_jukebox(struct rpc_task
*task
, struct inode
*inode
)
47 if (task
->tk_status
!= -EJUKEBOX
)
49 if (task
->tk_status
== -EJUKEBOX
)
50 nfs_inc_stats(inode
, NFSIOS_DELAY
);
52 rpc_restart_call(task
);
53 rpc_delay(task
, NFS_JUKEBOX_RETRY_TIME
);
58 do_proc_get_root(struct rpc_clnt
*client
, struct nfs_fh
*fhandle
,
59 struct nfs_fsinfo
*info
)
61 struct rpc_message msg
= {
62 .rpc_proc
= &nfs3_procedures
[NFS3PROC_FSINFO
],
68 dprintk("%s: call fsinfo\n", __func__
);
69 nfs_fattr_init(info
->fattr
);
70 status
= rpc_call_sync(client
, &msg
, 0);
71 dprintk("%s: reply fsinfo: %d\n", __func__
, status
);
72 if (status
== 0 && !(info
->fattr
->valid
& NFS_ATTR_FATTR
)) {
73 msg
.rpc_proc
= &nfs3_procedures
[NFS3PROC_GETATTR
];
74 msg
.rpc_resp
= info
->fattr
;
75 status
= rpc_call_sync(client
, &msg
, 0);
76 dprintk("%s: reply getattr: %d\n", __func__
, status
);
82 * Bare-bones access to getattr: this is for nfs_get_root/nfs_get_sb
85 nfs3_proc_get_root(struct nfs_server
*server
, struct nfs_fh
*fhandle
,
86 struct nfs_fsinfo
*info
)
90 status
= do_proc_get_root(server
->client
, fhandle
, info
);
91 if (status
&& server
->nfs_client
->cl_rpcclient
!= server
->client
)
92 status
= do_proc_get_root(server
->nfs_client
->cl_rpcclient
, fhandle
, info
);
97 * One function for each procedure in the NFS protocol.
100 nfs3_proc_getattr(struct nfs_server
*server
, struct nfs_fh
*fhandle
,
101 struct nfs_fattr
*fattr
, struct nfs4_label
*label
)
103 struct rpc_message msg
= {
104 .rpc_proc
= &nfs3_procedures
[NFS3PROC_GETATTR
],
110 dprintk("NFS call getattr\n");
111 nfs_fattr_init(fattr
);
112 status
= rpc_call_sync(server
->client
, &msg
, 0);
113 dprintk("NFS reply getattr: %d\n", status
);
118 nfs3_proc_setattr(struct dentry
*dentry
, struct nfs_fattr
*fattr
,
121 struct inode
*inode
= dentry
->d_inode
;
122 struct nfs3_sattrargs arg
= {
126 struct rpc_message msg
= {
127 .rpc_proc
= &nfs3_procedures
[NFS3PROC_SETATTR
],
133 dprintk("NFS call setattr\n");
134 if (sattr
->ia_valid
& ATTR_FILE
)
135 msg
.rpc_cred
= nfs_file_cred(sattr
->ia_file
);
136 nfs_fattr_init(fattr
);
137 status
= rpc_call_sync(NFS_CLIENT(inode
), &msg
, 0);
139 nfs_setattr_update_inode(inode
, sattr
);
140 dprintk("NFS reply setattr: %d\n", status
);
145 nfs3_proc_lookup(struct inode
*dir
, struct qstr
*name
,
146 struct nfs_fh
*fhandle
, struct nfs_fattr
*fattr
,
147 struct nfs4_label
*label
)
149 struct nfs3_diropargs arg
= {
154 struct nfs3_diropres res
= {
158 struct rpc_message msg
= {
159 .rpc_proc
= &nfs3_procedures
[NFS3PROC_LOOKUP
],
165 dprintk("NFS call lookup %s\n", name
->name
);
166 res
.dir_attr
= nfs_alloc_fattr();
167 if (res
.dir_attr
== NULL
)
170 nfs_fattr_init(fattr
);
171 status
= rpc_call_sync(NFS_CLIENT(dir
), &msg
, 0);
172 nfs_refresh_inode(dir
, res
.dir_attr
);
173 if (status
>= 0 && !(fattr
->valid
& NFS_ATTR_FATTR
)) {
174 msg
.rpc_proc
= &nfs3_procedures
[NFS3PROC_GETATTR
];
175 msg
.rpc_argp
= fhandle
;
176 msg
.rpc_resp
= fattr
;
177 status
= rpc_call_sync(NFS_CLIENT(dir
), &msg
, 0);
179 nfs_free_fattr(res
.dir_attr
);
180 dprintk("NFS reply lookup: %d\n", status
);
184 static int nfs3_proc_access(struct inode
*inode
, struct nfs_access_entry
*entry
)
186 struct nfs3_accessargs arg
= {
189 struct nfs3_accessres res
;
190 struct rpc_message msg
= {
191 .rpc_proc
= &nfs3_procedures
[NFS3PROC_ACCESS
],
194 .rpc_cred
= entry
->cred
,
196 int mode
= entry
->mask
;
197 int status
= -ENOMEM
;
199 dprintk("NFS call access\n");
202 arg
.access
|= NFS3_ACCESS_READ
;
203 if (S_ISDIR(inode
->i_mode
)) {
204 if (mode
& MAY_WRITE
)
205 arg
.access
|= NFS3_ACCESS_MODIFY
| NFS3_ACCESS_EXTEND
| NFS3_ACCESS_DELETE
;
207 arg
.access
|= NFS3_ACCESS_LOOKUP
;
209 if (mode
& MAY_WRITE
)
210 arg
.access
|= NFS3_ACCESS_MODIFY
| NFS3_ACCESS_EXTEND
;
212 arg
.access
|= NFS3_ACCESS_EXECUTE
;
215 res
.fattr
= nfs_alloc_fattr();
216 if (res
.fattr
== NULL
)
219 status
= rpc_call_sync(NFS_CLIENT(inode
), &msg
, 0);
220 nfs_refresh_inode(inode
, res
.fattr
);
223 if (res
.access
& NFS3_ACCESS_READ
)
224 entry
->mask
|= MAY_READ
;
225 if (res
.access
& (NFS3_ACCESS_MODIFY
| NFS3_ACCESS_EXTEND
| NFS3_ACCESS_DELETE
))
226 entry
->mask
|= MAY_WRITE
;
227 if (res
.access
& (NFS3_ACCESS_LOOKUP
|NFS3_ACCESS_EXECUTE
))
228 entry
->mask
|= MAY_EXEC
;
230 nfs_free_fattr(res
.fattr
);
232 dprintk("NFS reply access: %d\n", status
);
236 static int nfs3_proc_readlink(struct inode
*inode
, struct page
*page
,
237 unsigned int pgbase
, unsigned int pglen
)
239 struct nfs_fattr
*fattr
;
240 struct nfs3_readlinkargs args
= {
246 struct rpc_message msg
= {
247 .rpc_proc
= &nfs3_procedures
[NFS3PROC_READLINK
],
250 int status
= -ENOMEM
;
252 dprintk("NFS call readlink\n");
253 fattr
= nfs_alloc_fattr();
256 msg
.rpc_resp
= fattr
;
258 status
= rpc_call_sync(NFS_CLIENT(inode
), &msg
, 0);
259 nfs_refresh_inode(inode
, fattr
);
260 nfs_free_fattr(fattr
);
262 dprintk("NFS reply readlink: %d\n", status
);
266 struct nfs3_createdata
{
267 struct rpc_message msg
;
269 struct nfs3_createargs create
;
270 struct nfs3_mkdirargs mkdir
;
271 struct nfs3_symlinkargs symlink
;
272 struct nfs3_mknodargs mknod
;
274 struct nfs3_diropres res
;
276 struct nfs_fattr fattr
;
277 struct nfs_fattr dir_attr
;
280 static struct nfs3_createdata
*nfs3_alloc_createdata(void)
282 struct nfs3_createdata
*data
;
284 data
= kzalloc(sizeof(*data
), GFP_KERNEL
);
286 data
->msg
.rpc_argp
= &data
->arg
;
287 data
->msg
.rpc_resp
= &data
->res
;
288 data
->res
.fh
= &data
->fh
;
289 data
->res
.fattr
= &data
->fattr
;
290 data
->res
.dir_attr
= &data
->dir_attr
;
291 nfs_fattr_init(data
->res
.fattr
);
292 nfs_fattr_init(data
->res
.dir_attr
);
297 static int nfs3_do_create(struct inode
*dir
, struct dentry
*dentry
, struct nfs3_createdata
*data
)
301 status
= rpc_call_sync(NFS_CLIENT(dir
), &data
->msg
, 0);
302 nfs_post_op_update_inode(dir
, data
->res
.dir_attr
);
304 status
= nfs_instantiate(dentry
, data
->res
.fh
, data
->res
.fattr
, NULL
);
308 static void nfs3_free_createdata(struct nfs3_createdata
*data
)
314 * Create a regular file.
317 nfs3_proc_create(struct inode
*dir
, struct dentry
*dentry
, struct iattr
*sattr
,
320 struct posix_acl
*default_acl
, *acl
;
321 struct nfs3_createdata
*data
;
322 int status
= -ENOMEM
;
324 dprintk("NFS call create %pd\n", dentry
);
326 data
= nfs3_alloc_createdata();
330 data
->msg
.rpc_proc
= &nfs3_procedures
[NFS3PROC_CREATE
];
331 data
->arg
.create
.fh
= NFS_FH(dir
);
332 data
->arg
.create
.name
= dentry
->d_name
.name
;
333 data
->arg
.create
.len
= dentry
->d_name
.len
;
334 data
->arg
.create
.sattr
= sattr
;
336 data
->arg
.create
.createmode
= NFS3_CREATE_UNCHECKED
;
337 if (flags
& O_EXCL
) {
338 data
->arg
.create
.createmode
= NFS3_CREATE_EXCLUSIVE
;
339 data
->arg
.create
.verifier
[0] = cpu_to_be32(jiffies
);
340 data
->arg
.create
.verifier
[1] = cpu_to_be32(current
->pid
);
343 status
= posix_acl_create(dir
, &sattr
->ia_mode
, &default_acl
, &acl
);
348 status
= nfs3_do_create(dir
, dentry
, data
);
350 if (status
!= -ENOTSUPP
)
352 /* If the server doesn't support the exclusive creation
353 * semantics, try again with simple 'guarded' mode. */
354 switch (data
->arg
.create
.createmode
) {
355 case NFS3_CREATE_EXCLUSIVE
:
356 data
->arg
.create
.createmode
= NFS3_CREATE_GUARDED
;
359 case NFS3_CREATE_GUARDED
:
360 data
->arg
.create
.createmode
= NFS3_CREATE_UNCHECKED
;
363 case NFS3_CREATE_UNCHECKED
:
366 nfs_fattr_init(data
->res
.dir_attr
);
367 nfs_fattr_init(data
->res
.fattr
);
371 goto out_release_acls
;
373 /* When we created the file with exclusive semantics, make
374 * sure we set the attributes afterwards. */
375 if (data
->arg
.create
.createmode
== NFS3_CREATE_EXCLUSIVE
) {
376 dprintk("NFS call setattr (post-create)\n");
378 if (!(sattr
->ia_valid
& ATTR_ATIME_SET
))
379 sattr
->ia_valid
|= ATTR_ATIME
;
380 if (!(sattr
->ia_valid
& ATTR_MTIME_SET
))
381 sattr
->ia_valid
|= ATTR_MTIME
;
383 /* Note: we could use a guarded setattr here, but I'm
384 * not sure this buys us anything (and I'd have
385 * to revamp the NFSv3 XDR code) */
386 status
= nfs3_proc_setattr(dentry
, data
->res
.fattr
, sattr
);
387 nfs_post_op_update_inode(dentry
->d_inode
, data
->res
.fattr
);
388 dprintk("NFS reply setattr (post-create): %d\n", status
);
390 goto out_release_acls
;
393 status
= nfs3_proc_setacls(dentry
->d_inode
, acl
, default_acl
);
396 posix_acl_release(acl
);
397 posix_acl_release(default_acl
);
399 nfs3_free_createdata(data
);
400 dprintk("NFS reply create: %d\n", status
);
405 nfs3_proc_remove(struct inode
*dir
, struct qstr
*name
)
407 struct nfs_removeargs arg
= {
411 struct nfs_removeres res
;
412 struct rpc_message msg
= {
413 .rpc_proc
= &nfs3_procedures
[NFS3PROC_REMOVE
],
417 int status
= -ENOMEM
;
419 dprintk("NFS call remove %s\n", name
->name
);
420 res
.dir_attr
= nfs_alloc_fattr();
421 if (res
.dir_attr
== NULL
)
424 status
= rpc_call_sync(NFS_CLIENT(dir
), &msg
, 0);
425 nfs_post_op_update_inode(dir
, res
.dir_attr
);
426 nfs_free_fattr(res
.dir_attr
);
428 dprintk("NFS reply remove: %d\n", status
);
433 nfs3_proc_unlink_setup(struct rpc_message
*msg
, struct inode
*dir
)
435 msg
->rpc_proc
= &nfs3_procedures
[NFS3PROC_REMOVE
];
438 static void nfs3_proc_unlink_rpc_prepare(struct rpc_task
*task
, struct nfs_unlinkdata
*data
)
440 rpc_call_start(task
);
444 nfs3_proc_unlink_done(struct rpc_task
*task
, struct inode
*dir
)
446 struct nfs_removeres
*res
;
447 if (nfs3_async_handle_jukebox(task
, dir
))
449 res
= task
->tk_msg
.rpc_resp
;
450 nfs_post_op_update_inode(dir
, res
->dir_attr
);
455 nfs3_proc_rename_setup(struct rpc_message
*msg
, struct inode
*dir
)
457 msg
->rpc_proc
= &nfs3_procedures
[NFS3PROC_RENAME
];
460 static void nfs3_proc_rename_rpc_prepare(struct rpc_task
*task
, struct nfs_renamedata
*data
)
462 rpc_call_start(task
);
466 nfs3_proc_rename_done(struct rpc_task
*task
, struct inode
*old_dir
,
467 struct inode
*new_dir
)
469 struct nfs_renameres
*res
;
471 if (nfs3_async_handle_jukebox(task
, old_dir
))
473 res
= task
->tk_msg
.rpc_resp
;
475 nfs_post_op_update_inode(old_dir
, res
->old_fattr
);
476 nfs_post_op_update_inode(new_dir
, res
->new_fattr
);
481 nfs3_proc_rename(struct inode
*old_dir
, struct qstr
*old_name
,
482 struct inode
*new_dir
, struct qstr
*new_name
)
484 struct nfs_renameargs arg
= {
485 .old_dir
= NFS_FH(old_dir
),
486 .old_name
= old_name
,
487 .new_dir
= NFS_FH(new_dir
),
488 .new_name
= new_name
,
490 struct nfs_renameres res
;
491 struct rpc_message msg
= {
492 .rpc_proc
= &nfs3_procedures
[NFS3PROC_RENAME
],
496 int status
= -ENOMEM
;
498 dprintk("NFS call rename %s -> %s\n", old_name
->name
, new_name
->name
);
500 res
.old_fattr
= nfs_alloc_fattr();
501 res
.new_fattr
= nfs_alloc_fattr();
502 if (res
.old_fattr
== NULL
|| res
.new_fattr
== NULL
)
505 status
= rpc_call_sync(NFS_CLIENT(old_dir
), &msg
, 0);
506 nfs_post_op_update_inode(old_dir
, res
.old_fattr
);
507 nfs_post_op_update_inode(new_dir
, res
.new_fattr
);
509 nfs_free_fattr(res
.old_fattr
);
510 nfs_free_fattr(res
.new_fattr
);
511 dprintk("NFS reply rename: %d\n", status
);
516 nfs3_proc_link(struct inode
*inode
, struct inode
*dir
, struct qstr
*name
)
518 struct nfs3_linkargs arg
= {
519 .fromfh
= NFS_FH(inode
),
521 .toname
= name
->name
,
524 struct nfs3_linkres res
;
525 struct rpc_message msg
= {
526 .rpc_proc
= &nfs3_procedures
[NFS3PROC_LINK
],
530 int status
= -ENOMEM
;
532 dprintk("NFS call link %s\n", name
->name
);
533 res
.fattr
= nfs_alloc_fattr();
534 res
.dir_attr
= nfs_alloc_fattr();
535 if (res
.fattr
== NULL
|| res
.dir_attr
== NULL
)
538 status
= rpc_call_sync(NFS_CLIENT(inode
), &msg
, 0);
539 nfs_post_op_update_inode(dir
, res
.dir_attr
);
540 nfs_post_op_update_inode(inode
, res
.fattr
);
542 nfs_free_fattr(res
.dir_attr
);
543 nfs_free_fattr(res
.fattr
);
544 dprintk("NFS reply link: %d\n", status
);
549 nfs3_proc_symlink(struct inode
*dir
, struct dentry
*dentry
, struct page
*page
,
550 unsigned int len
, struct iattr
*sattr
)
552 struct nfs3_createdata
*data
;
553 int status
= -ENOMEM
;
555 if (len
> NFS3_MAXPATHLEN
)
556 return -ENAMETOOLONG
;
558 dprintk("NFS call symlink %pd\n", dentry
);
560 data
= nfs3_alloc_createdata();
563 data
->msg
.rpc_proc
= &nfs3_procedures
[NFS3PROC_SYMLINK
];
564 data
->arg
.symlink
.fromfh
= NFS_FH(dir
);
565 data
->arg
.symlink
.fromname
= dentry
->d_name
.name
;
566 data
->arg
.symlink
.fromlen
= dentry
->d_name
.len
;
567 data
->arg
.symlink
.pages
= &page
;
568 data
->arg
.symlink
.pathlen
= len
;
569 data
->arg
.symlink
.sattr
= sattr
;
571 status
= nfs3_do_create(dir
, dentry
, data
);
573 nfs3_free_createdata(data
);
575 dprintk("NFS reply symlink: %d\n", status
);
580 nfs3_proc_mkdir(struct inode
*dir
, struct dentry
*dentry
, struct iattr
*sattr
)
582 struct posix_acl
*default_acl
, *acl
;
583 struct nfs3_createdata
*data
;
584 int status
= -ENOMEM
;
586 dprintk("NFS call mkdir %pd\n", dentry
);
588 data
= nfs3_alloc_createdata();
592 status
= posix_acl_create(dir
, &sattr
->ia_mode
, &default_acl
, &acl
);
596 data
->msg
.rpc_proc
= &nfs3_procedures
[NFS3PROC_MKDIR
];
597 data
->arg
.mkdir
.fh
= NFS_FH(dir
);
598 data
->arg
.mkdir
.name
= dentry
->d_name
.name
;
599 data
->arg
.mkdir
.len
= dentry
->d_name
.len
;
600 data
->arg
.mkdir
.sattr
= sattr
;
602 status
= nfs3_do_create(dir
, dentry
, data
);
604 goto out_release_acls
;
606 status
= nfs3_proc_setacls(dentry
->d_inode
, acl
, default_acl
);
609 posix_acl_release(acl
);
610 posix_acl_release(default_acl
);
612 nfs3_free_createdata(data
);
613 dprintk("NFS reply mkdir: %d\n", status
);
618 nfs3_proc_rmdir(struct inode
*dir
, struct qstr
*name
)
620 struct nfs_fattr
*dir_attr
;
621 struct nfs3_diropargs arg
= {
626 struct rpc_message msg
= {
627 .rpc_proc
= &nfs3_procedures
[NFS3PROC_RMDIR
],
630 int status
= -ENOMEM
;
632 dprintk("NFS call rmdir %s\n", name
->name
);
633 dir_attr
= nfs_alloc_fattr();
634 if (dir_attr
== NULL
)
637 msg
.rpc_resp
= dir_attr
;
638 status
= rpc_call_sync(NFS_CLIENT(dir
), &msg
, 0);
639 nfs_post_op_update_inode(dir
, dir_attr
);
640 nfs_free_fattr(dir_attr
);
642 dprintk("NFS reply rmdir: %d\n", status
);
647 * The READDIR implementation is somewhat hackish - we pass the user buffer
648 * to the encode function, which installs it in the receive iovec.
649 * The decode function itself doesn't perform any decoding, it just makes
650 * sure the reply is syntactically correct.
652 * Also note that this implementation handles both plain readdir and
656 nfs3_proc_readdir(struct dentry
*dentry
, struct rpc_cred
*cred
,
657 u64 cookie
, struct page
**pages
, unsigned int count
, int plus
)
659 struct inode
*dir
= dentry
->d_inode
;
660 __be32
*verf
= NFS_I(dir
)->cookieverf
;
661 struct nfs3_readdirargs arg
= {
664 .verf
= {verf
[0], verf
[1]},
669 struct nfs3_readdirres res
= {
673 struct rpc_message msg
= {
674 .rpc_proc
= &nfs3_procedures
[NFS3PROC_READDIR
],
679 int status
= -ENOMEM
;
682 msg
.rpc_proc
= &nfs3_procedures
[NFS3PROC_READDIRPLUS
];
684 dprintk("NFS call readdir%s %d\n",
685 plus
? "plus" : "", (unsigned int) cookie
);
687 res
.dir_attr
= nfs_alloc_fattr();
688 if (res
.dir_attr
== NULL
)
691 status
= rpc_call_sync(NFS_CLIENT(dir
), &msg
, 0);
693 nfs_invalidate_atime(dir
);
694 nfs_refresh_inode(dir
, res
.dir_attr
);
696 nfs_free_fattr(res
.dir_attr
);
698 dprintk("NFS reply readdir%s: %d\n",
699 plus
? "plus" : "", status
);
704 nfs3_proc_mknod(struct inode
*dir
, struct dentry
*dentry
, struct iattr
*sattr
,
707 struct posix_acl
*default_acl
, *acl
;
708 struct nfs3_createdata
*data
;
709 int status
= -ENOMEM
;
711 dprintk("NFS call mknod %pd %u:%u\n", dentry
,
712 MAJOR(rdev
), MINOR(rdev
));
714 data
= nfs3_alloc_createdata();
718 status
= posix_acl_create(dir
, &sattr
->ia_mode
, &default_acl
, &acl
);
722 data
->msg
.rpc_proc
= &nfs3_procedures
[NFS3PROC_MKNOD
];
723 data
->arg
.mknod
.fh
= NFS_FH(dir
);
724 data
->arg
.mknod
.name
= dentry
->d_name
.name
;
725 data
->arg
.mknod
.len
= dentry
->d_name
.len
;
726 data
->arg
.mknod
.sattr
= sattr
;
727 data
->arg
.mknod
.rdev
= rdev
;
729 switch (sattr
->ia_mode
& S_IFMT
) {
731 data
->arg
.mknod
.type
= NF3BLK
;
734 data
->arg
.mknod
.type
= NF3CHR
;
737 data
->arg
.mknod
.type
= NF3FIFO
;
740 data
->arg
.mknod
.type
= NF3SOCK
;
747 status
= nfs3_do_create(dir
, dentry
, data
);
749 goto out_release_acls
;
751 status
= nfs3_proc_setacls(dentry
->d_inode
, acl
, default_acl
);
754 posix_acl_release(acl
);
755 posix_acl_release(default_acl
);
757 nfs3_free_createdata(data
);
758 dprintk("NFS reply mknod: %d\n", status
);
763 nfs3_proc_statfs(struct nfs_server
*server
, struct nfs_fh
*fhandle
,
764 struct nfs_fsstat
*stat
)
766 struct rpc_message msg
= {
767 .rpc_proc
= &nfs3_procedures
[NFS3PROC_FSSTAT
],
773 dprintk("NFS call fsstat\n");
774 nfs_fattr_init(stat
->fattr
);
775 status
= rpc_call_sync(server
->client
, &msg
, 0);
776 dprintk("NFS reply fsstat: %d\n", status
);
781 do_proc_fsinfo(struct rpc_clnt
*client
, struct nfs_fh
*fhandle
,
782 struct nfs_fsinfo
*info
)
784 struct rpc_message msg
= {
785 .rpc_proc
= &nfs3_procedures
[NFS3PROC_FSINFO
],
791 dprintk("NFS call fsinfo\n");
792 nfs_fattr_init(info
->fattr
);
793 status
= rpc_call_sync(client
, &msg
, 0);
794 dprintk("NFS reply fsinfo: %d\n", status
);
799 * Bare-bones access to fsinfo: this is for nfs_get_root/nfs_get_sb via
803 nfs3_proc_fsinfo(struct nfs_server
*server
, struct nfs_fh
*fhandle
,
804 struct nfs_fsinfo
*info
)
808 status
= do_proc_fsinfo(server
->client
, fhandle
, info
);
809 if (status
&& server
->nfs_client
->cl_rpcclient
!= server
->client
)
810 status
= do_proc_fsinfo(server
->nfs_client
->cl_rpcclient
, fhandle
, info
);
815 nfs3_proc_pathconf(struct nfs_server
*server
, struct nfs_fh
*fhandle
,
816 struct nfs_pathconf
*info
)
818 struct rpc_message msg
= {
819 .rpc_proc
= &nfs3_procedures
[NFS3PROC_PATHCONF
],
825 dprintk("NFS call pathconf\n");
826 nfs_fattr_init(info
->fattr
);
827 status
= rpc_call_sync(server
->client
, &msg
, 0);
828 dprintk("NFS reply pathconf: %d\n", status
);
832 static int nfs3_read_done(struct rpc_task
*task
, struct nfs_read_data
*data
)
834 struct inode
*inode
= data
->header
->inode
;
836 if (nfs3_async_handle_jukebox(task
, inode
))
839 nfs_invalidate_atime(inode
);
840 nfs_refresh_inode(inode
, &data
->fattr
);
844 static void nfs3_proc_read_setup(struct nfs_read_data
*data
, struct rpc_message
*msg
)
846 msg
->rpc_proc
= &nfs3_procedures
[NFS3PROC_READ
];
849 static int nfs3_proc_read_rpc_prepare(struct rpc_task
*task
, struct nfs_read_data
*data
)
851 rpc_call_start(task
);
855 static int nfs3_write_done(struct rpc_task
*task
, struct nfs_write_data
*data
)
857 struct inode
*inode
= data
->header
->inode
;
859 if (nfs3_async_handle_jukebox(task
, inode
))
861 if (task
->tk_status
>= 0)
862 nfs_post_op_update_inode_force_wcc(inode
, data
->res
.fattr
);
866 static void nfs3_proc_write_setup(struct nfs_write_data
*data
, struct rpc_message
*msg
)
868 msg
->rpc_proc
= &nfs3_procedures
[NFS3PROC_WRITE
];
871 static int nfs3_proc_write_rpc_prepare(struct rpc_task
*task
, struct nfs_write_data
*data
)
873 rpc_call_start(task
);
877 static void nfs3_proc_commit_rpc_prepare(struct rpc_task
*task
, struct nfs_commit_data
*data
)
879 rpc_call_start(task
);
882 static int nfs3_commit_done(struct rpc_task
*task
, struct nfs_commit_data
*data
)
884 if (nfs3_async_handle_jukebox(task
, data
->inode
))
886 nfs_refresh_inode(data
->inode
, data
->res
.fattr
);
890 static void nfs3_proc_commit_setup(struct nfs_commit_data
*data
, struct rpc_message
*msg
)
892 msg
->rpc_proc
= &nfs3_procedures
[NFS3PROC_COMMIT
];
896 nfs3_proc_lock(struct file
*filp
, int cmd
, struct file_lock
*fl
)
898 struct inode
*inode
= file_inode(filp
);
900 return nlmclnt_proc(NFS_SERVER(inode
)->nlm_host
, cmd
, fl
);
903 static int nfs3_have_delegation(struct inode
*inode
, fmode_t flags
)
908 static int nfs3_return_delegation(struct inode
*inode
)
914 static const struct inode_operations nfs3_dir_inode_operations
= {
915 .create
= nfs_create
,
916 .lookup
= nfs_lookup
,
918 .unlink
= nfs_unlink
,
919 .symlink
= nfs_symlink
,
923 .rename
= nfs_rename
,
924 .permission
= nfs_permission
,
925 .getattr
= nfs_getattr
,
926 .setattr
= nfs_setattr
,
927 #ifdef CONFIG_NFS_V3_ACL
928 .listxattr
= generic_listxattr
,
929 .getxattr
= generic_getxattr
,
930 .setxattr
= generic_setxattr
,
931 .removexattr
= generic_removexattr
,
932 .get_acl
= nfs3_get_acl
,
933 .set_acl
= nfs3_set_acl
,
937 static const struct inode_operations nfs3_file_inode_operations
= {
938 .permission
= nfs_permission
,
939 .getattr
= nfs_getattr
,
940 .setattr
= nfs_setattr
,
941 #ifdef CONFIG_NFS_V3_ACL
942 .listxattr
= generic_listxattr
,
943 .getxattr
= generic_getxattr
,
944 .setxattr
= generic_setxattr
,
945 .removexattr
= generic_removexattr
,
946 .get_acl
= nfs3_get_acl
,
947 .set_acl
= nfs3_set_acl
,
951 const struct nfs_rpc_ops nfs_v3_clientops
= {
952 .version
= 3, /* protocol version */
953 .dentry_ops
= &nfs_dentry_operations
,
954 .dir_inode_ops
= &nfs3_dir_inode_operations
,
955 .file_inode_ops
= &nfs3_file_inode_operations
,
956 .file_ops
= &nfs_file_operations
,
957 .getroot
= nfs3_proc_get_root
,
958 .submount
= nfs_submount
,
959 .try_mount
= nfs_try_mount
,
960 .getattr
= nfs3_proc_getattr
,
961 .setattr
= nfs3_proc_setattr
,
962 .lookup
= nfs3_proc_lookup
,
963 .access
= nfs3_proc_access
,
964 .readlink
= nfs3_proc_readlink
,
965 .create
= nfs3_proc_create
,
966 .remove
= nfs3_proc_remove
,
967 .unlink_setup
= nfs3_proc_unlink_setup
,
968 .unlink_rpc_prepare
= nfs3_proc_unlink_rpc_prepare
,
969 .unlink_done
= nfs3_proc_unlink_done
,
970 .rename
= nfs3_proc_rename
,
971 .rename_setup
= nfs3_proc_rename_setup
,
972 .rename_rpc_prepare
= nfs3_proc_rename_rpc_prepare
,
973 .rename_done
= nfs3_proc_rename_done
,
974 .link
= nfs3_proc_link
,
975 .symlink
= nfs3_proc_symlink
,
976 .mkdir
= nfs3_proc_mkdir
,
977 .rmdir
= nfs3_proc_rmdir
,
978 .readdir
= nfs3_proc_readdir
,
979 .mknod
= nfs3_proc_mknod
,
980 .statfs
= nfs3_proc_statfs
,
981 .fsinfo
= nfs3_proc_fsinfo
,
982 .pathconf
= nfs3_proc_pathconf
,
983 .decode_dirent
= nfs3_decode_dirent
,
984 .read_setup
= nfs3_proc_read_setup
,
985 .read_pageio_init
= nfs_pageio_init_read
,
986 .read_rpc_prepare
= nfs3_proc_read_rpc_prepare
,
987 .read_done
= nfs3_read_done
,
988 .write_setup
= nfs3_proc_write_setup
,
989 .write_pageio_init
= nfs_pageio_init_write
,
990 .write_rpc_prepare
= nfs3_proc_write_rpc_prepare
,
991 .write_done
= nfs3_write_done
,
992 .commit_setup
= nfs3_proc_commit_setup
,
993 .commit_rpc_prepare
= nfs3_proc_commit_rpc_prepare
,
994 .commit_done
= nfs3_commit_done
,
995 .lock
= nfs3_proc_lock
,
996 .clear_acl_cache
= forget_all_cached_acls
,
997 .close_context
= nfs_close_context
,
998 .have_delegation
= nfs3_have_delegation
,
999 .return_delegation
= nfs3_return_delegation
,
1000 .alloc_client
= nfs_alloc_client
,
1001 .init_client
= nfs_init_client
,
1002 .free_client
= nfs_free_client
,
1003 .create_server
= nfs3_create_server
,
1004 .clone_server
= nfs3_clone_server
,