Experimental, for people to test, to see if this is worth putting more
effort into.
net/core/datagram.c | 9 +++------
net/core/sock.c | 17 +++++++----------
net/ipv4/af_inet.c | 10 ++++------
net/ipv4/tcp.c | 42 +++++++++++++++---------------------------
net/ipv4/tcp_ipv4.c | 9 ++++-----
net/unix/af_unix.c | 17 ++++++-----------
6 files changed, 39 insertions(+), 65 deletions(-)
diff -puN net/ipv4/tcp.c~tcp-wakeups net/ipv4/tcp.c
--- 25/net/ipv4/tcp.c~tcp-wakeups 2003-03-10 21:14:04.000000000 -0800
+++ 25-akpm/net/ipv4/tcp.c 2003-03-10 21:14:04.000000000 -0800
@@ -659,7 +659,7 @@ static int wait_for_tcp_connect(struct s
{
struct tcp_opt *tp = tcp_sk(sk);
struct task_struct *tsk = current;
- DECLARE_WAITQUEUE(wait, tsk);
+ DEFINE_WAIT(wait);
while ((1 << sk->state) & ~(TCPF_ESTABLISHED | TCPF_CLOSE_WAIT)) {
if (sk->err)
@@ -671,16 +671,14 @@ static int wait_for_tcp_connect(struct s
if (signal_pending(tsk))
return sock_intr_errno(*timeo_p);
- __set_task_state(tsk, TASK_INTERRUPTIBLE);
- add_wait_queue(sk->sleep, &wait);
+ prepare_to_wait(sk->sleep, &wait, TASK_INTERRUPTIBLE);
tp->write_pending++;
release_sock(sk);
*timeo_p = schedule_timeout(*timeo_p);
lock_sock(sk);
- __set_task_state(tsk, TASK_RUNNING);
- remove_wait_queue(sk->sleep, &wait);
+ finish_wait(sk->sleep, &wait);
tp->write_pending--;
}
return 0;
@@ -700,16 +698,15 @@ static int wait_for_tcp_memory(struct so
int err = 0;
long vm_wait = 0;
long current_timeo = *timeo;
- DECLARE_WAITQUEUE(wait, current);
+ DEFINE_WAIT(wait);
if (tcp_memory_free(sk))
current_timeo = vm_wait = (net_random() % (HZ / 5)) + 2;
- add_wait_queue(sk->sleep, &wait);
for (;;) {
set_bit(SOCK_ASYNC_NOSPACE, &sk->socket->flags);
- set_current_state(TASK_INTERRUPTIBLE);
+ prepare_to_wait(sk->sleep, &wait, TASK_INTERRUPTIBLE);
if (sk->err || (sk->shutdown & SEND_SHUTDOWN))
goto do_error;
@@ -740,8 +737,7 @@ static int wait_for_tcp_memory(struct so
*timeo = current_timeo;
}
out:
- current->state = TASK_RUNNING;
- remove_wait_queue(sk->sleep, &wait);
+ finish_wait(sk->sleep, &wait);
return err;
do_error:
@@ -1374,11 +1370,9 @@ static void cleanup_rbuf(struct sock *sk
static long tcp_data_wait(struct sock *sk, long timeo)
{
- DECLARE_WAITQUEUE(wait, current);
+ DEFINE_WAIT(wait);
- add_wait_queue(sk->sleep, &wait);
-
- __set_current_state(TASK_INTERRUPTIBLE);
+ prepare_to_wait(sk->sleep, &wait, TASK_INTERRUPTIBLE);
set_bit(SOCK_ASYNC_WAITDATA, &sk->socket->flags);
release_sock(sk);
@@ -1389,8 +1383,7 @@ static long tcp_data_wait(struct sock *s
lock_sock(sk);
clear_bit(SOCK_ASYNC_WAITDATA, &sk->socket->flags);
- remove_wait_queue(sk->sleep, &wait);
- __set_current_state(TASK_RUNNING);
+ finish_wait(sk->sleep, &wait);
return timeo;
}
@@ -2017,12 +2010,10 @@ void tcp_close(struct sock *sk, long tim
if (timeout) {
struct task_struct *tsk = current;
- DECLARE_WAITQUEUE(wait, current);
-
- add_wait_queue(sk->sleep, &wait);
+ DEFINE_WAIT(wait);
do {
- set_current_state(TASK_INTERRUPTIBLE);
+ prepare_to_wait(sk->sleep, &wait, TASK_INTERRUPTIBLE);
if (!closing(sk))
break;
release_sock(sk);
@@ -2030,8 +2021,7 @@ void tcp_close(struct sock *sk, long tim
lock_sock(sk);
} while (!signal_pending(tsk) && timeout);
- tsk->state = TASK_RUNNING;
- remove_wait_queue(sk->sleep, &wait);
+ finish_wait(sk->sleep, &wait);
}
adjudge_to_death:
@@ -2191,7 +2181,7 @@ int tcp_disconnect(struct sock *sk, int
static int wait_for_connect(struct sock *sk, long timeo)
{
struct tcp_opt *tp = tcp_sk(sk);
- DECLARE_WAITQUEUE(wait, current);
+ DEFINE_WAIT(wait);
int err;
/*
@@ -2208,9 +2198,8 @@ static int wait_for_connect(struct sock
* our exclusiveness temporarily when we get woken up without
* having to remove and re-insert us on the wait queue.
*/
- add_wait_queue_exclusive(sk->sleep, &wait);
for (;;) {
- current->state = TASK_INTERRUPTIBLE;
+ prepare_to_wait_exclusive(sk->sleep, &wait, TASK_INTERRUPTIBLE);
release_sock(sk);
if (!tp->accept_queue)
timeo = schedule_timeout(timeo);
@@ -2228,8 +2217,7 @@ static int wait_for_connect(struct sock
if (!timeo)
break;
}
- current->state = TASK_RUNNING;
- remove_wait_queue(sk->sleep, &wait);
+ finish_wait(sk->sleep, &wait);
return err;
}
diff -puN net/ipv4/tcp_ipv4.c~tcp-wakeups net/ipv4/tcp_ipv4.c
--- 25/net/ipv4/tcp_ipv4.c~tcp-wakeups 2003-03-10 21:14:04.000000000 -0800
+++ 25-akpm/net/ipv4/tcp_ipv4.c 2003-03-10 21:14:04.000000000 -0800
@@ -334,11 +334,11 @@ void tcp_listen_wlock(void)
write_lock(&tcp_lhash_lock);
if (atomic_read(&tcp_lhash_users)) {
- DECLARE_WAITQUEUE(wait, current);
+ DEFINE_WAIT(wait);
- add_wait_queue_exclusive(&tcp_lhash_wait, &wait);
for (;;) {
- set_current_state(TASK_UNINTERRUPTIBLE);
+ prepare_to_wait_exclusive(&tcp_lhash_wait,
+ &wait, TASK_UNINTERRUPTIBLE);
if (!atomic_read(&tcp_lhash_users))
break;
write_unlock_bh(&tcp_lhash_lock);
@@ -346,8 +346,7 @@ void tcp_listen_wlock(void)
write_lock_bh(&tcp_lhash_lock);
}
- __set_current_state(TASK_RUNNING);
- remove_wait_queue(&tcp_lhash_wait, &wait);
+ finish_wait(&tcp_lhash_wait, &wait);
}
}
diff -puN net/ipv4/af_inet.c~tcp-wakeups net/ipv4/af_inet.c
--- 25/net/ipv4/af_inet.c~tcp-wakeups 2003-03-10 21:14:04.000000000 -0800
+++ 25-akpm/net/ipv4/af_inet.c 2003-03-10 21:14:04.000000000 -0800
@@ -562,10 +562,9 @@ int inet_dgram_connect(struct socket *so
static long inet_wait_for_connect(struct sock *sk, long timeo)
{
- DECLARE_WAITQUEUE(wait, current);
+ DEFINE_WAIT(wait);
- __set_current_state(TASK_INTERRUPTIBLE);
- add_wait_queue(sk->sleep, &wait);
+ prepare_to_wait(sk->sleep, &wait, TASK_INTERRUPTIBLE);
/* Basic assumption: if someone sets sk->err, he _must_
* change state of the socket from TCP_SYN_*.
@@ -578,10 +577,9 @@ static long inet_wait_for_connect(struct
lock_sock(sk);
if (signal_pending(current) || !timeo)
break;
- set_current_state(TASK_INTERRUPTIBLE);
+ prepare_to_wait(sk->sleep, &wait, TASK_INTERRUPTIBLE);
}
- __set_current_state(TASK_RUNNING);
- remove_wait_queue(sk->sleep, &wait);
+ finish_wait(sk->sleep, &wait);
return timeo;
}
diff -puN net/core/datagram.c~tcp-wakeups net/core/datagram.c
--- 25/net/core/datagram.c~tcp-wakeups 2003-03-10 21:14:04.000000000 -0800
+++ 25-akpm/net/core/datagram.c 2003-03-10 21:14:04.000000000 -0800
@@ -68,11 +68,9 @@ static inline int connection_based(struc
static int wait_for_packet(struct sock *sk, int *err, long *timeo_p)
{
int error;
+ DEFINE_WAIT(wait);
- DECLARE_WAITQUEUE(wait, current);
-
- __set_current_state(TASK_INTERRUPTIBLE);
- add_wait_queue_exclusive(sk->sleep, &wait);
+ prepare_to_wait_exclusive(sk->sleep, &wait, TASK_INTERRUPTIBLE);
/* Socket errors? */
error = sock_error(sk);
@@ -101,8 +99,7 @@ static int wait_for_packet(struct sock *
error = 0;
*timeo_p = schedule_timeout(*timeo_p);
out:
- current->state = TASK_RUNNING;
- remove_wait_queue(sk->sleep, &wait);
+ finish_wait(sk->sleep, &wait);
return error;
interrupted:
error = sock_intr_errno(*timeo_p);
diff -puN net/core/sock.c~tcp-wakeups net/core/sock.c
--- 25/net/core/sock.c~tcp-wakeups 2003-03-10 21:14:04.000000000 -0800
+++ 25-akpm/net/core/sock.c 2003-03-10 21:14:04.000000000 -0800
@@ -746,17 +746,16 @@ void sock_kfree_s(struct sock *sk, void
*/
static long sock_wait_for_wmem(struct sock * sk, long timeo)
{
- DECLARE_WAITQUEUE(wait, current);
+ DEFINE_WAIT(wait);
clear_bit(SOCK_ASYNC_NOSPACE, &sk->socket->flags);
- add_wait_queue(sk->sleep, &wait);
for (;;) {
if (!timeo)
break;
if (signal_pending(current))
break;
set_bit(SOCK_NOSPACE, &sk->socket->flags);
- set_current_state(TASK_INTERRUPTIBLE);
+ prepare_to_wait(sk->sleep, &wait, TASK_INTERRUPTIBLE);
if (atomic_read(&sk->wmem_alloc) < sk->sndbuf)
break;
if (sk->shutdown & SEND_SHUTDOWN)
@@ -765,8 +764,7 @@ static long sock_wait_for_wmem(struct so
break;
timeo = schedule_timeout(timeo);
}
- __set_current_state(TASK_RUNNING);
- remove_wait_queue(sk->sleep, &wait);
+ finish_wait(sk->sleep, &wait);
return timeo;
}
@@ -860,19 +858,18 @@ struct sk_buff *sock_alloc_send_skb(stru
void __lock_sock(struct sock *sk)
{
- DECLARE_WAITQUEUE(wait, current);
+ DEFINE_WAIT(wait);
- add_wait_queue_exclusive(&sk->lock.wq, &wait);
for(;;) {
- current->state = TASK_UNINTERRUPTIBLE;
+ prepare_to_wait_exclusive(&sk->lock.wq, &wait,
+ TASK_UNINTERRUPTIBLE);
spin_unlock_bh(&sk->lock.slock);
schedule();
spin_lock_bh(&sk->lock.slock);
if(!sock_owned_by_user(sk))
break;
}
- current->state = TASK_RUNNING;
- remove_wait_queue(&sk->lock.wq, &wait);
+ finish_wait(&sk->lock.wq, &wait);
}
void __release_sock(struct sock *sk)
diff -puN net/unix/af_unix.c~tcp-wakeups net/unix/af_unix.c
--- 25/net/unix/af_unix.c~tcp-wakeups 2003-03-10 21:14:04.000000000 -0800
+++ 25-akpm/net/unix/af_unix.c 2003-03-10 21:14:04.000000000 -0800
@@ -859,10 +859,9 @@ static long unix_wait_for_peer(unix_sock
{
struct unix_sock *u = unix_sk(other);
int sched;
- DECLARE_WAITQUEUE(wait, current);
+ DEFINE_WAIT(wait);
- __set_current_state(TASK_INTERRUPTIBLE);
- add_wait_queue_exclusive(&u->peer_wait, &wait);
+ prepare_to_wait_exclusive(&u->peer_wait, &wait, TASK_INTERRUPTIBLE);
sched = (!test_bit(SOCK_DEAD, &other->flags) &&
!(other->shutdown&RCV_SHUTDOWN) &&
@@ -873,8 +872,7 @@ static long unix_wait_for_peer(unix_sock
if (sched)
timeo = schedule_timeout(timeo);
- __set_current_state(TASK_RUNNING);
- remove_wait_queue(&u->peer_wait, &wait);
+ finish_wait(&u->peer_wait, &wait);
return timeo;
}
@@ -1542,14 +1540,12 @@ out:
static long unix_stream_data_wait(unix_socket * sk, long timeo)
{
- DECLARE_WAITQUEUE(wait, current);
+ DEFINE_WAIT(wait);
unix_state_rlock(sk);
- add_wait_queue(sk->sleep, &wait);
-
for (;;) {
- set_current_state(TASK_INTERRUPTIBLE);
+ prepare_to_wait(sk->sleep, &wait, TASK_INTERRUPTIBLE);
if (skb_queue_len(&sk->receive_queue) ||
sk->err ||
@@ -1565,8 +1561,7 @@ static long unix_stream_data_wait(unix_s
clear_bit(SOCK_ASYNC_WAITDATA, &sk->socket->flags);
}
- __set_current_state(TASK_RUNNING);
- remove_wait_queue(sk->sleep, &wait);
+ finish_wait(sk->sleep, &wait);
unix_state_runlock(sk);
return timeo;
}
_