2 * linux/fs/nfs/nfs3proc.c
4 * Client-side NFSv3 procedures stubs.
6 * Copyright (C) 1997, Olaf Kirch
10 #include <linux/utsname.h>
11 #include <linux/errno.h>
12 #include <linux/string.h>
13 #include <linux/sunrpc/clnt.h>
14 #include <linux/nfs.h>
15 #include <linux/nfs3.h>
16 #include <linux/nfs_fs.h>
17 #include <linux/nfs_page.h>
18 #include <linux/lockd/bind.h>
19 #include <linux/nfs_mount.h>
24 #define NFSDBG_FACILITY NFSDBG_PROC
26 /* A wrapper to handle the EJUKEBOX error message */
28 nfs3_rpc_wrapper(struct rpc_clnt
*clnt
, struct rpc_message
*msg
, int flags
)
32 rpc_clnt_sigmask(clnt
, &oldset
);
34 res
= rpc_call_sync(clnt
, msg
, flags
);
37 schedule_timeout_interruptible(NFS_JUKEBOX_RETRY_TIME
);
39 } while (!signalled());
40 rpc_clnt_sigunmask(clnt
, &oldset
);
44 #define rpc_call_sync(clnt, msg, flags) nfs3_rpc_wrapper(clnt, msg, flags)
47 nfs3_async_handle_jukebox(struct rpc_task
*task
, struct inode
*inode
)
49 if (task
->tk_status
!= -EJUKEBOX
)
51 nfs_inc_stats(inode
, NFSIOS_DELAY
);
53 rpc_restart_call(task
);
54 rpc_delay(task
, NFS_JUKEBOX_RETRY_TIME
);
59 do_proc_get_root(struct rpc_clnt
*client
, struct nfs_fh
*fhandle
,
60 struct nfs_fsinfo
*info
)
62 struct rpc_message msg
= {
63 .rpc_proc
= &nfs3_procedures
[NFS3PROC_FSINFO
],
69 dprintk("%s: call fsinfo\n", __FUNCTION__
);
70 nfs_fattr_init(info
->fattr
);
71 status
= rpc_call_sync(client
, &msg
, 0);
72 dprintk("%s: reply fsinfo: %d\n", __FUNCTION__
, status
);
73 if (!(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", __FUNCTION__
, status
);
83 * Bare-bones access to getattr: this is for nfs_get_root/nfs_get_sb
86 nfs3_proc_get_root(struct nfs_server
*server
, struct nfs_fh
*fhandle
,
87 struct nfs_fsinfo
*info
)
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
);
98 * One function for each procedure in the NFS protocol.
101 nfs3_proc_getattr(struct nfs_server
*server
, struct nfs_fh
*fhandle
,
102 struct nfs_fattr
*fattr
)
104 struct rpc_message msg
= {
105 .rpc_proc
= &nfs3_procedures
[NFS3PROC_GETATTR
],
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
);
119 nfs3_proc_setattr(struct dentry
*dentry
, struct nfs_fattr
*fattr
,
122 struct inode
*inode
= dentry
->d_inode
;
123 struct nfs3_sattrargs arg
= {
127 struct rpc_message msg
= {
128 .rpc_proc
= &nfs3_procedures
[NFS3PROC_SETATTR
],
134 dprintk("NFS call setattr\n");
135 nfs_fattr_init(fattr
);
136 status
= rpc_call_sync(NFS_CLIENT(inode
), &msg
, 0);
138 nfs_setattr_update_inode(inode
, sattr
);
139 dprintk("NFS reply setattr: %d\n", status
);
144 nfs3_proc_lookup(struct inode
*dir
, struct qstr
*name
,
145 struct nfs_fh
*fhandle
, struct nfs_fattr
*fattr
)
147 struct nfs_fattr dir_attr
;
148 struct nfs3_diropargs arg
= {
153 struct nfs3_diropres res
= {
154 .dir_attr
= &dir_attr
,
158 struct rpc_message msg
= {
159 .rpc_proc
= &nfs3_procedures
[NFS3PROC_LOOKUP
],
165 dprintk("NFS call lookup %s\n", name
->name
);
166 nfs_fattr_init(&dir_attr
);
167 nfs_fattr_init(fattr
);
168 status
= rpc_call_sync(NFS_CLIENT(dir
), &msg
, 0);
169 if (status
>= 0 && !(fattr
->valid
& NFS_ATTR_FATTR
)) {
170 msg
.rpc_proc
= &nfs3_procedures
[NFS3PROC_GETATTR
];
171 msg
.rpc_argp
= fhandle
;
172 msg
.rpc_resp
= fattr
;
173 status
= rpc_call_sync(NFS_CLIENT(dir
), &msg
, 0);
175 dprintk("NFS reply lookup: %d\n", status
);
177 status
= nfs_refresh_inode(dir
, &dir_attr
);
181 static int nfs3_proc_access(struct inode
*inode
, struct nfs_access_entry
*entry
)
183 struct nfs_fattr fattr
;
184 struct nfs3_accessargs arg
= {
187 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
;
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
;
214 nfs_fattr_init(&fattr
);
215 status
= rpc_call_sync(NFS_CLIENT(inode
), &msg
, 0);
216 nfs_refresh_inode(inode
, &fattr
);
219 if (res
.access
& NFS3_ACCESS_READ
)
220 entry
->mask
|= MAY_READ
;
221 if (res
.access
& (NFS3_ACCESS_MODIFY
| NFS3_ACCESS_EXTEND
| NFS3_ACCESS_DELETE
))
222 entry
->mask
|= MAY_WRITE
;
223 if (res
.access
& (NFS3_ACCESS_LOOKUP
|NFS3_ACCESS_EXECUTE
))
224 entry
->mask
|= MAY_EXEC
;
226 dprintk("NFS reply access: %d\n", status
);
230 static int nfs3_proc_readlink(struct inode
*inode
, struct page
*page
,
231 unsigned int pgbase
, unsigned int pglen
)
233 struct nfs_fattr fattr
;
234 struct nfs3_readlinkargs args
= {
240 struct rpc_message msg
= {
241 .rpc_proc
= &nfs3_procedures
[NFS3PROC_READLINK
],
247 dprintk("NFS call readlink\n");
248 nfs_fattr_init(&fattr
);
249 status
= rpc_call_sync(NFS_CLIENT(inode
), &msg
, 0);
250 nfs_refresh_inode(inode
, &fattr
);
251 dprintk("NFS reply readlink: %d\n", status
);
256 * Create a regular file.
257 * For now, we don't implement O_EXCL.
260 nfs3_proc_create(struct inode
*dir
, struct dentry
*dentry
, struct iattr
*sattr
,
261 int flags
, struct nameidata
*nd
)
263 struct nfs_fh fhandle
;
264 struct nfs_fattr fattr
;
265 struct nfs_fattr dir_attr
;
266 struct nfs3_createargs arg
= {
268 .name
= dentry
->d_name
.name
,
269 .len
= dentry
->d_name
.len
,
272 struct nfs3_diropres res
= {
273 .dir_attr
= &dir_attr
,
277 struct rpc_message msg
= {
278 .rpc_proc
= &nfs3_procedures
[NFS3PROC_CREATE
],
282 mode_t mode
= sattr
->ia_mode
;
285 dprintk("NFS call create %s\n", dentry
->d_name
.name
);
286 arg
.createmode
= NFS3_CREATE_UNCHECKED
;
287 if (flags
& O_EXCL
) {
288 arg
.createmode
= NFS3_CREATE_EXCLUSIVE
;
289 arg
.verifier
[0] = jiffies
;
290 arg
.verifier
[1] = current
->pid
;
293 sattr
->ia_mode
&= ~current
->fs
->umask
;
296 nfs_fattr_init(&dir_attr
);
297 nfs_fattr_init(&fattr
);
298 status
= rpc_call_sync(NFS_CLIENT(dir
), &msg
, 0);
299 nfs_refresh_inode(dir
, &dir_attr
);
301 /* If the server doesn't support the exclusive creation semantics,
302 * try again with simple 'guarded' mode. */
303 if (status
== -ENOTSUPP
) {
304 switch (arg
.createmode
) {
305 case NFS3_CREATE_EXCLUSIVE
:
306 arg
.createmode
= NFS3_CREATE_GUARDED
;
309 case NFS3_CREATE_GUARDED
:
310 arg
.createmode
= NFS3_CREATE_UNCHECKED
;
313 case NFS3_CREATE_UNCHECKED
:
320 status
= nfs_instantiate(dentry
, &fhandle
, &fattr
);
324 /* When we created the file with exclusive semantics, make
325 * sure we set the attributes afterwards. */
326 if (arg
.createmode
== NFS3_CREATE_EXCLUSIVE
) {
327 dprintk("NFS call setattr (post-create)\n");
329 if (!(sattr
->ia_valid
& ATTR_ATIME_SET
))
330 sattr
->ia_valid
|= ATTR_ATIME
;
331 if (!(sattr
->ia_valid
& ATTR_MTIME_SET
))
332 sattr
->ia_valid
|= ATTR_MTIME
;
334 /* Note: we could use a guarded setattr here, but I'm
335 * not sure this buys us anything (and I'd have
336 * to revamp the NFSv3 XDR code) */
337 status
= nfs3_proc_setattr(dentry
, &fattr
, sattr
);
339 nfs_setattr_update_inode(dentry
->d_inode
, sattr
);
340 nfs_refresh_inode(dentry
->d_inode
, &fattr
);
341 dprintk("NFS reply setattr (post-create): %d\n", status
);
345 status
= nfs3_proc_set_default_acl(dir
, dentry
->d_inode
, mode
);
347 dprintk("NFS reply create: %d\n", status
);
352 nfs3_proc_remove(struct inode
*dir
, struct qstr
*name
)
354 struct nfs_fattr dir_attr
;
355 struct nfs3_diropargs arg
= {
360 struct rpc_message msg
= {
361 .rpc_proc
= &nfs3_procedures
[NFS3PROC_REMOVE
],
363 .rpc_resp
= &dir_attr
,
367 dprintk("NFS call remove %s\n", name
->name
);
368 nfs_fattr_init(&dir_attr
);
369 status
= rpc_call_sync(NFS_CLIENT(dir
), &msg
, 0);
370 nfs_post_op_update_inode(dir
, &dir_attr
);
371 dprintk("NFS reply remove: %d\n", status
);
376 nfs3_proc_unlink_setup(struct rpc_message
*msg
, struct dentry
*dir
, struct qstr
*name
)
379 struct nfs3_diropargs arg
;
380 struct nfs_fattr res
;
383 ptr
= kmalloc(sizeof(*ptr
), GFP_KERNEL
);
386 ptr
->arg
.fh
= NFS_FH(dir
->d_inode
);
387 ptr
->arg
.name
= name
->name
;
388 ptr
->arg
.len
= name
->len
;
389 nfs_fattr_init(&ptr
->res
);
390 msg
->rpc_proc
= &nfs3_procedures
[NFS3PROC_REMOVE
];
391 msg
->rpc_argp
= &ptr
->arg
;
392 msg
->rpc_resp
= &ptr
->res
;
397 nfs3_proc_unlink_done(struct dentry
*dir
, struct rpc_task
*task
)
399 struct rpc_message
*msg
= &task
->tk_msg
;
400 struct nfs_fattr
*dir_attr
;
402 if (nfs3_async_handle_jukebox(task
, dir
->d_inode
))
405 dir_attr
= (struct nfs_fattr
*)msg
->rpc_resp
;
406 nfs_post_op_update_inode(dir
->d_inode
, dir_attr
);
407 kfree(msg
->rpc_argp
);
413 nfs3_proc_rename(struct inode
*old_dir
, struct qstr
*old_name
,
414 struct inode
*new_dir
, struct qstr
*new_name
)
416 struct nfs_fattr old_dir_attr
, new_dir_attr
;
417 struct nfs3_renameargs arg
= {
418 .fromfh
= NFS_FH(old_dir
),
419 .fromname
= old_name
->name
,
420 .fromlen
= old_name
->len
,
421 .tofh
= NFS_FH(new_dir
),
422 .toname
= new_name
->name
,
423 .tolen
= new_name
->len
425 struct nfs3_renameres res
= {
426 .fromattr
= &old_dir_attr
,
427 .toattr
= &new_dir_attr
429 struct rpc_message msg
= {
430 .rpc_proc
= &nfs3_procedures
[NFS3PROC_RENAME
],
436 dprintk("NFS call rename %s -> %s\n", old_name
->name
, new_name
->name
);
437 nfs_fattr_init(&old_dir_attr
);
438 nfs_fattr_init(&new_dir_attr
);
439 status
= rpc_call_sync(NFS_CLIENT(old_dir
), &msg
, 0);
440 nfs_post_op_update_inode(old_dir
, &old_dir_attr
);
441 nfs_post_op_update_inode(new_dir
, &new_dir_attr
);
442 dprintk("NFS reply rename: %d\n", status
);
447 nfs3_proc_link(struct inode
*inode
, struct inode
*dir
, struct qstr
*name
)
449 struct nfs_fattr dir_attr
, fattr
;
450 struct nfs3_linkargs arg
= {
451 .fromfh
= NFS_FH(inode
),
453 .toname
= name
->name
,
456 struct nfs3_linkres res
= {
457 .dir_attr
= &dir_attr
,
460 struct rpc_message msg
= {
461 .rpc_proc
= &nfs3_procedures
[NFS3PROC_LINK
],
467 dprintk("NFS call link %s\n", name
->name
);
468 nfs_fattr_init(&dir_attr
);
469 nfs_fattr_init(&fattr
);
470 status
= rpc_call_sync(NFS_CLIENT(inode
), &msg
, 0);
471 nfs_post_op_update_inode(dir
, &dir_attr
);
472 nfs_post_op_update_inode(inode
, &fattr
);
473 dprintk("NFS reply link: %d\n", status
);
478 nfs3_proc_symlink(struct inode
*dir
, struct dentry
*dentry
, struct page
*page
,
479 unsigned int len
, struct iattr
*sattr
)
481 struct nfs_fh fhandle
;
482 struct nfs_fattr fattr
, dir_attr
;
483 struct nfs3_symlinkargs arg
= {
484 .fromfh
= NFS_FH(dir
),
485 .fromname
= dentry
->d_name
.name
,
486 .fromlen
= dentry
->d_name
.len
,
491 struct nfs3_diropres res
= {
492 .dir_attr
= &dir_attr
,
496 struct rpc_message msg
= {
497 .rpc_proc
= &nfs3_procedures
[NFS3PROC_SYMLINK
],
503 if (len
> NFS3_MAXPATHLEN
)
504 return -ENAMETOOLONG
;
506 dprintk("NFS call symlink %s\n", dentry
->d_name
.name
);
508 nfs_fattr_init(&dir_attr
);
509 nfs_fattr_init(&fattr
);
510 status
= rpc_call_sync(NFS_CLIENT(dir
), &msg
, 0);
511 nfs_post_op_update_inode(dir
, &dir_attr
);
514 status
= nfs_instantiate(dentry
, &fhandle
, &fattr
);
516 dprintk("NFS reply symlink: %d\n", status
);
521 nfs3_proc_mkdir(struct inode
*dir
, struct dentry
*dentry
, struct iattr
*sattr
)
523 struct nfs_fh fhandle
;
524 struct nfs_fattr fattr
, dir_attr
;
525 struct nfs3_mkdirargs arg
= {
527 .name
= dentry
->d_name
.name
,
528 .len
= dentry
->d_name
.len
,
531 struct nfs3_diropres res
= {
532 .dir_attr
= &dir_attr
,
536 struct rpc_message msg
= {
537 .rpc_proc
= &nfs3_procedures
[NFS3PROC_MKDIR
],
541 int mode
= sattr
->ia_mode
;
544 dprintk("NFS call mkdir %s\n", dentry
->d_name
.name
);
546 sattr
->ia_mode
&= ~current
->fs
->umask
;
548 nfs_fattr_init(&dir_attr
);
549 nfs_fattr_init(&fattr
);
550 status
= rpc_call_sync(NFS_CLIENT(dir
), &msg
, 0);
551 nfs_post_op_update_inode(dir
, &dir_attr
);
554 status
= nfs_instantiate(dentry
, &fhandle
, &fattr
);
557 status
= nfs3_proc_set_default_acl(dir
, dentry
->d_inode
, mode
);
559 dprintk("NFS reply mkdir: %d\n", status
);
564 nfs3_proc_rmdir(struct inode
*dir
, struct qstr
*name
)
566 struct nfs_fattr dir_attr
;
567 struct nfs3_diropargs arg
= {
572 struct rpc_message msg
= {
573 .rpc_proc
= &nfs3_procedures
[NFS3PROC_RMDIR
],
575 .rpc_resp
= &dir_attr
,
579 dprintk("NFS call rmdir %s\n", name
->name
);
580 nfs_fattr_init(&dir_attr
);
581 status
= rpc_call_sync(NFS_CLIENT(dir
), &msg
, 0);
582 nfs_post_op_update_inode(dir
, &dir_attr
);
583 dprintk("NFS reply rmdir: %d\n", status
);
588 * The READDIR implementation is somewhat hackish - we pass the user buffer
589 * to the encode function, which installs it in the receive iovec.
590 * The decode function itself doesn't perform any decoding, it just makes
591 * sure the reply is syntactically correct.
593 * Also note that this implementation handles both plain readdir and
597 nfs3_proc_readdir(struct dentry
*dentry
, struct rpc_cred
*cred
,
598 u64 cookie
, struct page
*page
, unsigned int count
, int plus
)
600 struct inode
*dir
= dentry
->d_inode
;
601 struct nfs_fattr dir_attr
;
602 __be32
*verf
= NFS_COOKIEVERF(dir
);
603 struct nfs3_readdirargs arg
= {
606 .verf
= {verf
[0], verf
[1]},
611 struct nfs3_readdirres res
= {
612 .dir_attr
= &dir_attr
,
616 struct rpc_message msg
= {
617 .rpc_proc
= &nfs3_procedures
[NFS3PROC_READDIR
],
625 msg
.rpc_proc
= &nfs3_procedures
[NFS3PROC_READDIRPLUS
];
627 dprintk("NFS call readdir%s %d\n",
628 plus
? "plus" : "", (unsigned int) cookie
);
630 nfs_fattr_init(&dir_attr
);
631 status
= rpc_call_sync(NFS_CLIENT(dir
), &msg
, 0);
632 nfs_refresh_inode(dir
, &dir_attr
);
633 dprintk("NFS reply readdir: %d\n", status
);
638 nfs3_proc_mknod(struct inode
*dir
, struct dentry
*dentry
, struct iattr
*sattr
,
642 struct nfs_fattr fattr
, dir_attr
;
643 struct nfs3_mknodargs arg
= {
645 .name
= dentry
->d_name
.name
,
646 .len
= dentry
->d_name
.len
,
650 struct nfs3_diropres res
= {
651 .dir_attr
= &dir_attr
,
655 struct rpc_message msg
= {
656 .rpc_proc
= &nfs3_procedures
[NFS3PROC_MKNOD
],
660 mode_t mode
= sattr
->ia_mode
;
663 switch (sattr
->ia_mode
& S_IFMT
) {
664 case S_IFBLK
: arg
.type
= NF3BLK
; break;
665 case S_IFCHR
: arg
.type
= NF3CHR
; break;
666 case S_IFIFO
: arg
.type
= NF3FIFO
; break;
667 case S_IFSOCK
: arg
.type
= NF3SOCK
; break;
668 default: return -EINVAL
;
671 dprintk("NFS call mknod %s %u:%u\n", dentry
->d_name
.name
,
672 MAJOR(rdev
), MINOR(rdev
));
674 sattr
->ia_mode
&= ~current
->fs
->umask
;
676 nfs_fattr_init(&dir_attr
);
677 nfs_fattr_init(&fattr
);
678 status
= rpc_call_sync(NFS_CLIENT(dir
), &msg
, 0);
679 nfs_post_op_update_inode(dir
, &dir_attr
);
682 status
= nfs_instantiate(dentry
, &fh
, &fattr
);
685 status
= nfs3_proc_set_default_acl(dir
, dentry
->d_inode
, mode
);
687 dprintk("NFS reply mknod: %d\n", status
);
692 nfs3_proc_statfs(struct nfs_server
*server
, struct nfs_fh
*fhandle
,
693 struct nfs_fsstat
*stat
)
695 struct rpc_message msg
= {
696 .rpc_proc
= &nfs3_procedures
[NFS3PROC_FSSTAT
],
702 dprintk("NFS call fsstat\n");
703 nfs_fattr_init(stat
->fattr
);
704 status
= rpc_call_sync(server
->client
, &msg
, 0);
705 dprintk("NFS reply statfs: %d\n", status
);
710 nfs3_proc_fsinfo(struct nfs_server
*server
, struct nfs_fh
*fhandle
,
711 struct nfs_fsinfo
*info
)
713 struct rpc_message msg
= {
714 .rpc_proc
= &nfs3_procedures
[NFS3PROC_FSINFO
],
720 dprintk("NFS call fsinfo\n");
721 nfs_fattr_init(info
->fattr
);
722 status
= rpc_call_sync(server
->nfs_client
->cl_rpcclient
, &msg
, 0);
723 dprintk("NFS reply fsinfo: %d\n", status
);
728 nfs3_proc_pathconf(struct nfs_server
*server
, struct nfs_fh
*fhandle
,
729 struct nfs_pathconf
*info
)
731 struct rpc_message msg
= {
732 .rpc_proc
= &nfs3_procedures
[NFS3PROC_PATHCONF
],
738 dprintk("NFS call pathconf\n");
739 nfs_fattr_init(info
->fattr
);
740 status
= rpc_call_sync(server
->client
, &msg
, 0);
741 dprintk("NFS reply pathconf: %d\n", status
);
745 static int nfs3_read_done(struct rpc_task
*task
, struct nfs_read_data
*data
)
747 if (nfs3_async_handle_jukebox(task
, data
->inode
))
749 /* Call back common NFS readpage processing */
750 if (task
->tk_status
>= 0)
751 nfs_refresh_inode(data
->inode
, &data
->fattr
);
755 static void nfs3_proc_read_setup(struct nfs_read_data
*data
)
757 struct rpc_message msg
= {
758 .rpc_proc
= &nfs3_procedures
[NFS3PROC_READ
],
759 .rpc_argp
= &data
->args
,
760 .rpc_resp
= &data
->res
,
761 .rpc_cred
= data
->cred
,
764 rpc_call_setup(&data
->task
, &msg
, 0);
767 static int nfs3_write_done(struct rpc_task
*task
, struct nfs_write_data
*data
)
769 if (nfs3_async_handle_jukebox(task
, data
->inode
))
771 if (task
->tk_status
>= 0)
772 nfs_post_op_update_inode(data
->inode
, data
->res
.fattr
);
776 static void nfs3_proc_write_setup(struct nfs_write_data
*data
, int how
)
778 struct rpc_message msg
= {
779 .rpc_proc
= &nfs3_procedures
[NFS3PROC_WRITE
],
780 .rpc_argp
= &data
->args
,
781 .rpc_resp
= &data
->res
,
782 .rpc_cred
= data
->cred
,
785 data
->args
.stable
= NFS_UNSTABLE
;
786 if (how
& FLUSH_STABLE
) {
787 data
->args
.stable
= NFS_FILE_SYNC
;
788 if (NFS_I(data
->inode
)->ncommit
)
789 data
->args
.stable
= NFS_DATA_SYNC
;
792 /* Finalize the task. */
793 rpc_call_setup(&data
->task
, &msg
, 0);
796 static int nfs3_commit_done(struct rpc_task
*task
, struct nfs_write_data
*data
)
798 if (nfs3_async_handle_jukebox(task
, data
->inode
))
800 if (task
->tk_status
>= 0)
801 nfs_post_op_update_inode(data
->inode
, data
->res
.fattr
);
805 static void nfs3_proc_commit_setup(struct nfs_write_data
*data
, int how
)
807 struct rpc_message msg
= {
808 .rpc_proc
= &nfs3_procedures
[NFS3PROC_COMMIT
],
809 .rpc_argp
= &data
->args
,
810 .rpc_resp
= &data
->res
,
811 .rpc_cred
= data
->cred
,
814 rpc_call_setup(&data
->task
, &msg
, 0);
818 nfs3_proc_lock(struct file
*filp
, int cmd
, struct file_lock
*fl
)
820 return nlmclnt_proc(filp
->f_path
.dentry
->d_inode
, cmd
, fl
);
823 const struct nfs_rpc_ops nfs_v3_clientops
= {
824 .version
= 3, /* protocol version */
825 .dentry_ops
= &nfs_dentry_operations
,
826 .dir_inode_ops
= &nfs3_dir_inode_operations
,
827 .file_inode_ops
= &nfs3_file_inode_operations
,
828 .getroot
= nfs3_proc_get_root
,
829 .getattr
= nfs3_proc_getattr
,
830 .setattr
= nfs3_proc_setattr
,
831 .lookup
= nfs3_proc_lookup
,
832 .access
= nfs3_proc_access
,
833 .readlink
= nfs3_proc_readlink
,
834 .create
= nfs3_proc_create
,
835 .remove
= nfs3_proc_remove
,
836 .unlink_setup
= nfs3_proc_unlink_setup
,
837 .unlink_done
= nfs3_proc_unlink_done
,
838 .rename
= nfs3_proc_rename
,
839 .link
= nfs3_proc_link
,
840 .symlink
= nfs3_proc_symlink
,
841 .mkdir
= nfs3_proc_mkdir
,
842 .rmdir
= nfs3_proc_rmdir
,
843 .readdir
= nfs3_proc_readdir
,
844 .mknod
= nfs3_proc_mknod
,
845 .statfs
= nfs3_proc_statfs
,
846 .fsinfo
= nfs3_proc_fsinfo
,
847 .pathconf
= nfs3_proc_pathconf
,
848 .decode_dirent
= nfs3_decode_dirent
,
849 .read_setup
= nfs3_proc_read_setup
,
850 .read_done
= nfs3_read_done
,
851 .write_setup
= nfs3_proc_write_setup
,
852 .write_done
= nfs3_write_done
,
853 .commit_setup
= nfs3_proc_commit_setup
,
854 .commit_done
= nfs3_commit_done
,
855 .file_open
= nfs_open
,
856 .file_release
= nfs_release
,
857 .lock
= nfs3_proc_lock
,
858 .clear_acl_cache
= nfs3_forget_cached_acls
,