12522fe45SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-only 26ed7257bSPatrick Caulfield /****************************************************************************** 36ed7257bSPatrick Caulfield ******************************************************************************* 46ed7257bSPatrick Caulfield ** 56ed7257bSPatrick Caulfield ** Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved. 65e9ccc37SChristine Caulfield ** Copyright (C) 2004-2009 Red Hat, Inc. All rights reserved. 76ed7257bSPatrick Caulfield ** 86ed7257bSPatrick Caulfield ** 96ed7257bSPatrick Caulfield ******************************************************************************* 106ed7257bSPatrick Caulfield ******************************************************************************/ 116ed7257bSPatrick Caulfield 126ed7257bSPatrick Caulfield /* 136ed7257bSPatrick Caulfield * lowcomms.c 146ed7257bSPatrick Caulfield * 156ed7257bSPatrick Caulfield * This is the "low-level" comms layer. 166ed7257bSPatrick Caulfield * 176ed7257bSPatrick Caulfield * It is responsible for sending/receiving messages 186ed7257bSPatrick Caulfield * from other nodes in the cluster. 196ed7257bSPatrick Caulfield * 206ed7257bSPatrick Caulfield * Cluster nodes are referred to by their nodeids. nodeids are 216ed7257bSPatrick Caulfield * simply 32 bit numbers to the locking module - if they need to 222cf12c0bSJoe Perches * be expanded for the cluster infrastructure then that is its 236ed7257bSPatrick Caulfield * responsibility. It is this layer's 246ed7257bSPatrick Caulfield * responsibility to resolve these into IP address or 256ed7257bSPatrick Caulfield * whatever it needs for inter-node communication. 266ed7257bSPatrick Caulfield * 276ed7257bSPatrick Caulfield * The comms level is two kernel threads that deal mainly with 286ed7257bSPatrick Caulfield * the receiving of messages from other nodes and passing them 296ed7257bSPatrick Caulfield * up to the mid-level comms layer (which understands the 306ed7257bSPatrick Caulfield * message format) for execution by the locking core, and 316ed7257bSPatrick Caulfield * a send thread which does all the setting up of connections 326ed7257bSPatrick Caulfield * to remote nodes and the sending of data. Threads are not allowed 336ed7257bSPatrick Caulfield * to send their own data because it may cause them to wait in times 346ed7257bSPatrick Caulfield * of high load. Also, this way, the sending thread can collect together 356ed7257bSPatrick Caulfield * messages bound for one node and send them in one block. 366ed7257bSPatrick Caulfield * 372cf12c0bSJoe Perches * lowcomms will choose to use either TCP or SCTP as its transport layer 386ed7257bSPatrick Caulfield * depending on the configuration variable 'protocol'. This should be set 396ed7257bSPatrick Caulfield * to 0 (default) for TCP or 1 for SCTP. It should be configured using a 406ed7257bSPatrick Caulfield * cluster-wide mechanism as it must be the same on all nodes of the cluster 416ed7257bSPatrick Caulfield * for the DLM to function. 426ed7257bSPatrick Caulfield * 436ed7257bSPatrick Caulfield */ 446ed7257bSPatrick Caulfield 456ed7257bSPatrick Caulfield #include <asm/ioctls.h> 466ed7257bSPatrick Caulfield #include <net/sock.h> 476ed7257bSPatrick Caulfield #include <net/tcp.h> 486ed7257bSPatrick Caulfield #include <linux/pagemap.h> 496ed7257bSPatrick Caulfield #include <linux/file.h> 507a936ce7SMatthias Kaehlcke #include <linux/mutex.h> 516ed7257bSPatrick Caulfield #include <linux/sctp.h> 525a0e3ad6STejun Heo #include <linux/slab.h> 532f2d76ccSBenjamin Poirier #include <net/sctp/sctp.h> 5444ad532bSJoe Perches #include <net/ipv6.h> 556ed7257bSPatrick Caulfield 566ed7257bSPatrick Caulfield #include "dlm_internal.h" 576ed7257bSPatrick Caulfield #include "lowcomms.h" 586ed7257bSPatrick Caulfield #include "midcomms.h" 596ed7257bSPatrick Caulfield #include "config.h" 606ed7257bSPatrick Caulfield 616ed7257bSPatrick Caulfield #define NEEDED_RMEM (4*1024*1024) 625e9ccc37SChristine Caulfield #define CONN_HASH_SIZE 32 636ed7257bSPatrick Caulfield 64f92c8dd7SBob Peterson /* Number of messages to send before rescheduling */ 65f92c8dd7SBob Peterson #define MAX_SEND_MSG_COUNT 25 66055923bfSAlexander Aring #define DLM_SHUTDOWN_WAIT_TIMEOUT msecs_to_jiffies(10000) 67f92c8dd7SBob Peterson 686ed7257bSPatrick Caulfield struct connection { 696ed7257bSPatrick Caulfield struct socket *sock; /* NULL if not connected */ 706ed7257bSPatrick Caulfield uint32_t nodeid; /* So we know who we are in the list */ 716ed7257bSPatrick Caulfield struct mutex sock_mutex; 726ed7257bSPatrick Caulfield unsigned long flags; 736ed7257bSPatrick Caulfield #define CF_READ_PENDING 1 748a4abb08Stsutomu.owa@toshiba.co.jp #define CF_WRITE_PENDING 2 756ed7257bSPatrick Caulfield #define CF_INIT_PENDING 4 766ed7257bSPatrick Caulfield #define CF_IS_OTHERCON 5 77063c4c99SLars Marowsky-Bree #define CF_CLOSE 6 78b36930ddSDavid Miller #define CF_APP_LIMITED 7 79b2a66629Stsutomu.owa@toshiba.co.jp #define CF_CLOSING 8 80055923bfSAlexander Aring #define CF_SHUTDOWN 9 816ed7257bSPatrick Caulfield struct list_head writequeue; /* List of outgoing writequeue_entries */ 826ed7257bSPatrick Caulfield spinlock_t writequeue_lock; 836ed7257bSPatrick Caulfield int (*rx_action) (struct connection *); /* What to do when active */ 846ed7257bSPatrick Caulfield void (*connect_action) (struct connection *); /* What to do to connect */ 85055923bfSAlexander Aring void (*shutdown_action)(struct connection *con); /* What to do to shutdown */ 866ed7257bSPatrick Caulfield int retries; 876ed7257bSPatrick Caulfield #define MAX_CONNECT_RETRIES 3 885e9ccc37SChristine Caulfield struct hlist_node list; 896ed7257bSPatrick Caulfield struct connection *othercon; 906ed7257bSPatrick Caulfield struct work_struct rwork; /* Receive workqueue */ 916ed7257bSPatrick Caulfield struct work_struct swork; /* Send workqueue */ 92055923bfSAlexander Aring wait_queue_head_t shutdown_wait; /* wait for graceful shutdown */ 934798cbbfSAlexander Aring unsigned char *rx_buf; 944798cbbfSAlexander Aring int rx_buflen; 954798cbbfSAlexander Aring int rx_leftover; 96a47666ebSAlexander Aring struct rcu_head rcu; 976ed7257bSPatrick Caulfield }; 986ed7257bSPatrick Caulfield #define sock2con(x) ((struct connection *)(x)->sk_user_data) 996ed7257bSPatrick Caulfield 1006ed7257bSPatrick Caulfield /* An entry waiting to be sent */ 1016ed7257bSPatrick Caulfield struct writequeue_entry { 1026ed7257bSPatrick Caulfield struct list_head list; 1036ed7257bSPatrick Caulfield struct page *page; 1046ed7257bSPatrick Caulfield int offset; 1056ed7257bSPatrick Caulfield int len; 1066ed7257bSPatrick Caulfield int end; 1076ed7257bSPatrick Caulfield int users; 1086ed7257bSPatrick Caulfield struct connection *con; 1096ed7257bSPatrick Caulfield }; 1106ed7257bSPatrick Caulfield 11136b71a8bSDavid Teigland struct dlm_node_addr { 11236b71a8bSDavid Teigland struct list_head list; 11336b71a8bSDavid Teigland int nodeid; 11436b71a8bSDavid Teigland int addr_count; 11598e1b60eSMike Christie int curr_addr_index; 11636b71a8bSDavid Teigland struct sockaddr_storage *addr[DLM_MAX_ADDR_COUNT]; 11736b71a8bSDavid Teigland }; 11836b71a8bSDavid Teigland 119cc661fc9SBob Peterson static struct listen_sock_callbacks { 120cc661fc9SBob Peterson void (*sk_error_report)(struct sock *); 121cc661fc9SBob Peterson void (*sk_data_ready)(struct sock *); 122cc661fc9SBob Peterson void (*sk_state_change)(struct sock *); 123cc661fc9SBob Peterson void (*sk_write_space)(struct sock *); 124cc661fc9SBob Peterson } listen_sock; 125cc661fc9SBob Peterson 12636b71a8bSDavid Teigland static LIST_HEAD(dlm_node_addrs); 12736b71a8bSDavid Teigland static DEFINE_SPINLOCK(dlm_node_addrs_spin); 12836b71a8bSDavid Teigland 1296ed7257bSPatrick Caulfield static struct sockaddr_storage *dlm_local_addr[DLM_MAX_ADDR_COUNT]; 1306ed7257bSPatrick Caulfield static int dlm_local_count; 131513ef596SDavid Teigland static int dlm_allow_conn; 1326ed7257bSPatrick Caulfield 1336ed7257bSPatrick Caulfield /* Work queues */ 1346ed7257bSPatrick Caulfield static struct workqueue_struct *recv_workqueue; 1356ed7257bSPatrick Caulfield static struct workqueue_struct *send_workqueue; 1366ed7257bSPatrick Caulfield 1375e9ccc37SChristine Caulfield static struct hlist_head connection_hash[CONN_HASH_SIZE]; 138a47666ebSAlexander Aring static DEFINE_SPINLOCK(connections_lock); 139a47666ebSAlexander Aring DEFINE_STATIC_SRCU(connections_srcu); 1406ed7257bSPatrick Caulfield 1416ed7257bSPatrick Caulfield static void process_recv_sockets(struct work_struct *work); 1426ed7257bSPatrick Caulfield static void process_send_sockets(struct work_struct *work); 1436ed7257bSPatrick Caulfield 1445e9ccc37SChristine Caulfield 1455e9ccc37SChristine Caulfield /* This is deliberately very simple because most clusters have simple 1465e9ccc37SChristine Caulfield sequential nodeids, so we should be able to go straight to a connection 1475e9ccc37SChristine Caulfield struct in the array */ 1485e9ccc37SChristine Caulfield static inline int nodeid_hash(int nodeid) 1495e9ccc37SChristine Caulfield { 1505e9ccc37SChristine Caulfield return nodeid & (CONN_HASH_SIZE-1); 1515e9ccc37SChristine Caulfield } 1525e9ccc37SChristine Caulfield 1535e9ccc37SChristine Caulfield static struct connection *__find_con(int nodeid) 1545e9ccc37SChristine Caulfield { 155a47666ebSAlexander Aring int r, idx; 1565e9ccc37SChristine Caulfield struct connection *con; 1575e9ccc37SChristine Caulfield 1585e9ccc37SChristine Caulfield r = nodeid_hash(nodeid); 1595e9ccc37SChristine Caulfield 160a47666ebSAlexander Aring idx = srcu_read_lock(&connections_srcu); 161a47666ebSAlexander Aring hlist_for_each_entry_rcu(con, &connection_hash[r], list) { 162a47666ebSAlexander Aring if (con->nodeid == nodeid) { 163a47666ebSAlexander Aring srcu_read_unlock(&connections_srcu, idx); 1645e9ccc37SChristine Caulfield return con; 1655e9ccc37SChristine Caulfield } 166a47666ebSAlexander Aring } 167a47666ebSAlexander Aring srcu_read_unlock(&connections_srcu, idx); 168a47666ebSAlexander Aring 1695e9ccc37SChristine Caulfield return NULL; 1705e9ccc37SChristine Caulfield } 1715e9ccc37SChristine Caulfield 1726ed7257bSPatrick Caulfield /* 1736ed7257bSPatrick Caulfield * If 'allocation' is zero then we don't attempt to create a new 1746ed7257bSPatrick Caulfield * connection structure for this node. 1756ed7257bSPatrick Caulfield */ 176a47666ebSAlexander Aring static struct connection *nodeid2con(int nodeid, gfp_t alloc) 1776ed7257bSPatrick Caulfield { 1784f2b30fdSAlexander Aring struct connection *con, *tmp; 1796ed7257bSPatrick Caulfield int r; 1806ed7257bSPatrick Caulfield 1815e9ccc37SChristine Caulfield con = __find_con(nodeid); 1826ed7257bSPatrick Caulfield if (con || !alloc) 1836ed7257bSPatrick Caulfield return con; 1846ed7257bSPatrick Caulfield 185a47666ebSAlexander Aring con = kzalloc(sizeof(*con), alloc); 1866ed7257bSPatrick Caulfield if (!con) 1876ed7257bSPatrick Caulfield return NULL; 1886ed7257bSPatrick Caulfield 1894798cbbfSAlexander Aring con->rx_buflen = dlm_config.ci_buffer_size; 1904798cbbfSAlexander Aring con->rx_buf = kmalloc(con->rx_buflen, GFP_NOFS); 1914798cbbfSAlexander Aring if (!con->rx_buf) { 1924798cbbfSAlexander Aring kfree(con); 1934798cbbfSAlexander Aring return NULL; 1944798cbbfSAlexander Aring } 1954798cbbfSAlexander Aring 1966ed7257bSPatrick Caulfield con->nodeid = nodeid; 1976ed7257bSPatrick Caulfield mutex_init(&con->sock_mutex); 1986ed7257bSPatrick Caulfield INIT_LIST_HEAD(&con->writequeue); 1996ed7257bSPatrick Caulfield spin_lock_init(&con->writequeue_lock); 2006ed7257bSPatrick Caulfield INIT_WORK(&con->swork, process_send_sockets); 2016ed7257bSPatrick Caulfield INIT_WORK(&con->rwork, process_recv_sockets); 202055923bfSAlexander Aring init_waitqueue_head(&con->shutdown_wait); 2036ed7257bSPatrick Caulfield 2046ed7257bSPatrick Caulfield /* Setup action pointers for child sockets */ 2056ed7257bSPatrick Caulfield if (con->nodeid) { 2065e9ccc37SChristine Caulfield struct connection *zerocon = __find_con(0); 2076ed7257bSPatrick Caulfield 2086ed7257bSPatrick Caulfield con->connect_action = zerocon->connect_action; 2096ed7257bSPatrick Caulfield if (!con->rx_action) 2106ed7257bSPatrick Caulfield con->rx_action = zerocon->rx_action; 2116ed7257bSPatrick Caulfield } 2126ed7257bSPatrick Caulfield 213a47666ebSAlexander Aring r = nodeid_hash(nodeid); 214a47666ebSAlexander Aring 215a47666ebSAlexander Aring spin_lock(&connections_lock); 2164f2b30fdSAlexander Aring /* Because multiple workqueues/threads calls this function it can 2174f2b30fdSAlexander Aring * race on multiple cpu's. Instead of locking hot path __find_con() 2184f2b30fdSAlexander Aring * we just check in rare cases of recently added nodes again 2194f2b30fdSAlexander Aring * under protection of connections_lock. If this is the case we 2204f2b30fdSAlexander Aring * abort our connection creation and return the existing connection. 2214f2b30fdSAlexander Aring */ 2224f2b30fdSAlexander Aring tmp = __find_con(nodeid); 2234f2b30fdSAlexander Aring if (tmp) { 2244f2b30fdSAlexander Aring spin_unlock(&connections_lock); 2254f2b30fdSAlexander Aring kfree(con->rx_buf); 2264f2b30fdSAlexander Aring kfree(con); 2274f2b30fdSAlexander Aring return tmp; 2284f2b30fdSAlexander Aring } 2294f2b30fdSAlexander Aring 230a47666ebSAlexander Aring hlist_add_head_rcu(&con->list, &connection_hash[r]); 231a47666ebSAlexander Aring spin_unlock(&connections_lock); 232a47666ebSAlexander Aring 2336ed7257bSPatrick Caulfield return con; 2346ed7257bSPatrick Caulfield } 2356ed7257bSPatrick Caulfield 2365e9ccc37SChristine Caulfield /* Loop round all connections */ 2375e9ccc37SChristine Caulfield static void foreach_conn(void (*conn_func)(struct connection *c)) 2385e9ccc37SChristine Caulfield { 239a47666ebSAlexander Aring int i, idx; 2405e9ccc37SChristine Caulfield struct connection *con; 2415e9ccc37SChristine Caulfield 242a47666ebSAlexander Aring idx = srcu_read_lock(&connections_srcu); 2435e9ccc37SChristine Caulfield for (i = 0; i < CONN_HASH_SIZE; i++) { 244a47666ebSAlexander Aring hlist_for_each_entry_rcu(con, &connection_hash[i], list) 2455e9ccc37SChristine Caulfield conn_func(con); 2465e9ccc37SChristine Caulfield } 247a47666ebSAlexander Aring srcu_read_unlock(&connections_srcu, idx); 2486ed7257bSPatrick Caulfield } 2496ed7257bSPatrick Caulfield 25036b71a8bSDavid Teigland static struct dlm_node_addr *find_node_addr(int nodeid) 2516ed7257bSPatrick Caulfield { 25236b71a8bSDavid Teigland struct dlm_node_addr *na; 25336b71a8bSDavid Teigland 25436b71a8bSDavid Teigland list_for_each_entry(na, &dlm_node_addrs, list) { 25536b71a8bSDavid Teigland if (na->nodeid == nodeid) 25636b71a8bSDavid Teigland return na; 25736b71a8bSDavid Teigland } 25836b71a8bSDavid Teigland return NULL; 25936b71a8bSDavid Teigland } 26036b71a8bSDavid Teigland 26136b71a8bSDavid Teigland static int addr_compare(struct sockaddr_storage *x, struct sockaddr_storage *y) 26236b71a8bSDavid Teigland { 26336b71a8bSDavid Teigland switch (x->ss_family) { 26436b71a8bSDavid Teigland case AF_INET: { 26536b71a8bSDavid Teigland struct sockaddr_in *sinx = (struct sockaddr_in *)x; 26636b71a8bSDavid Teigland struct sockaddr_in *siny = (struct sockaddr_in *)y; 26736b71a8bSDavid Teigland if (sinx->sin_addr.s_addr != siny->sin_addr.s_addr) 26836b71a8bSDavid Teigland return 0; 26936b71a8bSDavid Teigland if (sinx->sin_port != siny->sin_port) 27036b71a8bSDavid Teigland return 0; 27136b71a8bSDavid Teigland break; 27236b71a8bSDavid Teigland } 27336b71a8bSDavid Teigland case AF_INET6: { 27436b71a8bSDavid Teigland struct sockaddr_in6 *sinx = (struct sockaddr_in6 *)x; 27536b71a8bSDavid Teigland struct sockaddr_in6 *siny = (struct sockaddr_in6 *)y; 27636b71a8bSDavid Teigland if (!ipv6_addr_equal(&sinx->sin6_addr, &siny->sin6_addr)) 27736b71a8bSDavid Teigland return 0; 27836b71a8bSDavid Teigland if (sinx->sin6_port != siny->sin6_port) 27936b71a8bSDavid Teigland return 0; 28036b71a8bSDavid Teigland break; 28136b71a8bSDavid Teigland } 28236b71a8bSDavid Teigland default: 28336b71a8bSDavid Teigland return 0; 28436b71a8bSDavid Teigland } 28536b71a8bSDavid Teigland return 1; 28636b71a8bSDavid Teigland } 28736b71a8bSDavid Teigland 28836b71a8bSDavid Teigland static int nodeid_to_addr(int nodeid, struct sockaddr_storage *sas_out, 28998e1b60eSMike Christie struct sockaddr *sa_out, bool try_new_addr) 29036b71a8bSDavid Teigland { 29136b71a8bSDavid Teigland struct sockaddr_storage sas; 29236b71a8bSDavid Teigland struct dlm_node_addr *na; 2936ed7257bSPatrick Caulfield 2946ed7257bSPatrick Caulfield if (!dlm_local_count) 2956ed7257bSPatrick Caulfield return -1; 2966ed7257bSPatrick Caulfield 29736b71a8bSDavid Teigland spin_lock(&dlm_node_addrs_spin); 29836b71a8bSDavid Teigland na = find_node_addr(nodeid); 29998e1b60eSMike Christie if (na && na->addr_count) { 300ee44b4bcSMarcelo Ricardo Leitner memcpy(&sas, na->addr[na->curr_addr_index], 301ee44b4bcSMarcelo Ricardo Leitner sizeof(struct sockaddr_storage)); 302ee44b4bcSMarcelo Ricardo Leitner 30398e1b60eSMike Christie if (try_new_addr) { 30498e1b60eSMike Christie na->curr_addr_index++; 30598e1b60eSMike Christie if (na->curr_addr_index == na->addr_count) 30698e1b60eSMike Christie na->curr_addr_index = 0; 30798e1b60eSMike Christie } 30898e1b60eSMike Christie } 30936b71a8bSDavid Teigland spin_unlock(&dlm_node_addrs_spin); 31036b71a8bSDavid Teigland 31136b71a8bSDavid Teigland if (!na) 31236b71a8bSDavid Teigland return -EEXIST; 31336b71a8bSDavid Teigland 31436b71a8bSDavid Teigland if (!na->addr_count) 31536b71a8bSDavid Teigland return -ENOENT; 31636b71a8bSDavid Teigland 31736b71a8bSDavid Teigland if (sas_out) 31836b71a8bSDavid Teigland memcpy(sas_out, &sas, sizeof(struct sockaddr_storage)); 31936b71a8bSDavid Teigland 32036b71a8bSDavid Teigland if (!sa_out) 32136b71a8bSDavid Teigland return 0; 3226ed7257bSPatrick Caulfield 3236ed7257bSPatrick Caulfield if (dlm_local_addr[0]->ss_family == AF_INET) { 32436b71a8bSDavid Teigland struct sockaddr_in *in4 = (struct sockaddr_in *) &sas; 32536b71a8bSDavid Teigland struct sockaddr_in *ret4 = (struct sockaddr_in *) sa_out; 3266ed7257bSPatrick Caulfield ret4->sin_addr.s_addr = in4->sin_addr.s_addr; 3276ed7257bSPatrick Caulfield } else { 32836b71a8bSDavid Teigland struct sockaddr_in6 *in6 = (struct sockaddr_in6 *) &sas; 32936b71a8bSDavid Teigland struct sockaddr_in6 *ret6 = (struct sockaddr_in6 *) sa_out; 3304e3fd7a0SAlexey Dobriyan ret6->sin6_addr = in6->sin6_addr; 3316ed7257bSPatrick Caulfield } 3326ed7257bSPatrick Caulfield 3336ed7257bSPatrick Caulfield return 0; 3346ed7257bSPatrick Caulfield } 3356ed7257bSPatrick Caulfield 33636b71a8bSDavid Teigland static int addr_to_nodeid(struct sockaddr_storage *addr, int *nodeid) 33736b71a8bSDavid Teigland { 33836b71a8bSDavid Teigland struct dlm_node_addr *na; 33936b71a8bSDavid Teigland int rv = -EEXIST; 34098e1b60eSMike Christie int addr_i; 34136b71a8bSDavid Teigland 34236b71a8bSDavid Teigland spin_lock(&dlm_node_addrs_spin); 34336b71a8bSDavid Teigland list_for_each_entry(na, &dlm_node_addrs, list) { 34436b71a8bSDavid Teigland if (!na->addr_count) 34536b71a8bSDavid Teigland continue; 34636b71a8bSDavid Teigland 34798e1b60eSMike Christie for (addr_i = 0; addr_i < na->addr_count; addr_i++) { 34898e1b60eSMike Christie if (addr_compare(na->addr[addr_i], addr)) { 34936b71a8bSDavid Teigland *nodeid = na->nodeid; 35036b71a8bSDavid Teigland rv = 0; 35198e1b60eSMike Christie goto unlock; 35236b71a8bSDavid Teigland } 35398e1b60eSMike Christie } 35498e1b60eSMike Christie } 35598e1b60eSMike Christie unlock: 35636b71a8bSDavid Teigland spin_unlock(&dlm_node_addrs_spin); 35736b71a8bSDavid Teigland return rv; 35836b71a8bSDavid Teigland } 35936b71a8bSDavid Teigland 36036b71a8bSDavid Teigland int dlm_lowcomms_addr(int nodeid, struct sockaddr_storage *addr, int len) 36136b71a8bSDavid Teigland { 36236b71a8bSDavid Teigland struct sockaddr_storage *new_addr; 36336b71a8bSDavid Teigland struct dlm_node_addr *new_node, *na; 36436b71a8bSDavid Teigland 36536b71a8bSDavid Teigland new_node = kzalloc(sizeof(struct dlm_node_addr), GFP_NOFS); 36636b71a8bSDavid Teigland if (!new_node) 36736b71a8bSDavid Teigland return -ENOMEM; 36836b71a8bSDavid Teigland 36936b71a8bSDavid Teigland new_addr = kzalloc(sizeof(struct sockaddr_storage), GFP_NOFS); 37036b71a8bSDavid Teigland if (!new_addr) { 37136b71a8bSDavid Teigland kfree(new_node); 37236b71a8bSDavid Teigland return -ENOMEM; 37336b71a8bSDavid Teigland } 37436b71a8bSDavid Teigland 37536b71a8bSDavid Teigland memcpy(new_addr, addr, len); 37636b71a8bSDavid Teigland 37736b71a8bSDavid Teigland spin_lock(&dlm_node_addrs_spin); 37836b71a8bSDavid Teigland na = find_node_addr(nodeid); 37936b71a8bSDavid Teigland if (!na) { 38036b71a8bSDavid Teigland new_node->nodeid = nodeid; 38136b71a8bSDavid Teigland new_node->addr[0] = new_addr; 38236b71a8bSDavid Teigland new_node->addr_count = 1; 38336b71a8bSDavid Teigland list_add(&new_node->list, &dlm_node_addrs); 38436b71a8bSDavid Teigland spin_unlock(&dlm_node_addrs_spin); 38536b71a8bSDavid Teigland return 0; 38636b71a8bSDavid Teigland } 38736b71a8bSDavid Teigland 38836b71a8bSDavid Teigland if (na->addr_count >= DLM_MAX_ADDR_COUNT) { 38936b71a8bSDavid Teigland spin_unlock(&dlm_node_addrs_spin); 39036b71a8bSDavid Teigland kfree(new_addr); 39136b71a8bSDavid Teigland kfree(new_node); 39236b71a8bSDavid Teigland return -ENOSPC; 39336b71a8bSDavid Teigland } 39436b71a8bSDavid Teigland 39536b71a8bSDavid Teigland na->addr[na->addr_count++] = new_addr; 39636b71a8bSDavid Teigland spin_unlock(&dlm_node_addrs_spin); 39736b71a8bSDavid Teigland kfree(new_node); 39836b71a8bSDavid Teigland return 0; 39936b71a8bSDavid Teigland } 40036b71a8bSDavid Teigland 4016ed7257bSPatrick Caulfield /* Data available on socket or listen socket received a connect */ 402676d2369SDavid S. Miller static void lowcomms_data_ready(struct sock *sk) 4036ed7257bSPatrick Caulfield { 40493eaadebStsutomu.owa@toshiba.co.jp struct connection *con; 40593eaadebStsutomu.owa@toshiba.co.jp 40693eaadebStsutomu.owa@toshiba.co.jp read_lock_bh(&sk->sk_callback_lock); 40793eaadebStsutomu.owa@toshiba.co.jp con = sock2con(sk); 408afb853fbSPatrick Caulfield if (con && !test_and_set_bit(CF_READ_PENDING, &con->flags)) 4096ed7257bSPatrick Caulfield queue_work(recv_workqueue, &con->rwork); 41093eaadebStsutomu.owa@toshiba.co.jp read_unlock_bh(&sk->sk_callback_lock); 4116ed7257bSPatrick Caulfield } 4126ed7257bSPatrick Caulfield 4136ed7257bSPatrick Caulfield static void lowcomms_write_space(struct sock *sk) 4146ed7257bSPatrick Caulfield { 41593eaadebStsutomu.owa@toshiba.co.jp struct connection *con; 4166ed7257bSPatrick Caulfield 41793eaadebStsutomu.owa@toshiba.co.jp read_lock_bh(&sk->sk_callback_lock); 41893eaadebStsutomu.owa@toshiba.co.jp con = sock2con(sk); 419b36930ddSDavid Miller if (!con) 42093eaadebStsutomu.owa@toshiba.co.jp goto out; 421b36930ddSDavid Miller 422b36930ddSDavid Miller clear_bit(SOCK_NOSPACE, &con->sock->flags); 423b36930ddSDavid Miller 424b36930ddSDavid Miller if (test_and_clear_bit(CF_APP_LIMITED, &con->flags)) { 425b36930ddSDavid Miller con->sock->sk->sk_write_pending--; 4269cd3e072SEric Dumazet clear_bit(SOCKWQ_ASYNC_NOSPACE, &con->sock->flags); 427b36930ddSDavid Miller } 428b36930ddSDavid Miller 4296ed7257bSPatrick Caulfield queue_work(send_workqueue, &con->swork); 43093eaadebStsutomu.owa@toshiba.co.jp out: 43193eaadebStsutomu.owa@toshiba.co.jp read_unlock_bh(&sk->sk_callback_lock); 4326ed7257bSPatrick Caulfield } 4336ed7257bSPatrick Caulfield 4346ed7257bSPatrick Caulfield static inline void lowcomms_connect_sock(struct connection *con) 4356ed7257bSPatrick Caulfield { 436063c4c99SLars Marowsky-Bree if (test_bit(CF_CLOSE, &con->flags)) 437063c4c99SLars Marowsky-Bree return; 4386ed7257bSPatrick Caulfield queue_work(send_workqueue, &con->swork); 43961d9102bSBob Peterson cond_resched(); 4406ed7257bSPatrick Caulfield } 4416ed7257bSPatrick Caulfield 4426ed7257bSPatrick Caulfield static void lowcomms_state_change(struct sock *sk) 4436ed7257bSPatrick Caulfield { 444ee44b4bcSMarcelo Ricardo Leitner /* SCTP layer is not calling sk_data_ready when the connection 445ee44b4bcSMarcelo Ricardo Leitner * is done, so we catch the signal through here. Also, it 446ee44b4bcSMarcelo Ricardo Leitner * doesn't switch socket state when entering shutdown, so we 447ee44b4bcSMarcelo Ricardo Leitner * skip the write in that case. 448ee44b4bcSMarcelo Ricardo Leitner */ 449ee44b4bcSMarcelo Ricardo Leitner if (sk->sk_shutdown) { 450ee44b4bcSMarcelo Ricardo Leitner if (sk->sk_shutdown == RCV_SHUTDOWN) 451ee44b4bcSMarcelo Ricardo Leitner lowcomms_data_ready(sk); 452ee44b4bcSMarcelo Ricardo Leitner } else if (sk->sk_state == TCP_ESTABLISHED) { 4536ed7257bSPatrick Caulfield lowcomms_write_space(sk); 4546ed7257bSPatrick Caulfield } 455ee44b4bcSMarcelo Ricardo Leitner } 4566ed7257bSPatrick Caulfield 457391fbdc5SChristine Caulfield int dlm_lowcomms_connect_node(int nodeid) 458391fbdc5SChristine Caulfield { 459391fbdc5SChristine Caulfield struct connection *con; 460391fbdc5SChristine Caulfield 461391fbdc5SChristine Caulfield if (nodeid == dlm_our_nodeid()) 462391fbdc5SChristine Caulfield return 0; 463391fbdc5SChristine Caulfield 464391fbdc5SChristine Caulfield con = nodeid2con(nodeid, GFP_NOFS); 465391fbdc5SChristine Caulfield if (!con) 466391fbdc5SChristine Caulfield return -ENOMEM; 467391fbdc5SChristine Caulfield lowcomms_connect_sock(con); 468391fbdc5SChristine Caulfield return 0; 469391fbdc5SChristine Caulfield } 470391fbdc5SChristine Caulfield 471b3a5bbfdSBob Peterson static void lowcomms_error_report(struct sock *sk) 472b3a5bbfdSBob Peterson { 473b81171cbSBob Peterson struct connection *con; 474b3a5bbfdSBob Peterson struct sockaddr_storage saddr; 475b81171cbSBob Peterson void (*orig_report)(struct sock *) = NULL; 476b3a5bbfdSBob Peterson 477b81171cbSBob Peterson read_lock_bh(&sk->sk_callback_lock); 478b81171cbSBob Peterson con = sock2con(sk); 479b81171cbSBob Peterson if (con == NULL) 480b81171cbSBob Peterson goto out; 481b81171cbSBob Peterson 482cc661fc9SBob Peterson orig_report = listen_sock.sk_error_report; 4831a31833dSBob Peterson if (con->sock == NULL || 4849b2c45d4SDenys Vlasenko kernel_getpeername(con->sock, (struct sockaddr *)&saddr) < 0) { 485b3a5bbfdSBob Peterson printk_ratelimited(KERN_ERR "dlm: node %d: socket error " 486b3a5bbfdSBob Peterson "sending to node %d, port %d, " 487b3a5bbfdSBob Peterson "sk_err=%d/%d\n", dlm_our_nodeid(), 488b3a5bbfdSBob Peterson con->nodeid, dlm_config.ci_tcp_port, 489b3a5bbfdSBob Peterson sk->sk_err, sk->sk_err_soft); 490b3a5bbfdSBob Peterson } else if (saddr.ss_family == AF_INET) { 491b3a5bbfdSBob Peterson struct sockaddr_in *sin4 = (struct sockaddr_in *)&saddr; 492b3a5bbfdSBob Peterson 493b3a5bbfdSBob Peterson printk_ratelimited(KERN_ERR "dlm: node %d: socket error " 494b3a5bbfdSBob Peterson "sending to node %d at %pI4, port %d, " 495b3a5bbfdSBob Peterson "sk_err=%d/%d\n", dlm_our_nodeid(), 496b3a5bbfdSBob Peterson con->nodeid, &sin4->sin_addr.s_addr, 497b3a5bbfdSBob Peterson dlm_config.ci_tcp_port, sk->sk_err, 498b3a5bbfdSBob Peterson sk->sk_err_soft); 499b3a5bbfdSBob Peterson } else { 500b3a5bbfdSBob Peterson struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)&saddr; 501b3a5bbfdSBob Peterson 502b3a5bbfdSBob Peterson printk_ratelimited(KERN_ERR "dlm: node %d: socket error " 503b3a5bbfdSBob Peterson "sending to node %d at %u.%u.%u.%u, " 504b3a5bbfdSBob Peterson "port %d, sk_err=%d/%d\n", dlm_our_nodeid(), 505b3a5bbfdSBob Peterson con->nodeid, sin6->sin6_addr.s6_addr32[0], 506b3a5bbfdSBob Peterson sin6->sin6_addr.s6_addr32[1], 507b3a5bbfdSBob Peterson sin6->sin6_addr.s6_addr32[2], 508b3a5bbfdSBob Peterson sin6->sin6_addr.s6_addr32[3], 509b3a5bbfdSBob Peterson dlm_config.ci_tcp_port, sk->sk_err, 510b3a5bbfdSBob Peterson sk->sk_err_soft); 511b3a5bbfdSBob Peterson } 512b81171cbSBob Peterson out: 513b81171cbSBob Peterson read_unlock_bh(&sk->sk_callback_lock); 514b81171cbSBob Peterson if (orig_report) 515b81171cbSBob Peterson orig_report(sk); 516b81171cbSBob Peterson } 517b81171cbSBob Peterson 518b81171cbSBob Peterson /* Note: sk_callback_lock must be locked before calling this function. */ 519cc661fc9SBob Peterson static void save_listen_callbacks(struct socket *sock) 520b81171cbSBob Peterson { 521cc661fc9SBob Peterson struct sock *sk = sock->sk; 522cc661fc9SBob Peterson 523cc661fc9SBob Peterson listen_sock.sk_data_ready = sk->sk_data_ready; 524cc661fc9SBob Peterson listen_sock.sk_state_change = sk->sk_state_change; 525cc661fc9SBob Peterson listen_sock.sk_write_space = sk->sk_write_space; 526cc661fc9SBob Peterson listen_sock.sk_error_report = sk->sk_error_report; 527b81171cbSBob Peterson } 528b81171cbSBob Peterson 529cc661fc9SBob Peterson static void restore_callbacks(struct socket *sock) 530b81171cbSBob Peterson { 531cc661fc9SBob Peterson struct sock *sk = sock->sk; 532cc661fc9SBob Peterson 533b81171cbSBob Peterson write_lock_bh(&sk->sk_callback_lock); 534b81171cbSBob Peterson sk->sk_user_data = NULL; 535cc661fc9SBob Peterson sk->sk_data_ready = listen_sock.sk_data_ready; 536cc661fc9SBob Peterson sk->sk_state_change = listen_sock.sk_state_change; 537cc661fc9SBob Peterson sk->sk_write_space = listen_sock.sk_write_space; 538cc661fc9SBob Peterson sk->sk_error_report = listen_sock.sk_error_report; 539b81171cbSBob Peterson write_unlock_bh(&sk->sk_callback_lock); 540b3a5bbfdSBob Peterson } 541b3a5bbfdSBob Peterson 5426ed7257bSPatrick Caulfield /* Make a socket active */ 543988419a9Stsutomu.owa@toshiba.co.jp static void add_sock(struct socket *sock, struct connection *con) 5446ed7257bSPatrick Caulfield { 545b81171cbSBob Peterson struct sock *sk = sock->sk; 546b81171cbSBob Peterson 547b81171cbSBob Peterson write_lock_bh(&sk->sk_callback_lock); 5486ed7257bSPatrick Caulfield con->sock = sock; 5496ed7257bSPatrick Caulfield 550b81171cbSBob Peterson sk->sk_user_data = con; 5516ed7257bSPatrick Caulfield /* Install a data_ready callback */ 552b81171cbSBob Peterson sk->sk_data_ready = lowcomms_data_ready; 553b81171cbSBob Peterson sk->sk_write_space = lowcomms_write_space; 554b81171cbSBob Peterson sk->sk_state_change = lowcomms_state_change; 555b81171cbSBob Peterson sk->sk_allocation = GFP_NOFS; 556b81171cbSBob Peterson sk->sk_error_report = lowcomms_error_report; 557b81171cbSBob Peterson write_unlock_bh(&sk->sk_callback_lock); 5586ed7257bSPatrick Caulfield } 5596ed7257bSPatrick Caulfield 5606ed7257bSPatrick Caulfield /* Add the port number to an IPv6 or 4 sockaddr and return the address 5616ed7257bSPatrick Caulfield length */ 5626ed7257bSPatrick Caulfield static void make_sockaddr(struct sockaddr_storage *saddr, uint16_t port, 5636ed7257bSPatrick Caulfield int *addr_len) 5646ed7257bSPatrick Caulfield { 5656ed7257bSPatrick Caulfield saddr->ss_family = dlm_local_addr[0]->ss_family; 5666ed7257bSPatrick Caulfield if (saddr->ss_family == AF_INET) { 5676ed7257bSPatrick Caulfield struct sockaddr_in *in4_addr = (struct sockaddr_in *)saddr; 5686ed7257bSPatrick Caulfield in4_addr->sin_port = cpu_to_be16(port); 5696ed7257bSPatrick Caulfield *addr_len = sizeof(struct sockaddr_in); 5706ed7257bSPatrick Caulfield memset(&in4_addr->sin_zero, 0, sizeof(in4_addr->sin_zero)); 5716ed7257bSPatrick Caulfield } else { 5726ed7257bSPatrick Caulfield struct sockaddr_in6 *in6_addr = (struct sockaddr_in6 *)saddr; 5736ed7257bSPatrick Caulfield in6_addr->sin6_port = cpu_to_be16(port); 5746ed7257bSPatrick Caulfield *addr_len = sizeof(struct sockaddr_in6); 5756ed7257bSPatrick Caulfield } 57601c8cab2SPatrick Caulfield memset((char *)saddr + *addr_len, 0, sizeof(struct sockaddr_storage) - *addr_len); 5776ed7257bSPatrick Caulfield } 5786ed7257bSPatrick Caulfield 5796ed7257bSPatrick Caulfield /* Close a remote connection and tidy up */ 5800d737a8cSMarcelo Ricardo Leitner static void close_connection(struct connection *con, bool and_other, 5810d737a8cSMarcelo Ricardo Leitner bool tx, bool rx) 5826ed7257bSPatrick Caulfield { 583b2a66629Stsutomu.owa@toshiba.co.jp bool closing = test_and_set_bit(CF_CLOSING, &con->flags); 584b2a66629Stsutomu.owa@toshiba.co.jp 5850aa18464Stsutomu.owa@toshiba.co.jp if (tx && !closing && cancel_work_sync(&con->swork)) { 5860d737a8cSMarcelo Ricardo Leitner log_print("canceled swork for node %d", con->nodeid); 5870aa18464Stsutomu.owa@toshiba.co.jp clear_bit(CF_WRITE_PENDING, &con->flags); 5880aa18464Stsutomu.owa@toshiba.co.jp } 5890aa18464Stsutomu.owa@toshiba.co.jp if (rx && !closing && cancel_work_sync(&con->rwork)) { 5900d737a8cSMarcelo Ricardo Leitner log_print("canceled rwork for node %d", con->nodeid); 5910aa18464Stsutomu.owa@toshiba.co.jp clear_bit(CF_READ_PENDING, &con->flags); 5920aa18464Stsutomu.owa@toshiba.co.jp } 5936ed7257bSPatrick Caulfield 5940d737a8cSMarcelo Ricardo Leitner mutex_lock(&con->sock_mutex); 5956ed7257bSPatrick Caulfield if (con->sock) { 596cc661fc9SBob Peterson restore_callbacks(con->sock); 5976ed7257bSPatrick Caulfield sock_release(con->sock); 5986ed7257bSPatrick Caulfield con->sock = NULL; 5996ed7257bSPatrick Caulfield } 6006ed7257bSPatrick Caulfield if (con->othercon && and_other) { 6016ed7257bSPatrick Caulfield /* Will only re-enter once. */ 6020d737a8cSMarcelo Ricardo Leitner close_connection(con->othercon, false, true, true); 6036ed7257bSPatrick Caulfield } 6049e5f2825SPatrick Caulfield 6054798cbbfSAlexander Aring con->rx_leftover = 0; 6066ed7257bSPatrick Caulfield con->retries = 0; 6076ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 608b2a66629Stsutomu.owa@toshiba.co.jp clear_bit(CF_CLOSING, &con->flags); 6096ed7257bSPatrick Caulfield } 6106ed7257bSPatrick Caulfield 611055923bfSAlexander Aring static void shutdown_connection(struct connection *con) 612055923bfSAlexander Aring { 613055923bfSAlexander Aring int ret; 614055923bfSAlexander Aring 615055923bfSAlexander Aring if (cancel_work_sync(&con->swork)) { 616055923bfSAlexander Aring log_print("canceled swork for node %d", con->nodeid); 617055923bfSAlexander Aring clear_bit(CF_WRITE_PENDING, &con->flags); 618055923bfSAlexander Aring } 619055923bfSAlexander Aring 620055923bfSAlexander Aring mutex_lock(&con->sock_mutex); 621055923bfSAlexander Aring /* nothing to shutdown */ 622055923bfSAlexander Aring if (!con->sock) { 623055923bfSAlexander Aring mutex_unlock(&con->sock_mutex); 624055923bfSAlexander Aring return; 625055923bfSAlexander Aring } 626055923bfSAlexander Aring 627055923bfSAlexander Aring set_bit(CF_SHUTDOWN, &con->flags); 628055923bfSAlexander Aring ret = kernel_sock_shutdown(con->sock, SHUT_WR); 629055923bfSAlexander Aring mutex_unlock(&con->sock_mutex); 630055923bfSAlexander Aring if (ret) { 631055923bfSAlexander Aring log_print("Connection %p failed to shutdown: %d will force close", 632055923bfSAlexander Aring con, ret); 633055923bfSAlexander Aring goto force_close; 634055923bfSAlexander Aring } else { 635055923bfSAlexander Aring ret = wait_event_timeout(con->shutdown_wait, 636055923bfSAlexander Aring !test_bit(CF_SHUTDOWN, &con->flags), 637055923bfSAlexander Aring DLM_SHUTDOWN_WAIT_TIMEOUT); 638055923bfSAlexander Aring if (ret == 0) { 639055923bfSAlexander Aring log_print("Connection %p shutdown timed out, will force close", 640055923bfSAlexander Aring con); 641055923bfSAlexander Aring goto force_close; 642055923bfSAlexander Aring } 643055923bfSAlexander Aring } 644055923bfSAlexander Aring 645055923bfSAlexander Aring return; 646055923bfSAlexander Aring 647055923bfSAlexander Aring force_close: 648055923bfSAlexander Aring clear_bit(CF_SHUTDOWN, &con->flags); 649055923bfSAlexander Aring close_connection(con, false, true, true); 650055923bfSAlexander Aring } 651055923bfSAlexander Aring 652055923bfSAlexander Aring static void dlm_tcp_shutdown(struct connection *con) 653055923bfSAlexander Aring { 654055923bfSAlexander Aring if (con->othercon) 655055923bfSAlexander Aring shutdown_connection(con->othercon); 656055923bfSAlexander Aring shutdown_connection(con); 657055923bfSAlexander Aring } 658055923bfSAlexander Aring 6594798cbbfSAlexander Aring static int con_realloc_receive_buf(struct connection *con, int newlen) 6604798cbbfSAlexander Aring { 6614798cbbfSAlexander Aring unsigned char *newbuf; 6624798cbbfSAlexander Aring 6634798cbbfSAlexander Aring newbuf = kmalloc(newlen, GFP_NOFS); 6644798cbbfSAlexander Aring if (!newbuf) 6654798cbbfSAlexander Aring return -ENOMEM; 6664798cbbfSAlexander Aring 6674798cbbfSAlexander Aring /* copy any leftover from last receive */ 6684798cbbfSAlexander Aring if (con->rx_leftover) 6694798cbbfSAlexander Aring memmove(newbuf, con->rx_buf, con->rx_leftover); 6704798cbbfSAlexander Aring 6714798cbbfSAlexander Aring /* swap to new buffer space */ 6724798cbbfSAlexander Aring kfree(con->rx_buf); 6734798cbbfSAlexander Aring con->rx_buflen = newlen; 6744798cbbfSAlexander Aring con->rx_buf = newbuf; 6754798cbbfSAlexander Aring 6764798cbbfSAlexander Aring return 0; 6774798cbbfSAlexander Aring } 6784798cbbfSAlexander Aring 6796ed7257bSPatrick Caulfield /* Data received from remote end */ 6806ed7257bSPatrick Caulfield static int receive_from_sock(struct connection *con) 6816ed7257bSPatrick Caulfield { 6826ed7257bSPatrick Caulfield int call_again_soon = 0; 6834798cbbfSAlexander Aring struct msghdr msg; 6844798cbbfSAlexander Aring struct kvec iov; 6854798cbbfSAlexander Aring int ret, buflen; 6866ed7257bSPatrick Caulfield 6876ed7257bSPatrick Caulfield mutex_lock(&con->sock_mutex); 6886ed7257bSPatrick Caulfield 6896ed7257bSPatrick Caulfield if (con->sock == NULL) { 6906ed7257bSPatrick Caulfield ret = -EAGAIN; 6916ed7257bSPatrick Caulfield goto out_close; 6926ed7257bSPatrick Caulfield } 6934798cbbfSAlexander Aring 694acee4e52SMarcelo Ricardo Leitner if (con->nodeid == 0) { 695acee4e52SMarcelo Ricardo Leitner ret = -EINVAL; 696acee4e52SMarcelo Ricardo Leitner goto out_close; 697acee4e52SMarcelo Ricardo Leitner } 6986ed7257bSPatrick Caulfield 6994798cbbfSAlexander Aring /* realloc if we get new buffer size to read out */ 7004798cbbfSAlexander Aring buflen = dlm_config.ci_buffer_size; 7014798cbbfSAlexander Aring if (con->rx_buflen != buflen && con->rx_leftover <= buflen) { 7024798cbbfSAlexander Aring ret = con_realloc_receive_buf(con, buflen); 7034798cbbfSAlexander Aring if (ret < 0) 7046ed7257bSPatrick Caulfield goto out_resched; 7056ed7257bSPatrick Caulfield } 7066ed7257bSPatrick Caulfield 7074798cbbfSAlexander Aring /* calculate new buffer parameter regarding last receive and 7084798cbbfSAlexander Aring * possible leftover bytes 7096ed7257bSPatrick Caulfield */ 7104798cbbfSAlexander Aring iov.iov_base = con->rx_buf + con->rx_leftover; 7114798cbbfSAlexander Aring iov.iov_len = con->rx_buflen - con->rx_leftover; 7126ed7257bSPatrick Caulfield 7134798cbbfSAlexander Aring memset(&msg, 0, sizeof(msg)); 7144798cbbfSAlexander Aring msg.msg_flags = MSG_DONTWAIT | MSG_NOSIGNAL; 7154798cbbfSAlexander Aring ret = kernel_recvmsg(con->sock, &msg, &iov, 1, iov.iov_len, 7164798cbbfSAlexander Aring msg.msg_flags); 7176ed7257bSPatrick Caulfield if (ret <= 0) 7186ed7257bSPatrick Caulfield goto out_close; 7194798cbbfSAlexander Aring else if (ret == iov.iov_len) 720ee44b4bcSMarcelo Ricardo Leitner call_again_soon = 1; 7216ed7257bSPatrick Caulfield 7224798cbbfSAlexander Aring /* new buflen according readed bytes and leftover from last receive */ 7234798cbbfSAlexander Aring buflen = ret + con->rx_leftover; 7244798cbbfSAlexander Aring ret = dlm_process_incoming_buffer(con->nodeid, con->rx_buf, buflen); 7254798cbbfSAlexander Aring if (ret < 0) 7264798cbbfSAlexander Aring goto out_close; 7276ed7257bSPatrick Caulfield 7284798cbbfSAlexander Aring /* calculate leftover bytes from process and put it into begin of 7294798cbbfSAlexander Aring * the receive buffer, so next receive we have the full message 7304798cbbfSAlexander Aring * at the start address of the receive buffer. 7314798cbbfSAlexander Aring */ 7324798cbbfSAlexander Aring con->rx_leftover = buflen - ret; 7334798cbbfSAlexander Aring if (con->rx_leftover) { 7344798cbbfSAlexander Aring memmove(con->rx_buf, con->rx_buf + ret, 7354798cbbfSAlexander Aring con->rx_leftover); 7364798cbbfSAlexander Aring call_again_soon = true; 7376ed7257bSPatrick Caulfield } 7386ed7257bSPatrick Caulfield 7396ed7257bSPatrick Caulfield if (call_again_soon) 7406ed7257bSPatrick Caulfield goto out_resched; 7414798cbbfSAlexander Aring 7426ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 7436ed7257bSPatrick Caulfield return 0; 7446ed7257bSPatrick Caulfield 7456ed7257bSPatrick Caulfield out_resched: 7466ed7257bSPatrick Caulfield if (!test_and_set_bit(CF_READ_PENDING, &con->flags)) 7476ed7257bSPatrick Caulfield queue_work(recv_workqueue, &con->rwork); 7486ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 7496ed7257bSPatrick Caulfield return -EAGAIN; 7506ed7257bSPatrick Caulfield 7516ed7257bSPatrick Caulfield out_close: 7526ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 7539e5f2825SPatrick Caulfield if (ret != -EAGAIN) { 7546ed7257bSPatrick Caulfield /* Reconnect when there is something to send */ 755055923bfSAlexander Aring close_connection(con, false, true, false); 756055923bfSAlexander Aring if (ret == 0) { 757055923bfSAlexander Aring log_print("connection %p got EOF from %d", 758055923bfSAlexander Aring con, con->nodeid); 759055923bfSAlexander Aring /* handling for tcp shutdown */ 760055923bfSAlexander Aring clear_bit(CF_SHUTDOWN, &con->flags); 761055923bfSAlexander Aring wake_up(&con->shutdown_wait); 762055923bfSAlexander Aring /* signal to breaking receive worker */ 763055923bfSAlexander Aring ret = -1; 7646ed7257bSPatrick Caulfield } 765055923bfSAlexander Aring } 7666ed7257bSPatrick Caulfield return ret; 7676ed7257bSPatrick Caulfield } 7686ed7257bSPatrick Caulfield 7696ed7257bSPatrick Caulfield /* Listening socket is busy, accept a connection */ 7700774dc76SChristoph Hellwig static int accept_from_sock(struct connection *con) 7716ed7257bSPatrick Caulfield { 7726ed7257bSPatrick Caulfield int result; 7736ed7257bSPatrick Caulfield struct sockaddr_storage peeraddr; 7746ed7257bSPatrick Caulfield struct socket *newsock; 7756ed7257bSPatrick Caulfield int len; 7766ed7257bSPatrick Caulfield int nodeid; 7776ed7257bSPatrick Caulfield struct connection *newcon; 7786ed7257bSPatrick Caulfield struct connection *addcon; 7793f78cd7dSAlexander Aring unsigned int mark; 7806ed7257bSPatrick Caulfield 781513ef596SDavid Teigland if (!dlm_allow_conn) { 782513ef596SDavid Teigland return -1; 783513ef596SDavid Teigland } 784513ef596SDavid Teigland 7856ed7257bSPatrick Caulfield mutex_lock_nested(&con->sock_mutex, 0); 7866ed7257bSPatrick Caulfield 7873421fb15Stsutomu.owa@toshiba.co.jp if (!con->sock) { 7883421fb15Stsutomu.owa@toshiba.co.jp mutex_unlock(&con->sock_mutex); 7893421fb15Stsutomu.owa@toshiba.co.jp return -ENOTCONN; 7903421fb15Stsutomu.owa@toshiba.co.jp } 7916ed7257bSPatrick Caulfield 7923421fb15Stsutomu.owa@toshiba.co.jp result = kernel_accept(con->sock, &newsock, O_NONBLOCK); 7936ed7257bSPatrick Caulfield if (result < 0) 7946ed7257bSPatrick Caulfield goto accept_err; 7956ed7257bSPatrick Caulfield 7966ed7257bSPatrick Caulfield /* Get the connected socket's peer */ 7976ed7257bSPatrick Caulfield memset(&peeraddr, 0, sizeof(peeraddr)); 7989b2c45d4SDenys Vlasenko len = newsock->ops->getname(newsock, (struct sockaddr *)&peeraddr, 2); 7999b2c45d4SDenys Vlasenko if (len < 0) { 8006ed7257bSPatrick Caulfield result = -ECONNABORTED; 8016ed7257bSPatrick Caulfield goto accept_err; 8026ed7257bSPatrick Caulfield } 8036ed7257bSPatrick Caulfield 8046ed7257bSPatrick Caulfield /* Get the new node's NODEID */ 8056ed7257bSPatrick Caulfield make_sockaddr(&peeraddr, 0, &len); 80636b71a8bSDavid Teigland if (addr_to_nodeid(&peeraddr, &nodeid)) { 807bcaadf5cSMasatake YAMATO unsigned char *b=(unsigned char *)&peeraddr; 808617e82e1SDavid Teigland log_print("connect from non cluster node"); 809bcaadf5cSMasatake YAMATO print_hex_dump_bytes("ss: ", DUMP_PREFIX_NONE, 810bcaadf5cSMasatake YAMATO b, sizeof(struct sockaddr_storage)); 8116ed7257bSPatrick Caulfield sock_release(newsock); 8126ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 8136ed7257bSPatrick Caulfield return -1; 8146ed7257bSPatrick Caulfield } 8156ed7257bSPatrick Caulfield 8163f78cd7dSAlexander Aring dlm_comm_mark(nodeid, &mark); 8173f78cd7dSAlexander Aring sock_set_mark(newsock->sk, mark); 8183f78cd7dSAlexander Aring 8196ed7257bSPatrick Caulfield log_print("got connection from %d", nodeid); 8206ed7257bSPatrick Caulfield 8216ed7257bSPatrick Caulfield /* Check to see if we already have a connection to this node. This 8226ed7257bSPatrick Caulfield * could happen if the two nodes initiate a connection at roughly 8236ed7257bSPatrick Caulfield * the same time and the connections cross on the wire. 8246ed7257bSPatrick Caulfield * In this case we store the incoming one in "othercon" 8256ed7257bSPatrick Caulfield */ 826748285ccSDavid Teigland newcon = nodeid2con(nodeid, GFP_NOFS); 8276ed7257bSPatrick Caulfield if (!newcon) { 8286ed7257bSPatrick Caulfield result = -ENOMEM; 8296ed7257bSPatrick Caulfield goto accept_err; 8306ed7257bSPatrick Caulfield } 8316ed7257bSPatrick Caulfield mutex_lock_nested(&newcon->sock_mutex, 1); 8326ed7257bSPatrick Caulfield if (newcon->sock) { 8336ed7257bSPatrick Caulfield struct connection *othercon = newcon->othercon; 8346ed7257bSPatrick Caulfield 8356ed7257bSPatrick Caulfield if (!othercon) { 836a47666ebSAlexander Aring othercon = kzalloc(sizeof(*othercon), GFP_NOFS); 8376ed7257bSPatrick Caulfield if (!othercon) { 838617e82e1SDavid Teigland log_print("failed to allocate incoming socket"); 8396ed7257bSPatrick Caulfield mutex_unlock(&newcon->sock_mutex); 8406ed7257bSPatrick Caulfield result = -ENOMEM; 8416ed7257bSPatrick Caulfield goto accept_err; 8426ed7257bSPatrick Caulfield } 8434798cbbfSAlexander Aring 8444798cbbfSAlexander Aring othercon->rx_buflen = dlm_config.ci_buffer_size; 8454798cbbfSAlexander Aring othercon->rx_buf = kmalloc(othercon->rx_buflen, GFP_NOFS); 8464798cbbfSAlexander Aring if (!othercon->rx_buf) { 8474798cbbfSAlexander Aring mutex_unlock(&newcon->sock_mutex); 8484798cbbfSAlexander Aring kfree(othercon); 8494798cbbfSAlexander Aring log_print("failed to allocate incoming socket receive buffer"); 8504798cbbfSAlexander Aring result = -ENOMEM; 8514798cbbfSAlexander Aring goto accept_err; 8524798cbbfSAlexander Aring } 8534798cbbfSAlexander Aring 8546ed7257bSPatrick Caulfield othercon->nodeid = nodeid; 8556ed7257bSPatrick Caulfield othercon->rx_action = receive_from_sock; 8566ed7257bSPatrick Caulfield mutex_init(&othercon->sock_mutex); 85726b41099Stsutomu.owa@toshiba.co.jp INIT_LIST_HEAD(&othercon->writequeue); 85826b41099Stsutomu.owa@toshiba.co.jp spin_lock_init(&othercon->writequeue_lock); 8596ed7257bSPatrick Caulfield INIT_WORK(&othercon->swork, process_send_sockets); 8606ed7257bSPatrick Caulfield INIT_WORK(&othercon->rwork, process_recv_sockets); 861055923bfSAlexander Aring init_waitqueue_head(&othercon->shutdown_wait); 8626ed7257bSPatrick Caulfield set_bit(CF_IS_OTHERCON, &othercon->flags); 863ba3ab3caSAlexander Aring } else { 864ba3ab3caSAlexander Aring /* close other sock con if we have something new */ 865ba3ab3caSAlexander Aring close_connection(othercon, false, true, false); 86661d96be0SPatrick Caulfield } 867ba3ab3caSAlexander Aring 868c7355827Stsutomu.owa@toshiba.co.jp mutex_lock_nested(&othercon->sock_mutex, 2); 8696ed7257bSPatrick Caulfield newcon->othercon = othercon; 870988419a9Stsutomu.owa@toshiba.co.jp add_sock(newsock, othercon); 8716ed7257bSPatrick Caulfield addcon = othercon; 872c7355827Stsutomu.owa@toshiba.co.jp mutex_unlock(&othercon->sock_mutex); 8736ed7257bSPatrick Caulfield } 8746ed7257bSPatrick Caulfield else { 8756ed7257bSPatrick Caulfield newcon->rx_action = receive_from_sock; 8763735b4b9SBob Peterson /* accept copies the sk after we've saved the callbacks, so we 8773735b4b9SBob Peterson don't want to save them a second time or comm errors will 8783735b4b9SBob Peterson result in calling sk_error_report recursively. */ 879988419a9Stsutomu.owa@toshiba.co.jp add_sock(newsock, newcon); 8806ed7257bSPatrick Caulfield addcon = newcon; 8816ed7257bSPatrick Caulfield } 8826ed7257bSPatrick Caulfield 8836ed7257bSPatrick Caulfield mutex_unlock(&newcon->sock_mutex); 8846ed7257bSPatrick Caulfield 8856ed7257bSPatrick Caulfield /* 8866ed7257bSPatrick Caulfield * Add it to the active queue in case we got data 88725985edcSLucas De Marchi * between processing the accept adding the socket 8886ed7257bSPatrick Caulfield * to the read_sockets list 8896ed7257bSPatrick Caulfield */ 8906ed7257bSPatrick Caulfield if (!test_and_set_bit(CF_READ_PENDING, &addcon->flags)) 8916ed7257bSPatrick Caulfield queue_work(recv_workqueue, &addcon->rwork); 8926ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 8936ed7257bSPatrick Caulfield 8946ed7257bSPatrick Caulfield return 0; 8956ed7257bSPatrick Caulfield 8966ed7257bSPatrick Caulfield accept_err: 8976ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 8983421fb15Stsutomu.owa@toshiba.co.jp if (newsock) 8996ed7257bSPatrick Caulfield sock_release(newsock); 9006ed7257bSPatrick Caulfield 9016ed7257bSPatrick Caulfield if (result != -EAGAIN) 902617e82e1SDavid Teigland log_print("error accepting connection from node: %d", result); 9036ed7257bSPatrick Caulfield return result; 9046ed7257bSPatrick Caulfield } 9056ed7257bSPatrick Caulfield 9066ed7257bSPatrick Caulfield static void free_entry(struct writequeue_entry *e) 9076ed7257bSPatrick Caulfield { 9086ed7257bSPatrick Caulfield __free_page(e->page); 9096ed7257bSPatrick Caulfield kfree(e); 9106ed7257bSPatrick Caulfield } 9116ed7257bSPatrick Caulfield 9125d689871SMike Christie /* 9135d689871SMike Christie * writequeue_entry_complete - try to delete and free write queue entry 9145d689871SMike Christie * @e: write queue entry to try to delete 9155d689871SMike Christie * @completed: bytes completed 9165d689871SMike Christie * 9175d689871SMike Christie * writequeue_lock must be held. 9185d689871SMike Christie */ 9195d689871SMike Christie static void writequeue_entry_complete(struct writequeue_entry *e, int completed) 9205d689871SMike Christie { 9215d689871SMike Christie e->offset += completed; 9225d689871SMike Christie e->len -= completed; 9235d689871SMike Christie 9245d689871SMike Christie if (e->len == 0 && e->users == 0) { 9255d689871SMike Christie list_del(&e->list); 9265d689871SMike Christie free_entry(e); 9275d689871SMike Christie } 9285d689871SMike Christie } 9295d689871SMike Christie 930ee44b4bcSMarcelo Ricardo Leitner /* 931ee44b4bcSMarcelo Ricardo Leitner * sctp_bind_addrs - bind a SCTP socket to all our addresses 932ee44b4bcSMarcelo Ricardo Leitner */ 933ee44b4bcSMarcelo Ricardo Leitner static int sctp_bind_addrs(struct connection *con, uint16_t port) 934ee44b4bcSMarcelo Ricardo Leitner { 935ee44b4bcSMarcelo Ricardo Leitner struct sockaddr_storage localaddr; 936c0425a42SChristoph Hellwig struct sockaddr *addr = (struct sockaddr *)&localaddr; 937ee44b4bcSMarcelo Ricardo Leitner int i, addr_len, result = 0; 938ee44b4bcSMarcelo Ricardo Leitner 939ee44b4bcSMarcelo Ricardo Leitner for (i = 0; i < dlm_local_count; i++) { 940ee44b4bcSMarcelo Ricardo Leitner memcpy(&localaddr, dlm_local_addr[i], sizeof(localaddr)); 941ee44b4bcSMarcelo Ricardo Leitner make_sockaddr(&localaddr, port, &addr_len); 942ee44b4bcSMarcelo Ricardo Leitner 943ee44b4bcSMarcelo Ricardo Leitner if (!i) 944c0425a42SChristoph Hellwig result = kernel_bind(con->sock, addr, addr_len); 945ee44b4bcSMarcelo Ricardo Leitner else 946c0425a42SChristoph Hellwig result = sock_bind_add(con->sock->sk, addr, addr_len); 947ee44b4bcSMarcelo Ricardo Leitner 948ee44b4bcSMarcelo Ricardo Leitner if (result < 0) { 949ee44b4bcSMarcelo Ricardo Leitner log_print("Can't bind to %d addr number %d, %d.\n", 950ee44b4bcSMarcelo Ricardo Leitner port, i + 1, result); 951ee44b4bcSMarcelo Ricardo Leitner break; 952ee44b4bcSMarcelo Ricardo Leitner } 953ee44b4bcSMarcelo Ricardo Leitner } 954ee44b4bcSMarcelo Ricardo Leitner return result; 955ee44b4bcSMarcelo Ricardo Leitner } 956ee44b4bcSMarcelo Ricardo Leitner 9576ed7257bSPatrick Caulfield /* Initiate an SCTP association. 9586ed7257bSPatrick Caulfield This is a special case of send_to_sock() in that we don't yet have a 9596ed7257bSPatrick Caulfield peeled-off socket for this association, so we use the listening socket 9606ed7257bSPatrick Caulfield and add the primary IP address of the remote node. 9616ed7257bSPatrick Caulfield */ 962ee44b4bcSMarcelo Ricardo Leitner static void sctp_connect_to_sock(struct connection *con) 9636ed7257bSPatrick Caulfield { 964ee44b4bcSMarcelo Ricardo Leitner struct sockaddr_storage daddr; 965ee44b4bcSMarcelo Ricardo Leitner int result; 966ee44b4bcSMarcelo Ricardo Leitner int addr_len; 967ee44b4bcSMarcelo Ricardo Leitner struct socket *sock; 9689c9f168fSAlexander Aring unsigned int mark; 969ee44b4bcSMarcelo Ricardo Leitner 970ee44b4bcSMarcelo Ricardo Leitner if (con->nodeid == 0) { 971ee44b4bcSMarcelo Ricardo Leitner log_print("attempt to connect sock 0 foiled"); 972ee44b4bcSMarcelo Ricardo Leitner return; 973ee44b4bcSMarcelo Ricardo Leitner } 9746ed7257bSPatrick Caulfield 9753f78cd7dSAlexander Aring dlm_comm_mark(con->nodeid, &mark); 9760461e0dbSAlexander Aring 9775d689871SMike Christie mutex_lock(&con->sock_mutex); 9786ed7257bSPatrick Caulfield 979ee44b4bcSMarcelo Ricardo Leitner /* Some odd races can cause double-connects, ignore them */ 980ee44b4bcSMarcelo Ricardo Leitner if (con->retries++ > MAX_CONNECT_RETRIES) 981ee44b4bcSMarcelo Ricardo Leitner goto out; 982ee44b4bcSMarcelo Ricardo Leitner 983ee44b4bcSMarcelo Ricardo Leitner if (con->sock) { 984ee44b4bcSMarcelo Ricardo Leitner log_print("node %d already connected.", con->nodeid); 985ee44b4bcSMarcelo Ricardo Leitner goto out; 986ee44b4bcSMarcelo Ricardo Leitner } 987ee44b4bcSMarcelo Ricardo Leitner 988ee44b4bcSMarcelo Ricardo Leitner memset(&daddr, 0, sizeof(daddr)); 989ee44b4bcSMarcelo Ricardo Leitner result = nodeid_to_addr(con->nodeid, &daddr, NULL, true); 990ee44b4bcSMarcelo Ricardo Leitner if (result < 0) { 9916ed7257bSPatrick Caulfield log_print("no address for nodeid %d", con->nodeid); 992ee44b4bcSMarcelo Ricardo Leitner goto out; 99304bedd79SDavid Teigland } 9946ed7257bSPatrick Caulfield 995ee44b4bcSMarcelo Ricardo Leitner /* Create a socket to communicate with */ 996ee44b4bcSMarcelo Ricardo Leitner result = sock_create_kern(&init_net, dlm_local_addr[0]->ss_family, 997ee44b4bcSMarcelo Ricardo Leitner SOCK_STREAM, IPPROTO_SCTP, &sock); 998ee44b4bcSMarcelo Ricardo Leitner if (result < 0) 999ee44b4bcSMarcelo Ricardo Leitner goto socket_err; 10006ed7257bSPatrick Caulfield 10019c9f168fSAlexander Aring sock_set_mark(sock->sk, mark); 10029c9f168fSAlexander Aring 1003ee44b4bcSMarcelo Ricardo Leitner con->rx_action = receive_from_sock; 1004ee44b4bcSMarcelo Ricardo Leitner con->connect_action = sctp_connect_to_sock; 1005988419a9Stsutomu.owa@toshiba.co.jp add_sock(sock, con); 10066ed7257bSPatrick Caulfield 1007ee44b4bcSMarcelo Ricardo Leitner /* Bind to all addresses. */ 1008ee44b4bcSMarcelo Ricardo Leitner if (sctp_bind_addrs(con, 0)) 1009ee44b4bcSMarcelo Ricardo Leitner goto bind_err; 101098e1b60eSMike Christie 1011ee44b4bcSMarcelo Ricardo Leitner make_sockaddr(&daddr, dlm_config.ci_tcp_port, &addr_len); 10126ed7257bSPatrick Caulfield 1013ee44b4bcSMarcelo Ricardo Leitner log_print("connecting to %d", con->nodeid); 10146ed7257bSPatrick Caulfield 1015ee44b4bcSMarcelo Ricardo Leitner /* Turn off Nagle's algorithm */ 101640ef92c6SChristoph Hellwig sctp_sock_set_nodelay(sock->sk); 1017ee44b4bcSMarcelo Ricardo Leitner 1018f706d830SGang He /* 1019f706d830SGang He * Make sock->ops->connect() function return in specified time, 1020f706d830SGang He * since O_NONBLOCK argument in connect() function does not work here, 1021f706d830SGang He * then, we should restore the default value of this attribute. 1022f706d830SGang He */ 102376ee0785SChristoph Hellwig sock_set_sndtimeo(sock->sk, 5); 1024ee44b4bcSMarcelo Ricardo Leitner result = sock->ops->connect(sock, (struct sockaddr *)&daddr, addr_len, 1025da3627c3SGang He 0); 102676ee0785SChristoph Hellwig sock_set_sndtimeo(sock->sk, 0); 1027f706d830SGang He 1028ee44b4bcSMarcelo Ricardo Leitner if (result == -EINPROGRESS) 1029ee44b4bcSMarcelo Ricardo Leitner result = 0; 1030ee44b4bcSMarcelo Ricardo Leitner if (result == 0) 1031ee44b4bcSMarcelo Ricardo Leitner goto out; 1032ee44b4bcSMarcelo Ricardo Leitner 1033ee44b4bcSMarcelo Ricardo Leitner bind_err: 1034ee44b4bcSMarcelo Ricardo Leitner con->sock = NULL; 1035ee44b4bcSMarcelo Ricardo Leitner sock_release(sock); 1036ee44b4bcSMarcelo Ricardo Leitner 1037ee44b4bcSMarcelo Ricardo Leitner socket_err: 1038ee44b4bcSMarcelo Ricardo Leitner /* 1039ee44b4bcSMarcelo Ricardo Leitner * Some errors are fatal and this list might need adjusting. For other 1040ee44b4bcSMarcelo Ricardo Leitner * errors we try again until the max number of retries is reached. 1041ee44b4bcSMarcelo Ricardo Leitner */ 1042ee44b4bcSMarcelo Ricardo Leitner if (result != -EHOSTUNREACH && 1043ee44b4bcSMarcelo Ricardo Leitner result != -ENETUNREACH && 1044ee44b4bcSMarcelo Ricardo Leitner result != -ENETDOWN && 1045ee44b4bcSMarcelo Ricardo Leitner result != -EINVAL && 1046ee44b4bcSMarcelo Ricardo Leitner result != -EPROTONOSUPPORT) { 1047ee44b4bcSMarcelo Ricardo Leitner log_print("connect %d try %d error %d", con->nodeid, 1048ee44b4bcSMarcelo Ricardo Leitner con->retries, result); 1049ee44b4bcSMarcelo Ricardo Leitner mutex_unlock(&con->sock_mutex); 1050ee44b4bcSMarcelo Ricardo Leitner msleep(1000); 1051ee44b4bcSMarcelo Ricardo Leitner lowcomms_connect_sock(con); 1052ee44b4bcSMarcelo Ricardo Leitner return; 10536ed7257bSPatrick Caulfield } 10545d689871SMike Christie 1055ee44b4bcSMarcelo Ricardo Leitner out: 10565d689871SMike Christie mutex_unlock(&con->sock_mutex); 10576ed7257bSPatrick Caulfield } 10586ed7257bSPatrick Caulfield 10596ed7257bSPatrick Caulfield /* Connect a new socket to its peer */ 10606ed7257bSPatrick Caulfield static void tcp_connect_to_sock(struct connection *con) 10616ed7257bSPatrick Caulfield { 10626bd8fedaSLon Hohberger struct sockaddr_storage saddr, src_addr; 10636ed7257bSPatrick Caulfield int addr_len; 1064a89d63a1SCasey Dahlin struct socket *sock = NULL; 10659c9f168fSAlexander Aring unsigned int mark; 106636b71a8bSDavid Teigland int result; 10676ed7257bSPatrick Caulfield 10686ed7257bSPatrick Caulfield if (con->nodeid == 0) { 10696ed7257bSPatrick Caulfield log_print("attempt to connect sock 0 foiled"); 10706ed7257bSPatrick Caulfield return; 10716ed7257bSPatrick Caulfield } 10726ed7257bSPatrick Caulfield 10733f78cd7dSAlexander Aring dlm_comm_mark(con->nodeid, &mark); 10740461e0dbSAlexander Aring 10756ed7257bSPatrick Caulfield mutex_lock(&con->sock_mutex); 10766ed7257bSPatrick Caulfield if (con->retries++ > MAX_CONNECT_RETRIES) 10776ed7257bSPatrick Caulfield goto out; 10786ed7257bSPatrick Caulfield 10796ed7257bSPatrick Caulfield /* Some odd races can cause double-connects, ignore them */ 108036b71a8bSDavid Teigland if (con->sock) 10816ed7257bSPatrick Caulfield goto out; 10826ed7257bSPatrick Caulfield 10836ed7257bSPatrick Caulfield /* Create a socket to communicate with */ 1084eeb1bd5cSEric W. Biederman result = sock_create_kern(&init_net, dlm_local_addr[0]->ss_family, 1085eeb1bd5cSEric W. Biederman SOCK_STREAM, IPPROTO_TCP, &sock); 10866ed7257bSPatrick Caulfield if (result < 0) 10876ed7257bSPatrick Caulfield goto out_err; 10886ed7257bSPatrick Caulfield 10899c9f168fSAlexander Aring sock_set_mark(sock->sk, mark); 10909c9f168fSAlexander Aring 10916ed7257bSPatrick Caulfield memset(&saddr, 0, sizeof(saddr)); 109298e1b60eSMike Christie result = nodeid_to_addr(con->nodeid, &saddr, NULL, false); 109336b71a8bSDavid Teigland if (result < 0) { 109436b71a8bSDavid Teigland log_print("no address for nodeid %d", con->nodeid); 10956ed7257bSPatrick Caulfield goto out_err; 109636b71a8bSDavid Teigland } 10976ed7257bSPatrick Caulfield 10986ed7257bSPatrick Caulfield con->rx_action = receive_from_sock; 10996ed7257bSPatrick Caulfield con->connect_action = tcp_connect_to_sock; 1100055923bfSAlexander Aring con->shutdown_action = dlm_tcp_shutdown; 1101988419a9Stsutomu.owa@toshiba.co.jp add_sock(sock, con); 11026ed7257bSPatrick Caulfield 11036bd8fedaSLon Hohberger /* Bind to our cluster-known address connecting to avoid 11046bd8fedaSLon Hohberger routing problems */ 11056bd8fedaSLon Hohberger memcpy(&src_addr, dlm_local_addr[0], sizeof(src_addr)); 11066bd8fedaSLon Hohberger make_sockaddr(&src_addr, 0, &addr_len); 11076bd8fedaSLon Hohberger result = sock->ops->bind(sock, (struct sockaddr *) &src_addr, 11086bd8fedaSLon Hohberger addr_len); 11096bd8fedaSLon Hohberger if (result < 0) { 11106bd8fedaSLon Hohberger log_print("could not bind for connect: %d", result); 11116bd8fedaSLon Hohberger /* This *may* not indicate a critical error */ 11126bd8fedaSLon Hohberger } 11136bd8fedaSLon Hohberger 11146ed7257bSPatrick Caulfield make_sockaddr(&saddr, dlm_config.ci_tcp_port, &addr_len); 11156ed7257bSPatrick Caulfield 11166ed7257bSPatrick Caulfield log_print("connecting to %d", con->nodeid); 1117cb2d45daSDavid Teigland 1118cb2d45daSDavid Teigland /* Turn off Nagle's algorithm */ 111912abc5eeSChristoph Hellwig tcp_sock_set_nodelay(sock->sk); 1120cb2d45daSDavid Teigland 112136b71a8bSDavid Teigland result = sock->ops->connect(sock, (struct sockaddr *)&saddr, addr_len, 11226ed7257bSPatrick Caulfield O_NONBLOCK); 11236ed7257bSPatrick Caulfield if (result == -EINPROGRESS) 11246ed7257bSPatrick Caulfield result = 0; 11256ed7257bSPatrick Caulfield if (result == 0) 11266ed7257bSPatrick Caulfield goto out; 11276ed7257bSPatrick Caulfield 11286ed7257bSPatrick Caulfield out_err: 11296ed7257bSPatrick Caulfield if (con->sock) { 11306ed7257bSPatrick Caulfield sock_release(con->sock); 11316ed7257bSPatrick Caulfield con->sock = NULL; 1132a89d63a1SCasey Dahlin } else if (sock) { 1133a89d63a1SCasey Dahlin sock_release(sock); 11346ed7257bSPatrick Caulfield } 11356ed7257bSPatrick Caulfield /* 11366ed7257bSPatrick Caulfield * Some errors are fatal and this list might need adjusting. For other 11376ed7257bSPatrick Caulfield * errors we try again until the max number of retries is reached. 11386ed7257bSPatrick Caulfield */ 113936b71a8bSDavid Teigland if (result != -EHOSTUNREACH && 114036b71a8bSDavid Teigland result != -ENETUNREACH && 114136b71a8bSDavid Teigland result != -ENETDOWN && 114236b71a8bSDavid Teigland result != -EINVAL && 114336b71a8bSDavid Teigland result != -EPROTONOSUPPORT) { 114436b71a8bSDavid Teigland log_print("connect %d try %d error %d", con->nodeid, 114536b71a8bSDavid Teigland con->retries, result); 114636b71a8bSDavid Teigland mutex_unlock(&con->sock_mutex); 114736b71a8bSDavid Teigland msleep(1000); 11486ed7257bSPatrick Caulfield lowcomms_connect_sock(con); 114936b71a8bSDavid Teigland return; 11506ed7257bSPatrick Caulfield } 11516ed7257bSPatrick Caulfield out: 11526ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 11536ed7257bSPatrick Caulfield return; 11546ed7257bSPatrick Caulfield } 11556ed7257bSPatrick Caulfield 11566ed7257bSPatrick Caulfield static struct socket *tcp_create_listen_sock(struct connection *con, 11576ed7257bSPatrick Caulfield struct sockaddr_storage *saddr) 11586ed7257bSPatrick Caulfield { 11596ed7257bSPatrick Caulfield struct socket *sock = NULL; 11606ed7257bSPatrick Caulfield int result = 0; 11616ed7257bSPatrick Caulfield int addr_len; 11626ed7257bSPatrick Caulfield 11636ed7257bSPatrick Caulfield if (dlm_local_addr[0]->ss_family == AF_INET) 11646ed7257bSPatrick Caulfield addr_len = sizeof(struct sockaddr_in); 11656ed7257bSPatrick Caulfield else 11666ed7257bSPatrick Caulfield addr_len = sizeof(struct sockaddr_in6); 11676ed7257bSPatrick Caulfield 11686ed7257bSPatrick Caulfield /* Create a socket to communicate with */ 1169eeb1bd5cSEric W. Biederman result = sock_create_kern(&init_net, dlm_local_addr[0]->ss_family, 1170eeb1bd5cSEric W. Biederman SOCK_STREAM, IPPROTO_TCP, &sock); 11716ed7257bSPatrick Caulfield if (result < 0) { 1172617e82e1SDavid Teigland log_print("Can't create listening comms socket"); 11736ed7257bSPatrick Caulfield goto create_out; 11746ed7257bSPatrick Caulfield } 11756ed7257bSPatrick Caulfield 1176a5b7ab63SAlexander Aring sock_set_mark(sock->sk, dlm_config.ci_mark); 1177a5b7ab63SAlexander Aring 1178cb2d45daSDavid Teigland /* Turn off Nagle's algorithm */ 117912abc5eeSChristoph Hellwig tcp_sock_set_nodelay(sock->sk); 1180cb2d45daSDavid Teigland 1181b58f0e8fSChristoph Hellwig sock_set_reuseaddr(sock->sk); 11826ed7257bSPatrick Caulfield 118393eaadebStsutomu.owa@toshiba.co.jp write_lock_bh(&sock->sk->sk_callback_lock); 1184b81171cbSBob Peterson sock->sk->sk_user_data = con; 1185cc661fc9SBob Peterson save_listen_callbacks(sock); 11860774dc76SChristoph Hellwig con->rx_action = accept_from_sock; 11876ed7257bSPatrick Caulfield con->connect_action = tcp_connect_to_sock; 118893eaadebStsutomu.owa@toshiba.co.jp write_unlock_bh(&sock->sk->sk_callback_lock); 11896ed7257bSPatrick Caulfield 11906ed7257bSPatrick Caulfield /* Bind to our port */ 11916ed7257bSPatrick Caulfield make_sockaddr(saddr, dlm_config.ci_tcp_port, &addr_len); 11926ed7257bSPatrick Caulfield result = sock->ops->bind(sock, (struct sockaddr *) saddr, addr_len); 11936ed7257bSPatrick Caulfield if (result < 0) { 1194617e82e1SDavid Teigland log_print("Can't bind to port %d", dlm_config.ci_tcp_port); 11956ed7257bSPatrick Caulfield sock_release(sock); 11966ed7257bSPatrick Caulfield sock = NULL; 11976ed7257bSPatrick Caulfield con->sock = NULL; 11986ed7257bSPatrick Caulfield goto create_out; 11996ed7257bSPatrick Caulfield } 1200ce3d9544SChristoph Hellwig sock_set_keepalive(sock->sk); 12016ed7257bSPatrick Caulfield 12026ed7257bSPatrick Caulfield result = sock->ops->listen(sock, 5); 12036ed7257bSPatrick Caulfield if (result < 0) { 1204617e82e1SDavid Teigland log_print("Can't listen on port %d", dlm_config.ci_tcp_port); 12056ed7257bSPatrick Caulfield sock_release(sock); 12066ed7257bSPatrick Caulfield sock = NULL; 12076ed7257bSPatrick Caulfield goto create_out; 12086ed7257bSPatrick Caulfield } 12096ed7257bSPatrick Caulfield 12106ed7257bSPatrick Caulfield create_out: 12116ed7257bSPatrick Caulfield return sock; 12126ed7257bSPatrick Caulfield } 12136ed7257bSPatrick Caulfield 12146ed7257bSPatrick Caulfield /* Get local addresses */ 12156ed7257bSPatrick Caulfield static void init_local(void) 12166ed7257bSPatrick Caulfield { 12176ed7257bSPatrick Caulfield struct sockaddr_storage sas, *addr; 12186ed7257bSPatrick Caulfield int i; 12196ed7257bSPatrick Caulfield 122030d3a237SPatrick Caulfield dlm_local_count = 0; 12211b189b88SDavid Teigland for (i = 0; i < DLM_MAX_ADDR_COUNT; i++) { 12226ed7257bSPatrick Caulfield if (dlm_our_addr(&sas, i)) 12236ed7257bSPatrick Caulfield break; 12246ed7257bSPatrick Caulfield 12255c93f56fSAmitoj Kaur Chawla addr = kmemdup(&sas, sizeof(*addr), GFP_NOFS); 12266ed7257bSPatrick Caulfield if (!addr) 12276ed7257bSPatrick Caulfield break; 12286ed7257bSPatrick Caulfield dlm_local_addr[dlm_local_count++] = addr; 12296ed7257bSPatrick Caulfield } 12306ed7257bSPatrick Caulfield } 12316ed7257bSPatrick Caulfield 1232043697f0SAlexander Aring static void deinit_local(void) 1233043697f0SAlexander Aring { 1234043697f0SAlexander Aring int i; 1235043697f0SAlexander Aring 1236043697f0SAlexander Aring for (i = 0; i < dlm_local_count; i++) 1237043697f0SAlexander Aring kfree(dlm_local_addr[i]); 1238043697f0SAlexander Aring } 1239043697f0SAlexander Aring 12406ed7257bSPatrick Caulfield /* Initialise SCTP socket and bind to all interfaces */ 12416ed7257bSPatrick Caulfield static int sctp_listen_for_all(void) 12426ed7257bSPatrick Caulfield { 12436ed7257bSPatrick Caulfield struct socket *sock = NULL; 1244ee44b4bcSMarcelo Ricardo Leitner int result = -EINVAL; 1245573c24c4SDavid Teigland struct connection *con = nodeid2con(0, GFP_NOFS); 12466ed7257bSPatrick Caulfield 12476ed7257bSPatrick Caulfield if (!con) 12486ed7257bSPatrick Caulfield return -ENOMEM; 12496ed7257bSPatrick Caulfield 12506ed7257bSPatrick Caulfield log_print("Using SCTP for communications"); 12516ed7257bSPatrick Caulfield 1252eeb1bd5cSEric W. Biederman result = sock_create_kern(&init_net, dlm_local_addr[0]->ss_family, 1253ee44b4bcSMarcelo Ricardo Leitner SOCK_STREAM, IPPROTO_SCTP, &sock); 12546ed7257bSPatrick Caulfield if (result < 0) { 12556ed7257bSPatrick Caulfield log_print("Can't create comms socket, check SCTP is loaded"); 12566ed7257bSPatrick Caulfield goto out; 12576ed7257bSPatrick Caulfield } 12586ed7257bSPatrick Caulfield 125926cfabf9SChristoph Hellwig sock_set_rcvbuf(sock->sk, NEEDED_RMEM); 1260a5b7ab63SAlexander Aring sock_set_mark(sock->sk, dlm_config.ci_mark); 126140ef92c6SChristoph Hellwig sctp_sock_set_nodelay(sock->sk); 126286e92ad2SMike Christie 1263b81171cbSBob Peterson write_lock_bh(&sock->sk->sk_callback_lock); 12646ed7257bSPatrick Caulfield /* Init con struct */ 12656ed7257bSPatrick Caulfield sock->sk->sk_user_data = con; 1266cc661fc9SBob Peterson save_listen_callbacks(sock); 12676ed7257bSPatrick Caulfield con->sock = sock; 12686ed7257bSPatrick Caulfield con->sock->sk->sk_data_ready = lowcomms_data_ready; 12690774dc76SChristoph Hellwig con->rx_action = accept_from_sock; 1270ee44b4bcSMarcelo Ricardo Leitner con->connect_action = sctp_connect_to_sock; 12716ed7257bSPatrick Caulfield 1272b81171cbSBob Peterson write_unlock_bh(&sock->sk->sk_callback_lock); 1273b81171cbSBob Peterson 1274ee44b4bcSMarcelo Ricardo Leitner /* Bind to all addresses. */ 1275ee44b4bcSMarcelo Ricardo Leitner if (sctp_bind_addrs(con, dlm_config.ci_tcp_port)) 12766ed7257bSPatrick Caulfield goto create_delsock; 12776ed7257bSPatrick Caulfield 12786ed7257bSPatrick Caulfield result = sock->ops->listen(sock, 5); 12796ed7257bSPatrick Caulfield if (result < 0) { 12806ed7257bSPatrick Caulfield log_print("Can't set socket listening"); 12816ed7257bSPatrick Caulfield goto create_delsock; 12826ed7257bSPatrick Caulfield } 12836ed7257bSPatrick Caulfield 12846ed7257bSPatrick Caulfield return 0; 12856ed7257bSPatrick Caulfield 12866ed7257bSPatrick Caulfield create_delsock: 12876ed7257bSPatrick Caulfield sock_release(sock); 12886ed7257bSPatrick Caulfield con->sock = NULL; 12896ed7257bSPatrick Caulfield out: 12906ed7257bSPatrick Caulfield return result; 12916ed7257bSPatrick Caulfield } 12926ed7257bSPatrick Caulfield 12936ed7257bSPatrick Caulfield static int tcp_listen_for_all(void) 12946ed7257bSPatrick Caulfield { 12956ed7257bSPatrick Caulfield struct socket *sock = NULL; 1296573c24c4SDavid Teigland struct connection *con = nodeid2con(0, GFP_NOFS); 12976ed7257bSPatrick Caulfield int result = -EINVAL; 12986ed7257bSPatrick Caulfield 12996ed7257bSPatrick Caulfield if (!con) 13006ed7257bSPatrick Caulfield return -ENOMEM; 13016ed7257bSPatrick Caulfield 13026ed7257bSPatrick Caulfield /* We don't support multi-homed hosts */ 13036ed7257bSPatrick Caulfield if (dlm_local_addr[1] != NULL) { 1304617e82e1SDavid Teigland log_print("TCP protocol can't handle multi-homed hosts, " 1305617e82e1SDavid Teigland "try SCTP"); 13066ed7257bSPatrick Caulfield return -EINVAL; 13076ed7257bSPatrick Caulfield } 13086ed7257bSPatrick Caulfield 13096ed7257bSPatrick Caulfield log_print("Using TCP for communications"); 13106ed7257bSPatrick Caulfield 13116ed7257bSPatrick Caulfield sock = tcp_create_listen_sock(con, dlm_local_addr[0]); 13126ed7257bSPatrick Caulfield if (sock) { 1313988419a9Stsutomu.owa@toshiba.co.jp add_sock(sock, con); 13146ed7257bSPatrick Caulfield result = 0; 13156ed7257bSPatrick Caulfield } 13166ed7257bSPatrick Caulfield else { 13176ed7257bSPatrick Caulfield result = -EADDRINUSE; 13186ed7257bSPatrick Caulfield } 13196ed7257bSPatrick Caulfield 13206ed7257bSPatrick Caulfield return result; 13216ed7257bSPatrick Caulfield } 13226ed7257bSPatrick Caulfield 13236ed7257bSPatrick Caulfield 13246ed7257bSPatrick Caulfield 13256ed7257bSPatrick Caulfield static struct writequeue_entry *new_writequeue_entry(struct connection *con, 13266ed7257bSPatrick Caulfield gfp_t allocation) 13276ed7257bSPatrick Caulfield { 13286ed7257bSPatrick Caulfield struct writequeue_entry *entry; 13296ed7257bSPatrick Caulfield 13306ed7257bSPatrick Caulfield entry = kmalloc(sizeof(struct writequeue_entry), allocation); 13316ed7257bSPatrick Caulfield if (!entry) 13326ed7257bSPatrick Caulfield return NULL; 13336ed7257bSPatrick Caulfield 13346ed7257bSPatrick Caulfield entry->page = alloc_page(allocation); 13356ed7257bSPatrick Caulfield if (!entry->page) { 13366ed7257bSPatrick Caulfield kfree(entry); 13376ed7257bSPatrick Caulfield return NULL; 13386ed7257bSPatrick Caulfield } 13396ed7257bSPatrick Caulfield 13406ed7257bSPatrick Caulfield entry->offset = 0; 13416ed7257bSPatrick Caulfield entry->len = 0; 13426ed7257bSPatrick Caulfield entry->end = 0; 13436ed7257bSPatrick Caulfield entry->users = 0; 13446ed7257bSPatrick Caulfield entry->con = con; 13456ed7257bSPatrick Caulfield 13466ed7257bSPatrick Caulfield return entry; 13476ed7257bSPatrick Caulfield } 13486ed7257bSPatrick Caulfield 1349617e82e1SDavid Teigland void *dlm_lowcomms_get_buffer(int nodeid, int len, gfp_t allocation, char **ppc) 13506ed7257bSPatrick Caulfield { 13516ed7257bSPatrick Caulfield struct connection *con; 13526ed7257bSPatrick Caulfield struct writequeue_entry *e; 13536ed7257bSPatrick Caulfield int offset = 0; 13546ed7257bSPatrick Caulfield 13556ed7257bSPatrick Caulfield con = nodeid2con(nodeid, allocation); 13566ed7257bSPatrick Caulfield if (!con) 13576ed7257bSPatrick Caulfield return NULL; 13586ed7257bSPatrick Caulfield 13596ed7257bSPatrick Caulfield spin_lock(&con->writequeue_lock); 13606ed7257bSPatrick Caulfield e = list_entry(con->writequeue.prev, struct writequeue_entry, list); 13616ed7257bSPatrick Caulfield if ((&e->list == &con->writequeue) || 136209cbfeafSKirill A. Shutemov (PAGE_SIZE - e->end < len)) { 13636ed7257bSPatrick Caulfield e = NULL; 13646ed7257bSPatrick Caulfield } else { 13656ed7257bSPatrick Caulfield offset = e->end; 13666ed7257bSPatrick Caulfield e->end += len; 1367eeee2b5fSWei Yongjun e->users++; 13686ed7257bSPatrick Caulfield } 13696ed7257bSPatrick Caulfield spin_unlock(&con->writequeue_lock); 13706ed7257bSPatrick Caulfield 13716ed7257bSPatrick Caulfield if (e) { 13726ed7257bSPatrick Caulfield got_one: 13736ed7257bSPatrick Caulfield *ppc = page_address(e->page) + offset; 13746ed7257bSPatrick Caulfield return e; 13756ed7257bSPatrick Caulfield } 13766ed7257bSPatrick Caulfield 13776ed7257bSPatrick Caulfield e = new_writequeue_entry(con, allocation); 13786ed7257bSPatrick Caulfield if (e) { 13796ed7257bSPatrick Caulfield spin_lock(&con->writequeue_lock); 13806ed7257bSPatrick Caulfield offset = e->end; 13816ed7257bSPatrick Caulfield e->end += len; 1382eeee2b5fSWei Yongjun e->users++; 13836ed7257bSPatrick Caulfield list_add_tail(&e->list, &con->writequeue); 13846ed7257bSPatrick Caulfield spin_unlock(&con->writequeue_lock); 13856ed7257bSPatrick Caulfield goto got_one; 13866ed7257bSPatrick Caulfield } 13876ed7257bSPatrick Caulfield return NULL; 13886ed7257bSPatrick Caulfield } 13896ed7257bSPatrick Caulfield 13906ed7257bSPatrick Caulfield void dlm_lowcomms_commit_buffer(void *mh) 13916ed7257bSPatrick Caulfield { 13926ed7257bSPatrick Caulfield struct writequeue_entry *e = (struct writequeue_entry *)mh; 13936ed7257bSPatrick Caulfield struct connection *con = e->con; 13946ed7257bSPatrick Caulfield int users; 13956ed7257bSPatrick Caulfield 13966ed7257bSPatrick Caulfield spin_lock(&con->writequeue_lock); 13976ed7257bSPatrick Caulfield users = --e->users; 13986ed7257bSPatrick Caulfield if (users) 13996ed7257bSPatrick Caulfield goto out; 14006ed7257bSPatrick Caulfield e->len = e->end - e->offset; 14016ed7257bSPatrick Caulfield spin_unlock(&con->writequeue_lock); 14026ed7257bSPatrick Caulfield 14036ed7257bSPatrick Caulfield queue_work(send_workqueue, &con->swork); 14046ed7257bSPatrick Caulfield return; 14056ed7257bSPatrick Caulfield 14066ed7257bSPatrick Caulfield out: 14076ed7257bSPatrick Caulfield spin_unlock(&con->writequeue_lock); 14086ed7257bSPatrick Caulfield return; 14096ed7257bSPatrick Caulfield } 14106ed7257bSPatrick Caulfield 14116ed7257bSPatrick Caulfield /* Send a message */ 14126ed7257bSPatrick Caulfield static void send_to_sock(struct connection *con) 14136ed7257bSPatrick Caulfield { 14146ed7257bSPatrick Caulfield int ret = 0; 14156ed7257bSPatrick Caulfield const int msg_flags = MSG_DONTWAIT | MSG_NOSIGNAL; 14166ed7257bSPatrick Caulfield struct writequeue_entry *e; 14176ed7257bSPatrick Caulfield int len, offset; 1418f92c8dd7SBob Peterson int count = 0; 14196ed7257bSPatrick Caulfield 14206ed7257bSPatrick Caulfield mutex_lock(&con->sock_mutex); 14216ed7257bSPatrick Caulfield if (con->sock == NULL) 14226ed7257bSPatrick Caulfield goto out_connect; 14236ed7257bSPatrick Caulfield 14246ed7257bSPatrick Caulfield spin_lock(&con->writequeue_lock); 14256ed7257bSPatrick Caulfield for (;;) { 14266ed7257bSPatrick Caulfield e = list_entry(con->writequeue.next, struct writequeue_entry, 14276ed7257bSPatrick Caulfield list); 14286ed7257bSPatrick Caulfield if ((struct list_head *) e == &con->writequeue) 14296ed7257bSPatrick Caulfield break; 14306ed7257bSPatrick Caulfield 14316ed7257bSPatrick Caulfield len = e->len; 14326ed7257bSPatrick Caulfield offset = e->offset; 14336ed7257bSPatrick Caulfield BUG_ON(len == 0 && e->users == 0); 14346ed7257bSPatrick Caulfield spin_unlock(&con->writequeue_lock); 14356ed7257bSPatrick Caulfield 14366ed7257bSPatrick Caulfield ret = 0; 14376ed7257bSPatrick Caulfield if (len) { 14381329e3f2SPaolo Bonzini ret = kernel_sendpage(con->sock, e->page, offset, len, 14396ed7257bSPatrick Caulfield msg_flags); 1440d66f8277SPatrick Caulfield if (ret == -EAGAIN || ret == 0) { 1441b36930ddSDavid Miller if (ret == -EAGAIN && 14429cd3e072SEric Dumazet test_bit(SOCKWQ_ASYNC_NOSPACE, &con->sock->flags) && 1443b36930ddSDavid Miller !test_and_set_bit(CF_APP_LIMITED, &con->flags)) { 1444b36930ddSDavid Miller /* Notify TCP that we're limited by the 1445b36930ddSDavid Miller * application window size. 1446b36930ddSDavid Miller */ 1447b36930ddSDavid Miller set_bit(SOCK_NOSPACE, &con->sock->flags); 1448b36930ddSDavid Miller con->sock->sk->sk_write_pending++; 1449b36930ddSDavid Miller } 1450d66f8277SPatrick Caulfield cond_resched(); 14516ed7257bSPatrick Caulfield goto out; 14529c5bef58SYing Xue } else if (ret < 0) 14536ed7257bSPatrick Caulfield goto send_error; 1454d66f8277SPatrick Caulfield } 1455f92c8dd7SBob Peterson 14566ed7257bSPatrick Caulfield /* Don't starve people filling buffers */ 1457f92c8dd7SBob Peterson if (++count >= MAX_SEND_MSG_COUNT) { 14586ed7257bSPatrick Caulfield cond_resched(); 1459f92c8dd7SBob Peterson count = 0; 1460f92c8dd7SBob Peterson } 14616ed7257bSPatrick Caulfield 14626ed7257bSPatrick Caulfield spin_lock(&con->writequeue_lock); 14635d689871SMike Christie writequeue_entry_complete(e, ret); 14646ed7257bSPatrick Caulfield } 14656ed7257bSPatrick Caulfield spin_unlock(&con->writequeue_lock); 14666ed7257bSPatrick Caulfield out: 14676ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 14686ed7257bSPatrick Caulfield return; 14696ed7257bSPatrick Caulfield 14706ed7257bSPatrick Caulfield send_error: 14716ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 1472ba3ab3caSAlexander Aring close_connection(con, false, false, true); 147301da24d3SBob Peterson /* Requeue the send work. When the work daemon runs again, it will try 147401da24d3SBob Peterson a new connection, then call this function again. */ 147501da24d3SBob Peterson queue_work(send_workqueue, &con->swork); 14766ed7257bSPatrick Caulfield return; 14776ed7257bSPatrick Caulfield 14786ed7257bSPatrick Caulfield out_connect: 14796ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 148001da24d3SBob Peterson queue_work(send_workqueue, &con->swork); 148101da24d3SBob Peterson cond_resched(); 14826ed7257bSPatrick Caulfield } 14836ed7257bSPatrick Caulfield 14846ed7257bSPatrick Caulfield static void clean_one_writequeue(struct connection *con) 14856ed7257bSPatrick Caulfield { 14865e9ccc37SChristine Caulfield struct writequeue_entry *e, *safe; 14876ed7257bSPatrick Caulfield 14886ed7257bSPatrick Caulfield spin_lock(&con->writequeue_lock); 14895e9ccc37SChristine Caulfield list_for_each_entry_safe(e, safe, &con->writequeue, list) { 14906ed7257bSPatrick Caulfield list_del(&e->list); 14916ed7257bSPatrick Caulfield free_entry(e); 14926ed7257bSPatrick Caulfield } 14936ed7257bSPatrick Caulfield spin_unlock(&con->writequeue_lock); 14946ed7257bSPatrick Caulfield } 14956ed7257bSPatrick Caulfield 14966ed7257bSPatrick Caulfield /* Called from recovery when it knows that a node has 14976ed7257bSPatrick Caulfield left the cluster */ 14986ed7257bSPatrick Caulfield int dlm_lowcomms_close(int nodeid) 14996ed7257bSPatrick Caulfield { 15006ed7257bSPatrick Caulfield struct connection *con; 150136b71a8bSDavid Teigland struct dlm_node_addr *na; 15026ed7257bSPatrick Caulfield 15036ed7257bSPatrick Caulfield log_print("closing connection to node %d", nodeid); 15046ed7257bSPatrick Caulfield con = nodeid2con(nodeid, 0); 15056ed7257bSPatrick Caulfield if (con) { 1506063c4c99SLars Marowsky-Bree set_bit(CF_CLOSE, &con->flags); 15070d737a8cSMarcelo Ricardo Leitner close_connection(con, true, true, true); 15086ed7257bSPatrick Caulfield clean_one_writequeue(con); 15096ed7257bSPatrick Caulfield } 151036b71a8bSDavid Teigland 151136b71a8bSDavid Teigland spin_lock(&dlm_node_addrs_spin); 151236b71a8bSDavid Teigland na = find_node_addr(nodeid); 151336b71a8bSDavid Teigland if (na) { 151436b71a8bSDavid Teigland list_del(&na->list); 151536b71a8bSDavid Teigland while (na->addr_count--) 151636b71a8bSDavid Teigland kfree(na->addr[na->addr_count]); 151736b71a8bSDavid Teigland kfree(na); 151836b71a8bSDavid Teigland } 151936b71a8bSDavid Teigland spin_unlock(&dlm_node_addrs_spin); 152036b71a8bSDavid Teigland 15216ed7257bSPatrick Caulfield return 0; 15226ed7257bSPatrick Caulfield } 15236ed7257bSPatrick Caulfield 15246ed7257bSPatrick Caulfield /* Receive workqueue function */ 15256ed7257bSPatrick Caulfield static void process_recv_sockets(struct work_struct *work) 15266ed7257bSPatrick Caulfield { 15276ed7257bSPatrick Caulfield struct connection *con = container_of(work, struct connection, rwork); 15286ed7257bSPatrick Caulfield int err; 15296ed7257bSPatrick Caulfield 15306ed7257bSPatrick Caulfield clear_bit(CF_READ_PENDING, &con->flags); 15316ed7257bSPatrick Caulfield do { 15326ed7257bSPatrick Caulfield err = con->rx_action(con); 15336ed7257bSPatrick Caulfield } while (!err); 15346ed7257bSPatrick Caulfield } 15356ed7257bSPatrick Caulfield 15366ed7257bSPatrick Caulfield /* Send workqueue function */ 15376ed7257bSPatrick Caulfield static void process_send_sockets(struct work_struct *work) 15386ed7257bSPatrick Caulfield { 15396ed7257bSPatrick Caulfield struct connection *con = container_of(work, struct connection, swork); 15406ed7257bSPatrick Caulfield 15418a4abb08Stsutomu.owa@toshiba.co.jp clear_bit(CF_WRITE_PENDING, &con->flags); 154261d9102bSBob Peterson if (con->sock == NULL) /* not mutex protected so check it inside too */ 15436ed7257bSPatrick Caulfield con->connect_action(con); 154401da24d3SBob Peterson if (!list_empty(&con->writequeue)) 15456ed7257bSPatrick Caulfield send_to_sock(con); 15466ed7257bSPatrick Caulfield } 15476ed7257bSPatrick Caulfield 15486ed7257bSPatrick Caulfield static void work_stop(void) 15496ed7257bSPatrick Caulfield { 1550b355516fSDavid Windsor if (recv_workqueue) 15516ed7257bSPatrick Caulfield destroy_workqueue(recv_workqueue); 1552b355516fSDavid Windsor if (send_workqueue) 15536ed7257bSPatrick Caulfield destroy_workqueue(send_workqueue); 15546ed7257bSPatrick Caulfield } 15556ed7257bSPatrick Caulfield 15566ed7257bSPatrick Caulfield static int work_start(void) 15576ed7257bSPatrick Caulfield { 1558e43f055aSDavid Teigland recv_workqueue = alloc_workqueue("dlm_recv", 1559e43f055aSDavid Teigland WQ_UNBOUND | WQ_MEM_RECLAIM, 1); 1560b9d41052SNamhyung Kim if (!recv_workqueue) { 1561b9d41052SNamhyung Kim log_print("can't start dlm_recv"); 1562b9d41052SNamhyung Kim return -ENOMEM; 15636ed7257bSPatrick Caulfield } 15646ed7257bSPatrick Caulfield 1565e43f055aSDavid Teigland send_workqueue = alloc_workqueue("dlm_send", 1566e43f055aSDavid Teigland WQ_UNBOUND | WQ_MEM_RECLAIM, 1); 1567b9d41052SNamhyung Kim if (!send_workqueue) { 1568b9d41052SNamhyung Kim log_print("can't start dlm_send"); 15696ed7257bSPatrick Caulfield destroy_workqueue(recv_workqueue); 1570b9d41052SNamhyung Kim return -ENOMEM; 15716ed7257bSPatrick Caulfield } 15726ed7257bSPatrick Caulfield 15736ed7257bSPatrick Caulfield return 0; 15746ed7257bSPatrick Caulfield } 15756ed7257bSPatrick Caulfield 1576f0fb83cbStsutomu.owa@toshiba.co.jp static void _stop_conn(struct connection *con, bool and_other) 15776ed7257bSPatrick Caulfield { 1578f0fb83cbStsutomu.owa@toshiba.co.jp mutex_lock(&con->sock_mutex); 1579173a31feStsutomu.owa@toshiba.co.jp set_bit(CF_CLOSE, &con->flags); 1580f0fb83cbStsutomu.owa@toshiba.co.jp set_bit(CF_READ_PENDING, &con->flags); 15818a4abb08Stsutomu.owa@toshiba.co.jp set_bit(CF_WRITE_PENDING, &con->flags); 158293eaadebStsutomu.owa@toshiba.co.jp if (con->sock && con->sock->sk) { 158393eaadebStsutomu.owa@toshiba.co.jp write_lock_bh(&con->sock->sk->sk_callback_lock); 1584afb853fbSPatrick Caulfield con->sock->sk->sk_user_data = NULL; 158593eaadebStsutomu.owa@toshiba.co.jp write_unlock_bh(&con->sock->sk->sk_callback_lock); 158693eaadebStsutomu.owa@toshiba.co.jp } 1587f0fb83cbStsutomu.owa@toshiba.co.jp if (con->othercon && and_other) 1588f0fb83cbStsutomu.owa@toshiba.co.jp _stop_conn(con->othercon, false); 1589f0fb83cbStsutomu.owa@toshiba.co.jp mutex_unlock(&con->sock_mutex); 1590f0fb83cbStsutomu.owa@toshiba.co.jp } 1591f0fb83cbStsutomu.owa@toshiba.co.jp 1592f0fb83cbStsutomu.owa@toshiba.co.jp static void stop_conn(struct connection *con) 1593f0fb83cbStsutomu.owa@toshiba.co.jp { 1594f0fb83cbStsutomu.owa@toshiba.co.jp _stop_conn(con, true); 1595afb853fbSPatrick Caulfield } 15965e9ccc37SChristine Caulfield 1597055923bfSAlexander Aring static void shutdown_conn(struct connection *con) 1598055923bfSAlexander Aring { 1599055923bfSAlexander Aring if (con->shutdown_action) 1600055923bfSAlexander Aring con->shutdown_action(con); 1601055923bfSAlexander Aring } 1602055923bfSAlexander Aring 16034798cbbfSAlexander Aring static void connection_release(struct rcu_head *rcu) 16044798cbbfSAlexander Aring { 16054798cbbfSAlexander Aring struct connection *con = container_of(rcu, struct connection, rcu); 16064798cbbfSAlexander Aring 16074798cbbfSAlexander Aring kfree(con->rx_buf); 16084798cbbfSAlexander Aring kfree(con); 16094798cbbfSAlexander Aring } 16104798cbbfSAlexander Aring 16115e9ccc37SChristine Caulfield static void free_conn(struct connection *con) 16125e9ccc37SChristine Caulfield { 16130d737a8cSMarcelo Ricardo Leitner close_connection(con, true, true, true); 1614a47666ebSAlexander Aring spin_lock(&connections_lock); 1615a47666ebSAlexander Aring hlist_del_rcu(&con->list); 1616a47666ebSAlexander Aring spin_unlock(&connections_lock); 1617948c47e9SAlexander Aring if (con->othercon) { 1618948c47e9SAlexander Aring clean_one_writequeue(con->othercon); 16194798cbbfSAlexander Aring call_rcu(&con->othercon->rcu, connection_release); 1620948c47e9SAlexander Aring } 16210de98432SAlexander Aring clean_one_writequeue(con); 16224798cbbfSAlexander Aring call_rcu(&con->rcu, connection_release); 16236ed7257bSPatrick Caulfield } 16245e9ccc37SChristine Caulfield 1625f0fb83cbStsutomu.owa@toshiba.co.jp static void work_flush(void) 1626f0fb83cbStsutomu.owa@toshiba.co.jp { 1627a47666ebSAlexander Aring int ok, idx; 1628f0fb83cbStsutomu.owa@toshiba.co.jp int i; 1629f0fb83cbStsutomu.owa@toshiba.co.jp struct connection *con; 1630f0fb83cbStsutomu.owa@toshiba.co.jp 1631f0fb83cbStsutomu.owa@toshiba.co.jp do { 1632f0fb83cbStsutomu.owa@toshiba.co.jp ok = 1; 1633f0fb83cbStsutomu.owa@toshiba.co.jp foreach_conn(stop_conn); 1634b355516fSDavid Windsor if (recv_workqueue) 1635f0fb83cbStsutomu.owa@toshiba.co.jp flush_workqueue(recv_workqueue); 1636b355516fSDavid Windsor if (send_workqueue) 1637f0fb83cbStsutomu.owa@toshiba.co.jp flush_workqueue(send_workqueue); 1638a47666ebSAlexander Aring idx = srcu_read_lock(&connections_srcu); 1639f0fb83cbStsutomu.owa@toshiba.co.jp for (i = 0; i < CONN_HASH_SIZE && ok; i++) { 1640a47666ebSAlexander Aring hlist_for_each_entry_rcu(con, &connection_hash[i], 1641a47666ebSAlexander Aring list) { 1642f0fb83cbStsutomu.owa@toshiba.co.jp ok &= test_bit(CF_READ_PENDING, &con->flags); 16438a4abb08Stsutomu.owa@toshiba.co.jp ok &= test_bit(CF_WRITE_PENDING, &con->flags); 16448a4abb08Stsutomu.owa@toshiba.co.jp if (con->othercon) { 1645f0fb83cbStsutomu.owa@toshiba.co.jp ok &= test_bit(CF_READ_PENDING, 1646f0fb83cbStsutomu.owa@toshiba.co.jp &con->othercon->flags); 16478a4abb08Stsutomu.owa@toshiba.co.jp ok &= test_bit(CF_WRITE_PENDING, 16488a4abb08Stsutomu.owa@toshiba.co.jp &con->othercon->flags); 16498a4abb08Stsutomu.owa@toshiba.co.jp } 1650f0fb83cbStsutomu.owa@toshiba.co.jp } 1651f0fb83cbStsutomu.owa@toshiba.co.jp } 1652a47666ebSAlexander Aring srcu_read_unlock(&connections_srcu, idx); 1653f0fb83cbStsutomu.owa@toshiba.co.jp } while (!ok); 1654f0fb83cbStsutomu.owa@toshiba.co.jp } 1655f0fb83cbStsutomu.owa@toshiba.co.jp 16565e9ccc37SChristine Caulfield void dlm_lowcomms_stop(void) 16575e9ccc37SChristine Caulfield { 16585e9ccc37SChristine Caulfield /* Set all the flags to prevent any 16595e9ccc37SChristine Caulfield socket activity. 16605e9ccc37SChristine Caulfield */ 1661513ef596SDavid Teigland dlm_allow_conn = 0; 1662aa7ab1e2SAlexander Aring 1663aa7ab1e2SAlexander Aring if (recv_workqueue) 1664aa7ab1e2SAlexander Aring flush_workqueue(recv_workqueue); 1665aa7ab1e2SAlexander Aring if (send_workqueue) 1666aa7ab1e2SAlexander Aring flush_workqueue(send_workqueue); 1667aa7ab1e2SAlexander Aring 1668055923bfSAlexander Aring foreach_conn(shutdown_conn); 1669f0fb83cbStsutomu.owa@toshiba.co.jp work_flush(); 16703a8db798SMarcelo Ricardo Leitner foreach_conn(free_conn); 16716ed7257bSPatrick Caulfield work_stop(); 1672043697f0SAlexander Aring deinit_local(); 16736ed7257bSPatrick Caulfield } 16746ed7257bSPatrick Caulfield 16756ed7257bSPatrick Caulfield int dlm_lowcomms_start(void) 16766ed7257bSPatrick Caulfield { 16776ed7257bSPatrick Caulfield int error = -EINVAL; 16786ed7257bSPatrick Caulfield struct connection *con; 16795e9ccc37SChristine Caulfield int i; 16805e9ccc37SChristine Caulfield 16815e9ccc37SChristine Caulfield for (i = 0; i < CONN_HASH_SIZE; i++) 16825e9ccc37SChristine Caulfield INIT_HLIST_HEAD(&connection_hash[i]); 16836ed7257bSPatrick Caulfield 16846ed7257bSPatrick Caulfield init_local(); 16856ed7257bSPatrick Caulfield if (!dlm_local_count) { 1686617e82e1SDavid Teigland error = -ENOTCONN; 16876ed7257bSPatrick Caulfield log_print("no local IP address has been set"); 1688513ef596SDavid Teigland goto fail; 16896ed7257bSPatrick Caulfield } 16906ed7257bSPatrick Caulfield 1691513ef596SDavid Teigland error = work_start(); 1692513ef596SDavid Teigland if (error) 1693a47666ebSAlexander Aring goto fail; 1694513ef596SDavid Teigland 1695513ef596SDavid Teigland dlm_allow_conn = 1; 16966ed7257bSPatrick Caulfield 16976ed7257bSPatrick Caulfield /* Start listening */ 16986ed7257bSPatrick Caulfield if (dlm_config.ci_protocol == 0) 16996ed7257bSPatrick Caulfield error = tcp_listen_for_all(); 17006ed7257bSPatrick Caulfield else 17016ed7257bSPatrick Caulfield error = sctp_listen_for_all(); 17026ed7257bSPatrick Caulfield if (error) 17036ed7257bSPatrick Caulfield goto fail_unlisten; 17046ed7257bSPatrick Caulfield 17056ed7257bSPatrick Caulfield return 0; 17066ed7257bSPatrick Caulfield 17076ed7257bSPatrick Caulfield fail_unlisten: 1708513ef596SDavid Teigland dlm_allow_conn = 0; 17096ed7257bSPatrick Caulfield con = nodeid2con(0,0); 17107ae0451eSAlexander Aring if (con) 17117ae0451eSAlexander Aring free_conn(con); 1712513ef596SDavid Teigland fail: 17136ed7257bSPatrick Caulfield return error; 17146ed7257bSPatrick Caulfield } 171536b71a8bSDavid Teigland 171636b71a8bSDavid Teigland void dlm_lowcomms_exit(void) 171736b71a8bSDavid Teigland { 171836b71a8bSDavid Teigland struct dlm_node_addr *na, *safe; 171936b71a8bSDavid Teigland 172036b71a8bSDavid Teigland spin_lock(&dlm_node_addrs_spin); 172136b71a8bSDavid Teigland list_for_each_entry_safe(na, safe, &dlm_node_addrs, list) { 172236b71a8bSDavid Teigland list_del(&na->list); 172336b71a8bSDavid Teigland while (na->addr_count--) 172436b71a8bSDavid Teigland kfree(na->addr[na->addr_count]); 172536b71a8bSDavid Teigland kfree(na); 172636b71a8bSDavid Teigland } 172736b71a8bSDavid Teigland spin_unlock(&dlm_node_addrs_spin); 172836b71a8bSDavid Teigland } 1729