?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
x86: Add a synthetic TSC_RELIABLE feature bit.
[linux/fpc-iii.git] / net / 9p / client.c
blob67717f69412e47c182f34715291ec83c979d6f73
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/client.h>
37 #include <net/9p/transport.h>
38 #include "protocol.h"
39
40 /*
41 * Client Option Parsing (code inspired by NFS code)
42 * - a little lazy - parse all client options
43 */
44
45 enum {
46 Opt_msize,
47 Opt_trans,
48 Opt_legacy,
49 Opt_err,
50 };
51
52 static const match_table_t tokens = {
53 {Opt_msize, "msize=%u"},
54 {Opt_legacy, "noextend"},
55 {Opt_trans, "trans=%s"},
56 {Opt_err, NULL},
57 };
58
59 static struct p9_req_t *
60 p9_client_rpc(struct p9_client *c, int8_t type, const char *fmt, ...);
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->dotu = 1;
79 clnt->msize = 8192;
80
81 if (!opts)
82 return 0;
83
84 options = kstrdup(opts, GFP_KERNEL);
85 if (!options) {
86 P9_DPRINTK(P9_DEBUG_ERROR,
87 "failed to allocate copy of option string\n");
88 return -ENOMEM;
89 }
90
91 while ((p = strsep(&options, ",")) != NULL) {
92 int token;
93 if (!*p)
94 continue;
95 token = match_token(p, tokens, args);
96 if (token < Opt_trans) {
97 int r = match_int(&args[0], &option);
98 if (r < 0) {
99 P9_DPRINTK(P9_DEBUG_ERROR,
100 "integer field, but no integer?\n");
101 ret = r;
102 continue;
103 }
104 }
105 switch (token) {
106 case Opt_msize:
107 clnt->msize = option;
108 break;
109 case Opt_trans:
110 clnt->trans_mod = v9fs_get_trans_by_name(&args[0]);
111 break;
112 case Opt_legacy:
113 clnt->dotu = 0;
114 break;
115 default:
116 continue;
117 }
118 }
119
120 if (!clnt->trans_mod)
121 clnt->trans_mod = v9fs_get_default_trans();
122
123 kfree(options);
124 return ret;
125 }
126
127 /**
128 * p9_tag_alloc - lookup/allocate a request by tag
129 * @c: client session to lookup tag within
130 * @tag: numeric id for transaction
131 *
132 * this is a simple array lookup, but will grow the
133 * request_slots as necessary to accomodate transaction
134 * ids which did not previously have a slot.
135 *
136 * this code relies on the client spinlock to manage locks, its
137 * possible we should switch to something else, but I'd rather
138 * stick with something low-overhead for the common case.
139 *
140 */
141
142 static struct p9_req_t *p9_tag_alloc(struct p9_client *c, u16 tag)
143 {
144 unsigned long flags;
145 int row, col;
146 struct p9_req_t *req;
147
148 /* This looks up the original request by tag so we know which
149 * buffer to read the data into */
150 tag++;
151
152 if (tag >= c->max_tag) {
153 spin_lock_irqsave(&c->lock, flags);
154 /* check again since original check was outside of lock */
155 while (tag >= c->max_tag) {
156 row = (tag / P9_ROW_MAXTAG);
157 c->reqs[row] = kcalloc(P9_ROW_MAXTAG,
158 sizeof(struct p9_req_t), GFP_ATOMIC);
159
160 if (!c->reqs[row]) {
161 printk(KERN_ERR "Couldn't grow tag array\n");
162 spin_unlock_irqrestore(&c->lock, flags);
163 return ERR_PTR(-ENOMEM);
164 }
165 for (col = 0; col < P9_ROW_MAXTAG; col++) {
166 c->reqs[row][col].status = REQ_STATUS_IDLE;
167 c->reqs[row][col].tc = NULL;
168 }
169 c->max_tag += P9_ROW_MAXTAG;
170 }
171 spin_unlock_irqrestore(&c->lock, flags);
172 }
173 row = tag / P9_ROW_MAXTAG;
174 col = tag % P9_ROW_MAXTAG;
175
176 req = &c->reqs[row][col];
177 if (!req->tc) {
178 req->wq = kmalloc(sizeof(wait_queue_head_t), GFP_KERNEL);
179 if (!req->wq) {
180 printk(KERN_ERR "Couldn't grow tag array\n");
181 return ERR_PTR(-ENOMEM);
182 }
183 init_waitqueue_head(req->wq);
184 req->tc = kmalloc(sizeof(struct p9_fcall)+c->msize,
185 GFP_KERNEL);
186 req->rc = kmalloc(sizeof(struct p9_fcall)+c->msize,
187 GFP_KERNEL);
188 if ((!req->tc) || (!req->rc)) {
189 printk(KERN_ERR "Couldn't grow tag array\n");
190 kfree(req->tc);
191 kfree(req->rc);
192 return ERR_PTR(-ENOMEM);
193 }
194 req->tc->sdata = (char *) req->tc + sizeof(struct p9_fcall);
195 req->tc->capacity = c->msize;
196 req->rc->sdata = (char *) req->rc + sizeof(struct p9_fcall);
197 req->rc->capacity = c->msize;
198 }
199
200 p9pdu_reset(req->tc);
201 p9pdu_reset(req->rc);
202
203 req->flush_tag = 0;
204 req->tc->tag = tag-1;
205 req->status = REQ_STATUS_ALLOC;
206
207 return &c->reqs[row][col];
208 }
209
210 /**
211 * p9_tag_lookup - lookup a request by tag
212 * @c: client session to lookup tag within
213 * @tag: numeric id for transaction
214 *
215 */
216
217 struct p9_req_t *p9_tag_lookup(struct p9_client *c, u16 tag)
218 {
219 int row, col;
220
221 /* This looks up the original request by tag so we know which
222 * buffer to read the data into */
223 tag++;
224
225 BUG_ON(tag >= c->max_tag);
226
227 row = tag / P9_ROW_MAXTAG;
228 col = tag % P9_ROW_MAXTAG;
229
230 return &c->reqs[row][col];
231 }
232 EXPORT_SYMBOL(p9_tag_lookup);
233
234 /**
235 * p9_tag_init - setup tags structure and contents
236 * @tags: tags structure from the client struct
237 *
238 * This initializes the tags structure for each client instance.
239 *
240 */
241
242 static int p9_tag_init(struct p9_client *c)
243 {
244 int err = 0;
245
246 c->tagpool = p9_idpool_create();
247 if (IS_ERR(c->tagpool)) {
248 err = PTR_ERR(c->tagpool);
249 c->tagpool = NULL;
250 goto error;
251 }
252
253 p9_idpool_get(c->tagpool); /* reserve tag 0 */
254
255 c->max_tag = 0;
256 error:
257 return err;
258 }
259
260 /**
261 * p9_tag_cleanup - cleans up tags structure and reclaims resources
262 * @tags: tags structure from the client struct
263 *
264 * This frees resources associated with the tags structure
265 *
266 */
267 static void p9_tag_cleanup(struct p9_client *c)
268 {
269 int row, col;
270
271 /* check to insure all requests are idle */
272 for (row = 0; row < (c->max_tag/P9_ROW_MAXTAG); row++) {
273 for (col = 0; col < P9_ROW_MAXTAG; col++) {
274 if (c->reqs[row][col].status != REQ_STATUS_IDLE) {
275 P9_DPRINTK(P9_DEBUG_MUX,
276 "Attempting to cleanup non-free tag %d,%d\n",
277 row, col);
278 /* TODO: delay execution of cleanup */
279 return;
280 }
281 }
282 }
283
284 if (c->tagpool)
285 p9_idpool_destroy(c->tagpool);
286
287 /* free requests associated with tags */
288 for (row = 0; row < (c->max_tag/P9_ROW_MAXTAG); row++) {
289 for (col = 0; col < P9_ROW_MAXTAG; col++) {
290 kfree(c->reqs[row][col].wq);
291 kfree(c->reqs[row][col].tc);
292 kfree(c->reqs[row][col].rc);
293 }
294 kfree(c->reqs[row]);
295 }
296 c->max_tag = 0;
297 }
298
299 /**
300 * p9_free_req - free a request and clean-up as necessary
301 * c: client state
302 * r: request to release
303 *
304 */
305
306 static void p9_free_req(struct p9_client *c, struct p9_req_t *r)
307 {
308 int tag = r->tc->tag;
309 P9_DPRINTK(P9_DEBUG_MUX, "clnt %p req %p tag: %d\n", c, r, tag);
310
311 r->status = REQ_STATUS_IDLE;
312 if (tag != P9_NOTAG && p9_idpool_check(tag, c->tagpool))
313 p9_idpool_put(tag, c->tagpool);
314
315 /* if this was a flush request we have to free response fcall */
316 if (r->rc->id == P9_RFLUSH) {
317 kfree(r->tc);
318 kfree(r->rc);
319 }
320 }
321
322 /**
323 * p9_client_cb - call back from transport to client
324 * c: client state
325 * req: request received
326 *
327 */
328 void p9_client_cb(struct p9_client *c, struct p9_req_t *req)
329 {
330 struct p9_req_t *other_req;
331 unsigned long flags;
332
333 P9_DPRINTK(P9_DEBUG_MUX, " tag %d\n", req->tc->tag);
334
335 if (req->status == REQ_STATUS_ERROR)
336 wake_up(req->wq);
337
338 if (req->flush_tag) { /* flush receive path */
339 P9_DPRINTK(P9_DEBUG_9P, "<<< RFLUSH %d\n", req->tc->tag);
340 spin_lock_irqsave(&c->lock, flags);
341 other_req = p9_tag_lookup(c, req->flush_tag);
342 if (other_req->status != REQ_STATUS_FLSH) /* stale flush */
343 spin_unlock_irqrestore(&c->lock, flags);
344 else {
345 other_req->status = REQ_STATUS_FLSHD;
346 spin_unlock_irqrestore(&c->lock, flags);
347 wake_up(other_req->wq);
348 }
349 p9_free_req(c, req);
350 } else { /* normal receive path */
351 P9_DPRINTK(P9_DEBUG_MUX, "normal: tag %d\n", req->tc->tag);
352 spin_lock_irqsave(&c->lock, flags);
353 if (req->status != REQ_STATUS_FLSHD)
354 req->status = REQ_STATUS_RCVD;
355 spin_unlock_irqrestore(&c->lock, flags);
356 wake_up(req->wq);
357 P9_DPRINTK(P9_DEBUG_MUX, "wakeup: %d\n", req->tc->tag);
358 }
359 }
360 EXPORT_SYMBOL(p9_client_cb);
361
362 /**
363 * p9_parse_header - parse header arguments out of a packet
364 * @pdu: packet to parse
365 * @size: size of packet
366 * @type: type of request
367 * @tag: tag of packet
368 * @rewind: set if we need to rewind offset afterwards
369 */
370
371 int
372 p9_parse_header(struct p9_fcall *pdu, int32_t *size, int8_t *type, int16_t *tag,
373 int rewind)
374 {
375 int8_t r_type;
376 int16_t r_tag;
377 int32_t r_size;
378 int offset = pdu->offset;
379 int err;
380
381 pdu->offset = 0;
382 if (pdu->size == 0)
383 pdu->size = 7;
384
385 err = p9pdu_readf(pdu, 0, "dbw", &r_size, &r_type, &r_tag);
386 if (err)
387 goto rewind_and_exit;
388
389 pdu->size = r_size;
390 pdu->id = r_type;
391 pdu->tag = r_tag;
392
393 P9_DPRINTK(P9_DEBUG_9P, "<<< size=%d type: %d tag: %d\n", pdu->size,
394 pdu->id, pdu->tag);
395
396 if (type)
397 *type = r_type;
398 if (tag)
399 *tag = r_tag;
400 if (size)
401 *size = r_size;
402
403
404 rewind_and_exit:
405 if (rewind)
406 pdu->offset = offset;
407 return err;
408 }
409 EXPORT_SYMBOL(p9_parse_header);
410
411 /**
412 * p9_check_errors - check 9p packet for error return and process it
413 * @c: current client instance
414 * @req: request to parse and check for error conditions
415 *
416 * returns error code if one is discovered, otherwise returns 0
417 *
418 * this will have to be more complicated if we have multiple
419 * error packet types
420 */
421
422 static int p9_check_errors(struct p9_client *c, struct p9_req_t *req)
423 {
424 int8_t type;
425 int err;
426
427 err = p9_parse_header(req->rc, NULL, &type, NULL, 0);
428 if (err) {
429 P9_DPRINTK(P9_DEBUG_ERROR, "couldn't parse header %d\n", err);
430 return err;
431 }
432
433 if (type == P9_RERROR) {
434 int ecode;
435 char *ename;
436
437 err = p9pdu_readf(req->rc, c->dotu, "s?d", &ename, &ecode);
438 if (err) {
439 P9_DPRINTK(P9_DEBUG_ERROR, "couldn't parse error%d\n",
440 err);
441 return err;
442 }
443
444 if (c->dotu)
445 err = -ecode;
446
447 if (!err) {
448 err = p9_errstr2errno(ename, strlen(ename));
449
450 /* string match failed */
451 if (!err)
452 err = -ESERVERFAULT;
453 }
454
455 P9_DPRINTK(P9_DEBUG_9P, "<<< RERROR (%d) %s\n", -ecode, ename);
456
457 kfree(ename);
458 } else
459 err = 0;
460
461 return err;
462 }
463
464 /**
465 * p9_client_flush - flush (cancel) a request
466 * c: client state
467 * req: request to cancel
468 *
469 * This sents a flush for a particular requests and links
470 * the flush request to the original request. The current
471 * code only supports a single flush request although the protocol
472 * allows for multiple flush requests to be sent for a single request.
473 *
474 */
475
476 static int p9_client_flush(struct p9_client *c, struct p9_req_t *oldreq)
477 {
478 struct p9_req_t *req;
479 int16_t oldtag;
480 int err;
481
482 err = p9_parse_header(oldreq->tc, NULL, NULL, &oldtag, 1);
483 if (err)
484 return err;
485
486 P9_DPRINTK(P9_DEBUG_9P, ">>> TFLUSH tag %d\n", oldtag);
487
488 req = p9_client_rpc(c, P9_TFLUSH, "w", oldtag);
489 if (IS_ERR(req))
490 return PTR_ERR(req);
491
492 req->flush_tag = oldtag;
493
494 /* we don't free anything here because RPC isn't complete */
495 return 0;
496 }
497
498 /**
499 * p9_client_rpc - issue a request and wait for a response
500 * @c: client session
501 * @type: type of request
502 * @fmt: protocol format string (see protocol.c)
503 *
504 * Returns request structure (which client must free using p9_free_req)
505 */
506
507 static struct p9_req_t *
508 p9_client_rpc(struct p9_client *c, int8_t type, const char *fmt, ...)
509 {
510 va_list ap;
511 int tag, err;
512 struct p9_req_t *req;
513 unsigned long flags;
514 int sigpending;
515 int flushed = 0;
516
517 P9_DPRINTK(P9_DEBUG_MUX, "client %p op %d\n", c, type);
518
519 if (c->status != Connected)
520 return ERR_PTR(-EIO);
521
522 if (signal_pending(current)) {
523 sigpending = 1;
524 clear_thread_flag(TIF_SIGPENDING);
525 } else
526 sigpending = 0;
527
528 tag = P9_NOTAG;
529 if (type != P9_TVERSION) {
530 tag = p9_idpool_get(c->tagpool);
531 if (tag < 0)
532 return ERR_PTR(-ENOMEM);
533 }
534
535 req = p9_tag_alloc(c, tag);
536 if (IS_ERR(req))
537 return req;
538
539 /* marshall the data */
540 p9pdu_prepare(req->tc, tag, type);
541 va_start(ap, fmt);
542 err = p9pdu_vwritef(req->tc, c->dotu, fmt, ap);
543 va_end(ap);
544 p9pdu_finalize(req->tc);
545
546 err = c->trans_mod->request(c, req);
547 if (err < 0) {
548 c->status = Disconnected;
549 goto reterr;
550 }
551
552 /* if it was a flush we just transmitted, return our tag */
553 if (type == P9_TFLUSH)
554 return req;
555 again:
556 P9_DPRINTK(P9_DEBUG_MUX, "wait %p tag: %d\n", req->wq, tag);
557 err = wait_event_interruptible(*req->wq,
558 req->status >= REQ_STATUS_RCVD);
559 P9_DPRINTK(P9_DEBUG_MUX, "wait %p tag: %d returned %d (flushed=%d)\n",
560 req->wq, tag, err, flushed);
561
562 if (req->status == REQ_STATUS_ERROR) {
563 P9_DPRINTK(P9_DEBUG_ERROR, "req_status error %d\n", req->t_err);
564 err = req->t_err;
565 } else if (err == -ERESTARTSYS && flushed) {
566 P9_DPRINTK(P9_DEBUG_MUX, "flushed - going again\n");
567 goto again;
568 } else if (req->status == REQ_STATUS_FLSHD) {
569 P9_DPRINTK(P9_DEBUG_MUX, "flushed - erestartsys\n");
570 err = -ERESTARTSYS;
571 }
572
573 if ((err == -ERESTARTSYS) && (c->status == Connected) && (!flushed)) {
574 P9_DPRINTK(P9_DEBUG_MUX, "flushing\n");
575 spin_lock_irqsave(&c->lock, flags);
576 if (req->status == REQ_STATUS_SENT)
577 req->status = REQ_STATUS_FLSH;
578 spin_unlock_irqrestore(&c->lock, flags);
579 sigpending = 1;
580 flushed = 1;
581 clear_thread_flag(TIF_SIGPENDING);
582
583 if (c->trans_mod->cancel(c, req)) {
584 err = p9_client_flush(c, req);
585 if (err == 0)
586 goto again;
587 }
588 }
589
590 if (sigpending) {
591 spin_lock_irqsave(&current->sighand->siglock, flags);
592 recalc_sigpending();
593 spin_unlock_irqrestore(&current->sighand->siglock, flags);
594 }
595
596 if (err < 0)
597 goto reterr;
598
599 err = p9_check_errors(c, req);
600 if (!err) {
601 P9_DPRINTK(P9_DEBUG_MUX, "exit: client %p op %d\n", c, type);
602 return req;
603 }
604
605 reterr:
606 P9_DPRINTK(P9_DEBUG_MUX, "exit: client %p op %d error: %d\n", c, type,
607 err);
608 p9_free_req(c, req);
609 return ERR_PTR(err);
610 }
611
612 static struct p9_fid *p9_fid_create(struct p9_client *clnt)
613 {
614 int err;
615 struct p9_fid *fid;
616
617 P9_DPRINTK(P9_DEBUG_FID, "clnt %p\n", clnt);
618 fid = kmalloc(sizeof(struct p9_fid), GFP_KERNEL);
619 if (!fid)
620 return ERR_PTR(-ENOMEM);
621
622 fid->fid = p9_idpool_get(clnt->fidpool);
623 if (fid->fid < 0) {
624 err = -ENOSPC;
625 goto error;
626 }
627
628 memset(&fid->qid, 0, sizeof(struct p9_qid));
629 fid->mode = -1;
630 fid->rdir_fpos = 0;
631 fid->uid = current->fsuid;
632 fid->clnt = clnt;
633 fid->aux = NULL;
634
635 spin_lock(&clnt->lock);
636 list_add(&fid->flist, &clnt->fidlist);
637 spin_unlock(&clnt->lock);
638
639 return fid;
640
641 error:
642 kfree(fid);
643 return ERR_PTR(err);
644 }
645
646 static void p9_fid_destroy(struct p9_fid *fid)
647 {
648 struct p9_client *clnt;
649
650 P9_DPRINTK(P9_DEBUG_FID, "fid %d\n", fid->fid);
651 clnt = fid->clnt;
652 p9_idpool_put(fid->fid, clnt->fidpool);
653 spin_lock(&clnt->lock);
654 list_del(&fid->flist);
655 spin_unlock(&clnt->lock);
656 kfree(fid);
657 }
658
659 int p9_client_version(struct p9_client *c)
660 {
661 int err = 0;
662 struct p9_req_t *req;
663 char *version;
664 int msize;
665
666 P9_DPRINTK(P9_DEBUG_9P, ">>> TVERSION msize %d extended %d\n",
667 c->msize, c->dotu);
668 req = p9_client_rpc(c, P9_TVERSION, "ds", c->msize,
669 c->dotu ? "9P2000.u" : "9P2000");
670 if (IS_ERR(req))
671 return PTR_ERR(req);
672
673 err = p9pdu_readf(req->rc, c->dotu, "ds", &msize, &version);
674 if (err) {
675 P9_DPRINTK(P9_DEBUG_9P, "version error %d\n", err);
676 p9pdu_dump(1, req->rc);
677 goto error;
678 }
679
680 P9_DPRINTK(P9_DEBUG_9P, "<<< RVERSION msize %d %s\n", msize, version);
681 if (!memcmp(version, "9P2000.u", 8))
682 c->dotu = 1;
683 else if (!memcmp(version, "9P2000", 6))
684 c->dotu = 0;
685 else {
686 err = -EREMOTEIO;
687 goto error;
688 }
689
690 if (msize < c->msize)
691 c->msize = msize;
692
693 error:
694 kfree(version);
695 p9_free_req(c, req);
696
697 return err;
698 }
699 EXPORT_SYMBOL(p9_client_version);
700
701 struct p9_client *p9_client_create(const char *dev_name, char *options)
702 {
703 int err;
704 struct p9_client *clnt;
705
706 err = 0;
707 clnt = kmalloc(sizeof(struct p9_client), GFP_KERNEL);
708 if (!clnt)
709 return ERR_PTR(-ENOMEM);
710
711 clnt->trans_mod = NULL;
712 clnt->trans = NULL;
713 spin_lock_init(&clnt->lock);
714 INIT_LIST_HEAD(&clnt->fidlist);
715 clnt->fidpool = p9_idpool_create();
716 if (IS_ERR(clnt->fidpool)) {
717 err = PTR_ERR(clnt->fidpool);
718 clnt->fidpool = NULL;
719 goto error;
720 }
721
722 p9_tag_init(clnt);
723
724 err = parse_opts(options, clnt);
725 if (err < 0)
726 goto error;
727
728 if (clnt->trans_mod == NULL) {
729 err = -EPROTONOSUPPORT;
730 P9_DPRINTK(P9_DEBUG_ERROR,
731 "No transport defined or default transport\n");
732 goto error;
733 }
734
735 P9_DPRINTK(P9_DEBUG_MUX, "clnt %p trans %p msize %d dotu %d\n",
736 clnt, clnt->trans_mod, clnt->msize, clnt->dotu);
737
738 err = clnt->trans_mod->create(clnt, dev_name, options);
739 if (err)
740 goto error;
741
742 if ((clnt->msize+P9_IOHDRSZ) > clnt->trans_mod->maxsize)
743 clnt->msize = clnt->trans_mod->maxsize-P9_IOHDRSZ;
744
745 err = p9_client_version(clnt);
746 if (err)
747 goto error;
748
749 return clnt;
750
751 error:
752 p9_client_destroy(clnt);
753 return ERR_PTR(err);
754 }
755 EXPORT_SYMBOL(p9_client_create);
756
757 void p9_client_destroy(struct p9_client *clnt)
758 {
759 struct p9_fid *fid, *fidptr;
760
761 P9_DPRINTK(P9_DEBUG_MUX, "clnt %p\n", clnt);
762
763 if (clnt->trans_mod)
764 clnt->trans_mod->close(clnt);
765
766 v9fs_put_trans(clnt->trans_mod);
767
768 list_for_each_entry_safe(fid, fidptr, &clnt->fidlist, flist)
769 p9_fid_destroy(fid);
770
771 if (clnt->fidpool)
772 p9_idpool_destroy(clnt->fidpool);
773
774 p9_tag_cleanup(clnt);
775
776 kfree(clnt);
777 }
778 EXPORT_SYMBOL(p9_client_destroy);
779
780 void p9_client_disconnect(struct p9_client *clnt)
781 {
782 P9_DPRINTK(P9_DEBUG_9P, "clnt %p\n", clnt);
783 clnt->status = Disconnected;
784 }
785 EXPORT_SYMBOL(p9_client_disconnect);
786
787 struct p9_fid *p9_client_attach(struct p9_client *clnt, struct p9_fid *afid,
788 char *uname, u32 n_uname, char *aname)
789 {
790 int err;
791 struct p9_req_t *req;
792 struct p9_fid *fid;
793 struct p9_qid qid;
794
795 P9_DPRINTK(P9_DEBUG_9P, ">>> TATTACH afid %d uname %s aname %s\n",
796 afid ? afid->fid : -1, uname, aname);
797 err = 0;
798
799 fid = p9_fid_create(clnt);
800 if (IS_ERR(fid)) {
801 err = PTR_ERR(fid);
802 fid = NULL;
803 goto error;
804 }
805
806 req = p9_client_rpc(clnt, P9_TATTACH, "ddss?d", fid->fid,
807 afid ? afid->fid : P9_NOFID, uname, aname, n_uname);
808 if (IS_ERR(req)) {
809 err = PTR_ERR(req);
810 goto error;
811 }
812
813 err = p9pdu_readf(req->rc, clnt->dotu, "Q", &qid);
814 if (err) {
815 p9pdu_dump(1, req->rc);
816 p9_free_req(clnt, req);
817 goto error;
818 }
819
820 P9_DPRINTK(P9_DEBUG_9P, "<<< RATTACH qid %x.%llx.%x\n",
821 qid.type, qid.path, qid.version);
822
823 memmove(&fid->qid, &qid, sizeof(struct p9_qid));
824
825 p9_free_req(clnt, req);
826 return fid;
827
828 error:
829 if (fid)
830 p9_fid_destroy(fid);
831 return ERR_PTR(err);
832 }
833 EXPORT_SYMBOL(p9_client_attach);
834
835 struct p9_fid *
836 p9_client_auth(struct p9_client *clnt, char *uname, u32 n_uname, char *aname)
837 {
838 int err;
839 struct p9_req_t *req;
840 struct p9_qid qid;
841 struct p9_fid *afid;
842
843 P9_DPRINTK(P9_DEBUG_9P, ">>> TAUTH uname %s aname %s\n", uname, aname);
844 err = 0;
845
846 afid = p9_fid_create(clnt);
847 if (IS_ERR(afid)) {
848 err = PTR_ERR(afid);
849 afid = NULL;
850 goto error;
851 }
852
853 req = p9_client_rpc(clnt, P9_TAUTH, "dss?d",
854 afid ? afid->fid : P9_NOFID, uname, aname, n_uname);
855 if (IS_ERR(req)) {
856 err = PTR_ERR(req);
857 goto error;
858 }
859
860 err = p9pdu_readf(req->rc, clnt->dotu, "Q", &qid);
861 if (err) {
862 p9pdu_dump(1, req->rc);
863 p9_free_req(clnt, req);
864 goto error;
865 }
866
867 P9_DPRINTK(P9_DEBUG_9P, "<<< RAUTH qid %x.%llx.%x\n",
868 qid.type, qid.path, qid.version);
869
870 memmove(&afid->qid, &qid, sizeof(struct p9_qid));
871 p9_free_req(clnt, req);
872 return afid;
873
874 error:
875 if (afid)
876 p9_fid_destroy(afid);
877 return ERR_PTR(err);
878 }
879 EXPORT_SYMBOL(p9_client_auth);
880
881 struct p9_fid *p9_client_walk(struct p9_fid *oldfid, int nwname, char **wnames,
882 int clone)
883 {
884 int err;
885 struct p9_client *clnt;
886 struct p9_fid *fid;
887 struct p9_qid *wqids;
888 struct p9_req_t *req;
889 int16_t nwqids, count;
890
891 err = 0;
892 clnt = oldfid->clnt;
893 if (clone) {
894 fid = p9_fid_create(clnt);
895 if (IS_ERR(fid)) {
896 err = PTR_ERR(fid);
897 fid = NULL;
898 goto error;
899 }
900
901 fid->uid = oldfid->uid;
902 } else
903 fid = oldfid;
904
905
906 P9_DPRINTK(P9_DEBUG_9P, ">>> TWALK fids %d,%d nwname %d wname[0] %s\n",
907 oldfid->fid, fid->fid, nwname, wnames ? wnames[0] : NULL);
908
909 req = p9_client_rpc(clnt, P9_TWALK, "ddT", oldfid->fid, fid->fid,
910 nwname, wnames);
911 if (IS_ERR(req)) {
912 err = PTR_ERR(req);
913 goto error;
914 }
915
916 err = p9pdu_readf(req->rc, clnt->dotu, "R", &nwqids, &wqids);
917 if (err) {
918 p9pdu_dump(1, req->rc);
919 p9_free_req(clnt, req);
920 goto clunk_fid;
921 }
922 p9_free_req(clnt, req);
923
924 P9_DPRINTK(P9_DEBUG_9P, "<<< RWALK nwqid %d:\n", nwqids);
925
926 if (nwqids != nwname) {
927 err = -ENOENT;
928 goto clunk_fid;
929 }
930
931 for (count = 0; count < nwqids; count++)
932 P9_DPRINTK(P9_DEBUG_9P, "<<< [%d] %x.%llx.%x\n",
933 count, wqids[count].type, wqids[count].path,
934 wqids[count].version);
935
936 if (nwname)
937 memmove(&fid->qid, &wqids[nwqids - 1], sizeof(struct p9_qid));
938 else
939 fid->qid = oldfid->qid;
940
941 return fid;
942
943 clunk_fid:
944 p9_client_clunk(fid);
945 fid = NULL;
946
947 error:
948 if (fid && (fid != oldfid))
949 p9_fid_destroy(fid);
950
951 return ERR_PTR(err);
952 }
953 EXPORT_SYMBOL(p9_client_walk);
954
955 int p9_client_open(struct p9_fid *fid, int mode)
956 {
957 int err;
958 struct p9_client *clnt;
959 struct p9_req_t *req;
960 struct p9_qid qid;
961 int iounit;
962
963 P9_DPRINTK(P9_DEBUG_9P, ">>> TOPEN fid %d mode %d\n", fid->fid, mode);
964 err = 0;
965 clnt = fid->clnt;
966
967 if (fid->mode != -1)
968 return -EINVAL;
969
970 req = p9_client_rpc(clnt, P9_TOPEN, "db", fid->fid, mode);
971 if (IS_ERR(req)) {
972 err = PTR_ERR(req);
973 goto error;
974 }
975
976 err = p9pdu_readf(req->rc, clnt->dotu, "Qd", &qid, &iounit);
977 if (err) {
978 p9pdu_dump(1, req->rc);
979 goto free_and_error;
980 }
981
982 P9_DPRINTK(P9_DEBUG_9P, "<<< ROPEN qid %x.%llx.%x iounit %x\n",
983 qid.type, qid.path, qid.version, iounit);
984
985 fid->mode = mode;
986 fid->iounit = iounit;
987
988 free_and_error:
989 p9_free_req(clnt, req);
990 error:
991 return err;
992 }
993 EXPORT_SYMBOL(p9_client_open);
994
995 int p9_client_fcreate(struct p9_fid *fid, char *name, u32 perm, int mode,
996 char *extension)
997 {
998 int err;
999 struct p9_client *clnt;
1000 struct p9_req_t *req;
1001 struct p9_qid qid;
1002 int iounit;
1003
1004 P9_DPRINTK(P9_DEBUG_9P, ">>> TCREATE fid %d name %s perm %d mode %d\n",
1005 fid->fid, name, perm, mode);
1006 err = 0;
1007 clnt = fid->clnt;
1008
1009 if (fid->mode != -1)
1010 return -EINVAL;
1011
1012 req = p9_client_rpc(clnt, P9_TCREATE, "dsdb?s", fid->fid, name, perm,
1013 mode, extension);
1014 if (IS_ERR(req)) {
1015 err = PTR_ERR(req);
1016 goto error;
1017 }
1018
1019 err = p9pdu_readf(req->rc, clnt->dotu, "Qd", &qid, &iounit);
1020 if (err) {
1021 p9pdu_dump(1, req->rc);
1022 goto free_and_error;
1023 }
1024
1025 P9_DPRINTK(P9_DEBUG_9P, "<<< RCREATE qid %x.%llx.%x iounit %x\n",
1026 qid.type, qid.path, qid.version, iounit);
1027
1028 fid->mode = mode;
1029 fid->iounit = iounit;
1030
1031 free_and_error:
1032 p9_free_req(clnt, req);
1033 error:
1034 return err;
1035 }
1036 EXPORT_SYMBOL(p9_client_fcreate);
1037
1038 int p9_client_clunk(struct p9_fid *fid)
1039 {
1040 int err;
1041 struct p9_client *clnt;
1042 struct p9_req_t *req;
1043
1044 P9_DPRINTK(P9_DEBUG_9P, ">>> TCLUNK fid %d\n", fid->fid);
1045 err = 0;
1046 clnt = fid->clnt;
1047
1048 req = p9_client_rpc(clnt, P9_TCLUNK, "d", fid->fid);
1049 if (IS_ERR(req)) {
1050 err = PTR_ERR(req);
1051 goto error;
1052 }
1053
1054 P9_DPRINTK(P9_DEBUG_9P, "<<< RCLUNK fid %d\n", fid->fid);
1055
1056 p9_free_req(clnt, req);
1057 p9_fid_destroy(fid);
1058
1059 error:
1060 return err;
1061 }
1062 EXPORT_SYMBOL(p9_client_clunk);
1063
1064 int p9_client_remove(struct p9_fid *fid)
1065 {
1066 int err;
1067 struct p9_client *clnt;
1068 struct p9_req_t *req;
1069
1070 P9_DPRINTK(P9_DEBUG_9P, ">>> TREMOVE fid %d\n", fid->fid);
1071 err = 0;
1072 clnt = fid->clnt;
1073
1074 req = p9_client_rpc(clnt, P9_TREMOVE, "d", fid->fid);
1075 if (IS_ERR(req)) {
1076 err = PTR_ERR(req);
1077 goto error;
1078 }
1079
1080 P9_DPRINTK(P9_DEBUG_9P, "<<< RREMOVE fid %d\n", fid->fid);
1081
1082 p9_free_req(clnt, req);
1083 p9_fid_destroy(fid);
1084
1085 error:
1086 return err;
1087 }
1088 EXPORT_SYMBOL(p9_client_remove);
1089
1090 int
1091 p9_client_read(struct p9_fid *fid, char *data, char __user *udata, u64 offset,
1092 u32 count)
1093 {
1094 int err, rsize, total;
1095 struct p9_client *clnt;
1096 struct p9_req_t *req;
1097 char *dataptr;
1098
1099 P9_DPRINTK(P9_DEBUG_9P, ">>> TREAD fid %d offset %llu %d\n", fid->fid,
1100 (long long unsigned) offset, count);
1101 err = 0;
1102 clnt = fid->clnt;
1103 total = 0;
1104
1105 rsize = fid->iounit;
1106 if (!rsize || rsize > clnt->msize-P9_IOHDRSZ)
1107 rsize = clnt->msize - P9_IOHDRSZ;
1108
1109 if (count < rsize)
1110 rsize = count;
1111
1112 req = p9_client_rpc(clnt, P9_TREAD, "dqd", fid->fid, offset, rsize);
1113 if (IS_ERR(req)) {
1114 err = PTR_ERR(req);
1115 goto error;
1116 }
1117
1118 err = p9pdu_readf(req->rc, clnt->dotu, "D", &count, &dataptr);
1119 if (err) {
1120 p9pdu_dump(1, req->rc);
1121 goto free_and_error;
1122 }
1123
1124 P9_DPRINTK(P9_DEBUG_9P, "<<< RREAD count %d\n", count);
1125
1126 if (data) {
1127 memmove(data, dataptr, count);
1128 data += count;
1129 }
1130
1131 if (udata) {
1132 err = copy_to_user(udata, dataptr, count);
1133 if (err) {
1134 err = -EFAULT;
1135 goto free_and_error;
1136 }
1137 }
1138
1139 p9_free_req(clnt, req);
1140 return count;
1141
1142 free_and_error:
1143 p9_free_req(clnt, req);
1144 error:
1145 return err;
1146 }
1147 EXPORT_SYMBOL(p9_client_read);
1148
1149 int
1150 p9_client_write(struct p9_fid *fid, char *data, const char __user *udata,
1151 u64 offset, u32 count)
1152 {
1153 int err, rsize, total;
1154 struct p9_client *clnt;
1155 struct p9_req_t *req;
1156
1157 P9_DPRINTK(P9_DEBUG_9P, ">>> TWRITE fid %d offset %llu count %d\n",
1158 fid->fid, (long long unsigned) offset, count);
1159 err = 0;
1160 clnt = fid->clnt;
1161 total = 0;
1162
1163 rsize = fid->iounit;
1164 if (!rsize || rsize > clnt->msize-P9_IOHDRSZ)
1165 rsize = clnt->msize - P9_IOHDRSZ;
1166
1167 if (count < rsize)
1168 rsize = count;
1169 if (data)
1170 req = p9_client_rpc(clnt, P9_TWRITE, "dqD", fid->fid, offset,
1171 rsize, data);
1172 else
1173 req = p9_client_rpc(clnt, P9_TWRITE, "dqU", fid->fid, offset,
1174 rsize, udata);
1175 if (IS_ERR(req)) {
1176 err = PTR_ERR(req);
1177 goto error;
1178 }
1179
1180 err = p9pdu_readf(req->rc, clnt->dotu, "d", &count);
1181 if (err) {
1182 p9pdu_dump(1, req->rc);
1183 goto free_and_error;
1184 }
1185
1186 P9_DPRINTK(P9_DEBUG_9P, "<<< RWRITE count %d\n", count);
1187
1188 p9_free_req(clnt, req);
1189 return count;
1190
1191 free_and_error:
1192 p9_free_req(clnt, req);
1193 error:
1194 return err;
1195 }
1196 EXPORT_SYMBOL(p9_client_write);
1197
1198 struct p9_wstat *p9_client_stat(struct p9_fid *fid)
1199 {
1200 int err;
1201 struct p9_client *clnt;
1202 struct p9_wstat *ret = kmalloc(sizeof(struct p9_wstat), GFP_KERNEL);
1203 struct p9_req_t *req;
1204 u16 ignored;
1205
1206 P9_DPRINTK(P9_DEBUG_9P, ">>> TSTAT fid %d\n", fid->fid);
1207
1208 if (!ret)
1209 return ERR_PTR(-ENOMEM);
1210
1211 err = 0;
1212 clnt = fid->clnt;
1213
1214 req = p9_client_rpc(clnt, P9_TSTAT, "d", fid->fid);
1215 if (IS_ERR(req)) {
1216 err = PTR_ERR(req);
1217 goto error;
1218 }
1219
1220 err = p9pdu_readf(req->rc, clnt->dotu, "wS", &ignored, ret);
1221 if (err) {
1222 ret = ERR_PTR(err);
1223 p9pdu_dump(1, req->rc);
1224 goto free_and_error;
1225 }
1226
1227 P9_DPRINTK(P9_DEBUG_9P,
1228 "<<< RSTAT sz=%x type=%x dev=%x qid=%x.%llx.%x\n"
1229 "<<< mode=%8.8x atime=%8.8x mtime=%8.8x length=%llx\n"
1230 "<<< name=%s uid=%s gid=%s muid=%s extension=(%s)\n"
1231 "<<< uid=%d gid=%d n_muid=%d\n",
1232 ret->size, ret->type, ret->dev, ret->qid.type,
1233 ret->qid.path, ret->qid.version, ret->mode,
1234 ret->atime, ret->mtime, ret->length, ret->name,
1235 ret->uid, ret->gid, ret->muid, ret->extension,
1236 ret->n_uid, ret->n_gid, ret->n_muid);
1237
1238 free_and_error:
1239 p9_free_req(clnt, req);
1240 error:
1241 return ret;
1242 }
1243 EXPORT_SYMBOL(p9_client_stat);
1244
1245 int p9_client_wstat(struct p9_fid *fid, struct p9_wstat *wst)
1246 {
1247 int err;
1248 struct p9_req_t *req;
1249 struct p9_client *clnt;
1250
1251 P9_DPRINTK(P9_DEBUG_9P, ">>> TWSTAT fid %d\n", fid->fid);
1252 P9_DPRINTK(P9_DEBUG_9P,
1253 " sz=%x type=%x dev=%x qid=%x.%llx.%x\n"
1254 " mode=%8.8x atime=%8.8x mtime=%8.8x length=%llx\n"
1255 " name=%s uid=%s gid=%s muid=%s extension=(%s)\n"
1256 " uid=%d gid=%d n_muid=%d\n",
1257 wst->size, wst->type, wst->dev, wst->qid.type,
1258 wst->qid.path, wst->qid.version, wst->mode,
1259 wst->atime, wst->mtime, wst->length, wst->name,
1260 wst->uid, wst->gid, wst->muid, wst->extension,
1261 wst->n_uid, wst->n_gid, wst->n_muid);
1262 err = 0;
1263 clnt = fid->clnt;
1264
1265 req = p9_client_rpc(clnt, P9_TWSTAT, "dwS", fid->fid, 0, wst);
1266 if (IS_ERR(req)) {
1267 err = PTR_ERR(req);
1268 goto error;
1269 }
1270
1271 P9_DPRINTK(P9_DEBUG_9P, "<<< RWSTAT fid %d\n", fid->fid);
1272
1273 p9_free_req(clnt, req);
1274 error:
1275 return err;
1276 }
1277 EXPORT_SYMBOL(p9_client_wstat);
Linux with added FPC-III support