Add debug fs to intel_cmt to help maintenance. It shows the following human readable snapshots of the internals of the CMT driver: - hrchy: A per monr view of the monr hierarchy. - pkgs: A per-package view of all online struct pkg_data. - rmids: A per-package view of occupancy and state of all rmids.
Signed-off-by: David Carrillo-Cisneros <[email protected]> --- arch/x86/events/intel/cmt.c | 385 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 385 insertions(+) diff --git a/arch/x86/events/intel/cmt.c b/arch/x86/events/intel/cmt.c index 8cbcbc6..554ebd2 100644 --- a/arch/x86/events/intel/cmt.c +++ b/arch/x86/events/intel/cmt.c @@ -2372,6 +2372,376 @@ static ssize_t max_recycle_threshold_store(struct device *dev, static DEVICE_ATTR_RW(max_recycle_threshold); + +#define INTEL_CMT_DEBUGFS + +#ifdef INTEL_CMT_DEBUGFS + +#include <linux/debugfs.h> + +#define DBG_PRINTF(format__, ...) \ + seq_printf(s, "%*s" format__, 4 * pad, "", ##__VA_ARGS__) + +static void cmt_dbg_show__pmonr(struct seq_file *s, + struct pmonr *pmonr, + int pad) +{ + struct pmonr *pos; + union pmonr_rmids rmids; + static const char * const state_strs[] = {"OFF", "UNUSED", "ACTIVE", + "DEP_IDLE", "DEP_DIRTY"}; + + DBG_PRINTF("pmonr: (%p, pkgid: %d, monr: %p)\n", + pmonr, pmonr->pkgd->pkgid, pmonr->monr); + pad++; + + rmids.value = atomic64_read(&pmonr->atomic_rmids); + DBG_PRINTF("atomic_rmids: (%d,%d), state: %s, lender: %p\n", + rmids.sched_rmid, rmids.read_rmid, + state_strs[pmonr->state], pmonr->lender); + + if (pmonr->state == PMONR_ACTIVE) { + DBG_PRINTF("pmonr_deps_head:"); + list_for_each_entry(pos, &pmonr->pmonr_deps_head, + pmonr_deps_entry) { + seq_printf(s, "%p,", pos); + } + seq_puts(s, "\n"); + } + + DBG_PRINTF("last_enter_active: %lu\n", + atomic64_read(&pmonr->last_enter_active)); + +} + +static void cmt_dbg_show__monr(struct seq_file *s, struct monr *monr, int pad) +{ + struct pkg_data *pkgd = NULL; + struct monr *pos; + struct pmonr *pmonr; + int p; + + DBG_PRINTF("\nmonr: %p, parent: %p\n", monr, monr->parent); + + pad++; + + DBG_PRINTF("children: ["); + + + list_for_each_entry(pos, &monr->children, parent_entry) + seq_printf(s, "%p, ", pos); + + seq_puts(s, "]\n"); + + DBG_PRINTF("mon_cgrp: (%s, %p)", + monr->mon_cgrp ? monr->mon_cgrp->css.cgroup->kn->name : "NA", + monr->mon_cgrp); + DBG_PRINTF("mon_events: %p\n", monr->mon_events); + + DBG_PRINTF("pmonrs:\n"); + rcu_read_lock(); + while ((pkgd = cmt_pkgs_data_next_rcu(pkgd))) { + pmonr = pkgd_pmonr(pkgd, monr); + cmt_dbg_show__pmonr(s, pmonr, pad + 1); + } + rcu_read_unlock(); + + DBG_PRINTF("last_rmid_recoup: %lu, nr_dep_pmonrs: %u, flags: %x\n", + atomic64_read(&monr->last_rmid_recoup), + atomic_read(&monr->nr_dep_pmonrs), monr->flags); + DBG_PRINTF("nr_has_user: %d, nr_nosteal_rmid: %d,", + monr->nr_has_user, monr->nr_nosteal_rmid); + DBG_PRINTF("nr_nolazy_rmid: %d, uflags: %x\n", + monr->nr_nolazy_rmid, monr->uflags); + DBG_PRINTF("pkg_uflags: ["); + for (p = 0; p < topology_max_packages(); p++) + seq_printf(s, "%x;", monr->pkg_uflags[p]); + seq_puts(s, "]\n"); +} + + +static void cmt_dbg_show__pkgd(struct seq_file *s, + struct pkg_data *pkgd, int pad, bool csd_full) +{ + struct pmonr *pmonr; + unsigned long flags; + int r; + + raw_spin_lock_irqsave(&pkgd->lock, flags); + + DBG_PRINTF("\npkgd: %p, pkgid: %d, max_rmid: %d\n", + pkgd, pkgd->pkgid, pkgd->max_rmid); + pad++; + + DBG_PRINTF("free_rmids: [%*pbl]\n", + CMT_MAX_NR_RMIDS, pkgd->free_rmids); + DBG_PRINTF("dirty_rmids: [%*pbl]\n", + CMT_MAX_NR_RMIDS, pkgd->dirty_rmids); + + DBG_PRINTF("active_pmonrs:\n"); + list_for_each_entry(pmonr, &pkgd->active_pmonrs, rot_entry) + cmt_dbg_show__pmonr(s, pmonr, pad + 1); + + DBG_PRINTF("dep_idle_pmonrs:\n"); + list_for_each_entry(pmonr, &pkgd->dep_idle_pmonrs, rot_entry) + cmt_dbg_show__pmonr(s, pmonr, pad + 1); + + DBG_PRINTF("dep_dirty_pmonrs:\n"); + list_for_each_entry(pmonr, &pkgd->dep_dirty_pmonrs, rot_entry) + cmt_dbg_show__pmonr(s, pmonr, pad + 1); + /* + * only print pmonr pointer since this pmonrs are contained in either + * Dep_Idle or Dep_Dirty pmonrs. + */ + DBG_PRINTF("dep_pmonrs: ["); + list_for_each_entry(pmonr, &pkgd->dep_pmonrs, pkgd_deps_entry) + seq_printf(s, "%p,", pmonr); + seq_puts(s, "]\n"); + + DBG_PRINTF("nr_dirty_rmids: %d, nr_dep_pmonrs: %d\n", + pkgd->nr_dirty_rmids, pkgd->nr_dep_pmonrs); + + DBG_PRINTF("work_cpu: %d\n", pkgd->work_cpu); + + DBG_PRINTF("ccsds ("); + if (csd_full) + seq_puts(s, "flags, info, func, "); + seq_puts(s, "on_read, value, ret, rmid): ["); + + pad += 1; + for (r = 0; r <= pkgd->max_rmid; r++) { + struct cmt_csd *ccsd = &pkgd->ccsds[r]; + + if (r % 4 == 0) { + seq_puts(s, "\n"); + DBG_PRINTF("("); + } else { + seq_puts(s, "("); + } + + if (csd_full) { + seq_printf(s, "%d, %p, %p, ", ccsd->csd.flags, + ccsd->csd.info, ccsd->csd.func); + } + seq_printf(s, "%d, %llu, %d, %d", + atomic_read(&ccsd->on_read), ccsd->value, + ccsd->ret, ccsd->rmid); + seq_puts(s, "),\t"); + } + seq_puts(s, "]"); + pad -= 1; + + raw_spin_unlock_irqrestore(&pkgd->lock, flags); +} + +static int cmt_dbg_pkgs_show(struct seq_file *s, void *unused) +{ + struct pkg_data *pkgd = NULL; + int pad = 0; + + mutex_lock(&cmt_mutex); + + while ((pkgd = cmt_pkgs_data_next_rcu(pkgd))) { + cmt_dbg_show__pkgd(s, pkgd, pad, false); + seq_puts(s, "\n"); + } + + mutex_unlock(&cmt_mutex); + + return 0; +} + +static int cmt_dbg_hrchy_show(struct seq_file *s, void *unused) +{ + struct monr *pos = NULL; + int pad = 0; + + mutex_lock(&cmt_mutex); + while ((pos = monr_next_descendant_pre(pos, monr_hrchy_root))) + cmt_dbg_show__monr(s, pos, pad); + mutex_unlock(&cmt_mutex); + + return 0; +} + +/* Must run on a CPU in pkgd's pkg. */ +static int cmt_dbg_rmids__rmids(struct seq_file *s, struct pkg_data *pkgd, + unsigned long *rmids, int pad) +{ + unsigned long zero_val[CMT_MAX_NR_RMIDS_LONGS]; + int err, r, nr_printed = 0; + u64 val; + + bitmap_copy(zero_val, rmids, CMT_MAX_NR_RMIDS); + + DBG_PRINTF("non-zero value (rmid, scaled llc_occupancy): ["); + pad++; + for_each_set_bit(r, rmids, CMT_MAX_NR_RMIDS) { + err = cmt_rmid_read(r, &val); + if (!err && !val) + continue; + + if (nr_printed % 4 == 0) { + seq_puts(s, "\n"); + DBG_PRINTF("("); + } else { + seq_puts(s, "("); + } + nr_printed++; + + if (err) { + seq_printf(s, "%d, error: %d),\t", r, err); + __clear_bit(r, zero_val); + continue; + } + seq_printf(s, "%d, %llu), ", r, val * cmt_l3_scale); + __clear_bit(r, zero_val); + } + seq_puts(s, "]\n"); + pad--; + + DBG_PRINTF("zero value: [%*pbl]\n", CMT_MAX_NR_RMIDS, zero_val); + + return 0; +} + +static int __cmt_dbg_rmids__pkgd(struct seq_file *s, + struct pkg_data *pkgd, int pad) +{ + unsigned long rmids_in_pmonr[CMT_MAX_NR_RMIDS_LONGS]; + int r; + + memset(rmids_in_pmonr, 0, CMT_MAX_NR_RMIDS_BYTES); + bitmap_fill(rmids_in_pmonr, pkgd->max_rmid + 1); + + for_each_set_bit(r, pkgd->free_rmids, CMT_MAX_NR_RMIDS) + __clear_bit(r, rmids_in_pmonr); + + for_each_set_bit(r, pkgd->dirty_rmids, CMT_MAX_NR_RMIDS) + __clear_bit(r, rmids_in_pmonr); + + + raw_spin_lock(&pkgd->lock); + + DBG_PRINTF("free_rmids:\n"); + cmt_dbg_rmids__rmids(s, pkgd, pkgd->free_rmids, pad + 1); + + DBG_PRINTF("dirty_rmids:\n"); + cmt_dbg_rmids__rmids(s, pkgd, pkgd->dirty_rmids, pad + 1); + + DBG_PRINTF("rmids_in_pmonr:\n"); + cmt_dbg_rmids__rmids(s, pkgd, rmids_in_pmonr, pad + 1); + + raw_spin_unlock(&pkgd->lock); + + return 0; +} + +struct dbg_smp_data { + struct seq_file *s; + struct pkg_data *pkgd; + int pad; +}; + +void cmt_dbg_rmids_pkgd(void *data) +{ + struct dbg_smp_data *d; + + d = (struct dbg_smp_data *)data; + __cmt_dbg_rmids__pkgd(d->s, d->pkgd, d->pad); +} + +static int cmt_dbg_rmids_show(struct seq_file *s, void *unused) +{ + struct dbg_smp_data d; + struct pkg_data *pkgd = NULL; + int pad = 0, err; + + mutex_lock(&cmt_mutex); + + while ((pkgd = cmt_pkgs_data_next_rcu(pkgd))) { + DBG_PRINTF("pkgid: %d\n", pkgd->pkgid); + d.s = s; + d.pkgd = pkgd; + d.pad = pad + 1; + err = smp_call_function_single(pkgd->work_cpu, + cmt_dbg_rmids_pkgd, &d, true); + seq_puts(s, "\n"); + } + + mutex_unlock(&cmt_mutex); + + return 0; + +} + +#define CMT_DBGS_FILE(name__) \ +static int cmt_dbg_ ## name__ ## _open(struct inode *inode, struct file *file)\ +{\ + return single_open(file, cmt_dbg_ ## name__ ## _show,\ + inode->i_private);\ +} \ +static const struct file_operations cmt_dbg_ ## name__ ## _ops = {\ + .open = cmt_dbg_ ## name__ ## _open,\ + .read = seq_read,\ + .llseek = seq_lseek,\ + .release = single_release,\ +} + +CMT_DBGS_FILE(hrchy); +CMT_DBGS_FILE(pkgs); +CMT_DBGS_FILE(rmids); + +struct dentry *cmt_dbgfs_root; + +static int start_debugfs(void) +{ + struct dentry *root, *pkgs, *hrchy, *rmids; + + root = debugfs_create_dir("intel_cmt", NULL); + if (IS_ERR(root)) + return PTR_ERR(root); + + pkgs = debugfs_create_file("pkgs", 0444, + root, NULL, &cmt_dbg_pkgs_ops); + if (IS_ERR(pkgs)) + return PTR_ERR(pkgs); + + hrchy = debugfs_create_file("hrchy", 0444, + root, NULL, &cmt_dbg_hrchy_ops); + if (IS_ERR(hrchy)) + return PTR_ERR(hrchy); + + rmids = debugfs_create_file("rmids", 0444, + root, NULL, &cmt_dbg_rmids_ops); + if (IS_ERR(rmids)) + return PTR_ERR(rmids); + + cmt_dbgfs_root = root; + + return 0; +} + +static void stop_debugfs(void) +{ + if (!cmt_dbgfs_root) + return; + debugfs_remove_recursive(cmt_dbgfs_root); + cmt_dbgfs_root = NULL; +} + +#else + +static int start_debugfs(void) +{ +} + +static void stop_debugfs(void) +{ +} + +#endif + static struct attribute *intel_cmt_attrs[] = { &dev_attr_max_recycle_threshold.attr, NULL, @@ -2774,6 +3144,15 @@ static void cmt_stop(void) mutex_unlock(&cmt_mutex); } +static void intel_cmt_terminate(void) +{ + stop_debugfs(); + static_branch_dec(&pqr_common_enable_key); + perf_pmu_unregister(&intel_cmt_pmu); + cmt_stop(); + cmt_dealloc(); +} + static int __init cmt_alloc(void) { pkg_uflags_size = sizeof(*pkg_uflags_zeroes) * topology_max_packages(); @@ -2904,6 +3283,12 @@ static int __init intel_cmt_init(void) static_branch_inc(&pqr_common_enable_key); + err = start_debugfs(); + if (err) { + intel_cmt_terminate(); + goto err_exit; + } + return err; err_stop: -- 2.8.0.rc3.226.g39d4020
