server.c 17 KB

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