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 5692732376SAlexander Aring #include <trace/events/dlm.h> 5792732376SAlexander Aring 586ed7257bSPatrick Caulfield #include "dlm_internal.h" 596ed7257bSPatrick Caulfield #include "lowcomms.h" 606ed7257bSPatrick Caulfield #include "midcomms.h" 613af2326cSAlexander Aring #include "memory.h" 626ed7257bSPatrick Caulfield #include "config.h" 636ed7257bSPatrick Caulfield 646ed7257bSPatrick Caulfield #define NEEDED_RMEM (4*1024*1024) 656ed7257bSPatrick Caulfield 66f92c8dd7SBob Peterson /* Number of messages to send before rescheduling */ 67f92c8dd7SBob Peterson #define MAX_SEND_MSG_COUNT 25 68055923bfSAlexander Aring #define DLM_SHUTDOWN_WAIT_TIMEOUT msecs_to_jiffies(10000) 69f92c8dd7SBob Peterson 706ed7257bSPatrick Caulfield struct connection { 716ed7257bSPatrick Caulfield struct socket *sock; /* NULL if not connected */ 726ed7257bSPatrick Caulfield uint32_t nodeid; /* So we know who we are in the list */ 736ed7257bSPatrick Caulfield struct mutex sock_mutex; 746ed7257bSPatrick Caulfield unsigned long flags; 756ed7257bSPatrick Caulfield #define CF_READ_PENDING 1 768a4abb08Stsutomu.owa@toshiba.co.jp #define CF_WRITE_PENDING 2 776ed7257bSPatrick Caulfield #define CF_INIT_PENDING 4 786ed7257bSPatrick Caulfield #define CF_IS_OTHERCON 5 79063c4c99SLars Marowsky-Bree #define CF_CLOSE 6 80b36930ddSDavid Miller #define CF_APP_LIMITED 7 81b2a66629Stsutomu.owa@toshiba.co.jp #define CF_CLOSING 8 82055923bfSAlexander Aring #define CF_SHUTDOWN 9 8319633c7eSAlexander Aring #define CF_CONNECTED 10 84ba868d9dSAlexander Aring #define CF_RECONNECT 11 85ba868d9dSAlexander Aring #define CF_DELAY_CONNECT 12 868aa31cbfSAlexander Aring #define CF_EOF 13 876ed7257bSPatrick Caulfield struct list_head writequeue; /* List of outgoing writequeue_entries */ 886ed7257bSPatrick Caulfield spinlock_t writequeue_lock; 898aa31cbfSAlexander Aring atomic_t writequeue_cnt; 906ed7257bSPatrick Caulfield int retries; 916ed7257bSPatrick Caulfield #define MAX_CONNECT_RETRIES 3 925e9ccc37SChristine Caulfield struct hlist_node list; 936ed7257bSPatrick Caulfield struct connection *othercon; 94ba868d9dSAlexander Aring struct connection *sendcon; 956ed7257bSPatrick Caulfield struct work_struct rwork; /* Receive workqueue */ 966ed7257bSPatrick Caulfield struct work_struct swork; /* Send workqueue */ 97055923bfSAlexander Aring wait_queue_head_t shutdown_wait; /* wait for graceful shutdown */ 984798cbbfSAlexander Aring unsigned char *rx_buf; 994798cbbfSAlexander Aring int rx_buflen; 1004798cbbfSAlexander Aring int rx_leftover; 101a47666ebSAlexander Aring struct rcu_head rcu; 1026ed7257bSPatrick Caulfield }; 1036ed7257bSPatrick Caulfield #define sock2con(x) ((struct connection *)(x)->sk_user_data) 1046ed7257bSPatrick Caulfield 105d11ccd45SAlexander Aring struct listen_connection { 106d11ccd45SAlexander Aring struct socket *sock; 107d11ccd45SAlexander Aring struct work_struct rwork; 108d11ccd45SAlexander Aring }; 109d11ccd45SAlexander Aring 110f0747ebfSAlexander Aring #define DLM_WQ_REMAIN_BYTES(e) (PAGE_SIZE - e->end) 111f0747ebfSAlexander Aring #define DLM_WQ_LENGTH_BYTES(e) (e->end - e->offset) 112f0747ebfSAlexander Aring 1136ed7257bSPatrick Caulfield /* An entry waiting to be sent */ 1146ed7257bSPatrick Caulfield struct writequeue_entry { 1156ed7257bSPatrick Caulfield struct list_head list; 1166ed7257bSPatrick Caulfield struct page *page; 1176ed7257bSPatrick Caulfield int offset; 1186ed7257bSPatrick Caulfield int len; 1196ed7257bSPatrick Caulfield int end; 1206ed7257bSPatrick Caulfield int users; 121706474fbSAlexander Aring bool dirty; 1226ed7257bSPatrick Caulfield struct connection *con; 1238f2dc78dSAlexander Aring struct list_head msgs; 1248f2dc78dSAlexander Aring struct kref ref; 1258f2dc78dSAlexander Aring }; 1268f2dc78dSAlexander Aring 1278f2dc78dSAlexander Aring struct dlm_msg { 1288f2dc78dSAlexander Aring struct writequeue_entry *entry; 1292874d1a6SAlexander Aring struct dlm_msg *orig_msg; 1302874d1a6SAlexander Aring bool retransmit; 1318f2dc78dSAlexander Aring void *ppc; 1328f2dc78dSAlexander Aring int len; 1338f2dc78dSAlexander Aring int idx; /* new()/commit() idx exchange */ 1348f2dc78dSAlexander Aring 1358f2dc78dSAlexander Aring struct list_head list; 1368f2dc78dSAlexander Aring struct kref ref; 1376ed7257bSPatrick Caulfield }; 1386ed7257bSPatrick Caulfield 13936b71a8bSDavid Teigland struct dlm_node_addr { 14036b71a8bSDavid Teigland struct list_head list; 14136b71a8bSDavid Teigland int nodeid; 142e125fbebSAlexander Aring int mark; 14336b71a8bSDavid Teigland int addr_count; 14498e1b60eSMike Christie int curr_addr_index; 14536b71a8bSDavid Teigland struct sockaddr_storage *addr[DLM_MAX_ADDR_COUNT]; 14636b71a8bSDavid Teigland }; 14736b71a8bSDavid Teigland 148a66c008cSAlexander Aring struct dlm_proto_ops { 1498728a455SAlexander Aring bool try_new_addr; 1502dc6b115SAlexander Aring const char *name; 1512dc6b115SAlexander Aring int proto; 1522dc6b115SAlexander Aring 1538728a455SAlexander Aring int (*connect)(struct connection *con, struct socket *sock, 1548728a455SAlexander Aring struct sockaddr *addr, int addr_len); 1558728a455SAlexander Aring void (*sockopts)(struct socket *sock); 1568728a455SAlexander Aring int (*bind)(struct socket *sock); 1572dc6b115SAlexander Aring int (*listen_validate)(void); 1582dc6b115SAlexander Aring void (*listen_sockopts)(struct socket *sock); 1592dc6b115SAlexander Aring int (*listen_bind)(struct socket *sock); 160a66c008cSAlexander Aring /* What to do to shutdown */ 161a66c008cSAlexander Aring void (*shutdown_action)(struct connection *con); 162a66c008cSAlexander Aring /* What to do to eof check */ 163a66c008cSAlexander Aring bool (*eof_condition)(struct connection *con); 164a66c008cSAlexander Aring }; 165a66c008cSAlexander Aring 166cc661fc9SBob Peterson static struct listen_sock_callbacks { 167cc661fc9SBob Peterson void (*sk_error_report)(struct sock *); 168cc661fc9SBob Peterson void (*sk_data_ready)(struct sock *); 169cc661fc9SBob Peterson void (*sk_state_change)(struct sock *); 170cc661fc9SBob Peterson void (*sk_write_space)(struct sock *); 171cc661fc9SBob Peterson } listen_sock; 172cc661fc9SBob Peterson 17336b71a8bSDavid Teigland static LIST_HEAD(dlm_node_addrs); 17436b71a8bSDavid Teigland static DEFINE_SPINLOCK(dlm_node_addrs_spin); 17536b71a8bSDavid Teigland 176d11ccd45SAlexander Aring static struct listen_connection listen_con; 1776ed7257bSPatrick Caulfield static struct sockaddr_storage *dlm_local_addr[DLM_MAX_ADDR_COUNT]; 1786ed7257bSPatrick Caulfield static int dlm_local_count; 1796ed7257bSPatrick Caulfield 1806ed7257bSPatrick Caulfield /* Work queues */ 1816ed7257bSPatrick Caulfield static struct workqueue_struct *recv_workqueue; 1826ed7257bSPatrick Caulfield static struct workqueue_struct *send_workqueue; 1836ed7257bSPatrick Caulfield 1845e9ccc37SChristine Caulfield static struct hlist_head connection_hash[CONN_HASH_SIZE]; 185a47666ebSAlexander Aring static DEFINE_SPINLOCK(connections_lock); 186a47666ebSAlexander Aring DEFINE_STATIC_SRCU(connections_srcu); 1876ed7257bSPatrick Caulfield 188a66c008cSAlexander Aring static const struct dlm_proto_ops *dlm_proto_ops; 189a66c008cSAlexander Aring 1906ed7257bSPatrick Caulfield static void process_recv_sockets(struct work_struct *work); 1916ed7257bSPatrick Caulfield static void process_send_sockets(struct work_struct *work); 1926ed7257bSPatrick Caulfield 193*1037c2a9SAlexander Aring bool dlm_lowcomms_is_running(void) 194*1037c2a9SAlexander Aring { 195*1037c2a9SAlexander Aring return !!listen_con.sock; 196*1037c2a9SAlexander Aring } 197*1037c2a9SAlexander Aring 1983af2326cSAlexander Aring static void writequeue_entry_ctor(void *data) 1993af2326cSAlexander Aring { 2003af2326cSAlexander Aring struct writequeue_entry *entry = data; 2013af2326cSAlexander Aring 2023af2326cSAlexander Aring INIT_LIST_HEAD(&entry->msgs); 2033af2326cSAlexander Aring } 2043af2326cSAlexander Aring 2053af2326cSAlexander Aring struct kmem_cache *dlm_lowcomms_writequeue_cache_create(void) 2063af2326cSAlexander Aring { 2073af2326cSAlexander Aring return kmem_cache_create("dlm_writequeue", sizeof(struct writequeue_entry), 2083af2326cSAlexander Aring 0, 0, writequeue_entry_ctor); 2093af2326cSAlexander Aring } 2103af2326cSAlexander Aring 211e4dc81edSAlexander Aring struct kmem_cache *dlm_lowcomms_msg_cache_create(void) 212e4dc81edSAlexander Aring { 213e4dc81edSAlexander Aring return kmem_cache_create("dlm_msg", sizeof(struct dlm_msg), 0, 0, NULL); 214e4dc81edSAlexander Aring } 215e4dc81edSAlexander Aring 21666d5955aSAlexander Aring /* need to held writequeue_lock */ 21766d5955aSAlexander Aring static struct writequeue_entry *con_next_wq(struct connection *con) 21866d5955aSAlexander Aring { 21966d5955aSAlexander Aring struct writequeue_entry *e; 22066d5955aSAlexander Aring 221dd070a56SAlexander Aring e = list_first_entry_or_null(&con->writequeue, struct writequeue_entry, 22266d5955aSAlexander Aring list); 223bcbfea41SAlexander Aring /* if len is zero nothing is to send, if there are users filling 224bcbfea41SAlexander Aring * buffers we wait until the users are done so we can send more. 225bcbfea41SAlexander Aring */ 226dd070a56SAlexander Aring if (!e || e->users || e->len == 0) 22766d5955aSAlexander Aring return NULL; 22866d5955aSAlexander Aring 22966d5955aSAlexander Aring return e; 23066d5955aSAlexander Aring } 23166d5955aSAlexander Aring 232b38bc9c2SAlexander Aring static struct connection *__find_con(int nodeid, int r) 2335e9ccc37SChristine Caulfield { 2345e9ccc37SChristine Caulfield struct connection *con; 2355e9ccc37SChristine Caulfield 236a47666ebSAlexander Aring hlist_for_each_entry_rcu(con, &connection_hash[r], list) { 237b38bc9c2SAlexander Aring if (con->nodeid == nodeid) 2385e9ccc37SChristine Caulfield return con; 2395e9ccc37SChristine Caulfield } 240a47666ebSAlexander Aring 2415e9ccc37SChristine Caulfield return NULL; 2425e9ccc37SChristine Caulfield } 2435e9ccc37SChristine Caulfield 2448aa31cbfSAlexander Aring static bool tcp_eof_condition(struct connection *con) 2458aa31cbfSAlexander Aring { 2468aa31cbfSAlexander Aring return atomic_read(&con->writequeue_cnt); 2478aa31cbfSAlexander Aring } 2488aa31cbfSAlexander Aring 2496cde210aSAlexander Aring static int dlm_con_init(struct connection *con, int nodeid) 2506ed7257bSPatrick Caulfield { 2514798cbbfSAlexander Aring con->rx_buflen = dlm_config.ci_buffer_size; 2524798cbbfSAlexander Aring con->rx_buf = kmalloc(con->rx_buflen, GFP_NOFS); 2536cde210aSAlexander Aring if (!con->rx_buf) 2546cde210aSAlexander Aring return -ENOMEM; 2554798cbbfSAlexander Aring 2566ed7257bSPatrick Caulfield con->nodeid = nodeid; 2576ed7257bSPatrick Caulfield mutex_init(&con->sock_mutex); 2586ed7257bSPatrick Caulfield INIT_LIST_HEAD(&con->writequeue); 2596ed7257bSPatrick Caulfield spin_lock_init(&con->writequeue_lock); 2608aa31cbfSAlexander Aring atomic_set(&con->writequeue_cnt, 0); 2616ed7257bSPatrick Caulfield INIT_WORK(&con->swork, process_send_sockets); 2626ed7257bSPatrick Caulfield INIT_WORK(&con->rwork, process_recv_sockets); 263055923bfSAlexander Aring init_waitqueue_head(&con->shutdown_wait); 2646ed7257bSPatrick Caulfield 2656cde210aSAlexander Aring return 0; 2666cde210aSAlexander Aring } 2676cde210aSAlexander Aring 2686cde210aSAlexander Aring /* 2696cde210aSAlexander Aring * If 'allocation' is zero then we don't attempt to create a new 2706cde210aSAlexander Aring * connection structure for this node. 2716cde210aSAlexander Aring */ 2726cde210aSAlexander Aring static struct connection *nodeid2con(int nodeid, gfp_t alloc) 2736cde210aSAlexander Aring { 2746cde210aSAlexander Aring struct connection *con, *tmp; 2756cde210aSAlexander Aring int r, ret; 2766cde210aSAlexander Aring 277b38bc9c2SAlexander Aring r = nodeid_hash(nodeid); 278b38bc9c2SAlexander Aring con = __find_con(nodeid, r); 2796cde210aSAlexander Aring if (con || !alloc) 2806cde210aSAlexander Aring return con; 2816cde210aSAlexander Aring 2826cde210aSAlexander Aring con = kzalloc(sizeof(*con), alloc); 2836cde210aSAlexander Aring if (!con) 2846cde210aSAlexander Aring return NULL; 2856cde210aSAlexander Aring 2866cde210aSAlexander Aring ret = dlm_con_init(con, nodeid); 2876cde210aSAlexander Aring if (ret) { 2886cde210aSAlexander Aring kfree(con); 2896cde210aSAlexander Aring return NULL; 2906cde210aSAlexander Aring } 2916cde210aSAlexander Aring 292a47666ebSAlexander Aring spin_lock(&connections_lock); 2934f2b30fdSAlexander Aring /* Because multiple workqueues/threads calls this function it can 2944f2b30fdSAlexander Aring * race on multiple cpu's. Instead of locking hot path __find_con() 2954f2b30fdSAlexander Aring * we just check in rare cases of recently added nodes again 2964f2b30fdSAlexander Aring * under protection of connections_lock. If this is the case we 2974f2b30fdSAlexander Aring * abort our connection creation and return the existing connection. 2984f2b30fdSAlexander Aring */ 299b38bc9c2SAlexander Aring tmp = __find_con(nodeid, r); 3004f2b30fdSAlexander Aring if (tmp) { 3014f2b30fdSAlexander Aring spin_unlock(&connections_lock); 3024f2b30fdSAlexander Aring kfree(con->rx_buf); 3034f2b30fdSAlexander Aring kfree(con); 3044f2b30fdSAlexander Aring return tmp; 3054f2b30fdSAlexander Aring } 3064f2b30fdSAlexander Aring 307a47666ebSAlexander Aring hlist_add_head_rcu(&con->list, &connection_hash[r]); 308a47666ebSAlexander Aring spin_unlock(&connections_lock); 309a47666ebSAlexander Aring 3106ed7257bSPatrick Caulfield return con; 3116ed7257bSPatrick Caulfield } 3126ed7257bSPatrick Caulfield 3135e9ccc37SChristine Caulfield /* Loop round all connections */ 3145e9ccc37SChristine Caulfield static void foreach_conn(void (*conn_func)(struct connection *c)) 3155e9ccc37SChristine Caulfield { 316b38bc9c2SAlexander Aring int i; 3175e9ccc37SChristine Caulfield struct connection *con; 3185e9ccc37SChristine Caulfield 3195e9ccc37SChristine Caulfield for (i = 0; i < CONN_HASH_SIZE; i++) { 320a47666ebSAlexander Aring hlist_for_each_entry_rcu(con, &connection_hash[i], list) 3215e9ccc37SChristine Caulfield conn_func(con); 3225e9ccc37SChristine Caulfield } 3236ed7257bSPatrick Caulfield } 3246ed7257bSPatrick Caulfield 32536b71a8bSDavid Teigland static struct dlm_node_addr *find_node_addr(int nodeid) 3266ed7257bSPatrick Caulfield { 32736b71a8bSDavid Teigland struct dlm_node_addr *na; 32836b71a8bSDavid Teigland 32936b71a8bSDavid Teigland list_for_each_entry(na, &dlm_node_addrs, list) { 33036b71a8bSDavid Teigland if (na->nodeid == nodeid) 33136b71a8bSDavid Teigland return na; 33236b71a8bSDavid Teigland } 33336b71a8bSDavid Teigland return NULL; 33436b71a8bSDavid Teigland } 33536b71a8bSDavid Teigland 33640c6b83eSAlexander Aring static int addr_compare(const struct sockaddr_storage *x, 33740c6b83eSAlexander Aring const struct sockaddr_storage *y) 33836b71a8bSDavid Teigland { 33936b71a8bSDavid Teigland switch (x->ss_family) { 34036b71a8bSDavid Teigland case AF_INET: { 34136b71a8bSDavid Teigland struct sockaddr_in *sinx = (struct sockaddr_in *)x; 34236b71a8bSDavid Teigland struct sockaddr_in *siny = (struct sockaddr_in *)y; 34336b71a8bSDavid Teigland if (sinx->sin_addr.s_addr != siny->sin_addr.s_addr) 34436b71a8bSDavid Teigland return 0; 34536b71a8bSDavid Teigland if (sinx->sin_port != siny->sin_port) 34636b71a8bSDavid Teigland return 0; 34736b71a8bSDavid Teigland break; 34836b71a8bSDavid Teigland } 34936b71a8bSDavid Teigland case AF_INET6: { 35036b71a8bSDavid Teigland struct sockaddr_in6 *sinx = (struct sockaddr_in6 *)x; 35136b71a8bSDavid Teigland struct sockaddr_in6 *siny = (struct sockaddr_in6 *)y; 35236b71a8bSDavid Teigland if (!ipv6_addr_equal(&sinx->sin6_addr, &siny->sin6_addr)) 35336b71a8bSDavid Teigland return 0; 35436b71a8bSDavid Teigland if (sinx->sin6_port != siny->sin6_port) 35536b71a8bSDavid Teigland return 0; 35636b71a8bSDavid Teigland break; 35736b71a8bSDavid Teigland } 35836b71a8bSDavid Teigland default: 35936b71a8bSDavid Teigland return 0; 36036b71a8bSDavid Teigland } 36136b71a8bSDavid Teigland return 1; 36236b71a8bSDavid Teigland } 36336b71a8bSDavid Teigland 36436b71a8bSDavid Teigland static int nodeid_to_addr(int nodeid, struct sockaddr_storage *sas_out, 365e125fbebSAlexander Aring struct sockaddr *sa_out, bool try_new_addr, 366e125fbebSAlexander Aring unsigned int *mark) 36736b71a8bSDavid Teigland { 36836b71a8bSDavid Teigland struct sockaddr_storage sas; 36936b71a8bSDavid Teigland struct dlm_node_addr *na; 3706ed7257bSPatrick Caulfield 3716ed7257bSPatrick Caulfield if (!dlm_local_count) 3726ed7257bSPatrick Caulfield return -1; 3736ed7257bSPatrick Caulfield 37436b71a8bSDavid Teigland spin_lock(&dlm_node_addrs_spin); 37536b71a8bSDavid Teigland na = find_node_addr(nodeid); 37698e1b60eSMike Christie if (na && na->addr_count) { 377ee44b4bcSMarcelo Ricardo Leitner memcpy(&sas, na->addr[na->curr_addr_index], 378ee44b4bcSMarcelo Ricardo Leitner sizeof(struct sockaddr_storage)); 379ee44b4bcSMarcelo Ricardo Leitner 38098e1b60eSMike Christie if (try_new_addr) { 38198e1b60eSMike Christie na->curr_addr_index++; 38298e1b60eSMike Christie if (na->curr_addr_index == na->addr_count) 38398e1b60eSMike Christie na->curr_addr_index = 0; 38498e1b60eSMike Christie } 38598e1b60eSMike Christie } 38636b71a8bSDavid Teigland spin_unlock(&dlm_node_addrs_spin); 38736b71a8bSDavid Teigland 38836b71a8bSDavid Teigland if (!na) 38936b71a8bSDavid Teigland return -EEXIST; 39036b71a8bSDavid Teigland 39136b71a8bSDavid Teigland if (!na->addr_count) 39236b71a8bSDavid Teigland return -ENOENT; 39336b71a8bSDavid Teigland 394e125fbebSAlexander Aring *mark = na->mark; 395e125fbebSAlexander Aring 39636b71a8bSDavid Teigland if (sas_out) 39736b71a8bSDavid Teigland memcpy(sas_out, &sas, sizeof(struct sockaddr_storage)); 39836b71a8bSDavid Teigland 39936b71a8bSDavid Teigland if (!sa_out) 40036b71a8bSDavid Teigland return 0; 4016ed7257bSPatrick Caulfield 4026ed7257bSPatrick Caulfield if (dlm_local_addr[0]->ss_family == AF_INET) { 40336b71a8bSDavid Teigland struct sockaddr_in *in4 = (struct sockaddr_in *) &sas; 40436b71a8bSDavid Teigland struct sockaddr_in *ret4 = (struct sockaddr_in *) sa_out; 4056ed7257bSPatrick Caulfield ret4->sin_addr.s_addr = in4->sin_addr.s_addr; 4066ed7257bSPatrick Caulfield } else { 40736b71a8bSDavid Teigland struct sockaddr_in6 *in6 = (struct sockaddr_in6 *) &sas; 40836b71a8bSDavid Teigland struct sockaddr_in6 *ret6 = (struct sockaddr_in6 *) sa_out; 4094e3fd7a0SAlexey Dobriyan ret6->sin6_addr = in6->sin6_addr; 4106ed7257bSPatrick Caulfield } 4116ed7257bSPatrick Caulfield 4126ed7257bSPatrick Caulfield return 0; 4136ed7257bSPatrick Caulfield } 4146ed7257bSPatrick Caulfield 415e125fbebSAlexander Aring static int addr_to_nodeid(struct sockaddr_storage *addr, int *nodeid, 416e125fbebSAlexander Aring unsigned int *mark) 41736b71a8bSDavid Teigland { 41836b71a8bSDavid Teigland struct dlm_node_addr *na; 41936b71a8bSDavid Teigland int rv = -EEXIST; 42098e1b60eSMike Christie int addr_i; 42136b71a8bSDavid Teigland 42236b71a8bSDavid Teigland spin_lock(&dlm_node_addrs_spin); 42336b71a8bSDavid Teigland list_for_each_entry(na, &dlm_node_addrs, list) { 42436b71a8bSDavid Teigland if (!na->addr_count) 42536b71a8bSDavid Teigland continue; 42636b71a8bSDavid Teigland 42798e1b60eSMike Christie for (addr_i = 0; addr_i < na->addr_count; addr_i++) { 42898e1b60eSMike Christie if (addr_compare(na->addr[addr_i], addr)) { 42936b71a8bSDavid Teigland *nodeid = na->nodeid; 430e125fbebSAlexander Aring *mark = na->mark; 43136b71a8bSDavid Teigland rv = 0; 43298e1b60eSMike Christie goto unlock; 43336b71a8bSDavid Teigland } 43498e1b60eSMike Christie } 43598e1b60eSMike Christie } 43698e1b60eSMike Christie unlock: 43736b71a8bSDavid Teigland spin_unlock(&dlm_node_addrs_spin); 43836b71a8bSDavid Teigland return rv; 43936b71a8bSDavid Teigland } 44036b71a8bSDavid Teigland 4414f19d071SAlexander Aring /* caller need to held dlm_node_addrs_spin lock */ 4424f19d071SAlexander Aring static bool dlm_lowcomms_na_has_addr(const struct dlm_node_addr *na, 4434f19d071SAlexander Aring const struct sockaddr_storage *addr) 4444f19d071SAlexander Aring { 4454f19d071SAlexander Aring int i; 4464f19d071SAlexander Aring 4474f19d071SAlexander Aring for (i = 0; i < na->addr_count; i++) { 4484f19d071SAlexander Aring if (addr_compare(na->addr[i], addr)) 4494f19d071SAlexander Aring return true; 4504f19d071SAlexander Aring } 4514f19d071SAlexander Aring 4524f19d071SAlexander Aring return false; 4534f19d071SAlexander Aring } 4544f19d071SAlexander Aring 45536b71a8bSDavid Teigland int dlm_lowcomms_addr(int nodeid, struct sockaddr_storage *addr, int len) 45636b71a8bSDavid Teigland { 45736b71a8bSDavid Teigland struct sockaddr_storage *new_addr; 45836b71a8bSDavid Teigland struct dlm_node_addr *new_node, *na; 4594f19d071SAlexander Aring bool ret; 46036b71a8bSDavid Teigland 46136b71a8bSDavid Teigland new_node = kzalloc(sizeof(struct dlm_node_addr), GFP_NOFS); 46236b71a8bSDavid Teigland if (!new_node) 46336b71a8bSDavid Teigland return -ENOMEM; 46436b71a8bSDavid Teigland 46536b71a8bSDavid Teigland new_addr = kzalloc(sizeof(struct sockaddr_storage), GFP_NOFS); 46636b71a8bSDavid Teigland if (!new_addr) { 46736b71a8bSDavid Teigland kfree(new_node); 46836b71a8bSDavid Teigland return -ENOMEM; 46936b71a8bSDavid Teigland } 47036b71a8bSDavid Teigland 47136b71a8bSDavid Teigland memcpy(new_addr, addr, len); 47236b71a8bSDavid Teigland 47336b71a8bSDavid Teigland spin_lock(&dlm_node_addrs_spin); 47436b71a8bSDavid Teigland na = find_node_addr(nodeid); 47536b71a8bSDavid Teigland if (!na) { 47636b71a8bSDavid Teigland new_node->nodeid = nodeid; 47736b71a8bSDavid Teigland new_node->addr[0] = new_addr; 47836b71a8bSDavid Teigland new_node->addr_count = 1; 479e125fbebSAlexander Aring new_node->mark = dlm_config.ci_mark; 48036b71a8bSDavid Teigland list_add(&new_node->list, &dlm_node_addrs); 48136b71a8bSDavid Teigland spin_unlock(&dlm_node_addrs_spin); 48236b71a8bSDavid Teigland return 0; 48336b71a8bSDavid Teigland } 48436b71a8bSDavid Teigland 4854f19d071SAlexander Aring ret = dlm_lowcomms_na_has_addr(na, addr); 4864f19d071SAlexander Aring if (ret) { 4874f19d071SAlexander Aring spin_unlock(&dlm_node_addrs_spin); 4884f19d071SAlexander Aring kfree(new_addr); 4894f19d071SAlexander Aring kfree(new_node); 4904f19d071SAlexander Aring return -EEXIST; 4914f19d071SAlexander Aring } 4924f19d071SAlexander Aring 49336b71a8bSDavid Teigland if (na->addr_count >= DLM_MAX_ADDR_COUNT) { 49436b71a8bSDavid Teigland spin_unlock(&dlm_node_addrs_spin); 49536b71a8bSDavid Teigland kfree(new_addr); 49636b71a8bSDavid Teigland kfree(new_node); 49736b71a8bSDavid Teigland return -ENOSPC; 49836b71a8bSDavid Teigland } 49936b71a8bSDavid Teigland 50036b71a8bSDavid Teigland na->addr[na->addr_count++] = new_addr; 50136b71a8bSDavid Teigland spin_unlock(&dlm_node_addrs_spin); 50236b71a8bSDavid Teigland kfree(new_node); 50336b71a8bSDavid Teigland return 0; 50436b71a8bSDavid Teigland } 50536b71a8bSDavid Teigland 5066ed7257bSPatrick Caulfield /* Data available on socket or listen socket received a connect */ 507676d2369SDavid S. Miller static void lowcomms_data_ready(struct sock *sk) 5086ed7257bSPatrick Caulfield { 50993eaadebStsutomu.owa@toshiba.co.jp struct connection *con; 51093eaadebStsutomu.owa@toshiba.co.jp 51193eaadebStsutomu.owa@toshiba.co.jp con = sock2con(sk); 512afb853fbSPatrick Caulfield if (con && !test_and_set_bit(CF_READ_PENDING, &con->flags)) 5136ed7257bSPatrick Caulfield queue_work(recv_workqueue, &con->rwork); 5146ed7257bSPatrick Caulfield } 5156ed7257bSPatrick Caulfield 516d11ccd45SAlexander Aring static void lowcomms_listen_data_ready(struct sock *sk) 517d11ccd45SAlexander Aring { 518d11ccd45SAlexander Aring queue_work(recv_workqueue, &listen_con.rwork); 519d11ccd45SAlexander Aring } 520d11ccd45SAlexander Aring 5216ed7257bSPatrick Caulfield static void lowcomms_write_space(struct sock *sk) 5226ed7257bSPatrick Caulfield { 52393eaadebStsutomu.owa@toshiba.co.jp struct connection *con; 5246ed7257bSPatrick Caulfield 52593eaadebStsutomu.owa@toshiba.co.jp con = sock2con(sk); 526b36930ddSDavid Miller if (!con) 52792c44605SAlexander Aring return; 528b36930ddSDavid Miller 52919633c7eSAlexander Aring if (!test_and_set_bit(CF_CONNECTED, &con->flags)) { 530dfc020f3SAlexander Aring log_print("connected to node %d", con->nodeid); 53119633c7eSAlexander Aring queue_work(send_workqueue, &con->swork); 53292c44605SAlexander Aring return; 53319633c7eSAlexander Aring } 53419633c7eSAlexander Aring 535b36930ddSDavid Miller clear_bit(SOCK_NOSPACE, &con->sock->flags); 536b36930ddSDavid Miller 537b36930ddSDavid Miller if (test_and_clear_bit(CF_APP_LIMITED, &con->flags)) { 538b36930ddSDavid Miller con->sock->sk->sk_write_pending--; 5399cd3e072SEric Dumazet clear_bit(SOCKWQ_ASYNC_NOSPACE, &con->sock->flags); 540b36930ddSDavid Miller } 541b36930ddSDavid Miller 5426ed7257bSPatrick Caulfield queue_work(send_workqueue, &con->swork); 5436ed7257bSPatrick Caulfield } 5446ed7257bSPatrick Caulfield 5456ed7257bSPatrick Caulfield static inline void lowcomms_connect_sock(struct connection *con) 5466ed7257bSPatrick Caulfield { 547063c4c99SLars Marowsky-Bree if (test_bit(CF_CLOSE, &con->flags)) 548063c4c99SLars Marowsky-Bree return; 5496ed7257bSPatrick Caulfield queue_work(send_workqueue, &con->swork); 55061d9102bSBob Peterson cond_resched(); 5516ed7257bSPatrick Caulfield } 5526ed7257bSPatrick Caulfield 5536ed7257bSPatrick Caulfield static void lowcomms_state_change(struct sock *sk) 5546ed7257bSPatrick Caulfield { 555ee44b4bcSMarcelo Ricardo Leitner /* SCTP layer is not calling sk_data_ready when the connection 556ee44b4bcSMarcelo Ricardo Leitner * is done, so we catch the signal through here. Also, it 557ee44b4bcSMarcelo Ricardo Leitner * doesn't switch socket state when entering shutdown, so we 558ee44b4bcSMarcelo Ricardo Leitner * skip the write in that case. 559ee44b4bcSMarcelo Ricardo Leitner */ 560ee44b4bcSMarcelo Ricardo Leitner if (sk->sk_shutdown) { 561ee44b4bcSMarcelo Ricardo Leitner if (sk->sk_shutdown == RCV_SHUTDOWN) 562ee44b4bcSMarcelo Ricardo Leitner lowcomms_data_ready(sk); 563ee44b4bcSMarcelo Ricardo Leitner } else if (sk->sk_state == TCP_ESTABLISHED) { 5646ed7257bSPatrick Caulfield lowcomms_write_space(sk); 5656ed7257bSPatrick Caulfield } 566ee44b4bcSMarcelo Ricardo Leitner } 5676ed7257bSPatrick Caulfield 568391fbdc5SChristine Caulfield int dlm_lowcomms_connect_node(int nodeid) 569391fbdc5SChristine Caulfield { 570391fbdc5SChristine Caulfield struct connection *con; 571b38bc9c2SAlexander Aring int idx; 572391fbdc5SChristine Caulfield 573391fbdc5SChristine Caulfield if (nodeid == dlm_our_nodeid()) 574391fbdc5SChristine Caulfield return 0; 575391fbdc5SChristine Caulfield 576b38bc9c2SAlexander Aring idx = srcu_read_lock(&connections_srcu); 577391fbdc5SChristine Caulfield con = nodeid2con(nodeid, GFP_NOFS); 578b38bc9c2SAlexander Aring if (!con) { 579b38bc9c2SAlexander Aring srcu_read_unlock(&connections_srcu, idx); 580391fbdc5SChristine Caulfield return -ENOMEM; 581b38bc9c2SAlexander Aring } 582b38bc9c2SAlexander Aring 583391fbdc5SChristine Caulfield lowcomms_connect_sock(con); 584b38bc9c2SAlexander Aring srcu_read_unlock(&connections_srcu, idx); 585b38bc9c2SAlexander Aring 586391fbdc5SChristine Caulfield return 0; 587391fbdc5SChristine Caulfield } 588391fbdc5SChristine Caulfield 589e125fbebSAlexander Aring int dlm_lowcomms_nodes_set_mark(int nodeid, unsigned int mark) 590e125fbebSAlexander Aring { 591e125fbebSAlexander Aring struct dlm_node_addr *na; 592e125fbebSAlexander Aring 593e125fbebSAlexander Aring spin_lock(&dlm_node_addrs_spin); 594e125fbebSAlexander Aring na = find_node_addr(nodeid); 595e125fbebSAlexander Aring if (!na) { 596e125fbebSAlexander Aring spin_unlock(&dlm_node_addrs_spin); 597e125fbebSAlexander Aring return -ENOENT; 598e125fbebSAlexander Aring } 599e125fbebSAlexander Aring 600e125fbebSAlexander Aring na->mark = mark; 601e125fbebSAlexander Aring spin_unlock(&dlm_node_addrs_spin); 602e125fbebSAlexander Aring 603e125fbebSAlexander Aring return 0; 604e125fbebSAlexander Aring } 605e125fbebSAlexander Aring 606b3a5bbfdSBob Peterson static void lowcomms_error_report(struct sock *sk) 607b3a5bbfdSBob Peterson { 608b81171cbSBob Peterson struct connection *con; 609b81171cbSBob Peterson void (*orig_report)(struct sock *) = NULL; 6104c3d9057SAlexander Aring struct inet_sock *inet; 611b3a5bbfdSBob Peterson 612b81171cbSBob Peterson con = sock2con(sk); 613b81171cbSBob Peterson if (con == NULL) 614b81171cbSBob Peterson goto out; 615b81171cbSBob Peterson 616cc661fc9SBob Peterson orig_report = listen_sock.sk_error_report; 617b3a5bbfdSBob Peterson 6184c3d9057SAlexander Aring inet = inet_sk(sk); 6194c3d9057SAlexander Aring switch (sk->sk_family) { 6204c3d9057SAlexander Aring case AF_INET: 621b3a5bbfdSBob Peterson printk_ratelimited(KERN_ERR "dlm: node %d: socket error " 6224c3d9057SAlexander Aring "sending to node %d at %pI4, dport %d, " 623b3a5bbfdSBob Peterson "sk_err=%d/%d\n", dlm_our_nodeid(), 6244c3d9057SAlexander Aring con->nodeid, &inet->inet_daddr, 6254c3d9057SAlexander Aring ntohs(inet->inet_dport), sk->sk_err, 626b3a5bbfdSBob Peterson sk->sk_err_soft); 6274c3d9057SAlexander Aring break; 6281b9beda8SAlexander Aring #if IS_ENABLED(CONFIG_IPV6) 6294c3d9057SAlexander Aring case AF_INET6: 630b3a5bbfdSBob Peterson printk_ratelimited(KERN_ERR "dlm: node %d: socket error " 6314c3d9057SAlexander Aring "sending to node %d at %pI6c, " 6324c3d9057SAlexander Aring "dport %d, sk_err=%d/%d\n", dlm_our_nodeid(), 6334c3d9057SAlexander Aring con->nodeid, &sk->sk_v6_daddr, 6344c3d9057SAlexander Aring ntohs(inet->inet_dport), sk->sk_err, 635b3a5bbfdSBob Peterson sk->sk_err_soft); 6364c3d9057SAlexander Aring break; 6371b9beda8SAlexander Aring #endif 6384c3d9057SAlexander Aring default: 6394c3d9057SAlexander Aring printk_ratelimited(KERN_ERR "dlm: node %d: socket error " 6404c3d9057SAlexander Aring "invalid socket family %d set, " 6414c3d9057SAlexander Aring "sk_err=%d/%d\n", dlm_our_nodeid(), 6424c3d9057SAlexander Aring sk->sk_family, sk->sk_err, sk->sk_err_soft); 6434c3d9057SAlexander Aring goto out; 644b3a5bbfdSBob Peterson } 645ba868d9dSAlexander Aring 646ba868d9dSAlexander Aring /* below sendcon only handling */ 647ba868d9dSAlexander Aring if (test_bit(CF_IS_OTHERCON, &con->flags)) 648ba868d9dSAlexander Aring con = con->sendcon; 649ba868d9dSAlexander Aring 650ba868d9dSAlexander Aring switch (sk->sk_err) { 651ba868d9dSAlexander Aring case ECONNREFUSED: 652ba868d9dSAlexander Aring set_bit(CF_DELAY_CONNECT, &con->flags); 653ba868d9dSAlexander Aring break; 654ba868d9dSAlexander Aring default: 655ba868d9dSAlexander Aring break; 656ba868d9dSAlexander Aring } 657ba868d9dSAlexander Aring 658ba868d9dSAlexander Aring if (!test_and_set_bit(CF_RECONNECT, &con->flags)) 659ba868d9dSAlexander Aring queue_work(send_workqueue, &con->swork); 660ba868d9dSAlexander Aring 661b81171cbSBob Peterson out: 662b81171cbSBob Peterson if (orig_report) 663b81171cbSBob Peterson orig_report(sk); 664b81171cbSBob Peterson } 665b81171cbSBob Peterson 666b81171cbSBob Peterson /* Note: sk_callback_lock must be locked before calling this function. */ 667cc661fc9SBob Peterson static void save_listen_callbacks(struct socket *sock) 668b81171cbSBob Peterson { 669cc661fc9SBob Peterson struct sock *sk = sock->sk; 670cc661fc9SBob Peterson 671cc661fc9SBob Peterson listen_sock.sk_data_ready = sk->sk_data_ready; 672cc661fc9SBob Peterson listen_sock.sk_state_change = sk->sk_state_change; 673cc661fc9SBob Peterson listen_sock.sk_write_space = sk->sk_write_space; 674cc661fc9SBob Peterson listen_sock.sk_error_report = sk->sk_error_report; 675b81171cbSBob Peterson } 676b81171cbSBob Peterson 677cc661fc9SBob Peterson static void restore_callbacks(struct socket *sock) 678b81171cbSBob Peterson { 679cc661fc9SBob Peterson struct sock *sk = sock->sk; 680cc661fc9SBob Peterson 68192c44605SAlexander Aring lock_sock(sk); 682b81171cbSBob Peterson sk->sk_user_data = NULL; 683cc661fc9SBob Peterson sk->sk_data_ready = listen_sock.sk_data_ready; 684cc661fc9SBob Peterson sk->sk_state_change = listen_sock.sk_state_change; 685cc661fc9SBob Peterson sk->sk_write_space = listen_sock.sk_write_space; 686cc661fc9SBob Peterson sk->sk_error_report = listen_sock.sk_error_report; 68792c44605SAlexander Aring release_sock(sk); 688b3a5bbfdSBob Peterson } 689b3a5bbfdSBob Peterson 690d11ccd45SAlexander Aring static void add_listen_sock(struct socket *sock, struct listen_connection *con) 691d11ccd45SAlexander Aring { 692d11ccd45SAlexander Aring struct sock *sk = sock->sk; 693d11ccd45SAlexander Aring 69492c44605SAlexander Aring lock_sock(sk); 695d11ccd45SAlexander Aring save_listen_callbacks(sock); 696d11ccd45SAlexander Aring con->sock = sock; 697d11ccd45SAlexander Aring 698d11ccd45SAlexander Aring sk->sk_user_data = con; 699d11ccd45SAlexander Aring sk->sk_allocation = GFP_NOFS; 700d11ccd45SAlexander Aring /* Install a data_ready callback */ 701d11ccd45SAlexander Aring sk->sk_data_ready = lowcomms_listen_data_ready; 70292c44605SAlexander Aring release_sock(sk); 703d11ccd45SAlexander Aring } 704d11ccd45SAlexander Aring 7056ed7257bSPatrick Caulfield /* Make a socket active */ 706988419a9Stsutomu.owa@toshiba.co.jp static void add_sock(struct socket *sock, struct connection *con) 7076ed7257bSPatrick Caulfield { 708b81171cbSBob Peterson struct sock *sk = sock->sk; 709b81171cbSBob Peterson 71092c44605SAlexander Aring lock_sock(sk); 7116ed7257bSPatrick Caulfield con->sock = sock; 7126ed7257bSPatrick Caulfield 713b81171cbSBob Peterson sk->sk_user_data = con; 7146ed7257bSPatrick Caulfield /* Install a data_ready callback */ 715b81171cbSBob Peterson sk->sk_data_ready = lowcomms_data_ready; 716b81171cbSBob Peterson sk->sk_write_space = lowcomms_write_space; 717b81171cbSBob Peterson sk->sk_state_change = lowcomms_state_change; 718b81171cbSBob Peterson sk->sk_allocation = GFP_NOFS; 719b81171cbSBob Peterson sk->sk_error_report = lowcomms_error_report; 72092c44605SAlexander Aring release_sock(sk); 7216ed7257bSPatrick Caulfield } 7226ed7257bSPatrick Caulfield 7236ed7257bSPatrick Caulfield /* Add the port number to an IPv6 or 4 sockaddr and return the address 7246ed7257bSPatrick Caulfield length */ 7256ed7257bSPatrick Caulfield static void make_sockaddr(struct sockaddr_storage *saddr, uint16_t port, 7266ed7257bSPatrick Caulfield int *addr_len) 7276ed7257bSPatrick Caulfield { 7286ed7257bSPatrick Caulfield saddr->ss_family = dlm_local_addr[0]->ss_family; 7296ed7257bSPatrick Caulfield if (saddr->ss_family == AF_INET) { 7306ed7257bSPatrick Caulfield struct sockaddr_in *in4_addr = (struct sockaddr_in *)saddr; 7316ed7257bSPatrick Caulfield in4_addr->sin_port = cpu_to_be16(port); 7326ed7257bSPatrick Caulfield *addr_len = sizeof(struct sockaddr_in); 7336ed7257bSPatrick Caulfield memset(&in4_addr->sin_zero, 0, sizeof(in4_addr->sin_zero)); 7346ed7257bSPatrick Caulfield } else { 7356ed7257bSPatrick Caulfield struct sockaddr_in6 *in6_addr = (struct sockaddr_in6 *)saddr; 7366ed7257bSPatrick Caulfield in6_addr->sin6_port = cpu_to_be16(port); 7376ed7257bSPatrick Caulfield *addr_len = sizeof(struct sockaddr_in6); 7386ed7257bSPatrick Caulfield } 73901c8cab2SPatrick Caulfield memset((char *)saddr + *addr_len, 0, sizeof(struct sockaddr_storage) - *addr_len); 7406ed7257bSPatrick Caulfield } 7416ed7257bSPatrick Caulfield 742706474fbSAlexander Aring static void dlm_page_release(struct kref *kref) 743706474fbSAlexander Aring { 744706474fbSAlexander Aring struct writequeue_entry *e = container_of(kref, struct writequeue_entry, 745706474fbSAlexander Aring ref); 746706474fbSAlexander Aring 747706474fbSAlexander Aring __free_page(e->page); 7483af2326cSAlexander Aring dlm_free_writequeue(e); 749706474fbSAlexander Aring } 750706474fbSAlexander Aring 751706474fbSAlexander Aring static void dlm_msg_release(struct kref *kref) 752706474fbSAlexander Aring { 753706474fbSAlexander Aring struct dlm_msg *msg = container_of(kref, struct dlm_msg, ref); 754706474fbSAlexander Aring 755706474fbSAlexander Aring kref_put(&msg->entry->ref, dlm_page_release); 756e4dc81edSAlexander Aring dlm_free_msg(msg); 757706474fbSAlexander Aring } 758706474fbSAlexander Aring 759706474fbSAlexander Aring static void free_entry(struct writequeue_entry *e) 760706474fbSAlexander Aring { 761706474fbSAlexander Aring struct dlm_msg *msg, *tmp; 762706474fbSAlexander Aring 763706474fbSAlexander Aring list_for_each_entry_safe(msg, tmp, &e->msgs, list) { 764706474fbSAlexander Aring if (msg->orig_msg) { 765706474fbSAlexander Aring msg->orig_msg->retransmit = false; 766706474fbSAlexander Aring kref_put(&msg->orig_msg->ref, dlm_msg_release); 767706474fbSAlexander Aring } 768706474fbSAlexander Aring 769706474fbSAlexander Aring list_del(&msg->list); 770706474fbSAlexander Aring kref_put(&msg->ref, dlm_msg_release); 771706474fbSAlexander Aring } 772706474fbSAlexander Aring 773706474fbSAlexander Aring list_del(&e->list); 774706474fbSAlexander Aring atomic_dec(&e->con->writequeue_cnt); 775706474fbSAlexander Aring kref_put(&e->ref, dlm_page_release); 776706474fbSAlexander Aring } 777706474fbSAlexander Aring 778d11ccd45SAlexander Aring static void dlm_close_sock(struct socket **sock) 779d11ccd45SAlexander Aring { 780d11ccd45SAlexander Aring if (*sock) { 781d11ccd45SAlexander Aring restore_callbacks(*sock); 782d11ccd45SAlexander Aring sock_release(*sock); 783d11ccd45SAlexander Aring *sock = NULL; 784d11ccd45SAlexander Aring } 785d11ccd45SAlexander Aring } 786d11ccd45SAlexander Aring 7876ed7257bSPatrick Caulfield /* Close a remote connection and tidy up */ 7880d737a8cSMarcelo Ricardo Leitner static void close_connection(struct connection *con, bool and_other, 7890d737a8cSMarcelo Ricardo Leitner bool tx, bool rx) 7906ed7257bSPatrick Caulfield { 791b2a66629Stsutomu.owa@toshiba.co.jp bool closing = test_and_set_bit(CF_CLOSING, &con->flags); 792706474fbSAlexander Aring struct writequeue_entry *e; 793b2a66629Stsutomu.owa@toshiba.co.jp 7940aa18464Stsutomu.owa@toshiba.co.jp if (tx && !closing && cancel_work_sync(&con->swork)) { 7950d737a8cSMarcelo Ricardo Leitner log_print("canceled swork for node %d", con->nodeid); 7960aa18464Stsutomu.owa@toshiba.co.jp clear_bit(CF_WRITE_PENDING, &con->flags); 7970aa18464Stsutomu.owa@toshiba.co.jp } 7980aa18464Stsutomu.owa@toshiba.co.jp if (rx && !closing && cancel_work_sync(&con->rwork)) { 7990d737a8cSMarcelo Ricardo Leitner log_print("canceled rwork for node %d", con->nodeid); 8000aa18464Stsutomu.owa@toshiba.co.jp clear_bit(CF_READ_PENDING, &con->flags); 8010aa18464Stsutomu.owa@toshiba.co.jp } 8026ed7257bSPatrick Caulfield 8030d737a8cSMarcelo Ricardo Leitner mutex_lock(&con->sock_mutex); 804d11ccd45SAlexander Aring dlm_close_sock(&con->sock); 805d11ccd45SAlexander Aring 8066ed7257bSPatrick Caulfield if (con->othercon && and_other) { 8076ed7257bSPatrick Caulfield /* Will only re-enter once. */ 808c6aa00e3SAlexander Aring close_connection(con->othercon, false, tx, rx); 8096ed7257bSPatrick Caulfield } 8109e5f2825SPatrick Caulfield 811706474fbSAlexander Aring /* if we send a writequeue entry only a half way, we drop the 812706474fbSAlexander Aring * whole entry because reconnection and that we not start of the 813706474fbSAlexander Aring * middle of a msg which will confuse the other end. 814706474fbSAlexander Aring * 815706474fbSAlexander Aring * we can always drop messages because retransmits, but what we 816706474fbSAlexander Aring * cannot allow is to transmit half messages which may be processed 817706474fbSAlexander Aring * at the other side. 818706474fbSAlexander Aring * 819706474fbSAlexander Aring * our policy is to start on a clean state when disconnects, we don't 820706474fbSAlexander Aring * know what's send/received on transport layer in this case. 821706474fbSAlexander Aring */ 822706474fbSAlexander Aring spin_lock(&con->writequeue_lock); 823706474fbSAlexander Aring if (!list_empty(&con->writequeue)) { 824706474fbSAlexander Aring e = list_first_entry(&con->writequeue, struct writequeue_entry, 825706474fbSAlexander Aring list); 826706474fbSAlexander Aring if (e->dirty) 827706474fbSAlexander Aring free_entry(e); 828706474fbSAlexander Aring } 829706474fbSAlexander Aring spin_unlock(&con->writequeue_lock); 830706474fbSAlexander Aring 8314798cbbfSAlexander Aring con->rx_leftover = 0; 8326ed7257bSPatrick Caulfield con->retries = 0; 833052849beSAlexander Aring clear_bit(CF_APP_LIMITED, &con->flags); 83419633c7eSAlexander Aring clear_bit(CF_CONNECTED, &con->flags); 835ba868d9dSAlexander Aring clear_bit(CF_DELAY_CONNECT, &con->flags); 836ba868d9dSAlexander Aring clear_bit(CF_RECONNECT, &con->flags); 8378aa31cbfSAlexander Aring clear_bit(CF_EOF, &con->flags); 8386ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 839b2a66629Stsutomu.owa@toshiba.co.jp clear_bit(CF_CLOSING, &con->flags); 8406ed7257bSPatrick Caulfield } 8416ed7257bSPatrick Caulfield 842055923bfSAlexander Aring static void shutdown_connection(struct connection *con) 843055923bfSAlexander Aring { 844055923bfSAlexander Aring int ret; 845055923bfSAlexander Aring 846eec054b5SAlexander Aring flush_work(&con->swork); 847055923bfSAlexander Aring 848055923bfSAlexander Aring mutex_lock(&con->sock_mutex); 849055923bfSAlexander Aring /* nothing to shutdown */ 850055923bfSAlexander Aring if (!con->sock) { 851055923bfSAlexander Aring mutex_unlock(&con->sock_mutex); 852055923bfSAlexander Aring return; 853055923bfSAlexander Aring } 854055923bfSAlexander Aring 855055923bfSAlexander Aring set_bit(CF_SHUTDOWN, &con->flags); 856055923bfSAlexander Aring ret = kernel_sock_shutdown(con->sock, SHUT_WR); 857055923bfSAlexander Aring mutex_unlock(&con->sock_mutex); 858055923bfSAlexander Aring if (ret) { 859055923bfSAlexander Aring log_print("Connection %p failed to shutdown: %d will force close", 860055923bfSAlexander Aring con, ret); 861055923bfSAlexander Aring goto force_close; 862055923bfSAlexander Aring } else { 863055923bfSAlexander Aring ret = wait_event_timeout(con->shutdown_wait, 864055923bfSAlexander Aring !test_bit(CF_SHUTDOWN, &con->flags), 865055923bfSAlexander Aring DLM_SHUTDOWN_WAIT_TIMEOUT); 866055923bfSAlexander Aring if (ret == 0) { 867055923bfSAlexander Aring log_print("Connection %p shutdown timed out, will force close", 868055923bfSAlexander Aring con); 869055923bfSAlexander Aring goto force_close; 870055923bfSAlexander Aring } 871055923bfSAlexander Aring } 872055923bfSAlexander Aring 873055923bfSAlexander Aring return; 874055923bfSAlexander Aring 875055923bfSAlexander Aring force_close: 876055923bfSAlexander Aring clear_bit(CF_SHUTDOWN, &con->flags); 877055923bfSAlexander Aring close_connection(con, false, true, true); 878055923bfSAlexander Aring } 879055923bfSAlexander Aring 880055923bfSAlexander Aring static void dlm_tcp_shutdown(struct connection *con) 881055923bfSAlexander Aring { 882055923bfSAlexander Aring if (con->othercon) 883055923bfSAlexander Aring shutdown_connection(con->othercon); 884055923bfSAlexander Aring shutdown_connection(con); 885055923bfSAlexander Aring } 886055923bfSAlexander Aring 8874798cbbfSAlexander Aring static int con_realloc_receive_buf(struct connection *con, int newlen) 8884798cbbfSAlexander Aring { 8894798cbbfSAlexander Aring unsigned char *newbuf; 8904798cbbfSAlexander Aring 8914798cbbfSAlexander Aring newbuf = kmalloc(newlen, GFP_NOFS); 8924798cbbfSAlexander Aring if (!newbuf) 8934798cbbfSAlexander Aring return -ENOMEM; 8944798cbbfSAlexander Aring 8954798cbbfSAlexander Aring /* copy any leftover from last receive */ 8964798cbbfSAlexander Aring if (con->rx_leftover) 8974798cbbfSAlexander Aring memmove(newbuf, con->rx_buf, con->rx_leftover); 8984798cbbfSAlexander Aring 8994798cbbfSAlexander Aring /* swap to new buffer space */ 9004798cbbfSAlexander Aring kfree(con->rx_buf); 9014798cbbfSAlexander Aring con->rx_buflen = newlen; 9024798cbbfSAlexander Aring con->rx_buf = newbuf; 9034798cbbfSAlexander Aring 9044798cbbfSAlexander Aring return 0; 9054798cbbfSAlexander Aring } 9064798cbbfSAlexander Aring 9076ed7257bSPatrick Caulfield /* Data received from remote end */ 9086ed7257bSPatrick Caulfield static int receive_from_sock(struct connection *con) 9096ed7257bSPatrick Caulfield { 9104798cbbfSAlexander Aring struct msghdr msg; 9114798cbbfSAlexander Aring struct kvec iov; 9124798cbbfSAlexander Aring int ret, buflen; 9136ed7257bSPatrick Caulfield 9146ed7257bSPatrick Caulfield mutex_lock(&con->sock_mutex); 9156ed7257bSPatrick Caulfield 9166ed7257bSPatrick Caulfield if (con->sock == NULL) { 9176ed7257bSPatrick Caulfield ret = -EAGAIN; 9186ed7257bSPatrick Caulfield goto out_close; 9196ed7257bSPatrick Caulfield } 9204798cbbfSAlexander Aring 9214798cbbfSAlexander Aring /* realloc if we get new buffer size to read out */ 9224798cbbfSAlexander Aring buflen = dlm_config.ci_buffer_size; 9234798cbbfSAlexander Aring if (con->rx_buflen != buflen && con->rx_leftover <= buflen) { 9244798cbbfSAlexander Aring ret = con_realloc_receive_buf(con, buflen); 9254798cbbfSAlexander Aring if (ret < 0) 9266ed7257bSPatrick Caulfield goto out_resched; 9276ed7257bSPatrick Caulfield } 9286ed7257bSPatrick Caulfield 92962699b3fSAlexander Aring for (;;) { 9304798cbbfSAlexander Aring /* calculate new buffer parameter regarding last receive and 9314798cbbfSAlexander Aring * possible leftover bytes 9326ed7257bSPatrick Caulfield */ 9334798cbbfSAlexander Aring iov.iov_base = con->rx_buf + con->rx_leftover; 9344798cbbfSAlexander Aring iov.iov_len = con->rx_buflen - con->rx_leftover; 9356ed7257bSPatrick Caulfield 9364798cbbfSAlexander Aring memset(&msg, 0, sizeof(msg)); 9374798cbbfSAlexander Aring msg.msg_flags = MSG_DONTWAIT | MSG_NOSIGNAL; 9384798cbbfSAlexander Aring ret = kernel_recvmsg(con->sock, &msg, &iov, 1, iov.iov_len, 9394798cbbfSAlexander Aring msg.msg_flags); 94092732376SAlexander Aring trace_dlm_recv(con->nodeid, ret); 94162699b3fSAlexander Aring if (ret == -EAGAIN) 94262699b3fSAlexander Aring break; 94362699b3fSAlexander Aring else if (ret <= 0) 9446ed7257bSPatrick Caulfield goto out_close; 9456ed7257bSPatrick Caulfield 9464798cbbfSAlexander Aring /* new buflen according readed bytes and leftover from last receive */ 9474798cbbfSAlexander Aring buflen = ret + con->rx_leftover; 9484798cbbfSAlexander Aring ret = dlm_process_incoming_buffer(con->nodeid, con->rx_buf, buflen); 9494798cbbfSAlexander Aring if (ret < 0) 9504798cbbfSAlexander Aring goto out_close; 9516ed7257bSPatrick Caulfield 9524798cbbfSAlexander Aring /* calculate leftover bytes from process and put it into begin of 9534798cbbfSAlexander Aring * the receive buffer, so next receive we have the full message 9544798cbbfSAlexander Aring * at the start address of the receive buffer. 9554798cbbfSAlexander Aring */ 9564798cbbfSAlexander Aring con->rx_leftover = buflen - ret; 9574798cbbfSAlexander Aring if (con->rx_leftover) { 9584798cbbfSAlexander Aring memmove(con->rx_buf, con->rx_buf + ret, 9594798cbbfSAlexander Aring con->rx_leftover); 9606ed7257bSPatrick Caulfield } 96162699b3fSAlexander Aring } 9624798cbbfSAlexander Aring 963b97f8525SAlexander Aring dlm_midcomms_receive_done(con->nodeid); 9646ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 9656ed7257bSPatrick Caulfield return 0; 9666ed7257bSPatrick Caulfield 9676ed7257bSPatrick Caulfield out_resched: 9686ed7257bSPatrick Caulfield if (!test_and_set_bit(CF_READ_PENDING, &con->flags)) 9696ed7257bSPatrick Caulfield queue_work(recv_workqueue, &con->rwork); 9706ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 9716ed7257bSPatrick Caulfield return -EAGAIN; 9726ed7257bSPatrick Caulfield 9736ed7257bSPatrick Caulfield out_close: 974055923bfSAlexander Aring if (ret == 0) { 975055923bfSAlexander Aring log_print("connection %p got EOF from %d", 976055923bfSAlexander Aring con, con->nodeid); 9778aa31cbfSAlexander Aring 978a66c008cSAlexander Aring if (dlm_proto_ops->eof_condition && 979a66c008cSAlexander Aring dlm_proto_ops->eof_condition(con)) { 9808aa31cbfSAlexander Aring set_bit(CF_EOF, &con->flags); 9818aa31cbfSAlexander Aring mutex_unlock(&con->sock_mutex); 9828aa31cbfSAlexander Aring } else { 9838aa31cbfSAlexander Aring mutex_unlock(&con->sock_mutex); 9848aa31cbfSAlexander Aring close_connection(con, false, true, false); 9858aa31cbfSAlexander Aring 986055923bfSAlexander Aring /* handling for tcp shutdown */ 987055923bfSAlexander Aring clear_bit(CF_SHUTDOWN, &con->flags); 988055923bfSAlexander Aring wake_up(&con->shutdown_wait); 9898aa31cbfSAlexander Aring } 9908aa31cbfSAlexander Aring 991055923bfSAlexander Aring /* signal to breaking receive worker */ 992055923bfSAlexander Aring ret = -1; 9938aa31cbfSAlexander Aring } else { 9948aa31cbfSAlexander Aring mutex_unlock(&con->sock_mutex); 9956ed7257bSPatrick Caulfield } 9966ed7257bSPatrick Caulfield return ret; 9976ed7257bSPatrick Caulfield } 9986ed7257bSPatrick Caulfield 9996ed7257bSPatrick Caulfield /* Listening socket is busy, accept a connection */ 1000d11ccd45SAlexander Aring static int accept_from_sock(struct listen_connection *con) 10016ed7257bSPatrick Caulfield { 10026ed7257bSPatrick Caulfield int result; 10036ed7257bSPatrick Caulfield struct sockaddr_storage peeraddr; 10046ed7257bSPatrick Caulfield struct socket *newsock; 1005b38bc9c2SAlexander Aring int len, idx; 10066ed7257bSPatrick Caulfield int nodeid; 10076ed7257bSPatrick Caulfield struct connection *newcon; 10086ed7257bSPatrick Caulfield struct connection *addcon; 10093f78cd7dSAlexander Aring unsigned int mark; 10106ed7257bSPatrick Caulfield 1011d11ccd45SAlexander Aring if (!con->sock) 10123421fb15Stsutomu.owa@toshiba.co.jp return -ENOTCONN; 10136ed7257bSPatrick Caulfield 10143421fb15Stsutomu.owa@toshiba.co.jp result = kernel_accept(con->sock, &newsock, O_NONBLOCK); 10156ed7257bSPatrick Caulfield if (result < 0) 10166ed7257bSPatrick Caulfield goto accept_err; 10176ed7257bSPatrick Caulfield 10186ed7257bSPatrick Caulfield /* Get the connected socket's peer */ 10196ed7257bSPatrick Caulfield memset(&peeraddr, 0, sizeof(peeraddr)); 10209b2c45d4SDenys Vlasenko len = newsock->ops->getname(newsock, (struct sockaddr *)&peeraddr, 2); 10219b2c45d4SDenys Vlasenko if (len < 0) { 10226ed7257bSPatrick Caulfield result = -ECONNABORTED; 10236ed7257bSPatrick Caulfield goto accept_err; 10246ed7257bSPatrick Caulfield } 10256ed7257bSPatrick Caulfield 10266ed7257bSPatrick Caulfield /* Get the new node's NODEID */ 10276ed7257bSPatrick Caulfield make_sockaddr(&peeraddr, 0, &len); 1028e125fbebSAlexander Aring if (addr_to_nodeid(&peeraddr, &nodeid, &mark)) { 1029feae43f8SAlexander Aring switch (peeraddr.ss_family) { 1030feae43f8SAlexander Aring case AF_INET: { 1031feae43f8SAlexander Aring struct sockaddr_in *sin = (struct sockaddr_in *)&peeraddr; 1032feae43f8SAlexander Aring 1033feae43f8SAlexander Aring log_print("connect from non cluster IPv4 node %pI4", 1034feae43f8SAlexander Aring &sin->sin_addr); 1035feae43f8SAlexander Aring break; 1036feae43f8SAlexander Aring } 1037feae43f8SAlexander Aring #if IS_ENABLED(CONFIG_IPV6) 1038feae43f8SAlexander Aring case AF_INET6: { 1039feae43f8SAlexander Aring struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)&peeraddr; 1040feae43f8SAlexander Aring 1041feae43f8SAlexander Aring log_print("connect from non cluster IPv6 node %pI6c", 1042feae43f8SAlexander Aring &sin6->sin6_addr); 1043feae43f8SAlexander Aring break; 1044feae43f8SAlexander Aring } 1045feae43f8SAlexander Aring #endif 1046feae43f8SAlexander Aring default: 1047feae43f8SAlexander Aring log_print("invalid family from non cluster node"); 1048feae43f8SAlexander Aring break; 1049feae43f8SAlexander Aring } 1050feae43f8SAlexander Aring 10516ed7257bSPatrick Caulfield sock_release(newsock); 10526ed7257bSPatrick Caulfield return -1; 10536ed7257bSPatrick Caulfield } 10546ed7257bSPatrick Caulfield 10556ed7257bSPatrick Caulfield log_print("got connection from %d", nodeid); 10566ed7257bSPatrick Caulfield 10576ed7257bSPatrick Caulfield /* Check to see if we already have a connection to this node. This 10586ed7257bSPatrick Caulfield * could happen if the two nodes initiate a connection at roughly 10596ed7257bSPatrick Caulfield * the same time and the connections cross on the wire. 10606ed7257bSPatrick Caulfield * In this case we store the incoming one in "othercon" 10616ed7257bSPatrick Caulfield */ 1062b38bc9c2SAlexander Aring idx = srcu_read_lock(&connections_srcu); 1063748285ccSDavid Teigland newcon = nodeid2con(nodeid, GFP_NOFS); 10646ed7257bSPatrick Caulfield if (!newcon) { 1065b38bc9c2SAlexander Aring srcu_read_unlock(&connections_srcu, idx); 10666ed7257bSPatrick Caulfield result = -ENOMEM; 10676ed7257bSPatrick Caulfield goto accept_err; 10686ed7257bSPatrick Caulfield } 1069d11ccd45SAlexander Aring 1070e125fbebSAlexander Aring sock_set_mark(newsock->sk, mark); 1071e125fbebSAlexander Aring 1072d11ccd45SAlexander Aring mutex_lock(&newcon->sock_mutex); 10736ed7257bSPatrick Caulfield if (newcon->sock) { 10746ed7257bSPatrick Caulfield struct connection *othercon = newcon->othercon; 10756ed7257bSPatrick Caulfield 10766ed7257bSPatrick Caulfield if (!othercon) { 1077a47666ebSAlexander Aring othercon = kzalloc(sizeof(*othercon), GFP_NOFS); 10786ed7257bSPatrick Caulfield if (!othercon) { 1079617e82e1SDavid Teigland log_print("failed to allocate incoming socket"); 10806ed7257bSPatrick Caulfield mutex_unlock(&newcon->sock_mutex); 1081b38bc9c2SAlexander Aring srcu_read_unlock(&connections_srcu, idx); 10826ed7257bSPatrick Caulfield result = -ENOMEM; 10836ed7257bSPatrick Caulfield goto accept_err; 10846ed7257bSPatrick Caulfield } 10854798cbbfSAlexander Aring 10866cde210aSAlexander Aring result = dlm_con_init(othercon, nodeid); 10876cde210aSAlexander Aring if (result < 0) { 10884798cbbfSAlexander Aring kfree(othercon); 10892fd8db2dSYang Yingliang mutex_unlock(&newcon->sock_mutex); 1090b38bc9c2SAlexander Aring srcu_read_unlock(&connections_srcu, idx); 10914798cbbfSAlexander Aring goto accept_err; 10924798cbbfSAlexander Aring } 10934798cbbfSAlexander Aring 1094e9a470acSAlexander Aring lockdep_set_subclass(&othercon->sock_mutex, 1); 10957443bc96SAlexander Aring set_bit(CF_IS_OTHERCON, &othercon->flags); 10966cde210aSAlexander Aring newcon->othercon = othercon; 1097ba868d9dSAlexander Aring othercon->sendcon = newcon; 1098ba3ab3caSAlexander Aring } else { 1099ba3ab3caSAlexander Aring /* close other sock con if we have something new */ 1100ba3ab3caSAlexander Aring close_connection(othercon, false, true, false); 110161d96be0SPatrick Caulfield } 1102ba3ab3caSAlexander Aring 1103e9a470acSAlexander Aring mutex_lock(&othercon->sock_mutex); 1104988419a9Stsutomu.owa@toshiba.co.jp add_sock(newsock, othercon); 11056ed7257bSPatrick Caulfield addcon = othercon; 1106c7355827Stsutomu.owa@toshiba.co.jp mutex_unlock(&othercon->sock_mutex); 11076ed7257bSPatrick Caulfield } 11086ed7257bSPatrick Caulfield else { 11093735b4b9SBob Peterson /* accept copies the sk after we've saved the callbacks, so we 11103735b4b9SBob Peterson don't want to save them a second time or comm errors will 11113735b4b9SBob Peterson result in calling sk_error_report recursively. */ 1112988419a9Stsutomu.owa@toshiba.co.jp add_sock(newsock, newcon); 11136ed7257bSPatrick Caulfield addcon = newcon; 11146ed7257bSPatrick Caulfield } 11156ed7257bSPatrick Caulfield 1116b30a624fSAlexander Aring set_bit(CF_CONNECTED, &addcon->flags); 11176ed7257bSPatrick Caulfield mutex_unlock(&newcon->sock_mutex); 11186ed7257bSPatrick Caulfield 11196ed7257bSPatrick Caulfield /* 11206ed7257bSPatrick Caulfield * Add it to the active queue in case we got data 112125985edcSLucas De Marchi * between processing the accept adding the socket 11226ed7257bSPatrick Caulfield * to the read_sockets list 11236ed7257bSPatrick Caulfield */ 11246ed7257bSPatrick Caulfield if (!test_and_set_bit(CF_READ_PENDING, &addcon->flags)) 11256ed7257bSPatrick Caulfield queue_work(recv_workqueue, &addcon->rwork); 11266ed7257bSPatrick Caulfield 1127b38bc9c2SAlexander Aring srcu_read_unlock(&connections_srcu, idx); 1128b38bc9c2SAlexander Aring 11296ed7257bSPatrick Caulfield return 0; 11306ed7257bSPatrick Caulfield 11316ed7257bSPatrick Caulfield accept_err: 11323421fb15Stsutomu.owa@toshiba.co.jp if (newsock) 11336ed7257bSPatrick Caulfield sock_release(newsock); 11346ed7257bSPatrick Caulfield 11356ed7257bSPatrick Caulfield if (result != -EAGAIN) 1136617e82e1SDavid Teigland log_print("error accepting connection from node: %d", result); 11376ed7257bSPatrick Caulfield return result; 11386ed7257bSPatrick Caulfield } 11396ed7257bSPatrick Caulfield 11405d689871SMike Christie /* 11415d689871SMike Christie * writequeue_entry_complete - try to delete and free write queue entry 11425d689871SMike Christie * @e: write queue entry to try to delete 11435d689871SMike Christie * @completed: bytes completed 11445d689871SMike Christie * 11455d689871SMike Christie * writequeue_lock must be held. 11465d689871SMike Christie */ 11475d689871SMike Christie static void writequeue_entry_complete(struct writequeue_entry *e, int completed) 11485d689871SMike Christie { 11495d689871SMike Christie e->offset += completed; 11505d689871SMike Christie e->len -= completed; 1151706474fbSAlexander Aring /* signal that page was half way transmitted */ 1152706474fbSAlexander Aring e->dirty = true; 11535d689871SMike Christie 11548f2dc78dSAlexander Aring if (e->len == 0 && e->users == 0) 11555d689871SMike Christie free_entry(e); 11565d689871SMike Christie } 11575d689871SMike Christie 1158ee44b4bcSMarcelo Ricardo Leitner /* 1159ee44b4bcSMarcelo Ricardo Leitner * sctp_bind_addrs - bind a SCTP socket to all our addresses 1160ee44b4bcSMarcelo Ricardo Leitner */ 116113004e8aSAlexander Aring static int sctp_bind_addrs(struct socket *sock, uint16_t port) 1162ee44b4bcSMarcelo Ricardo Leitner { 1163ee44b4bcSMarcelo Ricardo Leitner struct sockaddr_storage localaddr; 1164c0425a42SChristoph Hellwig struct sockaddr *addr = (struct sockaddr *)&localaddr; 1165ee44b4bcSMarcelo Ricardo Leitner int i, addr_len, result = 0; 1166ee44b4bcSMarcelo Ricardo Leitner 1167ee44b4bcSMarcelo Ricardo Leitner for (i = 0; i < dlm_local_count; i++) { 1168ee44b4bcSMarcelo Ricardo Leitner memcpy(&localaddr, dlm_local_addr[i], sizeof(localaddr)); 1169ee44b4bcSMarcelo Ricardo Leitner make_sockaddr(&localaddr, port, &addr_len); 1170ee44b4bcSMarcelo Ricardo Leitner 1171ee44b4bcSMarcelo Ricardo Leitner if (!i) 117213004e8aSAlexander Aring result = kernel_bind(sock, addr, addr_len); 1173ee44b4bcSMarcelo Ricardo Leitner else 117413004e8aSAlexander Aring result = sock_bind_add(sock->sk, addr, addr_len); 1175ee44b4bcSMarcelo Ricardo Leitner 1176ee44b4bcSMarcelo Ricardo Leitner if (result < 0) { 1177ee44b4bcSMarcelo Ricardo Leitner log_print("Can't bind to %d addr number %d, %d.\n", 1178ee44b4bcSMarcelo Ricardo Leitner port, i + 1, result); 1179ee44b4bcSMarcelo Ricardo Leitner break; 1180ee44b4bcSMarcelo Ricardo Leitner } 1181ee44b4bcSMarcelo Ricardo Leitner } 1182ee44b4bcSMarcelo Ricardo Leitner return result; 1183ee44b4bcSMarcelo Ricardo Leitner } 1184ee44b4bcSMarcelo Ricardo Leitner 11856ed7257bSPatrick Caulfield /* Get local addresses */ 11866ed7257bSPatrick Caulfield static void init_local(void) 11876ed7257bSPatrick Caulfield { 11886ed7257bSPatrick Caulfield struct sockaddr_storage sas, *addr; 11896ed7257bSPatrick Caulfield int i; 11906ed7257bSPatrick Caulfield 119130d3a237SPatrick Caulfield dlm_local_count = 0; 11921b189b88SDavid Teigland for (i = 0; i < DLM_MAX_ADDR_COUNT; i++) { 11936ed7257bSPatrick Caulfield if (dlm_our_addr(&sas, i)) 11946ed7257bSPatrick Caulfield break; 11956ed7257bSPatrick Caulfield 11965c93f56fSAmitoj Kaur Chawla addr = kmemdup(&sas, sizeof(*addr), GFP_NOFS); 11976ed7257bSPatrick Caulfield if (!addr) 11986ed7257bSPatrick Caulfield break; 11996ed7257bSPatrick Caulfield dlm_local_addr[dlm_local_count++] = addr; 12006ed7257bSPatrick Caulfield } 12016ed7257bSPatrick Caulfield } 12026ed7257bSPatrick Caulfield 1203043697f0SAlexander Aring static void deinit_local(void) 1204043697f0SAlexander Aring { 1205043697f0SAlexander Aring int i; 1206043697f0SAlexander Aring 1207043697f0SAlexander Aring for (i = 0; i < dlm_local_count; i++) 1208043697f0SAlexander Aring kfree(dlm_local_addr[i]); 1209043697f0SAlexander Aring } 1210043697f0SAlexander Aring 1211be3b0400SAlexander Aring static struct writequeue_entry *new_writequeue_entry(struct connection *con) 12126ed7257bSPatrick Caulfield { 12136ed7257bSPatrick Caulfield struct writequeue_entry *entry; 12146ed7257bSPatrick Caulfield 12153af2326cSAlexander Aring entry = dlm_allocate_writequeue(); 12166ed7257bSPatrick Caulfield if (!entry) 12176ed7257bSPatrick Caulfield return NULL; 12186ed7257bSPatrick Caulfield 1219be3b0400SAlexander Aring entry->page = alloc_page(GFP_ATOMIC | __GFP_ZERO); 12206ed7257bSPatrick Caulfield if (!entry->page) { 12213af2326cSAlexander Aring dlm_free_writequeue(entry); 12226ed7257bSPatrick Caulfield return NULL; 12236ed7257bSPatrick Caulfield } 12246ed7257bSPatrick Caulfield 12253af2326cSAlexander Aring entry->offset = 0; 12263af2326cSAlexander Aring entry->len = 0; 12273af2326cSAlexander Aring entry->end = 0; 12283af2326cSAlexander Aring entry->dirty = false; 12296ed7257bSPatrick Caulfield entry->con = con; 1230f0747ebfSAlexander Aring entry->users = 1; 12318f2dc78dSAlexander Aring kref_init(&entry->ref); 12326ed7257bSPatrick Caulfield return entry; 12336ed7257bSPatrick Caulfield } 12346ed7257bSPatrick Caulfield 1235f0747ebfSAlexander Aring static struct writequeue_entry *new_wq_entry(struct connection *con, int len, 1236be3b0400SAlexander Aring char **ppc, void (*cb)(void *data), 1237be3b0400SAlexander Aring void *data) 1238f0747ebfSAlexander Aring { 1239f0747ebfSAlexander Aring struct writequeue_entry *e; 1240f0747ebfSAlexander Aring 1241f0747ebfSAlexander Aring spin_lock(&con->writequeue_lock); 1242f0747ebfSAlexander Aring if (!list_empty(&con->writequeue)) { 1243f0747ebfSAlexander Aring e = list_last_entry(&con->writequeue, struct writequeue_entry, list); 1244f0747ebfSAlexander Aring if (DLM_WQ_REMAIN_BYTES(e) >= len) { 12458f2dc78dSAlexander Aring kref_get(&e->ref); 12468f2dc78dSAlexander Aring 1247f0747ebfSAlexander Aring *ppc = page_address(e->page) + e->end; 12488f2dc78dSAlexander Aring if (cb) 12495c16febbSAlexander Aring cb(data); 12508f2dc78dSAlexander Aring 1251f0747ebfSAlexander Aring e->end += len; 1252f0747ebfSAlexander Aring e->users++; 1253be3b0400SAlexander Aring goto out; 1254f0747ebfSAlexander Aring } 1255f0747ebfSAlexander Aring } 1256f0747ebfSAlexander Aring 1257be3b0400SAlexander Aring e = new_writequeue_entry(con); 1258f0747ebfSAlexander Aring if (!e) 1259be3b0400SAlexander Aring goto out; 1260f0747ebfSAlexander Aring 12618f2dc78dSAlexander Aring kref_get(&e->ref); 1262f0747ebfSAlexander Aring *ppc = page_address(e->page); 1263f0747ebfSAlexander Aring e->end += len; 12648aa31cbfSAlexander Aring atomic_inc(&con->writequeue_cnt); 12658f2dc78dSAlexander Aring if (cb) 12665c16febbSAlexander Aring cb(data); 12678f2dc78dSAlexander Aring 1268f0747ebfSAlexander Aring list_add_tail(&e->list, &con->writequeue); 1269f0747ebfSAlexander Aring 1270be3b0400SAlexander Aring out: 1271be3b0400SAlexander Aring spin_unlock(&con->writequeue_lock); 1272f0747ebfSAlexander Aring return e; 1273f0747ebfSAlexander Aring }; 1274f0747ebfSAlexander Aring 12752874d1a6SAlexander Aring static struct dlm_msg *dlm_lowcomms_new_msg_con(struct connection *con, int len, 12762874d1a6SAlexander Aring gfp_t allocation, char **ppc, 12775c16febbSAlexander Aring void (*cb)(void *data), 12785c16febbSAlexander Aring void *data) 12792874d1a6SAlexander Aring { 12802874d1a6SAlexander Aring struct writequeue_entry *e; 12812874d1a6SAlexander Aring struct dlm_msg *msg; 12822874d1a6SAlexander Aring 1283e4dc81edSAlexander Aring msg = dlm_allocate_msg(allocation); 12842874d1a6SAlexander Aring if (!msg) 12852874d1a6SAlexander Aring return NULL; 12862874d1a6SAlexander Aring 12872874d1a6SAlexander Aring kref_init(&msg->ref); 12882874d1a6SAlexander Aring 1289be3b0400SAlexander Aring e = new_wq_entry(con, len, ppc, cb, data); 12902874d1a6SAlexander Aring if (!e) { 1291e4dc81edSAlexander Aring dlm_free_msg(msg); 12922874d1a6SAlexander Aring return NULL; 12932874d1a6SAlexander Aring } 12942874d1a6SAlexander Aring 1295e4dc81edSAlexander Aring msg->retransmit = false; 1296e4dc81edSAlexander Aring msg->orig_msg = NULL; 12972874d1a6SAlexander Aring msg->ppc = *ppc; 12982874d1a6SAlexander Aring msg->len = len; 12992874d1a6SAlexander Aring msg->entry = e; 13002874d1a6SAlexander Aring 13012874d1a6SAlexander Aring return msg; 13022874d1a6SAlexander Aring } 13032874d1a6SAlexander Aring 1304a8449f23SAlexander Aring /* avoid false positive for nodes_srcu, unlock happens in 1305a8449f23SAlexander Aring * dlm_lowcomms_commit_msg which is a must call if success 1306a8449f23SAlexander Aring */ 1307a8449f23SAlexander Aring #ifndef __CHECKER__ 13088f2dc78dSAlexander Aring struct dlm_msg *dlm_lowcomms_new_msg(int nodeid, int len, gfp_t allocation, 13095c16febbSAlexander Aring char **ppc, void (*cb)(void *data), 13105c16febbSAlexander Aring void *data) 13116ed7257bSPatrick Caulfield { 13126ed7257bSPatrick Caulfield struct connection *con; 13138f2dc78dSAlexander Aring struct dlm_msg *msg; 1314b38bc9c2SAlexander Aring int idx; 13156ed7257bSPatrick Caulfield 1316d10a0b88SAlexander Aring if (len > DLM_MAX_SOCKET_BUFSIZE || 1317c45674fbSAlexander Aring len < sizeof(struct dlm_header)) { 1318d10a0b88SAlexander Aring BUILD_BUG_ON(PAGE_SIZE < DLM_MAX_SOCKET_BUFSIZE); 1319692f51c8SAlexander Aring log_print("failed to allocate a buffer of size %d", len); 1320c45674fbSAlexander Aring WARN_ON(1); 1321692f51c8SAlexander Aring return NULL; 1322692f51c8SAlexander Aring } 1323692f51c8SAlexander Aring 1324b38bc9c2SAlexander Aring idx = srcu_read_lock(&connections_srcu); 13256ed7257bSPatrick Caulfield con = nodeid2con(nodeid, allocation); 1326b38bc9c2SAlexander Aring if (!con) { 1327b38bc9c2SAlexander Aring srcu_read_unlock(&connections_srcu, idx); 13286ed7257bSPatrick Caulfield return NULL; 1329b38bc9c2SAlexander Aring } 13306ed7257bSPatrick Caulfield 13315c16febbSAlexander Aring msg = dlm_lowcomms_new_msg_con(con, len, allocation, ppc, cb, data); 13328f2dc78dSAlexander Aring if (!msg) { 1333b38bc9c2SAlexander Aring srcu_read_unlock(&connections_srcu, idx); 1334b38bc9c2SAlexander Aring return NULL; 1335b38bc9c2SAlexander Aring } 1336b38bc9c2SAlexander Aring 133730ea3257SAlexander Aring /* for dlm_lowcomms_commit_msg() */ 133830ea3257SAlexander Aring kref_get(&msg->ref); 13398f2dc78dSAlexander Aring /* we assume if successful commit must called */ 13408f2dc78dSAlexander Aring msg->idx = idx; 13418f2dc78dSAlexander Aring return msg; 13428f2dc78dSAlexander Aring } 1343a8449f23SAlexander Aring #endif 13448f2dc78dSAlexander Aring 13452874d1a6SAlexander Aring static void _dlm_lowcomms_commit_msg(struct dlm_msg *msg) 13466ed7257bSPatrick Caulfield { 13478f2dc78dSAlexander Aring struct writequeue_entry *e = msg->entry; 13486ed7257bSPatrick Caulfield struct connection *con = e->con; 13496ed7257bSPatrick Caulfield int users; 13506ed7257bSPatrick Caulfield 13516ed7257bSPatrick Caulfield spin_lock(&con->writequeue_lock); 13528f2dc78dSAlexander Aring kref_get(&msg->ref); 13538f2dc78dSAlexander Aring list_add(&msg->list, &e->msgs); 13548f2dc78dSAlexander Aring 13556ed7257bSPatrick Caulfield users = --e->users; 13566ed7257bSPatrick Caulfield if (users) 13576ed7257bSPatrick Caulfield goto out; 1358f0747ebfSAlexander Aring 1359f0747ebfSAlexander Aring e->len = DLM_WQ_LENGTH_BYTES(e); 13606ed7257bSPatrick Caulfield spin_unlock(&con->writequeue_lock); 13616ed7257bSPatrick Caulfield 13626ed7257bSPatrick Caulfield queue_work(send_workqueue, &con->swork); 13636ed7257bSPatrick Caulfield return; 13646ed7257bSPatrick Caulfield 13656ed7257bSPatrick Caulfield out: 13666ed7257bSPatrick Caulfield spin_unlock(&con->writequeue_lock); 13676ed7257bSPatrick Caulfield return; 13686ed7257bSPatrick Caulfield } 13696ed7257bSPatrick Caulfield 1370a8449f23SAlexander Aring /* avoid false positive for nodes_srcu, lock was happen in 1371a8449f23SAlexander Aring * dlm_lowcomms_new_msg 1372a8449f23SAlexander Aring */ 1373a8449f23SAlexander Aring #ifndef __CHECKER__ 13742874d1a6SAlexander Aring void dlm_lowcomms_commit_msg(struct dlm_msg *msg) 13752874d1a6SAlexander Aring { 13762874d1a6SAlexander Aring _dlm_lowcomms_commit_msg(msg); 13772874d1a6SAlexander Aring srcu_read_unlock(&connections_srcu, msg->idx); 137830ea3257SAlexander Aring /* because dlm_lowcomms_new_msg() */ 137930ea3257SAlexander Aring kref_put(&msg->ref, dlm_msg_release); 13802874d1a6SAlexander Aring } 1381a8449f23SAlexander Aring #endif 13822874d1a6SAlexander Aring 13838f2dc78dSAlexander Aring void dlm_lowcomms_put_msg(struct dlm_msg *msg) 13848f2dc78dSAlexander Aring { 13858f2dc78dSAlexander Aring kref_put(&msg->ref, dlm_msg_release); 13868f2dc78dSAlexander Aring } 13878f2dc78dSAlexander Aring 13882874d1a6SAlexander Aring /* does not held connections_srcu, usage workqueue only */ 13892874d1a6SAlexander Aring int dlm_lowcomms_resend_msg(struct dlm_msg *msg) 13902874d1a6SAlexander Aring { 13912874d1a6SAlexander Aring struct dlm_msg *msg_resend; 13922874d1a6SAlexander Aring char *ppc; 13932874d1a6SAlexander Aring 13942874d1a6SAlexander Aring if (msg->retransmit) 13952874d1a6SAlexander Aring return 1; 13962874d1a6SAlexander Aring 13972874d1a6SAlexander Aring msg_resend = dlm_lowcomms_new_msg_con(msg->entry->con, msg->len, 13982874d1a6SAlexander Aring GFP_ATOMIC, &ppc, NULL, NULL); 13992874d1a6SAlexander Aring if (!msg_resend) 14002874d1a6SAlexander Aring return -ENOMEM; 14012874d1a6SAlexander Aring 14022874d1a6SAlexander Aring msg->retransmit = true; 14032874d1a6SAlexander Aring kref_get(&msg->ref); 14042874d1a6SAlexander Aring msg_resend->orig_msg = msg; 14052874d1a6SAlexander Aring 14062874d1a6SAlexander Aring memcpy(ppc, msg->ppc, msg->len); 14072874d1a6SAlexander Aring _dlm_lowcomms_commit_msg(msg_resend); 14082874d1a6SAlexander Aring dlm_lowcomms_put_msg(msg_resend); 14092874d1a6SAlexander Aring 14102874d1a6SAlexander Aring return 0; 14112874d1a6SAlexander Aring } 14122874d1a6SAlexander Aring 14136ed7257bSPatrick Caulfield /* Send a message */ 14146ed7257bSPatrick Caulfield static void send_to_sock(struct connection *con) 14156ed7257bSPatrick Caulfield { 14166ed7257bSPatrick Caulfield const int msg_flags = MSG_DONTWAIT | MSG_NOSIGNAL; 14176ed7257bSPatrick Caulfield struct writequeue_entry *e; 141866d5955aSAlexander Aring int len, offset, ret; 1419194a3fb4SAlexander Aring int count; 1420194a3fb4SAlexander Aring 1421194a3fb4SAlexander Aring again: 1422194a3fb4SAlexander Aring count = 0; 14236ed7257bSPatrick Caulfield 14246ed7257bSPatrick Caulfield mutex_lock(&con->sock_mutex); 14256ed7257bSPatrick Caulfield if (con->sock == NULL) 14266ed7257bSPatrick Caulfield goto out_connect; 14276ed7257bSPatrick Caulfield 14286ed7257bSPatrick Caulfield spin_lock(&con->writequeue_lock); 14296ed7257bSPatrick Caulfield for (;;) { 143066d5955aSAlexander Aring e = con_next_wq(con); 143166d5955aSAlexander Aring if (!e) 14326ed7257bSPatrick Caulfield break; 14336ed7257bSPatrick Caulfield 14346ed7257bSPatrick Caulfield len = e->len; 14356ed7257bSPatrick Caulfield offset = e->offset; 14366ed7257bSPatrick Caulfield BUG_ON(len == 0 && e->users == 0); 14376ed7257bSPatrick Caulfield spin_unlock(&con->writequeue_lock); 14386ed7257bSPatrick Caulfield 14391329e3f2SPaolo Bonzini ret = kernel_sendpage(con->sock, e->page, offset, len, 14406ed7257bSPatrick Caulfield msg_flags); 144192732376SAlexander Aring trace_dlm_send(con->nodeid, ret); 1442d66f8277SPatrick Caulfield if (ret == -EAGAIN || ret == 0) { 1443b36930ddSDavid Miller if (ret == -EAGAIN && 14449cd3e072SEric Dumazet test_bit(SOCKWQ_ASYNC_NOSPACE, &con->sock->flags) && 1445b36930ddSDavid Miller !test_and_set_bit(CF_APP_LIMITED, &con->flags)) { 1446b36930ddSDavid Miller /* Notify TCP that we're limited by the 1447b36930ddSDavid Miller * application window size. 1448b36930ddSDavid Miller */ 1449b36930ddSDavid Miller set_bit(SOCK_NOSPACE, &con->sock->flags); 1450b36930ddSDavid Miller con->sock->sk->sk_write_pending++; 1451b36930ddSDavid Miller } 1452d66f8277SPatrick Caulfield cond_resched(); 14536ed7257bSPatrick Caulfield goto out; 14549c5bef58SYing Xue } else if (ret < 0) 1455ba868d9dSAlexander Aring goto out; 1456f92c8dd7SBob Peterson 14576ed7257bSPatrick Caulfield spin_lock(&con->writequeue_lock); 14585d689871SMike Christie writequeue_entry_complete(e, ret); 1459194a3fb4SAlexander Aring 1460194a3fb4SAlexander Aring /* Don't starve people filling buffers */ 1461194a3fb4SAlexander Aring if (++count >= MAX_SEND_MSG_COUNT) { 1462194a3fb4SAlexander Aring spin_unlock(&con->writequeue_lock); 1463194a3fb4SAlexander Aring mutex_unlock(&con->sock_mutex); 1464194a3fb4SAlexander Aring cond_resched(); 1465194a3fb4SAlexander Aring goto again; 1466194a3fb4SAlexander Aring } 14676ed7257bSPatrick Caulfield } 14686ed7257bSPatrick Caulfield spin_unlock(&con->writequeue_lock); 14698aa31cbfSAlexander Aring 14708aa31cbfSAlexander Aring /* close if we got EOF */ 14718aa31cbfSAlexander Aring if (test_and_clear_bit(CF_EOF, &con->flags)) { 14728aa31cbfSAlexander Aring mutex_unlock(&con->sock_mutex); 14738aa31cbfSAlexander Aring close_connection(con, false, false, true); 14748aa31cbfSAlexander Aring 14758aa31cbfSAlexander Aring /* handling for tcp shutdown */ 14768aa31cbfSAlexander Aring clear_bit(CF_SHUTDOWN, &con->flags); 14778aa31cbfSAlexander Aring wake_up(&con->shutdown_wait); 14788aa31cbfSAlexander Aring } else { 14798aa31cbfSAlexander Aring mutex_unlock(&con->sock_mutex); 14808aa31cbfSAlexander Aring } 14818aa31cbfSAlexander Aring 14828aa31cbfSAlexander Aring return; 14838aa31cbfSAlexander Aring 14846ed7257bSPatrick Caulfield out: 14856ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 14866ed7257bSPatrick Caulfield return; 14876ed7257bSPatrick Caulfield 14886ed7257bSPatrick Caulfield out_connect: 14896ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 149001da24d3SBob Peterson queue_work(send_workqueue, &con->swork); 149101da24d3SBob Peterson cond_resched(); 14926ed7257bSPatrick Caulfield } 14936ed7257bSPatrick Caulfield 14946ed7257bSPatrick Caulfield static void clean_one_writequeue(struct connection *con) 14956ed7257bSPatrick Caulfield { 14965e9ccc37SChristine Caulfield struct writequeue_entry *e, *safe; 14976ed7257bSPatrick Caulfield 14986ed7257bSPatrick Caulfield spin_lock(&con->writequeue_lock); 14995e9ccc37SChristine Caulfield list_for_each_entry_safe(e, safe, &con->writequeue, list) { 15006ed7257bSPatrick Caulfield free_entry(e); 15016ed7257bSPatrick Caulfield } 15026ed7257bSPatrick Caulfield spin_unlock(&con->writequeue_lock); 15036ed7257bSPatrick Caulfield } 15046ed7257bSPatrick Caulfield 15056ed7257bSPatrick Caulfield /* Called from recovery when it knows that a node has 15066ed7257bSPatrick Caulfield left the cluster */ 15076ed7257bSPatrick Caulfield int dlm_lowcomms_close(int nodeid) 15086ed7257bSPatrick Caulfield { 15096ed7257bSPatrick Caulfield struct connection *con; 151036b71a8bSDavid Teigland struct dlm_node_addr *na; 1511b38bc9c2SAlexander Aring int idx; 15126ed7257bSPatrick Caulfield 15136ed7257bSPatrick Caulfield log_print("closing connection to node %d", nodeid); 1514b38bc9c2SAlexander Aring idx = srcu_read_lock(&connections_srcu); 15156ed7257bSPatrick Caulfield con = nodeid2con(nodeid, 0); 15166ed7257bSPatrick Caulfield if (con) { 1517063c4c99SLars Marowsky-Bree set_bit(CF_CLOSE, &con->flags); 15180d737a8cSMarcelo Ricardo Leitner close_connection(con, true, true, true); 15196ed7257bSPatrick Caulfield clean_one_writequeue(con); 152053a5edaaSAlexander Aring if (con->othercon) 152153a5edaaSAlexander Aring clean_one_writequeue(con->othercon); 15226ed7257bSPatrick Caulfield } 1523b38bc9c2SAlexander Aring srcu_read_unlock(&connections_srcu, idx); 152436b71a8bSDavid Teigland 152536b71a8bSDavid Teigland spin_lock(&dlm_node_addrs_spin); 152636b71a8bSDavid Teigland na = find_node_addr(nodeid); 152736b71a8bSDavid Teigland if (na) { 152836b71a8bSDavid Teigland list_del(&na->list); 152936b71a8bSDavid Teigland while (na->addr_count--) 153036b71a8bSDavid Teigland kfree(na->addr[na->addr_count]); 153136b71a8bSDavid Teigland kfree(na); 153236b71a8bSDavid Teigland } 153336b71a8bSDavid Teigland spin_unlock(&dlm_node_addrs_spin); 153436b71a8bSDavid Teigland 15356ed7257bSPatrick Caulfield return 0; 15366ed7257bSPatrick Caulfield } 15376ed7257bSPatrick Caulfield 15386ed7257bSPatrick Caulfield /* Receive workqueue function */ 15396ed7257bSPatrick Caulfield static void process_recv_sockets(struct work_struct *work) 15406ed7257bSPatrick Caulfield { 15416ed7257bSPatrick Caulfield struct connection *con = container_of(work, struct connection, rwork); 15426ed7257bSPatrick Caulfield 15436ed7257bSPatrick Caulfield clear_bit(CF_READ_PENDING, &con->flags); 154462699b3fSAlexander Aring receive_from_sock(con); 15456ed7257bSPatrick Caulfield } 15466ed7257bSPatrick Caulfield 1547d11ccd45SAlexander Aring static void process_listen_recv_socket(struct work_struct *work) 1548d11ccd45SAlexander Aring { 1549f0f4bb43SAlexander Aring int ret; 1550f0f4bb43SAlexander Aring 1551f0f4bb43SAlexander Aring do { 1552f0f4bb43SAlexander Aring ret = accept_from_sock(&listen_con); 1553f0f4bb43SAlexander Aring } while (!ret); 1554d11ccd45SAlexander Aring } 1555d11ccd45SAlexander Aring 15568728a455SAlexander Aring static void dlm_connect(struct connection *con) 15578728a455SAlexander Aring { 15588728a455SAlexander Aring struct sockaddr_storage addr; 15598728a455SAlexander Aring int result, addr_len; 15608728a455SAlexander Aring struct socket *sock; 15618728a455SAlexander Aring unsigned int mark; 15628728a455SAlexander Aring 15638728a455SAlexander Aring /* Some odd races can cause double-connects, ignore them */ 15648728a455SAlexander Aring if (con->retries++ > MAX_CONNECT_RETRIES) 15658728a455SAlexander Aring return; 15668728a455SAlexander Aring 15678728a455SAlexander Aring if (con->sock) { 15688728a455SAlexander Aring log_print("node %d already connected.", con->nodeid); 15698728a455SAlexander Aring return; 15708728a455SAlexander Aring } 15718728a455SAlexander Aring 15728728a455SAlexander Aring memset(&addr, 0, sizeof(addr)); 15738728a455SAlexander Aring result = nodeid_to_addr(con->nodeid, &addr, NULL, 15748728a455SAlexander Aring dlm_proto_ops->try_new_addr, &mark); 15758728a455SAlexander Aring if (result < 0) { 15768728a455SAlexander Aring log_print("no address for nodeid %d", con->nodeid); 15778728a455SAlexander Aring return; 15788728a455SAlexander Aring } 15798728a455SAlexander Aring 15808728a455SAlexander Aring /* Create a socket to communicate with */ 15818728a455SAlexander Aring result = sock_create_kern(&init_net, dlm_local_addr[0]->ss_family, 15828728a455SAlexander Aring SOCK_STREAM, dlm_proto_ops->proto, &sock); 15838728a455SAlexander Aring if (result < 0) 15848728a455SAlexander Aring goto socket_err; 15858728a455SAlexander Aring 15868728a455SAlexander Aring sock_set_mark(sock->sk, mark); 15878728a455SAlexander Aring dlm_proto_ops->sockopts(sock); 15888728a455SAlexander Aring 15898728a455SAlexander Aring add_sock(sock, con); 15908728a455SAlexander Aring 15918728a455SAlexander Aring result = dlm_proto_ops->bind(sock); 15928728a455SAlexander Aring if (result < 0) 15938728a455SAlexander Aring goto add_sock_err; 15948728a455SAlexander Aring 15958728a455SAlexander Aring log_print_ratelimited("connecting to %d", con->nodeid); 15968728a455SAlexander Aring make_sockaddr(&addr, dlm_config.ci_tcp_port, &addr_len); 15978728a455SAlexander Aring result = dlm_proto_ops->connect(con, sock, (struct sockaddr *)&addr, 15988728a455SAlexander Aring addr_len); 15998728a455SAlexander Aring if (result < 0) 16008728a455SAlexander Aring goto add_sock_err; 16018728a455SAlexander Aring 16028728a455SAlexander Aring return; 16038728a455SAlexander Aring 16048728a455SAlexander Aring add_sock_err: 16058728a455SAlexander Aring dlm_close_sock(&con->sock); 16068728a455SAlexander Aring 16078728a455SAlexander Aring socket_err: 16088728a455SAlexander Aring /* 16098728a455SAlexander Aring * Some errors are fatal and this list might need adjusting. For other 16108728a455SAlexander Aring * errors we try again until the max number of retries is reached. 16118728a455SAlexander Aring */ 16128728a455SAlexander Aring if (result != -EHOSTUNREACH && 16138728a455SAlexander Aring result != -ENETUNREACH && 16148728a455SAlexander Aring result != -ENETDOWN && 16158728a455SAlexander Aring result != -EINVAL && 16168728a455SAlexander Aring result != -EPROTONOSUPPORT) { 16178728a455SAlexander Aring log_print("connect %d try %d error %d", con->nodeid, 16188728a455SAlexander Aring con->retries, result); 16198728a455SAlexander Aring msleep(1000); 16208728a455SAlexander Aring lowcomms_connect_sock(con); 16218728a455SAlexander Aring } 16228728a455SAlexander Aring } 16238728a455SAlexander Aring 16246ed7257bSPatrick Caulfield /* Send workqueue function */ 16256ed7257bSPatrick Caulfield static void process_send_sockets(struct work_struct *work) 16266ed7257bSPatrick Caulfield { 16276ed7257bSPatrick Caulfield struct connection *con = container_of(work, struct connection, swork); 16286ed7257bSPatrick Caulfield 16297443bc96SAlexander Aring WARN_ON(test_bit(CF_IS_OTHERCON, &con->flags)); 16307443bc96SAlexander Aring 16318a4abb08Stsutomu.owa@toshiba.co.jp clear_bit(CF_WRITE_PENDING, &con->flags); 1632ba868d9dSAlexander Aring 1633489d8e55SAlexander Aring if (test_and_clear_bit(CF_RECONNECT, &con->flags)) { 1634ba868d9dSAlexander Aring close_connection(con, false, false, true); 1635489d8e55SAlexander Aring dlm_midcomms_unack_msg_resend(con->nodeid); 1636489d8e55SAlexander Aring } 1637ba868d9dSAlexander Aring 16388728a455SAlexander Aring if (con->sock == NULL) { 1639ba868d9dSAlexander Aring if (test_and_clear_bit(CF_DELAY_CONNECT, &con->flags)) 1640ba868d9dSAlexander Aring msleep(1000); 16418728a455SAlexander Aring 16428728a455SAlexander Aring mutex_lock(&con->sock_mutex); 16438728a455SAlexander Aring dlm_connect(con); 16448728a455SAlexander Aring mutex_unlock(&con->sock_mutex); 1645ba868d9dSAlexander Aring } 16468728a455SAlexander Aring 164701da24d3SBob Peterson if (!list_empty(&con->writequeue)) 16486ed7257bSPatrick Caulfield send_to_sock(con); 16496ed7257bSPatrick Caulfield } 16506ed7257bSPatrick Caulfield 16516ed7257bSPatrick Caulfield static void work_stop(void) 16526ed7257bSPatrick Caulfield { 1653fcef0e6cSAlexander Aring if (recv_workqueue) { 16546ed7257bSPatrick Caulfield destroy_workqueue(recv_workqueue); 1655fcef0e6cSAlexander Aring recv_workqueue = NULL; 1656fcef0e6cSAlexander Aring } 1657fcef0e6cSAlexander Aring 1658fcef0e6cSAlexander Aring if (send_workqueue) { 16596ed7257bSPatrick Caulfield destroy_workqueue(send_workqueue); 1660fcef0e6cSAlexander Aring send_workqueue = NULL; 1661fcef0e6cSAlexander Aring } 16626ed7257bSPatrick Caulfield } 16636ed7257bSPatrick Caulfield 16646ed7257bSPatrick Caulfield static int work_start(void) 16656ed7257bSPatrick Caulfield { 16666c6a1cc6SAlexander Aring recv_workqueue = alloc_ordered_workqueue("dlm_recv", WQ_MEM_RECLAIM); 1667b9d41052SNamhyung Kim if (!recv_workqueue) { 1668b9d41052SNamhyung Kim log_print("can't start dlm_recv"); 1669b9d41052SNamhyung Kim return -ENOMEM; 16706ed7257bSPatrick Caulfield } 16716ed7257bSPatrick Caulfield 16726c6a1cc6SAlexander Aring send_workqueue = alloc_ordered_workqueue("dlm_send", WQ_MEM_RECLAIM); 1673b9d41052SNamhyung Kim if (!send_workqueue) { 1674b9d41052SNamhyung Kim log_print("can't start dlm_send"); 16756ed7257bSPatrick Caulfield destroy_workqueue(recv_workqueue); 1676fcef0e6cSAlexander Aring recv_workqueue = NULL; 1677b9d41052SNamhyung Kim return -ENOMEM; 16786ed7257bSPatrick Caulfield } 16796ed7257bSPatrick Caulfield 16806ed7257bSPatrick Caulfield return 0; 16816ed7257bSPatrick Caulfield } 16826ed7257bSPatrick Caulfield 16839d232469SAlexander Aring static void shutdown_conn(struct connection *con) 16849d232469SAlexander Aring { 1685a66c008cSAlexander Aring if (dlm_proto_ops->shutdown_action) 1686a66c008cSAlexander Aring dlm_proto_ops->shutdown_action(con); 16879d232469SAlexander Aring } 16889d232469SAlexander Aring 16899d232469SAlexander Aring void dlm_lowcomms_shutdown(void) 16909d232469SAlexander Aring { 1691b38bc9c2SAlexander Aring int idx; 1692b38bc9c2SAlexander Aring 1693*1037c2a9SAlexander Aring restore_callbacks(listen_con.sock); 16949d232469SAlexander Aring 16959d232469SAlexander Aring if (recv_workqueue) 16969d232469SAlexander Aring flush_workqueue(recv_workqueue); 16979d232469SAlexander Aring if (send_workqueue) 16989d232469SAlexander Aring flush_workqueue(send_workqueue); 16999d232469SAlexander Aring 17009d232469SAlexander Aring dlm_close_sock(&listen_con.sock); 17019d232469SAlexander Aring 1702b38bc9c2SAlexander Aring idx = srcu_read_lock(&connections_srcu); 17039d232469SAlexander Aring foreach_conn(shutdown_conn); 1704b38bc9c2SAlexander Aring srcu_read_unlock(&connections_srcu, idx); 17059d232469SAlexander Aring } 17069d232469SAlexander Aring 1707f0fb83cbStsutomu.owa@toshiba.co.jp static void _stop_conn(struct connection *con, bool and_other) 17086ed7257bSPatrick Caulfield { 1709f0fb83cbStsutomu.owa@toshiba.co.jp mutex_lock(&con->sock_mutex); 1710173a31feStsutomu.owa@toshiba.co.jp set_bit(CF_CLOSE, &con->flags); 1711f0fb83cbStsutomu.owa@toshiba.co.jp set_bit(CF_READ_PENDING, &con->flags); 17128a4abb08Stsutomu.owa@toshiba.co.jp set_bit(CF_WRITE_PENDING, &con->flags); 171393eaadebStsutomu.owa@toshiba.co.jp if (con->sock && con->sock->sk) { 171492c44605SAlexander Aring lock_sock(con->sock->sk); 1715afb853fbSPatrick Caulfield con->sock->sk->sk_user_data = NULL; 171692c44605SAlexander Aring release_sock(con->sock->sk); 171793eaadebStsutomu.owa@toshiba.co.jp } 1718f0fb83cbStsutomu.owa@toshiba.co.jp if (con->othercon && and_other) 1719f0fb83cbStsutomu.owa@toshiba.co.jp _stop_conn(con->othercon, false); 1720f0fb83cbStsutomu.owa@toshiba.co.jp mutex_unlock(&con->sock_mutex); 1721f0fb83cbStsutomu.owa@toshiba.co.jp } 1722f0fb83cbStsutomu.owa@toshiba.co.jp 1723f0fb83cbStsutomu.owa@toshiba.co.jp static void stop_conn(struct connection *con) 1724f0fb83cbStsutomu.owa@toshiba.co.jp { 1725f0fb83cbStsutomu.owa@toshiba.co.jp _stop_conn(con, true); 1726afb853fbSPatrick Caulfield } 17275e9ccc37SChristine Caulfield 17284798cbbfSAlexander Aring static void connection_release(struct rcu_head *rcu) 17294798cbbfSAlexander Aring { 17304798cbbfSAlexander Aring struct connection *con = container_of(rcu, struct connection, rcu); 17314798cbbfSAlexander Aring 17324798cbbfSAlexander Aring kfree(con->rx_buf); 17334798cbbfSAlexander Aring kfree(con); 17344798cbbfSAlexander Aring } 17354798cbbfSAlexander Aring 17365e9ccc37SChristine Caulfield static void free_conn(struct connection *con) 17375e9ccc37SChristine Caulfield { 17380d737a8cSMarcelo Ricardo Leitner close_connection(con, true, true, true); 1739a47666ebSAlexander Aring spin_lock(&connections_lock); 1740a47666ebSAlexander Aring hlist_del_rcu(&con->list); 1741a47666ebSAlexander Aring spin_unlock(&connections_lock); 1742948c47e9SAlexander Aring if (con->othercon) { 1743948c47e9SAlexander Aring clean_one_writequeue(con->othercon); 17445cbec208SAlexander Aring call_srcu(&connections_srcu, &con->othercon->rcu, 17455cbec208SAlexander Aring connection_release); 1746948c47e9SAlexander Aring } 17470de98432SAlexander Aring clean_one_writequeue(con); 17485cbec208SAlexander Aring call_srcu(&connections_srcu, &con->rcu, connection_release); 17496ed7257bSPatrick Caulfield } 17505e9ccc37SChristine Caulfield 1751f0fb83cbStsutomu.owa@toshiba.co.jp static void work_flush(void) 1752f0fb83cbStsutomu.owa@toshiba.co.jp { 1753b38bc9c2SAlexander Aring int ok; 1754f0fb83cbStsutomu.owa@toshiba.co.jp int i; 1755f0fb83cbStsutomu.owa@toshiba.co.jp struct connection *con; 1756f0fb83cbStsutomu.owa@toshiba.co.jp 1757f0fb83cbStsutomu.owa@toshiba.co.jp do { 1758f0fb83cbStsutomu.owa@toshiba.co.jp ok = 1; 1759f0fb83cbStsutomu.owa@toshiba.co.jp foreach_conn(stop_conn); 1760b355516fSDavid Windsor if (recv_workqueue) 1761f0fb83cbStsutomu.owa@toshiba.co.jp flush_workqueue(recv_workqueue); 1762b355516fSDavid Windsor if (send_workqueue) 1763f0fb83cbStsutomu.owa@toshiba.co.jp flush_workqueue(send_workqueue); 1764f0fb83cbStsutomu.owa@toshiba.co.jp for (i = 0; i < CONN_HASH_SIZE && ok; i++) { 1765a47666ebSAlexander Aring hlist_for_each_entry_rcu(con, &connection_hash[i], 1766a47666ebSAlexander Aring list) { 1767f0fb83cbStsutomu.owa@toshiba.co.jp ok &= test_bit(CF_READ_PENDING, &con->flags); 17688a4abb08Stsutomu.owa@toshiba.co.jp ok &= test_bit(CF_WRITE_PENDING, &con->flags); 17698a4abb08Stsutomu.owa@toshiba.co.jp if (con->othercon) { 1770f0fb83cbStsutomu.owa@toshiba.co.jp ok &= test_bit(CF_READ_PENDING, 1771f0fb83cbStsutomu.owa@toshiba.co.jp &con->othercon->flags); 17728a4abb08Stsutomu.owa@toshiba.co.jp ok &= test_bit(CF_WRITE_PENDING, 17738a4abb08Stsutomu.owa@toshiba.co.jp &con->othercon->flags); 17748a4abb08Stsutomu.owa@toshiba.co.jp } 1775f0fb83cbStsutomu.owa@toshiba.co.jp } 1776f0fb83cbStsutomu.owa@toshiba.co.jp } 1777f0fb83cbStsutomu.owa@toshiba.co.jp } while (!ok); 1778f0fb83cbStsutomu.owa@toshiba.co.jp } 1779f0fb83cbStsutomu.owa@toshiba.co.jp 17805e9ccc37SChristine Caulfield void dlm_lowcomms_stop(void) 17815e9ccc37SChristine Caulfield { 1782b38bc9c2SAlexander Aring int idx; 1783b38bc9c2SAlexander Aring 1784b38bc9c2SAlexander Aring idx = srcu_read_lock(&connections_srcu); 1785f0fb83cbStsutomu.owa@toshiba.co.jp work_flush(); 17863a8db798SMarcelo Ricardo Leitner foreach_conn(free_conn); 1787b38bc9c2SAlexander Aring srcu_read_unlock(&connections_srcu, idx); 17886ed7257bSPatrick Caulfield work_stop(); 1789043697f0SAlexander Aring deinit_local(); 1790a66c008cSAlexander Aring 1791a66c008cSAlexander Aring dlm_proto_ops = NULL; 17926ed7257bSPatrick Caulfield } 17936ed7257bSPatrick Caulfield 17942dc6b115SAlexander Aring static int dlm_listen_for_all(void) 17952dc6b115SAlexander Aring { 17962dc6b115SAlexander Aring struct socket *sock; 17972dc6b115SAlexander Aring int result; 17982dc6b115SAlexander Aring 17992dc6b115SAlexander Aring log_print("Using %s for communications", 18002dc6b115SAlexander Aring dlm_proto_ops->name); 18012dc6b115SAlexander Aring 18022dc6b115SAlexander Aring result = dlm_proto_ops->listen_validate(); 18032dc6b115SAlexander Aring if (result < 0) 18042dc6b115SAlexander Aring return result; 18052dc6b115SAlexander Aring 18062dc6b115SAlexander Aring result = sock_create_kern(&init_net, dlm_local_addr[0]->ss_family, 18072dc6b115SAlexander Aring SOCK_STREAM, dlm_proto_ops->proto, &sock); 18082dc6b115SAlexander Aring if (result < 0) { 1809fe933675SAlexander Aring log_print("Can't create comms socket: %d", result); 18101f4f1084SDan Carpenter return result; 18112dc6b115SAlexander Aring } 18122dc6b115SAlexander Aring 18132dc6b115SAlexander Aring sock_set_mark(sock->sk, dlm_config.ci_mark); 18142dc6b115SAlexander Aring dlm_proto_ops->listen_sockopts(sock); 18152dc6b115SAlexander Aring 18162dc6b115SAlexander Aring result = dlm_proto_ops->listen_bind(sock); 18172dc6b115SAlexander Aring if (result < 0) 18182dc6b115SAlexander Aring goto out; 18192dc6b115SAlexander Aring 18202dc6b115SAlexander Aring save_listen_callbacks(sock); 18212dc6b115SAlexander Aring add_listen_sock(sock, &listen_con); 18222dc6b115SAlexander Aring 18232dc6b115SAlexander Aring result = sock->ops->listen(sock, 5); 18242dc6b115SAlexander Aring if (result < 0) { 18252dc6b115SAlexander Aring dlm_close_sock(&listen_con.sock); 182608ae0547SAlexander Aring return result; 18272dc6b115SAlexander Aring } 18282dc6b115SAlexander Aring 18292dc6b115SAlexander Aring return 0; 18302dc6b115SAlexander Aring 18312dc6b115SAlexander Aring out: 18322dc6b115SAlexander Aring sock_release(sock); 18332dc6b115SAlexander Aring return result; 18342dc6b115SAlexander Aring } 18352dc6b115SAlexander Aring 18368728a455SAlexander Aring static int dlm_tcp_bind(struct socket *sock) 18378728a455SAlexander Aring { 18388728a455SAlexander Aring struct sockaddr_storage src_addr; 18398728a455SAlexander Aring int result, addr_len; 18408728a455SAlexander Aring 18418728a455SAlexander Aring /* Bind to our cluster-known address connecting to avoid 18428728a455SAlexander Aring * routing problems. 18438728a455SAlexander Aring */ 18448728a455SAlexander Aring memcpy(&src_addr, dlm_local_addr[0], sizeof(src_addr)); 18458728a455SAlexander Aring make_sockaddr(&src_addr, 0, &addr_len); 18468728a455SAlexander Aring 18478728a455SAlexander Aring result = sock->ops->bind(sock, (struct sockaddr *)&src_addr, 18488728a455SAlexander Aring addr_len); 18498728a455SAlexander Aring if (result < 0) { 18508728a455SAlexander Aring /* This *may* not indicate a critical error */ 18518728a455SAlexander Aring log_print("could not bind for connect: %d", result); 18528728a455SAlexander Aring } 18538728a455SAlexander Aring 18548728a455SAlexander Aring return 0; 18558728a455SAlexander Aring } 18568728a455SAlexander Aring 18578728a455SAlexander Aring static int dlm_tcp_connect(struct connection *con, struct socket *sock, 18588728a455SAlexander Aring struct sockaddr *addr, int addr_len) 18598728a455SAlexander Aring { 18608728a455SAlexander Aring int ret; 18618728a455SAlexander Aring 18628728a455SAlexander Aring ret = sock->ops->connect(sock, addr, addr_len, O_NONBLOCK); 18638728a455SAlexander Aring switch (ret) { 18648728a455SAlexander Aring case -EINPROGRESS: 18658728a455SAlexander Aring fallthrough; 18668728a455SAlexander Aring case 0: 18678728a455SAlexander Aring return 0; 18688728a455SAlexander Aring } 18698728a455SAlexander Aring 18708728a455SAlexander Aring return ret; 18718728a455SAlexander Aring } 18728728a455SAlexander Aring 18732dc6b115SAlexander Aring static int dlm_tcp_listen_validate(void) 18742dc6b115SAlexander Aring { 18752dc6b115SAlexander Aring /* We don't support multi-homed hosts */ 18762dc6b115SAlexander Aring if (dlm_local_count > 1) { 18772dc6b115SAlexander Aring log_print("TCP protocol can't handle multi-homed hosts, try SCTP"); 18782dc6b115SAlexander Aring return -EINVAL; 18792dc6b115SAlexander Aring } 18802dc6b115SAlexander Aring 18812dc6b115SAlexander Aring return 0; 18822dc6b115SAlexander Aring } 18832dc6b115SAlexander Aring 18842dc6b115SAlexander Aring static void dlm_tcp_sockopts(struct socket *sock) 18852dc6b115SAlexander Aring { 18862dc6b115SAlexander Aring /* Turn off Nagle's algorithm */ 18872dc6b115SAlexander Aring tcp_sock_set_nodelay(sock->sk); 18882dc6b115SAlexander Aring } 18892dc6b115SAlexander Aring 18902dc6b115SAlexander Aring static void dlm_tcp_listen_sockopts(struct socket *sock) 18912dc6b115SAlexander Aring { 18922dc6b115SAlexander Aring dlm_tcp_sockopts(sock); 18932dc6b115SAlexander Aring sock_set_reuseaddr(sock->sk); 18942dc6b115SAlexander Aring } 18952dc6b115SAlexander Aring 18962dc6b115SAlexander Aring static int dlm_tcp_listen_bind(struct socket *sock) 18972dc6b115SAlexander Aring { 18982dc6b115SAlexander Aring int addr_len; 18992dc6b115SAlexander Aring 19002dc6b115SAlexander Aring /* Bind to our port */ 19012dc6b115SAlexander Aring make_sockaddr(dlm_local_addr[0], dlm_config.ci_tcp_port, &addr_len); 19022dc6b115SAlexander Aring return sock->ops->bind(sock, (struct sockaddr *)dlm_local_addr[0], 19032dc6b115SAlexander Aring addr_len); 19042dc6b115SAlexander Aring } 19052dc6b115SAlexander Aring 1906a66c008cSAlexander Aring static const struct dlm_proto_ops dlm_tcp_ops = { 19072dc6b115SAlexander Aring .name = "TCP", 19082dc6b115SAlexander Aring .proto = IPPROTO_TCP, 19098728a455SAlexander Aring .connect = dlm_tcp_connect, 19108728a455SAlexander Aring .sockopts = dlm_tcp_sockopts, 19118728a455SAlexander Aring .bind = dlm_tcp_bind, 19122dc6b115SAlexander Aring .listen_validate = dlm_tcp_listen_validate, 19132dc6b115SAlexander Aring .listen_sockopts = dlm_tcp_listen_sockopts, 19142dc6b115SAlexander Aring .listen_bind = dlm_tcp_listen_bind, 1915a66c008cSAlexander Aring .shutdown_action = dlm_tcp_shutdown, 1916a66c008cSAlexander Aring .eof_condition = tcp_eof_condition, 1917a66c008cSAlexander Aring }; 1918a66c008cSAlexander Aring 19198728a455SAlexander Aring static int dlm_sctp_bind(struct socket *sock) 19208728a455SAlexander Aring { 19218728a455SAlexander Aring return sctp_bind_addrs(sock, 0); 19228728a455SAlexander Aring } 19238728a455SAlexander Aring 19248728a455SAlexander Aring static int dlm_sctp_connect(struct connection *con, struct socket *sock, 19258728a455SAlexander Aring struct sockaddr *addr, int addr_len) 19268728a455SAlexander Aring { 19278728a455SAlexander Aring int ret; 19288728a455SAlexander Aring 19298728a455SAlexander Aring /* 19308728a455SAlexander Aring * Make sock->ops->connect() function return in specified time, 19318728a455SAlexander Aring * since O_NONBLOCK argument in connect() function does not work here, 19328728a455SAlexander Aring * then, we should restore the default value of this attribute. 19338728a455SAlexander Aring */ 19348728a455SAlexander Aring sock_set_sndtimeo(sock->sk, 5); 19358728a455SAlexander Aring ret = sock->ops->connect(sock, addr, addr_len, 0); 19368728a455SAlexander Aring sock_set_sndtimeo(sock->sk, 0); 19378728a455SAlexander Aring if (ret < 0) 19388728a455SAlexander Aring return ret; 19398728a455SAlexander Aring 19408728a455SAlexander Aring if (!test_and_set_bit(CF_CONNECTED, &con->flags)) 1941dfc020f3SAlexander Aring log_print("connected to node %d", con->nodeid); 19428728a455SAlexander Aring 19438728a455SAlexander Aring return 0; 19448728a455SAlexander Aring } 19458728a455SAlexander Aring 194690d21fc0SAlexander Aring static int dlm_sctp_listen_validate(void) 194790d21fc0SAlexander Aring { 194890d21fc0SAlexander Aring if (!IS_ENABLED(CONFIG_IP_SCTP)) { 194990d21fc0SAlexander Aring log_print("SCTP is not enabled by this kernel"); 195090d21fc0SAlexander Aring return -EOPNOTSUPP; 195190d21fc0SAlexander Aring } 195290d21fc0SAlexander Aring 195390d21fc0SAlexander Aring request_module("sctp"); 195490d21fc0SAlexander Aring return 0; 195590d21fc0SAlexander Aring } 195690d21fc0SAlexander Aring 19572dc6b115SAlexander Aring static int dlm_sctp_bind_listen(struct socket *sock) 19582dc6b115SAlexander Aring { 19592dc6b115SAlexander Aring return sctp_bind_addrs(sock, dlm_config.ci_tcp_port); 19602dc6b115SAlexander Aring } 19612dc6b115SAlexander Aring 19622dc6b115SAlexander Aring static void dlm_sctp_sockopts(struct socket *sock) 19632dc6b115SAlexander Aring { 19642dc6b115SAlexander Aring /* Turn off Nagle's algorithm */ 19652dc6b115SAlexander Aring sctp_sock_set_nodelay(sock->sk); 19662dc6b115SAlexander Aring sock_set_rcvbuf(sock->sk, NEEDED_RMEM); 19672dc6b115SAlexander Aring } 19682dc6b115SAlexander Aring 1969a66c008cSAlexander Aring static const struct dlm_proto_ops dlm_sctp_ops = { 19702dc6b115SAlexander Aring .name = "SCTP", 19712dc6b115SAlexander Aring .proto = IPPROTO_SCTP, 19728728a455SAlexander Aring .try_new_addr = true, 19738728a455SAlexander Aring .connect = dlm_sctp_connect, 19748728a455SAlexander Aring .sockopts = dlm_sctp_sockopts, 19758728a455SAlexander Aring .bind = dlm_sctp_bind, 197690d21fc0SAlexander Aring .listen_validate = dlm_sctp_listen_validate, 19772dc6b115SAlexander Aring .listen_sockopts = dlm_sctp_sockopts, 19782dc6b115SAlexander Aring .listen_bind = dlm_sctp_bind_listen, 1979a66c008cSAlexander Aring }; 1980a66c008cSAlexander Aring 19816ed7257bSPatrick Caulfield int dlm_lowcomms_start(void) 19826ed7257bSPatrick Caulfield { 19836ed7257bSPatrick Caulfield int error = -EINVAL; 19846ed7257bSPatrick Caulfield 19856ed7257bSPatrick Caulfield init_local(); 19866ed7257bSPatrick Caulfield if (!dlm_local_count) { 1987617e82e1SDavid Teigland error = -ENOTCONN; 19886ed7257bSPatrick Caulfield log_print("no local IP address has been set"); 1989513ef596SDavid Teigland goto fail; 19906ed7257bSPatrick Caulfield } 19916ed7257bSPatrick Caulfield 1992513ef596SDavid Teigland error = work_start(); 1993513ef596SDavid Teigland if (error) 1994fcef0e6cSAlexander Aring goto fail_local; 1995513ef596SDavid Teigland 19966ed7257bSPatrick Caulfield /* Start listening */ 1997ac7d5d03SAlexander Aring switch (dlm_config.ci_protocol) { 1998ac7d5d03SAlexander Aring case DLM_PROTO_TCP: 1999a66c008cSAlexander Aring dlm_proto_ops = &dlm_tcp_ops; 2000ac7d5d03SAlexander Aring break; 2001ac7d5d03SAlexander Aring case DLM_PROTO_SCTP: 2002a66c008cSAlexander Aring dlm_proto_ops = &dlm_sctp_ops; 2003ac7d5d03SAlexander Aring break; 2004ac7d5d03SAlexander Aring default: 2005ac7d5d03SAlexander Aring log_print("Invalid protocol identifier %d set", 2006ac7d5d03SAlexander Aring dlm_config.ci_protocol); 2007ac7d5d03SAlexander Aring error = -EINVAL; 20082dc6b115SAlexander Aring goto fail_proto_ops; 2009ac7d5d03SAlexander Aring } 20102dc6b115SAlexander Aring 20112dc6b115SAlexander Aring error = dlm_listen_for_all(); 20126ed7257bSPatrick Caulfield if (error) 20132dc6b115SAlexander Aring goto fail_listen; 20146ed7257bSPatrick Caulfield 20156ed7257bSPatrick Caulfield return 0; 20166ed7257bSPatrick Caulfield 20172dc6b115SAlexander Aring fail_listen: 20182dc6b115SAlexander Aring dlm_proto_ops = NULL; 20192dc6b115SAlexander Aring fail_proto_ops: 2020fcef0e6cSAlexander Aring work_stop(); 2021fcef0e6cSAlexander Aring fail_local: 2022fcef0e6cSAlexander Aring deinit_local(); 2023513ef596SDavid Teigland fail: 20246ed7257bSPatrick Caulfield return error; 20256ed7257bSPatrick Caulfield } 202636b71a8bSDavid Teigland 20278b0188b0SAlexander Aring void dlm_lowcomms_init(void) 20288b0188b0SAlexander Aring { 20298b0188b0SAlexander Aring int i; 20308b0188b0SAlexander Aring 20318b0188b0SAlexander Aring for (i = 0; i < CONN_HASH_SIZE; i++) 20328b0188b0SAlexander Aring INIT_HLIST_HEAD(&connection_hash[i]); 20338b0188b0SAlexander Aring 20348b0188b0SAlexander Aring INIT_WORK(&listen_con.rwork, process_listen_recv_socket); 20358b0188b0SAlexander Aring } 20368b0188b0SAlexander Aring 203736b71a8bSDavid Teigland void dlm_lowcomms_exit(void) 203836b71a8bSDavid Teigland { 203936b71a8bSDavid Teigland struct dlm_node_addr *na, *safe; 204036b71a8bSDavid Teigland 204136b71a8bSDavid Teigland spin_lock(&dlm_node_addrs_spin); 204236b71a8bSDavid Teigland list_for_each_entry_safe(na, safe, &dlm_node_addrs, list) { 204336b71a8bSDavid Teigland list_del(&na->list); 204436b71a8bSDavid Teigland while (na->addr_count--) 204536b71a8bSDavid Teigland kfree(na->addr[na->addr_count]); 204636b71a8bSDavid Teigland kfree(na); 204736b71a8bSDavid Teigland } 204836b71a8bSDavid Teigland spin_unlock(&dlm_node_addrs_spin); 204936b71a8bSDavid Teigland } 2050