1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30#include <linux/types.h>
31#include <linux/param.h>
32#include <linux/slab.h>
33#include <linux/time.h>
34#include <linux/mm.h>
35#include <linux/utsname.h>
36#include <linux/errno.h>
37#include <linux/string.h>
38#include <linux/in.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 "internal.h"
47
48#define NFSDBG_FACILITY NFSDBG_PROC
49
50
51
52
53static int
54nfs_proc_get_root(struct nfs_server *server, struct nfs_fh *fhandle,
55 struct nfs_fsinfo *info)
56{
57 struct nfs_fattr *fattr = info->fattr;
58 struct nfs2_fsstat fsinfo;
59 struct rpc_message msg = {
60 .rpc_proc = &nfs_procedures[NFSPROC_GETATTR],
61 .rpc_argp = fhandle,
62 .rpc_resp = fattr,
63 };
64 int status;
65
66 dprintk("%s: call getattr\n", __FUNCTION__);
67 nfs_fattr_init(fattr);
68 status = rpc_call_sync(server->nfs_client->cl_rpcclient, &msg, 0);
69 dprintk("%s: reply getattr: %d\n", __FUNCTION__, status);
70 if (status)
71 return status;
72 dprintk("%s: call statfs\n", __FUNCTION__);
73 msg.rpc_proc = &nfs_procedures[NFSPROC_STATFS];
74 msg.rpc_resp = &fsinfo;
75 status = rpc_call_sync(server->nfs_client->cl_rpcclient, &msg, 0);
76 dprintk("%s: reply statfs: %d\n", __FUNCTION__, status);
77 if (status)
78 return status;
79 info->rtmax = NFS_MAXDATA;
80 info->rtpref = fsinfo.tsize;
81 info->rtmult = fsinfo.bsize;
82 info->wtmax = NFS_MAXDATA;
83 info->wtpref = fsinfo.tsize;
84 info->wtmult = fsinfo.bsize;
85 info->dtpref = fsinfo.tsize;
86 info->maxfilesize = 0x7FFFFFFF;
87 info->lease_time = 0;
88 return 0;
89}
90
91
92
93
94static int
95nfs_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
96 struct nfs_fattr *fattr)
97{
98 struct rpc_message msg = {
99 .rpc_proc = &nfs_procedures[NFSPROC_GETATTR],
100 .rpc_argp = fhandle,
101 .rpc_resp = fattr,
102 };
103 int status;
104
105 dprintk("NFS call getattr\n");
106 nfs_fattr_init(fattr);
107 status = rpc_call_sync(server->client, &msg, 0);
108 dprintk("NFS reply getattr: %d\n", status);
109 return status;
110}
111
112static int
113nfs_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
114 struct iattr *sattr)
115{
116 struct inode *inode = dentry->d_inode;
117 struct nfs_sattrargs arg = {
118 .fh = NFS_FH(inode),
119 .sattr = sattr
120 };
121 struct rpc_message msg = {
122 .rpc_proc = &nfs_procedures[NFSPROC_SETATTR],
123 .rpc_argp = &arg,
124 .rpc_resp = fattr,
125 };
126 int status;
127
128
129 sattr->ia_mode &= S_IALLUGO;
130
131 dprintk("NFS call setattr\n");
132 nfs_fattr_init(fattr);
133 status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
134 if (status == 0)
135 nfs_setattr_update_inode(inode, sattr);
136 dprintk("NFS reply setattr: %d\n", status);
137 return status;
138}
139
140static int
141nfs_proc_lookup(struct inode *dir, struct qstr *name,
142 struct nfs_fh *fhandle, struct nfs_fattr *fattr)
143{
144 struct nfs_diropargs arg = {
145 .fh = NFS_FH(dir),
146 .name = name->name,
147 .len = name->len
148 };
149 struct nfs_diropok res = {
150 .fh = fhandle,
151 .fattr = fattr
152 };
153 struct rpc_message msg = {
154 .rpc_proc = &nfs_procedures[NFSPROC_LOOKUP],
155 .rpc_argp = &arg,
156 .rpc_resp = &res,
157 };
158 int status;
159
160 dprintk("NFS call lookup %s\n", name->name);
161 nfs_fattr_init(fattr);
162 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
163 dprintk("NFS reply lookup: %d\n", status);
164 return status;
165}
166
167static int nfs_proc_readlink(struct inode *inode, struct page *page,
168 unsigned int pgbase, unsigned int pglen)
169{
170 struct nfs_readlinkargs args = {
171 .fh = NFS_FH(inode),
172 .pgbase = pgbase,
173 .pglen = pglen,
174 .pages = &page
175 };
176 struct rpc_message msg = {
177 .rpc_proc = &nfs_procedures[NFSPROC_READLINK],
178 .rpc_argp = &args,
179 };
180 int status;
181
182 dprintk("NFS call readlink\n");
183 status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
184 dprintk("NFS reply readlink: %d\n", status);
185 return status;
186}
187
188static int
189nfs_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
190 int flags, struct nameidata *nd)
191{
192 struct nfs_fh fhandle;
193 struct nfs_fattr fattr;
194 struct nfs_createargs arg = {
195 .fh = NFS_FH(dir),
196 .name = dentry->d_name.name,
197 .len = dentry->d_name.len,
198 .sattr = sattr
199 };
200 struct nfs_diropok res = {
201 .fh = &fhandle,
202 .fattr = &fattr
203 };
204 struct rpc_message msg = {
205 .rpc_proc = &nfs_procedures[NFSPROC_CREATE],
206 .rpc_argp = &arg,
207 .rpc_resp = &res,
208 };
209 int status;
210
211 nfs_fattr_init(&fattr);
212 dprintk("NFS call create %s\n", dentry->d_name.name);
213 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
214 nfs_mark_for_revalidate(dir);
215 if (status == 0)
216 status = nfs_instantiate(dentry, &fhandle, &fattr);
217 dprintk("NFS reply create: %d\n", status);
218 return status;
219}
220
221
222
223
224static int
225nfs_proc_mknod(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
226 dev_t rdev)
227{
228 struct nfs_fh fhandle;
229 struct nfs_fattr fattr;
230 struct nfs_createargs arg = {
231 .fh = NFS_FH(dir),
232 .name = dentry->d_name.name,
233 .len = dentry->d_name.len,
234 .sattr = sattr
235 };
236 struct nfs_diropok res = {
237 .fh = &fhandle,
238 .fattr = &fattr
239 };
240 struct rpc_message msg = {
241 .rpc_proc = &nfs_procedures[NFSPROC_CREATE],
242 .rpc_argp = &arg,
243 .rpc_resp = &res,
244 };
245 int status, mode;
246
247 dprintk("NFS call mknod %s\n", dentry->d_name.name);
248
249 mode = sattr->ia_mode;
250 if (S_ISFIFO(mode)) {
251 sattr->ia_mode = (mode & ~S_IFMT) | S_IFCHR;
252 sattr->ia_valid &= ~ATTR_SIZE;
253 } else if (S_ISCHR(mode) || S_ISBLK(mode)) {
254 sattr->ia_valid |= ATTR_SIZE;
255 sattr->ia_size = new_encode_dev(rdev);
256 }
257
258 nfs_fattr_init(&fattr);
259 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
260 nfs_mark_for_revalidate(dir);
261
262 if (status == -EINVAL && S_ISFIFO(mode)) {
263 sattr->ia_mode = mode;
264 nfs_fattr_init(&fattr);
265 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
266 }
267 if (status == 0)
268 status = nfs_instantiate(dentry, &fhandle, &fattr);
269 dprintk("NFS reply mknod: %d\n", status);
270 return status;
271}
272
273static int
274nfs_proc_remove(struct inode *dir, struct qstr *name)
275{
276 struct nfs_removeargs arg = {
277 .fh = NFS_FH(dir),
278 .name.len = name->len,
279 .name.name = name->name,
280 };
281 struct rpc_message msg = {
282 .rpc_proc = &nfs_procedures[NFSPROC_REMOVE],
283 .rpc_argp = &arg,
284 };
285 int status;
286
287 dprintk("NFS call remove %s\n", name->name);
288 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
289 nfs_mark_for_revalidate(dir);
290
291 dprintk("NFS reply remove: %d\n", status);
292 return status;
293}
294
295static void
296nfs_proc_unlink_setup(struct rpc_message *msg, struct inode *dir)
297{
298 msg->rpc_proc = &nfs_procedures[NFSPROC_REMOVE];
299}
300
301static int nfs_proc_unlink_done(struct rpc_task *task, struct inode *dir)
302{
303 nfs_mark_for_revalidate(dir);
304 return 1;
305}
306
307static int
308nfs_proc_rename(struct inode *old_dir, struct qstr *old_name,
309 struct inode *new_dir, struct qstr *new_name)
310{
311 struct nfs_renameargs arg = {
312 .fromfh = NFS_FH(old_dir),
313 .fromname = old_name->name,
314 .fromlen = old_name->len,
315 .tofh = NFS_FH(new_dir),
316 .toname = new_name->name,
317 .tolen = new_name->len
318 };
319 struct rpc_message msg = {
320 .rpc_proc = &nfs_procedures[NFSPROC_RENAME],
321 .rpc_argp = &arg,
322 };
323 int status;
324
325 dprintk("NFS call rename %s -> %s\n", old_name->name, new_name->name);
326 status = rpc_call_sync(NFS_CLIENT(old_dir), &msg, 0);
327 nfs_mark_for_revalidate(old_dir);
328 nfs_mark_for_revalidate(new_dir);
329 dprintk("NFS reply rename: %d\n", status);
330 return status;
331}
332
333static int
334nfs_proc_link(struct inode *inode, struct inode *dir, struct qstr *name)
335{
336 struct nfs_linkargs arg = {
337 .fromfh = NFS_FH(inode),
338 .tofh = NFS_FH(dir),
339 .toname = name->name,
340 .tolen = name->len
341 };
342 struct rpc_message msg = {
343 .rpc_proc = &nfs_procedures[NFSPROC_LINK],
344 .rpc_argp = &arg,
345 };
346 int status;
347
348 dprintk("NFS call link %s\n", name->name);
349 status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
350 nfs_mark_for_revalidate(inode);
351 nfs_mark_for_revalidate(dir);
352 dprintk("NFS reply link: %d\n", status);
353 return status;
354}
355
356static int
357nfs_proc_symlink(struct inode *dir, struct dentry *dentry, struct page *page,
358 unsigned int len, struct iattr *sattr)
359{
360 struct nfs_fh fhandle;
361 struct nfs_fattr fattr;
362 struct nfs_symlinkargs arg = {
363 .fromfh = NFS_FH(dir),
364 .fromname = dentry->d_name.name,
365 .fromlen = dentry->d_name.len,
366 .pages = &page,
367 .pathlen = len,
368 .sattr = sattr
369 };
370 struct rpc_message msg = {
371 .rpc_proc = &nfs_procedures[NFSPROC_SYMLINK],
372 .rpc_argp = &arg,
373 };
374 int status;
375
376 if (len > NFS2_MAXPATHLEN)
377 return -ENAMETOOLONG;
378
379 dprintk("NFS call symlink %s\n", dentry->d_name.name);
380
381 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
382 nfs_mark_for_revalidate(dir);
383
384
385
386
387
388
389 if (status == 0) {
390 nfs_fattr_init(&fattr);
391 fhandle.size = 0;
392 status = nfs_instantiate(dentry, &fhandle, &fattr);
393 }
394
395 dprintk("NFS reply symlink: %d\n", status);
396 return status;
397}
398
399static int
400nfs_proc_mkdir(struct inode *dir, struct dentry *dentry, struct iattr *sattr)
401{
402 struct nfs_fh fhandle;
403 struct nfs_fattr fattr;
404 struct nfs_createargs arg = {
405 .fh = NFS_FH(dir),
406 .name = dentry->d_name.name,
407 .len = dentry->d_name.len,
408 .sattr = sattr
409 };
410 struct nfs_diropok res = {
411 .fh = &fhandle,
412 .fattr = &fattr
413 };
414 struct rpc_message msg = {
415 .rpc_proc = &nfs_procedures[NFSPROC_MKDIR],
416 .rpc_argp = &arg,
417 .rpc_resp = &res,
418 };
419 int status;
420
421 dprintk("NFS call mkdir %s\n", dentry->d_name.name);
422 nfs_fattr_init(&fattr);
423 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
424 nfs_mark_for_revalidate(dir);
425 if (status == 0)
426 status = nfs_instantiate(dentry, &fhandle, &fattr);
427 dprintk("NFS reply mkdir: %d\n", status);
428 return status;
429}
430
431static int
432nfs_proc_rmdir(struct inode *dir, struct qstr *name)
433{
434 struct nfs_diropargs arg = {
435 .fh = NFS_FH(dir),
436 .name = name->name,
437 .len = name->len
438 };
439 struct rpc_message msg = {
440 .rpc_proc = &nfs_procedures[NFSPROC_RMDIR],
441 .rpc_argp = &arg,
442 };
443 int status;
444
445 dprintk("NFS call rmdir %s\n", name->name);
446 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
447 nfs_mark_for_revalidate(dir);
448 dprintk("NFS reply rmdir: %d\n", status);
449 return status;
450}
451
452
453
454
455
456
457
458
459static int
460nfs_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
461 u64 cookie, struct page *page, unsigned int count, int plus)
462{
463 struct inode *dir = dentry->d_inode;
464 struct nfs_readdirargs arg = {
465 .fh = NFS_FH(dir),
466 .cookie = cookie,
467 .count = count,
468 .pages = &page,
469 };
470 struct rpc_message msg = {
471 .rpc_proc = &nfs_procedures[NFSPROC_READDIR],
472 .rpc_argp = &arg,
473 .rpc_cred = cred,
474 };
475 int status;
476
477 dprintk("NFS call readdir %d\n", (unsigned int)cookie);
478 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
479
480 nfs_invalidate_atime(dir);
481
482 dprintk("NFS reply readdir: %d\n", status);
483 return status;
484}
485
486static int
487nfs_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle,
488 struct nfs_fsstat *stat)
489{
490 struct nfs2_fsstat fsinfo;
491 struct rpc_message msg = {
492 .rpc_proc = &nfs_procedures[NFSPROC_STATFS],
493 .rpc_argp = fhandle,
494 .rpc_resp = &fsinfo,
495 };
496 int status;
497
498 dprintk("NFS call statfs\n");
499 nfs_fattr_init(stat->fattr);
500 status = rpc_call_sync(server->client, &msg, 0);
501 dprintk("NFS reply statfs: %d\n", status);
502 if (status)
503 goto out;
504 stat->tbytes = (u64)fsinfo.blocks * fsinfo.bsize;
505 stat->fbytes = (u64)fsinfo.bfree * fsinfo.bsize;
506 stat->abytes = (u64)fsinfo.bavail * fsinfo.bsize;
507 stat->tfiles = 0;
508 stat->ffiles = 0;
509 stat->afiles = 0;
510out:
511 return status;
512}
513
514static int
515nfs_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle,
516 struct nfs_fsinfo *info)
517{
518 struct nfs2_fsstat fsinfo;
519 struct rpc_message msg = {
520 .rpc_proc = &nfs_procedures[NFSPROC_STATFS],
521 .rpc_argp = fhandle,
522 .rpc_resp = &fsinfo,
523 };
524 int status;
525
526 dprintk("NFS call fsinfo\n");
527 nfs_fattr_init(info->fattr);
528 status = rpc_call_sync(server->client, &msg, 0);
529 dprintk("NFS reply fsinfo: %d\n", status);
530 if (status)
531 goto out;
532 info->rtmax = NFS_MAXDATA;
533 info->rtpref = fsinfo.tsize;
534 info->rtmult = fsinfo.bsize;
535 info->wtmax = NFS_MAXDATA;
536 info->wtpref = fsinfo.tsize;
537 info->wtmult = fsinfo.bsize;
538 info->dtpref = fsinfo.tsize;
539 info->maxfilesize = 0x7FFFFFFF;
540 info->lease_time = 0;
541out:
542 return status;
543}
544
545static int
546nfs_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
547 struct nfs_pathconf *info)
548{
549 info->max_link = 0;
550 info->max_namelen = NFS2_MAXNAMLEN;
551 return 0;
552}
553
554static int nfs_read_done(struct rpc_task *task, struct nfs_read_data *data)
555{
556 nfs_invalidate_atime(data->inode);
557 if (task->tk_status >= 0) {
558 nfs_refresh_inode(data->inode, data->res.fattr);
559
560
561
562 if (data->args.offset + data->args.count >= data->res.fattr->size)
563 data->res.eof = 1;
564 }
565 return 0;
566}
567
568static void nfs_proc_read_setup(struct nfs_read_data *data)
569{
570 struct rpc_message msg = {
571 .rpc_proc = &nfs_procedures[NFSPROC_READ],
572 .rpc_argp = &data->args,
573 .rpc_resp = &data->res,
574 .rpc_cred = data->cred,
575 };
576
577 rpc_call_setup(&data->task, &msg, 0);
578}
579
580static int nfs_write_done(struct rpc_task *task, struct nfs_write_data *data)
581{
582 if (task->tk_status >= 0)
583 nfs_post_op_update_inode_force_wcc(data->inode, data->res.fattr);
584 return 0;
585}
586
587static void nfs_proc_write_setup(struct nfs_write_data *data, int how)
588{
589 struct rpc_message msg = {
590 .rpc_proc = &nfs_procedures[NFSPROC_WRITE],
591 .rpc_argp = &data->args,
592 .rpc_resp = &data->res,
593 .rpc_cred = data->cred,
594 };
595
596
597 data->args.stable = NFS_FILE_SYNC;
598
599
600 rpc_call_setup(&data->task, &msg, 0);
601}
602
603static void
604nfs_proc_commit_setup(struct nfs_write_data *data, int how)
605{
606 BUG();
607}
608
609static int
610nfs_proc_lock(struct file *filp, int cmd, struct file_lock *fl)
611{
612 return nlmclnt_proc(filp->f_path.dentry->d_inode, cmd, fl);
613}
614
615
616const struct nfs_rpc_ops nfs_v2_clientops = {
617 .version = 2,
618 .dentry_ops = &nfs_dentry_operations,
619 .dir_inode_ops = &nfs_dir_inode_operations,
620 .file_inode_ops = &nfs_file_inode_operations,
621 .getroot = nfs_proc_get_root,
622 .getattr = nfs_proc_getattr,
623 .setattr = nfs_proc_setattr,
624 .lookup = nfs_proc_lookup,
625 .access = NULL,
626 .readlink = nfs_proc_readlink,
627 .create = nfs_proc_create,
628 .remove = nfs_proc_remove,
629 .unlink_setup = nfs_proc_unlink_setup,
630 .unlink_done = nfs_proc_unlink_done,
631 .rename = nfs_proc_rename,
632 .link = nfs_proc_link,
633 .symlink = nfs_proc_symlink,
634 .mkdir = nfs_proc_mkdir,
635 .rmdir = nfs_proc_rmdir,
636 .readdir = nfs_proc_readdir,
637 .mknod = nfs_proc_mknod,
638 .statfs = nfs_proc_statfs,
639 .fsinfo = nfs_proc_fsinfo,
640 .pathconf = nfs_proc_pathconf,
641 .decode_dirent = nfs_decode_dirent,
642 .read_setup = nfs_proc_read_setup,
643 .read_done = nfs_read_done,
644 .write_setup = nfs_proc_write_setup,
645 .write_done = nfs_write_done,
646 .commit_setup = nfs_proc_commit_setup,
647 .file_open = nfs_open,
648 .file_release = nfs_release,
649 .lock = nfs_proc_lock,
650};
651