[NET] CORE: Introducing new memory accounting interface.

This patch introduces new memory accounting functions for each network
protocol. Most of them are renamed from memory accounting functions
for stream protocols. At the same time, some stream memory accounting
functions are removed since other functions do same thing.

Renaming:
	sk_stream_free_skb()		->	sk_wmem_free_skb()
	__sk_stream_mem_reclaim()	->	__sk_mem_reclaim()
	sk_stream_mem_reclaim()		->	sk_mem_reclaim()
	sk_stream_mem_schedule 		->    	__sk_mem_schedule()
	sk_stream_pages()      		->	sk_mem_pages()
	sk_stream_rmem_schedule()	->	sk_rmem_schedule()
	sk_stream_wmem_schedule()	->	sk_wmem_schedule()
	sk_charge_skb()			->	sk_mem_charge()

Removeing
	sk_stream_rfree():	consolidates into sock_rfree()
	sk_stream_set_owner_r(): consolidates into skb_set_owner_r()
	sk_stream_mem_schedule()

The following functions are added.
    	sk_has_account(): check if the protocol supports accounting
	sk_mem_uncharge(): do the opposite of sk_mem_charge()

In addition, to achieve consolidation, updating sk_wmem_queued is
removed from sk_mem_charge().

Next, to consolidate memory accounting functions, this patch adds
memory accounting calls to network core functions. Moreover, present
memory accounting call is renamed to new accounting call.

Finally we replace present memory accounting calls with new interface
in TCP and SCTP.

Signed-off-by: Takahiro Yasui <tyasui@redhat.com>
Signed-off-by: Hideo Aoki <haoki@redhat.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

1 files changed, 1 insertions, 83 deletions

diff --git a/net/core/stream.c b/net/core/stream.c
index bf188ffdbdbe..4a0ad152c9c4 100644
--- a/net/core/stream.c
+++ b/net/core/stream.c
@@ -172,17 +172,6 @@ do_interrupted:
 
 EXPORT_SYMBOL(sk_stream_wait_memory);
 
-void sk_stream_rfree(struct sk_buff *skb)
-{
-        struct sock *sk = skb->sk;
-
-        skb_truesize_check(skb);
-        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)
@@ -194,77 +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)
-{
-        atomic_sub(sk->sk_forward_alloc >> SK_STREAM_MEM_QUANTUM_SHIFT,
-                   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);
-        struct proto *prot = sk->sk_prot;
-
-        sk->sk_forward_alloc += amt * SK_STREAM_MEM_QUANTUM;
-        atomic_add(amt, prot->memory_allocated);
-
-        /* Under limit. */
-        if (atomic_read(prot->memory_allocated) < prot->sysctl_mem[0]) {
-                if (*prot->memory_pressure)
-                        *prot->memory_pressure = 0;
-                return 1;
-        }
-
-        /* Over hard limit. */
-        if (atomic_read(prot->memory_allocated) > prot->sysctl_mem[2]) {
-                prot->enter_memory_pressure();
-                goto suppress_allocation;
-        }
-
-        /* Under pressure. */
-        if (atomic_read(prot->memory_allocated) > prot->sysctl_mem[1])
-                prot->enter_memory_pressure();
-
-        if (kind) {
-                if (atomic_read(&sk->sk_rmem_alloc) < prot->sysctl_rmem[0])
-                        return 1;
-        } else if (sk->sk_wmem_queued < prot->sysctl_wmem[0])
-                return 1;
-
-        if (!*prot->memory_pressure ||
-            prot->sysctl_mem[2] > atomic_read(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, prot->memory_allocated);
-        return 0;
-}
-
-EXPORT_SYMBOL(sk_stream_mem_schedule);
-
 void sk_stream_kill_queues(struct sock *sk)
 {
         /* First the read buffer. */
@@ -277,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);