[linux.git] / net / tipc / server.c

/*
 * net/tipc/server.c: TIPC server infrastructure
 *
 * Copyright (c) 2012-2013, Wind River Systems
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the names of the copyright holders nor the names of its
 *    contributors may be used to endorse or promote products derived from
 *    this software without specific prior written permission.
 *
 * Alternatively, this software may be distributed under the terms of the
 * GNU General Public License ("GPL") version 2 as published by the Free
 * Software Foundation.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include "server.h"
#include "core.h"
#include "socket.h"
#include "addr.h"
#include "msg.h"
#include <net/sock.h>
#include <linux/module.h>

/* Number of messages to send before rescheduling */
#define MAX_SEND_MSG_COUNT	25
#define MAX_RECV_MSG_COUNT	25
#define CF_CONNECTED		1
#define CF_SERVER		2

#define sock2con(x) ((struct tipc_conn *)(x)->sk_user_data)

/**
 * struct tipc_conn - TIPC connection structure
 * @kref: reference counter to connection object
 * @conid: connection identifier
 * @sock: socket handler associated with connection
 * @flags: indicates connection state
 * @server: pointer to connected server
 * @rwork: receive work item
 * @usr_data: user-specified field
 * @rx_action: what to do when connection socket is active
 * @outqueue: pointer to first outbound message in queue
 * @outqueue_lock: control access to the outqueue
 * @outqueue: list of connection objects for its server
 * @swork: send work item
 */
struct tipc_conn {
	struct kref kref;
	int conid;
	struct socket *sock;
	unsigned long flags;
	struct tipc_server *server;
	struct work_struct rwork;
	int (*rx_action) (struct tipc_conn *con);
	void *usr_data;
	struct list_head outqueue;
	spinlock_t outqueue_lock;
	struct work_struct swork;
};

/* An entry waiting to be sent */
struct outqueue_entry {
	struct list_head list;
	struct kvec iov;
	struct sockaddr_tipc dest;
};

static void tipc_recv_work(struct work_struct *work);
static void tipc_send_work(struct work_struct *work);
static void tipc_clean_outqueues(struct tipc_conn *con);

static void tipc_conn_kref_release(struct kref *kref)
{
	struct tipc_conn *con = container_of(kref, struct tipc_conn, kref);
	struct tipc_server *s = con->server;
	struct sockaddr_tipc *saddr = s->saddr;
	struct socket *sock = con->sock;
	struct sock *sk;

	if (sock) {
		sk = sock->sk;
		if (test_bit(CF_SERVER, &con->flags)) {
			__module_get(sock->ops->owner);
			__module_get(sk->sk_prot_creator->owner);
		}
		saddr->scope = -TIPC_NODE_SCOPE;
		kernel_bind(sock, (struct sockaddr *)saddr, sizeof(*saddr));
		sock_release(sock);
		con->sock = NULL;
	}
	spin_lock_bh(&s->idr_lock);
	idr_remove(&s->conn_idr, con->conid);
	s->idr_in_use--;
	spin_unlock_bh(&s->idr_lock);
	tipc_clean_outqueues(con);
	kfree(con);
}

static void conn_put(struct tipc_conn *con)
{
	kref_put(&con->kref, tipc_conn_kref_release);
}

static void conn_get(struct tipc_conn *con)
{
	kref_get(&con->kref);
}

static struct tipc_conn *tipc_conn_lookup(struct tipc_server *s, int conid)
{
	struct tipc_conn *con;

	spin_lock_bh(&s->idr_lock);
	con = idr_find(&s->conn_idr, conid);
	if (con) {
		if (!test_bit(CF_CONNECTED, &con->flags) ||
		    !kref_get_unless_zero(&con->kref))
			con = NULL;
	}
	spin_unlock_bh(&s->idr_lock);
	return con;
}

static void sock_data_ready(struct sock *sk)
{
	struct tipc_conn *con;

	read_lock_bh(&sk->sk_callback_lock);
	con = sock2con(sk);
	if (con && test_bit(CF_CONNECTED, &con->flags)) {
		conn_get(con);
		if (!queue_work(con->server->rcv_wq, &con->rwork))
			conn_put(con);
	}
	read_unlock_bh(&sk->sk_callback_lock);
}

static void sock_write_space(struct sock *sk)
{
	struct tipc_conn *con;

	read_lock_bh(&sk->sk_callback_lock);
	con = sock2con(sk);
	if (con && test_bit(CF_CONNECTED, &con->flags)) {
		conn_get(con);
		if (!queue_work(con->server->send_wq, &con->swork))
			conn_put(con);
	}
	read_unlock_bh(&sk->sk_callback_lock);
}

static void tipc_register_callbacks(struct socket *sock, struct tipc_conn *con)
{
	struct sock *sk = sock->sk;

	write_lock_bh(&sk->sk_callback_lock);

	sk->sk_data_ready = sock_data_ready;
	sk->sk_write_space = sock_write_space;
	sk->sk_user_data = con;

	con->sock = sock;

	write_unlock_bh(&sk->sk_callback_lock);
}

static void tipc_close_conn(struct tipc_conn *con)
{
	struct tipc_server *s = con->server;
	struct sock *sk = con->sock->sk;
	bool disconnect = false;

	write_lock_bh(&sk->sk_callback_lock);
	disconnect = test_and_clear_bit(CF_CONNECTED, &con->flags);
	if (disconnect) {
		sk->sk_user_data = NULL;
		if (con->conid)
			s->tipc_conn_release(con->conid, con->usr_data);
	}
	write_unlock_bh(&sk->sk_callback_lock);

	/* Handle concurrent calls from sending and receiving threads */
	if (!disconnect)
		return;

	/* Don't flush pending works, -just let them expire */
	kernel_sock_shutdown(con->sock, SHUT_RDWR);
	conn_put(con);
}

static struct tipc_conn *tipc_alloc_conn(struct tipc_server *s)
{
	struct tipc_conn *con;
	int ret;

	con = kzalloc(sizeof(struct tipc_conn), GFP_ATOMIC);
	if (!con)
		return ERR_PTR(-ENOMEM);

	kref_init(&con->kref);
	INIT_LIST_HEAD(&con->outqueue);
	spin_lock_init(&con->outqueue_lock);
	INIT_WORK(&con->swork, tipc_send_work);
	INIT_WORK(&con->rwork, tipc_recv_work);

	spin_lock_bh(&s->idr_lock);
	ret = idr_alloc(&s->conn_idr, con, 0, 0, GFP_ATOMIC);
	if (ret < 0) {
		kfree(con);
		spin_unlock_bh(&s->idr_lock);
		return ERR_PTR(-ENOMEM);
	}
	con->conid = ret;
	s->idr_in_use++;
	spin_unlock_bh(&s->idr_lock);

	set_bit(CF_CONNECTED, &con->flags);
	con->server = s;

	return con;
}

static int tipc_receive_from_sock(struct tipc_conn *con)
{
	struct tipc_server *s = con->server;
	struct sock *sk = con->sock->sk;
	struct sockaddr_tipc addr;
	struct msghdr msg = {};
	struct kvec iov;
	void *buf;
	int ret;

	buf = kmem_cache_alloc(s->rcvbuf_cache, GFP_ATOMIC);
	if (!buf) {
		ret = -ENOMEM;
		goto out_close;
	}

	iov.iov_base = buf;
	iov.iov_len = s->max_rcvbuf_size;
	msg.msg_name = &addr;
	iov_iter_kvec(&msg.msg_iter, READ | ITER_KVEC, &iov, 1, iov.iov_len);
	ret = sock_recvmsg(con->sock, &msg, MSG_DONTWAIT);
	if (ret <= 0) {
		kmem_cache_free(s->rcvbuf_cache, buf);
		goto out_close;
	}

	read_lock_bh(&sk->sk_callback_lock);
	if (test_bit(CF_CONNECTED, &con->flags))
		ret = s->tipc_conn_recvmsg(sock_net(con->sock->sk), con->conid,
					   &addr, con->usr_data, buf, ret);
	read_unlock_bh(&sk->sk_callback_lock);
	kmem_cache_free(s->rcvbuf_cache, buf);
	if (ret < 0)
		tipc_conn_terminate(s, con->conid);
	return ret;

out_close:
	if (ret != -EWOULDBLOCK)
		tipc_close_conn(con);
	else if (ret == 0)
		/* Don't return success if we really got EOF */
		ret = -EAGAIN;

	return ret;
}

static int tipc_accept_from_sock(struct tipc_conn *con)
{
	struct tipc_server *s = con->server;
	struct socket *sock = con->sock;
	struct socket *newsock;
	struct tipc_conn *newcon;
	int ret;

	ret = kernel_accept(sock, &newsock, O_NONBLOCK);
	if (ret < 0)
		return ret;

	newcon = tipc_alloc_conn(con->server);
	if (IS_ERR(newcon)) {
		ret = PTR_ERR(newcon);
		sock_release(newsock);
		return ret;
	}

	newcon->rx_action = tipc_receive_from_sock;
	tipc_register_callbacks(newsock, newcon);

	/* Notify that new connection is incoming */
	newcon->usr_data = s->tipc_conn_new(newcon->conid);
	if (!newcon->usr_data) {
		sock_release(newsock);
		conn_put(newcon);
		return -ENOMEM;
	}

	/* Wake up receive process in case of 'SYN+' message */
	newsock->sk->sk_data_ready(newsock->sk);
	return ret;
}

static struct socket *tipc_create_listen_sock(struct tipc_conn *con)
{
	struct tipc_server *s = con->server;
	struct socket *sock = NULL;
	int ret;

	ret = sock_create_kern(s->net, AF_TIPC, SOCK_SEQPACKET, 0, &sock);
	if (ret < 0)
		return NULL;
	ret = kernel_setsockopt(sock, SOL_TIPC, TIPC_IMPORTANCE,
				(char *)&s->imp, sizeof(s->imp));
	if (ret < 0)
		goto create_err;
	ret = kernel_bind(sock, (struct sockaddr *)s->saddr, sizeof(*s->saddr));
	if (ret < 0)
		goto create_err;

	switch (s->type) {
	case SOCK_STREAM:
	case SOCK_SEQPACKET:
		con->rx_action = tipc_accept_from_sock;

		ret = kernel_listen(sock, 0);
		if (ret < 0)
			goto create_err;
		break;
	case SOCK_DGRAM:
	case SOCK_RDM:
		con->rx_action = tipc_receive_from_sock;
		break;
	default:
		pr_err("Unknown socket type %d\n", s->type);
		goto create_err;
	}

	/* As server's listening socket owner and creator is the same module,
	 * we have to decrease TIPC module reference count to guarantee that
	 * it remains zero after the server socket is created, otherwise,
	 * executing "rmmod" command is unable to make TIPC module deleted
	 * after TIPC module is inserted successfully.
	 *
	 * However, the reference count is ever increased twice in
	 * sock_create_kern(): one is to increase the reference count of owner
	 * of TIPC socket's proto_ops struct; another is to increment the
	 * reference count of owner of TIPC proto struct. Therefore, we must
	 * decrement the module reference count twice to ensure that it keeps
	 * zero after server's listening socket is created. Of course, we
	 * must bump the module reference count twice as well before the socket
	 * is closed.
	 */
	module_put(sock->ops->owner);
	module_put(sock->sk->sk_prot_creator->owner);
	set_bit(CF_SERVER, &con->flags);

	return sock;

create_err:
	kernel_sock_shutdown(sock, SHUT_RDWR);
	sock_release(sock);
	return NULL;
}

static int tipc_open_listening_sock(struct tipc_server *s)
{
	struct socket *sock;
	struct tipc_conn *con;

	con = tipc_alloc_conn(s);
	if (IS_ERR(con))
		return PTR_ERR(con);

	sock = tipc_create_listen_sock(con);
	if (!sock) {
		idr_remove(&s->conn_idr, con->conid);
		s->idr_in_use--;
		kfree(con);
		return -EINVAL;
	}

	tipc_register_callbacks(sock, con);
	return 0;
}

static struct outqueue_entry *tipc_alloc_entry(void *data, int len)
{
	struct outqueue_entry *entry;
	void *buf;

	entry = kmalloc(sizeof(struct outqueue_entry), GFP_ATOMIC);
	if (!entry)
		return NULL;

	buf = kmemdup(data, len, GFP_ATOMIC);
	if (!buf) {
		kfree(entry);
		return NULL;
	}

	entry->iov.iov_base = buf;
	entry->iov.iov_len = len;

	return entry;
}

static void tipc_free_entry(struct outqueue_entry *e)
{
	kfree(e->iov.iov_base);
	kfree(e);
}

static void tipc_clean_outqueues(struct tipc_conn *con)
{
	struct outqueue_entry *e, *safe;

	spin_lock_bh(&con->outqueue_lock);
	list_for_each_entry_safe(e, safe, &con->outqueue, list) {
		list_del(&e->list);
		tipc_free_entry(e);
	}
	spin_unlock_bh(&con->outqueue_lock);
}

int tipc_conn_sendmsg(struct tipc_server *s, int conid,
		      struct sockaddr_tipc *addr, void *data, size_t len)
{
	struct outqueue_entry *e;
	struct tipc_conn *con;

	con = tipc_conn_lookup(s, conid);
	if (!con)
		return -EINVAL;

	if (!test_bit(CF_CONNECTED, &con->flags)) {
		conn_put(con);
		return 0;
	}

	e = tipc_alloc_entry(data, len);
	if (!e) {
		conn_put(con);
		return -ENOMEM;
	}

	if (addr)
		memcpy(&e->dest, addr, sizeof(struct sockaddr_tipc));

	spin_lock_bh(&con->outqueue_lock);
	list_add_tail(&e->list, &con->outqueue);
	spin_unlock_bh(&con->outqueue_lock);

	if (!queue_work(s->send_wq, &con->swork))
		conn_put(con);
	return 0;
}

void tipc_conn_terminate(struct tipc_server *s, int conid)
{
	struct tipc_conn *con;

	con = tipc_conn_lookup(s, conid);
	if (con) {
		tipc_close_conn(con);
		conn_put(con);
	}
}

bool tipc_topsrv_kern_subscr(struct net *net, u32 port, u32 type, u32 lower,
			     u32 upper, u32 filter, int *conid)
{
	struct tipc_subscriber *scbr;
	struct tipc_subscr sub;
	struct tipc_server *s;
	struct tipc_conn *con;

	sub.seq.type = type;
	sub.seq.lower = lower;
	sub.seq.upper = upper;
	sub.timeout = TIPC_WAIT_FOREVER;
	sub.filter = filter;
	*(u32 *)&sub.usr_handle = port;

	con = tipc_alloc_conn(tipc_topsrv(net));
	if (IS_ERR(con))
		return false;

	*conid = con->conid;
	s = con->server;
	scbr = s->tipc_conn_new(*conid);
	if (!scbr) {
		conn_put(con);
		return false;
	}

	con->usr_data = scbr;
	con->sock = NULL;
	s->tipc_conn_recvmsg(net, *conid, NULL, scbr, &sub, sizeof(sub));
	return true;
}

void tipc_topsrv_kern_unsubscr(struct net *net, int conid)
{
	struct tipc_conn *con;
	struct tipc_server *srv;

	con = tipc_conn_lookup(tipc_topsrv(net), conid);
	if (!con)
		return;

	test_and_clear_bit(CF_CONNECTED, &con->flags);
	srv = con->server;
	if (con->conid)
		srv->tipc_conn_release(con->conid, con->usr_data);
	conn_put(con);
	conn_put(con);
}

static void tipc_send_kern_top_evt(struct net *net, struct tipc_event *evt)
{
	u32 port = *(u32 *)&evt->s.usr_handle;
	u32 self = tipc_own_addr(net);
	struct sk_buff_head evtq;
	struct sk_buff *skb;

	skb = tipc_msg_create(TOP_SRV, 0, INT_H_SIZE, sizeof(*evt),
			      self, self, port, port, 0);
	if (!skb)
		return;
	msg_set_dest_droppable(buf_msg(skb), true);
	memcpy(msg_data(buf_msg(skb)), evt, sizeof(*evt));
	skb_queue_head_init(&evtq);
	__skb_queue_tail(&evtq, skb);
	tipc_sk_rcv(net, &evtq);
}

static void tipc_send_to_sock(struct tipc_conn *con)
{
	struct tipc_server *s = con->server;
	struct outqueue_entry *e;
	struct tipc_event *evt;
	struct msghdr msg;
	int count = 0;
	int ret;

	spin_lock_bh(&con->outqueue_lock);
	while (test_bit(CF_CONNECTED, &con->flags)) {
		e = list_entry(con->outqueue.next, struct outqueue_entry, list);
		if ((struct list_head *) e == &con->outqueue)
			break;

		spin_unlock_bh(&con->outqueue_lock);

		if (con->sock) {
			memset(&msg, 0, sizeof(msg));
			msg.msg_flags = MSG_DONTWAIT;
			if (s->type == SOCK_DGRAM || s->type == SOCK_RDM) {
				msg.msg_name = &e->dest;
				msg.msg_namelen = sizeof(struct sockaddr_tipc);
			}
			ret = kernel_sendmsg(con->sock, &msg, &e->iov, 1,
					     e->iov.iov_len);
			if (ret == -EWOULDBLOCK || ret == 0) {
				cond_resched();
				goto out;
			} else if (ret < 0) {
				goto send_err;
			}
		} else {
			evt = e->iov.iov_base;
			tipc_send_kern_top_evt(s->net, evt);
		}
		/* Don't starve users filling buffers */
		if (++count >= MAX_SEND_MSG_COUNT) {
			cond_resched();
			count = 0;
		}

		spin_lock_bh(&con->outqueue_lock);
		list_del(&e->list);
		tipc_free_entry(e);
	}
	spin_unlock_bh(&con->outqueue_lock);
out:
	return;

send_err:
	tipc_close_conn(con);
}

static void tipc_recv_work(struct work_struct *work)
{
	struct tipc_conn *con = container_of(work, struct tipc_conn, rwork);
	int count = 0;

	while (test_bit(CF_CONNECTED, &con->flags)) {
		if (con->rx_action(con))
			break;

		/* Don't flood Rx machine */
		if (++count >= MAX_RECV_MSG_COUNT) {
			cond_resched();
			count = 0;
		}
	}
	conn_put(con);
}

static void tipc_send_work(struct work_struct *work)
{
	struct tipc_conn *con = container_of(work, struct tipc_conn, swork);

	if (test_bit(CF_CONNECTED, &con->flags))
		tipc_send_to_sock(con);

	conn_put(con);
}

static void tipc_work_stop(struct tipc_server *s)
{
	destroy_workqueue(s->rcv_wq);
	destroy_workqueue(s->send_wq);
}

static int tipc_work_start(struct tipc_server *s)
{
	s->rcv_wq = alloc_ordered_workqueue("tipc_rcv", 0);
	if (!s->rcv_wq) {
		pr_err("can't start tipc receive workqueue\n");
		return -ENOMEM;
	}

	s->send_wq = alloc_ordered_workqueue("tipc_send", 0);
	if (!s->send_wq) {
		pr_err("can't start tipc send workqueue\n");
		destroy_workqueue(s->rcv_wq);
		return -ENOMEM;
	}

	return 0;
}

int tipc_server_start(struct tipc_server *s)
{
	int ret;

	spin_lock_init(&s->idr_lock);
	idr_init(&s->conn_idr);
	s->idr_in_use = 0;

	s->rcvbuf_cache = kmem_cache_create(s->name, s->max_rcvbuf_size,
					    0, SLAB_HWCACHE_ALIGN, NULL);
	if (!s->rcvbuf_cache)
		return -ENOMEM;

	ret = tipc_work_start(s);
	if (ret < 0) {
		kmem_cache_destroy(s->rcvbuf_cache);
		return ret;
	}
	ret = tipc_open_listening_sock(s);
	if (ret < 0) {
		tipc_work_stop(s);
		kmem_cache_destroy(s->rcvbuf_cache);
		return ret;
	}
	return ret;
}

void tipc_server_stop(struct tipc_server *s)
{
	struct tipc_conn *con;
	int id;

	spin_lock_bh(&s->idr_lock);
	for (id = 0; s->idr_in_use; id++) {
		con = idr_find(&s->conn_idr, id);
		if (con) {
			spin_unlock_bh(&s->idr_lock);
			tipc_close_conn(con);
			spin_lock_bh(&s->idr_lock);
		}
	}
	spin_unlock_bh(&s->idr_lock);

	tipc_work_stop(s);
	kmem_cache_destroy(s->rcvbuf_cache);
	idr_destroy(&s->conn_idr);
}
Commit	Line	Data
c5fa7b3c YX	1	/*
	2	* net/tipc/server.c: TIPC server infrastructure
	3	*
	4	* Copyright (c) 2012-2013, Wind River Systems
	5	* All rights reserved.
	6	*
	7	* Redistribution and use in source and binary forms, with or without
	8	* modification, are permitted provided that the following conditions are met:
	9	*
	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.
	18	*
	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.
	22	*
	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.
	34	*/
	35
	36	#include "server.h"
	37	#include "core.h"
859fc7c0	38	#include "socket.h"
14c04493 JM	39	#include "addr.h"
14c04493 JM	40	#include "msg.h"
c5fa7b3c	41	#include <net/sock.h>
76100a8a	42	#include <linux/module.h>
c5fa7b3c YX	43
	44	/* Number of messages to send before rescheduling */
	45	#define MAX_SEND_MSG_COUNT 25
	46	#define MAX_RECV_MSG_COUNT 25
	47	#define CF_CONNECTED 1
76100a8a	48	#define CF_SERVER 2
c5fa7b3c YX	49
	50	#define sock2con(x) ((struct tipc_conn *)(x)->sk_user_data)
	51
	52	/**
	53	* struct tipc_conn - TIPC connection structure
	54	* @kref: reference counter to connection object
	55	* @conid: connection identifier
	56	* @sock: socket handler associated with connection
	57	* @flags: indicates connection state
	58	* @server: pointer to connected server
	59	* @rwork: receive work item
	60	* @usr_data: user-specified field
	61	* @rx_action: what to do when connection socket is active
	62	* @outqueue: pointer to first outbound message in queue
963a1855	63	* @outqueue_lock: control access to the outqueue
c5fa7b3c YX	64	* @outqueue: list of connection objects for its server
	65	* @swork: send work item
	66	*/
	67	struct tipc_conn {
	68	struct kref kref;
	69	int conid;
	70	struct socket *sock;
	71	unsigned long flags;
	72	struct tipc_server *server;
	73	struct work_struct rwork;
	74	int (rx_action) (struct tipc_conn con);
	75	void *usr_data;
	76	struct list_head outqueue;
	77	spinlock_t outqueue_lock;
	78	struct work_struct swork;
	79	};
	80
	81	/* An entry waiting to be sent */
	82	struct outqueue_entry {
	83	struct list_head list;
	84	struct kvec iov;
	85	struct sockaddr_tipc dest;
	86	};
	87
	88	static void tipc_recv_work(struct work_struct *work);
	89	static void tipc_send_work(struct work_struct *work);
	90	static void tipc_clean_outqueues(struct tipc_conn *con);
	91
	92	static void tipc_conn_kref_release(struct kref *kref)
	93	{
	94	struct tipc_conn *con = container_of(kref, struct tipc_conn, kref);
fc0adfc8 PB	95	struct tipc_server *s = con->server;
fc0adfc8 PB	96	struct sockaddr_tipc *saddr = s->saddr;
76100a8a YX	97	struct socket *sock = con->sock;
	98	struct sock *sk;
	99
	100	if (sock) {
	101	sk = sock->sk;
	102	if (test_bit(CF_SERVER, &con->flags)) {
	103	__module_get(sock->ops->owner);
	104	__module_get(sk->sk_prot_creator->owner);
	105	}
2b9bb7f3 YX	106	saddr->scope = -TIPC_NODE_SCOPE;
2b9bb7f3 YX	107	kernel_bind(sock, (struct sockaddr )saddr, sizeof(saddr));
def81f69	108	sock_release(sock);
c5fa7b3c YX	109	con->sock = NULL;
c5fa7b3c YX	110	}
14c04493 JM	111	spin_lock_bh(&s->idr_lock);
	112	idr_remove(&s->conn_idr, con->conid);
	113	s->idr_in_use--;
	114	spin_unlock_bh(&s->idr_lock);
c5fa7b3c	115	tipc_clean_outqueues(con);
c5fa7b3c YX	116	kfree(con);
	117	}
	118
	119	static void conn_put(struct tipc_conn *con)
	120	{
	121	kref_put(&con->kref, tipc_conn_kref_release);
	122	}
	123
	124	static void conn_get(struct tipc_conn *con)
	125	{
	126	kref_get(&con->kref);
	127	}
	128
	129	static struct tipc_conn tipc_conn_lookup(struct tipc_server s, int conid)
	130	{
	131	struct tipc_conn *con;
	132
	133	spin_lock_bh(&s->idr_lock);
	134	con = idr_find(&s->conn_idr, conid);
e88f2be8 JM	135	if (con) {
	136	if (!test_bit(CF_CONNECTED, &con->flags) \|\|
	137	!kref_get_unless_zero(&con->kref))
	138	con = NULL;
	139	}
c5fa7b3c YX	140	spin_unlock_bh(&s->idr_lock);
	141	return con;
	142	}
	143
676d2369	144	static void sock_data_ready(struct sock *sk)
c5fa7b3c YX	145	{
	146	struct tipc_conn *con;
	147
b91083a4	148	read_lock_bh(&sk->sk_callback_lock);
c5fa7b3c YX	149	con = sock2con(sk);
	150	if (con && test_bit(CF_CONNECTED, &con->flags)) {
	151	conn_get(con);
	152	if (!queue_work(con->server->rcv_wq, &con->rwork))
	153	conn_put(con);
	154	}
b91083a4	155	read_unlock_bh(&sk->sk_callback_lock);
c5fa7b3c YX	156	}
	157
	158	static void sock_write_space(struct sock *sk)
	159	{
	160	struct tipc_conn *con;
	161
b91083a4	162	read_lock_bh(&sk->sk_callback_lock);
c5fa7b3c YX	163	con = sock2con(sk);
	164	if (con && test_bit(CF_CONNECTED, &con->flags)) {
	165	conn_get(con);
	166	if (!queue_work(con->server->send_wq, &con->swork))
	167	conn_put(con);
	168	}
b91083a4	169	read_unlock_bh(&sk->sk_callback_lock);
c5fa7b3c YX	170	}
	171
	172	static void tipc_register_callbacks(struct socket sock, struct tipc_conn con)
	173	{
	174	struct sock *sk = sock->sk;
	175
	176	write_lock_bh(&sk->sk_callback_lock);
	177
	178	sk->sk_data_ready = sock_data_ready;
	179	sk->sk_write_space = sock_write_space;
	180	sk->sk_user_data = con;
	181
	182	con->sock = sock;
	183
	184	write_unlock_bh(&sk->sk_callback_lock);
	185	}
	186
9dc3abdd	187	static void tipc_close_conn(struct tipc_conn *con)
333f7962 PB	188	{
333f7962 PB	189	struct tipc_server *s = con->server;
e88f2be8 JM	190	struct sock *sk = con->sock->sk;
e88f2be8 JM	191	bool disconnect = false;
333f7962	192
e88f2be8 JM	193	write_lock_bh(&sk->sk_callback_lock);
	194	disconnect = test_and_clear_bit(CF_CONNECTED, &con->flags);
	195	if (disconnect) {
	196	sk->sk_user_data = NULL;
9dc3abdd PB	197	if (con->conid)
9dc3abdd PB	198	s->tipc_conn_release(con->conid, con->usr_data);
c5fa7b3c	199	}
e88f2be8 JM	200	write_unlock_bh(&sk->sk_callback_lock);
	201
	202	/* Handle concurrent calls from sending and receiving threads */
	203	if (!disconnect)
	204	return;
	205
	206	/* Don't flush pending works, -just let them expire */
	207	kernel_sock_shutdown(con->sock, SHUT_RDWR);
	208	conn_put(con);
c5fa7b3c YX	209	}
	210
	211	static struct tipc_conn tipc_alloc_conn(struct tipc_server s)
	212	{
	213	struct tipc_conn *con;
	214	int ret;
	215
	216	con = kzalloc(sizeof(struct tipc_conn), GFP_ATOMIC);
	217	if (!con)
	218	return ERR_PTR(-ENOMEM);
	219
	220	kref_init(&con->kref);
	221	INIT_LIST_HEAD(&con->outqueue);
	222	spin_lock_init(&con->outqueue_lock);
	223	INIT_WORK(&con->swork, tipc_send_work);
	224	INIT_WORK(&con->rwork, tipc_recv_work);
	225
	226	spin_lock_bh(&s->idr_lock);
	227	ret = idr_alloc(&s->conn_idr, con, 0, 0, GFP_ATOMIC);
	228	if (ret < 0) {
	229	kfree(con);
	230	spin_unlock_bh(&s->idr_lock);
	231	return ERR_PTR(-ENOMEM);
	232	}
	233	con->conid = ret;
	234	s->idr_in_use++;
	235	spin_unlock_bh(&s->idr_lock);
	236
	237	set_bit(CF_CONNECTED, &con->flags);
	238	con->server = s;
	239
	240	return con;
	241	}
	242
	243	static int tipc_receive_from_sock(struct tipc_conn *con)
	244	{
c5fa7b3c	245	struct tipc_server *s = con->server;
e88f2be8	246	struct sock *sk = con->sock->sk;
c5fa7b3c	247	struct sockaddr_tipc addr;
e88f2be8	248	struct msghdr msg = {};
c5fa7b3c YX	249	struct kvec iov;
	250	void *buf;
	251	int ret;
	252
	253	buf = kmem_cache_alloc(s->rcvbuf_cache, GFP_ATOMIC);
	254	if (!buf) {
	255	ret = -ENOMEM;
	256	goto out_close;
	257	}
	258
	259	iov.iov_base = buf;
	260	iov.iov_len = s->max_rcvbuf_size;
	261	msg.msg_name = &addr;
bc480273 AV	262	iov_iter_kvec(&msg.msg_iter, READ \| ITER_KVEC, &iov, 1, iov.iov_len);
bc480273 AV	263	ret = sock_recvmsg(con->sock, &msg, MSG_DONTWAIT);
c5fa7b3c YX	264	if (ret <= 0) {
	265	kmem_cache_free(s->rcvbuf_cache, buf);
	266	goto out_close;
	267	}
	268
e88f2be8 JM	269	read_lock_bh(&sk->sk_callback_lock);
	270	if (test_bit(CF_CONNECTED, &con->flags))
	271	ret = s->tipc_conn_recvmsg(sock_net(con->sock->sk), con->conid,
	272	&addr, con->usr_data, buf, ret);
	273	read_unlock_bh(&sk->sk_callback_lock);
c5fa7b3c	274	kmem_cache_free(s->rcvbuf_cache, buf);
e88f2be8 JM	275	if (ret < 0)
	276	tipc_conn_terminate(s, con->conid);
	277	return ret;
c5fa7b3c YX	278
	279	out_close:
	280	if (ret != -EWOULDBLOCK)
	281	tipc_close_conn(con);
	282	else if (ret == 0)
	283	/* Don't return success if we really got EOF */
	284	ret = -EAGAIN;
	285
	286	return ret;
	287	}
	288
	289	static int tipc_accept_from_sock(struct tipc_conn *con)
	290	{
	291	struct tipc_server *s = con->server;
	292	struct socket *sock = con->sock;
	293	struct socket *newsock;
	294	struct tipc_conn *newcon;
	295	int ret;
	296
76100a8a	297	ret = kernel_accept(sock, &newsock, O_NONBLOCK);
c5fa7b3c YX	298	if (ret < 0)
	299	return ret;
	300
	301	newcon = tipc_alloc_conn(con->server);
	302	if (IS_ERR(newcon)) {
	303	ret = PTR_ERR(newcon);
	304	sock_release(newsock);
	305	return ret;
	306	}
	307
	308	newcon->rx_action = tipc_receive_from_sock;
	309	tipc_register_callbacks(newsock, newcon);
	310
	311	/* Notify that new connection is incoming */
	312	newcon->usr_data = s->tipc_conn_new(newcon->conid);
90bdfcb7 YX	313	if (!newcon->usr_data) {
90bdfcb7 YX	314	sock_release(newsock);
a7d5f107	315	conn_put(newcon);
90bdfcb7 YX	316	return -ENOMEM;
90bdfcb7 YX	317	}
c5fa7b3c YX	318
c5fa7b3c YX	319	/* Wake up receive process in case of 'SYN+' message */
676d2369	320	newsock->sk->sk_data_ready(newsock->sk);
c5fa7b3c YX	321	return ret;
	322	}
	323
	324	static struct socket tipc_create_listen_sock(struct tipc_conn con)
	325	{
	326	struct tipc_server *s = con->server;
	327	struct socket *sock = NULL;
	328	int ret;
	329
fa787ae0	330	ret = sock_create_kern(s->net, AF_TIPC, SOCK_SEQPACKET, 0, &sock);
c5fa7b3c YX	331	if (ret < 0)
	332	return NULL;
	333	ret = kernel_setsockopt(sock, SOL_TIPC, TIPC_IMPORTANCE,
	334	(char *)&s->imp, sizeof(s->imp));
	335	if (ret < 0)
	336	goto create_err;
	337	ret = kernel_bind(sock, (struct sockaddr )s->saddr, sizeof(s->saddr));
	338	if (ret < 0)
	339	goto create_err;
	340
	341	switch (s->type) {
	342	case SOCK_STREAM:
	343	case SOCK_SEQPACKET:
	344	con->rx_action = tipc_accept_from_sock;
	345
	346	ret = kernel_listen(sock, 0);
	347	if (ret < 0)
	348	goto create_err;
	349	break;
	350	case SOCK_DGRAM:
	351	case SOCK_RDM:
	352	con->rx_action = tipc_receive_from_sock;
	353	break;
	354	default:
	355	pr_err("Unknown socket type %d\n", s->type);
	356	goto create_err;
	357	}
76100a8a YX	358
	359	/* As server's listening socket owner and creator is the same module,
	360	* we have to decrease TIPC module reference count to guarantee that
	361	* it remains zero after the server socket is created, otherwise,
	362	* executing "rmmod" command is unable to make TIPC module deleted
	363	* after TIPC module is inserted successfully.
	364	*
	365	* However, the reference count is ever increased twice in
	366	* sock_create_kern(): one is to increase the reference count of owner
	367	* of TIPC socket's proto_ops struct; another is to increment the
	368	* reference count of owner of TIPC proto struct. Therefore, we must
	369	* decrement the module reference count twice to ensure that it keeps
	370	* zero after server's listening socket is created. Of course, we
	371	* must bump the module reference count twice as well before the socket
	372	* is closed.
	373	*/
	374	module_put(sock->ops->owner);
	375	module_put(sock->sk->sk_prot_creator->owner);
	376	set_bit(CF_SERVER, &con->flags);
	377
c5fa7b3c YX	378	return sock;
	379
	380	create_err:
76100a8a	381	kernel_sock_shutdown(sock, SHUT_RDWR);
def81f69	382	sock_release(sock);
c5fa7b3c YX	383	return NULL;
	384	}
	385
	386	static int tipc_open_listening_sock(struct tipc_server *s)
	387	{
	388	struct socket *sock;
	389	struct tipc_conn *con;
	390
	391	con = tipc_alloc_conn(s);
	392	if (IS_ERR(con))
	393	return PTR_ERR(con);
	394
	395	sock = tipc_create_listen_sock(con);
c756891a YX	396	if (!sock) {
	397	idr_remove(&s->conn_idr, con->conid);
	398	s->idr_in_use--;
	399	kfree(con);
c5fa7b3c	400	return -EINVAL;
c756891a	401	}
c5fa7b3c YX	402
	403	tipc_register_callbacks(sock, con);
	404	return 0;
	405	}
	406
	407	static struct outqueue_entry tipc_alloc_entry(void data, int len)
	408	{
	409	struct outqueue_entry *entry;
	410	void *buf;
	411
	412	entry = kmalloc(sizeof(struct outqueue_entry), GFP_ATOMIC);
	413	if (!entry)
	414	return NULL;
	415
810bf110	416	buf = kmemdup(data, len, GFP_ATOMIC);
c5fa7b3c YX	417	if (!buf) {
	418	kfree(entry);
	419	return NULL;
	420	}
	421
c5fa7b3c YX	422	entry->iov.iov_base = buf;
	423	entry->iov.iov_len = len;
	424
	425	return entry;
	426	}
	427
	428	static void tipc_free_entry(struct outqueue_entry *e)
	429	{
	430	kfree(e->iov.iov_base);
	431	kfree(e);
	432	}
	433
	434	static void tipc_clean_outqueues(struct tipc_conn *con)
	435	{
	436	struct outqueue_entry e, safe;
	437
	438	spin_lock_bh(&con->outqueue_lock);
	439	list_for_each_entry_safe(e, safe, &con->outqueue, list) {
	440	list_del(&e->list);
	441	tipc_free_entry(e);
	442	}
	443	spin_unlock_bh(&con->outqueue_lock);
	444	}
	445
	446	int tipc_conn_sendmsg(struct tipc_server *s, int conid,
	447	struct sockaddr_tipc addr, void data, size_t len)
	448	{
	449	struct outqueue_entry *e;
	450	struct tipc_conn *con;
	451
	452	con = tipc_conn_lookup(s, conid);
	453	if (!con)
	454	return -EINVAL;
	455
4c887aa6 PB	456	if (!test_bit(CF_CONNECTED, &con->flags)) {
	457	conn_put(con);
	458	return 0;
	459	}
	460
c5fa7b3c YX	461	e = tipc_alloc_entry(data, len);
	462	if (!e) {
	463	conn_put(con);
	464	return -ENOMEM;
	465	}
	466
	467	if (addr)
	468	memcpy(&e->dest, addr, sizeof(struct sockaddr_tipc));
	469
	470	spin_lock_bh(&con->outqueue_lock);
	471	list_add_tail(&e->list, &con->outqueue);
	472	spin_unlock_bh(&con->outqueue_lock);
	473
4c887aa6	474	if (!queue_work(s->send_wq, &con->swork))
4652edb7	475	conn_put(con);
c5fa7b3c YX	476	return 0;
	477	}
	478
	479	void tipc_conn_terminate(struct tipc_server *s, int conid)
	480	{
	481	struct tipc_conn *con;
	482
	483	con = tipc_conn_lookup(s, conid);
	484	if (con) {
	485	tipc_close_conn(con);
	486	conn_put(con);
	487	}
	488	}
	489
232d07b7 JM	490	bool tipc_topsrv_kern_subscr(struct net *net, u32 port, u32 type, u32 lower,
232d07b7 JM	491	u32 upper, u32 filter, int *conid)
14c04493 JM	492	{
	493	struct tipc_subscriber *scbr;
	494	struct tipc_subscr sub;
	495	struct tipc_server *s;
	496	struct tipc_conn *con;
	497
	498	sub.seq.type = type;
	499	sub.seq.lower = lower;
	500	sub.seq.upper = upper;
	501	sub.timeout = TIPC_WAIT_FOREVER;
8348500f	502	sub.filter = filter;
14c04493 JM	503	(u32 )&sub.usr_handle = port;
	504
	505	con = tipc_alloc_conn(tipc_topsrv(net));
c75e427d	506	if (IS_ERR(con))
14c04493 JM	507	return false;
	508
	509	*conid = con->conid;
	510	s = con->server;
	511	scbr = s->tipc_conn_new(*conid);
	512	if (!scbr) {
672ecbe1	513	conn_put(con);
14c04493 JM	514	return false;
	515	}
	516
	517	con->usr_data = scbr;
	518	con->sock = NULL;
	519	s->tipc_conn_recvmsg(net, *conid, NULL, scbr, &sub, sizeof(sub));
	520	return true;
	521	}
	522
	523	void tipc_topsrv_kern_unsubscr(struct net *net, int conid)
	524	{
	525	struct tipc_conn *con;
e88f2be8	526	struct tipc_server *srv;
14c04493 JM	527
	528	con = tipc_conn_lookup(tipc_topsrv(net), conid);
	529	if (!con)
	530	return;
e88f2be8 JM	531
	532	test_and_clear_bit(CF_CONNECTED, &con->flags);
	533	srv = con->server;
	534	if (con->conid)
	535	srv->tipc_conn_release(con->conid, con->usr_data);
	536	conn_put(con);
14c04493 JM	537	conn_put(con);
	538	}
	539
	540	static void tipc_send_kern_top_evt(struct net net, struct tipc_event evt)
	541	{
	542	u32 port = (u32 )&evt->s.usr_handle;
	543	u32 self = tipc_own_addr(net);
	544	struct sk_buff_head evtq;
	545	struct sk_buff *skb;
	546
	547	skb = tipc_msg_create(TOP_SRV, 0, INT_H_SIZE, sizeof(*evt),
	548	self, self, port, port, 0);
	549	if (!skb)
	550	return;
	551	msg_set_dest_droppable(buf_msg(skb), true);
	552	memcpy(msg_data(buf_msg(skb)), evt, sizeof(*evt));
	553	skb_queue_head_init(&evtq);
	554	__skb_queue_tail(&evtq, skb);
	555	tipc_sk_rcv(net, &evtq);
	556	}
	557
c5fa7b3c YX	558	static void tipc_send_to_sock(struct tipc_conn *con)
c5fa7b3c YX	559	{
c5fa7b3c YX	560	struct tipc_server *s = con->server;
c5fa7b3c YX	561	struct outqueue_entry *e;
14c04493	562	struct tipc_event *evt;
c5fa7b3c	563	struct msghdr msg;
14c04493	564	int count = 0;
c5fa7b3c YX	565	int ret;
	566
	567	spin_lock_bh(&con->outqueue_lock);
4c887aa6	568	while (test_bit(CF_CONNECTED, &con->flags)) {
14c04493	569	e = list_entry(con->outqueue.next, struct outqueue_entry, list);
c5fa7b3c YX	570	if ((struct list_head *) e == &con->outqueue)
c5fa7b3c YX	571	break;
c5fa7b3c	572
14c04493	573	spin_unlock_bh(&con->outqueue_lock);
c5fa7b3c	574
14c04493 JM	575	if (con->sock) {
	576	memset(&msg, 0, sizeof(msg));
	577	msg.msg_flags = MSG_DONTWAIT;
	578	if (s->type == SOCK_DGRAM \|\| s->type == SOCK_RDM) {
	579	msg.msg_name = &e->dest;
	580	msg.msg_namelen = sizeof(struct sockaddr_tipc);
	581	}
	582	ret = kernel_sendmsg(con->sock, &msg, &e->iov, 1,
	583	e->iov.iov_len);
	584	if (ret == -EWOULDBLOCK \|\| ret == 0) {
	585	cond_resched();
	586	goto out;
	587	} else if (ret < 0) {
	588	goto send_err;
	589	}
	590	} else {
	591	evt = e->iov.iov_base;
	592	tipc_send_kern_top_evt(s->net, evt);
c5fa7b3c	593	}
c5fa7b3c YX	594	/* Don't starve users filling buffers */
	595	if (++count >= MAX_SEND_MSG_COUNT) {
	596	cond_resched();
	597	count = 0;
	598	}
	599
	600	spin_lock_bh(&con->outqueue_lock);
	601	list_del(&e->list);
	602	tipc_free_entry(e);
	603	}
	604	spin_unlock_bh(&con->outqueue_lock);
	605	out:
	606	return;
	607
	608	send_err:
	609	tipc_close_conn(con);
	610	}
	611
	612	static void tipc_recv_work(struct work_struct *work)
	613	{
	614	struct tipc_conn *con = container_of(work, struct tipc_conn, rwork);
	615	int count = 0;
	616
	617	while (test_bit(CF_CONNECTED, &con->flags)) {
	618	if (con->rx_action(con))
	619	break;
	620
	621	/* Don't flood Rx machine */
	622	if (++count >= MAX_RECV_MSG_COUNT) {
	623	cond_resched();
	624	count = 0;
	625	}
	626	}
	627	conn_put(con);
	628	}
	629
	630	static void tipc_send_work(struct work_struct *work)
	631	{
	632	struct tipc_conn *con = container_of(work, struct tipc_conn, swork);
	633
	634	if (test_bit(CF_CONNECTED, &con->flags))
	635	tipc_send_to_sock(con);
	636
	637	conn_put(con);
	638	}
	639
	640	static void tipc_work_stop(struct tipc_server *s)
	641	{
	642	destroy_workqueue(s->rcv_wq);
	643	destroy_workqueue(s->send_wq);
	644	}
	645
	646	static int tipc_work_start(struct tipc_server *s)
	647	{
06c8581f	648	s->rcv_wq = alloc_ordered_workqueue("tipc_rcv", 0);
c5fa7b3c YX	649	if (!s->rcv_wq) {
	650	pr_err("can't start tipc receive workqueue\n");
	651	return -ENOMEM;
	652	}
	653
06c8581f	654	s->send_wq = alloc_ordered_workqueue("tipc_send", 0);
c5fa7b3c YX	655	if (!s->send_wq) {
	656	pr_err("can't start tipc send workqueue\n");
	657	destroy_workqueue(s->rcv_wq);
	658	return -ENOMEM;
	659	}
	660
	661	return 0;
	662	}
	663
	664	int tipc_server_start(struct tipc_server *s)
	665	{
	666	int ret;
	667
	668	spin_lock_init(&s->idr_lock);
	669	idr_init(&s->conn_idr);
	670	s->idr_in_use = 0;
	671
	672	s->rcvbuf_cache = kmem_cache_create(s->name, s->max_rcvbuf_size,
	673	0, SLAB_HWCACHE_ALIGN, NULL);
	674	if (!s->rcvbuf_cache)
	675	return -ENOMEM;
	676
	677	ret = tipc_work_start(s);
	678	if (ret < 0) {
	679	kmem_cache_destroy(s->rcvbuf_cache);
	680	return ret;
	681	}
c756891a YX	682	ret = tipc_open_listening_sock(s);
	683	if (ret < 0) {
	684	tipc_work_stop(s);
	685	kmem_cache_destroy(s->rcvbuf_cache);
	686	return ret;
	687	}
c756891a	688	return ret;
c5fa7b3c YX	689	}
	690
	691	void tipc_server_stop(struct tipc_server *s)
	692	{
	693	struct tipc_conn *con;
c5fa7b3c YX	694	int id;
c5fa7b3c YX	695
c5fa7b3c	696	spin_lock_bh(&s->idr_lock);
35e22e49	697	for (id = 0; s->idr_in_use; id++) {
c5fa7b3c YX	698	con = idr_find(&s->conn_idr, id);
c5fa7b3c YX	699	if (con) {
c5fa7b3c YX	700	spin_unlock_bh(&s->idr_lock);
	701	tipc_close_conn(con);
	702	spin_lock_bh(&s->idr_lock);
	703	}
	704	}
	705	spin_unlock_bh(&s->idr_lock);
	706
	707	tipc_work_stop(s);
	708	kmem_cache_destroy(s->rcvbuf_cache);
	709	idr_destroy(&s->conn_idr);
	710	}