16ed7257bSPatrick Caulfield /****************************************************************************** 26ed7257bSPatrick Caulfield ******************************************************************************* 36ed7257bSPatrick Caulfield ** 46ed7257bSPatrick Caulfield ** Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved. 55e9ccc37SChristine Caulfield ** Copyright (C) 2004-2009 Red Hat, Inc. All rights reserved. 66ed7257bSPatrick Caulfield ** 76ed7257bSPatrick Caulfield ** This copyrighted material is made available to anyone wishing to use, 86ed7257bSPatrick Caulfield ** modify, copy, or redistribute it subject to the terms and conditions 96ed7257bSPatrick Caulfield ** of the GNU General Public License v.2. 106ed7257bSPatrick Caulfield ** 116ed7257bSPatrick Caulfield ******************************************************************************* 126ed7257bSPatrick Caulfield ******************************************************************************/ 136ed7257bSPatrick Caulfield 146ed7257bSPatrick Caulfield /* 156ed7257bSPatrick Caulfield * lowcomms.c 166ed7257bSPatrick Caulfield * 176ed7257bSPatrick Caulfield * This is the "low-level" comms layer. 186ed7257bSPatrick Caulfield * 196ed7257bSPatrick Caulfield * It is responsible for sending/receiving messages 206ed7257bSPatrick Caulfield * from other nodes in the cluster. 216ed7257bSPatrick Caulfield * 226ed7257bSPatrick Caulfield * Cluster nodes are referred to by their nodeids. nodeids are 236ed7257bSPatrick Caulfield * simply 32 bit numbers to the locking module - if they need to 242cf12c0bSJoe Perches * be expanded for the cluster infrastructure then that is its 256ed7257bSPatrick Caulfield * responsibility. It is this layer's 266ed7257bSPatrick Caulfield * responsibility to resolve these into IP address or 276ed7257bSPatrick Caulfield * whatever it needs for inter-node communication. 286ed7257bSPatrick Caulfield * 296ed7257bSPatrick Caulfield * The comms level is two kernel threads that deal mainly with 306ed7257bSPatrick Caulfield * the receiving of messages from other nodes and passing them 316ed7257bSPatrick Caulfield * up to the mid-level comms layer (which understands the 326ed7257bSPatrick Caulfield * message format) for execution by the locking core, and 336ed7257bSPatrick Caulfield * a send thread which does all the setting up of connections 346ed7257bSPatrick Caulfield * to remote nodes and the sending of data. Threads are not allowed 356ed7257bSPatrick Caulfield * to send their own data because it may cause them to wait in times 366ed7257bSPatrick Caulfield * of high load. Also, this way, the sending thread can collect together 376ed7257bSPatrick Caulfield * messages bound for one node and send them in one block. 386ed7257bSPatrick Caulfield * 392cf12c0bSJoe Perches * lowcomms will choose to use either TCP or SCTP as its transport layer 406ed7257bSPatrick Caulfield * depending on the configuration variable 'protocol'. This should be set 416ed7257bSPatrick Caulfield * to 0 (default) for TCP or 1 for SCTP. It should be configured using a 426ed7257bSPatrick Caulfield * cluster-wide mechanism as it must be the same on all nodes of the cluster 436ed7257bSPatrick Caulfield * for the DLM to function. 446ed7257bSPatrick Caulfield * 456ed7257bSPatrick Caulfield */ 466ed7257bSPatrick Caulfield 476ed7257bSPatrick Caulfield #include <asm/ioctls.h> 486ed7257bSPatrick Caulfield #include <net/sock.h> 496ed7257bSPatrick Caulfield #include <net/tcp.h> 506ed7257bSPatrick Caulfield #include <linux/pagemap.h> 516ed7257bSPatrick Caulfield #include <linux/file.h> 527a936ce7SMatthias Kaehlcke #include <linux/mutex.h> 536ed7257bSPatrick Caulfield #include <linux/sctp.h> 545a0e3ad6STejun Heo #include <linux/slab.h> 552f2d76ccSBenjamin Poirier #include <net/sctp/sctp.h> 5644ad532bSJoe Perches #include <net/ipv6.h> 576ed7257bSPatrick Caulfield 586ed7257bSPatrick Caulfield #include "dlm_internal.h" 596ed7257bSPatrick Caulfield #include "lowcomms.h" 606ed7257bSPatrick Caulfield #include "midcomms.h" 616ed7257bSPatrick Caulfield #include "config.h" 626ed7257bSPatrick Caulfield 636ed7257bSPatrick Caulfield #define NEEDED_RMEM (4*1024*1024) 645e9ccc37SChristine Caulfield #define CONN_HASH_SIZE 32 656ed7257bSPatrick Caulfield 66f92c8dd7SBob Peterson /* Number of messages to send before rescheduling */ 67f92c8dd7SBob Peterson #define MAX_SEND_MSG_COUNT 25 68f92c8dd7SBob Peterson 696ed7257bSPatrick Caulfield struct cbuf { 706ed7257bSPatrick Caulfield unsigned int base; 716ed7257bSPatrick Caulfield unsigned int len; 726ed7257bSPatrick Caulfield unsigned int mask; 736ed7257bSPatrick Caulfield }; 746ed7257bSPatrick Caulfield 756ed7257bSPatrick Caulfield static void cbuf_add(struct cbuf *cb, int n) 766ed7257bSPatrick Caulfield { 776ed7257bSPatrick Caulfield cb->len += n; 786ed7257bSPatrick Caulfield } 796ed7257bSPatrick Caulfield 806ed7257bSPatrick Caulfield static int cbuf_data(struct cbuf *cb) 816ed7257bSPatrick Caulfield { 826ed7257bSPatrick Caulfield return ((cb->base + cb->len) & cb->mask); 836ed7257bSPatrick Caulfield } 846ed7257bSPatrick Caulfield 856ed7257bSPatrick Caulfield static void cbuf_init(struct cbuf *cb, int size) 866ed7257bSPatrick Caulfield { 876ed7257bSPatrick Caulfield cb->base = cb->len = 0; 886ed7257bSPatrick Caulfield cb->mask = size-1; 896ed7257bSPatrick Caulfield } 906ed7257bSPatrick Caulfield 916ed7257bSPatrick Caulfield static void cbuf_eat(struct cbuf *cb, int n) 926ed7257bSPatrick Caulfield { 936ed7257bSPatrick Caulfield cb->len -= n; 946ed7257bSPatrick Caulfield cb->base += n; 956ed7257bSPatrick Caulfield cb->base &= cb->mask; 966ed7257bSPatrick Caulfield } 976ed7257bSPatrick Caulfield 986ed7257bSPatrick Caulfield static bool cbuf_empty(struct cbuf *cb) 996ed7257bSPatrick Caulfield { 1006ed7257bSPatrick Caulfield return cb->len == 0; 1016ed7257bSPatrick Caulfield } 1026ed7257bSPatrick Caulfield 1036ed7257bSPatrick Caulfield struct connection { 1046ed7257bSPatrick Caulfield struct socket *sock; /* NULL if not connected */ 1056ed7257bSPatrick Caulfield uint32_t nodeid; /* So we know who we are in the list */ 1066ed7257bSPatrick Caulfield struct mutex sock_mutex; 1076ed7257bSPatrick Caulfield unsigned long flags; 1086ed7257bSPatrick Caulfield #define CF_READ_PENDING 1 1096ed7257bSPatrick Caulfield #define CF_WRITE_PENDING 2 1106ed7257bSPatrick Caulfield #define CF_CONNECT_PENDING 3 1116ed7257bSPatrick Caulfield #define CF_INIT_PENDING 4 1126ed7257bSPatrick Caulfield #define CF_IS_OTHERCON 5 113063c4c99SLars Marowsky-Bree #define CF_CLOSE 6 114b36930ddSDavid Miller #define CF_APP_LIMITED 7 1156ed7257bSPatrick Caulfield struct list_head writequeue; /* List of outgoing writequeue_entries */ 1166ed7257bSPatrick Caulfield spinlock_t writequeue_lock; 1176ed7257bSPatrick Caulfield int (*rx_action) (struct connection *); /* What to do when active */ 1186ed7257bSPatrick Caulfield void (*connect_action) (struct connection *); /* What to do to connect */ 1196ed7257bSPatrick Caulfield struct page *rx_page; 1206ed7257bSPatrick Caulfield struct cbuf cb; 1216ed7257bSPatrick Caulfield int retries; 1226ed7257bSPatrick Caulfield #define MAX_CONNECT_RETRIES 3 1235e9ccc37SChristine Caulfield struct hlist_node list; 1246ed7257bSPatrick Caulfield struct connection *othercon; 1256ed7257bSPatrick Caulfield struct work_struct rwork; /* Receive workqueue */ 1266ed7257bSPatrick Caulfield struct work_struct swork; /* Send workqueue */ 127b3a5bbfdSBob Peterson void (*orig_error_report)(struct sock *sk); 1286ed7257bSPatrick Caulfield }; 1296ed7257bSPatrick Caulfield #define sock2con(x) ((struct connection *)(x)->sk_user_data) 1306ed7257bSPatrick Caulfield 1316ed7257bSPatrick Caulfield /* An entry waiting to be sent */ 1326ed7257bSPatrick Caulfield struct writequeue_entry { 1336ed7257bSPatrick Caulfield struct list_head list; 1346ed7257bSPatrick Caulfield struct page *page; 1356ed7257bSPatrick Caulfield int offset; 1366ed7257bSPatrick Caulfield int len; 1376ed7257bSPatrick Caulfield int end; 1386ed7257bSPatrick Caulfield int users; 1396ed7257bSPatrick Caulfield struct connection *con; 1406ed7257bSPatrick Caulfield }; 1416ed7257bSPatrick Caulfield 14236b71a8bSDavid Teigland struct dlm_node_addr { 14336b71a8bSDavid Teigland struct list_head list; 14436b71a8bSDavid Teigland int nodeid; 14536b71a8bSDavid Teigland int addr_count; 14698e1b60eSMike Christie int curr_addr_index; 14736b71a8bSDavid Teigland struct sockaddr_storage *addr[DLM_MAX_ADDR_COUNT]; 14836b71a8bSDavid Teigland }; 14936b71a8bSDavid Teigland 15036b71a8bSDavid Teigland static LIST_HEAD(dlm_node_addrs); 15136b71a8bSDavid Teigland static DEFINE_SPINLOCK(dlm_node_addrs_spin); 15236b71a8bSDavid Teigland 1536ed7257bSPatrick Caulfield static struct sockaddr_storage *dlm_local_addr[DLM_MAX_ADDR_COUNT]; 1546ed7257bSPatrick Caulfield static int dlm_local_count; 155513ef596SDavid Teigland static int dlm_allow_conn; 1566ed7257bSPatrick Caulfield 1576ed7257bSPatrick Caulfield /* Work queues */ 1586ed7257bSPatrick Caulfield static struct workqueue_struct *recv_workqueue; 1596ed7257bSPatrick Caulfield static struct workqueue_struct *send_workqueue; 1606ed7257bSPatrick Caulfield 1615e9ccc37SChristine Caulfield static struct hlist_head connection_hash[CONN_HASH_SIZE]; 1627a936ce7SMatthias Kaehlcke static DEFINE_MUTEX(connections_lock); 1636ed7257bSPatrick Caulfield static struct kmem_cache *con_cache; 1646ed7257bSPatrick Caulfield 1656ed7257bSPatrick Caulfield static void process_recv_sockets(struct work_struct *work); 1666ed7257bSPatrick Caulfield static void process_send_sockets(struct work_struct *work); 1676ed7257bSPatrick Caulfield 1685e9ccc37SChristine Caulfield 1695e9ccc37SChristine Caulfield /* This is deliberately very simple because most clusters have simple 1705e9ccc37SChristine Caulfield sequential nodeids, so we should be able to go straight to a connection 1715e9ccc37SChristine Caulfield struct in the array */ 1725e9ccc37SChristine Caulfield static inline int nodeid_hash(int nodeid) 1735e9ccc37SChristine Caulfield { 1745e9ccc37SChristine Caulfield return nodeid & (CONN_HASH_SIZE-1); 1755e9ccc37SChristine Caulfield } 1765e9ccc37SChristine Caulfield 1775e9ccc37SChristine Caulfield static struct connection *__find_con(int nodeid) 1785e9ccc37SChristine Caulfield { 1795e9ccc37SChristine Caulfield int r; 1805e9ccc37SChristine Caulfield struct connection *con; 1815e9ccc37SChristine Caulfield 1825e9ccc37SChristine Caulfield r = nodeid_hash(nodeid); 1835e9ccc37SChristine Caulfield 184b67bfe0dSSasha Levin hlist_for_each_entry(con, &connection_hash[r], list) { 1855e9ccc37SChristine Caulfield if (con->nodeid == nodeid) 1865e9ccc37SChristine Caulfield return con; 1875e9ccc37SChristine Caulfield } 1885e9ccc37SChristine Caulfield return NULL; 1895e9ccc37SChristine Caulfield } 1905e9ccc37SChristine Caulfield 1916ed7257bSPatrick Caulfield /* 1926ed7257bSPatrick Caulfield * If 'allocation' is zero then we don't attempt to create a new 1936ed7257bSPatrick Caulfield * connection structure for this node. 1946ed7257bSPatrick Caulfield */ 1956ed7257bSPatrick Caulfield static struct connection *__nodeid2con(int nodeid, gfp_t alloc) 1966ed7257bSPatrick Caulfield { 1976ed7257bSPatrick Caulfield struct connection *con = NULL; 1986ed7257bSPatrick Caulfield int r; 1996ed7257bSPatrick Caulfield 2005e9ccc37SChristine Caulfield con = __find_con(nodeid); 2016ed7257bSPatrick Caulfield if (con || !alloc) 2026ed7257bSPatrick Caulfield return con; 2036ed7257bSPatrick Caulfield 2046ed7257bSPatrick Caulfield con = kmem_cache_zalloc(con_cache, alloc); 2056ed7257bSPatrick Caulfield if (!con) 2066ed7257bSPatrick Caulfield return NULL; 2076ed7257bSPatrick Caulfield 2085e9ccc37SChristine Caulfield r = nodeid_hash(nodeid); 2095e9ccc37SChristine Caulfield hlist_add_head(&con->list, &connection_hash[r]); 2106ed7257bSPatrick Caulfield 2116ed7257bSPatrick Caulfield con->nodeid = nodeid; 2126ed7257bSPatrick Caulfield mutex_init(&con->sock_mutex); 2136ed7257bSPatrick Caulfield INIT_LIST_HEAD(&con->writequeue); 2146ed7257bSPatrick Caulfield spin_lock_init(&con->writequeue_lock); 2156ed7257bSPatrick Caulfield INIT_WORK(&con->swork, process_send_sockets); 2166ed7257bSPatrick Caulfield INIT_WORK(&con->rwork, process_recv_sockets); 2176ed7257bSPatrick Caulfield 2186ed7257bSPatrick Caulfield /* Setup action pointers for child sockets */ 2196ed7257bSPatrick Caulfield if (con->nodeid) { 2205e9ccc37SChristine Caulfield struct connection *zerocon = __find_con(0); 2216ed7257bSPatrick Caulfield 2226ed7257bSPatrick Caulfield con->connect_action = zerocon->connect_action; 2236ed7257bSPatrick Caulfield if (!con->rx_action) 2246ed7257bSPatrick Caulfield con->rx_action = zerocon->rx_action; 2256ed7257bSPatrick Caulfield } 2266ed7257bSPatrick Caulfield 2276ed7257bSPatrick Caulfield return con; 2286ed7257bSPatrick Caulfield } 2296ed7257bSPatrick Caulfield 2305e9ccc37SChristine Caulfield /* Loop round all connections */ 2315e9ccc37SChristine Caulfield static void foreach_conn(void (*conn_func)(struct connection *c)) 2325e9ccc37SChristine Caulfield { 2335e9ccc37SChristine Caulfield int i; 234b67bfe0dSSasha Levin struct hlist_node *n; 2355e9ccc37SChristine Caulfield struct connection *con; 2365e9ccc37SChristine Caulfield 2375e9ccc37SChristine Caulfield for (i = 0; i < CONN_HASH_SIZE; i++) { 238b67bfe0dSSasha Levin hlist_for_each_entry_safe(con, n, &connection_hash[i], list) 2395e9ccc37SChristine Caulfield conn_func(con); 2405e9ccc37SChristine Caulfield } 2415e9ccc37SChristine Caulfield } 2425e9ccc37SChristine Caulfield 2436ed7257bSPatrick Caulfield static struct connection *nodeid2con(int nodeid, gfp_t allocation) 2446ed7257bSPatrick Caulfield { 2456ed7257bSPatrick Caulfield struct connection *con; 2466ed7257bSPatrick Caulfield 2477a936ce7SMatthias Kaehlcke mutex_lock(&connections_lock); 2486ed7257bSPatrick Caulfield con = __nodeid2con(nodeid, allocation); 2497a936ce7SMatthias Kaehlcke mutex_unlock(&connections_lock); 2506ed7257bSPatrick Caulfield 2516ed7257bSPatrick Caulfield return con; 2526ed7257bSPatrick Caulfield } 2536ed7257bSPatrick Caulfield 25436b71a8bSDavid Teigland static struct dlm_node_addr *find_node_addr(int nodeid) 2556ed7257bSPatrick Caulfield { 25636b71a8bSDavid Teigland struct dlm_node_addr *na; 25736b71a8bSDavid Teigland 25836b71a8bSDavid Teigland list_for_each_entry(na, &dlm_node_addrs, list) { 25936b71a8bSDavid Teigland if (na->nodeid == nodeid) 26036b71a8bSDavid Teigland return na; 26136b71a8bSDavid Teigland } 26236b71a8bSDavid Teigland return NULL; 26336b71a8bSDavid Teigland } 26436b71a8bSDavid Teigland 26536b71a8bSDavid Teigland static int addr_compare(struct sockaddr_storage *x, struct sockaddr_storage *y) 26636b71a8bSDavid Teigland { 26736b71a8bSDavid Teigland switch (x->ss_family) { 26836b71a8bSDavid Teigland case AF_INET: { 26936b71a8bSDavid Teigland struct sockaddr_in *sinx = (struct sockaddr_in *)x; 27036b71a8bSDavid Teigland struct sockaddr_in *siny = (struct sockaddr_in *)y; 27136b71a8bSDavid Teigland if (sinx->sin_addr.s_addr != siny->sin_addr.s_addr) 27236b71a8bSDavid Teigland return 0; 27336b71a8bSDavid Teigland if (sinx->sin_port != siny->sin_port) 27436b71a8bSDavid Teigland return 0; 27536b71a8bSDavid Teigland break; 27636b71a8bSDavid Teigland } 27736b71a8bSDavid Teigland case AF_INET6: { 27836b71a8bSDavid Teigland struct sockaddr_in6 *sinx = (struct sockaddr_in6 *)x; 27936b71a8bSDavid Teigland struct sockaddr_in6 *siny = (struct sockaddr_in6 *)y; 28036b71a8bSDavid Teigland if (!ipv6_addr_equal(&sinx->sin6_addr, &siny->sin6_addr)) 28136b71a8bSDavid Teigland return 0; 28236b71a8bSDavid Teigland if (sinx->sin6_port != siny->sin6_port) 28336b71a8bSDavid Teigland return 0; 28436b71a8bSDavid Teigland break; 28536b71a8bSDavid Teigland } 28636b71a8bSDavid Teigland default: 28736b71a8bSDavid Teigland return 0; 28836b71a8bSDavid Teigland } 28936b71a8bSDavid Teigland return 1; 29036b71a8bSDavid Teigland } 29136b71a8bSDavid Teigland 29236b71a8bSDavid Teigland static int nodeid_to_addr(int nodeid, struct sockaddr_storage *sas_out, 29398e1b60eSMike Christie struct sockaddr *sa_out, bool try_new_addr) 29436b71a8bSDavid Teigland { 29536b71a8bSDavid Teigland struct sockaddr_storage sas; 29636b71a8bSDavid Teigland struct dlm_node_addr *na; 2976ed7257bSPatrick Caulfield 2986ed7257bSPatrick Caulfield if (!dlm_local_count) 2996ed7257bSPatrick Caulfield return -1; 3006ed7257bSPatrick Caulfield 30136b71a8bSDavid Teigland spin_lock(&dlm_node_addrs_spin); 30236b71a8bSDavid Teigland na = find_node_addr(nodeid); 30398e1b60eSMike Christie if (na && na->addr_count) { 304ee44b4bcSMarcelo Ricardo Leitner memcpy(&sas, na->addr[na->curr_addr_index], 305ee44b4bcSMarcelo Ricardo Leitner sizeof(struct sockaddr_storage)); 306ee44b4bcSMarcelo Ricardo Leitner 30798e1b60eSMike Christie if (try_new_addr) { 30898e1b60eSMike Christie na->curr_addr_index++; 30998e1b60eSMike Christie if (na->curr_addr_index == na->addr_count) 31098e1b60eSMike Christie na->curr_addr_index = 0; 31198e1b60eSMike Christie } 31298e1b60eSMike Christie } 31336b71a8bSDavid Teigland spin_unlock(&dlm_node_addrs_spin); 31436b71a8bSDavid Teigland 31536b71a8bSDavid Teigland if (!na) 31636b71a8bSDavid Teigland return -EEXIST; 31736b71a8bSDavid Teigland 31836b71a8bSDavid Teigland if (!na->addr_count) 31936b71a8bSDavid Teigland return -ENOENT; 32036b71a8bSDavid Teigland 32136b71a8bSDavid Teigland if (sas_out) 32236b71a8bSDavid Teigland memcpy(sas_out, &sas, sizeof(struct sockaddr_storage)); 32336b71a8bSDavid Teigland 32436b71a8bSDavid Teigland if (!sa_out) 32536b71a8bSDavid Teigland return 0; 3266ed7257bSPatrick Caulfield 3276ed7257bSPatrick Caulfield if (dlm_local_addr[0]->ss_family == AF_INET) { 32836b71a8bSDavid Teigland struct sockaddr_in *in4 = (struct sockaddr_in *) &sas; 32936b71a8bSDavid Teigland struct sockaddr_in *ret4 = (struct sockaddr_in *) sa_out; 3306ed7257bSPatrick Caulfield ret4->sin_addr.s_addr = in4->sin_addr.s_addr; 3316ed7257bSPatrick Caulfield } else { 33236b71a8bSDavid Teigland struct sockaddr_in6 *in6 = (struct sockaddr_in6 *) &sas; 33336b71a8bSDavid Teigland struct sockaddr_in6 *ret6 = (struct sockaddr_in6 *) sa_out; 3344e3fd7a0SAlexey Dobriyan ret6->sin6_addr = in6->sin6_addr; 3356ed7257bSPatrick Caulfield } 3366ed7257bSPatrick Caulfield 3376ed7257bSPatrick Caulfield return 0; 3386ed7257bSPatrick Caulfield } 3396ed7257bSPatrick Caulfield 34036b71a8bSDavid Teigland static int addr_to_nodeid(struct sockaddr_storage *addr, int *nodeid) 34136b71a8bSDavid Teigland { 34236b71a8bSDavid Teigland struct dlm_node_addr *na; 34336b71a8bSDavid Teigland int rv = -EEXIST; 34498e1b60eSMike Christie int addr_i; 34536b71a8bSDavid Teigland 34636b71a8bSDavid Teigland spin_lock(&dlm_node_addrs_spin); 34736b71a8bSDavid Teigland list_for_each_entry(na, &dlm_node_addrs, list) { 34836b71a8bSDavid Teigland if (!na->addr_count) 34936b71a8bSDavid Teigland continue; 35036b71a8bSDavid Teigland 35198e1b60eSMike Christie for (addr_i = 0; addr_i < na->addr_count; addr_i++) { 35298e1b60eSMike Christie if (addr_compare(na->addr[addr_i], addr)) { 35336b71a8bSDavid Teigland *nodeid = na->nodeid; 35436b71a8bSDavid Teigland rv = 0; 35598e1b60eSMike Christie goto unlock; 35636b71a8bSDavid Teigland } 35798e1b60eSMike Christie } 35898e1b60eSMike Christie } 35998e1b60eSMike Christie unlock: 36036b71a8bSDavid Teigland spin_unlock(&dlm_node_addrs_spin); 36136b71a8bSDavid Teigland return rv; 36236b71a8bSDavid Teigland } 36336b71a8bSDavid Teigland 36436b71a8bSDavid Teigland int dlm_lowcomms_addr(int nodeid, struct sockaddr_storage *addr, int len) 36536b71a8bSDavid Teigland { 36636b71a8bSDavid Teigland struct sockaddr_storage *new_addr; 36736b71a8bSDavid Teigland struct dlm_node_addr *new_node, *na; 36836b71a8bSDavid Teigland 36936b71a8bSDavid Teigland new_node = kzalloc(sizeof(struct dlm_node_addr), GFP_NOFS); 37036b71a8bSDavid Teigland if (!new_node) 37136b71a8bSDavid Teigland return -ENOMEM; 37236b71a8bSDavid Teigland 37336b71a8bSDavid Teigland new_addr = kzalloc(sizeof(struct sockaddr_storage), GFP_NOFS); 37436b71a8bSDavid Teigland if (!new_addr) { 37536b71a8bSDavid Teigland kfree(new_node); 37636b71a8bSDavid Teigland return -ENOMEM; 37736b71a8bSDavid Teigland } 37836b71a8bSDavid Teigland 37936b71a8bSDavid Teigland memcpy(new_addr, addr, len); 38036b71a8bSDavid Teigland 38136b71a8bSDavid Teigland spin_lock(&dlm_node_addrs_spin); 38236b71a8bSDavid Teigland na = find_node_addr(nodeid); 38336b71a8bSDavid Teigland if (!na) { 38436b71a8bSDavid Teigland new_node->nodeid = nodeid; 38536b71a8bSDavid Teigland new_node->addr[0] = new_addr; 38636b71a8bSDavid Teigland new_node->addr_count = 1; 38736b71a8bSDavid Teigland list_add(&new_node->list, &dlm_node_addrs); 38836b71a8bSDavid Teigland spin_unlock(&dlm_node_addrs_spin); 38936b71a8bSDavid Teigland return 0; 39036b71a8bSDavid Teigland } 39136b71a8bSDavid Teigland 39236b71a8bSDavid Teigland if (na->addr_count >= DLM_MAX_ADDR_COUNT) { 39336b71a8bSDavid Teigland spin_unlock(&dlm_node_addrs_spin); 39436b71a8bSDavid Teigland kfree(new_addr); 39536b71a8bSDavid Teigland kfree(new_node); 39636b71a8bSDavid Teigland return -ENOSPC; 39736b71a8bSDavid Teigland } 39836b71a8bSDavid Teigland 39936b71a8bSDavid Teigland na->addr[na->addr_count++] = new_addr; 40036b71a8bSDavid Teigland spin_unlock(&dlm_node_addrs_spin); 40136b71a8bSDavid Teigland kfree(new_node); 40236b71a8bSDavid Teigland return 0; 40336b71a8bSDavid Teigland } 40436b71a8bSDavid Teigland 4056ed7257bSPatrick Caulfield /* Data available on socket or listen socket received a connect */ 406676d2369SDavid S. Miller static void lowcomms_data_ready(struct sock *sk) 4076ed7257bSPatrick Caulfield { 4086ed7257bSPatrick Caulfield struct connection *con = sock2con(sk); 409afb853fbSPatrick Caulfield if (con && !test_and_set_bit(CF_READ_PENDING, &con->flags)) 4106ed7257bSPatrick Caulfield queue_work(recv_workqueue, &con->rwork); 4116ed7257bSPatrick Caulfield } 4126ed7257bSPatrick Caulfield 4136ed7257bSPatrick Caulfield static void lowcomms_write_space(struct sock *sk) 4146ed7257bSPatrick Caulfield { 4156ed7257bSPatrick Caulfield struct connection *con = sock2con(sk); 4166ed7257bSPatrick Caulfield 417b36930ddSDavid Miller if (!con) 418b36930ddSDavid Miller return; 419b36930ddSDavid Miller 420b36930ddSDavid Miller clear_bit(SOCK_NOSPACE, &con->sock->flags); 421b36930ddSDavid Miller 422b36930ddSDavid Miller if (test_and_clear_bit(CF_APP_LIMITED, &con->flags)) { 423b36930ddSDavid Miller con->sock->sk->sk_write_pending--; 4249cd3e072SEric Dumazet clear_bit(SOCKWQ_ASYNC_NOSPACE, &con->sock->flags); 425b36930ddSDavid Miller } 426b36930ddSDavid Miller 427b36930ddSDavid Miller if (!test_and_set_bit(CF_WRITE_PENDING, &con->flags)) 4286ed7257bSPatrick Caulfield queue_work(send_workqueue, &con->swork); 4296ed7257bSPatrick Caulfield } 4306ed7257bSPatrick Caulfield 4316ed7257bSPatrick Caulfield static inline void lowcomms_connect_sock(struct connection *con) 4326ed7257bSPatrick Caulfield { 433063c4c99SLars Marowsky-Bree if (test_bit(CF_CLOSE, &con->flags)) 434063c4c99SLars Marowsky-Bree return; 4356ed7257bSPatrick Caulfield if (!test_and_set_bit(CF_CONNECT_PENDING, &con->flags)) 4366ed7257bSPatrick Caulfield queue_work(send_workqueue, &con->swork); 4376ed7257bSPatrick Caulfield } 4386ed7257bSPatrick Caulfield 4396ed7257bSPatrick Caulfield static void lowcomms_state_change(struct sock *sk) 4406ed7257bSPatrick Caulfield { 441ee44b4bcSMarcelo Ricardo Leitner /* SCTP layer is not calling sk_data_ready when the connection 442ee44b4bcSMarcelo Ricardo Leitner * is done, so we catch the signal through here. Also, it 443ee44b4bcSMarcelo Ricardo Leitner * doesn't switch socket state when entering shutdown, so we 444ee44b4bcSMarcelo Ricardo Leitner * skip the write in that case. 445ee44b4bcSMarcelo Ricardo Leitner */ 446ee44b4bcSMarcelo Ricardo Leitner if (sk->sk_shutdown) { 447ee44b4bcSMarcelo Ricardo Leitner if (sk->sk_shutdown == RCV_SHUTDOWN) 448ee44b4bcSMarcelo Ricardo Leitner lowcomms_data_ready(sk); 449ee44b4bcSMarcelo Ricardo Leitner } else if (sk->sk_state == TCP_ESTABLISHED) { 4506ed7257bSPatrick Caulfield lowcomms_write_space(sk); 4516ed7257bSPatrick Caulfield } 452ee44b4bcSMarcelo Ricardo Leitner } 4536ed7257bSPatrick Caulfield 454391fbdc5SChristine Caulfield int dlm_lowcomms_connect_node(int nodeid) 455391fbdc5SChristine Caulfield { 456391fbdc5SChristine Caulfield struct connection *con; 457391fbdc5SChristine Caulfield 458391fbdc5SChristine Caulfield if (nodeid == dlm_our_nodeid()) 459391fbdc5SChristine Caulfield return 0; 460391fbdc5SChristine Caulfield 461391fbdc5SChristine Caulfield con = nodeid2con(nodeid, GFP_NOFS); 462391fbdc5SChristine Caulfield if (!con) 463391fbdc5SChristine Caulfield return -ENOMEM; 464391fbdc5SChristine Caulfield lowcomms_connect_sock(con); 465391fbdc5SChristine Caulfield return 0; 466391fbdc5SChristine Caulfield } 467391fbdc5SChristine Caulfield 468b3a5bbfdSBob Peterson static void lowcomms_error_report(struct sock *sk) 469b3a5bbfdSBob Peterson { 470b3a5bbfdSBob Peterson struct connection *con = sock2con(sk); 471b3a5bbfdSBob Peterson struct sockaddr_storage saddr; 472b3a5bbfdSBob Peterson 473b3a5bbfdSBob Peterson if (nodeid_to_addr(con->nodeid, &saddr, NULL, false)) { 474b3a5bbfdSBob Peterson printk_ratelimited(KERN_ERR "dlm: node %d: socket error " 475b3a5bbfdSBob Peterson "sending to node %d, port %d, " 476b3a5bbfdSBob Peterson "sk_err=%d/%d\n", dlm_our_nodeid(), 477b3a5bbfdSBob Peterson con->nodeid, dlm_config.ci_tcp_port, 478b3a5bbfdSBob Peterson sk->sk_err, sk->sk_err_soft); 479b3a5bbfdSBob Peterson return; 480b3a5bbfdSBob Peterson } else if (saddr.ss_family == AF_INET) { 481b3a5bbfdSBob Peterson struct sockaddr_in *sin4 = (struct sockaddr_in *)&saddr; 482b3a5bbfdSBob Peterson 483b3a5bbfdSBob Peterson printk_ratelimited(KERN_ERR "dlm: node %d: socket error " 484b3a5bbfdSBob Peterson "sending to node %d at %pI4, port %d, " 485b3a5bbfdSBob Peterson "sk_err=%d/%d\n", dlm_our_nodeid(), 486b3a5bbfdSBob Peterson con->nodeid, &sin4->sin_addr.s_addr, 487b3a5bbfdSBob Peterson dlm_config.ci_tcp_port, sk->sk_err, 488b3a5bbfdSBob Peterson sk->sk_err_soft); 489b3a5bbfdSBob Peterson } else { 490b3a5bbfdSBob Peterson struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)&saddr; 491b3a5bbfdSBob Peterson 492b3a5bbfdSBob Peterson printk_ratelimited(KERN_ERR "dlm: node %d: socket error " 493b3a5bbfdSBob Peterson "sending to node %d at %u.%u.%u.%u, " 494b3a5bbfdSBob Peterson "port %d, sk_err=%d/%d\n", dlm_our_nodeid(), 495b3a5bbfdSBob Peterson con->nodeid, sin6->sin6_addr.s6_addr32[0], 496b3a5bbfdSBob Peterson sin6->sin6_addr.s6_addr32[1], 497b3a5bbfdSBob Peterson sin6->sin6_addr.s6_addr32[2], 498b3a5bbfdSBob Peterson sin6->sin6_addr.s6_addr32[3], 499b3a5bbfdSBob Peterson dlm_config.ci_tcp_port, sk->sk_err, 500b3a5bbfdSBob Peterson sk->sk_err_soft); 501b3a5bbfdSBob Peterson } 502b3a5bbfdSBob Peterson con->orig_error_report(sk); 503b3a5bbfdSBob Peterson } 504b3a5bbfdSBob Peterson 5056ed7257bSPatrick Caulfield /* Make a socket active */ 5064dd40f0cSYing Xue static void add_sock(struct socket *sock, struct connection *con) 5076ed7257bSPatrick Caulfield { 5086ed7257bSPatrick Caulfield con->sock = sock; 5096ed7257bSPatrick Caulfield 5106ed7257bSPatrick Caulfield /* Install a data_ready callback */ 5116ed7257bSPatrick Caulfield con->sock->sk->sk_data_ready = lowcomms_data_ready; 5126ed7257bSPatrick Caulfield con->sock->sk->sk_write_space = lowcomms_write_space; 5136ed7257bSPatrick Caulfield con->sock->sk->sk_state_change = lowcomms_state_change; 5146ed7257bSPatrick Caulfield con->sock->sk->sk_user_data = con; 515d6d7b702SSteven Whitehouse con->sock->sk->sk_allocation = GFP_NOFS; 516b3a5bbfdSBob Peterson con->orig_error_report = con->sock->sk->sk_error_report; 517b3a5bbfdSBob Peterson con->sock->sk->sk_error_report = lowcomms_error_report; 5186ed7257bSPatrick Caulfield } 5196ed7257bSPatrick Caulfield 5206ed7257bSPatrick Caulfield /* Add the port number to an IPv6 or 4 sockaddr and return the address 5216ed7257bSPatrick Caulfield length */ 5226ed7257bSPatrick Caulfield static void make_sockaddr(struct sockaddr_storage *saddr, uint16_t port, 5236ed7257bSPatrick Caulfield int *addr_len) 5246ed7257bSPatrick Caulfield { 5256ed7257bSPatrick Caulfield saddr->ss_family = dlm_local_addr[0]->ss_family; 5266ed7257bSPatrick Caulfield if (saddr->ss_family == AF_INET) { 5276ed7257bSPatrick Caulfield struct sockaddr_in *in4_addr = (struct sockaddr_in *)saddr; 5286ed7257bSPatrick Caulfield in4_addr->sin_port = cpu_to_be16(port); 5296ed7257bSPatrick Caulfield *addr_len = sizeof(struct sockaddr_in); 5306ed7257bSPatrick Caulfield memset(&in4_addr->sin_zero, 0, sizeof(in4_addr->sin_zero)); 5316ed7257bSPatrick Caulfield } else { 5326ed7257bSPatrick Caulfield struct sockaddr_in6 *in6_addr = (struct sockaddr_in6 *)saddr; 5336ed7257bSPatrick Caulfield in6_addr->sin6_port = cpu_to_be16(port); 5346ed7257bSPatrick Caulfield *addr_len = sizeof(struct sockaddr_in6); 5356ed7257bSPatrick Caulfield } 53601c8cab2SPatrick Caulfield memset((char *)saddr + *addr_len, 0, sizeof(struct sockaddr_storage) - *addr_len); 5376ed7257bSPatrick Caulfield } 5386ed7257bSPatrick Caulfield 5396ed7257bSPatrick Caulfield /* Close a remote connection and tidy up */ 5400d737a8cSMarcelo Ricardo Leitner static void close_connection(struct connection *con, bool and_other, 5410d737a8cSMarcelo Ricardo Leitner bool tx, bool rx) 5426ed7257bSPatrick Caulfield { 5430d737a8cSMarcelo Ricardo Leitner clear_bit(CF_CONNECT_PENDING, &con->flags); 5440d737a8cSMarcelo Ricardo Leitner clear_bit(CF_WRITE_PENDING, &con->flags); 5450d737a8cSMarcelo Ricardo Leitner if (tx && cancel_work_sync(&con->swork)) 5460d737a8cSMarcelo Ricardo Leitner log_print("canceled swork for node %d", con->nodeid); 5470d737a8cSMarcelo Ricardo Leitner if (rx && cancel_work_sync(&con->rwork)) 5480d737a8cSMarcelo Ricardo Leitner log_print("canceled rwork for node %d", con->nodeid); 5496ed7257bSPatrick Caulfield 5500d737a8cSMarcelo Ricardo Leitner mutex_lock(&con->sock_mutex); 5516ed7257bSPatrick Caulfield if (con->sock) { 5526ed7257bSPatrick Caulfield sock_release(con->sock); 5536ed7257bSPatrick Caulfield con->sock = NULL; 5546ed7257bSPatrick Caulfield } 5556ed7257bSPatrick Caulfield if (con->othercon && and_other) { 5566ed7257bSPatrick Caulfield /* Will only re-enter once. */ 5570d737a8cSMarcelo Ricardo Leitner close_connection(con->othercon, false, true, true); 5586ed7257bSPatrick Caulfield } 5596ed7257bSPatrick Caulfield if (con->rx_page) { 5606ed7257bSPatrick Caulfield __free_page(con->rx_page); 5616ed7257bSPatrick Caulfield con->rx_page = NULL; 5626ed7257bSPatrick Caulfield } 5639e5f2825SPatrick Caulfield 5646ed7257bSPatrick Caulfield con->retries = 0; 5656ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 5666ed7257bSPatrick Caulfield } 5676ed7257bSPatrick Caulfield 5686ed7257bSPatrick Caulfield /* Data received from remote end */ 5696ed7257bSPatrick Caulfield static int receive_from_sock(struct connection *con) 5706ed7257bSPatrick Caulfield { 5716ed7257bSPatrick Caulfield int ret = 0; 5726ed7257bSPatrick Caulfield struct msghdr msg = {}; 5736ed7257bSPatrick Caulfield struct kvec iov[2]; 5746ed7257bSPatrick Caulfield unsigned len; 5756ed7257bSPatrick Caulfield int r; 5766ed7257bSPatrick Caulfield int call_again_soon = 0; 5776ed7257bSPatrick Caulfield int nvec; 5786ed7257bSPatrick Caulfield 5796ed7257bSPatrick Caulfield mutex_lock(&con->sock_mutex); 5806ed7257bSPatrick Caulfield 5816ed7257bSPatrick Caulfield if (con->sock == NULL) { 5826ed7257bSPatrick Caulfield ret = -EAGAIN; 5836ed7257bSPatrick Caulfield goto out_close; 5846ed7257bSPatrick Caulfield } 585acee4e52SMarcelo Ricardo Leitner if (con->nodeid == 0) { 586acee4e52SMarcelo Ricardo Leitner ret = -EINVAL; 587acee4e52SMarcelo Ricardo Leitner goto out_close; 588acee4e52SMarcelo Ricardo Leitner } 5896ed7257bSPatrick Caulfield 5906ed7257bSPatrick Caulfield if (con->rx_page == NULL) { 5916ed7257bSPatrick Caulfield /* 5926ed7257bSPatrick Caulfield * This doesn't need to be atomic, but I think it should 5936ed7257bSPatrick Caulfield * improve performance if it is. 5946ed7257bSPatrick Caulfield */ 5956ed7257bSPatrick Caulfield con->rx_page = alloc_page(GFP_ATOMIC); 5966ed7257bSPatrick Caulfield if (con->rx_page == NULL) 5976ed7257bSPatrick Caulfield goto out_resched; 5986ed7257bSPatrick Caulfield cbuf_init(&con->cb, PAGE_CACHE_SIZE); 5996ed7257bSPatrick Caulfield } 6006ed7257bSPatrick Caulfield 6016ed7257bSPatrick Caulfield /* 6026ed7257bSPatrick Caulfield * iov[0] is the bit of the circular buffer between the current end 6036ed7257bSPatrick Caulfield * point (cb.base + cb.len) and the end of the buffer. 6046ed7257bSPatrick Caulfield */ 6056ed7257bSPatrick Caulfield iov[0].iov_len = con->cb.base - cbuf_data(&con->cb); 6066ed7257bSPatrick Caulfield iov[0].iov_base = page_address(con->rx_page) + cbuf_data(&con->cb); 6076ed7257bSPatrick Caulfield iov[1].iov_len = 0; 6086ed7257bSPatrick Caulfield nvec = 1; 6096ed7257bSPatrick Caulfield 6106ed7257bSPatrick Caulfield /* 6116ed7257bSPatrick Caulfield * iov[1] is the bit of the circular buffer between the start of the 6126ed7257bSPatrick Caulfield * buffer and the start of the currently used section (cb.base) 6136ed7257bSPatrick Caulfield */ 6146ed7257bSPatrick Caulfield if (cbuf_data(&con->cb) >= con->cb.base) { 6156ed7257bSPatrick Caulfield iov[0].iov_len = PAGE_CACHE_SIZE - cbuf_data(&con->cb); 6166ed7257bSPatrick Caulfield iov[1].iov_len = con->cb.base; 6176ed7257bSPatrick Caulfield iov[1].iov_base = page_address(con->rx_page); 6186ed7257bSPatrick Caulfield nvec = 2; 6196ed7257bSPatrick Caulfield } 6206ed7257bSPatrick Caulfield len = iov[0].iov_len + iov[1].iov_len; 6216ed7257bSPatrick Caulfield 6226ed7257bSPatrick Caulfield r = ret = kernel_recvmsg(con->sock, &msg, iov, nvec, len, 6236ed7257bSPatrick Caulfield MSG_DONTWAIT | MSG_NOSIGNAL); 6246ed7257bSPatrick Caulfield if (ret <= 0) 6256ed7257bSPatrick Caulfield goto out_close; 626ee44b4bcSMarcelo Ricardo Leitner else if (ret == len) 627ee44b4bcSMarcelo Ricardo Leitner call_again_soon = 1; 6286ed7257bSPatrick Caulfield 6296ed7257bSPatrick Caulfield cbuf_add(&con->cb, ret); 6306ed7257bSPatrick Caulfield ret = dlm_process_incoming_buffer(con->nodeid, 6316ed7257bSPatrick Caulfield page_address(con->rx_page), 6326ed7257bSPatrick Caulfield con->cb.base, con->cb.len, 6336ed7257bSPatrick Caulfield PAGE_CACHE_SIZE); 6346ed7257bSPatrick Caulfield if (ret == -EBADMSG) { 635ee44b4bcSMarcelo Ricardo Leitner log_print("lowcomms: addr=%p, base=%u, len=%u, read=%d", 636ee44b4bcSMarcelo Ricardo Leitner page_address(con->rx_page), con->cb.base, 637ee44b4bcSMarcelo Ricardo Leitner con->cb.len, r); 6386ed7257bSPatrick Caulfield } 6396ed7257bSPatrick Caulfield if (ret < 0) 6406ed7257bSPatrick Caulfield goto out_close; 6416ed7257bSPatrick Caulfield cbuf_eat(&con->cb, ret); 6426ed7257bSPatrick Caulfield 6436ed7257bSPatrick Caulfield if (cbuf_empty(&con->cb) && !call_again_soon) { 6446ed7257bSPatrick Caulfield __free_page(con->rx_page); 6456ed7257bSPatrick Caulfield con->rx_page = NULL; 6466ed7257bSPatrick Caulfield } 6476ed7257bSPatrick Caulfield 6486ed7257bSPatrick Caulfield if (call_again_soon) 6496ed7257bSPatrick Caulfield goto out_resched; 6506ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 6516ed7257bSPatrick Caulfield return 0; 6526ed7257bSPatrick Caulfield 6536ed7257bSPatrick Caulfield out_resched: 6546ed7257bSPatrick Caulfield if (!test_and_set_bit(CF_READ_PENDING, &con->flags)) 6556ed7257bSPatrick Caulfield queue_work(recv_workqueue, &con->rwork); 6566ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 6576ed7257bSPatrick Caulfield return -EAGAIN; 6586ed7257bSPatrick Caulfield 6596ed7257bSPatrick Caulfield out_close: 6606ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 6619e5f2825SPatrick Caulfield if (ret != -EAGAIN) { 6620d737a8cSMarcelo Ricardo Leitner close_connection(con, false, true, false); 6636ed7257bSPatrick Caulfield /* Reconnect when there is something to send */ 6646ed7257bSPatrick Caulfield } 6656ed7257bSPatrick Caulfield /* Don't return success if we really got EOF */ 6666ed7257bSPatrick Caulfield if (ret == 0) 6676ed7257bSPatrick Caulfield ret = -EAGAIN; 6686ed7257bSPatrick Caulfield 6696ed7257bSPatrick Caulfield return ret; 6706ed7257bSPatrick Caulfield } 6716ed7257bSPatrick Caulfield 6726ed7257bSPatrick Caulfield /* Listening socket is busy, accept a connection */ 6736ed7257bSPatrick Caulfield static int tcp_accept_from_sock(struct connection *con) 6746ed7257bSPatrick Caulfield { 6756ed7257bSPatrick Caulfield int result; 6766ed7257bSPatrick Caulfield struct sockaddr_storage peeraddr; 6776ed7257bSPatrick Caulfield struct socket *newsock; 6786ed7257bSPatrick Caulfield int len; 6796ed7257bSPatrick Caulfield int nodeid; 6806ed7257bSPatrick Caulfield struct connection *newcon; 6816ed7257bSPatrick Caulfield struct connection *addcon; 6826ed7257bSPatrick Caulfield 683513ef596SDavid Teigland mutex_lock(&connections_lock); 684513ef596SDavid Teigland if (!dlm_allow_conn) { 685513ef596SDavid Teigland mutex_unlock(&connections_lock); 686513ef596SDavid Teigland return -1; 687513ef596SDavid Teigland } 688513ef596SDavid Teigland mutex_unlock(&connections_lock); 689513ef596SDavid Teigland 6906ed7257bSPatrick Caulfield memset(&peeraddr, 0, sizeof(peeraddr)); 691eeb1bd5cSEric W. Biederman result = sock_create_kern(&init_net, dlm_local_addr[0]->ss_family, 692eeb1bd5cSEric W. Biederman SOCK_STREAM, IPPROTO_TCP, &newsock); 6936ed7257bSPatrick Caulfield if (result < 0) 6946ed7257bSPatrick Caulfield return -ENOMEM; 6956ed7257bSPatrick Caulfield 6966ed7257bSPatrick Caulfield mutex_lock_nested(&con->sock_mutex, 0); 6976ed7257bSPatrick Caulfield 6986ed7257bSPatrick Caulfield result = -ENOTCONN; 6996ed7257bSPatrick Caulfield if (con->sock == NULL) 7006ed7257bSPatrick Caulfield goto accept_err; 7016ed7257bSPatrick Caulfield 7026ed7257bSPatrick Caulfield newsock->type = con->sock->type; 7036ed7257bSPatrick Caulfield newsock->ops = con->sock->ops; 7046ed7257bSPatrick Caulfield 7056ed7257bSPatrick Caulfield result = con->sock->ops->accept(con->sock, newsock, O_NONBLOCK); 7066ed7257bSPatrick Caulfield if (result < 0) 7076ed7257bSPatrick Caulfield goto accept_err; 7086ed7257bSPatrick Caulfield 7096ed7257bSPatrick Caulfield /* Get the connected socket's peer */ 7106ed7257bSPatrick Caulfield memset(&peeraddr, 0, sizeof(peeraddr)); 7116ed7257bSPatrick Caulfield if (newsock->ops->getname(newsock, (struct sockaddr *)&peeraddr, 7126ed7257bSPatrick Caulfield &len, 2)) { 7136ed7257bSPatrick Caulfield result = -ECONNABORTED; 7146ed7257bSPatrick Caulfield goto accept_err; 7156ed7257bSPatrick Caulfield } 7166ed7257bSPatrick Caulfield 7176ed7257bSPatrick Caulfield /* Get the new node's NODEID */ 7186ed7257bSPatrick Caulfield make_sockaddr(&peeraddr, 0, &len); 71936b71a8bSDavid Teigland if (addr_to_nodeid(&peeraddr, &nodeid)) { 720bcaadf5cSMasatake YAMATO unsigned char *b=(unsigned char *)&peeraddr; 721617e82e1SDavid Teigland log_print("connect from non cluster node"); 722bcaadf5cSMasatake YAMATO print_hex_dump_bytes("ss: ", DUMP_PREFIX_NONE, 723bcaadf5cSMasatake YAMATO b, sizeof(struct sockaddr_storage)); 7246ed7257bSPatrick Caulfield sock_release(newsock); 7256ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 7266ed7257bSPatrick Caulfield return -1; 7276ed7257bSPatrick Caulfield } 7286ed7257bSPatrick Caulfield 7296ed7257bSPatrick Caulfield log_print("got connection from %d", nodeid); 7306ed7257bSPatrick Caulfield 7316ed7257bSPatrick Caulfield /* Check to see if we already have a connection to this node. This 7326ed7257bSPatrick Caulfield * could happen if the two nodes initiate a connection at roughly 7336ed7257bSPatrick Caulfield * the same time and the connections cross on the wire. 7346ed7257bSPatrick Caulfield * In this case we store the incoming one in "othercon" 7356ed7257bSPatrick Caulfield */ 736748285ccSDavid Teigland newcon = nodeid2con(nodeid, GFP_NOFS); 7376ed7257bSPatrick Caulfield if (!newcon) { 7386ed7257bSPatrick Caulfield result = -ENOMEM; 7396ed7257bSPatrick Caulfield goto accept_err; 7406ed7257bSPatrick Caulfield } 7416ed7257bSPatrick Caulfield mutex_lock_nested(&newcon->sock_mutex, 1); 7426ed7257bSPatrick Caulfield if (newcon->sock) { 7436ed7257bSPatrick Caulfield struct connection *othercon = newcon->othercon; 7446ed7257bSPatrick Caulfield 7456ed7257bSPatrick Caulfield if (!othercon) { 746748285ccSDavid Teigland othercon = kmem_cache_zalloc(con_cache, GFP_NOFS); 7476ed7257bSPatrick Caulfield if (!othercon) { 748617e82e1SDavid Teigland log_print("failed to allocate incoming socket"); 7496ed7257bSPatrick Caulfield mutex_unlock(&newcon->sock_mutex); 7506ed7257bSPatrick Caulfield result = -ENOMEM; 7516ed7257bSPatrick Caulfield goto accept_err; 7526ed7257bSPatrick Caulfield } 7536ed7257bSPatrick Caulfield othercon->nodeid = nodeid; 7546ed7257bSPatrick Caulfield othercon->rx_action = receive_from_sock; 7556ed7257bSPatrick Caulfield mutex_init(&othercon->sock_mutex); 7566ed7257bSPatrick Caulfield INIT_WORK(&othercon->swork, process_send_sockets); 7576ed7257bSPatrick Caulfield INIT_WORK(&othercon->rwork, process_recv_sockets); 7586ed7257bSPatrick Caulfield set_bit(CF_IS_OTHERCON, &othercon->flags); 75961d96be0SPatrick Caulfield } 76061d96be0SPatrick Caulfield if (!othercon->sock) { 7616ed7257bSPatrick Caulfield newcon->othercon = othercon; 7626ed7257bSPatrick Caulfield othercon->sock = newsock; 7636ed7257bSPatrick Caulfield newsock->sk->sk_user_data = othercon; 7646ed7257bSPatrick Caulfield add_sock(newsock, othercon); 7656ed7257bSPatrick Caulfield addcon = othercon; 7666ed7257bSPatrick Caulfield } 7676ed7257bSPatrick Caulfield else { 76897d84836SPatrick Caulfield printk("Extra connection from node %d attempted\n", nodeid); 76997d84836SPatrick Caulfield result = -EAGAIN; 770f4fadb23Sakpm@linux-foundation.org mutex_unlock(&newcon->sock_mutex); 77197d84836SPatrick Caulfield goto accept_err; 77297d84836SPatrick Caulfield } 77397d84836SPatrick Caulfield } 77497d84836SPatrick Caulfield else { 7756ed7257bSPatrick Caulfield newsock->sk->sk_user_data = newcon; 7766ed7257bSPatrick Caulfield newcon->rx_action = receive_from_sock; 7776ed7257bSPatrick Caulfield add_sock(newsock, newcon); 7786ed7257bSPatrick Caulfield addcon = newcon; 7796ed7257bSPatrick Caulfield } 7806ed7257bSPatrick Caulfield 7816ed7257bSPatrick Caulfield mutex_unlock(&newcon->sock_mutex); 7826ed7257bSPatrick Caulfield 7836ed7257bSPatrick Caulfield /* 7846ed7257bSPatrick Caulfield * Add it to the active queue in case we got data 78525985edcSLucas De Marchi * between processing the accept adding the socket 7866ed7257bSPatrick Caulfield * to the read_sockets list 7876ed7257bSPatrick Caulfield */ 7886ed7257bSPatrick Caulfield if (!test_and_set_bit(CF_READ_PENDING, &addcon->flags)) 7896ed7257bSPatrick Caulfield queue_work(recv_workqueue, &addcon->rwork); 7906ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 7916ed7257bSPatrick Caulfield 7926ed7257bSPatrick Caulfield return 0; 7936ed7257bSPatrick Caulfield 7946ed7257bSPatrick Caulfield accept_err: 7956ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 7966ed7257bSPatrick Caulfield sock_release(newsock); 7976ed7257bSPatrick Caulfield 7986ed7257bSPatrick Caulfield if (result != -EAGAIN) 799617e82e1SDavid Teigland log_print("error accepting connection from node: %d", result); 8006ed7257bSPatrick Caulfield return result; 8016ed7257bSPatrick Caulfield } 8026ed7257bSPatrick Caulfield 80318df8a87Skbuild test robot static int sctp_accept_from_sock(struct connection *con) 804ee44b4bcSMarcelo Ricardo Leitner { 805ee44b4bcSMarcelo Ricardo Leitner /* Check that the new node is in the lockspace */ 806ee44b4bcSMarcelo Ricardo Leitner struct sctp_prim prim; 807ee44b4bcSMarcelo Ricardo Leitner int nodeid; 808ee44b4bcSMarcelo Ricardo Leitner int prim_len, ret; 809ee44b4bcSMarcelo Ricardo Leitner int addr_len; 810ee44b4bcSMarcelo Ricardo Leitner struct connection *newcon; 811ee44b4bcSMarcelo Ricardo Leitner struct connection *addcon; 812ee44b4bcSMarcelo Ricardo Leitner struct socket *newsock; 813ee44b4bcSMarcelo Ricardo Leitner 814ee44b4bcSMarcelo Ricardo Leitner mutex_lock(&connections_lock); 815ee44b4bcSMarcelo Ricardo Leitner if (!dlm_allow_conn) { 816ee44b4bcSMarcelo Ricardo Leitner mutex_unlock(&connections_lock); 817ee44b4bcSMarcelo Ricardo Leitner return -1; 818ee44b4bcSMarcelo Ricardo Leitner } 819ee44b4bcSMarcelo Ricardo Leitner mutex_unlock(&connections_lock); 820ee44b4bcSMarcelo Ricardo Leitner 821ee44b4bcSMarcelo Ricardo Leitner mutex_lock_nested(&con->sock_mutex, 0); 822ee44b4bcSMarcelo Ricardo Leitner 823ee44b4bcSMarcelo Ricardo Leitner ret = kernel_accept(con->sock, &newsock, O_NONBLOCK); 824ee44b4bcSMarcelo Ricardo Leitner if (ret < 0) 825ee44b4bcSMarcelo Ricardo Leitner goto accept_err; 826ee44b4bcSMarcelo Ricardo Leitner 827ee44b4bcSMarcelo Ricardo Leitner memset(&prim, 0, sizeof(struct sctp_prim)); 828ee44b4bcSMarcelo Ricardo Leitner prim_len = sizeof(struct sctp_prim); 829ee44b4bcSMarcelo Ricardo Leitner 830ee44b4bcSMarcelo Ricardo Leitner ret = kernel_getsockopt(newsock, IPPROTO_SCTP, SCTP_PRIMARY_ADDR, 831ee44b4bcSMarcelo Ricardo Leitner (char *)&prim, &prim_len); 832ee44b4bcSMarcelo Ricardo Leitner if (ret < 0) { 833ee44b4bcSMarcelo Ricardo Leitner log_print("getsockopt/sctp_primary_addr failed: %d", ret); 834ee44b4bcSMarcelo Ricardo Leitner goto accept_err; 835ee44b4bcSMarcelo Ricardo Leitner } 836ee44b4bcSMarcelo Ricardo Leitner 837ee44b4bcSMarcelo Ricardo Leitner make_sockaddr(&prim.ssp_addr, 0, &addr_len); 838ee44b4bcSMarcelo Ricardo Leitner if (addr_to_nodeid(&prim.ssp_addr, &nodeid)) { 839ee44b4bcSMarcelo Ricardo Leitner unsigned char *b = (unsigned char *)&prim.ssp_addr; 840ee44b4bcSMarcelo Ricardo Leitner 841ee44b4bcSMarcelo Ricardo Leitner log_print("reject connect from unknown addr"); 842ee44b4bcSMarcelo Ricardo Leitner print_hex_dump_bytes("ss: ", DUMP_PREFIX_NONE, 843ee44b4bcSMarcelo Ricardo Leitner b, sizeof(struct sockaddr_storage)); 844ee44b4bcSMarcelo Ricardo Leitner goto accept_err; 845ee44b4bcSMarcelo Ricardo Leitner } 846ee44b4bcSMarcelo Ricardo Leitner 847ee44b4bcSMarcelo Ricardo Leitner newcon = nodeid2con(nodeid, GFP_NOFS); 848ee44b4bcSMarcelo Ricardo Leitner if (!newcon) { 849ee44b4bcSMarcelo Ricardo Leitner ret = -ENOMEM; 850ee44b4bcSMarcelo Ricardo Leitner goto accept_err; 851ee44b4bcSMarcelo Ricardo Leitner } 852ee44b4bcSMarcelo Ricardo Leitner 853ee44b4bcSMarcelo Ricardo Leitner mutex_lock_nested(&newcon->sock_mutex, 1); 854ee44b4bcSMarcelo Ricardo Leitner 855ee44b4bcSMarcelo Ricardo Leitner if (newcon->sock) { 856ee44b4bcSMarcelo Ricardo Leitner struct connection *othercon = newcon->othercon; 857ee44b4bcSMarcelo Ricardo Leitner 858ee44b4bcSMarcelo Ricardo Leitner if (!othercon) { 859ee44b4bcSMarcelo Ricardo Leitner othercon = kmem_cache_zalloc(con_cache, GFP_NOFS); 860ee44b4bcSMarcelo Ricardo Leitner if (!othercon) { 861ee44b4bcSMarcelo Ricardo Leitner log_print("failed to allocate incoming socket"); 862ee44b4bcSMarcelo Ricardo Leitner mutex_unlock(&newcon->sock_mutex); 863ee44b4bcSMarcelo Ricardo Leitner ret = -ENOMEM; 864ee44b4bcSMarcelo Ricardo Leitner goto accept_err; 865ee44b4bcSMarcelo Ricardo Leitner } 866ee44b4bcSMarcelo Ricardo Leitner othercon->nodeid = nodeid; 867ee44b4bcSMarcelo Ricardo Leitner othercon->rx_action = receive_from_sock; 868ee44b4bcSMarcelo Ricardo Leitner mutex_init(&othercon->sock_mutex); 869ee44b4bcSMarcelo Ricardo Leitner INIT_WORK(&othercon->swork, process_send_sockets); 870ee44b4bcSMarcelo Ricardo Leitner INIT_WORK(&othercon->rwork, process_recv_sockets); 871ee44b4bcSMarcelo Ricardo Leitner set_bit(CF_IS_OTHERCON, &othercon->flags); 872ee44b4bcSMarcelo Ricardo Leitner } 873ee44b4bcSMarcelo Ricardo Leitner if (!othercon->sock) { 874ee44b4bcSMarcelo Ricardo Leitner newcon->othercon = othercon; 875ee44b4bcSMarcelo Ricardo Leitner othercon->sock = newsock; 876ee44b4bcSMarcelo Ricardo Leitner newsock->sk->sk_user_data = othercon; 877ee44b4bcSMarcelo Ricardo Leitner add_sock(newsock, othercon); 878ee44b4bcSMarcelo Ricardo Leitner addcon = othercon; 879ee44b4bcSMarcelo Ricardo Leitner } else { 880ee44b4bcSMarcelo Ricardo Leitner printk("Extra connection from node %d attempted\n", nodeid); 881ee44b4bcSMarcelo Ricardo Leitner ret = -EAGAIN; 882ee44b4bcSMarcelo Ricardo Leitner mutex_unlock(&newcon->sock_mutex); 883ee44b4bcSMarcelo Ricardo Leitner goto accept_err; 884ee44b4bcSMarcelo Ricardo Leitner } 885ee44b4bcSMarcelo Ricardo Leitner } else { 886ee44b4bcSMarcelo Ricardo Leitner newsock->sk->sk_user_data = newcon; 887ee44b4bcSMarcelo Ricardo Leitner newcon->rx_action = receive_from_sock; 888ee44b4bcSMarcelo Ricardo Leitner add_sock(newsock, newcon); 889ee44b4bcSMarcelo Ricardo Leitner addcon = newcon; 890ee44b4bcSMarcelo Ricardo Leitner } 891ee44b4bcSMarcelo Ricardo Leitner 892ee44b4bcSMarcelo Ricardo Leitner log_print("connected to %d", nodeid); 893ee44b4bcSMarcelo Ricardo Leitner 894ee44b4bcSMarcelo Ricardo Leitner mutex_unlock(&newcon->sock_mutex); 895ee44b4bcSMarcelo Ricardo Leitner 896ee44b4bcSMarcelo Ricardo Leitner /* 897ee44b4bcSMarcelo Ricardo Leitner * Add it to the active queue in case we got data 898ee44b4bcSMarcelo Ricardo Leitner * between processing the accept adding the socket 899ee44b4bcSMarcelo Ricardo Leitner * to the read_sockets list 900ee44b4bcSMarcelo Ricardo Leitner */ 901ee44b4bcSMarcelo Ricardo Leitner if (!test_and_set_bit(CF_READ_PENDING, &addcon->flags)) 902ee44b4bcSMarcelo Ricardo Leitner queue_work(recv_workqueue, &addcon->rwork); 903ee44b4bcSMarcelo Ricardo Leitner mutex_unlock(&con->sock_mutex); 904ee44b4bcSMarcelo Ricardo Leitner 905ee44b4bcSMarcelo Ricardo Leitner return 0; 906ee44b4bcSMarcelo Ricardo Leitner 907ee44b4bcSMarcelo Ricardo Leitner accept_err: 908ee44b4bcSMarcelo Ricardo Leitner mutex_unlock(&con->sock_mutex); 909ee44b4bcSMarcelo Ricardo Leitner if (newsock) 910ee44b4bcSMarcelo Ricardo Leitner sock_release(newsock); 911ee44b4bcSMarcelo Ricardo Leitner if (ret != -EAGAIN) 912ee44b4bcSMarcelo Ricardo Leitner log_print("error accepting connection from node: %d", ret); 913ee44b4bcSMarcelo Ricardo Leitner 914ee44b4bcSMarcelo Ricardo Leitner return ret; 915ee44b4bcSMarcelo Ricardo Leitner } 916ee44b4bcSMarcelo Ricardo Leitner 9176ed7257bSPatrick Caulfield static void free_entry(struct writequeue_entry *e) 9186ed7257bSPatrick Caulfield { 9196ed7257bSPatrick Caulfield __free_page(e->page); 9206ed7257bSPatrick Caulfield kfree(e); 9216ed7257bSPatrick Caulfield } 9226ed7257bSPatrick Caulfield 9235d689871SMike Christie /* 9245d689871SMike Christie * writequeue_entry_complete - try to delete and free write queue entry 9255d689871SMike Christie * @e: write queue entry to try to delete 9265d689871SMike Christie * @completed: bytes completed 9275d689871SMike Christie * 9285d689871SMike Christie * writequeue_lock must be held. 9295d689871SMike Christie */ 9305d689871SMike Christie static void writequeue_entry_complete(struct writequeue_entry *e, int completed) 9315d689871SMike Christie { 9325d689871SMike Christie e->offset += completed; 9335d689871SMike Christie e->len -= completed; 9345d689871SMike Christie 9355d689871SMike Christie if (e->len == 0 && e->users == 0) { 9365d689871SMike Christie list_del(&e->list); 9375d689871SMike Christie free_entry(e); 9385d689871SMike Christie } 9395d689871SMike Christie } 9405d689871SMike Christie 941ee44b4bcSMarcelo Ricardo Leitner /* 942ee44b4bcSMarcelo Ricardo Leitner * sctp_bind_addrs - bind a SCTP socket to all our addresses 943ee44b4bcSMarcelo Ricardo Leitner */ 944ee44b4bcSMarcelo Ricardo Leitner static int sctp_bind_addrs(struct connection *con, uint16_t port) 945ee44b4bcSMarcelo Ricardo Leitner { 946ee44b4bcSMarcelo Ricardo Leitner struct sockaddr_storage localaddr; 947ee44b4bcSMarcelo Ricardo Leitner int i, addr_len, result = 0; 948ee44b4bcSMarcelo Ricardo Leitner 949ee44b4bcSMarcelo Ricardo Leitner for (i = 0; i < dlm_local_count; i++) { 950ee44b4bcSMarcelo Ricardo Leitner memcpy(&localaddr, dlm_local_addr[i], sizeof(localaddr)); 951ee44b4bcSMarcelo Ricardo Leitner make_sockaddr(&localaddr, port, &addr_len); 952ee44b4bcSMarcelo Ricardo Leitner 953ee44b4bcSMarcelo Ricardo Leitner if (!i) 954ee44b4bcSMarcelo Ricardo Leitner result = kernel_bind(con->sock, 955ee44b4bcSMarcelo Ricardo Leitner (struct sockaddr *)&localaddr, 956ee44b4bcSMarcelo Ricardo Leitner addr_len); 957ee44b4bcSMarcelo Ricardo Leitner else 958ee44b4bcSMarcelo Ricardo Leitner result = kernel_setsockopt(con->sock, SOL_SCTP, 959ee44b4bcSMarcelo Ricardo Leitner SCTP_SOCKOPT_BINDX_ADD, 960ee44b4bcSMarcelo Ricardo Leitner (char *)&localaddr, addr_len); 961ee44b4bcSMarcelo Ricardo Leitner 962ee44b4bcSMarcelo Ricardo Leitner if (result < 0) { 963ee44b4bcSMarcelo Ricardo Leitner log_print("Can't bind to %d addr number %d, %d.\n", 964ee44b4bcSMarcelo Ricardo Leitner port, i + 1, result); 965ee44b4bcSMarcelo Ricardo Leitner break; 966ee44b4bcSMarcelo Ricardo Leitner } 967ee44b4bcSMarcelo Ricardo Leitner } 968ee44b4bcSMarcelo Ricardo Leitner return result; 969ee44b4bcSMarcelo Ricardo Leitner } 970ee44b4bcSMarcelo Ricardo Leitner 9716ed7257bSPatrick Caulfield /* Initiate an SCTP association. 9726ed7257bSPatrick Caulfield This is a special case of send_to_sock() in that we don't yet have a 9736ed7257bSPatrick Caulfield peeled-off socket for this association, so we use the listening socket 9746ed7257bSPatrick Caulfield and add the primary IP address of the remote node. 9756ed7257bSPatrick Caulfield */ 976ee44b4bcSMarcelo Ricardo Leitner static void sctp_connect_to_sock(struct connection *con) 9776ed7257bSPatrick Caulfield { 978ee44b4bcSMarcelo Ricardo Leitner struct sockaddr_storage daddr; 979ee44b4bcSMarcelo Ricardo Leitner int one = 1; 980ee44b4bcSMarcelo Ricardo Leitner int result; 981ee44b4bcSMarcelo Ricardo Leitner int addr_len; 982ee44b4bcSMarcelo Ricardo Leitner struct socket *sock; 983ee44b4bcSMarcelo Ricardo Leitner 984ee44b4bcSMarcelo Ricardo Leitner if (con->nodeid == 0) { 985ee44b4bcSMarcelo Ricardo Leitner log_print("attempt to connect sock 0 foiled"); 986ee44b4bcSMarcelo Ricardo Leitner return; 987ee44b4bcSMarcelo Ricardo Leitner } 9886ed7257bSPatrick Caulfield 9895d689871SMike Christie mutex_lock(&con->sock_mutex); 9906ed7257bSPatrick Caulfield 991ee44b4bcSMarcelo Ricardo Leitner /* Some odd races can cause double-connects, ignore them */ 992ee44b4bcSMarcelo Ricardo Leitner if (con->retries++ > MAX_CONNECT_RETRIES) 993ee44b4bcSMarcelo Ricardo Leitner goto out; 994ee44b4bcSMarcelo Ricardo Leitner 995ee44b4bcSMarcelo Ricardo Leitner if (con->sock) { 996ee44b4bcSMarcelo Ricardo Leitner log_print("node %d already connected.", con->nodeid); 997ee44b4bcSMarcelo Ricardo Leitner goto out; 998ee44b4bcSMarcelo Ricardo Leitner } 999ee44b4bcSMarcelo Ricardo Leitner 1000ee44b4bcSMarcelo Ricardo Leitner memset(&daddr, 0, sizeof(daddr)); 1001ee44b4bcSMarcelo Ricardo Leitner result = nodeid_to_addr(con->nodeid, &daddr, NULL, true); 1002ee44b4bcSMarcelo Ricardo Leitner if (result < 0) { 10036ed7257bSPatrick Caulfield log_print("no address for nodeid %d", con->nodeid); 1004ee44b4bcSMarcelo Ricardo Leitner goto out; 100504bedd79SDavid Teigland } 10066ed7257bSPatrick Caulfield 1007ee44b4bcSMarcelo Ricardo Leitner /* Create a socket to communicate with */ 1008ee44b4bcSMarcelo Ricardo Leitner result = sock_create_kern(&init_net, dlm_local_addr[0]->ss_family, 1009ee44b4bcSMarcelo Ricardo Leitner SOCK_STREAM, IPPROTO_SCTP, &sock); 1010ee44b4bcSMarcelo Ricardo Leitner if (result < 0) 1011ee44b4bcSMarcelo Ricardo Leitner goto socket_err; 10126ed7257bSPatrick Caulfield 1013ee44b4bcSMarcelo Ricardo Leitner sock->sk->sk_user_data = con; 1014ee44b4bcSMarcelo Ricardo Leitner con->rx_action = receive_from_sock; 1015ee44b4bcSMarcelo Ricardo Leitner con->connect_action = sctp_connect_to_sock; 1016ee44b4bcSMarcelo Ricardo Leitner add_sock(sock, con); 10176ed7257bSPatrick Caulfield 1018ee44b4bcSMarcelo Ricardo Leitner /* Bind to all addresses. */ 1019ee44b4bcSMarcelo Ricardo Leitner if (sctp_bind_addrs(con, 0)) 1020ee44b4bcSMarcelo Ricardo Leitner goto bind_err; 102198e1b60eSMike Christie 1022ee44b4bcSMarcelo Ricardo Leitner make_sockaddr(&daddr, dlm_config.ci_tcp_port, &addr_len); 10236ed7257bSPatrick Caulfield 1024ee44b4bcSMarcelo Ricardo Leitner log_print("connecting to %d", con->nodeid); 10256ed7257bSPatrick Caulfield 1026ee44b4bcSMarcelo Ricardo Leitner /* Turn off Nagle's algorithm */ 1027ee44b4bcSMarcelo Ricardo Leitner kernel_setsockopt(sock, SOL_TCP, TCP_NODELAY, (char *)&one, 1028ee44b4bcSMarcelo Ricardo Leitner sizeof(one)); 1029ee44b4bcSMarcelo Ricardo Leitner 1030ee44b4bcSMarcelo Ricardo Leitner result = sock->ops->connect(sock, (struct sockaddr *)&daddr, addr_len, 1031ee44b4bcSMarcelo Ricardo Leitner O_NONBLOCK); 1032ee44b4bcSMarcelo Ricardo Leitner if (result == -EINPROGRESS) 1033ee44b4bcSMarcelo Ricardo Leitner result = 0; 1034ee44b4bcSMarcelo Ricardo Leitner if (result == 0) 1035ee44b4bcSMarcelo Ricardo Leitner goto out; 1036ee44b4bcSMarcelo Ricardo Leitner 1037ee44b4bcSMarcelo Ricardo Leitner 1038ee44b4bcSMarcelo Ricardo Leitner bind_err: 1039ee44b4bcSMarcelo Ricardo Leitner con->sock = NULL; 1040ee44b4bcSMarcelo Ricardo Leitner sock_release(sock); 1041ee44b4bcSMarcelo Ricardo Leitner 1042ee44b4bcSMarcelo Ricardo Leitner socket_err: 1043ee44b4bcSMarcelo Ricardo Leitner /* 1044ee44b4bcSMarcelo Ricardo Leitner * Some errors are fatal and this list might need adjusting. For other 1045ee44b4bcSMarcelo Ricardo Leitner * errors we try again until the max number of retries is reached. 1046ee44b4bcSMarcelo Ricardo Leitner */ 1047ee44b4bcSMarcelo Ricardo Leitner if (result != -EHOSTUNREACH && 1048ee44b4bcSMarcelo Ricardo Leitner result != -ENETUNREACH && 1049ee44b4bcSMarcelo Ricardo Leitner result != -ENETDOWN && 1050ee44b4bcSMarcelo Ricardo Leitner result != -EINVAL && 1051ee44b4bcSMarcelo Ricardo Leitner result != -EPROTONOSUPPORT) { 1052ee44b4bcSMarcelo Ricardo Leitner log_print("connect %d try %d error %d", con->nodeid, 1053ee44b4bcSMarcelo Ricardo Leitner con->retries, result); 1054ee44b4bcSMarcelo Ricardo Leitner mutex_unlock(&con->sock_mutex); 1055ee44b4bcSMarcelo Ricardo Leitner msleep(1000); 10566ed7257bSPatrick Caulfield clear_bit(CF_CONNECT_PENDING, &con->flags); 1057ee44b4bcSMarcelo Ricardo Leitner lowcomms_connect_sock(con); 1058ee44b4bcSMarcelo Ricardo Leitner return; 10596ed7257bSPatrick Caulfield } 10605d689871SMike Christie 1061ee44b4bcSMarcelo Ricardo Leitner out: 10625d689871SMike Christie mutex_unlock(&con->sock_mutex); 106300dcffaeSMarcelo Ricardo Leitner set_bit(CF_WRITE_PENDING, &con->flags); 10646ed7257bSPatrick Caulfield } 10656ed7257bSPatrick Caulfield 10666ed7257bSPatrick Caulfield /* Connect a new socket to its peer */ 10676ed7257bSPatrick Caulfield static void tcp_connect_to_sock(struct connection *con) 10686ed7257bSPatrick Caulfield { 10696bd8fedaSLon Hohberger struct sockaddr_storage saddr, src_addr; 10706ed7257bSPatrick Caulfield int addr_len; 1071a89d63a1SCasey Dahlin struct socket *sock = NULL; 1072cb2d45daSDavid Teigland int one = 1; 107336b71a8bSDavid Teigland int result; 10746ed7257bSPatrick Caulfield 10756ed7257bSPatrick Caulfield if (con->nodeid == 0) { 10766ed7257bSPatrick Caulfield log_print("attempt to connect sock 0 foiled"); 10776ed7257bSPatrick Caulfield return; 10786ed7257bSPatrick Caulfield } 10796ed7257bSPatrick Caulfield 10806ed7257bSPatrick Caulfield mutex_lock(&con->sock_mutex); 10816ed7257bSPatrick Caulfield if (con->retries++ > MAX_CONNECT_RETRIES) 10826ed7257bSPatrick Caulfield goto out; 10836ed7257bSPatrick Caulfield 10846ed7257bSPatrick Caulfield /* Some odd races can cause double-connects, ignore them */ 108536b71a8bSDavid Teigland if (con->sock) 10866ed7257bSPatrick Caulfield goto out; 10876ed7257bSPatrick Caulfield 10886ed7257bSPatrick Caulfield /* Create a socket to communicate with */ 1089eeb1bd5cSEric W. Biederman result = sock_create_kern(&init_net, dlm_local_addr[0]->ss_family, 1090eeb1bd5cSEric W. Biederman SOCK_STREAM, IPPROTO_TCP, &sock); 10916ed7257bSPatrick Caulfield if (result < 0) 10926ed7257bSPatrick Caulfield goto out_err; 10936ed7257bSPatrick Caulfield 10946ed7257bSPatrick Caulfield memset(&saddr, 0, sizeof(saddr)); 109598e1b60eSMike Christie result = nodeid_to_addr(con->nodeid, &saddr, NULL, false); 109636b71a8bSDavid Teigland if (result < 0) { 109736b71a8bSDavid Teigland log_print("no address for nodeid %d", con->nodeid); 10986ed7257bSPatrick Caulfield goto out_err; 109936b71a8bSDavid Teigland } 11006ed7257bSPatrick Caulfield 11016ed7257bSPatrick Caulfield sock->sk->sk_user_data = con; 11026ed7257bSPatrick Caulfield con->rx_action = receive_from_sock; 11036ed7257bSPatrick Caulfield con->connect_action = tcp_connect_to_sock; 11046ed7257bSPatrick Caulfield add_sock(sock, con); 11056ed7257bSPatrick Caulfield 11066bd8fedaSLon Hohberger /* Bind to our cluster-known address connecting to avoid 11076bd8fedaSLon Hohberger routing problems */ 11086bd8fedaSLon Hohberger memcpy(&src_addr, dlm_local_addr[0], sizeof(src_addr)); 11096bd8fedaSLon Hohberger make_sockaddr(&src_addr, 0, &addr_len); 11106bd8fedaSLon Hohberger result = sock->ops->bind(sock, (struct sockaddr *) &src_addr, 11116bd8fedaSLon Hohberger addr_len); 11126bd8fedaSLon Hohberger if (result < 0) { 11136bd8fedaSLon Hohberger log_print("could not bind for connect: %d", result); 11146bd8fedaSLon Hohberger /* This *may* not indicate a critical error */ 11156bd8fedaSLon Hohberger } 11166bd8fedaSLon Hohberger 11176ed7257bSPatrick Caulfield make_sockaddr(&saddr, dlm_config.ci_tcp_port, &addr_len); 11186ed7257bSPatrick Caulfield 11196ed7257bSPatrick Caulfield log_print("connecting to %d", con->nodeid); 1120cb2d45daSDavid Teigland 1121cb2d45daSDavid Teigland /* Turn off Nagle's algorithm */ 1122cb2d45daSDavid Teigland kernel_setsockopt(sock, SOL_TCP, TCP_NODELAY, (char *)&one, 1123cb2d45daSDavid Teigland sizeof(one)); 1124cb2d45daSDavid Teigland 112536b71a8bSDavid Teigland result = sock->ops->connect(sock, (struct sockaddr *)&saddr, addr_len, 11266ed7257bSPatrick Caulfield O_NONBLOCK); 11276ed7257bSPatrick Caulfield if (result == -EINPROGRESS) 11286ed7257bSPatrick Caulfield result = 0; 11296ed7257bSPatrick Caulfield if (result == 0) 11306ed7257bSPatrick Caulfield goto out; 11316ed7257bSPatrick Caulfield 11326ed7257bSPatrick Caulfield out_err: 11336ed7257bSPatrick Caulfield if (con->sock) { 11346ed7257bSPatrick Caulfield sock_release(con->sock); 11356ed7257bSPatrick Caulfield con->sock = NULL; 1136a89d63a1SCasey Dahlin } else if (sock) { 1137a89d63a1SCasey Dahlin sock_release(sock); 11386ed7257bSPatrick Caulfield } 11396ed7257bSPatrick Caulfield /* 11406ed7257bSPatrick Caulfield * Some errors are fatal and this list might need adjusting. For other 11416ed7257bSPatrick Caulfield * errors we try again until the max number of retries is reached. 11426ed7257bSPatrick Caulfield */ 114336b71a8bSDavid Teigland if (result != -EHOSTUNREACH && 114436b71a8bSDavid Teigland result != -ENETUNREACH && 114536b71a8bSDavid Teigland result != -ENETDOWN && 114636b71a8bSDavid Teigland result != -EINVAL && 114736b71a8bSDavid Teigland result != -EPROTONOSUPPORT) { 114836b71a8bSDavid Teigland log_print("connect %d try %d error %d", con->nodeid, 114936b71a8bSDavid Teigland con->retries, result); 115036b71a8bSDavid Teigland mutex_unlock(&con->sock_mutex); 115136b71a8bSDavid Teigland msleep(1000); 1152356344c4SMarcelo Ricardo Leitner clear_bit(CF_CONNECT_PENDING, &con->flags); 11536ed7257bSPatrick Caulfield lowcomms_connect_sock(con); 115436b71a8bSDavid Teigland return; 11556ed7257bSPatrick Caulfield } 11566ed7257bSPatrick Caulfield out: 11576ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 115800dcffaeSMarcelo Ricardo Leitner set_bit(CF_WRITE_PENDING, &con->flags); 11596ed7257bSPatrick Caulfield return; 11606ed7257bSPatrick Caulfield } 11616ed7257bSPatrick Caulfield 11626ed7257bSPatrick Caulfield static struct socket *tcp_create_listen_sock(struct connection *con, 11636ed7257bSPatrick Caulfield struct sockaddr_storage *saddr) 11646ed7257bSPatrick Caulfield { 11656ed7257bSPatrick Caulfield struct socket *sock = NULL; 11666ed7257bSPatrick Caulfield int result = 0; 11676ed7257bSPatrick Caulfield int one = 1; 11686ed7257bSPatrick Caulfield int addr_len; 11696ed7257bSPatrick Caulfield 11706ed7257bSPatrick Caulfield if (dlm_local_addr[0]->ss_family == AF_INET) 11716ed7257bSPatrick Caulfield addr_len = sizeof(struct sockaddr_in); 11726ed7257bSPatrick Caulfield else 11736ed7257bSPatrick Caulfield addr_len = sizeof(struct sockaddr_in6); 11746ed7257bSPatrick Caulfield 11756ed7257bSPatrick Caulfield /* Create a socket to communicate with */ 1176eeb1bd5cSEric W. Biederman result = sock_create_kern(&init_net, dlm_local_addr[0]->ss_family, 1177eeb1bd5cSEric W. Biederman SOCK_STREAM, IPPROTO_TCP, &sock); 11786ed7257bSPatrick Caulfield if (result < 0) { 1179617e82e1SDavid Teigland log_print("Can't create listening comms socket"); 11806ed7257bSPatrick Caulfield goto create_out; 11816ed7257bSPatrick Caulfield } 11826ed7257bSPatrick Caulfield 1183cb2d45daSDavid Teigland /* Turn off Nagle's algorithm */ 1184cb2d45daSDavid Teigland kernel_setsockopt(sock, SOL_TCP, TCP_NODELAY, (char *)&one, 1185cb2d45daSDavid Teigland sizeof(one)); 1186cb2d45daSDavid Teigland 11876ed7257bSPatrick Caulfield result = kernel_setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, 11886ed7257bSPatrick Caulfield (char *)&one, sizeof(one)); 11896ed7257bSPatrick Caulfield 11906ed7257bSPatrick Caulfield if (result < 0) { 1191617e82e1SDavid Teigland log_print("Failed to set SO_REUSEADDR on socket: %d", result); 11926ed7257bSPatrick Caulfield } 11936ed7257bSPatrick Caulfield con->rx_action = tcp_accept_from_sock; 11946ed7257bSPatrick Caulfield con->connect_action = tcp_connect_to_sock; 11956ed7257bSPatrick Caulfield 11966ed7257bSPatrick Caulfield /* Bind to our port */ 11976ed7257bSPatrick Caulfield make_sockaddr(saddr, dlm_config.ci_tcp_port, &addr_len); 11986ed7257bSPatrick Caulfield result = sock->ops->bind(sock, (struct sockaddr *) saddr, addr_len); 11996ed7257bSPatrick Caulfield if (result < 0) { 1200617e82e1SDavid Teigland log_print("Can't bind to port %d", dlm_config.ci_tcp_port); 12016ed7257bSPatrick Caulfield sock_release(sock); 12026ed7257bSPatrick Caulfield sock = NULL; 12036ed7257bSPatrick Caulfield con->sock = NULL; 12046ed7257bSPatrick Caulfield goto create_out; 12056ed7257bSPatrick Caulfield } 12066ed7257bSPatrick Caulfield result = kernel_setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, 12076ed7257bSPatrick Caulfield (char *)&one, sizeof(one)); 12086ed7257bSPatrick Caulfield if (result < 0) { 1209617e82e1SDavid Teigland log_print("Set keepalive failed: %d", result); 12106ed7257bSPatrick Caulfield } 12116ed7257bSPatrick Caulfield 12126ed7257bSPatrick Caulfield result = sock->ops->listen(sock, 5); 12136ed7257bSPatrick Caulfield if (result < 0) { 1214617e82e1SDavid Teigland log_print("Can't listen on port %d", dlm_config.ci_tcp_port); 12156ed7257bSPatrick Caulfield sock_release(sock); 12166ed7257bSPatrick Caulfield sock = NULL; 12176ed7257bSPatrick Caulfield goto create_out; 12186ed7257bSPatrick Caulfield } 12196ed7257bSPatrick Caulfield 12206ed7257bSPatrick Caulfield create_out: 12216ed7257bSPatrick Caulfield return sock; 12226ed7257bSPatrick Caulfield } 12236ed7257bSPatrick Caulfield 12246ed7257bSPatrick Caulfield /* Get local addresses */ 12256ed7257bSPatrick Caulfield static void init_local(void) 12266ed7257bSPatrick Caulfield { 12276ed7257bSPatrick Caulfield struct sockaddr_storage sas, *addr; 12286ed7257bSPatrick Caulfield int i; 12296ed7257bSPatrick Caulfield 123030d3a237SPatrick Caulfield dlm_local_count = 0; 12311b189b88SDavid Teigland for (i = 0; i < DLM_MAX_ADDR_COUNT; i++) { 12326ed7257bSPatrick Caulfield if (dlm_our_addr(&sas, i)) 12336ed7257bSPatrick Caulfield break; 12346ed7257bSPatrick Caulfield 1235573c24c4SDavid Teigland addr = kmalloc(sizeof(*addr), GFP_NOFS); 12366ed7257bSPatrick Caulfield if (!addr) 12376ed7257bSPatrick Caulfield break; 12386ed7257bSPatrick Caulfield memcpy(addr, &sas, sizeof(*addr)); 12396ed7257bSPatrick Caulfield dlm_local_addr[dlm_local_count++] = addr; 12406ed7257bSPatrick Caulfield } 12416ed7257bSPatrick Caulfield } 12426ed7257bSPatrick Caulfield 12436ed7257bSPatrick Caulfield /* Initialise SCTP socket and bind to all interfaces */ 12446ed7257bSPatrick Caulfield static int sctp_listen_for_all(void) 12456ed7257bSPatrick Caulfield { 12466ed7257bSPatrick Caulfield struct socket *sock = NULL; 1247ee44b4bcSMarcelo Ricardo Leitner int result = -EINVAL; 1248573c24c4SDavid Teigland struct connection *con = nodeid2con(0, GFP_NOFS); 12496ed7257bSPatrick Caulfield int bufsize = NEEDED_RMEM; 125086e92ad2SMike Christie int one = 1; 12516ed7257bSPatrick Caulfield 12526ed7257bSPatrick Caulfield if (!con) 12536ed7257bSPatrick Caulfield return -ENOMEM; 12546ed7257bSPatrick Caulfield 12556ed7257bSPatrick Caulfield log_print("Using SCTP for communications"); 12566ed7257bSPatrick Caulfield 1257eeb1bd5cSEric W. Biederman result = sock_create_kern(&init_net, dlm_local_addr[0]->ss_family, 1258ee44b4bcSMarcelo Ricardo Leitner SOCK_STREAM, IPPROTO_SCTP, &sock); 12596ed7257bSPatrick Caulfield if (result < 0) { 12606ed7257bSPatrick Caulfield log_print("Can't create comms socket, check SCTP is loaded"); 12616ed7257bSPatrick Caulfield goto out; 12626ed7257bSPatrick Caulfield } 12636ed7257bSPatrick Caulfield 1264df61c952SDavid S. Miller result = kernel_setsockopt(sock, SOL_SOCKET, SO_RCVBUFFORCE, 12656ed7257bSPatrick Caulfield (char *)&bufsize, sizeof(bufsize)); 12666ed7257bSPatrick Caulfield if (result) 1267617e82e1SDavid Teigland log_print("Error increasing buffer space on socket %d", result); 12686ed7257bSPatrick Caulfield 126986e92ad2SMike Christie result = kernel_setsockopt(sock, SOL_SCTP, SCTP_NODELAY, (char *)&one, 127086e92ad2SMike Christie sizeof(one)); 127186e92ad2SMike Christie if (result < 0) 127286e92ad2SMike Christie log_print("Could not set SCTP NODELAY error %d\n", result); 127386e92ad2SMike Christie 12746ed7257bSPatrick Caulfield /* Init con struct */ 12756ed7257bSPatrick Caulfield sock->sk->sk_user_data = con; 12766ed7257bSPatrick Caulfield con->sock = sock; 12776ed7257bSPatrick Caulfield con->sock->sk->sk_data_ready = lowcomms_data_ready; 1278ee44b4bcSMarcelo Ricardo Leitner con->rx_action = sctp_accept_from_sock; 1279ee44b4bcSMarcelo Ricardo Leitner con->connect_action = sctp_connect_to_sock; 12806ed7257bSPatrick Caulfield 1281ee44b4bcSMarcelo Ricardo Leitner /* Bind to all addresses. */ 1282ee44b4bcSMarcelo Ricardo Leitner if (sctp_bind_addrs(con, dlm_config.ci_tcp_port)) 12836ed7257bSPatrick Caulfield goto create_delsock; 12846ed7257bSPatrick Caulfield 12856ed7257bSPatrick Caulfield result = sock->ops->listen(sock, 5); 12866ed7257bSPatrick Caulfield if (result < 0) { 12876ed7257bSPatrick Caulfield log_print("Can't set socket listening"); 12886ed7257bSPatrick Caulfield goto create_delsock; 12896ed7257bSPatrick Caulfield } 12906ed7257bSPatrick Caulfield 12916ed7257bSPatrick Caulfield return 0; 12926ed7257bSPatrick Caulfield 12936ed7257bSPatrick Caulfield create_delsock: 12946ed7257bSPatrick Caulfield sock_release(sock); 12956ed7257bSPatrick Caulfield con->sock = NULL; 12966ed7257bSPatrick Caulfield out: 12976ed7257bSPatrick Caulfield return result; 12986ed7257bSPatrick Caulfield } 12996ed7257bSPatrick Caulfield 13006ed7257bSPatrick Caulfield static int tcp_listen_for_all(void) 13016ed7257bSPatrick Caulfield { 13026ed7257bSPatrick Caulfield struct socket *sock = NULL; 1303573c24c4SDavid Teigland struct connection *con = nodeid2con(0, GFP_NOFS); 13046ed7257bSPatrick Caulfield int result = -EINVAL; 13056ed7257bSPatrick Caulfield 13066ed7257bSPatrick Caulfield if (!con) 13076ed7257bSPatrick Caulfield return -ENOMEM; 13086ed7257bSPatrick Caulfield 13096ed7257bSPatrick Caulfield /* We don't support multi-homed hosts */ 13106ed7257bSPatrick Caulfield if (dlm_local_addr[1] != NULL) { 1311617e82e1SDavid Teigland log_print("TCP protocol can't handle multi-homed hosts, " 1312617e82e1SDavid Teigland "try SCTP"); 13136ed7257bSPatrick Caulfield return -EINVAL; 13146ed7257bSPatrick Caulfield } 13156ed7257bSPatrick Caulfield 13166ed7257bSPatrick Caulfield log_print("Using TCP for communications"); 13176ed7257bSPatrick Caulfield 13186ed7257bSPatrick Caulfield sock = tcp_create_listen_sock(con, dlm_local_addr[0]); 13196ed7257bSPatrick Caulfield if (sock) { 13206ed7257bSPatrick Caulfield add_sock(sock, con); 13216ed7257bSPatrick Caulfield result = 0; 13226ed7257bSPatrick Caulfield } 13236ed7257bSPatrick Caulfield else { 13246ed7257bSPatrick Caulfield result = -EADDRINUSE; 13256ed7257bSPatrick Caulfield } 13266ed7257bSPatrick Caulfield 13276ed7257bSPatrick Caulfield return result; 13286ed7257bSPatrick Caulfield } 13296ed7257bSPatrick Caulfield 13306ed7257bSPatrick Caulfield 13316ed7257bSPatrick Caulfield 13326ed7257bSPatrick Caulfield static struct writequeue_entry *new_writequeue_entry(struct connection *con, 13336ed7257bSPatrick Caulfield gfp_t allocation) 13346ed7257bSPatrick Caulfield { 13356ed7257bSPatrick Caulfield struct writequeue_entry *entry; 13366ed7257bSPatrick Caulfield 13376ed7257bSPatrick Caulfield entry = kmalloc(sizeof(struct writequeue_entry), allocation); 13386ed7257bSPatrick Caulfield if (!entry) 13396ed7257bSPatrick Caulfield return NULL; 13406ed7257bSPatrick Caulfield 13416ed7257bSPatrick Caulfield entry->page = alloc_page(allocation); 13426ed7257bSPatrick Caulfield if (!entry->page) { 13436ed7257bSPatrick Caulfield kfree(entry); 13446ed7257bSPatrick Caulfield return NULL; 13456ed7257bSPatrick Caulfield } 13466ed7257bSPatrick Caulfield 13476ed7257bSPatrick Caulfield entry->offset = 0; 13486ed7257bSPatrick Caulfield entry->len = 0; 13496ed7257bSPatrick Caulfield entry->end = 0; 13506ed7257bSPatrick Caulfield entry->users = 0; 13516ed7257bSPatrick Caulfield entry->con = con; 13526ed7257bSPatrick Caulfield 13536ed7257bSPatrick Caulfield return entry; 13546ed7257bSPatrick Caulfield } 13556ed7257bSPatrick Caulfield 1356617e82e1SDavid Teigland void *dlm_lowcomms_get_buffer(int nodeid, int len, gfp_t allocation, char **ppc) 13576ed7257bSPatrick Caulfield { 13586ed7257bSPatrick Caulfield struct connection *con; 13596ed7257bSPatrick Caulfield struct writequeue_entry *e; 13606ed7257bSPatrick Caulfield int offset = 0; 13616ed7257bSPatrick Caulfield 13626ed7257bSPatrick Caulfield con = nodeid2con(nodeid, allocation); 13636ed7257bSPatrick Caulfield if (!con) 13646ed7257bSPatrick Caulfield return NULL; 13656ed7257bSPatrick Caulfield 13666ed7257bSPatrick Caulfield spin_lock(&con->writequeue_lock); 13676ed7257bSPatrick Caulfield e = list_entry(con->writequeue.prev, struct writequeue_entry, list); 13686ed7257bSPatrick Caulfield if ((&e->list == &con->writequeue) || 13696ed7257bSPatrick Caulfield (PAGE_CACHE_SIZE - e->end < len)) { 13706ed7257bSPatrick Caulfield e = NULL; 13716ed7257bSPatrick Caulfield } else { 13726ed7257bSPatrick Caulfield offset = e->end; 13736ed7257bSPatrick Caulfield e->end += len; 1374eeee2b5fSWei Yongjun e->users++; 13756ed7257bSPatrick Caulfield } 13766ed7257bSPatrick Caulfield spin_unlock(&con->writequeue_lock); 13776ed7257bSPatrick Caulfield 13786ed7257bSPatrick Caulfield if (e) { 13796ed7257bSPatrick Caulfield got_one: 13806ed7257bSPatrick Caulfield *ppc = page_address(e->page) + offset; 13816ed7257bSPatrick Caulfield return e; 13826ed7257bSPatrick Caulfield } 13836ed7257bSPatrick Caulfield 13846ed7257bSPatrick Caulfield e = new_writequeue_entry(con, allocation); 13856ed7257bSPatrick Caulfield if (e) { 13866ed7257bSPatrick Caulfield spin_lock(&con->writequeue_lock); 13876ed7257bSPatrick Caulfield offset = e->end; 13886ed7257bSPatrick Caulfield e->end += len; 1389eeee2b5fSWei Yongjun e->users++; 13906ed7257bSPatrick Caulfield list_add_tail(&e->list, &con->writequeue); 13916ed7257bSPatrick Caulfield spin_unlock(&con->writequeue_lock); 13926ed7257bSPatrick Caulfield goto got_one; 13936ed7257bSPatrick Caulfield } 13946ed7257bSPatrick Caulfield return NULL; 13956ed7257bSPatrick Caulfield } 13966ed7257bSPatrick Caulfield 13976ed7257bSPatrick Caulfield void dlm_lowcomms_commit_buffer(void *mh) 13986ed7257bSPatrick Caulfield { 13996ed7257bSPatrick Caulfield struct writequeue_entry *e = (struct writequeue_entry *)mh; 14006ed7257bSPatrick Caulfield struct connection *con = e->con; 14016ed7257bSPatrick Caulfield int users; 14026ed7257bSPatrick Caulfield 14036ed7257bSPatrick Caulfield spin_lock(&con->writequeue_lock); 14046ed7257bSPatrick Caulfield users = --e->users; 14056ed7257bSPatrick Caulfield if (users) 14066ed7257bSPatrick Caulfield goto out; 14076ed7257bSPatrick Caulfield e->len = e->end - e->offset; 14086ed7257bSPatrick Caulfield spin_unlock(&con->writequeue_lock); 14096ed7257bSPatrick Caulfield 14106ed7257bSPatrick Caulfield if (!test_and_set_bit(CF_WRITE_PENDING, &con->flags)) { 14116ed7257bSPatrick Caulfield queue_work(send_workqueue, &con->swork); 14126ed7257bSPatrick Caulfield } 14136ed7257bSPatrick Caulfield return; 14146ed7257bSPatrick Caulfield 14156ed7257bSPatrick Caulfield out: 14166ed7257bSPatrick Caulfield spin_unlock(&con->writequeue_lock); 14176ed7257bSPatrick Caulfield return; 14186ed7257bSPatrick Caulfield } 14196ed7257bSPatrick Caulfield 14206ed7257bSPatrick Caulfield /* Send a message */ 14216ed7257bSPatrick Caulfield static void send_to_sock(struct connection *con) 14226ed7257bSPatrick Caulfield { 14236ed7257bSPatrick Caulfield int ret = 0; 14246ed7257bSPatrick Caulfield const int msg_flags = MSG_DONTWAIT | MSG_NOSIGNAL; 14256ed7257bSPatrick Caulfield struct writequeue_entry *e; 14266ed7257bSPatrick Caulfield int len, offset; 1427f92c8dd7SBob Peterson int count = 0; 14286ed7257bSPatrick Caulfield 14296ed7257bSPatrick Caulfield mutex_lock(&con->sock_mutex); 14306ed7257bSPatrick Caulfield if (con->sock == NULL) 14316ed7257bSPatrick Caulfield goto out_connect; 14326ed7257bSPatrick Caulfield 14336ed7257bSPatrick Caulfield spin_lock(&con->writequeue_lock); 14346ed7257bSPatrick Caulfield for (;;) { 14356ed7257bSPatrick Caulfield e = list_entry(con->writequeue.next, struct writequeue_entry, 14366ed7257bSPatrick Caulfield list); 14376ed7257bSPatrick Caulfield if ((struct list_head *) e == &con->writequeue) 14386ed7257bSPatrick Caulfield break; 14396ed7257bSPatrick Caulfield 14406ed7257bSPatrick Caulfield len = e->len; 14416ed7257bSPatrick Caulfield offset = e->offset; 14426ed7257bSPatrick Caulfield BUG_ON(len == 0 && e->users == 0); 14436ed7257bSPatrick Caulfield spin_unlock(&con->writequeue_lock); 14446ed7257bSPatrick Caulfield 14456ed7257bSPatrick Caulfield ret = 0; 14466ed7257bSPatrick Caulfield if (len) { 14471329e3f2SPaolo Bonzini ret = kernel_sendpage(con->sock, e->page, offset, len, 14486ed7257bSPatrick Caulfield msg_flags); 1449d66f8277SPatrick Caulfield if (ret == -EAGAIN || ret == 0) { 1450b36930ddSDavid Miller if (ret == -EAGAIN && 14519cd3e072SEric Dumazet test_bit(SOCKWQ_ASYNC_NOSPACE, &con->sock->flags) && 1452b36930ddSDavid Miller !test_and_set_bit(CF_APP_LIMITED, &con->flags)) { 1453b36930ddSDavid Miller /* Notify TCP that we're limited by the 1454b36930ddSDavid Miller * application window size. 1455b36930ddSDavid Miller */ 1456b36930ddSDavid Miller set_bit(SOCK_NOSPACE, &con->sock->flags); 1457b36930ddSDavid Miller con->sock->sk->sk_write_pending++; 1458b36930ddSDavid Miller } 1459d66f8277SPatrick Caulfield cond_resched(); 14606ed7257bSPatrick Caulfield goto out; 14619c5bef58SYing Xue } else if (ret < 0) 14626ed7257bSPatrick Caulfield goto send_error; 1463d66f8277SPatrick Caulfield } 1464f92c8dd7SBob Peterson 14656ed7257bSPatrick Caulfield /* Don't starve people filling buffers */ 1466f92c8dd7SBob Peterson if (++count >= MAX_SEND_MSG_COUNT) { 14676ed7257bSPatrick Caulfield cond_resched(); 1468f92c8dd7SBob Peterson count = 0; 1469f92c8dd7SBob Peterson } 14706ed7257bSPatrick Caulfield 14716ed7257bSPatrick Caulfield spin_lock(&con->writequeue_lock); 14725d689871SMike Christie writequeue_entry_complete(e, ret); 14736ed7257bSPatrick Caulfield } 14746ed7257bSPatrick Caulfield spin_unlock(&con->writequeue_lock); 14756ed7257bSPatrick Caulfield out: 14766ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 14776ed7257bSPatrick Caulfield return; 14786ed7257bSPatrick Caulfield 14796ed7257bSPatrick Caulfield send_error: 14806ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 14810d737a8cSMarcelo Ricardo Leitner close_connection(con, false, false, true); 14826ed7257bSPatrick Caulfield lowcomms_connect_sock(con); 14836ed7257bSPatrick Caulfield return; 14846ed7257bSPatrick Caulfield 14856ed7257bSPatrick Caulfield out_connect: 14866ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 14876ed7257bSPatrick Caulfield lowcomms_connect_sock(con); 14886ed7257bSPatrick Caulfield } 14896ed7257bSPatrick Caulfield 14906ed7257bSPatrick Caulfield static void clean_one_writequeue(struct connection *con) 14916ed7257bSPatrick Caulfield { 14925e9ccc37SChristine Caulfield struct writequeue_entry *e, *safe; 14936ed7257bSPatrick Caulfield 14946ed7257bSPatrick Caulfield spin_lock(&con->writequeue_lock); 14955e9ccc37SChristine Caulfield list_for_each_entry_safe(e, safe, &con->writequeue, list) { 14966ed7257bSPatrick Caulfield list_del(&e->list); 14976ed7257bSPatrick Caulfield free_entry(e); 14986ed7257bSPatrick Caulfield } 14996ed7257bSPatrick Caulfield spin_unlock(&con->writequeue_lock); 15006ed7257bSPatrick Caulfield } 15016ed7257bSPatrick Caulfield 15026ed7257bSPatrick Caulfield /* Called from recovery when it knows that a node has 15036ed7257bSPatrick Caulfield left the cluster */ 15046ed7257bSPatrick Caulfield int dlm_lowcomms_close(int nodeid) 15056ed7257bSPatrick Caulfield { 15066ed7257bSPatrick Caulfield struct connection *con; 150736b71a8bSDavid Teigland struct dlm_node_addr *na; 15086ed7257bSPatrick Caulfield 15096ed7257bSPatrick Caulfield log_print("closing connection to node %d", nodeid); 15106ed7257bSPatrick Caulfield con = nodeid2con(nodeid, 0); 15116ed7257bSPatrick Caulfield if (con) { 1512063c4c99SLars Marowsky-Bree set_bit(CF_CLOSE, &con->flags); 15130d737a8cSMarcelo Ricardo Leitner close_connection(con, true, true, true); 15146ed7257bSPatrick Caulfield clean_one_writequeue(con); 15156ed7257bSPatrick Caulfield } 151636b71a8bSDavid Teigland 151736b71a8bSDavid Teigland spin_lock(&dlm_node_addrs_spin); 151836b71a8bSDavid Teigland na = find_node_addr(nodeid); 151936b71a8bSDavid Teigland if (na) { 152036b71a8bSDavid Teigland list_del(&na->list); 152136b71a8bSDavid Teigland while (na->addr_count--) 152236b71a8bSDavid Teigland kfree(na->addr[na->addr_count]); 152336b71a8bSDavid Teigland kfree(na); 152436b71a8bSDavid Teigland } 152536b71a8bSDavid Teigland spin_unlock(&dlm_node_addrs_spin); 152636b71a8bSDavid Teigland 15276ed7257bSPatrick Caulfield return 0; 15286ed7257bSPatrick Caulfield } 15296ed7257bSPatrick Caulfield 15306ed7257bSPatrick Caulfield /* Receive workqueue function */ 15316ed7257bSPatrick Caulfield static void process_recv_sockets(struct work_struct *work) 15326ed7257bSPatrick Caulfield { 15336ed7257bSPatrick Caulfield struct connection *con = container_of(work, struct connection, rwork); 15346ed7257bSPatrick Caulfield int err; 15356ed7257bSPatrick Caulfield 15366ed7257bSPatrick Caulfield clear_bit(CF_READ_PENDING, &con->flags); 15376ed7257bSPatrick Caulfield do { 15386ed7257bSPatrick Caulfield err = con->rx_action(con); 15396ed7257bSPatrick Caulfield } while (!err); 15406ed7257bSPatrick Caulfield } 15416ed7257bSPatrick Caulfield 15426ed7257bSPatrick Caulfield /* Send workqueue function */ 15436ed7257bSPatrick Caulfield static void process_send_sockets(struct work_struct *work) 15446ed7257bSPatrick Caulfield { 15456ed7257bSPatrick Caulfield struct connection *con = container_of(work, struct connection, swork); 15466ed7257bSPatrick Caulfield 154700dcffaeSMarcelo Ricardo Leitner if (test_and_clear_bit(CF_CONNECT_PENDING, &con->flags)) 15486ed7257bSPatrick Caulfield con->connect_action(con); 1549063c4c99SLars Marowsky-Bree if (test_and_clear_bit(CF_WRITE_PENDING, &con->flags)) 15506ed7257bSPatrick Caulfield send_to_sock(con); 15516ed7257bSPatrick Caulfield } 15526ed7257bSPatrick Caulfield 15536ed7257bSPatrick Caulfield 15546ed7257bSPatrick Caulfield /* Discard all entries on the write queues */ 15556ed7257bSPatrick Caulfield static void clean_writequeues(void) 15566ed7257bSPatrick Caulfield { 15575e9ccc37SChristine Caulfield foreach_conn(clean_one_writequeue); 15586ed7257bSPatrick Caulfield } 15596ed7257bSPatrick Caulfield 15606ed7257bSPatrick Caulfield static void work_stop(void) 15616ed7257bSPatrick Caulfield { 15626ed7257bSPatrick Caulfield destroy_workqueue(recv_workqueue); 15636ed7257bSPatrick Caulfield destroy_workqueue(send_workqueue); 15646ed7257bSPatrick Caulfield } 15656ed7257bSPatrick Caulfield 15666ed7257bSPatrick Caulfield static int work_start(void) 15676ed7257bSPatrick Caulfield { 1568e43f055aSDavid Teigland recv_workqueue = alloc_workqueue("dlm_recv", 1569e43f055aSDavid Teigland WQ_UNBOUND | WQ_MEM_RECLAIM, 1); 1570b9d41052SNamhyung Kim if (!recv_workqueue) { 1571b9d41052SNamhyung Kim log_print("can't start dlm_recv"); 1572b9d41052SNamhyung Kim return -ENOMEM; 15736ed7257bSPatrick Caulfield } 15746ed7257bSPatrick Caulfield 1575e43f055aSDavid Teigland send_workqueue = alloc_workqueue("dlm_send", 1576e43f055aSDavid Teigland WQ_UNBOUND | WQ_MEM_RECLAIM, 1); 1577b9d41052SNamhyung Kim if (!send_workqueue) { 1578b9d41052SNamhyung Kim log_print("can't start dlm_send"); 15796ed7257bSPatrick Caulfield destroy_workqueue(recv_workqueue); 1580b9d41052SNamhyung Kim return -ENOMEM; 15816ed7257bSPatrick Caulfield } 15826ed7257bSPatrick Caulfield 15836ed7257bSPatrick Caulfield return 0; 15846ed7257bSPatrick Caulfield } 15856ed7257bSPatrick Caulfield 15865e9ccc37SChristine Caulfield static void stop_conn(struct connection *con) 15876ed7257bSPatrick Caulfield { 15889e5f2825SPatrick Caulfield con->flags |= 0x0F; 1589391fbdc5SChristine Caulfield if (con->sock && con->sock->sk) 1590afb853fbSPatrick Caulfield con->sock->sk->sk_user_data = NULL; 1591afb853fbSPatrick Caulfield } 15925e9ccc37SChristine Caulfield 15935e9ccc37SChristine Caulfield static void free_conn(struct connection *con) 15945e9ccc37SChristine Caulfield { 15950d737a8cSMarcelo Ricardo Leitner close_connection(con, true, true, true); 15965e9ccc37SChristine Caulfield if (con->othercon) 15975e9ccc37SChristine Caulfield kmem_cache_free(con_cache, con->othercon); 15985e9ccc37SChristine Caulfield hlist_del(&con->list); 15995e9ccc37SChristine Caulfield kmem_cache_free(con_cache, con); 16006ed7257bSPatrick Caulfield } 16015e9ccc37SChristine Caulfield 16025e9ccc37SChristine Caulfield void dlm_lowcomms_stop(void) 16035e9ccc37SChristine Caulfield { 16045e9ccc37SChristine Caulfield /* Set all the flags to prevent any 16055e9ccc37SChristine Caulfield socket activity. 16065e9ccc37SChristine Caulfield */ 16075e9ccc37SChristine Caulfield mutex_lock(&connections_lock); 1608513ef596SDavid Teigland dlm_allow_conn = 0; 16095e9ccc37SChristine Caulfield foreach_conn(stop_conn); 16107a936ce7SMatthias Kaehlcke mutex_unlock(&connections_lock); 16116ed7257bSPatrick Caulfield 16126ed7257bSPatrick Caulfield work_stop(); 16136ed7257bSPatrick Caulfield 16147a936ce7SMatthias Kaehlcke mutex_lock(&connections_lock); 16156ed7257bSPatrick Caulfield clean_writequeues(); 16166ed7257bSPatrick Caulfield 16175e9ccc37SChristine Caulfield foreach_conn(free_conn); 16185e9ccc37SChristine Caulfield 16197a936ce7SMatthias Kaehlcke mutex_unlock(&connections_lock); 16206ed7257bSPatrick Caulfield kmem_cache_destroy(con_cache); 16216ed7257bSPatrick Caulfield } 16226ed7257bSPatrick Caulfield 16236ed7257bSPatrick Caulfield int dlm_lowcomms_start(void) 16246ed7257bSPatrick Caulfield { 16256ed7257bSPatrick Caulfield int error = -EINVAL; 16266ed7257bSPatrick Caulfield struct connection *con; 16275e9ccc37SChristine Caulfield int i; 16285e9ccc37SChristine Caulfield 16295e9ccc37SChristine Caulfield for (i = 0; i < CONN_HASH_SIZE; i++) 16305e9ccc37SChristine Caulfield INIT_HLIST_HEAD(&connection_hash[i]); 16316ed7257bSPatrick Caulfield 16326ed7257bSPatrick Caulfield init_local(); 16336ed7257bSPatrick Caulfield if (!dlm_local_count) { 1634617e82e1SDavid Teigland error = -ENOTCONN; 16356ed7257bSPatrick Caulfield log_print("no local IP address has been set"); 1636513ef596SDavid Teigland goto fail; 16376ed7257bSPatrick Caulfield } 16386ed7257bSPatrick Caulfield 16396ed7257bSPatrick Caulfield error = -ENOMEM; 16406ed7257bSPatrick Caulfield con_cache = kmem_cache_create("dlm_conn", sizeof(struct connection), 16416ed7257bSPatrick Caulfield __alignof__(struct connection), 0, 164220c2df83SPaul Mundt NULL); 16436ed7257bSPatrick Caulfield if (!con_cache) 1644513ef596SDavid Teigland goto fail; 1645513ef596SDavid Teigland 1646513ef596SDavid Teigland error = work_start(); 1647513ef596SDavid Teigland if (error) 1648513ef596SDavid Teigland goto fail_destroy; 1649513ef596SDavid Teigland 1650513ef596SDavid Teigland dlm_allow_conn = 1; 16516ed7257bSPatrick Caulfield 16526ed7257bSPatrick Caulfield /* Start listening */ 16536ed7257bSPatrick Caulfield if (dlm_config.ci_protocol == 0) 16546ed7257bSPatrick Caulfield error = tcp_listen_for_all(); 16556ed7257bSPatrick Caulfield else 16566ed7257bSPatrick Caulfield error = sctp_listen_for_all(); 16576ed7257bSPatrick Caulfield if (error) 16586ed7257bSPatrick Caulfield goto fail_unlisten; 16596ed7257bSPatrick Caulfield 16606ed7257bSPatrick Caulfield return 0; 16616ed7257bSPatrick Caulfield 16626ed7257bSPatrick Caulfield fail_unlisten: 1663513ef596SDavid Teigland dlm_allow_conn = 0; 16646ed7257bSPatrick Caulfield con = nodeid2con(0,0); 16656ed7257bSPatrick Caulfield if (con) { 16660d737a8cSMarcelo Ricardo Leitner close_connection(con, false, true, true); 16676ed7257bSPatrick Caulfield kmem_cache_free(con_cache, con); 16686ed7257bSPatrick Caulfield } 1669513ef596SDavid Teigland fail_destroy: 16706ed7257bSPatrick Caulfield kmem_cache_destroy(con_cache); 1671513ef596SDavid Teigland fail: 16726ed7257bSPatrick Caulfield return error; 16736ed7257bSPatrick Caulfield } 167436b71a8bSDavid Teigland 167536b71a8bSDavid Teigland void dlm_lowcomms_exit(void) 167636b71a8bSDavid Teigland { 167736b71a8bSDavid Teigland struct dlm_node_addr *na, *safe; 167836b71a8bSDavid Teigland 167936b71a8bSDavid Teigland spin_lock(&dlm_node_addrs_spin); 168036b71a8bSDavid Teigland list_for_each_entry_safe(na, safe, &dlm_node_addrs, list) { 168136b71a8bSDavid Teigland list_del(&na->list); 168236b71a8bSDavid Teigland while (na->addr_count--) 168336b71a8bSDavid Teigland kfree(na->addr[na->addr_count]); 168436b71a8bSDavid Teigland kfree(na); 168536b71a8bSDavid Teigland } 168636b71a8bSDavid Teigland spin_unlock(&dlm_node_addrs_spin); 168736b71a8bSDavid Teigland } 1688