4 * Copyright (C) 1992, 1993, 1994 Rick Sladkey
6 * OS-independent nfs remote procedure call functions
8 * Tuned by Alan Cox <A.Cox@swansea.ac.uk> for >3K buffers
9 * so at last we can have decent(ish) throughput off a
12 * Coding optimized and cleaned up by Florian La Roche.
13 * Note: Error returns are optimized for NFS_OK, which isn't translated via
14 * nfs_stat_to_errno(), but happens to be already the right return code.
16 * Also, the code currently doesn't check the size of the packet, when
17 * it decodes the packet.
19 * Feel free to fix it and mail me the diffs if it worries you.
21 * Completely rewritten to support the new RPC call interface;
22 * rewrote and moved the entire XDR stuff to xdr.c
23 * --Olaf Kirch June 1996
25 * The code below initializes all auto variables explicitly, otherwise
26 * it will fail to work as a module (gcc generates a memset call for an
30 #include <linux/types.h>
31 #include <linux/param.h>
32 #include <linux/slab.h>
33 #include <linux/time.h>
35 #include <linux/utsname.h>
36 #include <linux/errno.h>
37 #include <linux/string.h>
39 #include <linux/pagemap.h>
40 #include <linux/sunrpc/clnt.h>
41 #include <linux/nfs.h>
42 #include <linux/nfs2.h>
43 #include <linux/nfs_fs.h>
44 #include <linux/nfs_page.h>
45 #include <linux/lockd/bind.h>
46 #include <linux/smp_lock.h>
48 #define NFSDBG_FACILITY NFSDBG_PROC
50 extern struct rpc_procinfo nfs_procedures
[];
53 * Bare-bones access to getattr: this is for nfs_read_super.
56 nfs_proc_get_root(struct nfs_server
*server
, struct nfs_fh
*fhandle
,
57 struct nfs_fsinfo
*info
)
59 struct nfs_fattr
*fattr
= info
->fattr
;
60 struct nfs2_fsstat fsinfo
;
63 dprintk("%s: call getattr\n", __FUNCTION__
);
64 nfs_fattr_init(fattr
);
65 status
= rpc_call(server
->client_sys
, NFSPROC_GETATTR
, fhandle
, fattr
, 0);
66 dprintk("%s: reply getattr: %d\n", __FUNCTION__
, status
);
69 dprintk("%s: call statfs\n", __FUNCTION__
);
70 status
= rpc_call(server
->client_sys
, NFSPROC_STATFS
, fhandle
, &fsinfo
, 0);
71 dprintk("%s: reply statfs: %d\n", __FUNCTION__
, status
);
74 info
->rtmax
= NFS_MAXDATA
;
75 info
->rtpref
= fsinfo
.tsize
;
76 info
->rtmult
= fsinfo
.bsize
;
77 info
->wtmax
= NFS_MAXDATA
;
78 info
->wtpref
= fsinfo
.tsize
;
79 info
->wtmult
= fsinfo
.bsize
;
80 info
->dtpref
= fsinfo
.tsize
;
81 info
->maxfilesize
= 0x7FFFFFFF;
87 * One function for each procedure in the NFS protocol.
90 nfs_proc_getattr(struct nfs_server
*server
, struct nfs_fh
*fhandle
,
91 struct nfs_fattr
*fattr
)
95 dprintk("NFS call getattr\n");
96 nfs_fattr_init(fattr
);
97 status
= rpc_call(server
->client
, NFSPROC_GETATTR
,
99 dprintk("NFS reply getattr: %d\n", status
);
104 nfs_proc_setattr(struct dentry
*dentry
, struct nfs_fattr
*fattr
,
107 struct inode
*inode
= dentry
->d_inode
;
108 struct nfs_sattrargs arg
= {
114 dprintk("NFS call setattr\n");
115 nfs_fattr_init(fattr
);
116 status
= rpc_call(NFS_CLIENT(inode
), NFSPROC_SETATTR
, &arg
, fattr
, 0);
118 nfs_setattr_update_inode(inode
, sattr
);
119 dprintk("NFS reply setattr: %d\n", status
);
124 nfs_proc_lookup(struct inode
*dir
, struct qstr
*name
,
125 struct nfs_fh
*fhandle
, struct nfs_fattr
*fattr
)
127 struct nfs_diropargs arg
= {
132 struct nfs_diropok res
= {
138 dprintk("NFS call lookup %s\n", name
->name
);
139 nfs_fattr_init(fattr
);
140 status
= rpc_call(NFS_CLIENT(dir
), NFSPROC_LOOKUP
, &arg
, &res
, 0);
141 dprintk("NFS reply lookup: %d\n", status
);
145 static int nfs_proc_readlink(struct inode
*inode
, struct page
*page
,
146 unsigned int pgbase
, unsigned int pglen
)
148 struct nfs_readlinkargs args
= {
156 dprintk("NFS call readlink\n");
157 status
= rpc_call(NFS_CLIENT(inode
), NFSPROC_READLINK
, &args
, NULL
, 0);
158 dprintk("NFS reply readlink: %d\n", status
);
162 static int nfs_proc_read(struct nfs_read_data
*rdata
)
164 int flags
= rdata
->flags
;
165 struct inode
* inode
= rdata
->inode
;
166 struct nfs_fattr
* fattr
= rdata
->res
.fattr
;
167 struct rpc_message msg
= {
168 .rpc_proc
= &nfs_procedures
[NFSPROC_READ
],
169 .rpc_argp
= &rdata
->args
,
170 .rpc_resp
= &rdata
->res
,
171 .rpc_cred
= rdata
->cred
,
175 dprintk("NFS call read %d @ %Ld\n", rdata
->args
.count
,
176 (long long) rdata
->args
.offset
);
177 nfs_fattr_init(fattr
);
178 status
= rpc_call_sync(NFS_CLIENT(inode
), &msg
, flags
);
180 nfs_refresh_inode(inode
, fattr
);
181 /* Emulate the eof flag, which isn't normally needed in NFSv2
182 * as it is guaranteed to always return the file attributes
184 if (rdata
->args
.offset
+ rdata
->args
.count
>= fattr
->size
)
187 dprintk("NFS reply read: %d\n", status
);
191 static int nfs_proc_write(struct nfs_write_data
*wdata
)
193 int flags
= wdata
->flags
;
194 struct inode
* inode
= wdata
->inode
;
195 struct nfs_fattr
* fattr
= wdata
->res
.fattr
;
196 struct rpc_message msg
= {
197 .rpc_proc
= &nfs_procedures
[NFSPROC_WRITE
],
198 .rpc_argp
= &wdata
->args
,
199 .rpc_resp
= &wdata
->res
,
200 .rpc_cred
= wdata
->cred
,
204 dprintk("NFS call write %d @ %Ld\n", wdata
->args
.count
,
205 (long long) wdata
->args
.offset
);
206 nfs_fattr_init(fattr
);
207 status
= rpc_call_sync(NFS_CLIENT(inode
), &msg
, flags
);
209 nfs_post_op_update_inode(inode
, fattr
);
210 wdata
->res
.count
= wdata
->args
.count
;
211 wdata
->verf
.committed
= NFS_FILE_SYNC
;
213 dprintk("NFS reply write: %d\n", status
);
214 return status
< 0? status
: wdata
->res
.count
;
218 nfs_proc_create(struct inode
*dir
, struct dentry
*dentry
, struct iattr
*sattr
,
219 int flags
, struct nameidata
*nd
)
221 struct nfs_fh fhandle
;
222 struct nfs_fattr fattr
;
223 struct nfs_createargs arg
= {
225 .name
= dentry
->d_name
.name
,
226 .len
= dentry
->d_name
.len
,
229 struct nfs_diropok res
= {
235 nfs_fattr_init(&fattr
);
236 dprintk("NFS call create %s\n", dentry
->d_name
.name
);
237 status
= rpc_call(NFS_CLIENT(dir
), NFSPROC_CREATE
, &arg
, &res
, 0);
239 status
= nfs_instantiate(dentry
, &fhandle
, &fattr
);
240 dprintk("NFS reply create: %d\n", status
);
245 * In NFSv2, mknod is grafted onto the create call.
248 nfs_proc_mknod(struct inode
*dir
, struct dentry
*dentry
, struct iattr
*sattr
,
251 struct nfs_fh fhandle
;
252 struct nfs_fattr fattr
;
253 struct nfs_createargs arg
= {
255 .name
= dentry
->d_name
.name
,
256 .len
= dentry
->d_name
.len
,
259 struct nfs_diropok res
= {
265 dprintk("NFS call mknod %s\n", dentry
->d_name
.name
);
267 mode
= sattr
->ia_mode
;
268 if (S_ISFIFO(mode
)) {
269 sattr
->ia_mode
= (mode
& ~S_IFMT
) | S_IFCHR
;
270 sattr
->ia_valid
&= ~ATTR_SIZE
;
271 } else if (S_ISCHR(mode
) || S_ISBLK(mode
)) {
272 sattr
->ia_valid
|= ATTR_SIZE
;
273 sattr
->ia_size
= new_encode_dev(rdev
);/* get out your barf bag */
276 nfs_fattr_init(&fattr
);
277 status
= rpc_call(NFS_CLIENT(dir
), NFSPROC_CREATE
, &arg
, &res
, 0);
278 nfs_mark_for_revalidate(dir
);
280 if (status
== -EINVAL
&& S_ISFIFO(mode
)) {
281 sattr
->ia_mode
= mode
;
282 nfs_fattr_init(&fattr
);
283 status
= rpc_call(NFS_CLIENT(dir
), NFSPROC_CREATE
, &arg
, &res
, 0);
286 status
= nfs_instantiate(dentry
, &fhandle
, &fattr
);
287 dprintk("NFS reply mknod: %d\n", status
);
292 nfs_proc_remove(struct inode
*dir
, struct qstr
*name
)
294 struct nfs_diropargs arg
= {
299 struct rpc_message msg
= {
300 .rpc_proc
= &nfs_procedures
[NFSPROC_REMOVE
],
307 dprintk("NFS call remove %s\n", name
->name
);
308 status
= rpc_call_sync(NFS_CLIENT(dir
), &msg
, 0);
309 nfs_mark_for_revalidate(dir
);
311 dprintk("NFS reply remove: %d\n", status
);
316 nfs_proc_unlink_setup(struct rpc_message
*msg
, struct dentry
*dir
, struct qstr
*name
)
318 struct nfs_diropargs
*arg
;
320 arg
= (struct nfs_diropargs
*)kmalloc(sizeof(*arg
), GFP_KERNEL
);
323 arg
->fh
= NFS_FH(dir
->d_inode
);
324 arg
->name
= name
->name
;
325 arg
->len
= name
->len
;
326 msg
->rpc_proc
= &nfs_procedures
[NFSPROC_REMOVE
];
332 nfs_proc_unlink_done(struct dentry
*dir
, struct rpc_task
*task
)
334 struct rpc_message
*msg
= &task
->tk_msg
;
337 nfs_mark_for_revalidate(dir
->d_inode
);
338 kfree(msg
->rpc_argp
);
344 nfs_proc_rename(struct inode
*old_dir
, struct qstr
*old_name
,
345 struct inode
*new_dir
, struct qstr
*new_name
)
347 struct nfs_renameargs arg
= {
348 .fromfh
= NFS_FH(old_dir
),
349 .fromname
= old_name
->name
,
350 .fromlen
= old_name
->len
,
351 .tofh
= NFS_FH(new_dir
),
352 .toname
= new_name
->name
,
353 .tolen
= new_name
->len
357 dprintk("NFS call rename %s -> %s\n", old_name
->name
, new_name
->name
);
358 status
= rpc_call(NFS_CLIENT(old_dir
), NFSPROC_RENAME
, &arg
, NULL
, 0);
359 nfs_mark_for_revalidate(old_dir
);
360 nfs_mark_for_revalidate(new_dir
);
361 dprintk("NFS reply rename: %d\n", status
);
366 nfs_proc_link(struct inode
*inode
, struct inode
*dir
, struct qstr
*name
)
368 struct nfs_linkargs arg
= {
369 .fromfh
= NFS_FH(inode
),
371 .toname
= name
->name
,
376 dprintk("NFS call link %s\n", name
->name
);
377 status
= rpc_call(NFS_CLIENT(inode
), NFSPROC_LINK
, &arg
, NULL
, 0);
378 nfs_mark_for_revalidate(inode
);
379 nfs_mark_for_revalidate(dir
);
380 dprintk("NFS reply link: %d\n", status
);
385 nfs_proc_symlink(struct inode
*dir
, struct qstr
*name
, struct qstr
*path
,
386 struct iattr
*sattr
, struct nfs_fh
*fhandle
,
387 struct nfs_fattr
*fattr
)
389 struct nfs_symlinkargs arg
= {
390 .fromfh
= NFS_FH(dir
),
391 .fromname
= name
->name
,
392 .fromlen
= name
->len
,
393 .topath
= path
->name
,
399 if (path
->len
> NFS2_MAXPATHLEN
)
400 return -ENAMETOOLONG
;
401 dprintk("NFS call symlink %s -> %s\n", name
->name
, path
->name
);
402 nfs_fattr_init(fattr
);
404 status
= rpc_call(NFS_CLIENT(dir
), NFSPROC_SYMLINK
, &arg
, NULL
, 0);
405 nfs_mark_for_revalidate(dir
);
406 dprintk("NFS reply symlink: %d\n", status
);
411 nfs_proc_mkdir(struct inode
*dir
, struct dentry
*dentry
, struct iattr
*sattr
)
413 struct nfs_fh fhandle
;
414 struct nfs_fattr fattr
;
415 struct nfs_createargs arg
= {
417 .name
= dentry
->d_name
.name
,
418 .len
= dentry
->d_name
.len
,
421 struct nfs_diropok res
= {
427 dprintk("NFS call mkdir %s\n", dentry
->d_name
.name
);
428 nfs_fattr_init(&fattr
);
429 status
= rpc_call(NFS_CLIENT(dir
), NFSPROC_MKDIR
, &arg
, &res
, 0);
430 nfs_mark_for_revalidate(dir
);
432 status
= nfs_instantiate(dentry
, &fhandle
, &fattr
);
433 dprintk("NFS reply mkdir: %d\n", status
);
438 nfs_proc_rmdir(struct inode
*dir
, struct qstr
*name
)
440 struct nfs_diropargs arg
= {
447 dprintk("NFS call rmdir %s\n", name
->name
);
448 status
= rpc_call(NFS_CLIENT(dir
), NFSPROC_RMDIR
, &arg
, NULL
, 0);
449 nfs_mark_for_revalidate(dir
);
450 dprintk("NFS reply rmdir: %d\n", status
);
455 * The READDIR implementation is somewhat hackish - we pass a temporary
456 * buffer to the encode function, which installs it in the receive
457 * the receive iovec. The decode function just parses the reply to make
458 * sure it is syntactically correct; the entries itself are decoded
459 * from nfs_readdir by calling the decode_entry function directly.
462 nfs_proc_readdir(struct dentry
*dentry
, struct rpc_cred
*cred
,
463 u64 cookie
, struct page
*page
, unsigned int count
, int plus
)
465 struct inode
*dir
= dentry
->d_inode
;
466 struct nfs_readdirargs arg
= {
472 struct rpc_message msg
= {
473 .rpc_proc
= &nfs_procedures
[NFSPROC_READDIR
],
482 dprintk("NFS call readdir %d\n", (unsigned int)cookie
);
483 status
= rpc_call_sync(NFS_CLIENT(dir
), &msg
, 0);
485 dprintk("NFS reply readdir: %d\n", status
);
491 nfs_proc_statfs(struct nfs_server
*server
, struct nfs_fh
*fhandle
,
492 struct nfs_fsstat
*stat
)
494 struct nfs2_fsstat fsinfo
;
497 dprintk("NFS call statfs\n");
498 nfs_fattr_init(stat
->fattr
);
499 status
= rpc_call(server
->client
, NFSPROC_STATFS
, fhandle
, &fsinfo
, 0);
500 dprintk("NFS reply statfs: %d\n", status
);
503 stat
->tbytes
= (u64
)fsinfo
.blocks
* fsinfo
.bsize
;
504 stat
->fbytes
= (u64
)fsinfo
.bfree
* fsinfo
.bsize
;
505 stat
->abytes
= (u64
)fsinfo
.bavail
* fsinfo
.bsize
;
514 nfs_proc_fsinfo(struct nfs_server
*server
, struct nfs_fh
*fhandle
,
515 struct nfs_fsinfo
*info
)
517 struct nfs2_fsstat fsinfo
;
520 dprintk("NFS call fsinfo\n");
521 nfs_fattr_init(info
->fattr
);
522 status
= rpc_call(server
->client
, NFSPROC_STATFS
, fhandle
, &fsinfo
, 0);
523 dprintk("NFS reply fsinfo: %d\n", status
);
526 info
->rtmax
= NFS_MAXDATA
;
527 info
->rtpref
= fsinfo
.tsize
;
528 info
->rtmult
= fsinfo
.bsize
;
529 info
->wtmax
= NFS_MAXDATA
;
530 info
->wtpref
= fsinfo
.tsize
;
531 info
->wtmult
= fsinfo
.bsize
;
532 info
->dtpref
= fsinfo
.tsize
;
533 info
->maxfilesize
= 0x7FFFFFFF;
534 info
->lease_time
= 0;
540 nfs_proc_pathconf(struct nfs_server
*server
, struct nfs_fh
*fhandle
,
541 struct nfs_pathconf
*info
)
544 info
->max_namelen
= NFS2_MAXNAMLEN
;
548 extern u32
* nfs_decode_dirent(u32
*, struct nfs_entry
*, int);
551 nfs_read_done(struct rpc_task
*task
)
553 struct nfs_read_data
*data
= (struct nfs_read_data
*) task
->tk_calldata
;
555 if (task
->tk_status
>= 0) {
556 nfs_refresh_inode(data
->inode
, data
->res
.fattr
);
557 /* Emulate the eof flag, which isn't normally needed in NFSv2
558 * as it is guaranteed to always return the file attributes
560 if (data
->args
.offset
+ data
->args
.count
>= data
->res
.fattr
->size
)
563 nfs_readpage_result(task
);
567 nfs_proc_read_setup(struct nfs_read_data
*data
)
569 struct rpc_task
*task
= &data
->task
;
570 struct inode
*inode
= data
->inode
;
572 struct rpc_message msg
= {
573 .rpc_proc
= &nfs_procedures
[NFSPROC_READ
],
574 .rpc_argp
= &data
->args
,
575 .rpc_resp
= &data
->res
,
576 .rpc_cred
= data
->cred
,
579 /* N.B. Do we need to test? Never called for swapfile inode */
580 flags
= RPC_TASK_ASYNC
| (IS_SWAPFILE(inode
)? NFS_RPC_SWAPFLAGS
: 0);
582 /* Finalize the task. */
583 rpc_init_task(task
, NFS_CLIENT(inode
), nfs_read_done
, flags
);
584 rpc_call_setup(task
, &msg
, 0);
588 nfs_write_done(struct rpc_task
*task
)
590 struct nfs_write_data
*data
= (struct nfs_write_data
*) task
->tk_calldata
;
592 if (task
->tk_status
>= 0)
593 nfs_post_op_update_inode(data
->inode
, data
->res
.fattr
);
594 nfs_writeback_done(task
);
598 nfs_proc_write_setup(struct nfs_write_data
*data
, int how
)
600 struct rpc_task
*task
= &data
->task
;
601 struct inode
*inode
= data
->inode
;
603 struct rpc_message msg
= {
604 .rpc_proc
= &nfs_procedures
[NFSPROC_WRITE
],
605 .rpc_argp
= &data
->args
,
606 .rpc_resp
= &data
->res
,
607 .rpc_cred
= data
->cred
,
610 /* Note: NFSv2 ignores @stable and always uses NFS_FILE_SYNC */
611 data
->args
.stable
= NFS_FILE_SYNC
;
613 /* Set the initial flags for the task. */
614 flags
= (how
& FLUSH_SYNC
) ? 0 : RPC_TASK_ASYNC
;
616 /* Finalize the task. */
617 rpc_init_task(task
, NFS_CLIENT(inode
), nfs_write_done
, flags
);
618 rpc_call_setup(task
, &msg
, 0);
622 nfs_proc_commit_setup(struct nfs_write_data
*data
, int how
)
628 nfs_proc_lock(struct file
*filp
, int cmd
, struct file_lock
*fl
)
630 return nlmclnt_proc(filp
->f_dentry
->d_inode
, cmd
, fl
);
634 struct nfs_rpc_ops nfs_v2_clientops
= {
635 .version
= 2, /* protocol version */
636 .dentry_ops
= &nfs_dentry_operations
,
637 .dir_inode_ops
= &nfs_dir_inode_operations
,
638 .file_inode_ops
= &nfs_file_inode_operations
,
639 .getroot
= nfs_proc_get_root
,
640 .getattr
= nfs_proc_getattr
,
641 .setattr
= nfs_proc_setattr
,
642 .lookup
= nfs_proc_lookup
,
643 .access
= NULL
, /* access */
644 .readlink
= nfs_proc_readlink
,
645 .read
= nfs_proc_read
,
646 .write
= nfs_proc_write
,
647 .commit
= NULL
, /* commit */
648 .create
= nfs_proc_create
,
649 .remove
= nfs_proc_remove
,
650 .unlink_setup
= nfs_proc_unlink_setup
,
651 .unlink_done
= nfs_proc_unlink_done
,
652 .rename
= nfs_proc_rename
,
653 .link
= nfs_proc_link
,
654 .symlink
= nfs_proc_symlink
,
655 .mkdir
= nfs_proc_mkdir
,
656 .rmdir
= nfs_proc_rmdir
,
657 .readdir
= nfs_proc_readdir
,
658 .mknod
= nfs_proc_mknod
,
659 .statfs
= nfs_proc_statfs
,
660 .fsinfo
= nfs_proc_fsinfo
,
661 .pathconf
= nfs_proc_pathconf
,
662 .decode_dirent
= nfs_decode_dirent
,
663 .read_setup
= nfs_proc_read_setup
,
664 .write_setup
= nfs_proc_write_setup
,
665 .commit_setup
= nfs_proc_commit_setup
,
666 .file_open
= nfs_open
,
667 .file_release
= nfs_release
,
668 .lock
= nfs_proc_lock
,