kernel/cgroup/debug.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * Debug controller
0004  *
0005  * WARNING: This controller is for cgroup core debugging only.
0006  * Its interfaces are unstable and subject to changes at any time.
0007  */
0008 #include <linux/ctype.h>
0009 #include <linux/mm.h>
0010 #include <linux/slab.h>
0011
0012 #include "cgroup-internal.h"
0013
0014 static struct cgroup_subsys_state *
0015 debug_css_alloc(struct cgroup_subsys_state *parent_css)
0016 {
0017     struct cgroup_subsys_state *css = kzalloc(sizeof(*css), GFP_KERNEL);
0018
0019     if (!css)
0020         return ERR_PTR(-ENOMEM);
0021
0022     return css;
0023 }
0024
0025 static void debug_css_free(struct cgroup_subsys_state *css)
0026 {
0027     kfree(css);
0028 }
0029
0030 /*
0031  * debug_taskcount_read - return the number of tasks in a cgroup.
0032  * @cgrp: the cgroup in question
0033  */
0034 static u64 debug_taskcount_read(struct cgroup_subsys_state *css,
0035                 struct cftype *cft)
0036 {
0037     return cgroup_task_count(css->cgroup);
0038 }
0039
0040 static int current_css_set_read(struct seq_file *seq, void *v)
0041 {
0042     struct kernfs_open_file *of = seq->private;
0043     struct css_set *cset;
0044     struct cgroup_subsys *ss;
0045     struct cgroup_subsys_state *css;
0046     int i, refcnt;
0047
0048     if (!cgroup_kn_lock_live(of->kn, false))
0049         return -ENODEV;
0050
0051     spin_lock_irq(&css_set_lock);
0052     rcu_read_lock();
0053     cset = task_css_set(current);
0054     refcnt = refcount_read(&cset->refcount);
0055     seq_printf(seq, "css_set %pK %d", cset, refcnt);
0056     if (refcnt > cset->nr_tasks)
0057         seq_printf(seq, " +%d", refcnt - cset->nr_tasks);
0058     seq_puts(seq, "\n");
0059
0060     /*
0061      * Print the css'es stored in the current css_set.
0062      */
0063     for_each_subsys(ss, i) {
0064         css = cset->subsys[ss->id];
0065         if (!css)
0066             continue;
0067         seq_printf(seq, "%2d: %-4s\t- %p[%d]\n", ss->id, ss->name,
0068               css, css->id);
0069     }
0070     rcu_read_unlock();
0071     spin_unlock_irq(&css_set_lock);
0072     cgroup_kn_unlock(of->kn);
0073     return 0;
0074 }
0075
0076 static u64 current_css_set_refcount_read(struct cgroup_subsys_state *css,
0077                      struct cftype *cft)
0078 {
0079     u64 count;
0080
0081     rcu_read_lock();
0082     count = refcount_read(&task_css_set(current)->refcount);
0083     rcu_read_unlock();
0084     return count;
0085 }
0086
0087 static int current_css_set_cg_links_read(struct seq_file *seq, void *v)
0088 {
0089     struct cgrp_cset_link *link;
0090     struct css_set *cset;
0091     char *name_buf;
0092
0093     name_buf = kmalloc(NAME_MAX + 1, GFP_KERNEL);
0094     if (!name_buf)
0095         return -ENOMEM;
0096
0097     spin_lock_irq(&css_set_lock);
0098     rcu_read_lock();
0099     cset = task_css_set(current);
0100     list_for_each_entry(link, &cset->cgrp_links, cgrp_link) {
0101         struct cgroup *c = link->cgrp;
0102
0103         cgroup_name(c, name_buf, NAME_MAX + 1);
0104         seq_printf(seq, "Root %d group %s\n",
0105                c->root->hierarchy_id, name_buf);
0106     }
0107     rcu_read_unlock();
0108     spin_unlock_irq(&css_set_lock);
0109     kfree(name_buf);
0110     return 0;
0111 }
0112
0113 #define MAX_TASKS_SHOWN_PER_CSS 25
0114 static int cgroup_css_links_read(struct seq_file *seq, void *v)
0115 {
0116     struct cgroup_subsys_state *css = seq_css(seq);
0117     struct cgrp_cset_link *link;
0118     int dead_cnt = 0, extra_refs = 0, threaded_csets = 0;
0119
0120     spin_lock_irq(&css_set_lock);
0121
0122     list_for_each_entry(link, &css->cgroup->cset_links, cset_link) {
0123         struct css_set *cset = link->cset;
0124         struct task_struct *task;
0125         int count = 0;
0126         int refcnt = refcount_read(&cset->refcount);
0127
0128         /*
0129          * Print out the proc_cset and threaded_cset relationship
0130          * and highlight difference between refcount and task_count.
0131          */
0132         seq_printf(seq, "css_set %pK", cset);
0133         if (rcu_dereference_protected(cset->dom_cset, 1) != cset) {
0134             threaded_csets++;
0135             seq_printf(seq, "=>%pK", cset->dom_cset);
0136         }
0137         if (!list_empty(&cset->threaded_csets)) {
0138             struct css_set *tcset;
0139             int idx = 0;
0140
0141             list_for_each_entry(tcset, &cset->threaded_csets,
0142                         threaded_csets_node) {
0143                 seq_puts(seq, idx ? "," : "<=");
0144                 seq_printf(seq, "%pK", tcset);
0145                 idx++;
0146             }
0147         } else {
0148             seq_printf(seq, " %d", refcnt);
0149             if (refcnt - cset->nr_tasks > 0) {
0150                 int extra = refcnt - cset->nr_tasks;
0151
0152                 seq_printf(seq, " +%d", extra);
0153                 /*
0154                  * Take out the one additional reference in
0155                  * init_css_set.
0156                  */
0157                 if (cset == &init_css_set)
0158                     extra--;
0159                 extra_refs += extra;
0160             }
0161         }
0162         seq_puts(seq, "\n");
0163
0164         list_for_each_entry(task, &cset->tasks, cg_list) {
0165             if (count++ <= MAX_TASKS_SHOWN_PER_CSS)
0166                 seq_printf(seq, "  task %d\n",
0167                        task_pid_vnr(task));
0168         }
0169
0170         list_for_each_entry(task, &cset->mg_tasks, cg_list) {
0171             if (count++ <= MAX_TASKS_SHOWN_PER_CSS)
0172                 seq_printf(seq, "  task %d\n",
0173                        task_pid_vnr(task));
0174         }
0175         /* show # of overflowed tasks */
0176         if (count > MAX_TASKS_SHOWN_PER_CSS)
0177             seq_printf(seq, "  ... (%d)\n",
0178                    count - MAX_TASKS_SHOWN_PER_CSS);
0179
0180         if (cset->dead) {
0181             seq_puts(seq, "    [dead]\n");
0182             dead_cnt++;
0183         }
0184
0185         WARN_ON(count != cset->nr_tasks);
0186     }
0187     spin_unlock_irq(&css_set_lock);
0188
0189     if (!dead_cnt && !extra_refs && !threaded_csets)
0190         return 0;
0191
0192     seq_puts(seq, "\n");
0193     if (threaded_csets)
0194         seq_printf(seq, "threaded css_sets = %d\n", threaded_csets);
0195     if (extra_refs)
0196         seq_printf(seq, "extra references = %d\n", extra_refs);
0197     if (dead_cnt)
0198         seq_printf(seq, "dead css_sets = %d\n", dead_cnt);
0199
0200     return 0;
0201 }
0202
0203 static int cgroup_subsys_states_read(struct seq_file *seq, void *v)
0204 {
0205     struct kernfs_open_file *of = seq->private;
0206     struct cgroup *cgrp;
0207     struct cgroup_subsys *ss;
0208     struct cgroup_subsys_state *css;
0209     char pbuf[16];
0210     int i;
0211
0212     cgrp = cgroup_kn_lock_live(of->kn, false);
0213     if (!cgrp)
0214         return -ENODEV;
0215
0216     for_each_subsys(ss, i) {
0217         css = rcu_dereference_check(cgrp->subsys[ss->id], true);
0218         if (!css)
0219             continue;
0220
0221         pbuf[0] = '\0';
0222
0223         /* Show the parent CSS if applicable*/
0224         if (css->parent)
0225             snprintf(pbuf, sizeof(pbuf) - 1, " P=%d",
0226                  css->parent->id);
0227         seq_printf(seq, "%2d: %-4s\t- %p[%d] %d%s\n", ss->id, ss->name,
0228               css, css->id,
0229               atomic_read(&css->online_cnt), pbuf);
0230     }
0231
0232     cgroup_kn_unlock(of->kn);
0233     return 0;
0234 }
0235
0236 static void cgroup_masks_read_one(struct seq_file *seq, const char *name,
0237                   u16 mask)
0238 {
0239     struct cgroup_subsys *ss;
0240     int ssid;
0241     bool first = true;
0242
0243     seq_printf(seq, "%-17s: ", name);
0244     for_each_subsys(ss, ssid) {
0245         if (!(mask & (1 << ssid)))
0246             continue;
0247         if (!first)
0248             seq_puts(seq, ", ");
0249         seq_puts(seq, ss->name);
0250         first = false;
0251     }
0252     seq_putc(seq, '\n');
0253 }
0254
0255 static int cgroup_masks_read(struct seq_file *seq, void *v)
0256 {
0257     struct kernfs_open_file *of = seq->private;
0258     struct cgroup *cgrp;
0259
0260     cgrp = cgroup_kn_lock_live(of->kn, false);
0261     if (!cgrp)
0262         return -ENODEV;
0263
0264     cgroup_masks_read_one(seq, "subtree_control", cgrp->subtree_control);
0265     cgroup_masks_read_one(seq, "subtree_ss_mask", cgrp->subtree_ss_mask);
0266
0267     cgroup_kn_unlock(of->kn);
0268     return 0;
0269 }
0270
0271 static u64 releasable_read(struct cgroup_subsys_state *css, struct cftype *cft)
0272 {
0273     return (!cgroup_is_populated(css->cgroup) &&
0274         !css_has_online_children(&css->cgroup->self));
0275 }
0276
0277 static struct cftype debug_legacy_files[] =  {
0278     {
0279         .name = "taskcount",
0280         .read_u64 = debug_taskcount_read,
0281     },
0282
0283     {
0284         .name = "current_css_set",
0285         .seq_show = current_css_set_read,
0286         .flags = CFTYPE_ONLY_ON_ROOT,
0287     },
0288
0289     {
0290         .name = "current_css_set_refcount",
0291         .read_u64 = current_css_set_refcount_read,
0292         .flags = CFTYPE_ONLY_ON_ROOT,
0293     },
0294
0295     {
0296         .name = "current_css_set_cg_links",
0297         .seq_show = current_css_set_cg_links_read,
0298         .flags = CFTYPE_ONLY_ON_ROOT,
0299     },
0300
0301     {
0302         .name = "cgroup_css_links",
0303         .seq_show = cgroup_css_links_read,
0304     },
0305
0306     {
0307         .name = "cgroup_subsys_states",
0308         .seq_show = cgroup_subsys_states_read,
0309     },
0310
0311     {
0312         .name = "cgroup_masks",
0313         .seq_show = cgroup_masks_read,
0314     },
0315
0316     {
0317         .name = "releasable",
0318         .read_u64 = releasable_read,
0319     },
0320
0321     { } /* terminate */
0322 };
0323
0324 static struct cftype debug_files[] =  {
0325     {
0326         .name = "taskcount",
0327         .read_u64 = debug_taskcount_read,
0328     },
0329
0330     {
0331         .name = "current_css_set",
0332         .seq_show = current_css_set_read,
0333         .flags = CFTYPE_ONLY_ON_ROOT,
0334     },
0335
0336     {
0337         .name = "current_css_set_refcount",
0338         .read_u64 = current_css_set_refcount_read,
0339         .flags = CFTYPE_ONLY_ON_ROOT,
0340     },
0341
0342     {
0343         .name = "current_css_set_cg_links",
0344         .seq_show = current_css_set_cg_links_read,
0345         .flags = CFTYPE_ONLY_ON_ROOT,
0346     },
0347
0348     {
0349         .name = "css_links",
0350         .seq_show = cgroup_css_links_read,
0351     },
0352
0353     {
0354         .name = "csses",
0355         .seq_show = cgroup_subsys_states_read,
0356     },
0357
0358     {
0359         .name = "masks",
0360         .seq_show = cgroup_masks_read,
0361     },
0362
0363     { } /* terminate */
0364 };
0365
0366 struct cgroup_subsys debug_cgrp_subsys = {
0367     .css_alloc  = debug_css_alloc,
0368     .css_free   = debug_css_free,
0369     .legacy_cftypes = debug_legacy_files,
0370 };
0371
0372 /*
0373  * On v2, debug is an implicit controller enabled by "cgroup_debug" boot
0374  * parameter.
0375  */
0376 void __init enable_debug_cgroup(void)
0377 {
0378     debug_cgrp_subsys.dfl_cftypes = debug_files;
0379     debug_cgrp_subsys.implicit_on_dfl = true;
0380     debug_cgrp_subsys.threaded = true;
0381 }