2 * linux/fs/9p/trans_fd.c
4 * Fd transport layer. Includes deprecated socket layer.
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>
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.
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.
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
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>
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>
45 #define MAX_SOCK_BUF (64*1024)
47 #define SCHED_TIMEOUT 10
48 #define MAXPOLLWADDR 2
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)
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
80 * Option Parsing (code inspired by NFS code)
81 * - a little lazy - parse all fd-transport options
85 /* Options that take integer arguments */
86 Opt_port, Opt_rfdno, Opt_wfdno, Opt_err,
89 static match_table_t tokens = {
90 {Opt_port, "port=%u"},
91 {Opt_rfdno, "rfdno=%u"},
92 {Opt_wfdno, "wfdno=%u"},
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 */
110 typedef void (*p9_conn_req_callback)(struct p9_req *req, void *a);
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
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
129 struct p9_fcall *tcall;
130 struct p9_fcall *rcall;
132 p9_conn_req_callback cb;
135 struct list_head req_list;
138 struct p9_mux_poll_task {
139 struct task_struct *task;
140 struct list_head mux_list;
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
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
165 * @rq: current read work
166 * @wq: current write work
172 spinlock_t lock; /* protect lock structure */
173 struct list_head mux_list;
174 struct p9_mux_poll_task *poll_task;
176 unsigned char extended;
177 struct p9_trans *trans;
178 struct p9_idpool *tagpool;
180 struct list_head req_list;
181 struct list_head unsent_req_list;
182 struct p9_fcall *rcall;
188 wait_queue_t poll_wait[MAXPOLLWADDR];
189 wait_queue_head_t *poll_waddr[MAXPOLLWADDR];
191 struct work_struct rq;
192 struct work_struct wq;
193 unsigned long wsched;
197 * struct p9_mux_rpc - fd mux rpc accounting structure
198 * @m: connection this request was issued on
200 * @tcall: request &p9_fcall
201 * @rcall: response &p9_fcall
202 * @wqueue: wait queue that client is blocked on for this rpc
204 * Bug: isn't this information duplicated elsewhere like &p9_req
210 struct p9_fcall *tcall;
211 struct p9_fcall *rcall;
212 wait_queue_head_t wqueue;
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,
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);
223 static DEFINE_MUTEX(p9_mux_task_lock);
224 static struct workqueue_struct *p9_mux_wq;
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];
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);
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 */
239 static void p9_conn_cancel(struct p9_conn *m, int err);
241 static int p9_mux_global_init(void)
245 for (i = 0; i < ARRAY_SIZE(p9_mux_poll_tasks); i++)
246 p9_mux_poll_tasks[i].task = NULL;
248 p9_mux_wq = create_workqueue("v9fs");
250 printk(KERN_WARNING "v9fs: mux: creating workqueue failed\n");
257 static u16 p9_mux_get_tag(struct p9_conn *m)
261 tag = p9_idpool_get(m->tagpool);
268 static void p9_mux_put_tag(struct p9_conn *m, u16 tag)
270 if (tag != P9_NOTAG && p9_idpool_check(tag, m->tagpool))
271 p9_idpool_put(tag, m->tagpool);
275 * p9_mux_calc_poll_procs - calculates the number of polling procs
276 * @muxnum: number of mounts
278 * Calculation is based on the number of mounted v9fs filesystems.
279 * The current implementation returns sqrt of the number of mounts.
282 static int p9_mux_calc_poll_procs(int muxnum)
286 if (p9_mux_poll_task_num)
287 n = muxnum / p9_mux_poll_task_num +
288 (muxnum % p9_mux_poll_task_num ? 1 : 0);
292 if (n > ARRAY_SIZE(p9_mux_poll_tasks))
293 n = ARRAY_SIZE(p9_mux_poll_tasks);
298 static int p9_mux_poll_start(struct p9_conn *m)
301 struct p9_mux_poll_task *vpt, *vptlast;
302 struct task_struct *pproc;
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);
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",
315 pproc = kthread_create(p9_poll_proc, vpt,
318 if (!IS_ERR(pproc)) {
320 INIT_LIST_HEAD(&vpt->mux_list);
322 p9_mux_poll_task_num++;
323 wake_up_process(vpt->task);
329 if (i >= ARRAY_SIZE(p9_mux_poll_tasks))
330 P9_DPRINTK(P9_DEBUG_ERROR,
331 "warning: no free poll slots\n");
334 n = (p9_mux_num + 1) / p9_mux_poll_task_num +
335 ((p9_mux_num + 1) % p9_mux_poll_task_num ? 1 : 0);
338 for (i = 0; i < ARRAY_SIZE(p9_mux_poll_tasks); i++) {
339 vpt = &p9_mux_poll_tasks[i];
340 if (vpt->task != NULL) {
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);
347 memset(&m->poll_waddr, 0,
348 sizeof(m->poll_waddr));
349 init_poll_funcptr(&m->pt, p9_pollwait);
355 if (i >= ARRAY_SIZE(p9_mux_poll_tasks)) {
356 if (vptlast == NULL) {
357 mutex_unlock(&p9_mux_task_lock);
361 P9_DPRINTK(P9_DEBUG_MUX, "put in proc %d\n", i);
362 list_add(&m->mux_list, &vptlast->mux_list);
364 m->poll_task = vptlast;
365 memset(&m->poll_waddr, 0, sizeof(m->poll_waddr));
366 init_poll_funcptr(&m->pt, p9_pollwait);
370 mutex_unlock(&p9_mux_task_lock);
375 static void p9_mux_poll_stop(struct p9_conn *m)
378 struct p9_mux_poll_task *vpt;
380 mutex_lock(&p9_mux_task_lock);
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;
391 P9_DPRINTK(P9_DEBUG_MUX, "destroy proc %p\n", vpt);
392 kthread_stop(vpt->task);
394 p9_mux_poll_task_num--;
397 mutex_unlock(&p9_mux_task_lock);
401 * p9_conn_create - allocate and initialize the per-session mux data
402 * @trans: transport structure
404 * Note: Creates the polling task if this is the first session.
407 static struct p9_conn *p9_conn_create(struct p9_trans *trans)
410 struct p9_conn *m, *mtmp;
412 P9_DPRINTK(P9_DEBUG_MUX, "transport %p msize %d\n", trans,
414 m = kmalloc(sizeof(struct p9_conn), GFP_KERNEL);
416 return ERR_PTR(-ENOMEM);
418 spin_lock_init(&m->lock);
419 INIT_LIST_HEAD(&m->mux_list);
420 m->msize = trans->msize;
421 m->extended = trans->extended;
423 m->tagpool = p9_idpool_create();
424 if (IS_ERR(m->tagpool)) {
425 mtmp = ERR_PTR(-ENOMEM);
431 INIT_LIST_HEAD(&m->req_list);
432 INIT_LIST_HEAD(&m->unsent_req_list);
436 m->wpos = m->wsize = 0;
438 INIT_WORK(&m->rq, p9_read_work);
439 INIT_WORK(&m->wq, p9_write_work);
441 memset(&m->poll_waddr, 0, sizeof(m->poll_waddr));
443 n = p9_mux_poll_start(m);
449 n = p9_fd_poll(trans, &m->pt);
451 P9_DPRINTK(P9_DEBUG_MUX, "mux %p can read\n", m);
452 set_bit(Rpending, &m->wsched);
456 P9_DPRINTK(P9_DEBUG_MUX, "mux %p can write\n", m);
457 set_bit(Wpending, &m->wsched);
460 for (i = 0; i < ARRAY_SIZE(m->poll_waddr); i++) {
461 if (IS_ERR(m->poll_waddr[i])) {
463 mtmp = (void *)m->poll_waddr; /* the error code */
474 * p9_mux_destroy - cancels all pending requests and frees mux resources
479 static void p9_conn_destroy(struct p9_conn *m)
481 P9_DPRINTK(P9_DEBUG_MUX, "mux %p prev %p next %p\n", m,
482 m->mux_list.prev, m->mux_list.next);
485 cancel_work_sync(&m->rq);
486 cancel_work_sync(&m->wq);
488 p9_conn_cancel(m, -ECONNRESET);
491 p9_idpool_destroy(m->tagpool);
496 * p9_pollwait - add poll task to the wait queue
497 * @filp: file pointer being polled
498 * @wait_address: wait_q to block on
501 * called by files poll operation to add v9fs-poll task to files wait queue
505 p9_pollwait(struct file *filp, wait_queue_head_t *wait_address, poll_table *p)
510 m = container_of(p, struct p9_conn, pt);
511 for (i = 0; i < ARRAY_SIZE(m->poll_waddr); i++)
512 if (m->poll_waddr[i] == NULL)
515 if (i >= ARRAY_SIZE(m->poll_waddr)) {
516 P9_DPRINTK(P9_DEBUG_ERROR, "not enough wait_address slots\n");
520 m->poll_waddr[i] = wait_address;
523 P9_DPRINTK(P9_DEBUG_ERROR, "no wait_address\n");
524 m->poll_waddr[i] = ERR_PTR(-EIO);
528 init_waitqueue_entry(&m->poll_wait[i], m->poll_task->task);
529 add_wait_queue(wait_address, &m->poll_wait[i]);
533 * p9_poll_mux - polls a mux and schedules read or write works if necessary
534 * @m: connection to poll
538 static void p9_poll_mux(struct p9_conn *m)
545 n = p9_fd_poll(m->trans, NULL);
546 if (n < 0 || n & (POLLERR | POLLHUP | POLLNVAL)) {
547 P9_DPRINTK(P9_DEBUG_MUX, "error mux %p err %d\n", m, n);
550 p9_conn_cancel(m, n);
554 set_bit(Rpending, &m->wsched);
555 P9_DPRINTK(P9_DEBUG_MUX, "mux %p can read\n", m);
556 if (!test_and_set_bit(Rworksched, &m->wsched)) {
557 P9_DPRINTK(P9_DEBUG_MUX, "schedule read work %p\n", m);
558 queue_work(p9_mux_wq, &m->rq);
563 set_bit(Wpending, &m->wsched);
564 P9_DPRINTK(P9_DEBUG_MUX, "mux %p can write\n", m);
565 if ((m->wsize || !list_empty(&m->unsent_req_list))
566 && !test_and_set_bit(Wworksched, &m->wsched)) {
567 P9_DPRINTK(P9_DEBUG_MUX, "schedule write work %p\n", m);
568 queue_work(p9_mux_wq, &m->wq);
574 * p9_poll_proc - poll worker thread
575 * @a: thread state and arguments
577 * polls all v9fs transports for new events and queues the appropriate
578 * work to the work queue
582 static int p9_poll_proc(void *a)
584 struct p9_conn *m, *mtmp;
585 struct p9_mux_poll_task *vpt;
588 P9_DPRINTK(P9_DEBUG_MUX, "start %p %p\n", current, vpt);
589 while (!kthread_should_stop()) {
590 set_current_state(TASK_INTERRUPTIBLE);
592 list_for_each_entry_safe(m, mtmp, &vpt->mux_list, mux_list) {
596 P9_DPRINTK(P9_DEBUG_MUX, "sleeping...\n");
597 schedule_timeout(SCHED_TIMEOUT * HZ);
600 __set_current_state(TASK_RUNNING);
601 P9_DPRINTK(P9_DEBUG_MUX, "finish\n");
606 * p9_write_work - called when a transport can send some data
607 * @work: container for work to be done
611 static void p9_write_work(struct work_struct *work)
617 m = container_of(work, struct p9_conn, wq);
620 clear_bit(Wworksched, &m->wsched);
625 if (list_empty(&m->unsent_req_list)) {
626 clear_bit(Wworksched, &m->wsched);
632 req = list_entry(m->unsent_req_list.next, struct p9_req,
634 list_move_tail(&req->req_list, &m->req_list);
635 if (req->err == ERREQFLUSH)
638 m->wbuf = req->tcall->sdata;
639 m->wsize = req->tcall->size;
641 spin_unlock(&m->lock);
644 P9_DPRINTK(P9_DEBUG_MUX, "mux %p pos %d size %d\n", m, m->wpos,
646 clear_bit(Wpending, &m->wsched);
647 err = p9_fd_write(m->trans, m->wbuf + m->wpos, m->wsize - m->wpos);
648 P9_DPRINTK(P9_DEBUG_MUX, "mux %p sent %d bytes\n", m, err);
649 if (err == -EAGAIN) {
650 clear_bit(Wworksched, &m->wsched);
662 if (m->wpos == m->wsize)
663 m->wpos = m->wsize = 0;
665 if (m->wsize == 0 && !list_empty(&m->unsent_req_list)) {
666 if (test_and_clear_bit(Wpending, &m->wsched))
669 n = p9_fd_poll(m->trans, NULL);
672 P9_DPRINTK(P9_DEBUG_MUX, "schedule write work %p\n", m);
673 queue_work(p9_mux_wq, &m->wq);
675 clear_bit(Wworksched, &m->wsched);
677 clear_bit(Wworksched, &m->wsched);
682 p9_conn_cancel(m, err);
683 clear_bit(Wworksched, &m->wsched);
686 static void process_request(struct p9_conn *m, struct p9_req *req)
689 struct p9_str *ename;
691 if (!req->err && req->rcall->id == P9_RERROR) {
692 ecode = req->rcall->params.rerror.errno;
693 ename = &req->rcall->params.rerror.error;
695 P9_DPRINTK(P9_DEBUG_MUX, "Rerror %.*s\n", ename->len,
702 req->err = p9_errstr2errno(ename->str, ename->len);
704 /* string match failed */
706 PRINT_FCALL_ERROR("unknown error", req->rcall);
707 req->err = -ESERVERFAULT;
710 } else if (req->tcall && req->rcall->id != req->tcall->id + 1) {
711 P9_DPRINTK(P9_DEBUG_ERROR,
712 "fcall mismatch: expected %d, got %d\n",
713 req->tcall->id + 1, req->rcall->id);
720 * p9_read_work - called when there is some data to be read from a transport
721 * @work: container of work to be done
725 static void p9_read_work(struct work_struct *work)
729 struct p9_req *req, *rptr, *rreq;
730 struct p9_fcall *rcall;
733 m = container_of(work, struct p9_conn, rq);
739 P9_DPRINTK(P9_DEBUG_MUX, "start mux %p pos %d\n", m, m->rpos);
743 kmalloc(sizeof(struct p9_fcall) + m->msize, GFP_KERNEL);
749 m->rbuf = (char *)m->rcall + sizeof(struct p9_fcall);
753 clear_bit(Rpending, &m->wsched);
754 err = p9_fd_read(m->trans, m->rbuf + m->rpos, m->msize - m->rpos);
755 P9_DPRINTK(P9_DEBUG_MUX, "mux %p got %d bytes\n", m, err);
756 if (err == -EAGAIN) {
757 clear_bit(Rworksched, &m->wsched);
765 while (m->rpos > 4) {
766 n = le32_to_cpu(*(__le32 *) m->rbuf);
768 P9_DPRINTK(P9_DEBUG_ERROR,
769 "requested packet size too big: %d\n", n);
778 p9_deserialize_fcall(m->rbuf, n, m->rcall, m->extended);
782 #ifdef CONFIG_NET_9P_DEBUG
783 if ((p9_debug_level&P9_DEBUG_FCALL) == P9_DEBUG_FCALL) {
786 p9_printfcall(buf, sizeof(buf), m->rcall,
788 printk(KERN_NOTICE ">>> %p %s\n", m, buf);
795 m->rcall = kmalloc(sizeof(struct p9_fcall) + m->msize,
802 m->rbuf = (char *)m->rcall + sizeof(struct p9_fcall);
803 memmove(m->rbuf, rbuf + n, m->rpos - n);
811 P9_DPRINTK(P9_DEBUG_MUX, "mux %p fcall id %d tag %d\n", m,
812 rcall->id, rcall->tag);
816 list_for_each_entry_safe(rreq, rptr, &m->req_list, req_list) {
817 if (rreq->tag == rcall->tag) {
819 if (req->flush != Flushing)
820 list_del(&req->req_list);
824 spin_unlock(&m->lock);
828 process_request(m, req);
830 if (req->flush != Flushing) {
832 (*req->cb) (req, req->cba);
837 if (err >= 0 && rcall->id != P9_RFLUSH)
838 P9_DPRINTK(P9_DEBUG_ERROR,
839 "unexpected response mux %p id %d tag %d\n",
840 m, rcall->id, rcall->tag);
845 if (!list_empty(&m->req_list)) {
846 if (test_and_clear_bit(Rpending, &m->wsched))
849 n = p9_fd_poll(m->trans, NULL);
852 P9_DPRINTK(P9_DEBUG_MUX, "schedule read work %p\n", m);
853 queue_work(p9_mux_wq, &m->rq);
855 clear_bit(Rworksched, &m->wsched);
857 clear_bit(Rworksched, &m->wsched);
862 p9_conn_cancel(m, err);
863 clear_bit(Rworksched, &m->wsched);
867 * p9_send_request - send 9P request
868 * The function can sleep until the request is scheduled for sending.
869 * The function can be interrupted. Return from the function is not
870 * a guarantee that the request is sent successfully. Can return errors
871 * that can be retrieved by PTR_ERR macros.
874 * @tc: request to be sent
875 * @cb: callback function to call when response is received
876 * @cba: parameter to pass to the callback function
880 static struct p9_req *p9_send_request(struct p9_conn *m,
882 p9_conn_req_callback cb, void *cba)
887 P9_DPRINTK(P9_DEBUG_MUX, "mux %p task %p tcall %p id %d\n", m, current,
890 return ERR_PTR(m->err);
892 req = kmalloc(sizeof(struct p9_req), GFP_KERNEL);
894 return ERR_PTR(-ENOMEM);
896 if (tc->id == P9_TVERSION)
899 n = p9_mux_get_tag(m);
902 return ERR_PTR(-ENOMEM);
906 #ifdef CONFIG_NET_9P_DEBUG
907 if ((p9_debug_level&P9_DEBUG_FCALL) == P9_DEBUG_FCALL) {
910 p9_printfcall(buf, sizeof(buf), tc, m->extended);
911 printk(KERN_NOTICE "<<< %p %s\n", m, buf);
915 spin_lock_init(&req->lock);
925 list_add_tail(&req->req_list, &m->unsent_req_list);
926 spin_unlock(&m->lock);
928 if (test_and_clear_bit(Wpending, &m->wsched))
931 n = p9_fd_poll(m->trans, NULL);
933 if (n & POLLOUT && !test_and_set_bit(Wworksched, &m->wsched))
934 queue_work(p9_mux_wq, &m->wq);
939 static void p9_mux_free_request(struct p9_conn *m, struct p9_req *req)
941 p9_mux_put_tag(m, req->tag);
945 static void p9_mux_flush_cb(struct p9_req *freq, void *a)
949 struct p9_req *req, *rreq, *rptr;
952 P9_DPRINTK(P9_DEBUG_MUX, "mux %p tc %p rc %p err %d oldtag %d\n", m,
953 freq->tcall, freq->rcall, freq->err,
954 freq->tcall->params.tflush.oldtag);
957 tag = freq->tcall->params.tflush.oldtag;
959 list_for_each_entry_safe(rreq, rptr, &m->req_list, req_list) {
960 if (rreq->tag == tag) {
962 list_del(&req->req_list);
966 spin_unlock(&m->lock);
969 spin_lock(&req->lock);
970 req->flush = Flushed;
971 spin_unlock(&req->lock);
974 (*req->cb) (req, req->cba);
981 p9_mux_free_request(m, freq);
985 p9_mux_flush_request(struct p9_conn *m, struct p9_req *req)
988 struct p9_req *rreq, *rptr;
990 P9_DPRINTK(P9_DEBUG_MUX, "mux %p req %p tag %d\n", m, req, req->tag);
992 /* if a response was received for a request, do nothing */
993 spin_lock(&req->lock);
994 if (req->rcall || req->err) {
995 spin_unlock(&req->lock);
996 P9_DPRINTK(P9_DEBUG_MUX,
997 "mux %p req %p response already received\n", m, req);
1001 req->flush = Flushing;
1002 spin_unlock(&req->lock);
1004 spin_lock(&m->lock);
1005 /* if the request is not sent yet, just remove it from the list */
1006 list_for_each_entry_safe(rreq, rptr, &m->unsent_req_list, req_list) {
1007 if (rreq->tag == req->tag) {
1008 P9_DPRINTK(P9_DEBUG_MUX,
1009 "mux %p req %p request is not sent yet\n", m, req);
1010 list_del(&rreq->req_list);
1011 req->flush = Flushed;
1012 spin_unlock(&m->lock);
1014 (*req->cb) (req, req->cba);
1018 spin_unlock(&m->lock);
1020 clear_thread_flag(TIF_SIGPENDING);
1021 fc = p9_create_tflush(req->tag);
1022 p9_send_request(m, fc, p9_mux_flush_cb, m);
1027 p9_conn_rpc_cb(struct p9_req *req, void *a)
1029 struct p9_mux_rpc *r;
1031 P9_DPRINTK(P9_DEBUG_MUX, "req %p r %p\n", req, a);
1033 r->rcall = req->rcall;
1036 if (req->flush != None && !req->err)
1037 r->err = -ERESTARTSYS;
1039 wake_up(&r->wqueue);
1043 * p9_fd_rpc- sends 9P request and waits until a response is available.
1044 * The function can be interrupted.
1045 * @t: transport data
1046 * @tc: request to be sent
1047 * @rc: pointer where a pointer to the response is stored
1052 p9_fd_rpc(struct p9_trans *t, struct p9_fcall *tc, struct p9_fcall **rc)
1054 struct p9_trans_fd *p = t->priv;
1055 struct p9_conn *m = p->conn;
1056 int err, sigpending;
1057 unsigned long flags;
1059 struct p9_mux_rpc r;
1065 init_waitqueue_head(&r.wqueue);
1071 if (signal_pending(current)) {
1073 clear_thread_flag(TIF_SIGPENDING);
1076 req = p9_send_request(m, tc, p9_conn_rpc_cb, &r);
1079 P9_DPRINTK(P9_DEBUG_MUX, "error %d\n", err);
1083 err = wait_event_interruptible(r.wqueue, r.rcall != NULL || r.err < 0);
1087 if (err == -ERESTARTSYS && m->trans->status == Connected
1089 if (p9_mux_flush_request(m, req)) {
1090 /* wait until we get response of the flush message */
1092 clear_thread_flag(TIF_SIGPENDING);
1093 err = wait_event_interruptible(r.wqueue,
1095 } while (!r.rcall && !r.err && err == -ERESTARTSYS &&
1096 m->trans->status == Connected && !m->err);
1104 spin_lock_irqsave(¤t->sighand->siglock, flags);
1105 recalc_sigpending();
1106 spin_unlock_irqrestore(¤t->sighand->siglock, flags);
1114 p9_mux_free_request(m, req);
1123 * p9_conn_rpcnb - sends 9P request without waiting for response.
1125 * @tc: request to be sent
1126 * @cb: callback function to be called when response arrives
1127 * @a: value to pass to the callback function
1131 int p9_conn_rpcnb(struct p9_conn *m, struct p9_fcall *tc,
1132 p9_conn_req_callback cb, void *a)
1137 req = p9_send_request(m, tc, cb, a);
1140 P9_DPRINTK(P9_DEBUG_MUX, "error %d\n", err);
1141 return PTR_ERR(req);
1144 P9_DPRINTK(P9_DEBUG_MUX, "mux %p tc %p tag %d\n", m, tc, req->tag);
1147 #endif /* P9_NONBLOCK */
1150 * p9_conn_cancel - cancel all pending requests with error
1156 void p9_conn_cancel(struct p9_conn *m, int err)
1158 struct p9_req *req, *rtmp;
1159 LIST_HEAD(cancel_list);
1161 P9_DPRINTK(P9_DEBUG_ERROR, "mux %p err %d\n", m, err);
1163 spin_lock(&m->lock);
1164 list_for_each_entry_safe(req, rtmp, &m->req_list, req_list) {
1165 list_move(&req->req_list, &cancel_list);
1167 list_for_each_entry_safe(req, rtmp, &m->unsent_req_list, req_list) {
1168 list_move(&req->req_list, &cancel_list);
1170 spin_unlock(&m->lock);
1172 list_for_each_entry_safe(req, rtmp, &cancel_list, req_list) {
1173 list_del(&req->req_list);
1178 (*req->cb) (req, req->cba);
1185 * parse_options - parse mount options into session structure
1186 * @options: options string passed from mount
1187 * @opts: transport-specific structure to parse options into
1189 * Returns 0 upon success, -ERRNO upon failure
1192 static int parse_opts(char *params, struct p9_fd_opts *opts)
1195 substring_t args[MAX_OPT_ARGS];
1200 opts->port = P9_PORT;
1207 options = kstrdup(params, GFP_KERNEL);
1209 P9_DPRINTK(P9_DEBUG_ERROR,
1210 "failed to allocate copy of option string\n");
1214 while ((p = strsep(&options, ",")) != NULL) {
1219 token = match_token(p, tokens, args);
1220 r = match_int(&args[0], &option);
1222 P9_DPRINTK(P9_DEBUG_ERROR,
1223 "integer field, but no integer?\n");
1229 opts->port = option;
1245 static int p9_fd_open(struct p9_trans *trans, int rfd, int wfd)
1247 struct p9_trans_fd *ts = kmalloc(sizeof(struct p9_trans_fd),
1254 if (!ts->rd || !ts->wr) {
1264 trans->status = Connected;
1269 static int p9_socket_open(struct p9_trans *trans, struct socket *csocket)
1273 csocket->sk->sk_allocation = GFP_NOIO;
1274 fd = sock_map_fd(csocket, 0);
1276 P9_EPRINTK(KERN_ERR, "p9_socket_open: failed to map fd\n");
1280 ret = p9_fd_open(trans, fd, fd);
1282 P9_EPRINTK(KERN_ERR, "p9_socket_open: failed to open fd\n");
1283 sockfd_put(csocket);
1287 ((struct p9_trans_fd *)trans->priv)->rd->f_flags |= O_NONBLOCK;
1293 * p9_fd_read- read from a fd
1294 * @trans: transport instance state
1295 * @v: buffer to receive data into
1296 * @len: size of receive buffer
1300 static int p9_fd_read(struct p9_trans *trans, void *v, int len)
1303 struct p9_trans_fd *ts = NULL;
1305 if (trans && trans->status != Disconnected)
1311 if (!(ts->rd->f_flags & O_NONBLOCK))
1312 P9_DPRINTK(P9_DEBUG_ERROR, "blocking read ...\n");
1314 ret = kernel_read(ts->rd, ts->rd->f_pos, v, len);
1315 if (ret <= 0 && ret != -ERESTARTSYS && ret != -EAGAIN)
1316 trans->status = Disconnected;
1321 * p9_fd_write - write to a socket
1322 * @trans: transport instance state
1323 * @v: buffer to send data from
1324 * @len: size of send buffer
1328 static int p9_fd_write(struct p9_trans *trans, void *v, int len)
1332 struct p9_trans_fd *ts = NULL;
1334 if (trans && trans->status != Disconnected)
1340 if (!(ts->wr->f_flags & O_NONBLOCK))
1341 P9_DPRINTK(P9_DEBUG_ERROR, "blocking write ...\n");
1345 /* The cast to a user pointer is valid due to the set_fs() */
1346 ret = vfs_write(ts->wr, (void __user *)v, len, &ts->wr->f_pos);
1349 if (ret <= 0 && ret != -ERESTARTSYS && ret != -EAGAIN)
1350 trans->status = Disconnected;
1355 p9_fd_poll(struct p9_trans *trans, struct poll_table_struct *pt)
1358 struct p9_trans_fd *ts = NULL;
1361 if (trans && trans->status == Connected)
1367 if (!ts->rd->f_op || !ts->rd->f_op->poll)
1370 if (!ts->wr->f_op || !ts->wr->f_op->poll)
1376 ret = ts->rd->f_op->poll(ts->rd, pt);
1380 if (ts->rd != ts->wr) {
1381 n = ts->wr->f_op->poll(ts->wr, pt);
1386 ret = (ret & ~POLLOUT) | (n & ~POLLIN);
1395 * p9_fd_close - shutdown socket
1396 * @trans: private socket structure
1400 static void p9_fd_close(struct p9_trans *trans)
1402 struct p9_trans_fd *ts;
1407 ts = xchg(&trans->priv, NULL);
1412 p9_conn_destroy(ts->conn);
1414 trans->status = Disconnected;
1423 * stolen from NFS - maybe should be made a generic function?
1425 static inline int valid_ipaddr4(const char *buf)
1427 int rc, count, in[4];
1429 rc = sscanf(buf, "%d.%d.%d.%d", &in[0], &in[1], &in[2], &in[3]);
1432 for (count = 0; count < 4; count++) {
1433 if (in[count] > 255)
1439 static struct p9_trans *
1440 p9_trans_create_tcp(const char *addr, char *args, int msize, unsigned char dotu)
1443 struct p9_trans *trans;
1444 struct socket *csocket;
1445 struct sockaddr_in sin_server;
1446 struct p9_fd_opts opts;
1447 struct p9_trans_fd *p;
1449 err = parse_opts(args, &opts);
1451 return ERR_PTR(err);
1453 if (valid_ipaddr4(addr) < 0)
1454 return ERR_PTR(-EINVAL);
1457 trans = kmalloc(sizeof(struct p9_trans), GFP_KERNEL);
1459 return ERR_PTR(-ENOMEM);
1460 trans->msize = msize;
1461 trans->extended = dotu;
1462 trans->rpc = p9_fd_rpc;
1463 trans->close = p9_fd_close;
1465 sin_server.sin_family = AF_INET;
1466 sin_server.sin_addr.s_addr = in_aton(addr);
1467 sin_server.sin_port = htons(opts.port);
1468 sock_create_kern(PF_INET, SOCK_STREAM, IPPROTO_TCP, &csocket);
1471 P9_EPRINTK(KERN_ERR, "p9_trans_tcp: problem creating socket\n");
1476 err = csocket->ops->connect(csocket,
1477 (struct sockaddr *)&sin_server,
1478 sizeof(struct sockaddr_in), 0);
1480 P9_EPRINTK(KERN_ERR,
1481 "p9_trans_tcp: problem connecting socket to %s\n",
1486 err = p9_socket_open(trans, csocket);
1490 p = (struct p9_trans_fd *) trans->priv;
1491 p->conn = p9_conn_create(trans);
1492 if (IS_ERR(p->conn)) {
1493 err = PTR_ERR(p->conn);
1502 sock_release(csocket);
1505 return ERR_PTR(err);
1508 static struct p9_trans *
1509 p9_trans_create_unix(const char *addr, char *args, int msize,
1513 struct socket *csocket;
1514 struct sockaddr_un sun_server;
1515 struct p9_trans *trans;
1516 struct p9_trans_fd *p;
1519 trans = kmalloc(sizeof(struct p9_trans), GFP_KERNEL);
1521 return ERR_PTR(-ENOMEM);
1523 trans->rpc = p9_fd_rpc;
1524 trans->close = p9_fd_close;
1526 if (strlen(addr) > UNIX_PATH_MAX) {
1527 P9_EPRINTK(KERN_ERR, "p9_trans_unix: address too long: %s\n",
1529 err = -ENAMETOOLONG;
1533 sun_server.sun_family = PF_UNIX;
1534 strcpy(sun_server.sun_path, addr);
1535 sock_create_kern(PF_UNIX, SOCK_STREAM, 0, &csocket);
1536 err = csocket->ops->connect(csocket, (struct sockaddr *)&sun_server,
1537 sizeof(struct sockaddr_un) - 1, 0);
1539 P9_EPRINTK(KERN_ERR,
1540 "p9_trans_unix: problem connecting socket: %s: %d\n",
1545 err = p9_socket_open(trans, csocket);
1549 trans->msize = msize;
1550 trans->extended = dotu;
1551 p = (struct p9_trans_fd *) trans->priv;
1552 p->conn = p9_conn_create(trans);
1553 if (IS_ERR(p->conn)) {
1554 err = PTR_ERR(p->conn);
1563 sock_release(csocket);
1566 return ERR_PTR(err);
1569 static struct p9_trans *
1570 p9_trans_create_fd(const char *name, char *args, int msize,
1571 unsigned char extended)
1574 struct p9_trans *trans;
1575 struct p9_fd_opts opts;
1576 struct p9_trans_fd *p;
1578 parse_opts(args, &opts);
1580 if (opts.rfd == ~0 || opts.wfd == ~0) {
1581 printk(KERN_ERR "v9fs: Insufficient options for proto=fd\n");
1582 return ERR_PTR(-ENOPROTOOPT);
1585 trans = kmalloc(sizeof(struct p9_trans), GFP_KERNEL);
1587 return ERR_PTR(-ENOMEM);
1589 trans->rpc = p9_fd_rpc;
1590 trans->close = p9_fd_close;
1592 err = p9_fd_open(trans, opts.rfd, opts.wfd);
1596 trans->msize = msize;
1597 trans->extended = extended;
1598 p = (struct p9_trans_fd *) trans->priv;
1599 p->conn = p9_conn_create(trans);
1600 if (IS_ERR(p->conn)) {
1601 err = PTR_ERR(p->conn);
1610 return ERR_PTR(err);
1613 static struct p9_trans_module p9_tcp_trans = {
1615 .maxsize = MAX_SOCK_BUF,
1617 .create = p9_trans_create_tcp,
1618 .owner = THIS_MODULE,
1621 static struct p9_trans_module p9_unix_trans = {
1623 .maxsize = MAX_SOCK_BUF,
1625 .create = p9_trans_create_unix,
1626 .owner = THIS_MODULE,
1629 static struct p9_trans_module p9_fd_trans = {
1631 .maxsize = MAX_SOCK_BUF,
1633 .create = p9_trans_create_fd,
1634 .owner = THIS_MODULE,
1637 int p9_trans_fd_init(void)
1639 int ret = p9_mux_global_init();
1641 printk(KERN_WARNING "9p: starting mux failed\n");
1645 v9fs_register_trans(&p9_tcp_trans);
1646 v9fs_register_trans(&p9_unix_trans);
1647 v9fs_register_trans(&p9_fd_trans);
1652 void p9_trans_fd_exit(void)
1654 v9fs_unregister_trans(&p9_tcp_trans);
1655 v9fs_unregister_trans(&p9_unix_trans);
1656 v9fs_unregister_trans(&p9_fd_trans);