fs: dlm: rework receive and transmit handling
Alexander Aring
maintainercover fs: dlm: rework receive and transmit handling
Hi,
This patch series contains a huge change regarding to the receive/transmit handling of dlm. As I placed sequence numbering on dlm messages I expierenced that dlm messages can be transmitted in an incorrect order. I changed the transmit handling that the writequeue handles entries per dlm message buffer and sendmsg() will use scatter/gather to transmit a bunch of them. At the receive handling I removed some allocations and copies into different buffers. There is only one receive buffer now which fill be get filled and the upper layer will working on that buffer as well.
- Alex
Alexander Aring (6):
fs: dlm: remove lock dependency warning
fs: dlm: handle range check as callback
fs: dlm: disallow buffer size below default
fs: dlm: release connection with call_rcu
fs: dlm: rework receive handling
fs: dlm: rework transmit handling
fs/dlm/config.c | 47 +++-- fs/dlm/config.h | 2 + fs/dlm/lowcomms.c | 471 ++++++++++++++++++++++------------------------ fs/dlm/midcomms.c | 136 ++++++------- fs/dlm/midcomms.h | 3 +- 5 files changed, 310 insertions(+), 349 deletions(-)
Signature · 1 line
2.26.2
Alexander Aring
maintainerPATCH 1/6 fs: dlm: remove lock dependency warning
During my experiments to make dlm robust against tcpkill application I was able to run sometimes in a circular lock dependency warning between clusters_root.subsys.su_mutex and con->sock_mutex. We don't need to held the sock_mutex when getting the mark value which held the clusters_root.subsys.su_mutex. This patch moves the specific handling just before the sock_mutex will be held.
--- fs/dlm/lowcomms.c | 18 ++++++++---------- 1 file changed, 8 insertions(+), 10 deletions(-)
fs/dlm/lowcomms.c +8 -10
@@ -971,6 +971,10 @@ static void sctp_connect_to_sock(struct connection *con)return ; } + result =dlm_comm_mark (con->nodeid, &mark); +if (result <0 ) +return ; +mutex_lock (&con->sock_mutex);/* Some odd races can cause double-connects, ignore them */
@@ -995,11 +999,6 @@ static void sctp_connect_to_sock(struct connection *con)if (result <0 ) goto socket_err; -/* set skb mark */ - result =dlm_comm_mark (con->nodeid, &mark); -if (result <0 ) - goto bind_err; -sock_set_mark (sock->sk, mark); con->rx_action = receive_from_sock;
@@ -1072,6 +1071,10 @@ static void tcp_connect_to_sock(struct connection *con)return ; } + result =dlm_comm_mark (con->nodeid, &mark); +if (result <0 ) +return ; +mutex_lock (&con->sock_mutex);if (con->retries++ >MAX_CONNECT_RETRIES ) goto out;
@@ -1086,11 +1089,6 @@ static void tcp_connect_to_sock(struct connection *con)if (result <0 ) goto out_err; -/* set skb mark */ - result =dlm_comm_mark (con->nodeid, &mark); -if (result <0 ) - goto out_err; -sock_set_mark (sock->sk, mark);memset (&saddr,0 ,sizeof (saddr));
Signature · 1 line
2.26.2
Alexander Aring
maintainerPATCH 2/6 fs: dlm: handle range check as callback
In reply to Alexander AringThis patch adds a callback to CLUSTER_ATTR macro to allow individual callbacks for attributes which might have a more complex attribute range checking just than non zero.
--- fs/dlm/config.c | 41 +++++++++++++++++++++++------------------ 1 file changed, 23 insertions(+), 18 deletions(-)
fs/dlm/config.c +23 -18
@@ -125,7 +125,7 @@ static ssize_t cluster_cluster_name_store(struct config_item *item,CONFIGFS_ATTR (cluster_, cluster_name);static ssize_t cluster_set (struct dlm_cluster *cl,unsigned int *cl_field, -int *info_field,int check_zero, +int *info_field,bool (*check_cb)(unsigned int x),const char *buf,size_t len) {unsigned int x;
@@ -137,7 +137,7 @@ static ssize_t cluster_set(struct dlm_cluster *cl, unsigned int *cl_field,if (rc)return rc; -if (check_zero && !x) +if (check_cb &&check_cb (x))return -EINVAL ; *cl_field = x;
@@ -146,13 +146,13 @@ static ssize_t cluster_set(struct dlm_cluster *cl, unsigned int *cl_field,return len; } -#define CLUSTER_ATTR (name, check_zero) \ +#define CLUSTER_ATTR (name, check_cb) \ static ssize_t cluster_##name##_store(struct config_item *item, \ const char *buf, size_t len) \ { \ struct dlm_cluster *cl = config_item_to_cluster(item); \ return cluster_set(cl, &cl->cl_##name, &dlm_config.ci_##name, \ - check_zero, buf, len); \ + check_cb, buf, len); \ } \ static ssize_t cluster_##name##_show(struct config_item *item, char *buf) \ { \
@@ -161,20 +161,25 @@ static ssize_t cluster_##name##_show(struct config_item *item, char *buf) \ } \CONFIGFS_ATTR (cluster_, name); -CLUSTER_ATTR (tcp_port,1 ); -CLUSTER_ATTR (buffer_size,1 ); -CLUSTER_ATTR (rsbtbl_size,1 ); -CLUSTER_ATTR (recover_timer,1 ); -CLUSTER_ATTR (toss_secs,1 ); -CLUSTER_ATTR (scan_secs,1 ); -CLUSTER_ATTR (log_debug,0 ); -CLUSTER_ATTR (log_info,0 ); -CLUSTER_ATTR (protocol,0 ); -CLUSTER_ATTR (mark,0 ); -CLUSTER_ATTR (timewarn_cs,1 ); -CLUSTER_ATTR (waitwarn_us,0 ); -CLUSTER_ATTR (new_rsb_count,0 ); -CLUSTER_ATTR (recover_callbacks,0 ); +static bool dlm_check_zero (unsigned int x) +{ +return !x; +} + +CLUSTER_ATTR (tcp_port, dlm_check_zero); +CLUSTER_ATTR (buffer_size, dlm_check_zero); +CLUSTER_ATTR (rsbtbl_size, dlm_check_zero); +CLUSTER_ATTR (recover_timer, dlm_check_zero); +CLUSTER_ATTR (toss_secs, dlm_check_zero); +CLUSTER_ATTR (scan_secs, dlm_check_zero); +CLUSTER_ATTR (log_debug,NULL ); +CLUSTER_ATTR (log_info,NULL ); +CLUSTER_ATTR (protocol,NULL ); +CLUSTER_ATTR (mark,NULL ); +CLUSTER_ATTR (timewarn_cs, dlm_check_zero); +CLUSTER_ATTR (waitwarn_us,NULL ); +CLUSTER_ATTR (new_rsb_count,NULL ); +CLUSTER_ATTR (recover_callbacks,NULL );static struct configfs_attribute *cluster_attrs[] = { [CLUSTER_ATTR_TCP_PORT ] = &cluster_attr_tcp_port,
Signature · 1 line
2.26.2
Alexander Aring
maintainerPATCH 3/6 fs: dlm: disallow buffer size below default
In reply to Alexander AringI observed dlm messages cannot below this value delivered from upper layers. This buffer is used inside the current receive handling to copy a dlm message into it. However we should not allow sizes below the default value.
--- fs/dlm/config.c | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-)
fs/dlm/config.c +7 -2
@@ -166,8 +166,14 @@ static bool dlm_check_zero(unsigned int x)return !x; } +#define DEFAULT_BUFFER_SIZE 4096 +static bool dlm_check_buffer_size (unsigned int x) +{ +return (x <DEFAULT_BUFFER_SIZE ); +} +CLUSTER_ATTR (tcp_port, dlm_check_zero); -CLUSTER_ATTR (buffer_size, dlm_check_zero); +CLUSTER_ATTR (buffer_size, dlm_check_buffer_size);CLUSTER_ATTR (rsbtbl_size, dlm_check_zero);CLUSTER_ATTR (recover_timer, dlm_check_zero);CLUSTER_ATTR (toss_secs, dlm_check_zero);
@@ -897,7 +903,6 @@ int dlm_our_addr(struct sockaddr_storage *addr, int num)/* Config file defaults */ #define DEFAULT_TCP_PORT 21064 -#define DEFAULT_BUFFER_SIZE 4096#define DEFAULT_RSBTBL_SIZE 1024#define DEFAULT_RECOVER_TIMER 5#define DEFAULT_TOSS_SECS 10
Signature · 1 line
2.26.2
Alexander Aring
maintainerPATCH 4/6 fs: dlm: release connection with call_rcu
In reply to Alexander AringThis patch will introduce to use call_rcu() for a connection structure which will call do a deep-free of fields of the connection structure.
--- fs/dlm/lowcomms.c | 17 +++++++++++------ 1 file changed, 11 insertions(+), 6 deletions(-)
fs/dlm/lowcomms.c +11 -6
@@ -1603,18 +1603,23 @@ static void shutdown_conn(struct connection *con) con->shutdown_action (con); } +static void connection_release (struct rcu_head *rcu) +{ + struct connection *con = container_of(rcu, struct connection, rcu); + +clean_one_writequeue (con); +kfree (con); +} +static void free_conn (struct connection *con) {close_connection (con, true, true, true);spin_lock (&connections_lock);hlist_del_rcu (&con->list);spin_unlock (&connections_lock); -if (con->othercon) { -clean_one_writequeue (con->othercon); -kfree_rcu (con->othercon, rcu); - } -clean_one_writequeue (con); -kfree_rcu (con, rcu); +if (con->othercon) +call_rcu (&con->othercon->rcu, connection_release); +call_rcu (&con->rcu, connection_release); }static void work_flush (void )
Signature · 1 line
2.26.2
Alexander Aring
maintainerPATCH 5/6 fs: dlm: rework receive handling
In reply to Alexander AringThis patch reworks the current receive handling of dlm. As I tried to change the send handling to fix reorder issues I took a look into the receive handling and simplified it, it works as the following:
Each connection has a preallocated receive buffer with a minimum length of 4096. On receive, the upper layer protocol will process all dlm message until there is not enough data anymore. If there exists "leftover" data at the end of the receive buffer because the dlm message wasn't fully received it will be copied to the begin of the preallocated receive buffer. Next receive more data will be appended to the previous "leftover" data and processing will begin again.
This will remove a lot of code of the current mechanism. Inside the processing functionality we will ensure with a memmove() that the dlm message should be memory aligned. To have a dlm message always started at the beginning of the buffer will reduce some amount of memmove() calls because src and dest pointers are the same.
The cluster attribute "buffer_size" becomes a new meaning, it's now the size of application layer receive buffer size. If this is changed during runtime the receive buffer will be reallocated. It's important that the receive buffer size has at minimum the size of the maximum possible dlm message size otherwise the received message cannot be placed inside the receive buffer size.
--- fs/dlm/config.c | 1 - fs/dlm/config.h | 2 + fs/dlm/lowcomms.c | 168 +++++++++++++++++++++------------------------- fs/dlm/midcomms.c | 136 +++++++++++++++---------------------- fs/dlm/midcomms.h | 3 +- 5 files changed, 132 insertions(+), 178 deletions(-)
fs/dlm/config.c +0 -1
@@ -166,7 +166,6 @@ static bool dlm_check_zero(unsigned int x)return !x; } -#define DEFAULT_BUFFER_SIZE 4096static bool dlm_check_buffer_size (unsigned int x) {return (x <DEFAULT_BUFFER_SIZE );
fs/dlm/config.h +2 -0
@@ -12,6 +12,8 @@ #ifndef __CONFIG_DOT_H__ #define __CONFIG_DOT_H__ +#define DEFAULT_BUFFER_SIZE 4096 + struct dlm_config_node { int nodeid; int weight;
fs/dlm/lowcomms.c +76 -92
246 lines not on this page · raw message
fs/dlm/midcomms.c +53 -83
167 lines not on this page · raw message
fs/dlm/midcomms.h +1 -2
@@ -12,8 +12,7 @@#ifndef __MIDCOMMS_DOT_H__#define __MIDCOMMS_DOT_H__ -int dlm_process_incoming_buffer (int nodeid,const void *base,unsigned offset, -unsigned len,unsigned limit); +int dlm_process_incoming_buffer (int nodeid,unsigned char *buf,int buflen);#endif /* __MIDCOMMS_DOT_H__ */
Signature · 1 line
2.26.2
Alexander Aring
maintainerPATCH 6/6 fs: dlm: rework transmit handling
In reply to Alexander AringI detected that dlm messages are transmitted sometimes in a incorrect order according to the writequeue locked area of commit_buffer(). This patch replace the current sending mechanism by a basic per dlm message queue which handles a entry of the writequeue as per dlm message. The sending mechanism will then use a scatter/gather of the first n writequeue entries. However that will ensure we send dlm messages in order according to the commit_buffer() call. The lock of the writequeue was changed that readers are lockless with help of RCU.
--- fs/dlm/lowcomms.c | 268 ++++++++++++++++++++++------------------------ 1 file changed, 131 insertions(+), 137 deletions(-)
fs/dlm/lowcomms.c +131 -137
@@ -61,8 +61,8 @@#define NEEDED_RMEM (4*1024*1024)#define CONN_HASH_SIZE 32 -/* Number of messages to send before rescheduling */ -#define MAX_SEND_MSG_COUNT 25 +/* How many dlm messages should be used for scatter/gather to send */ +#define MAX_SEND_IOV_COUNT 25#define DLM_SHUTDOWN_WAIT_TIMEOUT msecs_to_jiffies(10000)struct connection {
@@ -83,6 +83,10 @@ struct connection {int (*rx_action) (struct connection *);/* What to do when active */ void (*connect_action) (struct connection *);/* What to do to connect */ void (*shutdown_action)(struct connection *con);/* What to do to shutdown */ +struct writequeue_entry *tx_queue[MAX_SEND_IOV_COUNT ]; +struct kvec tx_iov[MAX_SEND_IOV_COUNT ]; +struct msghdr tx_msg; +int tx_queue_cnt;int retries;#define MAX_CONNECT_RETRIES 3struct hlist_node list;
@@ -99,13 +103,12 @@ struct connection {/* An entry waiting to be sent */ struct writequeue_entry { -struct list_head list; -struct page *page; -int offset; -int len; -int end; -int users;struct connection *con; +unsigned char *buf; +int len; + +struct list_head list; +struct rcu_head rcu; };struct dlm_node_addr {
@@ -233,6 +236,19 @@ static void foreach_conn(void (*conn_func)(struct connection *c))srcu_read_unlock (&connections_srcu, idx); } +/* can only be used to check if something is pending to transmit */ +static bool writequeue_has_entries (struct connection *con) +{ +void *e; + +rcu_read_lock (); + e =list_first_or_null_rcu (&con->writequeue, + struct writequeue_entry, list); +rcu_read_unlock (); + +return !!e; +} +static struct dlm_node_addr *find_node_addr (int nodeid) {struct dlm_node_addr *na;
@@ -588,6 +604,15 @@ static void close_connection(struct connection *con, bool and_other,close_connection (con->othercon, false, true, true); } +/* ideally we would check which messages inside the writequeue +* was sent and which was not, if we didn't send everything in +* one sendmsg() call. However on a sock_release() we will +* drop messages anyway, there need to be other mechanisms +* to check on duplicates or retranmissions. Setting +* con->tx_queue_cnt to zero should ensure we doesn't start +* to transmit in the middle of an dlm message. +*/ + con->tx_queue_cnt =0 ; con->rx_leftover =0 ; con->retries =0 ;mutex_unlock (&con->sock_mutex);
@@ -885,28 +910,23 @@ static int accept_from_sock(struct connection *con)return result; } -static void free_entry (struct writequeue_entry *e) +static void writequeue_entry_release (struct rcu_head *rcu) { -__free_page (e->page); + struct writequeue_entry *e = container_of(rcu, struct writequeue_entry, + rcu); + +kfree (e->buf);kfree (e); } -/* -* writequeue_entry_complete - try to delete and free write queue entry -* @e: write queue entry to try to delete -* @completed: bytes completed -* -* writequeue_lock must be held. -*/ -static void writequeue_entry_complete (struct writequeue_entry *e,int completed) +static void writequeue_entry_complete (struct connection *con, +struct writequeue_entry *e) { - e->offset += completed; - e->len -= completed; +spin_lock (&con->writequeue_lock); +list_del_rcu (&e->list); +spin_unlock (&con->writequeue_lock); -if (e->len ==0 && e->users ==0 ) { -list_del (&e->list); -free_entry (e); - } +call_rcu (&e->rcu, writequeue_entry_release); }/*
@@ -1306,149 +1326,123 @@ static int tcp_listen_for_all(void)return result; } - - -static struct writequeue_entry *new_writequeue_entry (struct connection *con, -gfp_t allocation) +void *dlm_lowcomms_get_buffer (int nodeid,int len,gfp_t allocation,char **ppc) { -struct writequeue_entry *entry; - - entry =kmalloc (sizeof (struct writequeue_entry ), allocation); -if (!entry) -return NULL ; +struct writequeue_entry *e; +struct connection *con; +void *buf; - entry->page =alloc_page (allocation); -if (!entry->page) { -kfree (entry); +if (len >DEFAULT_BUFFER_SIZE ) { +log_print ("Error ULP tried to allocate more than capable message size" );return NULL ; } - entry->offset =0 ; - entry->len =0 ; - entry->end =0 ; - entry->users =0 ; - entry->con = con; - -return entry; -} - -void *dlm_lowcomms_get_buffer (int nodeid,int len,gfp_t allocation,char **ppc) -{ -struct connection *con; -struct writequeue_entry *e; -int offset =0 ; - con =nodeid2con (nodeid, allocation);if (!con)return NULL ; -spin_lock (&con->writequeue_lock); - e = list_entry(con->writequeue.prev, struct writequeue_entry, list); -if ((&e->list == &con->writequeue) || - (PAGE_SIZE - e->end < len)) { - e =NULL ; - }else { - offset = e->end; - e->end += len; - e->users++; - } -spin_unlock (&con->writequeue_lock); + e =kzalloc (sizeof (*e), allocation); +if (!e) +return NULL ; -if (e) { - got_one: - *ppc =page_address (e->page) + offset; -return e; + buf =kmalloc (len, allocation); +if (!buf) { +kfree (e); +return NULL ; } - e =new_writequeue_entry (con, allocation); -if (e) { -spin_lock (&con->writequeue_lock); - offset = e->end; - e->end += len; - e->users++; -list_add_tail (&e->list, &con->writequeue); -spin_unlock (&con->writequeue_lock); - goto got_one; - } -return NULL ; + e->con = con; + e->buf = buf; + e->len = len; + + *ppc = buf; + +return e; }void dlm_lowcomms_commit_buffer (void *mh) { -struct writequeue_entry *e = (struct writequeue_entry *)mh; +struct writequeue_entry *e = mh;struct connection *con = e->con; -int users;spin_lock (&con->writequeue_lock); - users = --e->users; -if (users) - goto out; - e->len = e->end - e->offset; +list_add_tail_rcu (&e->list, &con->writequeue);spin_unlock (&con->writequeue_lock);queue_work (send_workqueue, &con->swork); -return ; +} -out: -spin_unlock (&con->writequeue_lock); -return ; +static void send_to_sock_setup_msg (struct connection *con) +{ +struct writequeue_entry *e; +size_t size =0 ; +int num =0 ; + +rcu_read_lock (); +list_for_each_entry_rcu (e, &con->writequeue, list) { +if (num ==MAX_SEND_IOV_COUNT ) +break ; + + con->tx_iov[num].iov_base = e->buf; + con->tx_iov[num].iov_len = e->len; + con->tx_queue[num] = e; + + size += con->tx_iov[num].iov_len; + num++; + } +rcu_read_unlock (); + +memset (&con->tx_msg,0 ,sizeof (con->tx_msg)); + con->tx_msg.msg_flags =MSG_DONTWAIT |MSG_NOSIGNAL ; +iov_iter_kvec (&con->tx_msg.msg_iter,WRITE , con->tx_iov, num, size); + con->tx_queue_cnt = num; }/* Send a message */ static void send_to_sock (struct connection *con) { -int ret =0 ; -const int msg_flags =MSG_DONTWAIT |MSG_NOSIGNAL ; -struct writequeue_entry *e; -int len, offset; -int count =0 ; +int ret, i;mutex_lock (&con->sock_mutex);if (con->sock ==NULL ) goto out_connect; -spin_lock (&con->writequeue_lock); -for (;;) { - e = list_entry(con->writequeue.next, struct writequeue_entry, - list); -if ((struct list_head *) e == &con->writequeue) -break ; - - len = e->len; - offset = e->offset; -BUG_ON (len ==0 && e->users ==0 ); -spin_unlock (&con->writequeue_lock); - - ret =0 ; -if (len) { - ret =kernel_sendpage (con->sock, e->page, offset, len, - msg_flags); -if (ret == -EAGAIN || ret ==0 ) { -if (ret == -EAGAIN && -test_bit (SOCKWQ_ASYNC_NOSPACE , &con->sock->flags) && - !test_and_set_bit (CF_APP_LIMITED , &con->flags)) { -/* Notify TCP that we're limited by the -* application window size. -*/ -set_bit (SOCK_NOSPACE , &con->sock->flags); - con->sock->sk->sk_write_pending++; - } -cond_resched (); - goto out; - }else if (ret <0 ) - goto send_error; +/* fill up msghdr with messages from writequeue */ +if (!con->tx_queue_cnt) +send_to_sock_setup_msg (con); + + ret =sock_sendmsg (con->sock, &con->tx_msg); +if (ret == -EAGAIN ) { +if (ret == -EAGAIN && +test_bit (SOCKWQ_ASYNC_NOSPACE , &con->sock->flags) && + !test_and_set_bit (CF_APP_LIMITED , &con->flags)) { +/* Notify TCP that we're limited by the +* application window size. +*/ +set_bit (SOCK_NOSPACE , &con->sock->flags); + con->sock->sk->sk_write_pending++; } +queue_work (send_workqueue, &con->swork); +cond_resched (); + goto out; + }else if (ret <0 ) { + goto send_error; + } -/* Don't starve people filling buffers */ -if (++count >=MAX_SEND_MSG_COUNT ) { -cond_resched (); - count =0 ; - } +/* if we have nothing left to write cleanup messages from writequeue */ +if (!msg_data_left (&con->tx_msg)) { +for (i =0 ; i < con->tx_queue_cnt; i++) +writequeue_entry_complete (con, con->tx_queue[i]); + + con->tx_queue_cnt =0 ; -spin_lock (&con->writequeue_lock); -writequeue_entry_complete (e, ret); +if (writequeue_has_entries (con)) +queue_work (send_workqueue, &con->swork); + }else { +/* call again sendmsg() we didn't send everything */ +queue_work (send_workqueue, &con->swork); } -spin_unlock (&con->writequeue_lock); + out:mutex_unlock (&con->sock_mutex);return ;
@@ -1469,14 +1463,13 @@ static void send_to_sock(struct connection *con)static void clean_one_writequeue (struct connection *con) { -struct writequeue_entry *e, *safe; +struct writequeue_entry *e; -spin_lock (&con->writequeue_lock); -list_for_each_entry_safe (e, safe, &con->writequeue, list) { -list_del (&e->list); -free_entry (e); +rcu_read_lock (); +list_for_each_entry_rcu (e, &con->writequeue, list) { +writequeue_entry_complete (con, e); } -spin_unlock (&con->writequeue_lock); +rcu_read_unlock (); }/* Called from recovery when it knows that a node has
@@ -1527,7 +1520,8 @@ static void process_send_sockets(struct work_struct *work)clear_bit (CF_WRITE_PENDING , &con->flags);if (con->sock ==NULL )/* not mutex protected so check it inside too */ con->connect_action (con); -if (!list_empty (&con->writequeue)) + +if (writequeue_has_entries (con))send_to_sock (con); }
Signature · 1 line
2.26.2
Alexander Ahring Oder Aring
maintainercover fs: dlm: rework receive and transmit handling
In reply to Alexander AringHi David,
Quoted 12 lines · Alexander Aring
Hi,
This patch series contains a huge change regarding to the receive/transmit handling of dlm. As I placed sequence numbering on dlm messages I expierenced that dlm messages can be transmitted in an incorrect order. I changed the transmit handling that the writequeue handles entries per dlm message buffer and
sendmsg()will use scatter/gather to transmit a bunch of them. At the receive handling I removed some allocations and copies into different buffers. There is only one receive buffer now which fill be get filled and the upper layer will working on that buffer as well.
I got a review today and we should stick to sendpage() functionality. Please wait for a resend of v2. Meanwhile I also detected issues with the mark handling which I want to fix as well.
Thanks.
- Alex