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> 57*40e0b090SPeilin Ye #include <trace/events/sock.h> 5892732376SAlexander Aring 596ed7257bSPatrick Caulfield #include "dlm_internal.h" 606ed7257bSPatrick Caulfield #include "lowcomms.h" 616ed7257bSPatrick Caulfield #include "midcomms.h" 623af2326cSAlexander Aring #include "memory.h" 636ed7257bSPatrick Caulfield #include "config.h" 646ed7257bSPatrick Caulfield 656ed7257bSPatrick Caulfield #define NEEDED_RMEM (4*1024*1024) 666ed7257bSPatrick Caulfield 676ed7257bSPatrick Caulfield struct connection { 686ed7257bSPatrick Caulfield struct socket *sock; /* NULL if not connected */ 696ed7257bSPatrick Caulfield uint32_t nodeid; /* So we know who we are in the list */ 70dbb751ffSAlexander Aring /* this semaphore is used to allow parallel recv/send in read 71dbb751ffSAlexander Aring * lock mode. When we release a sock we need to held the write lock. 72dbb751ffSAlexander Aring * 73dbb751ffSAlexander Aring * However this is locking code and not nice. When we remove the 74dbb751ffSAlexander Aring * othercon handling we can look into other mechanism to synchronize 75dbb751ffSAlexander Aring * io handling to call sock_release() at the right time. 76dbb751ffSAlexander Aring */ 77dbb751ffSAlexander Aring struct rw_semaphore sock_lock; 786ed7257bSPatrick Caulfield unsigned long flags; 79dbb751ffSAlexander Aring #define CF_APP_LIMITED 0 80dbb751ffSAlexander Aring #define CF_RECV_PENDING 1 81dbb751ffSAlexander Aring #define CF_SEND_PENDING 2 82dbb751ffSAlexander Aring #define CF_RECV_INTR 3 83dbb751ffSAlexander Aring #define CF_IO_STOP 4 846ed7257bSPatrick Caulfield #define CF_IS_OTHERCON 5 856ed7257bSPatrick Caulfield struct list_head writequeue; /* List of outgoing writequeue_entries */ 866ed7257bSPatrick Caulfield spinlock_t writequeue_lock; 876ed7257bSPatrick Caulfield int retries; 885e9ccc37SChristine Caulfield struct hlist_node list; 89dbb751ffSAlexander Aring /* due some connect()/accept() races we currently have this cross over 90dbb751ffSAlexander Aring * connection attempt second connection for one node. 91dbb751ffSAlexander Aring * 92dbb751ffSAlexander Aring * There is a solution to avoid the race by introducing a connect 93dbb751ffSAlexander Aring * rule as e.g. our_nodeid > nodeid_to_connect who is allowed to 94dbb751ffSAlexander Aring * connect. Otherside can connect but will only be considered that 95dbb751ffSAlexander Aring * the other side wants to have a reconnect. 96dbb751ffSAlexander Aring * 97dbb751ffSAlexander Aring * However changing to this behaviour will break backwards compatible. 98dbb751ffSAlexander Aring * In a DLM protocol major version upgrade we should remove this! 99dbb751ffSAlexander Aring */ 1006ed7257bSPatrick Caulfield struct connection *othercon; 101dbb751ffSAlexander Aring struct work_struct rwork; /* receive worker */ 102dbb751ffSAlexander Aring struct work_struct swork; /* send worker */ 103dbb751ffSAlexander Aring unsigned char rx_leftover_buf[DLM_MAX_SOCKET_BUFSIZE]; 1044798cbbfSAlexander Aring int rx_leftover; 1056f0b0b5dSAlexander Aring int mark; 1066f0b0b5dSAlexander Aring int addr_count; 1076f0b0b5dSAlexander Aring int curr_addr_index; 1086f0b0b5dSAlexander Aring struct sockaddr_storage addr[DLM_MAX_ADDR_COUNT]; 1096f0b0b5dSAlexander Aring spinlock_t addrs_lock; 110a47666ebSAlexander Aring struct rcu_head rcu; 1116ed7257bSPatrick Caulfield }; 1126ed7257bSPatrick Caulfield #define sock2con(x) ((struct connection *)(x)->sk_user_data) 1136ed7257bSPatrick Caulfield 114d11ccd45SAlexander Aring struct listen_connection { 115d11ccd45SAlexander Aring struct socket *sock; 116d11ccd45SAlexander Aring struct work_struct rwork; 117d11ccd45SAlexander Aring }; 118d11ccd45SAlexander Aring 119f0747ebfSAlexander Aring #define DLM_WQ_REMAIN_BYTES(e) (PAGE_SIZE - e->end) 120f0747ebfSAlexander Aring #define DLM_WQ_LENGTH_BYTES(e) (e->end - e->offset) 121f0747ebfSAlexander Aring 1226ed7257bSPatrick Caulfield /* An entry waiting to be sent */ 1236ed7257bSPatrick Caulfield struct writequeue_entry { 1246ed7257bSPatrick Caulfield struct list_head list; 1256ed7257bSPatrick Caulfield struct page *page; 1266ed7257bSPatrick Caulfield int offset; 1276ed7257bSPatrick Caulfield int len; 1286ed7257bSPatrick Caulfield int end; 1296ed7257bSPatrick Caulfield int users; 130706474fbSAlexander Aring bool dirty; 1316ed7257bSPatrick Caulfield struct connection *con; 1328f2dc78dSAlexander Aring struct list_head msgs; 1338f2dc78dSAlexander Aring struct kref ref; 1348f2dc78dSAlexander Aring }; 1358f2dc78dSAlexander Aring 1368f2dc78dSAlexander Aring struct dlm_msg { 1378f2dc78dSAlexander Aring struct writequeue_entry *entry; 1382874d1a6SAlexander Aring struct dlm_msg *orig_msg; 1392874d1a6SAlexander Aring bool retransmit; 1408f2dc78dSAlexander Aring void *ppc; 1418f2dc78dSAlexander Aring int len; 1428f2dc78dSAlexander Aring int idx; /* new()/commit() idx exchange */ 1438f2dc78dSAlexander Aring 1448f2dc78dSAlexander Aring struct list_head list; 1458f2dc78dSAlexander Aring struct kref ref; 1466ed7257bSPatrick Caulfield }; 1476ed7257bSPatrick Caulfield 148dbb751ffSAlexander Aring struct processqueue_entry { 149dbb751ffSAlexander Aring unsigned char *buf; 150dbb751ffSAlexander Aring int nodeid; 151dbb751ffSAlexander Aring int buflen; 152dbb751ffSAlexander Aring 153dbb751ffSAlexander Aring struct list_head list; 154dbb751ffSAlexander Aring }; 155dbb751ffSAlexander Aring 156a66c008cSAlexander Aring struct dlm_proto_ops { 1578728a455SAlexander Aring bool try_new_addr; 1582dc6b115SAlexander Aring const char *name; 1592dc6b115SAlexander Aring int proto; 1602dc6b115SAlexander Aring 1618728a455SAlexander Aring int (*connect)(struct connection *con, struct socket *sock, 1628728a455SAlexander Aring struct sockaddr *addr, int addr_len); 1638728a455SAlexander Aring void (*sockopts)(struct socket *sock); 1648728a455SAlexander Aring int (*bind)(struct socket *sock); 1652dc6b115SAlexander Aring int (*listen_validate)(void); 1662dc6b115SAlexander Aring void (*listen_sockopts)(struct socket *sock); 1672dc6b115SAlexander Aring int (*listen_bind)(struct socket *sock); 168a66c008cSAlexander Aring }; 169a66c008cSAlexander Aring 170cc661fc9SBob Peterson static struct listen_sock_callbacks { 171cc661fc9SBob Peterson void (*sk_error_report)(struct sock *); 172cc661fc9SBob Peterson void (*sk_data_ready)(struct sock *); 173cc661fc9SBob Peterson void (*sk_state_change)(struct sock *); 174cc661fc9SBob Peterson void (*sk_write_space)(struct sock *); 175cc661fc9SBob Peterson } listen_sock; 176cc661fc9SBob Peterson 177d11ccd45SAlexander Aring static struct listen_connection listen_con; 178c51c9cd8SAlexander Aring static struct sockaddr_storage dlm_local_addr[DLM_MAX_ADDR_COUNT]; 1796ed7257bSPatrick Caulfield static int dlm_local_count; 1806ed7257bSPatrick Caulfield 1816ed7257bSPatrick Caulfield /* Work queues */ 182dbb751ffSAlexander Aring static struct workqueue_struct *io_workqueue; 183dbb751ffSAlexander Aring static struct workqueue_struct *process_workqueue; 1846ed7257bSPatrick Caulfield 1855e9ccc37SChristine Caulfield static struct hlist_head connection_hash[CONN_HASH_SIZE]; 186a47666ebSAlexander Aring static DEFINE_SPINLOCK(connections_lock); 187a47666ebSAlexander Aring DEFINE_STATIC_SRCU(connections_srcu); 1886ed7257bSPatrick Caulfield 189a66c008cSAlexander Aring static const struct dlm_proto_ops *dlm_proto_ops; 190a66c008cSAlexander Aring 191dbb751ffSAlexander Aring #define DLM_IO_SUCCESS 0 192dbb751ffSAlexander Aring #define DLM_IO_END 1 193dbb751ffSAlexander Aring #define DLM_IO_EOF 2 194dbb751ffSAlexander Aring #define DLM_IO_RESCHED 3 195dbb751ffSAlexander Aring 1966ed7257bSPatrick Caulfield static void process_recv_sockets(struct work_struct *work); 1976ed7257bSPatrick Caulfield static void process_send_sockets(struct work_struct *work); 198dbb751ffSAlexander Aring static void process_dlm_messages(struct work_struct *work); 199dbb751ffSAlexander Aring 200dbb751ffSAlexander Aring static DECLARE_WORK(process_work, process_dlm_messages); 201dbb751ffSAlexander Aring static DEFINE_SPINLOCK(processqueue_lock); 202dbb751ffSAlexander Aring static bool process_dlm_messages_pending; 203dbb751ffSAlexander Aring static LIST_HEAD(processqueue); 2046ed7257bSPatrick Caulfield 2051037c2a9SAlexander Aring bool dlm_lowcomms_is_running(void) 2061037c2a9SAlexander Aring { 2071037c2a9SAlexander Aring return !!listen_con.sock; 2081037c2a9SAlexander Aring } 2091037c2a9SAlexander Aring 210dbb751ffSAlexander Aring static void lowcomms_queue_swork(struct connection *con) 211dbb751ffSAlexander Aring { 2127a5e9f1fSAlexander Aring assert_spin_locked(&con->writequeue_lock); 213dbb751ffSAlexander Aring 214dbb751ffSAlexander Aring if (!test_bit(CF_IO_STOP, &con->flags) && 215dbb751ffSAlexander Aring !test_bit(CF_APP_LIMITED, &con->flags) && 216dbb751ffSAlexander Aring !test_and_set_bit(CF_SEND_PENDING, &con->flags)) 217dbb751ffSAlexander Aring queue_work(io_workqueue, &con->swork); 218dbb751ffSAlexander Aring } 219dbb751ffSAlexander Aring 220dbb751ffSAlexander Aring static void lowcomms_queue_rwork(struct connection *con) 221dbb751ffSAlexander Aring { 2227a5e9f1fSAlexander Aring #ifdef CONFIG_LOCKDEP 223dbb751ffSAlexander Aring WARN_ON_ONCE(!lockdep_sock_is_held(con->sock->sk)); 2247a5e9f1fSAlexander Aring #endif 225dbb751ffSAlexander Aring 226dbb751ffSAlexander Aring if (!test_bit(CF_IO_STOP, &con->flags) && 227dbb751ffSAlexander Aring !test_and_set_bit(CF_RECV_PENDING, &con->flags)) 228dbb751ffSAlexander Aring queue_work(io_workqueue, &con->rwork); 229dbb751ffSAlexander Aring } 230dbb751ffSAlexander Aring 2313af2326cSAlexander Aring static void writequeue_entry_ctor(void *data) 2323af2326cSAlexander Aring { 2333af2326cSAlexander Aring struct writequeue_entry *entry = data; 2343af2326cSAlexander Aring 2353af2326cSAlexander Aring INIT_LIST_HEAD(&entry->msgs); 2363af2326cSAlexander Aring } 2373af2326cSAlexander Aring 2383af2326cSAlexander Aring struct kmem_cache *dlm_lowcomms_writequeue_cache_create(void) 2393af2326cSAlexander Aring { 2403af2326cSAlexander Aring return kmem_cache_create("dlm_writequeue", sizeof(struct writequeue_entry), 2413af2326cSAlexander Aring 0, 0, writequeue_entry_ctor); 2423af2326cSAlexander Aring } 2433af2326cSAlexander Aring 244e4dc81edSAlexander Aring struct kmem_cache *dlm_lowcomms_msg_cache_create(void) 245e4dc81edSAlexander Aring { 246e4dc81edSAlexander Aring return kmem_cache_create("dlm_msg", sizeof(struct dlm_msg), 0, 0, NULL); 247e4dc81edSAlexander Aring } 248e4dc81edSAlexander Aring 24966d5955aSAlexander Aring /* need to held writequeue_lock */ 25066d5955aSAlexander Aring static struct writequeue_entry *con_next_wq(struct connection *con) 25166d5955aSAlexander Aring { 25266d5955aSAlexander Aring struct writequeue_entry *e; 25366d5955aSAlexander Aring 254dd070a56SAlexander Aring e = list_first_entry_or_null(&con->writequeue, struct writequeue_entry, 25566d5955aSAlexander Aring list); 256bcbfea41SAlexander Aring /* if len is zero nothing is to send, if there are users filling 257bcbfea41SAlexander Aring * buffers we wait until the users are done so we can send more. 258bcbfea41SAlexander Aring */ 259dd070a56SAlexander Aring if (!e || e->users || e->len == 0) 26066d5955aSAlexander Aring return NULL; 26166d5955aSAlexander Aring 26266d5955aSAlexander Aring return e; 26366d5955aSAlexander Aring } 26466d5955aSAlexander Aring 265b38bc9c2SAlexander Aring static struct connection *__find_con(int nodeid, int r) 2665e9ccc37SChristine Caulfield { 2675e9ccc37SChristine Caulfield struct connection *con; 2685e9ccc37SChristine Caulfield 269a47666ebSAlexander Aring hlist_for_each_entry_rcu(con, &connection_hash[r], list) { 270b38bc9c2SAlexander Aring if (con->nodeid == nodeid) 2715e9ccc37SChristine Caulfield return con; 2725e9ccc37SChristine Caulfield } 273a47666ebSAlexander Aring 2745e9ccc37SChristine Caulfield return NULL; 2755e9ccc37SChristine Caulfield } 2765e9ccc37SChristine Caulfield 277dbb751ffSAlexander Aring static void dlm_con_init(struct connection *con, int nodeid) 2786ed7257bSPatrick Caulfield { 2796ed7257bSPatrick Caulfield con->nodeid = nodeid; 280dbb751ffSAlexander Aring init_rwsem(&con->sock_lock); 2816ed7257bSPatrick Caulfield INIT_LIST_HEAD(&con->writequeue); 2826ed7257bSPatrick Caulfield spin_lock_init(&con->writequeue_lock); 2836ed7257bSPatrick Caulfield INIT_WORK(&con->swork, process_send_sockets); 2846ed7257bSPatrick Caulfield INIT_WORK(&con->rwork, process_recv_sockets); 285dbb751ffSAlexander Aring spin_lock_init(&con->addrs_lock); 2866cde210aSAlexander Aring } 2876cde210aSAlexander Aring 2886cde210aSAlexander Aring /* 2896cde210aSAlexander Aring * If 'allocation' is zero then we don't attempt to create a new 2906cde210aSAlexander Aring * connection structure for this node. 2916cde210aSAlexander Aring */ 2926cde210aSAlexander Aring static struct connection *nodeid2con(int nodeid, gfp_t alloc) 2936cde210aSAlexander Aring { 2946cde210aSAlexander Aring struct connection *con, *tmp; 295dbb751ffSAlexander Aring int r; 2966cde210aSAlexander Aring 297b38bc9c2SAlexander Aring r = nodeid_hash(nodeid); 298b38bc9c2SAlexander Aring con = __find_con(nodeid, r); 2996cde210aSAlexander Aring if (con || !alloc) 3006cde210aSAlexander Aring return con; 3016cde210aSAlexander Aring 3026cde210aSAlexander Aring con = kzalloc(sizeof(*con), alloc); 3036cde210aSAlexander Aring if (!con) 3046cde210aSAlexander Aring return NULL; 3056cde210aSAlexander Aring 306dbb751ffSAlexander Aring dlm_con_init(con, nodeid); 3076cde210aSAlexander Aring 308a47666ebSAlexander Aring spin_lock(&connections_lock); 3094f2b30fdSAlexander Aring /* Because multiple workqueues/threads calls this function it can 3104f2b30fdSAlexander Aring * race on multiple cpu's. Instead of locking hot path __find_con() 3114f2b30fdSAlexander Aring * we just check in rare cases of recently added nodes again 3124f2b30fdSAlexander Aring * under protection of connections_lock. If this is the case we 3134f2b30fdSAlexander Aring * abort our connection creation and return the existing connection. 3144f2b30fdSAlexander Aring */ 315b38bc9c2SAlexander Aring tmp = __find_con(nodeid, r); 3164f2b30fdSAlexander Aring if (tmp) { 3174f2b30fdSAlexander Aring spin_unlock(&connections_lock); 3184f2b30fdSAlexander Aring kfree(con); 3194f2b30fdSAlexander Aring return tmp; 3204f2b30fdSAlexander Aring } 3214f2b30fdSAlexander Aring 322a47666ebSAlexander Aring hlist_add_head_rcu(&con->list, &connection_hash[r]); 323a47666ebSAlexander Aring spin_unlock(&connections_lock); 324a47666ebSAlexander Aring 3256ed7257bSPatrick Caulfield return con; 3266ed7257bSPatrick Caulfield } 3276ed7257bSPatrick Caulfield 32840c6b83eSAlexander Aring static int addr_compare(const struct sockaddr_storage *x, 32940c6b83eSAlexander Aring const struct sockaddr_storage *y) 33036b71a8bSDavid Teigland { 33136b71a8bSDavid Teigland switch (x->ss_family) { 33236b71a8bSDavid Teigland case AF_INET: { 33336b71a8bSDavid Teigland struct sockaddr_in *sinx = (struct sockaddr_in *)x; 33436b71a8bSDavid Teigland struct sockaddr_in *siny = (struct sockaddr_in *)y; 33536b71a8bSDavid Teigland if (sinx->sin_addr.s_addr != siny->sin_addr.s_addr) 33636b71a8bSDavid Teigland return 0; 33736b71a8bSDavid Teigland if (sinx->sin_port != siny->sin_port) 33836b71a8bSDavid Teigland return 0; 33936b71a8bSDavid Teigland break; 34036b71a8bSDavid Teigland } 34136b71a8bSDavid Teigland case AF_INET6: { 34236b71a8bSDavid Teigland struct sockaddr_in6 *sinx = (struct sockaddr_in6 *)x; 34336b71a8bSDavid Teigland struct sockaddr_in6 *siny = (struct sockaddr_in6 *)y; 34436b71a8bSDavid Teigland if (!ipv6_addr_equal(&sinx->sin6_addr, &siny->sin6_addr)) 34536b71a8bSDavid Teigland return 0; 34636b71a8bSDavid Teigland if (sinx->sin6_port != siny->sin6_port) 34736b71a8bSDavid Teigland return 0; 34836b71a8bSDavid Teigland break; 34936b71a8bSDavid Teigland } 35036b71a8bSDavid Teigland default: 35136b71a8bSDavid Teigland return 0; 35236b71a8bSDavid Teigland } 35336b71a8bSDavid Teigland return 1; 35436b71a8bSDavid Teigland } 35536b71a8bSDavid Teigland 35636b71a8bSDavid Teigland static int nodeid_to_addr(int nodeid, struct sockaddr_storage *sas_out, 357e125fbebSAlexander Aring struct sockaddr *sa_out, bool try_new_addr, 358e125fbebSAlexander Aring unsigned int *mark) 35936b71a8bSDavid Teigland { 36036b71a8bSDavid Teigland struct sockaddr_storage sas; 3616f0b0b5dSAlexander Aring struct connection *con; 3626f0b0b5dSAlexander Aring int idx; 3636ed7257bSPatrick Caulfield 3646ed7257bSPatrick Caulfield if (!dlm_local_count) 3656ed7257bSPatrick Caulfield return -1; 3666ed7257bSPatrick Caulfield 3676f0b0b5dSAlexander Aring idx = srcu_read_lock(&connections_srcu); 3686f0b0b5dSAlexander Aring con = nodeid2con(nodeid, 0); 3696f0b0b5dSAlexander Aring if (!con) { 3706f0b0b5dSAlexander Aring srcu_read_unlock(&connections_srcu, idx); 3716f0b0b5dSAlexander Aring return -ENOENT; 3726f0b0b5dSAlexander Aring } 3736f0b0b5dSAlexander Aring 3746f0b0b5dSAlexander Aring spin_lock(&con->addrs_lock); 3756f0b0b5dSAlexander Aring if (!con->addr_count) { 3766f0b0b5dSAlexander Aring spin_unlock(&con->addrs_lock); 3776f0b0b5dSAlexander Aring srcu_read_unlock(&connections_srcu, idx); 3786f0b0b5dSAlexander Aring return -ENOENT; 3796f0b0b5dSAlexander Aring } 3806f0b0b5dSAlexander Aring 3816f0b0b5dSAlexander Aring memcpy(&sas, &con->addr[con->curr_addr_index], 382ee44b4bcSMarcelo Ricardo Leitner sizeof(struct sockaddr_storage)); 383ee44b4bcSMarcelo Ricardo Leitner 38498e1b60eSMike Christie if (try_new_addr) { 3856f0b0b5dSAlexander Aring con->curr_addr_index++; 3866f0b0b5dSAlexander Aring if (con->curr_addr_index == con->addr_count) 3876f0b0b5dSAlexander Aring con->curr_addr_index = 0; 38898e1b60eSMike Christie } 38936b71a8bSDavid Teigland 3906f0b0b5dSAlexander Aring *mark = con->mark; 3916f0b0b5dSAlexander Aring spin_unlock(&con->addrs_lock); 392e125fbebSAlexander Aring 39336b71a8bSDavid Teigland if (sas_out) 39436b71a8bSDavid Teigland memcpy(sas_out, &sas, sizeof(struct sockaddr_storage)); 39536b71a8bSDavid Teigland 3966f0b0b5dSAlexander Aring if (!sa_out) { 3976f0b0b5dSAlexander Aring srcu_read_unlock(&connections_srcu, idx); 39836b71a8bSDavid Teigland return 0; 3996f0b0b5dSAlexander Aring } 4006ed7257bSPatrick Caulfield 401c51c9cd8SAlexander Aring if (dlm_local_addr[0].ss_family == AF_INET) { 40236b71a8bSDavid Teigland struct sockaddr_in *in4 = (struct sockaddr_in *) &sas; 40336b71a8bSDavid Teigland struct sockaddr_in *ret4 = (struct sockaddr_in *) sa_out; 4046ed7257bSPatrick Caulfield ret4->sin_addr.s_addr = in4->sin_addr.s_addr; 4056ed7257bSPatrick Caulfield } else { 40636b71a8bSDavid Teigland struct sockaddr_in6 *in6 = (struct sockaddr_in6 *) &sas; 40736b71a8bSDavid Teigland struct sockaddr_in6 *ret6 = (struct sockaddr_in6 *) sa_out; 4084e3fd7a0SAlexey Dobriyan ret6->sin6_addr = in6->sin6_addr; 4096ed7257bSPatrick Caulfield } 4106ed7257bSPatrick Caulfield 4116f0b0b5dSAlexander Aring srcu_read_unlock(&connections_srcu, idx); 4126ed7257bSPatrick Caulfield return 0; 4136ed7257bSPatrick Caulfield } 4146ed7257bSPatrick Caulfield 415e125fbebSAlexander Aring static int addr_to_nodeid(struct sockaddr_storage *addr, int *nodeid, 416e125fbebSAlexander Aring unsigned int *mark) 41736b71a8bSDavid Teigland { 4186f0b0b5dSAlexander Aring struct connection *con; 4196f0b0b5dSAlexander Aring int i, idx, addr_i; 42036b71a8bSDavid Teigland 4216f0b0b5dSAlexander Aring idx = srcu_read_lock(&connections_srcu); 4226f0b0b5dSAlexander Aring for (i = 0; i < CONN_HASH_SIZE; i++) { 4236f0b0b5dSAlexander Aring hlist_for_each_entry_rcu(con, &connection_hash[i], list) { 4246f0b0b5dSAlexander Aring WARN_ON_ONCE(!con->addr_count); 42536b71a8bSDavid Teigland 4266f0b0b5dSAlexander Aring spin_lock(&con->addrs_lock); 4276f0b0b5dSAlexander Aring for (addr_i = 0; addr_i < con->addr_count; addr_i++) { 4286f0b0b5dSAlexander Aring if (addr_compare(&con->addr[addr_i], addr)) { 4296f0b0b5dSAlexander Aring *nodeid = con->nodeid; 4306f0b0b5dSAlexander Aring *mark = con->mark; 4316f0b0b5dSAlexander Aring spin_unlock(&con->addrs_lock); 4326f0b0b5dSAlexander Aring srcu_read_unlock(&connections_srcu, idx); 4336f0b0b5dSAlexander Aring return 0; 43436b71a8bSDavid Teigland } 43598e1b60eSMike Christie } 4366f0b0b5dSAlexander Aring spin_unlock(&con->addrs_lock); 43798e1b60eSMike Christie } 4386f0b0b5dSAlexander Aring } 4396f0b0b5dSAlexander Aring srcu_read_unlock(&connections_srcu, idx); 4406f0b0b5dSAlexander Aring 4416f0b0b5dSAlexander Aring return -ENOENT; 44236b71a8bSDavid Teigland } 44336b71a8bSDavid Teigland 4446f0b0b5dSAlexander Aring static bool dlm_lowcomms_con_has_addr(const struct connection *con, 4454f19d071SAlexander Aring const struct sockaddr_storage *addr) 4464f19d071SAlexander Aring { 4474f19d071SAlexander Aring int i; 4484f19d071SAlexander Aring 4496f0b0b5dSAlexander Aring for (i = 0; i < con->addr_count; i++) { 4506f0b0b5dSAlexander Aring if (addr_compare(&con->addr[i], addr)) 4514f19d071SAlexander Aring return true; 4524f19d071SAlexander Aring } 4534f19d071SAlexander Aring 4544f19d071SAlexander Aring return false; 4554f19d071SAlexander Aring } 4564f19d071SAlexander Aring 45736b71a8bSDavid Teigland int dlm_lowcomms_addr(int nodeid, struct sockaddr_storage *addr, int len) 45836b71a8bSDavid Teigland { 4596f0b0b5dSAlexander Aring struct connection *con; 4606f0b0b5dSAlexander Aring bool ret, idx; 46136b71a8bSDavid Teigland 4626f0b0b5dSAlexander Aring idx = srcu_read_lock(&connections_srcu); 4636f0b0b5dSAlexander Aring con = nodeid2con(nodeid, GFP_NOFS); 4646f0b0b5dSAlexander Aring if (!con) { 4656f0b0b5dSAlexander Aring srcu_read_unlock(&connections_srcu, idx); 46636b71a8bSDavid Teigland return -ENOMEM; 46736b71a8bSDavid Teigland } 46836b71a8bSDavid Teigland 4696f0b0b5dSAlexander Aring spin_lock(&con->addrs_lock); 4706f0b0b5dSAlexander Aring if (!con->addr_count) { 4716f0b0b5dSAlexander Aring memcpy(&con->addr[0], addr, sizeof(*addr)); 4726f0b0b5dSAlexander Aring con->addr_count = 1; 4736f0b0b5dSAlexander Aring con->mark = dlm_config.ci_mark; 4746f0b0b5dSAlexander Aring spin_unlock(&con->addrs_lock); 4756f0b0b5dSAlexander Aring srcu_read_unlock(&connections_srcu, idx); 47636b71a8bSDavid Teigland return 0; 47736b71a8bSDavid Teigland } 47836b71a8bSDavid Teigland 4796f0b0b5dSAlexander Aring ret = dlm_lowcomms_con_has_addr(con, addr); 4804f19d071SAlexander Aring if (ret) { 4816f0b0b5dSAlexander Aring spin_unlock(&con->addrs_lock); 4826f0b0b5dSAlexander Aring srcu_read_unlock(&connections_srcu, idx); 4834f19d071SAlexander Aring return -EEXIST; 4844f19d071SAlexander Aring } 4854f19d071SAlexander Aring 4866f0b0b5dSAlexander Aring if (con->addr_count >= DLM_MAX_ADDR_COUNT) { 4876f0b0b5dSAlexander Aring spin_unlock(&con->addrs_lock); 4886f0b0b5dSAlexander Aring srcu_read_unlock(&connections_srcu, idx); 48936b71a8bSDavid Teigland return -ENOSPC; 49036b71a8bSDavid Teigland } 49136b71a8bSDavid Teigland 4926f0b0b5dSAlexander Aring memcpy(&con->addr[con->addr_count++], addr, sizeof(*addr)); 4936f0b0b5dSAlexander Aring srcu_read_unlock(&connections_srcu, idx); 4946f0b0b5dSAlexander Aring spin_unlock(&con->addrs_lock); 49536b71a8bSDavid Teigland return 0; 49636b71a8bSDavid Teigland } 49736b71a8bSDavid Teigland 4986ed7257bSPatrick Caulfield /* Data available on socket or listen socket received a connect */ 499676d2369SDavid S. Miller static void lowcomms_data_ready(struct sock *sk) 5006ed7257bSPatrick Caulfield { 501e9dd5fd8SAlexander Aring struct connection *con = sock2con(sk); 50293eaadebStsutomu.owa@toshiba.co.jp 503*40e0b090SPeilin Ye trace_sk_data_ready(sk); 504*40e0b090SPeilin Ye 505dbb751ffSAlexander Aring set_bit(CF_RECV_INTR, &con->flags); 506dbb751ffSAlexander Aring lowcomms_queue_rwork(con); 507d11ccd45SAlexander Aring } 508d11ccd45SAlexander Aring 5096ed7257bSPatrick Caulfield static void lowcomms_write_space(struct sock *sk) 5106ed7257bSPatrick Caulfield { 511e9dd5fd8SAlexander Aring struct connection *con = sock2con(sk); 512b36930ddSDavid Miller 513b36930ddSDavid Miller clear_bit(SOCK_NOSPACE, &con->sock->flags); 514b36930ddSDavid Miller 515dbb751ffSAlexander Aring spin_lock_bh(&con->writequeue_lock); 516b36930ddSDavid Miller if (test_and_clear_bit(CF_APP_LIMITED, &con->flags)) { 517b36930ddSDavid Miller con->sock->sk->sk_write_pending--; 5189cd3e072SEric Dumazet clear_bit(SOCKWQ_ASYNC_NOSPACE, &con->sock->flags); 519b36930ddSDavid Miller } 520b36930ddSDavid Miller 521dbb751ffSAlexander Aring lowcomms_queue_swork(con); 522dbb751ffSAlexander Aring spin_unlock_bh(&con->writequeue_lock); 5236ed7257bSPatrick Caulfield } 5246ed7257bSPatrick Caulfield 5256ed7257bSPatrick Caulfield static void lowcomms_state_change(struct sock *sk) 5266ed7257bSPatrick Caulfield { 527ee44b4bcSMarcelo Ricardo Leitner /* SCTP layer is not calling sk_data_ready when the connection 528dbb751ffSAlexander Aring * is done, so we catch the signal through here. 529ee44b4bcSMarcelo Ricardo Leitner */ 530ee44b4bcSMarcelo Ricardo Leitner if (sk->sk_shutdown == RCV_SHUTDOWN) 531ee44b4bcSMarcelo Ricardo Leitner lowcomms_data_ready(sk); 5326ed7257bSPatrick Caulfield } 533dbb751ffSAlexander Aring 534dbb751ffSAlexander Aring static void lowcomms_listen_data_ready(struct sock *sk) 535dbb751ffSAlexander Aring { 536*40e0b090SPeilin Ye trace_sk_data_ready(sk); 537*40e0b090SPeilin Ye 538dbb751ffSAlexander Aring queue_work(io_workqueue, &listen_con.rwork); 539ee44b4bcSMarcelo Ricardo Leitner } 5406ed7257bSPatrick Caulfield 541391fbdc5SChristine Caulfield int dlm_lowcomms_connect_node(int nodeid) 542391fbdc5SChristine Caulfield { 543391fbdc5SChristine Caulfield struct connection *con; 544b38bc9c2SAlexander Aring int idx; 545391fbdc5SChristine Caulfield 546391fbdc5SChristine Caulfield if (nodeid == dlm_our_nodeid()) 547391fbdc5SChristine Caulfield return 0; 548391fbdc5SChristine Caulfield 549b38bc9c2SAlexander Aring idx = srcu_read_lock(&connections_srcu); 5506f0b0b5dSAlexander Aring con = nodeid2con(nodeid, 0); 5516f0b0b5dSAlexander Aring if (WARN_ON_ONCE(!con)) { 552b38bc9c2SAlexander Aring srcu_read_unlock(&connections_srcu, idx); 5536f0b0b5dSAlexander Aring return -ENOENT; 554b38bc9c2SAlexander Aring } 555b38bc9c2SAlexander Aring 556dbb751ffSAlexander Aring down_read(&con->sock_lock); 557dbb751ffSAlexander Aring if (!con->sock) { 558dbb751ffSAlexander Aring spin_lock_bh(&con->writequeue_lock); 559dbb751ffSAlexander Aring lowcomms_queue_swork(con); 560dbb751ffSAlexander Aring spin_unlock_bh(&con->writequeue_lock); 561dbb751ffSAlexander Aring } 562dbb751ffSAlexander Aring up_read(&con->sock_lock); 563b38bc9c2SAlexander Aring srcu_read_unlock(&connections_srcu, idx); 564b38bc9c2SAlexander Aring 565dbb751ffSAlexander Aring cond_resched(); 566391fbdc5SChristine Caulfield return 0; 567391fbdc5SChristine Caulfield } 568391fbdc5SChristine Caulfield 569e125fbebSAlexander Aring int dlm_lowcomms_nodes_set_mark(int nodeid, unsigned int mark) 570e125fbebSAlexander Aring { 5716f0b0b5dSAlexander Aring struct connection *con; 5726f0b0b5dSAlexander Aring int idx; 573e125fbebSAlexander Aring 5746f0b0b5dSAlexander Aring idx = srcu_read_lock(&connections_srcu); 5756f0b0b5dSAlexander Aring con = nodeid2con(nodeid, 0); 5766f0b0b5dSAlexander Aring if (!con) { 5776f0b0b5dSAlexander Aring srcu_read_unlock(&connections_srcu, idx); 578e125fbebSAlexander Aring return -ENOENT; 579e125fbebSAlexander Aring } 580e125fbebSAlexander Aring 5816f0b0b5dSAlexander Aring spin_lock(&con->addrs_lock); 5826f0b0b5dSAlexander Aring con->mark = mark; 5836f0b0b5dSAlexander Aring spin_unlock(&con->addrs_lock); 5846f0b0b5dSAlexander Aring srcu_read_unlock(&connections_srcu, idx); 585e125fbebSAlexander Aring return 0; 586e125fbebSAlexander Aring } 587e125fbebSAlexander Aring 588b3a5bbfdSBob Peterson static void lowcomms_error_report(struct sock *sk) 589b3a5bbfdSBob Peterson { 590e9dd5fd8SAlexander Aring struct connection *con = sock2con(sk); 5914c3d9057SAlexander Aring struct inet_sock *inet; 592b3a5bbfdSBob Peterson 5934c3d9057SAlexander Aring inet = inet_sk(sk); 5944c3d9057SAlexander Aring switch (sk->sk_family) { 5954c3d9057SAlexander Aring case AF_INET: 596b3a5bbfdSBob Peterson printk_ratelimited(KERN_ERR "dlm: node %d: socket error " 5974c3d9057SAlexander Aring "sending to node %d at %pI4, dport %d, " 598b3a5bbfdSBob Peterson "sk_err=%d/%d\n", dlm_our_nodeid(), 5994c3d9057SAlexander Aring con->nodeid, &inet->inet_daddr, 6004c3d9057SAlexander Aring ntohs(inet->inet_dport), sk->sk_err, 601b3a5bbfdSBob Peterson sk->sk_err_soft); 6024c3d9057SAlexander Aring break; 6031b9beda8SAlexander Aring #if IS_ENABLED(CONFIG_IPV6) 6044c3d9057SAlexander Aring case AF_INET6: 605b3a5bbfdSBob Peterson printk_ratelimited(KERN_ERR "dlm: node %d: socket error " 6064c3d9057SAlexander Aring "sending to node %d at %pI6c, " 6074c3d9057SAlexander Aring "dport %d, sk_err=%d/%d\n", dlm_our_nodeid(), 6084c3d9057SAlexander Aring con->nodeid, &sk->sk_v6_daddr, 6094c3d9057SAlexander Aring ntohs(inet->inet_dport), sk->sk_err, 610b3a5bbfdSBob Peterson sk->sk_err_soft); 6114c3d9057SAlexander Aring break; 6121b9beda8SAlexander Aring #endif 6134c3d9057SAlexander Aring default: 6144c3d9057SAlexander Aring printk_ratelimited(KERN_ERR "dlm: node %d: socket error " 6154c3d9057SAlexander Aring "invalid socket family %d set, " 6164c3d9057SAlexander Aring "sk_err=%d/%d\n", dlm_our_nodeid(), 6174c3d9057SAlexander Aring sk->sk_family, sk->sk_err, sk->sk_err_soft); 618ba868d9dSAlexander Aring break; 619ba868d9dSAlexander Aring } 620ba868d9dSAlexander Aring 621dbb751ffSAlexander Aring dlm_midcomms_unack_msg_resend(con->nodeid); 622ba868d9dSAlexander Aring 623c852a6d7SAlexander Aring listen_sock.sk_error_report(sk); 624b81171cbSBob Peterson } 625b81171cbSBob Peterson 626dbb751ffSAlexander Aring static void restore_callbacks(struct sock *sk) 627b81171cbSBob Peterson { 6287a5e9f1fSAlexander Aring #ifdef CONFIG_LOCKDEP 629dbb751ffSAlexander Aring WARN_ON_ONCE(!lockdep_sock_is_held(sk)); 6307a5e9f1fSAlexander Aring #endif 631cc661fc9SBob Peterson 632b81171cbSBob Peterson sk->sk_user_data = NULL; 633cc661fc9SBob Peterson sk->sk_data_ready = listen_sock.sk_data_ready; 634cc661fc9SBob Peterson sk->sk_state_change = listen_sock.sk_state_change; 635cc661fc9SBob Peterson sk->sk_write_space = listen_sock.sk_write_space; 636cc661fc9SBob Peterson sk->sk_error_report = listen_sock.sk_error_report; 637b3a5bbfdSBob Peterson } 638b3a5bbfdSBob Peterson 6396ed7257bSPatrick Caulfield /* Make a socket active */ 640988419a9Stsutomu.owa@toshiba.co.jp static void add_sock(struct socket *sock, struct connection *con) 6416ed7257bSPatrick Caulfield { 642b81171cbSBob Peterson struct sock *sk = sock->sk; 643b81171cbSBob Peterson 64492c44605SAlexander Aring lock_sock(sk); 6456ed7257bSPatrick Caulfield con->sock = sock; 6466ed7257bSPatrick Caulfield 647b81171cbSBob Peterson sk->sk_user_data = con; 648b81171cbSBob Peterson sk->sk_data_ready = lowcomms_data_ready; 649b81171cbSBob Peterson sk->sk_write_space = lowcomms_write_space; 650dbb751ffSAlexander Aring if (dlm_config.ci_protocol == DLM_PROTO_SCTP) 651b81171cbSBob Peterson sk->sk_state_change = lowcomms_state_change; 652b81171cbSBob Peterson sk->sk_allocation = GFP_NOFS; 65398123866SBenjamin Coddington sk->sk_use_task_frag = false; 654b81171cbSBob Peterson sk->sk_error_report = lowcomms_error_report; 65592c44605SAlexander Aring release_sock(sk); 6566ed7257bSPatrick Caulfield } 6576ed7257bSPatrick Caulfield 6586ed7257bSPatrick Caulfield /* Add the port number to an IPv6 or 4 sockaddr and return the address 6596ed7257bSPatrick Caulfield length */ 6606ed7257bSPatrick Caulfield static void make_sockaddr(struct sockaddr_storage *saddr, uint16_t port, 6616ed7257bSPatrick Caulfield int *addr_len) 6626ed7257bSPatrick Caulfield { 663c51c9cd8SAlexander Aring saddr->ss_family = dlm_local_addr[0].ss_family; 6646ed7257bSPatrick Caulfield if (saddr->ss_family == AF_INET) { 6656ed7257bSPatrick Caulfield struct sockaddr_in *in4_addr = (struct sockaddr_in *)saddr; 6666ed7257bSPatrick Caulfield in4_addr->sin_port = cpu_to_be16(port); 6676ed7257bSPatrick Caulfield *addr_len = sizeof(struct sockaddr_in); 6686ed7257bSPatrick Caulfield memset(&in4_addr->sin_zero, 0, sizeof(in4_addr->sin_zero)); 6696ed7257bSPatrick Caulfield } else { 6706ed7257bSPatrick Caulfield struct sockaddr_in6 *in6_addr = (struct sockaddr_in6 *)saddr; 6716ed7257bSPatrick Caulfield in6_addr->sin6_port = cpu_to_be16(port); 6726ed7257bSPatrick Caulfield *addr_len = sizeof(struct sockaddr_in6); 6736ed7257bSPatrick Caulfield } 67401c8cab2SPatrick Caulfield memset((char *)saddr + *addr_len, 0, sizeof(struct sockaddr_storage) - *addr_len); 6756ed7257bSPatrick Caulfield } 6766ed7257bSPatrick Caulfield 677706474fbSAlexander Aring static void dlm_page_release(struct kref *kref) 678706474fbSAlexander Aring { 679706474fbSAlexander Aring struct writequeue_entry *e = container_of(kref, struct writequeue_entry, 680706474fbSAlexander Aring ref); 681706474fbSAlexander Aring 682706474fbSAlexander Aring __free_page(e->page); 6833af2326cSAlexander Aring dlm_free_writequeue(e); 684706474fbSAlexander Aring } 685706474fbSAlexander Aring 686706474fbSAlexander Aring static void dlm_msg_release(struct kref *kref) 687706474fbSAlexander Aring { 688706474fbSAlexander Aring struct dlm_msg *msg = container_of(kref, struct dlm_msg, ref); 689706474fbSAlexander Aring 690706474fbSAlexander Aring kref_put(&msg->entry->ref, dlm_page_release); 691e4dc81edSAlexander Aring dlm_free_msg(msg); 692706474fbSAlexander Aring } 693706474fbSAlexander Aring 694706474fbSAlexander Aring static void free_entry(struct writequeue_entry *e) 695706474fbSAlexander Aring { 696706474fbSAlexander Aring struct dlm_msg *msg, *tmp; 697706474fbSAlexander Aring 698706474fbSAlexander Aring list_for_each_entry_safe(msg, tmp, &e->msgs, list) { 699706474fbSAlexander Aring if (msg->orig_msg) { 700706474fbSAlexander Aring msg->orig_msg->retransmit = false; 701706474fbSAlexander Aring kref_put(&msg->orig_msg->ref, dlm_msg_release); 702706474fbSAlexander Aring } 703706474fbSAlexander Aring 704706474fbSAlexander Aring list_del(&msg->list); 705706474fbSAlexander Aring kref_put(&msg->ref, dlm_msg_release); 706706474fbSAlexander Aring } 707706474fbSAlexander Aring 708706474fbSAlexander Aring list_del(&e->list); 709706474fbSAlexander Aring kref_put(&e->ref, dlm_page_release); 710706474fbSAlexander Aring } 711706474fbSAlexander Aring 712d11ccd45SAlexander Aring static void dlm_close_sock(struct socket **sock) 713d11ccd45SAlexander Aring { 714dbb751ffSAlexander Aring lock_sock((*sock)->sk); 715dbb751ffSAlexander Aring restore_callbacks((*sock)->sk); 716dbb751ffSAlexander Aring release_sock((*sock)->sk); 717dbb751ffSAlexander Aring 718d11ccd45SAlexander Aring sock_release(*sock); 719d11ccd45SAlexander Aring *sock = NULL; 720d11ccd45SAlexander Aring } 721dbb751ffSAlexander Aring 722dbb751ffSAlexander Aring static void allow_connection_io(struct connection *con) 723dbb751ffSAlexander Aring { 724dbb751ffSAlexander Aring if (con->othercon) 725dbb751ffSAlexander Aring clear_bit(CF_IO_STOP, &con->othercon->flags); 726dbb751ffSAlexander Aring clear_bit(CF_IO_STOP, &con->flags); 727dbb751ffSAlexander Aring } 728dbb751ffSAlexander Aring 729dbb751ffSAlexander Aring static void stop_connection_io(struct connection *con) 730dbb751ffSAlexander Aring { 731dbb751ffSAlexander Aring if (con->othercon) 732dbb751ffSAlexander Aring stop_connection_io(con->othercon); 733dbb751ffSAlexander Aring 734dbb751ffSAlexander Aring down_write(&con->sock_lock); 735dbb751ffSAlexander Aring if (con->sock) { 736dbb751ffSAlexander Aring lock_sock(con->sock->sk); 737dbb751ffSAlexander Aring restore_callbacks(con->sock->sk); 738dbb751ffSAlexander Aring 739dbb751ffSAlexander Aring spin_lock_bh(&con->writequeue_lock); 740dbb751ffSAlexander Aring set_bit(CF_IO_STOP, &con->flags); 741dbb751ffSAlexander Aring spin_unlock_bh(&con->writequeue_lock); 742dbb751ffSAlexander Aring release_sock(con->sock->sk); 743dbb751ffSAlexander Aring } else { 744dbb751ffSAlexander Aring spin_lock_bh(&con->writequeue_lock); 745dbb751ffSAlexander Aring set_bit(CF_IO_STOP, &con->flags); 746dbb751ffSAlexander Aring spin_unlock_bh(&con->writequeue_lock); 747dbb751ffSAlexander Aring } 748dbb751ffSAlexander Aring up_write(&con->sock_lock); 749dbb751ffSAlexander Aring 750dbb751ffSAlexander Aring cancel_work_sync(&con->swork); 751dbb751ffSAlexander Aring cancel_work_sync(&con->rwork); 752d11ccd45SAlexander Aring } 753d11ccd45SAlexander Aring 7546ed7257bSPatrick Caulfield /* Close a remote connection and tidy up */ 755dbb751ffSAlexander Aring static void close_connection(struct connection *con, bool and_other) 7566ed7257bSPatrick Caulfield { 757706474fbSAlexander Aring struct writequeue_entry *e; 758b2a66629Stsutomu.owa@toshiba.co.jp 759dbb751ffSAlexander Aring if (con->othercon && and_other) 760dbb751ffSAlexander Aring close_connection(con->othercon, false); 761dbb751ffSAlexander Aring 762dbb751ffSAlexander Aring down_write(&con->sock_lock); 763dbb751ffSAlexander Aring if (!con->sock) { 764dbb751ffSAlexander Aring up_write(&con->sock_lock); 765dbb751ffSAlexander Aring return; 7660aa18464Stsutomu.owa@toshiba.co.jp } 7676ed7257bSPatrick Caulfield 768d11ccd45SAlexander Aring dlm_close_sock(&con->sock); 769d11ccd45SAlexander Aring 770706474fbSAlexander Aring /* if we send a writequeue entry only a half way, we drop the 771706474fbSAlexander Aring * whole entry because reconnection and that we not start of the 772706474fbSAlexander Aring * middle of a msg which will confuse the other end. 773706474fbSAlexander Aring * 774706474fbSAlexander Aring * we can always drop messages because retransmits, but what we 775706474fbSAlexander Aring * cannot allow is to transmit half messages which may be processed 776706474fbSAlexander Aring * at the other side. 777706474fbSAlexander Aring * 778706474fbSAlexander Aring * our policy is to start on a clean state when disconnects, we don't 779706474fbSAlexander Aring * know what's send/received on transport layer in this case. 780706474fbSAlexander Aring */ 781dbb751ffSAlexander Aring spin_lock_bh(&con->writequeue_lock); 782706474fbSAlexander Aring if (!list_empty(&con->writequeue)) { 783706474fbSAlexander Aring e = list_first_entry(&con->writequeue, struct writequeue_entry, 784706474fbSAlexander Aring list); 785706474fbSAlexander Aring if (e->dirty) 786706474fbSAlexander Aring free_entry(e); 787706474fbSAlexander Aring } 788dbb751ffSAlexander Aring spin_unlock_bh(&con->writequeue_lock); 789706474fbSAlexander Aring 7904798cbbfSAlexander Aring con->rx_leftover = 0; 7916ed7257bSPatrick Caulfield con->retries = 0; 792052849beSAlexander Aring clear_bit(CF_APP_LIMITED, &con->flags); 793dbb751ffSAlexander Aring clear_bit(CF_RECV_PENDING, &con->flags); 794dbb751ffSAlexander Aring clear_bit(CF_SEND_PENDING, &con->flags); 795dbb751ffSAlexander Aring up_write(&con->sock_lock); 7966ed7257bSPatrick Caulfield } 7976ed7257bSPatrick Caulfield 798dbb751ffSAlexander Aring static struct processqueue_entry *new_processqueue_entry(int nodeid, 799dbb751ffSAlexander Aring int buflen) 8004798cbbfSAlexander Aring { 801dbb751ffSAlexander Aring struct processqueue_entry *pentry; 8024798cbbfSAlexander Aring 803dbb751ffSAlexander Aring pentry = kmalloc(sizeof(*pentry), GFP_NOFS); 804dbb751ffSAlexander Aring if (!pentry) 805dbb751ffSAlexander Aring return NULL; 8064798cbbfSAlexander Aring 807dbb751ffSAlexander Aring pentry->buf = kmalloc(buflen, GFP_NOFS); 808dbb751ffSAlexander Aring if (!pentry->buf) { 809dbb751ffSAlexander Aring kfree(pentry); 810dbb751ffSAlexander Aring return NULL; 811dbb751ffSAlexander Aring } 8124798cbbfSAlexander Aring 813dbb751ffSAlexander Aring pentry->nodeid = nodeid; 814dbb751ffSAlexander Aring return pentry; 815dbb751ffSAlexander Aring } 8164798cbbfSAlexander Aring 817dbb751ffSAlexander Aring static void free_processqueue_entry(struct processqueue_entry *pentry) 818dbb751ffSAlexander Aring { 819dbb751ffSAlexander Aring kfree(pentry->buf); 820dbb751ffSAlexander Aring kfree(pentry); 821dbb751ffSAlexander Aring } 822dbb751ffSAlexander Aring 823dbb751ffSAlexander Aring struct dlm_processed_nodes { 824dbb751ffSAlexander Aring int nodeid; 825dbb751ffSAlexander Aring 826dbb751ffSAlexander Aring struct list_head list; 827dbb751ffSAlexander Aring }; 828dbb751ffSAlexander Aring 829dbb751ffSAlexander Aring static void add_processed_node(int nodeid, struct list_head *processed_nodes) 830dbb751ffSAlexander Aring { 831dbb751ffSAlexander Aring struct dlm_processed_nodes *n; 832dbb751ffSAlexander Aring 833dbb751ffSAlexander Aring list_for_each_entry(n, processed_nodes, list) { 834dbb751ffSAlexander Aring /* we already remembered this node */ 835dbb751ffSAlexander Aring if (n->nodeid == nodeid) 836dbb751ffSAlexander Aring return; 837dbb751ffSAlexander Aring } 838dbb751ffSAlexander Aring 839dbb751ffSAlexander Aring /* if it's fails in worst case we simple don't send an ack back. 840dbb751ffSAlexander Aring * We try it next time. 841dbb751ffSAlexander Aring */ 842dbb751ffSAlexander Aring n = kmalloc(sizeof(*n), GFP_NOFS); 843dbb751ffSAlexander Aring if (!n) 844dbb751ffSAlexander Aring return; 845dbb751ffSAlexander Aring 846dbb751ffSAlexander Aring n->nodeid = nodeid; 847dbb751ffSAlexander Aring list_add(&n->list, processed_nodes); 848dbb751ffSAlexander Aring } 849dbb751ffSAlexander Aring 850dbb751ffSAlexander Aring static void process_dlm_messages(struct work_struct *work) 851dbb751ffSAlexander Aring { 852dbb751ffSAlexander Aring struct dlm_processed_nodes *n, *n_tmp; 853dbb751ffSAlexander Aring struct processqueue_entry *pentry; 854dbb751ffSAlexander Aring LIST_HEAD(processed_nodes); 855dbb751ffSAlexander Aring 856dbb751ffSAlexander Aring spin_lock(&processqueue_lock); 857dbb751ffSAlexander Aring pentry = list_first_entry_or_null(&processqueue, 858dbb751ffSAlexander Aring struct processqueue_entry, list); 859dbb751ffSAlexander Aring if (WARN_ON_ONCE(!pentry)) { 860dbb751ffSAlexander Aring spin_unlock(&processqueue_lock); 861dbb751ffSAlexander Aring return; 862dbb751ffSAlexander Aring } 863dbb751ffSAlexander Aring 864dbb751ffSAlexander Aring list_del(&pentry->list); 865dbb751ffSAlexander Aring spin_unlock(&processqueue_lock); 866dbb751ffSAlexander Aring 867dbb751ffSAlexander Aring for (;;) { 868dbb751ffSAlexander Aring dlm_process_incoming_buffer(pentry->nodeid, pentry->buf, 869dbb751ffSAlexander Aring pentry->buflen); 870dbb751ffSAlexander Aring add_processed_node(pentry->nodeid, &processed_nodes); 871dbb751ffSAlexander Aring free_processqueue_entry(pentry); 872dbb751ffSAlexander Aring 873dbb751ffSAlexander Aring spin_lock(&processqueue_lock); 874dbb751ffSAlexander Aring pentry = list_first_entry_or_null(&processqueue, 875dbb751ffSAlexander Aring struct processqueue_entry, list); 876dbb751ffSAlexander Aring if (!pentry) { 877dbb751ffSAlexander Aring process_dlm_messages_pending = false; 878dbb751ffSAlexander Aring spin_unlock(&processqueue_lock); 879dbb751ffSAlexander Aring break; 880dbb751ffSAlexander Aring } 881dbb751ffSAlexander Aring 882dbb751ffSAlexander Aring list_del(&pentry->list); 883dbb751ffSAlexander Aring spin_unlock(&processqueue_lock); 884dbb751ffSAlexander Aring } 885dbb751ffSAlexander Aring 886dbb751ffSAlexander Aring /* send ack back after we processed couple of messages */ 887dbb751ffSAlexander Aring list_for_each_entry_safe(n, n_tmp, &processed_nodes, list) { 888dbb751ffSAlexander Aring list_del(&n->list); 889dbb751ffSAlexander Aring dlm_midcomms_receive_done(n->nodeid); 890dbb751ffSAlexander Aring kfree(n); 891dbb751ffSAlexander Aring } 8924798cbbfSAlexander Aring } 8934798cbbfSAlexander Aring 8946ed7257bSPatrick Caulfield /* Data received from remote end */ 895dbb751ffSAlexander Aring static int receive_from_sock(struct connection *con, int buflen) 8966ed7257bSPatrick Caulfield { 897dbb751ffSAlexander Aring struct processqueue_entry *pentry; 898dbb751ffSAlexander Aring int ret, buflen_real; 8994798cbbfSAlexander Aring struct msghdr msg; 9004798cbbfSAlexander Aring struct kvec iov; 9016ed7257bSPatrick Caulfield 902dbb751ffSAlexander Aring pentry = new_processqueue_entry(con->nodeid, buflen); 903dbb751ffSAlexander Aring if (!pentry) 904dbb751ffSAlexander Aring return DLM_IO_RESCHED; 9056ed7257bSPatrick Caulfield 906dbb751ffSAlexander Aring memcpy(pentry->buf, con->rx_leftover_buf, con->rx_leftover); 9074798cbbfSAlexander Aring 9084798cbbfSAlexander Aring /* calculate new buffer parameter regarding last receive and 9094798cbbfSAlexander Aring * possible leftover bytes 9106ed7257bSPatrick Caulfield */ 911dbb751ffSAlexander Aring iov.iov_base = pentry->buf + con->rx_leftover; 912dbb751ffSAlexander Aring iov.iov_len = buflen - con->rx_leftover; 9136ed7257bSPatrick Caulfield 9144798cbbfSAlexander Aring memset(&msg, 0, sizeof(msg)); 9154798cbbfSAlexander Aring msg.msg_flags = MSG_DONTWAIT | MSG_NOSIGNAL; 916dbb751ffSAlexander Aring clear_bit(CF_RECV_INTR, &con->flags); 917dbb751ffSAlexander Aring again: 9184798cbbfSAlexander Aring ret = kernel_recvmsg(con->sock, &msg, &iov, 1, iov.iov_len, 9194798cbbfSAlexander Aring msg.msg_flags); 92092732376SAlexander Aring trace_dlm_recv(con->nodeid, ret); 921dbb751ffSAlexander Aring if (ret == -EAGAIN) { 922dbb751ffSAlexander Aring lock_sock(con->sock->sk); 923dbb751ffSAlexander Aring if (test_and_clear_bit(CF_RECV_INTR, &con->flags)) { 924dbb751ffSAlexander Aring release_sock(con->sock->sk); 925dbb751ffSAlexander Aring goto again; 926dbb751ffSAlexander Aring } 927dbb751ffSAlexander Aring 928dbb751ffSAlexander Aring clear_bit(CF_RECV_PENDING, &con->flags); 929dbb751ffSAlexander Aring release_sock(con->sock->sk); 930dbb751ffSAlexander Aring free_processqueue_entry(pentry); 931dbb751ffSAlexander Aring return DLM_IO_END; 932dbb751ffSAlexander Aring } else if (ret == 0) { 933dbb751ffSAlexander Aring /* close will clear CF_RECV_PENDING */ 934dbb751ffSAlexander Aring free_processqueue_entry(pentry); 935dbb751ffSAlexander Aring return DLM_IO_EOF; 936dbb751ffSAlexander Aring } else if (ret < 0) { 937dbb751ffSAlexander Aring free_processqueue_entry(pentry); 938dbb751ffSAlexander Aring return ret; 939dbb751ffSAlexander Aring } 9406ed7257bSPatrick Caulfield 9414798cbbfSAlexander Aring /* new buflen according readed bytes and leftover from last receive */ 942dbb751ffSAlexander Aring buflen_real = ret + con->rx_leftover; 943dbb751ffSAlexander Aring ret = dlm_validate_incoming_buffer(con->nodeid, pentry->buf, 944dbb751ffSAlexander Aring buflen_real); 945dbb751ffSAlexander Aring if (ret < 0) { 946dbb751ffSAlexander Aring free_processqueue_entry(pentry); 947dbb751ffSAlexander Aring return ret; 948dbb751ffSAlexander Aring } 949dbb751ffSAlexander Aring 950dbb751ffSAlexander Aring pentry->buflen = ret; 9516ed7257bSPatrick Caulfield 9524798cbbfSAlexander Aring /* calculate leftover bytes from process and put it into begin of 9534798cbbfSAlexander Aring * the receive buffer, so next receive we have the full message 9544798cbbfSAlexander Aring * at the start address of the receive buffer. 9554798cbbfSAlexander Aring */ 956dbb751ffSAlexander Aring con->rx_leftover = buflen_real - ret; 957dbb751ffSAlexander Aring memmove(con->rx_leftover_buf, pentry->buf + ret, 9584798cbbfSAlexander Aring con->rx_leftover); 959dbb751ffSAlexander Aring 960dbb751ffSAlexander Aring spin_lock(&processqueue_lock); 961dbb751ffSAlexander Aring list_add_tail(&pentry->list, &processqueue); 962dbb751ffSAlexander Aring if (!process_dlm_messages_pending) { 963dbb751ffSAlexander Aring process_dlm_messages_pending = true; 964dbb751ffSAlexander Aring queue_work(process_workqueue, &process_work); 9656ed7257bSPatrick Caulfield } 966dbb751ffSAlexander Aring spin_unlock(&processqueue_lock); 9674798cbbfSAlexander Aring 968dbb751ffSAlexander Aring return DLM_IO_SUCCESS; 9696ed7257bSPatrick Caulfield } 9706ed7257bSPatrick Caulfield 9716ed7257bSPatrick Caulfield /* Listening socket is busy, accept a connection */ 972dbb751ffSAlexander Aring static int accept_from_sock(void) 9736ed7257bSPatrick Caulfield { 9746ed7257bSPatrick Caulfield struct sockaddr_storage peeraddr; 975dbb751ffSAlexander Aring int len, idx, result, nodeid; 9766ed7257bSPatrick Caulfield struct connection *newcon; 977dbb751ffSAlexander Aring struct socket *newsock; 9783f78cd7dSAlexander Aring unsigned int mark; 9796ed7257bSPatrick Caulfield 980dbb751ffSAlexander Aring result = kernel_accept(listen_con.sock, &newsock, O_NONBLOCK); 981dbb751ffSAlexander Aring if (result == -EAGAIN) 982dbb751ffSAlexander Aring return DLM_IO_END; 983dbb751ffSAlexander Aring else if (result < 0) 9846ed7257bSPatrick Caulfield goto accept_err; 9856ed7257bSPatrick Caulfield 9866ed7257bSPatrick Caulfield /* Get the connected socket's peer */ 9876ed7257bSPatrick Caulfield memset(&peeraddr, 0, sizeof(peeraddr)); 9889b2c45d4SDenys Vlasenko len = newsock->ops->getname(newsock, (struct sockaddr *)&peeraddr, 2); 9899b2c45d4SDenys Vlasenko if (len < 0) { 9906ed7257bSPatrick Caulfield result = -ECONNABORTED; 9916ed7257bSPatrick Caulfield goto accept_err; 9926ed7257bSPatrick Caulfield } 9936ed7257bSPatrick Caulfield 9946ed7257bSPatrick Caulfield /* Get the new node's NODEID */ 9956ed7257bSPatrick Caulfield make_sockaddr(&peeraddr, 0, &len); 996e125fbebSAlexander Aring if (addr_to_nodeid(&peeraddr, &nodeid, &mark)) { 997feae43f8SAlexander Aring switch (peeraddr.ss_family) { 998feae43f8SAlexander Aring case AF_INET: { 999feae43f8SAlexander Aring struct sockaddr_in *sin = (struct sockaddr_in *)&peeraddr; 1000feae43f8SAlexander Aring 1001feae43f8SAlexander Aring log_print("connect from non cluster IPv4 node %pI4", 1002feae43f8SAlexander Aring &sin->sin_addr); 1003feae43f8SAlexander Aring break; 1004feae43f8SAlexander Aring } 1005feae43f8SAlexander Aring #if IS_ENABLED(CONFIG_IPV6) 1006feae43f8SAlexander Aring case AF_INET6: { 1007feae43f8SAlexander Aring struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)&peeraddr; 1008feae43f8SAlexander Aring 1009feae43f8SAlexander Aring log_print("connect from non cluster IPv6 node %pI6c", 1010feae43f8SAlexander Aring &sin6->sin6_addr); 1011feae43f8SAlexander Aring break; 1012feae43f8SAlexander Aring } 1013feae43f8SAlexander Aring #endif 1014feae43f8SAlexander Aring default: 1015feae43f8SAlexander Aring log_print("invalid family from non cluster node"); 1016feae43f8SAlexander Aring break; 1017feae43f8SAlexander Aring } 1018feae43f8SAlexander Aring 10196ed7257bSPatrick Caulfield sock_release(newsock); 10206ed7257bSPatrick Caulfield return -1; 10216ed7257bSPatrick Caulfield } 10226ed7257bSPatrick Caulfield 10236ed7257bSPatrick Caulfield log_print("got connection from %d", nodeid); 10246ed7257bSPatrick Caulfield 10256ed7257bSPatrick Caulfield /* Check to see if we already have a connection to this node. This 10266ed7257bSPatrick Caulfield * could happen if the two nodes initiate a connection at roughly 10276ed7257bSPatrick Caulfield * the same time and the connections cross on the wire. 10286ed7257bSPatrick Caulfield * In this case we store the incoming one in "othercon" 10296ed7257bSPatrick Caulfield */ 1030b38bc9c2SAlexander Aring idx = srcu_read_lock(&connections_srcu); 10316f0b0b5dSAlexander Aring newcon = nodeid2con(nodeid, 0); 10326f0b0b5dSAlexander Aring if (WARN_ON_ONCE(!newcon)) { 1033b38bc9c2SAlexander Aring srcu_read_unlock(&connections_srcu, idx); 10346f0b0b5dSAlexander Aring result = -ENOENT; 10356ed7257bSPatrick Caulfield goto accept_err; 10366ed7257bSPatrick Caulfield } 1037d11ccd45SAlexander Aring 1038e125fbebSAlexander Aring sock_set_mark(newsock->sk, mark); 1039e125fbebSAlexander Aring 1040dbb751ffSAlexander Aring down_write(&newcon->sock_lock); 10416ed7257bSPatrick Caulfield if (newcon->sock) { 10426ed7257bSPatrick Caulfield struct connection *othercon = newcon->othercon; 10436ed7257bSPatrick Caulfield 10446ed7257bSPatrick Caulfield if (!othercon) { 1045a47666ebSAlexander Aring othercon = kzalloc(sizeof(*othercon), GFP_NOFS); 10466ed7257bSPatrick Caulfield if (!othercon) { 1047617e82e1SDavid Teigland log_print("failed to allocate incoming socket"); 1048dbb751ffSAlexander Aring up_write(&newcon->sock_lock); 1049b38bc9c2SAlexander Aring srcu_read_unlock(&connections_srcu, idx); 10506ed7257bSPatrick Caulfield result = -ENOMEM; 10516ed7257bSPatrick Caulfield goto accept_err; 10526ed7257bSPatrick Caulfield } 10534798cbbfSAlexander Aring 1054dbb751ffSAlexander Aring dlm_con_init(othercon, nodeid); 1055dbb751ffSAlexander Aring lockdep_set_subclass(&othercon->sock_lock, 1); 10566cde210aSAlexander Aring newcon->othercon = othercon; 1057dbb751ffSAlexander Aring set_bit(CF_IS_OTHERCON, &othercon->flags); 1058ba3ab3caSAlexander Aring } else { 1059ba3ab3caSAlexander Aring /* close other sock con if we have something new */ 1060dbb751ffSAlexander Aring close_connection(othercon, false); 106161d96be0SPatrick Caulfield } 1062ba3ab3caSAlexander Aring 1063dbb751ffSAlexander Aring down_write(&othercon->sock_lock); 1064988419a9Stsutomu.owa@toshiba.co.jp add_sock(newsock, othercon); 1065dbb751ffSAlexander Aring 1066dbb751ffSAlexander Aring /* check if we receved something while adding */ 1067dbb751ffSAlexander Aring lock_sock(othercon->sock->sk); 1068dbb751ffSAlexander Aring lowcomms_queue_rwork(othercon); 1069dbb751ffSAlexander Aring release_sock(othercon->sock->sk); 1070dbb751ffSAlexander Aring up_write(&othercon->sock_lock); 10716ed7257bSPatrick Caulfield } 10726ed7257bSPatrick Caulfield else { 10733735b4b9SBob Peterson /* accept copies the sk after we've saved the callbacks, so we 10743735b4b9SBob Peterson don't want to save them a second time or comm errors will 10753735b4b9SBob Peterson result in calling sk_error_report recursively. */ 1076988419a9Stsutomu.owa@toshiba.co.jp add_sock(newsock, newcon); 1077dbb751ffSAlexander Aring 1078dbb751ffSAlexander Aring /* check if we receved something while adding */ 1079dbb751ffSAlexander Aring lock_sock(newcon->sock->sk); 1080dbb751ffSAlexander Aring lowcomms_queue_rwork(newcon); 1081dbb751ffSAlexander Aring release_sock(newcon->sock->sk); 10826ed7257bSPatrick Caulfield } 1083dbb751ffSAlexander Aring up_write(&newcon->sock_lock); 1084b38bc9c2SAlexander Aring srcu_read_unlock(&connections_srcu, idx); 1085b38bc9c2SAlexander Aring 1086dbb751ffSAlexander Aring return DLM_IO_SUCCESS; 10876ed7257bSPatrick Caulfield 10886ed7257bSPatrick Caulfield accept_err: 10893421fb15Stsutomu.owa@toshiba.co.jp if (newsock) 10906ed7257bSPatrick Caulfield sock_release(newsock); 10916ed7257bSPatrick Caulfield 10926ed7257bSPatrick Caulfield return result; 10936ed7257bSPatrick Caulfield } 10946ed7257bSPatrick Caulfield 10955d689871SMike Christie /* 10965d689871SMike Christie * writequeue_entry_complete - try to delete and free write queue entry 10975d689871SMike Christie * @e: write queue entry to try to delete 10985d689871SMike Christie * @completed: bytes completed 10995d689871SMike Christie * 11005d689871SMike Christie * writequeue_lock must be held. 11015d689871SMike Christie */ 11025d689871SMike Christie static void writequeue_entry_complete(struct writequeue_entry *e, int completed) 11035d689871SMike Christie { 11045d689871SMike Christie e->offset += completed; 11055d689871SMike Christie e->len -= completed; 1106706474fbSAlexander Aring /* signal that page was half way transmitted */ 1107706474fbSAlexander Aring e->dirty = true; 11085d689871SMike Christie 11098f2dc78dSAlexander Aring if (e->len == 0 && e->users == 0) 11105d689871SMike Christie free_entry(e); 11115d689871SMike Christie } 11125d689871SMike Christie 1113ee44b4bcSMarcelo Ricardo Leitner /* 1114ee44b4bcSMarcelo Ricardo Leitner * sctp_bind_addrs - bind a SCTP socket to all our addresses 1115ee44b4bcSMarcelo Ricardo Leitner */ 111613004e8aSAlexander Aring static int sctp_bind_addrs(struct socket *sock, uint16_t port) 1117ee44b4bcSMarcelo Ricardo Leitner { 1118ee44b4bcSMarcelo Ricardo Leitner struct sockaddr_storage localaddr; 1119c0425a42SChristoph Hellwig struct sockaddr *addr = (struct sockaddr *)&localaddr; 1120ee44b4bcSMarcelo Ricardo Leitner int i, addr_len, result = 0; 1121ee44b4bcSMarcelo Ricardo Leitner 1122ee44b4bcSMarcelo Ricardo Leitner for (i = 0; i < dlm_local_count; i++) { 1123c51c9cd8SAlexander Aring memcpy(&localaddr, &dlm_local_addr[i], sizeof(localaddr)); 1124ee44b4bcSMarcelo Ricardo Leitner make_sockaddr(&localaddr, port, &addr_len); 1125ee44b4bcSMarcelo Ricardo Leitner 1126ee44b4bcSMarcelo Ricardo Leitner if (!i) 112713004e8aSAlexander Aring result = kernel_bind(sock, addr, addr_len); 1128ee44b4bcSMarcelo Ricardo Leitner else 112913004e8aSAlexander Aring result = sock_bind_add(sock->sk, addr, addr_len); 1130ee44b4bcSMarcelo Ricardo Leitner 1131ee44b4bcSMarcelo Ricardo Leitner if (result < 0) { 1132ee44b4bcSMarcelo Ricardo Leitner log_print("Can't bind to %d addr number %d, %d.\n", 1133ee44b4bcSMarcelo Ricardo Leitner port, i + 1, result); 1134ee44b4bcSMarcelo Ricardo Leitner break; 1135ee44b4bcSMarcelo Ricardo Leitner } 1136ee44b4bcSMarcelo Ricardo Leitner } 1137ee44b4bcSMarcelo Ricardo Leitner return result; 1138ee44b4bcSMarcelo Ricardo Leitner } 1139ee44b4bcSMarcelo Ricardo Leitner 11406ed7257bSPatrick Caulfield /* Get local addresses */ 11416ed7257bSPatrick Caulfield static void init_local(void) 11426ed7257bSPatrick Caulfield { 1143c51c9cd8SAlexander Aring struct sockaddr_storage sas; 11446ed7257bSPatrick Caulfield int i; 11456ed7257bSPatrick Caulfield 114630d3a237SPatrick Caulfield dlm_local_count = 0; 11471b189b88SDavid Teigland for (i = 0; i < DLM_MAX_ADDR_COUNT; i++) { 11486ed7257bSPatrick Caulfield if (dlm_our_addr(&sas, i)) 11496ed7257bSPatrick Caulfield break; 11506ed7257bSPatrick Caulfield 1151c51c9cd8SAlexander Aring memcpy(&dlm_local_addr[dlm_local_count++], &sas, sizeof(sas)); 11526ed7257bSPatrick Caulfield } 11536ed7257bSPatrick Caulfield } 11546ed7257bSPatrick Caulfield 1155be3b0400SAlexander Aring static struct writequeue_entry *new_writequeue_entry(struct connection *con) 11566ed7257bSPatrick Caulfield { 11576ed7257bSPatrick Caulfield struct writequeue_entry *entry; 11586ed7257bSPatrick Caulfield 11593af2326cSAlexander Aring entry = dlm_allocate_writequeue(); 11606ed7257bSPatrick Caulfield if (!entry) 11616ed7257bSPatrick Caulfield return NULL; 11626ed7257bSPatrick Caulfield 1163be3b0400SAlexander Aring entry->page = alloc_page(GFP_ATOMIC | __GFP_ZERO); 11646ed7257bSPatrick Caulfield if (!entry->page) { 11653af2326cSAlexander Aring dlm_free_writequeue(entry); 11666ed7257bSPatrick Caulfield return NULL; 11676ed7257bSPatrick Caulfield } 11686ed7257bSPatrick Caulfield 11693af2326cSAlexander Aring entry->offset = 0; 11703af2326cSAlexander Aring entry->len = 0; 11713af2326cSAlexander Aring entry->end = 0; 11723af2326cSAlexander Aring entry->dirty = false; 11736ed7257bSPatrick Caulfield entry->con = con; 1174f0747ebfSAlexander Aring entry->users = 1; 11758f2dc78dSAlexander Aring kref_init(&entry->ref); 11766ed7257bSPatrick Caulfield return entry; 11776ed7257bSPatrick Caulfield } 11786ed7257bSPatrick Caulfield 1179f0747ebfSAlexander Aring static struct writequeue_entry *new_wq_entry(struct connection *con, int len, 1180be3b0400SAlexander Aring char **ppc, void (*cb)(void *data), 1181be3b0400SAlexander Aring void *data) 1182f0747ebfSAlexander Aring { 1183f0747ebfSAlexander Aring struct writequeue_entry *e; 1184f0747ebfSAlexander Aring 1185dbb751ffSAlexander Aring spin_lock_bh(&con->writequeue_lock); 1186f0747ebfSAlexander Aring if (!list_empty(&con->writequeue)) { 1187f0747ebfSAlexander Aring e = list_last_entry(&con->writequeue, struct writequeue_entry, list); 1188f0747ebfSAlexander Aring if (DLM_WQ_REMAIN_BYTES(e) >= len) { 11898f2dc78dSAlexander Aring kref_get(&e->ref); 11908f2dc78dSAlexander Aring 1191f0747ebfSAlexander Aring *ppc = page_address(e->page) + e->end; 11928f2dc78dSAlexander Aring if (cb) 11935c16febbSAlexander Aring cb(data); 11948f2dc78dSAlexander Aring 1195f0747ebfSAlexander Aring e->end += len; 1196f0747ebfSAlexander Aring e->users++; 1197be3b0400SAlexander Aring goto out; 1198f0747ebfSAlexander Aring } 1199f0747ebfSAlexander Aring } 1200f0747ebfSAlexander Aring 1201be3b0400SAlexander Aring e = new_writequeue_entry(con); 1202f0747ebfSAlexander Aring if (!e) 1203be3b0400SAlexander Aring goto out; 1204f0747ebfSAlexander Aring 12058f2dc78dSAlexander Aring kref_get(&e->ref); 1206f0747ebfSAlexander Aring *ppc = page_address(e->page); 1207f0747ebfSAlexander Aring e->end += len; 12088f2dc78dSAlexander Aring if (cb) 12095c16febbSAlexander Aring cb(data); 12108f2dc78dSAlexander Aring 1211f0747ebfSAlexander Aring list_add_tail(&e->list, &con->writequeue); 1212f0747ebfSAlexander Aring 1213be3b0400SAlexander Aring out: 1214dbb751ffSAlexander Aring spin_unlock_bh(&con->writequeue_lock); 1215f0747ebfSAlexander Aring return e; 1216f0747ebfSAlexander Aring }; 1217f0747ebfSAlexander Aring 12182874d1a6SAlexander Aring static struct dlm_msg *dlm_lowcomms_new_msg_con(struct connection *con, int len, 12192874d1a6SAlexander Aring gfp_t allocation, char **ppc, 12205c16febbSAlexander Aring void (*cb)(void *data), 12215c16febbSAlexander Aring void *data) 12222874d1a6SAlexander Aring { 12232874d1a6SAlexander Aring struct writequeue_entry *e; 12242874d1a6SAlexander Aring struct dlm_msg *msg; 12252874d1a6SAlexander Aring 1226e4dc81edSAlexander Aring msg = dlm_allocate_msg(allocation); 12272874d1a6SAlexander Aring if (!msg) 12282874d1a6SAlexander Aring return NULL; 12292874d1a6SAlexander Aring 12302874d1a6SAlexander Aring kref_init(&msg->ref); 12312874d1a6SAlexander Aring 1232be3b0400SAlexander Aring e = new_wq_entry(con, len, ppc, cb, data); 12332874d1a6SAlexander Aring if (!e) { 1234e4dc81edSAlexander Aring dlm_free_msg(msg); 12352874d1a6SAlexander Aring return NULL; 12362874d1a6SAlexander Aring } 12372874d1a6SAlexander Aring 1238e4dc81edSAlexander Aring msg->retransmit = false; 1239e4dc81edSAlexander Aring msg->orig_msg = NULL; 12402874d1a6SAlexander Aring msg->ppc = *ppc; 12412874d1a6SAlexander Aring msg->len = len; 12422874d1a6SAlexander Aring msg->entry = e; 12432874d1a6SAlexander Aring 12442874d1a6SAlexander Aring return msg; 12452874d1a6SAlexander Aring } 12462874d1a6SAlexander Aring 1247a8449f23SAlexander Aring /* avoid false positive for nodes_srcu, unlock happens in 1248a8449f23SAlexander Aring * dlm_lowcomms_commit_msg which is a must call if success 1249a8449f23SAlexander Aring */ 1250a8449f23SAlexander Aring #ifndef __CHECKER__ 12518f2dc78dSAlexander Aring struct dlm_msg *dlm_lowcomms_new_msg(int nodeid, int len, gfp_t allocation, 12525c16febbSAlexander Aring char **ppc, void (*cb)(void *data), 12535c16febbSAlexander Aring void *data) 12546ed7257bSPatrick Caulfield { 12556ed7257bSPatrick Caulfield struct connection *con; 12568f2dc78dSAlexander Aring struct dlm_msg *msg; 1257b38bc9c2SAlexander Aring int idx; 12586ed7257bSPatrick Caulfield 1259d10a0b88SAlexander Aring if (len > DLM_MAX_SOCKET_BUFSIZE || 1260c45674fbSAlexander Aring len < sizeof(struct dlm_header)) { 1261d10a0b88SAlexander Aring BUILD_BUG_ON(PAGE_SIZE < DLM_MAX_SOCKET_BUFSIZE); 1262692f51c8SAlexander Aring log_print("failed to allocate a buffer of size %d", len); 1263dbb751ffSAlexander Aring WARN_ON_ONCE(1); 1264692f51c8SAlexander Aring return NULL; 1265692f51c8SAlexander Aring } 1266692f51c8SAlexander Aring 1267b38bc9c2SAlexander Aring idx = srcu_read_lock(&connections_srcu); 12686f0b0b5dSAlexander Aring con = nodeid2con(nodeid, 0); 12696f0b0b5dSAlexander Aring if (WARN_ON_ONCE(!con)) { 1270b38bc9c2SAlexander Aring srcu_read_unlock(&connections_srcu, idx); 12716ed7257bSPatrick Caulfield return NULL; 1272b38bc9c2SAlexander Aring } 12736ed7257bSPatrick Caulfield 12745c16febbSAlexander Aring msg = dlm_lowcomms_new_msg_con(con, len, allocation, ppc, cb, data); 12758f2dc78dSAlexander Aring if (!msg) { 1276b38bc9c2SAlexander Aring srcu_read_unlock(&connections_srcu, idx); 1277b38bc9c2SAlexander Aring return NULL; 1278b38bc9c2SAlexander Aring } 1279b38bc9c2SAlexander Aring 128030ea3257SAlexander Aring /* for dlm_lowcomms_commit_msg() */ 128130ea3257SAlexander Aring kref_get(&msg->ref); 12828f2dc78dSAlexander Aring /* we assume if successful commit must called */ 12838f2dc78dSAlexander Aring msg->idx = idx; 12848f2dc78dSAlexander Aring return msg; 12858f2dc78dSAlexander Aring } 1286a8449f23SAlexander Aring #endif 12878f2dc78dSAlexander Aring 12882874d1a6SAlexander Aring static void _dlm_lowcomms_commit_msg(struct dlm_msg *msg) 12896ed7257bSPatrick Caulfield { 12908f2dc78dSAlexander Aring struct writequeue_entry *e = msg->entry; 12916ed7257bSPatrick Caulfield struct connection *con = e->con; 12926ed7257bSPatrick Caulfield int users; 12936ed7257bSPatrick Caulfield 1294dbb751ffSAlexander Aring spin_lock_bh(&con->writequeue_lock); 12958f2dc78dSAlexander Aring kref_get(&msg->ref); 12968f2dc78dSAlexander Aring list_add(&msg->list, &e->msgs); 12978f2dc78dSAlexander Aring 12986ed7257bSPatrick Caulfield users = --e->users; 12996ed7257bSPatrick Caulfield if (users) 13006ed7257bSPatrick Caulfield goto out; 1301f0747ebfSAlexander Aring 1302f0747ebfSAlexander Aring e->len = DLM_WQ_LENGTH_BYTES(e); 13036ed7257bSPatrick Caulfield 1304dbb751ffSAlexander Aring lowcomms_queue_swork(con); 13056ed7257bSPatrick Caulfield 13066ed7257bSPatrick Caulfield out: 1307dbb751ffSAlexander Aring spin_unlock_bh(&con->writequeue_lock); 13086ed7257bSPatrick Caulfield return; 13096ed7257bSPatrick Caulfield } 13106ed7257bSPatrick Caulfield 1311a8449f23SAlexander Aring /* avoid false positive for nodes_srcu, lock was happen in 1312a8449f23SAlexander Aring * dlm_lowcomms_new_msg 1313a8449f23SAlexander Aring */ 1314a8449f23SAlexander Aring #ifndef __CHECKER__ 13152874d1a6SAlexander Aring void dlm_lowcomms_commit_msg(struct dlm_msg *msg) 13162874d1a6SAlexander Aring { 13172874d1a6SAlexander Aring _dlm_lowcomms_commit_msg(msg); 13182874d1a6SAlexander Aring srcu_read_unlock(&connections_srcu, msg->idx); 131930ea3257SAlexander Aring /* because dlm_lowcomms_new_msg() */ 132030ea3257SAlexander Aring kref_put(&msg->ref, dlm_msg_release); 13212874d1a6SAlexander Aring } 1322a8449f23SAlexander Aring #endif 13232874d1a6SAlexander Aring 13248f2dc78dSAlexander Aring void dlm_lowcomms_put_msg(struct dlm_msg *msg) 13258f2dc78dSAlexander Aring { 13268f2dc78dSAlexander Aring kref_put(&msg->ref, dlm_msg_release); 13278f2dc78dSAlexander Aring } 13288f2dc78dSAlexander Aring 1329dbb751ffSAlexander Aring /* does not held connections_srcu, usage lowcomms_error_report only */ 13302874d1a6SAlexander Aring int dlm_lowcomms_resend_msg(struct dlm_msg *msg) 13312874d1a6SAlexander Aring { 13322874d1a6SAlexander Aring struct dlm_msg *msg_resend; 13332874d1a6SAlexander Aring char *ppc; 13342874d1a6SAlexander Aring 13352874d1a6SAlexander Aring if (msg->retransmit) 13362874d1a6SAlexander Aring return 1; 13372874d1a6SAlexander Aring 13382874d1a6SAlexander Aring msg_resend = dlm_lowcomms_new_msg_con(msg->entry->con, msg->len, 13392874d1a6SAlexander Aring GFP_ATOMIC, &ppc, NULL, NULL); 13402874d1a6SAlexander Aring if (!msg_resend) 13412874d1a6SAlexander Aring return -ENOMEM; 13422874d1a6SAlexander Aring 13432874d1a6SAlexander Aring msg->retransmit = true; 13442874d1a6SAlexander Aring kref_get(&msg->ref); 13452874d1a6SAlexander Aring msg_resend->orig_msg = msg; 13462874d1a6SAlexander Aring 13472874d1a6SAlexander Aring memcpy(ppc, msg->ppc, msg->len); 13482874d1a6SAlexander Aring _dlm_lowcomms_commit_msg(msg_resend); 13492874d1a6SAlexander Aring dlm_lowcomms_put_msg(msg_resend); 13502874d1a6SAlexander Aring 13512874d1a6SAlexander Aring return 0; 13522874d1a6SAlexander Aring } 13532874d1a6SAlexander Aring 13546ed7257bSPatrick Caulfield /* Send a message */ 1355dbb751ffSAlexander Aring static int send_to_sock(struct connection *con) 13566ed7257bSPatrick Caulfield { 13576ed7257bSPatrick Caulfield const int msg_flags = MSG_DONTWAIT | MSG_NOSIGNAL; 13586ed7257bSPatrick Caulfield struct writequeue_entry *e; 135966d5955aSAlexander Aring int len, offset, ret; 1360194a3fb4SAlexander Aring 1361dbb751ffSAlexander Aring spin_lock_bh(&con->writequeue_lock); 136266d5955aSAlexander Aring e = con_next_wq(con); 1363dbb751ffSAlexander Aring if (!e) { 1364dbb751ffSAlexander Aring clear_bit(CF_SEND_PENDING, &con->flags); 1365dbb751ffSAlexander Aring spin_unlock_bh(&con->writequeue_lock); 1366dbb751ffSAlexander Aring return DLM_IO_END; 1367dbb751ffSAlexander Aring } 13686ed7257bSPatrick Caulfield 13696ed7257bSPatrick Caulfield len = e->len; 13706ed7257bSPatrick Caulfield offset = e->offset; 1371dbb751ffSAlexander Aring WARN_ON_ONCE(len == 0 && e->users == 0); 1372dbb751ffSAlexander Aring spin_unlock_bh(&con->writequeue_lock); 13736ed7257bSPatrick Caulfield 13741329e3f2SPaolo Bonzini ret = kernel_sendpage(con->sock, e->page, offset, len, 13756ed7257bSPatrick Caulfield msg_flags); 137692732376SAlexander Aring trace_dlm_send(con->nodeid, ret); 1377d66f8277SPatrick Caulfield if (ret == -EAGAIN || ret == 0) { 1378dbb751ffSAlexander Aring lock_sock(con->sock->sk); 1379dbb751ffSAlexander Aring spin_lock_bh(&con->writequeue_lock); 1380dbb751ffSAlexander Aring if (test_bit(SOCKWQ_ASYNC_NOSPACE, &con->sock->flags) && 1381b36930ddSDavid Miller !test_and_set_bit(CF_APP_LIMITED, &con->flags)) { 1382b36930ddSDavid Miller /* Notify TCP that we're limited by the 1383b36930ddSDavid Miller * application window size. 1384b36930ddSDavid Miller */ 1385dbb751ffSAlexander Aring set_bit(SOCK_NOSPACE, &con->sock->sk->sk_socket->flags); 1386b36930ddSDavid Miller con->sock->sk->sk_write_pending++; 1387f92c8dd7SBob Peterson 1388dbb751ffSAlexander Aring clear_bit(CF_SEND_PENDING, &con->flags); 1389dbb751ffSAlexander Aring spin_unlock_bh(&con->writequeue_lock); 1390dbb751ffSAlexander Aring release_sock(con->sock->sk); 1391dbb751ffSAlexander Aring 1392dbb751ffSAlexander Aring /* wait for write_space() event */ 1393dbb751ffSAlexander Aring return DLM_IO_END; 1394dbb751ffSAlexander Aring } 1395dbb751ffSAlexander Aring spin_unlock_bh(&con->writequeue_lock); 1396dbb751ffSAlexander Aring release_sock(con->sock->sk); 1397dbb751ffSAlexander Aring 1398dbb751ffSAlexander Aring return DLM_IO_RESCHED; 1399dbb751ffSAlexander Aring } else if (ret < 0) { 1400dbb751ffSAlexander Aring return ret; 1401dbb751ffSAlexander Aring } 1402dbb751ffSAlexander Aring 1403dbb751ffSAlexander Aring spin_lock_bh(&con->writequeue_lock); 14045d689871SMike Christie writequeue_entry_complete(e, ret); 1405dbb751ffSAlexander Aring spin_unlock_bh(&con->writequeue_lock); 1406194a3fb4SAlexander Aring 1407dbb751ffSAlexander Aring return DLM_IO_SUCCESS; 14086ed7257bSPatrick Caulfield } 14096ed7257bSPatrick Caulfield 14106ed7257bSPatrick Caulfield static void clean_one_writequeue(struct connection *con) 14116ed7257bSPatrick Caulfield { 14125e9ccc37SChristine Caulfield struct writequeue_entry *e, *safe; 14136ed7257bSPatrick Caulfield 1414dbb751ffSAlexander Aring spin_lock_bh(&con->writequeue_lock); 14155e9ccc37SChristine Caulfield list_for_each_entry_safe(e, safe, &con->writequeue, list) { 14166ed7257bSPatrick Caulfield free_entry(e); 14176ed7257bSPatrick Caulfield } 1418dbb751ffSAlexander Aring spin_unlock_bh(&con->writequeue_lock); 14196ed7257bSPatrick Caulfield } 14206ed7257bSPatrick Caulfield 14216f0b0b5dSAlexander Aring static void connection_release(struct rcu_head *rcu) 14226f0b0b5dSAlexander Aring { 14236f0b0b5dSAlexander Aring struct connection *con = container_of(rcu, struct connection, rcu); 14246f0b0b5dSAlexander Aring 1425dbb751ffSAlexander Aring WARN_ON_ONCE(!list_empty(&con->writequeue)); 1426dbb751ffSAlexander Aring WARN_ON_ONCE(con->sock); 14276f0b0b5dSAlexander Aring kfree(con); 14286f0b0b5dSAlexander Aring } 14296f0b0b5dSAlexander Aring 14306ed7257bSPatrick Caulfield /* Called from recovery when it knows that a node has 14316ed7257bSPatrick Caulfield left the cluster */ 14326ed7257bSPatrick Caulfield int dlm_lowcomms_close(int nodeid) 14336ed7257bSPatrick Caulfield { 14346ed7257bSPatrick Caulfield struct connection *con; 1435b38bc9c2SAlexander Aring int idx; 14366ed7257bSPatrick Caulfield 14376ed7257bSPatrick Caulfield log_print("closing connection to node %d", nodeid); 14386f0b0b5dSAlexander Aring 1439b38bc9c2SAlexander Aring idx = srcu_read_lock(&connections_srcu); 14406ed7257bSPatrick Caulfield con = nodeid2con(nodeid, 0); 14416f0b0b5dSAlexander Aring if (WARN_ON_ONCE(!con)) { 14426f0b0b5dSAlexander Aring srcu_read_unlock(&connections_srcu, idx); 14436f0b0b5dSAlexander Aring return -ENOENT; 14446f0b0b5dSAlexander Aring } 14456f0b0b5dSAlexander Aring 1446dbb751ffSAlexander Aring stop_connection_io(con); 1447dbb751ffSAlexander Aring log_print("io handling for node: %d stopped", nodeid); 1448dbb751ffSAlexander Aring close_connection(con, true); 1449dbb751ffSAlexander Aring 14506f0b0b5dSAlexander Aring spin_lock(&connections_lock); 14516f0b0b5dSAlexander Aring hlist_del_rcu(&con->list); 14526f0b0b5dSAlexander Aring spin_unlock(&connections_lock); 14536f0b0b5dSAlexander Aring 14546ed7257bSPatrick Caulfield clean_one_writequeue(con); 14556f0b0b5dSAlexander Aring call_srcu(&connections_srcu, &con->rcu, connection_release); 14566f0b0b5dSAlexander Aring if (con->othercon) { 145753a5edaaSAlexander Aring clean_one_writequeue(con->othercon); 14586f0b0b5dSAlexander Aring if (con->othercon) 14596f0b0b5dSAlexander Aring call_srcu(&connections_srcu, &con->othercon->rcu, connection_release); 14606ed7257bSPatrick Caulfield } 1461b38bc9c2SAlexander Aring srcu_read_unlock(&connections_srcu, idx); 146236b71a8bSDavid Teigland 1463dbb751ffSAlexander Aring /* for debugging we print when we are done to compare with other 1464dbb751ffSAlexander Aring * messages in between. This function need to be correctly synchronized 1465dbb751ffSAlexander Aring * with io handling 1466dbb751ffSAlexander Aring */ 1467dbb751ffSAlexander Aring log_print("closing connection to node %d done", nodeid); 1468dbb751ffSAlexander Aring 14696ed7257bSPatrick Caulfield return 0; 14706ed7257bSPatrick Caulfield } 14716ed7257bSPatrick Caulfield 1472dbb751ffSAlexander Aring /* Receive worker function */ 14736ed7257bSPatrick Caulfield static void process_recv_sockets(struct work_struct *work) 14746ed7257bSPatrick Caulfield { 14756ed7257bSPatrick Caulfield struct connection *con = container_of(work, struct connection, rwork); 1476dbb751ffSAlexander Aring int ret, buflen; 14776ed7257bSPatrick Caulfield 1478dbb751ffSAlexander Aring down_read(&con->sock_lock); 1479dbb751ffSAlexander Aring if (!con->sock) { 1480dbb751ffSAlexander Aring up_read(&con->sock_lock); 1481dbb751ffSAlexander Aring return; 1482dbb751ffSAlexander Aring } 1483dbb751ffSAlexander Aring 1484dbb751ffSAlexander Aring buflen = READ_ONCE(dlm_config.ci_buffer_size); 1485dbb751ffSAlexander Aring do { 1486dbb751ffSAlexander Aring ret = receive_from_sock(con, buflen); 1487dbb751ffSAlexander Aring } while (ret == DLM_IO_SUCCESS); 1488dbb751ffSAlexander Aring up_read(&con->sock_lock); 1489dbb751ffSAlexander Aring 1490dbb751ffSAlexander Aring switch (ret) { 1491dbb751ffSAlexander Aring case DLM_IO_END: 1492dbb751ffSAlexander Aring /* CF_RECV_PENDING cleared */ 1493dbb751ffSAlexander Aring break; 1494dbb751ffSAlexander Aring case DLM_IO_EOF: 1495dbb751ffSAlexander Aring close_connection(con, false); 1496dbb751ffSAlexander Aring /* CF_RECV_PENDING cleared */ 1497dbb751ffSAlexander Aring break; 1498dbb751ffSAlexander Aring case DLM_IO_RESCHED: 1499dbb751ffSAlexander Aring cond_resched(); 1500dbb751ffSAlexander Aring queue_work(io_workqueue, &con->rwork); 1501dbb751ffSAlexander Aring /* CF_RECV_PENDING not cleared */ 1502dbb751ffSAlexander Aring break; 1503dbb751ffSAlexander Aring default: 1504dbb751ffSAlexander Aring if (ret < 0) { 1505dbb751ffSAlexander Aring if (test_bit(CF_IS_OTHERCON, &con->flags)) { 1506dbb751ffSAlexander Aring close_connection(con, false); 1507dbb751ffSAlexander Aring } else { 1508dbb751ffSAlexander Aring spin_lock_bh(&con->writequeue_lock); 1509dbb751ffSAlexander Aring lowcomms_queue_swork(con); 1510dbb751ffSAlexander Aring spin_unlock_bh(&con->writequeue_lock); 1511dbb751ffSAlexander Aring } 1512dbb751ffSAlexander Aring 1513dbb751ffSAlexander Aring /* CF_RECV_PENDING cleared for othercon 1514dbb751ffSAlexander Aring * we trigger send queue if not already done 1515dbb751ffSAlexander Aring * and process_send_sockets will handle it 1516dbb751ffSAlexander Aring */ 1517dbb751ffSAlexander Aring break; 1518dbb751ffSAlexander Aring } 1519dbb751ffSAlexander Aring 1520dbb751ffSAlexander Aring WARN_ON_ONCE(1); 1521dbb751ffSAlexander Aring break; 1522dbb751ffSAlexander Aring } 15236ed7257bSPatrick Caulfield } 15246ed7257bSPatrick Caulfield 1525d11ccd45SAlexander Aring static void process_listen_recv_socket(struct work_struct *work) 1526d11ccd45SAlexander Aring { 1527f0f4bb43SAlexander Aring int ret; 1528f0f4bb43SAlexander Aring 1529dbb751ffSAlexander Aring if (WARN_ON_ONCE(!listen_con.sock)) 1530dbb751ffSAlexander Aring return; 1531dbb751ffSAlexander Aring 1532f0f4bb43SAlexander Aring do { 1533dbb751ffSAlexander Aring ret = accept_from_sock(); 1534dbb751ffSAlexander Aring } while (ret == DLM_IO_SUCCESS); 1535dbb751ffSAlexander Aring 1536dbb751ffSAlexander Aring if (ret < 0) 1537dbb751ffSAlexander Aring log_print("critical error accepting connection: %d", ret); 1538d11ccd45SAlexander Aring } 1539d11ccd45SAlexander Aring 1540dbb751ffSAlexander Aring static int dlm_connect(struct connection *con) 15418728a455SAlexander Aring { 15428728a455SAlexander Aring struct sockaddr_storage addr; 15438728a455SAlexander Aring int result, addr_len; 15448728a455SAlexander Aring struct socket *sock; 15458728a455SAlexander Aring unsigned int mark; 15468728a455SAlexander Aring 15478728a455SAlexander Aring memset(&addr, 0, sizeof(addr)); 15488728a455SAlexander Aring result = nodeid_to_addr(con->nodeid, &addr, NULL, 15498728a455SAlexander Aring dlm_proto_ops->try_new_addr, &mark); 15508728a455SAlexander Aring if (result < 0) { 15518728a455SAlexander Aring log_print("no address for nodeid %d", con->nodeid); 1552dbb751ffSAlexander Aring return result; 15538728a455SAlexander Aring } 15548728a455SAlexander Aring 15558728a455SAlexander Aring /* Create a socket to communicate with */ 1556c51c9cd8SAlexander Aring result = sock_create_kern(&init_net, dlm_local_addr[0].ss_family, 15578728a455SAlexander Aring SOCK_STREAM, dlm_proto_ops->proto, &sock); 15588728a455SAlexander Aring if (result < 0) 1559dbb751ffSAlexander Aring return result; 15608728a455SAlexander Aring 15618728a455SAlexander Aring sock_set_mark(sock->sk, mark); 15628728a455SAlexander Aring dlm_proto_ops->sockopts(sock); 15638728a455SAlexander Aring 15648728a455SAlexander Aring result = dlm_proto_ops->bind(sock); 1565dbb751ffSAlexander Aring if (result < 0) { 1566dbb751ffSAlexander Aring sock_release(sock); 1567dbb751ffSAlexander Aring return result; 1568dbb751ffSAlexander Aring } 1569dbb751ffSAlexander Aring 1570dbb751ffSAlexander Aring add_sock(sock, con); 15718728a455SAlexander Aring 15728728a455SAlexander Aring log_print_ratelimited("connecting to %d", con->nodeid); 15738728a455SAlexander Aring make_sockaddr(&addr, dlm_config.ci_tcp_port, &addr_len); 15748728a455SAlexander Aring result = dlm_proto_ops->connect(con, sock, (struct sockaddr *)&addr, 15758728a455SAlexander Aring addr_len); 1576dbb751ffSAlexander Aring switch (result) { 1577dbb751ffSAlexander Aring case -EINPROGRESS: 1578dbb751ffSAlexander Aring /* not an error */ 1579dbb751ffSAlexander Aring fallthrough; 1580dbb751ffSAlexander Aring case 0: 1581dbb751ffSAlexander Aring break; 1582dbb751ffSAlexander Aring default: 15838728a455SAlexander Aring if (result < 0) 15848728a455SAlexander Aring dlm_close_sock(&con->sock); 15858728a455SAlexander Aring 1586dbb751ffSAlexander Aring break; 15878728a455SAlexander Aring } 15888728a455SAlexander Aring 1589dbb751ffSAlexander Aring return result; 1590dbb751ffSAlexander Aring } 1591dbb751ffSAlexander Aring 1592dbb751ffSAlexander Aring /* Send worker function */ 15936ed7257bSPatrick Caulfield static void process_send_sockets(struct work_struct *work) 15946ed7257bSPatrick Caulfield { 15956ed7257bSPatrick Caulfield struct connection *con = container_of(work, struct connection, swork); 1596dbb751ffSAlexander Aring int ret; 15976ed7257bSPatrick Caulfield 1598dbb751ffSAlexander Aring WARN_ON_ONCE(test_bit(CF_IS_OTHERCON, &con->flags)); 15997443bc96SAlexander Aring 1600dbb751ffSAlexander Aring down_read(&con->sock_lock); 1601dbb751ffSAlexander Aring if (!con->sock) { 1602dbb751ffSAlexander Aring up_read(&con->sock_lock); 1603dbb751ffSAlexander Aring down_write(&con->sock_lock); 1604dbb751ffSAlexander Aring if (!con->sock) { 1605dbb751ffSAlexander Aring ret = dlm_connect(con); 1606dbb751ffSAlexander Aring switch (ret) { 1607dbb751ffSAlexander Aring case 0: 1608dbb751ffSAlexander Aring break; 1609dbb751ffSAlexander Aring case -EINPROGRESS: 1610dbb751ffSAlexander Aring /* avoid spamming resched on connection 1611dbb751ffSAlexander Aring * we might can switch to a state_change 1612dbb751ffSAlexander Aring * event based mechanism if established 1613dbb751ffSAlexander Aring */ 1614dbb751ffSAlexander Aring msleep(100); 1615dbb751ffSAlexander Aring break; 1616dbb751ffSAlexander Aring default: 1617dbb751ffSAlexander Aring /* CF_SEND_PENDING not cleared */ 1618dbb751ffSAlexander Aring up_write(&con->sock_lock); 1619dbb751ffSAlexander Aring log_print("connect to node %d try %d error %d", 1620dbb751ffSAlexander Aring con->nodeid, con->retries++, ret); 1621ba868d9dSAlexander Aring msleep(1000); 1622dbb751ffSAlexander Aring /* For now we try forever to reconnect. In 1623dbb751ffSAlexander Aring * future we should send a event to cluster 1624dbb751ffSAlexander Aring * manager to fence itself after certain amount 1625dbb751ffSAlexander Aring * of retries. 1626dbb751ffSAlexander Aring */ 1627dbb751ffSAlexander Aring queue_work(io_workqueue, &con->swork); 1628dbb751ffSAlexander Aring return; 1629dbb751ffSAlexander Aring } 1630dbb751ffSAlexander Aring } 1631dbb751ffSAlexander Aring downgrade_write(&con->sock_lock); 1632ba868d9dSAlexander Aring } 16338728a455SAlexander Aring 1634dbb751ffSAlexander Aring do { 1635dbb751ffSAlexander Aring ret = send_to_sock(con); 1636dbb751ffSAlexander Aring } while (ret == DLM_IO_SUCCESS); 1637dbb751ffSAlexander Aring up_read(&con->sock_lock); 1638dbb751ffSAlexander Aring 1639dbb751ffSAlexander Aring switch (ret) { 1640dbb751ffSAlexander Aring case DLM_IO_END: 1641dbb751ffSAlexander Aring /* CF_SEND_PENDING cleared */ 1642dbb751ffSAlexander Aring break; 1643dbb751ffSAlexander Aring case DLM_IO_RESCHED: 1644dbb751ffSAlexander Aring /* CF_SEND_PENDING not cleared */ 1645dbb751ffSAlexander Aring cond_resched(); 1646dbb751ffSAlexander Aring queue_work(io_workqueue, &con->swork); 1647dbb751ffSAlexander Aring break; 1648dbb751ffSAlexander Aring default: 1649dbb751ffSAlexander Aring if (ret < 0) { 1650dbb751ffSAlexander Aring close_connection(con, false); 1651dbb751ffSAlexander Aring 1652dbb751ffSAlexander Aring /* CF_SEND_PENDING cleared */ 1653dbb751ffSAlexander Aring spin_lock_bh(&con->writequeue_lock); 1654dbb751ffSAlexander Aring lowcomms_queue_swork(con); 1655dbb751ffSAlexander Aring spin_unlock_bh(&con->writequeue_lock); 1656dbb751ffSAlexander Aring break; 1657dbb751ffSAlexander Aring } 1658dbb751ffSAlexander Aring 1659dbb751ffSAlexander Aring WARN_ON_ONCE(1); 1660dbb751ffSAlexander Aring break; 1661dbb751ffSAlexander Aring } 16626ed7257bSPatrick Caulfield } 16636ed7257bSPatrick Caulfield 16646ed7257bSPatrick Caulfield static void work_stop(void) 16656ed7257bSPatrick Caulfield { 1666dbb751ffSAlexander Aring if (io_workqueue) { 1667dbb751ffSAlexander Aring destroy_workqueue(io_workqueue); 1668dbb751ffSAlexander Aring io_workqueue = NULL; 1669fcef0e6cSAlexander Aring } 1670fcef0e6cSAlexander Aring 1671dbb751ffSAlexander Aring if (process_workqueue) { 1672dbb751ffSAlexander Aring destroy_workqueue(process_workqueue); 1673dbb751ffSAlexander Aring process_workqueue = NULL; 1674fcef0e6cSAlexander Aring } 16756ed7257bSPatrick Caulfield } 16766ed7257bSPatrick Caulfield 16776ed7257bSPatrick Caulfield static int work_start(void) 16786ed7257bSPatrick Caulfield { 1679dbb751ffSAlexander Aring io_workqueue = alloc_workqueue("dlm_io", WQ_HIGHPRI | WQ_MEM_RECLAIM, 1680dbb751ffSAlexander Aring 0); 1681dbb751ffSAlexander Aring if (!io_workqueue) { 1682dbb751ffSAlexander Aring log_print("can't start dlm_io"); 1683b9d41052SNamhyung Kim return -ENOMEM; 16846ed7257bSPatrick Caulfield } 16856ed7257bSPatrick Caulfield 1686dbb751ffSAlexander Aring /* ordered dlm message process queue, 1687dbb751ffSAlexander Aring * should be converted to a tasklet 1688dbb751ffSAlexander Aring */ 1689dbb751ffSAlexander Aring process_workqueue = alloc_ordered_workqueue("dlm_process", 1690dbb751ffSAlexander Aring WQ_HIGHPRI | WQ_MEM_RECLAIM); 1691dbb751ffSAlexander Aring if (!process_workqueue) { 1692dbb751ffSAlexander Aring log_print("can't start dlm_process"); 1693dbb751ffSAlexander Aring destroy_workqueue(io_workqueue); 1694dbb751ffSAlexander Aring io_workqueue = NULL; 1695b9d41052SNamhyung Kim return -ENOMEM; 16966ed7257bSPatrick Caulfield } 16976ed7257bSPatrick Caulfield 16986ed7257bSPatrick Caulfield return 0; 16996ed7257bSPatrick Caulfield } 17006ed7257bSPatrick Caulfield 17019d232469SAlexander Aring void dlm_lowcomms_shutdown(void) 17029d232469SAlexander Aring { 1703c3d88dfdSAlexander Aring /* stop lowcomms_listen_data_ready calls */ 1704c3d88dfdSAlexander Aring lock_sock(listen_con.sock->sk); 1705c3d88dfdSAlexander Aring listen_con.sock->sk->sk_data_ready = listen_sock.sk_data_ready; 1706c3d88dfdSAlexander Aring release_sock(listen_con.sock->sk); 17079d232469SAlexander Aring 1708c3d88dfdSAlexander Aring cancel_work_sync(&listen_con.rwork); 17099d232469SAlexander Aring dlm_close_sock(&listen_con.sock); 1710dbb751ffSAlexander Aring 1711dbb751ffSAlexander Aring flush_workqueue(process_workqueue); 17124f567acbSAlexander Aring } 17134f567acbSAlexander Aring 17144f567acbSAlexander Aring void dlm_lowcomms_shutdown_node(int nodeid, bool force) 17154f567acbSAlexander Aring { 17164f567acbSAlexander Aring struct connection *con; 17174f567acbSAlexander Aring int idx; 17189d232469SAlexander Aring 1719b38bc9c2SAlexander Aring idx = srcu_read_lock(&connections_srcu); 17204f567acbSAlexander Aring con = nodeid2con(nodeid, 0); 17214f567acbSAlexander Aring if (WARN_ON_ONCE(!con)) { 17224f567acbSAlexander Aring srcu_read_unlock(&connections_srcu, idx); 17234f567acbSAlexander Aring return; 17244f567acbSAlexander Aring } 17254f567acbSAlexander Aring 1726c3d88dfdSAlexander Aring flush_work(&con->swork); 1727dbb751ffSAlexander Aring stop_connection_io(con); 17284f567acbSAlexander Aring WARN_ON_ONCE(!force && !list_empty(&con->writequeue)); 1729dbb751ffSAlexander Aring close_connection(con, true); 17304f567acbSAlexander Aring clean_one_writequeue(con); 17314f567acbSAlexander Aring if (con->othercon) 17324f567acbSAlexander Aring clean_one_writequeue(con->othercon); 1733dbb751ffSAlexander Aring allow_connection_io(con); 1734b38bc9c2SAlexander Aring srcu_read_unlock(&connections_srcu, idx); 17359d232469SAlexander Aring } 17369d232469SAlexander Aring 17375e9ccc37SChristine Caulfield void dlm_lowcomms_stop(void) 17385e9ccc37SChristine Caulfield { 17396ed7257bSPatrick Caulfield work_stop(); 1740a66c008cSAlexander Aring dlm_proto_ops = NULL; 17416ed7257bSPatrick Caulfield } 17426ed7257bSPatrick Caulfield 17432dc6b115SAlexander Aring static int dlm_listen_for_all(void) 17442dc6b115SAlexander Aring { 17452dc6b115SAlexander Aring struct socket *sock; 17462dc6b115SAlexander Aring int result; 17472dc6b115SAlexander Aring 17482dc6b115SAlexander Aring log_print("Using %s for communications", 17492dc6b115SAlexander Aring dlm_proto_ops->name); 17502dc6b115SAlexander Aring 17512dc6b115SAlexander Aring result = dlm_proto_ops->listen_validate(); 17522dc6b115SAlexander Aring if (result < 0) 17532dc6b115SAlexander Aring return result; 17542dc6b115SAlexander Aring 1755c51c9cd8SAlexander Aring result = sock_create_kern(&init_net, dlm_local_addr[0].ss_family, 17562dc6b115SAlexander Aring SOCK_STREAM, dlm_proto_ops->proto, &sock); 17572dc6b115SAlexander Aring if (result < 0) { 1758fe933675SAlexander Aring log_print("Can't create comms socket: %d", result); 17591f4f1084SDan Carpenter return result; 17602dc6b115SAlexander Aring } 17612dc6b115SAlexander Aring 17622dc6b115SAlexander Aring sock_set_mark(sock->sk, dlm_config.ci_mark); 17632dc6b115SAlexander Aring dlm_proto_ops->listen_sockopts(sock); 17642dc6b115SAlexander Aring 17652dc6b115SAlexander Aring result = dlm_proto_ops->listen_bind(sock); 17662dc6b115SAlexander Aring if (result < 0) 17672dc6b115SAlexander Aring goto out; 17682dc6b115SAlexander Aring 1769c3d88dfdSAlexander Aring lock_sock(sock->sk); 1770c3d88dfdSAlexander Aring listen_sock.sk_data_ready = sock->sk->sk_data_ready; 1771c3d88dfdSAlexander Aring listen_sock.sk_write_space = sock->sk->sk_write_space; 1772c3d88dfdSAlexander Aring listen_sock.sk_error_report = sock->sk->sk_error_report; 1773c3d88dfdSAlexander Aring listen_sock.sk_state_change = sock->sk->sk_state_change; 1774c3d88dfdSAlexander Aring 1775c3d88dfdSAlexander Aring listen_con.sock = sock; 1776c3d88dfdSAlexander Aring 1777c3d88dfdSAlexander Aring sock->sk->sk_allocation = GFP_NOFS; 177898123866SBenjamin Coddington sock->sk->sk_use_task_frag = false; 1779c3d88dfdSAlexander Aring sock->sk->sk_data_ready = lowcomms_listen_data_ready; 1780c3d88dfdSAlexander Aring release_sock(sock->sk); 17812dc6b115SAlexander Aring 17822dc6b115SAlexander Aring result = sock->ops->listen(sock, 5); 17832dc6b115SAlexander Aring if (result < 0) { 17842dc6b115SAlexander Aring dlm_close_sock(&listen_con.sock); 178508ae0547SAlexander Aring return result; 17862dc6b115SAlexander Aring } 17872dc6b115SAlexander Aring 17882dc6b115SAlexander Aring return 0; 17892dc6b115SAlexander Aring 17902dc6b115SAlexander Aring out: 17912dc6b115SAlexander Aring sock_release(sock); 17922dc6b115SAlexander Aring return result; 17932dc6b115SAlexander Aring } 17942dc6b115SAlexander Aring 17958728a455SAlexander Aring static int dlm_tcp_bind(struct socket *sock) 17968728a455SAlexander Aring { 17978728a455SAlexander Aring struct sockaddr_storage src_addr; 17988728a455SAlexander Aring int result, addr_len; 17998728a455SAlexander Aring 18008728a455SAlexander Aring /* Bind to our cluster-known address connecting to avoid 18018728a455SAlexander Aring * routing problems. 18028728a455SAlexander Aring */ 1803c51c9cd8SAlexander Aring memcpy(&src_addr, &dlm_local_addr[0], sizeof(src_addr)); 18048728a455SAlexander Aring make_sockaddr(&src_addr, 0, &addr_len); 18058728a455SAlexander Aring 18068728a455SAlexander Aring result = sock->ops->bind(sock, (struct sockaddr *)&src_addr, 18078728a455SAlexander Aring addr_len); 18088728a455SAlexander Aring if (result < 0) { 18098728a455SAlexander Aring /* This *may* not indicate a critical error */ 18108728a455SAlexander Aring log_print("could not bind for connect: %d", result); 18118728a455SAlexander Aring } 18128728a455SAlexander Aring 18138728a455SAlexander Aring return 0; 18148728a455SAlexander Aring } 18158728a455SAlexander Aring 18168728a455SAlexander Aring static int dlm_tcp_connect(struct connection *con, struct socket *sock, 18178728a455SAlexander Aring struct sockaddr *addr, int addr_len) 18188728a455SAlexander Aring { 1819dbb751ffSAlexander Aring return sock->ops->connect(sock, addr, addr_len, O_NONBLOCK); 18208728a455SAlexander Aring } 18218728a455SAlexander Aring 18222dc6b115SAlexander Aring static int dlm_tcp_listen_validate(void) 18232dc6b115SAlexander Aring { 18242dc6b115SAlexander Aring /* We don't support multi-homed hosts */ 18252dc6b115SAlexander Aring if (dlm_local_count > 1) { 18262dc6b115SAlexander Aring log_print("TCP protocol can't handle multi-homed hosts, try SCTP"); 18272dc6b115SAlexander Aring return -EINVAL; 18282dc6b115SAlexander Aring } 18292dc6b115SAlexander Aring 18302dc6b115SAlexander Aring return 0; 18312dc6b115SAlexander Aring } 18322dc6b115SAlexander Aring 18332dc6b115SAlexander Aring static void dlm_tcp_sockopts(struct socket *sock) 18342dc6b115SAlexander Aring { 18352dc6b115SAlexander Aring /* Turn off Nagle's algorithm */ 18362dc6b115SAlexander Aring tcp_sock_set_nodelay(sock->sk); 18372dc6b115SAlexander Aring } 18382dc6b115SAlexander Aring 18392dc6b115SAlexander Aring static void dlm_tcp_listen_sockopts(struct socket *sock) 18402dc6b115SAlexander Aring { 18412dc6b115SAlexander Aring dlm_tcp_sockopts(sock); 18422dc6b115SAlexander Aring sock_set_reuseaddr(sock->sk); 18432dc6b115SAlexander Aring } 18442dc6b115SAlexander Aring 18452dc6b115SAlexander Aring static int dlm_tcp_listen_bind(struct socket *sock) 18462dc6b115SAlexander Aring { 18472dc6b115SAlexander Aring int addr_len; 18482dc6b115SAlexander Aring 18492dc6b115SAlexander Aring /* Bind to our port */ 1850c51c9cd8SAlexander Aring make_sockaddr(&dlm_local_addr[0], dlm_config.ci_tcp_port, &addr_len); 1851c51c9cd8SAlexander Aring return sock->ops->bind(sock, (struct sockaddr *)&dlm_local_addr[0], 18522dc6b115SAlexander Aring addr_len); 18532dc6b115SAlexander Aring } 18542dc6b115SAlexander Aring 1855a66c008cSAlexander Aring static const struct dlm_proto_ops dlm_tcp_ops = { 18562dc6b115SAlexander Aring .name = "TCP", 18572dc6b115SAlexander Aring .proto = IPPROTO_TCP, 18588728a455SAlexander Aring .connect = dlm_tcp_connect, 18598728a455SAlexander Aring .sockopts = dlm_tcp_sockopts, 18608728a455SAlexander Aring .bind = dlm_tcp_bind, 18612dc6b115SAlexander Aring .listen_validate = dlm_tcp_listen_validate, 18622dc6b115SAlexander Aring .listen_sockopts = dlm_tcp_listen_sockopts, 18632dc6b115SAlexander Aring .listen_bind = dlm_tcp_listen_bind, 1864a66c008cSAlexander Aring }; 1865a66c008cSAlexander Aring 18668728a455SAlexander Aring static int dlm_sctp_bind(struct socket *sock) 18678728a455SAlexander Aring { 18688728a455SAlexander Aring return sctp_bind_addrs(sock, 0); 18698728a455SAlexander Aring } 18708728a455SAlexander Aring 18718728a455SAlexander Aring static int dlm_sctp_connect(struct connection *con, struct socket *sock, 18728728a455SAlexander Aring struct sockaddr *addr, int addr_len) 18738728a455SAlexander Aring { 18748728a455SAlexander Aring int ret; 18758728a455SAlexander Aring 18768728a455SAlexander Aring /* 18778728a455SAlexander Aring * Make sock->ops->connect() function return in specified time, 18788728a455SAlexander Aring * since O_NONBLOCK argument in connect() function does not work here, 18798728a455SAlexander Aring * then, we should restore the default value of this attribute. 18808728a455SAlexander Aring */ 18818728a455SAlexander Aring sock_set_sndtimeo(sock->sk, 5); 18828728a455SAlexander Aring ret = sock->ops->connect(sock, addr, addr_len, 0); 18838728a455SAlexander Aring sock_set_sndtimeo(sock->sk, 0); 18848728a455SAlexander Aring return ret; 18858728a455SAlexander Aring } 18868728a455SAlexander Aring 188790d21fc0SAlexander Aring static int dlm_sctp_listen_validate(void) 188890d21fc0SAlexander Aring { 188990d21fc0SAlexander Aring if (!IS_ENABLED(CONFIG_IP_SCTP)) { 189090d21fc0SAlexander Aring log_print("SCTP is not enabled by this kernel"); 189190d21fc0SAlexander Aring return -EOPNOTSUPP; 189290d21fc0SAlexander Aring } 189390d21fc0SAlexander Aring 189490d21fc0SAlexander Aring request_module("sctp"); 189590d21fc0SAlexander Aring return 0; 189690d21fc0SAlexander Aring } 189790d21fc0SAlexander Aring 18982dc6b115SAlexander Aring static int dlm_sctp_bind_listen(struct socket *sock) 18992dc6b115SAlexander Aring { 19002dc6b115SAlexander Aring return sctp_bind_addrs(sock, dlm_config.ci_tcp_port); 19012dc6b115SAlexander Aring } 19022dc6b115SAlexander Aring 19032dc6b115SAlexander Aring static void dlm_sctp_sockopts(struct socket *sock) 19042dc6b115SAlexander Aring { 19052dc6b115SAlexander Aring /* Turn off Nagle's algorithm */ 19062dc6b115SAlexander Aring sctp_sock_set_nodelay(sock->sk); 19072dc6b115SAlexander Aring sock_set_rcvbuf(sock->sk, NEEDED_RMEM); 19082dc6b115SAlexander Aring } 19092dc6b115SAlexander Aring 1910a66c008cSAlexander Aring static const struct dlm_proto_ops dlm_sctp_ops = { 19112dc6b115SAlexander Aring .name = "SCTP", 19122dc6b115SAlexander Aring .proto = IPPROTO_SCTP, 19138728a455SAlexander Aring .try_new_addr = true, 19148728a455SAlexander Aring .connect = dlm_sctp_connect, 19158728a455SAlexander Aring .sockopts = dlm_sctp_sockopts, 19168728a455SAlexander Aring .bind = dlm_sctp_bind, 191790d21fc0SAlexander Aring .listen_validate = dlm_sctp_listen_validate, 19182dc6b115SAlexander Aring .listen_sockopts = dlm_sctp_sockopts, 19192dc6b115SAlexander Aring .listen_bind = dlm_sctp_bind_listen, 1920a66c008cSAlexander Aring }; 1921a66c008cSAlexander Aring 19226ed7257bSPatrick Caulfield int dlm_lowcomms_start(void) 19236ed7257bSPatrick Caulfield { 19241351975aSAlexander Aring int error; 19256ed7257bSPatrick Caulfield 19266ed7257bSPatrick Caulfield init_local(); 19276ed7257bSPatrick Caulfield if (!dlm_local_count) { 1928617e82e1SDavid Teigland error = -ENOTCONN; 19296ed7257bSPatrick Caulfield log_print("no local IP address has been set"); 1930513ef596SDavid Teigland goto fail; 19316ed7257bSPatrick Caulfield } 19326ed7257bSPatrick Caulfield 1933513ef596SDavid Teigland error = work_start(); 1934513ef596SDavid Teigland if (error) 1935c51c9cd8SAlexander Aring goto fail; 1936513ef596SDavid Teigland 19376ed7257bSPatrick Caulfield /* Start listening */ 1938ac7d5d03SAlexander Aring switch (dlm_config.ci_protocol) { 1939ac7d5d03SAlexander Aring case DLM_PROTO_TCP: 1940a66c008cSAlexander Aring dlm_proto_ops = &dlm_tcp_ops; 1941ac7d5d03SAlexander Aring break; 1942ac7d5d03SAlexander Aring case DLM_PROTO_SCTP: 1943a66c008cSAlexander Aring dlm_proto_ops = &dlm_sctp_ops; 1944ac7d5d03SAlexander Aring break; 1945ac7d5d03SAlexander Aring default: 1946ac7d5d03SAlexander Aring log_print("Invalid protocol identifier %d set", 1947ac7d5d03SAlexander Aring dlm_config.ci_protocol); 1948ac7d5d03SAlexander Aring error = -EINVAL; 19492dc6b115SAlexander Aring goto fail_proto_ops; 1950ac7d5d03SAlexander Aring } 19512dc6b115SAlexander Aring 19522dc6b115SAlexander Aring error = dlm_listen_for_all(); 19536ed7257bSPatrick Caulfield if (error) 19542dc6b115SAlexander Aring goto fail_listen; 19556ed7257bSPatrick Caulfield 19566ed7257bSPatrick Caulfield return 0; 19576ed7257bSPatrick Caulfield 19582dc6b115SAlexander Aring fail_listen: 19592dc6b115SAlexander Aring dlm_proto_ops = NULL; 19602dc6b115SAlexander Aring fail_proto_ops: 1961fcef0e6cSAlexander Aring work_stop(); 1962513ef596SDavid Teigland fail: 19636ed7257bSPatrick Caulfield return error; 19646ed7257bSPatrick Caulfield } 196536b71a8bSDavid Teigland 19668b0188b0SAlexander Aring void dlm_lowcomms_init(void) 19678b0188b0SAlexander Aring { 19688b0188b0SAlexander Aring int i; 19698b0188b0SAlexander Aring 19708b0188b0SAlexander Aring for (i = 0; i < CONN_HASH_SIZE; i++) 19718b0188b0SAlexander Aring INIT_HLIST_HEAD(&connection_hash[i]); 19728b0188b0SAlexander Aring 19738b0188b0SAlexander Aring INIT_WORK(&listen_con.rwork, process_listen_recv_socket); 19748b0188b0SAlexander Aring } 19758b0188b0SAlexander Aring 197636b71a8bSDavid Teigland void dlm_lowcomms_exit(void) 197736b71a8bSDavid Teigland { 19786f0b0b5dSAlexander Aring struct connection *con; 19796f0b0b5dSAlexander Aring int i, idx; 198036b71a8bSDavid Teigland 19816f0b0b5dSAlexander Aring idx = srcu_read_lock(&connections_srcu); 19826f0b0b5dSAlexander Aring for (i = 0; i < CONN_HASH_SIZE; i++) { 19836f0b0b5dSAlexander Aring hlist_for_each_entry_rcu(con, &connection_hash[i], list) { 19846f0b0b5dSAlexander Aring spin_lock(&connections_lock); 19856f0b0b5dSAlexander Aring hlist_del_rcu(&con->list); 19866f0b0b5dSAlexander Aring spin_unlock(&connections_lock); 19876f0b0b5dSAlexander Aring 19886f0b0b5dSAlexander Aring if (con->othercon) 19896f0b0b5dSAlexander Aring call_srcu(&connections_srcu, &con->othercon->rcu, 19906f0b0b5dSAlexander Aring connection_release); 19916f0b0b5dSAlexander Aring call_srcu(&connections_srcu, &con->rcu, connection_release); 199236b71a8bSDavid Teigland } 19936f0b0b5dSAlexander Aring } 19946f0b0b5dSAlexander Aring srcu_read_unlock(&connections_srcu, idx); 199536b71a8bSDavid Teigland } 1996