588bf88c3305d3e73bed1584d4aa23f234c4e26c
[muen/linux.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 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
29
30 #include <linux/in.h>
31 #include <linux/module.h>
32 #include <linux/net.h>
33 #include <linux/ipv6.h>
34 #include <linux/kthread.h>
35 #include <linux/errno.h>
36 #include <linux/kernel.h>
37 #include <linux/un.h>
38 #include <linux/uaccess.h>
39 #include <linux/inet.h>
40 #include <linux/idr.h>
41 #include <linux/file.h>
42 #include <linux/parser.h>
43 #include <linux/slab.h>
44 #include <linux/seq_file.h>
45 #include <net/9p/9p.h>
46 #include <net/9p/client.h>
47 #include <net/9p/transport.h>
48
49 #include <linux/syscalls.h> /* killme */
50
51 #define P9_PORT 564
52 #define MAX_SOCK_BUF (64*1024)
53 #define MAXPOLLWADDR    2
54
55 static struct p9_trans_module p9_tcp_trans;
56 static struct p9_trans_module p9_fd_trans;
57
58 /**
59  * struct p9_fd_opts - per-transport options
60  * @rfd: file descriptor for reading (trans=fd)
61  * @wfd: file descriptor for writing (trans=fd)
62  * @port: port to connect to (trans=tcp)
63  *
64  */
65
66 struct p9_fd_opts {
67         int rfd;
68         int wfd;
69         u16 port;
70         bool privport;
71 };
72
73 /*
74   * Option Parsing (code inspired by NFS code)
75   *  - a little lazy - parse all fd-transport options
76   */
77
78 enum {
79         /* Options that take integer arguments */
80         Opt_port, Opt_rfdno, Opt_wfdno, Opt_err,
81         /* Options that take no arguments */
82         Opt_privport,
83 };
84
85 static const match_table_t tokens = {
86         {Opt_port, "port=%u"},
87         {Opt_rfdno, "rfdno=%u"},
88         {Opt_wfdno, "wfdno=%u"},
89         {Opt_privport, "privport"},
90         {Opt_err, NULL},
91 };
92
93 enum {
94         Rworksched = 1,         /* read work scheduled or running */
95         Rpending = 2,           /* can read */
96         Wworksched = 4,         /* write work scheduled or running */
97         Wpending = 8,           /* can write */
98 };
99
100 struct p9_poll_wait {
101         struct p9_conn *conn;
102         wait_queue_entry_t wait;
103         wait_queue_head_t *wait_addr;
104 };
105
106 /**
107  * struct p9_conn - fd mux connection state information
108  * @mux_list: list link for mux to manage multiple connections (?)
109  * @client: reference to client instance for this connection
110  * @err: error state
111  * @req_list: accounting for requests which have been sent
112  * @unsent_req_list: accounting for requests that haven't been sent
113  * @req: current request being processed (if any)
114  * @tmp_buf: temporary buffer to read in header
115  * @rc: temporary fcall for reading current frame
116  * @wpos: write position for current frame
117  * @wsize: amount of data to write for current frame
118  * @wbuf: current write buffer
119  * @poll_pending_link: pending links to be polled per conn
120  * @poll_wait: array of wait_q's for various worker threads
121  * @pt: poll state
122  * @rq: current read work
123  * @wq: current write work
124  * @wsched: ????
125  *
126  */
127
128 struct p9_conn {
129         struct list_head mux_list;
130         struct p9_client *client;
131         int err;
132         struct list_head req_list;
133         struct list_head unsent_req_list;
134         struct p9_req_t *req;
135         char tmp_buf[7];
136         struct p9_fcall rc;
137         int wpos;
138         int wsize;
139         char *wbuf;
140         struct list_head poll_pending_link;
141         struct p9_poll_wait poll_wait[MAXPOLLWADDR];
142         poll_table pt;
143         struct work_struct rq;
144         struct work_struct wq;
145         unsigned long wsched;
146 };
147
148 /**
149  * struct p9_trans_fd - transport state
150  * @rd: reference to file to read from
151  * @wr: reference of file to write to
152  * @conn: connection state reference
153  *
154  */
155
156 struct p9_trans_fd {
157         struct file *rd;
158         struct file *wr;
159         struct p9_conn conn;
160 };
161
162 static void p9_poll_workfn(struct work_struct *work);
163
164 static DEFINE_SPINLOCK(p9_poll_lock);
165 static LIST_HEAD(p9_poll_pending_list);
166 static DECLARE_WORK(p9_poll_work, p9_poll_workfn);
167
168 static unsigned int p9_ipport_resv_min = P9_DEF_MIN_RESVPORT;
169 static unsigned int p9_ipport_resv_max = P9_DEF_MAX_RESVPORT;
170
171 static void p9_mux_poll_stop(struct p9_conn *m)
172 {
173         unsigned long flags;
174         int i;
175
176         for (i = 0; i < ARRAY_SIZE(m->poll_wait); i++) {
177                 struct p9_poll_wait *pwait = &m->poll_wait[i];
178
179                 if (pwait->wait_addr) {
180                         remove_wait_queue(pwait->wait_addr, &pwait->wait);
181                         pwait->wait_addr = NULL;
182                 }
183         }
184
185         spin_lock_irqsave(&p9_poll_lock, flags);
186         list_del_init(&m->poll_pending_link);
187         spin_unlock_irqrestore(&p9_poll_lock, flags);
188 }
189
190 /**
191  * p9_conn_cancel - cancel all pending requests with error
192  * @m: mux data
193  * @err: error code
194  *
195  */
196
197 static void p9_conn_cancel(struct p9_conn *m, int err)
198 {
199         struct p9_req_t *req, *rtmp;
200         unsigned long flags;
201         LIST_HEAD(cancel_list);
202
203         p9_debug(P9_DEBUG_ERROR, "mux %p err %d\n", m, err);
204
205         spin_lock_irqsave(&m->client->lock, flags);
206
207         if (m->err) {
208                 spin_unlock_irqrestore(&m->client->lock, flags);
209                 return;
210         }
211
212         m->err = err;
213
214         list_for_each_entry_safe(req, rtmp, &m->req_list, req_list) {
215                 list_move(&req->req_list, &cancel_list);
216         }
217         list_for_each_entry_safe(req, rtmp, &m->unsent_req_list, req_list) {
218                 list_move(&req->req_list, &cancel_list);
219         }
220         spin_unlock_irqrestore(&m->client->lock, flags);
221
222         list_for_each_entry_safe(req, rtmp, &cancel_list, req_list) {
223                 p9_debug(P9_DEBUG_ERROR, "call back req %p\n", req);
224                 list_del(&req->req_list);
225                 if (!req->t_err)
226                         req->t_err = err;
227                 p9_client_cb(m->client, req, REQ_STATUS_ERROR);
228         }
229 }
230
231 static __poll_t
232 p9_fd_poll(struct p9_client *client, struct poll_table_struct *pt, int *err)
233 {
234         __poll_t ret;
235         struct p9_trans_fd *ts = NULL;
236
237         if (client && client->status == Connected)
238                 ts = client->trans;
239
240         if (!ts) {
241                 if (err)
242                         *err = -EREMOTEIO;
243                 return EPOLLERR;
244         }
245
246         ret = vfs_poll(ts->rd, pt);
247         if (ts->rd != ts->wr)
248                 ret = (ret & ~EPOLLOUT) | (vfs_poll(ts->wr, pt) & ~EPOLLIN);
249         return ret;
250 }
251
252 /**
253  * p9_fd_read- read from a fd
254  * @client: client instance
255  * @v: buffer to receive data into
256  * @len: size of receive buffer
257  *
258  */
259
260 static int p9_fd_read(struct p9_client *client, void *v, int len)
261 {
262         int ret;
263         struct p9_trans_fd *ts = NULL;
264         loff_t pos;
265
266         if (client && client->status != Disconnected)
267                 ts = client->trans;
268
269         if (!ts)
270                 return -EREMOTEIO;
271
272         if (!(ts->rd->f_flags & O_NONBLOCK))
273                 p9_debug(P9_DEBUG_ERROR, "blocking read ...\n");
274
275         pos = ts->rd->f_pos;
276         ret = kernel_read(ts->rd, v, len, &pos);
277         if (ret <= 0 && ret != -ERESTARTSYS && ret != -EAGAIN)
278                 client->status = Disconnected;
279         return ret;
280 }
281
282 /**
283  * p9_read_work - called when there is some data to be read from a transport
284  * @work: container of work to be done
285  *
286  */
287
288 static void p9_read_work(struct work_struct *work)
289 {
290         __poll_t n;
291         int err;
292         struct p9_conn *m;
293         int status = REQ_STATUS_ERROR;
294
295         m = container_of(work, struct p9_conn, rq);
296
297         if (m->err < 0)
298                 return;
299
300         p9_debug(P9_DEBUG_TRANS, "start mux %p pos %zd\n", m, m->rc.offset);
301
302         if (!m->rc.sdata) {
303                 m->rc.sdata = m->tmp_buf;
304                 m->rc.offset = 0;
305                 m->rc.capacity = 7; /* start by reading header */
306         }
307
308         clear_bit(Rpending, &m->wsched);
309         p9_debug(P9_DEBUG_TRANS, "read mux %p pos %zd size: %zd = %zd\n",
310                  m, m->rc.offset, m->rc.capacity,
311                  m->rc.capacity - m->rc.offset);
312         err = p9_fd_read(m->client, m->rc.sdata + m->rc.offset,
313                          m->rc.capacity - m->rc.offset);
314         p9_debug(P9_DEBUG_TRANS, "mux %p got %d bytes\n", m, err);
315         if (err == -EAGAIN)
316                 goto end_clear;
317
318         if (err <= 0)
319                 goto error;
320
321         m->rc.offset += err;
322
323         /* header read in */
324         if ((!m->req) && (m->rc.offset == m->rc.capacity)) {
325                 p9_debug(P9_DEBUG_TRANS, "got new header\n");
326
327                 err = p9_parse_header(&m->rc, NULL, NULL, NULL, 0);
328                 if (err) {
329                         p9_debug(P9_DEBUG_ERROR,
330                                  "error parsing header: %d\n", err);
331                         goto error;
332                 }
333
334                 if (m->rc.size >= m->client->msize) {
335                         p9_debug(P9_DEBUG_ERROR,
336                                  "requested packet size too big: %d\n",
337                                  m->rc.size);
338                         err = -EIO;
339                         goto error;
340                 }
341
342                 p9_debug(P9_DEBUG_TRANS,
343                          "mux %p pkt: size: %d bytes tag: %d\n",
344                          m, m->rc.size, m->rc.tag);
345
346                 m->req = p9_tag_lookup(m->client, m->rc.tag);
347                 if (!m->req || (m->req->status != REQ_STATUS_SENT)) {
348                         p9_debug(P9_DEBUG_ERROR, "Unexpected packet tag %d\n",
349                                  m->rc.tag);
350                         err = -EIO;
351                         goto error;
352                 }
353
354                 if (m->req->rc == NULL) {
355                         p9_debug(P9_DEBUG_ERROR,
356                                  "No recv fcall for tag %d (req %p), disconnecting!\n",
357                                  m->rc.tag, m->req);
358                         m->req = NULL;
359                         err = -EIO;
360                         goto error;
361                 }
362                 m->rc.sdata = (char *)m->req->rc + sizeof(struct p9_fcall);
363                 memcpy(m->rc.sdata, m->tmp_buf, m->rc.capacity);
364                 m->rc.capacity = m->rc.size;
365         }
366
367         /* packet is read in
368          * not an else because some packets (like clunk) have no payload
369          */
370         if ((m->req) && (m->rc.offset == m->rc.capacity)) {
371                 p9_debug(P9_DEBUG_TRANS, "got new packet\n");
372                 spin_lock(&m->client->lock);
373                 if (m->req->status != REQ_STATUS_ERROR)
374                         status = REQ_STATUS_RCVD;
375                 list_del(&m->req->req_list);
376                 spin_unlock(&m->client->lock);
377                 p9_client_cb(m->client, m->req, status);
378                 m->rc.sdata = NULL;
379                 m->rc.offset = 0;
380                 m->rc.capacity = 0;
381                 m->req = NULL;
382         }
383
384 end_clear:
385         clear_bit(Rworksched, &m->wsched);
386
387         if (!list_empty(&m->req_list)) {
388                 if (test_and_clear_bit(Rpending, &m->wsched))
389                         n = EPOLLIN;
390                 else
391                         n = p9_fd_poll(m->client, NULL, NULL);
392
393                 if ((n & EPOLLIN) && !test_and_set_bit(Rworksched, &m->wsched)) {
394                         p9_debug(P9_DEBUG_TRANS, "sched read work %p\n", m);
395                         schedule_work(&m->rq);
396                 }
397         }
398
399         return;
400 error:
401         p9_conn_cancel(m, err);
402         clear_bit(Rworksched, &m->wsched);
403 }
404
405 /**
406  * p9_fd_write - write to a socket
407  * @client: client instance
408  * @v: buffer to send data from
409  * @len: size of send buffer
410  *
411  */
412
413 static int p9_fd_write(struct p9_client *client, void *v, int len)
414 {
415         ssize_t ret;
416         struct p9_trans_fd *ts = NULL;
417
418         if (client && client->status != Disconnected)
419                 ts = client->trans;
420
421         if (!ts)
422                 return -EREMOTEIO;
423
424         if (!(ts->wr->f_flags & O_NONBLOCK))
425                 p9_debug(P9_DEBUG_ERROR, "blocking write ...\n");
426
427         ret = kernel_write(ts->wr, v, len, &ts->wr->f_pos);
428         if (ret <= 0 && ret != -ERESTARTSYS && ret != -EAGAIN)
429                 client->status = Disconnected;
430         return ret;
431 }
432
433 /**
434  * p9_write_work - called when a transport can send some data
435  * @work: container for work to be done
436  *
437  */
438
439 static void p9_write_work(struct work_struct *work)
440 {
441         __poll_t n;
442         int err;
443         struct p9_conn *m;
444         struct p9_req_t *req;
445
446         m = container_of(work, struct p9_conn, wq);
447
448         if (m->err < 0) {
449                 clear_bit(Wworksched, &m->wsched);
450                 return;
451         }
452
453         if (!m->wsize) {
454                 spin_lock(&m->client->lock);
455                 if (list_empty(&m->unsent_req_list)) {
456                         clear_bit(Wworksched, &m->wsched);
457                         spin_unlock(&m->client->lock);
458                         return;
459                 }
460
461                 req = list_entry(m->unsent_req_list.next, struct p9_req_t,
462                                req_list);
463                 req->status = REQ_STATUS_SENT;
464                 p9_debug(P9_DEBUG_TRANS, "move req %p\n", req);
465                 list_move_tail(&req->req_list, &m->req_list);
466
467                 m->wbuf = req->tc->sdata;
468                 m->wsize = req->tc->size;
469                 m->wpos = 0;
470                 spin_unlock(&m->client->lock);
471         }
472
473         p9_debug(P9_DEBUG_TRANS, "mux %p pos %d size %d\n",
474                  m, m->wpos, m->wsize);
475         clear_bit(Wpending, &m->wsched);
476         err = p9_fd_write(m->client, m->wbuf + m->wpos, m->wsize - m->wpos);
477         p9_debug(P9_DEBUG_TRANS, "mux %p sent %d bytes\n", m, err);
478         if (err == -EAGAIN)
479                 goto end_clear;
480
481
482         if (err < 0)
483                 goto error;
484         else if (err == 0) {
485                 err = -EREMOTEIO;
486                 goto error;
487         }
488
489         m->wpos += err;
490         if (m->wpos == m->wsize)
491                 m->wpos = m->wsize = 0;
492
493 end_clear:
494         clear_bit(Wworksched, &m->wsched);
495
496         if (m->wsize || !list_empty(&m->unsent_req_list)) {
497                 if (test_and_clear_bit(Wpending, &m->wsched))
498                         n = EPOLLOUT;
499                 else
500                         n = p9_fd_poll(m->client, NULL, NULL);
501
502                 if ((n & EPOLLOUT) &&
503                    !test_and_set_bit(Wworksched, &m->wsched)) {
504                         p9_debug(P9_DEBUG_TRANS, "sched write work %p\n", m);
505                         schedule_work(&m->wq);
506                 }
507         }
508
509         return;
510
511 error:
512         p9_conn_cancel(m, err);
513         clear_bit(Wworksched, &m->wsched);
514 }
515
516 static int p9_pollwake(wait_queue_entry_t *wait, unsigned int mode, int sync, void *key)
517 {
518         struct p9_poll_wait *pwait =
519                 container_of(wait, struct p9_poll_wait, wait);
520         struct p9_conn *m = pwait->conn;
521         unsigned long flags;
522
523         spin_lock_irqsave(&p9_poll_lock, flags);
524         if (list_empty(&m->poll_pending_link))
525                 list_add_tail(&m->poll_pending_link, &p9_poll_pending_list);
526         spin_unlock_irqrestore(&p9_poll_lock, flags);
527
528         schedule_work(&p9_poll_work);
529         return 1;
530 }
531
532 /**
533  * p9_pollwait - add poll task to the wait queue
534  * @filp: file pointer being polled
535  * @wait_address: wait_q to block on
536  * @p: poll state
537  *
538  * called by files poll operation to add v9fs-poll task to files wait queue
539  */
540
541 static void
542 p9_pollwait(struct file *filp, wait_queue_head_t *wait_address, poll_table *p)
543 {
544         struct p9_conn *m = container_of(p, struct p9_conn, pt);
545         struct p9_poll_wait *pwait = NULL;
546         int i;
547
548         for (i = 0; i < ARRAY_SIZE(m->poll_wait); i++) {
549                 if (m->poll_wait[i].wait_addr == NULL) {
550                         pwait = &m->poll_wait[i];
551                         break;
552                 }
553         }
554
555         if (!pwait) {
556                 p9_debug(P9_DEBUG_ERROR, "not enough wait_address slots\n");
557                 return;
558         }
559
560         pwait->conn = m;
561         pwait->wait_addr = wait_address;
562         init_waitqueue_func_entry(&pwait->wait, p9_pollwake);
563         add_wait_queue(wait_address, &pwait->wait);
564 }
565
566 /**
567  * p9_conn_create - initialize the per-session mux data
568  * @client: client instance
569  *
570  * Note: Creates the polling task if this is the first session.
571  */
572
573 static void p9_conn_create(struct p9_client *client)
574 {
575         __poll_t n;
576         struct p9_trans_fd *ts = client->trans;
577         struct p9_conn *m = &ts->conn;
578
579         p9_debug(P9_DEBUG_TRANS, "client %p msize %d\n", client, client->msize);
580
581         INIT_LIST_HEAD(&m->mux_list);
582         m->client = client;
583
584         INIT_LIST_HEAD(&m->req_list);
585         INIT_LIST_HEAD(&m->unsent_req_list);
586         INIT_WORK(&m->rq, p9_read_work);
587         INIT_WORK(&m->wq, p9_write_work);
588         INIT_LIST_HEAD(&m->poll_pending_link);
589         init_poll_funcptr(&m->pt, p9_pollwait);
590
591         n = p9_fd_poll(client, &m->pt, NULL);
592         if (n & EPOLLIN) {
593                 p9_debug(P9_DEBUG_TRANS, "mux %p can read\n", m);
594                 set_bit(Rpending, &m->wsched);
595         }
596
597         if (n & EPOLLOUT) {
598                 p9_debug(P9_DEBUG_TRANS, "mux %p can write\n", m);
599                 set_bit(Wpending, &m->wsched);
600         }
601 }
602
603 /**
604  * p9_poll_mux - polls a mux and schedules read or write works if necessary
605  * @m: connection to poll
606  *
607  */
608
609 static void p9_poll_mux(struct p9_conn *m)
610 {
611         __poll_t n;
612         int err = -ECONNRESET;
613
614         if (m->err < 0)
615                 return;
616
617         n = p9_fd_poll(m->client, NULL, &err);
618         if (n & (EPOLLERR | EPOLLHUP | EPOLLNVAL)) {
619                 p9_debug(P9_DEBUG_TRANS, "error mux %p err %d\n", m, n);
620                 p9_conn_cancel(m, err);
621         }
622
623         if (n & EPOLLIN) {
624                 set_bit(Rpending, &m->wsched);
625                 p9_debug(P9_DEBUG_TRANS, "mux %p can read\n", m);
626                 if (!test_and_set_bit(Rworksched, &m->wsched)) {
627                         p9_debug(P9_DEBUG_TRANS, "sched read work %p\n", m);
628                         schedule_work(&m->rq);
629                 }
630         }
631
632         if (n & EPOLLOUT) {
633                 set_bit(Wpending, &m->wsched);
634                 p9_debug(P9_DEBUG_TRANS, "mux %p can write\n", m);
635                 if ((m->wsize || !list_empty(&m->unsent_req_list)) &&
636                     !test_and_set_bit(Wworksched, &m->wsched)) {
637                         p9_debug(P9_DEBUG_TRANS, "sched write work %p\n", m);
638                         schedule_work(&m->wq);
639                 }
640         }
641 }
642
643 /**
644  * p9_fd_request - send 9P request
645  * The function can sleep until the request is scheduled for sending.
646  * The function can be interrupted. Return from the function is not
647  * a guarantee that the request is sent successfully.
648  *
649  * @client: client instance
650  * @req: request to be sent
651  *
652  */
653
654 static int p9_fd_request(struct p9_client *client, struct p9_req_t *req)
655 {
656         __poll_t n;
657         struct p9_trans_fd *ts = client->trans;
658         struct p9_conn *m = &ts->conn;
659
660         p9_debug(P9_DEBUG_TRANS, "mux %p task %p tcall %p id %d\n",
661                  m, current, req->tc, req->tc->id);
662         if (m->err < 0)
663                 return m->err;
664
665         spin_lock(&client->lock);
666         req->status = REQ_STATUS_UNSENT;
667         list_add_tail(&req->req_list, &m->unsent_req_list);
668         spin_unlock(&client->lock);
669
670         if (test_and_clear_bit(Wpending, &m->wsched))
671                 n = EPOLLOUT;
672         else
673                 n = p9_fd_poll(m->client, NULL, NULL);
674
675         if (n & EPOLLOUT && !test_and_set_bit(Wworksched, &m->wsched))
676                 schedule_work(&m->wq);
677
678         return 0;
679 }
680
681 static int p9_fd_cancel(struct p9_client *client, struct p9_req_t *req)
682 {
683         int ret = 1;
684
685         p9_debug(P9_DEBUG_TRANS, "client %p req %p\n", client, req);
686
687         spin_lock(&client->lock);
688
689         if (req->status == REQ_STATUS_UNSENT) {
690                 list_del(&req->req_list);
691                 req->status = REQ_STATUS_FLSHD;
692                 ret = 0;
693         }
694         spin_unlock(&client->lock);
695
696         return ret;
697 }
698
699 static int p9_fd_cancelled(struct p9_client *client, struct p9_req_t *req)
700 {
701         p9_debug(P9_DEBUG_TRANS, "client %p req %p\n", client, req);
702
703         /* we haven't received a response for oldreq,
704          * remove it from the list.
705          */
706         spin_lock(&client->lock);
707         list_del(&req->req_list);
708         spin_unlock(&client->lock);
709
710         return 0;
711 }
712
713 static int p9_fd_show_options(struct seq_file *m, struct p9_client *clnt)
714 {
715         if (clnt->trans_mod == &p9_tcp_trans) {
716                 if (clnt->trans_opts.tcp.port != P9_PORT)
717                         seq_printf(m, ",port=%u", clnt->trans_opts.tcp.port);
718         } else if (clnt->trans_mod == &p9_fd_trans) {
719                 if (clnt->trans_opts.fd.rfd != ~0)
720                         seq_printf(m, ",rfd=%u", clnt->trans_opts.fd.rfd);
721                 if (clnt->trans_opts.fd.wfd != ~0)
722                         seq_printf(m, ",wfd=%u", clnt->trans_opts.fd.wfd);
723         }
724         return 0;
725 }
726
727 /**
728  * parse_opts - parse mount options into p9_fd_opts structure
729  * @params: options string passed from mount
730  * @opts: fd transport-specific structure to parse options into
731  *
732  * Returns 0 upon success, -ERRNO upon failure
733  */
734
735 static int parse_opts(char *params, struct p9_fd_opts *opts)
736 {
737         char *p;
738         substring_t args[MAX_OPT_ARGS];
739         int option;
740         char *options, *tmp_options;
741
742         opts->port = P9_PORT;
743         opts->rfd = ~0;
744         opts->wfd = ~0;
745         opts->privport = false;
746
747         if (!params)
748                 return 0;
749
750         tmp_options = kstrdup(params, GFP_KERNEL);
751         if (!tmp_options) {
752                 p9_debug(P9_DEBUG_ERROR,
753                          "failed to allocate copy of option string\n");
754                 return -ENOMEM;
755         }
756         options = tmp_options;
757
758         while ((p = strsep(&options, ",")) != NULL) {
759                 int token;
760                 int r;
761                 if (!*p)
762                         continue;
763                 token = match_token(p, tokens, args);
764                 if ((token != Opt_err) && (token != Opt_privport)) {
765                         r = match_int(&args[0], &option);
766                         if (r < 0) {
767                                 p9_debug(P9_DEBUG_ERROR,
768                                          "integer field, but no integer?\n");
769                                 continue;
770                         }
771                 }
772                 switch (token) {
773                 case Opt_port:
774                         opts->port = option;
775                         break;
776                 case Opt_rfdno:
777                         opts->rfd = option;
778                         break;
779                 case Opt_wfdno:
780                         opts->wfd = option;
781                         break;
782                 case Opt_privport:
783                         opts->privport = true;
784                         break;
785                 default:
786                         continue;
787                 }
788         }
789
790         kfree(tmp_options);
791         return 0;
792 }
793
794 static int p9_fd_open(struct p9_client *client, int rfd, int wfd)
795 {
796         struct p9_trans_fd *ts = kzalloc(sizeof(struct p9_trans_fd),
797                                            GFP_KERNEL);
798         if (!ts)
799                 return -ENOMEM;
800
801         ts->rd = fget(rfd);
802         ts->wr = fget(wfd);
803         if (!ts->rd || !ts->wr) {
804                 if (ts->rd)
805                         fput(ts->rd);
806                 if (ts->wr)
807                         fput(ts->wr);
808                 kfree(ts);
809                 return -EIO;
810         }
811
812         client->trans = ts;
813         client->status = Connected;
814
815         return 0;
816 }
817
818 static int p9_socket_open(struct p9_client *client, struct socket *csocket)
819 {
820         struct p9_trans_fd *p;
821         struct file *file;
822
823         p = kzalloc(sizeof(struct p9_trans_fd), GFP_KERNEL);
824         if (!p)
825                 return -ENOMEM;
826
827         csocket->sk->sk_allocation = GFP_NOIO;
828         file = sock_alloc_file(csocket, 0, NULL);
829         if (IS_ERR(file)) {
830                 pr_err("%s (%d): failed to map fd\n",
831                        __func__, task_pid_nr(current));
832                 kfree(p);
833                 return PTR_ERR(file);
834         }
835
836         get_file(file);
837         p->wr = p->rd = file;
838         client->trans = p;
839         client->status = Connected;
840
841         p->rd->f_flags |= O_NONBLOCK;
842
843         p9_conn_create(client);
844         return 0;
845 }
846
847 /**
848  * p9_mux_destroy - cancels all pending requests of mux
849  * @m: mux to destroy
850  *
851  */
852
853 static void p9_conn_destroy(struct p9_conn *m)
854 {
855         p9_debug(P9_DEBUG_TRANS, "mux %p prev %p next %p\n",
856                  m, m->mux_list.prev, m->mux_list.next);
857
858         p9_mux_poll_stop(m);
859         cancel_work_sync(&m->rq);
860         cancel_work_sync(&m->wq);
861
862         p9_conn_cancel(m, -ECONNRESET);
863
864         m->client = NULL;
865 }
866
867 /**
868  * p9_fd_close - shutdown file descriptor transport
869  * @client: client instance
870  *
871  */
872
873 static void p9_fd_close(struct p9_client *client)
874 {
875         struct p9_trans_fd *ts;
876
877         if (!client)
878                 return;
879
880         ts = client->trans;
881         if (!ts)
882                 return;
883
884         client->status = Disconnected;
885
886         p9_conn_destroy(&ts->conn);
887
888         if (ts->rd)
889                 fput(ts->rd);
890         if (ts->wr)
891                 fput(ts->wr);
892
893         kfree(ts);
894 }
895
896 /*
897  * stolen from NFS - maybe should be made a generic function?
898  */
899 static inline int valid_ipaddr4(const char *buf)
900 {
901         int rc, count, in[4];
902
903         rc = sscanf(buf, "%d.%d.%d.%d", &in[0], &in[1], &in[2], &in[3]);
904         if (rc != 4)
905                 return -EINVAL;
906         for (count = 0; count < 4; count++) {
907                 if (in[count] > 255)
908                         return -EINVAL;
909         }
910         return 0;
911 }
912
913 static int p9_bind_privport(struct socket *sock)
914 {
915         struct sockaddr_in cl;
916         int port, err = -EINVAL;
917
918         memset(&cl, 0, sizeof(cl));
919         cl.sin_family = AF_INET;
920         cl.sin_addr.s_addr = INADDR_ANY;
921         for (port = p9_ipport_resv_max; port >= p9_ipport_resv_min; port--) {
922                 cl.sin_port = htons((ushort)port);
923                 err = kernel_bind(sock, (struct sockaddr *)&cl, sizeof(cl));
924                 if (err != -EADDRINUSE)
925                         break;
926         }
927         return err;
928 }
929
930
931 static int
932 p9_fd_create_tcp(struct p9_client *client, const char *addr, char *args)
933 {
934         int err;
935         struct socket *csocket;
936         struct sockaddr_in sin_server;
937         struct p9_fd_opts opts;
938
939         err = parse_opts(args, &opts);
940         if (err < 0)
941                 return err;
942
943         if (valid_ipaddr4(addr) < 0)
944                 return -EINVAL;
945
946         csocket = NULL;
947
948         client->trans_opts.tcp.port = opts.port;
949         client->trans_opts.tcp.privport = opts.privport;
950         sin_server.sin_family = AF_INET;
951         sin_server.sin_addr.s_addr = in_aton(addr);
952         sin_server.sin_port = htons(opts.port);
953         err = __sock_create(current->nsproxy->net_ns, PF_INET,
954                             SOCK_STREAM, IPPROTO_TCP, &csocket, 1);
955         if (err) {
956                 pr_err("%s (%d): problem creating socket\n",
957                        __func__, task_pid_nr(current));
958                 return err;
959         }
960
961         if (opts.privport) {
962                 err = p9_bind_privport(csocket);
963                 if (err < 0) {
964                         pr_err("%s (%d): problem binding to privport\n",
965                                __func__, task_pid_nr(current));
966                         sock_release(csocket);
967                         return err;
968                 }
969         }
970
971         err = csocket->ops->connect(csocket,
972                                     (struct sockaddr *)&sin_server,
973                                     sizeof(struct sockaddr_in), 0);
974         if (err < 0) {
975                 pr_err("%s (%d): problem connecting socket to %s\n",
976                        __func__, task_pid_nr(current), addr);
977                 sock_release(csocket);
978                 return err;
979         }
980
981         return p9_socket_open(client, csocket);
982 }
983
984 static int
985 p9_fd_create_unix(struct p9_client *client, const char *addr, char *args)
986 {
987         int err;
988         struct socket *csocket;
989         struct sockaddr_un sun_server;
990
991         csocket = NULL;
992
993         if (strlen(addr) >= UNIX_PATH_MAX) {
994                 pr_err("%s (%d): address too long: %s\n",
995                        __func__, task_pid_nr(current), addr);
996                 return -ENAMETOOLONG;
997         }
998
999         sun_server.sun_family = PF_UNIX;
1000         strcpy(sun_server.sun_path, addr);
1001         err = __sock_create(current->nsproxy->net_ns, PF_UNIX,
1002                             SOCK_STREAM, 0, &csocket, 1);
1003         if (err < 0) {
1004                 pr_err("%s (%d): problem creating socket\n",
1005                        __func__, task_pid_nr(current));
1006
1007                 return err;
1008         }
1009         err = csocket->ops->connect(csocket, (struct sockaddr *)&sun_server,
1010                         sizeof(struct sockaddr_un) - 1, 0);
1011         if (err < 0) {
1012                 pr_err("%s (%d): problem connecting socket: %s: %d\n",
1013                        __func__, task_pid_nr(current), addr, err);
1014                 sock_release(csocket);
1015                 return err;
1016         }
1017
1018         return p9_socket_open(client, csocket);
1019 }
1020
1021 static int
1022 p9_fd_create(struct p9_client *client, const char *addr, char *args)
1023 {
1024         int err;
1025         struct p9_fd_opts opts;
1026
1027         parse_opts(args, &opts);
1028         client->trans_opts.fd.rfd = opts.rfd;
1029         client->trans_opts.fd.wfd = opts.wfd;
1030
1031         if (opts.rfd == ~0 || opts.wfd == ~0) {
1032                 pr_err("Insufficient options for proto=fd\n");
1033                 return -ENOPROTOOPT;
1034         }
1035
1036         err = p9_fd_open(client, opts.rfd, opts.wfd);
1037         if (err < 0)
1038                 return err;
1039
1040         p9_conn_create(client);
1041
1042         return 0;
1043 }
1044
1045 static struct p9_trans_module p9_tcp_trans = {
1046         .name = "tcp",
1047         .maxsize = MAX_SOCK_BUF,
1048         .def = 0,
1049         .create = p9_fd_create_tcp,
1050         .close = p9_fd_close,
1051         .request = p9_fd_request,
1052         .cancel = p9_fd_cancel,
1053         .cancelled = p9_fd_cancelled,
1054         .show_options = p9_fd_show_options,
1055         .owner = THIS_MODULE,
1056 };
1057
1058 static struct p9_trans_module p9_unix_trans = {
1059         .name = "unix",
1060         .maxsize = MAX_SOCK_BUF,
1061         .def = 0,
1062         .create = p9_fd_create_unix,
1063         .close = p9_fd_close,
1064         .request = p9_fd_request,
1065         .cancel = p9_fd_cancel,
1066         .cancelled = p9_fd_cancelled,
1067         .show_options = p9_fd_show_options,
1068         .owner = THIS_MODULE,
1069 };
1070
1071 static struct p9_trans_module p9_fd_trans = {
1072         .name = "fd",
1073         .maxsize = MAX_SOCK_BUF,
1074         .def = 0,
1075         .create = p9_fd_create,
1076         .close = p9_fd_close,
1077         .request = p9_fd_request,
1078         .cancel = p9_fd_cancel,
1079         .cancelled = p9_fd_cancelled,
1080         .show_options = p9_fd_show_options,
1081         .owner = THIS_MODULE,
1082 };
1083
1084 /**
1085  * p9_poll_workfn - poll worker thread
1086  * @work: work queue
1087  *
1088  * polls all v9fs transports for new events and queues the appropriate
1089  * work to the work queue
1090  *
1091  */
1092
1093 static void p9_poll_workfn(struct work_struct *work)
1094 {
1095         unsigned long flags;
1096
1097         p9_debug(P9_DEBUG_TRANS, "start %p\n", current);
1098
1099         spin_lock_irqsave(&p9_poll_lock, flags);
1100         while (!list_empty(&p9_poll_pending_list)) {
1101                 struct p9_conn *conn = list_first_entry(&p9_poll_pending_list,
1102                                                         struct p9_conn,
1103                                                         poll_pending_link);
1104                 list_del_init(&conn->poll_pending_link);
1105                 spin_unlock_irqrestore(&p9_poll_lock, flags);
1106
1107                 p9_poll_mux(conn);
1108
1109                 spin_lock_irqsave(&p9_poll_lock, flags);
1110         }
1111         spin_unlock_irqrestore(&p9_poll_lock, flags);
1112
1113         p9_debug(P9_DEBUG_TRANS, "finish\n");
1114 }
1115
1116 int p9_trans_fd_init(void)
1117 {
1118         v9fs_register_trans(&p9_tcp_trans);
1119         v9fs_register_trans(&p9_unix_trans);
1120         v9fs_register_trans(&p9_fd_trans);
1121
1122         return 0;
1123 }
1124
1125 void p9_trans_fd_exit(void)
1126 {
1127         flush_work(&p9_poll_work);
1128         v9fs_unregister_trans(&p9_tcp_trans);
1129         v9fs_unregister_trans(&p9_unix_trans);
1130         v9fs_unregister_trans(&p9_fd_trans);
1131 }