2 * net/tipc/server.c: TIPC server infrastructure
4 * Copyright (c) 2012-2013, Wind River Systems
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. Neither the names of the copyright holders nor the names of its
16 * contributors may be used to endorse or promote products derived from
17 * this software without specific prior written permission.
19 * Alternatively, this software may be distributed under the terms of the
20 * GNU General Public License ("GPL") version 2 as published by the Free
21 * Software Foundation.
23 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
24 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
27 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
28 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
29 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
30 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
31 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
32 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
33 * POSSIBILITY OF SUCH DAMAGE.
40 /* Number of messages to send before rescheduling */
41 #define MAX_SEND_MSG_COUNT 25
42 #define MAX_RECV_MSG_COUNT 25
43 #define CF_CONNECTED 1
45 #define sock2con(x) ((struct tipc_conn *)(x)->sk_user_data)
48 * struct tipc_conn - TIPC connection structure
49 * @kref: reference counter to connection object
50 * @conid: connection identifier
51 * @sock: socket handler associated with connection
52 * @flags: indicates connection state
53 * @server: pointer to connected server
54 * @rwork: receive work item
55 * @usr_data: user-specified field
56 * @rx_action: what to do when connection socket is active
57 * @outqueue: pointer to first outbound message in queue
58 * @outqueue_lock: controll access to the outqueue
59 * @outqueue: list of connection objects for its server
60 * @swork: send work item
67 struct tipc_server
*server
;
68 struct work_struct rwork
;
69 int (*rx_action
) (struct tipc_conn
*con
);
71 struct list_head outqueue
;
72 spinlock_t outqueue_lock
;
73 struct work_struct swork
;
76 /* An entry waiting to be sent */
77 struct outqueue_entry
{
78 struct list_head list
;
80 struct sockaddr_tipc dest
;
83 static void tipc_recv_work(struct work_struct
*work
);
84 static void tipc_send_work(struct work_struct
*work
);
85 static void tipc_clean_outqueues(struct tipc_conn
*con
);
87 static void tipc_conn_kref_release(struct kref
*kref
)
89 struct tipc_conn
*con
= container_of(kref
, struct tipc_conn
, kref
);
90 struct tipc_server
*s
= con
->server
;
93 tipc_sock_release_local(con
->sock
);
97 tipc_clean_outqueues(con
);
100 s
->tipc_conn_shutdown(con
->conid
, con
->usr_data
);
105 static void conn_put(struct tipc_conn
*con
)
107 kref_put(&con
->kref
, tipc_conn_kref_release
);
110 static void conn_get(struct tipc_conn
*con
)
112 kref_get(&con
->kref
);
115 static struct tipc_conn
*tipc_conn_lookup(struct tipc_server
*s
, int conid
)
117 struct tipc_conn
*con
;
119 spin_lock_bh(&s
->idr_lock
);
120 con
= idr_find(&s
->conn_idr
, conid
);
123 spin_unlock_bh(&s
->idr_lock
);
127 static void sock_data_ready(struct sock
*sk
, int unused
)
129 struct tipc_conn
*con
;
131 read_lock(&sk
->sk_callback_lock
);
133 if (con
&& test_bit(CF_CONNECTED
, &con
->flags
)) {
135 if (!queue_work(con
->server
->rcv_wq
, &con
->rwork
))
138 read_unlock(&sk
->sk_callback_lock
);
141 static void sock_write_space(struct sock
*sk
)
143 struct tipc_conn
*con
;
145 read_lock(&sk
->sk_callback_lock
);
147 if (con
&& test_bit(CF_CONNECTED
, &con
->flags
)) {
149 if (!queue_work(con
->server
->send_wq
, &con
->swork
))
152 read_unlock(&sk
->sk_callback_lock
);
155 static void tipc_register_callbacks(struct socket
*sock
, struct tipc_conn
*con
)
157 struct sock
*sk
= sock
->sk
;
159 write_lock_bh(&sk
->sk_callback_lock
);
161 sk
->sk_data_ready
= sock_data_ready
;
162 sk
->sk_write_space
= sock_write_space
;
163 sk
->sk_user_data
= con
;
167 write_unlock_bh(&sk
->sk_callback_lock
);
170 static void tipc_unregister_callbacks(struct tipc_conn
*con
)
172 struct sock
*sk
= con
->sock
->sk
;
174 write_lock_bh(&sk
->sk_callback_lock
);
175 sk
->sk_user_data
= NULL
;
176 write_unlock_bh(&sk
->sk_callback_lock
);
179 static void tipc_close_conn(struct tipc_conn
*con
)
181 struct tipc_server
*s
= con
->server
;
183 if (test_and_clear_bit(CF_CONNECTED
, &con
->flags
)) {
184 spin_lock_bh(&s
->idr_lock
);
185 idr_remove(&s
->conn_idr
, con
->conid
);
187 spin_unlock_bh(&s
->idr_lock
);
189 tipc_unregister_callbacks(con
);
191 /* We shouldn't flush pending works as we may be in the
192 * thread. In fact the races with pending rx/tx work structs
193 * are harmless for us here as we have already deleted this
194 * connection from server connection list and set
195 * sk->sk_user_data to 0 before releasing connection object.
197 kernel_sock_shutdown(con
->sock
, SHUT_RDWR
);
203 static struct tipc_conn
*tipc_alloc_conn(struct tipc_server
*s
)
205 struct tipc_conn
*con
;
208 con
= kzalloc(sizeof(struct tipc_conn
), GFP_ATOMIC
);
210 return ERR_PTR(-ENOMEM
);
212 kref_init(&con
->kref
);
213 INIT_LIST_HEAD(&con
->outqueue
);
214 spin_lock_init(&con
->outqueue_lock
);
215 INIT_WORK(&con
->swork
, tipc_send_work
);
216 INIT_WORK(&con
->rwork
, tipc_recv_work
);
218 spin_lock_bh(&s
->idr_lock
);
219 ret
= idr_alloc(&s
->conn_idr
, con
, 0, 0, GFP_ATOMIC
);
222 spin_unlock_bh(&s
->idr_lock
);
223 return ERR_PTR(-ENOMEM
);
227 spin_unlock_bh(&s
->idr_lock
);
229 set_bit(CF_CONNECTED
, &con
->flags
);
235 static int tipc_receive_from_sock(struct tipc_conn
*con
)
237 struct msghdr msg
= {};
238 struct tipc_server
*s
= con
->server
;
239 struct sockaddr_tipc addr
;
244 buf
= kmem_cache_alloc(s
->rcvbuf_cache
, GFP_ATOMIC
);
251 iov
.iov_len
= s
->max_rcvbuf_size
;
252 msg
.msg_name
= &addr
;
253 ret
= kernel_recvmsg(con
->sock
, &msg
, &iov
, 1, iov
.iov_len
,
256 kmem_cache_free(s
->rcvbuf_cache
, buf
);
260 s
->tipc_conn_recvmsg(con
->conid
, &addr
, con
->usr_data
, buf
, ret
);
262 kmem_cache_free(s
->rcvbuf_cache
, buf
);
267 if (ret
!= -EWOULDBLOCK
)
268 tipc_close_conn(con
);
270 /* Don't return success if we really got EOF */
276 static int tipc_accept_from_sock(struct tipc_conn
*con
)
278 struct tipc_server
*s
= con
->server
;
279 struct socket
*sock
= con
->sock
;
280 struct socket
*newsock
;
281 struct tipc_conn
*newcon
;
284 ret
= tipc_sock_accept_local(sock
, &newsock
, O_NONBLOCK
);
288 newcon
= tipc_alloc_conn(con
->server
);
289 if (IS_ERR(newcon
)) {
290 ret
= PTR_ERR(newcon
);
291 sock_release(newsock
);
295 newcon
->rx_action
= tipc_receive_from_sock
;
296 tipc_register_callbacks(newsock
, newcon
);
298 /* Notify that new connection is incoming */
299 newcon
->usr_data
= s
->tipc_conn_new(newcon
->conid
);
301 /* Wake up receive process in case of 'SYN+' message */
302 newsock
->sk
->sk_data_ready(newsock
->sk
, 0);
306 static struct socket
*tipc_create_listen_sock(struct tipc_conn
*con
)
308 struct tipc_server
*s
= con
->server
;
309 struct socket
*sock
= NULL
;
312 ret
= tipc_sock_create_local(s
->type
, &sock
);
315 ret
= kernel_setsockopt(sock
, SOL_TIPC
, TIPC_IMPORTANCE
,
316 (char *)&s
->imp
, sizeof(s
->imp
));
319 ret
= kernel_bind(sock
, (struct sockaddr
*)s
->saddr
, sizeof(*s
->saddr
));
326 con
->rx_action
= tipc_accept_from_sock
;
328 ret
= kernel_listen(sock
, 0);
334 con
->rx_action
= tipc_receive_from_sock
;
337 pr_err("Unknown socket type %d\n", s
->type
);
348 static int tipc_open_listening_sock(struct tipc_server
*s
)
351 struct tipc_conn
*con
;
353 con
= tipc_alloc_conn(s
);
357 sock
= tipc_create_listen_sock(con
);
359 idr_remove(&s
->conn_idr
, con
->conid
);
365 tipc_register_callbacks(sock
, con
);
369 static struct outqueue_entry
*tipc_alloc_entry(void *data
, int len
)
371 struct outqueue_entry
*entry
;
374 entry
= kmalloc(sizeof(struct outqueue_entry
), GFP_ATOMIC
);
378 buf
= kmalloc(len
, GFP_ATOMIC
);
384 memcpy(buf
, data
, len
);
385 entry
->iov
.iov_base
= buf
;
386 entry
->iov
.iov_len
= len
;
391 static void tipc_free_entry(struct outqueue_entry
*e
)
393 kfree(e
->iov
.iov_base
);
397 static void tipc_clean_outqueues(struct tipc_conn
*con
)
399 struct outqueue_entry
*e
, *safe
;
401 spin_lock_bh(&con
->outqueue_lock
);
402 list_for_each_entry_safe(e
, safe
, &con
->outqueue
, list
) {
406 spin_unlock_bh(&con
->outqueue_lock
);
409 int tipc_conn_sendmsg(struct tipc_server
*s
, int conid
,
410 struct sockaddr_tipc
*addr
, void *data
, size_t len
)
412 struct outqueue_entry
*e
;
413 struct tipc_conn
*con
;
415 con
= tipc_conn_lookup(s
, conid
);
419 e
= tipc_alloc_entry(data
, len
);
426 memcpy(&e
->dest
, addr
, sizeof(struct sockaddr_tipc
));
428 spin_lock_bh(&con
->outqueue_lock
);
429 list_add_tail(&e
->list
, &con
->outqueue
);
430 spin_unlock_bh(&con
->outqueue_lock
);
432 if (test_bit(CF_CONNECTED
, &con
->flags
))
433 if (!queue_work(s
->send_wq
, &con
->swork
))
439 void tipc_conn_terminate(struct tipc_server
*s
, int conid
)
441 struct tipc_conn
*con
;
443 con
= tipc_conn_lookup(s
, conid
);
445 tipc_close_conn(con
);
450 static void tipc_send_to_sock(struct tipc_conn
*con
)
453 struct tipc_server
*s
= con
->server
;
454 struct outqueue_entry
*e
;
458 spin_lock_bh(&con
->outqueue_lock
);
460 e
= list_entry(con
->outqueue
.next
, struct outqueue_entry
,
462 if ((struct list_head
*) e
== &con
->outqueue
)
464 spin_unlock_bh(&con
->outqueue_lock
);
466 memset(&msg
, 0, sizeof(msg
));
467 msg
.msg_flags
= MSG_DONTWAIT
;
469 if (s
->type
== SOCK_DGRAM
|| s
->type
== SOCK_RDM
) {
470 msg
.msg_name
= &e
->dest
;
471 msg
.msg_namelen
= sizeof(struct sockaddr_tipc
);
473 ret
= kernel_sendmsg(con
->sock
, &msg
, &e
->iov
, 1,
475 if (ret
== -EWOULDBLOCK
|| ret
== 0) {
478 } else if (ret
< 0) {
482 /* Don't starve users filling buffers */
483 if (++count
>= MAX_SEND_MSG_COUNT
) {
488 spin_lock_bh(&con
->outqueue_lock
);
492 spin_unlock_bh(&con
->outqueue_lock
);
497 tipc_close_conn(con
);
500 static void tipc_recv_work(struct work_struct
*work
)
502 struct tipc_conn
*con
= container_of(work
, struct tipc_conn
, rwork
);
505 while (test_bit(CF_CONNECTED
, &con
->flags
)) {
506 if (con
->rx_action(con
))
509 /* Don't flood Rx machine */
510 if (++count
>= MAX_RECV_MSG_COUNT
) {
518 static void tipc_send_work(struct work_struct
*work
)
520 struct tipc_conn
*con
= container_of(work
, struct tipc_conn
, swork
);
522 if (test_bit(CF_CONNECTED
, &con
->flags
))
523 tipc_send_to_sock(con
);
528 static void tipc_work_stop(struct tipc_server
*s
)
530 destroy_workqueue(s
->rcv_wq
);
531 destroy_workqueue(s
->send_wq
);
534 static int tipc_work_start(struct tipc_server
*s
)
536 s
->rcv_wq
= alloc_workqueue("tipc_rcv", WQ_UNBOUND
, 1);
538 pr_err("can't start tipc receive workqueue\n");
542 s
->send_wq
= alloc_workqueue("tipc_send", WQ_UNBOUND
, 1);
544 pr_err("can't start tipc send workqueue\n");
545 destroy_workqueue(s
->rcv_wq
);
552 int tipc_server_start(struct tipc_server
*s
)
556 spin_lock_init(&s
->idr_lock
);
557 idr_init(&s
->conn_idr
);
560 s
->rcvbuf_cache
= kmem_cache_create(s
->name
, s
->max_rcvbuf_size
,
561 0, SLAB_HWCACHE_ALIGN
, NULL
);
562 if (!s
->rcvbuf_cache
)
565 ret
= tipc_work_start(s
);
567 kmem_cache_destroy(s
->rcvbuf_cache
);
570 ret
= tipc_open_listening_sock(s
);
573 kmem_cache_destroy(s
->rcvbuf_cache
);
580 void tipc_server_stop(struct tipc_server
*s
)
582 struct tipc_conn
*con
;
590 spin_lock_bh(&s
->idr_lock
);
591 for (id
= 0; total
< s
->idr_in_use
; id
++) {
592 con
= idr_find(&s
->conn_idr
, id
);
595 spin_unlock_bh(&s
->idr_lock
);
596 tipc_close_conn(con
);
597 spin_lock_bh(&s
->idr_lock
);
600 spin_unlock_bh(&s
->idr_lock
);
603 kmem_cache_destroy(s
->rcvbuf_cache
);
604 idr_destroy(&s
->conn_idr
);