netdev: Add addr_list_lock to struct net_device.

[linux-2.6] / net / core / stream.c

diff --git a/net/core/stream.c b/net/core/stream.c
index ac9edfdf874214432ba7c81978035c5960debba1..4a0ad152c9c4492c35fc3abc6ac21bf4580abb20 100644 (file)
--- a/net/core/stream.c
+++ b/net/core/stream.c
@@ -35,7 +35,7 @@ void sk_stream_write_space(struct sock *sk)
                if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
                        wake_up_interruptible(sk->sk_sleep);
                if (sock->fasync_list && !(sk->sk_shutdown & SEND_SHUTDOWN))
-                       sock_wake_async(sock, 2, POLL_OUT);
+                       sock_wake_async(sock, SOCK_WAKE_SPACE, POLL_OUT);
        }
 }
 
@@ -52,10 +52,12 @@ int sk_stream_wait_connect(struct sock *sk, long *timeo_p)
 {
        struct task_struct *tsk = current;
        DEFINE_WAIT(wait);
+       int done;
 
-       while (1) {
-               if (sk->sk_err)
-                       return sock_error(sk);
+       do {
+               int err = sock_error(sk);
+               if (err)
+                       return err;
                if ((1 << sk->sk_state) & ~(TCPF_SYN_SENT | TCPF_SYN_RECV))
                        return -EPIPE;
                if (!*timeo_p)
@@ -65,13 +67,13 @@ int sk_stream_wait_connect(struct sock *sk, long *timeo_p)
 
                prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
                sk->sk_write_pending++;
-               if (sk_wait_event(sk, timeo_p,
-                                 !((1 << sk->sk_state) & 
-                                   ~(TCPF_ESTABLISHED | TCPF_CLOSE_WAIT))))
-                       break;
+               done = sk_wait_event(sk, timeo_p,
+                                    !sk->sk_err &&
+                                    !((1 << sk->sk_state) &
+                                      ~(TCPF_ESTABLISHED | TCPF_CLOSE_WAIT)));
                finish_wait(sk->sk_sleep, &wait);
                sk->sk_write_pending--;
-       }
+       } while (!done);
        return 0;
 }
 
@@ -137,7 +139,9 @@ int sk_stream_wait_memory(struct sock *sk, long *timeo_p)
 
                set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
                sk->sk_write_pending++;
-               sk_wait_event(sk, &current_timeo, sk_stream_memory_free(sk) &&
+               sk_wait_event(sk, &current_timeo, !sk->sk_err &&
+                                                 !(sk->sk_shutdown & SEND_SHUTDOWN) &&
+                                                 sk_stream_memory_free(sk) &&
                                                  vm_wait);
                sk->sk_write_pending--;
 
@@ -168,16 +172,6 @@ do_interrupted:
 
 EXPORT_SYMBOL(sk_stream_wait_memory);
 
-void sk_stream_rfree(struct sk_buff *skb)
-{
-       struct sock *sk = skb->sk;
-
-       atomic_sub(skb->truesize, &sk->sk_rmem_alloc);
-       sk->sk_forward_alloc += skb->truesize;
-}
-
-EXPORT_SYMBOL(sk_stream_rfree);
-
 int sk_stream_error(struct sock *sk, int flags, int err)
 {
        if (err == -EPIPE)
@@ -189,78 +183,6 @@ int sk_stream_error(struct sock *sk, int flags, int err)
 
 EXPORT_SYMBOL(sk_stream_error);
 
-void __sk_stream_mem_reclaim(struct sock *sk)
-{
-       if (sk->sk_forward_alloc >= SK_STREAM_MEM_QUANTUM) {
-               atomic_sub(sk->sk_forward_alloc / SK_STREAM_MEM_QUANTUM,
-                          sk->sk_prot->memory_allocated);
-               sk->sk_forward_alloc &= SK_STREAM_MEM_QUANTUM - 1;
-               if (*sk->sk_prot->memory_pressure &&
-                   (atomic_read(sk->sk_prot->memory_allocated) <
-                    sk->sk_prot->sysctl_mem[0]))
-                       *sk->sk_prot->memory_pressure = 0;
-       }
-}
-
-EXPORT_SYMBOL(__sk_stream_mem_reclaim);
-
-int sk_stream_mem_schedule(struct sock *sk, int size, int kind)
-{
-       int amt = sk_stream_pages(size);
-
-       sk->sk_forward_alloc += amt * SK_STREAM_MEM_QUANTUM;
-       atomic_add(amt, sk->sk_prot->memory_allocated);
-
-       /* Under limit. */
-       if (atomic_read(sk->sk_prot->memory_allocated) < sk->sk_prot->sysctl_mem[0]) {
-               if (*sk->sk_prot->memory_pressure)
-                       *sk->sk_prot->memory_pressure = 0;
-               return 1;
-       }
-
-       /* Over hard limit. */
-       if (atomic_read(sk->sk_prot->memory_allocated) > sk->sk_prot->sysctl_mem[2]) {
-               sk->sk_prot->enter_memory_pressure();
-               goto suppress_allocation;
-       }
-
-       /* Under pressure. */
-       if (atomic_read(sk->sk_prot->memory_allocated) > sk->sk_prot->sysctl_mem[1])
-               sk->sk_prot->enter_memory_pressure();
-
-       if (kind) {
-               if (atomic_read(&sk->sk_rmem_alloc) < sk->sk_prot->sysctl_rmem[0])
-                       return 1;
-       } else if (sk->sk_wmem_queued < sk->sk_prot->sysctl_wmem[0])
-               return 1;
-
-       if (!*sk->sk_prot->memory_pressure ||
-           sk->sk_prot->sysctl_mem[2] > atomic_read(sk->sk_prot->sockets_allocated) *
-                               sk_stream_pages(sk->sk_wmem_queued +
-                                               atomic_read(&sk->sk_rmem_alloc) +
-                                               sk->sk_forward_alloc))
-               return 1;
-
-suppress_allocation:
-
-       if (!kind) {
-               sk_stream_moderate_sndbuf(sk);
-
-               /* Fail only if socket is _under_ its sndbuf.
-                * In this case we cannot block, so that we have to fail.
-                */
-               if (sk->sk_wmem_queued + size >= sk->sk_sndbuf)
-                       return 1;
-       }
-
-       /* Alas. Undo changes. */
-       sk->sk_forward_alloc -= amt * SK_STREAM_MEM_QUANTUM;
-       atomic_sub(amt, sk->sk_prot->memory_allocated);
-       return 0;
-}
-
-EXPORT_SYMBOL(sk_stream_mem_schedule);
-
 void sk_stream_kill_queues(struct sock *sk)
 {
        /* First the read buffer. */
@@ -273,7 +195,7 @@ void sk_stream_kill_queues(struct sock *sk)
        BUG_TRAP(skb_queue_empty(&sk->sk_write_queue));
 
        /* Account for returned memory. */
-       sk_stream_mem_reclaim(sk);
+       sk_mem_reclaim(sk);
 
        BUG_TRAP(!sk->sk_wmem_queued);
        BUG_TRAP(!sk->sk_forward_alloc);