?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[MIPS] Remove pnx8550-v2pci_defconfig
[linux-2.6/zen-sources.git] / fs / nfs / nfs3proc.c
blob7d0371e2bad53228b8d2cbee4e95b9bf3fe75b25
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 /*
257 * Create a regular file.
258 * For now, we don't implement O_EXCL.
259 */
260 static int
261 nfs3_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
262 int flags, struct nameidata *nd)
263 {
264 struct nfs_fh fhandle;
265 struct nfs_fattr fattr;
266 struct nfs_fattr dir_attr;
267 struct nfs3_createargs arg = {
268 .fh = NFS_FH(dir),
269 .name = dentry->d_name.name,
270 .len = dentry->d_name.len,
271 .sattr = sattr,
272 };
273 struct nfs3_diropres res = {
274 .dir_attr = &dir_attr,
275 .fh = &fhandle,
276 .fattr = &fattr
277 };
278 struct rpc_message msg = {
279 .rpc_proc = &nfs3_procedures[NFS3PROC_CREATE],
280 .rpc_argp = &arg,
281 .rpc_resp = &res,
282 };
283 mode_t mode = sattr->ia_mode;
284 int status;
285
286 dprintk("NFS call create %s\n", dentry->d_name.name);
287 arg.createmode = NFS3_CREATE_UNCHECKED;
288 if (flags & O_EXCL) {
289 arg.createmode = NFS3_CREATE_EXCLUSIVE;
290 arg.verifier[0] = jiffies;
291 arg.verifier[1] = current->pid;
292 }
293
294 sattr->ia_mode &= ~current->fs->umask;
295
296 again:
297 nfs_fattr_init(&dir_attr);
298 nfs_fattr_init(&fattr);
299 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
300 nfs_refresh_inode(dir, &dir_attr);
301
302 /* If the server doesn't support the exclusive creation semantics,
303 * try again with simple 'guarded' mode. */
304 if (status == -ENOTSUPP) {
305 switch (arg.createmode) {
306 case NFS3_CREATE_EXCLUSIVE:
307 arg.createmode = NFS3_CREATE_GUARDED;
308 break;
309
310 case NFS3_CREATE_GUARDED:
311 arg.createmode = NFS3_CREATE_UNCHECKED;
312 break;
313
314 case NFS3_CREATE_UNCHECKED:
315 goto out;
316 }
317 goto again;
318 }
319
320 if (status == 0)
321 status = nfs_instantiate(dentry, &fhandle, &fattr);
322 if (status != 0)
323 goto out;
324
325 /* When we created the file with exclusive semantics, make
326 * sure we set the attributes afterwards. */
327 if (arg.createmode == NFS3_CREATE_EXCLUSIVE) {
328 dprintk("NFS call setattr (post-create)\n");
329
330 if (!(sattr->ia_valid & ATTR_ATIME_SET))
331 sattr->ia_valid |= ATTR_ATIME;
332 if (!(sattr->ia_valid & ATTR_MTIME_SET))
333 sattr->ia_valid |= ATTR_MTIME;
334
335 /* Note: we could use a guarded setattr here, but I'm
336 * not sure this buys us anything (and I'd have
337 * to revamp the NFSv3 XDR code) */
338 status = nfs3_proc_setattr(dentry, &fattr, sattr);
339 if (status == 0)
340 nfs_setattr_update_inode(dentry->d_inode, sattr);
341 nfs_refresh_inode(dentry->d_inode, &fattr);
342 dprintk("NFS reply setattr (post-create): %d\n", status);
343 }
344 if (status != 0)
345 goto out;
346 status = nfs3_proc_set_default_acl(dir, dentry->d_inode, mode);
347 out:
348 dprintk("NFS reply create: %d\n", status);
349 return status;
350 }
351
352 static int
353 nfs3_proc_remove(struct inode *dir, struct qstr *name)
354 {
355 struct nfs_fattr dir_attr;
356 struct nfs3_diropargs arg = {
357 .fh = NFS_FH(dir),
358 .name = name->name,
359 .len = name->len
360 };
361 struct rpc_message msg = {
362 .rpc_proc = &nfs3_procedures[NFS3PROC_REMOVE],
363 .rpc_argp = &arg,
364 .rpc_resp = &dir_attr,
365 };
366 int status;
367
368 dprintk("NFS call remove %s\n", name->name);
369 nfs_fattr_init(&dir_attr);
370 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
371 nfs_post_op_update_inode(dir, &dir_attr);
372 dprintk("NFS reply remove: %d\n", status);
373 return status;
374 }
375
376 static int
377 nfs3_proc_unlink_setup(struct rpc_message *msg, struct dentry *dir, struct qstr *name)
378 {
379 struct unlinkxdr {
380 struct nfs3_diropargs arg;
381 struct nfs_fattr res;
382 } *ptr;
383
384 ptr = kmalloc(sizeof(*ptr), GFP_KERNEL);
385 if (!ptr)
386 return -ENOMEM;
387 ptr->arg.fh = NFS_FH(dir->d_inode);
388 ptr->arg.name = name->name;
389 ptr->arg.len = name->len;
390 nfs_fattr_init(&ptr->res);
391 msg->rpc_proc = &nfs3_procedures[NFS3PROC_REMOVE];
392 msg->rpc_argp = &ptr->arg;
393 msg->rpc_resp = &ptr->res;
394 return 0;
395 }
396
397 static int
398 nfs3_proc_unlink_done(struct dentry *dir, struct rpc_task *task)
399 {
400 struct rpc_message *msg = &task->tk_msg;
401 struct nfs_fattr *dir_attr;
402
403 if (nfs3_async_handle_jukebox(task, dir->d_inode))
404 return 1;
405 if (msg->rpc_argp) {
406 dir_attr = (struct nfs_fattr*)msg->rpc_resp;
407 nfs_post_op_update_inode(dir->d_inode, dir_attr);
408 kfree(msg->rpc_argp);
409 }
410 return 0;
411 }
412
413 static int
414 nfs3_proc_rename(struct inode *old_dir, struct qstr *old_name,
415 struct inode *new_dir, struct qstr *new_name)
416 {
417 struct nfs_fattr old_dir_attr, new_dir_attr;
418 struct nfs3_renameargs arg = {
419 .fromfh = NFS_FH(old_dir),
420 .fromname = old_name->name,
421 .fromlen = old_name->len,
422 .tofh = NFS_FH(new_dir),
423 .toname = new_name->name,
424 .tolen = new_name->len
425 };
426 struct nfs3_renameres res = {
427 .fromattr = &old_dir_attr,
428 .toattr = &new_dir_attr
429 };
430 struct rpc_message msg = {
431 .rpc_proc = &nfs3_procedures[NFS3PROC_RENAME],
432 .rpc_argp = &arg,
433 .rpc_resp = &res,
434 };
435 int status;
436
437 dprintk("NFS call rename %s -> %s\n", old_name->name, new_name->name);
438 nfs_fattr_init(&old_dir_attr);
439 nfs_fattr_init(&new_dir_attr);
440 status = rpc_call_sync(NFS_CLIENT(old_dir), &msg, 0);
441 nfs_post_op_update_inode(old_dir, &old_dir_attr);
442 nfs_post_op_update_inode(new_dir, &new_dir_attr);
443 dprintk("NFS reply rename: %d\n", status);
444 return status;
445 }
446
447 static int
448 nfs3_proc_link(struct inode *inode, struct inode *dir, struct qstr *name)
449 {
450 struct nfs_fattr dir_attr, fattr;
451 struct nfs3_linkargs arg = {
452 .fromfh = NFS_FH(inode),
453 .tofh = NFS_FH(dir),
454 .toname = name->name,
455 .tolen = name->len
456 };
457 struct nfs3_linkres res = {
458 .dir_attr = &dir_attr,
459 .fattr = &fattr
460 };
461 struct rpc_message msg = {
462 .rpc_proc = &nfs3_procedures[NFS3PROC_LINK],
463 .rpc_argp = &arg,
464 .rpc_resp = &res,
465 };
466 int status;
467
468 dprintk("NFS call link %s\n", name->name);
469 nfs_fattr_init(&dir_attr);
470 nfs_fattr_init(&fattr);
471 status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
472 nfs_post_op_update_inode(dir, &dir_attr);
473 nfs_post_op_update_inode(inode, &fattr);
474 dprintk("NFS reply link: %d\n", status);
475 return status;
476 }
477
478 static int
479 nfs3_proc_symlink(struct inode *dir, struct dentry *dentry, struct page *page,
480 unsigned int len, struct iattr *sattr)
481 {
482 struct nfs_fh fhandle;
483 struct nfs_fattr fattr, dir_attr;
484 struct nfs3_symlinkargs arg = {
485 .fromfh = NFS_FH(dir),
486 .fromname = dentry->d_name.name,
487 .fromlen = dentry->d_name.len,
488 .pages = &page,
489 .pathlen = len,
490 .sattr = sattr
491 };
492 struct nfs3_diropres res = {
493 .dir_attr = &dir_attr,
494 .fh = &fhandle,
495 .fattr = &fattr
496 };
497 struct rpc_message msg = {
498 .rpc_proc = &nfs3_procedures[NFS3PROC_SYMLINK],
499 .rpc_argp = &arg,
500 .rpc_resp = &res,
501 };
502 int status;
503
504 if (len > NFS3_MAXPATHLEN)
505 return -ENAMETOOLONG;
506
507 dprintk("NFS call symlink %s\n", dentry->d_name.name);
508
509 nfs_fattr_init(&dir_attr);
510 nfs_fattr_init(&fattr);
511 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
512 nfs_post_op_update_inode(dir, &dir_attr);
513 if (status != 0)
514 goto out;
515 status = nfs_instantiate(dentry, &fhandle, &fattr);
516 out:
517 dprintk("NFS reply symlink: %d\n", status);
518 return status;
519 }
520
521 static int
522 nfs3_proc_mkdir(struct inode *dir, struct dentry *dentry, struct iattr *sattr)
523 {
524 struct nfs_fh fhandle;
525 struct nfs_fattr fattr, dir_attr;
526 struct nfs3_mkdirargs arg = {
527 .fh = NFS_FH(dir),
528 .name = dentry->d_name.name,
529 .len = dentry->d_name.len,
530 .sattr = sattr
531 };
532 struct nfs3_diropres res = {
533 .dir_attr = &dir_attr,
534 .fh = &fhandle,
535 .fattr = &fattr
536 };
537 struct rpc_message msg = {
538 .rpc_proc = &nfs3_procedures[NFS3PROC_MKDIR],
539 .rpc_argp = &arg,
540 .rpc_resp = &res,
541 };
542 int mode = sattr->ia_mode;
543 int status;
544
545 dprintk("NFS call mkdir %s\n", dentry->d_name.name);
546
547 sattr->ia_mode &= ~current->fs->umask;
548
549 nfs_fattr_init(&dir_attr);
550 nfs_fattr_init(&fattr);
551 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
552 nfs_post_op_update_inode(dir, &dir_attr);
553 if (status != 0)
554 goto out;
555 status = nfs_instantiate(dentry, &fhandle, &fattr);
556 if (status != 0)
557 goto out;
558 status = nfs3_proc_set_default_acl(dir, dentry->d_inode, mode);
559 out:
560 dprintk("NFS reply mkdir: %d\n", status);
561 return status;
562 }
563
564 static int
565 nfs3_proc_rmdir(struct inode *dir, struct qstr *name)
566 {
567 struct nfs_fattr dir_attr;
568 struct nfs3_diropargs arg = {
569 .fh = NFS_FH(dir),
570 .name = name->name,
571 .len = name->len
572 };
573 struct rpc_message msg = {
574 .rpc_proc = &nfs3_procedures[NFS3PROC_RMDIR],
575 .rpc_argp = &arg,
576 .rpc_resp = &dir_attr,
577 };
578 int status;
579
580 dprintk("NFS call rmdir %s\n", name->name);
581 nfs_fattr_init(&dir_attr);
582 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
583 nfs_post_op_update_inode(dir, &dir_attr);
584 dprintk("NFS reply rmdir: %d\n", status);
585 return status;
586 }
587
588 /*
589 * The READDIR implementation is somewhat hackish - we pass the user buffer
590 * to the encode function, which installs it in the receive iovec.
591 * The decode function itself doesn't perform any decoding, it just makes
592 * sure the reply is syntactically correct.
593 *
594 * Also note that this implementation handles both plain readdir and
595 * readdirplus.
596 */
597 static int
598 nfs3_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
599 u64 cookie, struct page *page, unsigned int count, int plus)
600 {
601 struct inode *dir = dentry->d_inode;
602 struct nfs_fattr dir_attr;
603 __be32 *verf = NFS_COOKIEVERF(dir);
604 struct nfs3_readdirargs arg = {
605 .fh = NFS_FH(dir),
606 .cookie = cookie,
607 .verf = {verf[0], verf[1]},
608 .plus = plus,
609 .count = count,
610 .pages = &page
611 };
612 struct nfs3_readdirres res = {
613 .dir_attr = &dir_attr,
614 .verf = verf,
615 .plus = plus
616 };
617 struct rpc_message msg = {
618 .rpc_proc = &nfs3_procedures[NFS3PROC_READDIR],
619 .rpc_argp = &arg,
620 .rpc_resp = &res,
621 .rpc_cred = cred
622 };
623 int status;
624
625 if (plus)
626 msg.rpc_proc = &nfs3_procedures[NFS3PROC_READDIRPLUS];
627
628 dprintk("NFS call readdir%s %d\n",
629 plus? "plus" : "", (unsigned int) cookie);
630
631 nfs_fattr_init(&dir_attr);
632 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
633 nfs_refresh_inode(dir, &dir_attr);
634 dprintk("NFS reply readdir: %d\n", status);
635 return status;
636 }
637
638 static int
639 nfs3_proc_mknod(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
640 dev_t rdev)
641 {
642 struct nfs_fh fh;
643 struct nfs_fattr fattr, dir_attr;
644 struct nfs3_mknodargs arg = {
645 .fh = NFS_FH(dir),
646 .name = dentry->d_name.name,
647 .len = dentry->d_name.len,
648 .sattr = sattr,
649 .rdev = rdev
650 };
651 struct nfs3_diropres res = {
652 .dir_attr = &dir_attr,
653 .fh = &fh,
654 .fattr = &fattr
655 };
656 struct rpc_message msg = {
657 .rpc_proc = &nfs3_procedures[NFS3PROC_MKNOD],
658 .rpc_argp = &arg,
659 .rpc_resp = &res,
660 };
661 mode_t mode = sattr->ia_mode;
662 int status;
663
664 switch (sattr->ia_mode & S_IFMT) {
665 case S_IFBLK: arg.type = NF3BLK; break;
666 case S_IFCHR: arg.type = NF3CHR; break;
667 case S_IFIFO: arg.type = NF3FIFO; break;
668 case S_IFSOCK: arg.type = NF3SOCK; break;
669 default: return -EINVAL;
670 }
671
672 dprintk("NFS call mknod %s %u:%u\n", dentry->d_name.name,
673 MAJOR(rdev), MINOR(rdev));
674
675 sattr->ia_mode &= ~current->fs->umask;
676
677 nfs_fattr_init(&dir_attr);
678 nfs_fattr_init(&fattr);
679 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
680 nfs_post_op_update_inode(dir, &dir_attr);
681 if (status != 0)
682 goto out;
683 status = nfs_instantiate(dentry, &fh, &fattr);
684 if (status != 0)
685 goto out;
686 status = nfs3_proc_set_default_acl(dir, dentry->d_inode, mode);
687 out:
688 dprintk("NFS reply mknod: %d\n", status);
689 return status;
690 }
691
692 static int
693 nfs3_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle,
694 struct nfs_fsstat *stat)
695 {
696 struct rpc_message msg = {
697 .rpc_proc = &nfs3_procedures[NFS3PROC_FSSTAT],
698 .rpc_argp = fhandle,
699 .rpc_resp = stat,
700 };
701 int status;
702
703 dprintk("NFS call fsstat\n");
704 nfs_fattr_init(stat->fattr);
705 status = rpc_call_sync(server->client, &msg, 0);
706 dprintk("NFS reply statfs: %d\n", status);
707 return status;
708 }
709
710 static int
711 nfs3_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle,
712 struct nfs_fsinfo *info)
713 {
714 struct rpc_message msg = {
715 .rpc_proc = &nfs3_procedures[NFS3PROC_FSINFO],
716 .rpc_argp = fhandle,
717 .rpc_resp = info,
718 };
719 int status;
720
721 dprintk("NFS call fsinfo\n");
722 nfs_fattr_init(info->fattr);
723 status = rpc_call_sync(server->nfs_client->cl_rpcclient, &msg, 0);
724 dprintk("NFS reply fsinfo: %d\n", status);
725 return status;
726 }
727
728 static int
729 nfs3_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
730 struct nfs_pathconf *info)
731 {
732 struct rpc_message msg = {
733 .rpc_proc = &nfs3_procedures[NFS3PROC_PATHCONF],
734 .rpc_argp = fhandle,
735 .rpc_resp = info,
736 };
737 int status;
738
739 dprintk("NFS call pathconf\n");
740 nfs_fattr_init(info->fattr);
741 status = rpc_call_sync(server->client, &msg, 0);
742 dprintk("NFS reply pathconf: %d\n", status);
743 return status;
744 }
745
746 static int nfs3_read_done(struct rpc_task *task, struct nfs_read_data *data)
747 {
748 if (nfs3_async_handle_jukebox(task, data->inode))
749 return -EAGAIN;
750 /* Call back common NFS readpage processing */
751 if (task->tk_status >= 0)
752 nfs_refresh_inode(data->inode, &data->fattr);
753 return 0;
754 }
755
756 static void nfs3_proc_read_setup(struct nfs_read_data *data)
757 {
758 struct rpc_message msg = {
759 .rpc_proc = &nfs3_procedures[NFS3PROC_READ],
760 .rpc_argp = &data->args,
761 .rpc_resp = &data->res,
762 .rpc_cred = data->cred,
763 };
764
765 rpc_call_setup(&data->task, &msg, 0);
766 }
767
768 static int nfs3_write_done(struct rpc_task *task, struct nfs_write_data *data)
769 {
770 if (nfs3_async_handle_jukebox(task, data->inode))
771 return -EAGAIN;
772 if (task->tk_status >= 0)
773 nfs_post_op_update_inode(data->inode, data->res.fattr);
774 return 0;
775 }
776
777 static void nfs3_proc_write_setup(struct nfs_write_data *data, int how)
778 {
779 struct rpc_message msg = {
780 .rpc_proc = &nfs3_procedures[NFS3PROC_WRITE],
781 .rpc_argp = &data->args,
782 .rpc_resp = &data->res,
783 .rpc_cred = data->cred,
784 };
785
786 data->args.stable = NFS_UNSTABLE;
787 if (how & FLUSH_STABLE) {
788 data->args.stable = NFS_FILE_SYNC;
789 if (NFS_I(data->inode)->ncommit)
790 data->args.stable = NFS_DATA_SYNC;
791 }
792
793 /* Finalize the task. */
794 rpc_call_setup(&data->task, &msg, 0);
795 }
796
797 static int nfs3_commit_done(struct rpc_task *task, struct nfs_write_data *data)
798 {
799 if (nfs3_async_handle_jukebox(task, data->inode))
800 return -EAGAIN;
801 if (task->tk_status >= 0)
802 nfs_post_op_update_inode(data->inode, data->res.fattr);
803 return 0;
804 }
805
806 static void nfs3_proc_commit_setup(struct nfs_write_data *data, int how)
807 {
808 struct rpc_message msg = {
809 .rpc_proc = &nfs3_procedures[NFS3PROC_COMMIT],
810 .rpc_argp = &data->args,
811 .rpc_resp = &data->res,
812 .rpc_cred = data->cred,
813 };
814
815 rpc_call_setup(&data->task, &msg, 0);
816 }
817
818 static int
819 nfs3_proc_lock(struct file *filp, int cmd, struct file_lock *fl)
820 {
821 return nlmclnt_proc(filp->f_path.dentry->d_inode, cmd, fl);
822 }
823
824 const struct nfs_rpc_ops nfs_v3_clientops = {
825 .version = 3, /* protocol version */
826 .dentry_ops = &nfs_dentry_operations,
827 .dir_inode_ops = &nfs3_dir_inode_operations,
828 .file_inode_ops = &nfs3_file_inode_operations,
829 .getroot = nfs3_proc_get_root,
830 .getattr = nfs3_proc_getattr,
831 .setattr = nfs3_proc_setattr,
832 .lookup = nfs3_proc_lookup,
833 .access = nfs3_proc_access,
834 .readlink = nfs3_proc_readlink,
835 .create = nfs3_proc_create,
836 .remove = nfs3_proc_remove,
837 .unlink_setup = nfs3_proc_unlink_setup,
838 .unlink_done = nfs3_proc_unlink_done,
839 .rename = nfs3_proc_rename,
840 .link = nfs3_proc_link,
841 .symlink = nfs3_proc_symlink,
842 .mkdir = nfs3_proc_mkdir,
843 .rmdir = nfs3_proc_rmdir,
844 .readdir = nfs3_proc_readdir,
845 .mknod = nfs3_proc_mknod,
846 .statfs = nfs3_proc_statfs,
847 .fsinfo = nfs3_proc_fsinfo,
848 .pathconf = nfs3_proc_pathconf,
849 .decode_dirent = nfs3_decode_dirent,
850 .read_setup = nfs3_proc_read_setup,
851 .read_done = nfs3_read_done,
852 .write_setup = nfs3_proc_write_setup,
853 .write_done = nfs3_write_done,
854 .commit_setup = nfs3_proc_commit_setup,
855 .commit_done = nfs3_commit_done,
856 .file_open = nfs_open,
857 .file_release = nfs_release,
858 .lock = nfs3_proc_lock,
859 .clear_acl_cache = nfs3_forget_cached_acls,
860 };
Stable & featurefull patchset based on Linus's git branch