]> git.openfabrics.org - ~shefty/rdma-dev.git/commit
net: introduce res_counter_charge_nofail() for socket allocations
authorGlauber Costa <glommer@parallels.com>
Fri, 20 Jan 2012 04:57:16 +0000 (04:57 +0000)
committerDavid S. Miller <davem@davemloft.net>
Sun, 22 Jan 2012 20:08:46 +0000 (15:08 -0500)
commit0e90b31f4ba77027a7c21cbfc66404df0851ca21
tree10dc6c443e2f058869d3953a90e6d48fb53f83ae
parent8cfd14ad1eb52e44cb1fe7b47a68126e45e04026
net: introduce res_counter_charge_nofail() for socket allocations

There is a case in __sk_mem_schedule(), where an allocation
is beyond the maximum, but yet we are allowed to proceed.
It happens under the following condition:

sk->sk_wmem_queued + size >= sk->sk_sndbuf

The network code won't revert the allocation in this case,
meaning that at some point later it'll try to do it. Since
this is never communicated to the underlying res_counter
code, there is an inbalance in res_counter uncharge operation.

I see two ways of fixing this:

1) storing the information about those allocations somewhere
   in memcg, and then deducting from that first, before
   we start draining the res_counter,
2) providing a slightly different allocation function for
   the res_counter, that matches the original behavior of
   the network code more closely.

I decided to go for #2 here, believing it to be more elegant,
since #1 would require us to do basically that, but in a more
obscure way.

Signed-off-by: Glauber Costa <glommer@parallels.com>
Cc: KAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujitsu.com>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: Michal Hocko <mhocko@suse.cz>
CC: Tejun Heo <tj@kernel.org>
CC: Li Zefan <lizf@cn.fujitsu.com>
CC: Laurent Chavey <chavey@google.com>
Acked-by: Tejun Heo <tj@kernel.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
include/linux/res_counter.h
include/net/sock.h
kernel/res_counter.c
net/core/sock.c