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> 551b866434SDaniel Borkmann #include <linux/sctp.h> 562f2d76ccSBenjamin Poirier #include <net/sctp/sctp.h> 5744ad532bSJoe Perches #include <net/ipv6.h> 586ed7257bSPatrick Caulfield 596ed7257bSPatrick Caulfield #include "dlm_internal.h" 606ed7257bSPatrick Caulfield #include "lowcomms.h" 616ed7257bSPatrick Caulfield #include "midcomms.h" 626ed7257bSPatrick Caulfield #include "config.h" 636ed7257bSPatrick Caulfield 646ed7257bSPatrick Caulfield #define NEEDED_RMEM (4*1024*1024) 655e9ccc37SChristine Caulfield #define CONN_HASH_SIZE 32 666ed7257bSPatrick Caulfield 67f92c8dd7SBob Peterson /* Number of messages to send before rescheduling */ 68f92c8dd7SBob Peterson #define MAX_SEND_MSG_COUNT 25 69f92c8dd7SBob Peterson 706ed7257bSPatrick Caulfield struct cbuf { 716ed7257bSPatrick Caulfield unsigned int base; 726ed7257bSPatrick Caulfield unsigned int len; 736ed7257bSPatrick Caulfield unsigned int mask; 746ed7257bSPatrick Caulfield }; 756ed7257bSPatrick Caulfield 766ed7257bSPatrick Caulfield static void cbuf_add(struct cbuf *cb, int n) 776ed7257bSPatrick Caulfield { 786ed7257bSPatrick Caulfield cb->len += n; 796ed7257bSPatrick Caulfield } 806ed7257bSPatrick Caulfield 816ed7257bSPatrick Caulfield static int cbuf_data(struct cbuf *cb) 826ed7257bSPatrick Caulfield { 836ed7257bSPatrick Caulfield return ((cb->base + cb->len) & cb->mask); 846ed7257bSPatrick Caulfield } 856ed7257bSPatrick Caulfield 866ed7257bSPatrick Caulfield static void cbuf_init(struct cbuf *cb, int size) 876ed7257bSPatrick Caulfield { 886ed7257bSPatrick Caulfield cb->base = cb->len = 0; 896ed7257bSPatrick Caulfield cb->mask = size-1; 906ed7257bSPatrick Caulfield } 916ed7257bSPatrick Caulfield 926ed7257bSPatrick Caulfield static void cbuf_eat(struct cbuf *cb, int n) 936ed7257bSPatrick Caulfield { 946ed7257bSPatrick Caulfield cb->len -= n; 956ed7257bSPatrick Caulfield cb->base += n; 966ed7257bSPatrick Caulfield cb->base &= cb->mask; 976ed7257bSPatrick Caulfield } 986ed7257bSPatrick Caulfield 996ed7257bSPatrick Caulfield static bool cbuf_empty(struct cbuf *cb) 1006ed7257bSPatrick Caulfield { 1016ed7257bSPatrick Caulfield return cb->len == 0; 1026ed7257bSPatrick Caulfield } 1036ed7257bSPatrick Caulfield 1046ed7257bSPatrick Caulfield struct connection { 1056ed7257bSPatrick Caulfield struct socket *sock; /* NULL if not connected */ 1066ed7257bSPatrick Caulfield uint32_t nodeid; /* So we know who we are in the list */ 1076ed7257bSPatrick Caulfield struct mutex sock_mutex; 1086ed7257bSPatrick Caulfield unsigned long flags; 1096ed7257bSPatrick Caulfield #define CF_READ_PENDING 1 1106ed7257bSPatrick Caulfield #define CF_WRITE_PENDING 2 1116ed7257bSPatrick Caulfield #define CF_CONNECT_PENDING 3 1126ed7257bSPatrick Caulfield #define CF_INIT_PENDING 4 1136ed7257bSPatrick Caulfield #define CF_IS_OTHERCON 5 114063c4c99SLars Marowsky-Bree #define CF_CLOSE 6 115b36930ddSDavid Miller #define CF_APP_LIMITED 7 1166ed7257bSPatrick Caulfield struct list_head writequeue; /* List of outgoing writequeue_entries */ 1176ed7257bSPatrick Caulfield spinlock_t writequeue_lock; 1186ed7257bSPatrick Caulfield int (*rx_action) (struct connection *); /* What to do when active */ 1196ed7257bSPatrick Caulfield void (*connect_action) (struct connection *); /* What to do to connect */ 1206ed7257bSPatrick Caulfield struct page *rx_page; 1216ed7257bSPatrick Caulfield struct cbuf cb; 1226ed7257bSPatrick Caulfield int retries; 1236ed7257bSPatrick Caulfield #define MAX_CONNECT_RETRIES 3 1246ed7257bSPatrick Caulfield int sctp_assoc; 1255e9ccc37SChristine Caulfield struct hlist_node list; 1266ed7257bSPatrick Caulfield struct connection *othercon; 1276ed7257bSPatrick Caulfield struct work_struct rwork; /* Receive workqueue */ 1286ed7257bSPatrick Caulfield struct work_struct swork; /* Send workqueue */ 12998e1b60eSMike Christie bool try_new_addr; 1306ed7257bSPatrick Caulfield }; 1316ed7257bSPatrick Caulfield #define sock2con(x) ((struct connection *)(x)->sk_user_data) 1326ed7257bSPatrick Caulfield 1336ed7257bSPatrick Caulfield /* An entry waiting to be sent */ 1346ed7257bSPatrick Caulfield struct writequeue_entry { 1356ed7257bSPatrick Caulfield struct list_head list; 1366ed7257bSPatrick Caulfield struct page *page; 1376ed7257bSPatrick Caulfield int offset; 1386ed7257bSPatrick Caulfield int len; 1396ed7257bSPatrick Caulfield int end; 1406ed7257bSPatrick Caulfield int users; 1416ed7257bSPatrick Caulfield struct connection *con; 1426ed7257bSPatrick Caulfield }; 1436ed7257bSPatrick Caulfield 14436b71a8bSDavid Teigland struct dlm_node_addr { 14536b71a8bSDavid Teigland struct list_head list; 14636b71a8bSDavid Teigland int nodeid; 14736b71a8bSDavid Teigland int addr_count; 14898e1b60eSMike Christie int curr_addr_index; 14936b71a8bSDavid Teigland struct sockaddr_storage *addr[DLM_MAX_ADDR_COUNT]; 15036b71a8bSDavid Teigland }; 15136b71a8bSDavid Teigland 15236b71a8bSDavid Teigland static LIST_HEAD(dlm_node_addrs); 15336b71a8bSDavid Teigland static DEFINE_SPINLOCK(dlm_node_addrs_spin); 15436b71a8bSDavid Teigland 1556ed7257bSPatrick Caulfield static struct sockaddr_storage *dlm_local_addr[DLM_MAX_ADDR_COUNT]; 1566ed7257bSPatrick Caulfield static int dlm_local_count; 157513ef596SDavid Teigland static int dlm_allow_conn; 1586ed7257bSPatrick Caulfield 1596ed7257bSPatrick Caulfield /* Work queues */ 1606ed7257bSPatrick Caulfield static struct workqueue_struct *recv_workqueue; 1616ed7257bSPatrick Caulfield static struct workqueue_struct *send_workqueue; 1626ed7257bSPatrick Caulfield 1635e9ccc37SChristine Caulfield static struct hlist_head connection_hash[CONN_HASH_SIZE]; 1647a936ce7SMatthias Kaehlcke static DEFINE_MUTEX(connections_lock); 1656ed7257bSPatrick Caulfield static struct kmem_cache *con_cache; 1666ed7257bSPatrick Caulfield 1676ed7257bSPatrick Caulfield static void process_recv_sockets(struct work_struct *work); 1686ed7257bSPatrick Caulfield static void process_send_sockets(struct work_struct *work); 1696ed7257bSPatrick Caulfield 1705e9ccc37SChristine Caulfield 1715e9ccc37SChristine Caulfield /* This is deliberately very simple because most clusters have simple 1725e9ccc37SChristine Caulfield sequential nodeids, so we should be able to go straight to a connection 1735e9ccc37SChristine Caulfield struct in the array */ 1745e9ccc37SChristine Caulfield static inline int nodeid_hash(int nodeid) 1755e9ccc37SChristine Caulfield { 1765e9ccc37SChristine Caulfield return nodeid & (CONN_HASH_SIZE-1); 1775e9ccc37SChristine Caulfield } 1785e9ccc37SChristine Caulfield 1795e9ccc37SChristine Caulfield static struct connection *__find_con(int nodeid) 1805e9ccc37SChristine Caulfield { 1815e9ccc37SChristine Caulfield int r; 1825e9ccc37SChristine Caulfield struct connection *con; 1835e9ccc37SChristine Caulfield 1845e9ccc37SChristine Caulfield r = nodeid_hash(nodeid); 1855e9ccc37SChristine Caulfield 186b67bfe0dSSasha Levin hlist_for_each_entry(con, &connection_hash[r], list) { 1875e9ccc37SChristine Caulfield if (con->nodeid == nodeid) 1885e9ccc37SChristine Caulfield return con; 1895e9ccc37SChristine Caulfield } 1905e9ccc37SChristine Caulfield return NULL; 1915e9ccc37SChristine Caulfield } 1925e9ccc37SChristine Caulfield 1936ed7257bSPatrick Caulfield /* 1946ed7257bSPatrick Caulfield * If 'allocation' is zero then we don't attempt to create a new 1956ed7257bSPatrick Caulfield * connection structure for this node. 1966ed7257bSPatrick Caulfield */ 1976ed7257bSPatrick Caulfield static struct connection *__nodeid2con(int nodeid, gfp_t alloc) 1986ed7257bSPatrick Caulfield { 1996ed7257bSPatrick Caulfield struct connection *con = NULL; 2006ed7257bSPatrick Caulfield int r; 2016ed7257bSPatrick Caulfield 2025e9ccc37SChristine Caulfield con = __find_con(nodeid); 2036ed7257bSPatrick Caulfield if (con || !alloc) 2046ed7257bSPatrick Caulfield return con; 2056ed7257bSPatrick Caulfield 2066ed7257bSPatrick Caulfield con = kmem_cache_zalloc(con_cache, alloc); 2076ed7257bSPatrick Caulfield if (!con) 2086ed7257bSPatrick Caulfield return NULL; 2096ed7257bSPatrick Caulfield 2105e9ccc37SChristine Caulfield r = nodeid_hash(nodeid); 2115e9ccc37SChristine Caulfield hlist_add_head(&con->list, &connection_hash[r]); 2126ed7257bSPatrick Caulfield 2136ed7257bSPatrick Caulfield con->nodeid = nodeid; 2146ed7257bSPatrick Caulfield mutex_init(&con->sock_mutex); 2156ed7257bSPatrick Caulfield INIT_LIST_HEAD(&con->writequeue); 2166ed7257bSPatrick Caulfield spin_lock_init(&con->writequeue_lock); 2176ed7257bSPatrick Caulfield INIT_WORK(&con->swork, process_send_sockets); 2186ed7257bSPatrick Caulfield INIT_WORK(&con->rwork, process_recv_sockets); 2196ed7257bSPatrick Caulfield 2206ed7257bSPatrick Caulfield /* Setup action pointers for child sockets */ 2216ed7257bSPatrick Caulfield if (con->nodeid) { 2225e9ccc37SChristine Caulfield struct connection *zerocon = __find_con(0); 2236ed7257bSPatrick Caulfield 2246ed7257bSPatrick Caulfield con->connect_action = zerocon->connect_action; 2256ed7257bSPatrick Caulfield if (!con->rx_action) 2266ed7257bSPatrick Caulfield con->rx_action = zerocon->rx_action; 2276ed7257bSPatrick Caulfield } 2286ed7257bSPatrick Caulfield 2296ed7257bSPatrick Caulfield return con; 2306ed7257bSPatrick Caulfield } 2316ed7257bSPatrick Caulfield 2325e9ccc37SChristine Caulfield /* Loop round all connections */ 2335e9ccc37SChristine Caulfield static void foreach_conn(void (*conn_func)(struct connection *c)) 2345e9ccc37SChristine Caulfield { 2355e9ccc37SChristine Caulfield int i; 236b67bfe0dSSasha Levin struct hlist_node *n; 2375e9ccc37SChristine Caulfield struct connection *con; 2385e9ccc37SChristine Caulfield 2395e9ccc37SChristine Caulfield for (i = 0; i < CONN_HASH_SIZE; i++) { 240b67bfe0dSSasha Levin hlist_for_each_entry_safe(con, n, &connection_hash[i], list) 2415e9ccc37SChristine Caulfield conn_func(con); 2425e9ccc37SChristine Caulfield } 2435e9ccc37SChristine Caulfield } 2445e9ccc37SChristine Caulfield 2456ed7257bSPatrick Caulfield static struct connection *nodeid2con(int nodeid, gfp_t allocation) 2466ed7257bSPatrick Caulfield { 2476ed7257bSPatrick Caulfield struct connection *con; 2486ed7257bSPatrick Caulfield 2497a936ce7SMatthias Kaehlcke mutex_lock(&connections_lock); 2506ed7257bSPatrick Caulfield con = __nodeid2con(nodeid, allocation); 2517a936ce7SMatthias Kaehlcke mutex_unlock(&connections_lock); 2526ed7257bSPatrick Caulfield 2536ed7257bSPatrick Caulfield return con; 2546ed7257bSPatrick Caulfield } 2556ed7257bSPatrick Caulfield 2566ed7257bSPatrick Caulfield /* This is a bit drastic, but only called when things go wrong */ 2576ed7257bSPatrick Caulfield static struct connection *assoc2con(int assoc_id) 2586ed7257bSPatrick Caulfield { 2596ed7257bSPatrick Caulfield int i; 2606ed7257bSPatrick Caulfield struct connection *con; 2616ed7257bSPatrick Caulfield 2627a936ce7SMatthias Kaehlcke mutex_lock(&connections_lock); 2635e9ccc37SChristine Caulfield 2645e9ccc37SChristine Caulfield for (i = 0 ; i < CONN_HASH_SIZE; i++) { 265b67bfe0dSSasha Levin hlist_for_each_entry(con, &connection_hash[i], list) { 266f70cb33bSJulia Lawall if (con->sctp_assoc == assoc_id) { 2677a936ce7SMatthias Kaehlcke mutex_unlock(&connections_lock); 2686ed7257bSPatrick Caulfield return con; 2696ed7257bSPatrick Caulfield } 2706ed7257bSPatrick Caulfield } 2715e9ccc37SChristine Caulfield } 2727a936ce7SMatthias Kaehlcke mutex_unlock(&connections_lock); 2736ed7257bSPatrick Caulfield return NULL; 2746ed7257bSPatrick Caulfield } 2756ed7257bSPatrick Caulfield 27636b71a8bSDavid Teigland static struct dlm_node_addr *find_node_addr(int nodeid) 2776ed7257bSPatrick Caulfield { 27836b71a8bSDavid Teigland struct dlm_node_addr *na; 27936b71a8bSDavid Teigland 28036b71a8bSDavid Teigland list_for_each_entry(na, &dlm_node_addrs, list) { 28136b71a8bSDavid Teigland if (na->nodeid == nodeid) 28236b71a8bSDavid Teigland return na; 28336b71a8bSDavid Teigland } 28436b71a8bSDavid Teigland return NULL; 28536b71a8bSDavid Teigland } 28636b71a8bSDavid Teigland 28736b71a8bSDavid Teigland static int addr_compare(struct sockaddr_storage *x, struct sockaddr_storage *y) 28836b71a8bSDavid Teigland { 28936b71a8bSDavid Teigland switch (x->ss_family) { 29036b71a8bSDavid Teigland case AF_INET: { 29136b71a8bSDavid Teigland struct sockaddr_in *sinx = (struct sockaddr_in *)x; 29236b71a8bSDavid Teigland struct sockaddr_in *siny = (struct sockaddr_in *)y; 29336b71a8bSDavid Teigland if (sinx->sin_addr.s_addr != siny->sin_addr.s_addr) 29436b71a8bSDavid Teigland return 0; 29536b71a8bSDavid Teigland if (sinx->sin_port != siny->sin_port) 29636b71a8bSDavid Teigland return 0; 29736b71a8bSDavid Teigland break; 29836b71a8bSDavid Teigland } 29936b71a8bSDavid Teigland case AF_INET6: { 30036b71a8bSDavid Teigland struct sockaddr_in6 *sinx = (struct sockaddr_in6 *)x; 30136b71a8bSDavid Teigland struct sockaddr_in6 *siny = (struct sockaddr_in6 *)y; 30236b71a8bSDavid Teigland if (!ipv6_addr_equal(&sinx->sin6_addr, &siny->sin6_addr)) 30336b71a8bSDavid Teigland return 0; 30436b71a8bSDavid Teigland if (sinx->sin6_port != siny->sin6_port) 30536b71a8bSDavid Teigland return 0; 30636b71a8bSDavid Teigland break; 30736b71a8bSDavid Teigland } 30836b71a8bSDavid Teigland default: 30936b71a8bSDavid Teigland return 0; 31036b71a8bSDavid Teigland } 31136b71a8bSDavid Teigland return 1; 31236b71a8bSDavid Teigland } 31336b71a8bSDavid Teigland 31436b71a8bSDavid Teigland static int nodeid_to_addr(int nodeid, struct sockaddr_storage *sas_out, 31598e1b60eSMike Christie struct sockaddr *sa_out, bool try_new_addr) 31636b71a8bSDavid Teigland { 31736b71a8bSDavid Teigland struct sockaddr_storage sas; 31836b71a8bSDavid Teigland struct dlm_node_addr *na; 3196ed7257bSPatrick Caulfield 3206ed7257bSPatrick Caulfield if (!dlm_local_count) 3216ed7257bSPatrick Caulfield return -1; 3226ed7257bSPatrick Caulfield 32336b71a8bSDavid Teigland spin_lock(&dlm_node_addrs_spin); 32436b71a8bSDavid Teigland na = find_node_addr(nodeid); 32598e1b60eSMike Christie if (na && na->addr_count) { 32698e1b60eSMike Christie if (try_new_addr) { 32798e1b60eSMike Christie na->curr_addr_index++; 32898e1b60eSMike Christie if (na->curr_addr_index == na->addr_count) 32998e1b60eSMike Christie na->curr_addr_index = 0; 33098e1b60eSMike Christie } 33198e1b60eSMike Christie 33298e1b60eSMike Christie memcpy(&sas, na->addr[na->curr_addr_index ], 33398e1b60eSMike Christie sizeof(struct sockaddr_storage)); 33498e1b60eSMike Christie } 33536b71a8bSDavid Teigland spin_unlock(&dlm_node_addrs_spin); 33636b71a8bSDavid Teigland 33736b71a8bSDavid Teigland if (!na) 33836b71a8bSDavid Teigland return -EEXIST; 33936b71a8bSDavid Teigland 34036b71a8bSDavid Teigland if (!na->addr_count) 34136b71a8bSDavid Teigland return -ENOENT; 34236b71a8bSDavid Teigland 34336b71a8bSDavid Teigland if (sas_out) 34436b71a8bSDavid Teigland memcpy(sas_out, &sas, sizeof(struct sockaddr_storage)); 34536b71a8bSDavid Teigland 34636b71a8bSDavid Teigland if (!sa_out) 34736b71a8bSDavid Teigland return 0; 3486ed7257bSPatrick Caulfield 3496ed7257bSPatrick Caulfield if (dlm_local_addr[0]->ss_family == AF_INET) { 35036b71a8bSDavid Teigland struct sockaddr_in *in4 = (struct sockaddr_in *) &sas; 35136b71a8bSDavid Teigland struct sockaddr_in *ret4 = (struct sockaddr_in *) sa_out; 3526ed7257bSPatrick Caulfield ret4->sin_addr.s_addr = in4->sin_addr.s_addr; 3536ed7257bSPatrick Caulfield } else { 35436b71a8bSDavid Teigland struct sockaddr_in6 *in6 = (struct sockaddr_in6 *) &sas; 35536b71a8bSDavid Teigland struct sockaddr_in6 *ret6 = (struct sockaddr_in6 *) sa_out; 3564e3fd7a0SAlexey Dobriyan ret6->sin6_addr = in6->sin6_addr; 3576ed7257bSPatrick Caulfield } 3586ed7257bSPatrick Caulfield 3596ed7257bSPatrick Caulfield return 0; 3606ed7257bSPatrick Caulfield } 3616ed7257bSPatrick Caulfield 36236b71a8bSDavid Teigland static int addr_to_nodeid(struct sockaddr_storage *addr, int *nodeid) 36336b71a8bSDavid Teigland { 36436b71a8bSDavid Teigland struct dlm_node_addr *na; 36536b71a8bSDavid Teigland int rv = -EEXIST; 36698e1b60eSMike Christie int addr_i; 36736b71a8bSDavid Teigland 36836b71a8bSDavid Teigland spin_lock(&dlm_node_addrs_spin); 36936b71a8bSDavid Teigland list_for_each_entry(na, &dlm_node_addrs, list) { 37036b71a8bSDavid Teigland if (!na->addr_count) 37136b71a8bSDavid Teigland continue; 37236b71a8bSDavid Teigland 37398e1b60eSMike Christie for (addr_i = 0; addr_i < na->addr_count; addr_i++) { 37498e1b60eSMike Christie if (addr_compare(na->addr[addr_i], addr)) { 37536b71a8bSDavid Teigland *nodeid = na->nodeid; 37636b71a8bSDavid Teigland rv = 0; 37798e1b60eSMike Christie goto unlock; 37836b71a8bSDavid Teigland } 37998e1b60eSMike Christie } 38098e1b60eSMike Christie } 38198e1b60eSMike Christie unlock: 38236b71a8bSDavid Teigland spin_unlock(&dlm_node_addrs_spin); 38336b71a8bSDavid Teigland return rv; 38436b71a8bSDavid Teigland } 38536b71a8bSDavid Teigland 38636b71a8bSDavid Teigland int dlm_lowcomms_addr(int nodeid, struct sockaddr_storage *addr, int len) 38736b71a8bSDavid Teigland { 38836b71a8bSDavid Teigland struct sockaddr_storage *new_addr; 38936b71a8bSDavid Teigland struct dlm_node_addr *new_node, *na; 39036b71a8bSDavid Teigland 39136b71a8bSDavid Teigland new_node = kzalloc(sizeof(struct dlm_node_addr), GFP_NOFS); 39236b71a8bSDavid Teigland if (!new_node) 39336b71a8bSDavid Teigland return -ENOMEM; 39436b71a8bSDavid Teigland 39536b71a8bSDavid Teigland new_addr = kzalloc(sizeof(struct sockaddr_storage), GFP_NOFS); 39636b71a8bSDavid Teigland if (!new_addr) { 39736b71a8bSDavid Teigland kfree(new_node); 39836b71a8bSDavid Teigland return -ENOMEM; 39936b71a8bSDavid Teigland } 40036b71a8bSDavid Teigland 40136b71a8bSDavid Teigland memcpy(new_addr, addr, len); 40236b71a8bSDavid Teigland 40336b71a8bSDavid Teigland spin_lock(&dlm_node_addrs_spin); 40436b71a8bSDavid Teigland na = find_node_addr(nodeid); 40536b71a8bSDavid Teigland if (!na) { 40636b71a8bSDavid Teigland new_node->nodeid = nodeid; 40736b71a8bSDavid Teigland new_node->addr[0] = new_addr; 40836b71a8bSDavid Teigland new_node->addr_count = 1; 40936b71a8bSDavid Teigland list_add(&new_node->list, &dlm_node_addrs); 41036b71a8bSDavid Teigland spin_unlock(&dlm_node_addrs_spin); 41136b71a8bSDavid Teigland return 0; 41236b71a8bSDavid Teigland } 41336b71a8bSDavid Teigland 41436b71a8bSDavid Teigland if (na->addr_count >= DLM_MAX_ADDR_COUNT) { 41536b71a8bSDavid Teigland spin_unlock(&dlm_node_addrs_spin); 41636b71a8bSDavid Teigland kfree(new_addr); 41736b71a8bSDavid Teigland kfree(new_node); 41836b71a8bSDavid Teigland return -ENOSPC; 41936b71a8bSDavid Teigland } 42036b71a8bSDavid Teigland 42136b71a8bSDavid Teigland na->addr[na->addr_count++] = new_addr; 42236b71a8bSDavid Teigland spin_unlock(&dlm_node_addrs_spin); 42336b71a8bSDavid Teigland kfree(new_node); 42436b71a8bSDavid Teigland return 0; 42536b71a8bSDavid Teigland } 42636b71a8bSDavid Teigland 4276ed7257bSPatrick Caulfield /* Data available on socket or listen socket received a connect */ 4286ed7257bSPatrick Caulfield static void lowcomms_data_ready(struct sock *sk, int count_unused) 4296ed7257bSPatrick Caulfield { 4306ed7257bSPatrick Caulfield struct connection *con = sock2con(sk); 431afb853fbSPatrick Caulfield if (con && !test_and_set_bit(CF_READ_PENDING, &con->flags)) 4326ed7257bSPatrick Caulfield queue_work(recv_workqueue, &con->rwork); 4336ed7257bSPatrick Caulfield } 4346ed7257bSPatrick Caulfield 4356ed7257bSPatrick Caulfield static void lowcomms_write_space(struct sock *sk) 4366ed7257bSPatrick Caulfield { 4376ed7257bSPatrick Caulfield struct connection *con = sock2con(sk); 4386ed7257bSPatrick Caulfield 439b36930ddSDavid Miller if (!con) 440b36930ddSDavid Miller return; 441b36930ddSDavid Miller 442b36930ddSDavid Miller clear_bit(SOCK_NOSPACE, &con->sock->flags); 443b36930ddSDavid Miller 444b36930ddSDavid Miller if (test_and_clear_bit(CF_APP_LIMITED, &con->flags)) { 445b36930ddSDavid Miller con->sock->sk->sk_write_pending--; 446b36930ddSDavid Miller clear_bit(SOCK_ASYNC_NOSPACE, &con->sock->flags); 447b36930ddSDavid Miller } 448b36930ddSDavid Miller 449b36930ddSDavid Miller if (!test_and_set_bit(CF_WRITE_PENDING, &con->flags)) 4506ed7257bSPatrick Caulfield queue_work(send_workqueue, &con->swork); 4516ed7257bSPatrick Caulfield } 4526ed7257bSPatrick Caulfield 4536ed7257bSPatrick Caulfield static inline void lowcomms_connect_sock(struct connection *con) 4546ed7257bSPatrick Caulfield { 455063c4c99SLars Marowsky-Bree if (test_bit(CF_CLOSE, &con->flags)) 456063c4c99SLars Marowsky-Bree return; 4576ed7257bSPatrick Caulfield if (!test_and_set_bit(CF_CONNECT_PENDING, &con->flags)) 4586ed7257bSPatrick Caulfield queue_work(send_workqueue, &con->swork); 4596ed7257bSPatrick Caulfield } 4606ed7257bSPatrick Caulfield 4616ed7257bSPatrick Caulfield static void lowcomms_state_change(struct sock *sk) 4626ed7257bSPatrick Caulfield { 4636ed7257bSPatrick Caulfield if (sk->sk_state == TCP_ESTABLISHED) 4646ed7257bSPatrick Caulfield lowcomms_write_space(sk); 4656ed7257bSPatrick Caulfield } 4666ed7257bSPatrick Caulfield 467391fbdc5SChristine Caulfield int dlm_lowcomms_connect_node(int nodeid) 468391fbdc5SChristine Caulfield { 469391fbdc5SChristine Caulfield struct connection *con; 470391fbdc5SChristine Caulfield 47104bedd79SDavid Teigland /* with sctp there's no connecting without sending */ 47204bedd79SDavid Teigland if (dlm_config.ci_protocol != 0) 47304bedd79SDavid Teigland return 0; 47404bedd79SDavid Teigland 475391fbdc5SChristine Caulfield if (nodeid == dlm_our_nodeid()) 476391fbdc5SChristine Caulfield return 0; 477391fbdc5SChristine Caulfield 478391fbdc5SChristine Caulfield con = nodeid2con(nodeid, GFP_NOFS); 479391fbdc5SChristine Caulfield if (!con) 480391fbdc5SChristine Caulfield return -ENOMEM; 481391fbdc5SChristine Caulfield lowcomms_connect_sock(con); 482391fbdc5SChristine Caulfield return 0; 483391fbdc5SChristine Caulfield } 484391fbdc5SChristine Caulfield 4856ed7257bSPatrick Caulfield /* Make a socket active */ 4864dd40f0cSYing Xue static void add_sock(struct socket *sock, struct connection *con) 4876ed7257bSPatrick Caulfield { 4886ed7257bSPatrick Caulfield con->sock = sock; 4896ed7257bSPatrick Caulfield 4906ed7257bSPatrick Caulfield /* Install a data_ready callback */ 4916ed7257bSPatrick Caulfield con->sock->sk->sk_data_ready = lowcomms_data_ready; 4926ed7257bSPatrick Caulfield con->sock->sk->sk_write_space = lowcomms_write_space; 4936ed7257bSPatrick Caulfield con->sock->sk->sk_state_change = lowcomms_state_change; 4946ed7257bSPatrick Caulfield con->sock->sk->sk_user_data = con; 495d6d7b702SSteven Whitehouse con->sock->sk->sk_allocation = GFP_NOFS; 4966ed7257bSPatrick Caulfield } 4976ed7257bSPatrick Caulfield 4986ed7257bSPatrick Caulfield /* Add the port number to an IPv6 or 4 sockaddr and return the address 4996ed7257bSPatrick Caulfield length */ 5006ed7257bSPatrick Caulfield static void make_sockaddr(struct sockaddr_storage *saddr, uint16_t port, 5016ed7257bSPatrick Caulfield int *addr_len) 5026ed7257bSPatrick Caulfield { 5036ed7257bSPatrick Caulfield saddr->ss_family = dlm_local_addr[0]->ss_family; 5046ed7257bSPatrick Caulfield if (saddr->ss_family == AF_INET) { 5056ed7257bSPatrick Caulfield struct sockaddr_in *in4_addr = (struct sockaddr_in *)saddr; 5066ed7257bSPatrick Caulfield in4_addr->sin_port = cpu_to_be16(port); 5076ed7257bSPatrick Caulfield *addr_len = sizeof(struct sockaddr_in); 5086ed7257bSPatrick Caulfield memset(&in4_addr->sin_zero, 0, sizeof(in4_addr->sin_zero)); 5096ed7257bSPatrick Caulfield } else { 5106ed7257bSPatrick Caulfield struct sockaddr_in6 *in6_addr = (struct sockaddr_in6 *)saddr; 5116ed7257bSPatrick Caulfield in6_addr->sin6_port = cpu_to_be16(port); 5126ed7257bSPatrick Caulfield *addr_len = sizeof(struct sockaddr_in6); 5136ed7257bSPatrick Caulfield } 51401c8cab2SPatrick Caulfield memset((char *)saddr + *addr_len, 0, sizeof(struct sockaddr_storage) - *addr_len); 5156ed7257bSPatrick Caulfield } 5166ed7257bSPatrick Caulfield 5176ed7257bSPatrick Caulfield /* Close a remote connection and tidy up */ 5186ed7257bSPatrick Caulfield static void close_connection(struct connection *con, bool and_other) 5196ed7257bSPatrick Caulfield { 5206ed7257bSPatrick Caulfield mutex_lock(&con->sock_mutex); 5216ed7257bSPatrick Caulfield 5226ed7257bSPatrick Caulfield if (con->sock) { 5236ed7257bSPatrick Caulfield sock_release(con->sock); 5246ed7257bSPatrick Caulfield con->sock = NULL; 5256ed7257bSPatrick Caulfield } 5266ed7257bSPatrick Caulfield if (con->othercon && and_other) { 5276ed7257bSPatrick Caulfield /* Will only re-enter once. */ 5286ed7257bSPatrick Caulfield close_connection(con->othercon, false); 5296ed7257bSPatrick Caulfield } 5306ed7257bSPatrick Caulfield if (con->rx_page) { 5316ed7257bSPatrick Caulfield __free_page(con->rx_page); 5326ed7257bSPatrick Caulfield con->rx_page = NULL; 5336ed7257bSPatrick Caulfield } 5349e5f2825SPatrick Caulfield 5356ed7257bSPatrick Caulfield con->retries = 0; 5366ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 5376ed7257bSPatrick Caulfield } 5386ed7257bSPatrick Caulfield 5396ed7257bSPatrick Caulfield /* We only send shutdown messages to nodes that are not part of the cluster */ 5406ed7257bSPatrick Caulfield static void sctp_send_shutdown(sctp_assoc_t associd) 5416ed7257bSPatrick Caulfield { 5426ed7257bSPatrick Caulfield static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))]; 5436ed7257bSPatrick Caulfield struct msghdr outmessage; 5446ed7257bSPatrick Caulfield struct cmsghdr *cmsg; 5456ed7257bSPatrick Caulfield struct sctp_sndrcvinfo *sinfo; 5466ed7257bSPatrick Caulfield int ret; 5476ed7257bSPatrick Caulfield struct connection *con; 5486ed7257bSPatrick Caulfield 5496ed7257bSPatrick Caulfield con = nodeid2con(0,0); 5506ed7257bSPatrick Caulfield BUG_ON(con == NULL); 5516ed7257bSPatrick Caulfield 5526ed7257bSPatrick Caulfield outmessage.msg_name = NULL; 5536ed7257bSPatrick Caulfield outmessage.msg_namelen = 0; 5546ed7257bSPatrick Caulfield outmessage.msg_control = outcmsg; 5556ed7257bSPatrick Caulfield outmessage.msg_controllen = sizeof(outcmsg); 5566ed7257bSPatrick Caulfield outmessage.msg_flags = MSG_EOR; 5576ed7257bSPatrick Caulfield 5586ed7257bSPatrick Caulfield cmsg = CMSG_FIRSTHDR(&outmessage); 5596ed7257bSPatrick Caulfield cmsg->cmsg_level = IPPROTO_SCTP; 5606ed7257bSPatrick Caulfield cmsg->cmsg_type = SCTP_SNDRCV; 5616ed7257bSPatrick Caulfield cmsg->cmsg_len = CMSG_LEN(sizeof(struct sctp_sndrcvinfo)); 5626ed7257bSPatrick Caulfield outmessage.msg_controllen = cmsg->cmsg_len; 5636ed7257bSPatrick Caulfield sinfo = CMSG_DATA(cmsg); 5646ed7257bSPatrick Caulfield memset(sinfo, 0x00, sizeof(struct sctp_sndrcvinfo)); 5656ed7257bSPatrick Caulfield 5666ed7257bSPatrick Caulfield sinfo->sinfo_flags |= MSG_EOF; 5676ed7257bSPatrick Caulfield sinfo->sinfo_assoc_id = associd; 5686ed7257bSPatrick Caulfield 5696ed7257bSPatrick Caulfield ret = kernel_sendmsg(con->sock, &outmessage, NULL, 0, 0); 5706ed7257bSPatrick Caulfield 5716ed7257bSPatrick Caulfield if (ret != 0) 5726ed7257bSPatrick Caulfield log_print("send EOF to node failed: %d", ret); 5736ed7257bSPatrick Caulfield } 5746ed7257bSPatrick Caulfield 5755e9ccc37SChristine Caulfield static void sctp_init_failed_foreach(struct connection *con) 5765e9ccc37SChristine Caulfield { 57798e1b60eSMike Christie 57898e1b60eSMike Christie /* 57998e1b60eSMike Christie * Don't try to recover base con and handle race where the 58098e1b60eSMike Christie * other node's assoc init creates a assoc and we get that 58198e1b60eSMike Christie * notification, then we get a notification that our attempt 58298e1b60eSMike Christie * failed due. This happens when we are still trying the primary 58398e1b60eSMike Christie * address, but the other node has already tried secondary addrs 58498e1b60eSMike Christie * and found one that worked. 58598e1b60eSMike Christie */ 58698e1b60eSMike Christie if (!con->nodeid || con->sctp_assoc) 58798e1b60eSMike Christie return; 58898e1b60eSMike Christie 58998e1b60eSMike Christie log_print("Retrying SCTP association init for node %d\n", con->nodeid); 59098e1b60eSMike Christie 59198e1b60eSMike Christie con->try_new_addr = true; 5925e9ccc37SChristine Caulfield con->sctp_assoc = 0; 593b390ca38SMike Christie if (test_and_clear_bit(CF_INIT_PENDING, &con->flags)) { 5945e9ccc37SChristine Caulfield if (!test_and_set_bit(CF_WRITE_PENDING, &con->flags)) 5955e9ccc37SChristine Caulfield queue_work(send_workqueue, &con->swork); 5965e9ccc37SChristine Caulfield } 5975e9ccc37SChristine Caulfield } 5985e9ccc37SChristine Caulfield 5996ed7257bSPatrick Caulfield /* INIT failed but we don't know which node... 6006ed7257bSPatrick Caulfield restart INIT on all pending nodes */ 6016ed7257bSPatrick Caulfield static void sctp_init_failed(void) 6026ed7257bSPatrick Caulfield { 6037a936ce7SMatthias Kaehlcke mutex_lock(&connections_lock); 6045e9ccc37SChristine Caulfield 6055e9ccc37SChristine Caulfield foreach_conn(sctp_init_failed_foreach); 6065e9ccc37SChristine Caulfield 6077a936ce7SMatthias Kaehlcke mutex_unlock(&connections_lock); 6086ed7257bSPatrick Caulfield } 6096ed7257bSPatrick Caulfield 6106ed7257bSPatrick Caulfield /* Something happened to an association */ 611617e82e1SDavid Teigland static void process_sctp_notification(struct connection *con, 612617e82e1SDavid Teigland struct msghdr *msg, char *buf) 6136ed7257bSPatrick Caulfield { 6146ed7257bSPatrick Caulfield union sctp_notification *sn = (union sctp_notification *)buf; 6156ed7257bSPatrick Caulfield 6166ed7257bSPatrick Caulfield if (sn->sn_header.sn_type == SCTP_ASSOC_CHANGE) { 6176ed7257bSPatrick Caulfield switch (sn->sn_assoc_change.sac_state) { 6186ed7257bSPatrick Caulfield 6196ed7257bSPatrick Caulfield case SCTP_COMM_UP: 6206ed7257bSPatrick Caulfield case SCTP_RESTART: 6216ed7257bSPatrick Caulfield { 6226ed7257bSPatrick Caulfield /* Check that the new node is in the lockspace */ 6236ed7257bSPatrick Caulfield struct sctp_prim prim; 6246ed7257bSPatrick Caulfield int nodeid; 6256ed7257bSPatrick Caulfield int prim_len, ret; 6266ed7257bSPatrick Caulfield int addr_len; 6276ed7257bSPatrick Caulfield struct connection *new_con; 6286ed7257bSPatrick Caulfield 6296ed7257bSPatrick Caulfield /* 6306ed7257bSPatrick Caulfield * We get this before any data for an association. 6316ed7257bSPatrick Caulfield * We verify that the node is in the cluster and 6326ed7257bSPatrick Caulfield * then peel off a socket for it. 6336ed7257bSPatrick Caulfield */ 6346ed7257bSPatrick Caulfield if ((int)sn->sn_assoc_change.sac_assoc_id <= 0) { 6356ed7257bSPatrick Caulfield log_print("COMM_UP for invalid assoc ID %d", 6366ed7257bSPatrick Caulfield (int)sn->sn_assoc_change.sac_assoc_id); 6376ed7257bSPatrick Caulfield sctp_init_failed(); 6386ed7257bSPatrick Caulfield return; 6396ed7257bSPatrick Caulfield } 6406ed7257bSPatrick Caulfield memset(&prim, 0, sizeof(struct sctp_prim)); 6416ed7257bSPatrick Caulfield prim_len = sizeof(struct sctp_prim); 6426ed7257bSPatrick Caulfield prim.ssp_assoc_id = sn->sn_assoc_change.sac_assoc_id; 6436ed7257bSPatrick Caulfield 6446ed7257bSPatrick Caulfield ret = kernel_getsockopt(con->sock, 6456ed7257bSPatrick Caulfield IPPROTO_SCTP, 6466ed7257bSPatrick Caulfield SCTP_PRIMARY_ADDR, 6476ed7257bSPatrick Caulfield (char*)&prim, 6486ed7257bSPatrick Caulfield &prim_len); 6496ed7257bSPatrick Caulfield if (ret < 0) { 6506ed7257bSPatrick Caulfield log_print("getsockopt/sctp_primary_addr on " 6516ed7257bSPatrick Caulfield "new assoc %d failed : %d", 6526ed7257bSPatrick Caulfield (int)sn->sn_assoc_change.sac_assoc_id, 6536ed7257bSPatrick Caulfield ret); 6546ed7257bSPatrick Caulfield 6556ed7257bSPatrick Caulfield /* Retry INIT later */ 6566ed7257bSPatrick Caulfield new_con = assoc2con(sn->sn_assoc_change.sac_assoc_id); 6576ed7257bSPatrick Caulfield if (new_con) 6586ed7257bSPatrick Caulfield clear_bit(CF_CONNECT_PENDING, &con->flags); 6596ed7257bSPatrick Caulfield return; 6606ed7257bSPatrick Caulfield } 6616ed7257bSPatrick Caulfield make_sockaddr(&prim.ssp_addr, 0, &addr_len); 66236b71a8bSDavid Teigland if (addr_to_nodeid(&prim.ssp_addr, &nodeid)) { 6636ed7257bSPatrick Caulfield unsigned char *b=(unsigned char *)&prim.ssp_addr; 6646ed7257bSPatrick Caulfield log_print("reject connect from unknown addr"); 665bcaadf5cSMasatake YAMATO print_hex_dump_bytes("ss: ", DUMP_PREFIX_NONE, 666bcaadf5cSMasatake YAMATO b, sizeof(struct sockaddr_storage)); 6676ed7257bSPatrick Caulfield sctp_send_shutdown(prim.ssp_assoc_id); 6686ed7257bSPatrick Caulfield return; 6696ed7257bSPatrick Caulfield } 6706ed7257bSPatrick Caulfield 671748285ccSDavid Teigland new_con = nodeid2con(nodeid, GFP_NOFS); 6726ed7257bSPatrick Caulfield if (!new_con) 6736ed7257bSPatrick Caulfield return; 6746ed7257bSPatrick Caulfield 6756ed7257bSPatrick Caulfield /* Peel off a new sock */ 6762f2d76ccSBenjamin Poirier sctp_lock_sock(con->sock->sk); 6772f2d76ccSBenjamin Poirier ret = sctp_do_peeloff(con->sock->sk, 6782f2d76ccSBenjamin Poirier sn->sn_assoc_change.sac_assoc_id, 6792f2d76ccSBenjamin Poirier &new_con->sock); 6802f2d76ccSBenjamin Poirier sctp_release_sock(con->sock->sk); 6816861f350SDavid Teigland if (ret < 0) { 682617e82e1SDavid Teigland log_print("Can't peel off a socket for " 6836861f350SDavid Teigland "connection %d to node %d: err=%d", 6842f2d76ccSBenjamin Poirier (int)sn->sn_assoc_change.sac_assoc_id, 6852f2d76ccSBenjamin Poirier nodeid, ret); 6866861f350SDavid Teigland return; 6876861f350SDavid Teigland } 6886ed7257bSPatrick Caulfield add_sock(new_con->sock, new_con); 6896ed7257bSPatrick Caulfield 6906861f350SDavid Teigland log_print("connecting to %d sctp association %d", 6916861f350SDavid Teigland nodeid, (int)sn->sn_assoc_change.sac_assoc_id); 6926ed7257bSPatrick Caulfield 693e1631d0cSMike Christie new_con->sctp_assoc = sn->sn_assoc_change.sac_assoc_id; 69498e1b60eSMike Christie new_con->try_new_addr = false; 6956ed7257bSPatrick Caulfield /* Send any pending writes */ 6966ed7257bSPatrick Caulfield clear_bit(CF_CONNECT_PENDING, &new_con->flags); 697efad7e6bSMike Christie clear_bit(CF_INIT_PENDING, &new_con->flags); 6986ed7257bSPatrick Caulfield if (!test_and_set_bit(CF_WRITE_PENDING, &new_con->flags)) { 6996ed7257bSPatrick Caulfield queue_work(send_workqueue, &new_con->swork); 7006ed7257bSPatrick Caulfield } 7016ed7257bSPatrick Caulfield if (!test_and_set_bit(CF_READ_PENDING, &new_con->flags)) 7026ed7257bSPatrick Caulfield queue_work(recv_workqueue, &new_con->rwork); 7036ed7257bSPatrick Caulfield } 7046ed7257bSPatrick Caulfield break; 7056ed7257bSPatrick Caulfield 7066ed7257bSPatrick Caulfield case SCTP_COMM_LOST: 7076ed7257bSPatrick Caulfield case SCTP_SHUTDOWN_COMP: 7086ed7257bSPatrick Caulfield { 7096ed7257bSPatrick Caulfield con = assoc2con(sn->sn_assoc_change.sac_assoc_id); 7106ed7257bSPatrick Caulfield if (con) { 7116ed7257bSPatrick Caulfield con->sctp_assoc = 0; 7126ed7257bSPatrick Caulfield } 7136ed7257bSPatrick Caulfield } 7146ed7257bSPatrick Caulfield break; 7156ed7257bSPatrick Caulfield 7166ed7257bSPatrick Caulfield /* We don't know which INIT failed, so clear the PENDING flags 7176ed7257bSPatrick Caulfield * on them all. if assoc_id is zero then it will then try 7186ed7257bSPatrick Caulfield * again */ 7196ed7257bSPatrick Caulfield 7206ed7257bSPatrick Caulfield case SCTP_CANT_STR_ASSOC: 7216ed7257bSPatrick Caulfield { 7226ed7257bSPatrick Caulfield log_print("Can't start SCTP association - retrying"); 7236ed7257bSPatrick Caulfield sctp_init_failed(); 7246ed7257bSPatrick Caulfield } 7256ed7257bSPatrick Caulfield break; 7266ed7257bSPatrick Caulfield 7276ed7257bSPatrick Caulfield default: 7286ed7257bSPatrick Caulfield log_print("unexpected SCTP assoc change id=%d state=%d", 7296ed7257bSPatrick Caulfield (int)sn->sn_assoc_change.sac_assoc_id, 7306ed7257bSPatrick Caulfield sn->sn_assoc_change.sac_state); 7316ed7257bSPatrick Caulfield } 7326ed7257bSPatrick Caulfield } 7336ed7257bSPatrick Caulfield } 7346ed7257bSPatrick Caulfield 7356ed7257bSPatrick Caulfield /* Data received from remote end */ 7366ed7257bSPatrick Caulfield static int receive_from_sock(struct connection *con) 7376ed7257bSPatrick Caulfield { 7386ed7257bSPatrick Caulfield int ret = 0; 7396ed7257bSPatrick Caulfield struct msghdr msg = {}; 7406ed7257bSPatrick Caulfield struct kvec iov[2]; 7416ed7257bSPatrick Caulfield unsigned len; 7426ed7257bSPatrick Caulfield int r; 7436ed7257bSPatrick Caulfield int call_again_soon = 0; 7446ed7257bSPatrick Caulfield int nvec; 7456ed7257bSPatrick Caulfield char incmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))]; 7466ed7257bSPatrick Caulfield 7476ed7257bSPatrick Caulfield mutex_lock(&con->sock_mutex); 7486ed7257bSPatrick Caulfield 7496ed7257bSPatrick Caulfield if (con->sock == NULL) { 7506ed7257bSPatrick Caulfield ret = -EAGAIN; 7516ed7257bSPatrick Caulfield goto out_close; 7526ed7257bSPatrick Caulfield } 7536ed7257bSPatrick Caulfield 7546ed7257bSPatrick Caulfield if (con->rx_page == NULL) { 7556ed7257bSPatrick Caulfield /* 7566ed7257bSPatrick Caulfield * This doesn't need to be atomic, but I think it should 7576ed7257bSPatrick Caulfield * improve performance if it is. 7586ed7257bSPatrick Caulfield */ 7596ed7257bSPatrick Caulfield con->rx_page = alloc_page(GFP_ATOMIC); 7606ed7257bSPatrick Caulfield if (con->rx_page == NULL) 7616ed7257bSPatrick Caulfield goto out_resched; 7626ed7257bSPatrick Caulfield cbuf_init(&con->cb, PAGE_CACHE_SIZE); 7636ed7257bSPatrick Caulfield } 7646ed7257bSPatrick Caulfield 7656ed7257bSPatrick Caulfield /* Only SCTP needs these really */ 7666ed7257bSPatrick Caulfield memset(&incmsg, 0, sizeof(incmsg)); 7676ed7257bSPatrick Caulfield msg.msg_control = incmsg; 7686ed7257bSPatrick Caulfield msg.msg_controllen = sizeof(incmsg); 7696ed7257bSPatrick Caulfield 7706ed7257bSPatrick Caulfield /* 7716ed7257bSPatrick Caulfield * iov[0] is the bit of the circular buffer between the current end 7726ed7257bSPatrick Caulfield * point (cb.base + cb.len) and the end of the buffer. 7736ed7257bSPatrick Caulfield */ 7746ed7257bSPatrick Caulfield iov[0].iov_len = con->cb.base - cbuf_data(&con->cb); 7756ed7257bSPatrick Caulfield iov[0].iov_base = page_address(con->rx_page) + cbuf_data(&con->cb); 7766ed7257bSPatrick Caulfield iov[1].iov_len = 0; 7776ed7257bSPatrick Caulfield nvec = 1; 7786ed7257bSPatrick Caulfield 7796ed7257bSPatrick Caulfield /* 7806ed7257bSPatrick Caulfield * iov[1] is the bit of the circular buffer between the start of the 7816ed7257bSPatrick Caulfield * buffer and the start of the currently used section (cb.base) 7826ed7257bSPatrick Caulfield */ 7836ed7257bSPatrick Caulfield if (cbuf_data(&con->cb) >= con->cb.base) { 7846ed7257bSPatrick Caulfield iov[0].iov_len = PAGE_CACHE_SIZE - cbuf_data(&con->cb); 7856ed7257bSPatrick Caulfield iov[1].iov_len = con->cb.base; 7866ed7257bSPatrick Caulfield iov[1].iov_base = page_address(con->rx_page); 7876ed7257bSPatrick Caulfield nvec = 2; 7886ed7257bSPatrick Caulfield } 7896ed7257bSPatrick Caulfield len = iov[0].iov_len + iov[1].iov_len; 7906ed7257bSPatrick Caulfield 7916ed7257bSPatrick Caulfield r = ret = kernel_recvmsg(con->sock, &msg, iov, nvec, len, 7926ed7257bSPatrick Caulfield MSG_DONTWAIT | MSG_NOSIGNAL); 7936ed7257bSPatrick Caulfield if (ret <= 0) 7946ed7257bSPatrick Caulfield goto out_close; 7956ed7257bSPatrick Caulfield 7966ed7257bSPatrick Caulfield /* Process SCTP notifications */ 7976ed7257bSPatrick Caulfield if (msg.msg_flags & MSG_NOTIFICATION) { 7986ed7257bSPatrick Caulfield msg.msg_control = incmsg; 7996ed7257bSPatrick Caulfield msg.msg_controllen = sizeof(incmsg); 8006ed7257bSPatrick Caulfield 8016ed7257bSPatrick Caulfield process_sctp_notification(con, &msg, 8026ed7257bSPatrick Caulfield page_address(con->rx_page) + con->cb.base); 8036ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 8046ed7257bSPatrick Caulfield return 0; 8056ed7257bSPatrick Caulfield } 8066ed7257bSPatrick Caulfield BUG_ON(con->nodeid == 0); 8076ed7257bSPatrick Caulfield 8086ed7257bSPatrick Caulfield if (ret == len) 8096ed7257bSPatrick Caulfield call_again_soon = 1; 8106ed7257bSPatrick Caulfield cbuf_add(&con->cb, ret); 8116ed7257bSPatrick Caulfield ret = dlm_process_incoming_buffer(con->nodeid, 8126ed7257bSPatrick Caulfield page_address(con->rx_page), 8136ed7257bSPatrick Caulfield con->cb.base, con->cb.len, 8146ed7257bSPatrick Caulfield PAGE_CACHE_SIZE); 8156ed7257bSPatrick Caulfield if (ret == -EBADMSG) { 816617e82e1SDavid Teigland log_print("lowcomms: addr=%p, base=%u, len=%u, " 817617e82e1SDavid Teigland "iov_len=%u, iov_base[0]=%p, read=%d", 8186ed7257bSPatrick Caulfield page_address(con->rx_page), con->cb.base, con->cb.len, 8196ed7257bSPatrick Caulfield len, iov[0].iov_base, r); 8206ed7257bSPatrick Caulfield } 8216ed7257bSPatrick Caulfield if (ret < 0) 8226ed7257bSPatrick Caulfield goto out_close; 8236ed7257bSPatrick Caulfield cbuf_eat(&con->cb, ret); 8246ed7257bSPatrick Caulfield 8256ed7257bSPatrick Caulfield if (cbuf_empty(&con->cb) && !call_again_soon) { 8266ed7257bSPatrick Caulfield __free_page(con->rx_page); 8276ed7257bSPatrick Caulfield con->rx_page = NULL; 8286ed7257bSPatrick Caulfield } 8296ed7257bSPatrick Caulfield 8306ed7257bSPatrick Caulfield if (call_again_soon) 8316ed7257bSPatrick Caulfield goto out_resched; 8326ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 8336ed7257bSPatrick Caulfield return 0; 8346ed7257bSPatrick Caulfield 8356ed7257bSPatrick Caulfield out_resched: 8366ed7257bSPatrick Caulfield if (!test_and_set_bit(CF_READ_PENDING, &con->flags)) 8376ed7257bSPatrick Caulfield queue_work(recv_workqueue, &con->rwork); 8386ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 8396ed7257bSPatrick Caulfield return -EAGAIN; 8406ed7257bSPatrick Caulfield 8416ed7257bSPatrick Caulfield out_close: 8426ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 8439e5f2825SPatrick Caulfield if (ret != -EAGAIN) { 8446ed7257bSPatrick Caulfield close_connection(con, false); 8456ed7257bSPatrick Caulfield /* Reconnect when there is something to send */ 8466ed7257bSPatrick Caulfield } 8476ed7257bSPatrick Caulfield /* Don't return success if we really got EOF */ 8486ed7257bSPatrick Caulfield if (ret == 0) 8496ed7257bSPatrick Caulfield ret = -EAGAIN; 8506ed7257bSPatrick Caulfield 8516ed7257bSPatrick Caulfield return ret; 8526ed7257bSPatrick Caulfield } 8536ed7257bSPatrick Caulfield 8546ed7257bSPatrick Caulfield /* Listening socket is busy, accept a connection */ 8556ed7257bSPatrick Caulfield static int tcp_accept_from_sock(struct connection *con) 8566ed7257bSPatrick Caulfield { 8576ed7257bSPatrick Caulfield int result; 8586ed7257bSPatrick Caulfield struct sockaddr_storage peeraddr; 8596ed7257bSPatrick Caulfield struct socket *newsock; 8606ed7257bSPatrick Caulfield int len; 8616ed7257bSPatrick Caulfield int nodeid; 8626ed7257bSPatrick Caulfield struct connection *newcon; 8636ed7257bSPatrick Caulfield struct connection *addcon; 8646ed7257bSPatrick Caulfield 865513ef596SDavid Teigland mutex_lock(&connections_lock); 866513ef596SDavid Teigland if (!dlm_allow_conn) { 867513ef596SDavid Teigland mutex_unlock(&connections_lock); 868513ef596SDavid Teigland return -1; 869513ef596SDavid Teigland } 870513ef596SDavid Teigland mutex_unlock(&connections_lock); 871513ef596SDavid Teigland 8726ed7257bSPatrick Caulfield memset(&peeraddr, 0, sizeof(peeraddr)); 8736ed7257bSPatrick Caulfield result = sock_create_kern(dlm_local_addr[0]->ss_family, SOCK_STREAM, 8746ed7257bSPatrick Caulfield IPPROTO_TCP, &newsock); 8756ed7257bSPatrick Caulfield if (result < 0) 8766ed7257bSPatrick Caulfield return -ENOMEM; 8776ed7257bSPatrick Caulfield 8786ed7257bSPatrick Caulfield mutex_lock_nested(&con->sock_mutex, 0); 8796ed7257bSPatrick Caulfield 8806ed7257bSPatrick Caulfield result = -ENOTCONN; 8816ed7257bSPatrick Caulfield if (con->sock == NULL) 8826ed7257bSPatrick Caulfield goto accept_err; 8836ed7257bSPatrick Caulfield 8846ed7257bSPatrick Caulfield newsock->type = con->sock->type; 8856ed7257bSPatrick Caulfield newsock->ops = con->sock->ops; 8866ed7257bSPatrick Caulfield 8876ed7257bSPatrick Caulfield result = con->sock->ops->accept(con->sock, newsock, O_NONBLOCK); 8886ed7257bSPatrick Caulfield if (result < 0) 8896ed7257bSPatrick Caulfield goto accept_err; 8906ed7257bSPatrick Caulfield 8916ed7257bSPatrick Caulfield /* Get the connected socket's peer */ 8926ed7257bSPatrick Caulfield memset(&peeraddr, 0, sizeof(peeraddr)); 8936ed7257bSPatrick Caulfield if (newsock->ops->getname(newsock, (struct sockaddr *)&peeraddr, 8946ed7257bSPatrick Caulfield &len, 2)) { 8956ed7257bSPatrick Caulfield result = -ECONNABORTED; 8966ed7257bSPatrick Caulfield goto accept_err; 8976ed7257bSPatrick Caulfield } 8986ed7257bSPatrick Caulfield 8996ed7257bSPatrick Caulfield /* Get the new node's NODEID */ 9006ed7257bSPatrick Caulfield make_sockaddr(&peeraddr, 0, &len); 90136b71a8bSDavid Teigland if (addr_to_nodeid(&peeraddr, &nodeid)) { 902bcaadf5cSMasatake YAMATO unsigned char *b=(unsigned char *)&peeraddr; 903617e82e1SDavid Teigland log_print("connect from non cluster node"); 904bcaadf5cSMasatake YAMATO print_hex_dump_bytes("ss: ", DUMP_PREFIX_NONE, 905bcaadf5cSMasatake YAMATO b, sizeof(struct sockaddr_storage)); 9066ed7257bSPatrick Caulfield sock_release(newsock); 9076ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 9086ed7257bSPatrick Caulfield return -1; 9096ed7257bSPatrick Caulfield } 9106ed7257bSPatrick Caulfield 9116ed7257bSPatrick Caulfield log_print("got connection from %d", nodeid); 9126ed7257bSPatrick Caulfield 9136ed7257bSPatrick Caulfield /* Check to see if we already have a connection to this node. This 9146ed7257bSPatrick Caulfield * could happen if the two nodes initiate a connection at roughly 9156ed7257bSPatrick Caulfield * the same time and the connections cross on the wire. 9166ed7257bSPatrick Caulfield * In this case we store the incoming one in "othercon" 9176ed7257bSPatrick Caulfield */ 918748285ccSDavid Teigland newcon = nodeid2con(nodeid, GFP_NOFS); 9196ed7257bSPatrick Caulfield if (!newcon) { 9206ed7257bSPatrick Caulfield result = -ENOMEM; 9216ed7257bSPatrick Caulfield goto accept_err; 9226ed7257bSPatrick Caulfield } 9236ed7257bSPatrick Caulfield mutex_lock_nested(&newcon->sock_mutex, 1); 9246ed7257bSPatrick Caulfield if (newcon->sock) { 9256ed7257bSPatrick Caulfield struct connection *othercon = newcon->othercon; 9266ed7257bSPatrick Caulfield 9276ed7257bSPatrick Caulfield if (!othercon) { 928748285ccSDavid Teigland othercon = kmem_cache_zalloc(con_cache, GFP_NOFS); 9296ed7257bSPatrick Caulfield if (!othercon) { 930617e82e1SDavid Teigland log_print("failed to allocate incoming socket"); 9316ed7257bSPatrick Caulfield mutex_unlock(&newcon->sock_mutex); 9326ed7257bSPatrick Caulfield result = -ENOMEM; 9336ed7257bSPatrick Caulfield goto accept_err; 9346ed7257bSPatrick Caulfield } 9356ed7257bSPatrick Caulfield othercon->nodeid = nodeid; 9366ed7257bSPatrick Caulfield othercon->rx_action = receive_from_sock; 9376ed7257bSPatrick Caulfield mutex_init(&othercon->sock_mutex); 9386ed7257bSPatrick Caulfield INIT_WORK(&othercon->swork, process_send_sockets); 9396ed7257bSPatrick Caulfield INIT_WORK(&othercon->rwork, process_recv_sockets); 9406ed7257bSPatrick Caulfield set_bit(CF_IS_OTHERCON, &othercon->flags); 94161d96be0SPatrick Caulfield } 94261d96be0SPatrick Caulfield if (!othercon->sock) { 9436ed7257bSPatrick Caulfield newcon->othercon = othercon; 9446ed7257bSPatrick Caulfield othercon->sock = newsock; 9456ed7257bSPatrick Caulfield newsock->sk->sk_user_data = othercon; 9466ed7257bSPatrick Caulfield add_sock(newsock, othercon); 9476ed7257bSPatrick Caulfield addcon = othercon; 9486ed7257bSPatrick Caulfield } 9496ed7257bSPatrick Caulfield else { 95097d84836SPatrick Caulfield printk("Extra connection from node %d attempted\n", nodeid); 95197d84836SPatrick Caulfield result = -EAGAIN; 952f4fadb23Sakpm@linux-foundation.org mutex_unlock(&newcon->sock_mutex); 95397d84836SPatrick Caulfield goto accept_err; 95497d84836SPatrick Caulfield } 95597d84836SPatrick Caulfield } 95697d84836SPatrick Caulfield else { 9576ed7257bSPatrick Caulfield newsock->sk->sk_user_data = newcon; 9586ed7257bSPatrick Caulfield newcon->rx_action = receive_from_sock; 9596ed7257bSPatrick Caulfield add_sock(newsock, newcon); 9606ed7257bSPatrick Caulfield addcon = newcon; 9616ed7257bSPatrick Caulfield } 9626ed7257bSPatrick Caulfield 9636ed7257bSPatrick Caulfield mutex_unlock(&newcon->sock_mutex); 9646ed7257bSPatrick Caulfield 9656ed7257bSPatrick Caulfield /* 9666ed7257bSPatrick Caulfield * Add it to the active queue in case we got data 96725985edcSLucas De Marchi * between processing the accept adding the socket 9686ed7257bSPatrick Caulfield * to the read_sockets list 9696ed7257bSPatrick Caulfield */ 9706ed7257bSPatrick Caulfield if (!test_and_set_bit(CF_READ_PENDING, &addcon->flags)) 9716ed7257bSPatrick Caulfield queue_work(recv_workqueue, &addcon->rwork); 9726ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 9736ed7257bSPatrick Caulfield 9746ed7257bSPatrick Caulfield return 0; 9756ed7257bSPatrick Caulfield 9766ed7257bSPatrick Caulfield accept_err: 9776ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 9786ed7257bSPatrick Caulfield sock_release(newsock); 9796ed7257bSPatrick Caulfield 9806ed7257bSPatrick Caulfield if (result != -EAGAIN) 981617e82e1SDavid Teigland log_print("error accepting connection from node: %d", result); 9826ed7257bSPatrick Caulfield return result; 9836ed7257bSPatrick Caulfield } 9846ed7257bSPatrick Caulfield 9856ed7257bSPatrick Caulfield static void free_entry(struct writequeue_entry *e) 9866ed7257bSPatrick Caulfield { 9876ed7257bSPatrick Caulfield __free_page(e->page); 9886ed7257bSPatrick Caulfield kfree(e); 9896ed7257bSPatrick Caulfield } 9906ed7257bSPatrick Caulfield 9916ed7257bSPatrick Caulfield /* Initiate an SCTP association. 9926ed7257bSPatrick Caulfield This is a special case of send_to_sock() in that we don't yet have a 9936ed7257bSPatrick Caulfield peeled-off socket for this association, so we use the listening socket 9946ed7257bSPatrick Caulfield and add the primary IP address of the remote node. 9956ed7257bSPatrick Caulfield */ 9966ed7257bSPatrick Caulfield static void sctp_init_assoc(struct connection *con) 9976ed7257bSPatrick Caulfield { 9986ed7257bSPatrick Caulfield struct sockaddr_storage rem_addr; 9996ed7257bSPatrick Caulfield char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))]; 10006ed7257bSPatrick Caulfield struct msghdr outmessage; 10016ed7257bSPatrick Caulfield struct cmsghdr *cmsg; 10026ed7257bSPatrick Caulfield struct sctp_sndrcvinfo *sinfo; 10036ed7257bSPatrick Caulfield struct connection *base_con; 10046ed7257bSPatrick Caulfield struct writequeue_entry *e; 10056ed7257bSPatrick Caulfield int len, offset; 10066ed7257bSPatrick Caulfield int ret; 10076ed7257bSPatrick Caulfield int addrlen; 10086ed7257bSPatrick Caulfield struct kvec iov[1]; 10096ed7257bSPatrick Caulfield 10106ed7257bSPatrick Caulfield if (test_and_set_bit(CF_INIT_PENDING, &con->flags)) 10116ed7257bSPatrick Caulfield return; 10126ed7257bSPatrick Caulfield 10136ed7257bSPatrick Caulfield if (con->retries++ > MAX_CONNECT_RETRIES) 10146ed7257bSPatrick Caulfield return; 10156ed7257bSPatrick Caulfield 101698e1b60eSMike Christie if (nodeid_to_addr(con->nodeid, NULL, (struct sockaddr *)&rem_addr, 101798e1b60eSMike Christie con->try_new_addr)) { 10186ed7257bSPatrick Caulfield log_print("no address for nodeid %d", con->nodeid); 10196ed7257bSPatrick Caulfield return; 10206ed7257bSPatrick Caulfield } 10216ed7257bSPatrick Caulfield base_con = nodeid2con(0, 0); 10226ed7257bSPatrick Caulfield BUG_ON(base_con == NULL); 10236ed7257bSPatrick Caulfield 10246ed7257bSPatrick Caulfield make_sockaddr(&rem_addr, dlm_config.ci_tcp_port, &addrlen); 10256ed7257bSPatrick Caulfield 10266ed7257bSPatrick Caulfield outmessage.msg_name = &rem_addr; 10276ed7257bSPatrick Caulfield outmessage.msg_namelen = addrlen; 10286ed7257bSPatrick Caulfield outmessage.msg_control = outcmsg; 10296ed7257bSPatrick Caulfield outmessage.msg_controllen = sizeof(outcmsg); 10306ed7257bSPatrick Caulfield outmessage.msg_flags = MSG_EOR; 10316ed7257bSPatrick Caulfield 10326ed7257bSPatrick Caulfield spin_lock(&con->writequeue_lock); 10336ed7257bSPatrick Caulfield 103404bedd79SDavid Teigland if (list_empty(&con->writequeue)) { 103504bedd79SDavid Teigland spin_unlock(&con->writequeue_lock); 103604bedd79SDavid Teigland log_print("writequeue empty for nodeid %d", con->nodeid); 103704bedd79SDavid Teigland return; 103804bedd79SDavid Teigland } 10396ed7257bSPatrick Caulfield 104004bedd79SDavid Teigland e = list_first_entry(&con->writequeue, struct writequeue_entry, list); 10416ed7257bSPatrick Caulfield len = e->len; 10426ed7257bSPatrick Caulfield offset = e->offset; 10436ed7257bSPatrick Caulfield spin_unlock(&con->writequeue_lock); 10446ed7257bSPatrick Caulfield 10456ed7257bSPatrick Caulfield /* Send the first block off the write queue */ 10466ed7257bSPatrick Caulfield iov[0].iov_base = page_address(e->page)+offset; 10476ed7257bSPatrick Caulfield iov[0].iov_len = len; 10486ed7257bSPatrick Caulfield 104998e1b60eSMike Christie if (rem_addr.ss_family == AF_INET) { 105098e1b60eSMike Christie struct sockaddr_in *sin = (struct sockaddr_in *)&rem_addr; 105198e1b60eSMike Christie log_print("Trying to connect to %pI4", &sin->sin_addr.s_addr); 105298e1b60eSMike Christie } else { 105398e1b60eSMike Christie struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)&rem_addr; 105498e1b60eSMike Christie log_print("Trying to connect to %pI6", &sin6->sin6_addr); 105598e1b60eSMike Christie } 105698e1b60eSMike Christie 10576ed7257bSPatrick Caulfield cmsg = CMSG_FIRSTHDR(&outmessage); 10586ed7257bSPatrick Caulfield cmsg->cmsg_level = IPPROTO_SCTP; 10596ed7257bSPatrick Caulfield cmsg->cmsg_type = SCTP_SNDRCV; 10606ed7257bSPatrick Caulfield cmsg->cmsg_len = CMSG_LEN(sizeof(struct sctp_sndrcvinfo)); 10616ed7257bSPatrick Caulfield sinfo = CMSG_DATA(cmsg); 10626ed7257bSPatrick Caulfield memset(sinfo, 0x00, sizeof(struct sctp_sndrcvinfo)); 10636ed7257bSPatrick Caulfield sinfo->sinfo_ppid = cpu_to_le32(dlm_our_nodeid()); 10646ed7257bSPatrick Caulfield outmessage.msg_controllen = cmsg->cmsg_len; 106598e1b60eSMike Christie sinfo->sinfo_flags |= SCTP_ADDR_OVER; 10666ed7257bSPatrick Caulfield 10676ed7257bSPatrick Caulfield ret = kernel_sendmsg(base_con->sock, &outmessage, iov, 1, len); 10686ed7257bSPatrick Caulfield if (ret < 0) { 1069617e82e1SDavid Teigland log_print("Send first packet to node %d failed: %d", 1070617e82e1SDavid Teigland con->nodeid, ret); 10716ed7257bSPatrick Caulfield 10726ed7257bSPatrick Caulfield /* Try again later */ 10736ed7257bSPatrick Caulfield clear_bit(CF_CONNECT_PENDING, &con->flags); 10746ed7257bSPatrick Caulfield clear_bit(CF_INIT_PENDING, &con->flags); 10756ed7257bSPatrick Caulfield } 10766ed7257bSPatrick Caulfield else { 10776ed7257bSPatrick Caulfield spin_lock(&con->writequeue_lock); 10786ed7257bSPatrick Caulfield e->offset += ret; 10796ed7257bSPatrick Caulfield e->len -= ret; 10806ed7257bSPatrick Caulfield 10816ed7257bSPatrick Caulfield if (e->len == 0 && e->users == 0) { 10826ed7257bSPatrick Caulfield list_del(&e->list); 10836ed7257bSPatrick Caulfield free_entry(e); 10846ed7257bSPatrick Caulfield } 10856ed7257bSPatrick Caulfield spin_unlock(&con->writequeue_lock); 10866ed7257bSPatrick Caulfield } 10876ed7257bSPatrick Caulfield } 10886ed7257bSPatrick Caulfield 10896ed7257bSPatrick Caulfield /* Connect a new socket to its peer */ 10906ed7257bSPatrick Caulfield static void tcp_connect_to_sock(struct connection *con) 10916ed7257bSPatrick Caulfield { 10926bd8fedaSLon Hohberger struct sockaddr_storage saddr, src_addr; 10936ed7257bSPatrick Caulfield int addr_len; 1094a89d63a1SCasey Dahlin struct socket *sock = NULL; 1095cb2d45daSDavid Teigland int one = 1; 109636b71a8bSDavid Teigland int result; 10976ed7257bSPatrick Caulfield 10986ed7257bSPatrick Caulfield if (con->nodeid == 0) { 10996ed7257bSPatrick Caulfield log_print("attempt to connect sock 0 foiled"); 11006ed7257bSPatrick Caulfield return; 11016ed7257bSPatrick Caulfield } 11026ed7257bSPatrick Caulfield 11036ed7257bSPatrick Caulfield mutex_lock(&con->sock_mutex); 11046ed7257bSPatrick Caulfield if (con->retries++ > MAX_CONNECT_RETRIES) 11056ed7257bSPatrick Caulfield goto out; 11066ed7257bSPatrick Caulfield 11076ed7257bSPatrick Caulfield /* Some odd races can cause double-connects, ignore them */ 110836b71a8bSDavid Teigland if (con->sock) 11096ed7257bSPatrick Caulfield goto out; 11106ed7257bSPatrick Caulfield 11116ed7257bSPatrick Caulfield /* Create a socket to communicate with */ 11126ed7257bSPatrick Caulfield result = sock_create_kern(dlm_local_addr[0]->ss_family, SOCK_STREAM, 11136ed7257bSPatrick Caulfield IPPROTO_TCP, &sock); 11146ed7257bSPatrick Caulfield if (result < 0) 11156ed7257bSPatrick Caulfield goto out_err; 11166ed7257bSPatrick Caulfield 11176ed7257bSPatrick Caulfield memset(&saddr, 0, sizeof(saddr)); 111898e1b60eSMike Christie result = nodeid_to_addr(con->nodeid, &saddr, NULL, false); 111936b71a8bSDavid Teigland if (result < 0) { 112036b71a8bSDavid Teigland log_print("no address for nodeid %d", con->nodeid); 11216ed7257bSPatrick Caulfield goto out_err; 112236b71a8bSDavid Teigland } 11236ed7257bSPatrick Caulfield 11246ed7257bSPatrick Caulfield sock->sk->sk_user_data = con; 11256ed7257bSPatrick Caulfield con->rx_action = receive_from_sock; 11266ed7257bSPatrick Caulfield con->connect_action = tcp_connect_to_sock; 11276ed7257bSPatrick Caulfield add_sock(sock, con); 11286ed7257bSPatrick Caulfield 11296bd8fedaSLon Hohberger /* Bind to our cluster-known address connecting to avoid 11306bd8fedaSLon Hohberger routing problems */ 11316bd8fedaSLon Hohberger memcpy(&src_addr, dlm_local_addr[0], sizeof(src_addr)); 11326bd8fedaSLon Hohberger make_sockaddr(&src_addr, 0, &addr_len); 11336bd8fedaSLon Hohberger result = sock->ops->bind(sock, (struct sockaddr *) &src_addr, 11346bd8fedaSLon Hohberger addr_len); 11356bd8fedaSLon Hohberger if (result < 0) { 11366bd8fedaSLon Hohberger log_print("could not bind for connect: %d", result); 11376bd8fedaSLon Hohberger /* This *may* not indicate a critical error */ 11386bd8fedaSLon Hohberger } 11396bd8fedaSLon Hohberger 11406ed7257bSPatrick Caulfield make_sockaddr(&saddr, dlm_config.ci_tcp_port, &addr_len); 11416ed7257bSPatrick Caulfield 11426ed7257bSPatrick Caulfield log_print("connecting to %d", con->nodeid); 1143cb2d45daSDavid Teigland 1144cb2d45daSDavid Teigland /* Turn off Nagle's algorithm */ 1145cb2d45daSDavid Teigland kernel_setsockopt(sock, SOL_TCP, TCP_NODELAY, (char *)&one, 1146cb2d45daSDavid Teigland sizeof(one)); 1147cb2d45daSDavid Teigland 114836b71a8bSDavid Teigland result = sock->ops->connect(sock, (struct sockaddr *)&saddr, addr_len, 11496ed7257bSPatrick Caulfield O_NONBLOCK); 11506ed7257bSPatrick Caulfield if (result == -EINPROGRESS) 11516ed7257bSPatrick Caulfield result = 0; 11526ed7257bSPatrick Caulfield if (result == 0) 11536ed7257bSPatrick Caulfield goto out; 11546ed7257bSPatrick Caulfield 11556ed7257bSPatrick Caulfield out_err: 11566ed7257bSPatrick Caulfield if (con->sock) { 11576ed7257bSPatrick Caulfield sock_release(con->sock); 11586ed7257bSPatrick Caulfield con->sock = NULL; 1159a89d63a1SCasey Dahlin } else if (sock) { 1160a89d63a1SCasey Dahlin sock_release(sock); 11616ed7257bSPatrick Caulfield } 11626ed7257bSPatrick Caulfield /* 11636ed7257bSPatrick Caulfield * Some errors are fatal and this list might need adjusting. For other 11646ed7257bSPatrick Caulfield * errors we try again until the max number of retries is reached. 11656ed7257bSPatrick Caulfield */ 116636b71a8bSDavid Teigland if (result != -EHOSTUNREACH && 116736b71a8bSDavid Teigland result != -ENETUNREACH && 116836b71a8bSDavid Teigland result != -ENETDOWN && 116936b71a8bSDavid Teigland result != -EINVAL && 117036b71a8bSDavid Teigland result != -EPROTONOSUPPORT) { 117136b71a8bSDavid Teigland log_print("connect %d try %d error %d", con->nodeid, 117236b71a8bSDavid Teigland con->retries, result); 117336b71a8bSDavid Teigland mutex_unlock(&con->sock_mutex); 117436b71a8bSDavid Teigland msleep(1000); 11756ed7257bSPatrick Caulfield lowcomms_connect_sock(con); 117636b71a8bSDavid Teigland return; 11776ed7257bSPatrick Caulfield } 11786ed7257bSPatrick Caulfield out: 11796ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 11806ed7257bSPatrick Caulfield return; 11816ed7257bSPatrick Caulfield } 11826ed7257bSPatrick Caulfield 11836ed7257bSPatrick Caulfield static struct socket *tcp_create_listen_sock(struct connection *con, 11846ed7257bSPatrick Caulfield struct sockaddr_storage *saddr) 11856ed7257bSPatrick Caulfield { 11866ed7257bSPatrick Caulfield struct socket *sock = NULL; 11876ed7257bSPatrick Caulfield int result = 0; 11886ed7257bSPatrick Caulfield int one = 1; 11896ed7257bSPatrick Caulfield int addr_len; 11906ed7257bSPatrick Caulfield 11916ed7257bSPatrick Caulfield if (dlm_local_addr[0]->ss_family == AF_INET) 11926ed7257bSPatrick Caulfield addr_len = sizeof(struct sockaddr_in); 11936ed7257bSPatrick Caulfield else 11946ed7257bSPatrick Caulfield addr_len = sizeof(struct sockaddr_in6); 11956ed7257bSPatrick Caulfield 11966ed7257bSPatrick Caulfield /* Create a socket to communicate with */ 1197617e82e1SDavid Teigland result = sock_create_kern(dlm_local_addr[0]->ss_family, SOCK_STREAM, 1198617e82e1SDavid Teigland IPPROTO_TCP, &sock); 11996ed7257bSPatrick Caulfield if (result < 0) { 1200617e82e1SDavid Teigland log_print("Can't create listening comms socket"); 12016ed7257bSPatrick Caulfield goto create_out; 12026ed7257bSPatrick Caulfield } 12036ed7257bSPatrick Caulfield 1204cb2d45daSDavid Teigland /* Turn off Nagle's algorithm */ 1205cb2d45daSDavid Teigland kernel_setsockopt(sock, SOL_TCP, TCP_NODELAY, (char *)&one, 1206cb2d45daSDavid Teigland sizeof(one)); 1207cb2d45daSDavid Teigland 12086ed7257bSPatrick Caulfield result = kernel_setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, 12096ed7257bSPatrick Caulfield (char *)&one, sizeof(one)); 12106ed7257bSPatrick Caulfield 12116ed7257bSPatrick Caulfield if (result < 0) { 1212617e82e1SDavid Teigland log_print("Failed to set SO_REUSEADDR on socket: %d", result); 12136ed7257bSPatrick Caulfield } 12146ed7257bSPatrick Caulfield con->rx_action = tcp_accept_from_sock; 12156ed7257bSPatrick Caulfield con->connect_action = tcp_connect_to_sock; 12166ed7257bSPatrick Caulfield 12176ed7257bSPatrick Caulfield /* Bind to our port */ 12186ed7257bSPatrick Caulfield make_sockaddr(saddr, dlm_config.ci_tcp_port, &addr_len); 12196ed7257bSPatrick Caulfield result = sock->ops->bind(sock, (struct sockaddr *) saddr, addr_len); 12206ed7257bSPatrick Caulfield if (result < 0) { 1221617e82e1SDavid Teigland log_print("Can't bind to port %d", dlm_config.ci_tcp_port); 12226ed7257bSPatrick Caulfield sock_release(sock); 12236ed7257bSPatrick Caulfield sock = NULL; 12246ed7257bSPatrick Caulfield con->sock = NULL; 12256ed7257bSPatrick Caulfield goto create_out; 12266ed7257bSPatrick Caulfield } 12276ed7257bSPatrick Caulfield result = kernel_setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, 12286ed7257bSPatrick Caulfield (char *)&one, sizeof(one)); 12296ed7257bSPatrick Caulfield if (result < 0) { 1230617e82e1SDavid Teigland log_print("Set keepalive failed: %d", result); 12316ed7257bSPatrick Caulfield } 12326ed7257bSPatrick Caulfield 12336ed7257bSPatrick Caulfield result = sock->ops->listen(sock, 5); 12346ed7257bSPatrick Caulfield if (result < 0) { 1235617e82e1SDavid Teigland log_print("Can't listen on port %d", dlm_config.ci_tcp_port); 12366ed7257bSPatrick Caulfield sock_release(sock); 12376ed7257bSPatrick Caulfield sock = NULL; 12386ed7257bSPatrick Caulfield goto create_out; 12396ed7257bSPatrick Caulfield } 12406ed7257bSPatrick Caulfield 12416ed7257bSPatrick Caulfield create_out: 12426ed7257bSPatrick Caulfield return sock; 12436ed7257bSPatrick Caulfield } 12446ed7257bSPatrick Caulfield 12456ed7257bSPatrick Caulfield /* Get local addresses */ 12466ed7257bSPatrick Caulfield static void init_local(void) 12476ed7257bSPatrick Caulfield { 12486ed7257bSPatrick Caulfield struct sockaddr_storage sas, *addr; 12496ed7257bSPatrick Caulfield int i; 12506ed7257bSPatrick Caulfield 125130d3a237SPatrick Caulfield dlm_local_count = 0; 12521b189b88SDavid Teigland for (i = 0; i < DLM_MAX_ADDR_COUNT; i++) { 12536ed7257bSPatrick Caulfield if (dlm_our_addr(&sas, i)) 12546ed7257bSPatrick Caulfield break; 12556ed7257bSPatrick Caulfield 1256573c24c4SDavid Teigland addr = kmalloc(sizeof(*addr), GFP_NOFS); 12576ed7257bSPatrick Caulfield if (!addr) 12586ed7257bSPatrick Caulfield break; 12596ed7257bSPatrick Caulfield memcpy(addr, &sas, sizeof(*addr)); 12606ed7257bSPatrick Caulfield dlm_local_addr[dlm_local_count++] = addr; 12616ed7257bSPatrick Caulfield } 12626ed7257bSPatrick Caulfield } 12636ed7257bSPatrick Caulfield 1264617e82e1SDavid Teigland /* Bind to an IP address. SCTP allows multiple address so it can do 1265617e82e1SDavid Teigland multi-homing */ 1266617e82e1SDavid Teigland static int add_sctp_bind_addr(struct connection *sctp_con, 1267617e82e1SDavid Teigland struct sockaddr_storage *addr, 1268617e82e1SDavid Teigland int addr_len, int num) 12696ed7257bSPatrick Caulfield { 12706ed7257bSPatrick Caulfield int result = 0; 12716ed7257bSPatrick Caulfield 12726ed7257bSPatrick Caulfield if (num == 1) 12736ed7257bSPatrick Caulfield result = kernel_bind(sctp_con->sock, 12746ed7257bSPatrick Caulfield (struct sockaddr *) addr, 12756ed7257bSPatrick Caulfield addr_len); 12766ed7257bSPatrick Caulfield else 12776ed7257bSPatrick Caulfield result = kernel_setsockopt(sctp_con->sock, SOL_SCTP, 12786ed7257bSPatrick Caulfield SCTP_SOCKOPT_BINDX_ADD, 12796ed7257bSPatrick Caulfield (char *)addr, addr_len); 12806ed7257bSPatrick Caulfield 12816ed7257bSPatrick Caulfield if (result < 0) 12826ed7257bSPatrick Caulfield log_print("Can't bind to port %d addr number %d", 12836ed7257bSPatrick Caulfield dlm_config.ci_tcp_port, num); 12846ed7257bSPatrick Caulfield 12856ed7257bSPatrick Caulfield return result; 12866ed7257bSPatrick Caulfield } 12876ed7257bSPatrick Caulfield 12886ed7257bSPatrick Caulfield /* Initialise SCTP socket and bind to all interfaces */ 12896ed7257bSPatrick Caulfield static int sctp_listen_for_all(void) 12906ed7257bSPatrick Caulfield { 12916ed7257bSPatrick Caulfield struct socket *sock = NULL; 12926ed7257bSPatrick Caulfield struct sockaddr_storage localaddr; 12936ed7257bSPatrick Caulfield struct sctp_event_subscribe subscribe; 12946ed7257bSPatrick Caulfield int result = -EINVAL, num = 1, i, addr_len; 1295573c24c4SDavid Teigland struct connection *con = nodeid2con(0, GFP_NOFS); 12966ed7257bSPatrick Caulfield int bufsize = NEEDED_RMEM; 12976ed7257bSPatrick Caulfield 12986ed7257bSPatrick Caulfield if (!con) 12996ed7257bSPatrick Caulfield return -ENOMEM; 13006ed7257bSPatrick Caulfield 13016ed7257bSPatrick Caulfield log_print("Using SCTP for communications"); 13026ed7257bSPatrick Caulfield 13036ed7257bSPatrick Caulfield result = sock_create_kern(dlm_local_addr[0]->ss_family, SOCK_SEQPACKET, 13046ed7257bSPatrick Caulfield IPPROTO_SCTP, &sock); 13056ed7257bSPatrick Caulfield if (result < 0) { 13066ed7257bSPatrick Caulfield log_print("Can't create comms socket, check SCTP is loaded"); 13076ed7257bSPatrick Caulfield goto out; 13086ed7257bSPatrick Caulfield } 13096ed7257bSPatrick Caulfield 13106ed7257bSPatrick Caulfield /* Listen for events */ 13116ed7257bSPatrick Caulfield memset(&subscribe, 0, sizeof(subscribe)); 13126ed7257bSPatrick Caulfield subscribe.sctp_data_io_event = 1; 13136ed7257bSPatrick Caulfield subscribe.sctp_association_event = 1; 13146ed7257bSPatrick Caulfield subscribe.sctp_send_failure_event = 1; 13156ed7257bSPatrick Caulfield subscribe.sctp_shutdown_event = 1; 13166ed7257bSPatrick Caulfield subscribe.sctp_partial_delivery_event = 1; 13176ed7257bSPatrick Caulfield 1318df61c952SDavid S. Miller result = kernel_setsockopt(sock, SOL_SOCKET, SO_RCVBUFFORCE, 13196ed7257bSPatrick Caulfield (char *)&bufsize, sizeof(bufsize)); 13206ed7257bSPatrick Caulfield if (result) 1321617e82e1SDavid Teigland log_print("Error increasing buffer space on socket %d", result); 13226ed7257bSPatrick Caulfield 13236ed7257bSPatrick Caulfield result = kernel_setsockopt(sock, SOL_SCTP, SCTP_EVENTS, 13246ed7257bSPatrick Caulfield (char *)&subscribe, sizeof(subscribe)); 13256ed7257bSPatrick Caulfield if (result < 0) { 13266ed7257bSPatrick Caulfield log_print("Failed to set SCTP_EVENTS on socket: result=%d", 13276ed7257bSPatrick Caulfield result); 13286ed7257bSPatrick Caulfield goto create_delsock; 13296ed7257bSPatrick Caulfield } 13306ed7257bSPatrick Caulfield 13316ed7257bSPatrick Caulfield /* Init con struct */ 13326ed7257bSPatrick Caulfield sock->sk->sk_user_data = con; 13336ed7257bSPatrick Caulfield con->sock = sock; 13346ed7257bSPatrick Caulfield con->sock->sk->sk_data_ready = lowcomms_data_ready; 13356ed7257bSPatrick Caulfield con->rx_action = receive_from_sock; 13366ed7257bSPatrick Caulfield con->connect_action = sctp_init_assoc; 13376ed7257bSPatrick Caulfield 13386ed7257bSPatrick Caulfield /* Bind to all interfaces. */ 13396ed7257bSPatrick Caulfield for (i = 0; i < dlm_local_count; i++) { 13406ed7257bSPatrick Caulfield memcpy(&localaddr, dlm_local_addr[i], sizeof(localaddr)); 13416ed7257bSPatrick Caulfield make_sockaddr(&localaddr, dlm_config.ci_tcp_port, &addr_len); 13426ed7257bSPatrick Caulfield 13436ed7257bSPatrick Caulfield result = add_sctp_bind_addr(con, &localaddr, addr_len, num); 13446ed7257bSPatrick Caulfield if (result) 13456ed7257bSPatrick Caulfield goto create_delsock; 13466ed7257bSPatrick Caulfield ++num; 13476ed7257bSPatrick Caulfield } 13486ed7257bSPatrick Caulfield 13496ed7257bSPatrick Caulfield result = sock->ops->listen(sock, 5); 13506ed7257bSPatrick Caulfield if (result < 0) { 13516ed7257bSPatrick Caulfield log_print("Can't set socket listening"); 13526ed7257bSPatrick Caulfield goto create_delsock; 13536ed7257bSPatrick Caulfield } 13546ed7257bSPatrick Caulfield 13556ed7257bSPatrick Caulfield return 0; 13566ed7257bSPatrick Caulfield 13576ed7257bSPatrick Caulfield create_delsock: 13586ed7257bSPatrick Caulfield sock_release(sock); 13596ed7257bSPatrick Caulfield con->sock = NULL; 13606ed7257bSPatrick Caulfield out: 13616ed7257bSPatrick Caulfield return result; 13626ed7257bSPatrick Caulfield } 13636ed7257bSPatrick Caulfield 13646ed7257bSPatrick Caulfield static int tcp_listen_for_all(void) 13656ed7257bSPatrick Caulfield { 13666ed7257bSPatrick Caulfield struct socket *sock = NULL; 1367573c24c4SDavid Teigland struct connection *con = nodeid2con(0, GFP_NOFS); 13686ed7257bSPatrick Caulfield int result = -EINVAL; 13696ed7257bSPatrick Caulfield 13706ed7257bSPatrick Caulfield if (!con) 13716ed7257bSPatrick Caulfield return -ENOMEM; 13726ed7257bSPatrick Caulfield 13736ed7257bSPatrick Caulfield /* We don't support multi-homed hosts */ 13746ed7257bSPatrick Caulfield if (dlm_local_addr[1] != NULL) { 1375617e82e1SDavid Teigland log_print("TCP protocol can't handle multi-homed hosts, " 1376617e82e1SDavid Teigland "try SCTP"); 13776ed7257bSPatrick Caulfield return -EINVAL; 13786ed7257bSPatrick Caulfield } 13796ed7257bSPatrick Caulfield 13806ed7257bSPatrick Caulfield log_print("Using TCP for communications"); 13816ed7257bSPatrick Caulfield 13826ed7257bSPatrick Caulfield sock = tcp_create_listen_sock(con, dlm_local_addr[0]); 13836ed7257bSPatrick Caulfield if (sock) { 13846ed7257bSPatrick Caulfield add_sock(sock, con); 13856ed7257bSPatrick Caulfield result = 0; 13866ed7257bSPatrick Caulfield } 13876ed7257bSPatrick Caulfield else { 13886ed7257bSPatrick Caulfield result = -EADDRINUSE; 13896ed7257bSPatrick Caulfield } 13906ed7257bSPatrick Caulfield 13916ed7257bSPatrick Caulfield return result; 13926ed7257bSPatrick Caulfield } 13936ed7257bSPatrick Caulfield 13946ed7257bSPatrick Caulfield 13956ed7257bSPatrick Caulfield 13966ed7257bSPatrick Caulfield static struct writequeue_entry *new_writequeue_entry(struct connection *con, 13976ed7257bSPatrick Caulfield gfp_t allocation) 13986ed7257bSPatrick Caulfield { 13996ed7257bSPatrick Caulfield struct writequeue_entry *entry; 14006ed7257bSPatrick Caulfield 14016ed7257bSPatrick Caulfield entry = kmalloc(sizeof(struct writequeue_entry), allocation); 14026ed7257bSPatrick Caulfield if (!entry) 14036ed7257bSPatrick Caulfield return NULL; 14046ed7257bSPatrick Caulfield 14056ed7257bSPatrick Caulfield entry->page = alloc_page(allocation); 14066ed7257bSPatrick Caulfield if (!entry->page) { 14076ed7257bSPatrick Caulfield kfree(entry); 14086ed7257bSPatrick Caulfield return NULL; 14096ed7257bSPatrick Caulfield } 14106ed7257bSPatrick Caulfield 14116ed7257bSPatrick Caulfield entry->offset = 0; 14126ed7257bSPatrick Caulfield entry->len = 0; 14136ed7257bSPatrick Caulfield entry->end = 0; 14146ed7257bSPatrick Caulfield entry->users = 0; 14156ed7257bSPatrick Caulfield entry->con = con; 14166ed7257bSPatrick Caulfield 14176ed7257bSPatrick Caulfield return entry; 14186ed7257bSPatrick Caulfield } 14196ed7257bSPatrick Caulfield 1420617e82e1SDavid Teigland void *dlm_lowcomms_get_buffer(int nodeid, int len, gfp_t allocation, char **ppc) 14216ed7257bSPatrick Caulfield { 14226ed7257bSPatrick Caulfield struct connection *con; 14236ed7257bSPatrick Caulfield struct writequeue_entry *e; 14246ed7257bSPatrick Caulfield int offset = 0; 14256ed7257bSPatrick Caulfield 14266ed7257bSPatrick Caulfield con = nodeid2con(nodeid, allocation); 14276ed7257bSPatrick Caulfield if (!con) 14286ed7257bSPatrick Caulfield return NULL; 14296ed7257bSPatrick Caulfield 14306ed7257bSPatrick Caulfield spin_lock(&con->writequeue_lock); 14316ed7257bSPatrick Caulfield e = list_entry(con->writequeue.prev, struct writequeue_entry, list); 14326ed7257bSPatrick Caulfield if ((&e->list == &con->writequeue) || 14336ed7257bSPatrick Caulfield (PAGE_CACHE_SIZE - e->end < len)) { 14346ed7257bSPatrick Caulfield e = NULL; 14356ed7257bSPatrick Caulfield } else { 14366ed7257bSPatrick Caulfield offset = e->end; 14376ed7257bSPatrick Caulfield e->end += len; 1438eeee2b5fSWei Yongjun e->users++; 14396ed7257bSPatrick Caulfield } 14406ed7257bSPatrick Caulfield spin_unlock(&con->writequeue_lock); 14416ed7257bSPatrick Caulfield 14426ed7257bSPatrick Caulfield if (e) { 14436ed7257bSPatrick Caulfield got_one: 14446ed7257bSPatrick Caulfield *ppc = page_address(e->page) + offset; 14456ed7257bSPatrick Caulfield return e; 14466ed7257bSPatrick Caulfield } 14476ed7257bSPatrick Caulfield 14486ed7257bSPatrick Caulfield e = new_writequeue_entry(con, allocation); 14496ed7257bSPatrick Caulfield if (e) { 14506ed7257bSPatrick Caulfield spin_lock(&con->writequeue_lock); 14516ed7257bSPatrick Caulfield offset = e->end; 14526ed7257bSPatrick Caulfield e->end += len; 1453eeee2b5fSWei Yongjun e->users++; 14546ed7257bSPatrick Caulfield list_add_tail(&e->list, &con->writequeue); 14556ed7257bSPatrick Caulfield spin_unlock(&con->writequeue_lock); 14566ed7257bSPatrick Caulfield goto got_one; 14576ed7257bSPatrick Caulfield } 14586ed7257bSPatrick Caulfield return NULL; 14596ed7257bSPatrick Caulfield } 14606ed7257bSPatrick Caulfield 14616ed7257bSPatrick Caulfield void dlm_lowcomms_commit_buffer(void *mh) 14626ed7257bSPatrick Caulfield { 14636ed7257bSPatrick Caulfield struct writequeue_entry *e = (struct writequeue_entry *)mh; 14646ed7257bSPatrick Caulfield struct connection *con = e->con; 14656ed7257bSPatrick Caulfield int users; 14666ed7257bSPatrick Caulfield 14676ed7257bSPatrick Caulfield spin_lock(&con->writequeue_lock); 14686ed7257bSPatrick Caulfield users = --e->users; 14696ed7257bSPatrick Caulfield if (users) 14706ed7257bSPatrick Caulfield goto out; 14716ed7257bSPatrick Caulfield e->len = e->end - e->offset; 14726ed7257bSPatrick Caulfield spin_unlock(&con->writequeue_lock); 14736ed7257bSPatrick Caulfield 14746ed7257bSPatrick Caulfield if (!test_and_set_bit(CF_WRITE_PENDING, &con->flags)) { 14756ed7257bSPatrick Caulfield queue_work(send_workqueue, &con->swork); 14766ed7257bSPatrick Caulfield } 14776ed7257bSPatrick Caulfield return; 14786ed7257bSPatrick Caulfield 14796ed7257bSPatrick Caulfield out: 14806ed7257bSPatrick Caulfield spin_unlock(&con->writequeue_lock); 14816ed7257bSPatrick Caulfield return; 14826ed7257bSPatrick Caulfield } 14836ed7257bSPatrick Caulfield 14846ed7257bSPatrick Caulfield /* Send a message */ 14856ed7257bSPatrick Caulfield static void send_to_sock(struct connection *con) 14866ed7257bSPatrick Caulfield { 14876ed7257bSPatrick Caulfield int ret = 0; 14886ed7257bSPatrick Caulfield const int msg_flags = MSG_DONTWAIT | MSG_NOSIGNAL; 14896ed7257bSPatrick Caulfield struct writequeue_entry *e; 14906ed7257bSPatrick Caulfield int len, offset; 1491f92c8dd7SBob Peterson int count = 0; 14926ed7257bSPatrick Caulfield 14936ed7257bSPatrick Caulfield mutex_lock(&con->sock_mutex); 14946ed7257bSPatrick Caulfield if (con->sock == NULL) 14956ed7257bSPatrick Caulfield goto out_connect; 14966ed7257bSPatrick Caulfield 14976ed7257bSPatrick Caulfield spin_lock(&con->writequeue_lock); 14986ed7257bSPatrick Caulfield for (;;) { 14996ed7257bSPatrick Caulfield e = list_entry(con->writequeue.next, struct writequeue_entry, 15006ed7257bSPatrick Caulfield list); 15016ed7257bSPatrick Caulfield if ((struct list_head *) e == &con->writequeue) 15026ed7257bSPatrick Caulfield break; 15036ed7257bSPatrick Caulfield 15046ed7257bSPatrick Caulfield len = e->len; 15056ed7257bSPatrick Caulfield offset = e->offset; 15066ed7257bSPatrick Caulfield BUG_ON(len == 0 && e->users == 0); 15076ed7257bSPatrick Caulfield spin_unlock(&con->writequeue_lock); 15086ed7257bSPatrick Caulfield 15096ed7257bSPatrick Caulfield ret = 0; 15106ed7257bSPatrick Caulfield if (len) { 15111329e3f2SPaolo Bonzini ret = kernel_sendpage(con->sock, e->page, offset, len, 15126ed7257bSPatrick Caulfield msg_flags); 1513d66f8277SPatrick Caulfield if (ret == -EAGAIN || ret == 0) { 1514b36930ddSDavid Miller if (ret == -EAGAIN && 1515b36930ddSDavid Miller test_bit(SOCK_ASYNC_NOSPACE, &con->sock->flags) && 1516b36930ddSDavid Miller !test_and_set_bit(CF_APP_LIMITED, &con->flags)) { 1517b36930ddSDavid Miller /* Notify TCP that we're limited by the 1518b36930ddSDavid Miller * application window size. 1519b36930ddSDavid Miller */ 1520b36930ddSDavid Miller set_bit(SOCK_NOSPACE, &con->sock->flags); 1521b36930ddSDavid Miller con->sock->sk->sk_write_pending++; 1522b36930ddSDavid Miller } 1523d66f8277SPatrick Caulfield cond_resched(); 15246ed7257bSPatrick Caulfield goto out; 15259c5bef58SYing Xue } else if (ret < 0) 15266ed7257bSPatrick Caulfield goto send_error; 1527d66f8277SPatrick Caulfield } 1528f92c8dd7SBob Peterson 15296ed7257bSPatrick Caulfield /* Don't starve people filling buffers */ 1530f92c8dd7SBob Peterson if (++count >= MAX_SEND_MSG_COUNT) { 15316ed7257bSPatrick Caulfield cond_resched(); 1532f92c8dd7SBob Peterson count = 0; 1533f92c8dd7SBob Peterson } 15346ed7257bSPatrick Caulfield 15356ed7257bSPatrick Caulfield spin_lock(&con->writequeue_lock); 15366ed7257bSPatrick Caulfield e->offset += ret; 15376ed7257bSPatrick Caulfield e->len -= ret; 15386ed7257bSPatrick Caulfield 15396ed7257bSPatrick Caulfield if (e->len == 0 && e->users == 0) { 15406ed7257bSPatrick Caulfield list_del(&e->list); 15416ed7257bSPatrick Caulfield free_entry(e); 15426ed7257bSPatrick Caulfield } 15436ed7257bSPatrick Caulfield } 15446ed7257bSPatrick Caulfield spin_unlock(&con->writequeue_lock); 15456ed7257bSPatrick Caulfield out: 15466ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 15476ed7257bSPatrick Caulfield return; 15486ed7257bSPatrick Caulfield 15496ed7257bSPatrick Caulfield send_error: 15506ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 15516ed7257bSPatrick Caulfield close_connection(con, false); 15526ed7257bSPatrick Caulfield lowcomms_connect_sock(con); 15536ed7257bSPatrick Caulfield return; 15546ed7257bSPatrick Caulfield 15556ed7257bSPatrick Caulfield out_connect: 15566ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 15576ed7257bSPatrick Caulfield if (!test_bit(CF_INIT_PENDING, &con->flags)) 15586ed7257bSPatrick Caulfield lowcomms_connect_sock(con); 15596ed7257bSPatrick Caulfield } 15606ed7257bSPatrick Caulfield 15616ed7257bSPatrick Caulfield static void clean_one_writequeue(struct connection *con) 15626ed7257bSPatrick Caulfield { 15635e9ccc37SChristine Caulfield struct writequeue_entry *e, *safe; 15646ed7257bSPatrick Caulfield 15656ed7257bSPatrick Caulfield spin_lock(&con->writequeue_lock); 15665e9ccc37SChristine Caulfield list_for_each_entry_safe(e, safe, &con->writequeue, list) { 15676ed7257bSPatrick Caulfield list_del(&e->list); 15686ed7257bSPatrick Caulfield free_entry(e); 15696ed7257bSPatrick Caulfield } 15706ed7257bSPatrick Caulfield spin_unlock(&con->writequeue_lock); 15716ed7257bSPatrick Caulfield } 15726ed7257bSPatrick Caulfield 15736ed7257bSPatrick Caulfield /* Called from recovery when it knows that a node has 15746ed7257bSPatrick Caulfield left the cluster */ 15756ed7257bSPatrick Caulfield int dlm_lowcomms_close(int nodeid) 15766ed7257bSPatrick Caulfield { 15776ed7257bSPatrick Caulfield struct connection *con; 157836b71a8bSDavid Teigland struct dlm_node_addr *na; 15796ed7257bSPatrick Caulfield 15806ed7257bSPatrick Caulfield log_print("closing connection to node %d", nodeid); 15816ed7257bSPatrick Caulfield con = nodeid2con(nodeid, 0); 15826ed7257bSPatrick Caulfield if (con) { 1583063c4c99SLars Marowsky-Bree clear_bit(CF_CONNECT_PENDING, &con->flags); 1584063c4c99SLars Marowsky-Bree clear_bit(CF_WRITE_PENDING, &con->flags); 1585063c4c99SLars Marowsky-Bree set_bit(CF_CLOSE, &con->flags); 1586063c4c99SLars Marowsky-Bree if (cancel_work_sync(&con->swork)) 1587063c4c99SLars Marowsky-Bree log_print("canceled swork for node %d", nodeid); 1588063c4c99SLars Marowsky-Bree if (cancel_work_sync(&con->rwork)) 1589063c4c99SLars Marowsky-Bree log_print("canceled rwork for node %d", nodeid); 15906ed7257bSPatrick Caulfield clean_one_writequeue(con); 15916ed7257bSPatrick Caulfield close_connection(con, true); 15926ed7257bSPatrick Caulfield } 159336b71a8bSDavid Teigland 159436b71a8bSDavid Teigland spin_lock(&dlm_node_addrs_spin); 159536b71a8bSDavid Teigland na = find_node_addr(nodeid); 159636b71a8bSDavid Teigland if (na) { 159736b71a8bSDavid Teigland list_del(&na->list); 159836b71a8bSDavid Teigland while (na->addr_count--) 159936b71a8bSDavid Teigland kfree(na->addr[na->addr_count]); 160036b71a8bSDavid Teigland kfree(na); 160136b71a8bSDavid Teigland } 160236b71a8bSDavid Teigland spin_unlock(&dlm_node_addrs_spin); 160336b71a8bSDavid Teigland 16046ed7257bSPatrick Caulfield return 0; 16056ed7257bSPatrick Caulfield } 16066ed7257bSPatrick Caulfield 16076ed7257bSPatrick Caulfield /* Receive workqueue function */ 16086ed7257bSPatrick Caulfield static void process_recv_sockets(struct work_struct *work) 16096ed7257bSPatrick Caulfield { 16106ed7257bSPatrick Caulfield struct connection *con = container_of(work, struct connection, rwork); 16116ed7257bSPatrick Caulfield int err; 16126ed7257bSPatrick Caulfield 16136ed7257bSPatrick Caulfield clear_bit(CF_READ_PENDING, &con->flags); 16146ed7257bSPatrick Caulfield do { 16156ed7257bSPatrick Caulfield err = con->rx_action(con); 16166ed7257bSPatrick Caulfield } while (!err); 16176ed7257bSPatrick Caulfield } 16186ed7257bSPatrick Caulfield 16196ed7257bSPatrick Caulfield /* Send workqueue function */ 16206ed7257bSPatrick Caulfield static void process_send_sockets(struct work_struct *work) 16216ed7257bSPatrick Caulfield { 16226ed7257bSPatrick Caulfield struct connection *con = container_of(work, struct connection, swork); 16236ed7257bSPatrick Caulfield 16246ed7257bSPatrick Caulfield if (test_and_clear_bit(CF_CONNECT_PENDING, &con->flags)) { 16256ed7257bSPatrick Caulfield con->connect_action(con); 1626063c4c99SLars Marowsky-Bree set_bit(CF_WRITE_PENDING, &con->flags); 16276ed7257bSPatrick Caulfield } 1628063c4c99SLars Marowsky-Bree if (test_and_clear_bit(CF_WRITE_PENDING, &con->flags)) 16296ed7257bSPatrick Caulfield send_to_sock(con); 16306ed7257bSPatrick Caulfield } 16316ed7257bSPatrick Caulfield 16326ed7257bSPatrick Caulfield 16336ed7257bSPatrick Caulfield /* Discard all entries on the write queues */ 16346ed7257bSPatrick Caulfield static void clean_writequeues(void) 16356ed7257bSPatrick Caulfield { 16365e9ccc37SChristine Caulfield foreach_conn(clean_one_writequeue); 16376ed7257bSPatrick Caulfield } 16386ed7257bSPatrick Caulfield 16396ed7257bSPatrick Caulfield static void work_stop(void) 16406ed7257bSPatrick Caulfield { 16416ed7257bSPatrick Caulfield destroy_workqueue(recv_workqueue); 16426ed7257bSPatrick Caulfield destroy_workqueue(send_workqueue); 16436ed7257bSPatrick Caulfield } 16446ed7257bSPatrick Caulfield 16456ed7257bSPatrick Caulfield static int work_start(void) 16466ed7257bSPatrick Caulfield { 1647e43f055aSDavid Teigland recv_workqueue = alloc_workqueue("dlm_recv", 1648e43f055aSDavid Teigland WQ_UNBOUND | WQ_MEM_RECLAIM, 1); 1649b9d41052SNamhyung Kim if (!recv_workqueue) { 1650b9d41052SNamhyung Kim log_print("can't start dlm_recv"); 1651b9d41052SNamhyung Kim return -ENOMEM; 16526ed7257bSPatrick Caulfield } 16536ed7257bSPatrick Caulfield 1654e43f055aSDavid Teigland send_workqueue = alloc_workqueue("dlm_send", 1655e43f055aSDavid Teigland WQ_UNBOUND | WQ_MEM_RECLAIM, 1); 1656b9d41052SNamhyung Kim if (!send_workqueue) { 1657b9d41052SNamhyung Kim log_print("can't start dlm_send"); 16586ed7257bSPatrick Caulfield destroy_workqueue(recv_workqueue); 1659b9d41052SNamhyung Kim return -ENOMEM; 16606ed7257bSPatrick Caulfield } 16616ed7257bSPatrick Caulfield 16626ed7257bSPatrick Caulfield return 0; 16636ed7257bSPatrick Caulfield } 16646ed7257bSPatrick Caulfield 16655e9ccc37SChristine Caulfield static void stop_conn(struct connection *con) 16666ed7257bSPatrick Caulfield { 16679e5f2825SPatrick Caulfield con->flags |= 0x0F; 1668391fbdc5SChristine Caulfield if (con->sock && con->sock->sk) 1669afb853fbSPatrick Caulfield con->sock->sk->sk_user_data = NULL; 1670afb853fbSPatrick Caulfield } 16715e9ccc37SChristine Caulfield 16725e9ccc37SChristine Caulfield static void free_conn(struct connection *con) 16735e9ccc37SChristine Caulfield { 16745e9ccc37SChristine Caulfield close_connection(con, true); 16755e9ccc37SChristine Caulfield if (con->othercon) 16765e9ccc37SChristine Caulfield kmem_cache_free(con_cache, con->othercon); 16775e9ccc37SChristine Caulfield hlist_del(&con->list); 16785e9ccc37SChristine Caulfield kmem_cache_free(con_cache, con); 16796ed7257bSPatrick Caulfield } 16805e9ccc37SChristine Caulfield 16815e9ccc37SChristine Caulfield void dlm_lowcomms_stop(void) 16825e9ccc37SChristine Caulfield { 16835e9ccc37SChristine Caulfield /* Set all the flags to prevent any 16845e9ccc37SChristine Caulfield socket activity. 16855e9ccc37SChristine Caulfield */ 16865e9ccc37SChristine Caulfield mutex_lock(&connections_lock); 1687513ef596SDavid Teigland dlm_allow_conn = 0; 16885e9ccc37SChristine Caulfield foreach_conn(stop_conn); 16897a936ce7SMatthias Kaehlcke mutex_unlock(&connections_lock); 16906ed7257bSPatrick Caulfield 16916ed7257bSPatrick Caulfield work_stop(); 16926ed7257bSPatrick Caulfield 16937a936ce7SMatthias Kaehlcke mutex_lock(&connections_lock); 16946ed7257bSPatrick Caulfield clean_writequeues(); 16956ed7257bSPatrick Caulfield 16965e9ccc37SChristine Caulfield foreach_conn(free_conn); 16975e9ccc37SChristine Caulfield 16987a936ce7SMatthias Kaehlcke mutex_unlock(&connections_lock); 16996ed7257bSPatrick Caulfield kmem_cache_destroy(con_cache); 17006ed7257bSPatrick Caulfield } 17016ed7257bSPatrick Caulfield 17026ed7257bSPatrick Caulfield int dlm_lowcomms_start(void) 17036ed7257bSPatrick Caulfield { 17046ed7257bSPatrick Caulfield int error = -EINVAL; 17056ed7257bSPatrick Caulfield struct connection *con; 17065e9ccc37SChristine Caulfield int i; 17075e9ccc37SChristine Caulfield 17085e9ccc37SChristine Caulfield for (i = 0; i < CONN_HASH_SIZE; i++) 17095e9ccc37SChristine Caulfield INIT_HLIST_HEAD(&connection_hash[i]); 17106ed7257bSPatrick Caulfield 17116ed7257bSPatrick Caulfield init_local(); 17126ed7257bSPatrick Caulfield if (!dlm_local_count) { 1713617e82e1SDavid Teigland error = -ENOTCONN; 17146ed7257bSPatrick Caulfield log_print("no local IP address has been set"); 1715513ef596SDavid Teigland goto fail; 17166ed7257bSPatrick Caulfield } 17176ed7257bSPatrick Caulfield 17186ed7257bSPatrick Caulfield error = -ENOMEM; 17196ed7257bSPatrick Caulfield con_cache = kmem_cache_create("dlm_conn", sizeof(struct connection), 17206ed7257bSPatrick Caulfield __alignof__(struct connection), 0, 172120c2df83SPaul Mundt NULL); 17226ed7257bSPatrick Caulfield if (!con_cache) 1723513ef596SDavid Teigland goto fail; 1724513ef596SDavid Teigland 1725513ef596SDavid Teigland error = work_start(); 1726513ef596SDavid Teigland if (error) 1727513ef596SDavid Teigland goto fail_destroy; 1728513ef596SDavid Teigland 1729513ef596SDavid Teigland dlm_allow_conn = 1; 17306ed7257bSPatrick Caulfield 17316ed7257bSPatrick Caulfield /* Start listening */ 17326ed7257bSPatrick Caulfield if (dlm_config.ci_protocol == 0) 17336ed7257bSPatrick Caulfield error = tcp_listen_for_all(); 17346ed7257bSPatrick Caulfield else 17356ed7257bSPatrick Caulfield error = sctp_listen_for_all(); 17366ed7257bSPatrick Caulfield if (error) 17376ed7257bSPatrick Caulfield goto fail_unlisten; 17386ed7257bSPatrick Caulfield 17396ed7257bSPatrick Caulfield return 0; 17406ed7257bSPatrick Caulfield 17416ed7257bSPatrick Caulfield fail_unlisten: 1742513ef596SDavid Teigland dlm_allow_conn = 0; 17436ed7257bSPatrick Caulfield con = nodeid2con(0,0); 17446ed7257bSPatrick Caulfield if (con) { 17456ed7257bSPatrick Caulfield close_connection(con, false); 17466ed7257bSPatrick Caulfield kmem_cache_free(con_cache, con); 17476ed7257bSPatrick Caulfield } 1748513ef596SDavid Teigland fail_destroy: 17496ed7257bSPatrick Caulfield kmem_cache_destroy(con_cache); 1750513ef596SDavid Teigland fail: 17516ed7257bSPatrick Caulfield return error; 17526ed7257bSPatrick Caulfield } 175336b71a8bSDavid Teigland 175436b71a8bSDavid Teigland void dlm_lowcomms_exit(void) 175536b71a8bSDavid Teigland { 175636b71a8bSDavid Teigland struct dlm_node_addr *na, *safe; 175736b71a8bSDavid Teigland 175836b71a8bSDavid Teigland spin_lock(&dlm_node_addrs_spin); 175936b71a8bSDavid Teigland list_for_each_entry_safe(na, safe, &dlm_node_addrs, list) { 176036b71a8bSDavid Teigland list_del(&na->list); 176136b71a8bSDavid Teigland while (na->addr_count--) 176236b71a8bSDavid Teigland kfree(na->addr[na->addr_count]); 176336b71a8bSDavid Teigland kfree(na); 176436b71a8bSDavid Teigland } 176536b71a8bSDavid Teigland spin_unlock(&dlm_node_addrs_spin); 176636b71a8bSDavid Teigland } 1767