This patch adds a new cgroup helper cgroup_freeze_no_kn() to freeze a cgroup hierarchy that is on a default cgroup v2 without going through kernfs interface.
For some cases we want to freeze the cgroup of a task based on some signals, doing so from bpf is better than user space which could be too late.
The cgroup_freeze_no_kn() will acquire the cgroup_mutex and release it at the end.
It also checks if the cgroup is on the default hierarchy and it is not a root cgroup.
Signed-off-by: Djalal Harouni tixxdz@gmail.com --- include/linux/cgroup.h | 2 ++ kernel/cgroup/cgroup.c | 69 ++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 71 insertions(+)
diff --git a/include/linux/cgroup.h b/include/linux/cgroup.h index 34aaf0e87def..5019b32ea933 100644 --- a/include/linux/cgroup.h +++ b/include/linux/cgroup.h @@ -137,6 +137,8 @@ int cgroup_init(void);
int cgroup_parse_float(const char *input, unsigned dec_shift, s64 *v);
+int cgroup_freeze_no_kn(struct cgroup *cgrp, int freeze); + /* * Iteration helpers and macros. */ diff --git a/kernel/cgroup/cgroup.c b/kernel/cgroup/cgroup.c index a66c088c851c..0aafcd9e39b5 100644 --- a/kernel/cgroup/cgroup.c +++ b/kernel/cgroup/cgroup.c @@ -1595,6 +1595,26 @@ static u16 cgroup_calc_subtree_ss_mask(u16 subtree_control, u16 this_ss_mask) return cur_ss_mask; }
+/** + * cgroup_dfl_write_no_kn - check if direct writes to cgroup without going + * through kernfs is allowed. + * @cgrp: the target cgroup + * + * This helper ensures that the cgroup is on the default hierarchy and it + * is not a root cgroup. + * + * Return: %0 on success or a negative errno code on failure. + */ +static int cgroup_dfl_write_no_kn(struct cgroup *cgrp) +{ + lockdep_assert_held(&cgroup_mutex); + + if (!cgroup_on_dfl(cgrp) || !cgroup_parent(cgrp)) + return -EOPNOTSUPP; + + return 0; +} + /** * cgroup_kn_unlock - unlocking helper for cgroup kernfs methods * @kn: the kernfs_node being serviced @@ -1668,6 +1688,25 @@ struct cgroup *cgroup_kn_lock_live(struct kernfs_node *kn, bool drain_offline) return NULL; }
+/** + * cgroup_lock_live_no_kn - locking helper for direct writes to cgroup without + * going through kernfs interface. + * @cgrp: the target cgroup + * + * This helper performs cgroup locking and verifies that the associated cgroup + * is alive. Returns the cgroup if alive; otherwise, %NULL. + * A successful return should be undone by a matching cgroup_unlock() + * invocation. + */ +static struct cgroup *cgroup_lock_live_no_kn(struct cgroup *cgrp) +{ + cgroup_lock(); + if (!cgroup_is_dead(cgrp)) + return cgrp; + cgroup_unlock(); + return NULL; +} + static void cgroup_rm_file(struct cgroup *cgrp, const struct cftype *cft) { char name[CGROUP_FILE_NAME_MAX]; @@ -3930,6 +3969,36 @@ static int cgroup_freeze_show(struct seq_file *seq, void *v) return 0; }
+/** + * cgroup_freeze_no_kn - Freeze a cgroup that is on the default hierarchy + * without going through kernfs interface. + * + * @cgrp: the target cgroup + * @freeze: freeze state, passing value 1 causes the freezing of the cgroup + * and all descendant cgroups. Processes under this cgroup hierarchy will + * be stopped and will not run until the cgroup is explicitly unfrozen. + * Passing value 0 unthaws the cgroup hierarchy. + * + * Return: %0 on success or a negative errno code on failure. + */ +int cgroup_freeze_no_kn(struct cgroup *cgrp, int freeze) +{ + int ret = 0; + + if (freeze < 0 || freeze > 1) + return -ERANGE; + + if (!cgroup_lock_live_no_kn(cgrp)) + return -ENOENT; + + ret = cgroup_dfl_write_no_kn(cgrp); + if (!ret) + cgroup_freeze(cgrp, freeze); + + cgroup_unlock(); + return ret; +} + static ssize_t cgroup_freeze_write(struct kernfs_open_file *of, char *buf, size_t nbytes, loff_t off) {