memcg: oom kill disable and oom status
[linux-2.6.git] / Documentation / cgroups / memory.txt
1 Memory Resource Controller
2
3 NOTE: The Memory Resource Controller has been generically been referred
4 to as the memory controller in this document. Do not confuse memory controller
5 used here with the memory controller that is used in hardware.
6
7 Salient features
8
9 a. Enable control of Anonymous, Page Cache (mapped and unmapped) and
10    Swap Cache memory pages.
11 b. The infrastructure allows easy addition of other types of memory to control
12 c. Provides *zero overhead* for non memory controller users
13 d. Provides a double LRU: global memory pressure causes reclaim from the
14    global LRU; a cgroup on hitting a limit, reclaims from the per
15    cgroup LRU
16
17 Benefits and Purpose of the memory controller
18
19 The memory controller isolates the memory behaviour of a group of tasks
20 from the rest of the system. The article on LWN [12] mentions some probable
21 uses of the memory controller. The memory controller can be used to
22
23 a. Isolate an application or a group of applications
24    Memory hungry applications can be isolated and limited to a smaller
25    amount of memory.
26 b. Create a cgroup with limited amount of memory, this can be used
27    as a good alternative to booting with mem=XXXX.
28 c. Virtualization solutions can control the amount of memory they want
29    to assign to a virtual machine instance.
30 d. A CD/DVD burner could control the amount of memory used by the
31    rest of the system to ensure that burning does not fail due to lack
32    of available memory.
33 e. There are several other use cases, find one or use the controller just
34    for fun (to learn and hack on the VM subsystem).
35
36 1. History
37
38 The memory controller has a long history. A request for comments for the memory
39 controller was posted by Balbir Singh [1]. At the time the RFC was posted
40 there were several implementations for memory control. The goal of the
41 RFC was to build consensus and agreement for the minimal features required
42 for memory control. The first RSS controller was posted by Balbir Singh[2]
43 in Feb 2007. Pavel Emelianov [3][4][5] has since posted three versions of the
44 RSS controller. At OLS, at the resource management BoF, everyone suggested
45 that we handle both page cache and RSS together. Another request was raised
46 to allow user space handling of OOM. The current memory controller is
47 at version 6; it combines both mapped (RSS) and unmapped Page
48 Cache Control [11].
49
50 2. Memory Control
51
52 Memory is a unique resource in the sense that it is present in a limited
53 amount. If a task requires a lot of CPU processing, the task can spread
54 its processing over a period of hours, days, months or years, but with
55 memory, the same physical memory needs to be reused to accomplish the task.
56
57 The memory controller implementation has been divided into phases. These
58 are:
59
60 1. Memory controller
61 2. mlock(2) controller
62 3. Kernel user memory accounting and slab control
63 4. user mappings length controller
64
65 The memory controller is the first controller developed.
66
67 2.1. Design
68
69 The core of the design is a counter called the res_counter. The res_counter
70 tracks the current memory usage and limit of the group of processes associated
71 with the controller. Each cgroup has a memory controller specific data
72 structure (mem_cgroup) associated with it.
73
74 2.2. Accounting
75
76                 +--------------------+
77                 |  mem_cgroup     |
78                 |  (res_counter)     |
79                 +--------------------+
80                  /            ^      \
81                 /             |       \
82            +---------------+  |        +---------------+
83            | mm_struct     |  |....    | mm_struct     |
84            |               |  |        |               |
85            +---------------+  |        +---------------+
86                               |
87                               + --------------+
88                                               |
89            +---------------+           +------+--------+
90            | page          +---------->  page_cgroup|
91            |               |           |               |
92            +---------------+           +---------------+
93
94              (Figure 1: Hierarchy of Accounting)
95
96
97 Figure 1 shows the important aspects of the controller
98
99 1. Accounting happens per cgroup
100 2. Each mm_struct knows about which cgroup it belongs to
101 3. Each page has a pointer to the page_cgroup, which in turn knows the
102    cgroup it belongs to
103
104 The accounting is done as follows: mem_cgroup_charge() is invoked to setup
105 the necessary data structures and check if the cgroup that is being charged
106 is over its limit. If it is then reclaim is invoked on the cgroup.
107 More details can be found in the reclaim section of this document.
108 If everything goes well, a page meta-data-structure called page_cgroup is
109 allocated and associated with the page.  This routine also adds the page to
110 the per cgroup LRU.
111
112 2.2.1 Accounting details
113
114 All mapped anon pages (RSS) and cache pages (Page Cache) are accounted.
115 (some pages which never be reclaimable and will not be on global LRU
116  are not accounted. we just accounts pages under usual vm management.)
117
118 RSS pages are accounted at page_fault unless they've already been accounted
119 for earlier. A file page will be accounted for as Page Cache when it's
120 inserted into inode (radix-tree). While it's mapped into the page tables of
121 processes, duplicate accounting is carefully avoided.
122
123 A RSS page is unaccounted when it's fully unmapped. A PageCache page is
124 unaccounted when it's removed from radix-tree.
125
126 At page migration, accounting information is kept.
127
128 Note: we just account pages-on-lru because our purpose is to control amount
129 of used pages. not-on-lru pages are tend to be out-of-control from vm view.
130
131 2.3 Shared Page Accounting
132
133 Shared pages are accounted on the basis of the first touch approach. The
134 cgroup that first touches a page is accounted for the page. The principle
135 behind this approach is that a cgroup that aggressively uses a shared
136 page will eventually get charged for it (once it is uncharged from
137 the cgroup that brought it in -- this will happen on memory pressure).
138
139 Exception: If CONFIG_CGROUP_CGROUP_MEM_RES_CTLR_SWAP is not used..
140 When you do swapoff and make swapped-out pages of shmem(tmpfs) to
141 be backed into memory in force, charges for pages are accounted against the
142 caller of swapoff rather than the users of shmem.
143
144
145 2.4 Swap Extension (CONFIG_CGROUP_MEM_RES_CTLR_SWAP)
146 Swap Extension allows you to record charge for swap. A swapped-in page is
147 charged back to original page allocator if possible.
148
149 When swap is accounted, following files are added.
150  - memory.memsw.usage_in_bytes.
151  - memory.memsw.limit_in_bytes.
152
153 usage of mem+swap is limited by memsw.limit_in_bytes.
154
155 * why 'mem+swap' rather than swap.
156 The global LRU(kswapd) can swap out arbitrary pages. Swap-out means
157 to move account from memory to swap...there is no change in usage of
158 mem+swap. In other words, when we want to limit the usage of swap without
159 affecting global LRU, mem+swap limit is better than just limiting swap from
160 OS point of view.
161
162 * What happens when a cgroup hits memory.memsw.limit_in_bytes
163 When a cgroup his memory.memsw.limit_in_bytes, it's useless to do swap-out
164 in this cgroup. Then, swap-out will not be done by cgroup routine and file
165 caches are dropped. But as mentioned above, global LRU can do swapout memory
166 from it for sanity of the system's memory management state. You can't forbid
167 it by cgroup.
168
169 2.5 Reclaim
170
171 Each cgroup maintains a per cgroup LRU that consists of an active
172 and inactive list. When a cgroup goes over its limit, we first try
173 to reclaim memory from the cgroup so as to make space for the new
174 pages that the cgroup has touched. If the reclaim is unsuccessful,
175 an OOM routine is invoked to select and kill the bulkiest task in the
176 cgroup.
177
178 The reclaim algorithm has not been modified for cgroups, except that
179 pages that are selected for reclaiming come from the per cgroup LRU
180 list.
181
182 NOTE: Reclaim does not work for the root cgroup, since we cannot set any
183 limits on the root cgroup.
184
185 Note2: When panic_on_oom is set to "2", the whole system will panic.
186
187 When oom event notifier is registered, event will be delivered.
188 (See oom_control section)
189
190 2. Locking
191
192 The memory controller uses the following hierarchy
193
194 1. zone->lru_lock is used for selecting pages to be isolated
195 2. mem->per_zone->lru_lock protects the per cgroup LRU (per zone)
196 3. lock_page_cgroup() is used to protect page->page_cgroup
197
198 3. User Interface
199
200 0. Configuration
201
202 a. Enable CONFIG_CGROUPS
203 b. Enable CONFIG_RESOURCE_COUNTERS
204 c. Enable CONFIG_CGROUP_MEM_RES_CTLR
205
206 1. Prepare the cgroups
207 # mkdir -p /cgroups
208 # mount -t cgroup none /cgroups -o memory
209
210 2. Make the new group and move bash into it
211 # mkdir /cgroups/0
212 # echo $$ >  /cgroups/0/tasks
213
214 Since now we're in the 0 cgroup,
215 We can alter the memory limit:
216 # echo 4M > /cgroups/0/memory.limit_in_bytes
217
218 NOTE: We can use a suffix (k, K, m, M, g or G) to indicate values in kilo,
219 mega or gigabytes.
220 NOTE: We can write "-1" to reset the *.limit_in_bytes(unlimited).
221 NOTE: We cannot set limits on the root cgroup any more.
222
223 # cat /cgroups/0/memory.limit_in_bytes
224 4194304
225
226 NOTE: The interface has now changed to display the usage in bytes
227 instead of pages
228
229 We can check the usage:
230 # cat /cgroups/0/memory.usage_in_bytes
231 1216512
232
233 A successful write to this file does not guarantee a successful set of
234 this limit to the value written into the file.  This can be due to a
235 number of factors, such as rounding up to page boundaries or the total
236 availability of memory on the system.  The user is required to re-read
237 this file after a write to guarantee the value committed by the kernel.
238
239 # echo 1 > memory.limit_in_bytes
240 # cat memory.limit_in_bytes
241 4096
242
243 The memory.failcnt field gives the number of times that the cgroup limit was
244 exceeded.
245
246 The memory.stat file gives accounting information. Now, the number of
247 caches, RSS and Active pages/Inactive pages are shown.
248
249 4. Testing
250
251 Balbir posted lmbench, AIM9, LTP and vmmstress results [10] and [11].
252 Apart from that v6 has been tested with several applications and regular
253 daily use. The controller has also been tested on the PPC64, x86_64 and
254 UML platforms.
255
256 4.1 Troubleshooting
257
258 Sometimes a user might find that the application under a cgroup is
259 terminated. There are several causes for this:
260
261 1. The cgroup limit is too low (just too low to do anything useful)
262 2. The user is using anonymous memory and swap is turned off or too low
263
264 A sync followed by echo 1 > /proc/sys/vm/drop_caches will help get rid of
265 some of the pages cached in the cgroup (page cache pages).
266
267 4.2 Task migration
268
269 When a task migrates from one cgroup to another, its charge is not
270 carried forward by default. The pages allocated from the original cgroup still
271 remain charged to it, the charge is dropped when the page is freed or
272 reclaimed.
273
274 Note: You can move charges of a task along with task migration. See 8.
275
276 4.3 Removing a cgroup
277
278 A cgroup can be removed by rmdir, but as discussed in sections 4.1 and 4.2, a
279 cgroup might have some charge associated with it, even though all
280 tasks have migrated away from it.
281 Such charges are freed(at default) or moved to its parent. When moved,
282 both of RSS and CACHES are moved to parent.
283 If both of them are busy, rmdir() returns -EBUSY. See 5.1 Also.
284
285 Charges recorded in swap information is not updated at removal of cgroup.
286 Recorded information is discarded and a cgroup which uses swap (swapcache)
287 will be charged as a new owner of it.
288
289
290 5. Misc. interfaces.
291
292 5.1 force_empty
293   memory.force_empty interface is provided to make cgroup's memory usage empty.
294   You can use this interface only when the cgroup has no tasks.
295   When writing anything to this
296
297   # echo 0 > memory.force_empty
298
299   Almost all pages tracked by this memcg will be unmapped and freed. Some of
300   pages cannot be freed because it's locked or in-use. Such pages are moved
301   to parent and this cgroup will be empty. But this may return -EBUSY in
302   some too busy case.
303
304   Typical use case of this interface is that calling this before rmdir().
305   Because rmdir() moves all pages to parent, some out-of-use page caches can be
306   moved to the parent. If you want to avoid that, force_empty will be useful.
307
308 5.2 stat file
309
310 memory.stat file includes following statistics
311
312 cache           - # of bytes of page cache memory.
313 rss             - # of bytes of anonymous and swap cache memory.
314 pgpgin          - # of pages paged in (equivalent to # of charging events).
315 pgpgout         - # of pages paged out (equivalent to # of uncharging events).
316 active_anon     - # of bytes of anonymous and  swap cache memory on active
317                   lru list.
318 inactive_anon   - # of bytes of anonymous memory and swap cache memory on
319                   inactive lru list.
320 active_file     - # of bytes of file-backed memory on active lru list.
321 inactive_file   - # of bytes of file-backed memory on inactive lru list.
322 unevictable     - # of bytes of memory that cannot be reclaimed (mlocked etc).
323
324 The following additional stats are dependent on CONFIG_DEBUG_VM.
325
326 inactive_ratio          - VM internal parameter. (see mm/page_alloc.c)
327 recent_rotated_anon     - VM internal parameter. (see mm/vmscan.c)
328 recent_rotated_file     - VM internal parameter. (see mm/vmscan.c)
329 recent_scanned_anon     - VM internal parameter. (see mm/vmscan.c)
330 recent_scanned_file     - VM internal parameter. (see mm/vmscan.c)
331
332 Memo:
333         recent_rotated means recent frequency of lru rotation.
334         recent_scanned means recent # of scans to lru.
335         showing for better debug please see the code for meanings.
336
337 Note:
338         Only anonymous and swap cache memory is listed as part of 'rss' stat.
339         This should not be confused with the true 'resident set size' or the
340         amount of physical memory used by the cgroup. Per-cgroup rss
341         accounting is not done yet.
342
343 5.3 swappiness
344   Similar to /proc/sys/vm/swappiness, but affecting a hierarchy of groups only.
345
346   Following cgroups' swappiness can't be changed.
347   - root cgroup (uses /proc/sys/vm/swappiness).
348   - a cgroup which uses hierarchy and it has child cgroup.
349   - a cgroup which uses hierarchy and not the root of hierarchy.
350
351
352 6. Hierarchy support
353
354 The memory controller supports a deep hierarchy and hierarchical accounting.
355 The hierarchy is created by creating the appropriate cgroups in the
356 cgroup filesystem. Consider for example, the following cgroup filesystem
357 hierarchy
358
359                 root
360              /  |   \
361            /    |    \
362           a     b       c
363                         | \
364                         |  \
365                         d   e
366
367 In the diagram above, with hierarchical accounting enabled, all memory
368 usage of e, is accounted to its ancestors up until the root (i.e, c and root),
369 that has memory.use_hierarchy enabled.  If one of the ancestors goes over its
370 limit, the reclaim algorithm reclaims from the tasks in the ancestor and the
371 children of the ancestor.
372
373 6.1 Enabling hierarchical accounting and reclaim
374
375 The memory controller by default disables the hierarchy feature. Support
376 can be enabled by writing 1 to memory.use_hierarchy file of the root cgroup
377
378 # echo 1 > memory.use_hierarchy
379
380 The feature can be disabled by
381
382 # echo 0 > memory.use_hierarchy
383
384 NOTE1: Enabling/disabling will fail if the cgroup already has other
385 cgroups created below it.
386
387 NOTE2: When panic_on_oom is set to "2", the whole system will panic in
388 case of an oom event in any cgroup.
389
390 7. Soft limits
391
392 Soft limits allow for greater sharing of memory. The idea behind soft limits
393 is to allow control groups to use as much of the memory as needed, provided
394
395 a. There is no memory contention
396 b. They do not exceed their hard limit
397
398 When the system detects memory contention or low memory control groups
399 are pushed back to their soft limits. If the soft limit of each control
400 group is very high, they are pushed back as much as possible to make
401 sure that one control group does not starve the others of memory.
402
403 Please note that soft limits is a best effort feature, it comes with
404 no guarantees, but it does its best to make sure that when memory is
405 heavily contended for, memory is allocated based on the soft limit
406 hints/setup. Currently soft limit based reclaim is setup such that
407 it gets invoked from balance_pgdat (kswapd).
408
409 7.1 Interface
410
411 Soft limits can be setup by using the following commands (in this example we
412 assume a soft limit of 256 megabytes)
413
414 # echo 256M > memory.soft_limit_in_bytes
415
416 If we want to change this to 1G, we can at any time use
417
418 # echo 1G > memory.soft_limit_in_bytes
419
420 NOTE1: Soft limits take effect over a long period of time, since they involve
421        reclaiming memory for balancing between memory cgroups
422 NOTE2: It is recommended to set the soft limit always below the hard limit,
423        otherwise the hard limit will take precedence.
424
425 8. Move charges at task migration
426
427 Users can move charges associated with a task along with task migration, that
428 is, uncharge task's pages from the old cgroup and charge them to the new cgroup.
429 This feature is not supported in !CONFIG_MMU environments because of lack of
430 page tables.
431
432 8.1 Interface
433
434 This feature is disabled by default. It can be enabled(and disabled again) by
435 writing to memory.move_charge_at_immigrate of the destination cgroup.
436
437 If you want to enable it:
438
439 # echo (some positive value) > memory.move_charge_at_immigrate
440
441 Note: Each bits of move_charge_at_immigrate has its own meaning about what type
442       of charges should be moved. See 8.2 for details.
443 Note: Charges are moved only when you move mm->owner, IOW, a leader of a thread
444       group.
445 Note: If we cannot find enough space for the task in the destination cgroup, we
446       try to make space by reclaiming memory. Task migration may fail if we
447       cannot make enough space.
448 Note: It can take several seconds if you move charges in giga bytes order.
449
450 And if you want disable it again:
451
452 # echo 0 > memory.move_charge_at_immigrate
453
454 8.2 Type of charges which can be move
455
456 Each bits of move_charge_at_immigrate has its own meaning about what type of
457 charges should be moved.
458
459   bit | what type of charges would be moved ?
460  -----+------------------------------------------------------------------------
461    0  | A charge of an anonymous page(or swap of it) used by the target task.
462       | Those pages and swaps must be used only by the target task. You must
463       | enable Swap Extension(see 2.4) to enable move of swap charges.
464
465 Note: Those pages and swaps must be charged to the old cgroup.
466 Note: More type of pages(e.g. file cache, shmem,) will be supported by other
467       bits in future.
468
469 8.3 TODO
470
471 - Add support for other types of pages(e.g. file cache, shmem, etc.).
472 - Implement madvise(2) to let users decide the vma to be moved or not to be
473   moved.
474 - All of moving charge operations are done under cgroup_mutex. It's not good
475   behavior to hold the mutex too long, so we may need some trick.
476
477 9. Memory thresholds
478
479 Memory controler implements memory thresholds using cgroups notification
480 API (see cgroups.txt). It allows to register multiple memory and memsw
481 thresholds and gets notifications when it crosses.
482
483 To register a threshold application need:
484  - create an eventfd using eventfd(2);
485  - open memory.usage_in_bytes or memory.memsw.usage_in_bytes;
486  - write string like "<event_fd> <memory.usage_in_bytes> <threshold>" to
487    cgroup.event_control.
488
489 Application will be notified through eventfd when memory usage crosses
490 threshold in any direction.
491
492 It's applicable for root and non-root cgroup.
493
494 10. OOM Control
495
496 memory.oom_control file is for OOM notification and other controls.
497
498 Memory controler implements oom notifier using cgroup notification
499 API (See cgroups.txt). It allows to register multiple oom notification
500 delivery and gets notification when oom happens.
501
502 To register a notifier, application need:
503  - create an eventfd using eventfd(2)
504  - open memory.oom_control file
505  - write string like "<event_fd> <memory.oom_control>" to cgroup.event_control
506
507 Application will be notifier through eventfd when oom happens.
508 OOM notification doesn't work for root cgroup.
509
510 You can disable oom-killer by writing "1" to memory.oom_control file.
511 As.
512         #echo 1 > memory.oom_control
513
514 This operation is only allowed to the top cgroup of subhierarchy.
515 If oom-killer is disabled, tasks under cgroup will hang/sleep
516 in memcg's oom-waitq when they request accountable memory.
517
518 For running them, you have to relax the memcg's oom sitaution by
519         * enlarge limit or reduce usage.
520 To reduce usage,
521         * kill some tasks.
522         * move some tasks to other group with account migration.
523         * remove some files (on tmpfs?)
524
525 Then, stopped tasks will work again.
526
527 At reading, current status of OOM is shown.
528         oom_kill_disable 0 or 1 (if 1, oom-killer is disabled)
529         under_oom        0 or 1 (if 1, the memcg is under OOM,tasks may
530                                  be stopped.)
531
532 11. TODO
533
534 1. Add support for accounting huge pages (as a separate controller)
535 2. Make per-cgroup scanner reclaim not-shared pages first
536 3. Teach controller to account for shared-pages
537 4. Start reclamation in the background when the limit is
538    not yet hit but the usage is getting closer
539
540 Summary
541
542 Overall, the memory controller has been a stable controller and has been
543 commented and discussed quite extensively in the community.
544
545 References
546
547 1. Singh, Balbir. RFC: Memory Controller, http://lwn.net/Articles/206697/
548 2. Singh, Balbir. Memory Controller (RSS Control),
549    http://lwn.net/Articles/222762/
550 3. Emelianov, Pavel. Resource controllers based on process cgroups
551    http://lkml.org/lkml/2007/3/6/198
552 4. Emelianov, Pavel. RSS controller based on process cgroups (v2)
553    http://lkml.org/lkml/2007/4/9/78
554 5. Emelianov, Pavel. RSS controller based on process cgroups (v3)
555    http://lkml.org/lkml/2007/5/30/244
556 6. Menage, Paul. Control Groups v10, http://lwn.net/Articles/236032/
557 7. Vaidyanathan, Srinivasan, Control Groups: Pagecache accounting and control
558    subsystem (v3), http://lwn.net/Articles/235534/
559 8. Singh, Balbir. RSS controller v2 test results (lmbench),
560    http://lkml.org/lkml/2007/5/17/232
561 9. Singh, Balbir. RSS controller v2 AIM9 results
562    http://lkml.org/lkml/2007/5/18/1
563 10. Singh, Balbir. Memory controller v6 test results,
564     http://lkml.org/lkml/2007/8/19/36
565 11. Singh, Balbir. Memory controller introduction (v6),
566     http://lkml.org/lkml/2007/8/17/69
567 12. Corbet, Jonathan, Controlling memory use in cgroups,
568     http://lwn.net/Articles/243795/