vserver 2.0 rc7

[linux-2.6.git] / net / atm / svc.c

diff --git a/net/atm/svc.c b/net/atm/svc.c
index d531424..02f5374 100644 (file)
--- a/net/atm/svc.c
+++ b/net/atm/svc.c
@@ -53,20 +53,21 @@ static void svc_disconnect(struct atm_vcc *vcc)
 {
        DEFINE_WAIT(wait);
        struct sk_buff *skb;
+       struct sock *sk = sk_atm(vcc);
 
        DPRINTK("svc_disconnect %p\n",vcc);
        if (test_bit(ATM_VF_REGIS,&vcc->flags)) {
-               prepare_to_wait(vcc->sk->sk_sleep, &wait, TASK_UNINTERRUPTIBLE);
+               prepare_to_wait(sk->sk_sleep, &wait, TASK_UNINTERRUPTIBLE);
                sigd_enq(vcc,as_close,NULL,NULL,NULL);
                while (!test_bit(ATM_VF_RELEASED,&vcc->flags) && sigd) {
                        schedule();
-                       prepare_to_wait(vcc->sk->sk_sleep, &wait, TASK_UNINTERRUPTIBLE);
+                       prepare_to_wait(sk->sk_sleep, &wait, TASK_UNINTERRUPTIBLE);
                }
-               finish_wait(vcc->sk->sk_sleep, &wait);
+               finish_wait(sk->sk_sleep, &wait);
        }
        /* beware - socket is still in use by atmsigd until the last
           as_indicate has been answered */
-       while ((skb = skb_dequeue(&vcc->sk->sk_receive_queue)) != NULL) {
+       while ((skb = skb_dequeue(&sk->sk_receive_queue)) != NULL) {
                atm_return(vcc, skb->truesize);
                DPRINTK("LISTEN REL\n");
                sigd_enq2(NULL,as_reject,vcc,NULL,NULL,&vcc->qos,0);
@@ -318,8 +319,7 @@ static int svc_listen(struct socket *sock,int backlog)
                goto out;
        }
        set_bit(ATM_VF_LISTEN,&vcc->flags);
-       vcc->sk->sk_max_ack_backlog = backlog > 0 ? backlog :
-                                                   ATM_BACKLOG_DEFAULT;
+       sk->sk_max_ack_backlog = backlog > 0 ? backlog : ATM_BACKLOG_DEFAULT;
        error = -sk->sk_err;
 out:
        release_sock(sk);
@@ -348,8 +348,8 @@ static int svc_accept(struct socket *sock,struct socket *newsock,int flags)
        while (1) {
                DEFINE_WAIT(wait);
 
-               prepare_to_wait(old_vcc->sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
-               while (!(skb = skb_dequeue(&old_vcc->sk->sk_receive_queue)) &&
+               prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
+               while (!(skb = skb_dequeue(&sk->sk_receive_queue)) &&
                       sigd) {
                        if (test_bit(ATM_VF_RELEASED,&old_vcc->flags)) break;
                        if (test_bit(ATM_VF_CLOSE,&old_vcc->flags)) {
@@ -367,9 +367,9 @@ static int svc_accept(struct socket *sock,struct socket *newsock,int flags)
                                error = -ERESTARTSYS;
                                break;
                        }
-                       prepare_to_wait(old_vcc->sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
+                       prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
                }
-               finish_wait(old_vcc->sk->sk_sleep, &wait);
+               finish_wait(sk->sk_sleep, &wait);
                if (error)
                        goto out;
                if (!skb) {
@@ -385,7 +385,7 @@ static int svc_accept(struct socket *sock,struct socket *newsock,int flags)
                error = vcc_connect(newsock, msg->pvc.sap_addr.itf,
                                    msg->pvc.sap_addr.vpi, msg->pvc.sap_addr.vci);
                dev_kfree_skb(skb);
-               old_vcc->sk->sk_ack_backlog--;
+               sk->sk_ack_backlog--;
                if (error) {
                        sigd_enq2(NULL,as_reject,old_vcc,NULL,NULL,
                            &old_vcc->qos,error);
@@ -394,23 +394,23 @@ static int svc_accept(struct socket *sock,struct socket *newsock,int flags)
                }
                /* wait should be short, so we ignore the non-blocking flag */
                set_bit(ATM_VF_WAITING, &new_vcc->flags);
-               prepare_to_wait(new_vcc->sk->sk_sleep, &wait, TASK_UNINTERRUPTIBLE);
+               prepare_to_wait(sk_atm(new_vcc)->sk_sleep, &wait, TASK_UNINTERRUPTIBLE);
                sigd_enq(new_vcc,as_accept,old_vcc,NULL,NULL);
                while (test_bit(ATM_VF_WAITING, &new_vcc->flags) && sigd) {
                        release_sock(sk);
                        schedule();
                        lock_sock(sk);
-                       prepare_to_wait(new_vcc->sk->sk_sleep, &wait, TASK_UNINTERRUPTIBLE);
+                       prepare_to_wait(sk_atm(new_vcc)->sk_sleep, &wait, TASK_UNINTERRUPTIBLE);
                }
-               finish_wait(new_vcc->sk->sk_sleep, &wait);
+               finish_wait(sk_atm(new_vcc)->sk_sleep, &wait);
                if (!sigd) {
                        error = -EUNATCH;
                        goto out;
                }
-               if (!new_vcc->sk->sk_err)
+               if (!sk_atm(new_vcc)->sk_err)
                        break;
-               if (new_vcc->sk->sk_err != ERESTARTSYS) {
-                       error = -new_vcc->sk->sk_err;
+               if (sk_atm(new_vcc)->sk_err != ERESTARTSYS) {
+                       error = -sk_atm(new_vcc)->sk_err;
                        goto out;
                }
        }
@@ -436,19 +436,20 @@ static int svc_getname(struct socket *sock,struct sockaddr *sockaddr,
 
 int svc_change_qos(struct atm_vcc *vcc,struct atm_qos *qos)
 {
+       struct sock *sk = sk_atm(vcc);
        DEFINE_WAIT(wait);
 
        set_bit(ATM_VF_WAITING, &vcc->flags);
-       prepare_to_wait(vcc->sk->sk_sleep, &wait, TASK_UNINTERRUPTIBLE);
+       prepare_to_wait(sk->sk_sleep, &wait, TASK_UNINTERRUPTIBLE);
        sigd_enq2(vcc,as_modify,NULL,NULL,&vcc->local,qos,0);
        while (test_bit(ATM_VF_WAITING, &vcc->flags) &&
               !test_bit(ATM_VF_RELEASED, &vcc->flags) && sigd) {
                schedule();
-               prepare_to_wait(vcc->sk->sk_sleep, &wait, TASK_UNINTERRUPTIBLE);
+               prepare_to_wait(sk->sk_sleep, &wait, TASK_UNINTERRUPTIBLE);
        }
-       finish_wait(vcc->sk->sk_sleep, &wait);
+       finish_wait(sk->sk_sleep, &wait);
        if (!sigd) return -EUNATCH;
-       return -vcc->sk->sk_err;
+       return -sk->sk_err;
 }
 
 
@@ -533,28 +534,29 @@ static int svc_addparty(struct socket *sock, struct sockaddr *sockaddr,
                        int sockaddr_len, int flags)
 {
        DEFINE_WAIT(wait);
+       struct sock *sk = sock->sk;
        struct atm_vcc *vcc = ATM_SD(sock);
        int error;
 
-       lock_sock(vcc->sk);
+       lock_sock(sk);
        set_bit(ATM_VF_WAITING, &vcc->flags);
-       prepare_to_wait(vcc->sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
+       prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
        sigd_enq(vcc, as_addparty, NULL, NULL,
                 (struct sockaddr_atmsvc *) sockaddr);
        if (flags & O_NONBLOCK) {
-               finish_wait(vcc->sk->sk_sleep, &wait);
+               finish_wait(sk->sk_sleep, &wait);
                error = -EINPROGRESS;
                goto out;
        }
        DPRINTK("svc_addparty added wait queue\n");
        while (test_bit(ATM_VF_WAITING, &vcc->flags) && sigd) {
                schedule();
-               prepare_to_wait(vcc->sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
+               prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
        }
-       finish_wait(vcc->sk->sk_sleep, &wait);
-       error = xchg(&vcc->sk->sk_err_soft, 0);
+       finish_wait(sk->sk_sleep, &wait);
+       error = xchg(&sk->sk_err_soft, 0);
 out:
-       release_sock(vcc->sk);
+       release_sock(sk);
        return error;
 }
 
@@ -562,25 +564,26 @@ out:
 static int svc_dropparty(struct socket *sock, int ep_ref)
 {
        DEFINE_WAIT(wait);
+       struct sock *sk = sock->sk;
        struct atm_vcc *vcc = ATM_SD(sock);
        int error;
 
-       lock_sock(vcc->sk);
+       lock_sock(sk);
        set_bit(ATM_VF_WAITING, &vcc->flags);
-       prepare_to_wait(vcc->sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
+       prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
        sigd_enq2(vcc, as_dropparty, NULL, NULL, NULL, NULL, ep_ref);
        while (test_bit(ATM_VF_WAITING, &vcc->flags) && sigd) {
                schedule();
-               prepare_to_wait(vcc->sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
+               prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
        }
-       finish_wait(vcc->sk->sk_sleep, &wait);
+       finish_wait(sk->sk_sleep, &wait);
        if (!sigd) {
                error = -EUNATCH;
                goto out;
        }
-       error = xchg(&vcc->sk->sk_err_soft, 0);
+       error = xchg(&sk->sk_err_soft, 0);
 out:
-       release_sock(vcc->sk);
+       release_sock(sk);
        return error;
 }