cgroup/pids: Add pids.events.local

Hierarchical counting of events is not practical for watching when a
particular pids.max is being hit. Therefore introduce .local flavor of
events file (akin to memory controller) that collects only events
relevant to given cgroup.

The file is only added to the default hierarchy.

Signed-off-by: Michal Koutný <mkoutny@suse.com>
Signed-off-by: Tejun Heo <tj@kernel.org>

diff --git a/Documentation/admin-guide/cgroup-v2.rst b/Documentation/admin-guide/cgroup-v2.rst
index c8390baef90b9e4595c1ca212b3e186d5934cdf0..f886c6ad704e025017dbe506300201d75fbb7527 100644 (file)
--- a/Documentation/admin-guide/cgroup-v2.rst
+++ b/Documentation/admin-guide/cgroup-v2.rst
@@ -2220,6 +2220,11 @@ PID Interface Files
                The number of times the cgroup's total number of processes hit the pids.max
                limit (see also pids_localevents).
 
+  pids.events.local
+       Similar to pids.events but the fields in the file are local
+       to the cgroup i.e. not hierarchical. The file modified event
+       generated on this file reflects only the local events.
+
 Organisational operations are not blocked by cgroup policies, so it is
 possible to have pids.current > pids.max.  This can be done by either
 setting the limit to be smaller than pids.current, or attaching enough

diff --git a/kernel/cgroup/pids.c b/kernel/cgroup/pids.c
index c09b744d548c46f8499e8f9607d7f43f579f77a6..f5cb0ec45b9ddee9a7a3ce3bd85ab4161a2abbc5 100644 (file)
--- a/kernel/cgroup/pids.c
+++ b/kernel/cgroup/pids.c
@@ -57,10 +57,12 @@ struct pids_cgroup {
        atomic64_t                      limit;
        int64_t                         watermark;
 
-       /* Handle for "pids.events" */
+       /* Handles for pids.events[.local] */
        struct cgroup_file              events_file;
+       struct cgroup_file              events_local_file;
 
        atomic64_t                      events[NR_PIDCG_EVENTS];
+       atomic64_t                      events_local[NR_PIDCG_EVENTS];
 };
 
 static struct pids_cgroup *css_pids(struct cgroup_subsys_state *css)
@@ -244,21 +246,23 @@ static void pids_event(struct pids_cgroup *pids_forking,
        struct pids_cgroup *p = pids_forking;
        bool limit = false;
 
-       for (; parent_pids(p); p = parent_pids(p)) {
-               /* Only log the first time limit is hit. */
-               if (atomic64_inc_return(&p->events[PIDCG_FORKFAIL]) == 1) {
-                       pr_info("cgroup: fork rejected by pids controller in ");
-                       pr_cont_cgroup_path(p->css.cgroup);
-                       pr_cont("\n");
-               }
-               cgroup_file_notify(&p->events_file);
-
-               if (!cgroup_subsys_on_dfl(pids_cgrp_subsys) ||
-                   cgrp_dfl_root.flags & CGRP_ROOT_PIDS_LOCAL_EVENTS)
-                       break;
+       /* Only log the first time limit is hit. */
+       if (atomic64_inc_return(&p->events_local[PIDCG_FORKFAIL]) == 1) {
+               pr_info("cgroup: fork rejected by pids controller in ");
+               pr_cont_cgroup_path(p->css.cgroup);
+               pr_cont("\n");
+       }
+       cgroup_file_notify(&p->events_local_file);
+       if (!cgroup_subsys_on_dfl(pids_cgrp_subsys) ||
+           cgrp_dfl_root.flags & CGRP_ROOT_PIDS_LOCAL_EVENTS)
+               return;
 
-               if (p == pids_over_limit)
+       for (; parent_pids(p); p = parent_pids(p)) {
+               if (p == pids_over_limit) {
                        limit = true;
+                       atomic64_inc(&p->events_local[PIDCG_MAX]);
+                       cgroup_file_notify(&p->events_local_file);
+               }
                if (limit)
                        atomic64_inc(&p->events[PIDCG_MAX]);
 
@@ -368,20 +372,68 @@ static s64 pids_peak_read(struct cgroup_subsys_state *css,
        return READ_ONCE(pids->watermark);
 }
 
-static int pids_events_show(struct seq_file *sf, void *v)
+static int __pids_events_show(struct seq_file *sf, bool local)
 {
        struct pids_cgroup *pids = css_pids(seq_css(sf));
        enum pidcg_event pe = PIDCG_MAX;
+       atomic64_t *events;
 
        if (!cgroup_subsys_on_dfl(pids_cgrp_subsys) ||
-           cgrp_dfl_root.flags & CGRP_ROOT_PIDS_LOCAL_EVENTS)
+           cgrp_dfl_root.flags & CGRP_ROOT_PIDS_LOCAL_EVENTS) {
                pe = PIDCG_FORKFAIL;
+               local = true;
+       }
+       events = local ? pids->events_local : pids->events;
 
-       seq_printf(sf, "max %lld\n", (s64)atomic64_read(&pids->events[pe]));
+       seq_printf(sf, "max %lld\n", (s64)atomic64_read(&events[pe]));
+       return 0;
+}
+
+static int pids_events_show(struct seq_file *sf, void *v)
+{
+       __pids_events_show(sf, false);
+       return 0;
+}
+
+static int pids_events_local_show(struct seq_file *sf, void *v)
+{
+       __pids_events_show(sf, true);
        return 0;
 }
 
 static struct cftype pids_files[] = {
+       {
+               .name = "max",
+               .write = pids_max_write,
+               .seq_show = pids_max_show,
+               .flags = CFTYPE_NOT_ON_ROOT,
+       },
+       {
+               .name = "current",
+               .read_s64 = pids_current_read,
+               .flags = CFTYPE_NOT_ON_ROOT,
+       },
+       {
+               .name = "peak",
+               .flags = CFTYPE_NOT_ON_ROOT,
+               .read_s64 = pids_peak_read,
+       },
+       {
+               .name = "events",
+               .seq_show = pids_events_show,
+               .file_offset = offsetof(struct pids_cgroup, events_file),
+               .flags = CFTYPE_NOT_ON_ROOT,
+       },
+       {
+               .name = "events.local",
+               .seq_show = pids_events_local_show,
+               .file_offset = offsetof(struct pids_cgroup, events_local_file),
+               .flags = CFTYPE_NOT_ON_ROOT,
+       },
+       { }     /* terminate */
+};
+
+static struct cftype pids_files_legacy[] = {
        {
                .name = "max",
                .write = pids_max_write,
@@ -407,6 +459,7 @@ static struct cftype pids_files[] = {
        { }     /* terminate */
 };
 
+
 struct cgroup_subsys pids_cgrp_subsys = {
        .css_alloc      = pids_css_alloc,
        .css_free       = pids_css_free,
@@ -415,7 +468,7 @@ struct cgroup_subsys pids_cgrp_subsys = {
        .can_fork       = pids_can_fork,
        .cancel_fork    = pids_cancel_fork,
        .release        = pids_release,
-       .legacy_cftypes = pids_files,
+       .legacy_cftypes = pids_files_legacy,
        .dfl_cftypes    = pids_files,
        .threaded       = true,
 };