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