内核perf框架解构系列：PMU硬件架构相关的概念及编程
嵌入式技术
描述
1. 综述
本文乃内核 perf 框架解构系列文章第三篇。 《[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：
图 1 同时，此二者还可以通过第 0 和 第 1 个 fixed PMC 采集：
图 2 若要查询非 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);
};
version：PMU 的版本。
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 事件读取”一节。
attr：事件中保存的业务层所传入的属性。
hw：一个业务层的事件，其具体采集任务需要一个具体的硬件 PMC，struct my_hw_perf_event 即是对硬件 PMC 的抽象。参考下一小节。
3.3.2 硬件层抽象
struct my_hw_perf_event {
struct { /* hardware */
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 设计大图
图 3
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;
// suppose we are using the #2 generic pmc for 'Instruction Retired', umask 00h, event C0h
// suppose we are using the #3 generic pmc for 'UnHalted Core Cycles', umask 00h, event 3Ch
my_perf_event_init(&events[0], 0x00, 0xc0, 2, false);
my_perf_event_init(&events[1], 0x00, 0x3c, 3, false);
// suppose we are using the #0 fixed pmc for 'Instruction Retired', event C0h
// suppose we are using the #1 fixed pmc for 'UnHalted Core Cycles', event 3Ch
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
", 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 秒采集一次。
事件禁能（33 - 34 行）：事件禁能。
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
", x86_pmu.version);
printk("... bit width: %d
", x86_pmu.cntval_bits);
printk("... generic registers: %d
", x86_pmu.num_counters);
printk("... fixed-purpose events: %d
", x86_pmu.num_counters_fixed);
printk("... x86_model: %d
", boot_cpu_data.x86_model);
}
简单讲一下：
9 行：通过 cpuid 获取 PMU 基本信息。
17 - 22 行：根据 PMU 版本信息，计算 num_counters_fixed，也就是 fixed PMC 的数量。具体算法有点 specific，不必深究。
24 - 28 行：打印 PMU 信息概览。
在我的机器上：
... 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 两个事件做监控：
// suppose we are using the #2 generic pmc for 'Instruction Retired', umask 00h, event C0h // suppose we are using the #3 generic pmc for 'UnHalted Core Cycles', umask 00h, event 3Ch my_perf_event_init(&events[0], 0x00, 0xc0, 2, false); my_perf_event_init(&events[1], 0x00, 0x3c, 3, false); // suppose we are using the #0 fixed pmc for 'Instruction Retired', event C0h // suppose we are using the #1 fixed pmc for 'UnHalted Core Cycles', event 3Ch 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
为什么要配置成这样，参考下面两个寄存器：
图 4
图 5 在我们的 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 配置：
图 6
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;
/*
* Now we have the new raw value and have updated the prev
* timestamp already. We can now calculate the elapsed delta
* (event-)time and add that to the generic event.
*
* Careful, not all hw sign-extends above the physical width
* of the count.
*/
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; /* * Performance event hw details: */ #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) /* * All the fixed-mode PMCs are configured via this single MSR: */ #define MSR_ARCH_PERFMON_FIXED_CTR_CTRL 0x38d #define MSR_ARCH_PERFMON_FIXED_CTR0 0x309 /* RDPMC offset for Fixed PMCs */ #define INTEL_PMC_FIXED_RDPMC_BASE (1 << 30) #define INTEL_PMC_IDX_FIXED 32 struct my_hw_perf_event { struct { /* hardware */ 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 ", x86_pmu.version); printk("... bit width: %d ", x86_pmu.cntval_bits); printk("... generic registers: %d ", x86_pmu.num_counters); printk("... fixed-purpose events: %d ", x86_pmu.num_counters_fixed); printk("... x86_model: %d ", boot_cpu_data.x86_model); } /////////////////////////////// // read logic 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; /* * Now we have the new raw value and have updated the prev * timestamp already. We can now calculate the elapsed delta * (event-)time and add that to the generic event. * * Careful, not all hw sign-extends above the physical width * of the count. */ 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); } /////////////////////////////// // disable logic 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); } /////////////////////////////// // enable logic 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); } /////////////////////////////// // init logic 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; // suppose we are using the #2 generic pmc for 'Instruction Retired', umask 00h, event C0h // suppose we are using the #3 generic pmc for 'UnHalted Core Cycles', umask 00h, event 3Ch my_perf_event_init(&events[0], 0x00, 0xc0, 2, false); my_perf_event_init(&events[1], 0x00, 0x3c, 3, false); // suppose we are using the #0 fixed pmc for 'Instruction Retired', event C0h // suppose we are using the #1 fixed pmc for 'UnHalted Core Cycles', event 3Ch 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 ", 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");
编辑：黄飞
-
Allegro正负片的概念及相关设置说明2008-05-12 0
-
CAD命令：CAD软件中from命令的相关概念及应用2020-05-25 0
-
USB基本概念及从机编程方法介绍2021-11-08 0
-
嵌入式系统的概念及特点2021-12-22 0
-
Arm Neoverse V1 PMU指南2023-08-09 0
-
Arm Neoverse™ N1 PMU指南2023-08-12 0
-
电子商务相关概念及理论,下载2009-04-28 1096
-
简析ARM内核和架构概念及其之间的关系2018-11-28 5103
-
解构内核 perf 框架的实现讲解2023-01-16 1235
-
基于4.9内核的PMU的基本操作及编程2023-02-09 1650
-
Linux perf性能、实际应用与案例2023-07-03 637
-
如何使用perf性能分析工具2023-11-08 1422
-
Linux perf 简要介绍2023-11-09 774
-
谐波的概念及应用2024-10-18 221
全部0条评论
快来发表一下你的评论吧 !
