1
2
3
4
5
6
7
8
9#include <linux/mm.h>
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>
21
22#include "iostat.h"
23#include "internal.h"
24
25#define NFSDBG_FACILITY NFSDBG_PROC
26
27
28static int
29nfs3_rpc_wrapper(struct rpc_clnt *clnt, struct rpc_message *msg, int flags)
30{
31 int res;
32 do {
33 res = rpc_call_sync(clnt, msg, flags);
34 if (res != -EJUKEBOX)
35 break;
36 freezable_schedule_timeout_killable_unsafe(NFS_JUKEBOX_RETRY_TIME);
37 res = -ERESTARTSYS;
38 } while (!fatal_signal_pending(current));
39 return res;
40}
41
42#define rpc_call_sync(clnt, msg, flags) nfs3_rpc_wrapper(clnt, msg, flags)
43
44static int
45nfs3_async_handle_jukebox(struct rpc_task *task, struct inode *inode)
46{
47 if (task->tk_status != -EJUKEBOX)
48 return 0;
49 if (task->tk_status == -EJUKEBOX)
50 nfs_inc_stats(inode, NFSIOS_DELAY);
51 task->tk_status = 0;
52 rpc_restart_call(task);
53 rpc_delay(task, NFS_JUKEBOX_RETRY_TIME);
54 return 1;
55}
56
57static int
58do_proc_get_root(struct rpc_clnt *client, struct nfs_fh *fhandle,
59 struct nfs_fsinfo *info)
60{
61 struct rpc_message msg = {
62 .rpc_proc = &nfs3_procedures[NFS3PROC_FSINFO],
63 .rpc_argp = fhandle,
64 .rpc_resp = info,
65 };
66 int status;
67
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);
77 }
78 return status;
79}
80
81
82
83
84static int
85nfs3_proc_get_root(struct nfs_server *server, struct nfs_fh *fhandle,
86 struct nfs_fsinfo *info)
87{
88 int status;
89
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);
93 return status;
94}
95
96
97
98
99static int
100nfs3_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
101 struct nfs_fattr *fattr, struct nfs4_label *label)
102{
103 struct rpc_message msg = {
104 .rpc_proc = &nfs3_procedures[NFS3PROC_GETATTR],
105 .rpc_argp = fhandle,
106 .rpc_resp = fattr,
107 };
108 int status;
109
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);
114 return status;
115}
116
117static int
118nfs3_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
119 struct iattr *sattr)
120{
121 struct inode *inode = dentry->d_inode;
122 struct nfs3_sattrargs arg = {
123 .fh = NFS_FH(inode),
124 .sattr = sattr,
125 };
126 struct rpc_message msg = {
127 .rpc_proc = &nfs3_procedures[NFS3PROC_SETATTR],
128 .rpc_argp = &arg,
129 .rpc_resp = fattr,
130 };
131 int status;
132
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);
138 if (status == 0)
139 nfs_setattr_update_inode(inode, sattr);
140 dprintk("NFS reply setattr: %d\n", status);
141 return status;
142}
143
144static int
145nfs3_proc_lookup(struct inode *dir, struct qstr *name,
146 struct nfs_fh *fhandle, struct nfs_fattr *fattr,
147 struct nfs4_label *label)
148{
149 struct nfs3_diropargs arg = {
150 .fh = NFS_FH(dir),
151 .name = name->name,
152 .len = name->len
153 };
154 struct nfs3_diropres res = {
155 .fh = fhandle,
156 .fattr = fattr
157 };
158 struct rpc_message msg = {
159 .rpc_proc = &nfs3_procedures[NFS3PROC_LOOKUP],
160 .rpc_argp = &arg,
161 .rpc_resp = &res,
162 };
163 int status;
164
165 dprintk("NFS call lookup %s\n", name->name);
166 res.dir_attr = nfs_alloc_fattr();
167 if (res.dir_attr == NULL)
168 return -ENOMEM;
169
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);
178 }
179 nfs_free_fattr(res.dir_attr);
180 dprintk("NFS reply lookup: %d\n", status);
181 return status;
182}
183
184static int nfs3_proc_access(struct inode *inode, struct nfs_access_entry *entry)
185{
186 struct nfs3_accessargs arg = {
187 .fh = NFS_FH(inode),
188 };
189 struct nfs3_accessres res;
190 struct rpc_message msg = {
191 .rpc_proc = &nfs3_procedures[NFS3PROC_ACCESS],
192 .rpc_argp = &arg,
193 .rpc_resp = &res,
194 .rpc_cred = entry->cred,
195 };
196 int mode = entry->mask;
197 int status = -ENOMEM;
198
199 dprintk("NFS call access\n");
200
201 if (mode & MAY_READ)
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;
206 if (mode & MAY_EXEC)
207 arg.access |= NFS3_ACCESS_LOOKUP;
208 } else {
209 if (mode & MAY_WRITE)
210 arg.access |= NFS3_ACCESS_MODIFY | NFS3_ACCESS_EXTEND;
211 if (mode & MAY_EXEC)
212 arg.access |= NFS3_ACCESS_EXECUTE;
213 }
214
215 res.fattr = nfs_alloc_fattr();
216 if (res.fattr == NULL)
217 goto out;
218
219 status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
220 nfs_refresh_inode(inode, res.fattr);
221 if (status == 0) {
222 entry->mask = 0;
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;
229 }
230 nfs_free_fattr(res.fattr);
231out:
232 dprintk("NFS reply access: %d\n", status);
233 return status;
234}
235
236static int nfs3_proc_readlink(struct inode *inode, struct page *page,
237 unsigned int pgbase, unsigned int pglen)
238{
239 struct nfs_fattr *fattr;
240 struct nfs3_readlinkargs args = {
241 .fh = NFS_FH(inode),
242 .pgbase = pgbase,
243 .pglen = pglen,
244 .pages = &page
245 };
246 struct rpc_message msg = {
247 .rpc_proc = &nfs3_procedures[NFS3PROC_READLINK],
248 .rpc_argp = &args,
249 };
250 int status = -ENOMEM;
251
252 dprintk("NFS call readlink\n");
253 fattr = nfs_alloc_fattr();
254 if (fattr == NULL)
255 goto out;
256 msg.rpc_resp = fattr;
257
258 status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
259 nfs_refresh_inode(inode, fattr);
260 nfs_free_fattr(fattr);
261out:
262 dprintk("NFS reply readlink: %d\n", status);
263 return status;
264}
265
266struct nfs3_createdata {
267 struct rpc_message msg;
268 union {
269 struct nfs3_createargs create;
270 struct nfs3_mkdirargs mkdir;
271 struct nfs3_symlinkargs symlink;
272 struct nfs3_mknodargs mknod;
273 } arg;
274 struct nfs3_diropres res;
275 struct nfs_fh fh;
276 struct nfs_fattr fattr;
277 struct nfs_fattr dir_attr;
278};
279
280static struct nfs3_createdata *nfs3_alloc_createdata(void)
281{
282 struct nfs3_createdata *data;
283
284 data = kzalloc(sizeof(*data), GFP_KERNEL);
285 if (data != NULL) {
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);
293 }
294 return data;
295}
296
297static int nfs3_do_create(struct inode *dir, struct dentry *dentry, struct nfs3_createdata *data)
298{
299 int status;
300
301 status = rpc_call_sync(NFS_CLIENT(dir), &data->msg, 0);
302 nfs_post_op_update_inode(dir, data->res.dir_attr);
303 if (status == 0)
304 status = nfs_instantiate(dentry, data->res.fh, data->res.fattr, NULL);
305 return status;
306}
307
308static void nfs3_free_createdata(struct nfs3_createdata *data)
309{
310 kfree(data);
311}
312
313
314
315
316static int
317nfs3_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
318 int flags)
319{
320 struct nfs3_createdata *data;
321 umode_t mode = sattr->ia_mode;
322 int status = -ENOMEM;
323
324 dprintk("NFS call create %s\n", dentry->d_name.name);
325
326 data = nfs3_alloc_createdata();
327 if (data == NULL)
328 goto out;
329
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;
335
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] = jiffies;
340 data->arg.create.verifier[1] = current->pid;
341 }
342
343 sattr->ia_mode &= ~current_umask();
344
345 for (;;) {
346 status = nfs3_do_create(dir, dentry, data);
347
348 if (status != -ENOTSUPP)
349 break;
350
351
352 switch (data->arg.create.createmode) {
353 case NFS3_CREATE_EXCLUSIVE:
354 data->arg.create.createmode = NFS3_CREATE_GUARDED;
355 break;
356
357 case NFS3_CREATE_GUARDED:
358 data->arg.create.createmode = NFS3_CREATE_UNCHECKED;
359 break;
360
361 case NFS3_CREATE_UNCHECKED:
362 goto out;
363 }
364 nfs_fattr_init(data->res.dir_attr);
365 nfs_fattr_init(data->res.fattr);
366 }
367
368 if (status != 0)
369 goto out;
370
371
372
373 if (data->arg.create.createmode == NFS3_CREATE_EXCLUSIVE) {
374 dprintk("NFS call setattr (post-create)\n");
375
376 if (!(sattr->ia_valid & ATTR_ATIME_SET))
377 sattr->ia_valid |= ATTR_ATIME;
378 if (!(sattr->ia_valid & ATTR_MTIME_SET))
379 sattr->ia_valid |= ATTR_MTIME;
380
381
382
383
384 status = nfs3_proc_setattr(dentry, data->res.fattr, sattr);
385 nfs_post_op_update_inode(dentry->d_inode, data->res.fattr);
386 dprintk("NFS reply setattr (post-create): %d\n", status);
387 if (status != 0)
388 goto out;
389 }
390 status = nfs3_proc_set_default_acl(dir, dentry->d_inode, mode);
391out:
392 nfs3_free_createdata(data);
393 dprintk("NFS reply create: %d\n", status);
394 return status;
395}
396
397static int
398nfs3_proc_remove(struct inode *dir, struct qstr *name)
399{
400 struct nfs_removeargs arg = {
401 .fh = NFS_FH(dir),
402 .name = *name,
403 };
404 struct nfs_removeres res;
405 struct rpc_message msg = {
406 .rpc_proc = &nfs3_procedures[NFS3PROC_REMOVE],
407 .rpc_argp = &arg,
408 .rpc_resp = &res,
409 };
410 int status = -ENOMEM;
411
412 dprintk("NFS call remove %s\n", name->name);
413 res.dir_attr = nfs_alloc_fattr();
414 if (res.dir_attr == NULL)
415 goto out;
416
417 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
418 nfs_post_op_update_inode(dir, res.dir_attr);
419 nfs_free_fattr(res.dir_attr);
420out:
421 dprintk("NFS reply remove: %d\n", status);
422 return status;
423}
424
425static void
426nfs3_proc_unlink_setup(struct rpc_message *msg, struct inode *dir)
427{
428 msg->rpc_proc = &nfs3_procedures[NFS3PROC_REMOVE];
429}
430
431static void nfs3_proc_unlink_rpc_prepare(struct rpc_task *task, struct nfs_unlinkdata *data)
432{
433 rpc_call_start(task);
434}
435
436static int
437nfs3_proc_unlink_done(struct rpc_task *task, struct inode *dir)
438{
439 struct nfs_removeres *res;
440 if (nfs3_async_handle_jukebox(task, dir))
441 return 0;
442 res = task->tk_msg.rpc_resp;
443 nfs_post_op_update_inode(dir, res->dir_attr);
444 return 1;
445}
446
447static void
448nfs3_proc_rename_setup(struct rpc_message *msg, struct inode *dir)
449{
450 msg->rpc_proc = &nfs3_procedures[NFS3PROC_RENAME];
451}
452
453static void nfs3_proc_rename_rpc_prepare(struct rpc_task *task, struct nfs_renamedata *data)
454{
455 rpc_call_start(task);
456}
457
458static int
459nfs3_proc_rename_done(struct rpc_task *task, struct inode *old_dir,
460 struct inode *new_dir)
461{
462 struct nfs_renameres *res;
463
464 if (nfs3_async_handle_jukebox(task, old_dir))
465 return 0;
466 res = task->tk_msg.rpc_resp;
467
468 nfs_post_op_update_inode(old_dir, res->old_fattr);
469 nfs_post_op_update_inode(new_dir, res->new_fattr);
470 return 1;
471}
472
473static int
474nfs3_proc_rename(struct inode *old_dir, struct qstr *old_name,
475 struct inode *new_dir, struct qstr *new_name)
476{
477 struct nfs_renameargs arg = {
478 .old_dir = NFS_FH(old_dir),
479 .old_name = old_name,
480 .new_dir = NFS_FH(new_dir),
481 .new_name = new_name,
482 };
483 struct nfs_renameres res;
484 struct rpc_message msg = {
485 .rpc_proc = &nfs3_procedures[NFS3PROC_RENAME],
486 .rpc_argp = &arg,
487 .rpc_resp = &res,
488 };
489 int status = -ENOMEM;
490
491 dprintk("NFS call rename %s -> %s\n", old_name->name, new_name->name);
492
493 res.old_fattr = nfs_alloc_fattr();
494 res.new_fattr = nfs_alloc_fattr();
495 if (res.old_fattr == NULL || res.new_fattr == NULL)
496 goto out;
497
498 status = rpc_call_sync(NFS_CLIENT(old_dir), &msg, 0);
499 nfs_post_op_update_inode(old_dir, res.old_fattr);
500 nfs_post_op_update_inode(new_dir, res.new_fattr);
501out:
502 nfs_free_fattr(res.old_fattr);
503 nfs_free_fattr(res.new_fattr);
504 dprintk("NFS reply rename: %d\n", status);
505 return status;
506}
507
508static int
509nfs3_proc_link(struct inode *inode, struct inode *dir, struct qstr *name)
510{
511 struct nfs3_linkargs arg = {
512 .fromfh = NFS_FH(inode),
513 .tofh = NFS_FH(dir),
514 .toname = name->name,
515 .tolen = name->len
516 };
517 struct nfs3_linkres res;
518 struct rpc_message msg = {
519 .rpc_proc = &nfs3_procedures[NFS3PROC_LINK],
520 .rpc_argp = &arg,
521 .rpc_resp = &res,
522 };
523 int status = -ENOMEM;
524
525 dprintk("NFS call link %s\n", name->name);
526 res.fattr = nfs_alloc_fattr();
527 res.dir_attr = nfs_alloc_fattr();
528 if (res.fattr == NULL || res.dir_attr == NULL)
529 goto out;
530
531 status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
532 nfs_post_op_update_inode(dir, res.dir_attr);
533 nfs_post_op_update_inode(inode, res.fattr);
534out:
535 nfs_free_fattr(res.dir_attr);
536 nfs_free_fattr(res.fattr);
537 dprintk("NFS reply link: %d\n", status);
538 return status;
539}
540
541static int
542nfs3_proc_symlink(struct inode *dir, struct dentry *dentry, struct page *page,
543 unsigned int len, struct iattr *sattr)
544{
545 struct nfs3_createdata *data;
546 int status = -ENOMEM;
547
548 if (len > NFS3_MAXPATHLEN)
549 return -ENAMETOOLONG;
550
551 dprintk("NFS call symlink %s\n", dentry->d_name.name);
552
553 data = nfs3_alloc_createdata();
554 if (data == NULL)
555 goto out;
556 data->msg.rpc_proc = &nfs3_procedures[NFS3PROC_SYMLINK];
557 data->arg.symlink.fromfh = NFS_FH(dir);
558 data->arg.symlink.fromname = dentry->d_name.name;
559 data->arg.symlink.fromlen = dentry->d_name.len;
560 data->arg.symlink.pages = &page;
561 data->arg.symlink.pathlen = len;
562 data->arg.symlink.sattr = sattr;
563
564 status = nfs3_do_create(dir, dentry, data);
565
566 nfs3_free_createdata(data);
567out:
568 dprintk("NFS reply symlink: %d\n", status);
569 return status;
570}
571
572static int
573nfs3_proc_mkdir(struct inode *dir, struct dentry *dentry, struct iattr *sattr)
574{
575 struct nfs3_createdata *data;
576 umode_t mode = sattr->ia_mode;
577 int status = -ENOMEM;
578
579 dprintk("NFS call mkdir %s\n", dentry->d_name.name);
580
581 sattr->ia_mode &= ~current_umask();
582
583 data = nfs3_alloc_createdata();
584 if (data == NULL)
585 goto out;
586
587 data->msg.rpc_proc = &nfs3_procedures[NFS3PROC_MKDIR];
588 data->arg.mkdir.fh = NFS_FH(dir);
589 data->arg.mkdir.name = dentry->d_name.name;
590 data->arg.mkdir.len = dentry->d_name.len;
591 data->arg.mkdir.sattr = sattr;
592
593 status = nfs3_do_create(dir, dentry, data);
594 if (status != 0)
595 goto out;
596
597 status = nfs3_proc_set_default_acl(dir, dentry->d_inode, mode);
598out:
599 nfs3_free_createdata(data);
600 dprintk("NFS reply mkdir: %d\n", status);
601 return status;
602}
603
604static int
605nfs3_proc_rmdir(struct inode *dir, struct qstr *name)
606{
607 struct nfs_fattr *dir_attr;
608 struct nfs3_diropargs arg = {
609 .fh = NFS_FH(dir),
610 .name = name->name,
611 .len = name->len
612 };
613 struct rpc_message msg = {
614 .rpc_proc = &nfs3_procedures[NFS3PROC_RMDIR],
615 .rpc_argp = &arg,
616 };
617 int status = -ENOMEM;
618
619 dprintk("NFS call rmdir %s\n", name->name);
620 dir_attr = nfs_alloc_fattr();
621 if (dir_attr == NULL)
622 goto out;
623
624 msg.rpc_resp = dir_attr;
625 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
626 nfs_post_op_update_inode(dir, dir_attr);
627 nfs_free_fattr(dir_attr);
628out:
629 dprintk("NFS reply rmdir: %d\n", status);
630 return status;
631}
632
633
634
635
636
637
638
639
640
641
642static int
643nfs3_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
644 u64 cookie, struct page **pages, unsigned int count, int plus)
645{
646 struct inode *dir = dentry->d_inode;
647 __be32 *verf = NFS_I(dir)->cookieverf;
648 struct nfs3_readdirargs arg = {
649 .fh = NFS_FH(dir),
650 .cookie = cookie,
651 .verf = {verf[0], verf[1]},
652 .plus = plus,
653 .count = count,
654 .pages = pages
655 };
656 struct nfs3_readdirres res = {
657 .verf = verf,
658 .plus = plus
659 };
660 struct rpc_message msg = {
661 .rpc_proc = &nfs3_procedures[NFS3PROC_READDIR],
662 .rpc_argp = &arg,
663 .rpc_resp = &res,
664 .rpc_cred = cred
665 };
666 int status = -ENOMEM;
667
668 if (plus)
669 msg.rpc_proc = &nfs3_procedures[NFS3PROC_READDIRPLUS];
670
671 dprintk("NFS call readdir%s %d\n",
672 plus? "plus" : "", (unsigned int) cookie);
673
674 res.dir_attr = nfs_alloc_fattr();
675 if (res.dir_attr == NULL)
676 goto out;
677
678 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
679
680 nfs_invalidate_atime(dir);
681 nfs_refresh_inode(dir, res.dir_attr);
682
683 nfs_free_fattr(res.dir_attr);
684out:
685 dprintk("NFS reply readdir%s: %d\n",
686 plus? "plus" : "", status);
687 return status;
688}
689
690static int
691nfs3_proc_mknod(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
692 dev_t rdev)
693{
694 struct nfs3_createdata *data;
695 umode_t mode = sattr->ia_mode;
696 int status = -ENOMEM;
697
698 dprintk("NFS call mknod %s %u:%u\n", dentry->d_name.name,
699 MAJOR(rdev), MINOR(rdev));
700
701 sattr->ia_mode &= ~current_umask();
702
703 data = nfs3_alloc_createdata();
704 if (data == NULL)
705 goto out;
706
707 data->msg.rpc_proc = &nfs3_procedures[NFS3PROC_MKNOD];
708 data->arg.mknod.fh = NFS_FH(dir);
709 data->arg.mknod.name = dentry->d_name.name;
710 data->arg.mknod.len = dentry->d_name.len;
711 data->arg.mknod.sattr = sattr;
712 data->arg.mknod.rdev = rdev;
713
714 switch (sattr->ia_mode & S_IFMT) {
715 case S_IFBLK:
716 data->arg.mknod.type = NF3BLK;
717 break;
718 case S_IFCHR:
719 data->arg.mknod.type = NF3CHR;
720 break;
721 case S_IFIFO:
722 data->arg.mknod.type = NF3FIFO;
723 break;
724 case S_IFSOCK:
725 data->arg.mknod.type = NF3SOCK;
726 break;
727 default:
728 status = -EINVAL;
729 goto out;
730 }
731
732 status = nfs3_do_create(dir, dentry, data);
733 if (status != 0)
734 goto out;
735 status = nfs3_proc_set_default_acl(dir, dentry->d_inode, mode);
736out:
737 nfs3_free_createdata(data);
738 dprintk("NFS reply mknod: %d\n", status);
739 return status;
740}
741
742static int
743nfs3_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle,
744 struct nfs_fsstat *stat)
745{
746 struct rpc_message msg = {
747 .rpc_proc = &nfs3_procedures[NFS3PROC_FSSTAT],
748 .rpc_argp = fhandle,
749 .rpc_resp = stat,
750 };
751 int status;
752
753 dprintk("NFS call fsstat\n");
754 nfs_fattr_init(stat->fattr);
755 status = rpc_call_sync(server->client, &msg, 0);
756 dprintk("NFS reply fsstat: %d\n", status);
757 return status;
758}
759
760static int
761do_proc_fsinfo(struct rpc_clnt *client, struct nfs_fh *fhandle,
762 struct nfs_fsinfo *info)
763{
764 struct rpc_message msg = {
765 .rpc_proc = &nfs3_procedures[NFS3PROC_FSINFO],
766 .rpc_argp = fhandle,
767 .rpc_resp = info,
768 };
769 int status;
770
771 dprintk("NFS call fsinfo\n");
772 nfs_fattr_init(info->fattr);
773 status = rpc_call_sync(client, &msg, 0);
774 dprintk("NFS reply fsinfo: %d\n", status);
775 return status;
776}
777
778
779
780
781
782static int
783nfs3_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle,
784 struct nfs_fsinfo *info)
785{
786 int status;
787
788 status = do_proc_fsinfo(server->client, fhandle, info);
789 if (status && server->nfs_client->cl_rpcclient != server->client)
790 status = do_proc_fsinfo(server->nfs_client->cl_rpcclient, fhandle, info);
791 return status;
792}
793
794static int
795nfs3_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
796 struct nfs_pathconf *info)
797{
798 struct rpc_message msg = {
799 .rpc_proc = &nfs3_procedures[NFS3PROC_PATHCONF],
800 .rpc_argp = fhandle,
801 .rpc_resp = info,
802 };
803 int status;
804
805 dprintk("NFS call pathconf\n");
806 nfs_fattr_init(info->fattr);
807 status = rpc_call_sync(server->client, &msg, 0);
808 dprintk("NFS reply pathconf: %d\n", status);
809 return status;
810}
811
812static int nfs3_read_done(struct rpc_task *task, struct nfs_read_data *data)
813{
814 struct inode *inode = data->header->inode;
815
816 if (nfs3_async_handle_jukebox(task, inode))
817 return -EAGAIN;
818
819 nfs_invalidate_atime(inode);
820 nfs_refresh_inode(inode, &data->fattr);
821 return 0;
822}
823
824static void nfs3_proc_read_setup(struct nfs_read_data *data, struct rpc_message *msg)
825{
826 msg->rpc_proc = &nfs3_procedures[NFS3PROC_READ];
827}
828
829static void nfs3_proc_read_rpc_prepare(struct rpc_task *task, struct nfs_read_data *data)
830{
831 rpc_call_start(task);
832}
833
834static int nfs3_write_done(struct rpc_task *task, struct nfs_write_data *data)
835{
836 struct inode *inode = data->header->inode;
837
838 if (nfs3_async_handle_jukebox(task, inode))
839 return -EAGAIN;
840 if (task->tk_status >= 0)
841 nfs_post_op_update_inode_force_wcc(inode, data->res.fattr);
842 return 0;
843}
844
845static void nfs3_proc_write_setup(struct nfs_write_data *data, struct rpc_message *msg)
846{
847 msg->rpc_proc = &nfs3_procedures[NFS3PROC_WRITE];
848}
849
850static void nfs3_proc_write_rpc_prepare(struct rpc_task *task, struct nfs_write_data *data)
851{
852 rpc_call_start(task);
853}
854
855static void nfs3_proc_commit_rpc_prepare(struct rpc_task *task, struct nfs_commit_data *data)
856{
857 rpc_call_start(task);
858}
859
860static int nfs3_commit_done(struct rpc_task *task, struct nfs_commit_data *data)
861{
862 if (nfs3_async_handle_jukebox(task, data->inode))
863 return -EAGAIN;
864 nfs_refresh_inode(data->inode, data->res.fattr);
865 return 0;
866}
867
868static void nfs3_proc_commit_setup(struct nfs_commit_data *data, struct rpc_message *msg)
869{
870 msg->rpc_proc = &nfs3_procedures[NFS3PROC_COMMIT];
871}
872
873static int
874nfs3_proc_lock(struct file *filp, int cmd, struct file_lock *fl)
875{
876 struct inode *inode = file_inode(filp);
877
878 return nlmclnt_proc(NFS_SERVER(inode)->nlm_host, cmd, fl);
879}
880
881static int nfs3_have_delegation(struct inode *inode, fmode_t flags)
882{
883 return 0;
884}
885
886static int nfs3_return_delegation(struct inode *inode)
887{
888 nfs_wb_all(inode);
889 return 0;
890}
891
892static const struct inode_operations nfs3_dir_inode_operations = {
893 .create = nfs_create,
894 .lookup = nfs_lookup,
895 .link = nfs_link,
896 .unlink = nfs_unlink,
897 .symlink = nfs_symlink,
898 .mkdir = nfs_mkdir,
899 .rmdir = nfs_rmdir,
900 .mknod = nfs_mknod,
901 .rename = nfs_rename,
902 .permission = nfs_permission,
903 .getattr = nfs_getattr,
904 .setattr = nfs_setattr,
905 .listxattr = nfs3_listxattr,
906 .getxattr = nfs3_getxattr,
907 .setxattr = nfs3_setxattr,
908 .removexattr = nfs3_removexattr,
909};
910
911static const struct inode_operations nfs3_file_inode_operations = {
912 .permission = nfs_permission,
913 .getattr = nfs_getattr,
914 .setattr = nfs_setattr,
915 .listxattr = nfs3_listxattr,
916 .getxattr = nfs3_getxattr,
917 .setxattr = nfs3_setxattr,
918 .removexattr = nfs3_removexattr,
919};
920
921const struct nfs_rpc_ops nfs_v3_clientops = {
922 .version = 3,
923 .dentry_ops = &nfs_dentry_operations,
924 .dir_inode_ops = &nfs3_dir_inode_operations,
925 .file_inode_ops = &nfs3_file_inode_operations,
926 .file_ops = &nfs_file_operations,
927 .getroot = nfs3_proc_get_root,
928 .submount = nfs_submount,
929 .try_mount = nfs_try_mount,
930 .getattr = nfs3_proc_getattr,
931 .setattr = nfs3_proc_setattr,
932 .lookup = nfs3_proc_lookup,
933 .access = nfs3_proc_access,
934 .readlink = nfs3_proc_readlink,
935 .create = nfs3_proc_create,
936 .remove = nfs3_proc_remove,
937 .unlink_setup = nfs3_proc_unlink_setup,
938 .unlink_rpc_prepare = nfs3_proc_unlink_rpc_prepare,
939 .unlink_done = nfs3_proc_unlink_done,
940 .rename = nfs3_proc_rename,
941 .rename_setup = nfs3_proc_rename_setup,
942 .rename_rpc_prepare = nfs3_proc_rename_rpc_prepare,
943 .rename_done = nfs3_proc_rename_done,
944 .link = nfs3_proc_link,
945 .symlink = nfs3_proc_symlink,
946 .mkdir = nfs3_proc_mkdir,
947 .rmdir = nfs3_proc_rmdir,
948 .readdir = nfs3_proc_readdir,
949 .mknod = nfs3_proc_mknod,
950 .statfs = nfs3_proc_statfs,
951 .fsinfo = nfs3_proc_fsinfo,
952 .pathconf = nfs3_proc_pathconf,
953 .decode_dirent = nfs3_decode_dirent,
954 .read_setup = nfs3_proc_read_setup,
955 .read_pageio_init = nfs_pageio_init_read,
956 .read_rpc_prepare = nfs3_proc_read_rpc_prepare,
957 .read_done = nfs3_read_done,
958 .write_setup = nfs3_proc_write_setup,
959 .write_pageio_init = nfs_pageio_init_write,
960 .write_rpc_prepare = nfs3_proc_write_rpc_prepare,
961 .write_done = nfs3_write_done,
962 .commit_setup = nfs3_proc_commit_setup,
963 .commit_rpc_prepare = nfs3_proc_commit_rpc_prepare,
964 .commit_done = nfs3_commit_done,
965 .lock = nfs3_proc_lock,
966 .clear_acl_cache = nfs3_forget_cached_acls,
967 .close_context = nfs_close_context,
968 .have_delegation = nfs3_have_delegation,
969 .return_delegation = nfs3_return_delegation,
970 .alloc_client = nfs_alloc_client,
971 .init_client = nfs_init_client,
972 .free_client = nfs_free_client,
973 .create_server = nfs3_create_server,
974 .clone_server = nfs3_clone_server,
975};
976
