?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
uml: ptrace floating point fixes
[wrt350n-kernel.git] / fs / nfs / nfs3proc.c
blob4cdc2361a669bed2347d599f027cc10e57c9d7dc
1 /*
2 * linux/fs/nfs/nfs3proc.c
3 *
4 * Client-side NFSv3 procedures stubs.
5 *
6 * Copyright (C) 1997, Olaf Kirch
7 */
8
9 #include <linux/mm.h>
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>
20
21 #include "iostat.h"
22 #include "internal.h"
23
24 #define NFSDBG_FACILITY NFSDBG_PROC
25
26 /* A wrapper to handle the EJUKEBOX error message */
27 static int
28 nfs3_rpc_wrapper(struct rpc_clnt *clnt, struct rpc_message *msg, int flags)
29 {
30 sigset_t oldset;
31 int res;
32 rpc_clnt_sigmask(clnt, &oldset);
33 do {
34 res = rpc_call_sync(clnt, msg, flags);
35 if (res != -EJUKEBOX)
36 break;
37 schedule_timeout_interruptible(NFS_JUKEBOX_RETRY_TIME);
38 res = -ERESTARTSYS;
39 } while (!signalled());
40 rpc_clnt_sigunmask(clnt, &oldset);
41 return res;
42 }
43
44 #define rpc_call_sync(clnt, msg, flags) nfs3_rpc_wrapper(clnt, msg, flags)
45
46 static int
47 nfs3_async_handle_jukebox(struct rpc_task *task, struct inode *inode)
48 {
49 if (task->tk_status != -EJUKEBOX)
50 return 0;
51 nfs_inc_stats(inode, NFSIOS_DELAY);
52 task->tk_status = 0;
53 rpc_restart_call(task);
54 rpc_delay(task, NFS_JUKEBOX_RETRY_TIME);
55 return 1;
56 }
57
58 static int
59 do_proc_get_root(struct rpc_clnt *client, struct nfs_fh *fhandle,
60 struct nfs_fsinfo *info)
61 {
62 struct rpc_message msg = {
63 .rpc_proc = &nfs3_procedures[NFS3PROC_FSINFO],
64 .rpc_argp = fhandle,
65 .rpc_resp = info,
66 };
67 int status;
68
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);
78 }
79 return status;
80 }
81
82 /*
83 * Bare-bones access to getattr: this is for nfs_get_root/nfs_get_sb
84 */
85 static int
86 nfs3_proc_get_root(struct nfs_server *server, struct nfs_fh *fhandle,
87 struct nfs_fsinfo *info)
88 {
89 int status;
90
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);
94 return status;
95 }
96
97 /*
98 * One function for each procedure in the NFS protocol.
99 */
100 static int
101 nfs3_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
102 struct nfs_fattr *fattr)
103 {
104 struct rpc_message msg = {
105 .rpc_proc = &nfs3_procedures[NFS3PROC_GETATTR],
106 .rpc_argp = fhandle,
107 .rpc_resp = fattr,
108 };
109 int status;
110
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);
115 return status;
116 }
117
118 static int
119 nfs3_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
120 struct iattr *sattr)
121 {
122 struct inode *inode = dentry->d_inode;
123 struct nfs3_sattrargs arg = {
124 .fh = NFS_FH(inode),
125 .sattr = sattr,
126 };
127 struct rpc_message msg = {
128 .rpc_proc = &nfs3_procedures[NFS3PROC_SETATTR],
129 .rpc_argp = &arg,
130 .rpc_resp = fattr,
131 };
132 int status;
133
134 dprintk("NFS call setattr\n");
135 nfs_fattr_init(fattr);
136 status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
137 if (status == 0)
138 nfs_setattr_update_inode(inode, sattr);
139 dprintk("NFS reply setattr: %d\n", status);
140 return status;
141 }
142
143 static int
144 nfs3_proc_lookup(struct inode *dir, struct qstr *name,
145 struct nfs_fh *fhandle, struct nfs_fattr *fattr)
146 {
147 struct nfs_fattr dir_attr;
148 struct nfs3_diropargs arg = {
149 .fh = NFS_FH(dir),
150 .name = name->name,
151 .len = name->len
152 };
153 struct nfs3_diropres res = {
154 .dir_attr = &dir_attr,
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 nfs_fattr_init(&dir_attr);
167 nfs_fattr_init(fattr);
168 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
169 nfs_refresh_inode(dir, &dir_attr);
170 if (status >= 0 && !(fattr->valid & NFS_ATTR_FATTR)) {
171 msg.rpc_proc = &nfs3_procedures[NFS3PROC_GETATTR];
172 msg.rpc_argp = fhandle;
173 msg.rpc_resp = fattr;
174 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
175 }
176 dprintk("NFS reply lookup: %d\n", status);
177 return status;
178 }
179
180 static int nfs3_proc_access(struct inode *inode, struct nfs_access_entry *entry)
181 {
182 struct nfs_fattr fattr;
183 struct nfs3_accessargs arg = {
184 .fh = NFS_FH(inode),
185 };
186 struct nfs3_accessres res = {
187 .fattr = &fattr,
188 };
189 struct rpc_message msg = {
190 .rpc_proc = &nfs3_procedures[NFS3PROC_ACCESS],
191 .rpc_argp = &arg,
192 .rpc_resp = &res,
193 .rpc_cred = entry->cred,
194 };
195 int mode = entry->mask;
196 int status;
197
198 dprintk("NFS call access\n");
199
200 if (mode & MAY_READ)
201 arg.access |= NFS3_ACCESS_READ;
202 if (S_ISDIR(inode->i_mode)) {
203 if (mode & MAY_WRITE)
204 arg.access |= NFS3_ACCESS_MODIFY | NFS3_ACCESS_EXTEND | NFS3_ACCESS_DELETE;
205 if (mode & MAY_EXEC)
206 arg.access |= NFS3_ACCESS_LOOKUP;
207 } else {
208 if (mode & MAY_WRITE)
209 arg.access |= NFS3_ACCESS_MODIFY | NFS3_ACCESS_EXTEND;
210 if (mode & MAY_EXEC)
211 arg.access |= NFS3_ACCESS_EXECUTE;
212 }
213 nfs_fattr_init(&fattr);
214 status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
215 nfs_refresh_inode(inode, &fattr);
216 if (status == 0) {
217 entry->mask = 0;
218 if (res.access & NFS3_ACCESS_READ)
219 entry->mask |= MAY_READ;
220 if (res.access & (NFS3_ACCESS_MODIFY | NFS3_ACCESS_EXTEND | NFS3_ACCESS_DELETE))
221 entry->mask |= MAY_WRITE;
222 if (res.access & (NFS3_ACCESS_LOOKUP|NFS3_ACCESS_EXECUTE))
223 entry->mask |= MAY_EXEC;
224 }
225 dprintk("NFS reply access: %d\n", status);
226 return status;
227 }
228
229 static int nfs3_proc_readlink(struct inode *inode, struct page *page,
230 unsigned int pgbase, unsigned int pglen)
231 {
232 struct nfs_fattr fattr;
233 struct nfs3_readlinkargs args = {
234 .fh = NFS_FH(inode),
235 .pgbase = pgbase,
236 .pglen = pglen,
237 .pages = &page
238 };
239 struct rpc_message msg = {
240 .rpc_proc = &nfs3_procedures[NFS3PROC_READLINK],
241 .rpc_argp = &args,
242 .rpc_resp = &fattr,
243 };
244 int status;
245
246 dprintk("NFS call readlink\n");
247 nfs_fattr_init(&fattr);
248 status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
249 nfs_refresh_inode(inode, &fattr);
250 dprintk("NFS reply readlink: %d\n", status);
251 return status;
252 }
253
254 /*
255 * Create a regular file.
256 * For now, we don't implement O_EXCL.
257 */
258 static int
259 nfs3_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
260 int flags, struct nameidata *nd)
261 {
262 struct nfs_fh fhandle;
263 struct nfs_fattr fattr;
264 struct nfs_fattr dir_attr;
265 struct nfs3_createargs arg = {
266 .fh = NFS_FH(dir),
267 .name = dentry->d_name.name,
268 .len = dentry->d_name.len,
269 .sattr = sattr,
270 };
271 struct nfs3_diropres res = {
272 .dir_attr = &dir_attr,
273 .fh = &fhandle,
274 .fattr = &fattr
275 };
276 struct rpc_message msg = {
277 .rpc_proc = &nfs3_procedures[NFS3PROC_CREATE],
278 .rpc_argp = &arg,
279 .rpc_resp = &res,
280 };
281 mode_t mode = sattr->ia_mode;
282 int status;
283
284 dprintk("NFS call create %s\n", dentry->d_name.name);
285 arg.createmode = NFS3_CREATE_UNCHECKED;
286 if (flags & O_EXCL) {
287 arg.createmode = NFS3_CREATE_EXCLUSIVE;
288 arg.verifier[0] = jiffies;
289 arg.verifier[1] = current->pid;
290 }
291
292 sattr->ia_mode &= ~current->fs->umask;
293
294 again:
295 nfs_fattr_init(&dir_attr);
296 nfs_fattr_init(&fattr);
297 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
298 nfs_refresh_inode(dir, &dir_attr);
299
300 /* If the server doesn't support the exclusive creation semantics,
301 * try again with simple 'guarded' mode. */
302 if (status == -ENOTSUPP) {
303 switch (arg.createmode) {
304 case NFS3_CREATE_EXCLUSIVE:
305 arg.createmode = NFS3_CREATE_GUARDED;
306 break;
307
308 case NFS3_CREATE_GUARDED:
309 arg.createmode = NFS3_CREATE_UNCHECKED;
310 break;
311
312 case NFS3_CREATE_UNCHECKED:
313 goto out;
314 }
315 goto again;
316 }
317
318 if (status == 0)
319 status = nfs_instantiate(dentry, &fhandle, &fattr);
320 if (status != 0)
321 goto out;
322
323 /* When we created the file with exclusive semantics, make
324 * sure we set the attributes afterwards. */
325 if (arg.createmode == NFS3_CREATE_EXCLUSIVE) {
326 dprintk("NFS call setattr (post-create)\n");
327
328 if (!(sattr->ia_valid & ATTR_ATIME_SET))
329 sattr->ia_valid |= ATTR_ATIME;
330 if (!(sattr->ia_valid & ATTR_MTIME_SET))
331 sattr->ia_valid |= ATTR_MTIME;
332
333 /* Note: we could use a guarded setattr here, but I'm
334 * not sure this buys us anything (and I'd have
335 * to revamp the NFSv3 XDR code) */
336 status = nfs3_proc_setattr(dentry, &fattr, sattr);
337 nfs_post_op_update_inode(dentry->d_inode, &fattr);
338 dprintk("NFS reply setattr (post-create): %d\n", status);
339 }
340 if (status != 0)
341 goto out;
342 status = nfs3_proc_set_default_acl(dir, dentry->d_inode, mode);
343 out:
344 dprintk("NFS reply create: %d\n", status);
345 return status;
346 }
347
348 static int
349 nfs3_proc_remove(struct inode *dir, struct qstr *name)
350 {
351 struct nfs_removeargs arg = {
352 .fh = NFS_FH(dir),
353 .name.len = name->len,
354 .name.name = name->name,
355 };
356 struct nfs_removeres res;
357 struct rpc_message msg = {
358 .rpc_proc = &nfs3_procedures[NFS3PROC_REMOVE],
359 .rpc_argp = &arg,
360 .rpc_resp = &res,
361 };
362 int status;
363
364 dprintk("NFS call remove %s\n", name->name);
365 nfs_fattr_init(&res.dir_attr);
366 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
367 nfs_post_op_update_inode(dir, &res.dir_attr);
368 dprintk("NFS reply remove: %d\n", status);
369 return status;
370 }
371
372 static void
373 nfs3_proc_unlink_setup(struct rpc_message *msg, struct inode *dir)
374 {
375 msg->rpc_proc = &nfs3_procedures[NFS3PROC_REMOVE];
376 }
377
378 static int
379 nfs3_proc_unlink_done(struct rpc_task *task, struct inode *dir)
380 {
381 struct nfs_removeres *res;
382 if (nfs3_async_handle_jukebox(task, dir))
383 return 0;
384 res = task->tk_msg.rpc_resp;
385 nfs_post_op_update_inode(dir, &res->dir_attr);
386 return 1;
387 }
388
389 static int
390 nfs3_proc_rename(struct inode *old_dir, struct qstr *old_name,
391 struct inode *new_dir, struct qstr *new_name)
392 {
393 struct nfs_fattr old_dir_attr, new_dir_attr;
394 struct nfs3_renameargs arg = {
395 .fromfh = NFS_FH(old_dir),
396 .fromname = old_name->name,
397 .fromlen = old_name->len,
398 .tofh = NFS_FH(new_dir),
399 .toname = new_name->name,
400 .tolen = new_name->len
401 };
402 struct nfs3_renameres res = {
403 .fromattr = &old_dir_attr,
404 .toattr = &new_dir_attr
405 };
406 struct rpc_message msg = {
407 .rpc_proc = &nfs3_procedures[NFS3PROC_RENAME],
408 .rpc_argp = &arg,
409 .rpc_resp = &res,
410 };
411 int status;
412
413 dprintk("NFS call rename %s -> %s\n", old_name->name, new_name->name);
414 nfs_fattr_init(&old_dir_attr);
415 nfs_fattr_init(&new_dir_attr);
416 status = rpc_call_sync(NFS_CLIENT(old_dir), &msg, 0);
417 nfs_post_op_update_inode(old_dir, &old_dir_attr);
418 nfs_post_op_update_inode(new_dir, &new_dir_attr);
419 dprintk("NFS reply rename: %d\n", status);
420 return status;
421 }
422
423 static int
424 nfs3_proc_link(struct inode *inode, struct inode *dir, struct qstr *name)
425 {
426 struct nfs_fattr dir_attr, fattr;
427 struct nfs3_linkargs arg = {
428 .fromfh = NFS_FH(inode),
429 .tofh = NFS_FH(dir),
430 .toname = name->name,
431 .tolen = name->len
432 };
433 struct nfs3_linkres res = {
434 .dir_attr = &dir_attr,
435 .fattr = &fattr
436 };
437 struct rpc_message msg = {
438 .rpc_proc = &nfs3_procedures[NFS3PROC_LINK],
439 .rpc_argp = &arg,
440 .rpc_resp = &res,
441 };
442 int status;
443
444 dprintk("NFS call link %s\n", name->name);
445 nfs_fattr_init(&dir_attr);
446 nfs_fattr_init(&fattr);
447 status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
448 nfs_post_op_update_inode(dir, &dir_attr);
449 nfs_post_op_update_inode(inode, &fattr);
450 dprintk("NFS reply link: %d\n", status);
451 return status;
452 }
453
454 static int
455 nfs3_proc_symlink(struct inode *dir, struct dentry *dentry, struct page *page,
456 unsigned int len, struct iattr *sattr)
457 {
458 struct nfs_fh fhandle;
459 struct nfs_fattr fattr, dir_attr;
460 struct nfs3_symlinkargs arg = {
461 .fromfh = NFS_FH(dir),
462 .fromname = dentry->d_name.name,
463 .fromlen = dentry->d_name.len,
464 .pages = &page,
465 .pathlen = len,
466 .sattr = sattr
467 };
468 struct nfs3_diropres res = {
469 .dir_attr = &dir_attr,
470 .fh = &fhandle,
471 .fattr = &fattr
472 };
473 struct rpc_message msg = {
474 .rpc_proc = &nfs3_procedures[NFS3PROC_SYMLINK],
475 .rpc_argp = &arg,
476 .rpc_resp = &res,
477 };
478 int status;
479
480 if (len > NFS3_MAXPATHLEN)
481 return -ENAMETOOLONG;
482
483 dprintk("NFS call symlink %s\n", dentry->d_name.name);
484
485 nfs_fattr_init(&dir_attr);
486 nfs_fattr_init(&fattr);
487 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
488 nfs_post_op_update_inode(dir, &dir_attr);
489 if (status != 0)
490 goto out;
491 status = nfs_instantiate(dentry, &fhandle, &fattr);
492 out:
493 dprintk("NFS reply symlink: %d\n", status);
494 return status;
495 }
496
497 static int
498 nfs3_proc_mkdir(struct inode *dir, struct dentry *dentry, struct iattr *sattr)
499 {
500 struct nfs_fh fhandle;
501 struct nfs_fattr fattr, dir_attr;
502 struct nfs3_mkdirargs arg = {
503 .fh = NFS_FH(dir),
504 .name = dentry->d_name.name,
505 .len = dentry->d_name.len,
506 .sattr = sattr
507 };
508 struct nfs3_diropres res = {
509 .dir_attr = &dir_attr,
510 .fh = &fhandle,
511 .fattr = &fattr
512 };
513 struct rpc_message msg = {
514 .rpc_proc = &nfs3_procedures[NFS3PROC_MKDIR],
515 .rpc_argp = &arg,
516 .rpc_resp = &res,
517 };
518 int mode = sattr->ia_mode;
519 int status;
520
521 dprintk("NFS call mkdir %s\n", dentry->d_name.name);
522
523 sattr->ia_mode &= ~current->fs->umask;
524
525 nfs_fattr_init(&dir_attr);
526 nfs_fattr_init(&fattr);
527 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
528 nfs_post_op_update_inode(dir, &dir_attr);
529 if (status != 0)
530 goto out;
531 status = nfs_instantiate(dentry, &fhandle, &fattr);
532 if (status != 0)
533 goto out;
534 status = nfs3_proc_set_default_acl(dir, dentry->d_inode, mode);
535 out:
536 dprintk("NFS reply mkdir: %d\n", status);
537 return status;
538 }
539
540 static int
541 nfs3_proc_rmdir(struct inode *dir, struct qstr *name)
542 {
543 struct nfs_fattr dir_attr;
544 struct nfs3_diropargs arg = {
545 .fh = NFS_FH(dir),
546 .name = name->name,
547 .len = name->len
548 };
549 struct rpc_message msg = {
550 .rpc_proc = &nfs3_procedures[NFS3PROC_RMDIR],
551 .rpc_argp = &arg,
552 .rpc_resp = &dir_attr,
553 };
554 int status;
555
556 dprintk("NFS call rmdir %s\n", name->name);
557 nfs_fattr_init(&dir_attr);
558 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
559 nfs_post_op_update_inode(dir, &dir_attr);
560 dprintk("NFS reply rmdir: %d\n", status);
561 return status;
562 }
563
564 /*
565 * The READDIR implementation is somewhat hackish - we pass the user buffer
566 * to the encode function, which installs it in the receive iovec.
567 * The decode function itself doesn't perform any decoding, it just makes
568 * sure the reply is syntactically correct.
569 *
570 * Also note that this implementation handles both plain readdir and
571 * readdirplus.
572 */
573 static int
574 nfs3_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
575 u64 cookie, struct page *page, unsigned int count, int plus)
576 {
577 struct inode *dir = dentry->d_inode;
578 struct nfs_fattr dir_attr;
579 __be32 *verf = NFS_COOKIEVERF(dir);
580 struct nfs3_readdirargs arg = {
581 .fh = NFS_FH(dir),
582 .cookie = cookie,
583 .verf = {verf[0], verf[1]},
584 .plus = plus,
585 .count = count,
586 .pages = &page
587 };
588 struct nfs3_readdirres res = {
589 .dir_attr = &dir_attr,
590 .verf = verf,
591 .plus = plus
592 };
593 struct rpc_message msg = {
594 .rpc_proc = &nfs3_procedures[NFS3PROC_READDIR],
595 .rpc_argp = &arg,
596 .rpc_resp = &res,
597 .rpc_cred = cred
598 };
599 int status;
600
601 if (plus)
602 msg.rpc_proc = &nfs3_procedures[NFS3PROC_READDIRPLUS];
603
604 dprintk("NFS call readdir%s %d\n",
605 plus? "plus" : "", (unsigned int) cookie);
606
607 nfs_fattr_init(&dir_attr);
608 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
609
610 nfs_invalidate_atime(dir);
611
612 nfs_refresh_inode(dir, &dir_attr);
613 dprintk("NFS reply readdir: %d\n", status);
614 return status;
615 }
616
617 static int
618 nfs3_proc_mknod(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
619 dev_t rdev)
620 {
621 struct nfs_fh fh;
622 struct nfs_fattr fattr, dir_attr;
623 struct nfs3_mknodargs arg = {
624 .fh = NFS_FH(dir),
625 .name = dentry->d_name.name,
626 .len = dentry->d_name.len,
627 .sattr = sattr,
628 .rdev = rdev
629 };
630 struct nfs3_diropres res = {
631 .dir_attr = &dir_attr,
632 .fh = &fh,
633 .fattr = &fattr
634 };
635 struct rpc_message msg = {
636 .rpc_proc = &nfs3_procedures[NFS3PROC_MKNOD],
637 .rpc_argp = &arg,
638 .rpc_resp = &res,
639 };
640 mode_t mode = sattr->ia_mode;
641 int status;
642
643 switch (sattr->ia_mode & S_IFMT) {
644 case S_IFBLK: arg.type = NF3BLK; break;
645 case S_IFCHR: arg.type = NF3CHR; break;
646 case S_IFIFO: arg.type = NF3FIFO; break;
647 case S_IFSOCK: arg.type = NF3SOCK; break;
648 default: return -EINVAL;
649 }
650
651 dprintk("NFS call mknod %s %u:%u\n", dentry->d_name.name,
652 MAJOR(rdev), MINOR(rdev));
653
654 sattr->ia_mode &= ~current->fs->umask;
655
656 nfs_fattr_init(&dir_attr);
657 nfs_fattr_init(&fattr);
658 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
659 nfs_post_op_update_inode(dir, &dir_attr);
660 if (status != 0)
661 goto out;
662 status = nfs_instantiate(dentry, &fh, &fattr);
663 if (status != 0)
664 goto out;
665 status = nfs3_proc_set_default_acl(dir, dentry->d_inode, mode);
666 out:
667 dprintk("NFS reply mknod: %d\n", status);
668 return status;
669 }
670
671 static int
672 nfs3_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle,
673 struct nfs_fsstat *stat)
674 {
675 struct rpc_message msg = {
676 .rpc_proc = &nfs3_procedures[NFS3PROC_FSSTAT],
677 .rpc_argp = fhandle,
678 .rpc_resp = stat,
679 };
680 int status;
681
682 dprintk("NFS call fsstat\n");
683 nfs_fattr_init(stat->fattr);
684 status = rpc_call_sync(server->client, &msg, 0);
685 dprintk("NFS reply statfs: %d\n", status);
686 return status;
687 }
688
689 static int
690 nfs3_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle,
691 struct nfs_fsinfo *info)
692 {
693 struct rpc_message msg = {
694 .rpc_proc = &nfs3_procedures[NFS3PROC_FSINFO],
695 .rpc_argp = fhandle,
696 .rpc_resp = info,
697 };
698 int status;
699
700 dprintk("NFS call fsinfo\n");
701 nfs_fattr_init(info->fattr);
702 status = rpc_call_sync(server->nfs_client->cl_rpcclient, &msg, 0);
703 dprintk("NFS reply fsinfo: %d\n", status);
704 return status;
705 }
706
707 static int
708 nfs3_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
709 struct nfs_pathconf *info)
710 {
711 struct rpc_message msg = {
712 .rpc_proc = &nfs3_procedures[NFS3PROC_PATHCONF],
713 .rpc_argp = fhandle,
714 .rpc_resp = info,
715 };
716 int status;
717
718 dprintk("NFS call pathconf\n");
719 nfs_fattr_init(info->fattr);
720 status = rpc_call_sync(server->client, &msg, 0);
721 dprintk("NFS reply pathconf: %d\n", status);
722 return status;
723 }
724
725 static int nfs3_read_done(struct rpc_task *task, struct nfs_read_data *data)
726 {
727 if (nfs3_async_handle_jukebox(task, data->inode))
728 return -EAGAIN;
729
730 nfs_invalidate_atime(data->inode);
731 nfs_refresh_inode(data->inode, &data->fattr);
732 return 0;
733 }
734
735 static void nfs3_proc_read_setup(struct nfs_read_data *data)
736 {
737 struct rpc_message msg = {
738 .rpc_proc = &nfs3_procedures[NFS3PROC_READ],
739 .rpc_argp = &data->args,
740 .rpc_resp = &data->res,
741 .rpc_cred = data->cred,
742 };
743
744 rpc_call_setup(&data->task, &msg, 0);
745 }
746
747 static int nfs3_write_done(struct rpc_task *task, struct nfs_write_data *data)
748 {
749 if (nfs3_async_handle_jukebox(task, data->inode))
750 return -EAGAIN;
751 if (task->tk_status >= 0)
752 nfs_post_op_update_inode_force_wcc(data->inode, data->res.fattr);
753 return 0;
754 }
755
756 static void nfs3_proc_write_setup(struct nfs_write_data *data, int how)
757 {
758 struct rpc_message msg = {
759 .rpc_proc = &nfs3_procedures[NFS3PROC_WRITE],
760 .rpc_argp = &data->args,
761 .rpc_resp = &data->res,
762 .rpc_cred = data->cred,
763 };
764
765 data->args.stable = NFS_UNSTABLE;
766 if (how & FLUSH_STABLE) {
767 data->args.stable = NFS_FILE_SYNC;
768 if (NFS_I(data->inode)->ncommit)
769 data->args.stable = NFS_DATA_SYNC;
770 }
771
772 /* Finalize the task. */
773 rpc_call_setup(&data->task, &msg, 0);
774 }
775
776 static int nfs3_commit_done(struct rpc_task *task, struct nfs_write_data *data)
777 {
778 if (nfs3_async_handle_jukebox(task, data->inode))
779 return -EAGAIN;
780 nfs_refresh_inode(data->inode, data->res.fattr);
781 return 0;
782 }
783
784 static void nfs3_proc_commit_setup(struct nfs_write_data *data, int how)
785 {
786 struct rpc_message msg = {
787 .rpc_proc = &nfs3_procedures[NFS3PROC_COMMIT],
788 .rpc_argp = &data->args,
789 .rpc_resp = &data->res,
790 .rpc_cred = data->cred,
791 };
792
793 rpc_call_setup(&data->task, &msg, 0);
794 }
795
796 static int
797 nfs3_proc_lock(struct file *filp, int cmd, struct file_lock *fl)
798 {
799 return nlmclnt_proc(filp->f_path.dentry->d_inode, cmd, fl);
800 }
801
802 const struct nfs_rpc_ops nfs_v3_clientops = {
803 .version = 3, /* protocol version */
804 .dentry_ops = &nfs_dentry_operations,
805 .dir_inode_ops = &nfs3_dir_inode_operations,
806 .file_inode_ops = &nfs3_file_inode_operations,
807 .getroot = nfs3_proc_get_root,
808 .getattr = nfs3_proc_getattr,
809 .setattr = nfs3_proc_setattr,
810 .lookup = nfs3_proc_lookup,
811 .access = nfs3_proc_access,
812 .readlink = nfs3_proc_readlink,
813 .create = nfs3_proc_create,
814 .remove = nfs3_proc_remove,
815 .unlink_setup = nfs3_proc_unlink_setup,
816 .unlink_done = nfs3_proc_unlink_done,
817 .rename = nfs3_proc_rename,
818 .link = nfs3_proc_link,
819 .symlink = nfs3_proc_symlink,
820 .mkdir = nfs3_proc_mkdir,
821 .rmdir = nfs3_proc_rmdir,
822 .readdir = nfs3_proc_readdir,
823 .mknod = nfs3_proc_mknod,
824 .statfs = nfs3_proc_statfs,
825 .fsinfo = nfs3_proc_fsinfo,
826 .pathconf = nfs3_proc_pathconf,
827 .decode_dirent = nfs3_decode_dirent,
828 .read_setup = nfs3_proc_read_setup,
829 .read_done = nfs3_read_done,
830 .write_setup = nfs3_proc_write_setup,
831 .write_done = nfs3_write_done,
832 .commit_setup = nfs3_proc_commit_setup,
833 .commit_done = nfs3_commit_done,
834 .file_open = nfs_open,
835 .file_release = nfs_release,
836 .lock = nfs3_proc_lock,
837 .clear_acl_cache = nfs3_forget_cached_acls,
838 };
WRT350N Kernel Patches