1 /* SPDX-License-Identifier: GPL-2.0 */ 2 #ifndef _LINUX_CGROUP_H 3 #define _LINUX_CGROUP_H 4 /* 5 * cgroup interface 6 * 7 * Copyright (C) 2003 BULL SA 8 * Copyright (C) 2004-2006 Silicon Graphics, Inc. 9 * 10 */ 11 12 #include <linux/sched.h> 13 #include <linux/cpumask.h> 14 #include <linux/nodemask.h> 15 #include <linux/rculist.h> 16 #include <linux/cgroupstats.h> 17 #include <linux/fs.h> 18 #include <linux/seq_file.h> 19 #include <linux/kernfs.h> 20 #include <linux/jump_label.h> 21 #include <linux/types.h> 22 #include <linux/ns_common.h> 23 #include <linux/nsproxy.h> 24 #include <linux/user_namespace.h> 25 #include <linux/refcount.h> 26 #include <linux/kernel_stat.h> 27 28 #include <linux/cgroup-defs.h> 29 30 #ifdef CONFIG_CGROUPS 31 32 /* 33 * All weight knobs on the default hierarhcy should use the following min, 34 * default and max values. The default value is the logarithmic center of 35 * MIN and MAX and allows 100x to be expressed in both directions. 36 */ 37 #define CGROUP_WEIGHT_MIN 1 38 #define CGROUP_WEIGHT_DFL 100 39 #define CGROUP_WEIGHT_MAX 10000 40 41 /* walk only threadgroup leaders */ 42 #define CSS_TASK_ITER_PROCS (1U << 0) 43 /* walk all threaded css_sets in the domain */ 44 #define CSS_TASK_ITER_THREADED (1U << 1) 45 46 /* a css_task_iter should be treated as an opaque object */ 47 struct css_task_iter { 48 struct cgroup_subsys *ss; 49 unsigned int flags; 50 51 struct list_head *cset_pos; 52 struct list_head *cset_head; 53 54 struct list_head *tcset_pos; 55 struct list_head *tcset_head; 56 57 struct list_head *task_pos; 58 struct list_head *tasks_head; 59 struct list_head *mg_tasks_head; 60 61 struct css_set *cur_cset; 62 struct css_set *cur_dcset; 63 struct task_struct *cur_task; 64 struct list_head iters_node; /* css_set->task_iters */ 65 }; 66 67 extern struct cgroup_root cgrp_dfl_root; 68 extern struct css_set init_css_set; 69 70 #define SUBSYS(_x) extern struct cgroup_subsys _x ## _cgrp_subsys; 71 #include <linux/cgroup_subsys.h> 72 #undef SUBSYS 73 74 #define SUBSYS(_x) \ 75 extern struct static_key_true _x ## _cgrp_subsys_enabled_key; \ 76 extern struct static_key_true _x ## _cgrp_subsys_on_dfl_key; 77 #include <linux/cgroup_subsys.h> 78 #undef SUBSYS 79 80 /** 81 * cgroup_subsys_enabled - fast test on whether a subsys is enabled 82 * @ss: subsystem in question 83 */ 84 #define cgroup_subsys_enabled(ss) \ 85 static_branch_likely(&ss ## _enabled_key) 86 87 /** 88 * cgroup_subsys_on_dfl - fast test on whether a subsys is on default hierarchy 89 * @ss: subsystem in question 90 */ 91 #define cgroup_subsys_on_dfl(ss) \ 92 static_branch_likely(&ss ## _on_dfl_key) 93 94 bool css_has_online_children(struct cgroup_subsys_state *css); 95 struct cgroup_subsys_state *css_from_id(int id, struct cgroup_subsys *ss); 96 struct cgroup_subsys_state *cgroup_e_css(struct cgroup *cgroup, 97 struct cgroup_subsys *ss); 98 struct cgroup_subsys_state *cgroup_get_e_css(struct cgroup *cgroup, 99 struct cgroup_subsys *ss); 100 struct cgroup_subsys_state *css_tryget_online_from_dir(struct dentry *dentry, 101 struct cgroup_subsys *ss); 102 103 struct cgroup *cgroup_get_from_path(const char *path); 104 struct cgroup *cgroup_get_from_fd(int fd); 105 106 int cgroup_attach_task_all(struct task_struct *from, struct task_struct *); 107 int cgroup_transfer_tasks(struct cgroup *to, struct cgroup *from); 108 109 int cgroup_add_dfl_cftypes(struct cgroup_subsys *ss, struct cftype *cfts); 110 int cgroup_add_legacy_cftypes(struct cgroup_subsys *ss, struct cftype *cfts); 111 int cgroup_rm_cftypes(struct cftype *cfts); 112 void cgroup_file_notify(struct cgroup_file *cfile); 113 114 int task_cgroup_path(struct task_struct *task, char *buf, size_t buflen); 115 int cgroupstats_build(struct cgroupstats *stats, struct dentry *dentry); 116 int proc_cgroup_show(struct seq_file *m, struct pid_namespace *ns, 117 struct pid *pid, struct task_struct *tsk); 118 119 void cgroup_fork(struct task_struct *p); 120 extern int cgroup_can_fork(struct task_struct *p); 121 extern void cgroup_cancel_fork(struct task_struct *p); 122 extern void cgroup_post_fork(struct task_struct *p); 123 void cgroup_exit(struct task_struct *p); 124 void cgroup_free(struct task_struct *p); 125 126 int cgroup_init_early(void); 127 int cgroup_init(void); 128 129 /* 130 * Iteration helpers and macros. 131 */ 132 133 struct cgroup_subsys_state *css_next_child(struct cgroup_subsys_state *pos, 134 struct cgroup_subsys_state *parent); 135 struct cgroup_subsys_state *css_next_descendant_pre(struct cgroup_subsys_state *pos, 136 struct cgroup_subsys_state *css); 137 struct cgroup_subsys_state *css_rightmost_descendant(struct cgroup_subsys_state *pos); 138 struct cgroup_subsys_state *css_next_descendant_post(struct cgroup_subsys_state *pos, 139 struct cgroup_subsys_state *css); 140 141 struct task_struct *cgroup_taskset_first(struct cgroup_taskset *tset, 142 struct cgroup_subsys_state **dst_cssp); 143 struct task_struct *cgroup_taskset_next(struct cgroup_taskset *tset, 144 struct cgroup_subsys_state **dst_cssp); 145 146 void css_task_iter_start(struct cgroup_subsys_state *css, unsigned int flags, 147 struct css_task_iter *it); 148 struct task_struct *css_task_iter_next(struct css_task_iter *it); 149 void css_task_iter_end(struct css_task_iter *it); 150 151 /** 152 * css_for_each_child - iterate through children of a css 153 * @pos: the css * to use as the loop cursor 154 * @parent: css whose children to walk 155 * 156 * Walk @parent's children. Must be called under rcu_read_lock(). 157 * 158 * If a subsystem synchronizes ->css_online() and the start of iteration, a 159 * css which finished ->css_online() is guaranteed to be visible in the 160 * future iterations and will stay visible until the last reference is put. 161 * A css which hasn't finished ->css_online() or already finished 162 * ->css_offline() may show up during traversal. It's each subsystem's 163 * responsibility to synchronize against on/offlining. 164 * 165 * It is allowed to temporarily drop RCU read lock during iteration. The 166 * caller is responsible for ensuring that @pos remains accessible until 167 * the start of the next iteration by, for example, bumping the css refcnt. 168 */ 169 #define css_for_each_child(pos, parent) \ 170 for ((pos) = css_next_child(NULL, (parent)); (pos); \ 171 (pos) = css_next_child((pos), (parent))) 172 173 /** 174 * css_for_each_descendant_pre - pre-order walk of a css's descendants 175 * @pos: the css * to use as the loop cursor 176 * @root: css whose descendants to walk 177 * 178 * Walk @root's descendants. @root is included in the iteration and the 179 * first node to be visited. Must be called under rcu_read_lock(). 180 * 181 * If a subsystem synchronizes ->css_online() and the start of iteration, a 182 * css which finished ->css_online() is guaranteed to be visible in the 183 * future iterations and will stay visible until the last reference is put. 184 * A css which hasn't finished ->css_online() or already finished 185 * ->css_offline() may show up during traversal. It's each subsystem's 186 * responsibility to synchronize against on/offlining. 187 * 188 * For example, the following guarantees that a descendant can't escape 189 * state updates of its ancestors. 190 * 191 * my_online(@css) 192 * { 193 * Lock @css's parent and @css; 194 * Inherit state from the parent; 195 * Unlock both. 196 * } 197 * 198 * my_update_state(@css) 199 * { 200 * css_for_each_descendant_pre(@pos, @css) { 201 * Lock @pos; 202 * if (@pos == @css) 203 * Update @css's state; 204 * else 205 * Verify @pos is alive and inherit state from its parent; 206 * Unlock @pos; 207 * } 208 * } 209 * 210 * As long as the inheriting step, including checking the parent state, is 211 * enclosed inside @pos locking, double-locking the parent isn't necessary 212 * while inheriting. The state update to the parent is guaranteed to be 213 * visible by walking order and, as long as inheriting operations to the 214 * same @pos are atomic to each other, multiple updates racing each other 215 * still result in the correct state. It's guaranateed that at least one 216 * inheritance happens for any css after the latest update to its parent. 217 * 218 * If checking parent's state requires locking the parent, each inheriting 219 * iteration should lock and unlock both @pos->parent and @pos. 220 * 221 * Alternatively, a subsystem may choose to use a single global lock to 222 * synchronize ->css_online() and ->css_offline() against tree-walking 223 * operations. 224 * 225 * It is allowed to temporarily drop RCU read lock during iteration. The 226 * caller is responsible for ensuring that @pos remains accessible until 227 * the start of the next iteration by, for example, bumping the css refcnt. 228 */ 229 #define css_for_each_descendant_pre(pos, css) \ 230 for ((pos) = css_next_descendant_pre(NULL, (css)); (pos); \ 231 (pos) = css_next_descendant_pre((pos), (css))) 232 233 /** 234 * css_for_each_descendant_post - post-order walk of a css's descendants 235 * @pos: the css * to use as the loop cursor 236 * @css: css whose descendants to walk 237 * 238 * Similar to css_for_each_descendant_pre() but performs post-order 239 * traversal instead. @root is included in the iteration and the last 240 * node to be visited. 241 * 242 * If a subsystem synchronizes ->css_online() and the start of iteration, a 243 * css which finished ->css_online() is guaranteed to be visible in the 244 * future iterations and will stay visible until the last reference is put. 245 * A css which hasn't finished ->css_online() or already finished 246 * ->css_offline() may show up during traversal. It's each subsystem's 247 * responsibility to synchronize against on/offlining. 248 * 249 * Note that the walk visibility guarantee example described in pre-order 250 * walk doesn't apply the same to post-order walks. 251 */ 252 #define css_for_each_descendant_post(pos, css) \ 253 for ((pos) = css_next_descendant_post(NULL, (css)); (pos); \ 254 (pos) = css_next_descendant_post((pos), (css))) 255 256 /** 257 * cgroup_taskset_for_each - iterate cgroup_taskset 258 * @task: the loop cursor 259 * @dst_css: the destination css 260 * @tset: taskset to iterate 261 * 262 * @tset may contain multiple tasks and they may belong to multiple 263 * processes. 264 * 265 * On the v2 hierarchy, there may be tasks from multiple processes and they 266 * may not share the source or destination csses. 267 * 268 * On traditional hierarchies, when there are multiple tasks in @tset, if a 269 * task of a process is in @tset, all tasks of the process are in @tset. 270 * Also, all are guaranteed to share the same source and destination csses. 271 * 272 * Iteration is not in any specific order. 273 */ 274 #define cgroup_taskset_for_each(task, dst_css, tset) \ 275 for ((task) = cgroup_taskset_first((tset), &(dst_css)); \ 276 (task); \ 277 (task) = cgroup_taskset_next((tset), &(dst_css))) 278 279 /** 280 * cgroup_taskset_for_each_leader - iterate group leaders in a cgroup_taskset 281 * @leader: the loop cursor 282 * @dst_css: the destination css 283 * @tset: taskset to iterate 284 * 285 * Iterate threadgroup leaders of @tset. For single-task migrations, @tset 286 * may not contain any. 287 */ 288 #define cgroup_taskset_for_each_leader(leader, dst_css, tset) \ 289 for ((leader) = cgroup_taskset_first((tset), &(dst_css)); \ 290 (leader); \ 291 (leader) = cgroup_taskset_next((tset), &(dst_css))) \ 292 if ((leader) != (leader)->group_leader) \ 293 ; \ 294 else 295 296 /* 297 * Inline functions. 298 */ 299 300 /** 301 * css_get - obtain a reference on the specified css 302 * @css: target css 303 * 304 * The caller must already have a reference. 305 */ 306 static inline void css_get(struct cgroup_subsys_state *css) 307 { 308 if (!(css->flags & CSS_NO_REF)) 309 percpu_ref_get(&css->refcnt); 310 } 311 312 /** 313 * css_get_many - obtain references on the specified css 314 * @css: target css 315 * @n: number of references to get 316 * 317 * The caller must already have a reference. 318 */ 319 static inline void css_get_many(struct cgroup_subsys_state *css, unsigned int n) 320 { 321 if (!(css->flags & CSS_NO_REF)) 322 percpu_ref_get_many(&css->refcnt, n); 323 } 324 325 /** 326 * css_tryget - try to obtain a reference on the specified css 327 * @css: target css 328 * 329 * Obtain a reference on @css unless it already has reached zero and is 330 * being released. This function doesn't care whether @css is on or 331 * offline. The caller naturally needs to ensure that @css is accessible 332 * but doesn't have to be holding a reference on it - IOW, RCU protected 333 * access is good enough for this function. Returns %true if a reference 334 * count was successfully obtained; %false otherwise. 335 */ 336 static inline bool css_tryget(struct cgroup_subsys_state *css) 337 { 338 if (!(css->flags & CSS_NO_REF)) 339 return percpu_ref_tryget(&css->refcnt); 340 return true; 341 } 342 343 /** 344 * css_tryget_online - try to obtain a reference on the specified css if online 345 * @css: target css 346 * 347 * Obtain a reference on @css if it's online. The caller naturally needs 348 * to ensure that @css is accessible but doesn't have to be holding a 349 * reference on it - IOW, RCU protected access is good enough for this 350 * function. Returns %true if a reference count was successfully obtained; 351 * %false otherwise. 352 */ 353 static inline bool css_tryget_online(struct cgroup_subsys_state *css) 354 { 355 if (!(css->flags & CSS_NO_REF)) 356 return percpu_ref_tryget_live(&css->refcnt); 357 return true; 358 } 359 360 /** 361 * css_is_dying - test whether the specified css is dying 362 * @css: target css 363 * 364 * Test whether @css is in the process of offlining or already offline. In 365 * most cases, ->css_online() and ->css_offline() callbacks should be 366 * enough; however, the actual offline operations are RCU delayed and this 367 * test returns %true also when @css is scheduled to be offlined. 368 * 369 * This is useful, for example, when the use case requires synchronous 370 * behavior with respect to cgroup removal. cgroup removal schedules css 371 * offlining but the css can seem alive while the operation is being 372 * delayed. If the delay affects user visible semantics, this test can be 373 * used to resolve the situation. 374 */ 375 static inline bool css_is_dying(struct cgroup_subsys_state *css) 376 { 377 return !(css->flags & CSS_NO_REF) && percpu_ref_is_dying(&css->refcnt); 378 } 379 380 /** 381 * css_put - put a css reference 382 * @css: target css 383 * 384 * Put a reference obtained via css_get() and css_tryget_online(). 385 */ 386 static inline void css_put(struct cgroup_subsys_state *css) 387 { 388 if (!(css->flags & CSS_NO_REF)) 389 percpu_ref_put(&css->refcnt); 390 } 391 392 /** 393 * css_put_many - put css references 394 * @css: target css 395 * @n: number of references to put 396 * 397 * Put references obtained via css_get() and css_tryget_online(). 398 */ 399 static inline void css_put_many(struct cgroup_subsys_state *css, unsigned int n) 400 { 401 if (!(css->flags & CSS_NO_REF)) 402 percpu_ref_put_many(&css->refcnt, n); 403 } 404 405 static inline void cgroup_get(struct cgroup *cgrp) 406 { 407 css_get(&cgrp->self); 408 } 409 410 static inline bool cgroup_tryget(struct cgroup *cgrp) 411 { 412 return css_tryget(&cgrp->self); 413 } 414 415 static inline void cgroup_put(struct cgroup *cgrp) 416 { 417 css_put(&cgrp->self); 418 } 419 420 /** 421 * task_css_set_check - obtain a task's css_set with extra access conditions 422 * @task: the task to obtain css_set for 423 * @__c: extra condition expression to be passed to rcu_dereference_check() 424 * 425 * A task's css_set is RCU protected, initialized and exited while holding 426 * task_lock(), and can only be modified while holding both cgroup_mutex 427 * and task_lock() while the task is alive. This macro verifies that the 428 * caller is inside proper critical section and returns @task's css_set. 429 * 430 * The caller can also specify additional allowed conditions via @__c, such 431 * as locks used during the cgroup_subsys::attach() methods. 432 */ 433 #ifdef CONFIG_PROVE_RCU 434 extern struct mutex cgroup_mutex; 435 extern spinlock_t css_set_lock; 436 #define task_css_set_check(task, __c) \ 437 rcu_dereference_check((task)->cgroups, \ 438 lockdep_is_held(&cgroup_mutex) || \ 439 lockdep_is_held(&css_set_lock) || \ 440 ((task)->flags & PF_EXITING) || (__c)) 441 #else 442 #define task_css_set_check(task, __c) \ 443 rcu_dereference((task)->cgroups) 444 #endif 445 446 /** 447 * task_css_check - obtain css for (task, subsys) w/ extra access conds 448 * @task: the target task 449 * @subsys_id: the target subsystem ID 450 * @__c: extra condition expression to be passed to rcu_dereference_check() 451 * 452 * Return the cgroup_subsys_state for the (@task, @subsys_id) pair. The 453 * synchronization rules are the same as task_css_set_check(). 454 */ 455 #define task_css_check(task, subsys_id, __c) \ 456 task_css_set_check((task), (__c))->subsys[(subsys_id)] 457 458 /** 459 * task_css_set - obtain a task's css_set 460 * @task: the task to obtain css_set for 461 * 462 * See task_css_set_check(). 463 */ 464 static inline struct css_set *task_css_set(struct task_struct *task) 465 { 466 return task_css_set_check(task, false); 467 } 468 469 /** 470 * task_css - obtain css for (task, subsys) 471 * @task: the target task 472 * @subsys_id: the target subsystem ID 473 * 474 * See task_css_check(). 475 */ 476 static inline struct cgroup_subsys_state *task_css(struct task_struct *task, 477 int subsys_id) 478 { 479 return task_css_check(task, subsys_id, false); 480 } 481 482 /** 483 * task_get_css - find and get the css for (task, subsys) 484 * @task: the target task 485 * @subsys_id: the target subsystem ID 486 * 487 * Find the css for the (@task, @subsys_id) combination, increment a 488 * reference on and return it. This function is guaranteed to return a 489 * valid css. 490 */ 491 static inline struct cgroup_subsys_state * 492 task_get_css(struct task_struct *task, int subsys_id) 493 { 494 struct cgroup_subsys_state *css; 495 496 rcu_read_lock(); 497 while (true) { 498 css = task_css(task, subsys_id); 499 if (likely(css_tryget_online(css))) 500 break; 501 cpu_relax(); 502 } 503 rcu_read_unlock(); 504 return css; 505 } 506 507 /** 508 * task_css_is_root - test whether a task belongs to the root css 509 * @task: the target task 510 * @subsys_id: the target subsystem ID 511 * 512 * Test whether @task belongs to the root css on the specified subsystem. 513 * May be invoked in any context. 514 */ 515 static inline bool task_css_is_root(struct task_struct *task, int subsys_id) 516 { 517 return task_css_check(task, subsys_id, true) == 518 init_css_set.subsys[subsys_id]; 519 } 520 521 static inline struct cgroup *task_cgroup(struct task_struct *task, 522 int subsys_id) 523 { 524 return task_css(task, subsys_id)->cgroup; 525 } 526 527 static inline struct cgroup *task_dfl_cgroup(struct task_struct *task) 528 { 529 return task_css_set(task)->dfl_cgrp; 530 } 531 532 static inline struct cgroup *cgroup_parent(struct cgroup *cgrp) 533 { 534 struct cgroup_subsys_state *parent_css = cgrp->self.parent; 535 536 if (parent_css) 537 return container_of(parent_css, struct cgroup, self); 538 return NULL; 539 } 540 541 /** 542 * cgroup_is_descendant - test ancestry 543 * @cgrp: the cgroup to be tested 544 * @ancestor: possible ancestor of @cgrp 545 * 546 * Test whether @cgrp is a descendant of @ancestor. It also returns %true 547 * if @cgrp == @ancestor. This function is safe to call as long as @cgrp 548 * and @ancestor are accessible. 549 */ 550 static inline bool cgroup_is_descendant(struct cgroup *cgrp, 551 struct cgroup *ancestor) 552 { 553 if (cgrp->root != ancestor->root || cgrp->level < ancestor->level) 554 return false; 555 return cgrp->ancestor_ids[ancestor->level] == ancestor->id; 556 } 557 558 /** 559 * cgroup_ancestor - find ancestor of cgroup 560 * @cgrp: cgroup to find ancestor of 561 * @ancestor_level: level of ancestor to find starting from root 562 * 563 * Find ancestor of cgroup at specified level starting from root if it exists 564 * and return pointer to it. Return NULL if @cgrp doesn't have ancestor at 565 * @ancestor_level. 566 * 567 * This function is safe to call as long as @cgrp is accessible. 568 */ 569 static inline struct cgroup *cgroup_ancestor(struct cgroup *cgrp, 570 int ancestor_level) 571 { 572 if (cgrp->level < ancestor_level) 573 return NULL; 574 while (cgrp && cgrp->level > ancestor_level) 575 cgrp = cgroup_parent(cgrp); 576 return cgrp; 577 } 578 579 /** 580 * task_under_cgroup_hierarchy - test task's membership of cgroup ancestry 581 * @task: the task to be tested 582 * @ancestor: possible ancestor of @task's cgroup 583 * 584 * Tests whether @task's default cgroup hierarchy is a descendant of @ancestor. 585 * It follows all the same rules as cgroup_is_descendant, and only applies 586 * to the default hierarchy. 587 */ 588 static inline bool task_under_cgroup_hierarchy(struct task_struct *task, 589 struct cgroup *ancestor) 590 { 591 struct css_set *cset = task_css_set(task); 592 593 return cgroup_is_descendant(cset->dfl_cgrp, ancestor); 594 } 595 596 /* no synchronization, the result can only be used as a hint */ 597 static inline bool cgroup_is_populated(struct cgroup *cgrp) 598 { 599 return cgrp->nr_populated_csets + cgrp->nr_populated_domain_children + 600 cgrp->nr_populated_threaded_children; 601 } 602 603 /* returns ino associated with a cgroup */ 604 static inline ino_t cgroup_ino(struct cgroup *cgrp) 605 { 606 return cgrp->kn->id.ino; 607 } 608 609 /* cft/css accessors for cftype->write() operation */ 610 static inline struct cftype *of_cft(struct kernfs_open_file *of) 611 { 612 return of->kn->priv; 613 } 614 615 struct cgroup_subsys_state *of_css(struct kernfs_open_file *of); 616 617 /* cft/css accessors for cftype->seq_*() operations */ 618 static inline struct cftype *seq_cft(struct seq_file *seq) 619 { 620 return of_cft(seq->private); 621 } 622 623 static inline struct cgroup_subsys_state *seq_css(struct seq_file *seq) 624 { 625 return of_css(seq->private); 626 } 627 628 /* 629 * Name / path handling functions. All are thin wrappers around the kernfs 630 * counterparts and can be called under any context. 631 */ 632 633 static inline int cgroup_name(struct cgroup *cgrp, char *buf, size_t buflen) 634 { 635 return kernfs_name(cgrp->kn, buf, buflen); 636 } 637 638 static inline int cgroup_path(struct cgroup *cgrp, char *buf, size_t buflen) 639 { 640 return kernfs_path(cgrp->kn, buf, buflen); 641 } 642 643 static inline void pr_cont_cgroup_name(struct cgroup *cgrp) 644 { 645 pr_cont_kernfs_name(cgrp->kn); 646 } 647 648 static inline void pr_cont_cgroup_path(struct cgroup *cgrp) 649 { 650 pr_cont_kernfs_path(cgrp->kn); 651 } 652 653 static inline struct psi_group *cgroup_psi(struct cgroup *cgrp) 654 { 655 return &cgrp->psi; 656 } 657 658 static inline void cgroup_init_kthreadd(void) 659 { 660 /* 661 * kthreadd is inherited by all kthreads, keep it in the root so 662 * that the new kthreads are guaranteed to stay in the root until 663 * initialization is finished. 664 */ 665 current->no_cgroup_migration = 1; 666 } 667 668 static inline void cgroup_kthread_ready(void) 669 { 670 /* 671 * This kthread finished initialization. The creator should have 672 * set PF_NO_SETAFFINITY if this kthread should stay in the root. 673 */ 674 current->no_cgroup_migration = 0; 675 } 676 677 static inline union kernfs_node_id *cgroup_get_kernfs_id(struct cgroup *cgrp) 678 { 679 return &cgrp->kn->id; 680 } 681 682 void cgroup_path_from_kernfs_id(const union kernfs_node_id *id, 683 char *buf, size_t buflen); 684 #else /* !CONFIG_CGROUPS */ 685 686 struct cgroup_subsys_state; 687 struct cgroup; 688 689 static inline void css_put(struct cgroup_subsys_state *css) {} 690 static inline int cgroup_attach_task_all(struct task_struct *from, 691 struct task_struct *t) { return 0; } 692 static inline int cgroupstats_build(struct cgroupstats *stats, 693 struct dentry *dentry) { return -EINVAL; } 694 695 static inline void cgroup_fork(struct task_struct *p) {} 696 static inline int cgroup_can_fork(struct task_struct *p) { return 0; } 697 static inline void cgroup_cancel_fork(struct task_struct *p) {} 698 static inline void cgroup_post_fork(struct task_struct *p) {} 699 static inline void cgroup_exit(struct task_struct *p) {} 700 static inline void cgroup_free(struct task_struct *p) {} 701 702 static inline int cgroup_init_early(void) { return 0; } 703 static inline int cgroup_init(void) { return 0; } 704 static inline void cgroup_init_kthreadd(void) {} 705 static inline void cgroup_kthread_ready(void) {} 706 static inline union kernfs_node_id *cgroup_get_kernfs_id(struct cgroup *cgrp) 707 { 708 return NULL; 709 } 710 711 static inline struct cgroup *cgroup_parent(struct cgroup *cgrp) 712 { 713 return NULL; 714 } 715 716 static inline struct psi_group *cgroup_psi(struct cgroup *cgrp) 717 { 718 return NULL; 719 } 720 721 static inline bool task_under_cgroup_hierarchy(struct task_struct *task, 722 struct cgroup *ancestor) 723 { 724 return true; 725 } 726 727 static inline void cgroup_path_from_kernfs_id(const union kernfs_node_id *id, 728 char *buf, size_t buflen) {} 729 #endif /* !CONFIG_CGROUPS */ 730 731 #ifdef CONFIG_CGROUPS 732 /* 733 * cgroup scalable recursive statistics. 734 */ 735 void cgroup_rstat_updated(struct cgroup *cgrp, int cpu); 736 void cgroup_rstat_flush(struct cgroup *cgrp); 737 void cgroup_rstat_flush_irqsafe(struct cgroup *cgrp); 738 void cgroup_rstat_flush_hold(struct cgroup *cgrp); 739 void cgroup_rstat_flush_release(void); 740 741 /* 742 * Basic resource stats. 743 */ 744 #ifdef CONFIG_CGROUP_CPUACCT 745 void cpuacct_charge(struct task_struct *tsk, u64 cputime); 746 void cpuacct_account_field(struct task_struct *tsk, int index, u64 val); 747 #else 748 static inline void cpuacct_charge(struct task_struct *tsk, u64 cputime) {} 749 static inline void cpuacct_account_field(struct task_struct *tsk, int index, 750 u64 val) {} 751 #endif 752 753 void __cgroup_account_cputime(struct cgroup *cgrp, u64 delta_exec); 754 void __cgroup_account_cputime_field(struct cgroup *cgrp, 755 enum cpu_usage_stat index, u64 delta_exec); 756 757 static inline void cgroup_account_cputime(struct task_struct *task, 758 u64 delta_exec) 759 { 760 struct cgroup *cgrp; 761 762 cpuacct_charge(task, delta_exec); 763 764 rcu_read_lock(); 765 cgrp = task_dfl_cgroup(task); 766 if (cgroup_parent(cgrp)) 767 __cgroup_account_cputime(cgrp, delta_exec); 768 rcu_read_unlock(); 769 } 770 771 static inline void cgroup_account_cputime_field(struct task_struct *task, 772 enum cpu_usage_stat index, 773 u64 delta_exec) 774 { 775 struct cgroup *cgrp; 776 777 cpuacct_account_field(task, index, delta_exec); 778 779 rcu_read_lock(); 780 cgrp = task_dfl_cgroup(task); 781 if (cgroup_parent(cgrp)) 782 __cgroup_account_cputime_field(cgrp, index, delta_exec); 783 rcu_read_unlock(); 784 } 785 786 #else /* CONFIG_CGROUPS */ 787 788 static inline void cgroup_account_cputime(struct task_struct *task, 789 u64 delta_exec) {} 790 static inline void cgroup_account_cputime_field(struct task_struct *task, 791 enum cpu_usage_stat index, 792 u64 delta_exec) {} 793 794 #endif /* CONFIG_CGROUPS */ 795 796 /* 797 * sock->sk_cgrp_data handling. For more info, see sock_cgroup_data 798 * definition in cgroup-defs.h. 799 */ 800 #ifdef CONFIG_SOCK_CGROUP_DATA 801 802 #if defined(CONFIG_CGROUP_NET_PRIO) || defined(CONFIG_CGROUP_NET_CLASSID) 803 extern spinlock_t cgroup_sk_update_lock; 804 #endif 805 806 void cgroup_sk_alloc_disable(void); 807 void cgroup_sk_alloc(struct sock_cgroup_data *skcd); 808 void cgroup_sk_free(struct sock_cgroup_data *skcd); 809 810 static inline struct cgroup *sock_cgroup_ptr(struct sock_cgroup_data *skcd) 811 { 812 #if defined(CONFIG_CGROUP_NET_PRIO) || defined(CONFIG_CGROUP_NET_CLASSID) 813 unsigned long v; 814 815 /* 816 * @skcd->val is 64bit but the following is safe on 32bit too as we 817 * just need the lower ulong to be written and read atomically. 818 */ 819 v = READ_ONCE(skcd->val); 820 821 if (v & 1) 822 return &cgrp_dfl_root.cgrp; 823 824 return (struct cgroup *)(unsigned long)v ?: &cgrp_dfl_root.cgrp; 825 #else 826 return (struct cgroup *)(unsigned long)skcd->val; 827 #endif 828 } 829 830 #else /* CONFIG_CGROUP_DATA */ 831 832 static inline void cgroup_sk_alloc(struct sock_cgroup_data *skcd) {} 833 static inline void cgroup_sk_free(struct sock_cgroup_data *skcd) {} 834 835 #endif /* CONFIG_CGROUP_DATA */ 836 837 struct cgroup_namespace { 838 refcount_t count; 839 struct ns_common ns; 840 struct user_namespace *user_ns; 841 struct ucounts *ucounts; 842 struct css_set *root_cset; 843 }; 844 845 extern struct cgroup_namespace init_cgroup_ns; 846 847 #ifdef CONFIG_CGROUPS 848 849 void free_cgroup_ns(struct cgroup_namespace *ns); 850 851 struct cgroup_namespace *copy_cgroup_ns(unsigned long flags, 852 struct user_namespace *user_ns, 853 struct cgroup_namespace *old_ns); 854 855 int cgroup_path_ns(struct cgroup *cgrp, char *buf, size_t buflen, 856 struct cgroup_namespace *ns); 857 858 #else /* !CONFIG_CGROUPS */ 859 860 static inline void free_cgroup_ns(struct cgroup_namespace *ns) { } 861 static inline struct cgroup_namespace * 862 copy_cgroup_ns(unsigned long flags, struct user_namespace *user_ns, 863 struct cgroup_namespace *old_ns) 864 { 865 return old_ns; 866 } 867 868 #endif /* !CONFIG_CGROUPS */ 869 870 static inline void get_cgroup_ns(struct cgroup_namespace *ns) 871 { 872 if (ns) 873 refcount_inc(&ns->count); 874 } 875 876 static inline void put_cgroup_ns(struct cgroup_namespace *ns) 877 { 878 if (ns && refcount_dec_and_test(&ns->count)) 879 free_cgroup_ns(ns); 880 } 881 882 #endif /* _LINUX_CGROUP_H */ 883