100e0f34cSAndy Grover /* 200e0f34cSAndy Grover * Copyright (c) 2006 Oracle. All rights reserved. 300e0f34cSAndy Grover * 400e0f34cSAndy Grover * This software is available to you under a choice of one of two 500e0f34cSAndy Grover * licenses. You may choose to be licensed under the terms of the GNU 600e0f34cSAndy Grover * General Public License (GPL) Version 2, available from the file 700e0f34cSAndy Grover * COPYING in the main directory of this source tree, or the 800e0f34cSAndy Grover * OpenIB.org BSD license below: 900e0f34cSAndy Grover * 1000e0f34cSAndy Grover * Redistribution and use in source and binary forms, with or 1100e0f34cSAndy Grover * without modification, are permitted provided that the following 1200e0f34cSAndy Grover * conditions are met: 1300e0f34cSAndy Grover * 1400e0f34cSAndy Grover * - Redistributions of source code must retain the above 1500e0f34cSAndy Grover * copyright notice, this list of conditions and the following 1600e0f34cSAndy Grover * disclaimer. 1700e0f34cSAndy Grover * 1800e0f34cSAndy Grover * - Redistributions in binary form must reproduce the above 1900e0f34cSAndy Grover * copyright notice, this list of conditions and the following 2000e0f34cSAndy Grover * disclaimer in the documentation and/or other materials 2100e0f34cSAndy Grover * provided with the distribution. 2200e0f34cSAndy Grover * 2300e0f34cSAndy Grover * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 2400e0f34cSAndy Grover * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 2500e0f34cSAndy Grover * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 2600e0f34cSAndy Grover * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 2700e0f34cSAndy Grover * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 2800e0f34cSAndy Grover * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 2900e0f34cSAndy Grover * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 3000e0f34cSAndy Grover * SOFTWARE. 3100e0f34cSAndy Grover * 3200e0f34cSAndy Grover */ 3300e0f34cSAndy Grover #include <linux/kernel.h> 3400e0f34cSAndy Grover #include <linux/list.h> 355a0e3ad6STejun Heo #include <linux/slab.h> 3600e0f34cSAndy Grover #include <net/inet_hashtables.h> 3700e0f34cSAndy Grover 3800e0f34cSAndy Grover #include "rds.h" 3900e0f34cSAndy Grover #include "loop.h" 4000e0f34cSAndy Grover #include "rdma.h" 4100e0f34cSAndy Grover 4200e0f34cSAndy Grover #define RDS_CONNECTION_HASH_BITS 12 4300e0f34cSAndy Grover #define RDS_CONNECTION_HASH_ENTRIES (1 << RDS_CONNECTION_HASH_BITS) 4400e0f34cSAndy Grover #define RDS_CONNECTION_HASH_MASK (RDS_CONNECTION_HASH_ENTRIES - 1) 4500e0f34cSAndy Grover 4600e0f34cSAndy Grover /* converting this to RCU is a chore for another day.. */ 4700e0f34cSAndy Grover static DEFINE_SPINLOCK(rds_conn_lock); 4800e0f34cSAndy Grover static unsigned long rds_conn_count; 4900e0f34cSAndy Grover static struct hlist_head rds_conn_hash[RDS_CONNECTION_HASH_ENTRIES]; 5000e0f34cSAndy Grover static struct kmem_cache *rds_conn_slab; 5100e0f34cSAndy Grover 5200e0f34cSAndy Grover static struct hlist_head *rds_conn_bucket(__be32 laddr, __be32 faddr) 5300e0f34cSAndy Grover { 5400e0f34cSAndy Grover /* Pass NULL, don't need struct net for hash */ 5500e0f34cSAndy Grover unsigned long hash = inet_ehashfn(NULL, 5600e0f34cSAndy Grover be32_to_cpu(laddr), 0, 5700e0f34cSAndy Grover be32_to_cpu(faddr), 0); 5800e0f34cSAndy Grover return &rds_conn_hash[hash & RDS_CONNECTION_HASH_MASK]; 5900e0f34cSAndy Grover } 6000e0f34cSAndy Grover 6100e0f34cSAndy Grover #define rds_conn_info_set(var, test, suffix) do { \ 6200e0f34cSAndy Grover if (test) \ 6300e0f34cSAndy Grover var |= RDS_INFO_CONNECTION_FLAG_##suffix; \ 6400e0f34cSAndy Grover } while (0) 6500e0f34cSAndy Grover 6600e0f34cSAndy Grover static inline int rds_conn_is_sending(struct rds_connection *conn) 6700e0f34cSAndy Grover { 6800e0f34cSAndy Grover int ret = 0; 6900e0f34cSAndy Grover 7000e0f34cSAndy Grover if (!mutex_trylock(&conn->c_send_lock)) 7100e0f34cSAndy Grover ret = 1; 7200e0f34cSAndy Grover else 7300e0f34cSAndy Grover mutex_unlock(&conn->c_send_lock); 7400e0f34cSAndy Grover 7500e0f34cSAndy Grover return ret; 7600e0f34cSAndy Grover } 7700e0f34cSAndy Grover 7800e0f34cSAndy Grover static struct rds_connection *rds_conn_lookup(struct hlist_head *head, 7900e0f34cSAndy Grover __be32 laddr, __be32 faddr, 8000e0f34cSAndy Grover struct rds_transport *trans) 8100e0f34cSAndy Grover { 8200e0f34cSAndy Grover struct rds_connection *conn, *ret = NULL; 8300e0f34cSAndy Grover struct hlist_node *pos; 8400e0f34cSAndy Grover 8500e0f34cSAndy Grover hlist_for_each_entry(conn, pos, head, c_hash_node) { 8600e0f34cSAndy Grover if (conn->c_faddr == faddr && conn->c_laddr == laddr && 8700e0f34cSAndy Grover conn->c_trans == trans) { 8800e0f34cSAndy Grover ret = conn; 8900e0f34cSAndy Grover break; 9000e0f34cSAndy Grover } 9100e0f34cSAndy Grover } 9200e0f34cSAndy Grover rdsdebug("returning conn %p for %pI4 -> %pI4\n", ret, 9300e0f34cSAndy Grover &laddr, &faddr); 9400e0f34cSAndy Grover return ret; 9500e0f34cSAndy Grover } 9600e0f34cSAndy Grover 9700e0f34cSAndy Grover /* 9800e0f34cSAndy Grover * This is called by transports as they're bringing down a connection. 9900e0f34cSAndy Grover * It clears partial message state so that the transport can start sending 10000e0f34cSAndy Grover * and receiving over this connection again in the future. It is up to 10100e0f34cSAndy Grover * the transport to have serialized this call with its send and recv. 10200e0f34cSAndy Grover */ 10300e0f34cSAndy Grover void rds_conn_reset(struct rds_connection *conn) 10400e0f34cSAndy Grover { 10500e0f34cSAndy Grover rdsdebug("connection %pI4 to %pI4 reset\n", 10600e0f34cSAndy Grover &conn->c_laddr, &conn->c_faddr); 10700e0f34cSAndy Grover 10800e0f34cSAndy Grover rds_stats_inc(s_conn_reset); 10900e0f34cSAndy Grover rds_send_reset(conn); 11000e0f34cSAndy Grover conn->c_flags = 0; 11100e0f34cSAndy Grover 11200e0f34cSAndy Grover /* Do not clear next_rx_seq here, else we cannot distinguish 11300e0f34cSAndy Grover * retransmitted packets from new packets, and will hand all 11400e0f34cSAndy Grover * of them to the application. That is not consistent with the 11500e0f34cSAndy Grover * reliability guarantees of RDS. */ 11600e0f34cSAndy Grover } 11700e0f34cSAndy Grover 11800e0f34cSAndy Grover /* 11900e0f34cSAndy Grover * There is only every one 'conn' for a given pair of addresses in the 12000e0f34cSAndy Grover * system at a time. They contain messages to be retransmitted and so 12100e0f34cSAndy Grover * span the lifetime of the actual underlying transport connections. 12200e0f34cSAndy Grover * 12300e0f34cSAndy Grover * For now they are not garbage collected once they're created. They 12400e0f34cSAndy Grover * are torn down as the module is removed, if ever. 12500e0f34cSAndy Grover */ 12600e0f34cSAndy Grover static struct rds_connection *__rds_conn_create(__be32 laddr, __be32 faddr, 12700e0f34cSAndy Grover struct rds_transport *trans, gfp_t gfp, 12800e0f34cSAndy Grover int is_outgoing) 12900e0f34cSAndy Grover { 130cb24405eSAndy Grover struct rds_connection *conn, *parent = NULL; 13100e0f34cSAndy Grover struct hlist_head *head = rds_conn_bucket(laddr, faddr); 13200e0f34cSAndy Grover unsigned long flags; 13300e0f34cSAndy Grover int ret; 13400e0f34cSAndy Grover 13500e0f34cSAndy Grover spin_lock_irqsave(&rds_conn_lock, flags); 13600e0f34cSAndy Grover conn = rds_conn_lookup(head, laddr, faddr, trans); 137f64f9e71SJoe Perches if (conn && conn->c_loopback && conn->c_trans != &rds_loop_transport && 138f64f9e71SJoe Perches !is_outgoing) { 13900e0f34cSAndy Grover /* This is a looped back IB connection, and we're 14000e0f34cSAndy Grover * called by the code handling the incoming connect. 14100e0f34cSAndy Grover * We need a second connection object into which we 14200e0f34cSAndy Grover * can stick the other QP. */ 14300e0f34cSAndy Grover parent = conn; 14400e0f34cSAndy Grover conn = parent->c_passive; 14500e0f34cSAndy Grover } 14600e0f34cSAndy Grover spin_unlock_irqrestore(&rds_conn_lock, flags); 14700e0f34cSAndy Grover if (conn) 14800e0f34cSAndy Grover goto out; 14900e0f34cSAndy Grover 15005a178ecSWei Yongjun conn = kmem_cache_zalloc(rds_conn_slab, gfp); 15100e0f34cSAndy Grover if (conn == NULL) { 15200e0f34cSAndy Grover conn = ERR_PTR(-ENOMEM); 15300e0f34cSAndy Grover goto out; 15400e0f34cSAndy Grover } 15500e0f34cSAndy Grover 15600e0f34cSAndy Grover INIT_HLIST_NODE(&conn->c_hash_node); 15700e0f34cSAndy Grover conn->c_laddr = laddr; 15800e0f34cSAndy Grover conn->c_faddr = faddr; 15900e0f34cSAndy Grover spin_lock_init(&conn->c_lock); 16000e0f34cSAndy Grover conn->c_next_tx_seq = 1; 16100e0f34cSAndy Grover 16200e0f34cSAndy Grover mutex_init(&conn->c_send_lock); 16300e0f34cSAndy Grover INIT_LIST_HEAD(&conn->c_send_queue); 16400e0f34cSAndy Grover INIT_LIST_HEAD(&conn->c_retrans); 16500e0f34cSAndy Grover 16600e0f34cSAndy Grover ret = rds_cong_get_maps(conn); 16700e0f34cSAndy Grover if (ret) { 16800e0f34cSAndy Grover kmem_cache_free(rds_conn_slab, conn); 16900e0f34cSAndy Grover conn = ERR_PTR(ret); 17000e0f34cSAndy Grover goto out; 17100e0f34cSAndy Grover } 17200e0f34cSAndy Grover 17300e0f34cSAndy Grover /* 17400e0f34cSAndy Grover * This is where a connection becomes loopback. If *any* RDS sockets 17500e0f34cSAndy Grover * can bind to the destination address then we'd rather the messages 17600e0f34cSAndy Grover * flow through loopback rather than either transport. 17700e0f34cSAndy Grover */ 17800e0f34cSAndy Grover if (rds_trans_get_preferred(faddr)) { 17900e0f34cSAndy Grover conn->c_loopback = 1; 18000e0f34cSAndy Grover if (is_outgoing && trans->t_prefer_loopback) { 18100e0f34cSAndy Grover /* "outgoing" connection - and the transport 18200e0f34cSAndy Grover * says it wants the connection handled by the 18300e0f34cSAndy Grover * loopback transport. This is what TCP does. 18400e0f34cSAndy Grover */ 18500e0f34cSAndy Grover trans = &rds_loop_transport; 18600e0f34cSAndy Grover } 18700e0f34cSAndy Grover } 18800e0f34cSAndy Grover 18900e0f34cSAndy Grover conn->c_trans = trans; 19000e0f34cSAndy Grover 19100e0f34cSAndy Grover ret = trans->conn_alloc(conn, gfp); 19200e0f34cSAndy Grover if (ret) { 19300e0f34cSAndy Grover kmem_cache_free(rds_conn_slab, conn); 19400e0f34cSAndy Grover conn = ERR_PTR(ret); 19500e0f34cSAndy Grover goto out; 19600e0f34cSAndy Grover } 19700e0f34cSAndy Grover 19800e0f34cSAndy Grover atomic_set(&conn->c_state, RDS_CONN_DOWN); 19900e0f34cSAndy Grover conn->c_reconnect_jiffies = 0; 20000e0f34cSAndy Grover INIT_DELAYED_WORK(&conn->c_send_w, rds_send_worker); 20100e0f34cSAndy Grover INIT_DELAYED_WORK(&conn->c_recv_w, rds_recv_worker); 20200e0f34cSAndy Grover INIT_DELAYED_WORK(&conn->c_conn_w, rds_connect_worker); 20300e0f34cSAndy Grover INIT_WORK(&conn->c_down_w, rds_shutdown_worker); 20400e0f34cSAndy Grover mutex_init(&conn->c_cm_lock); 20500e0f34cSAndy Grover conn->c_flags = 0; 20600e0f34cSAndy Grover 20700e0f34cSAndy Grover rdsdebug("allocated conn %p for %pI4 -> %pI4 over %s %s\n", 20800e0f34cSAndy Grover conn, &laddr, &faddr, 20900e0f34cSAndy Grover trans->t_name ? trans->t_name : "[unknown]", 21000e0f34cSAndy Grover is_outgoing ? "(outgoing)" : ""); 21100e0f34cSAndy Grover 212cb24405eSAndy Grover /* 213cb24405eSAndy Grover * Since we ran without holding the conn lock, someone could 214cb24405eSAndy Grover * have created the same conn (either normal or passive) in the 215cb24405eSAndy Grover * interim. We check while holding the lock. If we won, we complete 216cb24405eSAndy Grover * init and return our conn. If we lost, we rollback and return the 217cb24405eSAndy Grover * other one. 218cb24405eSAndy Grover */ 21900e0f34cSAndy Grover spin_lock_irqsave(&rds_conn_lock, flags); 220cb24405eSAndy Grover if (parent) { 221cb24405eSAndy Grover /* Creating passive conn */ 222cb24405eSAndy Grover if (parent->c_passive) { 22300e0f34cSAndy Grover trans->conn_free(conn->c_transport_data); 22400e0f34cSAndy Grover kmem_cache_free(rds_conn_slab, conn); 225cb24405eSAndy Grover conn = parent->c_passive; 22600e0f34cSAndy Grover } else { 227cb24405eSAndy Grover parent->c_passive = conn; 22800e0f34cSAndy Grover rds_cong_add_conn(conn); 22900e0f34cSAndy Grover rds_conn_count++; 23000e0f34cSAndy Grover } 231cb24405eSAndy Grover } else { 232cb24405eSAndy Grover /* Creating normal conn */ 233cb24405eSAndy Grover struct rds_connection *found; 23400e0f34cSAndy Grover 235cb24405eSAndy Grover found = rds_conn_lookup(head, laddr, faddr, trans); 236cb24405eSAndy Grover if (found) { 237cb24405eSAndy Grover trans->conn_free(conn->c_transport_data); 238cb24405eSAndy Grover kmem_cache_free(rds_conn_slab, conn); 239cb24405eSAndy Grover conn = found; 240cb24405eSAndy Grover } else { 241cb24405eSAndy Grover hlist_add_head(&conn->c_hash_node, head); 242cb24405eSAndy Grover rds_cong_add_conn(conn); 243cb24405eSAndy Grover rds_conn_count++; 244cb24405eSAndy Grover } 245cb24405eSAndy Grover } 24600e0f34cSAndy Grover spin_unlock_irqrestore(&rds_conn_lock, flags); 24700e0f34cSAndy Grover 24800e0f34cSAndy Grover out: 24900e0f34cSAndy Grover return conn; 25000e0f34cSAndy Grover } 25100e0f34cSAndy Grover 25200e0f34cSAndy Grover struct rds_connection *rds_conn_create(__be32 laddr, __be32 faddr, 25300e0f34cSAndy Grover struct rds_transport *trans, gfp_t gfp) 25400e0f34cSAndy Grover { 25500e0f34cSAndy Grover return __rds_conn_create(laddr, faddr, trans, gfp, 0); 25600e0f34cSAndy Grover } 257616b757aSAndy Grover EXPORT_SYMBOL_GPL(rds_conn_create); 25800e0f34cSAndy Grover 25900e0f34cSAndy Grover struct rds_connection *rds_conn_create_outgoing(__be32 laddr, __be32 faddr, 26000e0f34cSAndy Grover struct rds_transport *trans, gfp_t gfp) 26100e0f34cSAndy Grover { 26200e0f34cSAndy Grover return __rds_conn_create(laddr, faddr, trans, gfp, 1); 26300e0f34cSAndy Grover } 264616b757aSAndy Grover EXPORT_SYMBOL_GPL(rds_conn_create_outgoing); 26500e0f34cSAndy Grover 26600e0f34cSAndy Grover void rds_conn_destroy(struct rds_connection *conn) 26700e0f34cSAndy Grover { 26800e0f34cSAndy Grover struct rds_message *rm, *rtmp; 26900e0f34cSAndy Grover 27000e0f34cSAndy Grover rdsdebug("freeing conn %p for %pI4 -> " 27100e0f34cSAndy Grover "%pI4\n", conn, &conn->c_laddr, 27200e0f34cSAndy Grover &conn->c_faddr); 27300e0f34cSAndy Grover 27400e0f34cSAndy Grover hlist_del_init(&conn->c_hash_node); 27500e0f34cSAndy Grover 27600e0f34cSAndy Grover /* wait for the rds thread to shut it down */ 27700e0f34cSAndy Grover atomic_set(&conn->c_state, RDS_CONN_ERROR); 27800e0f34cSAndy Grover cancel_delayed_work(&conn->c_conn_w); 27900e0f34cSAndy Grover queue_work(rds_wq, &conn->c_down_w); 28000e0f34cSAndy Grover flush_workqueue(rds_wq); 28100e0f34cSAndy Grover 28200e0f34cSAndy Grover /* tear down queued messages */ 28300e0f34cSAndy Grover list_for_each_entry_safe(rm, rtmp, 28400e0f34cSAndy Grover &conn->c_send_queue, 28500e0f34cSAndy Grover m_conn_item) { 28600e0f34cSAndy Grover list_del_init(&rm->m_conn_item); 28700e0f34cSAndy Grover BUG_ON(!list_empty(&rm->m_sock_item)); 28800e0f34cSAndy Grover rds_message_put(rm); 28900e0f34cSAndy Grover } 29000e0f34cSAndy Grover if (conn->c_xmit_rm) 29100e0f34cSAndy Grover rds_message_put(conn->c_xmit_rm); 29200e0f34cSAndy Grover 29300e0f34cSAndy Grover conn->c_trans->conn_free(conn->c_transport_data); 29400e0f34cSAndy Grover 29500e0f34cSAndy Grover /* 29600e0f34cSAndy Grover * The congestion maps aren't freed up here. They're 29700e0f34cSAndy Grover * freed by rds_cong_exit() after all the connections 29800e0f34cSAndy Grover * have been freed. 29900e0f34cSAndy Grover */ 30000e0f34cSAndy Grover rds_cong_remove_conn(conn); 30100e0f34cSAndy Grover 30200e0f34cSAndy Grover BUG_ON(!list_empty(&conn->c_retrans)); 30300e0f34cSAndy Grover kmem_cache_free(rds_conn_slab, conn); 30400e0f34cSAndy Grover 30500e0f34cSAndy Grover rds_conn_count--; 30600e0f34cSAndy Grover } 307616b757aSAndy Grover EXPORT_SYMBOL_GPL(rds_conn_destroy); 30800e0f34cSAndy Grover 30900e0f34cSAndy Grover static void rds_conn_message_info(struct socket *sock, unsigned int len, 31000e0f34cSAndy Grover struct rds_info_iterator *iter, 31100e0f34cSAndy Grover struct rds_info_lengths *lens, 31200e0f34cSAndy Grover int want_send) 31300e0f34cSAndy Grover { 31400e0f34cSAndy Grover struct hlist_head *head; 31500e0f34cSAndy Grover struct hlist_node *pos; 31600e0f34cSAndy Grover struct list_head *list; 31700e0f34cSAndy Grover struct rds_connection *conn; 31800e0f34cSAndy Grover struct rds_message *rm; 31900e0f34cSAndy Grover unsigned long flags; 32000e0f34cSAndy Grover unsigned int total = 0; 32100e0f34cSAndy Grover size_t i; 32200e0f34cSAndy Grover 32300e0f34cSAndy Grover len /= sizeof(struct rds_info_message); 32400e0f34cSAndy Grover 32500e0f34cSAndy Grover spin_lock_irqsave(&rds_conn_lock, flags); 32600e0f34cSAndy Grover 32700e0f34cSAndy Grover for (i = 0, head = rds_conn_hash; i < ARRAY_SIZE(rds_conn_hash); 32800e0f34cSAndy Grover i++, head++) { 32900e0f34cSAndy Grover hlist_for_each_entry(conn, pos, head, c_hash_node) { 33000e0f34cSAndy Grover if (want_send) 33100e0f34cSAndy Grover list = &conn->c_send_queue; 33200e0f34cSAndy Grover else 33300e0f34cSAndy Grover list = &conn->c_retrans; 33400e0f34cSAndy Grover 33500e0f34cSAndy Grover spin_lock(&conn->c_lock); 33600e0f34cSAndy Grover 33700e0f34cSAndy Grover /* XXX too lazy to maintain counts.. */ 33800e0f34cSAndy Grover list_for_each_entry(rm, list, m_conn_item) { 33900e0f34cSAndy Grover total++; 34000e0f34cSAndy Grover if (total <= len) 34100e0f34cSAndy Grover rds_inc_info_copy(&rm->m_inc, iter, 34200e0f34cSAndy Grover conn->c_laddr, 34300e0f34cSAndy Grover conn->c_faddr, 0); 34400e0f34cSAndy Grover } 34500e0f34cSAndy Grover 34600e0f34cSAndy Grover spin_unlock(&conn->c_lock); 34700e0f34cSAndy Grover } 34800e0f34cSAndy Grover } 34900e0f34cSAndy Grover 35000e0f34cSAndy Grover spin_unlock_irqrestore(&rds_conn_lock, flags); 35100e0f34cSAndy Grover 35200e0f34cSAndy Grover lens->nr = total; 35300e0f34cSAndy Grover lens->each = sizeof(struct rds_info_message); 35400e0f34cSAndy Grover } 35500e0f34cSAndy Grover 35600e0f34cSAndy Grover static void rds_conn_message_info_send(struct socket *sock, unsigned int len, 35700e0f34cSAndy Grover struct rds_info_iterator *iter, 35800e0f34cSAndy Grover struct rds_info_lengths *lens) 35900e0f34cSAndy Grover { 36000e0f34cSAndy Grover rds_conn_message_info(sock, len, iter, lens, 1); 36100e0f34cSAndy Grover } 36200e0f34cSAndy Grover 36300e0f34cSAndy Grover static void rds_conn_message_info_retrans(struct socket *sock, 36400e0f34cSAndy Grover unsigned int len, 36500e0f34cSAndy Grover struct rds_info_iterator *iter, 36600e0f34cSAndy Grover struct rds_info_lengths *lens) 36700e0f34cSAndy Grover { 36800e0f34cSAndy Grover rds_conn_message_info(sock, len, iter, lens, 0); 36900e0f34cSAndy Grover } 37000e0f34cSAndy Grover 37100e0f34cSAndy Grover void rds_for_each_conn_info(struct socket *sock, unsigned int len, 37200e0f34cSAndy Grover struct rds_info_iterator *iter, 37300e0f34cSAndy Grover struct rds_info_lengths *lens, 37400e0f34cSAndy Grover int (*visitor)(struct rds_connection *, void *), 37500e0f34cSAndy Grover size_t item_len) 37600e0f34cSAndy Grover { 37700e0f34cSAndy Grover uint64_t buffer[(item_len + 7) / 8]; 37800e0f34cSAndy Grover struct hlist_head *head; 37900e0f34cSAndy Grover struct hlist_node *pos; 38000e0f34cSAndy Grover struct hlist_node *tmp; 38100e0f34cSAndy Grover struct rds_connection *conn; 38200e0f34cSAndy Grover unsigned long flags; 38300e0f34cSAndy Grover size_t i; 38400e0f34cSAndy Grover 38500e0f34cSAndy Grover spin_lock_irqsave(&rds_conn_lock, flags); 38600e0f34cSAndy Grover 38700e0f34cSAndy Grover lens->nr = 0; 38800e0f34cSAndy Grover lens->each = item_len; 38900e0f34cSAndy Grover 39000e0f34cSAndy Grover for (i = 0, head = rds_conn_hash; i < ARRAY_SIZE(rds_conn_hash); 39100e0f34cSAndy Grover i++, head++) { 39200e0f34cSAndy Grover hlist_for_each_entry_safe(conn, pos, tmp, head, c_hash_node) { 39300e0f34cSAndy Grover 39400e0f34cSAndy Grover /* XXX no c_lock usage.. */ 39500e0f34cSAndy Grover if (!visitor(conn, buffer)) 39600e0f34cSAndy Grover continue; 39700e0f34cSAndy Grover 39800e0f34cSAndy Grover /* We copy as much as we can fit in the buffer, 39900e0f34cSAndy Grover * but we count all items so that the caller 40000e0f34cSAndy Grover * can resize the buffer. */ 40100e0f34cSAndy Grover if (len >= item_len) { 40200e0f34cSAndy Grover rds_info_copy(iter, buffer, item_len); 40300e0f34cSAndy Grover len -= item_len; 40400e0f34cSAndy Grover } 40500e0f34cSAndy Grover lens->nr++; 40600e0f34cSAndy Grover } 40700e0f34cSAndy Grover } 40800e0f34cSAndy Grover 40900e0f34cSAndy Grover spin_unlock_irqrestore(&rds_conn_lock, flags); 41000e0f34cSAndy Grover } 411616b757aSAndy Grover EXPORT_SYMBOL_GPL(rds_for_each_conn_info); 41200e0f34cSAndy Grover 41300e0f34cSAndy Grover static int rds_conn_info_visitor(struct rds_connection *conn, 41400e0f34cSAndy Grover void *buffer) 41500e0f34cSAndy Grover { 41600e0f34cSAndy Grover struct rds_info_connection *cinfo = buffer; 41700e0f34cSAndy Grover 41800e0f34cSAndy Grover cinfo->next_tx_seq = conn->c_next_tx_seq; 41900e0f34cSAndy Grover cinfo->next_rx_seq = conn->c_next_rx_seq; 42000e0f34cSAndy Grover cinfo->laddr = conn->c_laddr; 42100e0f34cSAndy Grover cinfo->faddr = conn->c_faddr; 42200e0f34cSAndy Grover strncpy(cinfo->transport, conn->c_trans->t_name, 42300e0f34cSAndy Grover sizeof(cinfo->transport)); 42400e0f34cSAndy Grover cinfo->flags = 0; 42500e0f34cSAndy Grover 42600e0f34cSAndy Grover rds_conn_info_set(cinfo->flags, 42700e0f34cSAndy Grover rds_conn_is_sending(conn), SENDING); 42800e0f34cSAndy Grover /* XXX Future: return the state rather than these funky bits */ 42900e0f34cSAndy Grover rds_conn_info_set(cinfo->flags, 43000e0f34cSAndy Grover atomic_read(&conn->c_state) == RDS_CONN_CONNECTING, 43100e0f34cSAndy Grover CONNECTING); 43200e0f34cSAndy Grover rds_conn_info_set(cinfo->flags, 43300e0f34cSAndy Grover atomic_read(&conn->c_state) == RDS_CONN_UP, 43400e0f34cSAndy Grover CONNECTED); 43500e0f34cSAndy Grover return 1; 43600e0f34cSAndy Grover } 43700e0f34cSAndy Grover 43800e0f34cSAndy Grover static void rds_conn_info(struct socket *sock, unsigned int len, 43900e0f34cSAndy Grover struct rds_info_iterator *iter, 44000e0f34cSAndy Grover struct rds_info_lengths *lens) 44100e0f34cSAndy Grover { 44200e0f34cSAndy Grover rds_for_each_conn_info(sock, len, iter, lens, 44300e0f34cSAndy Grover rds_conn_info_visitor, 44400e0f34cSAndy Grover sizeof(struct rds_info_connection)); 44500e0f34cSAndy Grover } 44600e0f34cSAndy Grover 44700e0f34cSAndy Grover int __init rds_conn_init(void) 44800e0f34cSAndy Grover { 44900e0f34cSAndy Grover rds_conn_slab = kmem_cache_create("rds_connection", 45000e0f34cSAndy Grover sizeof(struct rds_connection), 45100e0f34cSAndy Grover 0, 0, NULL); 45200e0f34cSAndy Grover if (rds_conn_slab == NULL) 45300e0f34cSAndy Grover return -ENOMEM; 45400e0f34cSAndy Grover 45500e0f34cSAndy Grover rds_info_register_func(RDS_INFO_CONNECTIONS, rds_conn_info); 45600e0f34cSAndy Grover rds_info_register_func(RDS_INFO_SEND_MESSAGES, 45700e0f34cSAndy Grover rds_conn_message_info_send); 45800e0f34cSAndy Grover rds_info_register_func(RDS_INFO_RETRANS_MESSAGES, 45900e0f34cSAndy Grover rds_conn_message_info_retrans); 46000e0f34cSAndy Grover 46100e0f34cSAndy Grover return 0; 46200e0f34cSAndy Grover } 46300e0f34cSAndy Grover 46400e0f34cSAndy Grover void rds_conn_exit(void) 46500e0f34cSAndy Grover { 46600e0f34cSAndy Grover rds_loop_exit(); 46700e0f34cSAndy Grover 46800e0f34cSAndy Grover WARN_ON(!hlist_empty(rds_conn_hash)); 46900e0f34cSAndy Grover 47000e0f34cSAndy Grover kmem_cache_destroy(rds_conn_slab); 47100e0f34cSAndy Grover 47200e0f34cSAndy Grover rds_info_deregister_func(RDS_INFO_CONNECTIONS, rds_conn_info); 47300e0f34cSAndy Grover rds_info_deregister_func(RDS_INFO_SEND_MESSAGES, 47400e0f34cSAndy Grover rds_conn_message_info_send); 47500e0f34cSAndy Grover rds_info_deregister_func(RDS_INFO_RETRANS_MESSAGES, 47600e0f34cSAndy Grover rds_conn_message_info_retrans); 47700e0f34cSAndy Grover } 47800e0f34cSAndy Grover 47900e0f34cSAndy Grover /* 48000e0f34cSAndy Grover * Force a disconnect 48100e0f34cSAndy Grover */ 48200e0f34cSAndy Grover void rds_conn_drop(struct rds_connection *conn) 48300e0f34cSAndy Grover { 48400e0f34cSAndy Grover atomic_set(&conn->c_state, RDS_CONN_ERROR); 48500e0f34cSAndy Grover queue_work(rds_wq, &conn->c_down_w); 48600e0f34cSAndy Grover } 487616b757aSAndy Grover EXPORT_SYMBOL_GPL(rds_conn_drop); 48800e0f34cSAndy Grover 48900e0f34cSAndy Grover /* 49000e0f34cSAndy Grover * An error occurred on the connection 49100e0f34cSAndy Grover */ 49200e0f34cSAndy Grover void 49300e0f34cSAndy Grover __rds_conn_error(struct rds_connection *conn, const char *fmt, ...) 49400e0f34cSAndy Grover { 49500e0f34cSAndy Grover va_list ap; 49600e0f34cSAndy Grover 49700e0f34cSAndy Grover va_start(ap, fmt); 49800e0f34cSAndy Grover vprintk(fmt, ap); 49900e0f34cSAndy Grover va_end(ap); 50000e0f34cSAndy Grover 50100e0f34cSAndy Grover rds_conn_drop(conn); 50200e0f34cSAndy Grover } 503