9p: introduce missing kfree
[linux-2.6.git] / net / 9p / trans_fd.c
1 /*
2  * linux/fs/9p/trans_fd.c
3  *
4  * Fd transport layer.  Includes deprecated socket layer.
5  *
6  *  Copyright (C) 2006 by Russ Cox <rsc@swtch.com>
7  *  Copyright (C) 2004-2005 by Latchesar Ionkov <lucho@ionkov.net>
8  *  Copyright (C) 2004-2008 by Eric Van Hensbergen <ericvh@gmail.com>
9  *  Copyright (C) 1997-2002 by Ron Minnich <rminnich@sarnoff.com>
10  *
11  *  This program is free software; you can redistribute it and/or modify
12  *  it under the terms of the GNU General Public License version 2
13  *  as published by the Free Software Foundation.
14  *
15  *  This program is distributed in the hope that it will be useful,
16  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  *  GNU General Public License for more details.
19  *
20  *  You should have received a copy of the GNU General Public License
21  *  along with this program; if not, write to:
22  *  Free Software Foundation
23  *  51 Franklin Street, Fifth Floor
24  *  Boston, MA  02111-1301  USA
25  *
26  */
27
28 #include <linux/in.h>
29 #include <linux/module.h>
30 #include <linux/net.h>
31 #include <linux/ipv6.h>
32 #include <linux/kthread.h>
33 #include <linux/errno.h>
34 #include <linux/kernel.h>
35 #include <linux/un.h>
36 #include <linux/uaccess.h>
37 #include <linux/inet.h>
38 #include <linux/idr.h>
39 #include <linux/file.h>
40 #include <linux/parser.h>
41 #include <net/9p/9p.h>
42 #include <net/9p/transport.h>
43
44 #define P9_PORT 564
45 #define MAX_SOCK_BUF (64*1024)
46 #define ERREQFLUSH      1
47 #define SCHED_TIMEOUT   10
48 #define MAXPOLLWADDR    2
49
50 /**
51  * struct p9_fd_opts - per-transport options
52  * @rfd: file descriptor for reading (trans=fd)
53  * @wfd: file descriptor for writing (trans=fd)
54  * @port: port to connect to (trans=tcp)
55  *
56  */
57
58 struct p9_fd_opts {
59         int rfd;
60         int wfd;
61         u16 port;
62 };
63
64
65 /**
66  * struct p9_trans_fd - transport state
67  * @rd: reference to file to read from
68  * @wr: reference of file to write to
69  * @conn: connection state reference
70  *
71  */
72
73 struct p9_trans_fd {
74         struct file *rd;
75         struct file *wr;
76         struct p9_conn *conn;
77 };
78
79 /*
80   * Option Parsing (code inspired by NFS code)
81   *  - a little lazy - parse all fd-transport options
82   */
83
84 enum {
85         /* Options that take integer arguments */
86         Opt_port, Opt_rfdno, Opt_wfdno, Opt_err,
87 };
88
89 static match_table_t tokens = {
90         {Opt_port, "port=%u"},
91         {Opt_rfdno, "rfdno=%u"},
92         {Opt_wfdno, "wfdno=%u"},
93         {Opt_err, NULL},
94 };
95
96 enum {
97         Rworksched = 1,         /* read work scheduled or running */
98         Rpending = 2,           /* can read */
99         Wworksched = 4,         /* write work scheduled or running */
100         Wpending = 8,           /* can write */
101 };
102
103 enum {
104         None,
105         Flushing,
106         Flushed,
107 };
108
109 struct p9_req;
110 typedef void (*p9_conn_req_callback)(struct p9_req *req, void *a);
111
112 /**
113  * struct p9_req - fd mux encoding of an rpc transaction
114  * @lock: protects req_list
115  * @tag: numeric tag for rpc transaction
116  * @tcall: request &p9_fcall structure
117  * @rcall: response &p9_fcall structure
118  * @err: error state
119  * @cb: callback for when response is received
120  * @cba: argument to pass to callback
121  * @flush: flag to indicate RPC has been flushed
122  * @req_list: list link for higher level objects to chain requests
123  *
124  */
125
126 struct p9_req {
127         spinlock_t lock;
128         int tag;
129         struct p9_fcall *tcall;
130         struct p9_fcall *rcall;
131         int err;
132         p9_conn_req_callback cb;
133         void *cba;
134         int flush;
135         struct list_head req_list;
136 };
137
138 struct p9_mux_poll_task {
139         struct task_struct *task;
140         struct list_head mux_list;
141         int muxnum;
142 };
143
144 /**
145  * struct p9_conn - fd mux connection state information
146  * @lock: protects mux_list (?)
147  * @mux_list: list link for mux to manage multiple connections (?)
148  * @poll_task: task polling on this connection
149  * @msize: maximum size for connection (dup)
150  * @extended: 9p2000.u flag (dup)
151  * @trans: reference to transport instance for this connection
152  * @tagpool: id accounting for transactions
153  * @err: error state
154  * @req_list: accounting for requests which have been sent
155  * @unsent_req_list: accounting for requests that haven't been sent
156  * @rcall: current response &p9_fcall structure
157  * @rpos: read position in current frame
158  * @rbuf: current read buffer
159  * @wpos: write position for current frame
160  * @wsize: amount of data to write for current frame
161  * @wbuf: current write buffer
162  * @poll_wait: array of wait_q's for various worker threads
163  * @poll_waddr: ????
164  * @pt: poll state
165  * @rq: current read work
166  * @wq: current write work
167  * @wsched: ????
168  *
169  */
170
171 struct p9_conn {
172         spinlock_t lock; /* protect lock structure */
173         struct list_head mux_list;
174         struct p9_mux_poll_task *poll_task;
175         int msize;
176         unsigned char extended;
177         struct p9_trans *trans;
178         struct p9_idpool *tagpool;
179         int err;
180         struct list_head req_list;
181         struct list_head unsent_req_list;
182         struct p9_fcall *rcall;
183         int rpos;
184         char *rbuf;
185         int wpos;
186         int wsize;
187         char *wbuf;
188         wait_queue_t poll_wait[MAXPOLLWADDR];
189         wait_queue_head_t *poll_waddr[MAXPOLLWADDR];
190         poll_table pt;
191         struct work_struct rq;
192         struct work_struct wq;
193         unsigned long wsched;
194 };
195
196 /**
197  * struct p9_mux_rpc - fd mux rpc accounting structure
198  * @m: connection this request was issued on
199  * @err: error state
200  * @tcall: request &p9_fcall
201  * @rcall: response &p9_fcall
202  * @wqueue: wait queue that client is blocked on for this rpc
203  *
204  * Bug: isn't this information duplicated elsewhere like &p9_req
205  */
206
207 struct p9_mux_rpc {
208         struct p9_conn *m;
209         int err;
210         struct p9_fcall *tcall;
211         struct p9_fcall *rcall;
212         wait_queue_head_t wqueue;
213 };
214
215 static int p9_poll_proc(void *);
216 static void p9_read_work(struct work_struct *work);
217 static void p9_write_work(struct work_struct *work);
218 static void p9_pollwait(struct file *filp, wait_queue_head_t *wait_address,
219                                                                 poll_table *p);
220 static int p9_fd_write(struct p9_trans *trans, void *v, int len);
221 static int p9_fd_read(struct p9_trans *trans, void *v, int len);
222
223 static DEFINE_MUTEX(p9_mux_task_lock);
224 static struct workqueue_struct *p9_mux_wq;
225
226 static int p9_mux_num;
227 static int p9_mux_poll_task_num;
228 static struct p9_mux_poll_task p9_mux_poll_tasks[100];
229
230 static void p9_conn_destroy(struct p9_conn *);
231 static unsigned int p9_fd_poll(struct p9_trans *trans,
232                                                 struct poll_table_struct *pt);
233
234 #ifdef P9_NONBLOCK
235 static int p9_conn_rpcnb(struct p9_conn *m, struct p9_fcall *tc,
236         p9_conn_req_callback cb, void *a);
237 #endif /* P9_NONBLOCK */
238
239 static void p9_conn_cancel(struct p9_conn *m, int err);
240
241 static u16 p9_mux_get_tag(struct p9_conn *m)
242 {
243         int tag;
244
245         tag = p9_idpool_get(m->tagpool);
246         if (tag < 0)
247                 return P9_NOTAG;
248         else
249                 return (u16) tag;
250 }
251
252 static void p9_mux_put_tag(struct p9_conn *m, u16 tag)
253 {
254         if (tag != P9_NOTAG && p9_idpool_check(tag, m->tagpool))
255                 p9_idpool_put(tag, m->tagpool);
256 }
257
258 /**
259  * p9_mux_calc_poll_procs - calculates the number of polling procs
260  * @muxnum: number of mounts
261  *
262  * Calculation is based on the number of mounted v9fs filesystems.
263  * The current implementation returns sqrt of the number of mounts.
264  */
265
266 static int p9_mux_calc_poll_procs(int muxnum)
267 {
268         int n;
269
270         if (p9_mux_poll_task_num)
271                 n = muxnum / p9_mux_poll_task_num +
272                     (muxnum % p9_mux_poll_task_num ? 1 : 0);
273         else
274                 n = 1;
275
276         if (n > ARRAY_SIZE(p9_mux_poll_tasks))
277                 n = ARRAY_SIZE(p9_mux_poll_tasks);
278
279         return n;
280 }
281
282 static int p9_mux_poll_start(struct p9_conn *m)
283 {
284         int i, n;
285         struct p9_mux_poll_task *vpt, *vptlast;
286         struct task_struct *pproc;
287
288         P9_DPRINTK(P9_DEBUG_MUX, "mux %p muxnum %d procnum %d\n", m, p9_mux_num,
289                 p9_mux_poll_task_num);
290         mutex_lock(&p9_mux_task_lock);
291
292         n = p9_mux_calc_poll_procs(p9_mux_num + 1);
293         if (n > p9_mux_poll_task_num) {
294                 for (i = 0; i < ARRAY_SIZE(p9_mux_poll_tasks); i++) {
295                         if (p9_mux_poll_tasks[i].task == NULL) {
296                                 vpt = &p9_mux_poll_tasks[i];
297                                 P9_DPRINTK(P9_DEBUG_MUX, "create proc %p\n",
298                                                                         vpt);
299                                 pproc = kthread_create(p9_poll_proc, vpt,
300                                                                 "v9fs-poll");
301
302                                 if (!IS_ERR(pproc)) {
303                                         vpt->task = pproc;
304                                         INIT_LIST_HEAD(&vpt->mux_list);
305                                         vpt->muxnum = 0;
306                                         p9_mux_poll_task_num++;
307                                         wake_up_process(vpt->task);
308                                 }
309                                 break;
310                         }
311                 }
312
313                 if (i >= ARRAY_SIZE(p9_mux_poll_tasks))
314                         P9_DPRINTK(P9_DEBUG_ERROR,
315                                         "warning: no free poll slots\n");
316         }
317
318         n = (p9_mux_num + 1) / p9_mux_poll_task_num +
319             ((p9_mux_num + 1) % p9_mux_poll_task_num ? 1 : 0);
320
321         vptlast = NULL;
322         for (i = 0; i < ARRAY_SIZE(p9_mux_poll_tasks); i++) {
323                 vpt = &p9_mux_poll_tasks[i];
324                 if (vpt->task != NULL) {
325                         vptlast = vpt;
326                         if (vpt->muxnum < n) {
327                                 P9_DPRINTK(P9_DEBUG_MUX, "put in proc %d\n", i);
328                                 list_add(&m->mux_list, &vpt->mux_list);
329                                 vpt->muxnum++;
330                                 m->poll_task = vpt;
331                                 memset(&m->poll_waddr, 0,
332                                                         sizeof(m->poll_waddr));
333                                 init_poll_funcptr(&m->pt, p9_pollwait);
334                                 break;
335                         }
336                 }
337         }
338
339         if (i >= ARRAY_SIZE(p9_mux_poll_tasks)) {
340                 if (vptlast == NULL) {
341                         mutex_unlock(&p9_mux_task_lock);
342                         return -ENOMEM;
343                 }
344
345                 P9_DPRINTK(P9_DEBUG_MUX, "put in proc %d\n", i);
346                 list_add(&m->mux_list, &vptlast->mux_list);
347                 vptlast->muxnum++;
348                 m->poll_task = vptlast;
349                 memset(&m->poll_waddr, 0, sizeof(m->poll_waddr));
350                 init_poll_funcptr(&m->pt, p9_pollwait);
351         }
352
353         p9_mux_num++;
354         mutex_unlock(&p9_mux_task_lock);
355
356         return 0;
357 }
358
359 static void p9_mux_poll_stop(struct p9_conn *m)
360 {
361         int i;
362         struct p9_mux_poll_task *vpt;
363
364         mutex_lock(&p9_mux_task_lock);
365         vpt = m->poll_task;
366         list_del(&m->mux_list);
367         for (i = 0; i < ARRAY_SIZE(m->poll_waddr); i++) {
368                 if (m->poll_waddr[i] != NULL) {
369                         remove_wait_queue(m->poll_waddr[i], &m->poll_wait[i]);
370                         m->poll_waddr[i] = NULL;
371                 }
372         }
373         vpt->muxnum--;
374         if (!vpt->muxnum) {
375                 P9_DPRINTK(P9_DEBUG_MUX, "destroy proc %p\n", vpt);
376                 kthread_stop(vpt->task);
377                 vpt->task = NULL;
378                 p9_mux_poll_task_num--;
379         }
380         p9_mux_num--;
381         mutex_unlock(&p9_mux_task_lock);
382 }
383
384 /**
385  * p9_conn_create - allocate and initialize the per-session mux data
386  * @trans: transport structure
387  *
388  * Note: Creates the polling task if this is the first session.
389  */
390
391 static struct p9_conn *p9_conn_create(struct p9_trans *trans)
392 {
393         int i, n;
394         struct p9_conn *m;
395
396         P9_DPRINTK(P9_DEBUG_MUX, "transport %p msize %d\n", trans,
397                                                                 trans->msize);
398         m = kzalloc(sizeof(struct p9_conn), GFP_KERNEL);
399         if (!m)
400                 return ERR_PTR(-ENOMEM);
401
402         spin_lock_init(&m->lock);
403         INIT_LIST_HEAD(&m->mux_list);
404         m->msize = trans->msize;
405         m->extended = trans->extended;
406         m->trans = trans;
407         m->tagpool = p9_idpool_create();
408         if (IS_ERR(m->tagpool)) {
409                 kfree(m);
410                 return ERR_PTR(-ENOMEM);
411         }
412
413         INIT_LIST_HEAD(&m->req_list);
414         INIT_LIST_HEAD(&m->unsent_req_list);
415         INIT_WORK(&m->rq, p9_read_work);
416         INIT_WORK(&m->wq, p9_write_work);
417         n = p9_mux_poll_start(m);
418         if (n) {
419                 kfree(m);
420                 return ERR_PTR(n);
421         }
422
423         n = p9_fd_poll(trans, &m->pt);
424         if (n & POLLIN) {
425                 P9_DPRINTK(P9_DEBUG_MUX, "mux %p can read\n", m);
426                 set_bit(Rpending, &m->wsched);
427         }
428
429         if (n & POLLOUT) {
430                 P9_DPRINTK(P9_DEBUG_MUX, "mux %p can write\n", m);
431                 set_bit(Wpending, &m->wsched);
432         }
433
434         for (i = 0; i < ARRAY_SIZE(m->poll_waddr); i++) {
435                 if (IS_ERR(m->poll_waddr[i])) {
436                         p9_mux_poll_stop(m);
437                         kfree(m);
438                         return (void *)m->poll_waddr;   /* the error code */
439                 }
440         }
441
442         return m;
443 }
444
445 /**
446  * p9_mux_destroy - cancels all pending requests and frees mux resources
447  * @m: mux to destroy
448  *
449  */
450
451 static void p9_conn_destroy(struct p9_conn *m)
452 {
453         P9_DPRINTK(P9_DEBUG_MUX, "mux %p prev %p next %p\n", m,
454                 m->mux_list.prev, m->mux_list.next);
455
456         p9_mux_poll_stop(m);
457         cancel_work_sync(&m->rq);
458         cancel_work_sync(&m->wq);
459
460         p9_conn_cancel(m, -ECONNRESET);
461
462         m->trans = NULL;
463         p9_idpool_destroy(m->tagpool);
464         kfree(m);
465 }
466
467 /**
468  * p9_pollwait - add poll task to the wait queue
469  * @filp: file pointer being polled
470  * @wait_address: wait_q to block on
471  * @p: poll state
472  *
473  * called by files poll operation to add v9fs-poll task to files wait queue
474  */
475
476 static void
477 p9_pollwait(struct file *filp, wait_queue_head_t *wait_address, poll_table *p)
478 {
479         int i;
480         struct p9_conn *m;
481
482         m = container_of(p, struct p9_conn, pt);
483         for (i = 0; i < ARRAY_SIZE(m->poll_waddr); i++)
484                 if (m->poll_waddr[i] == NULL)
485                         break;
486
487         if (i >= ARRAY_SIZE(m->poll_waddr)) {
488                 P9_DPRINTK(P9_DEBUG_ERROR, "not enough wait_address slots\n");
489                 return;
490         }
491
492         m->poll_waddr[i] = wait_address;
493
494         if (!wait_address) {
495                 P9_DPRINTK(P9_DEBUG_ERROR, "no wait_address\n");
496                 m->poll_waddr[i] = ERR_PTR(-EIO);
497                 return;
498         }
499
500         init_waitqueue_entry(&m->poll_wait[i], m->poll_task->task);
501         add_wait_queue(wait_address, &m->poll_wait[i]);
502 }
503
504 /**
505  * p9_poll_mux - polls a mux and schedules read or write works if necessary
506  * @m: connection to poll
507  *
508  */
509
510 static void p9_poll_mux(struct p9_conn *m)
511 {
512         int n;
513
514         if (m->err < 0)
515                 return;
516
517         n = p9_fd_poll(m->trans, NULL);
518         if (n < 0 || n & (POLLERR | POLLHUP | POLLNVAL)) {
519                 P9_DPRINTK(P9_DEBUG_MUX, "error mux %p err %d\n", m, n);
520                 if (n >= 0)
521                         n = -ECONNRESET;
522                 p9_conn_cancel(m, n);
523         }
524
525         if (n & POLLIN) {
526                 set_bit(Rpending, &m->wsched);
527                 P9_DPRINTK(P9_DEBUG_MUX, "mux %p can read\n", m);
528                 if (!test_and_set_bit(Rworksched, &m->wsched)) {
529                         P9_DPRINTK(P9_DEBUG_MUX, "schedule read work %p\n", m);
530                         queue_work(p9_mux_wq, &m->rq);
531                 }
532         }
533
534         if (n & POLLOUT) {
535                 set_bit(Wpending, &m->wsched);
536                 P9_DPRINTK(P9_DEBUG_MUX, "mux %p can write\n", m);
537                 if ((m->wsize || !list_empty(&m->unsent_req_list))
538                     && !test_and_set_bit(Wworksched, &m->wsched)) {
539                         P9_DPRINTK(P9_DEBUG_MUX, "schedule write work %p\n", m);
540                         queue_work(p9_mux_wq, &m->wq);
541                 }
542         }
543 }
544
545 /**
546  * p9_poll_proc - poll worker thread
547  * @a: thread state and arguments
548  *
549  * polls all v9fs transports for new events and queues the appropriate
550  * work to the work queue
551  *
552  */
553
554 static int p9_poll_proc(void *a)
555 {
556         struct p9_conn *m, *mtmp;
557         struct p9_mux_poll_task *vpt;
558
559         vpt = a;
560         P9_DPRINTK(P9_DEBUG_MUX, "start %p %p\n", current, vpt);
561         while (!kthread_should_stop()) {
562                 set_current_state(TASK_INTERRUPTIBLE);
563
564                 list_for_each_entry_safe(m, mtmp, &vpt->mux_list, mux_list) {
565                         p9_poll_mux(m);
566                 }
567
568                 P9_DPRINTK(P9_DEBUG_MUX, "sleeping...\n");
569                 schedule_timeout(SCHED_TIMEOUT * HZ);
570         }
571
572         __set_current_state(TASK_RUNNING);
573         P9_DPRINTK(P9_DEBUG_MUX, "finish\n");
574         return 0;
575 }
576
577 /**
578  * p9_write_work - called when a transport can send some data
579  * @work: container for work to be done
580  *
581  */
582
583 static void p9_write_work(struct work_struct *work)
584 {
585         int n, err;
586         struct p9_conn *m;
587         struct p9_req *req;
588
589         m = container_of(work, struct p9_conn, wq);
590
591         if (m->err < 0) {
592                 clear_bit(Wworksched, &m->wsched);
593                 return;
594         }
595
596         if (!m->wsize) {
597                 if (list_empty(&m->unsent_req_list)) {
598                         clear_bit(Wworksched, &m->wsched);
599                         return;
600                 }
601
602                 spin_lock(&m->lock);
603 again:
604                 req = list_entry(m->unsent_req_list.next, struct p9_req,
605                                req_list);
606                 list_move_tail(&req->req_list, &m->req_list);
607                 if (req->err == ERREQFLUSH)
608                         goto again;
609
610                 m->wbuf = req->tcall->sdata;
611                 m->wsize = req->tcall->size;
612                 m->wpos = 0;
613                 spin_unlock(&m->lock);
614         }
615
616         P9_DPRINTK(P9_DEBUG_MUX, "mux %p pos %d size %d\n", m, m->wpos,
617                                                                 m->wsize);
618         clear_bit(Wpending, &m->wsched);
619         err = p9_fd_write(m->trans, m->wbuf + m->wpos, m->wsize - m->wpos);
620         P9_DPRINTK(P9_DEBUG_MUX, "mux %p sent %d bytes\n", m, err);
621         if (err == -EAGAIN) {
622                 clear_bit(Wworksched, &m->wsched);
623                 return;
624         }
625
626         if (err < 0)
627                 goto error;
628         else if (err == 0) {
629                 err = -EREMOTEIO;
630                 goto error;
631         }
632
633         m->wpos += err;
634         if (m->wpos == m->wsize)
635                 m->wpos = m->wsize = 0;
636
637         if (m->wsize == 0 && !list_empty(&m->unsent_req_list)) {
638                 if (test_and_clear_bit(Wpending, &m->wsched))
639                         n = POLLOUT;
640                 else
641                         n = p9_fd_poll(m->trans, NULL);
642
643                 if (n & POLLOUT) {
644                         P9_DPRINTK(P9_DEBUG_MUX, "schedule write work %p\n", m);
645                         queue_work(p9_mux_wq, &m->wq);
646                 } else
647                         clear_bit(Wworksched, &m->wsched);
648         } else
649                 clear_bit(Wworksched, &m->wsched);
650
651         return;
652
653 error:
654         p9_conn_cancel(m, err);
655         clear_bit(Wworksched, &m->wsched);
656 }
657
658 static void process_request(struct p9_conn *m, struct p9_req *req)
659 {
660         int ecode;
661         struct p9_str *ename;
662
663         if (!req->err && req->rcall->id == P9_RERROR) {
664                 ecode = req->rcall->params.rerror.errno;
665                 ename = &req->rcall->params.rerror.error;
666
667                 P9_DPRINTK(P9_DEBUG_MUX, "Rerror %.*s\n", ename->len,
668                                                                 ename->str);
669
670                 if (m->extended)
671                         req->err = -ecode;
672
673                 if (!req->err) {
674                         req->err = p9_errstr2errno(ename->str, ename->len);
675
676                         /* string match failed */
677                         if (!req->err) {
678                                 PRINT_FCALL_ERROR("unknown error", req->rcall);
679                                 req->err = -ESERVERFAULT;
680                         }
681                 }
682         } else if (req->tcall && req->rcall->id != req->tcall->id + 1) {
683                 P9_DPRINTK(P9_DEBUG_ERROR,
684                                 "fcall mismatch: expected %d, got %d\n",
685                                 req->tcall->id + 1, req->rcall->id);
686                 if (!req->err)
687                         req->err = -EIO;
688         }
689 }
690
691 /**
692  * p9_read_work - called when there is some data to be read from a transport
693  * @work: container of work to be done
694  *
695  */
696
697 static void p9_read_work(struct work_struct *work)
698 {
699         int n, err;
700         struct p9_conn *m;
701         struct p9_req *req, *rptr, *rreq;
702         struct p9_fcall *rcall;
703         char *rbuf;
704
705         m = container_of(work, struct p9_conn, rq);
706
707         if (m->err < 0)
708                 return;
709
710         rcall = NULL;
711         P9_DPRINTK(P9_DEBUG_MUX, "start mux %p pos %d\n", m, m->rpos);
712
713         if (!m->rcall) {
714                 m->rcall =
715                     kmalloc(sizeof(struct p9_fcall) + m->msize, GFP_KERNEL);
716                 if (!m->rcall) {
717                         err = -ENOMEM;
718                         goto error;
719                 }
720
721                 m->rbuf = (char *)m->rcall + sizeof(struct p9_fcall);
722                 m->rpos = 0;
723         }
724
725         clear_bit(Rpending, &m->wsched);
726         err = p9_fd_read(m->trans, m->rbuf + m->rpos, m->msize - m->rpos);
727         P9_DPRINTK(P9_DEBUG_MUX, "mux %p got %d bytes\n", m, err);
728         if (err == -EAGAIN) {
729                 clear_bit(Rworksched, &m->wsched);
730                 return;
731         }
732
733         if (err <= 0)
734                 goto error;
735
736         m->rpos += err;
737         while (m->rpos > 4) {
738                 n = le32_to_cpu(*(__le32 *) m->rbuf);
739                 if (n >= m->msize) {
740                         P9_DPRINTK(P9_DEBUG_ERROR,
741                                 "requested packet size too big: %d\n", n);
742                         err = -EIO;
743                         goto error;
744                 }
745
746                 if (m->rpos < n)
747                         break;
748
749                 err =
750                     p9_deserialize_fcall(m->rbuf, n, m->rcall, m->extended);
751                 if (err < 0)
752                         goto error;
753
754 #ifdef CONFIG_NET_9P_DEBUG
755                 if ((p9_debug_level&P9_DEBUG_FCALL) == P9_DEBUG_FCALL) {
756                         char buf[150];
757
758                         p9_printfcall(buf, sizeof(buf), m->rcall,
759                                 m->extended);
760                         printk(KERN_NOTICE ">>> %p %s\n", m, buf);
761                 }
762 #endif
763
764                 rcall = m->rcall;
765                 rbuf = m->rbuf;
766                 if (m->rpos > n) {
767                         m->rcall = kmalloc(sizeof(struct p9_fcall) + m->msize,
768                                            GFP_KERNEL);
769                         if (!m->rcall) {
770                                 err = -ENOMEM;
771                                 goto error;
772                         }
773
774                         m->rbuf = (char *)m->rcall + sizeof(struct p9_fcall);
775                         memmove(m->rbuf, rbuf + n, m->rpos - n);
776                         m->rpos -= n;
777                 } else {
778                         m->rcall = NULL;
779                         m->rbuf = NULL;
780                         m->rpos = 0;
781                 }
782
783                 P9_DPRINTK(P9_DEBUG_MUX, "mux %p fcall id %d tag %d\n", m,
784                                                         rcall->id, rcall->tag);
785
786                 req = NULL;
787                 spin_lock(&m->lock);
788                 list_for_each_entry_safe(rreq, rptr, &m->req_list, req_list) {
789                         if (rreq->tag == rcall->tag) {
790                                 req = rreq;
791                                 if (req->flush != Flushing)
792                                         list_del(&req->req_list);
793                                 break;
794                         }
795                 }
796                 spin_unlock(&m->lock);
797
798                 if (req) {
799                         req->rcall = rcall;
800                         process_request(m, req);
801
802                         if (req->flush != Flushing) {
803                                 if (req->cb)
804                                         (*req->cb) (req, req->cba);
805                                 else
806                                         kfree(req->rcall);
807                         }
808                 } else {
809                         if (err >= 0 && rcall->id != P9_RFLUSH)
810                                 P9_DPRINTK(P9_DEBUG_ERROR,
811                                   "unexpected response mux %p id %d tag %d\n",
812                                   m, rcall->id, rcall->tag);
813                         kfree(rcall);
814                 }
815         }
816
817         if (!list_empty(&m->req_list)) {
818                 if (test_and_clear_bit(Rpending, &m->wsched))
819                         n = POLLIN;
820                 else
821                         n = p9_fd_poll(m->trans, NULL);
822
823                 if (n & POLLIN) {
824                         P9_DPRINTK(P9_DEBUG_MUX, "schedule read work %p\n", m);
825                         queue_work(p9_mux_wq, &m->rq);
826                 } else
827                         clear_bit(Rworksched, &m->wsched);
828         } else
829                 clear_bit(Rworksched, &m->wsched);
830
831         return;
832
833 error:
834         p9_conn_cancel(m, err);
835         clear_bit(Rworksched, &m->wsched);
836 }
837
838 /**
839  * p9_send_request - send 9P request
840  * The function can sleep until the request is scheduled for sending.
841  * The function can be interrupted. Return from the function is not
842  * a guarantee that the request is sent successfully. Can return errors
843  * that can be retrieved by PTR_ERR macros.
844  *
845  * @m: mux data
846  * @tc: request to be sent
847  * @cb: callback function to call when response is received
848  * @cba: parameter to pass to the callback function
849  *
850  */
851
852 static struct p9_req *p9_send_request(struct p9_conn *m,
853                                           struct p9_fcall *tc,
854                                           p9_conn_req_callback cb, void *cba)
855 {
856         int n;
857         struct p9_req *req;
858
859         P9_DPRINTK(P9_DEBUG_MUX, "mux %p task %p tcall %p id %d\n", m, current,
860                 tc, tc->id);
861         if (m->err < 0)
862                 return ERR_PTR(m->err);
863
864         req = kmalloc(sizeof(struct p9_req), GFP_KERNEL);
865         if (!req)
866                 return ERR_PTR(-ENOMEM);
867
868         if (tc->id == P9_TVERSION)
869                 n = P9_NOTAG;
870         else
871                 n = p9_mux_get_tag(m);
872
873         if (n < 0) {
874                 kfree(req);
875                 return ERR_PTR(-ENOMEM);
876         }
877
878         p9_set_tag(tc, n);
879
880 #ifdef CONFIG_NET_9P_DEBUG
881         if ((p9_debug_level&P9_DEBUG_FCALL) == P9_DEBUG_FCALL) {
882                 char buf[150];
883
884                 p9_printfcall(buf, sizeof(buf), tc, m->extended);
885                 printk(KERN_NOTICE "<<< %p %s\n", m, buf);
886         }
887 #endif
888
889         spin_lock_init(&req->lock);
890         req->tag = n;
891         req->tcall = tc;
892         req->rcall = NULL;
893         req->err = 0;
894         req->cb = cb;
895         req->cba = cba;
896         req->flush = None;
897
898         spin_lock(&m->lock);
899         list_add_tail(&req->req_list, &m->unsent_req_list);
900         spin_unlock(&m->lock);
901
902         if (test_and_clear_bit(Wpending, &m->wsched))
903                 n = POLLOUT;
904         else
905                 n = p9_fd_poll(m->trans, NULL);
906
907         if (n & POLLOUT && !test_and_set_bit(Wworksched, &m->wsched))
908                 queue_work(p9_mux_wq, &m->wq);
909
910         return req;
911 }
912
913 static void p9_mux_free_request(struct p9_conn *m, struct p9_req *req)
914 {
915         p9_mux_put_tag(m, req->tag);
916         kfree(req);
917 }
918
919 static void p9_mux_flush_cb(struct p9_req *freq, void *a)
920 {
921         int tag;
922         struct p9_conn *m;
923         struct p9_req *req, *rreq, *rptr;
924
925         m = a;
926         P9_DPRINTK(P9_DEBUG_MUX, "mux %p tc %p rc %p err %d oldtag %d\n", m,
927                 freq->tcall, freq->rcall, freq->err,
928                 freq->tcall->params.tflush.oldtag);
929
930         spin_lock(&m->lock);
931         tag = freq->tcall->params.tflush.oldtag;
932         req = NULL;
933         list_for_each_entry_safe(rreq, rptr, &m->req_list, req_list) {
934                 if (rreq->tag == tag) {
935                         req = rreq;
936                         list_del(&req->req_list);
937                         break;
938                 }
939         }
940         spin_unlock(&m->lock);
941
942         if (req) {
943                 spin_lock(&req->lock);
944                 req->flush = Flushed;
945                 spin_unlock(&req->lock);
946
947                 if (req->cb)
948                         (*req->cb) (req, req->cba);
949                 else
950                         kfree(req->rcall);
951         }
952
953         kfree(freq->tcall);
954         kfree(freq->rcall);
955         p9_mux_free_request(m, freq);
956 }
957
958 static int
959 p9_mux_flush_request(struct p9_conn *m, struct p9_req *req)
960 {
961         struct p9_fcall *fc;
962         struct p9_req *rreq, *rptr;
963
964         P9_DPRINTK(P9_DEBUG_MUX, "mux %p req %p tag %d\n", m, req, req->tag);
965
966         /* if a response was received for a request, do nothing */
967         spin_lock(&req->lock);
968         if (req->rcall || req->err) {
969                 spin_unlock(&req->lock);
970                 P9_DPRINTK(P9_DEBUG_MUX,
971                         "mux %p req %p response already received\n", m, req);
972                 return 0;
973         }
974
975         req->flush = Flushing;
976         spin_unlock(&req->lock);
977
978         spin_lock(&m->lock);
979         /* if the request is not sent yet, just remove it from the list */
980         list_for_each_entry_safe(rreq, rptr, &m->unsent_req_list, req_list) {
981                 if (rreq->tag == req->tag) {
982                         P9_DPRINTK(P9_DEBUG_MUX,
983                            "mux %p req %p request is not sent yet\n", m, req);
984                         list_del(&rreq->req_list);
985                         req->flush = Flushed;
986                         spin_unlock(&m->lock);
987                         if (req->cb)
988                                 (*req->cb) (req, req->cba);
989                         return 0;
990                 }
991         }
992         spin_unlock(&m->lock);
993
994         clear_thread_flag(TIF_SIGPENDING);
995         fc = p9_create_tflush(req->tag);
996         p9_send_request(m, fc, p9_mux_flush_cb, m);
997         return 1;
998 }
999
1000 static void
1001 p9_conn_rpc_cb(struct p9_req *req, void *a)
1002 {
1003         struct p9_mux_rpc *r;
1004
1005         P9_DPRINTK(P9_DEBUG_MUX, "req %p r %p\n", req, a);
1006         r = a;
1007         r->rcall = req->rcall;
1008         r->err = req->err;
1009
1010         if (req->flush != None && !req->err)
1011                 r->err = -ERESTARTSYS;
1012
1013         wake_up(&r->wqueue);
1014 }
1015
1016 /**
1017  * p9_fd_rpc- sends 9P request and waits until a response is available.
1018  *      The function can be interrupted.
1019  * @t: transport data
1020  * @tc: request to be sent
1021  * @rc: pointer where a pointer to the response is stored
1022  *
1023  */
1024
1025 int
1026 p9_fd_rpc(struct p9_trans *t, struct p9_fcall *tc, struct p9_fcall **rc)
1027 {
1028         struct p9_trans_fd *p = t->priv;
1029         struct p9_conn *m = p->conn;
1030         int err, sigpending;
1031         unsigned long flags;
1032         struct p9_req *req;
1033         struct p9_mux_rpc r;
1034
1035         r.err = 0;
1036         r.tcall = tc;
1037         r.rcall = NULL;
1038         r.m = m;
1039         init_waitqueue_head(&r.wqueue);
1040
1041         if (rc)
1042                 *rc = NULL;
1043
1044         sigpending = 0;
1045         if (signal_pending(current)) {
1046                 sigpending = 1;
1047                 clear_thread_flag(TIF_SIGPENDING);
1048         }
1049
1050         req = p9_send_request(m, tc, p9_conn_rpc_cb, &r);
1051         if (IS_ERR(req)) {
1052                 err = PTR_ERR(req);
1053                 P9_DPRINTK(P9_DEBUG_MUX, "error %d\n", err);
1054                 return err;
1055         }
1056
1057         err = wait_event_interruptible(r.wqueue, r.rcall != NULL || r.err < 0);
1058         if (r.err < 0)
1059                 err = r.err;
1060
1061         if (err == -ERESTARTSYS && m->trans->status == Connected
1062                                                         && m->err == 0) {
1063                 if (p9_mux_flush_request(m, req)) {
1064                         /* wait until we get response of the flush message */
1065                         do {
1066                                 clear_thread_flag(TIF_SIGPENDING);
1067                                 err = wait_event_interruptible(r.wqueue,
1068                                         r.rcall || r.err);
1069                         } while (!r.rcall && !r.err && err == -ERESTARTSYS &&
1070                                 m->trans->status == Connected && !m->err);
1071
1072                         err = -ERESTARTSYS;
1073                 }
1074                 sigpending = 1;
1075         }
1076
1077         if (sigpending) {
1078                 spin_lock_irqsave(&current->sighand->siglock, flags);
1079                 recalc_sigpending();
1080                 spin_unlock_irqrestore(&current->sighand->siglock, flags);
1081         }
1082
1083         if (rc)
1084                 *rc = r.rcall;
1085         else
1086                 kfree(r.rcall);
1087
1088         p9_mux_free_request(m, req);
1089         if (err > 0)
1090                 err = -EIO;
1091
1092         return err;
1093 }
1094
1095 #ifdef P9_NONBLOCK
1096 /**
1097  * p9_conn_rpcnb - sends 9P request without waiting for response.
1098  * @m: mux data
1099  * @tc: request to be sent
1100  * @cb: callback function to be called when response arrives
1101  * @a: value to pass to the callback function
1102  *
1103  */
1104
1105 int p9_conn_rpcnb(struct p9_conn *m, struct p9_fcall *tc,
1106                    p9_conn_req_callback cb, void *a)
1107 {
1108         int err;
1109         struct p9_req *req;
1110
1111         req = p9_send_request(m, tc, cb, a);
1112         if (IS_ERR(req)) {
1113                 err = PTR_ERR(req);
1114                 P9_DPRINTK(P9_DEBUG_MUX, "error %d\n", err);
1115                 return PTR_ERR(req);
1116         }
1117
1118         P9_DPRINTK(P9_DEBUG_MUX, "mux %p tc %p tag %d\n", m, tc, req->tag);
1119         return 0;
1120 }
1121 #endif /* P9_NONBLOCK */
1122
1123 /**
1124  * p9_conn_cancel - cancel all pending requests with error
1125  * @m: mux data
1126  * @err: error code
1127  *
1128  */
1129
1130 void p9_conn_cancel(struct p9_conn *m, int err)
1131 {
1132         struct p9_req *req, *rtmp;
1133         LIST_HEAD(cancel_list);
1134
1135         P9_DPRINTK(P9_DEBUG_ERROR, "mux %p err %d\n", m, err);
1136         m->err = err;
1137         spin_lock(&m->lock);
1138         list_for_each_entry_safe(req, rtmp, &m->req_list, req_list) {
1139                 list_move(&req->req_list, &cancel_list);
1140         }
1141         list_for_each_entry_safe(req, rtmp, &m->unsent_req_list, req_list) {
1142                 list_move(&req->req_list, &cancel_list);
1143         }
1144         spin_unlock(&m->lock);
1145
1146         list_for_each_entry_safe(req, rtmp, &cancel_list, req_list) {
1147                 list_del(&req->req_list);
1148                 if (!req->err)
1149                         req->err = err;
1150
1151                 if (req->cb)
1152                         (*req->cb) (req, req->cba);
1153                 else
1154                         kfree(req->rcall);
1155         }
1156 }
1157
1158 /**
1159  * parse_options - parse mount options into session structure
1160  * @options: options string passed from mount
1161  * @opts: transport-specific structure to parse options into
1162  *
1163  * Returns 0 upon success, -ERRNO upon failure
1164  */
1165
1166 static int parse_opts(char *params, struct p9_fd_opts *opts)
1167 {
1168         char *p;
1169         substring_t args[MAX_OPT_ARGS];
1170         int option;
1171         char *options;
1172         int ret;
1173
1174         opts->port = P9_PORT;
1175         opts->rfd = ~0;
1176         opts->wfd = ~0;
1177
1178         if (!params)
1179                 return 0;
1180
1181         options = kstrdup(params, GFP_KERNEL);
1182         if (!options) {
1183                 P9_DPRINTK(P9_DEBUG_ERROR,
1184                                 "failed to allocate copy of option string\n");
1185                 return -ENOMEM;
1186         }
1187
1188         while ((p = strsep(&options, ",")) != NULL) {
1189                 int token;
1190                 int r;
1191                 if (!*p)
1192                         continue;
1193                 token = match_token(p, tokens, args);
1194                 r = match_int(&args[0], &option);
1195                 if (r < 0) {
1196                         P9_DPRINTK(P9_DEBUG_ERROR,
1197                          "integer field, but no integer?\n");
1198                         ret = r;
1199                         continue;
1200                 }
1201                 switch (token) {
1202                 case Opt_port:
1203                         opts->port = option;
1204                         break;
1205                 case Opt_rfdno:
1206                         opts->rfd = option;
1207                         break;
1208                 case Opt_wfdno:
1209                         opts->wfd = option;
1210                         break;
1211                 default:
1212                         continue;
1213                 }
1214         }
1215         kfree(options);
1216         return 0;
1217 }
1218
1219 static int p9_fd_open(struct p9_trans *trans, int rfd, int wfd)
1220 {
1221         struct p9_trans_fd *ts = kmalloc(sizeof(struct p9_trans_fd),
1222                                            GFP_KERNEL);
1223         if (!ts)
1224                 return -ENOMEM;
1225
1226         ts->rd = fget(rfd);
1227         ts->wr = fget(wfd);
1228         if (!ts->rd || !ts->wr) {
1229                 if (ts->rd)
1230                         fput(ts->rd);
1231                 if (ts->wr)
1232                         fput(ts->wr);
1233                 kfree(ts);
1234                 return -EIO;
1235         }
1236
1237         trans->priv = ts;
1238         trans->status = Connected;
1239
1240         return 0;
1241 }
1242
1243 static int p9_socket_open(struct p9_trans *trans, struct socket *csocket)
1244 {
1245         int fd, ret;
1246
1247         csocket->sk->sk_allocation = GFP_NOIO;
1248         fd = sock_map_fd(csocket, 0);
1249         if (fd < 0) {
1250                 P9_EPRINTK(KERN_ERR, "p9_socket_open: failed to map fd\n");
1251                 return fd;
1252         }
1253
1254         ret = p9_fd_open(trans, fd, fd);
1255         if (ret < 0) {
1256                 P9_EPRINTK(KERN_ERR, "p9_socket_open: failed to open fd\n");
1257                 sockfd_put(csocket);
1258                 return ret;
1259         }
1260
1261         ((struct p9_trans_fd *)trans->priv)->rd->f_flags |= O_NONBLOCK;
1262
1263         return 0;
1264 }
1265
1266 /**
1267  * p9_fd_read- read from a fd
1268  * @trans: transport instance state
1269  * @v: buffer to receive data into
1270  * @len: size of receive buffer
1271  *
1272  */
1273
1274 static int p9_fd_read(struct p9_trans *trans, void *v, int len)
1275 {
1276         int ret;
1277         struct p9_trans_fd *ts = NULL;
1278
1279         if (trans && trans->status != Disconnected)
1280                 ts = trans->priv;
1281
1282         if (!ts)
1283                 return -EREMOTEIO;
1284
1285         if (!(ts->rd->f_flags & O_NONBLOCK))
1286                 P9_DPRINTK(P9_DEBUG_ERROR, "blocking read ...\n");
1287
1288         ret = kernel_read(ts->rd, ts->rd->f_pos, v, len);
1289         if (ret <= 0 && ret != -ERESTARTSYS && ret != -EAGAIN)
1290                 trans->status = Disconnected;
1291         return ret;
1292 }
1293
1294 /**
1295  * p9_fd_write - write to a socket
1296  * @trans: transport instance state
1297  * @v: buffer to send data from
1298  * @len: size of send buffer
1299  *
1300  */
1301
1302 static int p9_fd_write(struct p9_trans *trans, void *v, int len)
1303 {
1304         int ret;
1305         mm_segment_t oldfs;
1306         struct p9_trans_fd *ts = NULL;
1307
1308         if (trans && trans->status != Disconnected)
1309                 ts = trans->priv;
1310
1311         if (!ts)
1312                 return -EREMOTEIO;
1313
1314         if (!(ts->wr->f_flags & O_NONBLOCK))
1315                 P9_DPRINTK(P9_DEBUG_ERROR, "blocking write ...\n");
1316
1317         oldfs = get_fs();
1318         set_fs(get_ds());
1319         /* The cast to a user pointer is valid due to the set_fs() */
1320         ret = vfs_write(ts->wr, (void __user *)v, len, &ts->wr->f_pos);
1321         set_fs(oldfs);
1322
1323         if (ret <= 0 && ret != -ERESTARTSYS && ret != -EAGAIN)
1324                 trans->status = Disconnected;
1325         return ret;
1326 }
1327
1328 static unsigned int
1329 p9_fd_poll(struct p9_trans *trans, struct poll_table_struct *pt)
1330 {
1331         int ret, n;
1332         struct p9_trans_fd *ts = NULL;
1333
1334         if (trans && trans->status == Connected)
1335                 ts = trans->priv;
1336
1337         if (!ts)
1338                 return -EREMOTEIO;
1339
1340         if (!ts->rd->f_op || !ts->rd->f_op->poll)
1341                 return -EIO;
1342
1343         if (!ts->wr->f_op || !ts->wr->f_op->poll)
1344                 return -EIO;
1345
1346         ret = ts->rd->f_op->poll(ts->rd, pt);
1347         if (ret < 0)
1348                 return ret;
1349
1350         if (ts->rd != ts->wr) {
1351                 n = ts->wr->f_op->poll(ts->wr, pt);
1352                 if (n < 0)
1353                         return n;
1354                 ret = (ret & ~POLLOUT) | (n & ~POLLIN);
1355         }
1356
1357         return ret;
1358 }
1359
1360 /**
1361  * p9_fd_close - shutdown socket
1362  * @trans: private socket structure
1363  *
1364  */
1365
1366 static void p9_fd_close(struct p9_trans *trans)
1367 {
1368         struct p9_trans_fd *ts;
1369
1370         if (!trans)
1371                 return;
1372
1373         ts = xchg(&trans->priv, NULL);
1374
1375         if (!ts)
1376                 return;
1377
1378         p9_conn_destroy(ts->conn);
1379
1380         trans->status = Disconnected;
1381         if (ts->rd)
1382                 fput(ts->rd);
1383         if (ts->wr)
1384                 fput(ts->wr);
1385         kfree(ts);
1386 }
1387
1388 /*
1389  * stolen from NFS - maybe should be made a generic function?
1390  */
1391 static inline int valid_ipaddr4(const char *buf)
1392 {
1393         int rc, count, in[4];
1394
1395         rc = sscanf(buf, "%d.%d.%d.%d", &in[0], &in[1], &in[2], &in[3]);
1396         if (rc != 4)
1397                 return -EINVAL;
1398         for (count = 0; count < 4; count++) {
1399                 if (in[count] > 255)
1400                         return -EINVAL;
1401         }
1402         return 0;
1403 }
1404
1405 static struct p9_trans *
1406 p9_trans_create_tcp(const char *addr, char *args, int msize, unsigned char dotu)
1407 {
1408         int err;
1409         struct p9_trans *trans;
1410         struct socket *csocket;
1411         struct sockaddr_in sin_server;
1412         struct p9_fd_opts opts;
1413         struct p9_trans_fd *p;
1414
1415         err = parse_opts(args, &opts);
1416         if (err < 0)
1417                 return ERR_PTR(err);
1418
1419         if (valid_ipaddr4(addr) < 0)
1420                 return ERR_PTR(-EINVAL);
1421
1422         csocket = NULL;
1423         trans = kmalloc(sizeof(struct p9_trans), GFP_KERNEL);
1424         if (!trans)
1425                 return ERR_PTR(-ENOMEM);
1426         trans->msize = msize;
1427         trans->extended = dotu;
1428         trans->rpc = p9_fd_rpc;
1429         trans->close = p9_fd_close;
1430
1431         sin_server.sin_family = AF_INET;
1432         sin_server.sin_addr.s_addr = in_aton(addr);
1433         sin_server.sin_port = htons(opts.port);
1434         sock_create_kern(PF_INET, SOCK_STREAM, IPPROTO_TCP, &csocket);
1435
1436         if (!csocket) {
1437                 P9_EPRINTK(KERN_ERR, "p9_trans_tcp: problem creating socket\n");
1438                 err = -EIO;
1439                 goto error;
1440         }
1441
1442         err = csocket->ops->connect(csocket,
1443                                     (struct sockaddr *)&sin_server,
1444                                     sizeof(struct sockaddr_in), 0);
1445         if (err < 0) {
1446                 P9_EPRINTK(KERN_ERR,
1447                         "p9_trans_tcp: problem connecting socket to %s\n",
1448                         addr);
1449                 goto error;
1450         }
1451
1452         err = p9_socket_open(trans, csocket);
1453         if (err < 0)
1454                 goto error;
1455
1456         p = (struct p9_trans_fd *) trans->priv;
1457         p->conn = p9_conn_create(trans);
1458         if (IS_ERR(p->conn)) {
1459                 err = PTR_ERR(p->conn);
1460                 p->conn = NULL;
1461                 goto error;
1462         }
1463
1464         return trans;
1465
1466 error:
1467         if (csocket)
1468                 sock_release(csocket);
1469
1470         kfree(trans);
1471         return ERR_PTR(err);
1472 }
1473
1474 static struct p9_trans *
1475 p9_trans_create_unix(const char *addr, char *args, int msize,
1476                                                         unsigned char dotu)
1477 {
1478         int err;
1479         struct socket *csocket;
1480         struct sockaddr_un sun_server;
1481         struct p9_trans *trans;
1482         struct p9_trans_fd *p;
1483
1484         csocket = NULL;
1485         trans = kmalloc(sizeof(struct p9_trans), GFP_KERNEL);
1486         if (!trans)
1487                 return ERR_PTR(-ENOMEM);
1488
1489         trans->rpc = p9_fd_rpc;
1490         trans->close = p9_fd_close;
1491
1492         if (strlen(addr) > UNIX_PATH_MAX) {
1493                 P9_EPRINTK(KERN_ERR, "p9_trans_unix: address too long: %s\n",
1494                         addr);
1495                 err = -ENAMETOOLONG;
1496                 goto error;
1497         }
1498
1499         sun_server.sun_family = PF_UNIX;
1500         strcpy(sun_server.sun_path, addr);
1501         sock_create_kern(PF_UNIX, SOCK_STREAM, 0, &csocket);
1502         err = csocket->ops->connect(csocket, (struct sockaddr *)&sun_server,
1503                         sizeof(struct sockaddr_un) - 1, 0);
1504         if (err < 0) {
1505                 P9_EPRINTK(KERN_ERR,
1506                         "p9_trans_unix: problem connecting socket: %s: %d\n",
1507                         addr, err);
1508                 goto error;
1509         }
1510
1511         err = p9_socket_open(trans, csocket);
1512         if (err < 0)
1513                 goto error;
1514
1515         trans->msize = msize;
1516         trans->extended = dotu;
1517         p = (struct p9_trans_fd *) trans->priv;
1518         p->conn = p9_conn_create(trans);
1519         if (IS_ERR(p->conn)) {
1520                 err = PTR_ERR(p->conn);
1521                 p->conn = NULL;
1522                 goto error;
1523         }
1524
1525         return trans;
1526
1527 error:
1528         if (csocket)
1529                 sock_release(csocket);
1530
1531         kfree(trans);
1532         return ERR_PTR(err);
1533 }
1534
1535 static struct p9_trans *
1536 p9_trans_create_fd(const char *name, char *args, int msize,
1537                                                         unsigned char extended)
1538 {
1539         int err;
1540         struct p9_trans *trans;
1541         struct p9_fd_opts opts;
1542         struct p9_trans_fd *p;
1543
1544         parse_opts(args, &opts);
1545
1546         if (opts.rfd == ~0 || opts.wfd == ~0) {
1547                 printk(KERN_ERR "v9fs: Insufficient options for proto=fd\n");
1548                 return ERR_PTR(-ENOPROTOOPT);
1549         }
1550
1551         trans = kmalloc(sizeof(struct p9_trans), GFP_KERNEL);
1552         if (!trans)
1553                 return ERR_PTR(-ENOMEM);
1554
1555         trans->rpc = p9_fd_rpc;
1556         trans->close = p9_fd_close;
1557
1558         err = p9_fd_open(trans, opts.rfd, opts.wfd);
1559         if (err < 0)
1560                 goto error;
1561
1562         trans->msize = msize;
1563         trans->extended = extended;
1564         p = (struct p9_trans_fd *) trans->priv;
1565         p->conn = p9_conn_create(trans);
1566         if (IS_ERR(p->conn)) {
1567                 err = PTR_ERR(p->conn);
1568                 p->conn = NULL;
1569                 goto error;
1570         }
1571
1572         return trans;
1573
1574 error:
1575         kfree(trans);
1576         return ERR_PTR(err);
1577 }
1578
1579 static struct p9_trans_module p9_tcp_trans = {
1580         .name = "tcp",
1581         .maxsize = MAX_SOCK_BUF,
1582         .def = 1,
1583         .create = p9_trans_create_tcp,
1584         .owner = THIS_MODULE,
1585 };
1586
1587 static struct p9_trans_module p9_unix_trans = {
1588         .name = "unix",
1589         .maxsize = MAX_SOCK_BUF,
1590         .def = 0,
1591         .create = p9_trans_create_unix,
1592         .owner = THIS_MODULE,
1593 };
1594
1595 static struct p9_trans_module p9_fd_trans = {
1596         .name = "fd",
1597         .maxsize = MAX_SOCK_BUF,
1598         .def = 0,
1599         .create = p9_trans_create_fd,
1600         .owner = THIS_MODULE,
1601 };
1602
1603 int p9_trans_fd_init(void)
1604 {
1605         int i;
1606
1607         for (i = 0; i < ARRAY_SIZE(p9_mux_poll_tasks); i++)
1608                 p9_mux_poll_tasks[i].task = NULL;
1609
1610         p9_mux_wq = create_workqueue("v9fs");
1611         if (!p9_mux_wq) {
1612                 printk(KERN_WARNING "v9fs: mux: creating workqueue failed\n");
1613                 return -ENOMEM;
1614         }
1615
1616         v9fs_register_trans(&p9_tcp_trans);
1617         v9fs_register_trans(&p9_unix_trans);
1618         v9fs_register_trans(&p9_fd_trans);
1619
1620         return 0;
1621 }
1622
1623 void p9_trans_fd_exit(void)
1624 {
1625         v9fs_unregister_trans(&p9_tcp_trans);
1626         v9fs_unregister_trans(&p9_unix_trans);
1627         v9fs_unregister_trans(&p9_fd_trans);
1628
1629         destroy_workqueue(p9_mux_wq);
1630 }