3 files changed, 109 insertions, 115 deletions

diff --git a/net/ax25/af_ax25.c b/net/ax25/af_ax25.c
index 5f28887822e..6ded95272a5 100644
--- a/net/ax25/af_ax25.c
+++ b/net/ax25/af_ax25.c
@@ -1127,22 +1127,22 @@ static int __must_check ax25_connect(struct socket *sock,
                 switch (sk->sk_state) {
                 case TCP_SYN_SENT: /* still trying */
                         err = -EINPROGRESS;
-                        goto out;
+                        goto out_release;
 
                 case TCP_ESTABLISHED: /* connection established */
                         sock->state = SS_CONNECTED;
-                        goto out;
+                        goto out_release;
 
                 case TCP_CLOSE: /* connection refused */
                         sock->state = SS_UNCONNECTED;
                         err = -ECONNREFUSED;
-                        goto out;
+                        goto out_release;
                 }
         }
 
         if (sk->sk_state == TCP_ESTABLISHED && sk->sk_type == SOCK_SEQPACKET) {
                 err = -EISCONN; /* No reconnect on a seqpacket socket */
-                goto out;
+                goto out_release;
         }
 
         sk->sk_state   = TCP_CLOSE;
@@ -1159,12 +1159,12 @@ static int __must_check ax25_connect(struct socket *sock,
                 /* Valid number of digipeaters ? */
                 if (fsa->fsa_ax25.sax25_ndigis < 1 || fsa->fsa_ax25.sax25_ndigis > AX25_MAX_DIGIS) {
                         err = -EINVAL;
-                        goto out;
+                        goto out_release;
                 }
 
                 if ((digi = kmalloc(sizeof(ax25_digi), GFP_KERNEL)) == NULL) {
                         err = -ENOBUFS;
-                        goto out;
+                        goto out_release;
                 }
 
                 digi->ndigi      = fsa->fsa_ax25.sax25_ndigis;
@@ -1194,7 +1194,7 @@ static int __must_check ax25_connect(struct socket *sock,
                         current->comm);
                 if ((err = ax25_rt_autobind(ax25, &fsa->fsa_ax25.sax25_call)) < 0) {
                         kfree(digi);
-                        goto out;
+                        goto out_release;
                 }
 
                 ax25_fillin_cb(ax25, ax25->ax25_dev);
@@ -1203,7 +1203,7 @@ static int __must_check ax25_connect(struct socket *sock,
                 if (ax25->ax25_dev == NULL) {
                         kfree(digi);
                         err = -EHOSTUNREACH;
-                        goto out;
+                        goto out_release;
                 }
         }
 
@@ -1213,7 +1213,7 @@ static int __must_check ax25_connect(struct socket *sock,
                 kfree(digi);
                 err = -EADDRINUSE;              /* Already such a connection */
                 ax25_cb_put(ax25t);
-                goto out;
+                goto out_release;
         }
 
         ax25->dest_addr = fsa->fsa_ax25.sax25_call;
@@ -1223,7 +1223,7 @@ static int __must_check ax25_connect(struct socket *sock,
         if (sk->sk_type != SOCK_SEQPACKET) {
                 sock->state = SS_CONNECTED;
                 sk->sk_state   = TCP_ESTABLISHED;
-                goto out;
+                goto out_release;
         }
 
         /* Move to connecting socket, ax.25 lapb WAIT_UA.. */
@@ -1255,55 +1255,53 @@ static int __must_check ax25_connect(struct socket *sock,
         /* Now the loop */
         if (sk->sk_state != TCP_ESTABLISHED && (flags & O_NONBLOCK)) {
                 err = -EINPROGRESS;
-                goto out;
+                goto out_release;
         }
 
         if (sk->sk_state == TCP_SYN_SENT) {
-                struct task_struct *tsk = current;
-                DECLARE_WAITQUEUE(wait, tsk);
+                DEFINE_WAIT(wait);
 
-                add_wait_queue(sk->sk_sleep, &wait);
                 for (;;) {
+                        prepare_to_wait(sk->sk_sleep, &wait,
+                                        TASK_INTERRUPTIBLE);
                         if (sk->sk_state != TCP_SYN_SENT)
                                 break;
-                        set_current_state(TASK_INTERRUPTIBLE);
-                        release_sock(sk);
-                        if (!signal_pending(tsk)) {
+                        if (!signal_pending(current)) {
+                                release_sock(sk);
                                 schedule();
                                 lock_sock(sk);
                                 continue;
                         }
-                        current->state = TASK_RUNNING;
-                        remove_wait_queue(sk->sk_sleep, &wait);
-                        return -ERESTARTSYS;
+                        err = -ERESTARTSYS;
+                        break;
                 }
-                current->state = TASK_RUNNING;
-                remove_wait_queue(sk->sk_sleep, &wait);
+                finish_wait(sk->sk_sleep, &wait);
+
+                if (err)
+                        goto out_release;
         }
 
         if (sk->sk_state != TCP_ESTABLISHED) {
                 /* Not in ABM, not in WAIT_UA -> failed */
                 sock->state = SS_UNCONNECTED;
                 err = sock_error(sk);   /* Always set at this point */
-                goto out;
+                goto out_release;
         }
 
         sock->state = SS_CONNECTED;
 
-        err=0;
-out:
+        err = 0;
+out_release:
         release_sock(sk);
 
         return err;
 }
 
-
 static int ax25_accept(struct socket *sock, struct socket *newsock, int flags)
 {
-        struct task_struct *tsk = current;
-        DECLARE_WAITQUEUE(wait, tsk);
         struct sk_buff *skb;
         struct sock *newsk;
+        DEFINE_WAIT(wait);
         struct sock *sk;
         int err = 0;
 
@@ -1328,30 +1326,29 @@ static int ax25_accept(struct socket *sock, struct socket *newsock, int flags)
          *      The read queue this time is holding sockets ready to use
          *      hooked into the SABM we saved
          */
-        add_wait_queue(sk->sk_sleep, &wait);
         for (;;) {
+                prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
                 skb = skb_dequeue(&sk->sk_receive_queue);
                 if (skb)
                         break;
 
-                release_sock(sk);
-                current->state = TASK_INTERRUPTIBLE;
                 if (flags & O_NONBLOCK) {
-                        current->state = TASK_RUNNING;
-                        remove_wait_queue(sk->sk_sleep, &wait);
-                        return -EWOULDBLOCK;
+                        err = -EWOULDBLOCK;
+                        break;
                 }
-                if (!signal_pending(tsk)) {
+                if (!signal_pending(current)) {
+                        release_sock(sk);
                         schedule();
                         lock_sock(sk);
                         continue;
                 }
-                current->state = TASK_RUNNING;
-                remove_wait_queue(sk->sk_sleep, &wait);
-                return -ERESTARTSYS;
+                err = -ERESTARTSYS;
+                break;
         }
-        current->state = TASK_RUNNING;
-        remove_wait_queue(sk->sk_sleep, &wait);
+        finish_wait(sk->sk_sleep, &wait);
+
+        if (err)
+                goto out;
 
         newsk            = skb->sk;
         newsk->sk_socket = newsock;
diff --git a/net/netrom/af_netrom.c b/net/netrom/af_netrom.c
index 5dc7448925d..5d4a26c2aa0 100644
--- a/net/netrom/af_netrom.c
+++ b/net/netrom/af_netrom.c
@@ -625,42 +625,42 @@ static int nr_connect(struct socket *sock, struct sockaddr *uaddr,
         ax25_address *source = NULL;
         ax25_uid_assoc *user;
         struct net_device *dev;
+        int err = 0;
 
         lock_sock(sk);
         if (sk->sk_state == TCP_ESTABLISHED && sock->state == SS_CONNECTING) {
                 sock->state = SS_CONNECTED;
-                release_sock(sk);
-                return 0;       /* Connect completed during a ERESTARTSYS event */
+                goto out_release;       /* Connect completed during a ERESTARTSYS event */
         }
 
         if (sk->sk_state == TCP_CLOSE && sock->state == SS_CONNECTING) {
                 sock->state = SS_UNCONNECTED;
-                release_sock(sk);
-                return -ECONNREFUSED;
+                err = -ECONNREFUSED;
+                goto out_release;
         }
 
         if (sk->sk_state == TCP_ESTABLISHED) {
-                release_sock(sk);
-                return -EISCONN;        /* No reconnect on a seqpacket socket */
+                err = -EISCONN; /* No reconnect on a seqpacket socket */
+                goto out_release;
         }
 
         sk->sk_state   = TCP_CLOSE;
         sock->state = SS_UNCONNECTED;
 
         if (addr_len != sizeof(struct sockaddr_ax25) && addr_len != sizeof(struct full_sockaddr_ax25)) {
-                release_sock(sk);
-                return -EINVAL;
+                err = -EINVAL;
+                goto out_release;
         }
         if (addr->sax25_family != AF_NETROM) {
-                release_sock(sk);
-                return -EINVAL;
+                err = -EINVAL;
+                goto out_release;
         }
         if (sock_flag(sk, SOCK_ZAPPED)) {       /* Must bind first - autobinding in this may or may not work */
                 sock_reset_flag(sk, SOCK_ZAPPED);
 
                 if ((dev = nr_dev_first()) == NULL) {
-                        release_sock(sk);
-                        return -ENETUNREACH;
+                        err = -ENETUNREACH;
+                        goto out_release;
                 }
                 source = (ax25_address *)dev->dev_addr;
 
@@ -671,8 +671,8 @@ static int nr_connect(struct socket *sock, struct sockaddr *uaddr,
                 } else {
                         if (ax25_uid_policy && !capable(CAP_NET_ADMIN)) {
                                 dev_put(dev);
-                                release_sock(sk);
-                                return -EPERM;
+                                err = -EPERM;
+                                goto out_release;
                         }
                         nr->user_addr   = *source;
                 }
@@ -707,8 +707,8 @@ static int nr_connect(struct socket *sock, struct sockaddr *uaddr,
 
         /* Now the loop */
         if (sk->sk_state != TCP_ESTABLISHED && (flags & O_NONBLOCK)) {
-                release_sock(sk);
-                return -EINPROGRESS;
+                err = -EINPROGRESS;
+                goto out_release;
         }
 
         /*
@@ -716,46 +716,46 @@ static int nr_connect(struct socket *sock, struct sockaddr *uaddr,
          * closed.
          */
         if (sk->sk_state == TCP_SYN_SENT) {
-                struct task_struct *tsk = current;
-                DECLARE_WAITQUEUE(wait, tsk);
+                DEFINE_WAIT(wait);
 
-                add_wait_queue(sk->sk_sleep, &wait);
                 for (;;) {
-                        set_current_state(TASK_INTERRUPTIBLE);
+                        prepare_to_wait(sk->sk_sleep, &wait,
+                                        TASK_INTERRUPTIBLE);
                         if (sk->sk_state != TCP_SYN_SENT)
                                 break;
-                        release_sock(sk);
-                        if (!signal_pending(tsk)) {
+                        if (!signal_pending(current)) {
+                                release_sock(sk);
                                 schedule();
                                 lock_sock(sk);
                                 continue;
                         }
-                        current->state = TASK_RUNNING;
-                        remove_wait_queue(sk->sk_sleep, &wait);
-                        return -ERESTARTSYS;
+                        err = -ERESTARTSYS;
+                        break;
                 }
-                current->state = TASK_RUNNING;
-                remove_wait_queue(sk->sk_sleep, &wait);
+                finish_wait(sk->sk_sleep, &wait);
+                if (err)
+                        goto out_release;
         }
 
         if (sk->sk_state != TCP_ESTABLISHED) {
                 sock->state = SS_UNCONNECTED;
-                release_sock(sk);
-                return sock_error(sk);  /* Always set at this point */
+                err = sock_error(sk);   /* Always set at this point */
+                goto out_release;
         }
 
         sock->state = SS_CONNECTED;
+
+out_release:
         release_sock(sk);
 
-        return 0;
+        return err;
 }
 
 static int nr_accept(struct socket *sock, struct socket *newsock, int flags)
 {
-        struct task_struct *tsk = current;
-        DECLARE_WAITQUEUE(wait, tsk);
         struct sk_buff *skb;
         struct sock *newsk;
+        DEFINE_WAIT(wait);
         struct sock *sk;
         int err = 0;
 
@@ -765,42 +765,40 @@ static int nr_accept(struct socket *sock, struct socket *newsock, int flags)
         lock_sock(sk);
         if (sk->sk_type != SOCK_SEQPACKET) {
                 err = -EOPNOTSUPP;
-                goto out;
+                goto out_release;
         }
 
         if (sk->sk_state != TCP_LISTEN) {
                 err = -EINVAL;
-                goto out;
+                goto out_release;
         }
 
         /*
          *      The write queue this time is holding sockets ready to use
          *      hooked into the SABM we saved
          */
-        add_wait_queue(sk->sk_sleep, &wait);
         for (;;) {
+                prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
                 skb = skb_dequeue(&sk->sk_receive_queue);
                 if (skb)
                         break;
 
-                current->state = TASK_INTERRUPTIBLE;
-                release_sock(sk);
                 if (flags & O_NONBLOCK) {
-                        current->state = TASK_RUNNING;
-                        remove_wait_queue(sk->sk_sleep, &wait);
-                        return -EWOULDBLOCK;
+                        err = -EWOULDBLOCK;
+                        break;
                 }
-                if (!signal_pending(tsk)) {
+                if (!signal_pending(current)) {
+                        release_sock(sk);
                         schedule();
                         lock_sock(sk);
                         continue;
                 }
-                current->state = TASK_RUNNING;
-                remove_wait_queue(sk->sk_sleep, &wait);
-                return -ERESTARTSYS;
+                err = -ERESTARTSYS;
+                break;
         }
-        current->state = TASK_RUNNING;
-        remove_wait_queue(sk->sk_sleep, &wait);
+        finish_wait(sk->sk_sleep, &wait);
+        if (err)
+                goto out_release;
 
         newsk = skb->sk;
         newsk->sk_socket = newsock;
@@ -811,8 +809,9 @@ static int nr_accept(struct socket *sock, struct socket *newsock, int flags)
         sk_acceptq_removed(sk);
         newsock->sk = newsk;
 
-out:
+out_release:
         release_sock(sk);
+
         return err;
 }
 
diff --git a/net/rose/af_rose.c b/net/rose/af_rose.c
index 806bf6f5dc6..d476c43d521 100644
--- a/net/rose/af_rose.c
+++ b/net/rose/af_rose.c
@@ -812,26 +812,26 @@ rose_try_next_neigh:
          * closed.
          */
         if (sk->sk_state == TCP_SYN_SENT) {
-                struct task_struct *tsk = current;
-                DECLARE_WAITQUEUE(wait, tsk);
+                DEFINE_WAIT(wait);
 
-                add_wait_queue(sk->sk_sleep, &wait);
                 for (;;) {
-                        set_current_state(TASK_INTERRUPTIBLE);
+                        prepare_to_wait(sk->sk_sleep, &wait,
+                                        TASK_INTERRUPTIBLE);
                         if (sk->sk_state != TCP_SYN_SENT)
                                 break;
-                        release_sock(sk);
-                        if (!signal_pending(tsk)) {
+                        if (!signal_pending(current)) {
+                                release_sock(sk);
                                 schedule();
                                 lock_sock(sk);
                                 continue;
                         }
-                        current->state = TASK_RUNNING;
-                        remove_wait_queue(sk->sk_sleep, &wait);
-                        return -ERESTARTSYS;
+                        err = -ERESTARTSYS;
+                        break;
                 }
-                current->state = TASK_RUNNING;
-                remove_wait_queue(sk->sk_sleep, &wait);
+                finish_wait(sk->sk_sleep, &wait);
+
+                if (err)
+                        goto out_release;
         }
 
         if (sk->sk_state != TCP_ESTABLISHED) {
@@ -856,10 +856,9 @@ out_release:
 
 static int rose_accept(struct socket *sock, struct socket *newsock, int flags)
 {
-        struct task_struct *tsk = current;
-        DECLARE_WAITQUEUE(wait, tsk);
         struct sk_buff *skb;
         struct sock *newsk;
+        DEFINE_WAIT(wait);
         struct sock *sk;
         int err = 0;
 
@@ -869,42 +868,41 @@ static int rose_accept(struct socket *sock, struct socket *newsock, int flags)
         lock_sock(sk);
         if (sk->sk_type != SOCK_SEQPACKET) {
                 err = -EOPNOTSUPP;
-                goto out;
+                goto out_release;
         }
 
         if (sk->sk_state != TCP_LISTEN) {
                 err = -EINVAL;
-                goto out;
+                goto out_release;
         }
 
         /*
          *      The write queue this time is holding sockets ready to use
          *      hooked into the SABM we saved
          */
-        add_wait_queue(sk->sk_sleep, &wait);
         for (;;) {
+                prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
+
                 skb = skb_dequeue(&sk->sk_receive_queue);
                 if (skb)
                         break;
 
-                current->state = TASK_INTERRUPTIBLE;
-                release_sock(sk);
                 if (flags & O_NONBLOCK) {
-                        current->state = TASK_RUNNING;
-                        remove_wait_queue(sk->sk_sleep, &wait);
-                        return -EWOULDBLOCK;
+                        err = -EWOULDBLOCK;
+                        break;
                 }
-                if (!signal_pending(tsk)) {
+                if (!signal_pending(current)) {
+                        release_sock(sk);
                         schedule();
                         lock_sock(sk);
                         continue;
                 }
-                current->state = TASK_RUNNING;
-                remove_wait_queue(sk->sk_sleep, &wait);
-                return -ERESTARTSYS;
+                err = -ERESTARTSYS;
+                break;
         }
-        current->state = TASK_RUNNING;
-        remove_wait_queue(sk->sk_sleep, &wait);
+        finish_wait(sk->sk_sleep, &wait);
+        if (err)
+                goto out_release;
 
         newsk = skb->sk;
         newsk->sk_socket = newsock;
@@ -916,7 +914,7 @@ static int rose_accept(struct socket *sock, struct socket *newsock, int flags)
         sk->sk_ack_backlog--;
         newsock->sk = newsk;
 
-out:
+out_release:
         release_sock(sk);
 
         return err;