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/in.h> 35 #include <net/tcp.h> 36 37 #include "rds_single_path.h" 38 #include "rds.h" 39 #include "tcp.h" 40 41 void rds_tcp_state_change(struct sock *sk) 42 { 43 void (*state_change)(struct sock *sk); 44 struct rds_conn_path *cp; 45 struct rds_tcp_connection *tc; 46 47 read_lock_bh(&sk->sk_callback_lock); 48 cp = sk->sk_user_data; 49 if (!cp) { 50 state_change = sk->sk_state_change; 51 goto out; 52 } 53 tc = cp->cp_transport_data; 54 state_change = tc->t_orig_state_change; 55 56 rdsdebug("sock %p state_change to %d\n", tc->t_sock, sk->sk_state); 57 58 switch (sk->sk_state) { 59 /* ignore connecting sockets as they make progress */ 60 case TCP_SYN_SENT: 61 case TCP_SYN_RECV: 62 break; 63 case TCP_ESTABLISHED: 64 rds_connect_path_complete(cp, RDS_CONN_CONNECTING); 65 break; 66 case TCP_CLOSE_WAIT: 67 case TCP_CLOSE: 68 rds_conn_path_drop(cp); 69 default: 70 break; 71 } 72 out: 73 read_unlock_bh(&sk->sk_callback_lock); 74 state_change(sk); 75 } 76 77 int rds_tcp_conn_connect(struct rds_connection *conn) 78 { 79 struct socket *sock = NULL; 80 struct sockaddr_in src, dest; 81 int ret; 82 struct rds_tcp_connection *tc = conn->c_transport_data; 83 struct rds_conn_path *cp = &conn->c_path[0]; 84 85 mutex_lock(&tc->t_conn_path_lock); 86 87 if (rds_conn_up(conn)) { 88 mutex_unlock(&tc->t_conn_path_lock); 89 return 0; 90 } 91 ret = sock_create_kern(rds_conn_net(conn), PF_INET, 92 SOCK_STREAM, IPPROTO_TCP, &sock); 93 if (ret < 0) 94 goto out; 95 96 rds_tcp_tune(sock); 97 98 src.sin_family = AF_INET; 99 src.sin_addr.s_addr = (__force u32)conn->c_laddr; 100 src.sin_port = (__force u16)htons(0); 101 102 ret = sock->ops->bind(sock, (struct sockaddr *)&src, sizeof(src)); 103 if (ret) { 104 rdsdebug("bind failed with %d at address %pI4\n", 105 ret, &conn->c_laddr); 106 goto out; 107 } 108 109 dest.sin_family = AF_INET; 110 dest.sin_addr.s_addr = (__force u32)conn->c_faddr; 111 dest.sin_port = (__force u16)htons(RDS_TCP_PORT); 112 113 /* 114 * once we call connect() we can start getting callbacks and they 115 * own the socket 116 */ 117 rds_tcp_set_callbacks(sock, cp); 118 ret = sock->ops->connect(sock, (struct sockaddr *)&dest, sizeof(dest), 119 O_NONBLOCK); 120 121 rdsdebug("connect to address %pI4 returned %d\n", &conn->c_faddr, ret); 122 if (ret == -EINPROGRESS) 123 ret = 0; 124 if (ret == 0) { 125 rds_tcp_keepalive(sock); 126 sock = NULL; 127 } else { 128 rds_tcp_restore_callbacks(sock, conn->c_transport_data); 129 } 130 131 out: 132 mutex_unlock(&tc->t_conn_path_lock); 133 if (sock) 134 sock_release(sock); 135 return ret; 136 } 137 138 /* 139 * Before killing the tcp socket this needs to serialize with callbacks. The 140 * caller has already grabbed the sending sem so we're serialized with other 141 * senders. 142 * 143 * TCP calls the callbacks with the sock lock so we hold it while we reset the 144 * callbacks to those set by TCP. Our callbacks won't execute again once we 145 * hold the sock lock. 146 */ 147 void rds_tcp_conn_path_shutdown(struct rds_conn_path *cp) 148 { 149 struct rds_tcp_connection *tc = cp->cp_transport_data; 150 struct socket *sock = tc->t_sock; 151 152 rdsdebug("shutting down conn %p tc %p sock %p\n", 153 cp->cp_conn, tc, sock); 154 155 if (sock) { 156 sock->ops->shutdown(sock, RCV_SHUTDOWN | SEND_SHUTDOWN); 157 lock_sock(sock->sk); 158 rds_tcp_restore_callbacks(sock, tc); /* tc->tc_sock = NULL */ 159 160 release_sock(sock->sk); 161 sock_release(sock); 162 } 163 164 if (tc->t_tinc) { 165 rds_inc_put(&tc->t_tinc->ti_inc); 166 tc->t_tinc = NULL; 167 } 168 tc->t_tinc_hdr_rem = sizeof(struct rds_header); 169 tc->t_tinc_data_rem = 0; 170 } 171