linux-toradex.git/include/linux/res_counter.h, branch v3.9-rc3

include/linux/res_counter.h needs errno.h

2013-03-13T22:21:44+00:00

alpha allmodconfig:

  In file included from mm/memcontrol.c:28:
  include/linux/res_counter.h: In function 'res_counter_set_limit':
  include/linux/res_counter.h:203: error: 'EBUSY' undeclared (first use in this function)
  include/linux/res_counter.h:203: error: (Each undeclared identifier is reported only once
  include/linux/res_counter.h:203: error: for each function it appears in.)

Cc: Kamezawa Hiroyuki 
Cc: Glauber Costa 
Cc: Tejun Heo 
Cc: Frederic Weisbecker 
Signed-off-by: Andrew Morton 
Signed-off-by: Linus Torvalds

res_counter: return amount of charges after res_counter_uncharge()

2012-12-18T23:02:12+00:00

It is useful to know how many charges are still left after a call to
res_counter_uncharge.  While it is possible to issue a res_counter_read
after uncharge, this can be racy.

If we need, for instance, to take some action when the counters drop down
to 0, only one of the callers should see it.  This is the same semantics
as the atomic variables in the kernel.

Since the current return value is void, we don't need to worry about
anything breaking due to this change: nobody relied on that, and only
users appearing from now on will be checking this value.

Signed-off-by: Glauber Costa 
Reviewed-by: Michal Hocko 
Acked-by: Kamezawa Hiroyuki 
Acked-by: David Rientjes 
Cc: Johannes Weiner 
Cc: Suleiman Souhlal 
Cc: Tejun Heo 
Cc: Christoph Lameter 
Cc: Frederic Weisbecker 
Cc: Greg Thelen 
Cc: JoonSoo Kim 
Cc: Mel Gorman 
Cc: Pekka Enberg 
Cc: Rik van Riel 
Signed-off-by: Andrew Morton 
Signed-off-by: Linus Torvalds

res_counter: delete res_counter_write()

2012-12-13T01:38:33+00:00

Since commit 628f42355389 ("memcg: limit change shrink usage") both
res_counter_write() and write_strategy_fn have been unused.  This patch
deletes them both.

Signed-off-by: Greg Thelen 
Cc: Glauber Costa 
Cc: Tejun Heo 
Acked-by: KAMEZAWA Hiroyuki 
Cc: Frederic Weisbecker 
Signed-off-by: Andrew Morton 
Signed-off-by: Linus Torvalds

rescounter: remove __must_check from res_counter_charge_nofail()

2012-05-29T23:22:27+00:00

Since we will succeed with the allocation no matter what, there isn't a
need to use __must_check with it.  It can very well be optional.

Signed-off-by: Glauber Costa 
Signed-off-by: KAMEZAWA Hiroyuki 
Cc: Aneesh Kumar K.V 
Cc: Michal Hocko 
Cc: Johannes Weiner 
Cc: Frederic Weisbecker 
Cc: Ying Han 
Reviewed-by: Tejun Heo 
Signed-off-by: Andrew Morton 
Signed-off-by: Linus Torvalds

rescounters: add res_counter_uncharge_until()

2012-05-29T23:22:27+00:00

When killing a res_counter which is a child of other counter, we need to
do

	res_counter_uncharge(child, xxx)
	res_counter_charge(parent, xxx)

This is not atomic and wastes CPU.  This patch adds
res_counter_uncharge_until().  This function's uncharge propagates to
ancestors until specified res_counter.

	res_counter_uncharge_until(child, parent, xxx)

Now the operation is atomic and efficient.

Signed-off-by: Frederic Weisbecker 
Signed-off-by: KAMEZAWA Hiroyuki 
Cc: Aneesh Kumar K.V 
Cc: Michal Hocko 
Cc: Johannes Weiner 
Cc: Ying Han 
Cc: Glauber Costa 
Reviewed-by: Tejun Heo 
Signed-off-by: Andrew Morton 
Signed-off-by: Linus Torvalds

res_counter: Merge res_counter_charge and res_counter_charge_nofail

2012-04-27T21:36:45+00:00

These two functions do almost the same thing and duplicate some code.
Merge their implementation into a single common function.
res_counter_charge_locked() takes one more parameter but it doesn't seem
to be used outside res_counter.c yet anyway.

There is no (intended) change in the behaviour.

Signed-off-by: Frederic Weisbecker 
Signed-off-by: Tejun Heo 
Acked-by: KAMEZAWA Hiroyuki 
Acked-by: Glauber Costa 
Acked-by: Kirill A. Shutemov 
Cc: Li Zefan

net: introduce res_counter_charge_nofail() for socket allocations

2012-01-22T20:08:46+00:00

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 
Cc: KAMEZAWA Hiroyuki 
Cc: Johannes Weiner 
Cc: Michal Hocko 
CC: Tejun Heo 
CC: Li Zefan 
CC: Laurent Chavey 
Acked-by: Tejun Heo 
Signed-off-by: David S. Miller

cgroup: make sure memcg margin is 0 when over limit

2012-01-22T20:08:45+00:00

For the memcg sock code, we'll need to register allocations
that are temporarily over limit. Let's make sure that margin
is 0 in this case.

I am keeping this as a separate patch, so that if any weirdness
interaction appears in the future, we can now exactly what caused
it.

Suggested by Johannes Weiner

Signed-off-by: Glauber Costa 
CC: KAMEZAWA Hiroyuki 
CC: Johannes Weiner 
CC: Michal Hocko 
CC: Tejun Heo 
CC: Li Zefan 
Acked-by: Tejun Heo 
Signed-off-by: David S. Miller

memcg: simplify the way memory limits are checked

2011-03-24T02:46:23+00:00

Since transparent huge pages, checking whether memory cgroups are below
their limits is no longer enough, but the actual amount of chargeable
space is important.

To not have more than one limit-checking interface, replace
memory_cgroup_check_under_limit() and memory_cgroup_check_margin() with a
single memory_cgroup_margin() that returns the chargeable space and leaves
the comparison to the callsite.

Soft limits are now checked the other way round, by using the already
existing function that returns the amount by which soft limits are
exceeded: res_counter_soft_limit_excess().

Also remove all the corresponding functions on the res_counter side that
are now no longer used.

Signed-off-by: Johannes Weiner 
Acked-by: KAMEZAWA Hiroyuki 
Cc: Daisuke Nishimura 
Acked-by: Balbir Singh 
Cc: Minchan Kim 
Signed-off-by: Andrew Morton 
Signed-off-by: Linus Torvalds

memcg: soft limit reclaim should end at limit not below

2011-03-24T02:46:23+00:00

Soft limit reclaim continues until the usage is below the current soft
limit, but the documented semantics are actually that soft limit reclaim
will push usage back until the soft limits are met again.

Signed-off-by: Johannes Weiner 
Acked-by: KAMEZAWA Hiroyuki 
Cc: Daisuke Nishimura 
Acked-by: Balbir Singh 
Cc: Minchan Kim 
Signed-off-by: Andrew Morton 
Signed-off-by: Linus Torvalds