tcp_listen.c 6.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247
  1. /*
  2. * Copyright (c) 2006 Oracle. All rights reserved.
  3. *
  4. * This software is available to you under a choice of one of two
  5. * licenses. You may choose to be licensed under the terms of the GNU
  6. * General Public License (GPL) Version 2, available from the file
  7. * COPYING in the main directory of this source tree, or the
  8. * OpenIB.org BSD license below:
  9. *
  10. * Redistribution and use in source and binary forms, with or
  11. * without modification, are permitted provided that the following
  12. * conditions are met:
  13. *
  14. * - Redistributions of source code must retain the above
  15. * copyright notice, this list of conditions and the following
  16. * disclaimer.
  17. *
  18. * - Redistributions in binary form must reproduce the above
  19. * copyright notice, this list of conditions and the following
  20. * disclaimer in the documentation and/or other materials
  21. * provided with the distribution.
  22. *
  23. * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  24. * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  25. * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  26. * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  27. * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  28. * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  29. * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  30. * SOFTWARE.
  31. *
  32. */
  33. #include <linux/kernel.h>
  34. #include <linux/gfp.h>
  35. #include <linux/in.h>
  36. #include <net/tcp.h>
  37. #include "rds.h"
  38. #include "tcp.h"
  39. /*
  40. * cheesy, but simple..
  41. */
  42. static void rds_tcp_accept_worker(struct work_struct *work);
  43. static DECLARE_WORK(rds_tcp_listen_work, rds_tcp_accept_worker);
  44. static struct socket *rds_tcp_listen_sock;
  45. static int rds_tcp_keepalive(struct socket *sock)
  46. {
  47. /* values below based on xs_udp_default_timeout */
  48. int keepidle = 5; /* send a probe 'keepidle' secs after last data */
  49. int keepcnt = 5; /* number of unack'ed probes before declaring dead */
  50. int keepalive = 1;
  51. int ret = 0;
  52. ret = kernel_setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE,
  53. (char *)&keepalive, sizeof(keepalive));
  54. if (ret < 0)
  55. goto bail;
  56. ret = kernel_setsockopt(sock, IPPROTO_TCP, TCP_KEEPCNT,
  57. (char *)&keepcnt, sizeof(keepcnt));
  58. if (ret < 0)
  59. goto bail;
  60. ret = kernel_setsockopt(sock, IPPROTO_TCP, TCP_KEEPIDLE,
  61. (char *)&keepidle, sizeof(keepidle));
  62. if (ret < 0)
  63. goto bail;
  64. /* KEEPINTVL is the interval between successive probes. We follow
  65. * the model in xs_tcp_finish_connecting() and re-use keepidle.
  66. */
  67. ret = kernel_setsockopt(sock, IPPROTO_TCP, TCP_KEEPINTVL,
  68. (char *)&keepidle, sizeof(keepidle));
  69. bail:
  70. return ret;
  71. }
  72. static int rds_tcp_accept_one(struct socket *sock)
  73. {
  74. struct socket *new_sock = NULL;
  75. struct rds_connection *conn;
  76. int ret;
  77. struct inet_sock *inet;
  78. struct rds_tcp_connection *rs_tcp;
  79. ret = sock_create_lite(sock->sk->sk_family, sock->sk->sk_type,
  80. sock->sk->sk_protocol, &new_sock);
  81. if (ret)
  82. goto out;
  83. new_sock->type = sock->type;
  84. new_sock->ops = sock->ops;
  85. ret = sock->ops->accept(sock, new_sock, O_NONBLOCK);
  86. if (ret < 0)
  87. goto out;
  88. ret = rds_tcp_keepalive(new_sock);
  89. if (ret < 0)
  90. goto out;
  91. rds_tcp_tune(new_sock);
  92. inet = inet_sk(new_sock->sk);
  93. rdsdebug("accepted tcp %pI4:%u -> %pI4:%u\n",
  94. &inet->inet_saddr, ntohs(inet->inet_sport),
  95. &inet->inet_daddr, ntohs(inet->inet_dport));
  96. conn = rds_conn_create(inet->inet_saddr, inet->inet_daddr,
  97. &rds_tcp_transport, GFP_KERNEL);
  98. if (IS_ERR(conn)) {
  99. ret = PTR_ERR(conn);
  100. goto out;
  101. }
  102. /* An incoming SYN request came in, and TCP just accepted it.
  103. * We always create a new conn for listen side of TCP, and do not
  104. * add it to the c_hash_list.
  105. *
  106. * If the client reboots, this conn will need to be cleaned up.
  107. * rds_tcp_state_change() will do that cleanup
  108. */
  109. rs_tcp = (struct rds_tcp_connection *)conn->c_transport_data;
  110. WARN_ON(!rs_tcp || rs_tcp->t_sock);
  111. /*
  112. * see the comment above rds_queue_delayed_reconnect()
  113. */
  114. if (!rds_conn_transition(conn, RDS_CONN_DOWN, RDS_CONN_CONNECTING)) {
  115. if (rds_conn_state(conn) == RDS_CONN_UP)
  116. rds_tcp_stats_inc(s_tcp_listen_closed_stale);
  117. else
  118. rds_tcp_stats_inc(s_tcp_connect_raced);
  119. rds_conn_drop(conn);
  120. ret = 0;
  121. goto out;
  122. }
  123. rds_tcp_set_callbacks(new_sock, conn);
  124. rds_connect_complete(conn);
  125. new_sock = NULL;
  126. ret = 0;
  127. out:
  128. if (new_sock)
  129. sock_release(new_sock);
  130. return ret;
  131. }
  132. static void rds_tcp_accept_worker(struct work_struct *work)
  133. {
  134. while (rds_tcp_accept_one(rds_tcp_listen_sock) == 0)
  135. cond_resched();
  136. }
  137. void rds_tcp_listen_data_ready(struct sock *sk)
  138. {
  139. void (*ready)(struct sock *sk);
  140. rdsdebug("listen data ready sk %p\n", sk);
  141. read_lock(&sk->sk_callback_lock);
  142. ready = sk->sk_user_data;
  143. if (!ready) { /* check for teardown race */
  144. ready = sk->sk_data_ready;
  145. goto out;
  146. }
  147. /*
  148. * ->sk_data_ready is also called for a newly established child socket
  149. * before it has been accepted and the accepter has set up their
  150. * data_ready.. we only want to queue listen work for our listening
  151. * socket
  152. */
  153. if (sk->sk_state == TCP_LISTEN)
  154. queue_work(rds_wq, &rds_tcp_listen_work);
  155. out:
  156. read_unlock(&sk->sk_callback_lock);
  157. ready(sk);
  158. }
  159. int rds_tcp_listen_init(void)
  160. {
  161. struct sockaddr_in sin;
  162. struct socket *sock = NULL;
  163. int ret;
  164. ret = sock_create(PF_INET, SOCK_STREAM, IPPROTO_TCP, &sock);
  165. if (ret < 0)
  166. goto out;
  167. sock->sk->sk_reuse = SK_CAN_REUSE;
  168. rds_tcp_nonagle(sock);
  169. write_lock_bh(&sock->sk->sk_callback_lock);
  170. sock->sk->sk_user_data = sock->sk->sk_data_ready;
  171. sock->sk->sk_data_ready = rds_tcp_listen_data_ready;
  172. write_unlock_bh(&sock->sk->sk_callback_lock);
  173. sin.sin_family = PF_INET;
  174. sin.sin_addr.s_addr = (__force u32)htonl(INADDR_ANY);
  175. sin.sin_port = (__force u16)htons(RDS_TCP_PORT);
  176. ret = sock->ops->bind(sock, (struct sockaddr *)&sin, sizeof(sin));
  177. if (ret < 0)
  178. goto out;
  179. ret = sock->ops->listen(sock, 64);
  180. if (ret < 0)
  181. goto out;
  182. rds_tcp_listen_sock = sock;
  183. sock = NULL;
  184. out:
  185. if (sock)
  186. sock_release(sock);
  187. return ret;
  188. }
  189. void rds_tcp_listen_stop(void)
  190. {
  191. struct socket *sock = rds_tcp_listen_sock;
  192. struct sock *sk;
  193. if (!sock)
  194. return;
  195. sk = sock->sk;
  196. /* serialize with and prevent further callbacks */
  197. lock_sock(sk);
  198. write_lock_bh(&sk->sk_callback_lock);
  199. if (sk->sk_user_data) {
  200. sk->sk_data_ready = sk->sk_user_data;
  201. sk->sk_user_data = NULL;
  202. }
  203. write_unlock_bh(&sk->sk_callback_lock);
  204. release_sock(sk);
  205. /* wait for accepts to stop and close the socket */
  206. flush_workqueue(rds_wq);
  207. sock_release(sock);
  208. rds_tcp_listen_sock = NULL;
  209. }