linux-toradex.git/include/linux/res_counter.h, branch v3.6-rc1

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

memcg: prevent endless loop when charging huge pages to near-limit group

2011-02-03T00:03:19+00:00

If reclaim after a failed charging was unsuccessful, the limits are
checked again, just in case they settled by means of other tasks.

This is all fine as long as every charge is of size PAGE_SIZE, because in
that case, being below the limit means having at least PAGE_SIZE bytes
available.

But with transparent huge pages, we may end up in an endless loop where
charging and reclaim fail, but we keep going because the limits are not
yet exceeded, although not allowing for a huge page.

Fix this up by explicitely checking for enough room, not just whether we
are within limits.

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

memcg: some modification to softlimit under hierarchical memory reclaim.

2009-10-01T23:11:13+00:00

This patch clean up/fixes for memcg's uncharge soft limit path.

Problems:
  Now, res_counter_charge()/uncharge() handles softlimit information at
  charge/uncharge and softlimit-check is done when event counter per memcg
  goes over limit. Now, event counter per memcg is updated only when
  memory usage is over soft limit. Here, considering hierarchical memcg
  management, ancesotors should be taken care of.

  Now, ancerstors(hierarchy) are handled in charge() but not in uncharge().
  This is not good.

  Prolems:
  1. memcg's event counter incremented only when softlimit hits. That's bad.
     It makes event counter hard to be reused for other purpose.

  2. At uncharge, only the lowest level rescounter is handled. This is bug.
     Because ancesotor's event counter is not incremented, children should
     take care of them.

  3. res_counter_uncharge()'s 3rd argument is NULL in most case.
     ops under res_counter->lock should be small. No "if" sentense is better.

Fixes:
  * Removed soft_limit_xx poitner and checks in charge and uncharge.
    Do-check-only-when-necessary scheme works enough well without them.

  * make event-counter of memcg incremented at every charge/uncharge.
    (per-cpu area will be accessed soon anyway)

  * All ancestors are checked at soft-limit-check. This is necessary because
    ancesotor's event counter may never be modified. Then, they should be
    checked at the same time.

Reviewed-by: Daisuke Nishimura 
Signed-off-by: KAMEZAWA Hiroyuki 
Cc: Paul Menage 
Cc: Li Zefan 
Cc: Balbir Singh 
Signed-off-by: Andrew Morton 
Signed-off-by: Linus Torvalds

memory controller: soft limit organize cgroups

2009-09-24T14:20:59+00:00

Organize cgroups over soft limit in a RB-Tree

Introduce an RB-Tree for storing memory cgroups that are over their soft
limit.  The overall goal is to

1. Add a memory cgroup to the RB-Tree when the soft limit is exceeded.
   We are careful about updates, updates take place only after a particular
   time interval has passed
2. We remove the node from the RB-Tree when the usage goes below the soft
   limit

The next set of patches will exploit the RB-Tree to get the group that is
over its soft limit by the largest amount and reclaim from it, when we
face memory contention.

[hugh.dickins@tiscali.co.uk: CONFIG_CGROUP_MEM_RES_CTLR=y CONFIG_PREEMPT=y fails to boot]
Signed-off-by: Balbir Singh 
Signed-off-by: KAMEZAWA Hiroyuki 
Cc: Li Zefan 
Cc: KOSAKI Motohiro 
Signed-off-by: Hugh Dickins 
Cc: Jiri Slaby 
Signed-off-by: Andrew Morton 
Signed-off-by: Linus Torvalds