Commit 194a3fb4 authored Oct 27, 2022 by Alexander Aring Committed by David Teigland Nov 08, 2022

fs: dlm: relax sending to allow receiving

This patch drops additionally the sock_mutex when there is a sending
message burst. Since we have acknowledge handling we free sending
buffers only when we receive an ack back, but if we are stuck in
send_to_sock() looping because dlm sends a lot of messages and we never
leave the loop the sending buffer fill up very quickly. We can't receive
during this iteration because the sock_mutex is held. This patch will
unlock the sock_mutex so it should be possible to receive messages when
a burst of sending messages happens. This will allow to free up memory
because acks which are already received can be processed.

Signed-off-by: Alexander Aring <aahringo@redhat.com>
Signed-off-by: David Teigland <teigland@redhat.com>

parent 3872f87b

fs/dlm/lowcomms.c

+10 −5

Original line number	Diff line number	Diff line
		@@ -1418,7 +1418,10 @@ static void send_to_sock(struct connection *con)
		const int msg_flags = MSG_DONTWAIT \| MSG_NOSIGNAL;
		struct writequeue_entry *e;
		int len, offset, ret;
		int count = 0;
		int count;

		again:
		count = 0;

		mutex_lock(&con->sock_mutex);
		if (con->sock == NULL)
		@@ -1453,14 +1456,16 @@ static void send_to_sock(struct connection *con)
		} else if (ret < 0)
		goto out;

		spin_lock(&con->writequeue_lock);
		writequeue_entry_complete(e, ret);

		/* Don't starve people filling buffers */
		if (++count >= MAX_SEND_MSG_COUNT) {
		spin_unlock(&con->writequeue_lock);
		mutex_unlock(&con->sock_mutex);
		cond_resched();
		count = 0;
		goto again;
		}

		spin_lock(&con->writequeue_lock);
		writequeue_entry_complete(e, ret);
		}
		spin_unlock(&con->writequeue_lock);