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 8119633c7eSAlexander Aring #define CF_CONNECTED 10 82ba868d9dSAlexander Aring #define CF_RECONNECT 11 83ba868d9dSAlexander Aring #define CF_DELAY_CONNECT 12 846ed7257bSPatrick Caulfield struct list_head writequeue; /* List of outgoing writequeue_entries */ 856ed7257bSPatrick Caulfield spinlock_t writequeue_lock; 866ed7257bSPatrick Caulfield void (*connect_action) (struct connection *); /* What to do to connect */ 87055923bfSAlexander Aring void (*shutdown_action)(struct connection *con); /* What to do to shutdown */ 886ed7257bSPatrick Caulfield int retries; 896ed7257bSPatrick Caulfield #define MAX_CONNECT_RETRIES 3 905e9ccc37SChristine Caulfield struct hlist_node list; 916ed7257bSPatrick Caulfield struct connection *othercon; 92ba868d9dSAlexander Aring struct connection *sendcon; 936ed7257bSPatrick Caulfield struct work_struct rwork; /* Receive workqueue */ 946ed7257bSPatrick Caulfield struct work_struct swork; /* Send workqueue */ 95055923bfSAlexander Aring wait_queue_head_t shutdown_wait; /* wait for graceful shutdown */ 964798cbbfSAlexander Aring unsigned char *rx_buf; 974798cbbfSAlexander Aring int rx_buflen; 984798cbbfSAlexander Aring int rx_leftover; 99a47666ebSAlexander Aring struct rcu_head rcu; 1006ed7257bSPatrick Caulfield }; 1016ed7257bSPatrick Caulfield #define sock2con(x) ((struct connection *)(x)->sk_user_data) 1026ed7257bSPatrick Caulfield 103d11ccd45SAlexander Aring struct listen_connection { 104d11ccd45SAlexander Aring struct socket *sock; 105d11ccd45SAlexander Aring struct work_struct rwork; 106d11ccd45SAlexander Aring }; 107d11ccd45SAlexander Aring 108f0747ebfSAlexander Aring #define DLM_WQ_REMAIN_BYTES(e) (PAGE_SIZE - e->end) 109f0747ebfSAlexander Aring #define DLM_WQ_LENGTH_BYTES(e) (e->end - e->offset) 110f0747ebfSAlexander Aring 1116ed7257bSPatrick Caulfield /* An entry waiting to be sent */ 1126ed7257bSPatrick Caulfield struct writequeue_entry { 1136ed7257bSPatrick Caulfield struct list_head list; 1146ed7257bSPatrick Caulfield struct page *page; 1156ed7257bSPatrick Caulfield int offset; 1166ed7257bSPatrick Caulfield int len; 1176ed7257bSPatrick Caulfield int end; 1186ed7257bSPatrick Caulfield int users; 119b38bc9c2SAlexander Aring int idx; /* get()/commit() idx exchange */ 1206ed7257bSPatrick Caulfield struct connection *con; 1216ed7257bSPatrick Caulfield }; 1226ed7257bSPatrick Caulfield 12336b71a8bSDavid Teigland struct dlm_node_addr { 12436b71a8bSDavid Teigland struct list_head list; 12536b71a8bSDavid Teigland int nodeid; 126e125fbebSAlexander Aring int mark; 12736b71a8bSDavid Teigland int addr_count; 12898e1b60eSMike Christie int curr_addr_index; 12936b71a8bSDavid Teigland struct sockaddr_storage *addr[DLM_MAX_ADDR_COUNT]; 13036b71a8bSDavid Teigland }; 13136b71a8bSDavid Teigland 132cc661fc9SBob Peterson static struct listen_sock_callbacks { 133cc661fc9SBob Peterson void (*sk_error_report)(struct sock *); 134cc661fc9SBob Peterson void (*sk_data_ready)(struct sock *); 135cc661fc9SBob Peterson void (*sk_state_change)(struct sock *); 136cc661fc9SBob Peterson void (*sk_write_space)(struct sock *); 137cc661fc9SBob Peterson } listen_sock; 138cc661fc9SBob Peterson 13936b71a8bSDavid Teigland static LIST_HEAD(dlm_node_addrs); 14036b71a8bSDavid Teigland static DEFINE_SPINLOCK(dlm_node_addrs_spin); 14136b71a8bSDavid Teigland 142d11ccd45SAlexander Aring static struct listen_connection listen_con; 1436ed7257bSPatrick Caulfield static struct sockaddr_storage *dlm_local_addr[DLM_MAX_ADDR_COUNT]; 1446ed7257bSPatrick Caulfield static int dlm_local_count; 14551746163SAlexander Aring int dlm_allow_conn; 1466ed7257bSPatrick Caulfield 1476ed7257bSPatrick Caulfield /* Work queues */ 1486ed7257bSPatrick Caulfield static struct workqueue_struct *recv_workqueue; 1496ed7257bSPatrick Caulfield static struct workqueue_struct *send_workqueue; 1506ed7257bSPatrick Caulfield 1515e9ccc37SChristine Caulfield static struct hlist_head connection_hash[CONN_HASH_SIZE]; 152a47666ebSAlexander Aring static DEFINE_SPINLOCK(connections_lock); 153a47666ebSAlexander Aring DEFINE_STATIC_SRCU(connections_srcu); 1546ed7257bSPatrick Caulfield 1556ed7257bSPatrick Caulfield static void process_recv_sockets(struct work_struct *work); 1566ed7257bSPatrick Caulfield static void process_send_sockets(struct work_struct *work); 1576ed7257bSPatrick Caulfield 1580672c3c2SAlexander Aring static void sctp_connect_to_sock(struct connection *con); 1590672c3c2SAlexander Aring static void tcp_connect_to_sock(struct connection *con); 16042873c90SAlexander Aring static void dlm_tcp_shutdown(struct connection *con); 1615e9ccc37SChristine Caulfield 1625e9ccc37SChristine Caulfield /* This is deliberately very simple because most clusters have simple 1635e9ccc37SChristine Caulfield sequential nodeids, so we should be able to go straight to a connection 1645e9ccc37SChristine Caulfield struct in the array */ 1655e9ccc37SChristine Caulfield static inline int nodeid_hash(int nodeid) 1665e9ccc37SChristine Caulfield { 1675e9ccc37SChristine Caulfield return nodeid & (CONN_HASH_SIZE-1); 1685e9ccc37SChristine Caulfield } 1695e9ccc37SChristine Caulfield 170b38bc9c2SAlexander Aring static struct connection *__find_con(int nodeid, int r) 1715e9ccc37SChristine Caulfield { 1725e9ccc37SChristine Caulfield struct connection *con; 1735e9ccc37SChristine Caulfield 174a47666ebSAlexander Aring hlist_for_each_entry_rcu(con, &connection_hash[r], list) { 175b38bc9c2SAlexander Aring if (con->nodeid == nodeid) 1765e9ccc37SChristine Caulfield return con; 1775e9ccc37SChristine Caulfield } 178a47666ebSAlexander Aring 1795e9ccc37SChristine Caulfield return NULL; 1805e9ccc37SChristine Caulfield } 1815e9ccc37SChristine Caulfield 1826cde210aSAlexander Aring static int dlm_con_init(struct connection *con, int nodeid) 1836ed7257bSPatrick Caulfield { 1844798cbbfSAlexander Aring con->rx_buflen = dlm_config.ci_buffer_size; 1854798cbbfSAlexander Aring con->rx_buf = kmalloc(con->rx_buflen, GFP_NOFS); 1866cde210aSAlexander Aring if (!con->rx_buf) 1876cde210aSAlexander Aring return -ENOMEM; 1884798cbbfSAlexander Aring 1896ed7257bSPatrick Caulfield con->nodeid = nodeid; 1906ed7257bSPatrick Caulfield mutex_init(&con->sock_mutex); 1916ed7257bSPatrick Caulfield INIT_LIST_HEAD(&con->writequeue); 1926ed7257bSPatrick Caulfield spin_lock_init(&con->writequeue_lock); 1936ed7257bSPatrick Caulfield INIT_WORK(&con->swork, process_send_sockets); 1946ed7257bSPatrick Caulfield INIT_WORK(&con->rwork, process_recv_sockets); 195055923bfSAlexander Aring init_waitqueue_head(&con->shutdown_wait); 1966ed7257bSPatrick Caulfield 19742873c90SAlexander Aring if (dlm_config.ci_protocol == 0) { 1980672c3c2SAlexander Aring con->connect_action = tcp_connect_to_sock; 19942873c90SAlexander Aring con->shutdown_action = dlm_tcp_shutdown; 20042873c90SAlexander Aring } else { 2010672c3c2SAlexander Aring con->connect_action = sctp_connect_to_sock; 20242873c90SAlexander Aring } 2036ed7257bSPatrick Caulfield 2046cde210aSAlexander Aring return 0; 2056cde210aSAlexander Aring } 2066cde210aSAlexander Aring 2076cde210aSAlexander Aring /* 2086cde210aSAlexander Aring * If 'allocation' is zero then we don't attempt to create a new 2096cde210aSAlexander Aring * connection structure for this node. 2106cde210aSAlexander Aring */ 2116cde210aSAlexander Aring static struct connection *nodeid2con(int nodeid, gfp_t alloc) 2126cde210aSAlexander Aring { 2136cde210aSAlexander Aring struct connection *con, *tmp; 2146cde210aSAlexander Aring int r, ret; 2156cde210aSAlexander Aring 216b38bc9c2SAlexander Aring r = nodeid_hash(nodeid); 217b38bc9c2SAlexander Aring con = __find_con(nodeid, r); 2186cde210aSAlexander Aring if (con || !alloc) 2196cde210aSAlexander Aring return con; 2206cde210aSAlexander Aring 2216cde210aSAlexander Aring con = kzalloc(sizeof(*con), alloc); 2226cde210aSAlexander Aring if (!con) 2236cde210aSAlexander Aring return NULL; 2246cde210aSAlexander Aring 2256cde210aSAlexander Aring ret = dlm_con_init(con, nodeid); 2266cde210aSAlexander Aring if (ret) { 2276cde210aSAlexander Aring kfree(con); 2286cde210aSAlexander Aring return NULL; 2296cde210aSAlexander Aring } 2306cde210aSAlexander Aring 231a47666ebSAlexander Aring spin_lock(&connections_lock); 2324f2b30fdSAlexander Aring /* Because multiple workqueues/threads calls this function it can 2334f2b30fdSAlexander Aring * race on multiple cpu's. Instead of locking hot path __find_con() 2344f2b30fdSAlexander Aring * we just check in rare cases of recently added nodes again 2354f2b30fdSAlexander Aring * under protection of connections_lock. If this is the case we 2364f2b30fdSAlexander Aring * abort our connection creation and return the existing connection. 2374f2b30fdSAlexander Aring */ 238b38bc9c2SAlexander Aring tmp = __find_con(nodeid, r); 2394f2b30fdSAlexander Aring if (tmp) { 2404f2b30fdSAlexander Aring spin_unlock(&connections_lock); 2414f2b30fdSAlexander Aring kfree(con->rx_buf); 2424f2b30fdSAlexander Aring kfree(con); 2434f2b30fdSAlexander Aring return tmp; 2444f2b30fdSAlexander Aring } 2454f2b30fdSAlexander Aring 246a47666ebSAlexander Aring hlist_add_head_rcu(&con->list, &connection_hash[r]); 247a47666ebSAlexander Aring spin_unlock(&connections_lock); 248a47666ebSAlexander Aring 2496ed7257bSPatrick Caulfield return con; 2506ed7257bSPatrick Caulfield } 2516ed7257bSPatrick Caulfield 2525e9ccc37SChristine Caulfield /* Loop round all connections */ 2535e9ccc37SChristine Caulfield static void foreach_conn(void (*conn_func)(struct connection *c)) 2545e9ccc37SChristine Caulfield { 255b38bc9c2SAlexander Aring int i; 2565e9ccc37SChristine Caulfield struct connection *con; 2575e9ccc37SChristine Caulfield 2585e9ccc37SChristine Caulfield for (i = 0; i < CONN_HASH_SIZE; i++) { 259a47666ebSAlexander Aring hlist_for_each_entry_rcu(con, &connection_hash[i], list) 2605e9ccc37SChristine Caulfield conn_func(con); 2615e9ccc37SChristine Caulfield } 2626ed7257bSPatrick Caulfield } 2636ed7257bSPatrick Caulfield 26436b71a8bSDavid Teigland static struct dlm_node_addr *find_node_addr(int nodeid) 2656ed7257bSPatrick Caulfield { 26636b71a8bSDavid Teigland struct dlm_node_addr *na; 26736b71a8bSDavid Teigland 26836b71a8bSDavid Teigland list_for_each_entry(na, &dlm_node_addrs, list) { 26936b71a8bSDavid Teigland if (na->nodeid == nodeid) 27036b71a8bSDavid Teigland return na; 27136b71a8bSDavid Teigland } 27236b71a8bSDavid Teigland return NULL; 27336b71a8bSDavid Teigland } 27436b71a8bSDavid Teigland 27540c6b83eSAlexander Aring static int addr_compare(const struct sockaddr_storage *x, 27640c6b83eSAlexander Aring const struct sockaddr_storage *y) 27736b71a8bSDavid Teigland { 27836b71a8bSDavid Teigland switch (x->ss_family) { 27936b71a8bSDavid Teigland case AF_INET: { 28036b71a8bSDavid Teigland struct sockaddr_in *sinx = (struct sockaddr_in *)x; 28136b71a8bSDavid Teigland struct sockaddr_in *siny = (struct sockaddr_in *)y; 28236b71a8bSDavid Teigland if (sinx->sin_addr.s_addr != siny->sin_addr.s_addr) 28336b71a8bSDavid Teigland return 0; 28436b71a8bSDavid Teigland if (sinx->sin_port != siny->sin_port) 28536b71a8bSDavid Teigland return 0; 28636b71a8bSDavid Teigland break; 28736b71a8bSDavid Teigland } 28836b71a8bSDavid Teigland case AF_INET6: { 28936b71a8bSDavid Teigland struct sockaddr_in6 *sinx = (struct sockaddr_in6 *)x; 29036b71a8bSDavid Teigland struct sockaddr_in6 *siny = (struct sockaddr_in6 *)y; 29136b71a8bSDavid Teigland if (!ipv6_addr_equal(&sinx->sin6_addr, &siny->sin6_addr)) 29236b71a8bSDavid Teigland return 0; 29336b71a8bSDavid Teigland if (sinx->sin6_port != siny->sin6_port) 29436b71a8bSDavid Teigland return 0; 29536b71a8bSDavid Teigland break; 29636b71a8bSDavid Teigland } 29736b71a8bSDavid Teigland default: 29836b71a8bSDavid Teigland return 0; 29936b71a8bSDavid Teigland } 30036b71a8bSDavid Teigland return 1; 30136b71a8bSDavid Teigland } 30236b71a8bSDavid Teigland 30336b71a8bSDavid Teigland static int nodeid_to_addr(int nodeid, struct sockaddr_storage *sas_out, 304e125fbebSAlexander Aring struct sockaddr *sa_out, bool try_new_addr, 305e125fbebSAlexander Aring unsigned int *mark) 30636b71a8bSDavid Teigland { 30736b71a8bSDavid Teigland struct sockaddr_storage sas; 30836b71a8bSDavid Teigland struct dlm_node_addr *na; 3096ed7257bSPatrick Caulfield 3106ed7257bSPatrick Caulfield if (!dlm_local_count) 3116ed7257bSPatrick Caulfield return -1; 3126ed7257bSPatrick Caulfield 31336b71a8bSDavid Teigland spin_lock(&dlm_node_addrs_spin); 31436b71a8bSDavid Teigland na = find_node_addr(nodeid); 31598e1b60eSMike Christie if (na && na->addr_count) { 316ee44b4bcSMarcelo Ricardo Leitner memcpy(&sas, na->addr[na->curr_addr_index], 317ee44b4bcSMarcelo Ricardo Leitner sizeof(struct sockaddr_storage)); 318ee44b4bcSMarcelo Ricardo Leitner 31998e1b60eSMike Christie if (try_new_addr) { 32098e1b60eSMike Christie na->curr_addr_index++; 32198e1b60eSMike Christie if (na->curr_addr_index == na->addr_count) 32298e1b60eSMike Christie na->curr_addr_index = 0; 32398e1b60eSMike Christie } 32498e1b60eSMike Christie } 32536b71a8bSDavid Teigland spin_unlock(&dlm_node_addrs_spin); 32636b71a8bSDavid Teigland 32736b71a8bSDavid Teigland if (!na) 32836b71a8bSDavid Teigland return -EEXIST; 32936b71a8bSDavid Teigland 33036b71a8bSDavid Teigland if (!na->addr_count) 33136b71a8bSDavid Teigland return -ENOENT; 33236b71a8bSDavid Teigland 333e125fbebSAlexander Aring *mark = na->mark; 334e125fbebSAlexander Aring 33536b71a8bSDavid Teigland if (sas_out) 33636b71a8bSDavid Teigland memcpy(sas_out, &sas, sizeof(struct sockaddr_storage)); 33736b71a8bSDavid Teigland 33836b71a8bSDavid Teigland if (!sa_out) 33936b71a8bSDavid Teigland return 0; 3406ed7257bSPatrick Caulfield 3416ed7257bSPatrick Caulfield if (dlm_local_addr[0]->ss_family == AF_INET) { 34236b71a8bSDavid Teigland struct sockaddr_in *in4 = (struct sockaddr_in *) &sas; 34336b71a8bSDavid Teigland struct sockaddr_in *ret4 = (struct sockaddr_in *) sa_out; 3446ed7257bSPatrick Caulfield ret4->sin_addr.s_addr = in4->sin_addr.s_addr; 3456ed7257bSPatrick Caulfield } else { 34636b71a8bSDavid Teigland struct sockaddr_in6 *in6 = (struct sockaddr_in6 *) &sas; 34736b71a8bSDavid Teigland struct sockaddr_in6 *ret6 = (struct sockaddr_in6 *) sa_out; 3484e3fd7a0SAlexey Dobriyan ret6->sin6_addr = in6->sin6_addr; 3496ed7257bSPatrick Caulfield } 3506ed7257bSPatrick Caulfield 3516ed7257bSPatrick Caulfield return 0; 3526ed7257bSPatrick Caulfield } 3536ed7257bSPatrick Caulfield 354e125fbebSAlexander Aring static int addr_to_nodeid(struct sockaddr_storage *addr, int *nodeid, 355e125fbebSAlexander Aring unsigned int *mark) 35636b71a8bSDavid Teigland { 35736b71a8bSDavid Teigland struct dlm_node_addr *na; 35836b71a8bSDavid Teigland int rv = -EEXIST; 35998e1b60eSMike Christie int addr_i; 36036b71a8bSDavid Teigland 36136b71a8bSDavid Teigland spin_lock(&dlm_node_addrs_spin); 36236b71a8bSDavid Teigland list_for_each_entry(na, &dlm_node_addrs, list) { 36336b71a8bSDavid Teigland if (!na->addr_count) 36436b71a8bSDavid Teigland continue; 36536b71a8bSDavid Teigland 36698e1b60eSMike Christie for (addr_i = 0; addr_i < na->addr_count; addr_i++) { 36798e1b60eSMike Christie if (addr_compare(na->addr[addr_i], addr)) { 36836b71a8bSDavid Teigland *nodeid = na->nodeid; 369e125fbebSAlexander Aring *mark = na->mark; 37036b71a8bSDavid Teigland rv = 0; 37198e1b60eSMike Christie goto unlock; 37236b71a8bSDavid Teigland } 37398e1b60eSMike Christie } 37498e1b60eSMike Christie } 37598e1b60eSMike Christie unlock: 37636b71a8bSDavid Teigland spin_unlock(&dlm_node_addrs_spin); 37736b71a8bSDavid Teigland return rv; 37836b71a8bSDavid Teigland } 37936b71a8bSDavid Teigland 3804f19d071SAlexander Aring /* caller need to held dlm_node_addrs_spin lock */ 3814f19d071SAlexander Aring static bool dlm_lowcomms_na_has_addr(const struct dlm_node_addr *na, 3824f19d071SAlexander Aring const struct sockaddr_storage *addr) 3834f19d071SAlexander Aring { 3844f19d071SAlexander Aring int i; 3854f19d071SAlexander Aring 3864f19d071SAlexander Aring for (i = 0; i < na->addr_count; i++) { 3874f19d071SAlexander Aring if (addr_compare(na->addr[i], addr)) 3884f19d071SAlexander Aring return true; 3894f19d071SAlexander Aring } 3904f19d071SAlexander Aring 3914f19d071SAlexander Aring return false; 3924f19d071SAlexander Aring } 3934f19d071SAlexander Aring 39436b71a8bSDavid Teigland int dlm_lowcomms_addr(int nodeid, struct sockaddr_storage *addr, int len) 39536b71a8bSDavid Teigland { 39636b71a8bSDavid Teigland struct sockaddr_storage *new_addr; 39736b71a8bSDavid Teigland struct dlm_node_addr *new_node, *na; 3984f19d071SAlexander Aring bool ret; 39936b71a8bSDavid Teigland 40036b71a8bSDavid Teigland new_node = kzalloc(sizeof(struct dlm_node_addr), GFP_NOFS); 40136b71a8bSDavid Teigland if (!new_node) 40236b71a8bSDavid Teigland return -ENOMEM; 40336b71a8bSDavid Teigland 40436b71a8bSDavid Teigland new_addr = kzalloc(sizeof(struct sockaddr_storage), GFP_NOFS); 40536b71a8bSDavid Teigland if (!new_addr) { 40636b71a8bSDavid Teigland kfree(new_node); 40736b71a8bSDavid Teigland return -ENOMEM; 40836b71a8bSDavid Teigland } 40936b71a8bSDavid Teigland 41036b71a8bSDavid Teigland memcpy(new_addr, addr, len); 41136b71a8bSDavid Teigland 41236b71a8bSDavid Teigland spin_lock(&dlm_node_addrs_spin); 41336b71a8bSDavid Teigland na = find_node_addr(nodeid); 41436b71a8bSDavid Teigland if (!na) { 41536b71a8bSDavid Teigland new_node->nodeid = nodeid; 41636b71a8bSDavid Teigland new_node->addr[0] = new_addr; 41736b71a8bSDavid Teigland new_node->addr_count = 1; 418e125fbebSAlexander Aring new_node->mark = dlm_config.ci_mark; 41936b71a8bSDavid Teigland list_add(&new_node->list, &dlm_node_addrs); 42036b71a8bSDavid Teigland spin_unlock(&dlm_node_addrs_spin); 42136b71a8bSDavid Teigland return 0; 42236b71a8bSDavid Teigland } 42336b71a8bSDavid Teigland 4244f19d071SAlexander Aring ret = dlm_lowcomms_na_has_addr(na, addr); 4254f19d071SAlexander Aring if (ret) { 4264f19d071SAlexander Aring spin_unlock(&dlm_node_addrs_spin); 4274f19d071SAlexander Aring kfree(new_addr); 4284f19d071SAlexander Aring kfree(new_node); 4294f19d071SAlexander Aring return -EEXIST; 4304f19d071SAlexander Aring } 4314f19d071SAlexander Aring 43236b71a8bSDavid Teigland if (na->addr_count >= DLM_MAX_ADDR_COUNT) { 43336b71a8bSDavid Teigland spin_unlock(&dlm_node_addrs_spin); 43436b71a8bSDavid Teigland kfree(new_addr); 43536b71a8bSDavid Teigland kfree(new_node); 43636b71a8bSDavid Teigland return -ENOSPC; 43736b71a8bSDavid Teigland } 43836b71a8bSDavid Teigland 43936b71a8bSDavid Teigland na->addr[na->addr_count++] = new_addr; 44036b71a8bSDavid Teigland spin_unlock(&dlm_node_addrs_spin); 44136b71a8bSDavid Teigland kfree(new_node); 44236b71a8bSDavid Teigland return 0; 44336b71a8bSDavid Teigland } 44436b71a8bSDavid Teigland 4456ed7257bSPatrick Caulfield /* Data available on socket or listen socket received a connect */ 446676d2369SDavid S. Miller static void lowcomms_data_ready(struct sock *sk) 4476ed7257bSPatrick Caulfield { 44893eaadebStsutomu.owa@toshiba.co.jp struct connection *con; 44993eaadebStsutomu.owa@toshiba.co.jp 45093eaadebStsutomu.owa@toshiba.co.jp read_lock_bh(&sk->sk_callback_lock); 45193eaadebStsutomu.owa@toshiba.co.jp con = sock2con(sk); 452afb853fbSPatrick Caulfield if (con && !test_and_set_bit(CF_READ_PENDING, &con->flags)) 4536ed7257bSPatrick Caulfield queue_work(recv_workqueue, &con->rwork); 45493eaadebStsutomu.owa@toshiba.co.jp read_unlock_bh(&sk->sk_callback_lock); 4556ed7257bSPatrick Caulfield } 4566ed7257bSPatrick Caulfield 457d11ccd45SAlexander Aring static void lowcomms_listen_data_ready(struct sock *sk) 458d11ccd45SAlexander Aring { 459d11ccd45SAlexander Aring queue_work(recv_workqueue, &listen_con.rwork); 460d11ccd45SAlexander Aring } 461d11ccd45SAlexander Aring 4626ed7257bSPatrick Caulfield static void lowcomms_write_space(struct sock *sk) 4636ed7257bSPatrick Caulfield { 46493eaadebStsutomu.owa@toshiba.co.jp struct connection *con; 4656ed7257bSPatrick Caulfield 46693eaadebStsutomu.owa@toshiba.co.jp read_lock_bh(&sk->sk_callback_lock); 46793eaadebStsutomu.owa@toshiba.co.jp con = sock2con(sk); 468b36930ddSDavid Miller if (!con) 46993eaadebStsutomu.owa@toshiba.co.jp goto out; 470b36930ddSDavid Miller 47119633c7eSAlexander Aring if (!test_and_set_bit(CF_CONNECTED, &con->flags)) { 47219633c7eSAlexander Aring log_print("successful connected to node %d", con->nodeid); 47319633c7eSAlexander Aring queue_work(send_workqueue, &con->swork); 47419633c7eSAlexander Aring goto out; 47519633c7eSAlexander Aring } 47619633c7eSAlexander Aring 477b36930ddSDavid Miller clear_bit(SOCK_NOSPACE, &con->sock->flags); 478b36930ddSDavid Miller 479b36930ddSDavid Miller if (test_and_clear_bit(CF_APP_LIMITED, &con->flags)) { 480b36930ddSDavid Miller con->sock->sk->sk_write_pending--; 4819cd3e072SEric Dumazet clear_bit(SOCKWQ_ASYNC_NOSPACE, &con->sock->flags); 482b36930ddSDavid Miller } 483b36930ddSDavid Miller 4846ed7257bSPatrick Caulfield queue_work(send_workqueue, &con->swork); 48593eaadebStsutomu.owa@toshiba.co.jp out: 48693eaadebStsutomu.owa@toshiba.co.jp read_unlock_bh(&sk->sk_callback_lock); 4876ed7257bSPatrick Caulfield } 4886ed7257bSPatrick Caulfield 4896ed7257bSPatrick Caulfield static inline void lowcomms_connect_sock(struct connection *con) 4906ed7257bSPatrick Caulfield { 491063c4c99SLars Marowsky-Bree if (test_bit(CF_CLOSE, &con->flags)) 492063c4c99SLars Marowsky-Bree return; 4936ed7257bSPatrick Caulfield queue_work(send_workqueue, &con->swork); 49461d9102bSBob Peterson cond_resched(); 4956ed7257bSPatrick Caulfield } 4966ed7257bSPatrick Caulfield 4976ed7257bSPatrick Caulfield static void lowcomms_state_change(struct sock *sk) 4986ed7257bSPatrick Caulfield { 499ee44b4bcSMarcelo Ricardo Leitner /* SCTP layer is not calling sk_data_ready when the connection 500ee44b4bcSMarcelo Ricardo Leitner * is done, so we catch the signal through here. Also, it 501ee44b4bcSMarcelo Ricardo Leitner * doesn't switch socket state when entering shutdown, so we 502ee44b4bcSMarcelo Ricardo Leitner * skip the write in that case. 503ee44b4bcSMarcelo Ricardo Leitner */ 504ee44b4bcSMarcelo Ricardo Leitner if (sk->sk_shutdown) { 505ee44b4bcSMarcelo Ricardo Leitner if (sk->sk_shutdown == RCV_SHUTDOWN) 506ee44b4bcSMarcelo Ricardo Leitner lowcomms_data_ready(sk); 507ee44b4bcSMarcelo Ricardo Leitner } else if (sk->sk_state == TCP_ESTABLISHED) { 5086ed7257bSPatrick Caulfield lowcomms_write_space(sk); 5096ed7257bSPatrick Caulfield } 510ee44b4bcSMarcelo Ricardo Leitner } 5116ed7257bSPatrick Caulfield 512391fbdc5SChristine Caulfield int dlm_lowcomms_connect_node(int nodeid) 513391fbdc5SChristine Caulfield { 514391fbdc5SChristine Caulfield struct connection *con; 515b38bc9c2SAlexander Aring int idx; 516391fbdc5SChristine Caulfield 517391fbdc5SChristine Caulfield if (nodeid == dlm_our_nodeid()) 518391fbdc5SChristine Caulfield return 0; 519391fbdc5SChristine Caulfield 520b38bc9c2SAlexander Aring idx = srcu_read_lock(&connections_srcu); 521391fbdc5SChristine Caulfield con = nodeid2con(nodeid, GFP_NOFS); 522b38bc9c2SAlexander Aring if (!con) { 523b38bc9c2SAlexander Aring srcu_read_unlock(&connections_srcu, idx); 524391fbdc5SChristine Caulfield return -ENOMEM; 525b38bc9c2SAlexander Aring } 526b38bc9c2SAlexander Aring 527391fbdc5SChristine Caulfield lowcomms_connect_sock(con); 528b38bc9c2SAlexander Aring srcu_read_unlock(&connections_srcu, idx); 529b38bc9c2SAlexander Aring 530391fbdc5SChristine Caulfield return 0; 531391fbdc5SChristine Caulfield } 532391fbdc5SChristine Caulfield 533e125fbebSAlexander Aring int dlm_lowcomms_nodes_set_mark(int nodeid, unsigned int mark) 534e125fbebSAlexander Aring { 535e125fbebSAlexander Aring struct dlm_node_addr *na; 536e125fbebSAlexander Aring 537e125fbebSAlexander Aring spin_lock(&dlm_node_addrs_spin); 538e125fbebSAlexander Aring na = find_node_addr(nodeid); 539e125fbebSAlexander Aring if (!na) { 540e125fbebSAlexander Aring spin_unlock(&dlm_node_addrs_spin); 541e125fbebSAlexander Aring return -ENOENT; 542e125fbebSAlexander Aring } 543e125fbebSAlexander Aring 544e125fbebSAlexander Aring na->mark = mark; 545e125fbebSAlexander Aring spin_unlock(&dlm_node_addrs_spin); 546e125fbebSAlexander Aring 547e125fbebSAlexander Aring return 0; 548e125fbebSAlexander Aring } 549e125fbebSAlexander Aring 550b3a5bbfdSBob Peterson static void lowcomms_error_report(struct sock *sk) 551b3a5bbfdSBob Peterson { 552b81171cbSBob Peterson struct connection *con; 553b3a5bbfdSBob Peterson struct sockaddr_storage saddr; 554b81171cbSBob Peterson void (*orig_report)(struct sock *) = NULL; 555b3a5bbfdSBob Peterson 556b81171cbSBob Peterson read_lock_bh(&sk->sk_callback_lock); 557b81171cbSBob Peterson con = sock2con(sk); 558b81171cbSBob Peterson if (con == NULL) 559b81171cbSBob Peterson goto out; 560b81171cbSBob Peterson 561cc661fc9SBob Peterson orig_report = listen_sock.sk_error_report; 5621a31833dSBob Peterson if (con->sock == NULL || 5639b2c45d4SDenys Vlasenko kernel_getpeername(con->sock, (struct sockaddr *)&saddr) < 0) { 564b3a5bbfdSBob Peterson printk_ratelimited(KERN_ERR "dlm: node %d: socket error " 565b3a5bbfdSBob Peterson "sending to node %d, port %d, " 566b3a5bbfdSBob Peterson "sk_err=%d/%d\n", dlm_our_nodeid(), 567b3a5bbfdSBob Peterson con->nodeid, dlm_config.ci_tcp_port, 568b3a5bbfdSBob Peterson sk->sk_err, sk->sk_err_soft); 569b3a5bbfdSBob Peterson } else if (saddr.ss_family == AF_INET) { 570b3a5bbfdSBob Peterson struct sockaddr_in *sin4 = (struct sockaddr_in *)&saddr; 571b3a5bbfdSBob Peterson 572b3a5bbfdSBob Peterson printk_ratelimited(KERN_ERR "dlm: node %d: socket error " 573b3a5bbfdSBob Peterson "sending to node %d at %pI4, port %d, " 574b3a5bbfdSBob Peterson "sk_err=%d/%d\n", dlm_our_nodeid(), 575b3a5bbfdSBob Peterson con->nodeid, &sin4->sin_addr.s_addr, 576b3a5bbfdSBob Peterson dlm_config.ci_tcp_port, sk->sk_err, 577b3a5bbfdSBob Peterson sk->sk_err_soft); 578b3a5bbfdSBob Peterson } else { 579b3a5bbfdSBob Peterson struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)&saddr; 580b3a5bbfdSBob Peterson 581b3a5bbfdSBob Peterson printk_ratelimited(KERN_ERR "dlm: node %d: socket error " 582b3a5bbfdSBob Peterson "sending to node %d at %u.%u.%u.%u, " 583b3a5bbfdSBob Peterson "port %d, sk_err=%d/%d\n", dlm_our_nodeid(), 584b3a5bbfdSBob Peterson con->nodeid, sin6->sin6_addr.s6_addr32[0], 585b3a5bbfdSBob Peterson sin6->sin6_addr.s6_addr32[1], 586b3a5bbfdSBob Peterson sin6->sin6_addr.s6_addr32[2], 587b3a5bbfdSBob Peterson sin6->sin6_addr.s6_addr32[3], 588b3a5bbfdSBob Peterson dlm_config.ci_tcp_port, sk->sk_err, 589b3a5bbfdSBob Peterson sk->sk_err_soft); 590b3a5bbfdSBob Peterson } 591ba868d9dSAlexander Aring 592ba868d9dSAlexander Aring /* below sendcon only handling */ 593ba868d9dSAlexander Aring if (test_bit(CF_IS_OTHERCON, &con->flags)) 594ba868d9dSAlexander Aring con = con->sendcon; 595ba868d9dSAlexander Aring 596ba868d9dSAlexander Aring switch (sk->sk_err) { 597ba868d9dSAlexander Aring case ECONNREFUSED: 598ba868d9dSAlexander Aring set_bit(CF_DELAY_CONNECT, &con->flags); 599ba868d9dSAlexander Aring break; 600ba868d9dSAlexander Aring default: 601ba868d9dSAlexander Aring break; 602ba868d9dSAlexander Aring } 603ba868d9dSAlexander Aring 604ba868d9dSAlexander Aring if (!test_and_set_bit(CF_RECONNECT, &con->flags)) 605ba868d9dSAlexander Aring queue_work(send_workqueue, &con->swork); 606ba868d9dSAlexander Aring 607b81171cbSBob Peterson out: 608b81171cbSBob Peterson read_unlock_bh(&sk->sk_callback_lock); 609b81171cbSBob Peterson if (orig_report) 610b81171cbSBob Peterson orig_report(sk); 611b81171cbSBob Peterson } 612b81171cbSBob Peterson 613b81171cbSBob Peterson /* Note: sk_callback_lock must be locked before calling this function. */ 614cc661fc9SBob Peterson static void save_listen_callbacks(struct socket *sock) 615b81171cbSBob Peterson { 616cc661fc9SBob Peterson struct sock *sk = sock->sk; 617cc661fc9SBob Peterson 618cc661fc9SBob Peterson listen_sock.sk_data_ready = sk->sk_data_ready; 619cc661fc9SBob Peterson listen_sock.sk_state_change = sk->sk_state_change; 620cc661fc9SBob Peterson listen_sock.sk_write_space = sk->sk_write_space; 621cc661fc9SBob Peterson listen_sock.sk_error_report = sk->sk_error_report; 622b81171cbSBob Peterson } 623b81171cbSBob Peterson 624cc661fc9SBob Peterson static void restore_callbacks(struct socket *sock) 625b81171cbSBob Peterson { 626cc661fc9SBob Peterson struct sock *sk = sock->sk; 627cc661fc9SBob Peterson 628b81171cbSBob Peterson write_lock_bh(&sk->sk_callback_lock); 629b81171cbSBob Peterson sk->sk_user_data = NULL; 630cc661fc9SBob Peterson sk->sk_data_ready = listen_sock.sk_data_ready; 631cc661fc9SBob Peterson sk->sk_state_change = listen_sock.sk_state_change; 632cc661fc9SBob Peterson sk->sk_write_space = listen_sock.sk_write_space; 633cc661fc9SBob Peterson sk->sk_error_report = listen_sock.sk_error_report; 634b81171cbSBob Peterson write_unlock_bh(&sk->sk_callback_lock); 635b3a5bbfdSBob Peterson } 636b3a5bbfdSBob Peterson 637d11ccd45SAlexander Aring static void add_listen_sock(struct socket *sock, struct listen_connection *con) 638d11ccd45SAlexander Aring { 639d11ccd45SAlexander Aring struct sock *sk = sock->sk; 640d11ccd45SAlexander Aring 641d11ccd45SAlexander Aring write_lock_bh(&sk->sk_callback_lock); 642d11ccd45SAlexander Aring save_listen_callbacks(sock); 643d11ccd45SAlexander Aring con->sock = sock; 644d11ccd45SAlexander Aring 645d11ccd45SAlexander Aring sk->sk_user_data = con; 646d11ccd45SAlexander Aring sk->sk_allocation = GFP_NOFS; 647d11ccd45SAlexander Aring /* Install a data_ready callback */ 648d11ccd45SAlexander Aring sk->sk_data_ready = lowcomms_listen_data_ready; 649d11ccd45SAlexander Aring write_unlock_bh(&sk->sk_callback_lock); 650d11ccd45SAlexander Aring } 651d11ccd45SAlexander Aring 6526ed7257bSPatrick Caulfield /* Make a socket active */ 653988419a9Stsutomu.owa@toshiba.co.jp static void add_sock(struct socket *sock, struct connection *con) 6546ed7257bSPatrick Caulfield { 655b81171cbSBob Peterson struct sock *sk = sock->sk; 656b81171cbSBob Peterson 657b81171cbSBob Peterson write_lock_bh(&sk->sk_callback_lock); 6586ed7257bSPatrick Caulfield con->sock = sock; 6596ed7257bSPatrick Caulfield 660b81171cbSBob Peterson sk->sk_user_data = con; 6616ed7257bSPatrick Caulfield /* Install a data_ready callback */ 662b81171cbSBob Peterson sk->sk_data_ready = lowcomms_data_ready; 663b81171cbSBob Peterson sk->sk_write_space = lowcomms_write_space; 664b81171cbSBob Peterson sk->sk_state_change = lowcomms_state_change; 665b81171cbSBob Peterson sk->sk_allocation = GFP_NOFS; 666b81171cbSBob Peterson sk->sk_error_report = lowcomms_error_report; 667b81171cbSBob Peterson write_unlock_bh(&sk->sk_callback_lock); 6686ed7257bSPatrick Caulfield } 6696ed7257bSPatrick Caulfield 6706ed7257bSPatrick Caulfield /* Add the port number to an IPv6 or 4 sockaddr and return the address 6716ed7257bSPatrick Caulfield length */ 6726ed7257bSPatrick Caulfield static void make_sockaddr(struct sockaddr_storage *saddr, uint16_t port, 6736ed7257bSPatrick Caulfield int *addr_len) 6746ed7257bSPatrick Caulfield { 6756ed7257bSPatrick Caulfield saddr->ss_family = dlm_local_addr[0]->ss_family; 6766ed7257bSPatrick Caulfield if (saddr->ss_family == AF_INET) { 6776ed7257bSPatrick Caulfield struct sockaddr_in *in4_addr = (struct sockaddr_in *)saddr; 6786ed7257bSPatrick Caulfield in4_addr->sin_port = cpu_to_be16(port); 6796ed7257bSPatrick Caulfield *addr_len = sizeof(struct sockaddr_in); 6806ed7257bSPatrick Caulfield memset(&in4_addr->sin_zero, 0, sizeof(in4_addr->sin_zero)); 6816ed7257bSPatrick Caulfield } else { 6826ed7257bSPatrick Caulfield struct sockaddr_in6 *in6_addr = (struct sockaddr_in6 *)saddr; 6836ed7257bSPatrick Caulfield in6_addr->sin6_port = cpu_to_be16(port); 6846ed7257bSPatrick Caulfield *addr_len = sizeof(struct sockaddr_in6); 6856ed7257bSPatrick Caulfield } 68601c8cab2SPatrick Caulfield memset((char *)saddr + *addr_len, 0, sizeof(struct sockaddr_storage) - *addr_len); 6876ed7257bSPatrick Caulfield } 6886ed7257bSPatrick Caulfield 689d11ccd45SAlexander Aring static void dlm_close_sock(struct socket **sock) 690d11ccd45SAlexander Aring { 691d11ccd45SAlexander Aring if (*sock) { 692d11ccd45SAlexander Aring restore_callbacks(*sock); 693d11ccd45SAlexander Aring sock_release(*sock); 694d11ccd45SAlexander Aring *sock = NULL; 695d11ccd45SAlexander Aring } 696d11ccd45SAlexander Aring } 697d11ccd45SAlexander Aring 6986ed7257bSPatrick Caulfield /* Close a remote connection and tidy up */ 6990d737a8cSMarcelo Ricardo Leitner static void close_connection(struct connection *con, bool and_other, 7000d737a8cSMarcelo Ricardo Leitner bool tx, bool rx) 7016ed7257bSPatrick Caulfield { 702b2a66629Stsutomu.owa@toshiba.co.jp bool closing = test_and_set_bit(CF_CLOSING, &con->flags); 703b2a66629Stsutomu.owa@toshiba.co.jp 7040aa18464Stsutomu.owa@toshiba.co.jp if (tx && !closing && cancel_work_sync(&con->swork)) { 7050d737a8cSMarcelo Ricardo Leitner log_print("canceled swork for node %d", con->nodeid); 7060aa18464Stsutomu.owa@toshiba.co.jp clear_bit(CF_WRITE_PENDING, &con->flags); 7070aa18464Stsutomu.owa@toshiba.co.jp } 7080aa18464Stsutomu.owa@toshiba.co.jp if (rx && !closing && cancel_work_sync(&con->rwork)) { 7090d737a8cSMarcelo Ricardo Leitner log_print("canceled rwork for node %d", con->nodeid); 7100aa18464Stsutomu.owa@toshiba.co.jp clear_bit(CF_READ_PENDING, &con->flags); 7110aa18464Stsutomu.owa@toshiba.co.jp } 7126ed7257bSPatrick Caulfield 7130d737a8cSMarcelo Ricardo Leitner mutex_lock(&con->sock_mutex); 714d11ccd45SAlexander Aring dlm_close_sock(&con->sock); 715d11ccd45SAlexander Aring 7166ed7257bSPatrick Caulfield if (con->othercon && and_other) { 7176ed7257bSPatrick Caulfield /* Will only re-enter once. */ 718*c6aa00e3SAlexander Aring close_connection(con->othercon, false, tx, rx); 7196ed7257bSPatrick Caulfield } 7209e5f2825SPatrick Caulfield 7214798cbbfSAlexander Aring con->rx_leftover = 0; 7226ed7257bSPatrick Caulfield con->retries = 0; 72319633c7eSAlexander Aring clear_bit(CF_CONNECTED, &con->flags); 724ba868d9dSAlexander Aring clear_bit(CF_DELAY_CONNECT, &con->flags); 725ba868d9dSAlexander Aring clear_bit(CF_RECONNECT, &con->flags); 7266ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 727b2a66629Stsutomu.owa@toshiba.co.jp clear_bit(CF_CLOSING, &con->flags); 7286ed7257bSPatrick Caulfield } 7296ed7257bSPatrick Caulfield 730055923bfSAlexander Aring static void shutdown_connection(struct connection *con) 731055923bfSAlexander Aring { 732055923bfSAlexander Aring int ret; 733055923bfSAlexander Aring 734eec054b5SAlexander Aring flush_work(&con->swork); 735055923bfSAlexander Aring 736055923bfSAlexander Aring mutex_lock(&con->sock_mutex); 737055923bfSAlexander Aring /* nothing to shutdown */ 738055923bfSAlexander Aring if (!con->sock) { 739055923bfSAlexander Aring mutex_unlock(&con->sock_mutex); 740055923bfSAlexander Aring return; 741055923bfSAlexander Aring } 742055923bfSAlexander Aring 743055923bfSAlexander Aring set_bit(CF_SHUTDOWN, &con->flags); 744055923bfSAlexander Aring ret = kernel_sock_shutdown(con->sock, SHUT_WR); 745055923bfSAlexander Aring mutex_unlock(&con->sock_mutex); 746055923bfSAlexander Aring if (ret) { 747055923bfSAlexander Aring log_print("Connection %p failed to shutdown: %d will force close", 748055923bfSAlexander Aring con, ret); 749055923bfSAlexander Aring goto force_close; 750055923bfSAlexander Aring } else { 751055923bfSAlexander Aring ret = wait_event_timeout(con->shutdown_wait, 752055923bfSAlexander Aring !test_bit(CF_SHUTDOWN, &con->flags), 753055923bfSAlexander Aring DLM_SHUTDOWN_WAIT_TIMEOUT); 754055923bfSAlexander Aring if (ret == 0) { 755055923bfSAlexander Aring log_print("Connection %p shutdown timed out, will force close", 756055923bfSAlexander Aring con); 757055923bfSAlexander Aring goto force_close; 758055923bfSAlexander Aring } 759055923bfSAlexander Aring } 760055923bfSAlexander Aring 761055923bfSAlexander Aring return; 762055923bfSAlexander Aring 763055923bfSAlexander Aring force_close: 764055923bfSAlexander Aring clear_bit(CF_SHUTDOWN, &con->flags); 765055923bfSAlexander Aring close_connection(con, false, true, true); 766055923bfSAlexander Aring } 767055923bfSAlexander Aring 768055923bfSAlexander Aring static void dlm_tcp_shutdown(struct connection *con) 769055923bfSAlexander Aring { 770055923bfSAlexander Aring if (con->othercon) 771055923bfSAlexander Aring shutdown_connection(con->othercon); 772055923bfSAlexander Aring shutdown_connection(con); 773055923bfSAlexander Aring } 774055923bfSAlexander Aring 7754798cbbfSAlexander Aring static int con_realloc_receive_buf(struct connection *con, int newlen) 7764798cbbfSAlexander Aring { 7774798cbbfSAlexander Aring unsigned char *newbuf; 7784798cbbfSAlexander Aring 7794798cbbfSAlexander Aring newbuf = kmalloc(newlen, GFP_NOFS); 7804798cbbfSAlexander Aring if (!newbuf) 7814798cbbfSAlexander Aring return -ENOMEM; 7824798cbbfSAlexander Aring 7834798cbbfSAlexander Aring /* copy any leftover from last receive */ 7844798cbbfSAlexander Aring if (con->rx_leftover) 7854798cbbfSAlexander Aring memmove(newbuf, con->rx_buf, con->rx_leftover); 7864798cbbfSAlexander Aring 7874798cbbfSAlexander Aring /* swap to new buffer space */ 7884798cbbfSAlexander Aring kfree(con->rx_buf); 7894798cbbfSAlexander Aring con->rx_buflen = newlen; 7904798cbbfSAlexander Aring con->rx_buf = newbuf; 7914798cbbfSAlexander Aring 7924798cbbfSAlexander Aring return 0; 7934798cbbfSAlexander Aring } 7944798cbbfSAlexander Aring 7956ed7257bSPatrick Caulfield /* Data received from remote end */ 7966ed7257bSPatrick Caulfield static int receive_from_sock(struct connection *con) 7976ed7257bSPatrick Caulfield { 7986ed7257bSPatrick Caulfield int call_again_soon = 0; 7994798cbbfSAlexander Aring struct msghdr msg; 8004798cbbfSAlexander Aring struct kvec iov; 8014798cbbfSAlexander Aring int ret, buflen; 8026ed7257bSPatrick Caulfield 8036ed7257bSPatrick Caulfield mutex_lock(&con->sock_mutex); 8046ed7257bSPatrick Caulfield 8056ed7257bSPatrick Caulfield if (con->sock == NULL) { 8066ed7257bSPatrick Caulfield ret = -EAGAIN; 8076ed7257bSPatrick Caulfield goto out_close; 8086ed7257bSPatrick Caulfield } 8094798cbbfSAlexander Aring 8104798cbbfSAlexander Aring /* realloc if we get new buffer size to read out */ 8114798cbbfSAlexander Aring buflen = dlm_config.ci_buffer_size; 8124798cbbfSAlexander Aring if (con->rx_buflen != buflen && con->rx_leftover <= buflen) { 8134798cbbfSAlexander Aring ret = con_realloc_receive_buf(con, buflen); 8144798cbbfSAlexander Aring if (ret < 0) 8156ed7257bSPatrick Caulfield goto out_resched; 8166ed7257bSPatrick Caulfield } 8176ed7257bSPatrick Caulfield 8184798cbbfSAlexander Aring /* calculate new buffer parameter regarding last receive and 8194798cbbfSAlexander Aring * possible leftover bytes 8206ed7257bSPatrick Caulfield */ 8214798cbbfSAlexander Aring iov.iov_base = con->rx_buf + con->rx_leftover; 8224798cbbfSAlexander Aring iov.iov_len = con->rx_buflen - con->rx_leftover; 8236ed7257bSPatrick Caulfield 8244798cbbfSAlexander Aring memset(&msg, 0, sizeof(msg)); 8254798cbbfSAlexander Aring msg.msg_flags = MSG_DONTWAIT | MSG_NOSIGNAL; 8264798cbbfSAlexander Aring ret = kernel_recvmsg(con->sock, &msg, &iov, 1, iov.iov_len, 8274798cbbfSAlexander Aring msg.msg_flags); 8286ed7257bSPatrick Caulfield if (ret <= 0) 8296ed7257bSPatrick Caulfield goto out_close; 8304798cbbfSAlexander Aring else if (ret == iov.iov_len) 831ee44b4bcSMarcelo Ricardo Leitner call_again_soon = 1; 8326ed7257bSPatrick Caulfield 8334798cbbfSAlexander Aring /* new buflen according readed bytes and leftover from last receive */ 8344798cbbfSAlexander Aring buflen = ret + con->rx_leftover; 8354798cbbfSAlexander Aring ret = dlm_process_incoming_buffer(con->nodeid, con->rx_buf, buflen); 8364798cbbfSAlexander Aring if (ret < 0) 8374798cbbfSAlexander Aring goto out_close; 8386ed7257bSPatrick Caulfield 8394798cbbfSAlexander Aring /* calculate leftover bytes from process and put it into begin of 8404798cbbfSAlexander Aring * the receive buffer, so next receive we have the full message 8414798cbbfSAlexander Aring * at the start address of the receive buffer. 8424798cbbfSAlexander Aring */ 8434798cbbfSAlexander Aring con->rx_leftover = buflen - ret; 8444798cbbfSAlexander Aring if (con->rx_leftover) { 8454798cbbfSAlexander Aring memmove(con->rx_buf, con->rx_buf + ret, 8464798cbbfSAlexander Aring con->rx_leftover); 8474798cbbfSAlexander Aring call_again_soon = true; 8486ed7257bSPatrick Caulfield } 8496ed7257bSPatrick Caulfield 8506ed7257bSPatrick Caulfield if (call_again_soon) 8516ed7257bSPatrick Caulfield goto out_resched; 8524798cbbfSAlexander Aring 8536ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 8546ed7257bSPatrick Caulfield return 0; 8556ed7257bSPatrick Caulfield 8566ed7257bSPatrick Caulfield out_resched: 8576ed7257bSPatrick Caulfield if (!test_and_set_bit(CF_READ_PENDING, &con->flags)) 8586ed7257bSPatrick Caulfield queue_work(recv_workqueue, &con->rwork); 8596ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 8606ed7257bSPatrick Caulfield return -EAGAIN; 8616ed7257bSPatrick Caulfield 8626ed7257bSPatrick Caulfield out_close: 8636ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 864055923bfSAlexander Aring if (ret == 0) { 865ba868d9dSAlexander Aring close_connection(con, false, true, false); 866055923bfSAlexander Aring log_print("connection %p got EOF from %d", 867055923bfSAlexander Aring con, con->nodeid); 868055923bfSAlexander Aring /* handling for tcp shutdown */ 869055923bfSAlexander Aring clear_bit(CF_SHUTDOWN, &con->flags); 870055923bfSAlexander Aring wake_up(&con->shutdown_wait); 871055923bfSAlexander Aring /* signal to breaking receive worker */ 872055923bfSAlexander Aring ret = -1; 8736ed7257bSPatrick Caulfield } 8746ed7257bSPatrick Caulfield return ret; 8756ed7257bSPatrick Caulfield } 8766ed7257bSPatrick Caulfield 8776ed7257bSPatrick Caulfield /* Listening socket is busy, accept a connection */ 878d11ccd45SAlexander Aring static int accept_from_sock(struct listen_connection *con) 8796ed7257bSPatrick Caulfield { 8806ed7257bSPatrick Caulfield int result; 8816ed7257bSPatrick Caulfield struct sockaddr_storage peeraddr; 8826ed7257bSPatrick Caulfield struct socket *newsock; 883b38bc9c2SAlexander Aring int len, idx; 8846ed7257bSPatrick Caulfield int nodeid; 8856ed7257bSPatrick Caulfield struct connection *newcon; 8866ed7257bSPatrick Caulfield struct connection *addcon; 8873f78cd7dSAlexander Aring unsigned int mark; 8886ed7257bSPatrick Caulfield 889513ef596SDavid Teigland if (!dlm_allow_conn) { 890513ef596SDavid Teigland return -1; 891513ef596SDavid Teigland } 892513ef596SDavid Teigland 893d11ccd45SAlexander Aring if (!con->sock) 8943421fb15Stsutomu.owa@toshiba.co.jp return -ENOTCONN; 8956ed7257bSPatrick Caulfield 8963421fb15Stsutomu.owa@toshiba.co.jp result = kernel_accept(con->sock, &newsock, O_NONBLOCK); 8976ed7257bSPatrick Caulfield if (result < 0) 8986ed7257bSPatrick Caulfield goto accept_err; 8996ed7257bSPatrick Caulfield 9006ed7257bSPatrick Caulfield /* Get the connected socket's peer */ 9016ed7257bSPatrick Caulfield memset(&peeraddr, 0, sizeof(peeraddr)); 9029b2c45d4SDenys Vlasenko len = newsock->ops->getname(newsock, (struct sockaddr *)&peeraddr, 2); 9039b2c45d4SDenys Vlasenko if (len < 0) { 9046ed7257bSPatrick Caulfield result = -ECONNABORTED; 9056ed7257bSPatrick Caulfield goto accept_err; 9066ed7257bSPatrick Caulfield } 9076ed7257bSPatrick Caulfield 9086ed7257bSPatrick Caulfield /* Get the new node's NODEID */ 9096ed7257bSPatrick Caulfield make_sockaddr(&peeraddr, 0, &len); 910e125fbebSAlexander Aring if (addr_to_nodeid(&peeraddr, &nodeid, &mark)) { 911bcaadf5cSMasatake YAMATO unsigned char *b=(unsigned char *)&peeraddr; 912617e82e1SDavid Teigland log_print("connect from non cluster node"); 913bcaadf5cSMasatake YAMATO print_hex_dump_bytes("ss: ", DUMP_PREFIX_NONE, 914bcaadf5cSMasatake YAMATO b, sizeof(struct sockaddr_storage)); 9156ed7257bSPatrick Caulfield sock_release(newsock); 9166ed7257bSPatrick Caulfield return -1; 9176ed7257bSPatrick Caulfield } 9186ed7257bSPatrick Caulfield 9196ed7257bSPatrick Caulfield log_print("got connection from %d", nodeid); 9206ed7257bSPatrick Caulfield 9216ed7257bSPatrick Caulfield /* Check to see if we already have a connection to this node. This 9226ed7257bSPatrick Caulfield * could happen if the two nodes initiate a connection at roughly 9236ed7257bSPatrick Caulfield * the same time and the connections cross on the wire. 9246ed7257bSPatrick Caulfield * In this case we store the incoming one in "othercon" 9256ed7257bSPatrick Caulfield */ 926b38bc9c2SAlexander Aring idx = srcu_read_lock(&connections_srcu); 927748285ccSDavid Teigland newcon = nodeid2con(nodeid, GFP_NOFS); 9286ed7257bSPatrick Caulfield if (!newcon) { 929b38bc9c2SAlexander Aring srcu_read_unlock(&connections_srcu, idx); 9306ed7257bSPatrick Caulfield result = -ENOMEM; 9316ed7257bSPatrick Caulfield goto accept_err; 9326ed7257bSPatrick Caulfield } 933d11ccd45SAlexander Aring 934e125fbebSAlexander Aring sock_set_mark(newsock->sk, mark); 935e125fbebSAlexander Aring 936d11ccd45SAlexander Aring mutex_lock(&newcon->sock_mutex); 9376ed7257bSPatrick Caulfield if (newcon->sock) { 9386ed7257bSPatrick Caulfield struct connection *othercon = newcon->othercon; 9396ed7257bSPatrick Caulfield 9406ed7257bSPatrick Caulfield if (!othercon) { 941a47666ebSAlexander Aring othercon = kzalloc(sizeof(*othercon), GFP_NOFS); 9426ed7257bSPatrick Caulfield if (!othercon) { 943617e82e1SDavid Teigland log_print("failed to allocate incoming socket"); 9446ed7257bSPatrick Caulfield mutex_unlock(&newcon->sock_mutex); 945b38bc9c2SAlexander Aring srcu_read_unlock(&connections_srcu, idx); 9466ed7257bSPatrick Caulfield result = -ENOMEM; 9476ed7257bSPatrick Caulfield goto accept_err; 9486ed7257bSPatrick Caulfield } 9494798cbbfSAlexander Aring 9506cde210aSAlexander Aring result = dlm_con_init(othercon, nodeid); 9516cde210aSAlexander Aring if (result < 0) { 9524798cbbfSAlexander Aring kfree(othercon); 9532fd8db2dSYang Yingliang mutex_unlock(&newcon->sock_mutex); 954b38bc9c2SAlexander Aring srcu_read_unlock(&connections_srcu, idx); 9554798cbbfSAlexander Aring goto accept_err; 9564798cbbfSAlexander Aring } 9574798cbbfSAlexander Aring 958e9a470acSAlexander Aring lockdep_set_subclass(&othercon->sock_mutex, 1); 9597443bc96SAlexander Aring set_bit(CF_IS_OTHERCON, &othercon->flags); 9606cde210aSAlexander Aring newcon->othercon = othercon; 961ba868d9dSAlexander Aring othercon->sendcon = newcon; 962ba3ab3caSAlexander Aring } else { 963ba3ab3caSAlexander Aring /* close other sock con if we have something new */ 964ba3ab3caSAlexander Aring close_connection(othercon, false, true, false); 96561d96be0SPatrick Caulfield } 966ba3ab3caSAlexander Aring 967e9a470acSAlexander Aring mutex_lock(&othercon->sock_mutex); 968988419a9Stsutomu.owa@toshiba.co.jp add_sock(newsock, othercon); 9696ed7257bSPatrick Caulfield addcon = othercon; 970c7355827Stsutomu.owa@toshiba.co.jp mutex_unlock(&othercon->sock_mutex); 9716ed7257bSPatrick Caulfield } 9726ed7257bSPatrick Caulfield else { 9733735b4b9SBob Peterson /* accept copies the sk after we've saved the callbacks, so we 9743735b4b9SBob Peterson don't want to save them a second time or comm errors will 9753735b4b9SBob Peterson result in calling sk_error_report recursively. */ 976988419a9Stsutomu.owa@toshiba.co.jp add_sock(newsock, newcon); 9776ed7257bSPatrick Caulfield addcon = newcon; 9786ed7257bSPatrick Caulfield } 9796ed7257bSPatrick Caulfield 980b30a624fSAlexander Aring set_bit(CF_CONNECTED, &addcon->flags); 9816ed7257bSPatrick Caulfield mutex_unlock(&newcon->sock_mutex); 9826ed7257bSPatrick Caulfield 9836ed7257bSPatrick Caulfield /* 9846ed7257bSPatrick Caulfield * Add it to the active queue in case we got data 98525985edcSLucas De Marchi * between processing the accept adding the socket 9866ed7257bSPatrick Caulfield * to the read_sockets list 9876ed7257bSPatrick Caulfield */ 9886ed7257bSPatrick Caulfield if (!test_and_set_bit(CF_READ_PENDING, &addcon->flags)) 9896ed7257bSPatrick Caulfield queue_work(recv_workqueue, &addcon->rwork); 9906ed7257bSPatrick Caulfield 991b38bc9c2SAlexander Aring srcu_read_unlock(&connections_srcu, idx); 992b38bc9c2SAlexander Aring 9936ed7257bSPatrick Caulfield return 0; 9946ed7257bSPatrick Caulfield 9956ed7257bSPatrick Caulfield accept_err: 9963421fb15Stsutomu.owa@toshiba.co.jp if (newsock) 9976ed7257bSPatrick Caulfield sock_release(newsock); 9986ed7257bSPatrick Caulfield 9996ed7257bSPatrick Caulfield if (result != -EAGAIN) 1000617e82e1SDavid Teigland log_print("error accepting connection from node: %d", result); 10016ed7257bSPatrick Caulfield return result; 10026ed7257bSPatrick Caulfield } 10036ed7257bSPatrick Caulfield 10046ed7257bSPatrick Caulfield static void free_entry(struct writequeue_entry *e) 10056ed7257bSPatrick Caulfield { 10066ed7257bSPatrick Caulfield __free_page(e->page); 10076ed7257bSPatrick Caulfield kfree(e); 10086ed7257bSPatrick Caulfield } 10096ed7257bSPatrick Caulfield 10105d689871SMike Christie /* 10115d689871SMike Christie * writequeue_entry_complete - try to delete and free write queue entry 10125d689871SMike Christie * @e: write queue entry to try to delete 10135d689871SMike Christie * @completed: bytes completed 10145d689871SMike Christie * 10155d689871SMike Christie * writequeue_lock must be held. 10165d689871SMike Christie */ 10175d689871SMike Christie static void writequeue_entry_complete(struct writequeue_entry *e, int completed) 10185d689871SMike Christie { 10195d689871SMike Christie e->offset += completed; 10205d689871SMike Christie e->len -= completed; 10215d689871SMike Christie 10225d689871SMike Christie if (e->len == 0 && e->users == 0) { 10235d689871SMike Christie list_del(&e->list); 10245d689871SMike Christie free_entry(e); 10255d689871SMike Christie } 10265d689871SMike Christie } 10275d689871SMike Christie 1028ee44b4bcSMarcelo Ricardo Leitner /* 1029ee44b4bcSMarcelo Ricardo Leitner * sctp_bind_addrs - bind a SCTP socket to all our addresses 1030ee44b4bcSMarcelo Ricardo Leitner */ 103113004e8aSAlexander Aring static int sctp_bind_addrs(struct socket *sock, uint16_t port) 1032ee44b4bcSMarcelo Ricardo Leitner { 1033ee44b4bcSMarcelo Ricardo Leitner struct sockaddr_storage localaddr; 1034c0425a42SChristoph Hellwig struct sockaddr *addr = (struct sockaddr *)&localaddr; 1035ee44b4bcSMarcelo Ricardo Leitner int i, addr_len, result = 0; 1036ee44b4bcSMarcelo Ricardo Leitner 1037ee44b4bcSMarcelo Ricardo Leitner for (i = 0; i < dlm_local_count; i++) { 1038ee44b4bcSMarcelo Ricardo Leitner memcpy(&localaddr, dlm_local_addr[i], sizeof(localaddr)); 1039ee44b4bcSMarcelo Ricardo Leitner make_sockaddr(&localaddr, port, &addr_len); 1040ee44b4bcSMarcelo Ricardo Leitner 1041ee44b4bcSMarcelo Ricardo Leitner if (!i) 104213004e8aSAlexander Aring result = kernel_bind(sock, addr, addr_len); 1043ee44b4bcSMarcelo Ricardo Leitner else 104413004e8aSAlexander Aring result = sock_bind_add(sock->sk, addr, addr_len); 1045ee44b4bcSMarcelo Ricardo Leitner 1046ee44b4bcSMarcelo Ricardo Leitner if (result < 0) { 1047ee44b4bcSMarcelo Ricardo Leitner log_print("Can't bind to %d addr number %d, %d.\n", 1048ee44b4bcSMarcelo Ricardo Leitner port, i + 1, result); 1049ee44b4bcSMarcelo Ricardo Leitner break; 1050ee44b4bcSMarcelo Ricardo Leitner } 1051ee44b4bcSMarcelo Ricardo Leitner } 1052ee44b4bcSMarcelo Ricardo Leitner return result; 1053ee44b4bcSMarcelo Ricardo Leitner } 1054ee44b4bcSMarcelo Ricardo Leitner 10556ed7257bSPatrick Caulfield /* Initiate an SCTP association. 10566ed7257bSPatrick Caulfield This is a special case of send_to_sock() in that we don't yet have a 10576ed7257bSPatrick Caulfield peeled-off socket for this association, so we use the listening socket 10586ed7257bSPatrick Caulfield and add the primary IP address of the remote node. 10596ed7257bSPatrick Caulfield */ 1060ee44b4bcSMarcelo Ricardo Leitner static void sctp_connect_to_sock(struct connection *con) 10616ed7257bSPatrick Caulfield { 1062ee44b4bcSMarcelo Ricardo Leitner struct sockaddr_storage daddr; 1063ee44b4bcSMarcelo Ricardo Leitner int result; 1064ee44b4bcSMarcelo Ricardo Leitner int addr_len; 1065ee44b4bcSMarcelo Ricardo Leitner struct socket *sock; 10669c9f168fSAlexander Aring unsigned int mark; 1067ee44b4bcSMarcelo Ricardo Leitner 10685d689871SMike Christie mutex_lock(&con->sock_mutex); 10696ed7257bSPatrick Caulfield 1070ee44b4bcSMarcelo Ricardo Leitner /* Some odd races can cause double-connects, ignore them */ 1071ee44b4bcSMarcelo Ricardo Leitner if (con->retries++ > MAX_CONNECT_RETRIES) 1072ee44b4bcSMarcelo Ricardo Leitner goto out; 1073ee44b4bcSMarcelo Ricardo Leitner 1074ee44b4bcSMarcelo Ricardo Leitner if (con->sock) { 1075ee44b4bcSMarcelo Ricardo Leitner log_print("node %d already connected.", con->nodeid); 1076ee44b4bcSMarcelo Ricardo Leitner goto out; 1077ee44b4bcSMarcelo Ricardo Leitner } 1078ee44b4bcSMarcelo Ricardo Leitner 1079ee44b4bcSMarcelo Ricardo Leitner memset(&daddr, 0, sizeof(daddr)); 1080e125fbebSAlexander Aring result = nodeid_to_addr(con->nodeid, &daddr, NULL, true, &mark); 1081ee44b4bcSMarcelo Ricardo Leitner if (result < 0) { 10826ed7257bSPatrick Caulfield log_print("no address for nodeid %d", con->nodeid); 1083ee44b4bcSMarcelo Ricardo Leitner goto out; 108404bedd79SDavid Teigland } 10856ed7257bSPatrick Caulfield 1086ee44b4bcSMarcelo Ricardo Leitner /* Create a socket to communicate with */ 1087ee44b4bcSMarcelo Ricardo Leitner result = sock_create_kern(&init_net, dlm_local_addr[0]->ss_family, 1088ee44b4bcSMarcelo Ricardo Leitner SOCK_STREAM, IPPROTO_SCTP, &sock); 1089ee44b4bcSMarcelo Ricardo Leitner if (result < 0) 1090ee44b4bcSMarcelo Ricardo Leitner goto socket_err; 10916ed7257bSPatrick Caulfield 10929c9f168fSAlexander Aring sock_set_mark(sock->sk, mark); 10939c9f168fSAlexander Aring 1094988419a9Stsutomu.owa@toshiba.co.jp add_sock(sock, con); 10956ed7257bSPatrick Caulfield 1096ee44b4bcSMarcelo Ricardo Leitner /* Bind to all addresses. */ 109713004e8aSAlexander Aring if (sctp_bind_addrs(con->sock, 0)) 1098ee44b4bcSMarcelo Ricardo Leitner goto bind_err; 109998e1b60eSMike Christie 1100ee44b4bcSMarcelo Ricardo Leitner make_sockaddr(&daddr, dlm_config.ci_tcp_port, &addr_len); 11016ed7257bSPatrick Caulfield 11022df6b762SAlexander Aring log_print_ratelimited("connecting to %d", con->nodeid); 11036ed7257bSPatrick Caulfield 1104ee44b4bcSMarcelo Ricardo Leitner /* Turn off Nagle's algorithm */ 110540ef92c6SChristoph Hellwig sctp_sock_set_nodelay(sock->sk); 1106ee44b4bcSMarcelo Ricardo Leitner 1107f706d830SGang He /* 1108f706d830SGang He * Make sock->ops->connect() function return in specified time, 1109f706d830SGang He * since O_NONBLOCK argument in connect() function does not work here, 1110f706d830SGang He * then, we should restore the default value of this attribute. 1111f706d830SGang He */ 111276ee0785SChristoph Hellwig sock_set_sndtimeo(sock->sk, 5); 1113ee44b4bcSMarcelo Ricardo Leitner result = sock->ops->connect(sock, (struct sockaddr *)&daddr, addr_len, 1114da3627c3SGang He 0); 111576ee0785SChristoph Hellwig sock_set_sndtimeo(sock->sk, 0); 1116f706d830SGang He 1117ee44b4bcSMarcelo Ricardo Leitner if (result == -EINPROGRESS) 1118ee44b4bcSMarcelo Ricardo Leitner result = 0; 111919633c7eSAlexander Aring if (result == 0) { 112019633c7eSAlexander Aring if (!test_and_set_bit(CF_CONNECTED, &con->flags)) 112119633c7eSAlexander Aring log_print("successful connected to node %d", con->nodeid); 1122ee44b4bcSMarcelo Ricardo Leitner goto out; 112319633c7eSAlexander Aring } 1124ee44b4bcSMarcelo Ricardo Leitner 1125ee44b4bcSMarcelo Ricardo Leitner bind_err: 1126ee44b4bcSMarcelo Ricardo Leitner con->sock = NULL; 1127ee44b4bcSMarcelo Ricardo Leitner sock_release(sock); 1128ee44b4bcSMarcelo Ricardo Leitner 1129ee44b4bcSMarcelo Ricardo Leitner socket_err: 1130ee44b4bcSMarcelo Ricardo Leitner /* 1131ee44b4bcSMarcelo Ricardo Leitner * Some errors are fatal and this list might need adjusting. For other 1132ee44b4bcSMarcelo Ricardo Leitner * errors we try again until the max number of retries is reached. 1133ee44b4bcSMarcelo Ricardo Leitner */ 1134ee44b4bcSMarcelo Ricardo Leitner if (result != -EHOSTUNREACH && 1135ee44b4bcSMarcelo Ricardo Leitner result != -ENETUNREACH && 1136ee44b4bcSMarcelo Ricardo Leitner result != -ENETDOWN && 1137ee44b4bcSMarcelo Ricardo Leitner result != -EINVAL && 1138ee44b4bcSMarcelo Ricardo Leitner result != -EPROTONOSUPPORT) { 1139ee44b4bcSMarcelo Ricardo Leitner log_print("connect %d try %d error %d", con->nodeid, 1140ee44b4bcSMarcelo Ricardo Leitner con->retries, result); 1141ee44b4bcSMarcelo Ricardo Leitner mutex_unlock(&con->sock_mutex); 1142ee44b4bcSMarcelo Ricardo Leitner msleep(1000); 1143ee44b4bcSMarcelo Ricardo Leitner lowcomms_connect_sock(con); 1144ee44b4bcSMarcelo Ricardo Leitner return; 11456ed7257bSPatrick Caulfield } 11465d689871SMike Christie 1147ee44b4bcSMarcelo Ricardo Leitner out: 11485d689871SMike Christie mutex_unlock(&con->sock_mutex); 11496ed7257bSPatrick Caulfield } 11506ed7257bSPatrick Caulfield 11516ed7257bSPatrick Caulfield /* Connect a new socket to its peer */ 11526ed7257bSPatrick Caulfield static void tcp_connect_to_sock(struct connection *con) 11536ed7257bSPatrick Caulfield { 11546bd8fedaSLon Hohberger struct sockaddr_storage saddr, src_addr; 1155e125fbebSAlexander Aring unsigned int mark; 11566ed7257bSPatrick Caulfield int addr_len; 1157a89d63a1SCasey Dahlin struct socket *sock = NULL; 115836b71a8bSDavid Teigland int result; 11596ed7257bSPatrick Caulfield 11606ed7257bSPatrick Caulfield mutex_lock(&con->sock_mutex); 11616ed7257bSPatrick Caulfield if (con->retries++ > MAX_CONNECT_RETRIES) 11626ed7257bSPatrick Caulfield goto out; 11636ed7257bSPatrick Caulfield 11646ed7257bSPatrick Caulfield /* Some odd races can cause double-connects, ignore them */ 116536b71a8bSDavid Teigland if (con->sock) 11666ed7257bSPatrick Caulfield goto out; 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) 11726ed7257bSPatrick Caulfield goto out_err; 11736ed7257bSPatrick Caulfield 11746ed7257bSPatrick Caulfield memset(&saddr, 0, sizeof(saddr)); 1175e125fbebSAlexander Aring result = nodeid_to_addr(con->nodeid, &saddr, NULL, false, &mark); 117636b71a8bSDavid Teigland if (result < 0) { 117736b71a8bSDavid Teigland log_print("no address for nodeid %d", con->nodeid); 11786ed7257bSPatrick Caulfield goto out_err; 117936b71a8bSDavid Teigland } 11806ed7257bSPatrick Caulfield 1181e125fbebSAlexander Aring sock_set_mark(sock->sk, mark); 1182e125fbebSAlexander Aring 1183988419a9Stsutomu.owa@toshiba.co.jp add_sock(sock, con); 11846ed7257bSPatrick Caulfield 11856bd8fedaSLon Hohberger /* Bind to our cluster-known address connecting to avoid 11866bd8fedaSLon Hohberger routing problems */ 11876bd8fedaSLon Hohberger memcpy(&src_addr, dlm_local_addr[0], sizeof(src_addr)); 11886bd8fedaSLon Hohberger make_sockaddr(&src_addr, 0, &addr_len); 11896bd8fedaSLon Hohberger result = sock->ops->bind(sock, (struct sockaddr *) &src_addr, 11906bd8fedaSLon Hohberger addr_len); 11916bd8fedaSLon Hohberger if (result < 0) { 11926bd8fedaSLon Hohberger log_print("could not bind for connect: %d", result); 11936bd8fedaSLon Hohberger /* This *may* not indicate a critical error */ 11946bd8fedaSLon Hohberger } 11956bd8fedaSLon Hohberger 11966ed7257bSPatrick Caulfield make_sockaddr(&saddr, dlm_config.ci_tcp_port, &addr_len); 11976ed7257bSPatrick Caulfield 11982df6b762SAlexander Aring log_print_ratelimited("connecting to %d", con->nodeid); 1199cb2d45daSDavid Teigland 1200cb2d45daSDavid Teigland /* Turn off Nagle's algorithm */ 120112abc5eeSChristoph Hellwig tcp_sock_set_nodelay(sock->sk); 1202cb2d45daSDavid Teigland 120336b71a8bSDavid Teigland result = sock->ops->connect(sock, (struct sockaddr *)&saddr, addr_len, 12046ed7257bSPatrick Caulfield O_NONBLOCK); 12056ed7257bSPatrick Caulfield if (result == -EINPROGRESS) 12066ed7257bSPatrick Caulfield result = 0; 12076ed7257bSPatrick Caulfield if (result == 0) 12086ed7257bSPatrick Caulfield goto out; 12096ed7257bSPatrick Caulfield 12106ed7257bSPatrick Caulfield out_err: 12116ed7257bSPatrick Caulfield if (con->sock) { 12126ed7257bSPatrick Caulfield sock_release(con->sock); 12136ed7257bSPatrick Caulfield con->sock = NULL; 1214a89d63a1SCasey Dahlin } else if (sock) { 1215a89d63a1SCasey Dahlin sock_release(sock); 12166ed7257bSPatrick Caulfield } 12176ed7257bSPatrick Caulfield /* 12186ed7257bSPatrick Caulfield * Some errors are fatal and this list might need adjusting. For other 12196ed7257bSPatrick Caulfield * errors we try again until the max number of retries is reached. 12206ed7257bSPatrick Caulfield */ 122136b71a8bSDavid Teigland if (result != -EHOSTUNREACH && 122236b71a8bSDavid Teigland result != -ENETUNREACH && 122336b71a8bSDavid Teigland result != -ENETDOWN && 122436b71a8bSDavid Teigland result != -EINVAL && 122536b71a8bSDavid Teigland result != -EPROTONOSUPPORT) { 122636b71a8bSDavid Teigland log_print("connect %d try %d error %d", con->nodeid, 122736b71a8bSDavid Teigland con->retries, result); 122836b71a8bSDavid Teigland mutex_unlock(&con->sock_mutex); 122936b71a8bSDavid Teigland msleep(1000); 12306ed7257bSPatrick Caulfield lowcomms_connect_sock(con); 123136b71a8bSDavid Teigland return; 12326ed7257bSPatrick Caulfield } 12336ed7257bSPatrick Caulfield out: 12346ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 12356ed7257bSPatrick Caulfield return; 12366ed7257bSPatrick Caulfield } 12376ed7257bSPatrick Caulfield 1238d11ccd45SAlexander Aring /* On error caller must run dlm_close_sock() for the 1239d11ccd45SAlexander Aring * listen connection socket. 1240d11ccd45SAlexander Aring */ 1241d11ccd45SAlexander Aring static int tcp_create_listen_sock(struct listen_connection *con, 12426ed7257bSPatrick Caulfield struct sockaddr_storage *saddr) 12436ed7257bSPatrick Caulfield { 12446ed7257bSPatrick Caulfield struct socket *sock = NULL; 12456ed7257bSPatrick Caulfield int result = 0; 12466ed7257bSPatrick Caulfield int addr_len; 12476ed7257bSPatrick Caulfield 12486ed7257bSPatrick Caulfield if (dlm_local_addr[0]->ss_family == AF_INET) 12496ed7257bSPatrick Caulfield addr_len = sizeof(struct sockaddr_in); 12506ed7257bSPatrick Caulfield else 12516ed7257bSPatrick Caulfield addr_len = sizeof(struct sockaddr_in6); 12526ed7257bSPatrick Caulfield 12536ed7257bSPatrick Caulfield /* Create a socket to communicate with */ 1254eeb1bd5cSEric W. Biederman result = sock_create_kern(&init_net, dlm_local_addr[0]->ss_family, 1255eeb1bd5cSEric W. Biederman SOCK_STREAM, IPPROTO_TCP, &sock); 12566ed7257bSPatrick Caulfield if (result < 0) { 1257617e82e1SDavid Teigland log_print("Can't create listening comms socket"); 12586ed7257bSPatrick Caulfield goto create_out; 12596ed7257bSPatrick Caulfield } 12606ed7257bSPatrick Caulfield 1261a5b7ab63SAlexander Aring sock_set_mark(sock->sk, dlm_config.ci_mark); 1262a5b7ab63SAlexander Aring 1263cb2d45daSDavid Teigland /* Turn off Nagle's algorithm */ 126412abc5eeSChristoph Hellwig tcp_sock_set_nodelay(sock->sk); 1265cb2d45daSDavid Teigland 1266b58f0e8fSChristoph Hellwig sock_set_reuseaddr(sock->sk); 12676ed7257bSPatrick Caulfield 1268d11ccd45SAlexander Aring add_listen_sock(sock, con); 12696ed7257bSPatrick Caulfield 12706ed7257bSPatrick Caulfield /* Bind to our port */ 12716ed7257bSPatrick Caulfield make_sockaddr(saddr, dlm_config.ci_tcp_port, &addr_len); 12726ed7257bSPatrick Caulfield result = sock->ops->bind(sock, (struct sockaddr *) saddr, addr_len); 12736ed7257bSPatrick Caulfield if (result < 0) { 1274617e82e1SDavid Teigland log_print("Can't bind to port %d", dlm_config.ci_tcp_port); 12756ed7257bSPatrick Caulfield goto create_out; 12766ed7257bSPatrick Caulfield } 1277ce3d9544SChristoph Hellwig sock_set_keepalive(sock->sk); 12786ed7257bSPatrick Caulfield 12796ed7257bSPatrick Caulfield result = sock->ops->listen(sock, 5); 12806ed7257bSPatrick Caulfield if (result < 0) { 1281617e82e1SDavid Teigland log_print("Can't listen on port %d", dlm_config.ci_tcp_port); 12826ed7257bSPatrick Caulfield goto create_out; 12836ed7257bSPatrick Caulfield } 12846ed7257bSPatrick Caulfield 1285d11ccd45SAlexander Aring return 0; 1286d11ccd45SAlexander Aring 12876ed7257bSPatrick Caulfield create_out: 1288d11ccd45SAlexander Aring return result; 12896ed7257bSPatrick Caulfield } 12906ed7257bSPatrick Caulfield 12916ed7257bSPatrick Caulfield /* Get local addresses */ 12926ed7257bSPatrick Caulfield static void init_local(void) 12936ed7257bSPatrick Caulfield { 12946ed7257bSPatrick Caulfield struct sockaddr_storage sas, *addr; 12956ed7257bSPatrick Caulfield int i; 12966ed7257bSPatrick Caulfield 129730d3a237SPatrick Caulfield dlm_local_count = 0; 12981b189b88SDavid Teigland for (i = 0; i < DLM_MAX_ADDR_COUNT; i++) { 12996ed7257bSPatrick Caulfield if (dlm_our_addr(&sas, i)) 13006ed7257bSPatrick Caulfield break; 13016ed7257bSPatrick Caulfield 13025c93f56fSAmitoj Kaur Chawla addr = kmemdup(&sas, sizeof(*addr), GFP_NOFS); 13036ed7257bSPatrick Caulfield if (!addr) 13046ed7257bSPatrick Caulfield break; 13056ed7257bSPatrick Caulfield dlm_local_addr[dlm_local_count++] = addr; 13066ed7257bSPatrick Caulfield } 13076ed7257bSPatrick Caulfield } 13086ed7257bSPatrick Caulfield 1309043697f0SAlexander Aring static void deinit_local(void) 1310043697f0SAlexander Aring { 1311043697f0SAlexander Aring int i; 1312043697f0SAlexander Aring 1313043697f0SAlexander Aring for (i = 0; i < dlm_local_count; i++) 1314043697f0SAlexander Aring kfree(dlm_local_addr[i]); 1315043697f0SAlexander Aring } 1316043697f0SAlexander Aring 1317d11ccd45SAlexander Aring /* Initialise SCTP socket and bind to all interfaces 1318d11ccd45SAlexander Aring * On error caller must run dlm_close_sock() for the 1319d11ccd45SAlexander Aring * listen connection socket. 1320d11ccd45SAlexander Aring */ 1321d11ccd45SAlexander Aring static int sctp_listen_for_all(struct listen_connection *con) 13226ed7257bSPatrick Caulfield { 13236ed7257bSPatrick Caulfield struct socket *sock = NULL; 1324ee44b4bcSMarcelo Ricardo Leitner int result = -EINVAL; 13256ed7257bSPatrick Caulfield 13266ed7257bSPatrick Caulfield log_print("Using SCTP for communications"); 13276ed7257bSPatrick Caulfield 1328eeb1bd5cSEric W. Biederman result = sock_create_kern(&init_net, dlm_local_addr[0]->ss_family, 1329ee44b4bcSMarcelo Ricardo Leitner SOCK_STREAM, IPPROTO_SCTP, &sock); 13306ed7257bSPatrick Caulfield if (result < 0) { 13316ed7257bSPatrick Caulfield log_print("Can't create comms socket, check SCTP is loaded"); 13326ed7257bSPatrick Caulfield goto out; 13336ed7257bSPatrick Caulfield } 13346ed7257bSPatrick Caulfield 133526cfabf9SChristoph Hellwig sock_set_rcvbuf(sock->sk, NEEDED_RMEM); 1336a5b7ab63SAlexander Aring sock_set_mark(sock->sk, dlm_config.ci_mark); 133740ef92c6SChristoph Hellwig sctp_sock_set_nodelay(sock->sk); 133886e92ad2SMike Christie 1339d11ccd45SAlexander Aring add_listen_sock(sock, con); 1340b81171cbSBob Peterson 1341ee44b4bcSMarcelo Ricardo Leitner /* Bind to all addresses. */ 1342d11ccd45SAlexander Aring result = sctp_bind_addrs(con->sock, dlm_config.ci_tcp_port); 1343d11ccd45SAlexander Aring if (result < 0) 1344d11ccd45SAlexander Aring goto out; 13456ed7257bSPatrick Caulfield 13466ed7257bSPatrick Caulfield result = sock->ops->listen(sock, 5); 13476ed7257bSPatrick Caulfield if (result < 0) { 13486ed7257bSPatrick Caulfield log_print("Can't set socket listening"); 1349d11ccd45SAlexander Aring goto out; 13506ed7257bSPatrick Caulfield } 13516ed7257bSPatrick Caulfield 13526ed7257bSPatrick Caulfield return 0; 13536ed7257bSPatrick Caulfield 13546ed7257bSPatrick Caulfield out: 13556ed7257bSPatrick Caulfield return result; 13566ed7257bSPatrick Caulfield } 13576ed7257bSPatrick Caulfield 13586ed7257bSPatrick Caulfield static int tcp_listen_for_all(void) 13596ed7257bSPatrick Caulfield { 13606ed7257bSPatrick Caulfield /* We don't support multi-homed hosts */ 13611a26bfafSAlexander Aring if (dlm_local_count > 1) { 1362617e82e1SDavid Teigland log_print("TCP protocol can't handle multi-homed hosts, " 1363617e82e1SDavid Teigland "try SCTP"); 13646ed7257bSPatrick Caulfield return -EINVAL; 13656ed7257bSPatrick Caulfield } 13666ed7257bSPatrick Caulfield 13676ed7257bSPatrick Caulfield log_print("Using TCP for communications"); 13686ed7257bSPatrick Caulfield 1369d11ccd45SAlexander Aring return tcp_create_listen_sock(&listen_con, dlm_local_addr[0]); 13706ed7257bSPatrick Caulfield } 13716ed7257bSPatrick Caulfield 13726ed7257bSPatrick Caulfield 13736ed7257bSPatrick Caulfield 13746ed7257bSPatrick Caulfield static struct writequeue_entry *new_writequeue_entry(struct connection *con, 13756ed7257bSPatrick Caulfield gfp_t allocation) 13766ed7257bSPatrick Caulfield { 13776ed7257bSPatrick Caulfield struct writequeue_entry *entry; 13786ed7257bSPatrick Caulfield 1379f0747ebfSAlexander Aring entry = kzalloc(sizeof(*entry), allocation); 13806ed7257bSPatrick Caulfield if (!entry) 13816ed7257bSPatrick Caulfield return NULL; 13826ed7257bSPatrick Caulfield 1383e1a7cbceSAlexander Aring entry->page = alloc_page(allocation | __GFP_ZERO); 13846ed7257bSPatrick Caulfield if (!entry->page) { 13856ed7257bSPatrick Caulfield kfree(entry); 13866ed7257bSPatrick Caulfield return NULL; 13876ed7257bSPatrick Caulfield } 13886ed7257bSPatrick Caulfield 13896ed7257bSPatrick Caulfield entry->con = con; 1390f0747ebfSAlexander Aring entry->users = 1; 13916ed7257bSPatrick Caulfield 13926ed7257bSPatrick Caulfield return entry; 13936ed7257bSPatrick Caulfield } 13946ed7257bSPatrick Caulfield 1395f0747ebfSAlexander Aring static struct writequeue_entry *new_wq_entry(struct connection *con, int len, 1396f0747ebfSAlexander Aring gfp_t allocation, char **ppc) 1397f0747ebfSAlexander Aring { 1398f0747ebfSAlexander Aring struct writequeue_entry *e; 1399f0747ebfSAlexander Aring 1400f0747ebfSAlexander Aring spin_lock(&con->writequeue_lock); 1401f0747ebfSAlexander Aring if (!list_empty(&con->writequeue)) { 1402f0747ebfSAlexander Aring e = list_last_entry(&con->writequeue, struct writequeue_entry, list); 1403f0747ebfSAlexander Aring if (DLM_WQ_REMAIN_BYTES(e) >= len) { 1404f0747ebfSAlexander Aring *ppc = page_address(e->page) + e->end; 1405f0747ebfSAlexander Aring e->end += len; 1406f0747ebfSAlexander Aring e->users++; 1407f0747ebfSAlexander Aring spin_unlock(&con->writequeue_lock); 1408f0747ebfSAlexander Aring 1409f0747ebfSAlexander Aring return e; 1410f0747ebfSAlexander Aring } 1411f0747ebfSAlexander Aring } 1412f0747ebfSAlexander Aring spin_unlock(&con->writequeue_lock); 1413f0747ebfSAlexander Aring 1414f0747ebfSAlexander Aring e = new_writequeue_entry(con, allocation); 1415f0747ebfSAlexander Aring if (!e) 1416f0747ebfSAlexander Aring return NULL; 1417f0747ebfSAlexander Aring 1418f0747ebfSAlexander Aring *ppc = page_address(e->page); 1419f0747ebfSAlexander Aring e->end += len; 1420f0747ebfSAlexander Aring 1421f0747ebfSAlexander Aring spin_lock(&con->writequeue_lock); 1422f0747ebfSAlexander Aring list_add_tail(&e->list, &con->writequeue); 1423f0747ebfSAlexander Aring spin_unlock(&con->writequeue_lock); 1424f0747ebfSAlexander Aring 1425f0747ebfSAlexander Aring return e; 1426f0747ebfSAlexander Aring }; 1427f0747ebfSAlexander Aring 1428617e82e1SDavid Teigland void *dlm_lowcomms_get_buffer(int nodeid, int len, gfp_t allocation, char **ppc) 14296ed7257bSPatrick Caulfield { 1430b38bc9c2SAlexander Aring struct writequeue_entry *e; 14316ed7257bSPatrick Caulfield struct connection *con; 1432b38bc9c2SAlexander Aring int idx; 14336ed7257bSPatrick Caulfield 1434c45674fbSAlexander Aring if (len > DEFAULT_BUFFER_SIZE || 1435c45674fbSAlexander Aring len < sizeof(struct dlm_header)) { 1436c45674fbSAlexander Aring BUILD_BUG_ON(PAGE_SIZE < DEFAULT_BUFFER_SIZE); 1437692f51c8SAlexander Aring log_print("failed to allocate a buffer of size %d", len); 1438c45674fbSAlexander Aring WARN_ON(1); 1439692f51c8SAlexander Aring return NULL; 1440692f51c8SAlexander Aring } 1441692f51c8SAlexander Aring 1442b38bc9c2SAlexander Aring idx = srcu_read_lock(&connections_srcu); 14436ed7257bSPatrick Caulfield con = nodeid2con(nodeid, allocation); 1444b38bc9c2SAlexander Aring if (!con) { 1445b38bc9c2SAlexander Aring srcu_read_unlock(&connections_srcu, idx); 14466ed7257bSPatrick Caulfield return NULL; 1447b38bc9c2SAlexander Aring } 14486ed7257bSPatrick Caulfield 1449b38bc9c2SAlexander Aring e = new_wq_entry(con, len, allocation, ppc); 1450b38bc9c2SAlexander Aring if (!e) { 1451b38bc9c2SAlexander Aring srcu_read_unlock(&connections_srcu, idx); 1452b38bc9c2SAlexander Aring return NULL; 1453b38bc9c2SAlexander Aring } 1454b38bc9c2SAlexander Aring 1455b38bc9c2SAlexander Aring /* we assume if successful commit must called */ 1456b38bc9c2SAlexander Aring e->idx = idx; 1457b38bc9c2SAlexander Aring 1458b38bc9c2SAlexander Aring return e; 14596ed7257bSPatrick Caulfield } 14606ed7257bSPatrick Caulfield 14616ed7257bSPatrick Caulfield void dlm_lowcomms_commit_buffer(void *mh) 14626ed7257bSPatrick Caulfield { 14636ed7257bSPatrick Caulfield struct writequeue_entry *e = (struct writequeue_entry *)mh; 14646ed7257bSPatrick Caulfield struct connection *con = e->con; 14656ed7257bSPatrick Caulfield int users; 14666ed7257bSPatrick Caulfield 14676ed7257bSPatrick Caulfield spin_lock(&con->writequeue_lock); 14686ed7257bSPatrick Caulfield users = --e->users; 14696ed7257bSPatrick Caulfield if (users) 14706ed7257bSPatrick Caulfield goto out; 1471f0747ebfSAlexander Aring 1472f0747ebfSAlexander Aring e->len = DLM_WQ_LENGTH_BYTES(e); 14736ed7257bSPatrick Caulfield spin_unlock(&con->writequeue_lock); 14746ed7257bSPatrick Caulfield 14756ed7257bSPatrick Caulfield queue_work(send_workqueue, &con->swork); 1476b38bc9c2SAlexander Aring srcu_read_unlock(&connections_srcu, e->idx); 14776ed7257bSPatrick Caulfield return; 14786ed7257bSPatrick Caulfield 14796ed7257bSPatrick Caulfield out: 14806ed7257bSPatrick Caulfield spin_unlock(&con->writequeue_lock); 1481b38bc9c2SAlexander Aring srcu_read_unlock(&connections_srcu, e->idx); 14826ed7257bSPatrick Caulfield return; 14836ed7257bSPatrick Caulfield } 14846ed7257bSPatrick Caulfield 14856ed7257bSPatrick Caulfield /* Send a message */ 14866ed7257bSPatrick Caulfield static void send_to_sock(struct connection *con) 14876ed7257bSPatrick Caulfield { 14886ed7257bSPatrick Caulfield int ret = 0; 14896ed7257bSPatrick Caulfield const int msg_flags = MSG_DONTWAIT | MSG_NOSIGNAL; 14906ed7257bSPatrick Caulfield struct writequeue_entry *e; 14916ed7257bSPatrick Caulfield int len, offset; 1492f92c8dd7SBob Peterson int count = 0; 14936ed7257bSPatrick Caulfield 14946ed7257bSPatrick Caulfield mutex_lock(&con->sock_mutex); 14956ed7257bSPatrick Caulfield if (con->sock == NULL) 14966ed7257bSPatrick Caulfield goto out_connect; 14976ed7257bSPatrick Caulfield 14986ed7257bSPatrick Caulfield spin_lock(&con->writequeue_lock); 14996ed7257bSPatrick Caulfield for (;;) { 1500f0747ebfSAlexander Aring if (list_empty(&con->writequeue)) 15016ed7257bSPatrick Caulfield break; 15026ed7257bSPatrick Caulfield 1503f0747ebfSAlexander Aring e = list_first_entry(&con->writequeue, struct writequeue_entry, list); 15046ed7257bSPatrick Caulfield len = e->len; 15056ed7257bSPatrick Caulfield offset = e->offset; 15066ed7257bSPatrick Caulfield BUG_ON(len == 0 && e->users == 0); 15076ed7257bSPatrick Caulfield spin_unlock(&con->writequeue_lock); 15086ed7257bSPatrick Caulfield 15096ed7257bSPatrick Caulfield ret = 0; 15106ed7257bSPatrick Caulfield if (len) { 15111329e3f2SPaolo Bonzini ret = kernel_sendpage(con->sock, e->page, offset, len, 15126ed7257bSPatrick Caulfield msg_flags); 1513d66f8277SPatrick Caulfield if (ret == -EAGAIN || ret == 0) { 1514b36930ddSDavid Miller if (ret == -EAGAIN && 15159cd3e072SEric Dumazet test_bit(SOCKWQ_ASYNC_NOSPACE, &con->sock->flags) && 1516b36930ddSDavid Miller !test_and_set_bit(CF_APP_LIMITED, &con->flags)) { 1517b36930ddSDavid Miller /* Notify TCP that we're limited by the 1518b36930ddSDavid Miller * application window size. 1519b36930ddSDavid Miller */ 1520b36930ddSDavid Miller set_bit(SOCK_NOSPACE, &con->sock->flags); 1521b36930ddSDavid Miller con->sock->sk->sk_write_pending++; 1522b36930ddSDavid Miller } 1523d66f8277SPatrick Caulfield cond_resched(); 15246ed7257bSPatrick Caulfield goto out; 15259c5bef58SYing Xue } else if (ret < 0) 1526ba868d9dSAlexander Aring goto out; 1527d66f8277SPatrick Caulfield } 1528f92c8dd7SBob Peterson 15296ed7257bSPatrick Caulfield /* Don't starve people filling buffers */ 1530f92c8dd7SBob Peterson if (++count >= MAX_SEND_MSG_COUNT) { 15316ed7257bSPatrick Caulfield cond_resched(); 1532f92c8dd7SBob Peterson count = 0; 1533f92c8dd7SBob Peterson } 15346ed7257bSPatrick Caulfield 15356ed7257bSPatrick Caulfield spin_lock(&con->writequeue_lock); 15365d689871SMike Christie writequeue_entry_complete(e, ret); 15376ed7257bSPatrick Caulfield } 15386ed7257bSPatrick Caulfield spin_unlock(&con->writequeue_lock); 15396ed7257bSPatrick Caulfield out: 15406ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 15416ed7257bSPatrick Caulfield return; 15426ed7257bSPatrick Caulfield 15436ed7257bSPatrick Caulfield out_connect: 15446ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 154501da24d3SBob Peterson queue_work(send_workqueue, &con->swork); 154601da24d3SBob Peterson cond_resched(); 15476ed7257bSPatrick Caulfield } 15486ed7257bSPatrick Caulfield 15496ed7257bSPatrick Caulfield static void clean_one_writequeue(struct connection *con) 15506ed7257bSPatrick Caulfield { 15515e9ccc37SChristine Caulfield struct writequeue_entry *e, *safe; 15526ed7257bSPatrick Caulfield 15536ed7257bSPatrick Caulfield spin_lock(&con->writequeue_lock); 15545e9ccc37SChristine Caulfield list_for_each_entry_safe(e, safe, &con->writequeue, list) { 15556ed7257bSPatrick Caulfield list_del(&e->list); 15566ed7257bSPatrick Caulfield free_entry(e); 15576ed7257bSPatrick Caulfield } 15586ed7257bSPatrick Caulfield spin_unlock(&con->writequeue_lock); 15596ed7257bSPatrick Caulfield } 15606ed7257bSPatrick Caulfield 15616ed7257bSPatrick Caulfield /* Called from recovery when it knows that a node has 15626ed7257bSPatrick Caulfield left the cluster */ 15636ed7257bSPatrick Caulfield int dlm_lowcomms_close(int nodeid) 15646ed7257bSPatrick Caulfield { 15656ed7257bSPatrick Caulfield struct connection *con; 156636b71a8bSDavid Teigland struct dlm_node_addr *na; 1567b38bc9c2SAlexander Aring int idx; 15686ed7257bSPatrick Caulfield 15696ed7257bSPatrick Caulfield log_print("closing connection to node %d", nodeid); 1570b38bc9c2SAlexander Aring idx = srcu_read_lock(&connections_srcu); 15716ed7257bSPatrick Caulfield con = nodeid2con(nodeid, 0); 15726ed7257bSPatrick Caulfield if (con) { 1573063c4c99SLars Marowsky-Bree set_bit(CF_CLOSE, &con->flags); 15740d737a8cSMarcelo Ricardo Leitner close_connection(con, true, true, true); 15756ed7257bSPatrick Caulfield clean_one_writequeue(con); 157653a5edaaSAlexander Aring if (con->othercon) 157753a5edaaSAlexander Aring clean_one_writequeue(con->othercon); 15786ed7257bSPatrick Caulfield } 1579b38bc9c2SAlexander Aring srcu_read_unlock(&connections_srcu, idx); 158036b71a8bSDavid Teigland 158136b71a8bSDavid Teigland spin_lock(&dlm_node_addrs_spin); 158236b71a8bSDavid Teigland na = find_node_addr(nodeid); 158336b71a8bSDavid Teigland if (na) { 158436b71a8bSDavid Teigland list_del(&na->list); 158536b71a8bSDavid Teigland while (na->addr_count--) 158636b71a8bSDavid Teigland kfree(na->addr[na->addr_count]); 158736b71a8bSDavid Teigland kfree(na); 158836b71a8bSDavid Teigland } 158936b71a8bSDavid Teigland spin_unlock(&dlm_node_addrs_spin); 159036b71a8bSDavid Teigland 15916ed7257bSPatrick Caulfield return 0; 15926ed7257bSPatrick Caulfield } 15936ed7257bSPatrick Caulfield 15946ed7257bSPatrick Caulfield /* Receive workqueue function */ 15956ed7257bSPatrick Caulfield static void process_recv_sockets(struct work_struct *work) 15966ed7257bSPatrick Caulfield { 15976ed7257bSPatrick Caulfield struct connection *con = container_of(work, struct connection, rwork); 15986ed7257bSPatrick Caulfield int err; 15996ed7257bSPatrick Caulfield 16006ed7257bSPatrick Caulfield clear_bit(CF_READ_PENDING, &con->flags); 16016ed7257bSPatrick Caulfield do { 1602d11ccd45SAlexander Aring err = receive_from_sock(con); 16036ed7257bSPatrick Caulfield } while (!err); 16046ed7257bSPatrick Caulfield } 16056ed7257bSPatrick Caulfield 1606d11ccd45SAlexander Aring static void process_listen_recv_socket(struct work_struct *work) 1607d11ccd45SAlexander Aring { 1608d11ccd45SAlexander Aring accept_from_sock(&listen_con); 1609d11ccd45SAlexander Aring } 1610d11ccd45SAlexander Aring 16116ed7257bSPatrick Caulfield /* Send workqueue function */ 16126ed7257bSPatrick Caulfield static void process_send_sockets(struct work_struct *work) 16136ed7257bSPatrick Caulfield { 16146ed7257bSPatrick Caulfield struct connection *con = container_of(work, struct connection, swork); 16156ed7257bSPatrick Caulfield 16167443bc96SAlexander Aring WARN_ON(test_bit(CF_IS_OTHERCON, &con->flags)); 16177443bc96SAlexander Aring 16188a4abb08Stsutomu.owa@toshiba.co.jp clear_bit(CF_WRITE_PENDING, &con->flags); 1619ba868d9dSAlexander Aring 1620ba868d9dSAlexander Aring if (test_and_clear_bit(CF_RECONNECT, &con->flags)) 1621ba868d9dSAlexander Aring close_connection(con, false, false, true); 1622ba868d9dSAlexander Aring 1623ba868d9dSAlexander Aring if (con->sock == NULL) { /* not mutex protected so check it inside too */ 1624ba868d9dSAlexander Aring if (test_and_clear_bit(CF_DELAY_CONNECT, &con->flags)) 1625ba868d9dSAlexander Aring msleep(1000); 16266ed7257bSPatrick Caulfield con->connect_action(con); 1627ba868d9dSAlexander Aring } 162801da24d3SBob Peterson if (!list_empty(&con->writequeue)) 16296ed7257bSPatrick Caulfield send_to_sock(con); 16306ed7257bSPatrick Caulfield } 16316ed7257bSPatrick Caulfield 16326ed7257bSPatrick Caulfield static void work_stop(void) 16336ed7257bSPatrick Caulfield { 1634b355516fSDavid Windsor if (recv_workqueue) 16356ed7257bSPatrick Caulfield destroy_workqueue(recv_workqueue); 1636b355516fSDavid Windsor if (send_workqueue) 16376ed7257bSPatrick Caulfield destroy_workqueue(send_workqueue); 16386ed7257bSPatrick Caulfield } 16396ed7257bSPatrick Caulfield 16406ed7257bSPatrick Caulfield static int work_start(void) 16416ed7257bSPatrick Caulfield { 1642e43f055aSDavid Teigland recv_workqueue = alloc_workqueue("dlm_recv", 1643e43f055aSDavid Teigland WQ_UNBOUND | WQ_MEM_RECLAIM, 1); 1644b9d41052SNamhyung Kim if (!recv_workqueue) { 1645b9d41052SNamhyung Kim log_print("can't start dlm_recv"); 1646b9d41052SNamhyung Kim return -ENOMEM; 16476ed7257bSPatrick Caulfield } 16486ed7257bSPatrick Caulfield 1649e43f055aSDavid Teigland send_workqueue = alloc_workqueue("dlm_send", 1650e43f055aSDavid Teigland WQ_UNBOUND | WQ_MEM_RECLAIM, 1); 1651b9d41052SNamhyung Kim if (!send_workqueue) { 1652b9d41052SNamhyung Kim log_print("can't start dlm_send"); 16536ed7257bSPatrick Caulfield destroy_workqueue(recv_workqueue); 1654b9d41052SNamhyung Kim return -ENOMEM; 16556ed7257bSPatrick Caulfield } 16566ed7257bSPatrick Caulfield 16576ed7257bSPatrick Caulfield return 0; 16586ed7257bSPatrick Caulfield } 16596ed7257bSPatrick Caulfield 16609d232469SAlexander Aring static void shutdown_conn(struct connection *con) 16619d232469SAlexander Aring { 16629d232469SAlexander Aring if (con->shutdown_action) 16639d232469SAlexander Aring con->shutdown_action(con); 16649d232469SAlexander Aring } 16659d232469SAlexander Aring 16669d232469SAlexander Aring void dlm_lowcomms_shutdown(void) 16679d232469SAlexander Aring { 1668b38bc9c2SAlexander Aring int idx; 1669b38bc9c2SAlexander Aring 16709d232469SAlexander Aring /* Set all the flags to prevent any 16719d232469SAlexander Aring * socket activity. 16729d232469SAlexander Aring */ 16739d232469SAlexander Aring dlm_allow_conn = 0; 16749d232469SAlexander Aring 16759d232469SAlexander Aring if (recv_workqueue) 16769d232469SAlexander Aring flush_workqueue(recv_workqueue); 16779d232469SAlexander Aring if (send_workqueue) 16789d232469SAlexander Aring flush_workqueue(send_workqueue); 16799d232469SAlexander Aring 16809d232469SAlexander Aring dlm_close_sock(&listen_con.sock); 16819d232469SAlexander Aring 1682b38bc9c2SAlexander Aring idx = srcu_read_lock(&connections_srcu); 16839d232469SAlexander Aring foreach_conn(shutdown_conn); 1684b38bc9c2SAlexander Aring srcu_read_unlock(&connections_srcu, idx); 16859d232469SAlexander Aring } 16869d232469SAlexander Aring 1687f0fb83cbStsutomu.owa@toshiba.co.jp static void _stop_conn(struct connection *con, bool and_other) 16886ed7257bSPatrick Caulfield { 1689f0fb83cbStsutomu.owa@toshiba.co.jp mutex_lock(&con->sock_mutex); 1690173a31feStsutomu.owa@toshiba.co.jp set_bit(CF_CLOSE, &con->flags); 1691f0fb83cbStsutomu.owa@toshiba.co.jp set_bit(CF_READ_PENDING, &con->flags); 16928a4abb08Stsutomu.owa@toshiba.co.jp set_bit(CF_WRITE_PENDING, &con->flags); 169393eaadebStsutomu.owa@toshiba.co.jp if (con->sock && con->sock->sk) { 169493eaadebStsutomu.owa@toshiba.co.jp write_lock_bh(&con->sock->sk->sk_callback_lock); 1695afb853fbSPatrick Caulfield con->sock->sk->sk_user_data = NULL; 169693eaadebStsutomu.owa@toshiba.co.jp write_unlock_bh(&con->sock->sk->sk_callback_lock); 169793eaadebStsutomu.owa@toshiba.co.jp } 1698f0fb83cbStsutomu.owa@toshiba.co.jp if (con->othercon && and_other) 1699f0fb83cbStsutomu.owa@toshiba.co.jp _stop_conn(con->othercon, false); 1700f0fb83cbStsutomu.owa@toshiba.co.jp mutex_unlock(&con->sock_mutex); 1701f0fb83cbStsutomu.owa@toshiba.co.jp } 1702f0fb83cbStsutomu.owa@toshiba.co.jp 1703f0fb83cbStsutomu.owa@toshiba.co.jp static void stop_conn(struct connection *con) 1704f0fb83cbStsutomu.owa@toshiba.co.jp { 1705f0fb83cbStsutomu.owa@toshiba.co.jp _stop_conn(con, true); 1706afb853fbSPatrick Caulfield } 17075e9ccc37SChristine Caulfield 17084798cbbfSAlexander Aring static void connection_release(struct rcu_head *rcu) 17094798cbbfSAlexander Aring { 17104798cbbfSAlexander Aring struct connection *con = container_of(rcu, struct connection, rcu); 17114798cbbfSAlexander Aring 17124798cbbfSAlexander Aring kfree(con->rx_buf); 17134798cbbfSAlexander Aring kfree(con); 17144798cbbfSAlexander Aring } 17154798cbbfSAlexander Aring 17165e9ccc37SChristine Caulfield static void free_conn(struct connection *con) 17175e9ccc37SChristine Caulfield { 17180d737a8cSMarcelo Ricardo Leitner close_connection(con, true, true, true); 1719a47666ebSAlexander Aring spin_lock(&connections_lock); 1720a47666ebSAlexander Aring hlist_del_rcu(&con->list); 1721a47666ebSAlexander Aring spin_unlock(&connections_lock); 1722948c47e9SAlexander Aring if (con->othercon) { 1723948c47e9SAlexander Aring clean_one_writequeue(con->othercon); 17245cbec208SAlexander Aring call_srcu(&connections_srcu, &con->othercon->rcu, 17255cbec208SAlexander Aring connection_release); 1726948c47e9SAlexander Aring } 17270de98432SAlexander Aring clean_one_writequeue(con); 17285cbec208SAlexander Aring call_srcu(&connections_srcu, &con->rcu, connection_release); 17296ed7257bSPatrick Caulfield } 17305e9ccc37SChristine Caulfield 1731f0fb83cbStsutomu.owa@toshiba.co.jp static void work_flush(void) 1732f0fb83cbStsutomu.owa@toshiba.co.jp { 1733b38bc9c2SAlexander Aring int ok; 1734f0fb83cbStsutomu.owa@toshiba.co.jp int i; 1735f0fb83cbStsutomu.owa@toshiba.co.jp struct connection *con; 1736f0fb83cbStsutomu.owa@toshiba.co.jp 1737f0fb83cbStsutomu.owa@toshiba.co.jp do { 1738f0fb83cbStsutomu.owa@toshiba.co.jp ok = 1; 1739f0fb83cbStsutomu.owa@toshiba.co.jp foreach_conn(stop_conn); 1740b355516fSDavid Windsor if (recv_workqueue) 1741f0fb83cbStsutomu.owa@toshiba.co.jp flush_workqueue(recv_workqueue); 1742b355516fSDavid Windsor if (send_workqueue) 1743f0fb83cbStsutomu.owa@toshiba.co.jp flush_workqueue(send_workqueue); 1744f0fb83cbStsutomu.owa@toshiba.co.jp for (i = 0; i < CONN_HASH_SIZE && ok; i++) { 1745a47666ebSAlexander Aring hlist_for_each_entry_rcu(con, &connection_hash[i], 1746a47666ebSAlexander Aring list) { 1747f0fb83cbStsutomu.owa@toshiba.co.jp ok &= test_bit(CF_READ_PENDING, &con->flags); 17488a4abb08Stsutomu.owa@toshiba.co.jp ok &= test_bit(CF_WRITE_PENDING, &con->flags); 17498a4abb08Stsutomu.owa@toshiba.co.jp if (con->othercon) { 1750f0fb83cbStsutomu.owa@toshiba.co.jp ok &= test_bit(CF_READ_PENDING, 1751f0fb83cbStsutomu.owa@toshiba.co.jp &con->othercon->flags); 17528a4abb08Stsutomu.owa@toshiba.co.jp ok &= test_bit(CF_WRITE_PENDING, 17538a4abb08Stsutomu.owa@toshiba.co.jp &con->othercon->flags); 17548a4abb08Stsutomu.owa@toshiba.co.jp } 1755f0fb83cbStsutomu.owa@toshiba.co.jp } 1756f0fb83cbStsutomu.owa@toshiba.co.jp } 1757f0fb83cbStsutomu.owa@toshiba.co.jp } while (!ok); 1758f0fb83cbStsutomu.owa@toshiba.co.jp } 1759f0fb83cbStsutomu.owa@toshiba.co.jp 17605e9ccc37SChristine Caulfield void dlm_lowcomms_stop(void) 17615e9ccc37SChristine Caulfield { 1762b38bc9c2SAlexander Aring int idx; 1763b38bc9c2SAlexander Aring 1764b38bc9c2SAlexander Aring idx = srcu_read_lock(&connections_srcu); 1765f0fb83cbStsutomu.owa@toshiba.co.jp work_flush(); 17663a8db798SMarcelo Ricardo Leitner foreach_conn(free_conn); 1767b38bc9c2SAlexander Aring srcu_read_unlock(&connections_srcu, idx); 17686ed7257bSPatrick Caulfield work_stop(); 1769043697f0SAlexander Aring deinit_local(); 17706ed7257bSPatrick Caulfield } 17716ed7257bSPatrick Caulfield 17726ed7257bSPatrick Caulfield int dlm_lowcomms_start(void) 17736ed7257bSPatrick Caulfield { 17746ed7257bSPatrick Caulfield int error = -EINVAL; 17755e9ccc37SChristine Caulfield int i; 17765e9ccc37SChristine Caulfield 17775e9ccc37SChristine Caulfield for (i = 0; i < CONN_HASH_SIZE; i++) 17785e9ccc37SChristine Caulfield INIT_HLIST_HEAD(&connection_hash[i]); 17796ed7257bSPatrick Caulfield 17806ed7257bSPatrick Caulfield init_local(); 17816ed7257bSPatrick Caulfield if (!dlm_local_count) { 1782617e82e1SDavid Teigland error = -ENOTCONN; 17836ed7257bSPatrick Caulfield log_print("no local IP address has been set"); 1784513ef596SDavid Teigland goto fail; 17856ed7257bSPatrick Caulfield } 17866ed7257bSPatrick Caulfield 1787d11ccd45SAlexander Aring INIT_WORK(&listen_con.rwork, process_listen_recv_socket); 1788d11ccd45SAlexander Aring 1789513ef596SDavid Teigland error = work_start(); 1790513ef596SDavid Teigland if (error) 1791a47666ebSAlexander Aring goto fail; 1792513ef596SDavid Teigland 1793513ef596SDavid Teigland dlm_allow_conn = 1; 17946ed7257bSPatrick Caulfield 17956ed7257bSPatrick Caulfield /* Start listening */ 17966ed7257bSPatrick Caulfield if (dlm_config.ci_protocol == 0) 17976ed7257bSPatrick Caulfield error = tcp_listen_for_all(); 17986ed7257bSPatrick Caulfield else 1799d11ccd45SAlexander Aring error = sctp_listen_for_all(&listen_con); 18006ed7257bSPatrick Caulfield if (error) 18016ed7257bSPatrick Caulfield goto fail_unlisten; 18026ed7257bSPatrick Caulfield 18036ed7257bSPatrick Caulfield return 0; 18046ed7257bSPatrick Caulfield 18056ed7257bSPatrick Caulfield fail_unlisten: 1806513ef596SDavid Teigland dlm_allow_conn = 0; 1807d11ccd45SAlexander Aring dlm_close_sock(&listen_con.sock); 1808513ef596SDavid Teigland fail: 18096ed7257bSPatrick Caulfield return error; 18106ed7257bSPatrick Caulfield } 181136b71a8bSDavid Teigland 181236b71a8bSDavid Teigland void dlm_lowcomms_exit(void) 181336b71a8bSDavid Teigland { 181436b71a8bSDavid Teigland struct dlm_node_addr *na, *safe; 181536b71a8bSDavid Teigland 181636b71a8bSDavid Teigland spin_lock(&dlm_node_addrs_spin); 181736b71a8bSDavid Teigland list_for_each_entry_safe(na, safe, &dlm_node_addrs, list) { 181836b71a8bSDavid Teigland list_del(&na->list); 181936b71a8bSDavid Teigland while (na->addr_count--) 182036b71a8bSDavid Teigland kfree(na->addr[na->addr_count]); 182136b71a8bSDavid Teigland kfree(na); 182236b71a8bSDavid Teigland } 182336b71a8bSDavid Teigland spin_unlock(&dlm_node_addrs_spin); 182436b71a8bSDavid Teigland } 1825