12522fe45SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-only 26ed7257bSPatrick Caulfield /****************************************************************************** 36ed7257bSPatrick Caulfield ******************************************************************************* 46ed7257bSPatrick Caulfield ** 56ed7257bSPatrick Caulfield ** Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved. 65e9ccc37SChristine Caulfield ** Copyright (C) 2004-2009 Red Hat, Inc. All rights reserved. 76ed7257bSPatrick Caulfield ** 86ed7257bSPatrick Caulfield ** 96ed7257bSPatrick Caulfield ******************************************************************************* 106ed7257bSPatrick Caulfield ******************************************************************************/ 116ed7257bSPatrick Caulfield 126ed7257bSPatrick Caulfield /* 136ed7257bSPatrick Caulfield * lowcomms.c 146ed7257bSPatrick Caulfield * 156ed7257bSPatrick Caulfield * This is the "low-level" comms layer. 166ed7257bSPatrick Caulfield * 176ed7257bSPatrick Caulfield * It is responsible for sending/receiving messages 186ed7257bSPatrick Caulfield * from other nodes in the cluster. 196ed7257bSPatrick Caulfield * 206ed7257bSPatrick Caulfield * Cluster nodes are referred to by their nodeids. nodeids are 216ed7257bSPatrick Caulfield * simply 32 bit numbers to the locking module - if they need to 222cf12c0bSJoe Perches * be expanded for the cluster infrastructure then that is its 236ed7257bSPatrick Caulfield * responsibility. It is this layer's 246ed7257bSPatrick Caulfield * responsibility to resolve these into IP address or 256ed7257bSPatrick Caulfield * whatever it needs for inter-node communication. 266ed7257bSPatrick Caulfield * 276ed7257bSPatrick Caulfield * The comms level is two kernel threads that deal mainly with 286ed7257bSPatrick Caulfield * the receiving of messages from other nodes and passing them 296ed7257bSPatrick Caulfield * up to the mid-level comms layer (which understands the 306ed7257bSPatrick Caulfield * message format) for execution by the locking core, and 316ed7257bSPatrick Caulfield * a send thread which does all the setting up of connections 326ed7257bSPatrick Caulfield * to remote nodes and the sending of data. Threads are not allowed 336ed7257bSPatrick Caulfield * to send their own data because it may cause them to wait in times 346ed7257bSPatrick Caulfield * of high load. Also, this way, the sending thread can collect together 356ed7257bSPatrick Caulfield * messages bound for one node and send them in one block. 366ed7257bSPatrick Caulfield * 372cf12c0bSJoe Perches * lowcomms will choose to use either TCP or SCTP as its transport layer 386ed7257bSPatrick Caulfield * depending on the configuration variable 'protocol'. This should be set 396ed7257bSPatrick Caulfield * to 0 (default) for TCP or 1 for SCTP. It should be configured using a 406ed7257bSPatrick Caulfield * cluster-wide mechanism as it must be the same on all nodes of the cluster 416ed7257bSPatrick Caulfield * for the DLM to function. 426ed7257bSPatrick Caulfield * 436ed7257bSPatrick Caulfield */ 446ed7257bSPatrick Caulfield 456ed7257bSPatrick Caulfield #include <asm/ioctls.h> 466ed7257bSPatrick Caulfield #include <net/sock.h> 476ed7257bSPatrick Caulfield #include <net/tcp.h> 486ed7257bSPatrick Caulfield #include <linux/pagemap.h> 496ed7257bSPatrick Caulfield #include <linux/file.h> 507a936ce7SMatthias Kaehlcke #include <linux/mutex.h> 516ed7257bSPatrick Caulfield #include <linux/sctp.h> 525a0e3ad6STejun Heo #include <linux/slab.h> 532f2d76ccSBenjamin Poirier #include <net/sctp/sctp.h> 5444ad532bSJoe Perches #include <net/ipv6.h> 556ed7257bSPatrick Caulfield 566ed7257bSPatrick Caulfield #include "dlm_internal.h" 576ed7257bSPatrick Caulfield #include "lowcomms.h" 586ed7257bSPatrick Caulfield #include "midcomms.h" 596ed7257bSPatrick Caulfield #include "config.h" 606ed7257bSPatrick Caulfield 616ed7257bSPatrick Caulfield #define NEEDED_RMEM (4*1024*1024) 625e9ccc37SChristine Caulfield #define CONN_HASH_SIZE 32 636ed7257bSPatrick Caulfield 64f92c8dd7SBob Peterson /* Number of messages to send before rescheduling */ 65f92c8dd7SBob Peterson #define MAX_SEND_MSG_COUNT 25 66f92c8dd7SBob Peterson 676ed7257bSPatrick Caulfield struct cbuf { 686ed7257bSPatrick Caulfield unsigned int base; 696ed7257bSPatrick Caulfield unsigned int len; 706ed7257bSPatrick Caulfield unsigned int mask; 716ed7257bSPatrick Caulfield }; 726ed7257bSPatrick Caulfield 736ed7257bSPatrick Caulfield static void cbuf_add(struct cbuf *cb, int n) 746ed7257bSPatrick Caulfield { 756ed7257bSPatrick Caulfield cb->len += n; 766ed7257bSPatrick Caulfield } 776ed7257bSPatrick Caulfield 786ed7257bSPatrick Caulfield static int cbuf_data(struct cbuf *cb) 796ed7257bSPatrick Caulfield { 806ed7257bSPatrick Caulfield return ((cb->base + cb->len) & cb->mask); 816ed7257bSPatrick Caulfield } 826ed7257bSPatrick Caulfield 836ed7257bSPatrick Caulfield static void cbuf_init(struct cbuf *cb, int size) 846ed7257bSPatrick Caulfield { 856ed7257bSPatrick Caulfield cb->base = cb->len = 0; 866ed7257bSPatrick Caulfield cb->mask = size-1; 876ed7257bSPatrick Caulfield } 886ed7257bSPatrick Caulfield 896ed7257bSPatrick Caulfield static void cbuf_eat(struct cbuf *cb, int n) 906ed7257bSPatrick Caulfield { 916ed7257bSPatrick Caulfield cb->len -= n; 926ed7257bSPatrick Caulfield cb->base += n; 936ed7257bSPatrick Caulfield cb->base &= cb->mask; 946ed7257bSPatrick Caulfield } 956ed7257bSPatrick Caulfield 966ed7257bSPatrick Caulfield static bool cbuf_empty(struct cbuf *cb) 976ed7257bSPatrick Caulfield { 986ed7257bSPatrick Caulfield return cb->len == 0; 996ed7257bSPatrick Caulfield } 1006ed7257bSPatrick Caulfield 1016ed7257bSPatrick Caulfield struct connection { 1026ed7257bSPatrick Caulfield struct socket *sock; /* NULL if not connected */ 1036ed7257bSPatrick Caulfield uint32_t nodeid; /* So we know who we are in the list */ 1046ed7257bSPatrick Caulfield struct mutex sock_mutex; 1056ed7257bSPatrick Caulfield unsigned long flags; 1066ed7257bSPatrick Caulfield #define CF_READ_PENDING 1 1078a4abb08Stsutomu.owa@toshiba.co.jp #define CF_WRITE_PENDING 2 1086ed7257bSPatrick Caulfield #define CF_INIT_PENDING 4 1096ed7257bSPatrick Caulfield #define CF_IS_OTHERCON 5 110063c4c99SLars Marowsky-Bree #define CF_CLOSE 6 111b36930ddSDavid Miller #define CF_APP_LIMITED 7 112b2a66629Stsutomu.owa@toshiba.co.jp #define CF_CLOSING 8 1136ed7257bSPatrick Caulfield struct list_head writequeue; /* List of outgoing writequeue_entries */ 1146ed7257bSPatrick Caulfield spinlock_t writequeue_lock; 1156ed7257bSPatrick Caulfield int (*rx_action) (struct connection *); /* What to do when active */ 1166ed7257bSPatrick Caulfield void (*connect_action) (struct connection *); /* What to do to connect */ 1176ed7257bSPatrick Caulfield struct page *rx_page; 1186ed7257bSPatrick Caulfield struct cbuf cb; 1196ed7257bSPatrick Caulfield int retries; 1206ed7257bSPatrick Caulfield #define MAX_CONNECT_RETRIES 3 1215e9ccc37SChristine Caulfield struct hlist_node list; 1226ed7257bSPatrick Caulfield struct connection *othercon; 1236ed7257bSPatrick Caulfield struct work_struct rwork; /* Receive workqueue */ 1246ed7257bSPatrick Caulfield struct work_struct swork; /* Send workqueue */ 1256ed7257bSPatrick Caulfield }; 1266ed7257bSPatrick Caulfield #define sock2con(x) ((struct connection *)(x)->sk_user_data) 1276ed7257bSPatrick Caulfield 1286ed7257bSPatrick Caulfield /* An entry waiting to be sent */ 1296ed7257bSPatrick Caulfield struct writequeue_entry { 1306ed7257bSPatrick Caulfield struct list_head list; 1316ed7257bSPatrick Caulfield struct page *page; 1326ed7257bSPatrick Caulfield int offset; 1336ed7257bSPatrick Caulfield int len; 1346ed7257bSPatrick Caulfield int end; 1356ed7257bSPatrick Caulfield int users; 1366ed7257bSPatrick Caulfield struct connection *con; 1376ed7257bSPatrick Caulfield }; 1386ed7257bSPatrick Caulfield 13936b71a8bSDavid Teigland struct dlm_node_addr { 14036b71a8bSDavid Teigland struct list_head list; 14136b71a8bSDavid Teigland int nodeid; 14236b71a8bSDavid Teigland int addr_count; 14398e1b60eSMike Christie int curr_addr_index; 14436b71a8bSDavid Teigland struct sockaddr_storage *addr[DLM_MAX_ADDR_COUNT]; 14536b71a8bSDavid Teigland }; 14636b71a8bSDavid Teigland 147cc661fc9SBob Peterson static struct listen_sock_callbacks { 148cc661fc9SBob Peterson void (*sk_error_report)(struct sock *); 149cc661fc9SBob Peterson void (*sk_data_ready)(struct sock *); 150cc661fc9SBob Peterson void (*sk_state_change)(struct sock *); 151cc661fc9SBob Peterson void (*sk_write_space)(struct sock *); 152cc661fc9SBob Peterson } listen_sock; 153cc661fc9SBob Peterson 15436b71a8bSDavid Teigland static LIST_HEAD(dlm_node_addrs); 15536b71a8bSDavid Teigland static DEFINE_SPINLOCK(dlm_node_addrs_spin); 15636b71a8bSDavid Teigland 1576ed7257bSPatrick Caulfield static struct sockaddr_storage *dlm_local_addr[DLM_MAX_ADDR_COUNT]; 1586ed7257bSPatrick Caulfield static int dlm_local_count; 159513ef596SDavid Teigland static int dlm_allow_conn; 1606ed7257bSPatrick Caulfield 1616ed7257bSPatrick Caulfield /* Work queues */ 1626ed7257bSPatrick Caulfield static struct workqueue_struct *recv_workqueue; 1636ed7257bSPatrick Caulfield static struct workqueue_struct *send_workqueue; 1646ed7257bSPatrick Caulfield 1655e9ccc37SChristine Caulfield static struct hlist_head connection_hash[CONN_HASH_SIZE]; 1667a936ce7SMatthias Kaehlcke static DEFINE_MUTEX(connections_lock); 1676ed7257bSPatrick Caulfield static struct kmem_cache *con_cache; 1686ed7257bSPatrick Caulfield 1696ed7257bSPatrick Caulfield static void process_recv_sockets(struct work_struct *work); 1706ed7257bSPatrick Caulfield static void process_send_sockets(struct work_struct *work); 1716ed7257bSPatrick Caulfield 1725e9ccc37SChristine Caulfield 1735e9ccc37SChristine Caulfield /* This is deliberately very simple because most clusters have simple 1745e9ccc37SChristine Caulfield sequential nodeids, so we should be able to go straight to a connection 1755e9ccc37SChristine Caulfield struct in the array */ 1765e9ccc37SChristine Caulfield static inline int nodeid_hash(int nodeid) 1775e9ccc37SChristine Caulfield { 1785e9ccc37SChristine Caulfield return nodeid & (CONN_HASH_SIZE-1); 1795e9ccc37SChristine Caulfield } 1805e9ccc37SChristine Caulfield 1815e9ccc37SChristine Caulfield static struct connection *__find_con(int nodeid) 1825e9ccc37SChristine Caulfield { 1835e9ccc37SChristine Caulfield int r; 1845e9ccc37SChristine Caulfield struct connection *con; 1855e9ccc37SChristine Caulfield 1865e9ccc37SChristine Caulfield r = nodeid_hash(nodeid); 1875e9ccc37SChristine Caulfield 188b67bfe0dSSasha Levin hlist_for_each_entry(con, &connection_hash[r], list) { 1895e9ccc37SChristine Caulfield if (con->nodeid == nodeid) 1905e9ccc37SChristine Caulfield return con; 1915e9ccc37SChristine Caulfield } 1925e9ccc37SChristine Caulfield return NULL; 1935e9ccc37SChristine Caulfield } 1945e9ccc37SChristine Caulfield 1956ed7257bSPatrick Caulfield /* 1966ed7257bSPatrick Caulfield * If 'allocation' is zero then we don't attempt to create a new 1976ed7257bSPatrick Caulfield * connection structure for this node. 1986ed7257bSPatrick Caulfield */ 1996ed7257bSPatrick Caulfield static struct connection *__nodeid2con(int nodeid, gfp_t alloc) 2006ed7257bSPatrick Caulfield { 2016ed7257bSPatrick Caulfield struct connection *con = NULL; 2026ed7257bSPatrick Caulfield int r; 2036ed7257bSPatrick Caulfield 2045e9ccc37SChristine Caulfield con = __find_con(nodeid); 2056ed7257bSPatrick Caulfield if (con || !alloc) 2066ed7257bSPatrick Caulfield return con; 2076ed7257bSPatrick Caulfield 2086ed7257bSPatrick Caulfield con = kmem_cache_zalloc(con_cache, alloc); 2096ed7257bSPatrick Caulfield if (!con) 2106ed7257bSPatrick Caulfield return NULL; 2116ed7257bSPatrick Caulfield 2125e9ccc37SChristine Caulfield r = nodeid_hash(nodeid); 2135e9ccc37SChristine Caulfield hlist_add_head(&con->list, &connection_hash[r]); 2146ed7257bSPatrick Caulfield 2156ed7257bSPatrick Caulfield con->nodeid = nodeid; 2166ed7257bSPatrick Caulfield mutex_init(&con->sock_mutex); 2176ed7257bSPatrick Caulfield INIT_LIST_HEAD(&con->writequeue); 2186ed7257bSPatrick Caulfield spin_lock_init(&con->writequeue_lock); 2196ed7257bSPatrick Caulfield INIT_WORK(&con->swork, process_send_sockets); 2206ed7257bSPatrick Caulfield INIT_WORK(&con->rwork, process_recv_sockets); 2216ed7257bSPatrick Caulfield 2226ed7257bSPatrick Caulfield /* Setup action pointers for child sockets */ 2236ed7257bSPatrick Caulfield if (con->nodeid) { 2245e9ccc37SChristine Caulfield struct connection *zerocon = __find_con(0); 2256ed7257bSPatrick Caulfield 2266ed7257bSPatrick Caulfield con->connect_action = zerocon->connect_action; 2276ed7257bSPatrick Caulfield if (!con->rx_action) 2286ed7257bSPatrick Caulfield con->rx_action = zerocon->rx_action; 2296ed7257bSPatrick Caulfield } 2306ed7257bSPatrick Caulfield 2316ed7257bSPatrick Caulfield return con; 2326ed7257bSPatrick Caulfield } 2336ed7257bSPatrick Caulfield 2345e9ccc37SChristine Caulfield /* Loop round all connections */ 2355e9ccc37SChristine Caulfield static void foreach_conn(void (*conn_func)(struct connection *c)) 2365e9ccc37SChristine Caulfield { 2375e9ccc37SChristine Caulfield int i; 238b67bfe0dSSasha Levin struct hlist_node *n; 2395e9ccc37SChristine Caulfield struct connection *con; 2405e9ccc37SChristine Caulfield 2415e9ccc37SChristine Caulfield for (i = 0; i < CONN_HASH_SIZE; i++) { 242b67bfe0dSSasha Levin hlist_for_each_entry_safe(con, n, &connection_hash[i], list) 2435e9ccc37SChristine Caulfield conn_func(con); 2445e9ccc37SChristine Caulfield } 2455e9ccc37SChristine Caulfield } 2465e9ccc37SChristine Caulfield 2476ed7257bSPatrick Caulfield static struct connection *nodeid2con(int nodeid, gfp_t allocation) 2486ed7257bSPatrick Caulfield { 2496ed7257bSPatrick Caulfield struct connection *con; 2506ed7257bSPatrick Caulfield 2517a936ce7SMatthias Kaehlcke mutex_lock(&connections_lock); 2526ed7257bSPatrick Caulfield con = __nodeid2con(nodeid, allocation); 2537a936ce7SMatthias Kaehlcke mutex_unlock(&connections_lock); 2546ed7257bSPatrick Caulfield 2556ed7257bSPatrick Caulfield return con; 2566ed7257bSPatrick Caulfield } 2576ed7257bSPatrick Caulfield 25836b71a8bSDavid Teigland static struct dlm_node_addr *find_node_addr(int nodeid) 2596ed7257bSPatrick Caulfield { 26036b71a8bSDavid Teigland struct dlm_node_addr *na; 26136b71a8bSDavid Teigland 26236b71a8bSDavid Teigland list_for_each_entry(na, &dlm_node_addrs, list) { 26336b71a8bSDavid Teigland if (na->nodeid == nodeid) 26436b71a8bSDavid Teigland return na; 26536b71a8bSDavid Teigland } 26636b71a8bSDavid Teigland return NULL; 26736b71a8bSDavid Teigland } 26836b71a8bSDavid Teigland 26936b71a8bSDavid Teigland static int addr_compare(struct sockaddr_storage *x, struct sockaddr_storage *y) 27036b71a8bSDavid Teigland { 27136b71a8bSDavid Teigland switch (x->ss_family) { 27236b71a8bSDavid Teigland case AF_INET: { 27336b71a8bSDavid Teigland struct sockaddr_in *sinx = (struct sockaddr_in *)x; 27436b71a8bSDavid Teigland struct sockaddr_in *siny = (struct sockaddr_in *)y; 27536b71a8bSDavid Teigland if (sinx->sin_addr.s_addr != siny->sin_addr.s_addr) 27636b71a8bSDavid Teigland return 0; 27736b71a8bSDavid Teigland if (sinx->sin_port != siny->sin_port) 27836b71a8bSDavid Teigland return 0; 27936b71a8bSDavid Teigland break; 28036b71a8bSDavid Teigland } 28136b71a8bSDavid Teigland case AF_INET6: { 28236b71a8bSDavid Teigland struct sockaddr_in6 *sinx = (struct sockaddr_in6 *)x; 28336b71a8bSDavid Teigland struct sockaddr_in6 *siny = (struct sockaddr_in6 *)y; 28436b71a8bSDavid Teigland if (!ipv6_addr_equal(&sinx->sin6_addr, &siny->sin6_addr)) 28536b71a8bSDavid Teigland return 0; 28636b71a8bSDavid Teigland if (sinx->sin6_port != siny->sin6_port) 28736b71a8bSDavid Teigland return 0; 28836b71a8bSDavid Teigland break; 28936b71a8bSDavid Teigland } 29036b71a8bSDavid Teigland default: 29136b71a8bSDavid Teigland return 0; 29236b71a8bSDavid Teigland } 29336b71a8bSDavid Teigland return 1; 29436b71a8bSDavid Teigland } 29536b71a8bSDavid Teigland 29636b71a8bSDavid Teigland static int nodeid_to_addr(int nodeid, struct sockaddr_storage *sas_out, 29798e1b60eSMike Christie struct sockaddr *sa_out, bool try_new_addr) 29836b71a8bSDavid Teigland { 29936b71a8bSDavid Teigland struct sockaddr_storage sas; 30036b71a8bSDavid Teigland struct dlm_node_addr *na; 3016ed7257bSPatrick Caulfield 3026ed7257bSPatrick Caulfield if (!dlm_local_count) 3036ed7257bSPatrick Caulfield return -1; 3046ed7257bSPatrick Caulfield 30536b71a8bSDavid Teigland spin_lock(&dlm_node_addrs_spin); 30636b71a8bSDavid Teigland na = find_node_addr(nodeid); 30798e1b60eSMike Christie if (na && na->addr_count) { 308ee44b4bcSMarcelo Ricardo Leitner memcpy(&sas, na->addr[na->curr_addr_index], 309ee44b4bcSMarcelo Ricardo Leitner sizeof(struct sockaddr_storage)); 310ee44b4bcSMarcelo Ricardo Leitner 31198e1b60eSMike Christie if (try_new_addr) { 31298e1b60eSMike Christie na->curr_addr_index++; 31398e1b60eSMike Christie if (na->curr_addr_index == na->addr_count) 31498e1b60eSMike Christie na->curr_addr_index = 0; 31598e1b60eSMike Christie } 31698e1b60eSMike Christie } 31736b71a8bSDavid Teigland spin_unlock(&dlm_node_addrs_spin); 31836b71a8bSDavid Teigland 31936b71a8bSDavid Teigland if (!na) 32036b71a8bSDavid Teigland return -EEXIST; 32136b71a8bSDavid Teigland 32236b71a8bSDavid Teigland if (!na->addr_count) 32336b71a8bSDavid Teigland return -ENOENT; 32436b71a8bSDavid Teigland 32536b71a8bSDavid Teigland if (sas_out) 32636b71a8bSDavid Teigland memcpy(sas_out, &sas, sizeof(struct sockaddr_storage)); 32736b71a8bSDavid Teigland 32836b71a8bSDavid Teigland if (!sa_out) 32936b71a8bSDavid Teigland return 0; 3306ed7257bSPatrick Caulfield 3316ed7257bSPatrick Caulfield if (dlm_local_addr[0]->ss_family == AF_INET) { 33236b71a8bSDavid Teigland struct sockaddr_in *in4 = (struct sockaddr_in *) &sas; 33336b71a8bSDavid Teigland struct sockaddr_in *ret4 = (struct sockaddr_in *) sa_out; 3346ed7257bSPatrick Caulfield ret4->sin_addr.s_addr = in4->sin_addr.s_addr; 3356ed7257bSPatrick Caulfield } else { 33636b71a8bSDavid Teigland struct sockaddr_in6 *in6 = (struct sockaddr_in6 *) &sas; 33736b71a8bSDavid Teigland struct sockaddr_in6 *ret6 = (struct sockaddr_in6 *) sa_out; 3384e3fd7a0SAlexey Dobriyan ret6->sin6_addr = in6->sin6_addr; 3396ed7257bSPatrick Caulfield } 3406ed7257bSPatrick Caulfield 3416ed7257bSPatrick Caulfield return 0; 3426ed7257bSPatrick Caulfield } 3436ed7257bSPatrick Caulfield 34436b71a8bSDavid Teigland static int addr_to_nodeid(struct sockaddr_storage *addr, int *nodeid) 34536b71a8bSDavid Teigland { 34636b71a8bSDavid Teigland struct dlm_node_addr *na; 34736b71a8bSDavid Teigland int rv = -EEXIST; 34898e1b60eSMike Christie int addr_i; 34936b71a8bSDavid Teigland 35036b71a8bSDavid Teigland spin_lock(&dlm_node_addrs_spin); 35136b71a8bSDavid Teigland list_for_each_entry(na, &dlm_node_addrs, list) { 35236b71a8bSDavid Teigland if (!na->addr_count) 35336b71a8bSDavid Teigland continue; 35436b71a8bSDavid Teigland 35598e1b60eSMike Christie for (addr_i = 0; addr_i < na->addr_count; addr_i++) { 35698e1b60eSMike Christie if (addr_compare(na->addr[addr_i], addr)) { 35736b71a8bSDavid Teigland *nodeid = na->nodeid; 35836b71a8bSDavid Teigland rv = 0; 35998e1b60eSMike Christie goto unlock; 36036b71a8bSDavid Teigland } 36198e1b60eSMike Christie } 36298e1b60eSMike Christie } 36398e1b60eSMike Christie unlock: 36436b71a8bSDavid Teigland spin_unlock(&dlm_node_addrs_spin); 36536b71a8bSDavid Teigland return rv; 36636b71a8bSDavid Teigland } 36736b71a8bSDavid Teigland 36836b71a8bSDavid Teigland int dlm_lowcomms_addr(int nodeid, struct sockaddr_storage *addr, int len) 36936b71a8bSDavid Teigland { 37036b71a8bSDavid Teigland struct sockaddr_storage *new_addr; 37136b71a8bSDavid Teigland struct dlm_node_addr *new_node, *na; 37236b71a8bSDavid Teigland 37336b71a8bSDavid Teigland new_node = kzalloc(sizeof(struct dlm_node_addr), GFP_NOFS); 37436b71a8bSDavid Teigland if (!new_node) 37536b71a8bSDavid Teigland return -ENOMEM; 37636b71a8bSDavid Teigland 37736b71a8bSDavid Teigland new_addr = kzalloc(sizeof(struct sockaddr_storage), GFP_NOFS); 37836b71a8bSDavid Teigland if (!new_addr) { 37936b71a8bSDavid Teigland kfree(new_node); 38036b71a8bSDavid Teigland return -ENOMEM; 38136b71a8bSDavid Teigland } 38236b71a8bSDavid Teigland 38336b71a8bSDavid Teigland memcpy(new_addr, addr, len); 38436b71a8bSDavid Teigland 38536b71a8bSDavid Teigland spin_lock(&dlm_node_addrs_spin); 38636b71a8bSDavid Teigland na = find_node_addr(nodeid); 38736b71a8bSDavid Teigland if (!na) { 38836b71a8bSDavid Teigland new_node->nodeid = nodeid; 38936b71a8bSDavid Teigland new_node->addr[0] = new_addr; 39036b71a8bSDavid Teigland new_node->addr_count = 1; 39136b71a8bSDavid Teigland list_add(&new_node->list, &dlm_node_addrs); 39236b71a8bSDavid Teigland spin_unlock(&dlm_node_addrs_spin); 39336b71a8bSDavid Teigland return 0; 39436b71a8bSDavid Teigland } 39536b71a8bSDavid Teigland 39636b71a8bSDavid Teigland if (na->addr_count >= DLM_MAX_ADDR_COUNT) { 39736b71a8bSDavid Teigland spin_unlock(&dlm_node_addrs_spin); 39836b71a8bSDavid Teigland kfree(new_addr); 39936b71a8bSDavid Teigland kfree(new_node); 40036b71a8bSDavid Teigland return -ENOSPC; 40136b71a8bSDavid Teigland } 40236b71a8bSDavid Teigland 40336b71a8bSDavid Teigland na->addr[na->addr_count++] = new_addr; 40436b71a8bSDavid Teigland spin_unlock(&dlm_node_addrs_spin); 40536b71a8bSDavid Teigland kfree(new_node); 40636b71a8bSDavid Teigland return 0; 40736b71a8bSDavid Teigland } 40836b71a8bSDavid Teigland 4096ed7257bSPatrick Caulfield /* Data available on socket or listen socket received a connect */ 410676d2369SDavid S. Miller static void lowcomms_data_ready(struct sock *sk) 4116ed7257bSPatrick Caulfield { 41293eaadebStsutomu.owa@toshiba.co.jp struct connection *con; 41393eaadebStsutomu.owa@toshiba.co.jp 41493eaadebStsutomu.owa@toshiba.co.jp read_lock_bh(&sk->sk_callback_lock); 41593eaadebStsutomu.owa@toshiba.co.jp con = sock2con(sk); 416afb853fbSPatrick Caulfield if (con && !test_and_set_bit(CF_READ_PENDING, &con->flags)) 4176ed7257bSPatrick Caulfield queue_work(recv_workqueue, &con->rwork); 41893eaadebStsutomu.owa@toshiba.co.jp read_unlock_bh(&sk->sk_callback_lock); 4196ed7257bSPatrick Caulfield } 4206ed7257bSPatrick Caulfield 4216ed7257bSPatrick Caulfield static void lowcomms_write_space(struct sock *sk) 4226ed7257bSPatrick Caulfield { 42393eaadebStsutomu.owa@toshiba.co.jp struct connection *con; 4246ed7257bSPatrick Caulfield 42593eaadebStsutomu.owa@toshiba.co.jp read_lock_bh(&sk->sk_callback_lock); 42693eaadebStsutomu.owa@toshiba.co.jp con = sock2con(sk); 427b36930ddSDavid Miller if (!con) 42893eaadebStsutomu.owa@toshiba.co.jp goto out; 429b36930ddSDavid Miller 430b36930ddSDavid Miller clear_bit(SOCK_NOSPACE, &con->sock->flags); 431b36930ddSDavid Miller 432b36930ddSDavid Miller if (test_and_clear_bit(CF_APP_LIMITED, &con->flags)) { 433b36930ddSDavid Miller con->sock->sk->sk_write_pending--; 4349cd3e072SEric Dumazet clear_bit(SOCKWQ_ASYNC_NOSPACE, &con->sock->flags); 435b36930ddSDavid Miller } 436b36930ddSDavid Miller 4376ed7257bSPatrick Caulfield queue_work(send_workqueue, &con->swork); 43893eaadebStsutomu.owa@toshiba.co.jp out: 43993eaadebStsutomu.owa@toshiba.co.jp read_unlock_bh(&sk->sk_callback_lock); 4406ed7257bSPatrick Caulfield } 4416ed7257bSPatrick Caulfield 4426ed7257bSPatrick Caulfield static inline void lowcomms_connect_sock(struct connection *con) 4436ed7257bSPatrick Caulfield { 444063c4c99SLars Marowsky-Bree if (test_bit(CF_CLOSE, &con->flags)) 445063c4c99SLars Marowsky-Bree return; 4466ed7257bSPatrick Caulfield queue_work(send_workqueue, &con->swork); 44761d9102bSBob Peterson cond_resched(); 4486ed7257bSPatrick Caulfield } 4496ed7257bSPatrick Caulfield 4506ed7257bSPatrick Caulfield static void lowcomms_state_change(struct sock *sk) 4516ed7257bSPatrick Caulfield { 452ee44b4bcSMarcelo Ricardo Leitner /* SCTP layer is not calling sk_data_ready when the connection 453ee44b4bcSMarcelo Ricardo Leitner * is done, so we catch the signal through here. Also, it 454ee44b4bcSMarcelo Ricardo Leitner * doesn't switch socket state when entering shutdown, so we 455ee44b4bcSMarcelo Ricardo Leitner * skip the write in that case. 456ee44b4bcSMarcelo Ricardo Leitner */ 457ee44b4bcSMarcelo Ricardo Leitner if (sk->sk_shutdown) { 458ee44b4bcSMarcelo Ricardo Leitner if (sk->sk_shutdown == RCV_SHUTDOWN) 459ee44b4bcSMarcelo Ricardo Leitner lowcomms_data_ready(sk); 460ee44b4bcSMarcelo Ricardo Leitner } else if (sk->sk_state == TCP_ESTABLISHED) { 4616ed7257bSPatrick Caulfield lowcomms_write_space(sk); 4626ed7257bSPatrick Caulfield } 463ee44b4bcSMarcelo Ricardo Leitner } 4646ed7257bSPatrick Caulfield 465391fbdc5SChristine Caulfield int dlm_lowcomms_connect_node(int nodeid) 466391fbdc5SChristine Caulfield { 467391fbdc5SChristine Caulfield struct connection *con; 468391fbdc5SChristine Caulfield 469391fbdc5SChristine Caulfield if (nodeid == dlm_our_nodeid()) 470391fbdc5SChristine Caulfield return 0; 471391fbdc5SChristine Caulfield 472391fbdc5SChristine Caulfield con = nodeid2con(nodeid, GFP_NOFS); 473391fbdc5SChristine Caulfield if (!con) 474391fbdc5SChristine Caulfield return -ENOMEM; 475391fbdc5SChristine Caulfield lowcomms_connect_sock(con); 476391fbdc5SChristine Caulfield return 0; 477391fbdc5SChristine Caulfield } 478391fbdc5SChristine Caulfield 479b3a5bbfdSBob Peterson static void lowcomms_error_report(struct sock *sk) 480b3a5bbfdSBob Peterson { 481b81171cbSBob Peterson struct connection *con; 482b3a5bbfdSBob Peterson struct sockaddr_storage saddr; 483b81171cbSBob Peterson void (*orig_report)(struct sock *) = NULL; 484b3a5bbfdSBob Peterson 485b81171cbSBob Peterson read_lock_bh(&sk->sk_callback_lock); 486b81171cbSBob Peterson con = sock2con(sk); 487b81171cbSBob Peterson if (con == NULL) 488b81171cbSBob Peterson goto out; 489b81171cbSBob Peterson 490cc661fc9SBob Peterson orig_report = listen_sock.sk_error_report; 4911a31833dSBob Peterson if (con->sock == NULL || 4929b2c45d4SDenys Vlasenko kernel_getpeername(con->sock, (struct sockaddr *)&saddr) < 0) { 493b3a5bbfdSBob Peterson printk_ratelimited(KERN_ERR "dlm: node %d: socket error " 494b3a5bbfdSBob Peterson "sending to node %d, port %d, " 495b3a5bbfdSBob Peterson "sk_err=%d/%d\n", dlm_our_nodeid(), 496b3a5bbfdSBob Peterson con->nodeid, dlm_config.ci_tcp_port, 497b3a5bbfdSBob Peterson sk->sk_err, sk->sk_err_soft); 498b3a5bbfdSBob Peterson } else if (saddr.ss_family == AF_INET) { 499b3a5bbfdSBob Peterson struct sockaddr_in *sin4 = (struct sockaddr_in *)&saddr; 500b3a5bbfdSBob Peterson 501b3a5bbfdSBob Peterson printk_ratelimited(KERN_ERR "dlm: node %d: socket error " 502b3a5bbfdSBob Peterson "sending to node %d at %pI4, port %d, " 503b3a5bbfdSBob Peterson "sk_err=%d/%d\n", dlm_our_nodeid(), 504b3a5bbfdSBob Peterson con->nodeid, &sin4->sin_addr.s_addr, 505b3a5bbfdSBob Peterson dlm_config.ci_tcp_port, sk->sk_err, 506b3a5bbfdSBob Peterson sk->sk_err_soft); 507b3a5bbfdSBob Peterson } else { 508b3a5bbfdSBob Peterson struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)&saddr; 509b3a5bbfdSBob Peterson 510b3a5bbfdSBob Peterson printk_ratelimited(KERN_ERR "dlm: node %d: socket error " 511b3a5bbfdSBob Peterson "sending to node %d at %u.%u.%u.%u, " 512b3a5bbfdSBob Peterson "port %d, sk_err=%d/%d\n", dlm_our_nodeid(), 513b3a5bbfdSBob Peterson con->nodeid, sin6->sin6_addr.s6_addr32[0], 514b3a5bbfdSBob Peterson sin6->sin6_addr.s6_addr32[1], 515b3a5bbfdSBob Peterson sin6->sin6_addr.s6_addr32[2], 516b3a5bbfdSBob Peterson sin6->sin6_addr.s6_addr32[3], 517b3a5bbfdSBob Peterson dlm_config.ci_tcp_port, sk->sk_err, 518b3a5bbfdSBob Peterson sk->sk_err_soft); 519b3a5bbfdSBob Peterson } 520b81171cbSBob Peterson out: 521b81171cbSBob Peterson read_unlock_bh(&sk->sk_callback_lock); 522b81171cbSBob Peterson if (orig_report) 523b81171cbSBob Peterson orig_report(sk); 524b81171cbSBob Peterson } 525b81171cbSBob Peterson 526b81171cbSBob Peterson /* Note: sk_callback_lock must be locked before calling this function. */ 527cc661fc9SBob Peterson static void save_listen_callbacks(struct socket *sock) 528b81171cbSBob Peterson { 529cc661fc9SBob Peterson struct sock *sk = sock->sk; 530cc661fc9SBob Peterson 531cc661fc9SBob Peterson listen_sock.sk_data_ready = sk->sk_data_ready; 532cc661fc9SBob Peterson listen_sock.sk_state_change = sk->sk_state_change; 533cc661fc9SBob Peterson listen_sock.sk_write_space = sk->sk_write_space; 534cc661fc9SBob Peterson listen_sock.sk_error_report = sk->sk_error_report; 535b81171cbSBob Peterson } 536b81171cbSBob Peterson 537cc661fc9SBob Peterson static void restore_callbacks(struct socket *sock) 538b81171cbSBob Peterson { 539cc661fc9SBob Peterson struct sock *sk = sock->sk; 540cc661fc9SBob Peterson 541b81171cbSBob Peterson write_lock_bh(&sk->sk_callback_lock); 542b81171cbSBob Peterson sk->sk_user_data = NULL; 543cc661fc9SBob Peterson sk->sk_data_ready = listen_sock.sk_data_ready; 544cc661fc9SBob Peterson sk->sk_state_change = listen_sock.sk_state_change; 545cc661fc9SBob Peterson sk->sk_write_space = listen_sock.sk_write_space; 546cc661fc9SBob Peterson sk->sk_error_report = listen_sock.sk_error_report; 547b81171cbSBob Peterson write_unlock_bh(&sk->sk_callback_lock); 548b3a5bbfdSBob Peterson } 549b3a5bbfdSBob Peterson 5506ed7257bSPatrick Caulfield /* Make a socket active */ 551988419a9Stsutomu.owa@toshiba.co.jp static void add_sock(struct socket *sock, struct connection *con) 5526ed7257bSPatrick Caulfield { 553b81171cbSBob Peterson struct sock *sk = sock->sk; 554b81171cbSBob Peterson 555b81171cbSBob Peterson write_lock_bh(&sk->sk_callback_lock); 5566ed7257bSPatrick Caulfield con->sock = sock; 5576ed7257bSPatrick Caulfield 558b81171cbSBob Peterson sk->sk_user_data = con; 5596ed7257bSPatrick Caulfield /* Install a data_ready callback */ 560b81171cbSBob Peterson sk->sk_data_ready = lowcomms_data_ready; 561b81171cbSBob Peterson sk->sk_write_space = lowcomms_write_space; 562b81171cbSBob Peterson sk->sk_state_change = lowcomms_state_change; 563b81171cbSBob Peterson sk->sk_allocation = GFP_NOFS; 564b81171cbSBob Peterson sk->sk_error_report = lowcomms_error_report; 565b81171cbSBob Peterson write_unlock_bh(&sk->sk_callback_lock); 5666ed7257bSPatrick Caulfield } 5676ed7257bSPatrick Caulfield 5686ed7257bSPatrick Caulfield /* Add the port number to an IPv6 or 4 sockaddr and return the address 5696ed7257bSPatrick Caulfield length */ 5706ed7257bSPatrick Caulfield static void make_sockaddr(struct sockaddr_storage *saddr, uint16_t port, 5716ed7257bSPatrick Caulfield int *addr_len) 5726ed7257bSPatrick Caulfield { 5736ed7257bSPatrick Caulfield saddr->ss_family = dlm_local_addr[0]->ss_family; 5746ed7257bSPatrick Caulfield if (saddr->ss_family == AF_INET) { 5756ed7257bSPatrick Caulfield struct sockaddr_in *in4_addr = (struct sockaddr_in *)saddr; 5766ed7257bSPatrick Caulfield in4_addr->sin_port = cpu_to_be16(port); 5776ed7257bSPatrick Caulfield *addr_len = sizeof(struct sockaddr_in); 5786ed7257bSPatrick Caulfield memset(&in4_addr->sin_zero, 0, sizeof(in4_addr->sin_zero)); 5796ed7257bSPatrick Caulfield } else { 5806ed7257bSPatrick Caulfield struct sockaddr_in6 *in6_addr = (struct sockaddr_in6 *)saddr; 5816ed7257bSPatrick Caulfield in6_addr->sin6_port = cpu_to_be16(port); 5826ed7257bSPatrick Caulfield *addr_len = sizeof(struct sockaddr_in6); 5836ed7257bSPatrick Caulfield } 58401c8cab2SPatrick Caulfield memset((char *)saddr + *addr_len, 0, sizeof(struct sockaddr_storage) - *addr_len); 5856ed7257bSPatrick Caulfield } 5866ed7257bSPatrick Caulfield 5876ed7257bSPatrick Caulfield /* Close a remote connection and tidy up */ 5880d737a8cSMarcelo Ricardo Leitner static void close_connection(struct connection *con, bool and_other, 5890d737a8cSMarcelo Ricardo Leitner bool tx, bool rx) 5906ed7257bSPatrick Caulfield { 591b2a66629Stsutomu.owa@toshiba.co.jp bool closing = test_and_set_bit(CF_CLOSING, &con->flags); 592b2a66629Stsutomu.owa@toshiba.co.jp 5930aa18464Stsutomu.owa@toshiba.co.jp if (tx && !closing && cancel_work_sync(&con->swork)) { 5940d737a8cSMarcelo Ricardo Leitner log_print("canceled swork for node %d", con->nodeid); 5950aa18464Stsutomu.owa@toshiba.co.jp clear_bit(CF_WRITE_PENDING, &con->flags); 5960aa18464Stsutomu.owa@toshiba.co.jp } 5970aa18464Stsutomu.owa@toshiba.co.jp if (rx && !closing && cancel_work_sync(&con->rwork)) { 5980d737a8cSMarcelo Ricardo Leitner log_print("canceled rwork for node %d", con->nodeid); 5990aa18464Stsutomu.owa@toshiba.co.jp clear_bit(CF_READ_PENDING, &con->flags); 6000aa18464Stsutomu.owa@toshiba.co.jp } 6016ed7257bSPatrick Caulfield 6020d737a8cSMarcelo Ricardo Leitner mutex_lock(&con->sock_mutex); 6036ed7257bSPatrick Caulfield if (con->sock) { 604cc661fc9SBob Peterson restore_callbacks(con->sock); 6056ed7257bSPatrick Caulfield sock_release(con->sock); 6066ed7257bSPatrick Caulfield con->sock = NULL; 6076ed7257bSPatrick Caulfield } 6086ed7257bSPatrick Caulfield if (con->othercon && and_other) { 6096ed7257bSPatrick Caulfield /* Will only re-enter once. */ 6100d737a8cSMarcelo Ricardo Leitner close_connection(con->othercon, false, true, true); 6116ed7257bSPatrick Caulfield } 6126ed7257bSPatrick Caulfield if (con->rx_page) { 6136ed7257bSPatrick Caulfield __free_page(con->rx_page); 6146ed7257bSPatrick Caulfield con->rx_page = NULL; 6156ed7257bSPatrick Caulfield } 6169e5f2825SPatrick Caulfield 6176ed7257bSPatrick Caulfield con->retries = 0; 6186ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 619b2a66629Stsutomu.owa@toshiba.co.jp clear_bit(CF_CLOSING, &con->flags); 6206ed7257bSPatrick Caulfield } 6216ed7257bSPatrick Caulfield 6226ed7257bSPatrick Caulfield /* Data received from remote end */ 6236ed7257bSPatrick Caulfield static int receive_from_sock(struct connection *con) 6246ed7257bSPatrick Caulfield { 6256ed7257bSPatrick Caulfield int ret = 0; 6266ed7257bSPatrick Caulfield struct msghdr msg = {}; 6276ed7257bSPatrick Caulfield struct kvec iov[2]; 6286ed7257bSPatrick Caulfield unsigned len; 6296ed7257bSPatrick Caulfield int r; 6306ed7257bSPatrick Caulfield int call_again_soon = 0; 6316ed7257bSPatrick Caulfield int nvec; 6326ed7257bSPatrick Caulfield 6336ed7257bSPatrick Caulfield mutex_lock(&con->sock_mutex); 6346ed7257bSPatrick Caulfield 6356ed7257bSPatrick Caulfield if (con->sock == NULL) { 6366ed7257bSPatrick Caulfield ret = -EAGAIN; 6376ed7257bSPatrick Caulfield goto out_close; 6386ed7257bSPatrick Caulfield } 639acee4e52SMarcelo Ricardo Leitner if (con->nodeid == 0) { 640acee4e52SMarcelo Ricardo Leitner ret = -EINVAL; 641acee4e52SMarcelo Ricardo Leitner goto out_close; 642acee4e52SMarcelo Ricardo Leitner } 6436ed7257bSPatrick Caulfield 6446ed7257bSPatrick Caulfield if (con->rx_page == NULL) { 6456ed7257bSPatrick Caulfield /* 6466ed7257bSPatrick Caulfield * This doesn't need to be atomic, but I think it should 6476ed7257bSPatrick Caulfield * improve performance if it is. 6486ed7257bSPatrick Caulfield */ 6496ed7257bSPatrick Caulfield con->rx_page = alloc_page(GFP_ATOMIC); 6506ed7257bSPatrick Caulfield if (con->rx_page == NULL) 6516ed7257bSPatrick Caulfield goto out_resched; 65209cbfeafSKirill A. Shutemov cbuf_init(&con->cb, PAGE_SIZE); 6536ed7257bSPatrick Caulfield } 6546ed7257bSPatrick Caulfield 6556ed7257bSPatrick Caulfield /* 6566ed7257bSPatrick Caulfield * iov[0] is the bit of the circular buffer between the current end 6576ed7257bSPatrick Caulfield * point (cb.base + cb.len) and the end of the buffer. 6586ed7257bSPatrick Caulfield */ 6596ed7257bSPatrick Caulfield iov[0].iov_len = con->cb.base - cbuf_data(&con->cb); 6606ed7257bSPatrick Caulfield iov[0].iov_base = page_address(con->rx_page) + cbuf_data(&con->cb); 6616ed7257bSPatrick Caulfield iov[1].iov_len = 0; 6626ed7257bSPatrick Caulfield nvec = 1; 6636ed7257bSPatrick Caulfield 6646ed7257bSPatrick Caulfield /* 6656ed7257bSPatrick Caulfield * iov[1] is the bit of the circular buffer between the start of the 6666ed7257bSPatrick Caulfield * buffer and the start of the currently used section (cb.base) 6676ed7257bSPatrick Caulfield */ 6686ed7257bSPatrick Caulfield if (cbuf_data(&con->cb) >= con->cb.base) { 66909cbfeafSKirill A. Shutemov iov[0].iov_len = PAGE_SIZE - cbuf_data(&con->cb); 6706ed7257bSPatrick Caulfield iov[1].iov_len = con->cb.base; 6716ed7257bSPatrick Caulfield iov[1].iov_base = page_address(con->rx_page); 6726ed7257bSPatrick Caulfield nvec = 2; 6736ed7257bSPatrick Caulfield } 6746ed7257bSPatrick Caulfield len = iov[0].iov_len + iov[1].iov_len; 675aa563d7bSDavid Howells iov_iter_kvec(&msg.msg_iter, READ, iov, nvec, len); 6766ed7257bSPatrick Caulfield 677c8c7840eSAl Viro r = ret = sock_recvmsg(con->sock, &msg, MSG_DONTWAIT | MSG_NOSIGNAL); 6786ed7257bSPatrick Caulfield if (ret <= 0) 6796ed7257bSPatrick Caulfield goto out_close; 680ee44b4bcSMarcelo Ricardo Leitner else if (ret == len) 681ee44b4bcSMarcelo Ricardo Leitner call_again_soon = 1; 6826ed7257bSPatrick Caulfield 6836ed7257bSPatrick Caulfield cbuf_add(&con->cb, ret); 6846ed7257bSPatrick Caulfield ret = dlm_process_incoming_buffer(con->nodeid, 6856ed7257bSPatrick Caulfield page_address(con->rx_page), 6866ed7257bSPatrick Caulfield con->cb.base, con->cb.len, 68709cbfeafSKirill A. Shutemov PAGE_SIZE); 6886ed7257bSPatrick Caulfield if (ret == -EBADMSG) { 689ee44b4bcSMarcelo Ricardo Leitner log_print("lowcomms: addr=%p, base=%u, len=%u, read=%d", 690ee44b4bcSMarcelo Ricardo Leitner page_address(con->rx_page), con->cb.base, 691ee44b4bcSMarcelo Ricardo Leitner con->cb.len, r); 6926ed7257bSPatrick Caulfield } 6936ed7257bSPatrick Caulfield if (ret < 0) 6946ed7257bSPatrick Caulfield goto out_close; 6956ed7257bSPatrick Caulfield cbuf_eat(&con->cb, ret); 6966ed7257bSPatrick Caulfield 6976ed7257bSPatrick Caulfield if (cbuf_empty(&con->cb) && !call_again_soon) { 6986ed7257bSPatrick Caulfield __free_page(con->rx_page); 6996ed7257bSPatrick Caulfield con->rx_page = NULL; 7006ed7257bSPatrick Caulfield } 7016ed7257bSPatrick Caulfield 7026ed7257bSPatrick Caulfield if (call_again_soon) 7036ed7257bSPatrick Caulfield goto out_resched; 7046ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 7056ed7257bSPatrick Caulfield return 0; 7066ed7257bSPatrick Caulfield 7076ed7257bSPatrick Caulfield out_resched: 7086ed7257bSPatrick Caulfield if (!test_and_set_bit(CF_READ_PENDING, &con->flags)) 7096ed7257bSPatrick Caulfield queue_work(recv_workqueue, &con->rwork); 7106ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 7116ed7257bSPatrick Caulfield return -EAGAIN; 7126ed7257bSPatrick Caulfield 7136ed7257bSPatrick Caulfield out_close: 7146ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 7159e5f2825SPatrick Caulfield if (ret != -EAGAIN) { 716c553e173Stsutomu.owa@toshiba.co.jp close_connection(con, true, true, false); 7176ed7257bSPatrick Caulfield /* Reconnect when there is something to send */ 7186ed7257bSPatrick Caulfield } 7196ed7257bSPatrick Caulfield /* Don't return success if we really got EOF */ 7206ed7257bSPatrick Caulfield if (ret == 0) 7216ed7257bSPatrick Caulfield ret = -EAGAIN; 7226ed7257bSPatrick Caulfield 7236ed7257bSPatrick Caulfield return ret; 7246ed7257bSPatrick Caulfield } 7256ed7257bSPatrick Caulfield 7266ed7257bSPatrick Caulfield /* Listening socket is busy, accept a connection */ 7270774dc76SChristoph Hellwig static int accept_from_sock(struct connection *con) 7286ed7257bSPatrick Caulfield { 7296ed7257bSPatrick Caulfield int result; 7306ed7257bSPatrick Caulfield struct sockaddr_storage peeraddr; 7316ed7257bSPatrick Caulfield struct socket *newsock; 7326ed7257bSPatrick Caulfield int len; 7336ed7257bSPatrick Caulfield int nodeid; 7346ed7257bSPatrick Caulfield struct connection *newcon; 7356ed7257bSPatrick Caulfield struct connection *addcon; 7366ed7257bSPatrick Caulfield 737513ef596SDavid Teigland mutex_lock(&connections_lock); 738513ef596SDavid Teigland if (!dlm_allow_conn) { 739513ef596SDavid Teigland mutex_unlock(&connections_lock); 740513ef596SDavid Teigland return -1; 741513ef596SDavid Teigland } 742513ef596SDavid Teigland mutex_unlock(&connections_lock); 743513ef596SDavid Teigland 7446ed7257bSPatrick Caulfield mutex_lock_nested(&con->sock_mutex, 0); 7456ed7257bSPatrick Caulfield 7463421fb15Stsutomu.owa@toshiba.co.jp if (!con->sock) { 7473421fb15Stsutomu.owa@toshiba.co.jp mutex_unlock(&con->sock_mutex); 7483421fb15Stsutomu.owa@toshiba.co.jp return -ENOTCONN; 7493421fb15Stsutomu.owa@toshiba.co.jp } 7506ed7257bSPatrick Caulfield 7513421fb15Stsutomu.owa@toshiba.co.jp result = kernel_accept(con->sock, &newsock, O_NONBLOCK); 7526ed7257bSPatrick Caulfield if (result < 0) 7536ed7257bSPatrick Caulfield goto accept_err; 7546ed7257bSPatrick Caulfield 7556ed7257bSPatrick Caulfield /* Get the connected socket's peer */ 7566ed7257bSPatrick Caulfield memset(&peeraddr, 0, sizeof(peeraddr)); 7579b2c45d4SDenys Vlasenko len = newsock->ops->getname(newsock, (struct sockaddr *)&peeraddr, 2); 7589b2c45d4SDenys Vlasenko if (len < 0) { 7596ed7257bSPatrick Caulfield result = -ECONNABORTED; 7606ed7257bSPatrick Caulfield goto accept_err; 7616ed7257bSPatrick Caulfield } 7626ed7257bSPatrick Caulfield 7636ed7257bSPatrick Caulfield /* Get the new node's NODEID */ 7646ed7257bSPatrick Caulfield make_sockaddr(&peeraddr, 0, &len); 76536b71a8bSDavid Teigland if (addr_to_nodeid(&peeraddr, &nodeid)) { 766bcaadf5cSMasatake YAMATO unsigned char *b=(unsigned char *)&peeraddr; 767617e82e1SDavid Teigland log_print("connect from non cluster node"); 768bcaadf5cSMasatake YAMATO print_hex_dump_bytes("ss: ", DUMP_PREFIX_NONE, 769bcaadf5cSMasatake YAMATO b, sizeof(struct sockaddr_storage)); 7706ed7257bSPatrick Caulfield sock_release(newsock); 7716ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 7726ed7257bSPatrick Caulfield return -1; 7736ed7257bSPatrick Caulfield } 7746ed7257bSPatrick Caulfield 7756ed7257bSPatrick Caulfield log_print("got connection from %d", nodeid); 7766ed7257bSPatrick Caulfield 7776ed7257bSPatrick Caulfield /* Check to see if we already have a connection to this node. This 7786ed7257bSPatrick Caulfield * could happen if the two nodes initiate a connection at roughly 7796ed7257bSPatrick Caulfield * the same time and the connections cross on the wire. 7806ed7257bSPatrick Caulfield * In this case we store the incoming one in "othercon" 7816ed7257bSPatrick Caulfield */ 782748285ccSDavid Teigland newcon = nodeid2con(nodeid, GFP_NOFS); 7836ed7257bSPatrick Caulfield if (!newcon) { 7846ed7257bSPatrick Caulfield result = -ENOMEM; 7856ed7257bSPatrick Caulfield goto accept_err; 7866ed7257bSPatrick Caulfield } 7876ed7257bSPatrick Caulfield mutex_lock_nested(&newcon->sock_mutex, 1); 7886ed7257bSPatrick Caulfield if (newcon->sock) { 7896ed7257bSPatrick Caulfield struct connection *othercon = newcon->othercon; 7906ed7257bSPatrick Caulfield 7916ed7257bSPatrick Caulfield if (!othercon) { 792748285ccSDavid Teigland othercon = kmem_cache_zalloc(con_cache, GFP_NOFS); 7936ed7257bSPatrick Caulfield if (!othercon) { 794617e82e1SDavid Teigland log_print("failed to allocate incoming socket"); 7956ed7257bSPatrick Caulfield mutex_unlock(&newcon->sock_mutex); 7966ed7257bSPatrick Caulfield result = -ENOMEM; 7976ed7257bSPatrick Caulfield goto accept_err; 7986ed7257bSPatrick Caulfield } 7996ed7257bSPatrick Caulfield othercon->nodeid = nodeid; 8006ed7257bSPatrick Caulfield othercon->rx_action = receive_from_sock; 8016ed7257bSPatrick Caulfield mutex_init(&othercon->sock_mutex); 80226b41099Stsutomu.owa@toshiba.co.jp INIT_LIST_HEAD(&othercon->writequeue); 80326b41099Stsutomu.owa@toshiba.co.jp spin_lock_init(&othercon->writequeue_lock); 8046ed7257bSPatrick Caulfield INIT_WORK(&othercon->swork, process_send_sockets); 8056ed7257bSPatrick Caulfield INIT_WORK(&othercon->rwork, process_recv_sockets); 8066ed7257bSPatrick Caulfield set_bit(CF_IS_OTHERCON, &othercon->flags); 80761d96be0SPatrick Caulfield } 808c7355827Stsutomu.owa@toshiba.co.jp mutex_lock_nested(&othercon->sock_mutex, 2); 80961d96be0SPatrick Caulfield if (!othercon->sock) { 8106ed7257bSPatrick Caulfield newcon->othercon = othercon; 811988419a9Stsutomu.owa@toshiba.co.jp add_sock(newsock, othercon); 8126ed7257bSPatrick Caulfield addcon = othercon; 813c7355827Stsutomu.owa@toshiba.co.jp mutex_unlock(&othercon->sock_mutex); 8146ed7257bSPatrick Caulfield } 8156ed7257bSPatrick Caulfield else { 81697d84836SPatrick Caulfield printk("Extra connection from node %d attempted\n", nodeid); 81797d84836SPatrick Caulfield result = -EAGAIN; 818c7355827Stsutomu.owa@toshiba.co.jp mutex_unlock(&othercon->sock_mutex); 819f4fadb23Sakpm@linux-foundation.org mutex_unlock(&newcon->sock_mutex); 82097d84836SPatrick Caulfield goto accept_err; 82197d84836SPatrick Caulfield } 82297d84836SPatrick Caulfield } 82397d84836SPatrick Caulfield else { 8246ed7257bSPatrick Caulfield newcon->rx_action = receive_from_sock; 8253735b4b9SBob Peterson /* accept copies the sk after we've saved the callbacks, so we 8263735b4b9SBob Peterson don't want to save them a second time or comm errors will 8273735b4b9SBob Peterson result in calling sk_error_report recursively. */ 828988419a9Stsutomu.owa@toshiba.co.jp add_sock(newsock, newcon); 8296ed7257bSPatrick Caulfield addcon = newcon; 8306ed7257bSPatrick Caulfield } 8316ed7257bSPatrick Caulfield 8326ed7257bSPatrick Caulfield mutex_unlock(&newcon->sock_mutex); 8336ed7257bSPatrick Caulfield 8346ed7257bSPatrick Caulfield /* 8356ed7257bSPatrick Caulfield * Add it to the active queue in case we got data 83625985edcSLucas De Marchi * between processing the accept adding the socket 8376ed7257bSPatrick Caulfield * to the read_sockets list 8386ed7257bSPatrick Caulfield */ 8396ed7257bSPatrick Caulfield if (!test_and_set_bit(CF_READ_PENDING, &addcon->flags)) 8406ed7257bSPatrick Caulfield queue_work(recv_workqueue, &addcon->rwork); 8416ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 8426ed7257bSPatrick Caulfield 8436ed7257bSPatrick Caulfield return 0; 8446ed7257bSPatrick Caulfield 8456ed7257bSPatrick Caulfield accept_err: 8466ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 8473421fb15Stsutomu.owa@toshiba.co.jp if (newsock) 8486ed7257bSPatrick Caulfield sock_release(newsock); 8496ed7257bSPatrick Caulfield 8506ed7257bSPatrick Caulfield if (result != -EAGAIN) 851617e82e1SDavid Teigland log_print("error accepting connection from node: %d", result); 8526ed7257bSPatrick Caulfield return result; 8536ed7257bSPatrick Caulfield } 8546ed7257bSPatrick Caulfield 8556ed7257bSPatrick Caulfield static void free_entry(struct writequeue_entry *e) 8566ed7257bSPatrick Caulfield { 8576ed7257bSPatrick Caulfield __free_page(e->page); 8586ed7257bSPatrick Caulfield kfree(e); 8596ed7257bSPatrick Caulfield } 8606ed7257bSPatrick Caulfield 8615d689871SMike Christie /* 8625d689871SMike Christie * writequeue_entry_complete - try to delete and free write queue entry 8635d689871SMike Christie * @e: write queue entry to try to delete 8645d689871SMike Christie * @completed: bytes completed 8655d689871SMike Christie * 8665d689871SMike Christie * writequeue_lock must be held. 8675d689871SMike Christie */ 8685d689871SMike Christie static void writequeue_entry_complete(struct writequeue_entry *e, int completed) 8695d689871SMike Christie { 8705d689871SMike Christie e->offset += completed; 8715d689871SMike Christie e->len -= completed; 8725d689871SMike Christie 8735d689871SMike Christie if (e->len == 0 && e->users == 0) { 8745d689871SMike Christie list_del(&e->list); 8755d689871SMike Christie free_entry(e); 8765d689871SMike Christie } 8775d689871SMike Christie } 8785d689871SMike Christie 879ee44b4bcSMarcelo Ricardo Leitner /* 880ee44b4bcSMarcelo Ricardo Leitner * sctp_bind_addrs - bind a SCTP socket to all our addresses 881ee44b4bcSMarcelo Ricardo Leitner */ 882ee44b4bcSMarcelo Ricardo Leitner static int sctp_bind_addrs(struct connection *con, uint16_t port) 883ee44b4bcSMarcelo Ricardo Leitner { 884ee44b4bcSMarcelo Ricardo Leitner struct sockaddr_storage localaddr; 885c0425a42SChristoph Hellwig struct sockaddr *addr = (struct sockaddr *)&localaddr; 886ee44b4bcSMarcelo Ricardo Leitner int i, addr_len, result = 0; 887ee44b4bcSMarcelo Ricardo Leitner 888ee44b4bcSMarcelo Ricardo Leitner for (i = 0; i < dlm_local_count; i++) { 889ee44b4bcSMarcelo Ricardo Leitner memcpy(&localaddr, dlm_local_addr[i], sizeof(localaddr)); 890ee44b4bcSMarcelo Ricardo Leitner make_sockaddr(&localaddr, port, &addr_len); 891ee44b4bcSMarcelo Ricardo Leitner 892ee44b4bcSMarcelo Ricardo Leitner if (!i) 893c0425a42SChristoph Hellwig result = kernel_bind(con->sock, addr, addr_len); 894ee44b4bcSMarcelo Ricardo Leitner else 895c0425a42SChristoph Hellwig result = sock_bind_add(con->sock->sk, addr, addr_len); 896ee44b4bcSMarcelo Ricardo Leitner 897ee44b4bcSMarcelo Ricardo Leitner if (result < 0) { 898ee44b4bcSMarcelo Ricardo Leitner log_print("Can't bind to %d addr number %d, %d.\n", 899ee44b4bcSMarcelo Ricardo Leitner port, i + 1, result); 900ee44b4bcSMarcelo Ricardo Leitner break; 901ee44b4bcSMarcelo Ricardo Leitner } 902ee44b4bcSMarcelo Ricardo Leitner } 903ee44b4bcSMarcelo Ricardo Leitner return result; 904ee44b4bcSMarcelo Ricardo Leitner } 905ee44b4bcSMarcelo Ricardo Leitner 9066ed7257bSPatrick Caulfield /* Initiate an SCTP association. 9076ed7257bSPatrick Caulfield This is a special case of send_to_sock() in that we don't yet have a 9086ed7257bSPatrick Caulfield peeled-off socket for this association, so we use the listening socket 9096ed7257bSPatrick Caulfield and add the primary IP address of the remote node. 9106ed7257bSPatrick Caulfield */ 911ee44b4bcSMarcelo Ricardo Leitner static void sctp_connect_to_sock(struct connection *con) 9126ed7257bSPatrick Caulfield { 913ee44b4bcSMarcelo Ricardo Leitner struct sockaddr_storage daddr; 914ee44b4bcSMarcelo Ricardo Leitner int result; 915ee44b4bcSMarcelo Ricardo Leitner int addr_len; 916ee44b4bcSMarcelo Ricardo Leitner struct socket *sock; 917ee44b4bcSMarcelo Ricardo Leitner 918ee44b4bcSMarcelo Ricardo Leitner if (con->nodeid == 0) { 919ee44b4bcSMarcelo Ricardo Leitner log_print("attempt to connect sock 0 foiled"); 920ee44b4bcSMarcelo Ricardo Leitner return; 921ee44b4bcSMarcelo Ricardo Leitner } 9226ed7257bSPatrick Caulfield 9235d689871SMike Christie mutex_lock(&con->sock_mutex); 9246ed7257bSPatrick Caulfield 925ee44b4bcSMarcelo Ricardo Leitner /* Some odd races can cause double-connects, ignore them */ 926ee44b4bcSMarcelo Ricardo Leitner if (con->retries++ > MAX_CONNECT_RETRIES) 927ee44b4bcSMarcelo Ricardo Leitner goto out; 928ee44b4bcSMarcelo Ricardo Leitner 929ee44b4bcSMarcelo Ricardo Leitner if (con->sock) { 930ee44b4bcSMarcelo Ricardo Leitner log_print("node %d already connected.", con->nodeid); 931ee44b4bcSMarcelo Ricardo Leitner goto out; 932ee44b4bcSMarcelo Ricardo Leitner } 933ee44b4bcSMarcelo Ricardo Leitner 934ee44b4bcSMarcelo Ricardo Leitner memset(&daddr, 0, sizeof(daddr)); 935ee44b4bcSMarcelo Ricardo Leitner result = nodeid_to_addr(con->nodeid, &daddr, NULL, true); 936ee44b4bcSMarcelo Ricardo Leitner if (result < 0) { 9376ed7257bSPatrick Caulfield log_print("no address for nodeid %d", con->nodeid); 938ee44b4bcSMarcelo Ricardo Leitner goto out; 93904bedd79SDavid Teigland } 9406ed7257bSPatrick Caulfield 941ee44b4bcSMarcelo Ricardo Leitner /* Create a socket to communicate with */ 942ee44b4bcSMarcelo Ricardo Leitner result = sock_create_kern(&init_net, dlm_local_addr[0]->ss_family, 943ee44b4bcSMarcelo Ricardo Leitner SOCK_STREAM, IPPROTO_SCTP, &sock); 944ee44b4bcSMarcelo Ricardo Leitner if (result < 0) 945ee44b4bcSMarcelo Ricardo Leitner goto socket_err; 9466ed7257bSPatrick Caulfield 947ee44b4bcSMarcelo Ricardo Leitner con->rx_action = receive_from_sock; 948ee44b4bcSMarcelo Ricardo Leitner con->connect_action = sctp_connect_to_sock; 949988419a9Stsutomu.owa@toshiba.co.jp add_sock(sock, con); 9506ed7257bSPatrick Caulfield 951ee44b4bcSMarcelo Ricardo Leitner /* Bind to all addresses. */ 952ee44b4bcSMarcelo Ricardo Leitner if (sctp_bind_addrs(con, 0)) 953ee44b4bcSMarcelo Ricardo Leitner goto bind_err; 95498e1b60eSMike Christie 955ee44b4bcSMarcelo Ricardo Leitner make_sockaddr(&daddr, dlm_config.ci_tcp_port, &addr_len); 9566ed7257bSPatrick Caulfield 957ee44b4bcSMarcelo Ricardo Leitner log_print("connecting to %d", con->nodeid); 9586ed7257bSPatrick Caulfield 959ee44b4bcSMarcelo Ricardo Leitner /* Turn off Nagle's algorithm */ 96040ef92c6SChristoph Hellwig sctp_sock_set_nodelay(sock->sk); 961ee44b4bcSMarcelo Ricardo Leitner 962f706d830SGang He /* 963f706d830SGang He * Make sock->ops->connect() function return in specified time, 964f706d830SGang He * since O_NONBLOCK argument in connect() function does not work here, 965f706d830SGang He * then, we should restore the default value of this attribute. 966f706d830SGang He */ 96776ee0785SChristoph Hellwig sock_set_sndtimeo(sock->sk, 5); 968ee44b4bcSMarcelo Ricardo Leitner result = sock->ops->connect(sock, (struct sockaddr *)&daddr, addr_len, 969da3627c3SGang He 0); 97076ee0785SChristoph Hellwig sock_set_sndtimeo(sock->sk, 0); 971f706d830SGang He 972ee44b4bcSMarcelo Ricardo Leitner if (result == -EINPROGRESS) 973ee44b4bcSMarcelo Ricardo Leitner result = 0; 974ee44b4bcSMarcelo Ricardo Leitner if (result == 0) 975ee44b4bcSMarcelo Ricardo Leitner goto out; 976ee44b4bcSMarcelo Ricardo Leitner 977ee44b4bcSMarcelo Ricardo Leitner bind_err: 978ee44b4bcSMarcelo Ricardo Leitner con->sock = NULL; 979ee44b4bcSMarcelo Ricardo Leitner sock_release(sock); 980ee44b4bcSMarcelo Ricardo Leitner 981ee44b4bcSMarcelo Ricardo Leitner socket_err: 982ee44b4bcSMarcelo Ricardo Leitner /* 983ee44b4bcSMarcelo Ricardo Leitner * Some errors are fatal and this list might need adjusting. For other 984ee44b4bcSMarcelo Ricardo Leitner * errors we try again until the max number of retries is reached. 985ee44b4bcSMarcelo Ricardo Leitner */ 986ee44b4bcSMarcelo Ricardo Leitner if (result != -EHOSTUNREACH && 987ee44b4bcSMarcelo Ricardo Leitner result != -ENETUNREACH && 988ee44b4bcSMarcelo Ricardo Leitner result != -ENETDOWN && 989ee44b4bcSMarcelo Ricardo Leitner result != -EINVAL && 990ee44b4bcSMarcelo Ricardo Leitner result != -EPROTONOSUPPORT) { 991ee44b4bcSMarcelo Ricardo Leitner log_print("connect %d try %d error %d", con->nodeid, 992ee44b4bcSMarcelo Ricardo Leitner con->retries, result); 993ee44b4bcSMarcelo Ricardo Leitner mutex_unlock(&con->sock_mutex); 994ee44b4bcSMarcelo Ricardo Leitner msleep(1000); 995ee44b4bcSMarcelo Ricardo Leitner lowcomms_connect_sock(con); 996ee44b4bcSMarcelo Ricardo Leitner return; 9976ed7257bSPatrick Caulfield } 9985d689871SMike Christie 999ee44b4bcSMarcelo Ricardo Leitner out: 10005d689871SMike Christie mutex_unlock(&con->sock_mutex); 10016ed7257bSPatrick Caulfield } 10026ed7257bSPatrick Caulfield 10036ed7257bSPatrick Caulfield /* Connect a new socket to its peer */ 10046ed7257bSPatrick Caulfield static void tcp_connect_to_sock(struct connection *con) 10056ed7257bSPatrick Caulfield { 10066bd8fedaSLon Hohberger struct sockaddr_storage saddr, src_addr; 10076ed7257bSPatrick Caulfield int addr_len; 1008a89d63a1SCasey Dahlin struct socket *sock = NULL; 100936b71a8bSDavid Teigland int result; 10106ed7257bSPatrick Caulfield 10116ed7257bSPatrick Caulfield if (con->nodeid == 0) { 10126ed7257bSPatrick Caulfield log_print("attempt to connect sock 0 foiled"); 10136ed7257bSPatrick Caulfield return; 10146ed7257bSPatrick Caulfield } 10156ed7257bSPatrick Caulfield 10166ed7257bSPatrick Caulfield mutex_lock(&con->sock_mutex); 10176ed7257bSPatrick Caulfield if (con->retries++ > MAX_CONNECT_RETRIES) 10186ed7257bSPatrick Caulfield goto out; 10196ed7257bSPatrick Caulfield 10206ed7257bSPatrick Caulfield /* Some odd races can cause double-connects, ignore them */ 102136b71a8bSDavid Teigland if (con->sock) 10226ed7257bSPatrick Caulfield goto out; 10236ed7257bSPatrick Caulfield 10246ed7257bSPatrick Caulfield /* Create a socket to communicate with */ 1025eeb1bd5cSEric W. Biederman result = sock_create_kern(&init_net, dlm_local_addr[0]->ss_family, 1026eeb1bd5cSEric W. Biederman SOCK_STREAM, IPPROTO_TCP, &sock); 10276ed7257bSPatrick Caulfield if (result < 0) 10286ed7257bSPatrick Caulfield goto out_err; 10296ed7257bSPatrick Caulfield 10306ed7257bSPatrick Caulfield memset(&saddr, 0, sizeof(saddr)); 103198e1b60eSMike Christie result = nodeid_to_addr(con->nodeid, &saddr, NULL, false); 103236b71a8bSDavid Teigland if (result < 0) { 103336b71a8bSDavid Teigland log_print("no address for nodeid %d", con->nodeid); 10346ed7257bSPatrick Caulfield goto out_err; 103536b71a8bSDavid Teigland } 10366ed7257bSPatrick Caulfield 10376ed7257bSPatrick Caulfield con->rx_action = receive_from_sock; 10386ed7257bSPatrick Caulfield con->connect_action = tcp_connect_to_sock; 1039988419a9Stsutomu.owa@toshiba.co.jp add_sock(sock, con); 10406ed7257bSPatrick Caulfield 10416bd8fedaSLon Hohberger /* Bind to our cluster-known address connecting to avoid 10426bd8fedaSLon Hohberger routing problems */ 10436bd8fedaSLon Hohberger memcpy(&src_addr, dlm_local_addr[0], sizeof(src_addr)); 10446bd8fedaSLon Hohberger make_sockaddr(&src_addr, 0, &addr_len); 10456bd8fedaSLon Hohberger result = sock->ops->bind(sock, (struct sockaddr *) &src_addr, 10466bd8fedaSLon Hohberger addr_len); 10476bd8fedaSLon Hohberger if (result < 0) { 10486bd8fedaSLon Hohberger log_print("could not bind for connect: %d", result); 10496bd8fedaSLon Hohberger /* This *may* not indicate a critical error */ 10506bd8fedaSLon Hohberger } 10516bd8fedaSLon Hohberger 10526ed7257bSPatrick Caulfield make_sockaddr(&saddr, dlm_config.ci_tcp_port, &addr_len); 10536ed7257bSPatrick Caulfield 10546ed7257bSPatrick Caulfield log_print("connecting to %d", con->nodeid); 1055cb2d45daSDavid Teigland 1056cb2d45daSDavid Teigland /* Turn off Nagle's algorithm */ 105712abc5eeSChristoph Hellwig tcp_sock_set_nodelay(sock->sk); 1058cb2d45daSDavid Teigland 105936b71a8bSDavid Teigland result = sock->ops->connect(sock, (struct sockaddr *)&saddr, addr_len, 10606ed7257bSPatrick Caulfield O_NONBLOCK); 10616ed7257bSPatrick Caulfield if (result == -EINPROGRESS) 10626ed7257bSPatrick Caulfield result = 0; 10636ed7257bSPatrick Caulfield if (result == 0) 10646ed7257bSPatrick Caulfield goto out; 10656ed7257bSPatrick Caulfield 10666ed7257bSPatrick Caulfield out_err: 10676ed7257bSPatrick Caulfield if (con->sock) { 10686ed7257bSPatrick Caulfield sock_release(con->sock); 10696ed7257bSPatrick Caulfield con->sock = NULL; 1070a89d63a1SCasey Dahlin } else if (sock) { 1071a89d63a1SCasey Dahlin sock_release(sock); 10726ed7257bSPatrick Caulfield } 10736ed7257bSPatrick Caulfield /* 10746ed7257bSPatrick Caulfield * Some errors are fatal and this list might need adjusting. For other 10756ed7257bSPatrick Caulfield * errors we try again until the max number of retries is reached. 10766ed7257bSPatrick Caulfield */ 107736b71a8bSDavid Teigland if (result != -EHOSTUNREACH && 107836b71a8bSDavid Teigland result != -ENETUNREACH && 107936b71a8bSDavid Teigland result != -ENETDOWN && 108036b71a8bSDavid Teigland result != -EINVAL && 108136b71a8bSDavid Teigland result != -EPROTONOSUPPORT) { 108236b71a8bSDavid Teigland log_print("connect %d try %d error %d", con->nodeid, 108336b71a8bSDavid Teigland con->retries, result); 108436b71a8bSDavid Teigland mutex_unlock(&con->sock_mutex); 108536b71a8bSDavid Teigland msleep(1000); 10866ed7257bSPatrick Caulfield lowcomms_connect_sock(con); 108736b71a8bSDavid Teigland return; 10886ed7257bSPatrick Caulfield } 10896ed7257bSPatrick Caulfield out: 10906ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 10916ed7257bSPatrick Caulfield return; 10926ed7257bSPatrick Caulfield } 10936ed7257bSPatrick Caulfield 10946ed7257bSPatrick Caulfield static struct socket *tcp_create_listen_sock(struct connection *con, 10956ed7257bSPatrick Caulfield struct sockaddr_storage *saddr) 10966ed7257bSPatrick Caulfield { 10976ed7257bSPatrick Caulfield struct socket *sock = NULL; 10986ed7257bSPatrick Caulfield int result = 0; 10996ed7257bSPatrick Caulfield int addr_len; 11006ed7257bSPatrick Caulfield 11016ed7257bSPatrick Caulfield if (dlm_local_addr[0]->ss_family == AF_INET) 11026ed7257bSPatrick Caulfield addr_len = sizeof(struct sockaddr_in); 11036ed7257bSPatrick Caulfield else 11046ed7257bSPatrick Caulfield addr_len = sizeof(struct sockaddr_in6); 11056ed7257bSPatrick Caulfield 11066ed7257bSPatrick Caulfield /* Create a socket to communicate with */ 1107eeb1bd5cSEric W. Biederman result = sock_create_kern(&init_net, dlm_local_addr[0]->ss_family, 1108eeb1bd5cSEric W. Biederman SOCK_STREAM, IPPROTO_TCP, &sock); 11096ed7257bSPatrick Caulfield if (result < 0) { 1110617e82e1SDavid Teigland log_print("Can't create listening comms socket"); 11116ed7257bSPatrick Caulfield goto create_out; 11126ed7257bSPatrick Caulfield } 11136ed7257bSPatrick Caulfield 1114a5b7ab63SAlexander Aring sock_set_mark(sock->sk, dlm_config.ci_mark); 1115a5b7ab63SAlexander Aring 1116cb2d45daSDavid Teigland /* Turn off Nagle's algorithm */ 111712abc5eeSChristoph Hellwig tcp_sock_set_nodelay(sock->sk); 1118cb2d45daSDavid Teigland 1119b58f0e8fSChristoph Hellwig sock_set_reuseaddr(sock->sk); 11206ed7257bSPatrick Caulfield 112193eaadebStsutomu.owa@toshiba.co.jp write_lock_bh(&sock->sk->sk_callback_lock); 1122b81171cbSBob Peterson sock->sk->sk_user_data = con; 1123cc661fc9SBob Peterson save_listen_callbacks(sock); 11240774dc76SChristoph Hellwig con->rx_action = accept_from_sock; 11256ed7257bSPatrick Caulfield con->connect_action = tcp_connect_to_sock; 112693eaadebStsutomu.owa@toshiba.co.jp write_unlock_bh(&sock->sk->sk_callback_lock); 11276ed7257bSPatrick Caulfield 11286ed7257bSPatrick Caulfield /* Bind to our port */ 11296ed7257bSPatrick Caulfield make_sockaddr(saddr, dlm_config.ci_tcp_port, &addr_len); 11306ed7257bSPatrick Caulfield result = sock->ops->bind(sock, (struct sockaddr *) saddr, addr_len); 11316ed7257bSPatrick Caulfield if (result < 0) { 1132617e82e1SDavid Teigland log_print("Can't bind to port %d", dlm_config.ci_tcp_port); 11336ed7257bSPatrick Caulfield sock_release(sock); 11346ed7257bSPatrick Caulfield sock = NULL; 11356ed7257bSPatrick Caulfield con->sock = NULL; 11366ed7257bSPatrick Caulfield goto create_out; 11376ed7257bSPatrick Caulfield } 1138ce3d9544SChristoph Hellwig sock_set_keepalive(sock->sk); 11396ed7257bSPatrick Caulfield 11406ed7257bSPatrick Caulfield result = sock->ops->listen(sock, 5); 11416ed7257bSPatrick Caulfield if (result < 0) { 1142617e82e1SDavid Teigland log_print("Can't listen on port %d", dlm_config.ci_tcp_port); 11436ed7257bSPatrick Caulfield sock_release(sock); 11446ed7257bSPatrick Caulfield sock = NULL; 11456ed7257bSPatrick Caulfield goto create_out; 11466ed7257bSPatrick Caulfield } 11476ed7257bSPatrick Caulfield 11486ed7257bSPatrick Caulfield create_out: 11496ed7257bSPatrick Caulfield return sock; 11506ed7257bSPatrick Caulfield } 11516ed7257bSPatrick Caulfield 11526ed7257bSPatrick Caulfield /* Get local addresses */ 11536ed7257bSPatrick Caulfield static void init_local(void) 11546ed7257bSPatrick Caulfield { 11556ed7257bSPatrick Caulfield struct sockaddr_storage sas, *addr; 11566ed7257bSPatrick Caulfield int i; 11576ed7257bSPatrick Caulfield 115830d3a237SPatrick Caulfield dlm_local_count = 0; 11591b189b88SDavid Teigland for (i = 0; i < DLM_MAX_ADDR_COUNT; i++) { 11606ed7257bSPatrick Caulfield if (dlm_our_addr(&sas, i)) 11616ed7257bSPatrick Caulfield break; 11626ed7257bSPatrick Caulfield 11635c93f56fSAmitoj Kaur Chawla addr = kmemdup(&sas, sizeof(*addr), GFP_NOFS); 11646ed7257bSPatrick Caulfield if (!addr) 11656ed7257bSPatrick Caulfield break; 11666ed7257bSPatrick Caulfield dlm_local_addr[dlm_local_count++] = addr; 11676ed7257bSPatrick Caulfield } 11686ed7257bSPatrick Caulfield } 11696ed7257bSPatrick Caulfield 11706ed7257bSPatrick Caulfield /* Initialise SCTP socket and bind to all interfaces */ 11716ed7257bSPatrick Caulfield static int sctp_listen_for_all(void) 11726ed7257bSPatrick Caulfield { 11736ed7257bSPatrick Caulfield struct socket *sock = NULL; 1174ee44b4bcSMarcelo Ricardo Leitner int result = -EINVAL; 1175573c24c4SDavid Teigland struct connection *con = nodeid2con(0, GFP_NOFS); 11766ed7257bSPatrick Caulfield 11776ed7257bSPatrick Caulfield if (!con) 11786ed7257bSPatrick Caulfield return -ENOMEM; 11796ed7257bSPatrick Caulfield 11806ed7257bSPatrick Caulfield log_print("Using SCTP for communications"); 11816ed7257bSPatrick Caulfield 1182eeb1bd5cSEric W. Biederman result = sock_create_kern(&init_net, dlm_local_addr[0]->ss_family, 1183ee44b4bcSMarcelo Ricardo Leitner SOCK_STREAM, IPPROTO_SCTP, &sock); 11846ed7257bSPatrick Caulfield if (result < 0) { 11856ed7257bSPatrick Caulfield log_print("Can't create comms socket, check SCTP is loaded"); 11866ed7257bSPatrick Caulfield goto out; 11876ed7257bSPatrick Caulfield } 11886ed7257bSPatrick Caulfield 118926cfabf9SChristoph Hellwig sock_set_rcvbuf(sock->sk, NEEDED_RMEM); 1190a5b7ab63SAlexander Aring sock_set_mark(sock->sk, dlm_config.ci_mark); 119140ef92c6SChristoph Hellwig sctp_sock_set_nodelay(sock->sk); 119286e92ad2SMike Christie 1193b81171cbSBob Peterson write_lock_bh(&sock->sk->sk_callback_lock); 11946ed7257bSPatrick Caulfield /* Init con struct */ 11956ed7257bSPatrick Caulfield sock->sk->sk_user_data = con; 1196cc661fc9SBob Peterson save_listen_callbacks(sock); 11976ed7257bSPatrick Caulfield con->sock = sock; 11986ed7257bSPatrick Caulfield con->sock->sk->sk_data_ready = lowcomms_data_ready; 11990774dc76SChristoph Hellwig con->rx_action = accept_from_sock; 1200ee44b4bcSMarcelo Ricardo Leitner con->connect_action = sctp_connect_to_sock; 12016ed7257bSPatrick Caulfield 1202b81171cbSBob Peterson write_unlock_bh(&sock->sk->sk_callback_lock); 1203b81171cbSBob Peterson 1204ee44b4bcSMarcelo Ricardo Leitner /* Bind to all addresses. */ 1205ee44b4bcSMarcelo Ricardo Leitner if (sctp_bind_addrs(con, dlm_config.ci_tcp_port)) 12066ed7257bSPatrick Caulfield goto create_delsock; 12076ed7257bSPatrick Caulfield 12086ed7257bSPatrick Caulfield result = sock->ops->listen(sock, 5); 12096ed7257bSPatrick Caulfield if (result < 0) { 12106ed7257bSPatrick Caulfield log_print("Can't set socket listening"); 12116ed7257bSPatrick Caulfield goto create_delsock; 12126ed7257bSPatrick Caulfield } 12136ed7257bSPatrick Caulfield 12146ed7257bSPatrick Caulfield return 0; 12156ed7257bSPatrick Caulfield 12166ed7257bSPatrick Caulfield create_delsock: 12176ed7257bSPatrick Caulfield sock_release(sock); 12186ed7257bSPatrick Caulfield con->sock = NULL; 12196ed7257bSPatrick Caulfield out: 12206ed7257bSPatrick Caulfield return result; 12216ed7257bSPatrick Caulfield } 12226ed7257bSPatrick Caulfield 12236ed7257bSPatrick Caulfield static int tcp_listen_for_all(void) 12246ed7257bSPatrick Caulfield { 12256ed7257bSPatrick Caulfield struct socket *sock = NULL; 1226573c24c4SDavid Teigland struct connection *con = nodeid2con(0, GFP_NOFS); 12276ed7257bSPatrick Caulfield int result = -EINVAL; 12286ed7257bSPatrick Caulfield 12296ed7257bSPatrick Caulfield if (!con) 12306ed7257bSPatrick Caulfield return -ENOMEM; 12316ed7257bSPatrick Caulfield 12326ed7257bSPatrick Caulfield /* We don't support multi-homed hosts */ 12336ed7257bSPatrick Caulfield if (dlm_local_addr[1] != NULL) { 1234617e82e1SDavid Teigland log_print("TCP protocol can't handle multi-homed hosts, " 1235617e82e1SDavid Teigland "try SCTP"); 12366ed7257bSPatrick Caulfield return -EINVAL; 12376ed7257bSPatrick Caulfield } 12386ed7257bSPatrick Caulfield 12396ed7257bSPatrick Caulfield log_print("Using TCP for communications"); 12406ed7257bSPatrick Caulfield 12416ed7257bSPatrick Caulfield sock = tcp_create_listen_sock(con, dlm_local_addr[0]); 12426ed7257bSPatrick Caulfield if (sock) { 1243988419a9Stsutomu.owa@toshiba.co.jp add_sock(sock, con); 12446ed7257bSPatrick Caulfield result = 0; 12456ed7257bSPatrick Caulfield } 12466ed7257bSPatrick Caulfield else { 12476ed7257bSPatrick Caulfield result = -EADDRINUSE; 12486ed7257bSPatrick Caulfield } 12496ed7257bSPatrick Caulfield 12506ed7257bSPatrick Caulfield return result; 12516ed7257bSPatrick Caulfield } 12526ed7257bSPatrick Caulfield 12536ed7257bSPatrick Caulfield 12546ed7257bSPatrick Caulfield 12556ed7257bSPatrick Caulfield static struct writequeue_entry *new_writequeue_entry(struct connection *con, 12566ed7257bSPatrick Caulfield gfp_t allocation) 12576ed7257bSPatrick Caulfield { 12586ed7257bSPatrick Caulfield struct writequeue_entry *entry; 12596ed7257bSPatrick Caulfield 12606ed7257bSPatrick Caulfield entry = kmalloc(sizeof(struct writequeue_entry), allocation); 12616ed7257bSPatrick Caulfield if (!entry) 12626ed7257bSPatrick Caulfield return NULL; 12636ed7257bSPatrick Caulfield 12646ed7257bSPatrick Caulfield entry->page = alloc_page(allocation); 12656ed7257bSPatrick Caulfield if (!entry->page) { 12666ed7257bSPatrick Caulfield kfree(entry); 12676ed7257bSPatrick Caulfield return NULL; 12686ed7257bSPatrick Caulfield } 12696ed7257bSPatrick Caulfield 12706ed7257bSPatrick Caulfield entry->offset = 0; 12716ed7257bSPatrick Caulfield entry->len = 0; 12726ed7257bSPatrick Caulfield entry->end = 0; 12736ed7257bSPatrick Caulfield entry->users = 0; 12746ed7257bSPatrick Caulfield entry->con = con; 12756ed7257bSPatrick Caulfield 12766ed7257bSPatrick Caulfield return entry; 12776ed7257bSPatrick Caulfield } 12786ed7257bSPatrick Caulfield 1279617e82e1SDavid Teigland void *dlm_lowcomms_get_buffer(int nodeid, int len, gfp_t allocation, char **ppc) 12806ed7257bSPatrick Caulfield { 12816ed7257bSPatrick Caulfield struct connection *con; 12826ed7257bSPatrick Caulfield struct writequeue_entry *e; 12836ed7257bSPatrick Caulfield int offset = 0; 12846ed7257bSPatrick Caulfield 12856ed7257bSPatrick Caulfield con = nodeid2con(nodeid, allocation); 12866ed7257bSPatrick Caulfield if (!con) 12876ed7257bSPatrick Caulfield return NULL; 12886ed7257bSPatrick Caulfield 12896ed7257bSPatrick Caulfield spin_lock(&con->writequeue_lock); 12906ed7257bSPatrick Caulfield e = list_entry(con->writequeue.prev, struct writequeue_entry, list); 12916ed7257bSPatrick Caulfield if ((&e->list == &con->writequeue) || 129209cbfeafSKirill A. Shutemov (PAGE_SIZE - e->end < len)) { 12936ed7257bSPatrick Caulfield e = NULL; 12946ed7257bSPatrick Caulfield } else { 12956ed7257bSPatrick Caulfield offset = e->end; 12966ed7257bSPatrick Caulfield e->end += len; 1297eeee2b5fSWei Yongjun e->users++; 12986ed7257bSPatrick Caulfield } 12996ed7257bSPatrick Caulfield spin_unlock(&con->writequeue_lock); 13006ed7257bSPatrick Caulfield 13016ed7257bSPatrick Caulfield if (e) { 13026ed7257bSPatrick Caulfield got_one: 13036ed7257bSPatrick Caulfield *ppc = page_address(e->page) + offset; 13046ed7257bSPatrick Caulfield return e; 13056ed7257bSPatrick Caulfield } 13066ed7257bSPatrick Caulfield 13076ed7257bSPatrick Caulfield e = new_writequeue_entry(con, allocation); 13086ed7257bSPatrick Caulfield if (e) { 13096ed7257bSPatrick Caulfield spin_lock(&con->writequeue_lock); 13106ed7257bSPatrick Caulfield offset = e->end; 13116ed7257bSPatrick Caulfield e->end += len; 1312eeee2b5fSWei Yongjun e->users++; 13136ed7257bSPatrick Caulfield list_add_tail(&e->list, &con->writequeue); 13146ed7257bSPatrick Caulfield spin_unlock(&con->writequeue_lock); 13156ed7257bSPatrick Caulfield goto got_one; 13166ed7257bSPatrick Caulfield } 13176ed7257bSPatrick Caulfield return NULL; 13186ed7257bSPatrick Caulfield } 13196ed7257bSPatrick Caulfield 13206ed7257bSPatrick Caulfield void dlm_lowcomms_commit_buffer(void *mh) 13216ed7257bSPatrick Caulfield { 13226ed7257bSPatrick Caulfield struct writequeue_entry *e = (struct writequeue_entry *)mh; 13236ed7257bSPatrick Caulfield struct connection *con = e->con; 13246ed7257bSPatrick Caulfield int users; 13256ed7257bSPatrick Caulfield 13266ed7257bSPatrick Caulfield spin_lock(&con->writequeue_lock); 13276ed7257bSPatrick Caulfield users = --e->users; 13286ed7257bSPatrick Caulfield if (users) 13296ed7257bSPatrick Caulfield goto out; 13306ed7257bSPatrick Caulfield e->len = e->end - e->offset; 13316ed7257bSPatrick Caulfield spin_unlock(&con->writequeue_lock); 13326ed7257bSPatrick Caulfield 13336ed7257bSPatrick Caulfield queue_work(send_workqueue, &con->swork); 13346ed7257bSPatrick Caulfield return; 13356ed7257bSPatrick Caulfield 13366ed7257bSPatrick Caulfield out: 13376ed7257bSPatrick Caulfield spin_unlock(&con->writequeue_lock); 13386ed7257bSPatrick Caulfield return; 13396ed7257bSPatrick Caulfield } 13406ed7257bSPatrick Caulfield 13416ed7257bSPatrick Caulfield /* Send a message */ 13426ed7257bSPatrick Caulfield static void send_to_sock(struct connection *con) 13436ed7257bSPatrick Caulfield { 13446ed7257bSPatrick Caulfield int ret = 0; 13456ed7257bSPatrick Caulfield const int msg_flags = MSG_DONTWAIT | MSG_NOSIGNAL; 13466ed7257bSPatrick Caulfield struct writequeue_entry *e; 13476ed7257bSPatrick Caulfield int len, offset; 1348f92c8dd7SBob Peterson int count = 0; 13496ed7257bSPatrick Caulfield 13506ed7257bSPatrick Caulfield mutex_lock(&con->sock_mutex); 13516ed7257bSPatrick Caulfield if (con->sock == NULL) 13526ed7257bSPatrick Caulfield goto out_connect; 13536ed7257bSPatrick Caulfield 13546ed7257bSPatrick Caulfield spin_lock(&con->writequeue_lock); 13556ed7257bSPatrick Caulfield for (;;) { 13566ed7257bSPatrick Caulfield e = list_entry(con->writequeue.next, struct writequeue_entry, 13576ed7257bSPatrick Caulfield list); 13586ed7257bSPatrick Caulfield if ((struct list_head *) e == &con->writequeue) 13596ed7257bSPatrick Caulfield break; 13606ed7257bSPatrick Caulfield 13616ed7257bSPatrick Caulfield len = e->len; 13626ed7257bSPatrick Caulfield offset = e->offset; 13636ed7257bSPatrick Caulfield BUG_ON(len == 0 && e->users == 0); 13646ed7257bSPatrick Caulfield spin_unlock(&con->writequeue_lock); 13656ed7257bSPatrick Caulfield 13666ed7257bSPatrick Caulfield ret = 0; 13676ed7257bSPatrick Caulfield if (len) { 13681329e3f2SPaolo Bonzini ret = kernel_sendpage(con->sock, e->page, offset, len, 13696ed7257bSPatrick Caulfield msg_flags); 1370d66f8277SPatrick Caulfield if (ret == -EAGAIN || ret == 0) { 1371b36930ddSDavid Miller if (ret == -EAGAIN && 13729cd3e072SEric Dumazet test_bit(SOCKWQ_ASYNC_NOSPACE, &con->sock->flags) && 1373b36930ddSDavid Miller !test_and_set_bit(CF_APP_LIMITED, &con->flags)) { 1374b36930ddSDavid Miller /* Notify TCP that we're limited by the 1375b36930ddSDavid Miller * application window size. 1376b36930ddSDavid Miller */ 1377b36930ddSDavid Miller set_bit(SOCK_NOSPACE, &con->sock->flags); 1378b36930ddSDavid Miller con->sock->sk->sk_write_pending++; 1379b36930ddSDavid Miller } 1380d66f8277SPatrick Caulfield cond_resched(); 13816ed7257bSPatrick Caulfield goto out; 13829c5bef58SYing Xue } else if (ret < 0) 13836ed7257bSPatrick Caulfield goto send_error; 1384d66f8277SPatrick Caulfield } 1385f92c8dd7SBob Peterson 13866ed7257bSPatrick Caulfield /* Don't starve people filling buffers */ 1387f92c8dd7SBob Peterson if (++count >= MAX_SEND_MSG_COUNT) { 13886ed7257bSPatrick Caulfield cond_resched(); 1389f92c8dd7SBob Peterson count = 0; 1390f92c8dd7SBob Peterson } 13916ed7257bSPatrick Caulfield 13926ed7257bSPatrick Caulfield spin_lock(&con->writequeue_lock); 13935d689871SMike Christie writequeue_entry_complete(e, ret); 13946ed7257bSPatrick Caulfield } 13956ed7257bSPatrick Caulfield spin_unlock(&con->writequeue_lock); 13966ed7257bSPatrick Caulfield out: 13976ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 13986ed7257bSPatrick Caulfield return; 13996ed7257bSPatrick Caulfield 14006ed7257bSPatrick Caulfield send_error: 14016ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 1402c553e173Stsutomu.owa@toshiba.co.jp close_connection(con, true, false, true); 140301da24d3SBob Peterson /* Requeue the send work. When the work daemon runs again, it will try 140401da24d3SBob Peterson a new connection, then call this function again. */ 140501da24d3SBob Peterson queue_work(send_workqueue, &con->swork); 14066ed7257bSPatrick Caulfield return; 14076ed7257bSPatrick Caulfield 14086ed7257bSPatrick Caulfield out_connect: 14096ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 141001da24d3SBob Peterson queue_work(send_workqueue, &con->swork); 141101da24d3SBob Peterson cond_resched(); 14126ed7257bSPatrick Caulfield } 14136ed7257bSPatrick Caulfield 14146ed7257bSPatrick Caulfield static void clean_one_writequeue(struct connection *con) 14156ed7257bSPatrick Caulfield { 14165e9ccc37SChristine Caulfield struct writequeue_entry *e, *safe; 14176ed7257bSPatrick Caulfield 14186ed7257bSPatrick Caulfield spin_lock(&con->writequeue_lock); 14195e9ccc37SChristine Caulfield list_for_each_entry_safe(e, safe, &con->writequeue, list) { 14206ed7257bSPatrick Caulfield list_del(&e->list); 14216ed7257bSPatrick Caulfield free_entry(e); 14226ed7257bSPatrick Caulfield } 14236ed7257bSPatrick Caulfield spin_unlock(&con->writequeue_lock); 14246ed7257bSPatrick Caulfield } 14256ed7257bSPatrick Caulfield 14266ed7257bSPatrick Caulfield /* Called from recovery when it knows that a node has 14276ed7257bSPatrick Caulfield left the cluster */ 14286ed7257bSPatrick Caulfield int dlm_lowcomms_close(int nodeid) 14296ed7257bSPatrick Caulfield { 14306ed7257bSPatrick Caulfield struct connection *con; 143136b71a8bSDavid Teigland struct dlm_node_addr *na; 14326ed7257bSPatrick Caulfield 14336ed7257bSPatrick Caulfield log_print("closing connection to node %d", nodeid); 14346ed7257bSPatrick Caulfield con = nodeid2con(nodeid, 0); 14356ed7257bSPatrick Caulfield if (con) { 1436063c4c99SLars Marowsky-Bree set_bit(CF_CLOSE, &con->flags); 14370d737a8cSMarcelo Ricardo Leitner close_connection(con, true, true, true); 14386ed7257bSPatrick Caulfield clean_one_writequeue(con); 14396ed7257bSPatrick Caulfield } 144036b71a8bSDavid Teigland 144136b71a8bSDavid Teigland spin_lock(&dlm_node_addrs_spin); 144236b71a8bSDavid Teigland na = find_node_addr(nodeid); 144336b71a8bSDavid Teigland if (na) { 144436b71a8bSDavid Teigland list_del(&na->list); 144536b71a8bSDavid Teigland while (na->addr_count--) 144636b71a8bSDavid Teigland kfree(na->addr[na->addr_count]); 144736b71a8bSDavid Teigland kfree(na); 144836b71a8bSDavid Teigland } 144936b71a8bSDavid Teigland spin_unlock(&dlm_node_addrs_spin); 145036b71a8bSDavid Teigland 14516ed7257bSPatrick Caulfield return 0; 14526ed7257bSPatrick Caulfield } 14536ed7257bSPatrick Caulfield 14546ed7257bSPatrick Caulfield /* Receive workqueue function */ 14556ed7257bSPatrick Caulfield static void process_recv_sockets(struct work_struct *work) 14566ed7257bSPatrick Caulfield { 14576ed7257bSPatrick Caulfield struct connection *con = container_of(work, struct connection, rwork); 14586ed7257bSPatrick Caulfield int err; 14596ed7257bSPatrick Caulfield 14606ed7257bSPatrick Caulfield clear_bit(CF_READ_PENDING, &con->flags); 14616ed7257bSPatrick Caulfield do { 14626ed7257bSPatrick Caulfield err = con->rx_action(con); 14636ed7257bSPatrick Caulfield } while (!err); 14646ed7257bSPatrick Caulfield } 14656ed7257bSPatrick Caulfield 14666ed7257bSPatrick Caulfield /* Send workqueue function */ 14676ed7257bSPatrick Caulfield static void process_send_sockets(struct work_struct *work) 14686ed7257bSPatrick Caulfield { 14696ed7257bSPatrick Caulfield struct connection *con = container_of(work, struct connection, swork); 14706ed7257bSPatrick Caulfield 14718a4abb08Stsutomu.owa@toshiba.co.jp clear_bit(CF_WRITE_PENDING, &con->flags); 147261d9102bSBob Peterson if (con->sock == NULL) /* not mutex protected so check it inside too */ 14736ed7257bSPatrick Caulfield con->connect_action(con); 147401da24d3SBob Peterson if (!list_empty(&con->writequeue)) 14756ed7257bSPatrick Caulfield send_to_sock(con); 14766ed7257bSPatrick Caulfield } 14776ed7257bSPatrick Caulfield 14786ed7257bSPatrick Caulfield 14796ed7257bSPatrick Caulfield /* Discard all entries on the write queues */ 14806ed7257bSPatrick Caulfield static void clean_writequeues(void) 14816ed7257bSPatrick Caulfield { 14825e9ccc37SChristine Caulfield foreach_conn(clean_one_writequeue); 14836ed7257bSPatrick Caulfield } 14846ed7257bSPatrick Caulfield 14856ed7257bSPatrick Caulfield static void work_stop(void) 14866ed7257bSPatrick Caulfield { 1487b355516fSDavid Windsor if (recv_workqueue) 14886ed7257bSPatrick Caulfield destroy_workqueue(recv_workqueue); 1489b355516fSDavid Windsor if (send_workqueue) 14906ed7257bSPatrick Caulfield destroy_workqueue(send_workqueue); 14916ed7257bSPatrick Caulfield } 14926ed7257bSPatrick Caulfield 14936ed7257bSPatrick Caulfield static int work_start(void) 14946ed7257bSPatrick Caulfield { 1495e43f055aSDavid Teigland recv_workqueue = alloc_workqueue("dlm_recv", 1496e43f055aSDavid Teigland WQ_UNBOUND | WQ_MEM_RECLAIM, 1); 1497b9d41052SNamhyung Kim if (!recv_workqueue) { 1498b9d41052SNamhyung Kim log_print("can't start dlm_recv"); 1499b9d41052SNamhyung Kim return -ENOMEM; 15006ed7257bSPatrick Caulfield } 15016ed7257bSPatrick Caulfield 1502e43f055aSDavid Teigland send_workqueue = alloc_workqueue("dlm_send", 1503e43f055aSDavid Teigland WQ_UNBOUND | WQ_MEM_RECLAIM, 1); 1504b9d41052SNamhyung Kim if (!send_workqueue) { 1505b9d41052SNamhyung Kim log_print("can't start dlm_send"); 15066ed7257bSPatrick Caulfield destroy_workqueue(recv_workqueue); 1507b9d41052SNamhyung Kim return -ENOMEM; 15086ed7257bSPatrick Caulfield } 15096ed7257bSPatrick Caulfield 15106ed7257bSPatrick Caulfield return 0; 15116ed7257bSPatrick Caulfield } 15126ed7257bSPatrick Caulfield 1513f0fb83cbStsutomu.owa@toshiba.co.jp static void _stop_conn(struct connection *con, bool and_other) 15146ed7257bSPatrick Caulfield { 1515f0fb83cbStsutomu.owa@toshiba.co.jp mutex_lock(&con->sock_mutex); 1516173a31feStsutomu.owa@toshiba.co.jp set_bit(CF_CLOSE, &con->flags); 1517f0fb83cbStsutomu.owa@toshiba.co.jp set_bit(CF_READ_PENDING, &con->flags); 15188a4abb08Stsutomu.owa@toshiba.co.jp set_bit(CF_WRITE_PENDING, &con->flags); 151993eaadebStsutomu.owa@toshiba.co.jp if (con->sock && con->sock->sk) { 152093eaadebStsutomu.owa@toshiba.co.jp write_lock_bh(&con->sock->sk->sk_callback_lock); 1521afb853fbSPatrick Caulfield con->sock->sk->sk_user_data = NULL; 152293eaadebStsutomu.owa@toshiba.co.jp write_unlock_bh(&con->sock->sk->sk_callback_lock); 152393eaadebStsutomu.owa@toshiba.co.jp } 1524f0fb83cbStsutomu.owa@toshiba.co.jp if (con->othercon && and_other) 1525f0fb83cbStsutomu.owa@toshiba.co.jp _stop_conn(con->othercon, false); 1526f0fb83cbStsutomu.owa@toshiba.co.jp mutex_unlock(&con->sock_mutex); 1527f0fb83cbStsutomu.owa@toshiba.co.jp } 1528f0fb83cbStsutomu.owa@toshiba.co.jp 1529f0fb83cbStsutomu.owa@toshiba.co.jp static void stop_conn(struct connection *con) 1530f0fb83cbStsutomu.owa@toshiba.co.jp { 1531f0fb83cbStsutomu.owa@toshiba.co.jp _stop_conn(con, true); 1532afb853fbSPatrick Caulfield } 15335e9ccc37SChristine Caulfield 15345e9ccc37SChristine Caulfield static void free_conn(struct connection *con) 15355e9ccc37SChristine Caulfield { 15360d737a8cSMarcelo Ricardo Leitner close_connection(con, true, true, true); 15375e9ccc37SChristine Caulfield if (con->othercon) 15385e9ccc37SChristine Caulfield kmem_cache_free(con_cache, con->othercon); 15395e9ccc37SChristine Caulfield hlist_del(&con->list); 15405e9ccc37SChristine Caulfield kmem_cache_free(con_cache, con); 15416ed7257bSPatrick Caulfield } 15425e9ccc37SChristine Caulfield 1543f0fb83cbStsutomu.owa@toshiba.co.jp static void work_flush(void) 1544f0fb83cbStsutomu.owa@toshiba.co.jp { 1545f0fb83cbStsutomu.owa@toshiba.co.jp int ok; 1546f0fb83cbStsutomu.owa@toshiba.co.jp int i; 1547f0fb83cbStsutomu.owa@toshiba.co.jp struct hlist_node *n; 1548f0fb83cbStsutomu.owa@toshiba.co.jp struct connection *con; 1549f0fb83cbStsutomu.owa@toshiba.co.jp 1550b355516fSDavid Windsor if (recv_workqueue) 1551f0fb83cbStsutomu.owa@toshiba.co.jp flush_workqueue(recv_workqueue); 1552b355516fSDavid Windsor if (send_workqueue) 1553f0fb83cbStsutomu.owa@toshiba.co.jp flush_workqueue(send_workqueue); 1554f0fb83cbStsutomu.owa@toshiba.co.jp do { 1555f0fb83cbStsutomu.owa@toshiba.co.jp ok = 1; 1556f0fb83cbStsutomu.owa@toshiba.co.jp foreach_conn(stop_conn); 1557b355516fSDavid Windsor if (recv_workqueue) 1558f0fb83cbStsutomu.owa@toshiba.co.jp flush_workqueue(recv_workqueue); 1559b355516fSDavid Windsor if (send_workqueue) 1560f0fb83cbStsutomu.owa@toshiba.co.jp flush_workqueue(send_workqueue); 1561f0fb83cbStsutomu.owa@toshiba.co.jp for (i = 0; i < CONN_HASH_SIZE && ok; i++) { 1562f0fb83cbStsutomu.owa@toshiba.co.jp hlist_for_each_entry_safe(con, n, 1563f0fb83cbStsutomu.owa@toshiba.co.jp &connection_hash[i], list) { 1564f0fb83cbStsutomu.owa@toshiba.co.jp ok &= test_bit(CF_READ_PENDING, &con->flags); 15658a4abb08Stsutomu.owa@toshiba.co.jp ok &= test_bit(CF_WRITE_PENDING, &con->flags); 15668a4abb08Stsutomu.owa@toshiba.co.jp if (con->othercon) { 1567f0fb83cbStsutomu.owa@toshiba.co.jp ok &= test_bit(CF_READ_PENDING, 1568f0fb83cbStsutomu.owa@toshiba.co.jp &con->othercon->flags); 15698a4abb08Stsutomu.owa@toshiba.co.jp ok &= test_bit(CF_WRITE_PENDING, 15708a4abb08Stsutomu.owa@toshiba.co.jp &con->othercon->flags); 15718a4abb08Stsutomu.owa@toshiba.co.jp } 1572f0fb83cbStsutomu.owa@toshiba.co.jp } 1573f0fb83cbStsutomu.owa@toshiba.co.jp } 1574f0fb83cbStsutomu.owa@toshiba.co.jp } while (!ok); 1575f0fb83cbStsutomu.owa@toshiba.co.jp } 1576f0fb83cbStsutomu.owa@toshiba.co.jp 15775e9ccc37SChristine Caulfield void dlm_lowcomms_stop(void) 15785e9ccc37SChristine Caulfield { 15795e9ccc37SChristine Caulfield /* Set all the flags to prevent any 15805e9ccc37SChristine Caulfield socket activity. 15815e9ccc37SChristine Caulfield */ 15825e9ccc37SChristine Caulfield mutex_lock(&connections_lock); 1583513ef596SDavid Teigland dlm_allow_conn = 0; 1584f0fb83cbStsutomu.owa@toshiba.co.jp mutex_unlock(&connections_lock); 1585f0fb83cbStsutomu.owa@toshiba.co.jp work_flush(); 15863a8db798SMarcelo Ricardo Leitner clean_writequeues(); 15873a8db798SMarcelo Ricardo Leitner foreach_conn(free_conn); 15886ed7257bSPatrick Caulfield work_stop(); 15896ed7257bSPatrick Caulfield 15906ed7257bSPatrick Caulfield kmem_cache_destroy(con_cache); 15916ed7257bSPatrick Caulfield } 15926ed7257bSPatrick Caulfield 15936ed7257bSPatrick Caulfield int dlm_lowcomms_start(void) 15946ed7257bSPatrick Caulfield { 15956ed7257bSPatrick Caulfield int error = -EINVAL; 15966ed7257bSPatrick Caulfield struct connection *con; 15975e9ccc37SChristine Caulfield int i; 15985e9ccc37SChristine Caulfield 15995e9ccc37SChristine Caulfield for (i = 0; i < CONN_HASH_SIZE; i++) 16005e9ccc37SChristine Caulfield INIT_HLIST_HEAD(&connection_hash[i]); 16016ed7257bSPatrick Caulfield 16026ed7257bSPatrick Caulfield init_local(); 16036ed7257bSPatrick Caulfield if (!dlm_local_count) { 1604617e82e1SDavid Teigland error = -ENOTCONN; 16056ed7257bSPatrick Caulfield log_print("no local IP address has been set"); 1606513ef596SDavid Teigland goto fail; 16076ed7257bSPatrick Caulfield } 16086ed7257bSPatrick Caulfield 16096ed7257bSPatrick Caulfield error = -ENOMEM; 16106ed7257bSPatrick Caulfield con_cache = kmem_cache_create("dlm_conn", sizeof(struct connection), 16116ed7257bSPatrick Caulfield __alignof__(struct connection), 0, 161220c2df83SPaul Mundt NULL); 16136ed7257bSPatrick Caulfield if (!con_cache) 1614513ef596SDavid Teigland goto fail; 1615513ef596SDavid Teigland 1616513ef596SDavid Teigland error = work_start(); 1617513ef596SDavid Teigland if (error) 1618513ef596SDavid Teigland goto fail_destroy; 1619513ef596SDavid Teigland 1620513ef596SDavid Teigland dlm_allow_conn = 1; 16216ed7257bSPatrick Caulfield 16226ed7257bSPatrick Caulfield /* Start listening */ 16236ed7257bSPatrick Caulfield if (dlm_config.ci_protocol == 0) 16246ed7257bSPatrick Caulfield error = tcp_listen_for_all(); 16256ed7257bSPatrick Caulfield else 16266ed7257bSPatrick Caulfield error = sctp_listen_for_all(); 16276ed7257bSPatrick Caulfield if (error) 16286ed7257bSPatrick Caulfield goto fail_unlisten; 16296ed7257bSPatrick Caulfield 16306ed7257bSPatrick Caulfield return 0; 16316ed7257bSPatrick Caulfield 16326ed7257bSPatrick Caulfield fail_unlisten: 1633513ef596SDavid Teigland dlm_allow_conn = 0; 16346ed7257bSPatrick Caulfield con = nodeid2con(0,0); 16356ed7257bSPatrick Caulfield if (con) { 16360d737a8cSMarcelo Ricardo Leitner close_connection(con, false, true, true); 16376ed7257bSPatrick Caulfield kmem_cache_free(con_cache, con); 16386ed7257bSPatrick Caulfield } 1639513ef596SDavid Teigland fail_destroy: 16406ed7257bSPatrick Caulfield kmem_cache_destroy(con_cache); 1641513ef596SDavid Teigland fail: 16426ed7257bSPatrick Caulfield return error; 16436ed7257bSPatrick Caulfield } 164436b71a8bSDavid Teigland 164536b71a8bSDavid Teigland void dlm_lowcomms_exit(void) 164636b71a8bSDavid Teigland { 164736b71a8bSDavid Teigland struct dlm_node_addr *na, *safe; 164836b71a8bSDavid Teigland 164936b71a8bSDavid Teigland spin_lock(&dlm_node_addrs_spin); 165036b71a8bSDavid Teigland list_for_each_entry_safe(na, safe, &dlm_node_addrs, list) { 165136b71a8bSDavid Teigland list_del(&na->list); 165236b71a8bSDavid Teigland while (na->addr_count--) 165336b71a8bSDavid Teigland kfree(na->addr[na->addr_count]); 165436b71a8bSDavid Teigland kfree(na); 165536b71a8bSDavid Teigland } 165636b71a8bSDavid Teigland spin_unlock(&dlm_node_addrs_spin); 165736b71a8bSDavid Teigland } 1658