12522fe45SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-only 26ed7257bSPatrick Caulfield /****************************************************************************** 36ed7257bSPatrick Caulfield ******************************************************************************* 46ed7257bSPatrick Caulfield ** 56ed7257bSPatrick Caulfield ** Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved. 65e9ccc37SChristine Caulfield ** Copyright (C) 2004-2009 Red Hat, Inc. All rights reserved. 76ed7257bSPatrick Caulfield ** 86ed7257bSPatrick Caulfield ** 96ed7257bSPatrick Caulfield ******************************************************************************* 106ed7257bSPatrick Caulfield ******************************************************************************/ 116ed7257bSPatrick Caulfield 126ed7257bSPatrick Caulfield /* 136ed7257bSPatrick Caulfield * lowcomms.c 146ed7257bSPatrick Caulfield * 156ed7257bSPatrick Caulfield * This is the "low-level" comms layer. 166ed7257bSPatrick Caulfield * 176ed7257bSPatrick Caulfield * It is responsible for sending/receiving messages 186ed7257bSPatrick Caulfield * from other nodes in the cluster. 196ed7257bSPatrick Caulfield * 206ed7257bSPatrick Caulfield * Cluster nodes are referred to by their nodeids. nodeids are 216ed7257bSPatrick Caulfield * simply 32 bit numbers to the locking module - if they need to 222cf12c0bSJoe Perches * be expanded for the cluster infrastructure then that is its 236ed7257bSPatrick Caulfield * responsibility. It is this layer's 246ed7257bSPatrick Caulfield * responsibility to resolve these into IP address or 256ed7257bSPatrick Caulfield * whatever it needs for inter-node communication. 266ed7257bSPatrick Caulfield * 276ed7257bSPatrick Caulfield * The comms level is two kernel threads that deal mainly with 286ed7257bSPatrick Caulfield * the receiving of messages from other nodes and passing them 296ed7257bSPatrick Caulfield * up to the mid-level comms layer (which understands the 306ed7257bSPatrick Caulfield * message format) for execution by the locking core, and 316ed7257bSPatrick Caulfield * a send thread which does all the setting up of connections 326ed7257bSPatrick Caulfield * to remote nodes and the sending of data. Threads are not allowed 336ed7257bSPatrick Caulfield * to send their own data because it may cause them to wait in times 346ed7257bSPatrick Caulfield * of high load. Also, this way, the sending thread can collect together 356ed7257bSPatrick Caulfield * messages bound for one node and send them in one block. 366ed7257bSPatrick Caulfield * 372cf12c0bSJoe Perches * lowcomms will choose to use either TCP or SCTP as its transport layer 386ed7257bSPatrick Caulfield * depending on the configuration variable 'protocol'. This should be set 396ed7257bSPatrick Caulfield * to 0 (default) for TCP or 1 for SCTP. It should be configured using a 406ed7257bSPatrick Caulfield * cluster-wide mechanism as it must be the same on all nodes of the cluster 416ed7257bSPatrick Caulfield * for the DLM to function. 426ed7257bSPatrick Caulfield * 436ed7257bSPatrick Caulfield */ 446ed7257bSPatrick Caulfield 456ed7257bSPatrick Caulfield #include <asm/ioctls.h> 466ed7257bSPatrick Caulfield #include <net/sock.h> 476ed7257bSPatrick Caulfield #include <net/tcp.h> 486ed7257bSPatrick Caulfield #include <linux/pagemap.h> 496ed7257bSPatrick Caulfield #include <linux/file.h> 507a936ce7SMatthias Kaehlcke #include <linux/mutex.h> 516ed7257bSPatrick Caulfield #include <linux/sctp.h> 525a0e3ad6STejun Heo #include <linux/slab.h> 532f2d76ccSBenjamin Poirier #include <net/sctp/sctp.h> 5444ad532bSJoe Perches #include <net/ipv6.h> 556ed7257bSPatrick Caulfield 566ed7257bSPatrick Caulfield #include "dlm_internal.h" 576ed7257bSPatrick Caulfield #include "lowcomms.h" 586ed7257bSPatrick Caulfield #include "midcomms.h" 596ed7257bSPatrick Caulfield #include "config.h" 606ed7257bSPatrick Caulfield 616ed7257bSPatrick Caulfield #define NEEDED_RMEM (4*1024*1024) 626ed7257bSPatrick Caulfield 63f92c8dd7SBob Peterson /* Number of messages to send before rescheduling */ 64f92c8dd7SBob Peterson #define MAX_SEND_MSG_COUNT 25 65055923bfSAlexander Aring #define DLM_SHUTDOWN_WAIT_TIMEOUT msecs_to_jiffies(10000) 66f92c8dd7SBob Peterson 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 */ 706ed7257bSPatrick Caulfield struct mutex sock_mutex; 716ed7257bSPatrick Caulfield unsigned long flags; 726ed7257bSPatrick Caulfield #define CF_READ_PENDING 1 738a4abb08Stsutomu.owa@toshiba.co.jp #define CF_WRITE_PENDING 2 746ed7257bSPatrick Caulfield #define CF_INIT_PENDING 4 756ed7257bSPatrick Caulfield #define CF_IS_OTHERCON 5 76063c4c99SLars Marowsky-Bree #define CF_CLOSE 6 77b36930ddSDavid Miller #define CF_APP_LIMITED 7 78b2a66629Stsutomu.owa@toshiba.co.jp #define CF_CLOSING 8 79055923bfSAlexander Aring #define CF_SHUTDOWN 9 8019633c7eSAlexander Aring #define CF_CONNECTED 10 81ba868d9dSAlexander Aring #define CF_RECONNECT 11 82ba868d9dSAlexander Aring #define CF_DELAY_CONNECT 12 838aa31cbfSAlexander Aring #define CF_EOF 13 846ed7257bSPatrick Caulfield struct list_head writequeue; /* List of outgoing writequeue_entries */ 856ed7257bSPatrick Caulfield spinlock_t writequeue_lock; 868aa31cbfSAlexander Aring atomic_t writequeue_cnt; 876ed7257bSPatrick Caulfield int retries; 886ed7257bSPatrick Caulfield #define MAX_CONNECT_RETRIES 3 895e9ccc37SChristine Caulfield struct hlist_node list; 906ed7257bSPatrick Caulfield struct connection *othercon; 91ba868d9dSAlexander Aring struct connection *sendcon; 926ed7257bSPatrick Caulfield struct work_struct rwork; /* Receive workqueue */ 936ed7257bSPatrick Caulfield struct work_struct swork; /* Send workqueue */ 94055923bfSAlexander Aring wait_queue_head_t shutdown_wait; /* wait for graceful shutdown */ 954798cbbfSAlexander Aring unsigned char *rx_buf; 964798cbbfSAlexander Aring int rx_buflen; 974798cbbfSAlexander Aring int rx_leftover; 98a47666ebSAlexander Aring struct rcu_head rcu; 996ed7257bSPatrick Caulfield }; 1006ed7257bSPatrick Caulfield #define sock2con(x) ((struct connection *)(x)->sk_user_data) 1016ed7257bSPatrick Caulfield 102d11ccd45SAlexander Aring struct listen_connection { 103d11ccd45SAlexander Aring struct socket *sock; 104d11ccd45SAlexander Aring struct work_struct rwork; 105d11ccd45SAlexander Aring }; 106d11ccd45SAlexander Aring 107f0747ebfSAlexander Aring #define DLM_WQ_REMAIN_BYTES(e) (PAGE_SIZE - e->end) 108f0747ebfSAlexander Aring #define DLM_WQ_LENGTH_BYTES(e) (e->end - e->offset) 109f0747ebfSAlexander Aring 1106ed7257bSPatrick Caulfield /* An entry waiting to be sent */ 1116ed7257bSPatrick Caulfield struct writequeue_entry { 1126ed7257bSPatrick Caulfield struct list_head list; 1136ed7257bSPatrick Caulfield struct page *page; 1146ed7257bSPatrick Caulfield int offset; 1156ed7257bSPatrick Caulfield int len; 1166ed7257bSPatrick Caulfield int end; 1176ed7257bSPatrick Caulfield int users; 118706474fbSAlexander Aring bool dirty; 1196ed7257bSPatrick Caulfield struct connection *con; 1208f2dc78dSAlexander Aring struct list_head msgs; 1218f2dc78dSAlexander Aring struct kref ref; 1228f2dc78dSAlexander Aring }; 1238f2dc78dSAlexander Aring 1248f2dc78dSAlexander Aring struct dlm_msg { 1258f2dc78dSAlexander Aring struct writequeue_entry *entry; 1262874d1a6SAlexander Aring struct dlm_msg *orig_msg; 1272874d1a6SAlexander Aring bool retransmit; 1288f2dc78dSAlexander Aring void *ppc; 1298f2dc78dSAlexander Aring int len; 1308f2dc78dSAlexander Aring int idx; /* new()/commit() idx exchange */ 1318f2dc78dSAlexander Aring 1328f2dc78dSAlexander Aring struct list_head list; 1338f2dc78dSAlexander Aring struct kref ref; 1346ed7257bSPatrick Caulfield }; 1356ed7257bSPatrick Caulfield 13636b71a8bSDavid Teigland struct dlm_node_addr { 13736b71a8bSDavid Teigland struct list_head list; 13836b71a8bSDavid Teigland int nodeid; 139e125fbebSAlexander Aring int mark; 14036b71a8bSDavid Teigland int addr_count; 14198e1b60eSMike Christie int curr_addr_index; 14236b71a8bSDavid Teigland struct sockaddr_storage *addr[DLM_MAX_ADDR_COUNT]; 14336b71a8bSDavid Teigland }; 14436b71a8bSDavid Teigland 145a66c008cSAlexander Aring struct dlm_proto_ops { 1462dc6b115SAlexander Aring const char *name; 1472dc6b115SAlexander Aring int proto; 1482dc6b115SAlexander Aring 1492dc6b115SAlexander Aring int (*listen_validate)(void); 1502dc6b115SAlexander Aring void (*listen_sockopts)(struct socket *sock); 1512dc6b115SAlexander Aring int (*listen_bind)(struct socket *sock); 1522dc6b115SAlexander Aring 153a66c008cSAlexander Aring /* What to do to connect */ 154a66c008cSAlexander Aring void (*connect_action)(struct connection *con); 155a66c008cSAlexander Aring /* What to do to shutdown */ 156a66c008cSAlexander Aring void (*shutdown_action)(struct connection *con); 157a66c008cSAlexander Aring /* What to do to eof check */ 158a66c008cSAlexander Aring bool (*eof_condition)(struct connection *con); 159a66c008cSAlexander Aring }; 160a66c008cSAlexander Aring 161cc661fc9SBob Peterson static struct listen_sock_callbacks { 162cc661fc9SBob Peterson void (*sk_error_report)(struct sock *); 163cc661fc9SBob Peterson void (*sk_data_ready)(struct sock *); 164cc661fc9SBob Peterson void (*sk_state_change)(struct sock *); 165cc661fc9SBob Peterson void (*sk_write_space)(struct sock *); 166cc661fc9SBob Peterson } listen_sock; 167cc661fc9SBob Peterson 16836b71a8bSDavid Teigland static LIST_HEAD(dlm_node_addrs); 16936b71a8bSDavid Teigland static DEFINE_SPINLOCK(dlm_node_addrs_spin); 17036b71a8bSDavid Teigland 171d11ccd45SAlexander Aring static struct listen_connection listen_con; 1726ed7257bSPatrick Caulfield static struct sockaddr_storage *dlm_local_addr[DLM_MAX_ADDR_COUNT]; 1736ed7257bSPatrick Caulfield static int dlm_local_count; 17451746163SAlexander Aring int dlm_allow_conn; 1756ed7257bSPatrick Caulfield 1766ed7257bSPatrick Caulfield /* Work queues */ 1776ed7257bSPatrick Caulfield static struct workqueue_struct *recv_workqueue; 1786ed7257bSPatrick Caulfield static struct workqueue_struct *send_workqueue; 1796ed7257bSPatrick Caulfield 1805e9ccc37SChristine Caulfield static struct hlist_head connection_hash[CONN_HASH_SIZE]; 181a47666ebSAlexander Aring static DEFINE_SPINLOCK(connections_lock); 182a47666ebSAlexander Aring DEFINE_STATIC_SRCU(connections_srcu); 1836ed7257bSPatrick Caulfield 184a66c008cSAlexander Aring static const struct dlm_proto_ops *dlm_proto_ops; 185a66c008cSAlexander Aring 1866ed7257bSPatrick Caulfield static void process_recv_sockets(struct work_struct *work); 1876ed7257bSPatrick Caulfield static void process_send_sockets(struct work_struct *work); 1886ed7257bSPatrick Caulfield 1890672c3c2SAlexander Aring static void sctp_connect_to_sock(struct connection *con); 1900672c3c2SAlexander Aring static void tcp_connect_to_sock(struct connection *con); 1915e9ccc37SChristine Caulfield 19266d5955aSAlexander Aring /* need to held writequeue_lock */ 19366d5955aSAlexander Aring static struct writequeue_entry *con_next_wq(struct connection *con) 19466d5955aSAlexander Aring { 19566d5955aSAlexander Aring struct writequeue_entry *e; 19666d5955aSAlexander Aring 19766d5955aSAlexander Aring if (list_empty(&con->writequeue)) 19866d5955aSAlexander Aring return NULL; 19966d5955aSAlexander Aring 20066d5955aSAlexander Aring e = list_first_entry(&con->writequeue, struct writequeue_entry, 20166d5955aSAlexander Aring list); 20266d5955aSAlexander Aring if (e->len == 0) 20366d5955aSAlexander Aring return NULL; 20466d5955aSAlexander Aring 20566d5955aSAlexander Aring return e; 20666d5955aSAlexander Aring } 20766d5955aSAlexander Aring 208b38bc9c2SAlexander Aring static struct connection *__find_con(int nodeid, int r) 2095e9ccc37SChristine Caulfield { 2105e9ccc37SChristine Caulfield struct connection *con; 2115e9ccc37SChristine Caulfield 212a47666ebSAlexander Aring hlist_for_each_entry_rcu(con, &connection_hash[r], list) { 213b38bc9c2SAlexander Aring if (con->nodeid == nodeid) 2145e9ccc37SChristine Caulfield return con; 2155e9ccc37SChristine Caulfield } 216a47666ebSAlexander Aring 2175e9ccc37SChristine Caulfield return NULL; 2185e9ccc37SChristine Caulfield } 2195e9ccc37SChristine Caulfield 2208aa31cbfSAlexander Aring static bool tcp_eof_condition(struct connection *con) 2218aa31cbfSAlexander Aring { 2228aa31cbfSAlexander Aring return atomic_read(&con->writequeue_cnt); 2238aa31cbfSAlexander Aring } 2248aa31cbfSAlexander Aring 2256cde210aSAlexander Aring static int dlm_con_init(struct connection *con, int nodeid) 2266ed7257bSPatrick Caulfield { 2274798cbbfSAlexander Aring con->rx_buflen = dlm_config.ci_buffer_size; 2284798cbbfSAlexander Aring con->rx_buf = kmalloc(con->rx_buflen, GFP_NOFS); 2296cde210aSAlexander Aring if (!con->rx_buf) 2306cde210aSAlexander Aring return -ENOMEM; 2314798cbbfSAlexander Aring 2326ed7257bSPatrick Caulfield con->nodeid = nodeid; 2336ed7257bSPatrick Caulfield mutex_init(&con->sock_mutex); 2346ed7257bSPatrick Caulfield INIT_LIST_HEAD(&con->writequeue); 2356ed7257bSPatrick Caulfield spin_lock_init(&con->writequeue_lock); 2368aa31cbfSAlexander Aring atomic_set(&con->writequeue_cnt, 0); 2376ed7257bSPatrick Caulfield INIT_WORK(&con->swork, process_send_sockets); 2386ed7257bSPatrick Caulfield INIT_WORK(&con->rwork, process_recv_sockets); 239055923bfSAlexander Aring init_waitqueue_head(&con->shutdown_wait); 2406ed7257bSPatrick Caulfield 2416cde210aSAlexander Aring return 0; 2426cde210aSAlexander Aring } 2436cde210aSAlexander Aring 2446cde210aSAlexander Aring /* 2456cde210aSAlexander Aring * If 'allocation' is zero then we don't attempt to create a new 2466cde210aSAlexander Aring * connection structure for this node. 2476cde210aSAlexander Aring */ 2486cde210aSAlexander Aring static struct connection *nodeid2con(int nodeid, gfp_t alloc) 2496cde210aSAlexander Aring { 2506cde210aSAlexander Aring struct connection *con, *tmp; 2516cde210aSAlexander Aring int r, ret; 2526cde210aSAlexander Aring 253b38bc9c2SAlexander Aring r = nodeid_hash(nodeid); 254b38bc9c2SAlexander Aring con = __find_con(nodeid, r); 2556cde210aSAlexander Aring if (con || !alloc) 2566cde210aSAlexander Aring return con; 2576cde210aSAlexander Aring 2586cde210aSAlexander Aring con = kzalloc(sizeof(*con), alloc); 2596cde210aSAlexander Aring if (!con) 2606cde210aSAlexander Aring return NULL; 2616cde210aSAlexander Aring 2626cde210aSAlexander Aring ret = dlm_con_init(con, nodeid); 2636cde210aSAlexander Aring if (ret) { 2646cde210aSAlexander Aring kfree(con); 2656cde210aSAlexander Aring return NULL; 2666cde210aSAlexander Aring } 2676cde210aSAlexander Aring 268a47666ebSAlexander Aring spin_lock(&connections_lock); 2694f2b30fdSAlexander Aring /* Because multiple workqueues/threads calls this function it can 2704f2b30fdSAlexander Aring * race on multiple cpu's. Instead of locking hot path __find_con() 2714f2b30fdSAlexander Aring * we just check in rare cases of recently added nodes again 2724f2b30fdSAlexander Aring * under protection of connections_lock. If this is the case we 2734f2b30fdSAlexander Aring * abort our connection creation and return the existing connection. 2744f2b30fdSAlexander Aring */ 275b38bc9c2SAlexander Aring tmp = __find_con(nodeid, r); 2764f2b30fdSAlexander Aring if (tmp) { 2774f2b30fdSAlexander Aring spin_unlock(&connections_lock); 2784f2b30fdSAlexander Aring kfree(con->rx_buf); 2794f2b30fdSAlexander Aring kfree(con); 2804f2b30fdSAlexander Aring return tmp; 2814f2b30fdSAlexander Aring } 2824f2b30fdSAlexander Aring 283a47666ebSAlexander Aring hlist_add_head_rcu(&con->list, &connection_hash[r]); 284a47666ebSAlexander Aring spin_unlock(&connections_lock); 285a47666ebSAlexander Aring 2866ed7257bSPatrick Caulfield return con; 2876ed7257bSPatrick Caulfield } 2886ed7257bSPatrick Caulfield 2895e9ccc37SChristine Caulfield /* Loop round all connections */ 2905e9ccc37SChristine Caulfield static void foreach_conn(void (*conn_func)(struct connection *c)) 2915e9ccc37SChristine Caulfield { 292b38bc9c2SAlexander Aring int i; 2935e9ccc37SChristine Caulfield struct connection *con; 2945e9ccc37SChristine Caulfield 2955e9ccc37SChristine Caulfield for (i = 0; i < CONN_HASH_SIZE; i++) { 296a47666ebSAlexander Aring hlist_for_each_entry_rcu(con, &connection_hash[i], list) 2975e9ccc37SChristine Caulfield conn_func(con); 2985e9ccc37SChristine Caulfield } 2996ed7257bSPatrick Caulfield } 3006ed7257bSPatrick Caulfield 30136b71a8bSDavid Teigland static struct dlm_node_addr *find_node_addr(int nodeid) 3026ed7257bSPatrick Caulfield { 30336b71a8bSDavid Teigland struct dlm_node_addr *na; 30436b71a8bSDavid Teigland 30536b71a8bSDavid Teigland list_for_each_entry(na, &dlm_node_addrs, list) { 30636b71a8bSDavid Teigland if (na->nodeid == nodeid) 30736b71a8bSDavid Teigland return na; 30836b71a8bSDavid Teigland } 30936b71a8bSDavid Teigland return NULL; 31036b71a8bSDavid Teigland } 31136b71a8bSDavid Teigland 31240c6b83eSAlexander Aring static int addr_compare(const struct sockaddr_storage *x, 31340c6b83eSAlexander Aring const struct sockaddr_storage *y) 31436b71a8bSDavid Teigland { 31536b71a8bSDavid Teigland switch (x->ss_family) { 31636b71a8bSDavid Teigland case AF_INET: { 31736b71a8bSDavid Teigland struct sockaddr_in *sinx = (struct sockaddr_in *)x; 31836b71a8bSDavid Teigland struct sockaddr_in *siny = (struct sockaddr_in *)y; 31936b71a8bSDavid Teigland if (sinx->sin_addr.s_addr != siny->sin_addr.s_addr) 32036b71a8bSDavid Teigland return 0; 32136b71a8bSDavid Teigland if (sinx->sin_port != siny->sin_port) 32236b71a8bSDavid Teigland return 0; 32336b71a8bSDavid Teigland break; 32436b71a8bSDavid Teigland } 32536b71a8bSDavid Teigland case AF_INET6: { 32636b71a8bSDavid Teigland struct sockaddr_in6 *sinx = (struct sockaddr_in6 *)x; 32736b71a8bSDavid Teigland struct sockaddr_in6 *siny = (struct sockaddr_in6 *)y; 32836b71a8bSDavid Teigland if (!ipv6_addr_equal(&sinx->sin6_addr, &siny->sin6_addr)) 32936b71a8bSDavid Teigland return 0; 33036b71a8bSDavid Teigland if (sinx->sin6_port != siny->sin6_port) 33136b71a8bSDavid Teigland return 0; 33236b71a8bSDavid Teigland break; 33336b71a8bSDavid Teigland } 33436b71a8bSDavid Teigland default: 33536b71a8bSDavid Teigland return 0; 33636b71a8bSDavid Teigland } 33736b71a8bSDavid Teigland return 1; 33836b71a8bSDavid Teigland } 33936b71a8bSDavid Teigland 34036b71a8bSDavid Teigland static int nodeid_to_addr(int nodeid, struct sockaddr_storage *sas_out, 341e125fbebSAlexander Aring struct sockaddr *sa_out, bool try_new_addr, 342e125fbebSAlexander Aring unsigned int *mark) 34336b71a8bSDavid Teigland { 34436b71a8bSDavid Teigland struct sockaddr_storage sas; 34536b71a8bSDavid Teigland struct dlm_node_addr *na; 3466ed7257bSPatrick Caulfield 3476ed7257bSPatrick Caulfield if (!dlm_local_count) 3486ed7257bSPatrick Caulfield return -1; 3496ed7257bSPatrick Caulfield 35036b71a8bSDavid Teigland spin_lock(&dlm_node_addrs_spin); 35136b71a8bSDavid Teigland na = find_node_addr(nodeid); 35298e1b60eSMike Christie if (na && na->addr_count) { 353ee44b4bcSMarcelo Ricardo Leitner memcpy(&sas, na->addr[na->curr_addr_index], 354ee44b4bcSMarcelo Ricardo Leitner sizeof(struct sockaddr_storage)); 355ee44b4bcSMarcelo Ricardo Leitner 35698e1b60eSMike Christie if (try_new_addr) { 35798e1b60eSMike Christie na->curr_addr_index++; 35898e1b60eSMike Christie if (na->curr_addr_index == na->addr_count) 35998e1b60eSMike Christie na->curr_addr_index = 0; 36098e1b60eSMike Christie } 36198e1b60eSMike Christie } 36236b71a8bSDavid Teigland spin_unlock(&dlm_node_addrs_spin); 36336b71a8bSDavid Teigland 36436b71a8bSDavid Teigland if (!na) 36536b71a8bSDavid Teigland return -EEXIST; 36636b71a8bSDavid Teigland 36736b71a8bSDavid Teigland if (!na->addr_count) 36836b71a8bSDavid Teigland return -ENOENT; 36936b71a8bSDavid Teigland 370e125fbebSAlexander Aring *mark = na->mark; 371e125fbebSAlexander Aring 37236b71a8bSDavid Teigland if (sas_out) 37336b71a8bSDavid Teigland memcpy(sas_out, &sas, sizeof(struct sockaddr_storage)); 37436b71a8bSDavid Teigland 37536b71a8bSDavid Teigland if (!sa_out) 37636b71a8bSDavid Teigland return 0; 3776ed7257bSPatrick Caulfield 3786ed7257bSPatrick Caulfield if (dlm_local_addr[0]->ss_family == AF_INET) { 37936b71a8bSDavid Teigland struct sockaddr_in *in4 = (struct sockaddr_in *) &sas; 38036b71a8bSDavid Teigland struct sockaddr_in *ret4 = (struct sockaddr_in *) sa_out; 3816ed7257bSPatrick Caulfield ret4->sin_addr.s_addr = in4->sin_addr.s_addr; 3826ed7257bSPatrick Caulfield } else { 38336b71a8bSDavid Teigland struct sockaddr_in6 *in6 = (struct sockaddr_in6 *) &sas; 38436b71a8bSDavid Teigland struct sockaddr_in6 *ret6 = (struct sockaddr_in6 *) sa_out; 3854e3fd7a0SAlexey Dobriyan ret6->sin6_addr = in6->sin6_addr; 3866ed7257bSPatrick Caulfield } 3876ed7257bSPatrick Caulfield 3886ed7257bSPatrick Caulfield return 0; 3896ed7257bSPatrick Caulfield } 3906ed7257bSPatrick Caulfield 391e125fbebSAlexander Aring static int addr_to_nodeid(struct sockaddr_storage *addr, int *nodeid, 392e125fbebSAlexander Aring unsigned int *mark) 39336b71a8bSDavid Teigland { 39436b71a8bSDavid Teigland struct dlm_node_addr *na; 39536b71a8bSDavid Teigland int rv = -EEXIST; 39698e1b60eSMike Christie int addr_i; 39736b71a8bSDavid Teigland 39836b71a8bSDavid Teigland spin_lock(&dlm_node_addrs_spin); 39936b71a8bSDavid Teigland list_for_each_entry(na, &dlm_node_addrs, list) { 40036b71a8bSDavid Teigland if (!na->addr_count) 40136b71a8bSDavid Teigland continue; 40236b71a8bSDavid Teigland 40398e1b60eSMike Christie for (addr_i = 0; addr_i < na->addr_count; addr_i++) { 40498e1b60eSMike Christie if (addr_compare(na->addr[addr_i], addr)) { 40536b71a8bSDavid Teigland *nodeid = na->nodeid; 406e125fbebSAlexander Aring *mark = na->mark; 40736b71a8bSDavid Teigland rv = 0; 40898e1b60eSMike Christie goto unlock; 40936b71a8bSDavid Teigland } 41098e1b60eSMike Christie } 41198e1b60eSMike Christie } 41298e1b60eSMike Christie unlock: 41336b71a8bSDavid Teigland spin_unlock(&dlm_node_addrs_spin); 41436b71a8bSDavid Teigland return rv; 41536b71a8bSDavid Teigland } 41636b71a8bSDavid Teigland 4174f19d071SAlexander Aring /* caller need to held dlm_node_addrs_spin lock */ 4184f19d071SAlexander Aring static bool dlm_lowcomms_na_has_addr(const struct dlm_node_addr *na, 4194f19d071SAlexander Aring const struct sockaddr_storage *addr) 4204f19d071SAlexander Aring { 4214f19d071SAlexander Aring int i; 4224f19d071SAlexander Aring 4234f19d071SAlexander Aring for (i = 0; i < na->addr_count; i++) { 4244f19d071SAlexander Aring if (addr_compare(na->addr[i], addr)) 4254f19d071SAlexander Aring return true; 4264f19d071SAlexander Aring } 4274f19d071SAlexander Aring 4284f19d071SAlexander Aring return false; 4294f19d071SAlexander Aring } 4304f19d071SAlexander Aring 43136b71a8bSDavid Teigland int dlm_lowcomms_addr(int nodeid, struct sockaddr_storage *addr, int len) 43236b71a8bSDavid Teigland { 43336b71a8bSDavid Teigland struct sockaddr_storage *new_addr; 43436b71a8bSDavid Teigland struct dlm_node_addr *new_node, *na; 4354f19d071SAlexander Aring bool ret; 43636b71a8bSDavid Teigland 43736b71a8bSDavid Teigland new_node = kzalloc(sizeof(struct dlm_node_addr), GFP_NOFS); 43836b71a8bSDavid Teigland if (!new_node) 43936b71a8bSDavid Teigland return -ENOMEM; 44036b71a8bSDavid Teigland 44136b71a8bSDavid Teigland new_addr = kzalloc(sizeof(struct sockaddr_storage), GFP_NOFS); 44236b71a8bSDavid Teigland if (!new_addr) { 44336b71a8bSDavid Teigland kfree(new_node); 44436b71a8bSDavid Teigland return -ENOMEM; 44536b71a8bSDavid Teigland } 44636b71a8bSDavid Teigland 44736b71a8bSDavid Teigland memcpy(new_addr, addr, len); 44836b71a8bSDavid Teigland 44936b71a8bSDavid Teigland spin_lock(&dlm_node_addrs_spin); 45036b71a8bSDavid Teigland na = find_node_addr(nodeid); 45136b71a8bSDavid Teigland if (!na) { 45236b71a8bSDavid Teigland new_node->nodeid = nodeid; 45336b71a8bSDavid Teigland new_node->addr[0] = new_addr; 45436b71a8bSDavid Teigland new_node->addr_count = 1; 455e125fbebSAlexander Aring new_node->mark = dlm_config.ci_mark; 45636b71a8bSDavid Teigland list_add(&new_node->list, &dlm_node_addrs); 45736b71a8bSDavid Teigland spin_unlock(&dlm_node_addrs_spin); 45836b71a8bSDavid Teigland return 0; 45936b71a8bSDavid Teigland } 46036b71a8bSDavid Teigland 4614f19d071SAlexander Aring ret = dlm_lowcomms_na_has_addr(na, addr); 4624f19d071SAlexander Aring if (ret) { 4634f19d071SAlexander Aring spin_unlock(&dlm_node_addrs_spin); 4644f19d071SAlexander Aring kfree(new_addr); 4654f19d071SAlexander Aring kfree(new_node); 4664f19d071SAlexander Aring return -EEXIST; 4674f19d071SAlexander Aring } 4684f19d071SAlexander Aring 46936b71a8bSDavid Teigland if (na->addr_count >= DLM_MAX_ADDR_COUNT) { 47036b71a8bSDavid Teigland spin_unlock(&dlm_node_addrs_spin); 47136b71a8bSDavid Teigland kfree(new_addr); 47236b71a8bSDavid Teigland kfree(new_node); 47336b71a8bSDavid Teigland return -ENOSPC; 47436b71a8bSDavid Teigland } 47536b71a8bSDavid Teigland 47636b71a8bSDavid Teigland na->addr[na->addr_count++] = new_addr; 47736b71a8bSDavid Teigland spin_unlock(&dlm_node_addrs_spin); 47836b71a8bSDavid Teigland kfree(new_node); 47936b71a8bSDavid Teigland return 0; 48036b71a8bSDavid Teigland } 48136b71a8bSDavid Teigland 4826ed7257bSPatrick Caulfield /* Data available on socket or listen socket received a connect */ 483676d2369SDavid S. Miller static void lowcomms_data_ready(struct sock *sk) 4846ed7257bSPatrick Caulfield { 48593eaadebStsutomu.owa@toshiba.co.jp struct connection *con; 48693eaadebStsutomu.owa@toshiba.co.jp 48793eaadebStsutomu.owa@toshiba.co.jp read_lock_bh(&sk->sk_callback_lock); 48893eaadebStsutomu.owa@toshiba.co.jp con = sock2con(sk); 489afb853fbSPatrick Caulfield if (con && !test_and_set_bit(CF_READ_PENDING, &con->flags)) 4906ed7257bSPatrick Caulfield queue_work(recv_workqueue, &con->rwork); 49193eaadebStsutomu.owa@toshiba.co.jp read_unlock_bh(&sk->sk_callback_lock); 4926ed7257bSPatrick Caulfield } 4936ed7257bSPatrick Caulfield 494d11ccd45SAlexander Aring static void lowcomms_listen_data_ready(struct sock *sk) 495d11ccd45SAlexander Aring { 4969a4139a7SAlexander Aring if (!dlm_allow_conn) 4979a4139a7SAlexander Aring return; 4989a4139a7SAlexander Aring 499d11ccd45SAlexander Aring queue_work(recv_workqueue, &listen_con.rwork); 500d11ccd45SAlexander Aring } 501d11ccd45SAlexander Aring 5026ed7257bSPatrick Caulfield static void lowcomms_write_space(struct sock *sk) 5036ed7257bSPatrick Caulfield { 50493eaadebStsutomu.owa@toshiba.co.jp struct connection *con; 5056ed7257bSPatrick Caulfield 50693eaadebStsutomu.owa@toshiba.co.jp read_lock_bh(&sk->sk_callback_lock); 50793eaadebStsutomu.owa@toshiba.co.jp con = sock2con(sk); 508b36930ddSDavid Miller if (!con) 50993eaadebStsutomu.owa@toshiba.co.jp goto out; 510b36930ddSDavid Miller 51119633c7eSAlexander Aring if (!test_and_set_bit(CF_CONNECTED, &con->flags)) { 51219633c7eSAlexander Aring log_print("successful connected to node %d", con->nodeid); 51319633c7eSAlexander Aring queue_work(send_workqueue, &con->swork); 51419633c7eSAlexander Aring goto out; 51519633c7eSAlexander Aring } 51619633c7eSAlexander Aring 517b36930ddSDavid Miller clear_bit(SOCK_NOSPACE, &con->sock->flags); 518b36930ddSDavid Miller 519b36930ddSDavid Miller if (test_and_clear_bit(CF_APP_LIMITED, &con->flags)) { 520b36930ddSDavid Miller con->sock->sk->sk_write_pending--; 5219cd3e072SEric Dumazet clear_bit(SOCKWQ_ASYNC_NOSPACE, &con->sock->flags); 522b36930ddSDavid Miller } 523b36930ddSDavid Miller 5246ed7257bSPatrick Caulfield queue_work(send_workqueue, &con->swork); 52593eaadebStsutomu.owa@toshiba.co.jp out: 52693eaadebStsutomu.owa@toshiba.co.jp read_unlock_bh(&sk->sk_callback_lock); 5276ed7257bSPatrick Caulfield } 5286ed7257bSPatrick Caulfield 5296ed7257bSPatrick Caulfield static inline void lowcomms_connect_sock(struct connection *con) 5306ed7257bSPatrick Caulfield { 531063c4c99SLars Marowsky-Bree if (test_bit(CF_CLOSE, &con->flags)) 532063c4c99SLars Marowsky-Bree return; 5336ed7257bSPatrick Caulfield queue_work(send_workqueue, &con->swork); 53461d9102bSBob Peterson cond_resched(); 5356ed7257bSPatrick Caulfield } 5366ed7257bSPatrick Caulfield 5376ed7257bSPatrick Caulfield static void lowcomms_state_change(struct sock *sk) 5386ed7257bSPatrick Caulfield { 539ee44b4bcSMarcelo Ricardo Leitner /* SCTP layer is not calling sk_data_ready when the connection 540ee44b4bcSMarcelo Ricardo Leitner * is done, so we catch the signal through here. Also, it 541ee44b4bcSMarcelo Ricardo Leitner * doesn't switch socket state when entering shutdown, so we 542ee44b4bcSMarcelo Ricardo Leitner * skip the write in that case. 543ee44b4bcSMarcelo Ricardo Leitner */ 544ee44b4bcSMarcelo Ricardo Leitner if (sk->sk_shutdown) { 545ee44b4bcSMarcelo Ricardo Leitner if (sk->sk_shutdown == RCV_SHUTDOWN) 546ee44b4bcSMarcelo Ricardo Leitner lowcomms_data_ready(sk); 547ee44b4bcSMarcelo Ricardo Leitner } else if (sk->sk_state == TCP_ESTABLISHED) { 5486ed7257bSPatrick Caulfield lowcomms_write_space(sk); 5496ed7257bSPatrick Caulfield } 550ee44b4bcSMarcelo Ricardo Leitner } 5516ed7257bSPatrick Caulfield 552391fbdc5SChristine Caulfield int dlm_lowcomms_connect_node(int nodeid) 553391fbdc5SChristine Caulfield { 554391fbdc5SChristine Caulfield struct connection *con; 555b38bc9c2SAlexander Aring int idx; 556391fbdc5SChristine Caulfield 557391fbdc5SChristine Caulfield if (nodeid == dlm_our_nodeid()) 558391fbdc5SChristine Caulfield return 0; 559391fbdc5SChristine Caulfield 560b38bc9c2SAlexander Aring idx = srcu_read_lock(&connections_srcu); 561391fbdc5SChristine Caulfield con = nodeid2con(nodeid, GFP_NOFS); 562b38bc9c2SAlexander Aring if (!con) { 563b38bc9c2SAlexander Aring srcu_read_unlock(&connections_srcu, idx); 564391fbdc5SChristine Caulfield return -ENOMEM; 565b38bc9c2SAlexander Aring } 566b38bc9c2SAlexander Aring 567391fbdc5SChristine Caulfield lowcomms_connect_sock(con); 568b38bc9c2SAlexander Aring srcu_read_unlock(&connections_srcu, idx); 569b38bc9c2SAlexander Aring 570391fbdc5SChristine Caulfield return 0; 571391fbdc5SChristine Caulfield } 572391fbdc5SChristine Caulfield 573e125fbebSAlexander Aring int dlm_lowcomms_nodes_set_mark(int nodeid, unsigned int mark) 574e125fbebSAlexander Aring { 575e125fbebSAlexander Aring struct dlm_node_addr *na; 576e125fbebSAlexander Aring 577e125fbebSAlexander Aring spin_lock(&dlm_node_addrs_spin); 578e125fbebSAlexander Aring na = find_node_addr(nodeid); 579e125fbebSAlexander Aring if (!na) { 580e125fbebSAlexander Aring spin_unlock(&dlm_node_addrs_spin); 581e125fbebSAlexander Aring return -ENOENT; 582e125fbebSAlexander Aring } 583e125fbebSAlexander Aring 584e125fbebSAlexander Aring na->mark = mark; 585e125fbebSAlexander Aring spin_unlock(&dlm_node_addrs_spin); 586e125fbebSAlexander Aring 587e125fbebSAlexander Aring return 0; 588e125fbebSAlexander Aring } 589e125fbebSAlexander Aring 590b3a5bbfdSBob Peterson static void lowcomms_error_report(struct sock *sk) 591b3a5bbfdSBob Peterson { 592b81171cbSBob Peterson struct connection *con; 593b3a5bbfdSBob Peterson struct sockaddr_storage saddr; 594b81171cbSBob Peterson void (*orig_report)(struct sock *) = NULL; 595b3a5bbfdSBob Peterson 596b81171cbSBob Peterson read_lock_bh(&sk->sk_callback_lock); 597b81171cbSBob Peterson con = sock2con(sk); 598b81171cbSBob Peterson if (con == NULL) 599b81171cbSBob Peterson goto out; 600b81171cbSBob Peterson 601cc661fc9SBob Peterson orig_report = listen_sock.sk_error_report; 602feb704bdSAlexander Aring if (kernel_getpeername(sk->sk_socket, (struct sockaddr *)&saddr) < 0) { 603b3a5bbfdSBob Peterson printk_ratelimited(KERN_ERR "dlm: node %d: socket error " 604b3a5bbfdSBob Peterson "sending to node %d, port %d, " 605b3a5bbfdSBob Peterson "sk_err=%d/%d\n", dlm_our_nodeid(), 606b3a5bbfdSBob Peterson con->nodeid, dlm_config.ci_tcp_port, 607b3a5bbfdSBob Peterson sk->sk_err, sk->sk_err_soft); 608b3a5bbfdSBob Peterson } else if (saddr.ss_family == AF_INET) { 609b3a5bbfdSBob Peterson struct sockaddr_in *sin4 = (struct sockaddr_in *)&saddr; 610b3a5bbfdSBob Peterson 611b3a5bbfdSBob Peterson printk_ratelimited(KERN_ERR "dlm: node %d: socket error " 612b3a5bbfdSBob Peterson "sending to node %d at %pI4, port %d, " 613b3a5bbfdSBob Peterson "sk_err=%d/%d\n", dlm_our_nodeid(), 614b3a5bbfdSBob Peterson con->nodeid, &sin4->sin_addr.s_addr, 615b3a5bbfdSBob Peterson dlm_config.ci_tcp_port, sk->sk_err, 616b3a5bbfdSBob Peterson sk->sk_err_soft); 617b3a5bbfdSBob Peterson } else { 618b3a5bbfdSBob Peterson struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)&saddr; 619b3a5bbfdSBob Peterson 620b3a5bbfdSBob Peterson printk_ratelimited(KERN_ERR "dlm: node %d: socket error " 621b3a5bbfdSBob Peterson "sending to node %d at %u.%u.%u.%u, " 622b3a5bbfdSBob Peterson "port %d, sk_err=%d/%d\n", dlm_our_nodeid(), 623b3a5bbfdSBob Peterson con->nodeid, sin6->sin6_addr.s6_addr32[0], 624b3a5bbfdSBob Peterson sin6->sin6_addr.s6_addr32[1], 625b3a5bbfdSBob Peterson sin6->sin6_addr.s6_addr32[2], 626b3a5bbfdSBob Peterson sin6->sin6_addr.s6_addr32[3], 627b3a5bbfdSBob Peterson dlm_config.ci_tcp_port, sk->sk_err, 628b3a5bbfdSBob Peterson sk->sk_err_soft); 629b3a5bbfdSBob Peterson } 630ba868d9dSAlexander Aring 631ba868d9dSAlexander Aring /* below sendcon only handling */ 632ba868d9dSAlexander Aring if (test_bit(CF_IS_OTHERCON, &con->flags)) 633ba868d9dSAlexander Aring con = con->sendcon; 634ba868d9dSAlexander Aring 635ba868d9dSAlexander Aring switch (sk->sk_err) { 636ba868d9dSAlexander Aring case ECONNREFUSED: 637ba868d9dSAlexander Aring set_bit(CF_DELAY_CONNECT, &con->flags); 638ba868d9dSAlexander Aring break; 639ba868d9dSAlexander Aring default: 640ba868d9dSAlexander Aring break; 641ba868d9dSAlexander Aring } 642ba868d9dSAlexander Aring 643ba868d9dSAlexander Aring if (!test_and_set_bit(CF_RECONNECT, &con->flags)) 644ba868d9dSAlexander Aring queue_work(send_workqueue, &con->swork); 645ba868d9dSAlexander Aring 646b81171cbSBob Peterson out: 647b81171cbSBob Peterson read_unlock_bh(&sk->sk_callback_lock); 648b81171cbSBob Peterson if (orig_report) 649b81171cbSBob Peterson orig_report(sk); 650b81171cbSBob Peterson } 651b81171cbSBob Peterson 652b81171cbSBob Peterson /* Note: sk_callback_lock must be locked before calling this function. */ 653cc661fc9SBob Peterson static void save_listen_callbacks(struct socket *sock) 654b81171cbSBob Peterson { 655cc661fc9SBob Peterson struct sock *sk = sock->sk; 656cc661fc9SBob Peterson 657cc661fc9SBob Peterson listen_sock.sk_data_ready = sk->sk_data_ready; 658cc661fc9SBob Peterson listen_sock.sk_state_change = sk->sk_state_change; 659cc661fc9SBob Peterson listen_sock.sk_write_space = sk->sk_write_space; 660cc661fc9SBob Peterson listen_sock.sk_error_report = sk->sk_error_report; 661b81171cbSBob Peterson } 662b81171cbSBob Peterson 663cc661fc9SBob Peterson static void restore_callbacks(struct socket *sock) 664b81171cbSBob Peterson { 665cc661fc9SBob Peterson struct sock *sk = sock->sk; 666cc661fc9SBob Peterson 667b81171cbSBob Peterson write_lock_bh(&sk->sk_callback_lock); 668b81171cbSBob Peterson sk->sk_user_data = NULL; 669cc661fc9SBob Peterson sk->sk_data_ready = listen_sock.sk_data_ready; 670cc661fc9SBob Peterson sk->sk_state_change = listen_sock.sk_state_change; 671cc661fc9SBob Peterson sk->sk_write_space = listen_sock.sk_write_space; 672cc661fc9SBob Peterson sk->sk_error_report = listen_sock.sk_error_report; 673b81171cbSBob Peterson write_unlock_bh(&sk->sk_callback_lock); 674b3a5bbfdSBob Peterson } 675b3a5bbfdSBob Peterson 676d11ccd45SAlexander Aring static void add_listen_sock(struct socket *sock, struct listen_connection *con) 677d11ccd45SAlexander Aring { 678d11ccd45SAlexander Aring struct sock *sk = sock->sk; 679d11ccd45SAlexander Aring 680d11ccd45SAlexander Aring write_lock_bh(&sk->sk_callback_lock); 681d11ccd45SAlexander Aring save_listen_callbacks(sock); 682d11ccd45SAlexander Aring con->sock = sock; 683d11ccd45SAlexander Aring 684d11ccd45SAlexander Aring sk->sk_user_data = con; 685d11ccd45SAlexander Aring sk->sk_allocation = GFP_NOFS; 686d11ccd45SAlexander Aring /* Install a data_ready callback */ 687d11ccd45SAlexander Aring sk->sk_data_ready = lowcomms_listen_data_ready; 688d11ccd45SAlexander Aring write_unlock_bh(&sk->sk_callback_lock); 689d11ccd45SAlexander Aring } 690d11ccd45SAlexander Aring 6916ed7257bSPatrick Caulfield /* Make a socket active */ 692988419a9Stsutomu.owa@toshiba.co.jp static void add_sock(struct socket *sock, struct connection *con) 6936ed7257bSPatrick Caulfield { 694b81171cbSBob Peterson struct sock *sk = sock->sk; 695b81171cbSBob Peterson 696b81171cbSBob Peterson write_lock_bh(&sk->sk_callback_lock); 6976ed7257bSPatrick Caulfield con->sock = sock; 6986ed7257bSPatrick Caulfield 699b81171cbSBob Peterson sk->sk_user_data = con; 7006ed7257bSPatrick Caulfield /* Install a data_ready callback */ 701b81171cbSBob Peterson sk->sk_data_ready = lowcomms_data_ready; 702b81171cbSBob Peterson sk->sk_write_space = lowcomms_write_space; 703b81171cbSBob Peterson sk->sk_state_change = lowcomms_state_change; 704b81171cbSBob Peterson sk->sk_allocation = GFP_NOFS; 705b81171cbSBob Peterson sk->sk_error_report = lowcomms_error_report; 706b81171cbSBob Peterson write_unlock_bh(&sk->sk_callback_lock); 7076ed7257bSPatrick Caulfield } 7086ed7257bSPatrick Caulfield 7096ed7257bSPatrick Caulfield /* Add the port number to an IPv6 or 4 sockaddr and return the address 7106ed7257bSPatrick Caulfield length */ 7116ed7257bSPatrick Caulfield static void make_sockaddr(struct sockaddr_storage *saddr, uint16_t port, 7126ed7257bSPatrick Caulfield int *addr_len) 7136ed7257bSPatrick Caulfield { 7146ed7257bSPatrick Caulfield saddr->ss_family = dlm_local_addr[0]->ss_family; 7156ed7257bSPatrick Caulfield if (saddr->ss_family == AF_INET) { 7166ed7257bSPatrick Caulfield struct sockaddr_in *in4_addr = (struct sockaddr_in *)saddr; 7176ed7257bSPatrick Caulfield in4_addr->sin_port = cpu_to_be16(port); 7186ed7257bSPatrick Caulfield *addr_len = sizeof(struct sockaddr_in); 7196ed7257bSPatrick Caulfield memset(&in4_addr->sin_zero, 0, sizeof(in4_addr->sin_zero)); 7206ed7257bSPatrick Caulfield } else { 7216ed7257bSPatrick Caulfield struct sockaddr_in6 *in6_addr = (struct sockaddr_in6 *)saddr; 7226ed7257bSPatrick Caulfield in6_addr->sin6_port = cpu_to_be16(port); 7236ed7257bSPatrick Caulfield *addr_len = sizeof(struct sockaddr_in6); 7246ed7257bSPatrick Caulfield } 72501c8cab2SPatrick Caulfield memset((char *)saddr + *addr_len, 0, sizeof(struct sockaddr_storage) - *addr_len); 7266ed7257bSPatrick Caulfield } 7276ed7257bSPatrick Caulfield 728706474fbSAlexander Aring static void dlm_page_release(struct kref *kref) 729706474fbSAlexander Aring { 730706474fbSAlexander Aring struct writequeue_entry *e = container_of(kref, struct writequeue_entry, 731706474fbSAlexander Aring ref); 732706474fbSAlexander Aring 733706474fbSAlexander Aring __free_page(e->page); 734706474fbSAlexander Aring kfree(e); 735706474fbSAlexander Aring } 736706474fbSAlexander Aring 737706474fbSAlexander Aring static void dlm_msg_release(struct kref *kref) 738706474fbSAlexander Aring { 739706474fbSAlexander Aring struct dlm_msg *msg = container_of(kref, struct dlm_msg, ref); 740706474fbSAlexander Aring 741706474fbSAlexander Aring kref_put(&msg->entry->ref, dlm_page_release); 742706474fbSAlexander Aring kfree(msg); 743706474fbSAlexander Aring } 744706474fbSAlexander Aring 745706474fbSAlexander Aring static void free_entry(struct writequeue_entry *e) 746706474fbSAlexander Aring { 747706474fbSAlexander Aring struct dlm_msg *msg, *tmp; 748706474fbSAlexander Aring 749706474fbSAlexander Aring list_for_each_entry_safe(msg, tmp, &e->msgs, list) { 750706474fbSAlexander Aring if (msg->orig_msg) { 751706474fbSAlexander Aring msg->orig_msg->retransmit = false; 752706474fbSAlexander Aring kref_put(&msg->orig_msg->ref, dlm_msg_release); 753706474fbSAlexander Aring } 754706474fbSAlexander Aring 755706474fbSAlexander Aring list_del(&msg->list); 756706474fbSAlexander Aring kref_put(&msg->ref, dlm_msg_release); 757706474fbSAlexander Aring } 758706474fbSAlexander Aring 759706474fbSAlexander Aring list_del(&e->list); 760706474fbSAlexander Aring atomic_dec(&e->con->writequeue_cnt); 761706474fbSAlexander Aring kref_put(&e->ref, dlm_page_release); 762706474fbSAlexander Aring } 763706474fbSAlexander Aring 764d11ccd45SAlexander Aring static void dlm_close_sock(struct socket **sock) 765d11ccd45SAlexander Aring { 766d11ccd45SAlexander Aring if (*sock) { 767d11ccd45SAlexander Aring restore_callbacks(*sock); 768d11ccd45SAlexander Aring sock_release(*sock); 769d11ccd45SAlexander Aring *sock = NULL; 770d11ccd45SAlexander Aring } 771d11ccd45SAlexander Aring } 772d11ccd45SAlexander Aring 7736ed7257bSPatrick Caulfield /* Close a remote connection and tidy up */ 7740d737a8cSMarcelo Ricardo Leitner static void close_connection(struct connection *con, bool and_other, 7750d737a8cSMarcelo Ricardo Leitner bool tx, bool rx) 7766ed7257bSPatrick Caulfield { 777b2a66629Stsutomu.owa@toshiba.co.jp bool closing = test_and_set_bit(CF_CLOSING, &con->flags); 778706474fbSAlexander Aring struct writequeue_entry *e; 779b2a66629Stsutomu.owa@toshiba.co.jp 7800aa18464Stsutomu.owa@toshiba.co.jp if (tx && !closing && cancel_work_sync(&con->swork)) { 7810d737a8cSMarcelo Ricardo Leitner log_print("canceled swork for node %d", con->nodeid); 7820aa18464Stsutomu.owa@toshiba.co.jp clear_bit(CF_WRITE_PENDING, &con->flags); 7830aa18464Stsutomu.owa@toshiba.co.jp } 7840aa18464Stsutomu.owa@toshiba.co.jp if (rx && !closing && cancel_work_sync(&con->rwork)) { 7850d737a8cSMarcelo Ricardo Leitner log_print("canceled rwork for node %d", con->nodeid); 7860aa18464Stsutomu.owa@toshiba.co.jp clear_bit(CF_READ_PENDING, &con->flags); 7870aa18464Stsutomu.owa@toshiba.co.jp } 7886ed7257bSPatrick Caulfield 7890d737a8cSMarcelo Ricardo Leitner mutex_lock(&con->sock_mutex); 790d11ccd45SAlexander Aring dlm_close_sock(&con->sock); 791d11ccd45SAlexander Aring 7926ed7257bSPatrick Caulfield if (con->othercon && and_other) { 7936ed7257bSPatrick Caulfield /* Will only re-enter once. */ 794c6aa00e3SAlexander Aring close_connection(con->othercon, false, tx, rx); 7956ed7257bSPatrick Caulfield } 7969e5f2825SPatrick Caulfield 797706474fbSAlexander Aring /* if we send a writequeue entry only a half way, we drop the 798706474fbSAlexander Aring * whole entry because reconnection and that we not start of the 799706474fbSAlexander Aring * middle of a msg which will confuse the other end. 800706474fbSAlexander Aring * 801706474fbSAlexander Aring * we can always drop messages because retransmits, but what we 802706474fbSAlexander Aring * cannot allow is to transmit half messages which may be processed 803706474fbSAlexander Aring * at the other side. 804706474fbSAlexander Aring * 805706474fbSAlexander Aring * our policy is to start on a clean state when disconnects, we don't 806706474fbSAlexander Aring * know what's send/received on transport layer in this case. 807706474fbSAlexander Aring */ 808706474fbSAlexander Aring spin_lock(&con->writequeue_lock); 809706474fbSAlexander Aring if (!list_empty(&con->writequeue)) { 810706474fbSAlexander Aring e = list_first_entry(&con->writequeue, struct writequeue_entry, 811706474fbSAlexander Aring list); 812706474fbSAlexander Aring if (e->dirty) 813706474fbSAlexander Aring free_entry(e); 814706474fbSAlexander Aring } 815706474fbSAlexander Aring spin_unlock(&con->writequeue_lock); 816706474fbSAlexander Aring 8174798cbbfSAlexander Aring con->rx_leftover = 0; 8186ed7257bSPatrick Caulfield con->retries = 0; 819052849beSAlexander Aring clear_bit(CF_APP_LIMITED, &con->flags); 82019633c7eSAlexander Aring clear_bit(CF_CONNECTED, &con->flags); 821ba868d9dSAlexander Aring clear_bit(CF_DELAY_CONNECT, &con->flags); 822ba868d9dSAlexander Aring clear_bit(CF_RECONNECT, &con->flags); 8238aa31cbfSAlexander Aring clear_bit(CF_EOF, &con->flags); 8246ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 825b2a66629Stsutomu.owa@toshiba.co.jp clear_bit(CF_CLOSING, &con->flags); 8266ed7257bSPatrick Caulfield } 8276ed7257bSPatrick Caulfield 828055923bfSAlexander Aring static void shutdown_connection(struct connection *con) 829055923bfSAlexander Aring { 830055923bfSAlexander Aring int ret; 831055923bfSAlexander Aring 832eec054b5SAlexander Aring flush_work(&con->swork); 833055923bfSAlexander Aring 834055923bfSAlexander Aring mutex_lock(&con->sock_mutex); 835055923bfSAlexander Aring /* nothing to shutdown */ 836055923bfSAlexander Aring if (!con->sock) { 837055923bfSAlexander Aring mutex_unlock(&con->sock_mutex); 838055923bfSAlexander Aring return; 839055923bfSAlexander Aring } 840055923bfSAlexander Aring 841055923bfSAlexander Aring set_bit(CF_SHUTDOWN, &con->flags); 842055923bfSAlexander Aring ret = kernel_sock_shutdown(con->sock, SHUT_WR); 843055923bfSAlexander Aring mutex_unlock(&con->sock_mutex); 844055923bfSAlexander Aring if (ret) { 845055923bfSAlexander Aring log_print("Connection %p failed to shutdown: %d will force close", 846055923bfSAlexander Aring con, ret); 847055923bfSAlexander Aring goto force_close; 848055923bfSAlexander Aring } else { 849055923bfSAlexander Aring ret = wait_event_timeout(con->shutdown_wait, 850055923bfSAlexander Aring !test_bit(CF_SHUTDOWN, &con->flags), 851055923bfSAlexander Aring DLM_SHUTDOWN_WAIT_TIMEOUT); 852055923bfSAlexander Aring if (ret == 0) { 853055923bfSAlexander Aring log_print("Connection %p shutdown timed out, will force close", 854055923bfSAlexander Aring con); 855055923bfSAlexander Aring goto force_close; 856055923bfSAlexander Aring } 857055923bfSAlexander Aring } 858055923bfSAlexander Aring 859055923bfSAlexander Aring return; 860055923bfSAlexander Aring 861055923bfSAlexander Aring force_close: 862055923bfSAlexander Aring clear_bit(CF_SHUTDOWN, &con->flags); 863055923bfSAlexander Aring close_connection(con, false, true, true); 864055923bfSAlexander Aring } 865055923bfSAlexander Aring 866055923bfSAlexander Aring static void dlm_tcp_shutdown(struct connection *con) 867055923bfSAlexander Aring { 868055923bfSAlexander Aring if (con->othercon) 869055923bfSAlexander Aring shutdown_connection(con->othercon); 870055923bfSAlexander Aring shutdown_connection(con); 871055923bfSAlexander Aring } 872055923bfSAlexander Aring 8734798cbbfSAlexander Aring static int con_realloc_receive_buf(struct connection *con, int newlen) 8744798cbbfSAlexander Aring { 8754798cbbfSAlexander Aring unsigned char *newbuf; 8764798cbbfSAlexander Aring 8774798cbbfSAlexander Aring newbuf = kmalloc(newlen, GFP_NOFS); 8784798cbbfSAlexander Aring if (!newbuf) 8794798cbbfSAlexander Aring return -ENOMEM; 8804798cbbfSAlexander Aring 8814798cbbfSAlexander Aring /* copy any leftover from last receive */ 8824798cbbfSAlexander Aring if (con->rx_leftover) 8834798cbbfSAlexander Aring memmove(newbuf, con->rx_buf, con->rx_leftover); 8844798cbbfSAlexander Aring 8854798cbbfSAlexander Aring /* swap to new buffer space */ 8864798cbbfSAlexander Aring kfree(con->rx_buf); 8874798cbbfSAlexander Aring con->rx_buflen = newlen; 8884798cbbfSAlexander Aring con->rx_buf = newbuf; 8894798cbbfSAlexander Aring 8904798cbbfSAlexander Aring return 0; 8914798cbbfSAlexander Aring } 8924798cbbfSAlexander Aring 8936ed7257bSPatrick Caulfield /* Data received from remote end */ 8946ed7257bSPatrick Caulfield static int receive_from_sock(struct connection *con) 8956ed7257bSPatrick Caulfield { 8966ed7257bSPatrick Caulfield int call_again_soon = 0; 8974798cbbfSAlexander Aring struct msghdr msg; 8984798cbbfSAlexander Aring struct kvec iov; 8994798cbbfSAlexander Aring int ret, buflen; 9006ed7257bSPatrick Caulfield 9016ed7257bSPatrick Caulfield mutex_lock(&con->sock_mutex); 9026ed7257bSPatrick Caulfield 9036ed7257bSPatrick Caulfield if (con->sock == NULL) { 9046ed7257bSPatrick Caulfield ret = -EAGAIN; 9056ed7257bSPatrick Caulfield goto out_close; 9066ed7257bSPatrick Caulfield } 9074798cbbfSAlexander Aring 9084798cbbfSAlexander Aring /* realloc if we get new buffer size to read out */ 9094798cbbfSAlexander Aring buflen = dlm_config.ci_buffer_size; 9104798cbbfSAlexander Aring if (con->rx_buflen != buflen && con->rx_leftover <= buflen) { 9114798cbbfSAlexander Aring ret = con_realloc_receive_buf(con, buflen); 9124798cbbfSAlexander Aring if (ret < 0) 9136ed7257bSPatrick Caulfield goto out_resched; 9146ed7257bSPatrick Caulfield } 9156ed7257bSPatrick Caulfield 9164798cbbfSAlexander Aring /* calculate new buffer parameter regarding last receive and 9174798cbbfSAlexander Aring * possible leftover bytes 9186ed7257bSPatrick Caulfield */ 9194798cbbfSAlexander Aring iov.iov_base = con->rx_buf + con->rx_leftover; 9204798cbbfSAlexander Aring iov.iov_len = con->rx_buflen - con->rx_leftover; 9216ed7257bSPatrick Caulfield 9224798cbbfSAlexander Aring memset(&msg, 0, sizeof(msg)); 9234798cbbfSAlexander Aring msg.msg_flags = MSG_DONTWAIT | MSG_NOSIGNAL; 9244798cbbfSAlexander Aring ret = kernel_recvmsg(con->sock, &msg, &iov, 1, iov.iov_len, 9254798cbbfSAlexander Aring msg.msg_flags); 9266ed7257bSPatrick Caulfield if (ret <= 0) 9276ed7257bSPatrick Caulfield goto out_close; 9284798cbbfSAlexander Aring else if (ret == iov.iov_len) 929ee44b4bcSMarcelo Ricardo Leitner call_again_soon = 1; 9306ed7257bSPatrick Caulfield 9314798cbbfSAlexander Aring /* new buflen according readed bytes and leftover from last receive */ 9324798cbbfSAlexander Aring buflen = ret + con->rx_leftover; 9334798cbbfSAlexander Aring ret = dlm_process_incoming_buffer(con->nodeid, con->rx_buf, buflen); 9344798cbbfSAlexander Aring if (ret < 0) 9354798cbbfSAlexander Aring goto out_close; 9366ed7257bSPatrick Caulfield 9374798cbbfSAlexander Aring /* calculate leftover bytes from process and put it into begin of 9384798cbbfSAlexander Aring * the receive buffer, so next receive we have the full message 9394798cbbfSAlexander Aring * at the start address of the receive buffer. 9404798cbbfSAlexander Aring */ 9414798cbbfSAlexander Aring con->rx_leftover = buflen - ret; 9424798cbbfSAlexander Aring if (con->rx_leftover) { 9434798cbbfSAlexander Aring memmove(con->rx_buf, con->rx_buf + ret, 9444798cbbfSAlexander Aring con->rx_leftover); 9454798cbbfSAlexander Aring call_again_soon = true; 9466ed7257bSPatrick Caulfield } 9476ed7257bSPatrick Caulfield 9486ed7257bSPatrick Caulfield if (call_again_soon) 9496ed7257bSPatrick Caulfield goto out_resched; 9504798cbbfSAlexander Aring 9516ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 9526ed7257bSPatrick Caulfield return 0; 9536ed7257bSPatrick Caulfield 9546ed7257bSPatrick Caulfield out_resched: 9556ed7257bSPatrick Caulfield if (!test_and_set_bit(CF_READ_PENDING, &con->flags)) 9566ed7257bSPatrick Caulfield queue_work(recv_workqueue, &con->rwork); 9576ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 9586ed7257bSPatrick Caulfield return -EAGAIN; 9596ed7257bSPatrick Caulfield 9606ed7257bSPatrick Caulfield out_close: 961055923bfSAlexander Aring if (ret == 0) { 962055923bfSAlexander Aring log_print("connection %p got EOF from %d", 963055923bfSAlexander Aring con, con->nodeid); 9648aa31cbfSAlexander Aring 965a66c008cSAlexander Aring if (dlm_proto_ops->eof_condition && 966a66c008cSAlexander Aring dlm_proto_ops->eof_condition(con)) { 9678aa31cbfSAlexander Aring set_bit(CF_EOF, &con->flags); 9688aa31cbfSAlexander Aring mutex_unlock(&con->sock_mutex); 9698aa31cbfSAlexander Aring } else { 9708aa31cbfSAlexander Aring mutex_unlock(&con->sock_mutex); 9718aa31cbfSAlexander Aring close_connection(con, false, true, false); 9728aa31cbfSAlexander Aring 973055923bfSAlexander Aring /* handling for tcp shutdown */ 974055923bfSAlexander Aring clear_bit(CF_SHUTDOWN, &con->flags); 975055923bfSAlexander Aring wake_up(&con->shutdown_wait); 9768aa31cbfSAlexander Aring } 9778aa31cbfSAlexander Aring 978055923bfSAlexander Aring /* signal to breaking receive worker */ 979055923bfSAlexander Aring ret = -1; 9808aa31cbfSAlexander Aring } else { 9818aa31cbfSAlexander Aring mutex_unlock(&con->sock_mutex); 9826ed7257bSPatrick Caulfield } 9836ed7257bSPatrick Caulfield return ret; 9846ed7257bSPatrick Caulfield } 9856ed7257bSPatrick Caulfield 9866ed7257bSPatrick Caulfield /* Listening socket is busy, accept a connection */ 987d11ccd45SAlexander Aring static int accept_from_sock(struct listen_connection *con) 9886ed7257bSPatrick Caulfield { 9896ed7257bSPatrick Caulfield int result; 9906ed7257bSPatrick Caulfield struct sockaddr_storage peeraddr; 9916ed7257bSPatrick Caulfield struct socket *newsock; 992b38bc9c2SAlexander Aring int len, idx; 9936ed7257bSPatrick Caulfield int nodeid; 9946ed7257bSPatrick Caulfield struct connection *newcon; 9956ed7257bSPatrick Caulfield struct connection *addcon; 9963f78cd7dSAlexander Aring unsigned int mark; 9976ed7257bSPatrick Caulfield 998d11ccd45SAlexander Aring if (!con->sock) 9993421fb15Stsutomu.owa@toshiba.co.jp return -ENOTCONN; 10006ed7257bSPatrick Caulfield 10013421fb15Stsutomu.owa@toshiba.co.jp result = kernel_accept(con->sock, &newsock, O_NONBLOCK); 10026ed7257bSPatrick Caulfield if (result < 0) 10036ed7257bSPatrick Caulfield goto accept_err; 10046ed7257bSPatrick Caulfield 10056ed7257bSPatrick Caulfield /* Get the connected socket's peer */ 10066ed7257bSPatrick Caulfield memset(&peeraddr, 0, sizeof(peeraddr)); 10079b2c45d4SDenys Vlasenko len = newsock->ops->getname(newsock, (struct sockaddr *)&peeraddr, 2); 10089b2c45d4SDenys Vlasenko if (len < 0) { 10096ed7257bSPatrick Caulfield result = -ECONNABORTED; 10106ed7257bSPatrick Caulfield goto accept_err; 10116ed7257bSPatrick Caulfield } 10126ed7257bSPatrick Caulfield 10136ed7257bSPatrick Caulfield /* Get the new node's NODEID */ 10146ed7257bSPatrick Caulfield make_sockaddr(&peeraddr, 0, &len); 1015e125fbebSAlexander Aring if (addr_to_nodeid(&peeraddr, &nodeid, &mark)) { 1016bcaadf5cSMasatake YAMATO unsigned char *b=(unsigned char *)&peeraddr; 1017617e82e1SDavid Teigland log_print("connect from non cluster node"); 1018bcaadf5cSMasatake YAMATO print_hex_dump_bytes("ss: ", DUMP_PREFIX_NONE, 1019bcaadf5cSMasatake YAMATO b, sizeof(struct sockaddr_storage)); 10206ed7257bSPatrick Caulfield sock_release(newsock); 10216ed7257bSPatrick Caulfield return -1; 10226ed7257bSPatrick Caulfield } 10236ed7257bSPatrick Caulfield 10246ed7257bSPatrick Caulfield log_print("got connection from %d", nodeid); 10256ed7257bSPatrick Caulfield 10266ed7257bSPatrick Caulfield /* Check to see if we already have a connection to this node. This 10276ed7257bSPatrick Caulfield * could happen if the two nodes initiate a connection at roughly 10286ed7257bSPatrick Caulfield * the same time and the connections cross on the wire. 10296ed7257bSPatrick Caulfield * In this case we store the incoming one in "othercon" 10306ed7257bSPatrick Caulfield */ 1031b38bc9c2SAlexander Aring idx = srcu_read_lock(&connections_srcu); 1032748285ccSDavid Teigland newcon = nodeid2con(nodeid, GFP_NOFS); 10336ed7257bSPatrick Caulfield if (!newcon) { 1034b38bc9c2SAlexander Aring srcu_read_unlock(&connections_srcu, idx); 10356ed7257bSPatrick Caulfield result = -ENOMEM; 10366ed7257bSPatrick Caulfield goto accept_err; 10376ed7257bSPatrick Caulfield } 1038d11ccd45SAlexander Aring 1039e125fbebSAlexander Aring sock_set_mark(newsock->sk, mark); 1040e125fbebSAlexander Aring 1041d11ccd45SAlexander Aring mutex_lock(&newcon->sock_mutex); 10426ed7257bSPatrick Caulfield if (newcon->sock) { 10436ed7257bSPatrick Caulfield struct connection *othercon = newcon->othercon; 10446ed7257bSPatrick Caulfield 10456ed7257bSPatrick Caulfield if (!othercon) { 1046a47666ebSAlexander Aring othercon = kzalloc(sizeof(*othercon), GFP_NOFS); 10476ed7257bSPatrick Caulfield if (!othercon) { 1048617e82e1SDavid Teigland log_print("failed to allocate incoming socket"); 10496ed7257bSPatrick Caulfield mutex_unlock(&newcon->sock_mutex); 1050b38bc9c2SAlexander Aring srcu_read_unlock(&connections_srcu, idx); 10516ed7257bSPatrick Caulfield result = -ENOMEM; 10526ed7257bSPatrick Caulfield goto accept_err; 10536ed7257bSPatrick Caulfield } 10544798cbbfSAlexander Aring 10556cde210aSAlexander Aring result = dlm_con_init(othercon, nodeid); 10566cde210aSAlexander Aring if (result < 0) { 10574798cbbfSAlexander Aring kfree(othercon); 10582fd8db2dSYang Yingliang mutex_unlock(&newcon->sock_mutex); 1059b38bc9c2SAlexander Aring srcu_read_unlock(&connections_srcu, idx); 10604798cbbfSAlexander Aring goto accept_err; 10614798cbbfSAlexander Aring } 10624798cbbfSAlexander Aring 1063e9a470acSAlexander Aring lockdep_set_subclass(&othercon->sock_mutex, 1); 10647443bc96SAlexander Aring set_bit(CF_IS_OTHERCON, &othercon->flags); 10656cde210aSAlexander Aring newcon->othercon = othercon; 1066ba868d9dSAlexander Aring othercon->sendcon = newcon; 1067ba3ab3caSAlexander Aring } else { 1068ba3ab3caSAlexander Aring /* close other sock con if we have something new */ 1069ba3ab3caSAlexander Aring close_connection(othercon, false, true, false); 107061d96be0SPatrick Caulfield } 1071ba3ab3caSAlexander Aring 1072e9a470acSAlexander Aring mutex_lock(&othercon->sock_mutex); 1073988419a9Stsutomu.owa@toshiba.co.jp add_sock(newsock, othercon); 10746ed7257bSPatrick Caulfield addcon = othercon; 1075c7355827Stsutomu.owa@toshiba.co.jp mutex_unlock(&othercon->sock_mutex); 10766ed7257bSPatrick Caulfield } 10776ed7257bSPatrick Caulfield else { 10783735b4b9SBob Peterson /* accept copies the sk after we've saved the callbacks, so we 10793735b4b9SBob Peterson don't want to save them a second time or comm errors will 10803735b4b9SBob Peterson result in calling sk_error_report recursively. */ 1081988419a9Stsutomu.owa@toshiba.co.jp add_sock(newsock, newcon); 10826ed7257bSPatrick Caulfield addcon = newcon; 10836ed7257bSPatrick Caulfield } 10846ed7257bSPatrick Caulfield 1085b30a624fSAlexander Aring set_bit(CF_CONNECTED, &addcon->flags); 10866ed7257bSPatrick Caulfield mutex_unlock(&newcon->sock_mutex); 10876ed7257bSPatrick Caulfield 10886ed7257bSPatrick Caulfield /* 10896ed7257bSPatrick Caulfield * Add it to the active queue in case we got data 109025985edcSLucas De Marchi * between processing the accept adding the socket 10916ed7257bSPatrick Caulfield * to the read_sockets list 10926ed7257bSPatrick Caulfield */ 10936ed7257bSPatrick Caulfield if (!test_and_set_bit(CF_READ_PENDING, &addcon->flags)) 10946ed7257bSPatrick Caulfield queue_work(recv_workqueue, &addcon->rwork); 10956ed7257bSPatrick Caulfield 1096b38bc9c2SAlexander Aring srcu_read_unlock(&connections_srcu, idx); 1097b38bc9c2SAlexander Aring 10986ed7257bSPatrick Caulfield return 0; 10996ed7257bSPatrick Caulfield 11006ed7257bSPatrick Caulfield accept_err: 11013421fb15Stsutomu.owa@toshiba.co.jp if (newsock) 11026ed7257bSPatrick Caulfield sock_release(newsock); 11036ed7257bSPatrick Caulfield 11046ed7257bSPatrick Caulfield if (result != -EAGAIN) 1105617e82e1SDavid Teigland log_print("error accepting connection from node: %d", result); 11066ed7257bSPatrick Caulfield return result; 11076ed7257bSPatrick Caulfield } 11086ed7257bSPatrick Caulfield 11095d689871SMike Christie /* 11105d689871SMike Christie * writequeue_entry_complete - try to delete and free write queue entry 11115d689871SMike Christie * @e: write queue entry to try to delete 11125d689871SMike Christie * @completed: bytes completed 11135d689871SMike Christie * 11145d689871SMike Christie * writequeue_lock must be held. 11155d689871SMike Christie */ 11165d689871SMike Christie static void writequeue_entry_complete(struct writequeue_entry *e, int completed) 11175d689871SMike Christie { 11185d689871SMike Christie e->offset += completed; 11195d689871SMike Christie e->len -= completed; 1120706474fbSAlexander Aring /* signal that page was half way transmitted */ 1121706474fbSAlexander Aring e->dirty = true; 11225d689871SMike Christie 11238f2dc78dSAlexander Aring if (e->len == 0 && e->users == 0) 11245d689871SMike Christie free_entry(e); 11255d689871SMike Christie } 11265d689871SMike Christie 1127ee44b4bcSMarcelo Ricardo Leitner /* 1128ee44b4bcSMarcelo Ricardo Leitner * sctp_bind_addrs - bind a SCTP socket to all our addresses 1129ee44b4bcSMarcelo Ricardo Leitner */ 113013004e8aSAlexander Aring static int sctp_bind_addrs(struct socket *sock, uint16_t port) 1131ee44b4bcSMarcelo Ricardo Leitner { 1132ee44b4bcSMarcelo Ricardo Leitner struct sockaddr_storage localaddr; 1133c0425a42SChristoph Hellwig struct sockaddr *addr = (struct sockaddr *)&localaddr; 1134ee44b4bcSMarcelo Ricardo Leitner int i, addr_len, result = 0; 1135ee44b4bcSMarcelo Ricardo Leitner 1136ee44b4bcSMarcelo Ricardo Leitner for (i = 0; i < dlm_local_count; i++) { 1137ee44b4bcSMarcelo Ricardo Leitner memcpy(&localaddr, dlm_local_addr[i], sizeof(localaddr)); 1138ee44b4bcSMarcelo Ricardo Leitner make_sockaddr(&localaddr, port, &addr_len); 1139ee44b4bcSMarcelo Ricardo Leitner 1140ee44b4bcSMarcelo Ricardo Leitner if (!i) 114113004e8aSAlexander Aring result = kernel_bind(sock, addr, addr_len); 1142ee44b4bcSMarcelo Ricardo Leitner else 114313004e8aSAlexander Aring result = sock_bind_add(sock->sk, addr, addr_len); 1144ee44b4bcSMarcelo Ricardo Leitner 1145ee44b4bcSMarcelo Ricardo Leitner if (result < 0) { 1146ee44b4bcSMarcelo Ricardo Leitner log_print("Can't bind to %d addr number %d, %d.\n", 1147ee44b4bcSMarcelo Ricardo Leitner port, i + 1, result); 1148ee44b4bcSMarcelo Ricardo Leitner break; 1149ee44b4bcSMarcelo Ricardo Leitner } 1150ee44b4bcSMarcelo Ricardo Leitner } 1151ee44b4bcSMarcelo Ricardo Leitner return result; 1152ee44b4bcSMarcelo Ricardo Leitner } 1153ee44b4bcSMarcelo Ricardo Leitner 11546ed7257bSPatrick Caulfield /* Initiate an SCTP association. 11556ed7257bSPatrick Caulfield This is a special case of send_to_sock() in that we don't yet have a 11566ed7257bSPatrick Caulfield peeled-off socket for this association, so we use the listening socket 11576ed7257bSPatrick Caulfield and add the primary IP address of the remote node. 11586ed7257bSPatrick Caulfield */ 1159ee44b4bcSMarcelo Ricardo Leitner static void sctp_connect_to_sock(struct connection *con) 11606ed7257bSPatrick Caulfield { 1161ee44b4bcSMarcelo Ricardo Leitner struct sockaddr_storage daddr; 1162ee44b4bcSMarcelo Ricardo Leitner int result; 1163ee44b4bcSMarcelo Ricardo Leitner int addr_len; 1164ee44b4bcSMarcelo Ricardo Leitner struct socket *sock; 11659c9f168fSAlexander Aring unsigned int mark; 1166ee44b4bcSMarcelo Ricardo Leitner 11675d689871SMike Christie mutex_lock(&con->sock_mutex); 11686ed7257bSPatrick Caulfield 1169ee44b4bcSMarcelo Ricardo Leitner /* Some odd races can cause double-connects, ignore them */ 1170ee44b4bcSMarcelo Ricardo Leitner if (con->retries++ > MAX_CONNECT_RETRIES) 1171ee44b4bcSMarcelo Ricardo Leitner goto out; 1172ee44b4bcSMarcelo Ricardo Leitner 1173ee44b4bcSMarcelo Ricardo Leitner if (con->sock) { 1174ee44b4bcSMarcelo Ricardo Leitner log_print("node %d already connected.", con->nodeid); 1175ee44b4bcSMarcelo Ricardo Leitner goto out; 1176ee44b4bcSMarcelo Ricardo Leitner } 1177ee44b4bcSMarcelo Ricardo Leitner 1178ee44b4bcSMarcelo Ricardo Leitner memset(&daddr, 0, sizeof(daddr)); 1179e125fbebSAlexander Aring result = nodeid_to_addr(con->nodeid, &daddr, NULL, true, &mark); 1180ee44b4bcSMarcelo Ricardo Leitner if (result < 0) { 11816ed7257bSPatrick Caulfield log_print("no address for nodeid %d", con->nodeid); 1182ee44b4bcSMarcelo Ricardo Leitner goto out; 118304bedd79SDavid Teigland } 11846ed7257bSPatrick Caulfield 1185ee44b4bcSMarcelo Ricardo Leitner /* Create a socket to communicate with */ 1186ee44b4bcSMarcelo Ricardo Leitner result = sock_create_kern(&init_net, dlm_local_addr[0]->ss_family, 1187ee44b4bcSMarcelo Ricardo Leitner SOCK_STREAM, IPPROTO_SCTP, &sock); 1188ee44b4bcSMarcelo Ricardo Leitner if (result < 0) 1189ee44b4bcSMarcelo Ricardo Leitner goto socket_err; 11906ed7257bSPatrick Caulfield 11919c9f168fSAlexander Aring sock_set_mark(sock->sk, mark); 11929c9f168fSAlexander Aring 1193988419a9Stsutomu.owa@toshiba.co.jp add_sock(sock, con); 11946ed7257bSPatrick Caulfield 1195ee44b4bcSMarcelo Ricardo Leitner /* Bind to all addresses. */ 119613004e8aSAlexander Aring if (sctp_bind_addrs(con->sock, 0)) 1197ee44b4bcSMarcelo Ricardo Leitner goto bind_err; 119898e1b60eSMike Christie 1199ee44b4bcSMarcelo Ricardo Leitner make_sockaddr(&daddr, dlm_config.ci_tcp_port, &addr_len); 12006ed7257bSPatrick Caulfield 12012df6b762SAlexander Aring log_print_ratelimited("connecting to %d", con->nodeid); 12026ed7257bSPatrick Caulfield 1203ee44b4bcSMarcelo Ricardo Leitner /* Turn off Nagle's algorithm */ 120440ef92c6SChristoph Hellwig sctp_sock_set_nodelay(sock->sk); 1205ee44b4bcSMarcelo Ricardo Leitner 1206f706d830SGang He /* 1207f706d830SGang He * Make sock->ops->connect() function return in specified time, 1208f706d830SGang He * since O_NONBLOCK argument in connect() function does not work here, 1209f706d830SGang He * then, we should restore the default value of this attribute. 1210f706d830SGang He */ 121176ee0785SChristoph Hellwig sock_set_sndtimeo(sock->sk, 5); 1212ee44b4bcSMarcelo Ricardo Leitner result = sock->ops->connect(sock, (struct sockaddr *)&daddr, addr_len, 1213da3627c3SGang He 0); 121476ee0785SChristoph Hellwig sock_set_sndtimeo(sock->sk, 0); 1215f706d830SGang He 1216ee44b4bcSMarcelo Ricardo Leitner if (result == -EINPROGRESS) 1217ee44b4bcSMarcelo Ricardo Leitner result = 0; 121819633c7eSAlexander Aring if (result == 0) { 121919633c7eSAlexander Aring if (!test_and_set_bit(CF_CONNECTED, &con->flags)) 122019633c7eSAlexander Aring log_print("successful connected to node %d", con->nodeid); 1221ee44b4bcSMarcelo Ricardo Leitner goto out; 122219633c7eSAlexander Aring } 1223ee44b4bcSMarcelo Ricardo Leitner 1224ee44b4bcSMarcelo Ricardo Leitner bind_err: 1225ee44b4bcSMarcelo Ricardo Leitner con->sock = NULL; 1226ee44b4bcSMarcelo Ricardo Leitner sock_release(sock); 1227ee44b4bcSMarcelo Ricardo Leitner 1228ee44b4bcSMarcelo Ricardo Leitner socket_err: 1229ee44b4bcSMarcelo Ricardo Leitner /* 1230ee44b4bcSMarcelo Ricardo Leitner * Some errors are fatal and this list might need adjusting. For other 1231ee44b4bcSMarcelo Ricardo Leitner * errors we try again until the max number of retries is reached. 1232ee44b4bcSMarcelo Ricardo Leitner */ 1233ee44b4bcSMarcelo Ricardo Leitner if (result != -EHOSTUNREACH && 1234ee44b4bcSMarcelo Ricardo Leitner result != -ENETUNREACH && 1235ee44b4bcSMarcelo Ricardo Leitner result != -ENETDOWN && 1236ee44b4bcSMarcelo Ricardo Leitner result != -EINVAL && 1237ee44b4bcSMarcelo Ricardo Leitner result != -EPROTONOSUPPORT) { 1238ee44b4bcSMarcelo Ricardo Leitner log_print("connect %d try %d error %d", con->nodeid, 1239ee44b4bcSMarcelo Ricardo Leitner con->retries, result); 1240ee44b4bcSMarcelo Ricardo Leitner mutex_unlock(&con->sock_mutex); 1241ee44b4bcSMarcelo Ricardo Leitner msleep(1000); 1242ee44b4bcSMarcelo Ricardo Leitner lowcomms_connect_sock(con); 1243ee44b4bcSMarcelo Ricardo Leitner return; 12446ed7257bSPatrick Caulfield } 12455d689871SMike Christie 1246ee44b4bcSMarcelo Ricardo Leitner out: 12475d689871SMike Christie mutex_unlock(&con->sock_mutex); 12486ed7257bSPatrick Caulfield } 12496ed7257bSPatrick Caulfield 12506ed7257bSPatrick Caulfield /* Connect a new socket to its peer */ 12516ed7257bSPatrick Caulfield static void tcp_connect_to_sock(struct connection *con) 12526ed7257bSPatrick Caulfield { 12536bd8fedaSLon Hohberger struct sockaddr_storage saddr, src_addr; 1254e125fbebSAlexander Aring unsigned int mark; 12556ed7257bSPatrick Caulfield int addr_len; 1256a89d63a1SCasey Dahlin struct socket *sock = NULL; 125736b71a8bSDavid Teigland int result; 12586ed7257bSPatrick Caulfield 12596ed7257bSPatrick Caulfield mutex_lock(&con->sock_mutex); 12606ed7257bSPatrick Caulfield if (con->retries++ > MAX_CONNECT_RETRIES) 12616ed7257bSPatrick Caulfield goto out; 12626ed7257bSPatrick Caulfield 12636ed7257bSPatrick Caulfield /* Some odd races can cause double-connects, ignore them */ 126436b71a8bSDavid Teigland if (con->sock) 12656ed7257bSPatrick Caulfield goto out; 12666ed7257bSPatrick Caulfield 12676ed7257bSPatrick Caulfield /* Create a socket to communicate with */ 1268eeb1bd5cSEric W. Biederman result = sock_create_kern(&init_net, dlm_local_addr[0]->ss_family, 1269eeb1bd5cSEric W. Biederman SOCK_STREAM, IPPROTO_TCP, &sock); 12706ed7257bSPatrick Caulfield if (result < 0) 12716ed7257bSPatrick Caulfield goto out_err; 12726ed7257bSPatrick Caulfield 12736ed7257bSPatrick Caulfield memset(&saddr, 0, sizeof(saddr)); 1274e125fbebSAlexander Aring result = nodeid_to_addr(con->nodeid, &saddr, NULL, false, &mark); 127536b71a8bSDavid Teigland if (result < 0) { 127636b71a8bSDavid Teigland log_print("no address for nodeid %d", con->nodeid); 12776ed7257bSPatrick Caulfield goto out_err; 127836b71a8bSDavid Teigland } 12796ed7257bSPatrick Caulfield 1280e125fbebSAlexander Aring sock_set_mark(sock->sk, mark); 1281e125fbebSAlexander Aring 1282988419a9Stsutomu.owa@toshiba.co.jp add_sock(sock, con); 12836ed7257bSPatrick Caulfield 12846bd8fedaSLon Hohberger /* Bind to our cluster-known address connecting to avoid 12856bd8fedaSLon Hohberger routing problems */ 12866bd8fedaSLon Hohberger memcpy(&src_addr, dlm_local_addr[0], sizeof(src_addr)); 12876bd8fedaSLon Hohberger make_sockaddr(&src_addr, 0, &addr_len); 12886bd8fedaSLon Hohberger result = sock->ops->bind(sock, (struct sockaddr *) &src_addr, 12896bd8fedaSLon Hohberger addr_len); 12906bd8fedaSLon Hohberger if (result < 0) { 12916bd8fedaSLon Hohberger log_print("could not bind for connect: %d", result); 12926bd8fedaSLon Hohberger /* This *may* not indicate a critical error */ 12936bd8fedaSLon Hohberger } 12946bd8fedaSLon Hohberger 12956ed7257bSPatrick Caulfield make_sockaddr(&saddr, dlm_config.ci_tcp_port, &addr_len); 12966ed7257bSPatrick Caulfield 12972df6b762SAlexander Aring log_print_ratelimited("connecting to %d", con->nodeid); 1298cb2d45daSDavid Teigland 1299cb2d45daSDavid Teigland /* Turn off Nagle's algorithm */ 130012abc5eeSChristoph Hellwig tcp_sock_set_nodelay(sock->sk); 1301cb2d45daSDavid Teigland 130236b71a8bSDavid Teigland result = sock->ops->connect(sock, (struct sockaddr *)&saddr, addr_len, 13036ed7257bSPatrick Caulfield O_NONBLOCK); 13046ed7257bSPatrick Caulfield if (result == -EINPROGRESS) 13056ed7257bSPatrick Caulfield result = 0; 13066ed7257bSPatrick Caulfield if (result == 0) 13076ed7257bSPatrick Caulfield goto out; 13086ed7257bSPatrick Caulfield 13096ed7257bSPatrick Caulfield out_err: 13106ed7257bSPatrick Caulfield if (con->sock) { 13116ed7257bSPatrick Caulfield sock_release(con->sock); 13126ed7257bSPatrick Caulfield con->sock = NULL; 1313a89d63a1SCasey Dahlin } else if (sock) { 1314a89d63a1SCasey Dahlin sock_release(sock); 13156ed7257bSPatrick Caulfield } 13166ed7257bSPatrick Caulfield /* 13176ed7257bSPatrick Caulfield * Some errors are fatal and this list might need adjusting. For other 13186ed7257bSPatrick Caulfield * errors we try again until the max number of retries is reached. 13196ed7257bSPatrick Caulfield */ 132036b71a8bSDavid Teigland if (result != -EHOSTUNREACH && 132136b71a8bSDavid Teigland result != -ENETUNREACH && 132236b71a8bSDavid Teigland result != -ENETDOWN && 132336b71a8bSDavid Teigland result != -EINVAL && 132436b71a8bSDavid Teigland result != -EPROTONOSUPPORT) { 132536b71a8bSDavid Teigland log_print("connect %d try %d error %d", con->nodeid, 132636b71a8bSDavid Teigland con->retries, result); 132736b71a8bSDavid Teigland mutex_unlock(&con->sock_mutex); 132836b71a8bSDavid Teigland msleep(1000); 13296ed7257bSPatrick Caulfield lowcomms_connect_sock(con); 133036b71a8bSDavid Teigland return; 13316ed7257bSPatrick Caulfield } 13326ed7257bSPatrick Caulfield out: 13336ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 13346ed7257bSPatrick Caulfield return; 13356ed7257bSPatrick Caulfield } 13366ed7257bSPatrick Caulfield 13376ed7257bSPatrick Caulfield /* Get local addresses */ 13386ed7257bSPatrick Caulfield static void init_local(void) 13396ed7257bSPatrick Caulfield { 13406ed7257bSPatrick Caulfield struct sockaddr_storage sas, *addr; 13416ed7257bSPatrick Caulfield int i; 13426ed7257bSPatrick Caulfield 134330d3a237SPatrick Caulfield dlm_local_count = 0; 13441b189b88SDavid Teigland for (i = 0; i < DLM_MAX_ADDR_COUNT; i++) { 13456ed7257bSPatrick Caulfield if (dlm_our_addr(&sas, i)) 13466ed7257bSPatrick Caulfield break; 13476ed7257bSPatrick Caulfield 13485c93f56fSAmitoj Kaur Chawla addr = kmemdup(&sas, sizeof(*addr), GFP_NOFS); 13496ed7257bSPatrick Caulfield if (!addr) 13506ed7257bSPatrick Caulfield break; 13516ed7257bSPatrick Caulfield dlm_local_addr[dlm_local_count++] = addr; 13526ed7257bSPatrick Caulfield } 13536ed7257bSPatrick Caulfield } 13546ed7257bSPatrick Caulfield 1355043697f0SAlexander Aring static void deinit_local(void) 1356043697f0SAlexander Aring { 1357043697f0SAlexander Aring int i; 1358043697f0SAlexander Aring 1359043697f0SAlexander Aring for (i = 0; i < dlm_local_count; i++) 1360043697f0SAlexander Aring kfree(dlm_local_addr[i]); 1361043697f0SAlexander Aring } 1362043697f0SAlexander Aring 13636ed7257bSPatrick Caulfield static struct writequeue_entry *new_writequeue_entry(struct connection *con, 13646ed7257bSPatrick Caulfield gfp_t allocation) 13656ed7257bSPatrick Caulfield { 13666ed7257bSPatrick Caulfield struct writequeue_entry *entry; 13676ed7257bSPatrick Caulfield 1368f0747ebfSAlexander Aring entry = kzalloc(sizeof(*entry), allocation); 13696ed7257bSPatrick Caulfield if (!entry) 13706ed7257bSPatrick Caulfield return NULL; 13716ed7257bSPatrick Caulfield 1372e1a7cbceSAlexander Aring entry->page = alloc_page(allocation | __GFP_ZERO); 13736ed7257bSPatrick Caulfield if (!entry->page) { 13746ed7257bSPatrick Caulfield kfree(entry); 13756ed7257bSPatrick Caulfield return NULL; 13766ed7257bSPatrick Caulfield } 13776ed7257bSPatrick Caulfield 13786ed7257bSPatrick Caulfield entry->con = con; 1379f0747ebfSAlexander Aring entry->users = 1; 13808f2dc78dSAlexander Aring kref_init(&entry->ref); 13818f2dc78dSAlexander Aring INIT_LIST_HEAD(&entry->msgs); 13826ed7257bSPatrick Caulfield 13836ed7257bSPatrick Caulfield return entry; 13846ed7257bSPatrick Caulfield } 13856ed7257bSPatrick Caulfield 1386f0747ebfSAlexander Aring static struct writequeue_entry *new_wq_entry(struct connection *con, int len, 13878f2dc78dSAlexander Aring gfp_t allocation, char **ppc, 13888f2dc78dSAlexander Aring void (*cb)(struct dlm_mhandle *mh), 13898f2dc78dSAlexander Aring struct dlm_mhandle *mh) 1390f0747ebfSAlexander Aring { 1391f0747ebfSAlexander Aring struct writequeue_entry *e; 1392f0747ebfSAlexander Aring 1393f0747ebfSAlexander Aring spin_lock(&con->writequeue_lock); 1394f0747ebfSAlexander Aring if (!list_empty(&con->writequeue)) { 1395f0747ebfSAlexander Aring e = list_last_entry(&con->writequeue, struct writequeue_entry, list); 1396f0747ebfSAlexander Aring if (DLM_WQ_REMAIN_BYTES(e) >= len) { 13978f2dc78dSAlexander Aring kref_get(&e->ref); 13988f2dc78dSAlexander Aring 1399f0747ebfSAlexander Aring *ppc = page_address(e->page) + e->end; 14008f2dc78dSAlexander Aring if (cb) 14018f2dc78dSAlexander Aring cb(mh); 14028f2dc78dSAlexander Aring 1403f0747ebfSAlexander Aring e->end += len; 1404f0747ebfSAlexander Aring e->users++; 1405f0747ebfSAlexander Aring spin_unlock(&con->writequeue_lock); 1406f0747ebfSAlexander Aring 1407f0747ebfSAlexander Aring return e; 1408f0747ebfSAlexander Aring } 1409f0747ebfSAlexander Aring } 1410f0747ebfSAlexander Aring spin_unlock(&con->writequeue_lock); 1411f0747ebfSAlexander Aring 1412f0747ebfSAlexander Aring e = new_writequeue_entry(con, allocation); 1413f0747ebfSAlexander Aring if (!e) 1414f0747ebfSAlexander Aring return NULL; 1415f0747ebfSAlexander Aring 14168f2dc78dSAlexander Aring kref_get(&e->ref); 1417f0747ebfSAlexander Aring *ppc = page_address(e->page); 1418f0747ebfSAlexander Aring e->end += len; 14198aa31cbfSAlexander Aring atomic_inc(&con->writequeue_cnt); 1420f0747ebfSAlexander Aring 1421f0747ebfSAlexander Aring spin_lock(&con->writequeue_lock); 14228f2dc78dSAlexander Aring if (cb) 14238f2dc78dSAlexander Aring cb(mh); 14248f2dc78dSAlexander Aring 1425f0747ebfSAlexander Aring list_add_tail(&e->list, &con->writequeue); 1426f0747ebfSAlexander Aring spin_unlock(&con->writequeue_lock); 1427f0747ebfSAlexander Aring 1428f0747ebfSAlexander Aring return e; 1429f0747ebfSAlexander Aring }; 1430f0747ebfSAlexander Aring 14312874d1a6SAlexander Aring static struct dlm_msg *dlm_lowcomms_new_msg_con(struct connection *con, int len, 14322874d1a6SAlexander Aring gfp_t allocation, char **ppc, 14332874d1a6SAlexander Aring void (*cb)(struct dlm_mhandle *mh), 14342874d1a6SAlexander Aring struct dlm_mhandle *mh) 14352874d1a6SAlexander Aring { 14362874d1a6SAlexander Aring struct writequeue_entry *e; 14372874d1a6SAlexander Aring struct dlm_msg *msg; 14382874d1a6SAlexander Aring 14392874d1a6SAlexander Aring msg = kzalloc(sizeof(*msg), allocation); 14402874d1a6SAlexander Aring if (!msg) 14412874d1a6SAlexander Aring return NULL; 14422874d1a6SAlexander Aring 14432874d1a6SAlexander Aring kref_init(&msg->ref); 14442874d1a6SAlexander Aring 14452874d1a6SAlexander Aring e = new_wq_entry(con, len, allocation, ppc, cb, mh); 14462874d1a6SAlexander Aring if (!e) { 14472874d1a6SAlexander Aring kfree(msg); 14482874d1a6SAlexander Aring return NULL; 14492874d1a6SAlexander Aring } 14502874d1a6SAlexander Aring 14512874d1a6SAlexander Aring msg->ppc = *ppc; 14522874d1a6SAlexander Aring msg->len = len; 14532874d1a6SAlexander Aring msg->entry = e; 14542874d1a6SAlexander Aring 14552874d1a6SAlexander Aring return msg; 14562874d1a6SAlexander Aring } 14572874d1a6SAlexander Aring 14588f2dc78dSAlexander Aring struct dlm_msg *dlm_lowcomms_new_msg(int nodeid, int len, gfp_t allocation, 14598f2dc78dSAlexander Aring char **ppc, void (*cb)(struct dlm_mhandle *mh), 14608f2dc78dSAlexander Aring struct dlm_mhandle *mh) 14616ed7257bSPatrick Caulfield { 14626ed7257bSPatrick Caulfield struct connection *con; 14638f2dc78dSAlexander Aring struct dlm_msg *msg; 1464b38bc9c2SAlexander Aring int idx; 14656ed7257bSPatrick Caulfield 1466d10a0b88SAlexander Aring if (len > DLM_MAX_SOCKET_BUFSIZE || 1467c45674fbSAlexander Aring len < sizeof(struct dlm_header)) { 1468d10a0b88SAlexander Aring BUILD_BUG_ON(PAGE_SIZE < DLM_MAX_SOCKET_BUFSIZE); 1469692f51c8SAlexander Aring log_print("failed to allocate a buffer of size %d", len); 1470c45674fbSAlexander Aring WARN_ON(1); 1471692f51c8SAlexander Aring return NULL; 1472692f51c8SAlexander Aring } 1473692f51c8SAlexander Aring 1474b38bc9c2SAlexander Aring idx = srcu_read_lock(&connections_srcu); 14756ed7257bSPatrick Caulfield con = nodeid2con(nodeid, allocation); 1476b38bc9c2SAlexander Aring if (!con) { 1477b38bc9c2SAlexander Aring srcu_read_unlock(&connections_srcu, idx); 14786ed7257bSPatrick Caulfield return NULL; 1479b38bc9c2SAlexander Aring } 14806ed7257bSPatrick Caulfield 14812874d1a6SAlexander Aring msg = dlm_lowcomms_new_msg_con(con, len, allocation, ppc, cb, mh); 14828f2dc78dSAlexander Aring if (!msg) { 1483b38bc9c2SAlexander Aring srcu_read_unlock(&connections_srcu, idx); 1484b38bc9c2SAlexander Aring return NULL; 1485b38bc9c2SAlexander Aring } 1486b38bc9c2SAlexander Aring 14878f2dc78dSAlexander Aring /* we assume if successful commit must called */ 14888f2dc78dSAlexander Aring msg->idx = idx; 14898f2dc78dSAlexander Aring return msg; 14908f2dc78dSAlexander Aring } 14918f2dc78dSAlexander Aring 14922874d1a6SAlexander Aring static void _dlm_lowcomms_commit_msg(struct dlm_msg *msg) 14936ed7257bSPatrick Caulfield { 14948f2dc78dSAlexander Aring struct writequeue_entry *e = msg->entry; 14956ed7257bSPatrick Caulfield struct connection *con = e->con; 14966ed7257bSPatrick Caulfield int users; 14976ed7257bSPatrick Caulfield 14986ed7257bSPatrick Caulfield spin_lock(&con->writequeue_lock); 14998f2dc78dSAlexander Aring kref_get(&msg->ref); 15008f2dc78dSAlexander Aring list_add(&msg->list, &e->msgs); 15018f2dc78dSAlexander Aring 15026ed7257bSPatrick Caulfield users = --e->users; 15036ed7257bSPatrick Caulfield if (users) 15046ed7257bSPatrick Caulfield goto out; 1505f0747ebfSAlexander Aring 1506f0747ebfSAlexander Aring e->len = DLM_WQ_LENGTH_BYTES(e); 15076ed7257bSPatrick Caulfield spin_unlock(&con->writequeue_lock); 15086ed7257bSPatrick Caulfield 15096ed7257bSPatrick Caulfield queue_work(send_workqueue, &con->swork); 15106ed7257bSPatrick Caulfield return; 15116ed7257bSPatrick Caulfield 15126ed7257bSPatrick Caulfield out: 15136ed7257bSPatrick Caulfield spin_unlock(&con->writequeue_lock); 15146ed7257bSPatrick Caulfield return; 15156ed7257bSPatrick Caulfield } 15166ed7257bSPatrick Caulfield 15172874d1a6SAlexander Aring void dlm_lowcomms_commit_msg(struct dlm_msg *msg) 15182874d1a6SAlexander Aring { 15192874d1a6SAlexander Aring _dlm_lowcomms_commit_msg(msg); 15202874d1a6SAlexander Aring srcu_read_unlock(&connections_srcu, msg->idx); 15212874d1a6SAlexander Aring } 15222874d1a6SAlexander Aring 15238f2dc78dSAlexander Aring void dlm_lowcomms_put_msg(struct dlm_msg *msg) 15248f2dc78dSAlexander Aring { 15258f2dc78dSAlexander Aring kref_put(&msg->ref, dlm_msg_release); 15268f2dc78dSAlexander Aring } 15278f2dc78dSAlexander Aring 15282874d1a6SAlexander Aring /* does not held connections_srcu, usage workqueue only */ 15292874d1a6SAlexander Aring int dlm_lowcomms_resend_msg(struct dlm_msg *msg) 15302874d1a6SAlexander Aring { 15312874d1a6SAlexander Aring struct dlm_msg *msg_resend; 15322874d1a6SAlexander Aring char *ppc; 15332874d1a6SAlexander Aring 15342874d1a6SAlexander Aring if (msg->retransmit) 15352874d1a6SAlexander Aring return 1; 15362874d1a6SAlexander Aring 15372874d1a6SAlexander Aring msg_resend = dlm_lowcomms_new_msg_con(msg->entry->con, msg->len, 15382874d1a6SAlexander Aring GFP_ATOMIC, &ppc, NULL, NULL); 15392874d1a6SAlexander Aring if (!msg_resend) 15402874d1a6SAlexander Aring return -ENOMEM; 15412874d1a6SAlexander Aring 15422874d1a6SAlexander Aring msg->retransmit = true; 15432874d1a6SAlexander Aring kref_get(&msg->ref); 15442874d1a6SAlexander Aring msg_resend->orig_msg = msg; 15452874d1a6SAlexander Aring 15462874d1a6SAlexander Aring memcpy(ppc, msg->ppc, msg->len); 15472874d1a6SAlexander Aring _dlm_lowcomms_commit_msg(msg_resend); 15482874d1a6SAlexander Aring dlm_lowcomms_put_msg(msg_resend); 15492874d1a6SAlexander Aring 15502874d1a6SAlexander Aring return 0; 15512874d1a6SAlexander Aring } 15522874d1a6SAlexander Aring 15536ed7257bSPatrick Caulfield /* Send a message */ 15546ed7257bSPatrick Caulfield static void send_to_sock(struct connection *con) 15556ed7257bSPatrick Caulfield { 15566ed7257bSPatrick Caulfield const int msg_flags = MSG_DONTWAIT | MSG_NOSIGNAL; 15576ed7257bSPatrick Caulfield struct writequeue_entry *e; 155866d5955aSAlexander Aring int len, offset, ret; 1559f92c8dd7SBob Peterson int count = 0; 15606ed7257bSPatrick Caulfield 15616ed7257bSPatrick Caulfield mutex_lock(&con->sock_mutex); 15626ed7257bSPatrick Caulfield if (con->sock == NULL) 15636ed7257bSPatrick Caulfield goto out_connect; 15646ed7257bSPatrick Caulfield 15656ed7257bSPatrick Caulfield spin_lock(&con->writequeue_lock); 15666ed7257bSPatrick Caulfield for (;;) { 156766d5955aSAlexander Aring e = con_next_wq(con); 156866d5955aSAlexander Aring if (!e) 15696ed7257bSPatrick Caulfield break; 15706ed7257bSPatrick Caulfield 1571f0747ebfSAlexander Aring e = list_first_entry(&con->writequeue, struct writequeue_entry, list); 15726ed7257bSPatrick Caulfield len = e->len; 15736ed7257bSPatrick Caulfield offset = e->offset; 15746ed7257bSPatrick Caulfield BUG_ON(len == 0 && e->users == 0); 15756ed7257bSPatrick Caulfield spin_unlock(&con->writequeue_lock); 15766ed7257bSPatrick Caulfield 15771329e3f2SPaolo Bonzini ret = kernel_sendpage(con->sock, e->page, offset, len, 15786ed7257bSPatrick Caulfield msg_flags); 1579d66f8277SPatrick Caulfield if (ret == -EAGAIN || ret == 0) { 1580b36930ddSDavid Miller if (ret == -EAGAIN && 15819cd3e072SEric Dumazet test_bit(SOCKWQ_ASYNC_NOSPACE, &con->sock->flags) && 1582b36930ddSDavid Miller !test_and_set_bit(CF_APP_LIMITED, &con->flags)) { 1583b36930ddSDavid Miller /* Notify TCP that we're limited by the 1584b36930ddSDavid Miller * application window size. 1585b36930ddSDavid Miller */ 1586b36930ddSDavid Miller set_bit(SOCK_NOSPACE, &con->sock->flags); 1587b36930ddSDavid Miller con->sock->sk->sk_write_pending++; 1588b36930ddSDavid Miller } 1589d66f8277SPatrick Caulfield cond_resched(); 15906ed7257bSPatrick Caulfield goto out; 15919c5bef58SYing Xue } else if (ret < 0) 1592ba868d9dSAlexander Aring goto out; 1593f92c8dd7SBob Peterson 15946ed7257bSPatrick Caulfield /* Don't starve people filling buffers */ 1595f92c8dd7SBob Peterson if (++count >= MAX_SEND_MSG_COUNT) { 15966ed7257bSPatrick Caulfield cond_resched(); 1597f92c8dd7SBob Peterson count = 0; 1598f92c8dd7SBob Peterson } 15996ed7257bSPatrick Caulfield 16006ed7257bSPatrick Caulfield spin_lock(&con->writequeue_lock); 16015d689871SMike Christie writequeue_entry_complete(e, ret); 16026ed7257bSPatrick Caulfield } 16036ed7257bSPatrick Caulfield spin_unlock(&con->writequeue_lock); 16048aa31cbfSAlexander Aring 16058aa31cbfSAlexander Aring /* close if we got EOF */ 16068aa31cbfSAlexander Aring if (test_and_clear_bit(CF_EOF, &con->flags)) { 16078aa31cbfSAlexander Aring mutex_unlock(&con->sock_mutex); 16088aa31cbfSAlexander Aring close_connection(con, false, false, true); 16098aa31cbfSAlexander Aring 16108aa31cbfSAlexander Aring /* handling for tcp shutdown */ 16118aa31cbfSAlexander Aring clear_bit(CF_SHUTDOWN, &con->flags); 16128aa31cbfSAlexander Aring wake_up(&con->shutdown_wait); 16138aa31cbfSAlexander Aring } else { 16148aa31cbfSAlexander Aring mutex_unlock(&con->sock_mutex); 16158aa31cbfSAlexander Aring } 16168aa31cbfSAlexander Aring 16178aa31cbfSAlexander Aring return; 16188aa31cbfSAlexander Aring 16196ed7257bSPatrick Caulfield out: 16206ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 16216ed7257bSPatrick Caulfield return; 16226ed7257bSPatrick Caulfield 16236ed7257bSPatrick Caulfield out_connect: 16246ed7257bSPatrick Caulfield mutex_unlock(&con->sock_mutex); 162501da24d3SBob Peterson queue_work(send_workqueue, &con->swork); 162601da24d3SBob Peterson cond_resched(); 16276ed7257bSPatrick Caulfield } 16286ed7257bSPatrick Caulfield 16296ed7257bSPatrick Caulfield static void clean_one_writequeue(struct connection *con) 16306ed7257bSPatrick Caulfield { 16315e9ccc37SChristine Caulfield struct writequeue_entry *e, *safe; 16326ed7257bSPatrick Caulfield 16336ed7257bSPatrick Caulfield spin_lock(&con->writequeue_lock); 16345e9ccc37SChristine Caulfield list_for_each_entry_safe(e, safe, &con->writequeue, list) { 16356ed7257bSPatrick Caulfield free_entry(e); 16366ed7257bSPatrick Caulfield } 16376ed7257bSPatrick Caulfield spin_unlock(&con->writequeue_lock); 16386ed7257bSPatrick Caulfield } 16396ed7257bSPatrick Caulfield 16406ed7257bSPatrick Caulfield /* Called from recovery when it knows that a node has 16416ed7257bSPatrick Caulfield left the cluster */ 16426ed7257bSPatrick Caulfield int dlm_lowcomms_close(int nodeid) 16436ed7257bSPatrick Caulfield { 16446ed7257bSPatrick Caulfield struct connection *con; 164536b71a8bSDavid Teigland struct dlm_node_addr *na; 1646b38bc9c2SAlexander Aring int idx; 16476ed7257bSPatrick Caulfield 16486ed7257bSPatrick Caulfield log_print("closing connection to node %d", nodeid); 1649b38bc9c2SAlexander Aring idx = srcu_read_lock(&connections_srcu); 16506ed7257bSPatrick Caulfield con = nodeid2con(nodeid, 0); 16516ed7257bSPatrick Caulfield if (con) { 1652063c4c99SLars Marowsky-Bree set_bit(CF_CLOSE, &con->flags); 16530d737a8cSMarcelo Ricardo Leitner close_connection(con, true, true, true); 16546ed7257bSPatrick Caulfield clean_one_writequeue(con); 165553a5edaaSAlexander Aring if (con->othercon) 165653a5edaaSAlexander Aring clean_one_writequeue(con->othercon); 16576ed7257bSPatrick Caulfield } 1658b38bc9c2SAlexander Aring srcu_read_unlock(&connections_srcu, idx); 165936b71a8bSDavid Teigland 166036b71a8bSDavid Teigland spin_lock(&dlm_node_addrs_spin); 166136b71a8bSDavid Teigland na = find_node_addr(nodeid); 166236b71a8bSDavid Teigland if (na) { 166336b71a8bSDavid Teigland list_del(&na->list); 166436b71a8bSDavid Teigland while (na->addr_count--) 166536b71a8bSDavid Teigland kfree(na->addr[na->addr_count]); 166636b71a8bSDavid Teigland kfree(na); 166736b71a8bSDavid Teigland } 166836b71a8bSDavid Teigland spin_unlock(&dlm_node_addrs_spin); 166936b71a8bSDavid Teigland 16706ed7257bSPatrick Caulfield return 0; 16716ed7257bSPatrick Caulfield } 16726ed7257bSPatrick Caulfield 16736ed7257bSPatrick Caulfield /* Receive workqueue function */ 16746ed7257bSPatrick Caulfield static void process_recv_sockets(struct work_struct *work) 16756ed7257bSPatrick Caulfield { 16766ed7257bSPatrick Caulfield struct connection *con = container_of(work, struct connection, rwork); 16776ed7257bSPatrick Caulfield int err; 16786ed7257bSPatrick Caulfield 16796ed7257bSPatrick Caulfield clear_bit(CF_READ_PENDING, &con->flags); 16806ed7257bSPatrick Caulfield do { 1681d11ccd45SAlexander Aring err = receive_from_sock(con); 16826ed7257bSPatrick Caulfield } while (!err); 16836ed7257bSPatrick Caulfield } 16846ed7257bSPatrick Caulfield 1685d11ccd45SAlexander Aring static void process_listen_recv_socket(struct work_struct *work) 1686d11ccd45SAlexander Aring { 1687d11ccd45SAlexander Aring accept_from_sock(&listen_con); 1688d11ccd45SAlexander Aring } 1689d11ccd45SAlexander Aring 16906ed7257bSPatrick Caulfield /* Send workqueue function */ 16916ed7257bSPatrick Caulfield static void process_send_sockets(struct work_struct *work) 16926ed7257bSPatrick Caulfield { 16936ed7257bSPatrick Caulfield struct connection *con = container_of(work, struct connection, swork); 16946ed7257bSPatrick Caulfield 16957443bc96SAlexander Aring WARN_ON(test_bit(CF_IS_OTHERCON, &con->flags)); 16967443bc96SAlexander Aring 16978a4abb08Stsutomu.owa@toshiba.co.jp clear_bit(CF_WRITE_PENDING, &con->flags); 1698ba868d9dSAlexander Aring 1699489d8e55SAlexander Aring if (test_and_clear_bit(CF_RECONNECT, &con->flags)) { 1700ba868d9dSAlexander Aring close_connection(con, false, false, true); 1701489d8e55SAlexander Aring dlm_midcomms_unack_msg_resend(con->nodeid); 1702489d8e55SAlexander Aring } 1703ba868d9dSAlexander Aring 1704ba868d9dSAlexander Aring if (con->sock == NULL) { /* not mutex protected so check it inside too */ 1705ba868d9dSAlexander Aring if (test_and_clear_bit(CF_DELAY_CONNECT, &con->flags)) 1706ba868d9dSAlexander Aring msleep(1000); 1707a66c008cSAlexander Aring dlm_proto_ops->connect_action(con); 1708ba868d9dSAlexander Aring } 170901da24d3SBob Peterson if (!list_empty(&con->writequeue)) 17106ed7257bSPatrick Caulfield send_to_sock(con); 17116ed7257bSPatrick Caulfield } 17126ed7257bSPatrick Caulfield 17136ed7257bSPatrick Caulfield static void work_stop(void) 17146ed7257bSPatrick Caulfield { 1715fcef0e6cSAlexander Aring if (recv_workqueue) { 17166ed7257bSPatrick Caulfield destroy_workqueue(recv_workqueue); 1717fcef0e6cSAlexander Aring recv_workqueue = NULL; 1718fcef0e6cSAlexander Aring } 1719fcef0e6cSAlexander Aring 1720fcef0e6cSAlexander Aring if (send_workqueue) { 17216ed7257bSPatrick Caulfield destroy_workqueue(send_workqueue); 1722fcef0e6cSAlexander Aring send_workqueue = NULL; 1723fcef0e6cSAlexander Aring } 17246ed7257bSPatrick Caulfield } 17256ed7257bSPatrick Caulfield 17266ed7257bSPatrick Caulfield static int work_start(void) 17276ed7257bSPatrick Caulfield { 17286c6a1cc6SAlexander Aring recv_workqueue = alloc_ordered_workqueue("dlm_recv", WQ_MEM_RECLAIM); 1729b9d41052SNamhyung Kim if (!recv_workqueue) { 1730b9d41052SNamhyung Kim log_print("can't start dlm_recv"); 1731b9d41052SNamhyung Kim return -ENOMEM; 17326ed7257bSPatrick Caulfield } 17336ed7257bSPatrick Caulfield 17346c6a1cc6SAlexander Aring send_workqueue = alloc_ordered_workqueue("dlm_send", WQ_MEM_RECLAIM); 1735b9d41052SNamhyung Kim if (!send_workqueue) { 1736b9d41052SNamhyung Kim log_print("can't start dlm_send"); 17376ed7257bSPatrick Caulfield destroy_workqueue(recv_workqueue); 1738fcef0e6cSAlexander Aring recv_workqueue = NULL; 1739b9d41052SNamhyung Kim return -ENOMEM; 17406ed7257bSPatrick Caulfield } 17416ed7257bSPatrick Caulfield 17426ed7257bSPatrick Caulfield return 0; 17436ed7257bSPatrick Caulfield } 17446ed7257bSPatrick Caulfield 17459d232469SAlexander Aring static void shutdown_conn(struct connection *con) 17469d232469SAlexander Aring { 1747a66c008cSAlexander Aring if (dlm_proto_ops->shutdown_action) 1748a66c008cSAlexander Aring dlm_proto_ops->shutdown_action(con); 17499d232469SAlexander Aring } 17509d232469SAlexander Aring 17519d232469SAlexander Aring void dlm_lowcomms_shutdown(void) 17529d232469SAlexander Aring { 1753b38bc9c2SAlexander Aring int idx; 1754b38bc9c2SAlexander Aring 17559d232469SAlexander Aring /* Set all the flags to prevent any 17569d232469SAlexander Aring * socket activity. 17579d232469SAlexander Aring */ 17589d232469SAlexander Aring dlm_allow_conn = 0; 17599d232469SAlexander Aring 17609d232469SAlexander Aring if (recv_workqueue) 17619d232469SAlexander Aring flush_workqueue(recv_workqueue); 17629d232469SAlexander Aring if (send_workqueue) 17639d232469SAlexander Aring flush_workqueue(send_workqueue); 17649d232469SAlexander Aring 17659d232469SAlexander Aring dlm_close_sock(&listen_con.sock); 17669d232469SAlexander Aring 1767b38bc9c2SAlexander Aring idx = srcu_read_lock(&connections_srcu); 17689d232469SAlexander Aring foreach_conn(shutdown_conn); 1769b38bc9c2SAlexander Aring srcu_read_unlock(&connections_srcu, idx); 17709d232469SAlexander Aring } 17719d232469SAlexander Aring 1772f0fb83cbStsutomu.owa@toshiba.co.jp static void _stop_conn(struct connection *con, bool and_other) 17736ed7257bSPatrick Caulfield { 1774f0fb83cbStsutomu.owa@toshiba.co.jp mutex_lock(&con->sock_mutex); 1775173a31feStsutomu.owa@toshiba.co.jp set_bit(CF_CLOSE, &con->flags); 1776f0fb83cbStsutomu.owa@toshiba.co.jp set_bit(CF_READ_PENDING, &con->flags); 17778a4abb08Stsutomu.owa@toshiba.co.jp set_bit(CF_WRITE_PENDING, &con->flags); 177893eaadebStsutomu.owa@toshiba.co.jp if (con->sock && con->sock->sk) { 177993eaadebStsutomu.owa@toshiba.co.jp write_lock_bh(&con->sock->sk->sk_callback_lock); 1780afb853fbSPatrick Caulfield con->sock->sk->sk_user_data = NULL; 178193eaadebStsutomu.owa@toshiba.co.jp write_unlock_bh(&con->sock->sk->sk_callback_lock); 178293eaadebStsutomu.owa@toshiba.co.jp } 1783f0fb83cbStsutomu.owa@toshiba.co.jp if (con->othercon && and_other) 1784f0fb83cbStsutomu.owa@toshiba.co.jp _stop_conn(con->othercon, false); 1785f0fb83cbStsutomu.owa@toshiba.co.jp mutex_unlock(&con->sock_mutex); 1786f0fb83cbStsutomu.owa@toshiba.co.jp } 1787f0fb83cbStsutomu.owa@toshiba.co.jp 1788f0fb83cbStsutomu.owa@toshiba.co.jp static void stop_conn(struct connection *con) 1789f0fb83cbStsutomu.owa@toshiba.co.jp { 1790f0fb83cbStsutomu.owa@toshiba.co.jp _stop_conn(con, true); 1791afb853fbSPatrick Caulfield } 17925e9ccc37SChristine Caulfield 17934798cbbfSAlexander Aring static void connection_release(struct rcu_head *rcu) 17944798cbbfSAlexander Aring { 17954798cbbfSAlexander Aring struct connection *con = container_of(rcu, struct connection, rcu); 17964798cbbfSAlexander Aring 17974798cbbfSAlexander Aring kfree(con->rx_buf); 17984798cbbfSAlexander Aring kfree(con); 17994798cbbfSAlexander Aring } 18004798cbbfSAlexander Aring 18015e9ccc37SChristine Caulfield static void free_conn(struct connection *con) 18025e9ccc37SChristine Caulfield { 18030d737a8cSMarcelo Ricardo Leitner close_connection(con, true, true, true); 1804a47666ebSAlexander Aring spin_lock(&connections_lock); 1805a47666ebSAlexander Aring hlist_del_rcu(&con->list); 1806a47666ebSAlexander Aring spin_unlock(&connections_lock); 1807948c47e9SAlexander Aring if (con->othercon) { 1808948c47e9SAlexander Aring clean_one_writequeue(con->othercon); 18095cbec208SAlexander Aring call_srcu(&connections_srcu, &con->othercon->rcu, 18105cbec208SAlexander Aring connection_release); 1811948c47e9SAlexander Aring } 18120de98432SAlexander Aring clean_one_writequeue(con); 18135cbec208SAlexander Aring call_srcu(&connections_srcu, &con->rcu, connection_release); 18146ed7257bSPatrick Caulfield } 18155e9ccc37SChristine Caulfield 1816f0fb83cbStsutomu.owa@toshiba.co.jp static void work_flush(void) 1817f0fb83cbStsutomu.owa@toshiba.co.jp { 1818b38bc9c2SAlexander Aring int ok; 1819f0fb83cbStsutomu.owa@toshiba.co.jp int i; 1820f0fb83cbStsutomu.owa@toshiba.co.jp struct connection *con; 1821f0fb83cbStsutomu.owa@toshiba.co.jp 1822f0fb83cbStsutomu.owa@toshiba.co.jp do { 1823f0fb83cbStsutomu.owa@toshiba.co.jp ok = 1; 1824f0fb83cbStsutomu.owa@toshiba.co.jp foreach_conn(stop_conn); 1825b355516fSDavid Windsor if (recv_workqueue) 1826f0fb83cbStsutomu.owa@toshiba.co.jp flush_workqueue(recv_workqueue); 1827b355516fSDavid Windsor if (send_workqueue) 1828f0fb83cbStsutomu.owa@toshiba.co.jp flush_workqueue(send_workqueue); 1829f0fb83cbStsutomu.owa@toshiba.co.jp for (i = 0; i < CONN_HASH_SIZE && ok; i++) { 1830a47666ebSAlexander Aring hlist_for_each_entry_rcu(con, &connection_hash[i], 1831a47666ebSAlexander Aring list) { 1832f0fb83cbStsutomu.owa@toshiba.co.jp ok &= test_bit(CF_READ_PENDING, &con->flags); 18338a4abb08Stsutomu.owa@toshiba.co.jp ok &= test_bit(CF_WRITE_PENDING, &con->flags); 18348a4abb08Stsutomu.owa@toshiba.co.jp if (con->othercon) { 1835f0fb83cbStsutomu.owa@toshiba.co.jp ok &= test_bit(CF_READ_PENDING, 1836f0fb83cbStsutomu.owa@toshiba.co.jp &con->othercon->flags); 18378a4abb08Stsutomu.owa@toshiba.co.jp ok &= test_bit(CF_WRITE_PENDING, 18388a4abb08Stsutomu.owa@toshiba.co.jp &con->othercon->flags); 18398a4abb08Stsutomu.owa@toshiba.co.jp } 1840f0fb83cbStsutomu.owa@toshiba.co.jp } 1841f0fb83cbStsutomu.owa@toshiba.co.jp } 1842f0fb83cbStsutomu.owa@toshiba.co.jp } while (!ok); 1843f0fb83cbStsutomu.owa@toshiba.co.jp } 1844f0fb83cbStsutomu.owa@toshiba.co.jp 18455e9ccc37SChristine Caulfield void dlm_lowcomms_stop(void) 18465e9ccc37SChristine Caulfield { 1847b38bc9c2SAlexander Aring int idx; 1848b38bc9c2SAlexander Aring 1849b38bc9c2SAlexander Aring idx = srcu_read_lock(&connections_srcu); 1850f0fb83cbStsutomu.owa@toshiba.co.jp work_flush(); 18513a8db798SMarcelo Ricardo Leitner foreach_conn(free_conn); 1852b38bc9c2SAlexander Aring srcu_read_unlock(&connections_srcu, idx); 18536ed7257bSPatrick Caulfield work_stop(); 1854043697f0SAlexander Aring deinit_local(); 1855a66c008cSAlexander Aring 1856a66c008cSAlexander Aring dlm_proto_ops = NULL; 18576ed7257bSPatrick Caulfield } 18586ed7257bSPatrick Caulfield 18592dc6b115SAlexander Aring static int dlm_listen_for_all(void) 18602dc6b115SAlexander Aring { 18612dc6b115SAlexander Aring struct socket *sock; 18622dc6b115SAlexander Aring int result; 18632dc6b115SAlexander Aring 18642dc6b115SAlexander Aring log_print("Using %s for communications", 18652dc6b115SAlexander Aring dlm_proto_ops->name); 18662dc6b115SAlexander Aring 18672dc6b115SAlexander Aring result = dlm_proto_ops->listen_validate(); 18682dc6b115SAlexander Aring if (result < 0) 18692dc6b115SAlexander Aring return result; 18702dc6b115SAlexander Aring 18712dc6b115SAlexander Aring result = sock_create_kern(&init_net, dlm_local_addr[0]->ss_family, 18722dc6b115SAlexander Aring SOCK_STREAM, dlm_proto_ops->proto, &sock); 18732dc6b115SAlexander Aring if (result < 0) { 18742dc6b115SAlexander Aring log_print("Can't create comms socket, check SCTP is loaded"); 18752dc6b115SAlexander Aring goto out; 18762dc6b115SAlexander Aring } 18772dc6b115SAlexander Aring 18782dc6b115SAlexander Aring sock_set_mark(sock->sk, dlm_config.ci_mark); 18792dc6b115SAlexander Aring dlm_proto_ops->listen_sockopts(sock); 18802dc6b115SAlexander Aring 18812dc6b115SAlexander Aring result = dlm_proto_ops->listen_bind(sock); 18822dc6b115SAlexander Aring if (result < 0) 18832dc6b115SAlexander Aring goto out; 18842dc6b115SAlexander Aring 18852dc6b115SAlexander Aring save_listen_callbacks(sock); 18862dc6b115SAlexander Aring add_listen_sock(sock, &listen_con); 18872dc6b115SAlexander Aring 18882dc6b115SAlexander Aring INIT_WORK(&listen_con.rwork, process_listen_recv_socket); 18892dc6b115SAlexander Aring result = sock->ops->listen(sock, 5); 18902dc6b115SAlexander Aring if (result < 0) { 18912dc6b115SAlexander Aring dlm_close_sock(&listen_con.sock); 18922dc6b115SAlexander Aring goto out; 18932dc6b115SAlexander Aring } 18942dc6b115SAlexander Aring 18952dc6b115SAlexander Aring return 0; 18962dc6b115SAlexander Aring 18972dc6b115SAlexander Aring out: 18982dc6b115SAlexander Aring sock_release(sock); 18992dc6b115SAlexander Aring return result; 19002dc6b115SAlexander Aring } 19012dc6b115SAlexander Aring 19022dc6b115SAlexander Aring static int dlm_tcp_listen_validate(void) 19032dc6b115SAlexander Aring { 19042dc6b115SAlexander Aring /* We don't support multi-homed hosts */ 19052dc6b115SAlexander Aring if (dlm_local_count > 1) { 19062dc6b115SAlexander Aring log_print("TCP protocol can't handle multi-homed hosts, try SCTP"); 19072dc6b115SAlexander Aring return -EINVAL; 19082dc6b115SAlexander Aring } 19092dc6b115SAlexander Aring 19102dc6b115SAlexander Aring return 0; 19112dc6b115SAlexander Aring } 19122dc6b115SAlexander Aring 19132dc6b115SAlexander Aring static void dlm_tcp_sockopts(struct socket *sock) 19142dc6b115SAlexander Aring { 19152dc6b115SAlexander Aring /* Turn off Nagle's algorithm */ 19162dc6b115SAlexander Aring tcp_sock_set_nodelay(sock->sk); 19172dc6b115SAlexander Aring } 19182dc6b115SAlexander Aring 19192dc6b115SAlexander Aring static void dlm_tcp_listen_sockopts(struct socket *sock) 19202dc6b115SAlexander Aring { 19212dc6b115SAlexander Aring dlm_tcp_sockopts(sock); 19222dc6b115SAlexander Aring sock_set_reuseaddr(sock->sk); 19232dc6b115SAlexander Aring } 19242dc6b115SAlexander Aring 19252dc6b115SAlexander Aring static int dlm_tcp_listen_bind(struct socket *sock) 19262dc6b115SAlexander Aring { 19272dc6b115SAlexander Aring int addr_len; 19282dc6b115SAlexander Aring 19292dc6b115SAlexander Aring /* Bind to our port */ 19302dc6b115SAlexander Aring make_sockaddr(dlm_local_addr[0], dlm_config.ci_tcp_port, &addr_len); 19312dc6b115SAlexander Aring return sock->ops->bind(sock, (struct sockaddr *)dlm_local_addr[0], 19322dc6b115SAlexander Aring addr_len); 19332dc6b115SAlexander Aring } 19342dc6b115SAlexander Aring 1935a66c008cSAlexander Aring static const struct dlm_proto_ops dlm_tcp_ops = { 19362dc6b115SAlexander Aring .name = "TCP", 19372dc6b115SAlexander Aring .proto = IPPROTO_TCP, 19382dc6b115SAlexander Aring .listen_validate = dlm_tcp_listen_validate, 19392dc6b115SAlexander Aring .listen_sockopts = dlm_tcp_listen_sockopts, 19402dc6b115SAlexander Aring .listen_bind = dlm_tcp_listen_bind, 1941a66c008cSAlexander Aring .connect_action = tcp_connect_to_sock, 1942a66c008cSAlexander Aring .shutdown_action = dlm_tcp_shutdown, 1943a66c008cSAlexander Aring .eof_condition = tcp_eof_condition, 1944a66c008cSAlexander Aring }; 1945a66c008cSAlexander Aring 1946*90d21fc0SAlexander Aring static int dlm_sctp_listen_validate(void) 1947*90d21fc0SAlexander Aring { 1948*90d21fc0SAlexander Aring if (!IS_ENABLED(CONFIG_IP_SCTP)) { 1949*90d21fc0SAlexander Aring log_print("SCTP is not enabled by this kernel"); 1950*90d21fc0SAlexander Aring return -EOPNOTSUPP; 1951*90d21fc0SAlexander Aring } 1952*90d21fc0SAlexander Aring 1953*90d21fc0SAlexander Aring request_module("sctp"); 1954*90d21fc0SAlexander Aring return 0; 1955*90d21fc0SAlexander Aring } 1956*90d21fc0SAlexander Aring 19572dc6b115SAlexander Aring static int dlm_sctp_bind_listen(struct socket *sock) 19582dc6b115SAlexander Aring { 19592dc6b115SAlexander Aring return sctp_bind_addrs(sock, dlm_config.ci_tcp_port); 19602dc6b115SAlexander Aring } 19612dc6b115SAlexander Aring 19622dc6b115SAlexander Aring static void dlm_sctp_sockopts(struct socket *sock) 19632dc6b115SAlexander Aring { 19642dc6b115SAlexander Aring /* Turn off Nagle's algorithm */ 19652dc6b115SAlexander Aring sctp_sock_set_nodelay(sock->sk); 19662dc6b115SAlexander Aring sock_set_rcvbuf(sock->sk, NEEDED_RMEM); 19672dc6b115SAlexander Aring } 19682dc6b115SAlexander Aring 1969a66c008cSAlexander Aring static const struct dlm_proto_ops dlm_sctp_ops = { 19702dc6b115SAlexander Aring .name = "SCTP", 19712dc6b115SAlexander Aring .proto = IPPROTO_SCTP, 1972*90d21fc0SAlexander Aring .listen_validate = dlm_sctp_listen_validate, 19732dc6b115SAlexander Aring .listen_sockopts = dlm_sctp_sockopts, 19742dc6b115SAlexander Aring .listen_bind = dlm_sctp_bind_listen, 1975a66c008cSAlexander Aring .connect_action = sctp_connect_to_sock, 1976a66c008cSAlexander Aring }; 1977a66c008cSAlexander Aring 19786ed7257bSPatrick Caulfield int dlm_lowcomms_start(void) 19796ed7257bSPatrick Caulfield { 19806ed7257bSPatrick Caulfield int error = -EINVAL; 19815e9ccc37SChristine Caulfield int i; 19825e9ccc37SChristine Caulfield 19835e9ccc37SChristine Caulfield for (i = 0; i < CONN_HASH_SIZE; i++) 19845e9ccc37SChristine Caulfield INIT_HLIST_HEAD(&connection_hash[i]); 19856ed7257bSPatrick Caulfield 19866ed7257bSPatrick Caulfield init_local(); 19876ed7257bSPatrick Caulfield if (!dlm_local_count) { 1988617e82e1SDavid Teigland error = -ENOTCONN; 19896ed7257bSPatrick Caulfield log_print("no local IP address has been set"); 1990513ef596SDavid Teigland goto fail; 19916ed7257bSPatrick Caulfield } 19926ed7257bSPatrick Caulfield 1993d11ccd45SAlexander Aring INIT_WORK(&listen_con.rwork, process_listen_recv_socket); 1994d11ccd45SAlexander Aring 1995513ef596SDavid Teigland error = work_start(); 1996513ef596SDavid Teigland if (error) 1997fcef0e6cSAlexander Aring goto fail_local; 1998513ef596SDavid Teigland 1999513ef596SDavid Teigland dlm_allow_conn = 1; 20006ed7257bSPatrick Caulfield 20016ed7257bSPatrick Caulfield /* Start listening */ 2002ac7d5d03SAlexander Aring switch (dlm_config.ci_protocol) { 2003ac7d5d03SAlexander Aring case DLM_PROTO_TCP: 2004a66c008cSAlexander Aring dlm_proto_ops = &dlm_tcp_ops; 2005ac7d5d03SAlexander Aring break; 2006ac7d5d03SAlexander Aring case DLM_PROTO_SCTP: 2007a66c008cSAlexander Aring dlm_proto_ops = &dlm_sctp_ops; 2008ac7d5d03SAlexander Aring break; 2009ac7d5d03SAlexander Aring default: 2010ac7d5d03SAlexander Aring log_print("Invalid protocol identifier %d set", 2011ac7d5d03SAlexander Aring dlm_config.ci_protocol); 2012ac7d5d03SAlexander Aring error = -EINVAL; 20132dc6b115SAlexander Aring goto fail_proto_ops; 2014ac7d5d03SAlexander Aring } 20152dc6b115SAlexander Aring 20162dc6b115SAlexander Aring error = dlm_listen_for_all(); 20176ed7257bSPatrick Caulfield if (error) 20182dc6b115SAlexander Aring goto fail_listen; 20196ed7257bSPatrick Caulfield 20206ed7257bSPatrick Caulfield return 0; 20216ed7257bSPatrick Caulfield 20222dc6b115SAlexander Aring fail_listen: 20232dc6b115SAlexander Aring dlm_proto_ops = NULL; 20242dc6b115SAlexander Aring fail_proto_ops: 2025513ef596SDavid Teigland dlm_allow_conn = 0; 2026d11ccd45SAlexander Aring dlm_close_sock(&listen_con.sock); 2027fcef0e6cSAlexander Aring work_stop(); 2028fcef0e6cSAlexander Aring fail_local: 2029fcef0e6cSAlexander Aring deinit_local(); 2030513ef596SDavid Teigland fail: 20316ed7257bSPatrick Caulfield return error; 20326ed7257bSPatrick Caulfield } 203336b71a8bSDavid Teigland 203436b71a8bSDavid Teigland void dlm_lowcomms_exit(void) 203536b71a8bSDavid Teigland { 203636b71a8bSDavid Teigland struct dlm_node_addr *na, *safe; 203736b71a8bSDavid Teigland 203836b71a8bSDavid Teigland spin_lock(&dlm_node_addrs_spin); 203936b71a8bSDavid Teigland list_for_each_entry_safe(na, safe, &dlm_node_addrs, list) { 204036b71a8bSDavid Teigland list_del(&na->list); 204136b71a8bSDavid Teigland while (na->addr_count--) 204236b71a8bSDavid Teigland kfree(na->addr[na->addr_count]); 204336b71a8bSDavid Teigland kfree(na); 204436b71a8bSDavid Teigland } 204536b71a8bSDavid Teigland spin_unlock(&dlm_node_addrs_spin); 204636b71a8bSDavid Teigland } 2047