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 pwait
->wait_addr
= wait_address
;
545 init_waitqueue_func_entry(&pwait
->wait
, p9_pollwake
);
546 add_wait_queue(wait_address
, &pwait
->wait
);
550 * p9_conn_create - allocate and initialize the per-session mux data
551 * @client: client instance
553 * Note: Creates the polling task if this is the first session.
556 static struct p9_conn
*p9_conn_create(struct p9_client
*client
)
561 P9_DPRINTK(P9_DEBUG_MUX
, "client %p msize %d\n", client
, client
->msize
);
562 m
= kzalloc(sizeof(struct p9_conn
), GFP_KERNEL
);
564 return ERR_PTR(-ENOMEM
);
566 INIT_LIST_HEAD(&m
->mux_list
);
569 INIT_LIST_HEAD(&m
->req_list
);
570 INIT_LIST_HEAD(&m
->unsent_req_list
);
571 INIT_WORK(&m
->rq
, p9_read_work
);
572 INIT_WORK(&m
->wq
, p9_write_work
);
573 INIT_LIST_HEAD(&m
->poll_pending_link
);
574 init_poll_funcptr(&m
->pt
, p9_pollwait
);
576 n
= p9_fd_poll(client
, &m
->pt
);
578 P9_DPRINTK(P9_DEBUG_MUX
, "mux %p can read\n", m
);
579 set_bit(Rpending
, &m
->wsched
);
583 P9_DPRINTK(P9_DEBUG_MUX
, "mux %p can write\n", m
);
584 set_bit(Wpending
, &m
->wsched
);
591 * p9_poll_mux - polls a mux and schedules read or write works if necessary
592 * @m: connection to poll
596 static void p9_poll_mux(struct p9_conn
*m
)
603 n
= p9_fd_poll(m
->client
, NULL
);
604 if (n
< 0 || n
& (POLLERR
| POLLHUP
| POLLNVAL
)) {
605 P9_DPRINTK(P9_DEBUG_MUX
, "error mux %p err %d\n", m
, n
);
608 p9_conn_cancel(m
, n
);
612 set_bit(Rpending
, &m
->wsched
);
613 P9_DPRINTK(P9_DEBUG_MUX
, "mux %p can read\n", m
);
614 if (!test_and_set_bit(Rworksched
, &m
->wsched
)) {
615 P9_DPRINTK(P9_DEBUG_MUX
, "schedule read work %p\n", m
);
616 queue_work(p9_mux_wq
, &m
->rq
);
621 set_bit(Wpending
, &m
->wsched
);
622 P9_DPRINTK(P9_DEBUG_MUX
, "mux %p can write\n", m
);
623 if ((m
->wsize
|| !list_empty(&m
->unsent_req_list
))
624 && !test_and_set_bit(Wworksched
, &m
->wsched
)) {
625 P9_DPRINTK(P9_DEBUG_MUX
, "schedule write work %p\n", m
);
626 queue_work(p9_mux_wq
, &m
->wq
);
632 * p9_fd_request - send 9P request
633 * The function can sleep until the request is scheduled for sending.
634 * The function can be interrupted. Return from the function is not
635 * a guarantee that the request is sent successfully.
637 * @client: client instance
638 * @req: request to be sent
642 static int p9_fd_request(struct p9_client
*client
, struct p9_req_t
*req
)
645 struct p9_trans_fd
*ts
= client
->trans
;
646 struct p9_conn
*m
= ts
->conn
;
648 P9_DPRINTK(P9_DEBUG_MUX
, "mux %p task %p tcall %p id %d\n", m
, current
,
649 req
->tc
, req
->tc
->id
);
653 #ifdef CONFIG_NET_9P_DEBUG
654 if ((p9_debug_level
&P9_DEBUG_FCALL
) == P9_DEBUG_FCALL
) {
657 p9_printfcall(buf
, sizeof(buf
), req
->tc
, client
->dotu
);
658 printk(KERN_NOTICE
"<<< %p %s\n", m
, buf
);
662 req
->status
= REQ_STATUS_UNSENT
;
664 spin_lock(&client
->lock
);
665 list_add_tail(&req
->req_list
, &m
->unsent_req_list
);
666 spin_unlock(&client
->lock
);
668 if (test_and_clear_bit(Wpending
, &m
->wsched
))
671 n
= p9_fd_poll(m
->client
, NULL
);
673 if (n
& POLLOUT
&& !test_and_set_bit(Wworksched
, &m
->wsched
))
674 queue_work(p9_mux_wq
, &m
->wq
);
679 static int p9_fd_cancel(struct p9_client
*client
, struct p9_req_t
*req
)
681 struct p9_trans_fd
*ts
= client
->trans
;
682 struct p9_conn
*m
= ts
->conn
;
684 P9_DPRINTK(P9_DEBUG_MUX
, "mux %p req %p tag %d\n", m
, req
, req
->tag
);
686 spin_lock(&client
->lock
);
687 list_del(&req
->req_list
);
688 spin_unlock(&client
->lock
);
690 /* if a response was received for a request, do nothing */
691 if (req
->rc
|| req
->t_err
) {
692 P9_DPRINTK(P9_DEBUG_MUX
,
693 "mux %p req %p response already received\n", m
, req
);
697 if (req
->status
== REQ_STATUS_UNSENT
) {
698 req
->status
= REQ_STATUS_FLSHD
;
706 * parse_options - parse mount options into session structure
707 * @options: options string passed from mount
708 * @opts: transport-specific structure to parse options into
710 * Returns 0 upon success, -ERRNO upon failure
713 static int parse_opts(char *params
, struct p9_fd_opts
*opts
)
716 substring_t args
[MAX_OPT_ARGS
];
721 opts
->port
= P9_PORT
;
728 options
= kstrdup(params
, GFP_KERNEL
);
730 P9_DPRINTK(P9_DEBUG_ERROR
,
731 "failed to allocate copy of option string\n");
735 while ((p
= strsep(&options
, ",")) != NULL
) {
740 token
= match_token(p
, tokens
, args
);
741 r
= match_int(&args
[0], &option
);
743 P9_DPRINTK(P9_DEBUG_ERROR
,
744 "integer field, but no integer?\n");
766 static int p9_fd_open(struct p9_client
*client
, int rfd
, int wfd
)
768 struct p9_trans_fd
*ts
= kmalloc(sizeof(struct p9_trans_fd
),
775 if (!ts
->rd
|| !ts
->wr
) {
785 client
->status
= Connected
;
790 static int p9_socket_open(struct p9_client
*client
, struct socket
*csocket
)
794 csocket
->sk
->sk_allocation
= GFP_NOIO
;
795 fd
= sock_map_fd(csocket
, 0);
797 P9_EPRINTK(KERN_ERR
, "p9_socket_open: failed to map fd\n");
801 ret
= p9_fd_open(client
, fd
, fd
);
803 P9_EPRINTK(KERN_ERR
, "p9_socket_open: failed to open fd\n");
808 ((struct p9_trans_fd
*)client
->trans
)->rd
->f_flags
|= O_NONBLOCK
;
814 * p9_mux_destroy - cancels all pending requests and frees mux resources
819 static void p9_conn_destroy(struct p9_conn
*m
)
821 P9_DPRINTK(P9_DEBUG_MUX
, "mux %p prev %p next %p\n", m
,
822 m
->mux_list
.prev
, m
->mux_list
.next
);
825 cancel_work_sync(&m
->rq
);
826 cancel_work_sync(&m
->wq
);
828 p9_conn_cancel(m
, -ECONNRESET
);
835 * p9_fd_close - shutdown file descriptor transport
836 * @client: client instance
840 static void p9_fd_close(struct p9_client
*client
)
842 struct p9_trans_fd
*ts
;
851 client
->status
= Disconnected
;
853 p9_conn_destroy(ts
->conn
);
864 * stolen from NFS - maybe should be made a generic function?
866 static inline int valid_ipaddr4(const char *buf
)
868 int rc
, count
, in
[4];
870 rc
= sscanf(buf
, "%d.%d.%d.%d", &in
[0], &in
[1], &in
[2], &in
[3]);
873 for (count
= 0; count
< 4; count
++) {
881 p9_fd_create_tcp(struct p9_client
*client
, const char *addr
, char *args
)
884 struct socket
*csocket
;
885 struct sockaddr_in sin_server
;
886 struct p9_fd_opts opts
;
887 struct p9_trans_fd
*p
= NULL
; /* this gets allocated in p9_fd_open */
889 err
= parse_opts(args
, &opts
);
893 if (valid_ipaddr4(addr
) < 0)
898 sin_server
.sin_family
= AF_INET
;
899 sin_server
.sin_addr
.s_addr
= in_aton(addr
);
900 sin_server
.sin_port
= htons(opts
.port
);
901 sock_create_kern(PF_INET
, SOCK_STREAM
, IPPROTO_TCP
, &csocket
);
904 P9_EPRINTK(KERN_ERR
, "p9_trans_tcp: problem creating socket\n");
909 err
= csocket
->ops
->connect(csocket
,
910 (struct sockaddr
*)&sin_server
,
911 sizeof(struct sockaddr_in
), 0);
914 "p9_trans_tcp: problem connecting socket to %s\n",
919 err
= p9_socket_open(client
, csocket
);
923 p
= (struct p9_trans_fd
*) client
->trans
;
924 p
->conn
= p9_conn_create(client
);
925 if (IS_ERR(p
->conn
)) {
926 err
= PTR_ERR(p
->conn
);
935 sock_release(csocket
);
943 p9_fd_create_unix(struct p9_client
*client
, const char *addr
, char *args
)
946 struct socket
*csocket
;
947 struct sockaddr_un sun_server
;
948 struct p9_trans_fd
*p
= NULL
; /* this gets allocated in p9_fd_open */
952 if (strlen(addr
) > UNIX_PATH_MAX
) {
953 P9_EPRINTK(KERN_ERR
, "p9_trans_unix: address too long: %s\n",
959 sun_server
.sun_family
= PF_UNIX
;
960 strcpy(sun_server
.sun_path
, addr
);
961 sock_create_kern(PF_UNIX
, SOCK_STREAM
, 0, &csocket
);
962 err
= csocket
->ops
->connect(csocket
, (struct sockaddr
*)&sun_server
,
963 sizeof(struct sockaddr_un
) - 1, 0);
966 "p9_trans_unix: problem connecting socket: %s: %d\n",
971 err
= p9_socket_open(client
, csocket
);
975 p
= (struct p9_trans_fd
*) client
->trans
;
976 p
->conn
= p9_conn_create(client
);
977 if (IS_ERR(p
->conn
)) {
978 err
= PTR_ERR(p
->conn
);
987 sock_release(csocket
);
994 p9_fd_create(struct p9_client
*client
, const char *addr
, char *args
)
997 struct p9_fd_opts opts
;
998 struct p9_trans_fd
*p
= NULL
; /* this get allocated in p9_fd_open */
1000 parse_opts(args
, &opts
);
1002 if (opts
.rfd
== ~0 || opts
.wfd
== ~0) {
1003 printk(KERN_ERR
"v9fs: Insufficient options for proto=fd\n");
1004 return -ENOPROTOOPT
;
1007 err
= p9_fd_open(client
, opts
.rfd
, opts
.wfd
);
1011 p
= (struct p9_trans_fd
*) client
->trans
;
1012 p
->conn
= p9_conn_create(client
);
1013 if (IS_ERR(p
->conn
)) {
1014 err
= PTR_ERR(p
->conn
);
1026 static struct p9_trans_module p9_tcp_trans
= {
1028 .maxsize
= MAX_SOCK_BUF
,
1030 .create
= p9_fd_create_tcp
,
1031 .close
= p9_fd_close
,
1032 .request
= p9_fd_request
,
1033 .cancel
= p9_fd_cancel
,
1034 .owner
= THIS_MODULE
,
1037 static struct p9_trans_module p9_unix_trans
= {
1039 .maxsize
= MAX_SOCK_BUF
,
1041 .create
= p9_fd_create_unix
,
1042 .close
= p9_fd_close
,
1043 .request
= p9_fd_request
,
1044 .cancel
= p9_fd_cancel
,
1045 .owner
= THIS_MODULE
,
1048 static struct p9_trans_module p9_fd_trans
= {
1050 .maxsize
= MAX_SOCK_BUF
,
1052 .create
= p9_fd_create
,
1053 .close
= p9_fd_close
,
1054 .request
= p9_fd_request
,
1055 .cancel
= p9_fd_cancel
,
1056 .owner
= THIS_MODULE
,
1060 * p9_poll_proc - poll worker thread
1061 * @a: thread state and arguments
1063 * polls all v9fs transports for new events and queues the appropriate
1064 * work to the work queue
1068 static int p9_poll_proc(void *a
)
1070 unsigned long flags
;
1072 P9_DPRINTK(P9_DEBUG_MUX
, "start %p\n", current
);
1074 spin_lock_irqsave(&p9_poll_lock
, flags
);
1075 while (!list_empty(&p9_poll_pending_list
)) {
1076 struct p9_conn
*conn
= list_first_entry(&p9_poll_pending_list
,
1079 list_del_init(&conn
->poll_pending_link
);
1080 spin_unlock_irqrestore(&p9_poll_lock
, flags
);
1084 spin_lock_irqsave(&p9_poll_lock
, flags
);
1086 spin_unlock_irqrestore(&p9_poll_lock
, flags
);
1088 set_current_state(TASK_INTERRUPTIBLE
);
1089 if (list_empty(&p9_poll_pending_list
)) {
1090 P9_DPRINTK(P9_DEBUG_MUX
, "sleeping...\n");
1093 __set_current_state(TASK_RUNNING
);
1095 if (!kthread_should_stop())
1098 P9_DPRINTK(P9_DEBUG_MUX
, "finish\n");
1102 int p9_trans_fd_init(void)
1104 p9_mux_wq
= create_workqueue("v9fs");
1106 printk(KERN_WARNING
"v9fs: mux: creating workqueue failed\n");
1110 p9_poll_task
= kthread_run(p9_poll_proc
, NULL
, "v9fs-poll");
1111 if (IS_ERR(p9_poll_task
)) {
1112 destroy_workqueue(p9_mux_wq
);
1113 printk(KERN_WARNING
"v9fs: mux: creating poll task failed\n");
1114 return PTR_ERR(p9_poll_task
);
1117 v9fs_register_trans(&p9_tcp_trans
);
1118 v9fs_register_trans(&p9_unix_trans
);
1119 v9fs_register_trans(&p9_fd_trans
);
1124 void p9_trans_fd_exit(void)
1126 kthread_stop(p9_poll_task
);
1127 v9fs_unregister_trans(&p9_tcp_trans
);
1128 v9fs_unregister_trans(&p9_unix_trans
);
1129 v9fs_unregister_trans(&p9_fd_trans
);
1131 destroy_workqueue(p9_mux_wq
);