Based on kernel version 3.16. Page generated on 2014-08-06 21:36 EST.
1 CGROUPS 2 ------- 3 4 Written by Paul Menage <email@example.com> based on 5 Documentation/cgroups/cpusets.txt 6 7 Original copyright statements from cpusets.txt: 8 Portions Copyright (C) 2004 BULL SA. 9 Portions Copyright (c) 2004-2006 Silicon Graphics, Inc. 10 Modified by Paul Jackson <firstname.lastname@example.org> 11 Modified by Christoph Lameter <email@example.com> 12 13 CONTENTS: 14 ========= 15 16 1. Control Groups 17 1.1 What are cgroups ? 18 1.2 Why are cgroups needed ? 19 1.3 How are cgroups implemented ? 20 1.4 What does notify_on_release do ? 21 1.5 What does clone_children do ? 22 1.6 How do I use cgroups ? 23 2. Usage Examples and Syntax 24 2.1 Basic Usage 25 2.2 Attaching processes 26 2.3 Mounting hierarchies by name 27 3. Kernel API 28 3.1 Overview 29 3.2 Synchronization 30 3.3 Subsystem API 31 4. Extended attributes usage 32 5. Questions 33 34 1. Control Groups 35 ================= 36 37 1.1 What are cgroups ? 38 ---------------------- 39 40 Control Groups provide a mechanism for aggregating/partitioning sets of 41 tasks, and all their future children, into hierarchical groups with 42 specialized behaviour. 43 44 Definitions: 45 46 A *cgroup* associates a set of tasks with a set of parameters for one 47 or more subsystems. 48 49 A *subsystem* is a module that makes use of the task grouping 50 facilities provided by cgroups to treat groups of tasks in 51 particular ways. A subsystem is typically a "resource controller" that 52 schedules a resource or applies per-cgroup limits, but it may be 53 anything that wants to act on a group of processes, e.g. a 54 virtualization subsystem. 55 56 A *hierarchy* is a set of cgroups arranged in a tree, such that 57 every task in the system is in exactly one of the cgroups in the 58 hierarchy, and a set of subsystems; each subsystem has system-specific 59 state attached to each cgroup in the hierarchy. Each hierarchy has 60 an instance of the cgroup virtual filesystem associated with it. 61 62 At any one time there may be multiple active hierarchies of task 63 cgroups. Each hierarchy is a partition of all tasks in the system. 64 65 User-level code may create and destroy cgroups by name in an 66 instance of the cgroup virtual file system, specify and query to 67 which cgroup a task is assigned, and list the task PIDs assigned to 68 a cgroup. Those creations and assignments only affect the hierarchy 69 associated with that instance of the cgroup file system. 70 71 On their own, the only use for cgroups is for simple job 72 tracking. The intention is that other subsystems hook into the generic 73 cgroup support to provide new attributes for cgroups, such as 74 accounting/limiting the resources which processes in a cgroup can 75 access. For example, cpusets (see Documentation/cgroups/cpusets.txt) allow 76 you to associate a set of CPUs and a set of memory nodes with the 77 tasks in each cgroup. 78 79 1.2 Why are cgroups needed ? 80 ---------------------------- 81 82 There are multiple efforts to provide process aggregations in the 83 Linux kernel, mainly for resource-tracking purposes. Such efforts 84 include cpusets, CKRM/ResGroups, UserBeanCounters, and virtual server 85 namespaces. These all require the basic notion of a 86 grouping/partitioning of processes, with newly forked processes ending 87 up in the same group (cgroup) as their parent process. 88 89 The kernel cgroup patch provides the minimum essential kernel 90 mechanisms required to efficiently implement such groups. It has 91 minimal impact on the system fast paths, and provides hooks for 92 specific subsystems such as cpusets to provide additional behaviour as 93 desired. 94 95 Multiple hierarchy support is provided to allow for situations where 96 the division of tasks into cgroups is distinctly different for 97 different subsystems - having parallel hierarchies allows each 98 hierarchy to be a natural division of tasks, without having to handle 99 complex combinations of tasks that would be present if several 100 unrelated subsystems needed to be forced into the same tree of 101 cgroups. 102 103 At one extreme, each resource controller or subsystem could be in a 104 separate hierarchy; at the other extreme, all subsystems 105 would be attached to the same hierarchy. 106 107 As an example of a scenario (originally proposed by firstname.lastname@example.org) 108 that can benefit from multiple hierarchies, consider a large 109 university server with various users - students, professors, system 110 tasks etc. The resource planning for this server could be along the 111 following lines: 112 113 CPU : "Top cpuset" 114 / \ 115 CPUSet1 CPUSet2 116 | | 117 (Professors) (Students) 118 119 In addition (system tasks) are attached to topcpuset (so 120 that they can run anywhere) with a limit of 20% 121 122 Memory : Professors (50%), Students (30%), system (20%) 123 124 Disk : Professors (50%), Students (30%), system (20%) 125 126 Network : WWW browsing (20%), Network File System (60%), others (20%) 127 / \ 128 Professors (15%) students (5%) 129 130 Browsers like Firefox/Lynx go into the WWW network class, while (k)nfsd goes 131 into the NFS network class. 132 133 At the same time Firefox/Lynx will share an appropriate CPU/Memory class 134 depending on who launched it (prof/student). 135 136 With the ability to classify tasks differently for different resources 137 (by putting those resource subsystems in different hierarchies), 138 the admin can easily set up a script which receives exec notifications 139 and depending on who is launching the browser he can 140 141 # echo browser_pid > /sys/fs/cgroup/<restype>/<userclass>/tasks 142 143 With only a single hierarchy, he now would potentially have to create 144 a separate cgroup for every browser launched and associate it with 145 appropriate network and other resource class. This may lead to 146 proliferation of such cgroups. 147 148 Also let's say that the administrator would like to give enhanced network 149 access temporarily to a student's browser (since it is night and the user 150 wants to do online gaming :)) OR give one of the student's simulation 151 apps enhanced CPU power. 152 153 With ability to write PIDs directly to resource classes, it's just a 154 matter of: 155 156 # echo pid > /sys/fs/cgroup/network/<new_class>/tasks 157 (after some time) 158 # echo pid > /sys/fs/cgroup/network/<orig_class>/tasks 159 160 Without this ability, the administrator would have to split the cgroup into 161 multiple separate ones and then associate the new cgroups with the 162 new resource classes. 163 164 165 166 1.3 How are cgroups implemented ? 167 --------------------------------- 168 169 Control Groups extends the kernel as follows: 170 171 - Each task in the system has a reference-counted pointer to a 172 css_set. 173 174 - A css_set contains a set of reference-counted pointers to 175 cgroup_subsys_state objects, one for each cgroup subsystem 176 registered in the system. There is no direct link from a task to 177 the cgroup of which it's a member in each hierarchy, but this 178 can be determined by following pointers through the 179 cgroup_subsys_state objects. This is because accessing the 180 subsystem state is something that's expected to happen frequently 181 and in performance-critical code, whereas operations that require a 182 task's actual cgroup assignments (in particular, moving between 183 cgroups) are less common. A linked list runs through the cg_list 184 field of each task_struct using the css_set, anchored at 185 css_set->tasks. 186 187 - A cgroup hierarchy filesystem can be mounted for browsing and 188 manipulation from user space. 189 190 - You can list all the tasks (by PID) attached to any cgroup. 191 192 The implementation of cgroups requires a few, simple hooks 193 into the rest of the kernel, none in performance-critical paths: 194 195 - in init/main.c, to initialize the root cgroups and initial 196 css_set at system boot. 197 198 - in fork and exit, to attach and detach a task from its css_set. 199 200 In addition, a new file system of type "cgroup" may be mounted, to 201 enable browsing and modifying the cgroups presently known to the 202 kernel. When mounting a cgroup hierarchy, you may specify a 203 comma-separated list of subsystems to mount as the filesystem mount 204 options. By default, mounting the cgroup filesystem attempts to 205 mount a hierarchy containing all registered subsystems. 206 207 If an active hierarchy with exactly the same set of subsystems already 208 exists, it will be reused for the new mount. If no existing hierarchy 209 matches, and any of the requested subsystems are in use in an existing 210 hierarchy, the mount will fail with -EBUSY. Otherwise, a new hierarchy 211 is activated, associated with the requested subsystems. 212 213 It's not currently possible to bind a new subsystem to an active 214 cgroup hierarchy, or to unbind a subsystem from an active cgroup 215 hierarchy. This may be possible in future, but is fraught with nasty 216 error-recovery issues. 217 218 When a cgroup filesystem is unmounted, if there are any 219 child cgroups created below the top-level cgroup, that hierarchy 220 will remain active even though unmounted; if there are no 221 child cgroups then the hierarchy will be deactivated. 222 223 No new system calls are added for cgroups - all support for 224 querying and modifying cgroups is via this cgroup file system. 225 226 Each task under /proc has an added file named 'cgroup' displaying, 227 for each active hierarchy, the subsystem names and the cgroup name 228 as the path relative to the root of the cgroup file system. 229 230 Each cgroup is represented by a directory in the cgroup file system 231 containing the following files describing that cgroup: 232 233 - tasks: list of tasks (by PID) attached to that cgroup. This list 234 is not guaranteed to be sorted. Writing a thread ID into this file 235 moves the thread into this cgroup. 236 - cgroup.procs: list of thread group IDs in the cgroup. This list is 237 not guaranteed to be sorted or free of duplicate TGIDs, and userspace 238 should sort/uniquify the list if this property is required. 239 Writing a thread group ID into this file moves all threads in that 240 group into this cgroup. 241 - notify_on_release flag: run the release agent on exit? 242 - release_agent: the path to use for release notifications (this file 243 exists in the top cgroup only) 244 245 Other subsystems such as cpusets may add additional files in each 246 cgroup dir. 247 248 New cgroups are created using the mkdir system call or shell 249 command. The properties of a cgroup, such as its flags, are 250 modified by writing to the appropriate file in that cgroups 251 directory, as listed above. 252 253 The named hierarchical structure of nested cgroups allows partitioning 254 a large system into nested, dynamically changeable, "soft-partitions". 255 256 The attachment of each task, automatically inherited at fork by any 257 children of that task, to a cgroup allows organizing the work load 258 on a system into related sets of tasks. A task may be re-attached to 259 any other cgroup, if allowed by the permissions on the necessary 260 cgroup file system directories. 261 262 When a task is moved from one cgroup to another, it gets a new 263 css_set pointer - if there's an already existing css_set with the 264 desired collection of cgroups then that group is reused, otherwise a new 265 css_set is allocated. The appropriate existing css_set is located by 266 looking into a hash table. 267 268 To allow access from a cgroup to the css_sets (and hence tasks) 269 that comprise it, a set of cg_cgroup_link objects form a lattice; 270 each cg_cgroup_link is linked into a list of cg_cgroup_links for 271 a single cgroup on its cgrp_link_list field, and a list of 272 cg_cgroup_links for a single css_set on its cg_link_list. 273 274 Thus the set of tasks in a cgroup can be listed by iterating over 275 each css_set that references the cgroup, and sub-iterating over 276 each css_set's task set. 277 278 The use of a Linux virtual file system (vfs) to represent the 279 cgroup hierarchy provides for a familiar permission and name space 280 for cgroups, with a minimum of additional kernel code. 281 282 1.4 What does notify_on_release do ? 283 ------------------------------------ 284 285 If the notify_on_release flag is enabled (1) in a cgroup, then 286 whenever the last task in the cgroup leaves (exits or attaches to 287 some other cgroup) and the last child cgroup of that cgroup 288 is removed, then the kernel runs the command specified by the contents 289 of the "release_agent" file in that hierarchy's root directory, 290 supplying the pathname (relative to the mount point of the cgroup 291 file system) of the abandoned cgroup. This enables automatic 292 removal of abandoned cgroups. The default value of 293 notify_on_release in the root cgroup at system boot is disabled 294 (0). The default value of other cgroups at creation is the current 295 value of their parents' notify_on_release settings. The default value of 296 a cgroup hierarchy's release_agent path is empty. 297 298 1.5 What does clone_children do ? 299 --------------------------------- 300 301 This flag only affects the cpuset controller. If the clone_children 302 flag is enabled (1) in a cgroup, a new cpuset cgroup will copy its 303 configuration from the parent during initialization. 304 305 1.6 How do I use cgroups ? 306 -------------------------- 307 308 To start a new job that is to be contained within a cgroup, using 309 the "cpuset" cgroup subsystem, the steps are something like: 310 311 1) mount -t tmpfs cgroup_root /sys/fs/cgroup 312 2) mkdir /sys/fs/cgroup/cpuset 313 3) mount -t cgroup -ocpuset cpuset /sys/fs/cgroup/cpuset 314 4) Create the new cgroup by doing mkdir's and write's (or echo's) in 315 the /sys/fs/cgroup virtual file system. 316 5) Start a task that will be the "founding father" of the new job. 317 6) Attach that task to the new cgroup by writing its PID to the 318 /sys/fs/cgroup/cpuset/tasks file for that cgroup. 319 7) fork, exec or clone the job tasks from this founding father task. 320 321 For example, the following sequence of commands will setup a cgroup 322 named "Charlie", containing just CPUs 2 and 3, and Memory Node 1, 323 and then start a subshell 'sh' in that cgroup: 324 325 mount -t tmpfs cgroup_root /sys/fs/cgroup 326 mkdir /sys/fs/cgroup/cpuset 327 mount -t cgroup cpuset -ocpuset /sys/fs/cgroup/cpuset 328 cd /sys/fs/cgroup/cpuset 329 mkdir Charlie 330 cd Charlie 331 /bin/echo 2-3 > cpuset.cpus 332 /bin/echo 1 > cpuset.mems 333 /bin/echo $$ > tasks 334 sh 335 # The subshell 'sh' is now running in cgroup Charlie 336 # The next line should display '/Charlie' 337 cat /proc/self/cgroup 338 339 2. Usage Examples and Syntax 340 ============================ 341 342 2.1 Basic Usage 343 --------------- 344 345 Creating, modifying, using cgroups can be done through the cgroup 346 virtual filesystem. 347 348 To mount a cgroup hierarchy with all available subsystems, type: 349 # mount -t cgroup xxx /sys/fs/cgroup 350 351 The "xxx" is not interpreted by the cgroup code, but will appear in 352 /proc/mounts so may be any useful identifying string that you like. 353 354 Note: Some subsystems do not work without some user input first. For instance, 355 if cpusets are enabled the user will have to populate the cpus and mems files 356 for each new cgroup created before that group can be used. 357 358 As explained in section `1.2 Why are cgroups needed?' you should create 359 different hierarchies of cgroups for each single resource or group of 360 resources you want to control. Therefore, you should mount a tmpfs on 361 /sys/fs/cgroup and create directories for each cgroup resource or resource 362 group. 363 364 # mount -t tmpfs cgroup_root /sys/fs/cgroup 365 # mkdir /sys/fs/cgroup/rg1 366 367 To mount a cgroup hierarchy with just the cpuset and memory 368 subsystems, type: 369 # mount -t cgroup -o cpuset,memory hier1 /sys/fs/cgroup/rg1 370 371 While remounting cgroups is currently supported, it is not recommend 372 to use it. Remounting allows changing bound subsystems and 373 release_agent. Rebinding is hardly useful as it only works when the 374 hierarchy is empty and release_agent itself should be replaced with 375 conventional fsnotify. The support for remounting will be removed in 376 the future. 377 378 To Specify a hierarchy's release_agent: 379 # mount -t cgroup -o cpuset,release_agent="/sbin/cpuset_release_agent" \ 380 xxx /sys/fs/cgroup/rg1 381 382 Note that specifying 'release_agent' more than once will return failure. 383 384 Note that changing the set of subsystems is currently only supported 385 when the hierarchy consists of a single (root) cgroup. Supporting 386 the ability to arbitrarily bind/unbind subsystems from an existing 387 cgroup hierarchy is intended to be implemented in the future. 388 389 Then under /sys/fs/cgroup/rg1 you can find a tree that corresponds to the 390 tree of the cgroups in the system. For instance, /sys/fs/cgroup/rg1 391 is the cgroup that holds the whole system. 392 393 If you want to change the value of release_agent: 394 # echo "/sbin/new_release_agent" > /sys/fs/cgroup/rg1/release_agent 395 396 It can also be changed via remount. 397 398 If you want to create a new cgroup under /sys/fs/cgroup/rg1: 399 # cd /sys/fs/cgroup/rg1 400 # mkdir my_cgroup 401 402 Now you want to do something with this cgroup. 403 # cd my_cgroup 404 405 In this directory you can find several files: 406 # ls 407 cgroup.procs notify_on_release tasks 408 (plus whatever files added by the attached subsystems) 409 410 Now attach your shell to this cgroup: 411 # /bin/echo $$ > tasks 412 413 You can also create cgroups inside your cgroup by using mkdir in this 414 directory. 415 # mkdir my_sub_cs 416 417 To remove a cgroup, just use rmdir: 418 # rmdir my_sub_cs 419 420 This will fail if the cgroup is in use (has cgroups inside, or 421 has processes attached, or is held alive by other subsystem-specific 422 reference). 423 424 2.2 Attaching processes 425 ----------------------- 426 427 # /bin/echo PID > tasks 428 429 Note that it is PID, not PIDs. You can only attach ONE task at a time. 430 If you have several tasks to attach, you have to do it one after another: 431 432 # /bin/echo PID1 > tasks 433 # /bin/echo PID2 > tasks 434 ... 435 # /bin/echo PIDn > tasks 436 437 You can attach the current shell task by echoing 0: 438 439 # echo 0 > tasks 440 441 You can use the cgroup.procs file instead of the tasks file to move all 442 threads in a threadgroup at once. Echoing the PID of any task in a 443 threadgroup to cgroup.procs causes all tasks in that threadgroup to be 444 attached to the cgroup. Writing 0 to cgroup.procs moves all tasks 445 in the writing task's threadgroup. 446 447 Note: Since every task is always a member of exactly one cgroup in each 448 mounted hierarchy, to remove a task from its current cgroup you must 449 move it into a new cgroup (possibly the root cgroup) by writing to the 450 new cgroup's tasks file. 451 452 Note: Due to some restrictions enforced by some cgroup subsystems, moving 453 a process to another cgroup can fail. 454 455 2.3 Mounting hierarchies by name 456 -------------------------------- 457 458 Passing the name=<x> option when mounting a cgroups hierarchy 459 associates the given name with the hierarchy. This can be used when 460 mounting a pre-existing hierarchy, in order to refer to it by name 461 rather than by its set of active subsystems. Each hierarchy is either 462 nameless, or has a unique name. 463 464 The name should match [\w.-]+ 465 466 When passing a name=<x> option for a new hierarchy, you need to 467 specify subsystems manually; the legacy behaviour of mounting all 468 subsystems when none are explicitly specified is not supported when 469 you give a subsystem a name. 470 471 The name of the subsystem appears as part of the hierarchy description 472 in /proc/mounts and /proc/<pid>/cgroups. 473 474 475 3. Kernel API 476 ============= 477 478 3.1 Overview 479 ------------ 480 481 Each kernel subsystem that wants to hook into the generic cgroup 482 system needs to create a cgroup_subsys object. This contains 483 various methods, which are callbacks from the cgroup system, along 484 with a subsystem ID which will be assigned by the cgroup system. 485 486 Other fields in the cgroup_subsys object include: 487 488 - subsys_id: a unique array index for the subsystem, indicating which 489 entry in cgroup->subsys this subsystem should be managing. 490 491 - name: should be initialized to a unique subsystem name. Should be 492 no longer than MAX_CGROUP_TYPE_NAMELEN. 493 494 - early_init: indicate if the subsystem needs early initialization 495 at system boot. 496 497 Each cgroup object created by the system has an array of pointers, 498 indexed by subsystem ID; this pointer is entirely managed by the 499 subsystem; the generic cgroup code will never touch this pointer. 500 501 3.2 Synchronization 502 ------------------- 503 504 There is a global mutex, cgroup_mutex, used by the cgroup 505 system. This should be taken by anything that wants to modify a 506 cgroup. It may also be taken to prevent cgroups from being 507 modified, but more specific locks may be more appropriate in that 508 situation. 509 510 See kernel/cgroup.c for more details. 511 512 Subsystems can take/release the cgroup_mutex via the functions 513 cgroup_lock()/cgroup_unlock(). 514 515 Accessing a task's cgroup pointer may be done in the following ways: 516 - while holding cgroup_mutex 517 - while holding the task's alloc_lock (via task_lock()) 518 - inside an rcu_read_lock() section via rcu_dereference() 519 520 3.3 Subsystem API 521 ----------------- 522 523 Each subsystem should: 524 525 - add an entry in linux/cgroup_subsys.h 526 - define a cgroup_subsys object called <name>_subsys 527 528 If a subsystem can be compiled as a module, it should also have in its 529 module initcall a call to cgroup_load_subsys(), and in its exitcall a 530 call to cgroup_unload_subsys(). It should also set its_subsys.module = 531 THIS_MODULE in its .c file. 532 533 Each subsystem may export the following methods. The only mandatory 534 methods are css_alloc/free. Any others that are null are presumed to 535 be successful no-ops. 536 537 struct cgroup_subsys_state *css_alloc(struct cgroup *cgrp) 538 (cgroup_mutex held by caller) 539 540 Called to allocate a subsystem state object for a cgroup. The 541 subsystem should allocate its subsystem state object for the passed 542 cgroup, returning a pointer to the new object on success or a 543 ERR_PTR() value. On success, the subsystem pointer should point to 544 a structure of type cgroup_subsys_state (typically embedded in a 545 larger subsystem-specific object), which will be initialized by the 546 cgroup system. Note that this will be called at initialization to 547 create the root subsystem state for this subsystem; this case can be 548 identified by the passed cgroup object having a NULL parent (since 549 it's the root of the hierarchy) and may be an appropriate place for 550 initialization code. 551 552 int css_online(struct cgroup *cgrp) 553 (cgroup_mutex held by caller) 554 555 Called after @cgrp successfully completed all allocations and made 556 visible to cgroup_for_each_child/descendant_*() iterators. The 557 subsystem may choose to fail creation by returning -errno. This 558 callback can be used to implement reliable state sharing and 559 propagation along the hierarchy. See the comment on 560 cgroup_for_each_descendant_pre() for details. 561 562 void css_offline(struct cgroup *cgrp); 563 (cgroup_mutex held by caller) 564 565 This is the counterpart of css_online() and called iff css_online() 566 has succeeded on @cgrp. This signifies the beginning of the end of 567 @cgrp. @cgrp is being removed and the subsystem should start dropping 568 all references it's holding on @cgrp. When all references are dropped, 569 cgroup removal will proceed to the next step - css_free(). After this 570 callback, @cgrp should be considered dead to the subsystem. 571 572 void css_free(struct cgroup *cgrp) 573 (cgroup_mutex held by caller) 574 575 The cgroup system is about to free @cgrp; the subsystem should free 576 its subsystem state object. By the time this method is called, @cgrp 577 is completely unused; @cgrp->parent is still valid. (Note - can also 578 be called for a newly-created cgroup if an error occurs after this 579 subsystem's create() method has been called for the new cgroup). 580 581 int can_attach(struct cgroup *cgrp, struct cgroup_taskset *tset) 582 (cgroup_mutex held by caller) 583 584 Called prior to moving one or more tasks into a cgroup; if the 585 subsystem returns an error, this will abort the attach operation. 586 @tset contains the tasks to be attached and is guaranteed to have at 587 least one task in it. 588 589 If there are multiple tasks in the taskset, then: 590 - it's guaranteed that all are from the same thread group 591 - @tset contains all tasks from the thread group whether or not 592 they're switching cgroups 593 - the first task is the leader 594 595 Each @tset entry also contains the task's old cgroup and tasks which 596 aren't switching cgroup can be skipped easily using the 597 cgroup_taskset_for_each() iterator. Note that this isn't called on a 598 fork. If this method returns 0 (success) then this should remain valid 599 while the caller holds cgroup_mutex and it is ensured that either 600 attach() or cancel_attach() will be called in future. 601 602 void cancel_attach(struct cgroup *cgrp, struct cgroup_taskset *tset) 603 (cgroup_mutex held by caller) 604 605 Called when a task attach operation has failed after can_attach() has succeeded. 606 A subsystem whose can_attach() has some side-effects should provide this 607 function, so that the subsystem can implement a rollback. If not, not necessary. 608 This will be called only about subsystems whose can_attach() operation have 609 succeeded. The parameters are identical to can_attach(). 610 611 void attach(struct cgroup *cgrp, struct cgroup_taskset *tset) 612 (cgroup_mutex held by caller) 613 614 Called after the task has been attached to the cgroup, to allow any 615 post-attachment activity that requires memory allocations or blocking. 616 The parameters are identical to can_attach(). 617 618 void fork(struct task_struct *task) 619 620 Called when a task is forked into a cgroup. 621 622 void exit(struct task_struct *task) 623 624 Called during task exit. 625 626 void bind(struct cgroup *root) 627 (cgroup_mutex held by caller) 628 629 Called when a cgroup subsystem is rebound to a different hierarchy 630 and root cgroup. Currently this will only involve movement between 631 the default hierarchy (which never has sub-cgroups) and a hierarchy 632 that is being created/destroyed (and hence has no sub-cgroups). 633 634 4. Extended attribute usage 635 =========================== 636 637 cgroup filesystem supports certain types of extended attributes in its 638 directories and files. The current supported types are: 639 - Trusted (XATTR_TRUSTED) 640 - Security (XATTR_SECURITY) 641 642 Both require CAP_SYS_ADMIN capability to set. 643 644 Like in tmpfs, the extended attributes in cgroup filesystem are stored 645 using kernel memory and it's advised to keep the usage at minimum. This 646 is the reason why user defined extended attributes are not supported, since 647 any user can do it and there's no limit in the value size. 648 649 The current known users for this feature are SELinux to limit cgroup usage 650 in containers and systemd for assorted meta data like main PID in a cgroup 651 (systemd creates a cgroup per service). 652 653 5. Questions 654 ============ 655 656 Q: what's up with this '/bin/echo' ? 657 A: bash's builtin 'echo' command does not check calls to write() against 658 errors. If you use it in the cgroup file system, you won't be 659 able to tell whether a command succeeded or failed. 660 661 Q: When I attach processes, only the first of the line gets really attached ! 662 A: We can only return one error code per call to write(). So you should also 663 put only ONE PID.