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/client.h>
43 #include <net/9p/transport.h>
46 #define MAX_SOCK_BUF (64*1024)
47 #define MAXPOLLWADDR 2
50 * struct p9_fd_opts - per-transport options
51 * @rfd: file descriptor for reading (trans=fd)
52 * @wfd: file descriptor for writing (trans=fd)
53 * @port: port to connect to (trans=tcp)
64 * struct p9_trans_fd - transport state
65 * @rd: reference to file to read from
66 * @wr: reference of file to write to
67 * @conn: connection state reference
78 * Option Parsing (code inspired by NFS code)
79 * - a little lazy - parse all fd-transport options
83 /* Options that take integer arguments */
84 Opt_port
, Opt_rfdno
, Opt_wfdno
, Opt_err
,
87 static const match_table_t tokens
= {
88 {Opt_port
, "port=%u"},
89 {Opt_rfdno
, "rfdno=%u"},
90 {Opt_wfdno
, "wfdno=%u"},
95 Rworksched
= 1, /* read work scheduled or running */
96 Rpending
= 2, /* can read */
97 Wworksched
= 4, /* write work scheduled or running */
98 Wpending
= 8, /* can write */
101 struct p9_poll_wait
{
102 struct p9_conn
*conn
;
104 wait_queue_head_t
*wait_addr
;
108 * struct p9_conn - fd mux connection state information
109 * @mux_list: list link for mux to manage multiple connections (?)
110 * @client: reference to client instance for this connection
112 * @req_list: accounting for requests which have been sent
113 * @unsent_req_list: accounting for requests that haven't been sent
114 * @req: current request being processed (if any)
115 * @tmp_buf: temporary buffer to read in header
116 * @rsize: amount to read for current frame
117 * @rpos: read position in current frame
118 * @rbuf: current read buffer
119 * @wpos: write position for current frame
120 * @wsize: amount of data to write for current frame
121 * @wbuf: current write buffer
122 * @poll_wait: array of wait_q's for various worker threads
125 * @rq: current read work
126 * @wq: current write work
132 struct list_head mux_list
;
133 struct p9_client
*client
;
135 struct list_head req_list
;
136 struct list_head unsent_req_list
;
137 struct p9_req_t
*req
;
145 struct list_head poll_pending_link
;
146 struct p9_poll_wait poll_wait
[MAXPOLLWADDR
];
148 struct work_struct rq
;
149 struct work_struct wq
;
150 unsigned long wsched
;
153 static DEFINE_SPINLOCK(p9_poll_lock
);
154 static LIST_HEAD(p9_poll_pending_list
);
155 static struct workqueue_struct
*p9_mux_wq
;
156 static struct task_struct
*p9_poll_task
;
158 static void p9_mux_poll_stop(struct p9_conn
*m
)
163 for (i
= 0; i
< ARRAY_SIZE(m
->poll_wait
); i
++) {
164 struct p9_poll_wait
*pwait
= &m
->poll_wait
[i
];
166 if (pwait
->wait_addr
) {
167 remove_wait_queue(pwait
->wait_addr
, &pwait
->wait
);
168 pwait
->wait_addr
= NULL
;
172 spin_lock_irqsave(&p9_poll_lock
, flags
);
173 list_del_init(&m
->poll_pending_link
);
174 spin_unlock_irqrestore(&p9_poll_lock
, flags
);
178 * p9_conn_cancel - cancel all pending requests with error
184 void p9_conn_cancel(struct p9_conn
*m
, int err
)
186 struct p9_req_t
*req
, *rtmp
;
188 LIST_HEAD(cancel_list
);
190 P9_DPRINTK(P9_DEBUG_ERROR
, "mux %p err %d\n", m
, err
);
192 spin_lock_irqsave(&m
->client
->lock
, flags
);
193 list_for_each_entry_safe(req
, rtmp
, &m
->req_list
, req_list
) {
194 req
->status
= REQ_STATUS_ERROR
;
197 list_move(&req
->req_list
, &cancel_list
);
199 list_for_each_entry_safe(req
, rtmp
, &m
->unsent_req_list
, req_list
) {
200 req
->status
= REQ_STATUS_ERROR
;
203 list_move(&req
->req_list
, &cancel_list
);
205 spin_unlock_irqrestore(&m
->client
->lock
, flags
);
207 list_for_each_entry_safe(req
, rtmp
, &cancel_list
, req_list
) {
208 list_del(&req
->req_list
);
209 P9_DPRINTK(P9_DEBUG_ERROR
, "call back req %p\n", req
);
210 p9_client_cb(m
->client
, req
);
215 p9_fd_poll(struct p9_client
*client
, struct poll_table_struct
*pt
)
218 struct p9_trans_fd
*ts
= NULL
;
220 if (client
&& client
->status
== Connected
)
226 if (!ts
->rd
->f_op
|| !ts
->rd
->f_op
->poll
)
229 if (!ts
->wr
->f_op
|| !ts
->wr
->f_op
->poll
)
232 ret
= ts
->rd
->f_op
->poll(ts
->rd
, pt
);
236 if (ts
->rd
!= ts
->wr
) {
237 n
= ts
->wr
->f_op
->poll(ts
->wr
, pt
);
240 ret
= (ret
& ~POLLOUT
) | (n
& ~POLLIN
);
247 * p9_fd_read- read from a fd
248 * @client: client instance
249 * @v: buffer to receive data into
250 * @len: size of receive buffer
254 static int p9_fd_read(struct p9_client
*client
, void *v
, int len
)
257 struct p9_trans_fd
*ts
= NULL
;
259 if (client
&& client
->status
!= Disconnected
)
265 if (!(ts
->rd
->f_flags
& O_NONBLOCK
))
266 P9_DPRINTK(P9_DEBUG_ERROR
, "blocking read ...\n");
268 ret
= kernel_read(ts
->rd
, ts
->rd
->f_pos
, v
, len
);
269 if (ret
<= 0 && ret
!= -ERESTARTSYS
&& ret
!= -EAGAIN
)
270 client
->status
= Disconnected
;
275 * p9_read_work - called when there is some data to be read from a transport
276 * @work: container of work to be done
280 static void p9_read_work(struct work_struct
*work
)
285 m
= container_of(work
, struct p9_conn
, rq
);
290 P9_DPRINTK(P9_DEBUG_MUX
, "start mux %p pos %d\n", m
, m
->rpos
);
293 m
->rbuf
= m
->tmp_buf
;
295 m
->rsize
= 7; /* start by reading header */
298 clear_bit(Rpending
, &m
->wsched
);
299 P9_DPRINTK(P9_DEBUG_MUX
, "read mux %p pos %d size: %d = %d\n", m
,
300 m
->rpos
, m
->rsize
, m
->rsize
-m
->rpos
);
301 err
= p9_fd_read(m
->client
, m
->rbuf
+ m
->rpos
,
303 P9_DPRINTK(P9_DEBUG_MUX
, "mux %p got %d bytes\n", m
, err
);
304 if (err
== -EAGAIN
) {
305 clear_bit(Rworksched
, &m
->wsched
);
314 if ((!m
->req
) && (m
->rpos
== m
->rsize
)) { /* header read in */
316 P9_DPRINTK(P9_DEBUG_MUX
, "got new header\n");
318 n
= le32_to_cpu(*(__le32
*) m
->rbuf
); /* read packet size */
319 if (n
>= m
->client
->msize
) {
320 P9_DPRINTK(P9_DEBUG_ERROR
,
321 "requested packet size too big: %d\n", n
);
326 tag
= le16_to_cpu(*(__le16
*) (m
->rbuf
+5)); /* read tag */
327 P9_DPRINTK(P9_DEBUG_MUX
, "mux %p pkt: size: %d bytes tag: %d\n",
330 m
->req
= p9_tag_lookup(m
->client
, tag
);
332 P9_DPRINTK(P9_DEBUG_ERROR
, "Unexpected packet tag %d\n",
338 if (m
->req
->rc
== NULL
) {
339 m
->req
->rc
= kmalloc(sizeof(struct p9_fcall
) +
340 m
->client
->msize
, GFP_KERNEL
);
347 m
->rbuf
= (char *)m
->req
->rc
+ sizeof(struct p9_fcall
);
348 memcpy(m
->rbuf
, m
->tmp_buf
, m
->rsize
);
352 /* not an else because some packets (like clunk) have no payload */
353 if ((m
->req
) && (m
->rpos
== m
->rsize
)) { /* packet is read in */
354 P9_DPRINTK(P9_DEBUG_MUX
, "got new packet\n");
356 list_del(&m
->req
->req_list
);
357 p9_client_cb(m
->client
, m
->req
);
365 if (!list_empty(&m
->req_list
)) {
366 if (test_and_clear_bit(Rpending
, &m
->wsched
))
369 n
= p9_fd_poll(m
->client
, NULL
);
372 P9_DPRINTK(P9_DEBUG_MUX
, "schedule read work %p\n", m
);
373 queue_work(p9_mux_wq
, &m
->rq
);
375 clear_bit(Rworksched
, &m
->wsched
);
377 clear_bit(Rworksched
, &m
->wsched
);
381 p9_conn_cancel(m
, err
);
382 clear_bit(Rworksched
, &m
->wsched
);
386 * p9_fd_write - write to a socket
387 * @client: client instance
388 * @v: buffer to send data from
389 * @len: size of send buffer
393 static int p9_fd_write(struct p9_client
*client
, void *v
, int len
)
397 struct p9_trans_fd
*ts
= NULL
;
399 if (client
&& client
->status
!= Disconnected
)
405 if (!(ts
->wr
->f_flags
& O_NONBLOCK
))
406 P9_DPRINTK(P9_DEBUG_ERROR
, "blocking write ...\n");
410 /* The cast to a user pointer is valid due to the set_fs() */
411 ret
= vfs_write(ts
->wr
, (void __user
*)v
, len
, &ts
->wr
->f_pos
);
414 if (ret
<= 0 && ret
!= -ERESTARTSYS
&& ret
!= -EAGAIN
)
415 client
->status
= Disconnected
;
420 * p9_write_work - called when a transport can send some data
421 * @work: container for work to be done
425 static void p9_write_work(struct work_struct
*work
)
429 struct p9_req_t
*req
;
431 m
= container_of(work
, struct p9_conn
, wq
);
434 clear_bit(Wworksched
, &m
->wsched
);
439 if (list_empty(&m
->unsent_req_list
)) {
440 clear_bit(Wworksched
, &m
->wsched
);
444 spin_lock(&m
->client
->lock
);
445 req
= list_entry(m
->unsent_req_list
.next
, struct p9_req_t
,
447 req
->status
= REQ_STATUS_SENT
;
448 list_move_tail(&req
->req_list
, &m
->req_list
);
450 m
->wbuf
= req
->tc
->sdata
;
451 m
->wsize
= req
->tc
->size
;
453 spin_unlock(&m
->client
->lock
);
456 P9_DPRINTK(P9_DEBUG_MUX
, "mux %p pos %d size %d\n", m
, m
->wpos
,
458 clear_bit(Wpending
, &m
->wsched
);
459 err
= p9_fd_write(m
->client
, m
->wbuf
+ m
->wpos
, m
->wsize
- m
->wpos
);
460 P9_DPRINTK(P9_DEBUG_MUX
, "mux %p sent %d bytes\n", m
, err
);
461 if (err
== -EAGAIN
) {
462 clear_bit(Wworksched
, &m
->wsched
);
474 if (m
->wpos
== m
->wsize
)
475 m
->wpos
= m
->wsize
= 0;
477 if (m
->wsize
== 0 && !list_empty(&m
->unsent_req_list
)) {
478 if (test_and_clear_bit(Wpending
, &m
->wsched
))
481 n
= p9_fd_poll(m
->client
, NULL
);
484 P9_DPRINTK(P9_DEBUG_MUX
, "schedule write work %p\n", m
);
485 queue_work(p9_mux_wq
, &m
->wq
);
487 clear_bit(Wworksched
, &m
->wsched
);
489 clear_bit(Wworksched
, &m
->wsched
);
494 p9_conn_cancel(m
, err
);
495 clear_bit(Wworksched
, &m
->wsched
);
498 static int p9_pollwake(wait_queue_t
*wait
, unsigned mode
, int sync
, void *key
)
500 struct p9_poll_wait
*pwait
=
501 container_of(wait
, struct p9_poll_wait
, wait
);
502 struct p9_conn
*m
= pwait
->conn
;
504 DECLARE_WAITQUEUE(dummy_wait
, p9_poll_task
);
506 spin_lock_irqsave(&p9_poll_lock
, flags
);
507 if (list_empty(&m
->poll_pending_link
))
508 list_add_tail(&m
->poll_pending_link
, &p9_poll_pending_list
);
509 spin_unlock_irqrestore(&p9_poll_lock
, flags
);
511 /* perform the default wake up operation */
512 return default_wake_function(&dummy_wait
, mode
, sync
, key
);
516 * p9_pollwait - add poll task to the wait queue
517 * @filp: file pointer being polled
518 * @wait_address: wait_q to block on
521 * called by files poll operation to add v9fs-poll task to files wait queue
525 p9_pollwait(struct file
*filp
, wait_queue_head_t
*wait_address
, poll_table
*p
)
527 struct p9_conn
*m
= container_of(p
, struct p9_conn
, pt
);
528 struct p9_poll_wait
*pwait
= NULL
;
531 for (i
= 0; i
< ARRAY_SIZE(m
->poll_wait
); i
++) {
532 if (m
->poll_wait
[i
].wait_addr
== NULL
) {
533 pwait
= &m
->poll_wait
[i
];
539 P9_DPRINTK(P9_DEBUG_ERROR
, "not enough wait_address slots\n");
544 P9_DPRINTK(P9_DEBUG_ERROR
, "no wait_address\n");
545 pwait
->wait_addr
= ERR_PTR(-EIO
);
550 pwait
->wait_addr
= wait_address
;
551 init_waitqueue_func_entry(&pwait
->wait
, p9_pollwake
);
552 add_wait_queue(wait_address
, &pwait
->wait
);
556 * p9_conn_create - allocate and initialize the per-session mux data
557 * @client: client instance
559 * Note: Creates the polling task if this is the first session.
562 static struct p9_conn
*p9_conn_create(struct p9_client
*client
)
567 P9_DPRINTK(P9_DEBUG_MUX
, "client %p msize %d\n", client
, client
->msize
);
568 m
= kzalloc(sizeof(struct p9_conn
), GFP_KERNEL
);
570 return ERR_PTR(-ENOMEM
);
572 INIT_LIST_HEAD(&m
->mux_list
);
575 INIT_LIST_HEAD(&m
->req_list
);
576 INIT_LIST_HEAD(&m
->unsent_req_list
);
577 INIT_WORK(&m
->rq
, p9_read_work
);
578 INIT_WORK(&m
->wq
, p9_write_work
);
579 INIT_LIST_HEAD(&m
->poll_pending_link
);
580 init_poll_funcptr(&m
->pt
, p9_pollwait
);
582 n
= p9_fd_poll(client
, &m
->pt
);
584 P9_DPRINTK(P9_DEBUG_MUX
, "mux %p can read\n", m
);
585 set_bit(Rpending
, &m
->wsched
);
589 P9_DPRINTK(P9_DEBUG_MUX
, "mux %p can write\n", m
);
590 set_bit(Wpending
, &m
->wsched
);
593 for (i
= 0; i
< ARRAY_SIZE(m
->poll_wait
); i
++) {
594 if (IS_ERR(m
->poll_wait
[i
].wait_addr
)) {
597 /* return the error code */
598 return (void *)m
->poll_wait
[i
].wait_addr
;
606 * p9_poll_mux - polls a mux and schedules read or write works if necessary
607 * @m: connection to poll
611 static void p9_poll_mux(struct p9_conn
*m
)
618 n
= p9_fd_poll(m
->client
, NULL
);
619 if (n
< 0 || n
& (POLLERR
| POLLHUP
| POLLNVAL
)) {
620 P9_DPRINTK(P9_DEBUG_MUX
, "error mux %p err %d\n", m
, n
);
623 p9_conn_cancel(m
, n
);
627 set_bit(Rpending
, &m
->wsched
);
628 P9_DPRINTK(P9_DEBUG_MUX
, "mux %p can read\n", m
);
629 if (!test_and_set_bit(Rworksched
, &m
->wsched
)) {
630 P9_DPRINTK(P9_DEBUG_MUX
, "schedule read work %p\n", m
);
631 queue_work(p9_mux_wq
, &m
->rq
);
636 set_bit(Wpending
, &m
->wsched
);
637 P9_DPRINTK(P9_DEBUG_MUX
, "mux %p can write\n", m
);
638 if ((m
->wsize
|| !list_empty(&m
->unsent_req_list
))
639 && !test_and_set_bit(Wworksched
, &m
->wsched
)) {
640 P9_DPRINTK(P9_DEBUG_MUX
, "schedule write work %p\n", m
);
641 queue_work(p9_mux_wq
, &m
->wq
);
647 * p9_fd_request - send 9P request
648 * The function can sleep until the request is scheduled for sending.
649 * The function can be interrupted. Return from the function is not
650 * a guarantee that the request is sent successfully.
652 * @client: client instance
653 * @req: request to be sent
657 static int p9_fd_request(struct p9_client
*client
, struct p9_req_t
*req
)
660 struct p9_trans_fd
*ts
= client
->trans
;
661 struct p9_conn
*m
= ts
->conn
;
663 P9_DPRINTK(P9_DEBUG_MUX
, "mux %p task %p tcall %p id %d\n", m
, current
,
664 req
->tc
, req
->tc
->id
);
668 #ifdef CONFIG_NET_9P_DEBUG
669 if ((p9_debug_level
&P9_DEBUG_FCALL
) == P9_DEBUG_FCALL
) {
672 p9_printfcall(buf
, sizeof(buf
), req
->tc
, client
->dotu
);
673 printk(KERN_NOTICE
"<<< %p %s\n", m
, buf
);
677 req
->status
= REQ_STATUS_UNSENT
;
679 spin_lock(&client
->lock
);
680 list_add_tail(&req
->req_list
, &m
->unsent_req_list
);
681 spin_unlock(&client
->lock
);
683 if (test_and_clear_bit(Wpending
, &m
->wsched
))
686 n
= p9_fd_poll(m
->client
, NULL
);
688 if (n
& POLLOUT
&& !test_and_set_bit(Wworksched
, &m
->wsched
))
689 queue_work(p9_mux_wq
, &m
->wq
);
694 static int p9_fd_cancel(struct p9_client
*client
, struct p9_req_t
*req
)
696 struct p9_trans_fd
*ts
= client
->trans
;
697 struct p9_conn
*m
= ts
->conn
;
699 P9_DPRINTK(P9_DEBUG_MUX
, "mux %p req %p tag %d\n", m
, req
, req
->tag
);
701 spin_lock(&client
->lock
);
702 list_del(&req
->req_list
);
703 spin_unlock(&client
->lock
);
705 /* if a response was received for a request, do nothing */
706 if (req
->rc
|| req
->t_err
) {
707 P9_DPRINTK(P9_DEBUG_MUX
,
708 "mux %p req %p response already received\n", m
, req
);
712 if (req
->status
== REQ_STATUS_UNSENT
) {
713 req
->status
= REQ_STATUS_FLSHD
;
721 * parse_options - parse mount options into session structure
722 * @options: options string passed from mount
723 * @opts: transport-specific structure to parse options into
725 * Returns 0 upon success, -ERRNO upon failure
728 static int parse_opts(char *params
, struct p9_fd_opts
*opts
)
731 substring_t args
[MAX_OPT_ARGS
];
736 opts
->port
= P9_PORT
;
743 options
= kstrdup(params
, GFP_KERNEL
);
745 P9_DPRINTK(P9_DEBUG_ERROR
,
746 "failed to allocate copy of option string\n");
750 while ((p
= strsep(&options
, ",")) != NULL
) {
755 token
= match_token(p
, tokens
, args
);
756 r
= match_int(&args
[0], &option
);
758 P9_DPRINTK(P9_DEBUG_ERROR
,
759 "integer field, but no integer?\n");
781 static int p9_fd_open(struct p9_client
*client
, int rfd
, int wfd
)
783 struct p9_trans_fd
*ts
= kmalloc(sizeof(struct p9_trans_fd
),
790 if (!ts
->rd
|| !ts
->wr
) {
800 client
->status
= Connected
;
805 static int p9_socket_open(struct p9_client
*client
, struct socket
*csocket
)
809 csocket
->sk
->sk_allocation
= GFP_NOIO
;
810 fd
= sock_map_fd(csocket
, 0);
812 P9_EPRINTK(KERN_ERR
, "p9_socket_open: failed to map fd\n");
816 ret
= p9_fd_open(client
, fd
, fd
);
818 P9_EPRINTK(KERN_ERR
, "p9_socket_open: failed to open fd\n");
823 ((struct p9_trans_fd
*)client
->trans
)->rd
->f_flags
|= O_NONBLOCK
;
829 * p9_mux_destroy - cancels all pending requests and frees mux resources
834 static void p9_conn_destroy(struct p9_conn
*m
)
836 P9_DPRINTK(P9_DEBUG_MUX
, "mux %p prev %p next %p\n", m
,
837 m
->mux_list
.prev
, m
->mux_list
.next
);
840 cancel_work_sync(&m
->rq
);
841 cancel_work_sync(&m
->wq
);
843 p9_conn_cancel(m
, -ECONNRESET
);
850 * p9_fd_close - shutdown file descriptor transport
851 * @client: client instance
855 static void p9_fd_close(struct p9_client
*client
)
857 struct p9_trans_fd
*ts
;
866 client
->status
= Disconnected
;
868 p9_conn_destroy(ts
->conn
);
879 * stolen from NFS - maybe should be made a generic function?
881 static inline int valid_ipaddr4(const char *buf
)
883 int rc
, count
, in
[4];
885 rc
= sscanf(buf
, "%d.%d.%d.%d", &in
[0], &in
[1], &in
[2], &in
[3]);
888 for (count
= 0; count
< 4; count
++) {
896 p9_fd_create_tcp(struct p9_client
*client
, const char *addr
, char *args
)
899 struct socket
*csocket
;
900 struct sockaddr_in sin_server
;
901 struct p9_fd_opts opts
;
902 struct p9_trans_fd
*p
= NULL
; /* this gets allocated in p9_fd_open */
904 err
= parse_opts(args
, &opts
);
908 if (valid_ipaddr4(addr
) < 0)
913 sin_server
.sin_family
= AF_INET
;
914 sin_server
.sin_addr
.s_addr
= in_aton(addr
);
915 sin_server
.sin_port
= htons(opts
.port
);
916 sock_create_kern(PF_INET
, SOCK_STREAM
, IPPROTO_TCP
, &csocket
);
919 P9_EPRINTK(KERN_ERR
, "p9_trans_tcp: problem creating socket\n");
924 err
= csocket
->ops
->connect(csocket
,
925 (struct sockaddr
*)&sin_server
,
926 sizeof(struct sockaddr_in
), 0);
929 "p9_trans_tcp: problem connecting socket to %s\n",
934 err
= p9_socket_open(client
, csocket
);
938 p
= (struct p9_trans_fd
*) client
->trans
;
939 p
->conn
= p9_conn_create(client
);
940 if (IS_ERR(p
->conn
)) {
941 err
= PTR_ERR(p
->conn
);
950 sock_release(csocket
);
958 p9_fd_create_unix(struct p9_client
*client
, const char *addr
, char *args
)
961 struct socket
*csocket
;
962 struct sockaddr_un sun_server
;
963 struct p9_trans_fd
*p
= NULL
; /* this gets allocated in p9_fd_open */
967 if (strlen(addr
) > UNIX_PATH_MAX
) {
968 P9_EPRINTK(KERN_ERR
, "p9_trans_unix: address too long: %s\n",
974 sun_server
.sun_family
= PF_UNIX
;
975 strcpy(sun_server
.sun_path
, addr
);
976 sock_create_kern(PF_UNIX
, SOCK_STREAM
, 0, &csocket
);
977 err
= csocket
->ops
->connect(csocket
, (struct sockaddr
*)&sun_server
,
978 sizeof(struct sockaddr_un
) - 1, 0);
981 "p9_trans_unix: problem connecting socket: %s: %d\n",
986 err
= p9_socket_open(client
, csocket
);
990 p
= (struct p9_trans_fd
*) client
->trans
;
991 p
->conn
= p9_conn_create(client
);
992 if (IS_ERR(p
->conn
)) {
993 err
= PTR_ERR(p
->conn
);
1002 sock_release(csocket
);
1009 p9_fd_create(struct p9_client
*client
, const char *addr
, char *args
)
1012 struct p9_fd_opts opts
;
1013 struct p9_trans_fd
*p
= NULL
; /* this get allocated in p9_fd_open */
1015 parse_opts(args
, &opts
);
1017 if (opts
.rfd
== ~0 || opts
.wfd
== ~0) {
1018 printk(KERN_ERR
"v9fs: Insufficient options for proto=fd\n");
1019 return -ENOPROTOOPT
;
1022 err
= p9_fd_open(client
, opts
.rfd
, opts
.wfd
);
1026 p
= (struct p9_trans_fd
*) client
->trans
;
1027 p
->conn
= p9_conn_create(client
);
1028 if (IS_ERR(p
->conn
)) {
1029 err
= PTR_ERR(p
->conn
);
1041 static struct p9_trans_module p9_tcp_trans
= {
1043 .maxsize
= MAX_SOCK_BUF
,
1045 .create
= p9_fd_create_tcp
,
1046 .close
= p9_fd_close
,
1047 .request
= p9_fd_request
,
1048 .cancel
= p9_fd_cancel
,
1049 .owner
= THIS_MODULE
,
1052 static struct p9_trans_module p9_unix_trans
= {
1054 .maxsize
= MAX_SOCK_BUF
,
1056 .create
= p9_fd_create_unix
,
1057 .close
= p9_fd_close
,
1058 .request
= p9_fd_request
,
1059 .cancel
= p9_fd_cancel
,
1060 .owner
= THIS_MODULE
,
1063 static struct p9_trans_module p9_fd_trans
= {
1065 .maxsize
= MAX_SOCK_BUF
,
1067 .create
= p9_fd_create
,
1068 .close
= p9_fd_close
,
1069 .request
= p9_fd_request
,
1070 .cancel
= p9_fd_cancel
,
1071 .owner
= THIS_MODULE
,
1075 * p9_poll_proc - poll worker thread
1076 * @a: thread state and arguments
1078 * polls all v9fs transports for new events and queues the appropriate
1079 * work to the work queue
1083 static int p9_poll_proc(void *a
)
1085 unsigned long flags
;
1087 P9_DPRINTK(P9_DEBUG_MUX
, "start %p\n", current
);
1089 spin_lock_irqsave(&p9_poll_lock
, flags
);
1090 while (!list_empty(&p9_poll_pending_list
)) {
1091 struct p9_conn
*conn
= list_first_entry(&p9_poll_pending_list
,
1094 list_del_init(&conn
->poll_pending_link
);
1095 spin_unlock_irqrestore(&p9_poll_lock
, flags
);
1099 spin_lock_irqsave(&p9_poll_lock
, flags
);
1101 spin_unlock_irqrestore(&p9_poll_lock
, flags
);
1103 set_current_state(TASK_INTERRUPTIBLE
);
1104 if (list_empty(&p9_poll_pending_list
)) {
1105 P9_DPRINTK(P9_DEBUG_MUX
, "sleeping...\n");
1108 __set_current_state(TASK_RUNNING
);
1110 if (!kthread_should_stop())
1113 P9_DPRINTK(P9_DEBUG_MUX
, "finish\n");
1117 int p9_trans_fd_init(void)
1119 p9_mux_wq
= create_workqueue("v9fs");
1121 printk(KERN_WARNING
"v9fs: mux: creating workqueue failed\n");
1125 p9_poll_task
= kthread_run(p9_poll_proc
, NULL
, "v9fs-poll");
1126 if (IS_ERR(p9_poll_task
)) {
1127 destroy_workqueue(p9_mux_wq
);
1128 printk(KERN_WARNING
"v9fs: mux: creating poll task failed\n");
1129 return PTR_ERR(p9_poll_task
);
1132 v9fs_register_trans(&p9_tcp_trans
);
1133 v9fs_register_trans(&p9_unix_trans
);
1134 v9fs_register_trans(&p9_fd_trans
);
1139 void p9_trans_fd_exit(void)
1141 kthread_stop(p9_poll_task
);
1142 v9fs_unregister_trans(&p9_tcp_trans
);
1143 v9fs_unregister_trans(&p9_unix_trans
);
1144 v9fs_unregister_trans(&p9_fd_trans
);
1146 destroy_workqueue(p9_mux_wq
);