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