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 68f92c8dd7SBob Peterson 696ed7257bSPatrick Caulfield struct connection { 706ed7257bSPatrick Caulfield struct socket *sock; /* NULL if not connected */ 716ed7257bSPatrick Caulfield uint32_t nodeid; /* So we know who we are in the list */ 726ed7257bSPatrick Caulfield struct mutex sock_mutex; 736ed7257bSPatrick Caulfield unsigned long flags; 746ed7257bSPatrick Caulfield #define CF_READ_PENDING 1 758a4abb08Stsutomu.owa@toshiba.co.jp #define CF_WRITE_PENDING 2 766ed7257bSPatrick Caulfield #define CF_INIT_PENDING 4 776ed7257bSPatrick Caulfield #define CF_IS_OTHERCON 5 78063c4c99SLars Marowsky-Bree #define CF_CLOSE 6 79b36930ddSDavid Miller #define CF_APP_LIMITED 7 80b2a66629Stsutomu.owa@toshiba.co.jp #define CF_CLOSING 8 81*4f567acbSAlexander Aring #define CF_CONNECTED 9 82*4f567acbSAlexander Aring #define CF_RECONNECT 10 83*4f567acbSAlexander Aring #define CF_DELAY_CONNECT 11 846ed7257bSPatrick Caulfield struct list_head writequeue; /* List of outgoing writequeue_entries */ 856ed7257bSPatrick Caulfield spinlock_t writequeue_lock; 866ed7257bSPatrick Caulfield int retries; 876ed7257bSPatrick Caulfield #define MAX_CONNECT_RETRIES 3 885e9ccc37SChristine Caulfield struct hlist_node list; 896ed7257bSPatrick Caulfield struct connection *othercon; 90ba868d9dSAlexander Aring struct connection *sendcon; 916ed7257bSPatrick Caulfield struct work_struct rwork; /* Receive workqueue */ 926ed7257bSPatrick Caulfield struct work_struct swork; /* Send workqueue */ 934798cbbfSAlexander Aring unsigned char *rx_buf; 944798cbbfSAlexander Aring int rx_buflen; 954798cbbfSAlexander Aring int rx_leftover; 96a47666ebSAlexander Aring struct rcu_head rcu; 976ed7257bSPatrick Caulfield }; 986ed7257bSPatrick Caulfield #define sock2con(x) ((struct connection *)(x)->sk_user_data) 996ed7257bSPatrick Caulfield 100d11ccd45SAlexander Aring struct listen_connection { 101d11ccd45SAlexander Aring struct socket *sock; 102d11ccd45SAlexander Aring struct work_struct rwork; 103d11ccd45SAlexander Aring }; 104d11ccd45SAlexander Aring 105f0747ebfSAlexander Aring #define DLM_WQ_REMAIN_BYTES(e) (PAGE_SIZE - e->end) 106f0747ebfSAlexander Aring #define DLM_WQ_LENGTH_BYTES(e) (e->end - e->offset) 107f0747ebfSAlexander Aring 1086ed7257bSPatrick Caulfield /* An entry waiting to be sent */ 1096ed7257bSPatrick Caulfield struct writequeue_entry { 1106ed7257bSPatrick Caulfield struct list_head list; 1116ed7257bSPatrick Caulfield struct page *page; 1126ed7257bSPatrick Caulfield int offset; 1136ed7257bSPatrick Caulfield int len; 1146ed7257bSPatrick Caulfield int end; 1156ed7257bSPatrick Caulfield int users; 116706474fbSAlexander Aring bool dirty; 1176ed7257bSPatrick Caulfield struct connection *con; 1188f2dc78dSAlexander Aring struct list_head msgs; 1198f2dc78dSAlexander Aring struct kref ref; 1208f2dc78dSAlexander Aring }; 1218f2dc78dSAlexander Aring 1228f2dc78dSAlexander Aring struct dlm_msg { 1238f2dc78dSAlexander Aring struct writequeue_entry *entry; 1242874d1a6SAlexander Aring struct dlm_msg *orig_msg; 1252874d1a6SAlexander Aring bool retransmit; 1268f2dc78dSAlexander Aring void *ppc; 1278f2dc78dSAlexander Aring int len; 1288f2dc78dSAlexander Aring int idx; /* new()/commit() idx exchange */ 1298f2dc78dSAlexander Aring 1308f2dc78dSAlexander Aring struct list_head list; 1318f2dc78dSAlexander Aring struct kref ref; 1326ed7257bSPatrick Caulfield }; 1336ed7257bSPatrick Caulfield 13436b71a8bSDavid Teigland struct dlm_node_addr { 13536b71a8bSDavid Teigland struct list_head list; 13636b71a8bSDavid Teigland int nodeid; 137e125fbebSAlexander Aring int mark; 13836b71a8bSDavid Teigland int addr_count; 13998e1b60eSMike Christie int curr_addr_index; 14036b71a8bSDavid Teigland struct sockaddr_storage *addr[DLM_MAX_ADDR_COUNT]; 14136b71a8bSDavid Teigland }; 14236b71a8bSDavid Teigland 143a66c008cSAlexander Aring struct dlm_proto_ops { 1448728a455SAlexander Aring bool try_new_addr; 1452dc6b115SAlexander Aring const char *name; 1462dc6b115SAlexander Aring int proto; 1472dc6b115SAlexander Aring 1488728a455SAlexander Aring int (*connect)(struct connection *con, struct socket *sock, 1498728a455SAlexander Aring struct sockaddr *addr, int addr_len); 1508728a455SAlexander Aring void (*sockopts)(struct socket *sock); 1518728a455SAlexander Aring int (*bind)(struct socket *sock); 1522dc6b115SAlexander Aring int (*listen_validate)(void); 1532dc6b115SAlexander Aring void (*listen_sockopts)(struct socket *sock); 1542dc6b115SAlexander Aring int (*listen_bind)(struct socket *sock); 155a66c008cSAlexander Aring }; 156a66c008cSAlexander Aring 157cc661fc9SBob Peterson static struct listen_sock_callbacks { 158cc661fc9SBob Peterson void (*sk_error_report)(struct sock *); 159cc661fc9SBob Peterson void (*sk_data_ready)(struct sock *); 160cc661fc9SBob Peterson void (*sk_state_change)(struct sock *); 161cc661fc9SBob Peterson void (*sk_write_space)(struct sock *); 162cc661fc9SBob Peterson } listen_sock; 163cc661fc9SBob Peterson 16436b71a8bSDavid Teigland static LIST_HEAD(dlm_node_addrs); 16536b71a8bSDavid Teigland static DEFINE_SPINLOCK(dlm_node_addrs_spin); 16636b71a8bSDavid Teigland 167d11ccd45SAlexander Aring static struct listen_connection listen_con; 1686ed7257bSPatrick Caulfield static struct sockaddr_storage *dlm_local_addr[DLM_MAX_ADDR_COUNT]; 1696ed7257bSPatrick Caulfield static int dlm_local_count; 1706ed7257bSPatrick Caulfield 1716ed7257bSPatrick Caulfield /* Work queues */ 1726ed7257bSPatrick Caulfield static struct workqueue_struct *recv_workqueue; 1736ed7257bSPatrick Caulfield static struct workqueue_struct *send_workqueue; 1746ed7257bSPatrick Caulfield 1755e9ccc37SChristine Caulfield static struct hlist_head connection_hash[CONN_HASH_SIZE]; 176a47666ebSAlexander Aring static DEFINE_SPINLOCK(connections_lock); 177a47666ebSAlexander Aring DEFINE_STATIC_SRCU(connections_srcu); 1786ed7257bSPatrick Caulfield 179a66c008cSAlexander Aring static const struct dlm_proto_ops *dlm_proto_ops; 180a66c008cSAlexander Aring 1816ed7257bSPatrick Caulfield static void process_recv_sockets(struct work_struct *work); 1826ed7257bSPatrick Caulfield static void process_send_sockets(struct work_struct *work); 1836ed7257bSPatrick Caulfield 1841037c2a9SAlexander Aring bool dlm_lowcomms_is_running(void) 1851037c2a9SAlexander Aring { 1861037c2a9SAlexander Aring return !!listen_con.sock; 1871037c2a9SAlexander Aring } 1881037c2a9SAlexander Aring 1893af2326cSAlexander Aring static void writequeue_entry_ctor(void *data) 1903af2326cSAlexander Aring { 1913af2326cSAlexander Aring struct writequeue_entry *entry = data; 1923af2326cSAlexander Aring 1933af2326cSAlexander Aring INIT_LIST_HEAD(&entry->msgs); 1943af2326cSAlexander Aring } 1953af2326cSAlexander Aring 1963af2326cSAlexander Aring struct kmem_cache *dlm_lowcomms_writequeue_cache_create(void) 1973af2326cSAlexander Aring { 1983af2326cSAlexander Aring return kmem_cache_create("dlm_writequeue", sizeof(struct writequeue_entry), 1993af2326cSAlexander Aring 0, 0, writequeue_entry_ctor); 2003af2326cSAlexander Aring } 2013af2326cSAlexander Aring 202e4dc81edSAlexander Aring struct kmem_cache *dlm_lowcomms_msg_cache_create(void) 203e4dc81edSAlexander Aring { 204e4dc81edSAlexander Aring return kmem_cache_create("dlm_msg", sizeof(struct dlm_msg), 0, 0, NULL); 205e4dc81edSAlexander Aring } 206e4dc81edSAlexander Aring 20766d5955aSAlexander Aring /* need to held writequeue_lock */ 20866d5955aSAlexander Aring static struct writequeue_entry *con_next_wq(struct connection *con) 20966d5955aSAlexander Aring { 21066d5955aSAlexander Aring struct writequeue_entry *e; 21166d5955aSAlexander Aring 212dd070a56SAlexander Aring e = list_first_entry_or_null(&con->writequeue, struct writequeue_entry, 21366d5955aSAlexander Aring list); 214bcbfea41SAlexander Aring /* if len is zero nothing is to send, if there are users filling 215bcbfea41SAlexander Aring * buffers we wait until the users are done so we can send more. 216bcbfea41SAlexander Aring */ 217dd070a56SAlexander Aring if (!e || e->users || e->len == 0) 21866d5955aSAlexander Aring return NULL; 21966d5955aSAlexander Aring 22066d5955aSAlexander Aring return e; 22166d5955aSAlexander Aring } 22266d5955aSAlexander Aring 223b38bc9c2SAlexander Aring static struct connection *__find_con(int nodeid, int r) 2245e9ccc37SChristine Caulfield { 2255e9ccc37SChristine Caulfield struct connection *con; 2265e9ccc37SChristine Caulfield 227a47666ebSAlexander Aring hlist_for_each_entry_rcu(con, &connection_hash[r], list) { 228b38bc9c2SAlexander Aring if (con->nodeid == nodeid) 2295e9ccc37SChristine Caulfield return con; 2305e9ccc37SChristine Caulfield } 231a47666ebSAlexander Aring 2325e9ccc37SChristine Caulfield return NULL; 2335e9ccc37SChristine Caulfield } 2345e9ccc37SChristine Caulfield 2356cde210aSAlexander Aring static int dlm_con_init(struct connection *con, int nodeid) 2366ed7257bSPatrick Caulfield { 2374798cbbfSAlexander Aring con->rx_buflen = dlm_config.ci_buffer_size; 2384798cbbfSAlexander Aring con->rx_buf = kmalloc(con->rx_buflen, GFP_NOFS); 2396cde210aSAlexander Aring if (!con->rx_buf) 2406cde210aSAlexander Aring return -ENOMEM; 2414798cbbfSAlexander Aring 2426ed7257bSPatrick Caulfield con->nodeid = nodeid; 2436ed7257bSPatrick Caulfield mutex_init(&con->sock_mutex); 2446ed7257bSPatrick Caulfield INIT_LIST_HEAD(&con->writequeue); 2456ed7257bSPatrick Caulfield spin_lock_init(&con->writequeue_lock); 2466ed7257bSPatrick Caulfield INIT_WORK(&con->swork, process_send_sockets); 2476ed7257bSPatrick Caulfield INIT_WORK(&con->rwork, process_recv_sockets); 2486ed7257bSPatrick Caulfield 2496cde210aSAlexander Aring return 0; 2506cde210aSAlexander Aring } 2516cde210aSAlexander Aring 2526cde210aSAlexander Aring /* 2536cde210aSAlexander Aring * If 'allocation' is zero then we don't attempt to create a new 2546cde210aSAlexander Aring * connection structure for this node. 2556cde210aSAlexander Aring */ 2566cde210aSAlexander Aring static struct connection *nodeid2con(int nodeid, gfp_t alloc) 2576cde210aSAlexander Aring { 2586cde210aSAlexander Aring struct connection *con, *tmp; 2596cde210aSAlexander Aring int r, ret; 2606cde210aSAlexander Aring 261b38bc9c2SAlexander Aring r = nodeid_hash(nodeid); 262b38bc9c2SAlexander Aring con = __find_con(nodeid, r); 2636cde210aSAlexander Aring if (con || !alloc) 2646cde210aSAlexander Aring return con; 2656cde210aSAlexander Aring 2666cde210aSAlexander Aring con = kzalloc(sizeof(*con), alloc); 2676cde210aSAlexander Aring if (!con) 2686cde210aSAlexander Aring return NULL; 2696cde210aSAlexander Aring 2706cde210aSAlexander Aring ret = dlm_con_init(con, nodeid); 2716cde210aSAlexander Aring if (ret) { 2726cde210aSAlexander Aring kfree(con); 2736cde210aSAlexander Aring return NULL; 2746cde210aSAlexander Aring } 2756cde210aSAlexander Aring 276a47666ebSAlexander Aring spin_lock(&connections_lock); 2774f2b30fdSAlexander Aring /* Because multiple workqueues/threads calls this function it can 2784f2b30fdSAlexander Aring * race on multiple cpu's. Instead of locking hot path __find_con() 2794f2b30fdSAlexander Aring * we just check in rare cases of recently added nodes again 2804f2b30fdSAlexander Aring * under protection of connections_lock. If this is the case we 2814f2b30fdSAlexander Aring * abort our connection creation and return the existing connection. 2824f2b30fdSAlexander Aring */ 283b38bc9c2SAlexander Aring tmp = __find_con(nodeid, r); 2844f2b30fdSAlexander Aring if (tmp) { 2854f2b30fdSAlexander Aring spin_unlock(&connections_lock); 2864f2b30fdSAlexander Aring kfree(con->rx_buf); 2874f2b30fdSAlexander Aring kfree(con); 2884f2b30fdSAlexander Aring return tmp; 2894f2b30fdSAlexander Aring } 2904f2b30fdSAlexander Aring 291a47666ebSAlexander Aring hlist_add_head_rcu(&con->list, &connection_hash[r]); 292a47666ebSAlexander Aring spin_unlock(&connections_lock); 293a47666ebSAlexander Aring 2946ed7257bSPatrick Caulfield return con; 2956ed7257bSPatrick Caulfield } 2966ed7257bSPatrick Caulfield 2975e9ccc37SChristine Caulfield /* Loop round all connections */ 2985e9ccc37SChristine Caulfield static void foreach_conn(void (*conn_func)(struct connection *c)) 2995e9ccc37SChristine Caulfield { 300b38bc9c2SAlexander Aring int i; 3015e9ccc37SChristine Caulfield struct connection *con; 3025e9ccc37SChristine Caulfield 3035e9ccc37SChristine Caulfield for (i = 0; i < CONN_HASH_SIZE; i++) { 304a47666ebSAlexander Aring hlist_for_each_entry_rcu(con, &connection_hash[i], list) 3055e9ccc37SChristine Caulfield conn_func(con); 3065e9ccc37SChristine Caulfield } 3076ed7257bSPatrick Caulfield } 3086ed7257bSPatrick Caulfield 30936b71a8bSDavid Teigland static struct dlm_node_addr *find_node_addr(int nodeid) 3106ed7257bSPatrick Caulfield { 31136b71a8bSDavid Teigland struct dlm_node_addr *na; 31236b71a8bSDavid Teigland 31336b71a8bSDavid Teigland list_for_each_entry(na, &dlm_node_addrs, list) { 31436b71a8bSDavid Teigland if (na->nodeid == nodeid) 31536b71a8bSDavid Teigland return na; 31636b71a8bSDavid Teigland } 31736b71a8bSDavid Teigland return NULL; 31836b71a8bSDavid Teigland } 31936b71a8bSDavid Teigland 32040c6b83eSAlexander Aring static int addr_compare(const struct sockaddr_storage *x, 32140c6b83eSAlexander Aring const struct sockaddr_storage *y) 32236b71a8bSDavid Teigland { 32336b71a8bSDavid Teigland switch (x->ss_family) { 32436b71a8bSDavid Teigland case AF_INET: { 32536b71a8bSDavid Teigland struct sockaddr_in *sinx = (struct sockaddr_in *)x; 32636b71a8bSDavid Teigland struct sockaddr_in *siny = (struct sockaddr_in *)y; 32736b71a8bSDavid Teigland if (sinx->sin_addr.s_addr != siny->sin_addr.s_addr) 32836b71a8bSDavid Teigland return 0; 32936b71a8bSDavid Teigland if (sinx->sin_port != siny->sin_port) 33036b71a8bSDavid Teigland return 0; 33136b71a8bSDavid Teigland break; 33236b71a8bSDavid Teigland } 33336b71a8bSDavid Teigland case AF_INET6: { 33436b71a8bSDavid Teigland struct sockaddr_in6 *sinx = (struct sockaddr_in6 *)x; 33536b71a8bSDavid Teigland struct sockaddr_in6 *siny = (struct sockaddr_in6 *)y; 33636b71a8bSDavid Teigland if (!ipv6_addr_equal(&sinx->sin6_addr, &siny->sin6_addr)) 33736b71a8bSDavid Teigland return 0; 33836b71a8bSDavid Teigland if (sinx->sin6_port != siny->sin6_port) 33936b71a8bSDavid Teigland return 0; 34036b71a8bSDavid Teigland break; 34136b71a8bSDavid Teigland } 34236b71a8bSDavid Teigland default: 34336b71a8bSDavid Teigland return 0; 34436b71a8bSDavid Teigland } 34536b71a8bSDavid Teigland return 1; 34636b71a8bSDavid Teigland } 34736b71a8bSDavid Teigland 34836b71a8bSDavid Teigland static int nodeid_to_addr(int nodeid, struct sockaddr_storage *sas_out, 349e125fbebSAlexander Aring struct sockaddr *sa_out, bool try_new_addr, 350e125fbebSAlexander Aring unsigned int *mark) 35136b71a8bSDavid Teigland { 35236b71a8bSDavid Teigland struct sockaddr_storage sas; 35336b71a8bSDavid Teigland struct dlm_node_addr *na; 3546ed7257bSPatrick Caulfield 3556ed7257bSPatrick Caulfield if (!dlm_local_count) 3566ed7257bSPatrick Caulfield return -1; 3576ed7257bSPatrick Caulfield 35836b71a8bSDavid Teigland spin_lock(&dlm_node_addrs_spin); 35936b71a8bSDavid Teigland na = find_node_addr(nodeid); 36098e1b60eSMike Christie if (na && na->addr_count) { 361ee44b4bcSMarcelo Ricardo Leitner memcpy(&sas, na->addr[na->curr_addr_index], 362ee44b4bcSMarcelo Ricardo Leitner sizeof(struct sockaddr_storage)); 363ee44b4bcSMarcelo Ricardo Leitner 36498e1b60eSMike Christie if (try_new_addr) { 36598e1b60eSMike Christie na->curr_addr_index++; 36698e1b60eSMike Christie if (na->curr_addr_index == na->addr_count) 36798e1b60eSMike Christie na->curr_addr_index = 0; 36898e1b60eSMike Christie } 36998e1b60eSMike Christie } 37036b71a8bSDavid Teigland spin_unlock(&dlm_node_addrs_spin); 37136b71a8bSDavid Teigland 37236b71a8bSDavid Teigland if (!na) 37336b71a8bSDavid Teigland return -EEXIST; 37436b71a8bSDavid Teigland 37536b71a8bSDavid Teigland if (!na->addr_count) 37636b71a8bSDavid Teigland return -ENOENT; 37736b71a8bSDavid Teigland 378e125fbebSAlexander Aring *mark = na->mark; 379e125fbebSAlexander Aring 38036b71a8bSDavid Teigland if (sas_out) 38136b71a8bSDavid Teigland memcpy(sas_out, &sas, sizeof(struct sockaddr_storage)); 38236b71a8bSDavid Teigland 38336b71a8bSDavid Teigland if (!sa_out) 38436b71a8bSDavid Teigland return 0; 3856ed7257bSPatrick Caulfield 3866ed7257bSPatrick Caulfield if (dlm_local_addr[0]->ss_family == AF_INET) { 38736b71a8bSDavid Teigland struct sockaddr_in *in4 = (struct sockaddr_in *) &sas; 38836b71a8bSDavid Teigland struct sockaddr_in *ret4 = (struct sockaddr_in *) sa_out; 3896ed7257bSPatrick Caulfield ret4->sin_addr.s_addr = in4->sin_addr.s_addr; 3906ed7257bSPatrick Caulfield } else { 39136b71a8bSDavid Teigland struct sockaddr_in6 *in6 = (struct sockaddr_in6 *) &sas; 39236b71a8bSDavid Teigland struct sockaddr_in6 *ret6 = (struct sockaddr_in6 *) sa_out; 3934e3fd7a0SAlexey Dobriyan ret6->sin6_addr = in6->sin6_addr; 3946ed7257bSPatrick Caulfield } 3956ed7257bSPatrick Caulfield 3966ed7257bSPatrick Caulfield return 0; 3976ed7257bSPatrick Caulfield } 3986ed7257bSPatrick Caulfield 399e125fbebSAlexander Aring static int addr_to_nodeid(struct sockaddr_storage *addr, int *nodeid, 400e125fbebSAlexander Aring unsigned int *mark) 40136b71a8bSDavid Teigland { 40236b71a8bSDavid Teigland struct dlm_node_addr *na; 40336b71a8bSDavid Teigland int rv = -EEXIST; 40498e1b60eSMike Christie int addr_i; 40536b71a8bSDavid Teigland 40636b71a8bSDavid Teigland spin_lock(&dlm_node_addrs_spin); 40736b71a8bSDavid Teigland list_for_each_entry(na, &dlm_node_addrs, list) { 40836b71a8bSDavid Teigland if (!na->addr_count) 40936b71a8bSDavid Teigland continue; 41036b71a8bSDavid Teigland 41198e1b60eSMike Christie for (addr_i = 0; addr_i < na->addr_count; addr_i++) { 41298e1b60eSMike Christie if (addr_compare(na->addr[addr_i], addr)) { 41336b71a8bSDavid Teigland *nodeid = na->nodeid; 414e125fbebSAlexander Aring *mark = na->mark; 41536b71a8bSDavid Teigland rv = 0; 41698e1b60eSMike Christie goto unlock; 41736b71a8bSDavid Teigland } 41898e1b60eSMike Christie } 41998e1b60eSMike Christie } 42098e1b60eSMike Christie unlock: 42136b71a8bSDavid Teigland spin_unlock(&dlm_node_addrs_spin); 42236b71a8bSDavid Teigland return rv; 42336b71a8bSDavid Teigland } 42436b71a8bSDavid Teigland 4254f19d071SAlexander Aring /* caller need to held dlm_node_addrs_spin lock */ 4264f19d071SAlexander Aring static bool dlm_lowcomms_na_has_addr(const struct dlm_node_addr *na, 4274f19d071SAlexander Aring const struct sockaddr_storage *addr) 4284f19d071SAlexander Aring { 4294f19d071SAlexander Aring int i; 4304f19d071SAlexander Aring 4314f19d071SAlexander Aring for (i = 0; i < na->addr_count; i++) { 4324f19d071SAlexander Aring if (addr_compare(na->addr[i], addr)) 4334f19d071SAlexander Aring return true; 4344f19d071SAlexander Aring } 4354f19d071SAlexander Aring 4364f19d071SAlexander Aring return false; 4374f19d071SAlexander Aring } 4384f19d071SAlexander Aring 43936b71a8bSDavid Teigland int dlm_lowcomms_addr(int nodeid, struct sockaddr_storage *addr, int len) 44036b71a8bSDavid Teigland { 44136b71a8bSDavid Teigland struct sockaddr_storage *new_addr; 44236b71a8bSDavid Teigland struct dlm_node_addr *new_node, *na; 4434f19d071SAlexander Aring bool ret; 44436b71a8bSDavid Teigland 44536b71a8bSDavid Teigland new_node = kzalloc(sizeof(struct dlm_node_addr), GFP_NOFS); 44636b71a8bSDavid Teigland if (!new_node) 44736b71a8bSDavid Teigland return -ENOMEM; 44836b71a8bSDavid Teigland 44936b71a8bSDavid Teigland new_addr = kzalloc(sizeof(struct sockaddr_storage), GFP_NOFS); 45036b71a8bSDavid Teigland if (!new_addr) { 45136b71a8bSDavid Teigland kfree(new_node); 45236b71a8bSDavid Teigland return -ENOMEM; 45336b71a8bSDavid Teigland } 45436b71a8bSDavid Teigland 45536b71a8bSDavid Teigland memcpy(new_addr, addr, len); 45636b71a8bSDavid Teigland 45736b71a8bSDavid Teigland spin_lock(&dlm_node_addrs_spin); 45836b71a8bSDavid Teigland na = find_node_addr(nodeid); 45936b71a8bSDavid Teigland if (!na) { 46036b71a8bSDavid Teigland new_node->nodeid = nodeid; 46136b71a8bSDavid Teigland new_node->addr[0] = new_addr; 46236b71a8bSDavid Teigland new_node->addr_count = 1; 463e125fbebSAlexander Aring new_node->mark = dlm_config.ci_mark; 46436b71a8bSDavid Teigland list_add(&new_node->list, &dlm_node_addrs); 46536b71a8bSDavid Teigland spin_unlock(&dlm_node_addrs_spin); 46636b71a8bSDavid Teigland return 0; 46736b71a8bSDavid Teigland } 46836b71a8bSDavid Teigland 4694f19d071SAlexander Aring ret = dlm_lowcomms_na_has_addr(na, addr); 4704f19d071SAlexander Aring if (ret) { 4714f19d071SAlexander Aring spin_unlock(&dlm_node_addrs_spin); 4724f19d071SAlexander Aring kfree(new_addr); 4734f19d071SAlexander Aring kfree(new_node); 4744f19d071SAlexander Aring return -EEXIST; 4754f19d071SAlexander Aring } 4764f19d071SAlexander Aring 47736b71a8bSDavid Teigland if (na->addr_count >= DLM_MAX_ADDR_COUNT) { 47836b71a8bSDavid Teigland spin_unlock(&dlm_node_addrs_spin); 47936b71a8bSDavid Teigland kfree(new_addr); 48036b71a8bSDavid Teigland kfree(new_node); 48136b71a8bSDavid Teigland return -ENOSPC; 48236b71a8bSDavid Teigland } 48336b71a8bSDavid Teigland 48436b71a8bSDavid Teigland na->addr[na->addr_count++] = new_addr; 48536b71a8bSDavid Teigland spin_unlock(&dlm_node_addrs_spin); 48636b71a8bSDavid Teigland kfree(new_node); 48736b71a8bSDavid Teigland return 0; 48836b71a8bSDavid Teigland } 48936b71a8bSDavid Teigland 4906ed7257bSPatrick Caulfield /* Data available on socket or listen socket received a connect */ 491676d2369SDavid S. Miller static void lowcomms_data_ready(struct sock *sk) 4926ed7257bSPatrick Caulfield { 49393eaadebStsutomu.owa@toshiba.co.jp struct connection *con; 49493eaadebStsutomu.owa@toshiba.co.jp 49593eaadebStsutomu.owa@toshiba.co.jp con = sock2con(sk); 496afb853fbSPatrick Caulfield if (con && !test_and_set_bit(CF_READ_PENDING, &con->flags)) 4976ed7257bSPatrick Caulfield queue_work(recv_workqueue, &con->rwork); 4986ed7257bSPatrick Caulfield } 4996ed7257bSPatrick Caulfield 500d11ccd45SAlexander Aring static void lowcomms_listen_data_ready(struct sock *sk) 501d11ccd45SAlexander Aring { 502d11ccd45SAlexander Aring queue_work(recv_workqueue, &listen_con.rwork); 503d11ccd45SAlexander Aring } 504d11ccd45SAlexander Aring 5056ed7257bSPatrick Caulfield static void lowcomms_write_space(struct sock *sk) 5066ed7257bSPatrick Caulfield { 50793eaadebStsutomu.owa@toshiba.co.jp struct connection *con; 5086ed7257bSPatrick Caulfield 50993eaadebStsutomu.owa@toshiba.co.jp con = sock2con(sk); 510b36930ddSDavid Miller if (!con) 51192c44605SAlexander Aring return; 512b36930ddSDavid Miller 51319633c7eSAlexander Aring if (!test_and_set_bit(CF_CONNECTED, &con->flags)) { 514dfc020f3SAlexander Aring log_print("connected to node %d", con->nodeid); 51519633c7eSAlexander Aring queue_work(send_workqueue, &con->swork); 51692c44605SAlexander Aring return; 51719633c7eSAlexander Aring } 51819633c7eSAlexander Aring 519b36930ddSDavid Miller clear_bit(SOCK_NOSPACE, &con->sock->flags); 520b36930ddSDavid Miller 521b36930ddSDavid Miller if (test_and_clear_bit(CF_APP_LIMITED, &con->flags)) { 522b36930ddSDavid Miller con->sock->sk->sk_write_pending--; 5239cd3e072SEric Dumazet clear_bit(SOCKWQ_ASYNC_NOSPACE, &con->sock->flags); 524b36930ddSDavid Miller } 525b36930ddSDavid Miller 5266ed7257bSPatrick Caulfield queue_work(send_workqueue, &con->swork); 5276ed7257bSPatrick Caulfield } 5286ed7257bSPatrick Caulfield 5296ed7257bSPatrick Caulfield static inline void lowcomms_connect_sock(struct connection *con) 5306ed7257bSPatrick Caulfield { 531063c4c99SLars Marowsky-Bree if (test_bit(CF_CLOSE, &con->flags)) 532063c4c99SLars Marowsky-Bree return; 5336ed7257bSPatrick Caulfield queue_work(send_workqueue, &con->swork); 53461d9102bSBob Peterson cond_resched(); 5356ed7257bSPatrick Caulfield } 5366ed7257bSPatrick Caulfield 5376ed7257bSPatrick Caulfield static void lowcomms_state_change(struct sock *sk) 5386ed7257bSPatrick Caulfield { 539ee44b4bcSMarcelo Ricardo Leitner /* SCTP layer is not calling sk_data_ready when the connection 540ee44b4bcSMarcelo Ricardo Leitner * is done, so we catch the signal through here. Also, it 541ee44b4bcSMarcelo Ricardo Leitner * doesn't switch socket state when entering shutdown, so we 542ee44b4bcSMarcelo Ricardo Leitner * skip the write in that case. 543ee44b4bcSMarcelo Ricardo Leitner */ 544ee44b4bcSMarcelo Ricardo Leitner if (sk->sk_shutdown) { 545ee44b4bcSMarcelo Ricardo Leitner if (sk->sk_shutdown == RCV_SHUTDOWN) 546ee44b4bcSMarcelo Ricardo Leitner lowcomms_data_ready(sk); 547ee44b4bcSMarcelo Ricardo Leitner } else if (sk->sk_state == TCP_ESTABLISHED) { 5486ed7257bSPatrick Caulfield lowcomms_write_space(sk); 5496ed7257bSPatrick Caulfield } 550ee44b4bcSMarcelo Ricardo Leitner } 5516ed7257bSPatrick Caulfield 552391fbdc5SChristine Caulfield int dlm_lowcomms_connect_node(int nodeid) 553391fbdc5SChristine Caulfield { 554391fbdc5SChristine Caulfield struct connection *con; 555b38bc9c2SAlexander Aring int idx; 556391fbdc5SChristine Caulfield 557391fbdc5SChristine Caulfield if (nodeid == dlm_our_nodeid()) 558391fbdc5SChristine Caulfield return 0; 559391fbdc5SChristine Caulfield 560b38bc9c2SAlexander Aring idx = srcu_read_lock(&connections_srcu); 561391fbdc5SChristine Caulfield con = nodeid2con(nodeid, GFP_NOFS); 562b38bc9c2SAlexander Aring if (!con) { 563b38bc9c2SAlexander Aring srcu_read_unlock(&connections_srcu, idx); 564391fbdc5SChristine Caulfield return -ENOMEM; 565b38bc9c2SAlexander Aring } 566b38bc9c2SAlexander Aring 567391fbdc5SChristine Caulfield lowcomms_connect_sock(con); 568b38bc9c2SAlexander Aring srcu_read_unlock(&connections_srcu, idx); 569b38bc9c2SAlexander Aring 570391fbdc5SChristine Caulfield return 0; 571391fbdc5SChristine Caulfield } 572391fbdc5SChristine Caulfield 573e125fbebSAlexander Aring int dlm_lowcomms_nodes_set_mark(int nodeid, unsigned int mark) 574e125fbebSAlexander Aring { 575e125fbebSAlexander Aring struct dlm_node_addr *na; 576e125fbebSAlexander Aring 577e125fbebSAlexander Aring spin_lock(&dlm_node_addrs_spin); 578e125fbebSAlexander Aring na = find_node_addr(nodeid); 579e125fbebSAlexander Aring if (!na) { 580e125fbebSAlexander Aring spin_unlock(&dlm_node_addrs_spin); 581e125fbebSAlexander Aring return -ENOENT; 582e125fbebSAlexander Aring } 583e125fbebSAlexander Aring 584e125fbebSAlexander Aring na->mark = mark; 585e125fbebSAlexander Aring spin_unlock(&dlm_node_addrs_spin); 586e125fbebSAlexander Aring 587e125fbebSAlexander Aring return 0; 588e125fbebSAlexander Aring } 589e125fbebSAlexander Aring 590b3a5bbfdSBob Peterson static void lowcomms_error_report(struct sock *sk) 591b3a5bbfdSBob Peterson { 592b81171cbSBob Peterson struct connection *con; 593b81171cbSBob Peterson void (*orig_report)(struct sock *) = NULL; 5944c3d9057SAlexander Aring struct inet_sock *inet; 595b3a5bbfdSBob Peterson 596b81171cbSBob Peterson con = sock2con(sk); 597b81171cbSBob Peterson if (con == NULL) 598b81171cbSBob Peterson goto out; 599b81171cbSBob Peterson 600cc661fc9SBob Peterson orig_report = listen_sock.sk_error_report; 601b3a5bbfdSBob Peterson 6024c3d9057SAlexander Aring inet = inet_sk(sk); 6034c3d9057SAlexander Aring switch (sk->sk_family) { 6044c3d9057SAlexander Aring case AF_INET: 605b3a5bbfdSBob Peterson printk_ratelimited(KERN_ERR "dlm: node %d: socket error " 6064c3d9057SAlexander Aring "sending to node %d at %pI4, dport %d, " 607b3a5bbfdSBob Peterson "sk_err=%d/%d\n", dlm_our_nodeid(), 6084c3d9057SAlexander Aring con->nodeid, &inet->inet_daddr, 6094c3d9057SAlexander Aring ntohs(inet->inet_dport), sk->sk_err, 610b3a5bbfdSBob Peterson sk->sk_err_soft); 6114c3d9057SAlexander Aring break; 6121b9beda8SAlexander Aring #if IS_ENABLED(CONFIG_IPV6) 6134c3d9057SAlexander Aring case AF_INET6: 614b3a5bbfdSBob Peterson printk_ratelimited(KERN_ERR "dlm: node %d: socket error " 6154c3d9057SAlexander Aring "sending to node %d at %pI6c, " 6164c3d9057SAlexander Aring "dport %d, sk_err=%d/%d\n", dlm_our_nodeid(), 6174c3d9057SAlexander Aring con->nodeid, &sk->sk_v6_daddr, 6184c3d9057SAlexander Aring ntohs(inet->inet_dport), sk->sk_err, 619b3a5bbfdSBob Peterson sk->sk_err_soft); 6204c3d9057SAlexander Aring break; 6211b9beda8SAlexander Aring #endif 6224c3d9057SAlexander Aring default: 6234c3d9057SAlexander Aring printk_ratelimited(KERN_ERR "dlm: node %d: socket error " 6244c3d9057SAlexander Aring "invalid socket family %d set, " 6254c3d9057SAlexander Aring "sk_err=%d/%d\n", dlm_our_nodeid(), 6264c3d9057SAlexander Aring sk->sk_family, sk->sk_err, sk->sk_err_soft); 6274c3d9057SAlexander Aring goto out; 628b3a5bbfdSBob Peterson } 629ba868d9dSAlexander Aring 630ba868d9dSAlexander Aring /* below sendcon only handling */ 631ba868d9dSAlexander Aring if (test_bit(CF_IS_OTHERCON, &con->flags)) 632ba868d9dSAlexander Aring con = con->sendcon; 633ba868d9dSAlexander Aring 634ba868d9dSAlexander Aring switch (sk->sk_err) { 635ba868d9dSAlexander Aring case ECONNREFUSED: 636ba868d9dSAlexander Aring set_bit(CF_DELAY_CONNECT, &con->flags); 637ba868d9dSAlexander Aring break; 638ba868d9dSAlexander Aring default: 639ba868d9dSAlexander Aring break; 640ba868d9dSAlexander Aring } 641ba868d9dSAlexander Aring 642ba868d9dSAlexander Aring if (!test_and_set_bit(CF_RECONNECT, &con->flags)) 643ba868d9dSAlexander Aring queue_work(send_workqueue, &con->swork); 644ba868d9dSAlexander Aring 645b81171cbSBob Peterson out: 646b81171cbSBob Peterson if (orig_report) 647b81171cbSBob Peterson orig_report(sk); 648b81171cbSBob Peterson } 649b81171cbSBob Peterson 650b81171cbSBob Peterson /* Note: sk_callback_lock must be locked before calling this function. */ 651cc661fc9SBob Peterson static void save_listen_callbacks(struct socket *sock) 652b81171cbSBob Peterson { 653cc661fc9SBob Peterson struct sock *sk = sock->sk; 654cc661fc9SBob Peterson 655cc661fc9SBob Peterson listen_sock.sk_data_ready = sk->sk_data_ready; 656cc661fc9SBob Peterson listen_sock.sk_state_change = sk->sk_state_change; 657cc661fc9SBob Peterson listen_sock.sk_write_space = sk->sk_write_space; 658cc661fc9SBob Peterson listen_sock.sk_error_report = sk->sk_error_report; 659b81171cbSBob Peterson } 660b81171cbSBob Peterson 661cc661fc9SBob Peterson static void restore_callbacks(struct socket *sock) 662b81171cbSBob Peterson { 663cc661fc9SBob Peterson struct sock *sk = sock->sk; 664cc661fc9SBob Peterson 66592c44605SAlexander Aring lock_sock(sk); 666b81171cbSBob Peterson sk->sk_user_data = NULL; 667cc661fc9SBob Peterson sk->sk_data_ready = listen_sock.sk_data_ready; 668cc661fc9SBob Peterson sk->sk_state_change = listen_sock.sk_state_change; 669cc661fc9SBob Peterson sk->sk_write_space = listen_sock.sk_write_space; 670cc661fc9SBob Peterson sk->sk_error_report = listen_sock.sk_error_report; 67192c44605SAlexander Aring release_sock(sk); 672b3a5bbfdSBob Peterson } 673b3a5bbfdSBob Peterson 674d11ccd45SAlexander Aring static void add_listen_sock(struct socket *sock, struct listen_connection *con) 675d11ccd45SAlexander Aring { 676d11ccd45SAlexander Aring struct sock *sk = sock->sk; 677d11ccd45SAlexander Aring 67892c44605SAlexander Aring lock_sock(sk); 679d11ccd45SAlexander Aring save_listen_callbacks(sock); 680d11ccd45SAlexander Aring con->sock = sock; 681d11ccd45SAlexander Aring 682d11ccd45SAlexander Aring sk->sk_user_data = con; 683d11ccd45SAlexander Aring sk->sk_allocation = GFP_NOFS; 684d11ccd45SAlexander Aring /* Install a data_ready callback */ 685d11ccd45SAlexander Aring sk->sk_data_ready = lowcomms_listen_data_ready; 68692c44605SAlexander Aring release_sock(sk); 687d11ccd45SAlexander Aring } 688d11ccd45SAlexander Aring 6896ed7257bSPatrick Caulfield /* Make a socket active */ 690988419a9Stsutomu.owa@toshiba.co.jp static void add_sock(struct socket *sock, struct connection *con) 6916ed7257bSPatrick Caulfield { 692b81171cbSBob Peterson struct sock *sk = sock->sk; 693b81171cbSBob Peterson 69492c44605SAlexander Aring lock_sock(sk); 6956ed7257bSPatrick Caulfield con->sock = sock; 6966ed7257bSPatrick Caulfield 697b81171cbSBob Peterson sk->sk_user_data = con; 6986ed7257bSPatrick Caulfield /* Install a data_ready callback */ 699b81171cbSBob Peterson sk->sk_data_ready = lowcomms_data_ready; 700b81171cbSBob Peterson sk->sk_write_space = lowcomms_write_space; 701b81171cbSBob Peterson sk->sk_state_change = lowcomms_state_change; 702b81171cbSBob Peterson sk->sk_allocation = GFP_NOFS; 703b81171cbSBob Peterson sk->sk_error_report = lowcomms_error_report; 70492c44605SAlexander Aring release_sock(sk); 7056ed7257bSPatrick Caulfield } 7066ed7257bSPatrick Caulfield 7076ed7257bSPatrick Caulfield /* Add the port number to an IPv6 or 4 sockaddr and return the address 7086ed7257bSPatrick Caulfield length */ 7096ed7257bSPatrick Caulfield static void make_sockaddr(struct sockaddr_storage *saddr, uint16_t port, 7106ed7257bSPatrick Caulfield int *addr_len) 7116ed7257bSPatrick Caulfield { 7126ed7257bSPatrick Caulfield saddr->ss_family = dlm_local_addr[0]->ss_family; 7136ed7257bSPatrick Caulfield if (saddr->ss_family == AF_INET) { 7146ed7257bSPatrick Caulfield struct sockaddr_in *in4_addr = (struct sockaddr_in *)saddr; 7156ed7257bSPatrick Caulfield in4_addr->sin_port = cpu_to_be16(port); 7166ed7257bSPatrick Caulfield *addr_len = sizeof(struct sockaddr_in); 7176ed7257bSPatrick Caulfield memset(&in4_addr->sin_zero, 0, sizeof(in4_addr->sin_zero)); 7186ed7257bSPatrick Caulfield } else { 7196ed7257bSPatrick Caulfield struct sockaddr_in6 *in6_addr = (struct sockaddr_in6 *)saddr; 7206ed7257bSPatrick Caulfield in6_addr->sin6_port = cpu_to_be16(port); 7216ed7257bSPatrick Caulfield *addr_len = sizeof(struct sockaddr_in6); 7226ed7257bSPatrick Caulfield } 72301c8cab2SPatrick Caulfield memset((char *)saddr + *addr_len, 0, sizeof(struct sockaddr_storage) - *addr_len); 7246ed7257bSPatrick Caulfield } 7256ed7257bSPatrick Caulfield 726706474fbSAlexander Aring static void dlm_page_release(struct kref *kref) 727706474fbSAlexander Aring { 728706474fbSAlexander Aring struct writequeue_entry *e = container_of(kref, struct writequeue_entry, 729706474fbSAlexander Aring ref); 730706474fbSAlexander Aring 731706474fbSAlexander Aring __free_page(e->page); 7323af2326cSAlexander Aring dlm_free_writequeue(e); 733706474fbSAlexander Aring } 734706474fbSAlexander Aring 735706474fbSAlexander Aring static void dlm_msg_release(struct kref *kref) 736706474fbSAlexander Aring { 737706474fbSAlexander Aring struct dlm_msg *msg = container_of(kref, struct dlm_msg, ref); 738706474fbSAlexander Aring 739706474fbSAlexander Aring kref_put(&msg->entry->ref, dlm_page_release); 740e4dc81edSAlexander Aring dlm_free_msg(msg); 741706474fbSAlexander Aring } 742706474fbSAlexander Aring 743706474fbSAlexander Aring static void free_entry(struct writequeue_entry *e) 744706474fbSAlexander Aring { 745706474fbSAlexander Aring struct dlm_msg *msg, *tmp; 746706474fbSAlexander Aring 747706474fbSAlexander Aring list_for_each_entry_safe(msg, tmp, &e->msgs, list) { 748706474fbSAlexander Aring if (msg->orig_msg) { 749706474fbSAlexander Aring msg->orig_msg->retransmit = false; 750706474fbSAlexander Aring kref_put(&msg->orig_msg->ref, dlm_msg_release); 751706474fbSAlexander Aring } 752706474fbSAlexander Aring 753706474fbSAlexander Aring list_del(&msg->list); 754706474fbSAlexander Aring kref_put(&msg->ref, dlm_msg_release); 755706474fbSAlexander Aring } 756706474fbSAlexander Aring 757706474fbSAlexander Aring list_del(&e->list); 758706474fbSAlexander Aring kref_put(&e->ref, dlm_page_release); 759706474fbSAlexander Aring } 760706474fbSAlexander Aring 761d11ccd45SAlexander Aring static void dlm_close_sock(struct socket **sock) 762d11ccd45SAlexander Aring { 763d11ccd45SAlexander Aring if (*sock) { 764d11ccd45SAlexander Aring restore_callbacks(*sock); 765d11ccd45SAlexander Aring sock_release(*sock); 766d11ccd45SAlexander Aring *sock = NULL; 767d11ccd45SAlexander Aring } 768d11ccd45SAlexander Aring } 769d11ccd45SAlexander Aring 7706ed7257bSPatrick Caulfield /* Close a remote connection and tidy up */ 7710d737a8cSMarcelo Ricardo Leitner static void close_connection(struct connection *con, bool and_other, 7720d737a8cSMarcelo Ricardo Leitner bool tx, bool rx) 7736ed7257bSPatrick Caulfield { 774b2a66629Stsutomu.owa@toshiba.co.jp bool closing = test_and_set_bit(CF_CLOSING, &con->flags); 775706474fbSAlexander Aring struct writequeue_entry *e; 776b2a66629Stsutomu.owa@toshiba.co.jp 7770aa18464Stsutomu.owa@toshiba.co.jp if (tx && !closing && cancel_work_sync(&con->swork)) { 7780d737a8cSMarcelo Ricardo Leitner log_print("canceled swork for node %d", con->nodeid); 7790aa18464Stsutomu.owa@toshiba.co.jp clear_bit(CF_WRITE_PENDING, &con->flags); 7800aa18464Stsutomu.owa@toshiba.co.jp } 7810aa18464Stsutomu.owa@toshiba.co.jp if (rx && !closing && cancel_work_sync(&con->rwork)) { 7820d737a8cSMarcelo Ricardo Leitner log_print("canceled rwork for node %d", con->nodeid); 7830aa18464Stsutomu.owa@toshiba.co.jp clear_bit(CF_READ_PENDING, &con->flags); 7840aa18464Stsutomu.owa@toshiba.co.jp } 7856ed7257bSPatrick Caulfield 7860d737a8cSMarcelo Ricardo Leitner mutex_lock(&con->sock_mutex); 787d11ccd45SAlexander Aring dlm_close_sock(&con->sock); 788d11ccd45SAlexander Aring 7896ed7257bSPatrick Caulfield if (con->othercon && and_other) { 7906ed7257bSPatrick Caulfield /* Will only re-enter once. */ 791c6aa00e3SAlexander Aring close_connection(con->othercon, false, tx, rx); 7926ed7257bSPatrick Caulfield } 7939e5f2825SPatrick Caulfield 794706474fbSAlexander Aring /* if we send a writequeue entry only a half way, we drop the 795706474fbSAlexander Aring * whole entry because reconnection and that we not start of the 796706474fbSAlexander Aring * middle of a msg which will confuse the other end. 797706474fbSAlexander Aring * 798706474fbSAlexander Aring * we can always drop messages because retransmits, but what we 799706474fbSAlexander Aring * cannot allow is to transmit half messages which may be processed 800706474fbSAlexander Aring * at the other side. 801706474fbSAlexander Aring * 802706474fbSAlexander Aring * our policy is to start on a clean state when disconnects, we don't 803706474fbSAlexander Aring * know what's send/received on transport layer in this case. 804706474fbSAlexander Aring */ 805706474fbSAlexander Aring spin_lock(&con->writequeue_lock); 806706474fbSAlexander Aring if (!list_empty(&con->writequeue)) { 807706474fbSAlexander Aring e = list_first_entry(&con->writequeue, struct writequeue_entry, 808706474fbSAlexander Aring list); 809706474fbSAlexander Aring if (e->dirty) 810706474fbSAlexander Aring free_entry(e); 811706474fbSAlexander Aring } 812706474fbSAlexander Aring spin_unlock(&con->writequeue_lock); 813706474fbSAlexander Aring 8144798cbbfSAlexander Aring con->rx_leftover = 0; 8156ed7257bSPatrick Caulfield con->retries = 0; 816052849beSAlexander Aring clear_bit(CF_APP_LIMITED, &con->flags); 81719633c7eSAlexander Aring clear_bit(CF_CONNECTED, &con->flags); 818ba868d9dSAlexander Aring clear_bit(CF_DELAY_CONNECT, &con->flags); 819ba868d9dSAlexander Aring clear_bit(CF_RECONNECT, &con->flags); 8206ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 821b2a66629Stsutomu.owa@toshiba.co.jp clear_bit(CF_CLOSING, &con->flags); 8226ed7257bSPatrick Caulfield } 8236ed7257bSPatrick Caulfield 8244798cbbfSAlexander Aring static int con_realloc_receive_buf(struct connection *con, int newlen) 8254798cbbfSAlexander Aring { 8264798cbbfSAlexander Aring unsigned char *newbuf; 8274798cbbfSAlexander Aring 8284798cbbfSAlexander Aring newbuf = kmalloc(newlen, GFP_NOFS); 8294798cbbfSAlexander Aring if (!newbuf) 8304798cbbfSAlexander Aring return -ENOMEM; 8314798cbbfSAlexander Aring 8324798cbbfSAlexander Aring /* copy any leftover from last receive */ 8334798cbbfSAlexander Aring if (con->rx_leftover) 8344798cbbfSAlexander Aring memmove(newbuf, con->rx_buf, con->rx_leftover); 8354798cbbfSAlexander Aring 8364798cbbfSAlexander Aring /* swap to new buffer space */ 8374798cbbfSAlexander Aring kfree(con->rx_buf); 8384798cbbfSAlexander Aring con->rx_buflen = newlen; 8394798cbbfSAlexander Aring con->rx_buf = newbuf; 8404798cbbfSAlexander Aring 8414798cbbfSAlexander Aring return 0; 8424798cbbfSAlexander Aring } 8434798cbbfSAlexander Aring 8446ed7257bSPatrick Caulfield /* Data received from remote end */ 8456ed7257bSPatrick Caulfield static int receive_from_sock(struct connection *con) 8466ed7257bSPatrick Caulfield { 8474798cbbfSAlexander Aring struct msghdr msg; 8484798cbbfSAlexander Aring struct kvec iov; 8494798cbbfSAlexander Aring int ret, buflen; 8506ed7257bSPatrick Caulfield 8516ed7257bSPatrick Caulfield mutex_lock(&con->sock_mutex); 8526ed7257bSPatrick Caulfield 8536ed7257bSPatrick Caulfield if (con->sock == NULL) { 8546ed7257bSPatrick Caulfield ret = -EAGAIN; 8556ed7257bSPatrick Caulfield goto out_close; 8566ed7257bSPatrick Caulfield } 8574798cbbfSAlexander Aring 8584798cbbfSAlexander Aring /* realloc if we get new buffer size to read out */ 8594798cbbfSAlexander Aring buflen = dlm_config.ci_buffer_size; 8604798cbbfSAlexander Aring if (con->rx_buflen != buflen && con->rx_leftover <= buflen) { 8614798cbbfSAlexander Aring ret = con_realloc_receive_buf(con, buflen); 8624798cbbfSAlexander Aring if (ret < 0) 8636ed7257bSPatrick Caulfield goto out_resched; 8646ed7257bSPatrick Caulfield } 8656ed7257bSPatrick Caulfield 86662699b3fSAlexander Aring for (;;) { 8674798cbbfSAlexander Aring /* calculate new buffer parameter regarding last receive and 8684798cbbfSAlexander Aring * possible leftover bytes 8696ed7257bSPatrick Caulfield */ 8704798cbbfSAlexander Aring iov.iov_base = con->rx_buf + con->rx_leftover; 8714798cbbfSAlexander Aring iov.iov_len = con->rx_buflen - con->rx_leftover; 8726ed7257bSPatrick Caulfield 8734798cbbfSAlexander Aring memset(&msg, 0, sizeof(msg)); 8744798cbbfSAlexander Aring msg.msg_flags = MSG_DONTWAIT | MSG_NOSIGNAL; 8754798cbbfSAlexander Aring ret = kernel_recvmsg(con->sock, &msg, &iov, 1, iov.iov_len, 8764798cbbfSAlexander Aring msg.msg_flags); 87792732376SAlexander Aring trace_dlm_recv(con->nodeid, ret); 87862699b3fSAlexander Aring if (ret == -EAGAIN) 87962699b3fSAlexander Aring break; 88062699b3fSAlexander Aring else if (ret <= 0) 8816ed7257bSPatrick Caulfield goto out_close; 8826ed7257bSPatrick Caulfield 8834798cbbfSAlexander Aring /* new buflen according readed bytes and leftover from last receive */ 8844798cbbfSAlexander Aring buflen = ret + con->rx_leftover; 8854798cbbfSAlexander Aring ret = dlm_process_incoming_buffer(con->nodeid, con->rx_buf, buflen); 8864798cbbfSAlexander Aring if (ret < 0) 8874798cbbfSAlexander Aring goto out_close; 8886ed7257bSPatrick Caulfield 8894798cbbfSAlexander Aring /* calculate leftover bytes from process and put it into begin of 8904798cbbfSAlexander Aring * the receive buffer, so next receive we have the full message 8914798cbbfSAlexander Aring * at the start address of the receive buffer. 8924798cbbfSAlexander Aring */ 8934798cbbfSAlexander Aring con->rx_leftover = buflen - ret; 8944798cbbfSAlexander Aring if (con->rx_leftover) { 8954798cbbfSAlexander Aring memmove(con->rx_buf, con->rx_buf + ret, 8964798cbbfSAlexander Aring con->rx_leftover); 8976ed7257bSPatrick Caulfield } 89862699b3fSAlexander Aring } 8994798cbbfSAlexander Aring 900b97f8525SAlexander Aring dlm_midcomms_receive_done(con->nodeid); 9016ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 9026ed7257bSPatrick Caulfield return 0; 9036ed7257bSPatrick Caulfield 9046ed7257bSPatrick Caulfield out_resched: 9056ed7257bSPatrick Caulfield if (!test_and_set_bit(CF_READ_PENDING, &con->flags)) 9066ed7257bSPatrick Caulfield queue_work(recv_workqueue, &con->rwork); 9076ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 9086ed7257bSPatrick Caulfield return -EAGAIN; 9096ed7257bSPatrick Caulfield 9106ed7257bSPatrick Caulfield out_close: 911055923bfSAlexander Aring if (ret == 0) { 912055923bfSAlexander Aring log_print("connection %p got EOF from %d", 913055923bfSAlexander Aring con, con->nodeid); 9148aa31cbfSAlexander Aring 9158aa31cbfSAlexander Aring mutex_unlock(&con->sock_mutex); 9168aa31cbfSAlexander Aring close_connection(con, false, true, false); 917055923bfSAlexander Aring /* signal to breaking receive worker */ 918055923bfSAlexander Aring ret = -1; 9198aa31cbfSAlexander Aring } else { 9208aa31cbfSAlexander Aring mutex_unlock(&con->sock_mutex); 9216ed7257bSPatrick Caulfield } 9226ed7257bSPatrick Caulfield return ret; 9236ed7257bSPatrick Caulfield } 9246ed7257bSPatrick Caulfield 9256ed7257bSPatrick Caulfield /* Listening socket is busy, accept a connection */ 926d11ccd45SAlexander Aring static int accept_from_sock(struct listen_connection *con) 9276ed7257bSPatrick Caulfield { 9286ed7257bSPatrick Caulfield int result; 9296ed7257bSPatrick Caulfield struct sockaddr_storage peeraddr; 9306ed7257bSPatrick Caulfield struct socket *newsock; 931b38bc9c2SAlexander Aring int len, idx; 9326ed7257bSPatrick Caulfield int nodeid; 9336ed7257bSPatrick Caulfield struct connection *newcon; 9346ed7257bSPatrick Caulfield struct connection *addcon; 9353f78cd7dSAlexander Aring unsigned int mark; 9366ed7257bSPatrick Caulfield 937d11ccd45SAlexander Aring if (!con->sock) 9383421fb15Stsutomu.owa@toshiba.co.jp return -ENOTCONN; 9396ed7257bSPatrick Caulfield 9403421fb15Stsutomu.owa@toshiba.co.jp result = kernel_accept(con->sock, &newsock, O_NONBLOCK); 9416ed7257bSPatrick Caulfield if (result < 0) 9426ed7257bSPatrick Caulfield goto accept_err; 9436ed7257bSPatrick Caulfield 9446ed7257bSPatrick Caulfield /* Get the connected socket's peer */ 9456ed7257bSPatrick Caulfield memset(&peeraddr, 0, sizeof(peeraddr)); 9469b2c45d4SDenys Vlasenko len = newsock->ops->getname(newsock, (struct sockaddr *)&peeraddr, 2); 9479b2c45d4SDenys Vlasenko if (len < 0) { 9486ed7257bSPatrick Caulfield result = -ECONNABORTED; 9496ed7257bSPatrick Caulfield goto accept_err; 9506ed7257bSPatrick Caulfield } 9516ed7257bSPatrick Caulfield 9526ed7257bSPatrick Caulfield /* Get the new node's NODEID */ 9536ed7257bSPatrick Caulfield make_sockaddr(&peeraddr, 0, &len); 954e125fbebSAlexander Aring if (addr_to_nodeid(&peeraddr, &nodeid, &mark)) { 955feae43f8SAlexander Aring switch (peeraddr.ss_family) { 956feae43f8SAlexander Aring case AF_INET: { 957feae43f8SAlexander Aring struct sockaddr_in *sin = (struct sockaddr_in *)&peeraddr; 958feae43f8SAlexander Aring 959feae43f8SAlexander Aring log_print("connect from non cluster IPv4 node %pI4", 960feae43f8SAlexander Aring &sin->sin_addr); 961feae43f8SAlexander Aring break; 962feae43f8SAlexander Aring } 963feae43f8SAlexander Aring #if IS_ENABLED(CONFIG_IPV6) 964feae43f8SAlexander Aring case AF_INET6: { 965feae43f8SAlexander Aring struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)&peeraddr; 966feae43f8SAlexander Aring 967feae43f8SAlexander Aring log_print("connect from non cluster IPv6 node %pI6c", 968feae43f8SAlexander Aring &sin6->sin6_addr); 969feae43f8SAlexander Aring break; 970feae43f8SAlexander Aring } 971feae43f8SAlexander Aring #endif 972feae43f8SAlexander Aring default: 973feae43f8SAlexander Aring log_print("invalid family from non cluster node"); 974feae43f8SAlexander Aring break; 975feae43f8SAlexander Aring } 976feae43f8SAlexander Aring 9776ed7257bSPatrick Caulfield sock_release(newsock); 9786ed7257bSPatrick Caulfield return -1; 9796ed7257bSPatrick Caulfield } 9806ed7257bSPatrick Caulfield 9816ed7257bSPatrick Caulfield log_print("got connection from %d", nodeid); 9826ed7257bSPatrick Caulfield 9836ed7257bSPatrick Caulfield /* Check to see if we already have a connection to this node. This 9846ed7257bSPatrick Caulfield * could happen if the two nodes initiate a connection at roughly 9856ed7257bSPatrick Caulfield * the same time and the connections cross on the wire. 9866ed7257bSPatrick Caulfield * In this case we store the incoming one in "othercon" 9876ed7257bSPatrick Caulfield */ 988b38bc9c2SAlexander Aring idx = srcu_read_lock(&connections_srcu); 989748285ccSDavid Teigland newcon = nodeid2con(nodeid, GFP_NOFS); 9906ed7257bSPatrick Caulfield if (!newcon) { 991b38bc9c2SAlexander Aring srcu_read_unlock(&connections_srcu, idx); 9926ed7257bSPatrick Caulfield result = -ENOMEM; 9936ed7257bSPatrick Caulfield goto accept_err; 9946ed7257bSPatrick Caulfield } 995d11ccd45SAlexander Aring 996e125fbebSAlexander Aring sock_set_mark(newsock->sk, mark); 997e125fbebSAlexander Aring 998d11ccd45SAlexander Aring mutex_lock(&newcon->sock_mutex); 9996ed7257bSPatrick Caulfield if (newcon->sock) { 10006ed7257bSPatrick Caulfield struct connection *othercon = newcon->othercon; 10016ed7257bSPatrick Caulfield 10026ed7257bSPatrick Caulfield if (!othercon) { 1003a47666ebSAlexander Aring othercon = kzalloc(sizeof(*othercon), GFP_NOFS); 10046ed7257bSPatrick Caulfield if (!othercon) { 1005617e82e1SDavid Teigland log_print("failed to allocate incoming socket"); 10066ed7257bSPatrick Caulfield mutex_unlock(&newcon->sock_mutex); 1007b38bc9c2SAlexander Aring srcu_read_unlock(&connections_srcu, idx); 10086ed7257bSPatrick Caulfield result = -ENOMEM; 10096ed7257bSPatrick Caulfield goto accept_err; 10106ed7257bSPatrick Caulfield } 10114798cbbfSAlexander Aring 10126cde210aSAlexander Aring result = dlm_con_init(othercon, nodeid); 10136cde210aSAlexander Aring if (result < 0) { 10144798cbbfSAlexander Aring kfree(othercon); 10152fd8db2dSYang Yingliang mutex_unlock(&newcon->sock_mutex); 1016b38bc9c2SAlexander Aring srcu_read_unlock(&connections_srcu, idx); 10174798cbbfSAlexander Aring goto accept_err; 10184798cbbfSAlexander Aring } 10194798cbbfSAlexander Aring 1020e9a470acSAlexander Aring lockdep_set_subclass(&othercon->sock_mutex, 1); 10217443bc96SAlexander Aring set_bit(CF_IS_OTHERCON, &othercon->flags); 10226cde210aSAlexander Aring newcon->othercon = othercon; 1023ba868d9dSAlexander Aring othercon->sendcon = newcon; 1024ba3ab3caSAlexander Aring } else { 1025ba3ab3caSAlexander Aring /* close other sock con if we have something new */ 1026ba3ab3caSAlexander Aring close_connection(othercon, false, true, false); 102761d96be0SPatrick Caulfield } 1028ba3ab3caSAlexander Aring 1029e9a470acSAlexander Aring mutex_lock(&othercon->sock_mutex); 1030988419a9Stsutomu.owa@toshiba.co.jp add_sock(newsock, othercon); 10316ed7257bSPatrick Caulfield addcon = othercon; 1032c7355827Stsutomu.owa@toshiba.co.jp mutex_unlock(&othercon->sock_mutex); 10336ed7257bSPatrick Caulfield } 10346ed7257bSPatrick Caulfield else { 10353735b4b9SBob Peterson /* accept copies the sk after we've saved the callbacks, so we 10363735b4b9SBob Peterson don't want to save them a second time or comm errors will 10373735b4b9SBob Peterson result in calling sk_error_report recursively. */ 1038988419a9Stsutomu.owa@toshiba.co.jp add_sock(newsock, newcon); 10396ed7257bSPatrick Caulfield addcon = newcon; 10406ed7257bSPatrick Caulfield } 10416ed7257bSPatrick Caulfield 1042b30a624fSAlexander Aring set_bit(CF_CONNECTED, &addcon->flags); 10436ed7257bSPatrick Caulfield mutex_unlock(&newcon->sock_mutex); 10446ed7257bSPatrick Caulfield 10456ed7257bSPatrick Caulfield /* 10466ed7257bSPatrick Caulfield * Add it to the active queue in case we got data 104725985edcSLucas De Marchi * between processing the accept adding the socket 10486ed7257bSPatrick Caulfield * to the read_sockets list 10496ed7257bSPatrick Caulfield */ 10506ed7257bSPatrick Caulfield if (!test_and_set_bit(CF_READ_PENDING, &addcon->flags)) 10516ed7257bSPatrick Caulfield queue_work(recv_workqueue, &addcon->rwork); 10526ed7257bSPatrick Caulfield 1053b38bc9c2SAlexander Aring srcu_read_unlock(&connections_srcu, idx); 1054b38bc9c2SAlexander Aring 10556ed7257bSPatrick Caulfield return 0; 10566ed7257bSPatrick Caulfield 10576ed7257bSPatrick Caulfield accept_err: 10583421fb15Stsutomu.owa@toshiba.co.jp if (newsock) 10596ed7257bSPatrick Caulfield sock_release(newsock); 10606ed7257bSPatrick Caulfield 10616ed7257bSPatrick Caulfield if (result != -EAGAIN) 1062617e82e1SDavid Teigland log_print("error accepting connection from node: %d", result); 10636ed7257bSPatrick Caulfield return result; 10646ed7257bSPatrick Caulfield } 10656ed7257bSPatrick Caulfield 10665d689871SMike Christie /* 10675d689871SMike Christie * writequeue_entry_complete - try to delete and free write queue entry 10685d689871SMike Christie * @e: write queue entry to try to delete 10695d689871SMike Christie * @completed: bytes completed 10705d689871SMike Christie * 10715d689871SMike Christie * writequeue_lock must be held. 10725d689871SMike Christie */ 10735d689871SMike Christie static void writequeue_entry_complete(struct writequeue_entry *e, int completed) 10745d689871SMike Christie { 10755d689871SMike Christie e->offset += completed; 10765d689871SMike Christie e->len -= completed; 1077706474fbSAlexander Aring /* signal that page was half way transmitted */ 1078706474fbSAlexander Aring e->dirty = true; 10795d689871SMike Christie 10808f2dc78dSAlexander Aring if (e->len == 0 && e->users == 0) 10815d689871SMike Christie free_entry(e); 10825d689871SMike Christie } 10835d689871SMike Christie 1084ee44b4bcSMarcelo Ricardo Leitner /* 1085ee44b4bcSMarcelo Ricardo Leitner * sctp_bind_addrs - bind a SCTP socket to all our addresses 1086ee44b4bcSMarcelo Ricardo Leitner */ 108713004e8aSAlexander Aring static int sctp_bind_addrs(struct socket *sock, uint16_t port) 1088ee44b4bcSMarcelo Ricardo Leitner { 1089ee44b4bcSMarcelo Ricardo Leitner struct sockaddr_storage localaddr; 1090c0425a42SChristoph Hellwig struct sockaddr *addr = (struct sockaddr *)&localaddr; 1091ee44b4bcSMarcelo Ricardo Leitner int i, addr_len, result = 0; 1092ee44b4bcSMarcelo Ricardo Leitner 1093ee44b4bcSMarcelo Ricardo Leitner for (i = 0; i < dlm_local_count; i++) { 1094ee44b4bcSMarcelo Ricardo Leitner memcpy(&localaddr, dlm_local_addr[i], sizeof(localaddr)); 1095ee44b4bcSMarcelo Ricardo Leitner make_sockaddr(&localaddr, port, &addr_len); 1096ee44b4bcSMarcelo Ricardo Leitner 1097ee44b4bcSMarcelo Ricardo Leitner if (!i) 109813004e8aSAlexander Aring result = kernel_bind(sock, addr, addr_len); 1099ee44b4bcSMarcelo Ricardo Leitner else 110013004e8aSAlexander Aring result = sock_bind_add(sock->sk, addr, addr_len); 1101ee44b4bcSMarcelo Ricardo Leitner 1102ee44b4bcSMarcelo Ricardo Leitner if (result < 0) { 1103ee44b4bcSMarcelo Ricardo Leitner log_print("Can't bind to %d addr number %d, %d.\n", 1104ee44b4bcSMarcelo Ricardo Leitner port, i + 1, result); 1105ee44b4bcSMarcelo Ricardo Leitner break; 1106ee44b4bcSMarcelo Ricardo Leitner } 1107ee44b4bcSMarcelo Ricardo Leitner } 1108ee44b4bcSMarcelo Ricardo Leitner return result; 1109ee44b4bcSMarcelo Ricardo Leitner } 1110ee44b4bcSMarcelo Ricardo Leitner 11116ed7257bSPatrick Caulfield /* Get local addresses */ 11126ed7257bSPatrick Caulfield static void init_local(void) 11136ed7257bSPatrick Caulfield { 11146ed7257bSPatrick Caulfield struct sockaddr_storage sas, *addr; 11156ed7257bSPatrick Caulfield int i; 11166ed7257bSPatrick Caulfield 111730d3a237SPatrick Caulfield dlm_local_count = 0; 11181b189b88SDavid Teigland for (i = 0; i < DLM_MAX_ADDR_COUNT; i++) { 11196ed7257bSPatrick Caulfield if (dlm_our_addr(&sas, i)) 11206ed7257bSPatrick Caulfield break; 11216ed7257bSPatrick Caulfield 11225c93f56fSAmitoj Kaur Chawla addr = kmemdup(&sas, sizeof(*addr), GFP_NOFS); 11236ed7257bSPatrick Caulfield if (!addr) 11246ed7257bSPatrick Caulfield break; 11256ed7257bSPatrick Caulfield dlm_local_addr[dlm_local_count++] = addr; 11266ed7257bSPatrick Caulfield } 11276ed7257bSPatrick Caulfield } 11286ed7257bSPatrick Caulfield 1129043697f0SAlexander Aring static void deinit_local(void) 1130043697f0SAlexander Aring { 1131043697f0SAlexander Aring int i; 1132043697f0SAlexander Aring 1133043697f0SAlexander Aring for (i = 0; i < dlm_local_count; i++) 1134043697f0SAlexander Aring kfree(dlm_local_addr[i]); 1135043697f0SAlexander Aring } 1136043697f0SAlexander Aring 1137be3b0400SAlexander Aring static struct writequeue_entry *new_writequeue_entry(struct connection *con) 11386ed7257bSPatrick Caulfield { 11396ed7257bSPatrick Caulfield struct writequeue_entry *entry; 11406ed7257bSPatrick Caulfield 11413af2326cSAlexander Aring entry = dlm_allocate_writequeue(); 11426ed7257bSPatrick Caulfield if (!entry) 11436ed7257bSPatrick Caulfield return NULL; 11446ed7257bSPatrick Caulfield 1145be3b0400SAlexander Aring entry->page = alloc_page(GFP_ATOMIC | __GFP_ZERO); 11466ed7257bSPatrick Caulfield if (!entry->page) { 11473af2326cSAlexander Aring dlm_free_writequeue(entry); 11486ed7257bSPatrick Caulfield return NULL; 11496ed7257bSPatrick Caulfield } 11506ed7257bSPatrick Caulfield 11513af2326cSAlexander Aring entry->offset = 0; 11523af2326cSAlexander Aring entry->len = 0; 11533af2326cSAlexander Aring entry->end = 0; 11543af2326cSAlexander Aring entry->dirty = false; 11556ed7257bSPatrick Caulfield entry->con = con; 1156f0747ebfSAlexander Aring entry->users = 1; 11578f2dc78dSAlexander Aring kref_init(&entry->ref); 11586ed7257bSPatrick Caulfield return entry; 11596ed7257bSPatrick Caulfield } 11606ed7257bSPatrick Caulfield 1161f0747ebfSAlexander Aring static struct writequeue_entry *new_wq_entry(struct connection *con, int len, 1162be3b0400SAlexander Aring char **ppc, void (*cb)(void *data), 1163be3b0400SAlexander Aring void *data) 1164f0747ebfSAlexander Aring { 1165f0747ebfSAlexander Aring struct writequeue_entry *e; 1166f0747ebfSAlexander Aring 1167f0747ebfSAlexander Aring spin_lock(&con->writequeue_lock); 1168f0747ebfSAlexander Aring if (!list_empty(&con->writequeue)) { 1169f0747ebfSAlexander Aring e = list_last_entry(&con->writequeue, struct writequeue_entry, list); 1170f0747ebfSAlexander Aring if (DLM_WQ_REMAIN_BYTES(e) >= len) { 11718f2dc78dSAlexander Aring kref_get(&e->ref); 11728f2dc78dSAlexander Aring 1173f0747ebfSAlexander Aring *ppc = page_address(e->page) + e->end; 11748f2dc78dSAlexander Aring if (cb) 11755c16febbSAlexander Aring cb(data); 11768f2dc78dSAlexander Aring 1177f0747ebfSAlexander Aring e->end += len; 1178f0747ebfSAlexander Aring e->users++; 1179be3b0400SAlexander Aring goto out; 1180f0747ebfSAlexander Aring } 1181f0747ebfSAlexander Aring } 1182f0747ebfSAlexander Aring 1183be3b0400SAlexander Aring e = new_writequeue_entry(con); 1184f0747ebfSAlexander Aring if (!e) 1185be3b0400SAlexander Aring goto out; 1186f0747ebfSAlexander Aring 11878f2dc78dSAlexander Aring kref_get(&e->ref); 1188f0747ebfSAlexander Aring *ppc = page_address(e->page); 1189f0747ebfSAlexander Aring e->end += len; 11908f2dc78dSAlexander Aring if (cb) 11915c16febbSAlexander Aring cb(data); 11928f2dc78dSAlexander Aring 1193f0747ebfSAlexander Aring list_add_tail(&e->list, &con->writequeue); 1194f0747ebfSAlexander Aring 1195be3b0400SAlexander Aring out: 1196be3b0400SAlexander Aring spin_unlock(&con->writequeue_lock); 1197f0747ebfSAlexander Aring return e; 1198f0747ebfSAlexander Aring }; 1199f0747ebfSAlexander Aring 12002874d1a6SAlexander Aring static struct dlm_msg *dlm_lowcomms_new_msg_con(struct connection *con, int len, 12012874d1a6SAlexander Aring gfp_t allocation, char **ppc, 12025c16febbSAlexander Aring void (*cb)(void *data), 12035c16febbSAlexander Aring void *data) 12042874d1a6SAlexander Aring { 12052874d1a6SAlexander Aring struct writequeue_entry *e; 12062874d1a6SAlexander Aring struct dlm_msg *msg; 12072874d1a6SAlexander Aring 1208e4dc81edSAlexander Aring msg = dlm_allocate_msg(allocation); 12092874d1a6SAlexander Aring if (!msg) 12102874d1a6SAlexander Aring return NULL; 12112874d1a6SAlexander Aring 12122874d1a6SAlexander Aring kref_init(&msg->ref); 12132874d1a6SAlexander Aring 1214be3b0400SAlexander Aring e = new_wq_entry(con, len, ppc, cb, data); 12152874d1a6SAlexander Aring if (!e) { 1216e4dc81edSAlexander Aring dlm_free_msg(msg); 12172874d1a6SAlexander Aring return NULL; 12182874d1a6SAlexander Aring } 12192874d1a6SAlexander Aring 1220e4dc81edSAlexander Aring msg->retransmit = false; 1221e4dc81edSAlexander Aring msg->orig_msg = NULL; 12222874d1a6SAlexander Aring msg->ppc = *ppc; 12232874d1a6SAlexander Aring msg->len = len; 12242874d1a6SAlexander Aring msg->entry = e; 12252874d1a6SAlexander Aring 12262874d1a6SAlexander Aring return msg; 12272874d1a6SAlexander Aring } 12282874d1a6SAlexander Aring 1229a8449f23SAlexander Aring /* avoid false positive for nodes_srcu, unlock happens in 1230a8449f23SAlexander Aring * dlm_lowcomms_commit_msg which is a must call if success 1231a8449f23SAlexander Aring */ 1232a8449f23SAlexander Aring #ifndef __CHECKER__ 12338f2dc78dSAlexander Aring struct dlm_msg *dlm_lowcomms_new_msg(int nodeid, int len, gfp_t allocation, 12345c16febbSAlexander Aring char **ppc, void (*cb)(void *data), 12355c16febbSAlexander Aring void *data) 12366ed7257bSPatrick Caulfield { 12376ed7257bSPatrick Caulfield struct connection *con; 12388f2dc78dSAlexander Aring struct dlm_msg *msg; 1239b38bc9c2SAlexander Aring int idx; 12406ed7257bSPatrick Caulfield 1241d10a0b88SAlexander Aring if (len > DLM_MAX_SOCKET_BUFSIZE || 1242c45674fbSAlexander Aring len < sizeof(struct dlm_header)) { 1243d10a0b88SAlexander Aring BUILD_BUG_ON(PAGE_SIZE < DLM_MAX_SOCKET_BUFSIZE); 1244692f51c8SAlexander Aring log_print("failed to allocate a buffer of size %d", len); 1245c45674fbSAlexander Aring WARN_ON(1); 1246692f51c8SAlexander Aring return NULL; 1247692f51c8SAlexander Aring } 1248692f51c8SAlexander Aring 1249b38bc9c2SAlexander Aring idx = srcu_read_lock(&connections_srcu); 12506ed7257bSPatrick Caulfield con = nodeid2con(nodeid, allocation); 1251b38bc9c2SAlexander Aring if (!con) { 1252b38bc9c2SAlexander Aring srcu_read_unlock(&connections_srcu, idx); 12536ed7257bSPatrick Caulfield return NULL; 1254b38bc9c2SAlexander Aring } 12556ed7257bSPatrick Caulfield 12565c16febbSAlexander Aring msg = dlm_lowcomms_new_msg_con(con, len, allocation, ppc, cb, data); 12578f2dc78dSAlexander Aring if (!msg) { 1258b38bc9c2SAlexander Aring srcu_read_unlock(&connections_srcu, idx); 1259b38bc9c2SAlexander Aring return NULL; 1260b38bc9c2SAlexander Aring } 1261b38bc9c2SAlexander Aring 126230ea3257SAlexander Aring /* for dlm_lowcomms_commit_msg() */ 126330ea3257SAlexander Aring kref_get(&msg->ref); 12648f2dc78dSAlexander Aring /* we assume if successful commit must called */ 12658f2dc78dSAlexander Aring msg->idx = idx; 12668f2dc78dSAlexander Aring return msg; 12678f2dc78dSAlexander Aring } 1268a8449f23SAlexander Aring #endif 12698f2dc78dSAlexander Aring 12702874d1a6SAlexander Aring static void _dlm_lowcomms_commit_msg(struct dlm_msg *msg) 12716ed7257bSPatrick Caulfield { 12728f2dc78dSAlexander Aring struct writequeue_entry *e = msg->entry; 12736ed7257bSPatrick Caulfield struct connection *con = e->con; 12746ed7257bSPatrick Caulfield int users; 12756ed7257bSPatrick Caulfield 12766ed7257bSPatrick Caulfield spin_lock(&con->writequeue_lock); 12778f2dc78dSAlexander Aring kref_get(&msg->ref); 12788f2dc78dSAlexander Aring list_add(&msg->list, &e->msgs); 12798f2dc78dSAlexander Aring 12806ed7257bSPatrick Caulfield users = --e->users; 12816ed7257bSPatrick Caulfield if (users) 12826ed7257bSPatrick Caulfield goto out; 1283f0747ebfSAlexander Aring 1284f0747ebfSAlexander Aring e->len = DLM_WQ_LENGTH_BYTES(e); 12856ed7257bSPatrick Caulfield spin_unlock(&con->writequeue_lock); 12866ed7257bSPatrick Caulfield 12876ed7257bSPatrick Caulfield queue_work(send_workqueue, &con->swork); 12886ed7257bSPatrick Caulfield return; 12896ed7257bSPatrick Caulfield 12906ed7257bSPatrick Caulfield out: 12916ed7257bSPatrick Caulfield spin_unlock(&con->writequeue_lock); 12926ed7257bSPatrick Caulfield return; 12936ed7257bSPatrick Caulfield } 12946ed7257bSPatrick Caulfield 1295a8449f23SAlexander Aring /* avoid false positive for nodes_srcu, lock was happen in 1296a8449f23SAlexander Aring * dlm_lowcomms_new_msg 1297a8449f23SAlexander Aring */ 1298a8449f23SAlexander Aring #ifndef __CHECKER__ 12992874d1a6SAlexander Aring void dlm_lowcomms_commit_msg(struct dlm_msg *msg) 13002874d1a6SAlexander Aring { 13012874d1a6SAlexander Aring _dlm_lowcomms_commit_msg(msg); 13022874d1a6SAlexander Aring srcu_read_unlock(&connections_srcu, msg->idx); 130330ea3257SAlexander Aring /* because dlm_lowcomms_new_msg() */ 130430ea3257SAlexander Aring kref_put(&msg->ref, dlm_msg_release); 13052874d1a6SAlexander Aring } 1306a8449f23SAlexander Aring #endif 13072874d1a6SAlexander Aring 13088f2dc78dSAlexander Aring void dlm_lowcomms_put_msg(struct dlm_msg *msg) 13098f2dc78dSAlexander Aring { 13108f2dc78dSAlexander Aring kref_put(&msg->ref, dlm_msg_release); 13118f2dc78dSAlexander Aring } 13128f2dc78dSAlexander Aring 13132874d1a6SAlexander Aring /* does not held connections_srcu, usage workqueue only */ 13142874d1a6SAlexander Aring int dlm_lowcomms_resend_msg(struct dlm_msg *msg) 13152874d1a6SAlexander Aring { 13162874d1a6SAlexander Aring struct dlm_msg *msg_resend; 13172874d1a6SAlexander Aring char *ppc; 13182874d1a6SAlexander Aring 13192874d1a6SAlexander Aring if (msg->retransmit) 13202874d1a6SAlexander Aring return 1; 13212874d1a6SAlexander Aring 13222874d1a6SAlexander Aring msg_resend = dlm_lowcomms_new_msg_con(msg->entry->con, msg->len, 13232874d1a6SAlexander Aring GFP_ATOMIC, &ppc, NULL, NULL); 13242874d1a6SAlexander Aring if (!msg_resend) 13252874d1a6SAlexander Aring return -ENOMEM; 13262874d1a6SAlexander Aring 13272874d1a6SAlexander Aring msg->retransmit = true; 13282874d1a6SAlexander Aring kref_get(&msg->ref); 13292874d1a6SAlexander Aring msg_resend->orig_msg = msg; 13302874d1a6SAlexander Aring 13312874d1a6SAlexander Aring memcpy(ppc, msg->ppc, msg->len); 13322874d1a6SAlexander Aring _dlm_lowcomms_commit_msg(msg_resend); 13332874d1a6SAlexander Aring dlm_lowcomms_put_msg(msg_resend); 13342874d1a6SAlexander Aring 13352874d1a6SAlexander Aring return 0; 13362874d1a6SAlexander Aring } 13372874d1a6SAlexander Aring 13386ed7257bSPatrick Caulfield /* Send a message */ 13396ed7257bSPatrick Caulfield static void send_to_sock(struct connection *con) 13406ed7257bSPatrick Caulfield { 13416ed7257bSPatrick Caulfield const int msg_flags = MSG_DONTWAIT | MSG_NOSIGNAL; 13426ed7257bSPatrick Caulfield struct writequeue_entry *e; 134366d5955aSAlexander Aring int len, offset, ret; 1344194a3fb4SAlexander Aring int count; 1345194a3fb4SAlexander Aring 1346194a3fb4SAlexander Aring again: 1347194a3fb4SAlexander Aring count = 0; 13486ed7257bSPatrick Caulfield 13496ed7257bSPatrick Caulfield mutex_lock(&con->sock_mutex); 13506ed7257bSPatrick Caulfield if (con->sock == NULL) 13516ed7257bSPatrick Caulfield goto out_connect; 13526ed7257bSPatrick Caulfield 13536ed7257bSPatrick Caulfield spin_lock(&con->writequeue_lock); 13546ed7257bSPatrick Caulfield for (;;) { 135566d5955aSAlexander Aring e = con_next_wq(con); 135666d5955aSAlexander Aring if (!e) 13576ed7257bSPatrick Caulfield break; 13586ed7257bSPatrick Caulfield 13596ed7257bSPatrick Caulfield len = e->len; 13606ed7257bSPatrick Caulfield offset = e->offset; 13616ed7257bSPatrick Caulfield BUG_ON(len == 0 && e->users == 0); 13626ed7257bSPatrick Caulfield spin_unlock(&con->writequeue_lock); 13636ed7257bSPatrick Caulfield 13641329e3f2SPaolo Bonzini ret = kernel_sendpage(con->sock, e->page, offset, len, 13656ed7257bSPatrick Caulfield msg_flags); 136692732376SAlexander Aring trace_dlm_send(con->nodeid, ret); 1367d66f8277SPatrick Caulfield if (ret == -EAGAIN || ret == 0) { 1368b36930ddSDavid Miller if (ret == -EAGAIN && 13699cd3e072SEric Dumazet test_bit(SOCKWQ_ASYNC_NOSPACE, &con->sock->flags) && 1370b36930ddSDavid Miller !test_and_set_bit(CF_APP_LIMITED, &con->flags)) { 1371b36930ddSDavid Miller /* Notify TCP that we're limited by the 1372b36930ddSDavid Miller * application window size. 1373b36930ddSDavid Miller */ 1374b36930ddSDavid Miller set_bit(SOCK_NOSPACE, &con->sock->flags); 1375b36930ddSDavid Miller con->sock->sk->sk_write_pending++; 1376b36930ddSDavid Miller } 1377d66f8277SPatrick Caulfield cond_resched(); 13786ed7257bSPatrick Caulfield goto out; 13799c5bef58SYing Xue } else if (ret < 0) 1380ba868d9dSAlexander Aring goto out; 1381f92c8dd7SBob Peterson 13826ed7257bSPatrick Caulfield spin_lock(&con->writequeue_lock); 13835d689871SMike Christie writequeue_entry_complete(e, ret); 1384194a3fb4SAlexander Aring 1385194a3fb4SAlexander Aring /* Don't starve people filling buffers */ 1386194a3fb4SAlexander Aring if (++count >= MAX_SEND_MSG_COUNT) { 1387194a3fb4SAlexander Aring spin_unlock(&con->writequeue_lock); 1388194a3fb4SAlexander Aring mutex_unlock(&con->sock_mutex); 1389194a3fb4SAlexander Aring cond_resched(); 1390194a3fb4SAlexander Aring goto again; 1391194a3fb4SAlexander Aring } 13926ed7257bSPatrick Caulfield } 13936ed7257bSPatrick Caulfield spin_unlock(&con->writequeue_lock); 13948aa31cbfSAlexander Aring 13956ed7257bSPatrick Caulfield out: 13966ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 13976ed7257bSPatrick Caulfield return; 13986ed7257bSPatrick Caulfield 13996ed7257bSPatrick Caulfield out_connect: 14006ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 140101da24d3SBob Peterson queue_work(send_workqueue, &con->swork); 140201da24d3SBob Peterson cond_resched(); 14036ed7257bSPatrick Caulfield } 14046ed7257bSPatrick Caulfield 14056ed7257bSPatrick Caulfield static void clean_one_writequeue(struct connection *con) 14066ed7257bSPatrick Caulfield { 14075e9ccc37SChristine Caulfield struct writequeue_entry *e, *safe; 14086ed7257bSPatrick Caulfield 14096ed7257bSPatrick Caulfield spin_lock(&con->writequeue_lock); 14105e9ccc37SChristine Caulfield list_for_each_entry_safe(e, safe, &con->writequeue, list) { 14116ed7257bSPatrick Caulfield free_entry(e); 14126ed7257bSPatrick Caulfield } 14136ed7257bSPatrick Caulfield spin_unlock(&con->writequeue_lock); 14146ed7257bSPatrick Caulfield } 14156ed7257bSPatrick Caulfield 14166ed7257bSPatrick Caulfield /* Called from recovery when it knows that a node has 14176ed7257bSPatrick Caulfield left the cluster */ 14186ed7257bSPatrick Caulfield int dlm_lowcomms_close(int nodeid) 14196ed7257bSPatrick Caulfield { 14206ed7257bSPatrick Caulfield struct connection *con; 142136b71a8bSDavid Teigland struct dlm_node_addr *na; 1422b38bc9c2SAlexander Aring int idx; 14236ed7257bSPatrick Caulfield 14246ed7257bSPatrick Caulfield log_print("closing connection to node %d", nodeid); 1425b38bc9c2SAlexander Aring idx = srcu_read_lock(&connections_srcu); 14266ed7257bSPatrick Caulfield con = nodeid2con(nodeid, 0); 14276ed7257bSPatrick Caulfield if (con) { 1428063c4c99SLars Marowsky-Bree set_bit(CF_CLOSE, &con->flags); 14290d737a8cSMarcelo Ricardo Leitner close_connection(con, true, true, true); 14306ed7257bSPatrick Caulfield clean_one_writequeue(con); 143153a5edaaSAlexander Aring if (con->othercon) 143253a5edaaSAlexander Aring clean_one_writequeue(con->othercon); 14336ed7257bSPatrick Caulfield } 1434b38bc9c2SAlexander Aring srcu_read_unlock(&connections_srcu, idx); 143536b71a8bSDavid Teigland 143636b71a8bSDavid Teigland spin_lock(&dlm_node_addrs_spin); 143736b71a8bSDavid Teigland na = find_node_addr(nodeid); 143836b71a8bSDavid Teigland if (na) { 143936b71a8bSDavid Teigland list_del(&na->list); 144036b71a8bSDavid Teigland while (na->addr_count--) 144136b71a8bSDavid Teigland kfree(na->addr[na->addr_count]); 144236b71a8bSDavid Teigland kfree(na); 144336b71a8bSDavid Teigland } 144436b71a8bSDavid Teigland spin_unlock(&dlm_node_addrs_spin); 144536b71a8bSDavid Teigland 14466ed7257bSPatrick Caulfield return 0; 14476ed7257bSPatrick Caulfield } 14486ed7257bSPatrick Caulfield 14496ed7257bSPatrick Caulfield /* Receive workqueue function */ 14506ed7257bSPatrick Caulfield static void process_recv_sockets(struct work_struct *work) 14516ed7257bSPatrick Caulfield { 14526ed7257bSPatrick Caulfield struct connection *con = container_of(work, struct connection, rwork); 14536ed7257bSPatrick Caulfield 14546ed7257bSPatrick Caulfield clear_bit(CF_READ_PENDING, &con->flags); 145562699b3fSAlexander Aring receive_from_sock(con); 14566ed7257bSPatrick Caulfield } 14576ed7257bSPatrick Caulfield 1458d11ccd45SAlexander Aring static void process_listen_recv_socket(struct work_struct *work) 1459d11ccd45SAlexander Aring { 1460f0f4bb43SAlexander Aring int ret; 1461f0f4bb43SAlexander Aring 1462f0f4bb43SAlexander Aring do { 1463f0f4bb43SAlexander Aring ret = accept_from_sock(&listen_con); 1464f0f4bb43SAlexander Aring } while (!ret); 1465d11ccd45SAlexander Aring } 1466d11ccd45SAlexander Aring 14678728a455SAlexander Aring static void dlm_connect(struct connection *con) 14688728a455SAlexander Aring { 14698728a455SAlexander Aring struct sockaddr_storage addr; 14708728a455SAlexander Aring int result, addr_len; 14718728a455SAlexander Aring struct socket *sock; 14728728a455SAlexander Aring unsigned int mark; 14738728a455SAlexander Aring 14748728a455SAlexander Aring /* Some odd races can cause double-connects, ignore them */ 14758728a455SAlexander Aring if (con->retries++ > MAX_CONNECT_RETRIES) 14768728a455SAlexander Aring return; 14778728a455SAlexander Aring 14788728a455SAlexander Aring if (con->sock) { 14798728a455SAlexander Aring log_print("node %d already connected.", con->nodeid); 14808728a455SAlexander Aring return; 14818728a455SAlexander Aring } 14828728a455SAlexander Aring 14838728a455SAlexander Aring memset(&addr, 0, sizeof(addr)); 14848728a455SAlexander Aring result = nodeid_to_addr(con->nodeid, &addr, NULL, 14858728a455SAlexander Aring dlm_proto_ops->try_new_addr, &mark); 14868728a455SAlexander Aring if (result < 0) { 14878728a455SAlexander Aring log_print("no address for nodeid %d", con->nodeid); 14888728a455SAlexander Aring return; 14898728a455SAlexander Aring } 14908728a455SAlexander Aring 14918728a455SAlexander Aring /* Create a socket to communicate with */ 14928728a455SAlexander Aring result = sock_create_kern(&init_net, dlm_local_addr[0]->ss_family, 14938728a455SAlexander Aring SOCK_STREAM, dlm_proto_ops->proto, &sock); 14948728a455SAlexander Aring if (result < 0) 14958728a455SAlexander Aring goto socket_err; 14968728a455SAlexander Aring 14978728a455SAlexander Aring sock_set_mark(sock->sk, mark); 14988728a455SAlexander Aring dlm_proto_ops->sockopts(sock); 14998728a455SAlexander Aring 15008728a455SAlexander Aring add_sock(sock, con); 15018728a455SAlexander Aring 15028728a455SAlexander Aring result = dlm_proto_ops->bind(sock); 15038728a455SAlexander Aring if (result < 0) 15048728a455SAlexander Aring goto add_sock_err; 15058728a455SAlexander Aring 15068728a455SAlexander Aring log_print_ratelimited("connecting to %d", con->nodeid); 15078728a455SAlexander Aring make_sockaddr(&addr, dlm_config.ci_tcp_port, &addr_len); 15088728a455SAlexander Aring result = dlm_proto_ops->connect(con, sock, (struct sockaddr *)&addr, 15098728a455SAlexander Aring addr_len); 15108728a455SAlexander Aring if (result < 0) 15118728a455SAlexander Aring goto add_sock_err; 15128728a455SAlexander Aring 15138728a455SAlexander Aring return; 15148728a455SAlexander Aring 15158728a455SAlexander Aring add_sock_err: 15168728a455SAlexander Aring dlm_close_sock(&con->sock); 15178728a455SAlexander Aring 15188728a455SAlexander Aring socket_err: 15198728a455SAlexander Aring /* 15208728a455SAlexander Aring * Some errors are fatal and this list might need adjusting. For other 15218728a455SAlexander Aring * errors we try again until the max number of retries is reached. 15228728a455SAlexander Aring */ 15238728a455SAlexander Aring if (result != -EHOSTUNREACH && 15248728a455SAlexander Aring result != -ENETUNREACH && 15258728a455SAlexander Aring result != -ENETDOWN && 15268728a455SAlexander Aring result != -EINVAL && 15278728a455SAlexander Aring result != -EPROTONOSUPPORT) { 15288728a455SAlexander Aring log_print("connect %d try %d error %d", con->nodeid, 15298728a455SAlexander Aring con->retries, result); 15308728a455SAlexander Aring msleep(1000); 15318728a455SAlexander Aring lowcomms_connect_sock(con); 15328728a455SAlexander Aring } 15338728a455SAlexander Aring } 15348728a455SAlexander Aring 15356ed7257bSPatrick Caulfield /* Send workqueue function */ 15366ed7257bSPatrick Caulfield static void process_send_sockets(struct work_struct *work) 15376ed7257bSPatrick Caulfield { 15386ed7257bSPatrick Caulfield struct connection *con = container_of(work, struct connection, swork); 15396ed7257bSPatrick Caulfield 15407443bc96SAlexander Aring WARN_ON(test_bit(CF_IS_OTHERCON, &con->flags)); 15417443bc96SAlexander Aring 15428a4abb08Stsutomu.owa@toshiba.co.jp clear_bit(CF_WRITE_PENDING, &con->flags); 1543ba868d9dSAlexander Aring 1544489d8e55SAlexander Aring if (test_and_clear_bit(CF_RECONNECT, &con->flags)) { 1545ba868d9dSAlexander Aring close_connection(con, false, false, true); 1546489d8e55SAlexander Aring dlm_midcomms_unack_msg_resend(con->nodeid); 1547489d8e55SAlexander Aring } 1548ba868d9dSAlexander Aring 15498728a455SAlexander Aring if (con->sock == NULL) { 1550ba868d9dSAlexander Aring if (test_and_clear_bit(CF_DELAY_CONNECT, &con->flags)) 1551ba868d9dSAlexander Aring msleep(1000); 15528728a455SAlexander Aring 15538728a455SAlexander Aring mutex_lock(&con->sock_mutex); 15548728a455SAlexander Aring dlm_connect(con); 15558728a455SAlexander Aring mutex_unlock(&con->sock_mutex); 1556ba868d9dSAlexander Aring } 15578728a455SAlexander Aring 155801da24d3SBob Peterson if (!list_empty(&con->writequeue)) 15596ed7257bSPatrick Caulfield send_to_sock(con); 15606ed7257bSPatrick Caulfield } 15616ed7257bSPatrick Caulfield 15626ed7257bSPatrick Caulfield static void work_stop(void) 15636ed7257bSPatrick Caulfield { 1564fcef0e6cSAlexander Aring if (recv_workqueue) { 15656ed7257bSPatrick Caulfield destroy_workqueue(recv_workqueue); 1566fcef0e6cSAlexander Aring recv_workqueue = NULL; 1567fcef0e6cSAlexander Aring } 1568fcef0e6cSAlexander Aring 1569fcef0e6cSAlexander Aring if (send_workqueue) { 15706ed7257bSPatrick Caulfield destroy_workqueue(send_workqueue); 1571fcef0e6cSAlexander Aring send_workqueue = NULL; 1572fcef0e6cSAlexander Aring } 15736ed7257bSPatrick Caulfield } 15746ed7257bSPatrick Caulfield 15756ed7257bSPatrick Caulfield static int work_start(void) 15766ed7257bSPatrick Caulfield { 15776c6a1cc6SAlexander Aring recv_workqueue = alloc_ordered_workqueue("dlm_recv", WQ_MEM_RECLAIM); 1578b9d41052SNamhyung Kim if (!recv_workqueue) { 1579b9d41052SNamhyung Kim log_print("can't start dlm_recv"); 1580b9d41052SNamhyung Kim return -ENOMEM; 15816ed7257bSPatrick Caulfield } 15826ed7257bSPatrick Caulfield 15836c6a1cc6SAlexander Aring send_workqueue = alloc_ordered_workqueue("dlm_send", WQ_MEM_RECLAIM); 1584b9d41052SNamhyung Kim if (!send_workqueue) { 1585b9d41052SNamhyung Kim log_print("can't start dlm_send"); 15866ed7257bSPatrick Caulfield destroy_workqueue(recv_workqueue); 1587fcef0e6cSAlexander Aring recv_workqueue = NULL; 1588b9d41052SNamhyung Kim return -ENOMEM; 15896ed7257bSPatrick Caulfield } 15906ed7257bSPatrick Caulfield 15916ed7257bSPatrick Caulfield return 0; 15926ed7257bSPatrick Caulfield } 15936ed7257bSPatrick Caulfield 15949d232469SAlexander Aring void dlm_lowcomms_shutdown(void) 15959d232469SAlexander Aring { 15961037c2a9SAlexander Aring restore_callbacks(listen_con.sock); 15979d232469SAlexander Aring 15989d232469SAlexander Aring if (recv_workqueue) 15999d232469SAlexander Aring flush_workqueue(recv_workqueue); 16009d232469SAlexander Aring if (send_workqueue) 16019d232469SAlexander Aring flush_workqueue(send_workqueue); 16029d232469SAlexander Aring 16039d232469SAlexander Aring dlm_close_sock(&listen_con.sock); 1604*4f567acbSAlexander Aring } 1605*4f567acbSAlexander Aring 1606*4f567acbSAlexander Aring void dlm_lowcomms_shutdown_node(int nodeid, bool force) 1607*4f567acbSAlexander Aring { 1608*4f567acbSAlexander Aring struct connection *con; 1609*4f567acbSAlexander Aring int idx; 16109d232469SAlexander Aring 1611b38bc9c2SAlexander Aring idx = srcu_read_lock(&connections_srcu); 1612*4f567acbSAlexander Aring con = nodeid2con(nodeid, 0); 1613*4f567acbSAlexander Aring if (WARN_ON_ONCE(!con)) { 1614*4f567acbSAlexander Aring srcu_read_unlock(&connections_srcu, idx); 1615*4f567acbSAlexander Aring return; 1616*4f567acbSAlexander Aring } 1617*4f567acbSAlexander Aring 1618*4f567acbSAlexander Aring WARN_ON_ONCE(!force && !list_empty(&con->writequeue)); 1619*4f567acbSAlexander Aring clean_one_writequeue(con); 1620*4f567acbSAlexander Aring if (con->othercon) 1621*4f567acbSAlexander Aring clean_one_writequeue(con->othercon); 1622*4f567acbSAlexander Aring close_connection(con, true, true, true); 1623b38bc9c2SAlexander Aring srcu_read_unlock(&connections_srcu, idx); 16249d232469SAlexander Aring } 16259d232469SAlexander Aring 1626f0fb83cbStsutomu.owa@toshiba.co.jp static void _stop_conn(struct connection *con, bool and_other) 16276ed7257bSPatrick Caulfield { 1628f0fb83cbStsutomu.owa@toshiba.co.jp mutex_lock(&con->sock_mutex); 1629173a31feStsutomu.owa@toshiba.co.jp set_bit(CF_CLOSE, &con->flags); 1630f0fb83cbStsutomu.owa@toshiba.co.jp set_bit(CF_READ_PENDING, &con->flags); 16318a4abb08Stsutomu.owa@toshiba.co.jp set_bit(CF_WRITE_PENDING, &con->flags); 163293eaadebStsutomu.owa@toshiba.co.jp if (con->sock && con->sock->sk) { 163392c44605SAlexander Aring lock_sock(con->sock->sk); 1634afb853fbSPatrick Caulfield con->sock->sk->sk_user_data = NULL; 163592c44605SAlexander Aring release_sock(con->sock->sk); 163693eaadebStsutomu.owa@toshiba.co.jp } 1637f0fb83cbStsutomu.owa@toshiba.co.jp if (con->othercon && and_other) 1638f0fb83cbStsutomu.owa@toshiba.co.jp _stop_conn(con->othercon, false); 1639f0fb83cbStsutomu.owa@toshiba.co.jp mutex_unlock(&con->sock_mutex); 1640f0fb83cbStsutomu.owa@toshiba.co.jp } 1641f0fb83cbStsutomu.owa@toshiba.co.jp 1642f0fb83cbStsutomu.owa@toshiba.co.jp static void stop_conn(struct connection *con) 1643f0fb83cbStsutomu.owa@toshiba.co.jp { 1644f0fb83cbStsutomu.owa@toshiba.co.jp _stop_conn(con, true); 1645afb853fbSPatrick Caulfield } 16465e9ccc37SChristine Caulfield 16474798cbbfSAlexander Aring static void connection_release(struct rcu_head *rcu) 16484798cbbfSAlexander Aring { 16494798cbbfSAlexander Aring struct connection *con = container_of(rcu, struct connection, rcu); 16504798cbbfSAlexander Aring 16514798cbbfSAlexander Aring kfree(con->rx_buf); 16524798cbbfSAlexander Aring kfree(con); 16534798cbbfSAlexander Aring } 16544798cbbfSAlexander Aring 16555e9ccc37SChristine Caulfield static void free_conn(struct connection *con) 16565e9ccc37SChristine Caulfield { 16570d737a8cSMarcelo Ricardo Leitner close_connection(con, true, true, true); 1658a47666ebSAlexander Aring spin_lock(&connections_lock); 1659a47666ebSAlexander Aring hlist_del_rcu(&con->list); 1660a47666ebSAlexander Aring spin_unlock(&connections_lock); 1661948c47e9SAlexander Aring if (con->othercon) { 1662948c47e9SAlexander Aring clean_one_writequeue(con->othercon); 16635cbec208SAlexander Aring call_srcu(&connections_srcu, &con->othercon->rcu, 16645cbec208SAlexander Aring connection_release); 1665948c47e9SAlexander Aring } 16660de98432SAlexander Aring clean_one_writequeue(con); 16675cbec208SAlexander Aring call_srcu(&connections_srcu, &con->rcu, connection_release); 16686ed7257bSPatrick Caulfield } 16695e9ccc37SChristine Caulfield 1670f0fb83cbStsutomu.owa@toshiba.co.jp static void work_flush(void) 1671f0fb83cbStsutomu.owa@toshiba.co.jp { 1672b38bc9c2SAlexander Aring int ok; 1673f0fb83cbStsutomu.owa@toshiba.co.jp int i; 1674f0fb83cbStsutomu.owa@toshiba.co.jp struct connection *con; 1675f0fb83cbStsutomu.owa@toshiba.co.jp 1676f0fb83cbStsutomu.owa@toshiba.co.jp do { 1677f0fb83cbStsutomu.owa@toshiba.co.jp ok = 1; 1678f0fb83cbStsutomu.owa@toshiba.co.jp foreach_conn(stop_conn); 1679b355516fSDavid Windsor if (recv_workqueue) 1680f0fb83cbStsutomu.owa@toshiba.co.jp flush_workqueue(recv_workqueue); 1681b355516fSDavid Windsor if (send_workqueue) 1682f0fb83cbStsutomu.owa@toshiba.co.jp flush_workqueue(send_workqueue); 1683f0fb83cbStsutomu.owa@toshiba.co.jp for (i = 0; i < CONN_HASH_SIZE && ok; i++) { 1684a47666ebSAlexander Aring hlist_for_each_entry_rcu(con, &connection_hash[i], 1685a47666ebSAlexander Aring list) { 1686f0fb83cbStsutomu.owa@toshiba.co.jp ok &= test_bit(CF_READ_PENDING, &con->flags); 16878a4abb08Stsutomu.owa@toshiba.co.jp ok &= test_bit(CF_WRITE_PENDING, &con->flags); 16888a4abb08Stsutomu.owa@toshiba.co.jp if (con->othercon) { 1689f0fb83cbStsutomu.owa@toshiba.co.jp ok &= test_bit(CF_READ_PENDING, 1690f0fb83cbStsutomu.owa@toshiba.co.jp &con->othercon->flags); 16918a4abb08Stsutomu.owa@toshiba.co.jp ok &= test_bit(CF_WRITE_PENDING, 16928a4abb08Stsutomu.owa@toshiba.co.jp &con->othercon->flags); 16938a4abb08Stsutomu.owa@toshiba.co.jp } 1694f0fb83cbStsutomu.owa@toshiba.co.jp } 1695f0fb83cbStsutomu.owa@toshiba.co.jp } 1696f0fb83cbStsutomu.owa@toshiba.co.jp } while (!ok); 1697f0fb83cbStsutomu.owa@toshiba.co.jp } 1698f0fb83cbStsutomu.owa@toshiba.co.jp 16995e9ccc37SChristine Caulfield void dlm_lowcomms_stop(void) 17005e9ccc37SChristine Caulfield { 1701b38bc9c2SAlexander Aring int idx; 1702b38bc9c2SAlexander Aring 1703b38bc9c2SAlexander Aring idx = srcu_read_lock(&connections_srcu); 1704f0fb83cbStsutomu.owa@toshiba.co.jp work_flush(); 17053a8db798SMarcelo Ricardo Leitner foreach_conn(free_conn); 1706b38bc9c2SAlexander Aring srcu_read_unlock(&connections_srcu, idx); 17076ed7257bSPatrick Caulfield work_stop(); 1708043697f0SAlexander Aring deinit_local(); 1709a66c008cSAlexander Aring 1710a66c008cSAlexander Aring dlm_proto_ops = NULL; 17116ed7257bSPatrick Caulfield } 17126ed7257bSPatrick Caulfield 17132dc6b115SAlexander Aring static int dlm_listen_for_all(void) 17142dc6b115SAlexander Aring { 17152dc6b115SAlexander Aring struct socket *sock; 17162dc6b115SAlexander Aring int result; 17172dc6b115SAlexander Aring 17182dc6b115SAlexander Aring log_print("Using %s for communications", 17192dc6b115SAlexander Aring dlm_proto_ops->name); 17202dc6b115SAlexander Aring 17212dc6b115SAlexander Aring result = dlm_proto_ops->listen_validate(); 17222dc6b115SAlexander Aring if (result < 0) 17232dc6b115SAlexander Aring return result; 17242dc6b115SAlexander Aring 17252dc6b115SAlexander Aring result = sock_create_kern(&init_net, dlm_local_addr[0]->ss_family, 17262dc6b115SAlexander Aring SOCK_STREAM, dlm_proto_ops->proto, &sock); 17272dc6b115SAlexander Aring if (result < 0) { 1728fe933675SAlexander Aring log_print("Can't create comms socket: %d", result); 17291f4f1084SDan Carpenter return result; 17302dc6b115SAlexander Aring } 17312dc6b115SAlexander Aring 17322dc6b115SAlexander Aring sock_set_mark(sock->sk, dlm_config.ci_mark); 17332dc6b115SAlexander Aring dlm_proto_ops->listen_sockopts(sock); 17342dc6b115SAlexander Aring 17352dc6b115SAlexander Aring result = dlm_proto_ops->listen_bind(sock); 17362dc6b115SAlexander Aring if (result < 0) 17372dc6b115SAlexander Aring goto out; 17382dc6b115SAlexander Aring 17392dc6b115SAlexander Aring save_listen_callbacks(sock); 17402dc6b115SAlexander Aring add_listen_sock(sock, &listen_con); 17412dc6b115SAlexander Aring 17422dc6b115SAlexander Aring result = sock->ops->listen(sock, 5); 17432dc6b115SAlexander Aring if (result < 0) { 17442dc6b115SAlexander Aring dlm_close_sock(&listen_con.sock); 174508ae0547SAlexander Aring return result; 17462dc6b115SAlexander Aring } 17472dc6b115SAlexander Aring 17482dc6b115SAlexander Aring return 0; 17492dc6b115SAlexander Aring 17502dc6b115SAlexander Aring out: 17512dc6b115SAlexander Aring sock_release(sock); 17522dc6b115SAlexander Aring return result; 17532dc6b115SAlexander Aring } 17542dc6b115SAlexander Aring 17558728a455SAlexander Aring static int dlm_tcp_bind(struct socket *sock) 17568728a455SAlexander Aring { 17578728a455SAlexander Aring struct sockaddr_storage src_addr; 17588728a455SAlexander Aring int result, addr_len; 17598728a455SAlexander Aring 17608728a455SAlexander Aring /* Bind to our cluster-known address connecting to avoid 17618728a455SAlexander Aring * routing problems. 17628728a455SAlexander Aring */ 17638728a455SAlexander Aring memcpy(&src_addr, dlm_local_addr[0], sizeof(src_addr)); 17648728a455SAlexander Aring make_sockaddr(&src_addr, 0, &addr_len); 17658728a455SAlexander Aring 17668728a455SAlexander Aring result = sock->ops->bind(sock, (struct sockaddr *)&src_addr, 17678728a455SAlexander Aring addr_len); 17688728a455SAlexander Aring if (result < 0) { 17698728a455SAlexander Aring /* This *may* not indicate a critical error */ 17708728a455SAlexander Aring log_print("could not bind for connect: %d", result); 17718728a455SAlexander Aring } 17728728a455SAlexander Aring 17738728a455SAlexander Aring return 0; 17748728a455SAlexander Aring } 17758728a455SAlexander Aring 17768728a455SAlexander Aring static int dlm_tcp_connect(struct connection *con, struct socket *sock, 17778728a455SAlexander Aring struct sockaddr *addr, int addr_len) 17788728a455SAlexander Aring { 17798728a455SAlexander Aring int ret; 17808728a455SAlexander Aring 17818728a455SAlexander Aring ret = sock->ops->connect(sock, addr, addr_len, O_NONBLOCK); 17828728a455SAlexander Aring switch (ret) { 17838728a455SAlexander Aring case -EINPROGRESS: 17848728a455SAlexander Aring fallthrough; 17858728a455SAlexander Aring case 0: 17868728a455SAlexander Aring return 0; 17878728a455SAlexander Aring } 17888728a455SAlexander Aring 17898728a455SAlexander Aring return ret; 17908728a455SAlexander Aring } 17918728a455SAlexander Aring 17922dc6b115SAlexander Aring static int dlm_tcp_listen_validate(void) 17932dc6b115SAlexander Aring { 17942dc6b115SAlexander Aring /* We don't support multi-homed hosts */ 17952dc6b115SAlexander Aring if (dlm_local_count > 1) { 17962dc6b115SAlexander Aring log_print("TCP protocol can't handle multi-homed hosts, try SCTP"); 17972dc6b115SAlexander Aring return -EINVAL; 17982dc6b115SAlexander Aring } 17992dc6b115SAlexander Aring 18002dc6b115SAlexander Aring return 0; 18012dc6b115SAlexander Aring } 18022dc6b115SAlexander Aring 18032dc6b115SAlexander Aring static void dlm_tcp_sockopts(struct socket *sock) 18042dc6b115SAlexander Aring { 18052dc6b115SAlexander Aring /* Turn off Nagle's algorithm */ 18062dc6b115SAlexander Aring tcp_sock_set_nodelay(sock->sk); 18072dc6b115SAlexander Aring } 18082dc6b115SAlexander Aring 18092dc6b115SAlexander Aring static void dlm_tcp_listen_sockopts(struct socket *sock) 18102dc6b115SAlexander Aring { 18112dc6b115SAlexander Aring dlm_tcp_sockopts(sock); 18122dc6b115SAlexander Aring sock_set_reuseaddr(sock->sk); 18132dc6b115SAlexander Aring } 18142dc6b115SAlexander Aring 18152dc6b115SAlexander Aring static int dlm_tcp_listen_bind(struct socket *sock) 18162dc6b115SAlexander Aring { 18172dc6b115SAlexander Aring int addr_len; 18182dc6b115SAlexander Aring 18192dc6b115SAlexander Aring /* Bind to our port */ 18202dc6b115SAlexander Aring make_sockaddr(dlm_local_addr[0], dlm_config.ci_tcp_port, &addr_len); 18212dc6b115SAlexander Aring return sock->ops->bind(sock, (struct sockaddr *)dlm_local_addr[0], 18222dc6b115SAlexander Aring addr_len); 18232dc6b115SAlexander Aring } 18242dc6b115SAlexander Aring 1825a66c008cSAlexander Aring static const struct dlm_proto_ops dlm_tcp_ops = { 18262dc6b115SAlexander Aring .name = "TCP", 18272dc6b115SAlexander Aring .proto = IPPROTO_TCP, 18288728a455SAlexander Aring .connect = dlm_tcp_connect, 18298728a455SAlexander Aring .sockopts = dlm_tcp_sockopts, 18308728a455SAlexander Aring .bind = dlm_tcp_bind, 18312dc6b115SAlexander Aring .listen_validate = dlm_tcp_listen_validate, 18322dc6b115SAlexander Aring .listen_sockopts = dlm_tcp_listen_sockopts, 18332dc6b115SAlexander Aring .listen_bind = dlm_tcp_listen_bind, 1834a66c008cSAlexander Aring }; 1835a66c008cSAlexander Aring 18368728a455SAlexander Aring static int dlm_sctp_bind(struct socket *sock) 18378728a455SAlexander Aring { 18388728a455SAlexander Aring return sctp_bind_addrs(sock, 0); 18398728a455SAlexander Aring } 18408728a455SAlexander Aring 18418728a455SAlexander Aring static int dlm_sctp_connect(struct connection *con, struct socket *sock, 18428728a455SAlexander Aring struct sockaddr *addr, int addr_len) 18438728a455SAlexander Aring { 18448728a455SAlexander Aring int ret; 18458728a455SAlexander Aring 18468728a455SAlexander Aring /* 18478728a455SAlexander Aring * Make sock->ops->connect() function return in specified time, 18488728a455SAlexander Aring * since O_NONBLOCK argument in connect() function does not work here, 18498728a455SAlexander Aring * then, we should restore the default value of this attribute. 18508728a455SAlexander Aring */ 18518728a455SAlexander Aring sock_set_sndtimeo(sock->sk, 5); 18528728a455SAlexander Aring ret = sock->ops->connect(sock, addr, addr_len, 0); 18538728a455SAlexander Aring sock_set_sndtimeo(sock->sk, 0); 18548728a455SAlexander Aring if (ret < 0) 18558728a455SAlexander Aring return ret; 18568728a455SAlexander Aring 18578728a455SAlexander Aring if (!test_and_set_bit(CF_CONNECTED, &con->flags)) 1858dfc020f3SAlexander Aring log_print("connected to node %d", con->nodeid); 18598728a455SAlexander Aring 18608728a455SAlexander Aring return 0; 18618728a455SAlexander Aring } 18628728a455SAlexander Aring 186390d21fc0SAlexander Aring static int dlm_sctp_listen_validate(void) 186490d21fc0SAlexander Aring { 186590d21fc0SAlexander Aring if (!IS_ENABLED(CONFIG_IP_SCTP)) { 186690d21fc0SAlexander Aring log_print("SCTP is not enabled by this kernel"); 186790d21fc0SAlexander Aring return -EOPNOTSUPP; 186890d21fc0SAlexander Aring } 186990d21fc0SAlexander Aring 187090d21fc0SAlexander Aring request_module("sctp"); 187190d21fc0SAlexander Aring return 0; 187290d21fc0SAlexander Aring } 187390d21fc0SAlexander Aring 18742dc6b115SAlexander Aring static int dlm_sctp_bind_listen(struct socket *sock) 18752dc6b115SAlexander Aring { 18762dc6b115SAlexander Aring return sctp_bind_addrs(sock, dlm_config.ci_tcp_port); 18772dc6b115SAlexander Aring } 18782dc6b115SAlexander Aring 18792dc6b115SAlexander Aring static void dlm_sctp_sockopts(struct socket *sock) 18802dc6b115SAlexander Aring { 18812dc6b115SAlexander Aring /* Turn off Nagle's algorithm */ 18822dc6b115SAlexander Aring sctp_sock_set_nodelay(sock->sk); 18832dc6b115SAlexander Aring sock_set_rcvbuf(sock->sk, NEEDED_RMEM); 18842dc6b115SAlexander Aring } 18852dc6b115SAlexander Aring 1886a66c008cSAlexander Aring static const struct dlm_proto_ops dlm_sctp_ops = { 18872dc6b115SAlexander Aring .name = "SCTP", 18882dc6b115SAlexander Aring .proto = IPPROTO_SCTP, 18898728a455SAlexander Aring .try_new_addr = true, 18908728a455SAlexander Aring .connect = dlm_sctp_connect, 18918728a455SAlexander Aring .sockopts = dlm_sctp_sockopts, 18928728a455SAlexander Aring .bind = dlm_sctp_bind, 189390d21fc0SAlexander Aring .listen_validate = dlm_sctp_listen_validate, 18942dc6b115SAlexander Aring .listen_sockopts = dlm_sctp_sockopts, 18952dc6b115SAlexander Aring .listen_bind = dlm_sctp_bind_listen, 1896a66c008cSAlexander Aring }; 1897a66c008cSAlexander Aring 18986ed7257bSPatrick Caulfield int dlm_lowcomms_start(void) 18996ed7257bSPatrick Caulfield { 19006ed7257bSPatrick Caulfield int error = -EINVAL; 19016ed7257bSPatrick Caulfield 19026ed7257bSPatrick Caulfield init_local(); 19036ed7257bSPatrick Caulfield if (!dlm_local_count) { 1904617e82e1SDavid Teigland error = -ENOTCONN; 19056ed7257bSPatrick Caulfield log_print("no local IP address has been set"); 1906513ef596SDavid Teigland goto fail; 19076ed7257bSPatrick Caulfield } 19086ed7257bSPatrick Caulfield 1909513ef596SDavid Teigland error = work_start(); 1910513ef596SDavid Teigland if (error) 1911fcef0e6cSAlexander Aring goto fail_local; 1912513ef596SDavid Teigland 19136ed7257bSPatrick Caulfield /* Start listening */ 1914ac7d5d03SAlexander Aring switch (dlm_config.ci_protocol) { 1915ac7d5d03SAlexander Aring case DLM_PROTO_TCP: 1916a66c008cSAlexander Aring dlm_proto_ops = &dlm_tcp_ops; 1917ac7d5d03SAlexander Aring break; 1918ac7d5d03SAlexander Aring case DLM_PROTO_SCTP: 1919a66c008cSAlexander Aring dlm_proto_ops = &dlm_sctp_ops; 1920ac7d5d03SAlexander Aring break; 1921ac7d5d03SAlexander Aring default: 1922ac7d5d03SAlexander Aring log_print("Invalid protocol identifier %d set", 1923ac7d5d03SAlexander Aring dlm_config.ci_protocol); 1924ac7d5d03SAlexander Aring error = -EINVAL; 19252dc6b115SAlexander Aring goto fail_proto_ops; 1926ac7d5d03SAlexander Aring } 19272dc6b115SAlexander Aring 19282dc6b115SAlexander Aring error = dlm_listen_for_all(); 19296ed7257bSPatrick Caulfield if (error) 19302dc6b115SAlexander Aring goto fail_listen; 19316ed7257bSPatrick Caulfield 19326ed7257bSPatrick Caulfield return 0; 19336ed7257bSPatrick Caulfield 19342dc6b115SAlexander Aring fail_listen: 19352dc6b115SAlexander Aring dlm_proto_ops = NULL; 19362dc6b115SAlexander Aring fail_proto_ops: 1937fcef0e6cSAlexander Aring work_stop(); 1938fcef0e6cSAlexander Aring fail_local: 1939fcef0e6cSAlexander Aring deinit_local(); 1940513ef596SDavid Teigland fail: 19416ed7257bSPatrick Caulfield return error; 19426ed7257bSPatrick Caulfield } 194336b71a8bSDavid Teigland 19448b0188b0SAlexander Aring void dlm_lowcomms_init(void) 19458b0188b0SAlexander Aring { 19468b0188b0SAlexander Aring int i; 19478b0188b0SAlexander Aring 19488b0188b0SAlexander Aring for (i = 0; i < CONN_HASH_SIZE; i++) 19498b0188b0SAlexander Aring INIT_HLIST_HEAD(&connection_hash[i]); 19508b0188b0SAlexander Aring 19518b0188b0SAlexander Aring INIT_WORK(&listen_con.rwork, process_listen_recv_socket); 19528b0188b0SAlexander Aring } 19538b0188b0SAlexander Aring 195436b71a8bSDavid Teigland void dlm_lowcomms_exit(void) 195536b71a8bSDavid Teigland { 195636b71a8bSDavid Teigland struct dlm_node_addr *na, *safe; 195736b71a8bSDavid Teigland 195836b71a8bSDavid Teigland spin_lock(&dlm_node_addrs_spin); 195936b71a8bSDavid Teigland list_for_each_entry_safe(na, safe, &dlm_node_addrs, list) { 196036b71a8bSDavid Teigland list_del(&na->list); 196136b71a8bSDavid Teigland while (na->addr_count--) 196236b71a8bSDavid Teigland kfree(na->addr[na->addr_count]); 196336b71a8bSDavid Teigland kfree(na); 196436b71a8bSDavid Teigland } 196536b71a8bSDavid Teigland spin_unlock(&dlm_node_addrs_spin); 196636b71a8bSDavid Teigland } 1967