projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:


553c34e9f296c415e6d20c8e7273dc2c59ecd804
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / net / 9p / client.c
1 /*
2 * net/9p/clnt.c
3 *
4 * 9P Client
5 *
6 * Copyright (C) 2008 by Eric Van Hensbergen <ericvh@gmail.com>
7 * Copyright (C) 2007 by Latchesar Ionkov <lucho@ionkov.net>
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2
11 * as published by the Free Software Foundation.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to:
20 * Free Software Foundation
21 * 51 Franklin Street, Fifth Floor
22 * Boston, MA 02111-1301 USA
23 *
24 */
25
26 #include <linux/module.h>
27 #include <linux/errno.h>
28 #include <linux/fs.h>
29 #include <linux/poll.h>
30 #include <linux/idr.h>
31 #include <linux/mutex.h>
32 #include <linux/sched.h>
33 #include <linux/uaccess.h>
34 #include <net/9p/9p.h>
35 #include <linux/parser.h>
36 #include <net/9p/transport.h>
37 #include <net/9p/client.h>
38
39 static struct p9_fid *p9_fid_create(struct p9_client *clnt);
40 static void p9_fid_destroy(struct p9_fid *fid);
41 static struct p9_stat *p9_clone_stat(struct p9_stat *st, int dotu);
42
43 /*
44 * Client Option Parsing (code inspired by NFS code)
45 * - a little lazy - parse all client options
46 */
47
48 enum {
49 Opt_msize,
50 Opt_trans,
51 Opt_legacy,
52 Opt_err,
53 };
54
55 static match_table_t tokens = {
56 {Opt_msize, "msize=%u"},
57 {Opt_legacy, "noextend"},
58 {Opt_trans, "trans=%s"},
59 {Opt_err, NULL},
60 };
61
62 /**
63 * v9fs_parse_options - parse mount options into session structure
64 * @options: options string passed from mount
65 * @v9ses: existing v9fs session information
66 *
67 * Return 0 upon success, -ERRNO upon failure
68 */
69
70 static int parse_opts(char *opts, struct p9_client *clnt)
71 {
72 char *options;
73 char *p;
74 substring_t args[MAX_OPT_ARGS];
75 int option;
76 int ret = 0;
77
78 clnt->trans_mod = v9fs_default_trans();
79 clnt->dotu = 1;
80 clnt->msize = 8192;
81
82 if (!opts)
83 return 0;
84
85 options = kstrdup(opts, GFP_KERNEL);
86 if (!options) {
87 P9_DPRINTK(P9_DEBUG_ERROR,
88 "failed to allocate copy of option string\n");
89 return -ENOMEM;
90 }
91
92 while ((p = strsep(&options, ",")) != NULL) {
93 int token;
94 if (!*p)
95 continue;
96 token = match_token(p, tokens, args);
97 if (token < Opt_trans) {
98 int r = match_int(&args[0], &option);
99 if (r < 0) {
100 P9_DPRINTK(P9_DEBUG_ERROR,
101 "integer field, but no integer?\n");
102 ret = r;
103 continue;
104 }
105 }
106 switch (token) {
107 case Opt_msize:
108 clnt->msize = option;
109 break;
110 case Opt_trans:
111 clnt->trans_mod = v9fs_match_trans(&args[0]);
112 break;
113 case Opt_legacy:
114 clnt->dotu = 0;
115 break;
116 default:
117 continue;
118 }
119 }
120 kfree(options);
121 return ret;
122 }
123
124
125 /**
126 * p9_client_rpc - sends 9P request and waits until a response is available.
127 * The function can be interrupted.
128 * @c: client data
129 * @tc: request to be sent
130 * @rc: pointer where a pointer to the response is stored
131 */
132 int
133 p9_client_rpc(struct p9_client *c, struct p9_fcall *tc,
134 struct p9_fcall **rc)
135 {
136 return c->trans->rpc(c->trans, tc, rc);
137 }
138
139 struct p9_client *p9_client_create(const char *dev_name, char *options)
140 {
141 int err, n;
142 struct p9_client *clnt;
143 struct p9_fcall *tc, *rc;
144 struct p9_str *version;
145
146 err = 0;
147 tc = NULL;
148 rc = NULL;
149 clnt = kmalloc(sizeof(struct p9_client), GFP_KERNEL);
150 if (!clnt)
151 return ERR_PTR(-ENOMEM);
152
153 clnt->trans = NULL;
154 spin_lock_init(&clnt->lock);
155 INIT_LIST_HEAD(&clnt->fidlist);
156 clnt->fidpool = p9_idpool_create();
157 if (!clnt->fidpool) {
158 err = PTR_ERR(clnt->fidpool);
159 clnt->fidpool = NULL;
160 goto error;
161 }
162
163 err = parse_opts(options, clnt);
164 if (err < 0)
165 goto error;
166
167 if (clnt->trans_mod == NULL) {
168 err = -EPROTONOSUPPORT;
169 P9_DPRINTK(P9_DEBUG_ERROR,
170 "No transport defined or default transport\n");
171 goto error;
172 }
173
174 P9_DPRINTK(P9_DEBUG_9P, "clnt %p trans %p msize %d dotu %d\n",
175 clnt, clnt->trans_mod, clnt->msize, clnt->dotu);
176
177
178 clnt->trans = clnt->trans_mod->create(dev_name, options, clnt->msize,
179 clnt->dotu);
180 if (IS_ERR(clnt->trans)) {
181 err = PTR_ERR(clnt->trans);
182 clnt->trans = NULL;
183 goto error;
184 }
185
186 if ((clnt->msize+P9_IOHDRSZ) > clnt->trans_mod->maxsize)
187 clnt->msize = clnt->trans_mod->maxsize-P9_IOHDRSZ;
188
189 tc = p9_create_tversion(clnt->msize, clnt->dotu?"9P2000.u":"9P2000");
190 if (IS_ERR(tc)) {
191 err = PTR_ERR(tc);
192 tc = NULL;
193 goto error;
194 }
195
196 err = p9_client_rpc(clnt, tc, &rc);
197 if (err)
198 goto error;
199
200 version = &rc->params.rversion.version;
201 if (version->len == 8 && !memcmp(version->str, "9P2000.u", 8))
202 clnt->dotu = 1;
203 else if (version->len == 6 && !memcmp(version->str, "9P2000", 6))
204 clnt->dotu = 0;
205 else {
206 err = -EREMOTEIO;
207 goto error;
208 }
209
210 n = rc->params.rversion.msize;
211 if (n < clnt->msize)
212 clnt->msize = n;
213
214 kfree(tc);
215 kfree(rc);
216 return clnt;
217
218 error:
219 kfree(tc);
220 kfree(rc);
221 p9_client_destroy(clnt);
222 return ERR_PTR(err);
223 }
224 EXPORT_SYMBOL(p9_client_create);
225
226 void p9_client_destroy(struct p9_client *clnt)
227 {
228 struct p9_fid *fid, *fidptr;
229
230 P9_DPRINTK(P9_DEBUG_9P, "clnt %p\n", clnt);
231
232 if (clnt->trans) {
233 clnt->trans->close(clnt->trans);
234 kfree(clnt->trans);
235 clnt->trans = NULL;
236 }
237
238 list_for_each_entry_safe(fid, fidptr, &clnt->fidlist, flist)
239 p9_fid_destroy(fid);
240
241 if (clnt->fidpool)
242 p9_idpool_destroy(clnt->fidpool);
243
244 kfree(clnt);
245 }
246 EXPORT_SYMBOL(p9_client_destroy);
247
248 void p9_client_disconnect(struct p9_client *clnt)
249 {
250 P9_DPRINTK(P9_DEBUG_9P, "clnt %p\n", clnt);
251 clnt->trans->status = Disconnected;
252 }
253 EXPORT_SYMBOL(p9_client_disconnect);
254
255 struct p9_fid *p9_client_attach(struct p9_client *clnt, struct p9_fid *afid,
256 char *uname, u32 n_uname, char *aname)
257 {
258 int err;
259 struct p9_fcall *tc, *rc;
260 struct p9_fid *fid;
261
262 P9_DPRINTK(P9_DEBUG_9P, "clnt %p afid %d uname %s aname %s\n",
263 clnt, afid?afid->fid:-1, uname, aname);
264 err = 0;
265 tc = NULL;
266 rc = NULL;
267
268 fid = p9_fid_create(clnt);
269 if (IS_ERR(fid)) {
270 err = PTR_ERR(fid);
271 fid = NULL;
272 goto error;
273 }
274
275 tc = p9_create_tattach(fid->fid, afid?afid->fid:P9_NOFID, uname, aname,
276 n_uname, clnt->dotu);
277 if (IS_ERR(tc)) {
278 err = PTR_ERR(tc);
279 tc = NULL;
280 goto error;
281 }
282
283 err = p9_client_rpc(clnt, tc, &rc);
284 if (err)
285 goto error;
286
287 memmove(&fid->qid, &rc->params.rattach.qid, sizeof(struct p9_qid));
288 kfree(tc);
289 kfree(rc);
290 return fid;
291
292 error:
293 kfree(tc);
294 kfree(rc);
295 if (fid)
296 p9_fid_destroy(fid);
297 return ERR_PTR(err);
298 }
299 EXPORT_SYMBOL(p9_client_attach);
300
301 struct p9_fid *p9_client_auth(struct p9_client *clnt, char *uname,
302 u32 n_uname, char *aname)
303 {
304 int err;
305 struct p9_fcall *tc, *rc;
306 struct p9_fid *fid;
307
308 P9_DPRINTK(P9_DEBUG_9P, "clnt %p uname %s aname %s\n", clnt, uname,
309 aname);
310 err = 0;
311 tc = NULL;
312 rc = NULL;
313
314 fid = p9_fid_create(clnt);
315 if (IS_ERR(fid)) {
316 err = PTR_ERR(fid);
317 fid = NULL;
318 goto error;
319 }
320
321 tc = p9_create_tauth(fid->fid, uname, aname, n_uname, clnt->dotu);
322 if (IS_ERR(tc)) {
323 err = PTR_ERR(tc);
324 tc = NULL;
325 goto error;
326 }
327
328 err = p9_client_rpc(clnt, tc, &rc);
329 if (err)
330 goto error;
331
332 memmove(&fid->qid, &rc->params.rauth.qid, sizeof(struct p9_qid));
333 kfree(tc);
334 kfree(rc);
335 return fid;
336
337 error:
338 kfree(tc);
339 kfree(rc);
340 if (fid)
341 p9_fid_destroy(fid);
342 return ERR_PTR(err);
343 }
344 EXPORT_SYMBOL(p9_client_auth);
345
346 struct p9_fid *p9_client_walk(struct p9_fid *oldfid, int nwname, char **wnames,
347 int clone)
348 {
349 int err;
350 struct p9_fcall *tc, *rc;
351 struct p9_client *clnt;
352 struct p9_fid *fid;
353
354 P9_DPRINTK(P9_DEBUG_9P, "fid %d nwname %d wname[0] %s\n",
355 oldfid->fid, nwname, wnames?wnames[0]:NULL);
356 err = 0;
357 tc = NULL;
358 rc = NULL;
359 clnt = oldfid->clnt;
360 if (clone) {
361 fid = p9_fid_create(clnt);
362 if (IS_ERR(fid)) {
363 err = PTR_ERR(fid);
364 fid = NULL;
365 goto error;
366 }
367
368 fid->uid = oldfid->uid;
369 } else
370 fid = oldfid;
371
372 tc = p9_create_twalk(oldfid->fid, fid->fid, nwname, wnames);
373 if (IS_ERR(tc)) {
374 err = PTR_ERR(tc);
375 tc = NULL;
376 goto error;
377 }
378
379 err = p9_client_rpc(clnt, tc, &rc);
380 if (err) {
381 if (rc && rc->id == P9_RWALK)
382 goto clunk_fid;
383 else
384 goto error;
385 }
386
387 if (rc->params.rwalk.nwqid != nwname) {
388 err = -ENOENT;
389 goto clunk_fid;
390 }
391
392 if (nwname)
393 memmove(&fid->qid,
394 &rc->params.rwalk.wqids[rc->params.rwalk.nwqid - 1],
395 sizeof(struct p9_qid));
396 else
397 fid->qid = oldfid->qid;
398
399 kfree(tc);
400 kfree(rc);
401 return fid;
402
403 clunk_fid:
404 kfree(tc);
405 kfree(rc);
406 rc = NULL;
407 tc = p9_create_tclunk(fid->fid);
408 if (IS_ERR(tc)) {
409 err = PTR_ERR(tc);
410 tc = NULL;
411 goto error;
412 }
413
414 p9_client_rpc(clnt, tc, &rc);
415
416 error:
417 kfree(tc);
418 kfree(rc);
419 if (fid && (fid != oldfid))
420 p9_fid_destroy(fid);
421
422 return ERR_PTR(err);
423 }
424 EXPORT_SYMBOL(p9_client_walk);
425
426 int p9_client_open(struct p9_fid *fid, int mode)
427 {
428 int err;
429 struct p9_fcall *tc, *rc;
430 struct p9_client *clnt;
431
432 P9_DPRINTK(P9_DEBUG_9P, "fid %d mode %d\n", fid->fid, mode);
433 err = 0;
434 tc = NULL;
435 rc = NULL;
436 clnt = fid->clnt;
437
438 if (fid->mode != -1)
439 return -EINVAL;
440
441 tc = p9_create_topen(fid->fid, mode);
442 if (IS_ERR(tc)) {
443 err = PTR_ERR(tc);
444 tc = NULL;
445 goto done;
446 }
447
448 err = p9_client_rpc(clnt, tc, &rc);
449 if (err)
450 goto done;
451
452 fid->mode = mode;
453 fid->iounit = rc->params.ropen.iounit;
454
455 done:
456 kfree(tc);
457 kfree(rc);
458 return err;
459 }
460 EXPORT_SYMBOL(p9_client_open);
461
462 int p9_client_fcreate(struct p9_fid *fid, char *name, u32 perm, int mode,
463 char *extension)
464 {
465 int err;
466 struct p9_fcall *tc, *rc;
467 struct p9_client *clnt;
468
469 P9_DPRINTK(P9_DEBUG_9P, "fid %d name %s perm %d mode %d\n", fid->fid,
470 name, perm, mode);
471 err = 0;
472 tc = NULL;
473 rc = NULL;
474 clnt = fid->clnt;
475
476 if (fid->mode != -1)
477 return -EINVAL;
478
479 tc = p9_create_tcreate(fid->fid, name, perm, mode, extension,
480 clnt->dotu);
481 if (IS_ERR(tc)) {
482 err = PTR_ERR(tc);
483 tc = NULL;
484 goto done;
485 }
486
487 err = p9_client_rpc(clnt, tc, &rc);
488 if (err)
489 goto done;
490
491 fid->mode = mode;
492 fid->iounit = rc->params.ropen.iounit;
493
494 done:
495 kfree(tc);
496 kfree(rc);
497 return err;
498 }
499 EXPORT_SYMBOL(p9_client_fcreate);
500
501 int p9_client_clunk(struct p9_fid *fid)
502 {
503 int err;
504 struct p9_fcall *tc, *rc;
505 struct p9_client *clnt;
506
507 P9_DPRINTK(P9_DEBUG_9P, "fid %d\n", fid->fid);
508 err = 0;
509 tc = NULL;
510 rc = NULL;
511 clnt = fid->clnt;
512
513 tc = p9_create_tclunk(fid->fid);
514 if (IS_ERR(tc)) {
515 err = PTR_ERR(tc);
516 tc = NULL;
517 goto done;
518 }
519
520 err = p9_client_rpc(clnt, tc, &rc);
521 if (err)
522 goto done;
523
524 p9_fid_destroy(fid);
525
526 done:
527 kfree(tc);
528 kfree(rc);
529 return err;
530 }
531 EXPORT_SYMBOL(p9_client_clunk);
532
533 int p9_client_remove(struct p9_fid *fid)
534 {
535 int err;
536 struct p9_fcall *tc, *rc;
537 struct p9_client *clnt;
538
539 P9_DPRINTK(P9_DEBUG_9P, "fid %d\n", fid->fid);
540 err = 0;
541 tc = NULL;
542 rc = NULL;
543 clnt = fid->clnt;
544
545 tc = p9_create_tremove(fid->fid);
546 if (IS_ERR(tc)) {
547 err = PTR_ERR(tc);
548 tc = NULL;
549 goto done;
550 }
551
552 err = p9_client_rpc(clnt, tc, &rc);
553 if (err)
554 goto done;
555
556 p9_fid_destroy(fid);
557
558 done:
559 kfree(tc);
560 kfree(rc);
561 return err;
562 }
563 EXPORT_SYMBOL(p9_client_remove);
564
565 int p9_client_read(struct p9_fid *fid, char *data, u64 offset, u32 count)
566 {
567 int err, n, rsize, total;
568 struct p9_fcall *tc, *rc;
569 struct p9_client *clnt;
570
571 P9_DPRINTK(P9_DEBUG_9P, "fid %d offset %llu %d\n", fid->fid,
572 (long long unsigned) offset, count);
573 err = 0;
574 tc = NULL;
575 rc = NULL;
576 clnt = fid->clnt;
577 total = 0;
578
579 rsize = fid->iounit;
580 if (!rsize || rsize > clnt->msize-P9_IOHDRSZ)
581 rsize = clnt->msize - P9_IOHDRSZ;
582
583 do {
584 if (count < rsize)
585 rsize = count;
586
587 tc = p9_create_tread(fid->fid, offset, rsize);
588 if (IS_ERR(tc)) {
589 err = PTR_ERR(tc);
590 tc = NULL;
591 goto error;
592 }
593
594 err = p9_client_rpc(clnt, tc, &rc);
595 if (err)
596 goto error;
597
598 n = rc->params.rread.count;
599 if (n > count)
600 n = count;
601
602 memmove(data, rc->params.rread.data, n);
603 count -= n;
604 data += n;
605 offset += n;
606 total += n;
607 kfree(tc);
608 tc = NULL;
609 kfree(rc);
610 rc = NULL;
611 } while (count > 0 && n == rsize);
612
613 return total;
614
615 error:
616 kfree(tc);
617 kfree(rc);
618 return err;
619 }
620 EXPORT_SYMBOL(p9_client_read);
621
622 int p9_client_write(struct p9_fid *fid, char *data, u64 offset, u32 count)
623 {
624 int err, n, rsize, total;
625 struct p9_fcall *tc, *rc;
626 struct p9_client *clnt;
627
628 P9_DPRINTK(P9_DEBUG_9P, "fid %d offset %llu count %d\n", fid->fid,
629 (long long unsigned) offset, count);
630 err = 0;
631 tc = NULL;
632 rc = NULL;
633 clnt = fid->clnt;
634 total = 0;
635
636 rsize = fid->iounit;
637 if (!rsize || rsize > clnt->msize-P9_IOHDRSZ)
638 rsize = clnt->msize - P9_IOHDRSZ;
639
640 do {
641 if (count < rsize)
642 rsize = count;
643
644 tc = p9_create_twrite(fid->fid, offset, rsize, data);
645 if (IS_ERR(tc)) {
646 err = PTR_ERR(tc);
647 tc = NULL;
648 goto error;
649 }
650
651 err = p9_client_rpc(clnt, tc, &rc);
652 if (err)
653 goto error;
654
655 n = rc->params.rread.count;
656 count -= n;
657 data += n;
658 offset += n;
659 total += n;
660 kfree(tc);
661 tc = NULL;
662 kfree(rc);
663 rc = NULL;
664 } while (count > 0);
665
666 return total;
667
668 error:
669 kfree(tc);
670 kfree(rc);
671 return err;
672 }
673 EXPORT_SYMBOL(p9_client_write);
674
675 int
676 p9_client_uread(struct p9_fid *fid, char __user *data, u64 offset, u32 count)
677 {
678 int err, n, rsize, total;
679 struct p9_fcall *tc, *rc;
680 struct p9_client *clnt;
681
682 P9_DPRINTK(P9_DEBUG_9P, "fid %d offset %llu count %d\n", fid->fid,
683 (long long unsigned) offset, count);
684 err = 0;
685 tc = NULL;
686 rc = NULL;
687 clnt = fid->clnt;
688 total = 0;
689
690 rsize = fid->iounit;
691 if (!rsize || rsize > clnt->msize-P9_IOHDRSZ)
692 rsize = clnt->msize - P9_IOHDRSZ;
693
694 do {
695 if (count < rsize)
696 rsize = count;
697
698 tc = p9_create_tread(fid->fid, offset, rsize);
699 if (IS_ERR(tc)) {
700 err = PTR_ERR(tc);
701 tc = NULL;
702 goto error;
703 }
704
705 err = p9_client_rpc(clnt, tc, &rc);
706 if (err)
707 goto error;
708
709 n = rc->params.rread.count;
710 if (n > count)
711 n = count;
712
713 err = copy_to_user(data, rc->params.rread.data, n);
714 if (err) {
715 err = -EFAULT;
716 goto error;
717 }
718
719 count -= n;
720 data += n;
721 offset += n;
722 total += n;
723 kfree(tc);
724 tc = NULL;
725 kfree(rc);
726 rc = NULL;
727 } while (count > 0 && n == rsize);
728
729 return total;
730
731 error:
732 kfree(tc);
733 kfree(rc);
734 return err;
735 }
736 EXPORT_SYMBOL(p9_client_uread);
737
738 int
739 p9_client_uwrite(struct p9_fid *fid, const char __user *data, u64 offset,
740 u32 count)
741 {
742 int err, n, rsize, total;
743 struct p9_fcall *tc, *rc;
744 struct p9_client *clnt;
745
746 P9_DPRINTK(P9_DEBUG_9P, "fid %d offset %llu count %d\n", fid->fid,
747 (long long unsigned) offset, count);
748 err = 0;
749 tc = NULL;
750 rc = NULL;
751 clnt = fid->clnt;
752 total = 0;
753
754 rsize = fid->iounit;
755 if (!rsize || rsize > clnt->msize-P9_IOHDRSZ)
756 rsize = clnt->msize - P9_IOHDRSZ;
757
758 do {
759 if (count < rsize)
760 rsize = count;
761
762 tc = p9_create_twrite_u(fid->fid, offset, rsize, data);
763 if (IS_ERR(tc)) {
764 err = PTR_ERR(tc);
765 tc = NULL;
766 goto error;
767 }
768
769 err = p9_client_rpc(clnt, tc, &rc);
770 if (err)
771 goto error;
772
773 n = rc->params.rread.count;
774 count -= n;
775 data += n;
776 offset += n;
777 total += n;
778 kfree(tc);
779 tc = NULL;
780 kfree(rc);
781 rc = NULL;
782 } while (count > 0);
783
784 return total;
785
786 error:
787 kfree(tc);
788 kfree(rc);
789 return err;
790 }
791 EXPORT_SYMBOL(p9_client_uwrite);
792
793 int p9_client_readn(struct p9_fid *fid, char *data, u64 offset, u32 count)
794 {
795 int n, total;
796
797 P9_DPRINTK(P9_DEBUG_9P, "fid %d offset %llu count %d\n", fid->fid,
798 (long long unsigned) offset, count);
799 n = 0;
800 total = 0;
801 while (count) {
802 n = p9_client_read(fid, data, offset, count);
803 if (n <= 0)
804 break;
805
806 data += n;
807 offset += n;
808 count -= n;
809 total += n;
810 }
811
812 if (n < 0)
813 total = n;
814
815 return total;
816 }
817 EXPORT_SYMBOL(p9_client_readn);
818
819 struct p9_stat *p9_client_stat(struct p9_fid *fid)
820 {
821 int err;
822 struct p9_fcall *tc, *rc;
823 struct p9_client *clnt;
824 struct p9_stat *ret;
825
826 P9_DPRINTK(P9_DEBUG_9P, "fid %d\n", fid->fid);
827 err = 0;
828 tc = NULL;
829 rc = NULL;
830 ret = NULL;
831 clnt = fid->clnt;
832
833 tc = p9_create_tstat(fid->fid);
834 if (IS_ERR(tc)) {
835 err = PTR_ERR(tc);
836 tc = NULL;
837 goto error;
838 }
839
840 err = p9_client_rpc(clnt, tc, &rc);
841 if (err)
842 goto error;
843
844 ret = p9_clone_stat(&rc->params.rstat.stat, clnt->dotu);
845 if (IS_ERR(ret)) {
846 err = PTR_ERR(ret);
847 ret = NULL;
848 goto error;
849 }
850
851 kfree(tc);
852 kfree(rc);
853 return ret;
854
855 error:
856 kfree(tc);
857 kfree(rc);
858 kfree(ret);
859 return ERR_PTR(err);
860 }
861 EXPORT_SYMBOL(p9_client_stat);
862
863 int p9_client_wstat(struct p9_fid *fid, struct p9_wstat *wst)
864 {
865 int err;
866 struct p9_fcall *tc, *rc;
867 struct p9_client *clnt;
868
869 P9_DPRINTK(P9_DEBUG_9P, "fid %d\n", fid->fid);
870 err = 0;
871 tc = NULL;
872 rc = NULL;
873 clnt = fid->clnt;
874
875 tc = p9_create_twstat(fid->fid, wst, clnt->dotu);
876 if (IS_ERR(tc)) {
877 err = PTR_ERR(tc);
878 tc = NULL;
879 goto done;
880 }
881
882 err = p9_client_rpc(clnt, tc, &rc);
883
884 done:
885 kfree(tc);
886 kfree(rc);
887 return err;
888 }
889 EXPORT_SYMBOL(p9_client_wstat);
890
891 struct p9_stat *p9_client_dirread(struct p9_fid *fid, u64 offset)
892 {
893 int err, n, m;
894 struct p9_fcall *tc, *rc;
895 struct p9_client *clnt;
896 struct p9_stat st, *ret;
897
898 P9_DPRINTK(P9_DEBUG_9P, "fid %d offset %llu\n", fid->fid,
899 (long long unsigned) offset);
900 err = 0;
901 tc = NULL;
902 rc = NULL;
903 ret = NULL;
904 clnt = fid->clnt;
905
906 /* if the offset is below or above the current response, free it */
907 if (offset < fid->rdir_fpos || (fid->rdir_fcall &&
908 offset >= fid->rdir_fpos+fid->rdir_fcall->params.rread.count)) {
909 fid->rdir_pos = 0;
910 if (fid->rdir_fcall)
911 fid->rdir_fpos += fid->rdir_fcall->params.rread.count;
912
913 kfree(fid->rdir_fcall);
914 fid->rdir_fcall = NULL;
915 if (offset < fid->rdir_fpos)
916 fid->rdir_fpos = 0;
917 }
918
919 if (!fid->rdir_fcall) {
920 n = fid->iounit;
921 if (!n || n > clnt->msize-P9_IOHDRSZ)
922 n = clnt->msize - P9_IOHDRSZ;
923
924 while (1) {
925 if (fid->rdir_fcall) {
926 fid->rdir_fpos +=
927 fid->rdir_fcall->params.rread.count;
928 kfree(fid->rdir_fcall);
929 fid->rdir_fcall = NULL;
930 }
931
932 tc = p9_create_tread(fid->fid, fid->rdir_fpos, n);
933 if (IS_ERR(tc)) {
934 err = PTR_ERR(tc);
935 tc = NULL;
936 goto error;
937 }
938
939 err = p9_client_rpc(clnt, tc, &rc);
940 if (err)
941 goto error;
942
943 n = rc->params.rread.count;
944 if (n == 0)
945 goto done;
946
947 fid->rdir_fcall = rc;
948 rc = NULL;
949 if (offset >= fid->rdir_fpos &&
950 offset < fid->rdir_fpos+n)
951 break;
952 }
953
954 fid->rdir_pos = 0;
955 }
956
957 m = offset - fid->rdir_fpos;
958 if (m < 0)
959 goto done;
960
961 n = p9_deserialize_stat(fid->rdir_fcall->params.rread.data + m,
962 fid->rdir_fcall->params.rread.count - m, &st, clnt->dotu);
963
964 if (!n) {
965 err = -EIO;
966 goto error;
967 }
968
969 fid->rdir_pos += n;
970 st.size = n;
971 ret = p9_clone_stat(&st, clnt->dotu);
972 if (IS_ERR(ret)) {
973 err = PTR_ERR(ret);
974 ret = NULL;
975 goto error;
976 }
977
978 done:
979 kfree(tc);
980 kfree(rc);
981 return ret;
982
983 error:
984 kfree(tc);
985 kfree(rc);
986 kfree(ret);
987 return ERR_PTR(err);
988 }
989 EXPORT_SYMBOL(p9_client_dirread);
990
991 static struct p9_stat *p9_clone_stat(struct p9_stat *st, int dotu)
992 {
993 int n;
994 char *p;
995 struct p9_stat *ret;
996
997 n = sizeof(struct p9_stat) + st->name.len + st->uid.len + st->gid.len +
998 st->muid.len;
999
1000 if (dotu)
1001 n += st->extension.len;
1002
1003 ret = kmalloc(n, GFP_KERNEL);
1004 if (!ret)
1005 return ERR_PTR(-ENOMEM);
1006
1007 memmove(ret, st, sizeof(struct p9_stat));
1008 p = ((char *) ret) + sizeof(struct p9_stat);
1009 memmove(p, st->name.str, st->name.len);
1010 ret->name.str = p;
1011 p += st->name.len;
1012 memmove(p, st->uid.str, st->uid.len);
1013 ret->uid.str = p;
1014 p += st->uid.len;
1015 memmove(p, st->gid.str, st->gid.len);
1016 ret->gid.str = p;
1017 p += st->gid.len;
1018 memmove(p, st->muid.str, st->muid.len);
1019 ret->muid.str = p;
1020 p += st->muid.len;
1021
1022 if (dotu) {
1023 memmove(p, st->extension.str, st->extension.len);
1024 ret->extension.str = p;
1025 p += st->extension.len;
1026 }
1027
1028 return ret;
1029 }
1030
1031 static struct p9_fid *p9_fid_create(struct p9_client *clnt)
1032 {
1033 int err;
1034 struct p9_fid *fid;
1035
1036 P9_DPRINTK(P9_DEBUG_9P, "clnt %p\n", clnt);
1037 fid = kmalloc(sizeof(struct p9_fid), GFP_KERNEL);
1038 if (!fid)
1039 return ERR_PTR(-ENOMEM);
1040
1041 fid->fid = p9_idpool_get(clnt->fidpool);
1042 if (fid->fid < 0) {
1043 err = -ENOSPC;
1044 goto error;
1045 }
1046
1047 memset(&fid->qid, 0, sizeof(struct p9_qid));
1048 fid->mode = -1;
1049 fid->rdir_fpos = 0;
1050 fid->rdir_pos = 0;
1051 fid->rdir_fcall = NULL;
1052 fid->uid = current->fsuid;
1053 fid->clnt = clnt;
1054 fid->aux = NULL;
1055
1056 spin_lock(&clnt->lock);
1057 list_add(&fid->flist, &clnt->fidlist);
1058 spin_unlock(&clnt->lock);
1059
1060 return fid;
1061
1062 error:
1063 kfree(fid);
1064 return ERR_PTR(err);
1065 }
1066
1067 static void p9_fid_destroy(struct p9_fid *fid)
1068 {
1069 struct p9_client *clnt;
1070
1071 P9_DPRINTK(P9_DEBUG_9P, "fid %d\n", fid->fid);
1072 clnt = fid->clnt;
1073 p9_idpool_put(fid->fid, clnt->fidpool);
1074 spin_lock(&clnt->lock);
1075 list_del(&fid->flist);
1076 spin_unlock(&clnt->lock);
1077 kfree(fid->rdir_fcall);
1078 kfree(fid);
1079 }
kernel source for telekom puls (alcatel/mediatek)