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
28 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
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>
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 <net/9p/9p.h>
45 #include <net/9p/client.h>
46 #include <net/9p/transport.h>
48 #include <linux/syscalls.h> /* killme */
51 #define MAX_SOCK_BUF (64*1024)
52 #define MAXPOLLWADDR 2
55 * struct p9_fd_opts - per-transport options
56 * @rfd: file descriptor for reading (trans=fd)
57 * @wfd: file descriptor for writing (trans=fd)
58 * @port: port to connect to (trans=tcp)
70 * struct p9_trans_fd - transport state
71 * @rd: reference to file to read from
72 * @wr: reference of file to write to
73 * @conn: connection state reference
84 * Option Parsing (code inspired by NFS code)
85 * - a little lazy - parse all fd-transport options
89 /* Options that take integer arguments */
90 Opt_port
, Opt_rfdno
, Opt_wfdno
, Opt_err
,
91 /* Options that take no arguments */
95 static const match_table_t tokens
= {
96 {Opt_port
, "port=%u"},
97 {Opt_rfdno
, "rfdno=%u"},
98 {Opt_wfdno
, "wfdno=%u"},
99 {Opt_privport
, "privport"},
104 Rworksched
= 1, /* read work scheduled or running */
105 Rpending
= 2, /* can read */
106 Wworksched
= 4, /* write work scheduled or running */
107 Wpending
= 8, /* can write */
110 struct p9_poll_wait
{
111 struct p9_conn
*conn
;
113 wait_queue_head_t
*wait_addr
;
117 * struct p9_conn - fd mux connection state information
118 * @mux_list: list link for mux to manage multiple connections (?)
119 * @client: reference to client instance for this connection
121 * @req_list: accounting for requests which have been sent
122 * @unsent_req_list: accounting for requests that haven't been sent
123 * @req: current request being processed (if any)
124 * @tmp_buf: temporary buffer to read in header
125 * @rsize: amount to read for current frame
126 * @rpos: read position in current frame
127 * @rbuf: current read buffer
128 * @wpos: write position for current frame
129 * @wsize: amount of data to write for current frame
130 * @wbuf: current write buffer
131 * @poll_pending_link: pending links to be polled per conn
132 * @poll_wait: array of wait_q's for various worker threads
134 * @rq: current read work
135 * @wq: current write work
141 struct list_head mux_list
;
142 struct p9_client
*client
;
144 struct list_head req_list
;
145 struct list_head unsent_req_list
;
146 struct p9_req_t
*req
;
154 struct list_head poll_pending_link
;
155 struct p9_poll_wait poll_wait
[MAXPOLLWADDR
];
157 struct work_struct rq
;
158 struct work_struct wq
;
159 unsigned long wsched
;
162 static void p9_poll_workfn(struct work_struct
*work
);
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
);
168 static unsigned int p9_ipport_resv_min
= P9_DEF_MIN_RESVPORT
;
169 static unsigned int p9_ipport_resv_max
= P9_DEF_MAX_RESVPORT
;
171 static void p9_mux_poll_stop(struct p9_conn
*m
)
176 for (i
= 0; i
< ARRAY_SIZE(m
->poll_wait
); i
++) {
177 struct p9_poll_wait
*pwait
= &m
->poll_wait
[i
];
179 if (pwait
->wait_addr
) {
180 remove_wait_queue(pwait
->wait_addr
, &pwait
->wait
);
181 pwait
->wait_addr
= NULL
;
185 spin_lock_irqsave(&p9_poll_lock
, flags
);
186 list_del_init(&m
->poll_pending_link
);
187 spin_unlock_irqrestore(&p9_poll_lock
, flags
);
191 * p9_conn_cancel - cancel all pending requests with error
197 static void p9_conn_cancel(struct p9_conn
*m
, int err
)
199 struct p9_req_t
*req
, *rtmp
;
201 LIST_HEAD(cancel_list
);
203 p9_debug(P9_DEBUG_ERROR
, "mux %p err %d\n", m
, err
);
205 spin_lock_irqsave(&m
->client
->lock
, flags
);
208 spin_unlock_irqrestore(&m
->client
->lock
, flags
);
214 list_for_each_entry_safe(req
, rtmp
, &m
->req_list
, req_list
) {
215 list_move(&req
->req_list
, &cancel_list
);
217 list_for_each_entry_safe(req
, rtmp
, &m
->unsent_req_list
, req_list
) {
218 list_move(&req
->req_list
, &cancel_list
);
220 spin_unlock_irqrestore(&m
->client
->lock
, flags
);
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
);
227 p9_client_cb(m
->client
, req
, REQ_STATUS_ERROR
);
232 p9_fd_poll(struct p9_client
*client
, struct poll_table_struct
*pt
)
235 struct p9_trans_fd
*ts
= NULL
;
237 if (client
&& client
->status
== Connected
)
243 if (!ts
->rd
->f_op
->poll
)
246 if (!ts
->wr
->f_op
->poll
)
249 ret
= ts
->rd
->f_op
->poll(ts
->rd
, pt
);
253 if (ts
->rd
!= ts
->wr
) {
254 n
= ts
->wr
->f_op
->poll(ts
->wr
, pt
);
257 ret
= (ret
& ~POLLOUT
) | (n
& ~POLLIN
);
264 * p9_fd_read- read from a fd
265 * @client: client instance
266 * @v: buffer to receive data into
267 * @len: size of receive buffer
271 static int p9_fd_read(struct p9_client
*client
, void *v
, int len
)
274 struct p9_trans_fd
*ts
= NULL
;
276 if (client
&& client
->status
!= Disconnected
)
282 if (!(ts
->rd
->f_flags
& O_NONBLOCK
))
283 p9_debug(P9_DEBUG_ERROR
, "blocking read ...\n");
285 ret
= kernel_read(ts
->rd
, ts
->rd
->f_pos
, v
, len
);
286 if (ret
<= 0 && ret
!= -ERESTARTSYS
&& ret
!= -EAGAIN
)
287 client
->status
= Disconnected
;
292 * p9_read_work - called when there is some data to be read from a transport
293 * @work: container of work to be done
297 static void p9_read_work(struct work_struct
*work
)
301 int status
= REQ_STATUS_ERROR
;
303 m
= container_of(work
, struct p9_conn
, rq
);
308 p9_debug(P9_DEBUG_TRANS
, "start mux %p pos %d\n", m
, m
->rpos
);
311 m
->rbuf
= m
->tmp_buf
;
313 m
->rsize
= 7; /* start by reading header */
316 clear_bit(Rpending
, &m
->wsched
);
317 p9_debug(P9_DEBUG_TRANS
, "read mux %p pos %d size: %d = %d\n",
318 m
, m
->rpos
, m
->rsize
, m
->rsize
-m
->rpos
);
319 err
= p9_fd_read(m
->client
, m
->rbuf
+ m
->rpos
,
321 p9_debug(P9_DEBUG_TRANS
, "mux %p got %d bytes\n", m
, err
);
322 if (err
== -EAGAIN
) {
331 if ((!m
->req
) && (m
->rpos
== m
->rsize
)) { /* header read in */
333 p9_debug(P9_DEBUG_TRANS
, "got new header\n");
335 n
= le32_to_cpu(*(__le32
*) m
->rbuf
); /* read packet size */
336 if (n
>= m
->client
->msize
) {
337 p9_debug(P9_DEBUG_ERROR
,
338 "requested packet size too big: %d\n", n
);
343 tag
= le16_to_cpu(*(__le16
*) (m
->rbuf
+5)); /* read tag */
344 p9_debug(P9_DEBUG_TRANS
,
345 "mux %p pkt: size: %d bytes tag: %d\n", m
, n
, tag
);
347 m
->req
= p9_tag_lookup(m
->client
, tag
);
348 if (!m
->req
|| (m
->req
->status
!= REQ_STATUS_SENT
&&
349 m
->req
->status
!= REQ_STATUS_FLSH
)) {
350 p9_debug(P9_DEBUG_ERROR
, "Unexpected packet tag %d\n",
356 if (m
->req
->rc
== NULL
) {
357 m
->req
->rc
= kmalloc(sizeof(struct p9_fcall
) +
358 m
->client
->msize
, GFP_NOFS
);
365 m
->rbuf
= (char *)m
->req
->rc
+ sizeof(struct p9_fcall
);
366 memcpy(m
->rbuf
, m
->tmp_buf
, m
->rsize
);
370 /* not an else because some packets (like clunk) have no payload */
371 if ((m
->req
) && (m
->rpos
== m
->rsize
)) { /* packet is read in */
372 p9_debug(P9_DEBUG_TRANS
, "got new packet\n");
373 spin_lock(&m
->client
->lock
);
374 if (m
->req
->status
!= REQ_STATUS_ERROR
)
375 status
= REQ_STATUS_RCVD
;
376 list_del(&m
->req
->req_list
);
377 spin_unlock(&m
->client
->lock
);
378 p9_client_cb(m
->client
, m
->req
, status
);
386 clear_bit(Rworksched
, &m
->wsched
);
388 if (!list_empty(&m
->req_list
)) {
389 if (test_and_clear_bit(Rpending
, &m
->wsched
))
392 n
= p9_fd_poll(m
->client
, NULL
);
394 if ((n
& POLLIN
) && !test_and_set_bit(Rworksched
, &m
->wsched
)) {
395 p9_debug(P9_DEBUG_TRANS
, "sched read work %p\n", m
);
396 schedule_work(&m
->rq
);
402 p9_conn_cancel(m
, err
);
403 clear_bit(Rworksched
, &m
->wsched
);
407 * p9_fd_write - write to a socket
408 * @client: client instance
409 * @v: buffer to send data from
410 * @len: size of send buffer
414 static int p9_fd_write(struct p9_client
*client
, void *v
, int len
)
418 struct p9_trans_fd
*ts
= NULL
;
420 if (client
&& client
->status
!= Disconnected
)
426 if (!(ts
->wr
->f_flags
& O_NONBLOCK
))
427 p9_debug(P9_DEBUG_ERROR
, "blocking write ...\n");
431 /* The cast to a user pointer is valid due to the set_fs() */
432 ret
= vfs_write(ts
->wr
, (__force
void __user
*)v
, len
, &ts
->wr
->f_pos
);
435 if (ret
<= 0 && ret
!= -ERESTARTSYS
&& ret
!= -EAGAIN
)
436 client
->status
= Disconnected
;
441 * p9_write_work - called when a transport can send some data
442 * @work: container for work to be done
446 static void p9_write_work(struct work_struct
*work
)
450 struct p9_req_t
*req
;
452 m
= container_of(work
, struct p9_conn
, wq
);
455 clear_bit(Wworksched
, &m
->wsched
);
460 spin_lock(&m
->client
->lock
);
461 if (list_empty(&m
->unsent_req_list
)) {
462 clear_bit(Wworksched
, &m
->wsched
);
463 spin_unlock(&m
->client
->lock
);
467 req
= list_entry(m
->unsent_req_list
.next
, struct p9_req_t
,
469 req
->status
= REQ_STATUS_SENT
;
470 p9_debug(P9_DEBUG_TRANS
, "move req %p\n", req
);
471 list_move_tail(&req
->req_list
, &m
->req_list
);
473 m
->wbuf
= req
->tc
->sdata
;
474 m
->wsize
= req
->tc
->size
;
476 spin_unlock(&m
->client
->lock
);
479 p9_debug(P9_DEBUG_TRANS
, "mux %p pos %d size %d\n",
480 m
, m
->wpos
, m
->wsize
);
481 clear_bit(Wpending
, &m
->wsched
);
482 err
= p9_fd_write(m
->client
, m
->wbuf
+ m
->wpos
, m
->wsize
- m
->wpos
);
483 p9_debug(P9_DEBUG_TRANS
, "mux %p sent %d bytes\n", m
, err
);
496 if (m
->wpos
== m
->wsize
)
497 m
->wpos
= m
->wsize
= 0;
500 clear_bit(Wworksched
, &m
->wsched
);
502 if (m
->wsize
|| !list_empty(&m
->unsent_req_list
)) {
503 if (test_and_clear_bit(Wpending
, &m
->wsched
))
506 n
= p9_fd_poll(m
->client
, NULL
);
509 !test_and_set_bit(Wworksched
, &m
->wsched
)) {
510 p9_debug(P9_DEBUG_TRANS
, "sched write work %p\n", m
);
511 schedule_work(&m
->wq
);
518 p9_conn_cancel(m
, err
);
519 clear_bit(Wworksched
, &m
->wsched
);
522 static int p9_pollwake(wait_queue_t
*wait
, unsigned int mode
, int sync
, void *key
)
524 struct p9_poll_wait
*pwait
=
525 container_of(wait
, struct p9_poll_wait
, wait
);
526 struct p9_conn
*m
= pwait
->conn
;
529 spin_lock_irqsave(&p9_poll_lock
, flags
);
530 if (list_empty(&m
->poll_pending_link
))
531 list_add_tail(&m
->poll_pending_link
, &p9_poll_pending_list
);
532 spin_unlock_irqrestore(&p9_poll_lock
, flags
);
534 schedule_work(&p9_poll_work
);
539 * p9_pollwait - add poll task to the wait queue
540 * @filp: file pointer being polled
541 * @wait_address: wait_q to block on
544 * called by files poll operation to add v9fs-poll task to files wait queue
548 p9_pollwait(struct file
*filp
, wait_queue_head_t
*wait_address
, poll_table
*p
)
550 struct p9_conn
*m
= container_of(p
, struct p9_conn
, pt
);
551 struct p9_poll_wait
*pwait
= NULL
;
554 for (i
= 0; i
< ARRAY_SIZE(m
->poll_wait
); i
++) {
555 if (m
->poll_wait
[i
].wait_addr
== NULL
) {
556 pwait
= &m
->poll_wait
[i
];
562 p9_debug(P9_DEBUG_ERROR
, "not enough wait_address slots\n");
567 pwait
->wait_addr
= wait_address
;
568 init_waitqueue_func_entry(&pwait
->wait
, p9_pollwake
);
569 add_wait_queue(wait_address
, &pwait
->wait
);
573 * p9_conn_create - allocate and initialize the per-session mux data
574 * @client: client instance
576 * Note: Creates the polling task if this is the first session.
579 static struct p9_conn
*p9_conn_create(struct p9_client
*client
)
584 p9_debug(P9_DEBUG_TRANS
, "client %p msize %d\n", client
, client
->msize
);
585 m
= kzalloc(sizeof(struct p9_conn
), GFP_KERNEL
);
587 return ERR_PTR(-ENOMEM
);
589 INIT_LIST_HEAD(&m
->mux_list
);
592 INIT_LIST_HEAD(&m
->req_list
);
593 INIT_LIST_HEAD(&m
->unsent_req_list
);
594 INIT_WORK(&m
->rq
, p9_read_work
);
595 INIT_WORK(&m
->wq
, p9_write_work
);
596 INIT_LIST_HEAD(&m
->poll_pending_link
);
597 init_poll_funcptr(&m
->pt
, p9_pollwait
);
599 n
= p9_fd_poll(client
, &m
->pt
);
601 p9_debug(P9_DEBUG_TRANS
, "mux %p can read\n", m
);
602 set_bit(Rpending
, &m
->wsched
);
606 p9_debug(P9_DEBUG_TRANS
, "mux %p can write\n", m
);
607 set_bit(Wpending
, &m
->wsched
);
614 * p9_poll_mux - polls a mux and schedules read or write works if necessary
615 * @m: connection to poll
619 static void p9_poll_mux(struct p9_conn
*m
)
626 n
= p9_fd_poll(m
->client
, NULL
);
627 if (n
< 0 || n
& (POLLERR
| POLLHUP
| POLLNVAL
)) {
628 p9_debug(P9_DEBUG_TRANS
, "error mux %p err %d\n", m
, n
);
631 p9_conn_cancel(m
, n
);
635 set_bit(Rpending
, &m
->wsched
);
636 p9_debug(P9_DEBUG_TRANS
, "mux %p can read\n", m
);
637 if (!test_and_set_bit(Rworksched
, &m
->wsched
)) {
638 p9_debug(P9_DEBUG_TRANS
, "sched read work %p\n", m
);
639 schedule_work(&m
->rq
);
644 set_bit(Wpending
, &m
->wsched
);
645 p9_debug(P9_DEBUG_TRANS
, "mux %p can write\n", m
);
646 if ((m
->wsize
|| !list_empty(&m
->unsent_req_list
)) &&
647 !test_and_set_bit(Wworksched
, &m
->wsched
)) {
648 p9_debug(P9_DEBUG_TRANS
, "sched write work %p\n", m
);
649 schedule_work(&m
->wq
);
655 * p9_fd_request - send 9P request
656 * The function can sleep until the request is scheduled for sending.
657 * The function can be interrupted. Return from the function is not
658 * a guarantee that the request is sent successfully.
660 * @client: client instance
661 * @req: request to be sent
665 static int p9_fd_request(struct p9_client
*client
, struct p9_req_t
*req
)
668 struct p9_trans_fd
*ts
= client
->trans
;
669 struct p9_conn
*m
= ts
->conn
;
671 p9_debug(P9_DEBUG_TRANS
, "mux %p task %p tcall %p id %d\n",
672 m
, current
, req
->tc
, req
->tc
->id
);
676 spin_lock(&client
->lock
);
677 req
->status
= REQ_STATUS_UNSENT
;
678 list_add_tail(&req
->req_list
, &m
->unsent_req_list
);
679 spin_unlock(&client
->lock
);
681 if (test_and_clear_bit(Wpending
, &m
->wsched
))
684 n
= p9_fd_poll(m
->client
, NULL
);
686 if (n
& POLLOUT
&& !test_and_set_bit(Wworksched
, &m
->wsched
))
687 schedule_work(&m
->wq
);
692 static int p9_fd_cancel(struct p9_client
*client
, struct p9_req_t
*req
)
696 p9_debug(P9_DEBUG_TRANS
, "client %p req %p\n", client
, req
);
698 spin_lock(&client
->lock
);
700 if (req
->status
== REQ_STATUS_UNSENT
) {
701 list_del(&req
->req_list
);
702 req
->status
= REQ_STATUS_FLSHD
;
704 } else if (req
->status
== REQ_STATUS_SENT
)
705 req
->status
= REQ_STATUS_FLSH
;
707 spin_unlock(&client
->lock
);
712 static int p9_fd_cancelled(struct p9_client
*client
, struct p9_req_t
*req
)
714 p9_debug(P9_DEBUG_TRANS
, "client %p req %p\n", client
, req
);
716 /* we haven't received a response for oldreq,
717 * remove it from the list.
719 spin_lock(&client
->lock
);
720 list_del(&req
->req_list
);
721 spin_unlock(&client
->lock
);
727 * parse_opts - parse mount options into p9_fd_opts structure
728 * @params: options string passed from mount
729 * @opts: fd transport-specific structure to parse options into
731 * Returns 0 upon success, -ERRNO upon failure
734 static int parse_opts(char *params
, struct p9_fd_opts
*opts
)
737 substring_t args
[MAX_OPT_ARGS
];
739 char *options
, *tmp_options
;
741 opts
->port
= P9_PORT
;
748 tmp_options
= kstrdup(params
, GFP_KERNEL
);
750 p9_debug(P9_DEBUG_ERROR
,
751 "failed to allocate copy of option string\n");
754 options
= tmp_options
;
756 while ((p
= strsep(&options
, ",")) != NULL
) {
761 token
= match_token(p
, tokens
, args
);
762 if ((token
!= Opt_err
) && (token
!= Opt_privport
)) {
763 r
= match_int(&args
[0], &option
);
765 p9_debug(P9_DEBUG_ERROR
,
766 "integer field, but no integer?\n");
792 static int p9_fd_open(struct p9_client
*client
, int rfd
, int wfd
)
794 struct p9_trans_fd
*ts
= kmalloc(sizeof(struct p9_trans_fd
),
801 if (!ts
->rd
|| !ts
->wr
) {
811 client
->status
= Connected
;
816 static int p9_socket_open(struct p9_client
*client
, struct socket
*csocket
)
818 struct p9_trans_fd
*p
;
822 p
= kmalloc(sizeof(struct p9_trans_fd
), GFP_KERNEL
);
826 csocket
->sk
->sk_allocation
= GFP_NOIO
;
827 file
= sock_alloc_file(csocket
, 0, NULL
);
829 pr_err("%s (%d): failed to map fd\n",
830 __func__
, task_pid_nr(current
));
831 sock_release(csocket
);
833 return PTR_ERR(file
);
837 p
->wr
= p
->rd
= file
;
839 client
->status
= Connected
;
841 p
->rd
->f_flags
|= O_NONBLOCK
;
843 p
->conn
= p9_conn_create(client
);
844 if (IS_ERR(p
->conn
)) {
845 ret
= PTR_ERR(p
->conn
);
856 * p9_mux_destroy - cancels all pending requests and frees mux resources
861 static void p9_conn_destroy(struct p9_conn
*m
)
863 p9_debug(P9_DEBUG_TRANS
, "mux %p prev %p next %p\n",
864 m
, m
->mux_list
.prev
, m
->mux_list
.next
);
867 cancel_work_sync(&m
->rq
);
868 cancel_work_sync(&m
->wq
);
870 p9_conn_cancel(m
, -ECONNRESET
);
877 * p9_fd_close - shutdown file descriptor transport
878 * @client: client instance
882 static void p9_fd_close(struct p9_client
*client
)
884 struct p9_trans_fd
*ts
;
893 client
->status
= Disconnected
;
895 p9_conn_destroy(ts
->conn
);
906 * stolen from NFS - maybe should be made a generic function?
908 static inline int valid_ipaddr4(const char *buf
)
910 int rc
, count
, in
[4];
912 rc
= sscanf(buf
, "%d.%d.%d.%d", &in
[0], &in
[1], &in
[2], &in
[3]);
915 for (count
= 0; count
< 4; count
++) {
922 static int p9_bind_privport(struct socket
*sock
)
924 struct sockaddr_in cl
;
925 int port
, err
= -EINVAL
;
927 memset(&cl
, 0, sizeof(cl
));
928 cl
.sin_family
= AF_INET
;
929 cl
.sin_addr
.s_addr
= INADDR_ANY
;
930 for (port
= p9_ipport_resv_max
; port
>= p9_ipport_resv_min
; port
--) {
931 cl
.sin_port
= htons((ushort
)port
);
932 err
= kernel_bind(sock
, (struct sockaddr
*)&cl
, sizeof(cl
));
933 if (err
!= -EADDRINUSE
)
941 p9_fd_create_tcp(struct p9_client
*client
, const char *addr
, char *args
)
944 struct socket
*csocket
;
945 struct sockaddr_in sin_server
;
946 struct p9_fd_opts opts
;
948 err
= parse_opts(args
, &opts
);
952 if (valid_ipaddr4(addr
) < 0)
957 sin_server
.sin_family
= AF_INET
;
958 sin_server
.sin_addr
.s_addr
= in_aton(addr
);
959 sin_server
.sin_port
= htons(opts
.port
);
960 err
= __sock_create(read_pnet(¤t
->nsproxy
->net_ns
), PF_INET
,
961 SOCK_STREAM
, IPPROTO_TCP
, &csocket
, 1);
963 pr_err("%s (%d): problem creating socket\n",
964 __func__
, task_pid_nr(current
));
969 err
= p9_bind_privport(csocket
);
971 pr_err("%s (%d): problem binding to privport\n",
972 __func__
, task_pid_nr(current
));
973 sock_release(csocket
);
978 err
= csocket
->ops
->connect(csocket
,
979 (struct sockaddr
*)&sin_server
,
980 sizeof(struct sockaddr_in
), 0);
982 pr_err("%s (%d): problem connecting socket to %s\n",
983 __func__
, task_pid_nr(current
), addr
);
984 sock_release(csocket
);
988 return p9_socket_open(client
, csocket
);
992 p9_fd_create_unix(struct p9_client
*client
, const char *addr
, char *args
)
995 struct socket
*csocket
;
996 struct sockaddr_un sun_server
;
1000 if (strlen(addr
) >= UNIX_PATH_MAX
) {
1001 pr_err("%s (%d): address too long: %s\n",
1002 __func__
, task_pid_nr(current
), addr
);
1003 return -ENAMETOOLONG
;
1006 sun_server
.sun_family
= PF_UNIX
;
1007 strcpy(sun_server
.sun_path
, addr
);
1008 err
= __sock_create(read_pnet(¤t
->nsproxy
->net_ns
), PF_UNIX
,
1009 SOCK_STREAM
, 0, &csocket
, 1);
1011 pr_err("%s (%d): problem creating socket\n",
1012 __func__
, task_pid_nr(current
));
1016 err
= csocket
->ops
->connect(csocket
, (struct sockaddr
*)&sun_server
,
1017 sizeof(struct sockaddr_un
) - 1, 0);
1019 pr_err("%s (%d): problem connecting socket: %s: %d\n",
1020 __func__
, task_pid_nr(current
), addr
, err
);
1021 sock_release(csocket
);
1025 return p9_socket_open(client
, csocket
);
1029 p9_fd_create(struct p9_client
*client
, const char *addr
, char *args
)
1032 struct p9_fd_opts opts
;
1033 struct p9_trans_fd
*p
;
1035 parse_opts(args
, &opts
);
1037 if (opts
.rfd
== ~0 || opts
.wfd
== ~0) {
1038 pr_err("Insufficient options for proto=fd\n");
1039 return -ENOPROTOOPT
;
1042 err
= p9_fd_open(client
, opts
.rfd
, opts
.wfd
);
1046 p
= (struct p9_trans_fd
*) client
->trans
;
1047 p
->conn
= p9_conn_create(client
);
1048 if (IS_ERR(p
->conn
)) {
1049 err
= PTR_ERR(p
->conn
);
1059 static struct p9_trans_module p9_tcp_trans
= {
1061 .maxsize
= MAX_SOCK_BUF
,
1063 .create
= p9_fd_create_tcp
,
1064 .close
= p9_fd_close
,
1065 .request
= p9_fd_request
,
1066 .cancel
= p9_fd_cancel
,
1067 .cancelled
= p9_fd_cancelled
,
1068 .owner
= THIS_MODULE
,
1071 static struct p9_trans_module p9_unix_trans
= {
1073 .maxsize
= MAX_SOCK_BUF
,
1075 .create
= p9_fd_create_unix
,
1076 .close
= p9_fd_close
,
1077 .request
= p9_fd_request
,
1078 .cancel
= p9_fd_cancel
,
1079 .cancelled
= p9_fd_cancelled
,
1080 .owner
= THIS_MODULE
,
1083 static struct p9_trans_module p9_fd_trans
= {
1085 .maxsize
= MAX_SOCK_BUF
,
1087 .create
= p9_fd_create
,
1088 .close
= p9_fd_close
,
1089 .request
= p9_fd_request
,
1090 .cancel
= p9_fd_cancel
,
1091 .cancelled
= p9_fd_cancelled
,
1092 .owner
= THIS_MODULE
,
1096 * p9_poll_proc - poll worker thread
1097 * @a: thread state and arguments
1099 * polls all v9fs transports for new events and queues the appropriate
1100 * work to the work queue
1104 static void p9_poll_workfn(struct work_struct
*work
)
1106 unsigned long flags
;
1108 p9_debug(P9_DEBUG_TRANS
, "start %p\n", current
);
1110 spin_lock_irqsave(&p9_poll_lock
, flags
);
1111 while (!list_empty(&p9_poll_pending_list
)) {
1112 struct p9_conn
*conn
= list_first_entry(&p9_poll_pending_list
,
1115 list_del_init(&conn
->poll_pending_link
);
1116 spin_unlock_irqrestore(&p9_poll_lock
, flags
);
1120 spin_lock_irqsave(&p9_poll_lock
, flags
);
1122 spin_unlock_irqrestore(&p9_poll_lock
, flags
);
1124 p9_debug(P9_DEBUG_TRANS
, "finish\n");
1127 int p9_trans_fd_init(void)
1129 v9fs_register_trans(&p9_tcp_trans
);
1130 v9fs_register_trans(&p9_unix_trans
);
1131 v9fs_register_trans(&p9_fd_trans
);
1136 void p9_trans_fd_exit(void)
1138 flush_work(&p9_poll_work
);
1139 v9fs_unregister_trans(&p9_tcp_trans
);
1140 v9fs_unregister_trans(&p9_unix_trans
);
1141 v9fs_unregister_trans(&p9_fd_trans
);