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