扩展阅读：perf 后端：硬件 PMU（上）
0. 目录
4.3.2 my_sys_perf_event_open4.3.3 intel_pmu_hw_config4.4.1 my_perf_event_enable4.4.2 x86_assign_hw_event4.4.3 intel_pmu_enable_event1. 综述
《[perf 2] perf 后端：硬件 PMU（上）》一文，我们讨论了 PMU 硬件的基本使用范式，架构相关的概念，以及寄存器层面的基本操作及编程。本文在上文基础上进行编码实践，目的是展示 Intel x86 架构下硬件 PMU 的编程操作，并从实践中提炼 perf 框架所面临和要解决的问题。本文在 4.9 内核、skylake 超线程平台上编写一个内核模块，模块的功能是使用硬件 PMU 采集相应事件。本文代码与 OS、处理器平台关系不是很大，可以移植到其他平台。阅读本文之前，强烈建议先阅读《[perf 2] perf 后端：硬件 PMU（上）》。本文所有代码在第 7 章附录中，读者自行编译成内核模块运行验证（请不要直接在生产环境中干这事）。2. 事件设计
本文通过硬件 PMU，采集 CPU 3 上的 'Instruction Retired' 及 'UnHalted Core Cycles' 事件。之所以选择此二者事件，是因为这二者不仅可以通过 generic PMC（指定 umask + eventsel 的方式）采集，亦可通过 fixed PMC 采集，如此我们可以同时利用两种 PMC 来对此二者事件进行监控，通过相互对比采集的事件数值确认程序的正确性（符合预期的情况是，两种 PMC 采集出来的事件数值几乎相等）。根据 Intel SDM Chapter 18 "Performance Monitoring"，此二者事件是 architecture 的。所谓 architecture，指的是在不同架构之间皆相同，其反义词是 model specific。'Instruction Retired' 事件的 umask 和 eventsel 分别是 00H 和 C0H；'UnHalted Core Cycles' 事件的 umask 和 eventsel 分别是 00H 和 3CH：同时，此二者还可以通过第 0 和 第 1 个 fixed PMC 采集：若要查询非 architecture 事件的 umask、eventsel，自行参阅 Intel SDM 19 "Performance Monitoring Events"，不在本文话题范围内。3. 编码设计
按说事件设计好，知道怎么用内核接口做 MSR 读写、发起 smp_call 以及起 hrtimer，基本上就可以开干了。但为了让代码看起来不是这么的 naive，我们稍微做一点点设计。3.1 PMC ID 编码空间划分
如你所知，generic PMC 和 fixed PMC，在实际编程中都是通过 ID 来索引的，也就是第几个 generic/fixed PMC。而此二者 ID 编码都是从 0 开始。为了不让二者的 ID 编码混淆，我们对这二者 PMC 的 ID 做编码空间划分。根据《[perf 2] perf 后端：硬件 PMU（上）》“4.3 PMU 的配置及使能”一节，“至少从目前的 Intel CPU 设计来说，其为 generic PMC 预留的数量为 32”，一个合理的编码空间划分方案如下：- 0 - 31：用于 generic PMC 的 ID 编码。
- 32 - ：用于 fixed PMC 的 ID 编码。
我们参考内核的实现，这里将 32 这个魔术字定义为宏：#define INTEL_PMC_IDX_FIXED 32
所以，编码为 32 的 fixed PMC，对应的是第 0 个 fixed PMC，以此类推。3.2 PMU 抽象
数据结构如下（之所以加个 my_ 前缀，是因为内核中也有 x86_pmu 的数据结构，虽然本人很反感 my_ 前缀的 naming，但先将就着。下文的数据结构同理。）：struct my_x86_pmu { int version; unsigned eventsel; unsigned perfctr; int num_counters; int num_counters_fixed; int cntval_bits; int (*rdpmc_index)(int index); void (*enable)(struct my_perf_event *); void (*disable)(struct my_perf_event *); void (*read)(struct my_perf_event *event); void (*hw_config)(struct my_perf_event *event);};
- eventsel：PMU IA32_PERFEVTSELx 寄存器起始地址。实际上，eventsel 是寄存器组，起始地址为 186H，一个 IA32_PERFEVTSELx 对应一个 generic PMC，用于对此 generic PMC 进行配置。
- perfctl：PMU 的 IA32_PMCx 寄存器起始地址。实际上，perfctl 是一个寄存器组，起始地址为 0C1H，可以通过 IA32_PMCx 读出一个 generic PMC 的数值（本文采用与内核相同的方式，使用 RDPMC 指令，而不是从 IA32_PMCx 中读取）。
- num_counters：generic PMC 数量。
- num_counters_fixed：fixed PMC 数量。
- cntval_bits：PMC 数据读出宽度。不同 PMU 实现，其 PMC 数据宽度可能是 48 bit 或其他，但内核的 perf 框架侧，会统一将其转成 64 bit 输出，方法是符号扩展，具体符号扩展算法需要依赖 PMC 的实际数据宽度，也就是 cntval_bits。
- rdpmc_index：如前文所言，内核 perf 框架中读取 PMC 数据时，使用的是 RDPMC 指令，此指令需要传入一个 index，rdpmc_index 函数将 PMC 的 ID 转成 RDPMC 指令所需的 index。实际上，此函数并未实现，Intel 平台下，读取 generic PMC 数值的 RDPMC index 参数，就是此 PMC 的 ID。fixed PMC index 的计算略有不同，参考下文“4.4.2 x86_assign_hw_event”一节。
- enable/disable/read：使能、禁能、读取一个 event。
- hw_config：此函数获取一个事件在寄存器层面的配置，参考下文“4.3.3 intel_pmu_hw_config”一节。
3.3 事件抽象
3.3.1 业务层抽象
所谓的业务层，指的是用户通过 perf 前端接口传进来的事件属性。struct my_perf_event_attr { u64 config;};
struct my_perf_event { local64_t count; struct my_perf_event_attr attr; struct my_hw_perf_event hw;};
- my_perf_event_attr.config：这是业务层传入的事件属性，是业务层语义，注意与下一小节中硬件层抽象 config 的区别。
- count：该事件的具体数值，用户读取一个事件的具体数值时，返回的就是这个值，参考下文“4.5 事件读取”一节。
- hw：一个业务层的事件，其具体采集任务需要一个具体的硬件 PMC，struct my_hw_perf_event 即是对硬件 PMC 的抽象。参考下一小节。
3.3.2 硬件层抽象
struct my_hw_perf_event { struct { u64 config; unsigned long config_base; unsigned long event_base; int event_base_rdpmc; int idx; };
local64_t prev_count;};
- config：事件的硬件层配置，对应一个 PMC 配置寄存器的配置，比如是否使能用户态（USER）下的事件采集。
- config_base：此 PMC 的配置寄存器，对于 generic PMC，其是 IA32_PERFEVTSELx，对于 fixed PMC，其是 IA32_FIXED_CTR_CTRL 。
- event_base：此 PMC 的读数寄存器，对于 generic PMC，其是 IA32_PMCx，对于 fixed PMC，其是 IA32_FIXED_CTRx。
- event_base_rdpmc：使用 RDPMC 指令读取此 PMC 数值时，应该传入的 index 参数。
- idx：此 PMC 的 ID 编码，注意，这是经过 ID 编码空间划分后的 ID。
- prev_count：上一次从该 PMC 读出的事件计数值。
3.4 设计大图
4. 工程实践
4.1 模型
代码的模型，是在一个 kthread 中，监控 3 号 CPU 的 instruction 和 cycles 事件，并同时采用 generic 和 fixed PMC 两种方案：static int test_loop(void *__){ unsigned long long prev_count[4] = { 0 }, now_count[4]; struct my_perf_event events[4]; int target_cpu = 3, i;
my_perf_event_init(&events[0], 0x00, 0xc0, 2, false); my_perf_event_init(&events[1], 0x00, 0x3c, 3, false);
my_perf_event_init(&events[2], 0x00, 0xc0, 0, true); my_perf_event_init(&events[3], 0x00, 0x3c, 1, true);
for (i = 0; i < ARRAY_SIZE(events); ++i) my_perf_event_enable(target_cpu, &events[i]);
for (i = 0; i < ARRAY_SIZE(events); ++i) prev_count[i] = my_perf_event_read(target_cpu, &events[i]);
while (!kthread_should_stop()) { for (i = 0; i < ARRAY_SIZE(events); ++i) { now_count[i] = my_perf_event_read(target_cpu, &events[i]); printk("event %d: %llu\n", i, now_count[i] - prev_count[i]); prev_count[i] = now_count[i]; }
msleep_interruptible(5000); }
for (i = 0; i < ARRAY_SIZE(events); ++i) my_perf_event_disable(target_cpu, &events[i]); return 0;}
static int __init test_module_init(void){ intel_pmu_init(); loop_task = kthread_run(test_loop, NULL, "test_loop");
return 0;}
static void __exit test_module_exit(void){ kthread_stop(loop_task);}
- 事件初始化（7 - 15 行）：调用 my_perf_event_init 接口初始化四个 PMC 监控事件，前两个采用 generic PMC 来监控，后两个采用 fixed PMC 来监控。
- 事件使能（17 - 18 行）：调用 my_perf_event_enable 接口使能上一步初始化的四个事件。
- 事件初始值读取（20 - 21 行）：调用 my_perf_event_read 接口读出四个事件的初始值。注意，PMC 第一次使用时，其中可能有残留的值（上一次被使用后残留的值），为了获取准确的读数，我们先读出其初始值，后续取每两次读数的差值，也即净增长值。
- 事件净增长值读取（23 - 31 行）：调用 my_perf_event_read 接口读出四个事件的当前值，并与上一次的读数做差获取净增长值。本文模型下，每 5 秒采集一次。
- PMU 初始化（41 行）：module 的 init 函数中，调用 intel_pmu_init 初始化 PMU。
4.2 PMU 初始化
my_x86_pmu 是对 x86 体系结构 PMU 的抽象，其各项回调函数，由具体处理器平台实现。本文实验是在 Intel x86 平台上，底层函数是 intel_pmu_ 前缀的 Intel PMU 实现。static struct my_x86_pmu x86_pmu = { .eventsel = MSR_ARCH_PERFMON_EVENTSEL0, .perfctr = MSR_ARCH_PERFMON_PERFCTR0,
.enable = intel_pmu_enable_event, .disable = intel_pmu_disable_event, .read = intel_pmu_read_event, .hw_config = intel_pmu_hw_config,};
intel_pmu_init 中做 PMU 的基本信息获取：void intel_pmu_init(void){ union cpuid10_edx edx; union cpuid10_eax eax; union cpuid10_ebx ebx; unsigned int unused; int version;
cpuid(10, &eax.full, &ebx.full, &unused, &edx.full);
version = eax.split.version_id;
x86_pmu.version = version; x86_pmu.num_counters = eax.split.num_counters; x86_pmu.cntval_bits = eax.split.bit_width;
if (version > 1) { int assume = 3 * !boot_cpu_has(X86_FEATURE_HYPERVISOR);
x86_pmu.num_counters_fixed = max((int)edx.split.num_counters_fixed, assume); }
printk("... version: %d\n", x86_pmu.version); printk("... bit width: %d\n", x86_pmu.cntval_bits); printk("... generic registers: %d\n", x86_pmu.num_counters); printk("... fixed-purpose events: %d\n", x86_pmu.num_counters_fixed); printk("... x86_model: %d\n", boot_cpu_data.x86_model);}
- 9 行：通过 cpuid 获取 PMU 基本信息。
- 17 - 22 行：根据 PMU 版本信息，计算 num_counters_fixed，也就是 fixed PMC 的数量。具体算法有点 specific，不必深究。
... version: 4... bit width: 48... generic registers: 4... fixed-purpose events: 3... x86_model: 85
4.3 事件初始化
static void intel_pmu_hw_config(struct my_perf_event *event){ event->hw.config = ARCH_PERFMON_EVENTSEL_INT;
event->hw.config |= ARCH_PERFMON_EVENTSEL_USR; event->hw.config |= ARCH_PERFMON_EVENTSEL_OS; event->hw.config |= event->attr.config & X86_RAW_EVENT_MASK;}
static void x86_pmu_event_init(struct my_perf_event *event){ x86_pmu.hw_config(event);}
static void perf_init_event(struct my_perf_event *event){ x86_pmu_event_init(event);}
static void my_sys_perf_event_open(struct my_perf_event *event, struct my_perf_event_attr *attr, int idx, bool fixed){ memset(event, 0, sizeof(*event));
event->attr = *attr;
if (fixed) event->hw.idx = idx + INTEL_PMC_IDX_FIXED; else event->hw.idx = idx;
perf_init_event(event);}
static void my_perf_event_init(struct my_perf_event *event, u64 umask, u64 eventsel, int idx, bool fixed){ struct my_perf_event_attr attr;
memset(&attr, 0, sizeof(attr)); attr.config = (umask << 4) | eventsel;
my_sys_perf_event_open(event, &attr, idx, fixed);}
4.3.1 my_perf_event_init
此函数接受 4 个参数，事件的抽象数据结构、事件的 umask/eventsel、事件底层 PMC ID 编号，此事件底层 PMC 是否是 fixed。框架侧调用点的注释写的很清楚了，使用第 2、3 个 generic PMC，分别对 instruction、cycles 两个事件做监控；同时使用第 0、1 个 fixed PMC，分别对 instruction、cycles 两个事件做监控：my_perf_event_init(&events[0], 0x00, 0xc0, 2, false);my_perf_event_init(&events[1], 0x00, 0x3c, 3, false);
my_perf_event_init(&events[2], 0x00, 0xc0, 0, true);my_perf_event_init(&events[3], 0x00, 0x3c, 1, true);
这里要注意，两个 generic PMC 的 ID 是我随便选的（我的机器上不大于 generic PMC 的最大编号，也就是 3 即可），两个 fixed PMC 的 ID 需要严格与 SDM 上的一致，也就是 0、1。参考本文“2. 事件设计”一节。my_perf_event_init 函数中将 umask、eventsel 按照 architecture specific 的约束，构造成事件属性的 config 域，最后调用 my_sys_perf_event_open 接口打开此事件。4.3.2 my_sys_perf_event_open
- 根据是否是 fixed PMC，对 PMC 的 ID 做编码空间上的隔离，注意这里的编码信息记录到事件的硬件抽象层，也就是 my_hw_perf_event 中。
- 最后调用 perf_init_event，此函数最终调用到 intel_pmu_hw_config，对事件的硬件层抽象做初始化。
4.3.3 intel_pmu_hw_config
在我们的 intel_pmu_hw_config 实现中，使能了如下 bit 位：- INT：如果 PMC overflow，则处理器通过其 LAPIC 触发一个 exception。
- USR：使能 CPU 在 ring 1、2、3 特权级下的事件计数（简单理解为，使能 CPU 运行在用户态时的事件计数）。
- OS：使能 CPU 在 ring 0 特权级下的事件计数（简单理解为，使能 CPU 运行在内核态时的事件计数）。
- UMASK + EventSelect：将业务层传入的事件 umask、eventsel，转成硬件层 PMC 的配置。
此寄存器 bit 位详解，参考 SDM "18.2.1.1 Architectural Performance Monitoring Version 1 Facilities"。注意：我们的代码模型下，hardcode 了寄存器的这几个 bit，实际的内核 perf 框架中，当然不是 hardcode 的，而是根据 perf 前端接口所传入的事件属性，决定对应 bit 位是否置上。比如 USER、OS bit 位是否置上，取决于 perf_event_attr 中的 exclude_user、exclude_kernel 配置：4.4 事件使能
static void __x86_pmu_enable_event(struct my_hw_perf_event *hwc, u64 enable_mask){ wrmsrl(hwc->config_base, hwc->config | enable_mask);}
static void intel_pmu_enable_fixed(struct my_perf_event *event){ u64 ctrl_val, mask, bits = 0; struct my_hw_perf_event *hwc = &event->hw; int idx = hwc->idx;
bits |= 0x8; if (hwc->config & ARCH_PERFMON_EVENTSEL_USR) bits |= 0x2; if (hwc->config & ARCH_PERFMON_EVENTSEL_OS) bits |= 0x1;
idx -= INTEL_PMC_IDX_FIXED; bits <<= (idx * 4); mask = 0xfULL << (idx * 4);
rdmsrl(hwc->config_base, ctrl_val); ctrl_val &= ~mask; ctrl_val |= bits; wrmsrl(hwc->config_base, ctrl_val);}
static void intel_pmu_enable_event(struct my_perf_event *event){ struct my_hw_perf_event *hwc = &event->hw;
switch (hwc->idx) { case 0 ... INTEL_PMC_IDX_FIXED - 1: __x86_pmu_enable_event(hwc, ARCH_PERFMON_EVENTSEL_ENABLE); break; case INTEL_PMC_IDX_FIXED ... INTEL_PMC_IDX_FIXED + 15: intel_pmu_enable_fixed(event); break; };}
static void x86_pmu_enable(struct my_perf_event *event){ x86_assign_hw_event(event); x86_pmu.enable(event);}
static void __my_perf_event_enable(void *info){ struct my_perf_event *event = info;
x86_pmu_enable(event);}
static void my_perf_event_enable(int target_cpu, struct my_perf_event *event){ (void)smp_call_function_single(target_cpu, __my_perf_event_enable, event, 1);}
4.4.1 my_perf_event_enable
因为 PMU 是 per-cpu 的，要使能目标 CPU 上的 event（本质就是使能目标 CPU 上的某个 PMC），需要通过 smp_call 跨核调过去，回调是 __my_perf_event_enable，此回调中干了两件事：- x86_assign_hw_event：为 event 分配一个 PMC，并初始化此 PMC 的寄存器信息。在咱们的模型下，event 的 PMC 是代码中手动指定的（my_perf_event_init 中指定了 PMC 的 ID）。
- intel_pmu_enable_event：写配置寄存器的 enable bit，从硬件上使能 PMC。
4.4.2 x86_assign_hw_event
根据事件硬件层抽象中的 idx，区分其是 generic 还是 fixed PMC，并分别调用相应逻辑：- 如果是 generic PMC（0 ... INTEL_PMC_IDX_FIXED - 1）：config_base 是 PMC 对应的 IA32_PERFEVTSELx 寄存器，event_base 是 PMC 对应的 IA32_PMCx 寄存器（实际上此寄存器压根没用到），event_base_rdpmc 就是 PMC 的编号（generic PMC ID 编址空间下）。
- 如果是 fixed PMC（INTEL_PMC_IDX_FIXED ... INTEL_PMC_IDX_FIXED + 15）：config_base 是 IA32_FIXED_CTR_CTRL 寄存器（所有 fixed PMC 皆是通过这一个寄存器来配置），event_base 是 PMC 对应的 IA32_FIXED_CTRx 寄存器（实际上此寄存器压根没用到），event_base_rdpmc 的计算算法见代码。
如果你对这些寄存器感到困惑，请参阅上一篇文章 “4.2 事件（PMC）的配置及读取”一节。此函数说白了，就是将一个事件与一个硬件 PMC 建立关系（assign）。static inline unsigned int x86_pmu_config_addr(int index){ return x86_pmu.eventsel + index;}
static inline unsigned int x86_pmu_event_addr(int index){ return x86_pmu.perfctr + index;}
static inline int x86_pmu_rdpmc_index(int index){ return x86_pmu.rdpmc_index ? x86_pmu.rdpmc_index(index) : index;}
static void x86_assign_hw_event(struct my_perf_event *event){ struct my_hw_perf_event *hwc = &event->hw;
switch (hwc->idx) { case 0 ... INTEL_PMC_IDX_FIXED - 1: hwc->config_base = x86_pmu_config_addr(hwc->idx); hwc->event_base = x86_pmu_event_addr(hwc->idx); hwc->event_base_rdpmc = x86_pmu_rdpmc_index(hwc->idx); break; case INTEL_PMC_IDX_FIXED ... INTEL_PMC_IDX_FIXED + 15: hwc->config_base = MSR_ARCH_PERFMON_FIXED_CTR_CTRL; hwc->event_base = MSR_ARCH_PERFMON_FIXED_CTR0; hwc->event_base_rdpmc = (hwc->idx - INTEL_PMC_IDX_FIXED) | INTEL_PMC_FIXED_RDPMC_BASE; break; default: return; };}
4.4.3 intel_pmu_enable_event
x86_assign_hw_event 函数中，为事件分配了一个硬件 PMC，并获取了 PMC 的配置、读数寄存器。intel_pmu_enable_event 函数，基于上一步成果，真正地写入寄存器，让 PMC 硬件实际生效。- 对于 generic PMC，使能 PMC 的代码（__x86_pmu_enable_event）非常简单，将 config 带上 EN bit，然后写入 IA32_PERFEVTSELx 寄存器，参考图 4。
- 对于 fixed PMC，略显复杂，但实际上也很简单，其本质就是写入 IA32_FIXED_CTR_CTRL 寄存器，参考图 5。
4.5 事件读取
my_perf_event_read 接口做了两件事：- perf_event_read：此函数通过 smp_call，一路调用到 PMC 底层寄存器读操作（x86_perf_event_update），通过 rdpmcl（底层是 RDPMC 指令），根据事件的 event_base_rdpmc，读出 PMC 硬件中的值，并将读出的硬件数据，做符号扩展至 64 bit，并将数值存到事件的 count 域中。
- perf_event_count：基于上一步成果，将 event 的 count 域返回。
u64 x86_perf_event_update(struct my_perf_event *event){ struct my_hw_perf_event *hwc = &event->hw; int shift = 64 - x86_pmu.cntval_bits; u64 prev_raw_count, new_raw_count; u64 delta;
again: prev_raw_count = local64_read(&hwc->prev_count); rdpmcl(hwc->event_base_rdpmc, new_raw_count);
if (local64_cmpxchg(&hwc->prev_count, prev_raw_count, new_raw_count) != prev_raw_count) goto again;
delta = (new_raw_count << shift) - (prev_raw_count << shift); delta >>= shift;
local64_add(delta, &event->count);
return new_raw_count;}
static void intel_pmu_read_event(struct my_perf_event *event){ x86_perf_event_update(event);}
static void x86_pmu_read(struct my_perf_event *event){ x86_pmu.read(event);}
static void __perf_event_read(void *info){ struct my_perf_event *event = info;
x86_pmu_read(event);}
static void perf_event_read(int target_cpu, struct my_perf_event *event){ (void)smp_call_function_single(target_cpu, __perf_event_read, event, 1);}
static u64 perf_event_count(struct my_perf_event *event){ return local64_read(&event->count);}
u64 my_perf_event_read(int target_cpu, struct my_perf_event *event){ perf_event_read(target_cpu, event); return perf_event_count(event);}
4.6 事件禁能
重点看 x86_pmu_disable_event（generic PMC）、intel_pmu_disable_fixed（fixed PMC），主体逻辑与事件使能类似，只不过是反着来的，操作的是同一个寄存器。读者自行理解，不啰嗦了。static inline void x86_pmu_disable_event(struct my_perf_event *event){ struct my_hw_perf_event *hwc = &event->hw;
wrmsrl(hwc->config_base, hwc->config);}
static void intel_pmu_disable_fixed(struct my_perf_event *event){ struct my_hw_perf_event *hwc = &event->hw; u64 ctrl_val, mask; int idx = hwc->idx;
mask = 0xfULL << ((idx - INTEL_PMC_IDX_FIXED) * 4); rdmsrl(hwc->config_base, ctrl_val); ctrl_val &= ~mask; wrmsrl(hwc->config_base, ctrl_val);}
static void intel_pmu_disable_event(struct my_perf_event *event){ struct my_hw_perf_event *hwc = &event->hw;
switch (hwc->idx) { case 0 ... INTEL_PMC_IDX_FIXED - 1: x86_pmu_disable_event(event); break; case INTEL_PMC_IDX_FIXED ... INTEL_PMC_IDX_FIXED + 15: intel_pmu_disable_fixed(event); break; };}
static void x86_pmu_disable(struct my_perf_event *event){ x86_pmu.disable(event);}
static void __perf_event_disable(void *info){ struct my_perf_event *event = info;
x86_pmu_disable(event);}
static void my_perf_event_disable(int target_cpu, struct my_perf_event *event){ smp_call_function_single(target_cpu, __perf_event_disable, event, 1);}
5. 总结
- 我们的模型下，通过查阅 SDM，获取所要监控事件的 umask、eventsel，并手动指定通过哪个 generic/fixed PMC 来监控对应事件。
- 模块初始化函数中，获取 PMU 信息，比较重要的是 PMU 的数据宽度（cntval_bits）。
- 事件初始化逻辑，将业务层传入的事件属性做记录，并生成事件硬件层抽象的基本配置（基于 umask、eventsel），并将 PMC 的 id 做编码空间隔离。
- 事件使能逻辑，根据 PMC 的 id，进一步设置事件硬件层抽象（本质上对应的就是一个 PMC）的寄存器信息，并写入硬件寄存器，实际使能此 PMC。
- 事件读取逻辑，通过 RDPMC 读出事件对应 PMC 的数值，并做 64 bit 符号扩展。
- 事件禁能逻辑，与事件使能逻辑相反，写入硬件寄存器禁能此 PMC。
6. 伏笔
行文至此，本文不仅没有解答上一篇文章 “5. 伏笔”一节的任何问题，反而引入了更多问题：- 我们所监控事件的 umask、eventsel 都是自己查 SDM 得来的，内核还支持通过事件的通用 ID 来指定，它是怎么实现的（《[perf 1] perf 前端》“3.2 事件类型”）？
- 我们对事件的 PMC 分配采用的是手动方式（手动指定 ID 以及是否使用 fixed PMC），内核 perf 框架显然不可能也这么干，它是怎么实现的？
- 本文指定的两个事件，即可以通过 generic PMC，也可以通过 fixed PMC，如果是内核 perf 框架，它会怎么做选择？
- 我们指定的事件之间并无事件组关系，而我们知道内核 perf 框架还支持事件组的采集，它是怎么实现的？
- 我们的模型只是采集某个 cpu 的 PMU 事件，perf 框架还支持 per-task 的 PMU 事件采集，它是怎么实现的？
这些问题的解答留待内核 perf 框架的后续解构文章。实际上，搞清楚了问题是什么，就已经搞清楚了问题总体的百分之八十。7. 附录
#include #include #include #include
static struct task_struct *loop_task;
#define MSR_ARCH_PERFMON_EVENTSEL0 0x186#define MSR_ARCH_PERFMON_PERFCTR0 0xc1
#define ARCH_PERFMON_EVENTSEL_EVENT 0x000000FFULL#define ARCH_PERFMON_EVENTSEL_UMASK 0x0000FF00ULL#define ARCH_PERFMON_EVENTSEL_USR (1ULL << 16)#define ARCH_PERFMON_EVENTSEL_OS (1ULL << 17)#define ARCH_PERFMON_EVENTSEL_EDGE (1ULL << 18)#define ARCH_PERFMON_EVENTSEL_PIN_CONTROL (1ULL << 19)#define ARCH_PERFMON_EVENTSEL_INT (1ULL << 20)#define ARCH_PERFMON_EVENTSEL_ANY (1ULL << 21)#define ARCH_PERFMON_EVENTSEL_ENABLE (1ULL << 22)#define ARCH_PERFMON_EVENTSEL_INV (1ULL << 23)#define ARCH_PERFMON_EVENTSEL_CMASK 0xFF000000ULL
#define X86_RAW_EVENT_MASK \ (ARCH_PERFMON_EVENTSEL_EVENT | \ ARCH_PERFMON_EVENTSEL_UMASK | \ ARCH_PERFMON_EVENTSEL_EDGE | \ ARCH_PERFMON_EVENTSEL_INV | \ ARCH_PERFMON_EVENTSEL_CMASK)
#define MSR_ARCH_PERFMON_FIXED_CTR_CTRL 0x38d#define MSR_ARCH_PERFMON_FIXED_CTR0 0x309
#define INTEL_PMC_FIXED_RDPMC_BASE (1 << 30)
#define INTEL_PMC_IDX_FIXED 32
struct my_hw_perf_event { struct { u64 config; unsigned long config_base; unsigned long event_base; int event_base_rdpmc; int idx; }; local64_t prev_count;};
struct my_perf_event_attr { u64 config;};
struct my_perf_event { local64_t count; struct my_perf_event_attr attr; struct my_hw_perf_event hw;};
struct my_x86_pmu { int version; unsigned eventsel; unsigned perfctr; int num_counters; int num_counters_fixed; int cntval_bits; int (*rdpmc_index)(int index);
void (*enable)(struct my_perf_event *); void (*disable)(struct my_perf_event *); void (*read)(struct my_perf_event *event); void (*hw_config)(struct my_perf_event *event);};
static void intel_pmu_enable_event(struct my_perf_event *event);static void intel_pmu_disable_event(struct my_perf_event *event);static void intel_pmu_read_event(struct my_perf_event *event);static void intel_pmu_hw_config(struct my_perf_event *event);
static struct my_x86_pmu x86_pmu = { .eventsel = MSR_ARCH_PERFMON_EVENTSEL0, .perfctr = MSR_ARCH_PERFMON_PERFCTR0,
.enable = intel_pmu_enable_event, .disable = intel_pmu_disable_event, .read = intel_pmu_read_event, .hw_config = intel_pmu_hw_config,};
static inline unsigned int x86_pmu_config_addr(int index){ return x86_pmu.eventsel + index;}
static inline unsigned int x86_pmu_event_addr(int index){ return x86_pmu.perfctr + index;}
static inline int x86_pmu_rdpmc_index(int index){ return x86_pmu.rdpmc_index ? x86_pmu.rdpmc_index(index) : index;}
static void x86_assign_hw_event(struct my_perf_event *event){ struct my_hw_perf_event *hwc = &event->hw;
switch (hwc->idx) { case 0 ... INTEL_PMC_IDX_FIXED - 1: hwc->config_base = x86_pmu_config_addr(hwc->idx); hwc->event_base = x86_pmu_event_addr(hwc->idx); hwc->event_base_rdpmc = x86_pmu_rdpmc_index(hwc->idx); break; case INTEL_PMC_IDX_FIXED ... INTEL_PMC_IDX_FIXED + 15: hwc->config_base = MSR_ARCH_PERFMON_FIXED_CTR_CTRL; hwc->event_base = MSR_ARCH_PERFMON_FIXED_CTR0; hwc->event_base_rdpmc = (hwc->idx - INTEL_PMC_IDX_FIXED) | INTEL_PMC_FIXED_RDPMC_BASE; break; default: return; };}
void intel_pmu_init(void){ union cpuid10_edx edx; union cpuid10_eax eax; union cpuid10_ebx ebx; unsigned int unused; int version;
cpuid(10, &eax.full, &ebx.full, &unused, &edx.full);
version = eax.split.version_id;
x86_pmu.version = version; x86_pmu.num_counters = eax.split.num_counters; x86_pmu.cntval_bits = eax.split.bit_width;
if (version > 1) { int assume = 3 * !boot_cpu_has(X86_FEATURE_HYPERVISOR);
x86_pmu.num_counters_fixed = max((int)edx.split.num_counters_fixed, assume); }
printk("... version: %d\n", x86_pmu.version); printk("... bit width: %d\n", x86_pmu.cntval_bits); printk("... generic registers: %d\n", x86_pmu.num_counters); printk("... fixed-purpose events: %d\n", x86_pmu.num_counters_fixed); printk("... x86_model: %d\n", boot_cpu_data.x86_model);}
u64 x86_perf_event_update(struct my_perf_event *event){ struct my_hw_perf_event *hwc = &event->hw; int shift = 64 - x86_pmu.cntval_bits; u64 prev_raw_count, new_raw_count; u64 delta;
again: prev_raw_count = local64_read(&hwc->prev_count); rdpmcl(hwc->event_base_rdpmc, new_raw_count);
if (local64_cmpxchg(&hwc->prev_count, prev_raw_count, new_raw_count) != prev_raw_count) goto again;
delta = (new_raw_count << shift) - (prev_raw_count << shift); delta >>= shift;
local64_add(delta, &event->count);
return new_raw_count;}
static void intel_pmu_read_event(struct my_perf_event *event){ x86_perf_event_update(event);}
static void x86_pmu_read(struct my_perf_event *event){ x86_pmu.read(event);}
static void __perf_event_read(void *info){ struct my_perf_event *event = info;
x86_pmu_read(event);}
static void perf_event_read(int target_cpu, struct my_perf_event *event){ (void)smp_call_function_single(target_cpu, __perf_event_read, event, 1);}
static u64 perf_event_count(struct my_perf_event *event){ return local64_read(&event->count);}
u64 my_perf_event_read(int target_cpu, struct my_perf_event *event){ perf_event_read(target_cpu, event); return perf_event_count(event);}
static inline void x86_pmu_disable_event(struct my_perf_event *event){ struct my_hw_perf_event *hwc = &event->hw;
wrmsrl(hwc->config_base, hwc->config);}
static void intel_pmu_disable_fixed(struct my_perf_event *event){ struct my_hw_perf_event *hwc = &event->hw; u64 ctrl_val, mask; int idx = hwc->idx;
mask = 0xfULL << ((idx - INTEL_PMC_IDX_FIXED) * 4); rdmsrl(hwc->config_base, ctrl_val); ctrl_val &= ~mask; wrmsrl(hwc->config_base, ctrl_val);}
static void intel_pmu_disable_event(struct my_perf_event *event){ struct my_hw_perf_event *hwc = &event->hw;
switch (hwc->idx) { case 0 ... INTEL_PMC_IDX_FIXED - 1: x86_pmu_disable_event(event); break; case INTEL_PMC_IDX_FIXED ... INTEL_PMC_IDX_FIXED + 15: intel_pmu_disable_fixed(event); break; };}
static void x86_pmu_disable(struct my_perf_event *event){ x86_pmu.disable(event);}
static void __perf_event_disable(void *info){ struct my_perf_event *event = info;
x86_pmu_disable(event);}
static void my_perf_event_disable(int target_cpu, struct my_perf_event *event){ smp_call_function_single(target_cpu, __perf_event_disable, event, 1);}
static void __x86_pmu_enable_event(struct my_hw_perf_event *hwc, u64 enable_mask){ wrmsrl(hwc->config_base, hwc->config | enable_mask);}
static void intel_pmu_enable_fixed(struct my_perf_event *event){ u64 ctrl_val, mask, bits = 0; struct my_hw_perf_event *hwc = &event->hw; int idx = hwc->idx;
bits |= 0x8; if (hwc->config & ARCH_PERFMON_EVENTSEL_USR) bits |= 0x2; if (hwc->config & ARCH_PERFMON_EVENTSEL_OS) bits |= 0x1;
idx -= INTEL_PMC_IDX_FIXED; bits <<= (idx * 4); mask = 0xfULL << (idx * 4);
rdmsrl(hwc->config_base, ctrl_val); ctrl_val &= ~mask; ctrl_val |= bits; wrmsrl(hwc->config_base, ctrl_val);}
static void intel_pmu_enable_event(struct my_perf_event *event){ struct my_hw_perf_event *hwc = &event->hw;
switch (hwc->idx) { case 0 ... INTEL_PMC_IDX_FIXED - 1: __x86_pmu_enable_event(hwc, ARCH_PERFMON_EVENTSEL_ENABLE); break; case INTEL_PMC_IDX_FIXED ... INTEL_PMC_IDX_FIXED + 15: intel_pmu_enable_fixed(event); break; };}
static void x86_pmu_enable(struct my_perf_event *event){ x86_assign_hw_event(event); x86_pmu.enable(event);}
static void __my_perf_event_enable(void *info){ struct my_perf_event *event = info;
x86_pmu_enable(event);}
static void my_perf_event_enable(int target_cpu, struct my_perf_event *event){ (void)smp_call_function_single(target_cpu, __my_perf_event_enable, event, 1);}
static void intel_pmu_hw_config(struct my_perf_event *event){ event->hw.config = ARCH_PERFMON_EVENTSEL_INT;
event->hw.config |= ARCH_PERFMON_EVENTSEL_USR; event->hw.config |= ARCH_PERFMON_EVENTSEL_OS; event->hw.config |= event->attr.config & X86_RAW_EVENT_MASK;}
static void x86_pmu_event_init(struct my_perf_event *event){ x86_pmu.hw_config(event);}
static void perf_init_event(struct my_perf_event *event){ x86_pmu_event_init(event);}
static void my_sys_perf_event_open(struct my_perf_event *event, struct my_perf_event_attr *attr, int idx, bool fixed){ memset(event, 0, sizeof(*event));
event->attr = *attr;
if (fixed) event->hw.idx = idx + INTEL_PMC_IDX_FIXED; else event->hw.idx = idx;
perf_init_event(event);}
static void my_perf_event_init(struct my_perf_event *event, u64 umask, u64 eventsel, int idx, bool fixed){ struct my_perf_event_attr attr;
memset(&attr, 0, sizeof(attr)); attr.config = (umask << 4) | eventsel;
my_sys_perf_event_open(event, &attr, idx, fixed);}
static int test_loop(void *__){ unsigned long long prev_count[4] = { 0 }, now_count[4]; struct my_perf_event events[4]; int target_cpu = 3, i;
my_perf_event_init(&events[0], 0x00, 0xc0, 2, false); my_perf_event_init(&events[1], 0x00, 0x3c, 3, false);
my_perf_event_init(&events[2], 0x00, 0xc0, 0, true); my_perf_event_init(&events[3], 0x00, 0x3c, 1, true);
for (i = 0; i < ARRAY_SIZE(events); ++i) my_perf_event_enable(target_cpu, &events[i]);
for (i = 0; i < ARRAY_SIZE(events); ++i) prev_count[i] = my_perf_event_read(target_cpu, &events[i]);
while (!kthread_should_stop()) { for (i = 0; i < ARRAY_SIZE(events); ++i) { now_count[i] = my_perf_event_read(target_cpu, &events[i]); printk("event %d: %llu\n", i, now_count[i] - prev_count[i]); prev_count[i] = now_count[i]; }
msleep_interruptible(5000); }
for (i = 0; i < ARRAY_SIZE(events); ++i) my_perf_event_disable(target_cpu, &events[i]); return 0;}
static int __init test_module_init(void){ intel_pmu_init(); loop_task = kthread_run(test_loop, NULL, "test_loop");
return 0;}
static void __exit test_module_exit(void){ kthread_stop(loop_task);}
module_init(test_module_init);module_exit(test_module_exit);
MODULE_LICENSE("GPL");
