Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit d9dc8b0f authored by WANG Cong's avatar WANG Cong Committed by David S. Miller
Browse files

net: fix sleeping for sk_wait_event() 



Similar to commit 14135f30 ("inet: fix sleeping inside inet_wait_for_connect()"),
sk_wait_event() needs to fix too, because release_sock() is blocking,
it changes the process state back to running after sleep, which breaks
the previous prepare_to_wait().

Switch to the new wait API.

Cc: Eric Dumazet <eric.dumazet@gmail.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Signed-off-by: default avatarCong Wang <xiyou.wangcong@gmail.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent 7d384846

crypto/algif_aead.c

+4 −5
Original line number Diff line number Diff line
@@ -132,28 +132,27 @@ static void aead_wmem_wakeup(struct sock *sk) 


static int aead_wait_for_data(struct sock *sk, unsigned flags)

{

	DEFINE_WAIT_FUNC(wait, woken_wake_function);

	struct alg_sock *ask = alg_sk(sk);

	struct aead_ctx *ctx = ask->private;

	long timeout;

	DEFINE_WAIT(wait);

	int err = -ERESTARTSYS;



	if (flags & MSG_DONTWAIT)

		return -EAGAIN;



	sk_set_bit(SOCKWQ_ASYNC_WAITDATA, sk);



	add_wait_queue(sk_sleep(sk), &wait);

	for (;;) {

		if (signal_pending(current))

			break;

		prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);

		timeout = MAX_SCHEDULE_TIMEOUT;

		if (sk_wait_event(sk, &timeout, !ctx->more)) {

		if (sk_wait_event(sk, &timeout, !ctx->more, &wait)) {

			err = 0;

			break;

		}

	}

	finish_wait(sk_sleep(sk), &wait);

	remove_wait_queue(sk_sleep(sk), &wait);



	sk_clear_bit(SOCKWQ_ASYNC_WAITDATA, sk);

crypto/algif_skcipher.c

+9 −9
Original line number Diff line number Diff line
@@ -199,26 +199,26 @@ static void skcipher_free_sgl(struct sock *sk) 


static int skcipher_wait_for_wmem(struct sock *sk, unsigned flags)

{

	long timeout;

	DEFINE_WAIT(wait);

	DEFINE_WAIT_FUNC(wait, woken_wake_function);

	int err = -ERESTARTSYS;

	long timeout;



	if (flags & MSG_DONTWAIT)

		return -EAGAIN;



	sk_set_bit(SOCKWQ_ASYNC_NOSPACE, sk);



	add_wait_queue(sk_sleep(sk), &wait);

	for (;;) {

		if (signal_pending(current))

			break;

		prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);

		timeout = MAX_SCHEDULE_TIMEOUT;

		if (sk_wait_event(sk, &timeout, skcipher_writable(sk))) {

		if (sk_wait_event(sk, &timeout, skcipher_writable(sk), &wait)) {

			err = 0;

			break;

		}

	}

	finish_wait(sk_sleep(sk), &wait);

	remove_wait_queue(sk_sleep(sk), &wait);



	return err;

}
@@ -242,10 +242,10 @@ static void skcipher_wmem_wakeup(struct sock *sk) 


static int skcipher_wait_for_data(struct sock *sk, unsigned flags)

{

	DEFINE_WAIT_FUNC(wait, woken_wake_function);

	struct alg_sock *ask = alg_sk(sk);

	struct skcipher_ctx *ctx = ask->private;

	long timeout;

	DEFINE_WAIT(wait);

	int err = -ERESTARTSYS;



	if (flags & MSG_DONTWAIT) {
@@ -254,17 +254,17 @@ static int skcipher_wait_for_data(struct sock *sk, unsigned flags) 


	sk_set_bit(SOCKWQ_ASYNC_WAITDATA, sk);



	add_wait_queue(sk_sleep(sk), &wait);

	for (;;) {

		if (signal_pending(current))

			break;

		prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);

		timeout = MAX_SCHEDULE_TIMEOUT;

		if (sk_wait_event(sk, &timeout, ctx->used)) {

		if (sk_wait_event(sk, &timeout, ctx->used, &wait)) {

			err = 0;

			break;

		}

	}

	finish_wait(sk_sleep(sk), &wait);

	remove_wait_queue(sk_sleep(sk), &wait);



	sk_clear_bit(SOCKWQ_ASYNC_WAITDATA, sk);

include/net/sock.h

+5 −3
Original line number Diff line number Diff line
@@ -915,12 +915,14 @@ static inline void sock_rps_reset_rxhash(struct sock *sk) 
#endif

}



#define sk_wait_event(__sk, __timeo, __condition)			\

#define sk_wait_event(__sk, __timeo, __condition, __wait)		\

	({	int __rc;						\

		release_sock(__sk);					\

		__rc = __condition;					\

		if (!__rc) {						\

			*(__timeo) = schedule_timeout(*(__timeo));	\

			*(__timeo) = wait_woken(__wait,			\

						TASK_INTERRUPTIBLE,	\

						*(__timeo));		\

		}							\

		sched_annotate_sleep();					\

		lock_sock(__sk);					\

net/core/sock.c

+4 −4
Original line number Diff line number Diff line
@@ -2078,14 +2078,14 @@ void __sk_flush_backlog(struct sock *sk) 
 */

int sk_wait_data(struct sock *sk, long *timeo, const struct sk_buff *skb)

{

	DEFINE_WAIT_FUNC(wait, woken_wake_function);

	int rc;

	DEFINE_WAIT(wait);



	prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);

	add_wait_queue(sk_sleep(sk), &wait);

	sk_set_bit(SOCKWQ_ASYNC_WAITDATA, sk);

	rc = sk_wait_event(sk, timeo, skb_peek_tail(&sk->sk_receive_queue) != skb);

	rc = sk_wait_event(sk, timeo, skb_peek_tail(&sk->sk_receive_queue) != skb, &wait);

	sk_clear_bit(SOCKWQ_ASYNC_WAITDATA, sk);

	finish_wait(sk_sleep(sk), &wait);

	remove_wait_queue(sk_sleep(sk), &wait);

	return rc;

}

EXPORT_SYMBOL(sk_wait_data);

net/core/stream.c

+14 −14
Original line number Diff line number Diff line
@@ -53,8 +53,8 @@ void sk_stream_write_space(struct sock *sk) 
 */

int sk_stream_wait_connect(struct sock *sk, long *timeo_p)

{

	DEFINE_WAIT_FUNC(wait, woken_wake_function);

	struct task_struct *tsk = current;

	DEFINE_WAIT(wait);

	int done;



	do {
@@ -68,13 +68,13 @@ int sk_stream_wait_connect(struct sock *sk, long *timeo_p) 
		if (signal_pending(tsk))

			return sock_intr_errno(*timeo_p);



		prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);

		add_wait_queue(sk_sleep(sk), &wait);

		sk->sk_write_pending++;

		done = sk_wait_event(sk, timeo_p,

				     !sk->sk_err &&

				     !((1 << sk->sk_state) &

				       ~(TCPF_ESTABLISHED | TCPF_CLOSE_WAIT)));

		finish_wait(sk_sleep(sk), &wait);

				       ~(TCPF_ESTABLISHED | TCPF_CLOSE_WAIT)), &wait);

		remove_wait_queue(sk_sleep(sk), &wait);

		sk->sk_write_pending--;

	} while (!done);

	return 0;
@@ -94,16 +94,16 @@ static inline int sk_stream_closing(struct sock *sk) 
void sk_stream_wait_close(struct sock *sk, long timeout)

{

	if (timeout) {

		DEFINE_WAIT(wait);

		DEFINE_WAIT_FUNC(wait, woken_wake_function);



		add_wait_queue(sk_sleep(sk), &wait);



		do {

			prepare_to_wait(sk_sleep(sk), &wait,

					TASK_INTERRUPTIBLE);

			if (sk_wait_event(sk, &timeout, !sk_stream_closing(sk)))

			if (sk_wait_event(sk, &timeout, !sk_stream_closing(sk), &wait))

				break;

		} while (!signal_pending(current) && timeout);



		finish_wait(sk_sleep(sk), &wait);

		remove_wait_queue(sk_sleep(sk), &wait);

	}

}

EXPORT_SYMBOL(sk_stream_wait_close);
@@ -119,16 +119,16 @@ int sk_stream_wait_memory(struct sock *sk, long *timeo_p) 
	long vm_wait = 0;

	long current_timeo = *timeo_p;

	bool noblock = (*timeo_p ? false : true);

	DEFINE_WAIT(wait);

	DEFINE_WAIT_FUNC(wait, woken_wake_function);



	if (sk_stream_memory_free(sk))

		current_timeo = vm_wait = (prandom_u32() % (HZ / 5)) + 2;



	add_wait_queue(sk_sleep(sk), &wait);



	while (1) {

		sk_set_bit(SOCKWQ_ASYNC_NOSPACE, sk);



		prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);



		if (sk->sk_err || (sk->sk_shutdown & SEND_SHUTDOWN))

			goto do_error;

		if (!*timeo_p) {
@@ -147,7 +147,7 @@ int sk_stream_wait_memory(struct sock *sk, long *timeo_p) 
		sk_wait_event(sk, &current_timeo, sk->sk_err ||

						  (sk->sk_shutdown & SEND_SHUTDOWN) ||

						  (sk_stream_memory_free(sk) &&

						  !vm_wait));

						  !vm_wait), &wait);

		sk->sk_write_pending--;



		if (vm_wait) {
@@ -161,7 +161,7 @@ int sk_stream_wait_memory(struct sock *sk, long *timeo_p) 
		*timeo_p = current_timeo;

	}

out:

	finish_wait(sk_sleep(sk), &wait);

	remove_wait_queue(sk_sleep(sk), &wait);

	return err;



do_error: