From nobody Tue Nov 17 14:02:42 2026 X-Original-To: dev-commits-src-all@mlmmj.nyi.freebsd.org Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2610:1c1:1:606c::19:1]) by mlmmj.nyi.freebsd.org (Postfix) with ESMTP id 4jTRJM18Lrz71532 for ; Tue, 17 Nov 2026 14:02:43 +0000 (UTC) (envelope-from git@FreeBSD.org) Received: from mxrelay.nyi.freebsd.org (mxrelay.nyi.freebsd.org [IPv6:2610:1c1:1:606c::19:3]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange x25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by mx1.freebsd.org (Postfix) with ESMTPS id 4jTRJM0PQBz4f5Y for ; Tue, 17 Nov 2026 14:02:43 +0000 (UTC) (envelope-from git@FreeBSD.org) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=freebsd.org; s=dkim; t=1794924163; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding; bh=UaXSFALlXIq01/Qxy5z8mBUom2oYB6KOJgXo0PNrWz4=; b=ZyQj0rquRUlcdFRnHLHO7Xd7XVFrJQEaiq/4/4kLKfJ6pSzgsuE6j835k9zWoq1cizq/Ej /WY+fpuk2h/EjM3tok6U7Xh/ILxOHmblsDHZ+xPF4ZyTYdaMqX7ohbHE1nTvSqwQylETpu OgLvWSHgzi3v7v+kJL+gzo9c184oF7dpIBEYDennS6vZ+aNvuBTQVC6Cpx/sDzgiShNRDf 66WS2TXT4jNJfh4Cs4oV2Vqi4axoPAvuhmZFifSretYkrw6c2rkeAiYfRgPdVU7C/3S0LV 2QtuibxNxuBYrJP3bFErwJPjuCMUma2TRrc9/LDs+NMUTaJhvCOfDEZVMxfhVA== ARC-Seal: i=1; a=rsa-sha256; d=freebsd.org; s=dkim; cv=none; t=1794924163; b=DtyvBM3nZh+kfLvmV+/ZoPmTevPjvB9q2d7WajutNR8iMzEOZPzEx7jOd0Ce0MdCnEe00n HrTAqJL/vcWS33ahP/gsF30cPlWleTj5ooLKkPVEHUjWY9yfGK2pVCFLD96275N7HYB4R5 vzUqz12PvrMBQg5hFp1oPUzZwhbfRral+D0D07QMl7bhhKksJvclE3Db2Sf8wLdURUnhJc aaUUoZZOvBF6e9pi88O+NbEulaYGI+AQ3MasiyPOf9kC6kTqyBpkEAzkooKCUmuwdwNcHr smnkLhSt/nN7p+LKU2JXP7uooOgbDhK8Jz3LoH/ycretrZMSbNCxeqGCs6eFcQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=freebsd.org; s=dkim; t=1794924163; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding; bh=UaXSFALlXIq01/Qxy5z8mBUom2oYB6KOJgXo0PNrWz4=; b=IPpceBiajWsGIpnL9y5vVYBKKaZTGXbUF0CxmUx41QKNbQFuaDbt8TH3P7svAaVSHhaI7x KZ8Av2Kc3JP/NXkLH42FaePYBj1942kepHsgUiAfOAlLad9bMrHNozbue7AqAPMA3YIyS1 WWe+pr0G5rrZYkJvKTzLstDfpK4O4TqBCj9ILZzL+Kh6D84WgAxt+cnQSjAzuG6qyB6kY2 7DDJjh8j2QWmPZDHIzCpz+qR4iRYPYe4rQ3NrNFPv61uUSaOpYKQdFrHgQ7Jmo4IUDrPpD T+K4uYQtQr3EjaaywjUNQtuj90LBf3aoKtVAbfdQHS2/+HP4iGGvJugdszF3JQ== ARC-Authentication-Results: i=1; mx1.freebsd.org; none Received: from gitrepo.freebsd.org (gitrepo.freebsd.org [IPv6:2610:1c1:1:6068::e6a:5]) by mxrelay.nyi.freebsd.org (Postfix) with ESMTP id 4jTRJM0374zlj3 for ; Tue, 17 Nov 2026 14:02:43 +0000 (UTC) (envelope-from git@FreeBSD.org) Received: from git (uid 1279) (envelope-from git@FreeBSD.org) id be1e by gitrepo.freebsd.org (DragonFly Mail Agent v0.13+ on gitrepo.freebsd.org); Tue, 17 Nov 2026 14:02:42 +0000 To: src-committers@FreeBSD.org, dev-commits-src-all@FreeBSD.org, dev-commits-src-main@FreeBSD.org Cc: Osvaldo Janeri Filho From: Mitchell Horne Subject: git: 7c743e3ba6c1 - main - tests/sys/pmc/amd: add IBS, row allocation, PerfEvtSel and PerfMonV2 tests List-Archive: https://lists.freebsd.org/archives/dev-commits-src-all X-BeenThere: dev-commits-src-all@freebsd.org List-Id: Commit messages for all branches of the src repository List-Post: List-Help: List-Subscribe: List-Unsubscribe: List-Owner: Precedence: list MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: 8bit X-Git-Committer: mhorne X-Git-Repository: src X-Git-Refname: refs/heads/main X-Git-Reftype: branch X-Git-Commit: 7c743e3ba6c1efc4aca9c0bb59e952cbdb63c1c7 Auto-Submitted: auto-generated Date: Tue, 17 Nov 2026 14:02:42 +0000 Message-Id: <6afc5e82.be1e.3a436021@gitrepo.freebsd.org> The branch main has been updated by mhorne: URL: https://cgit.FreeBSD.org/src/commit/?id=7c743e3ba6c1efc4aca9c0bb59e952cbdb63c1c7 commit 7c743e3ba6c1efc4aca9c0bb59e952cbdb63c1c7 Author: Osvaldo Janeri Filho AuthorDate: 2026-11-17 13:52:03 +0000 Commit: Mitchell Horne CommitDate: 2026-11-17 14:02:32 +0000 tests/sys/pmc/amd: add IBS, row allocation, PerfEvtSel and PerfMonV2 tests - pmc_ibs_test: the IBS class. - pmc_ibs_fetch_op_test: Fetch and Op together (572cd669d6) and IBS interrupt accounting (c97cea955f). - pmcstat_ibs_test: pmcstat records and replays IBS samples. - pmc_rowalloc_test: core row allocation. - pmc_start_msr_test: PerfEvtSel.En and PerfCntrGlobalCtl after pmc_start(). - pmu_perfmonv2_test: the PerfMonV2 global-control path. - amd_pmc_test_common.h: also match the AMD- row names of D60100. Reviewed by: mhorne Sponsored by: Advanced Micro Devices, Inc. Signed-off-by: Osvaldo Janeri Filho Signed-off-by: Davi C.A Differential Revision: https://reviews.freebsd.org/D61063 --- tests/sys/pmc/amd/Makefile | 12 + tests/sys/pmc/amd/amd_pmc_test_common.h | 22 +- tests/sys/pmc/amd/pmc_ibs_fetch_op_test.c | 338 ++++++++++++++++++++ tests/sys/pmc/amd/pmc_ibs_test.c | 502 ++++++++++++++++++++++++++++++ tests/sys/pmc/amd/pmc_rowalloc_test.c | 286 +++++++++++++++++ tests/sys/pmc/amd/pmc_start_msr_test.c | 264 ++++++++++++++++ tests/sys/pmc/amd/pmcstat_ibs_test.sh | 64 ++++ tests/sys/pmc/amd/pmu_perfmonv2_test.c | 186 +++++++++++ 8 files changed, 1669 insertions(+), 5 deletions(-) diff --git a/tests/sys/pmc/amd/Makefile b/tests/sys/pmc/amd/Makefile index 486cf61589ea..577517b1aa9e 100644 --- a/tests/sys/pmc/amd/Makefile +++ b/tests/sys/pmc/amd/Makefile @@ -1,16 +1,28 @@ TESTSDIR= ${TESTSBASE}/sys/pmc/amd +ATF_TESTS_C+= pmc_ibs_fetch_op_test +ATF_TESTS_C+= pmc_ibs_test +ATF_TESTS_C+= pmc_rowalloc_test +ATF_TESTS_C+= pmc_start_msr_test ATF_TESTS_C+= pmu_detect_test ATF_TESTS_C+= pmu_event_neg_test ATF_TESTS_C+= pmu_event_test ATF_TESTS_C+= pmu_mux_test +ATF_TESTS_C+= pmu_perfmonv2_test ATF_TESTS_C+= rapl_domains_test ATF_TESTS_SH+= pmc_frontend_test +ATF_TESTS_SH+= pmcstat_ibs_test # These need the counters of cpu0 to themselves. +TEST_METADATA.pmc_ibs_fetch_op_test+= is_exclusive="true" +TEST_METADATA.pmc_ibs_test+= is_exclusive="true" +TEST_METADATA.pmc_rowalloc_test+= is_exclusive="true" +TEST_METADATA.pmc_start_msr_test+= is_exclusive="true" TEST_METADATA.pmu_event_neg_test+= is_exclusive="true" TEST_METADATA.pmu_event_test+= is_exclusive="true" TEST_METADATA.pmu_mux_test+= is_exclusive="true" +TEST_METADATA.pmu_perfmonv2_test+= is_exclusive="true" +TEST_METADATA.pmcstat_ibs_test+= is_exclusive="true" TEST_METADATA.rapl_domains_test+= is_exclusive="true" LIBADD+= pmc diff --git a/tests/sys/pmc/amd/amd_pmc_test_common.h b/tests/sys/pmc/amd/amd_pmc_test_common.h index 543d5afe3a75..e2c82546ad4a 100644 --- a/tests/sys/pmc/amd/amd_pmc_test_common.h +++ b/tests/sys/pmc/amd/amd_pmc_test_common.h @@ -24,6 +24,7 @@ #include #include #include +#include #include #include @@ -270,11 +271,23 @@ amd_test_count_pmc_rows_with_prefix(int cpu, const char *prefix) } /* - * Count the AMD core counter rows ("K8-") on a CPU. The L3, DF and UMC - * rows share the K8 class and prefix ("K8-L3-", "K8-DF-", "K8-UMC") and are - * not core counters. With free_only, count only rows that are free. + * Return the core counter number of an AMD row name, or -1 for other rows + * (L3, DF, UMC). Rows are "AMD-", or "K8-" on older kernels. */ static inline int +amd_test_core_index(const char *name) +{ + unsigned int n; + char extra; + + if (sscanf(name, "AMD-%u%c", &n, &extra) == 1 || + sscanf(name, "K8-%u%c", &n, &extra) == 1) + return ((int)n); + return (-1); +} + +/* Count the AMD core counter rows on a CPU; with free_only, the free ones. */ +static inline int amd_test_count_core_rows(int cpu, bool free_only) { struct pmc_pmcinfo *pmcinfo; @@ -293,8 +306,7 @@ amd_test_count_core_rows(int cpu, bool free_only) count = 0; for (i = 0; i < npmc; i++) { p = &pmcinfo->pm_pmcs[i]; - if (strncmp(p->pm_name, "K8-", 3) != 0 || - p->pm_name[3] < '0' || p->pm_name[3] > '9') + if (amd_test_core_index(p->pm_name) < 0) continue; if (free_only && p->pm_rowdisp != PMC_DISP_FREE) continue; diff --git a/tests/sys/pmc/amd/pmc_ibs_fetch_op_test.c b/tests/sys/pmc/amd/pmc_ibs_fetch_op_test.c new file mode 100644 index 000000000000..02025ff636e7 --- /dev/null +++ b/tests/sys/pmc/amd/pmc_ibs_fetch_op_test.c @@ -0,0 +1,338 @@ +/* + * Copyright (c) 2026 Advanced Micro Devices, Inc. + * + * Author: Davi C.A + * Author: Osvaldo Janeri Filho + * + * SPDX-License-Identifier: BSD-2-Clause + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "amd_pmc_test_common.h" + +#define FETCH 0x01 +#define OP 0x02 +#define WORK_SECONDS 2 +#define LOG_WAIT 5 +#define MIN_PERCENT 25 + +struct episode { + int error; + char what[64]; + uint64_t samples[2]; /* FETCH, OP */ + uint64_t dropped; + uint64_t processed; /* kern.hwpmc.stats deltas */ + uint64_t ignored; + uint64_t bad; /* foreign PMC, wrong CPU or type */ +}; + +static void +fail_step(struct episode *ep, const char *what) +{ + if (ep->error == 0) { + ep->error = errno != 0 ? errno : EPROTO; + strlcpy(ep->what, what, sizeof(ep->what)); + } +} + +static uint64_t +stat(const char *name) +{ + uint64_t v; + size_t len; + + len = sizeof(v); + if (sysctlbyname(name, &v, &len, NULL, 0) != 0) + return (0); + return (v); +} + +/* Keeps both the fetch and the op pipe busy. */ +static void +workload(void) +{ + static volatile uint64_t table[4096]; + struct timespec end, now; + uint64_t v; + int i; + + clock_gettime(CLOCK_MONOTONIC, &end); + end.tv_sec += WORK_SECONDS; + v = 1; + do { + for (i = 0; i < 100000; i++) { + v = v * 6364136223846793005ULL + 1442695040888963407ULL; + if ((v >> 61) & 1) + table[v & (nitems(table) - 1)] += v; + else + v ^= table[(v >> 17) & (nitems(table) - 1)]; + } + clock_gettime(CLOCK_MONOTONIC, &now); + } while (timespeccmp(&now, &end, <)); +} + +static void +drain(void *parser, int kq, const pmc_id_t *ids, int cpu, struct episode *ep) +{ + static const uint8_t type[2] = { + PMC_CC_MULTIPART_IBS_FETCH, PMC_CC_MULTIPART_IBS_OP + }; + struct pmclog_ev ev; + struct kevent ke; + struct timespec deadline, left, now; + const struct pmclog_ev_callchain *cc; + int k; + + clock_gettime(CLOCK_MONOTONIC, &deadline); + deadline.tv_sec += LOG_WAIT; + for (;;) { + memset(&ev, 0, sizeof(ev)); + if (pmclog_read(parser, &ev) == 0) { + if (ev.pl_type == PMCLOG_TYPE_DROPNOTIFY) + ep->dropped++; + if (ev.pl_type != PMCLOG_TYPE_CALLCHAIN) + continue; + cc = &ev.pl_u.pl_cc; + for (k = 0; k < 2; k++) + if (ids[k] != PMC_ID_INVALID && + cc->pl_pmcid == ids[k]) + break; + if (k == 2 || cc->pl_npc == 0 || + PMC_CALLCHAIN_CPUFLAGS_TO_CPU(cc->pl_cpuflags) != + (unsigned int)cpu || + ((const uint8_t *)cc->pl_pc)[0] != type[k]) + ep->bad++; + else + ep->samples[k]++; + continue; + } + if (ev.pl_state != PMCLOG_EOF) { + errno = EPROTO; + fail_step(ep, "pmclog_read"); + return; + } + if (ev.pl_type == PMCLOG_TYPE_CLOSELOG) + return; + clock_gettime(CLOCK_MONOTONIC, &now); + if (timespeccmp(&now, &deadline, >=)) { + errno = ETIMEDOUT; + fail_step(ep, "waiting for CLOSELOG"); + return; + } + timespecsub(&deadline, &now, &left); + (void)kevent(kq, NULL, 0, &ke, 1, &left); + } +} + +/* A closed log leaves shutdown state on its owner: use a fresh process. */ +static void +run_episode(int cpu, int engines, struct episode *ep) +{ + static const char *const event[2] = { "IBS-FETCH", "IBS-OP" }; + static const pmc_value_t rate[2] = { + IBS_FETCH_MIN_RATE, IBS_OP_MIN_RATE + }; + char path[] = "ibs-fo.XXXXXX"; + struct kevent ke; + cpuset_t set; + pmc_id_t ids[2] = { PMC_ID_INVALID, PMC_ID_INVALID }; + void *parser; + int fd, k, kq, reader; + + memset(ep, 0, sizeof(*ep)); + CPU_ZERO(&set); + CPU_SET(cpu, &set); + if (pmc_init() != 0 || cpuset_setaffinity(CPU_LEVEL_WHICH, + CPU_WHICH_TID, -1, sizeof(set), &set) != 0) { + fail_step(ep, "pmc_init or pinning"); + return; + } + if ((fd = mkstemp(path)) < 0 || + (reader = open(path, O_RDONLY)) < 0 || unlink(path) != 0 || + (parser = pmclog_open(reader)) == NULL || + (kq = kqueue()) < 0) { + fail_step(ep, "log setup"); + return; + } + EV_SET(&ke, reader, EVFILT_VNODE, EV_ADD | EV_CLEAR, + NOTE_WRITE | NOTE_EXTEND, 0, NULL); + if (kevent(kq, &ke, 1, NULL, 0, NULL) != 0 || + pmc_configure_logfile(fd) != 0) { + fail_step(ep, "pmc_configure_logfile"); + return; + } + + ep->processed = stat("kern.hwpmc.stats.intr_processed"); + ep->ignored = stat("kern.hwpmc.stats.intr_ignored"); + for (k = 0; k < 2; k++) + if ((engines & (1 << k)) != 0 && (pmc_allocate(event[k], + PMC_MODE_SS, 0, cpu, &ids[k], rate[k]) != 0 || + pmc_start(ids[k]) != 0)) + fail_step(ep, event[k]); + if (ep->error == 0) + workload(); + for (k = 0; k < 2; k++) { + if (ids[k] == PMC_ID_INVALID) + continue; + (void)pmc_stop(ids[k]); + if (pmc_release(ids[k]) != 0) + fail_step(ep, "pmc_release"); + } + if (pmc_flush_logfile() != 0 || pmc_close_logfile() != 0) + fail_step(ep, "closing the log"); + else + drain(parser, kq, ids, cpu, ep); + ep->processed = stat("kern.hwpmc.stats.intr_processed") - ep->processed; + ep->ignored = stat("kern.hwpmc.stats.intr_ignored") - ep->ignored; + (void)pmc_configure_logfile(-1); +} + +static void +episode(int cpu, int engines, struct episode *ep) +{ + pid_t child; + ssize_t n; + int fds[2], status; + + ATF_REQUIRE(pipe(fds) == 0); + child = fork(); + ATF_REQUIRE(child >= 0); + if (child == 0) { + close(fds[0]); + run_episode(cpu, engines, ep); + n = write(fds[1], ep, sizeof(*ep)); + _exit(n == (ssize_t)sizeof(*ep) ? 0 : 1); + } + close(fds[1]); + n = read(fds[0], ep, sizeof(*ep)); + close(fds[0]); + ATF_REQUIRE(waitpid(child, &status, 0) == child); + ATF_REQUIRE_MSG(n == (ssize_t)sizeof(*ep) && WIFEXITED(status) && + WEXITSTATUS(status) == 0, "episode owner failed: status %#x", + status); + printf("engines %#x: fetch %ju op %ju dropped %ju bad %ju, " + "interrupts %ju processed %ju ignored\n", engines, + (uintmax_t)ep->samples[0], (uintmax_t)ep->samples[1], + (uintmax_t)ep->dropped, (uintmax_t)ep->bad, + (uintmax_t)ep->processed, (uintmax_t)ep->ignored); + ATF_REQUIRE_MSG(ep->error == 0, "%s failed: %s", ep->what, + strerror(ep->error)); + ATF_REQUIRE_MSG(ep->dropped == 0 && ep->bad == 0, + "%ju dropped buffers, %ju malformed or misrouted samples", + (uintmax_t)ep->dropped, (uintmax_t)ep->bad); +} + +/* Skip unless IBS Fetch and Op sampling work; return the CPU to use. */ +static int +setup(void) +{ + cpuset_t mask; + u_int regs[4]; + int cpu; + + amd_test_skip_unless_amd(); + do_cpuid(0x80000000, regs); + if (regs[0] < CPUID_IBSID) + atf_tc_skip("CPU lacks the IBS CPUID leaf"); + do_cpuid(CPUID_IBSID, regs); + if ((regs[0] & (CPUID_IBSID_FETCHSAM | CPUID_IBSID_OPSAM)) != + (CPUID_IBSID_FETCHSAM | CPUID_IBSID_OPSAM)) + atf_tc_skip("CPU lacks IBS Fetch or Op sampling"); + amd_test_skip_unless_hwpmc(); + + ATF_REQUIRE(cpuset_getaffinity(CPU_LEVEL_WHICH, CPU_WHICH_TID, -1, + sizeof(mask), &mask) == 0); + cpu = CPU_FFS(&mask) - 1; + ATF_REQUIRE(cpu >= 0); + return (cpu); +} + +/* + * Regression test for 572cd669d6: pmc_ibs_intr() skipped a valid Op sample + * when Fetch was valid in the same NMI, and IBS-OP starved. + */ +ATF_TC(fetch_and_op_together); +ATF_TC_HEAD(fetch_and_op_together, tc) +{ + atf_tc_set_md_var(tc, "descr", + "IBS-FETCH and IBS-OP system sampling on one CPU each deliver at " + "least a quarter of the samples they deliver alone"); + atf_tc_set_md_var(tc, "require.user", "root"); + atf_tc_set_md_var(tc, "timeout", "60"); +} +ATF_TC_BODY(fetch_and_op_together, tc) +{ + struct episode both, fetch, op; + int cpu; + + cpu = setup(); + + episode(cpu, FETCH, &fetch); + episode(cpu, OP, &op); + ATF_REQUIRE_MSG(fetch.samples[0] > 0 && op.samples[1] > 0, + "an engine alone delivered no samples: fetch %ju, op %ju", + (uintmax_t)fetch.samples[0], (uintmax_t)op.samples[1]); + episode(cpu, FETCH | OP, &both); + + ATF_CHECK_MSG(both.samples[0] * 100 >= fetch.samples[0] * MIN_PERCENT, + "IBS-FETCH starved beside IBS-OP: %ju samples, %ju alone", + (uintmax_t)both.samples[0], (uintmax_t)fetch.samples[0]); + ATF_CHECK_MSG(both.samples[1] * 100 >= op.samples[1] * MIN_PERCENT, + "IBS-OP starved beside IBS-FETCH: %ju samples, %ju alone", + (uintmax_t)both.samples[1], (uintmax_t)op.samples[1]); +} + +/* c97cea955f: an IBS interrupt was counted as processed twice. */ +ATF_TC(interrupts_counted_once); +ATF_TC_HEAD(interrupts_counted_once, tc) +{ + atf_tc_set_md_var(tc, "descr", + "Each IBS-FETCH sampling interrupt is counted once in " + "kern.hwpmc.stats.intr_processed and none in intr_ignored"); + atf_tc_set_md_var(tc, "require.user", "root"); + atf_tc_set_md_var(tc, "timeout", "30"); +} +ATF_TC_BODY(interrupts_counted_once, tc) +{ + struct episode ep; + + episode(setup(), FETCH, &ep); + ATF_CHECK_MSG(ep.ignored == 0, "%ju interrupts counted as ignored", + (uintmax_t)ep.ignored); + ATF_CHECK_MSG(ep.processed >= ep.samples[0] && + ep.processed <= ep.samples[0] + ep.samples[0] / 10 + 16, + "%ju interrupts processed for %ju samples", + (uintmax_t)ep.processed, (uintmax_t)ep.samples[0]); +} + +ATF_TP_ADD_TCS(tp) +{ + ATF_TP_ADD_TC(tp, fetch_and_op_together); + ATF_TP_ADD_TC(tp, interrupts_counted_once); + + return (atf_no_error()); +} diff --git a/tests/sys/pmc/amd/pmc_ibs_test.c b/tests/sys/pmc/amd/pmc_ibs_test.c new file mode 100644 index 000000000000..cd99cf459929 --- /dev/null +++ b/tests/sys/pmc/amd/pmc_ibs_test.c @@ -0,0 +1,502 @@ +/* + * Copyright (c) 2026 Advanced Micro Devices, Inc. + * + * Author: Davi C.A + * Author: Osvaldo Janeri Filho + * + * SPDX-License-Identifier: BSD-2-Clause + */ + +#include +#include +#include +#include +#include +#include +#include + +#include + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "amd_pmc_test_common.h" + +#define IBS_RATE IBS_FETCH_MIN_RATE +#define IBS_CAPS (PMC_CAP_INTERRUPT | PMC_CAP_SYSTEM | \ + PMC_CAP_EDGE | PMC_CAP_QUALIFIER | \ + PMC_CAP_PRECISE) +#define LOG_WAIT_SECONDS 5 + +static const struct pmc_classinfo * +ibs_classinfo(void) +{ + const struct pmc_cpuinfo *cpuinfo; + + ATF_REQUIRE_MSG(pmc_cpuinfo(&cpuinfo) == 0, + "pmc_cpuinfo() failed: %s", strerror(errno)); + return (amd_test_find_classinfo(cpuinfo, PMC_CLASS_IBS)); +} + +static void +skip_unless_ibs(void) +{ + u_int regs[4]; + + amd_test_skip_unless_amd(); + do_cpuid(0x80000000, regs); + if (regs[0] < CPUID_IBSID) + atf_tc_skip("CPU lacks the IBS CPUID leaf"); + do_cpuid(CPUID_IBSID, regs); + if ((regs[0] & (CPUID_IBSID_IBSFFV | CPUID_IBSID_FETCHSAM | + CPUID_IBSID_OPSAM)) != (CPUID_IBSID_IBSFFV | + CPUID_IBSID_FETCHSAM | CPUID_IBSID_OPSAM)) + atf_tc_skip("CPU lacks IBS Fetch or Op sampling"); + amd_test_skip_unless_hwpmc(); + if (ibs_classinfo() == NULL) + atf_tc_skip("hwpmc does not expose PMC_CLASS_IBS"); +} + +static int +pin_cpu(void) +{ + cpuset_t mask; + int cpu; + + ATF_REQUIRE(cpuset_getaffinity(CPU_LEVEL_WHICH, CPU_WHICH_TID, -1, + sizeof(mask), &mask) == 0); + cpu = CPU_FFS(&mask) - 1; + ATF_REQUIRE(cpu >= 0); + CPU_ZERO(&mask); + CPU_SET(cpu, &mask); + ATF_REQUIRE_MSG(cpuset_setaffinity(CPU_LEVEL_WHICH, CPU_WHICH_TID, -1, + sizeof(mask), &mask) == 0, "cannot bind to cpu%d: %s", cpu, + strerror(errno)); + return (cpu); +} + +static int +alloc_errno(const char *event, enum pmc_mode mode, int cpu, + pmc_value_t rate) +{ + pmc_id_t id; + + id = PMC_ID_INVALID; + errno = 0; + if (pmc_allocate(event, mode, 0, cpu, &id, rate) == 0) { + amd_test_release_pmc(id); + return (0); + } + return (errno); +} + +static pmc_id_t +alloc_attach_fetch(pid_t pid, pmc_value_t rate) +{ + pmc_id_t id; + int error; + + id = PMC_ID_INVALID; + ATF_REQUIRE_MSG(pmc_allocate("IBS-FETCH", PMC_MODE_TS, 0, PMC_CPU_ANY, + &id, rate) == 0, "pmc_allocate(TS IBS-FETCH) failed: %s", + strerror(errno)); + if (pmc_attach(id, pid) != 0) { + error = errno; + amd_test_release_pmc(id); + atf_tc_fail("pmc_attach(IBS-FETCH, %d) failed: %s", pid, + strerror(error)); + } + return (id); +} + +ATF_TC(class_info); +ATF_TC_HEAD(class_info, tc) +{ + atf_tc_set_md_var(tc, "descr", + "pmc_cpuinfo() reports PMC_CLASS_IBS with two PMCs, width 0 and " + "the interrupt, system, edge, qualifier and precise capabilities"); + atf_tc_set_md_var(tc, "require.user", "root"); +} +ATF_TC_BODY(class_info, tc) +{ + const struct pmc_classinfo *ci; + + skip_unless_ibs(); + ci = ibs_classinfo(); + ATF_CHECK_EQ_MSG(ci->pm_num, 2, "IBS class has %u PMCs", ci->pm_num); + ATF_CHECK_EQ_MSG(ci->pm_width, 0, "IBS class width is %u", + ci->pm_width); + ATF_CHECK_MSG((ci->pm_caps & IBS_CAPS) == IBS_CAPS, + "IBS class caps %#x lack %#x", ci->pm_caps, IBS_CAPS); +} + +ATF_TC(class_and_event_names); +ATF_TC_HEAD(class_and_event_names, tc) +{ + atf_tc_set_md_var(tc, "descr", + "libpmc names the class IBS and lists the FETCH and OP events"); + atf_tc_set_md_var(tc, "require.user", "root"); +} +ATF_TC_BODY(class_and_event_names, tc) +{ + const char **names; + const char *name; + bool fetch, op; + int i, n; + + skip_unless_ibs(); + name = pmc_name_of_class(PMC_CLASS_IBS); + ATF_REQUIRE(name != NULL); + ATF_CHECK_STREQ(name, "IBS"); + + ATF_REQUIRE_MSG(pmc_event_names_of_class(PMC_CLASS_IBS, &names, + &n) == 0, "pmc_event_names_of_class() failed: %s", + strerror(errno)); + fetch = op = false; + for (i = 0; i < n; i++) { + fetch |= strcasecmp(names[i], "FETCH") == 0; + op |= strcasecmp(names[i], "OP") == 0; + } + free(names); + ATF_CHECK_MSG(fetch && op, "IBS events: FETCH %s, OP %s", + fetch ? "listed" : "missing", op ? "listed" : "missing"); +} + +ATF_TC(pmcinfo_rows); +ATF_TC_HEAD(pmcinfo_rows, tc) +{ + atf_tc_set_md_var(tc, "descr", + "pmc_pmcinfo() has exactly one IBS-FETCH and one IBS-OP row"); + atf_tc_set_md_var(tc, "require.user", "root"); +} +ATF_TC_BODY(pmcinfo_rows, tc) +{ + size_t fetch, op; + int cpu; + + skip_unless_ibs(); + cpu = pin_cpu(); + fetch = amd_test_count_pmc_rows_with_prefix(cpu, "IBS-FETCH"); + op = amd_test_count_pmc_rows_with_prefix(cpu, "IBS-OP"); + ATF_CHECK_MSG(fetch == 1 && op == 1, + "cpu%d has %zu IBS-FETCH and %zu IBS-OP rows", cpu, fetch, op); +} + +ATF_TC(alloc_system_sampling); +ATF_TC_HEAD(alloc_system_sampling, tc) +{ + atf_tc_set_md_var(tc, "descr", + "IBS-FETCH and IBS-OP allocate as system-sampling PMCs; IBS-FETCH " + "reports the IBS capabilities and width 0"); + atf_tc_set_md_var(tc, "require.user", "root"); +} +ATF_TC_BODY(alloc_system_sampling, tc) +{ + pmc_id_t fetch, op; + uint32_t caps, width; + int cpu; + + skip_unless_ibs(); + cpu = pin_cpu(); + fetch = op = PMC_ID_INVALID; + ATF_REQUIRE_MSG(pmc_allocate("IBS-FETCH", PMC_MODE_SS, 0, cpu, &fetch, + IBS_RATE) == 0, "pmc_allocate(IBS-FETCH) failed: %s", + strerror(errno)); + ATF_CHECK_MSG(pmc_allocate("IBS-OP", PMC_MODE_SS, 0, cpu, &op, + IBS_RATE) == 0, "pmc_allocate(IBS-OP) failed: %s", + strerror(errno)); + + caps = 0; + width = UINT32_MAX; + ATF_CHECK(pmc_capabilities(fetch, &caps) == 0); + ATF_CHECK(pmc_width(fetch, &width) == 0); + ATF_CHECK_MSG((caps & IBS_CAPS) == IBS_CAPS, + "IBS-FETCH caps %#x lack %#x", caps, IBS_CAPS); + ATF_CHECK_EQ_MSG(width, 0, "IBS-FETCH width is %u", width); + + amd_test_release_pmc(op); + amd_test_release_pmc(fetch); +} + +ATF_TC(alloc_refusals); +ATF_TC_HEAD(alloc_refusals, tc) +{ + atf_tc_set_md_var(tc, "descr", + "IBS allocation fails with EINVAL in counting mode, below the " + "minimum sample rate and with an unknown qualifier"); + atf_tc_set_md_var(tc, "require.user", "root"); +} +ATF_TC_BODY(alloc_refusals, tc) +{ + int cpu, error; + + skip_unless_ibs(); + cpu = pin_cpu(); + + error = alloc_errno("IBS-FETCH", PMC_MODE_SC, cpu, IBS_RATE); + ATF_CHECK_MSG(error == EINVAL, "counting mode: errno %d (%s)", error, + strerror(error)); + error = alloc_errno("IBS-OP", PMC_MODE_SS, cpu, IBS_OP_MIN_RATE - 1); + ATF_CHECK_MSG(error == EINVAL, "rate %d: errno %d (%s)", + IBS_OP_MIN_RATE - 1, error, strerror(error)); + error = alloc_errno("IBS-OP,no_such_qualifier", PMC_MODE_SS, cpu, + IBS_RATE); + ATF_CHECK_MSG(error == EINVAL, "unknown qualifier: errno %d (%s)", + error, strerror(error)); +} + +ATF_TC(fetch_attach_detach); +ATF_TC_HEAD(fetch_attach_detach, tc) +{ + atf_tc_set_md_var(tc, "descr", + "A process-mode IBS-FETCH PMC attaches to its owner, detaches and " + "is released"); + atf_tc_set_md_var(tc, "require.user", "root"); +} +ATF_TC_BODY(fetch_attach_detach, tc) +{ + pmc_id_t id; + + skip_unless_ibs(); + (void)pin_cpu(); + id = alloc_attach_fetch(getpid(), IBS_RATE); + ATF_CHECK_MSG(pmc_detach(id, getpid()) == 0, + "pmc_detach() failed: %s", strerror(errno)); + amd_test_release_pmc(id); +} + +ATF_TC(fetch_self_count); +ATF_TC_HEAD(fetch_self_count, tc) +{ + atf_tc_set_md_var(tc, "descr", + "A running IBS-FETCH PMC attached to its owner reads a non-zero " + "count while the owner makes system calls"); + atf_tc_set_md_var(tc, "require.user", "root"); +} +ATF_TC_BODY(fetch_self_count, tc) +{ + pmc_id_t id; + pmc_value_t v; + int i, round; + + skip_unless_ibs(); + (void)pin_cpu(); + id = alloc_attach_fetch(getpid(), IBS_RATE); + ATF_REQUIRE_MSG(pmc_start(id) == 0, "pmc_start() failed: %s", + strerror(errno)); + + /* The count restarts after each sample, so one read may see 0. */ + v = 0; + for (round = 0; round < 100 && v == 0; round++) { + for (i = 0; i < 10000; i++) + (void)getppid(); + ATF_REQUIRE(pmc_read(id, &v) == 0); + } + ATF_CHECK(pmc_stop(id) == 0); + ATF_CHECK(pmc_detach(id, getpid()) == 0); + amd_test_release_pmc(id); + ATF_CHECK_MSG(v != 0, "IBS-FETCH count stayed 0"); +} + +/* Wait for a sample of pid, or for CLOSELOG if closing. */ +static int +wait_log(void *parser, int kq, pmc_id_t id, pid_t pid, bool closing, + bool *sampled, bool *dropped) +{ + struct pmclog_ev ev; + struct kevent ke; + struct timespec deadline, left, now; + const struct pmclog_ev_callchain *cc; + const uint8_t *hdr; + + ATF_REQUIRE(clock_gettime(CLOCK_MONOTONIC, &deadline) == 0); + deadline.tv_sec += LOG_WAIT_SECONDS; + for (;;) { + if (!closing && pmc_flush_logfile() != 0) + return (errno); + memset(&ev, 0, sizeof(ev)); + if (pmclog_read(parser, &ev) == 0) { + if (ev.pl_type == PMCLOG_TYPE_DROPNOTIFY) + *dropped = true; + if (ev.pl_type != PMCLOG_TYPE_CALLCHAIN) + continue; + cc = &ev.pl_u.pl_cc; + hdr = (const uint8_t *)cc->pl_pc; + if (cc->pl_pmcid != id || cc->pl_pid != (uint32_t)pid || + (cc->pl_cpuflags & PMC_CC_F_MULTIPART) == 0 || + cc->pl_npc == 0 || + hdr[0] != PMC_CC_MULTIPART_IBS_FETCH) + return (EPROTO); + *sampled = true; + if (!closing) + return (0); + continue; + } + if (ev.pl_state != PMCLOG_EOF) + return (EPROTO); + if (ev.pl_type == PMCLOG_TYPE_CLOSELOG) + return (closing ? 0 : EPROTO); + ATF_REQUIRE(clock_gettime(CLOCK_MONOTONIC, &now) == 0); + if (timespeccmp(&now, &deadline, >=)) + return (ETIMEDOUT); + timespecsub(&deadline, &now, &left); + if (kevent(kq, NULL, 0, &ke, 1, &left) < 0 && errno != EINTR) + return (errno); + } +} + +ATF_TC(fetch_child_samples); +ATF_TC_HEAD(fetch_child_samples, tc) +{ + atf_tc_set_md_var(tc, "descr", + "An IBS-FETCH PMC attached to a child writes IBS-FETCH samples of " + "that child to the owner's log, without drops"); + atf_tc_set_md_var(tc, "require.user", "root"); + atf_tc_set_md_var(tc, "timeout", "30"); +} +ATF_TC_BODY(fetch_child_samples, tc) +{ + struct kevent ke; + char path[] = "ibs-fetch.XXXXXX"; + volatile uint64_t x; + uint64_t i; + pmc_id_t id; + pid_t child; + const char *what; + void *parser; + bool configured, dropped, sampled; + int error, fd, kq, reader, status; + + skip_unless_ibs(); + (void)pin_cpu(); + + fd = mkstemp(path); + ATF_REQUIRE(fd >= 0); + reader = open(path, O_RDONLY); + ATF_REQUIRE(reader >= 0); + ATF_REQUIRE(unlink(path) == 0); + parser = pmclog_open(reader); + ATF_REQUIRE(parser != NULL); + kq = kqueue(); + ATF_REQUIRE(kq >= 0); + EV_SET(&ke, reader, EVFILT_VNODE, EV_ADD | EV_CLEAR, + NOTE_WRITE | NOTE_EXTEND, 0, NULL); + ATF_REQUIRE(kevent(kq, &ke, 1, NULL, 0, NULL) == 0); + + child = fork(); + ATF_REQUIRE(child >= 0); + if (child == 0) { + if (raise(SIGSTOP) != 0) + _exit(1); + x = 1; + for (i = 0; i < 500000000; i++) + x = x * 1664525U + 1013904223U; + _exit(0); + } + /* From here on, kill and reap the child before any failure. */ + what = NULL; + configured = false; + id = PMC_ID_INVALID; + if (waitpid(child, &status, WUNTRACED) != child || !WIFSTOPPED(status)) + what = "stopping the child"; + else if (pmc_configure_logfile(fd) != 0) + what = "pmc_configure_logfile"; + else { + configured = true; + if (pmc_allocate("IBS-FETCH", PMC_MODE_TS, 0, PMC_CPU_ANY, &id, + IBS_FETCH_MAX_RATE) != 0) + what = "pmc_allocate"; + else if (pmc_attach(id, child) != 0) + what = "pmc_attach"; + else if (pmc_start(id) != 0) + what = "pmc_start"; + else if (kill(child, SIGCONT) != 0) + what = "kill(SIGCONT)"; + } + error = what != NULL ? errno : 0; + + sampled = dropped = false; + if (error == 0) + error = wait_log(parser, kq, id, child, false, &sampled, + &dropped); + + (void)kill(child, SIGKILL); + (void)waitpid(child, &status, 0); + if (id != PMC_ID_INVALID) { + (void)pmc_stop(id); + amd_test_release_pmc(id); + } + if (configured) { + ATF_CHECK(pmc_flush_logfile() == 0); + if (pmc_close_logfile() != 0) + ATF_CHECK_MSG(false, "pmc_close_logfile() failed: %s", + strerror(errno)); + else if (error == 0) + error = wait_log(parser, kq, id, child, true, + &sampled, &dropped); + ATF_CHECK(pmc_configure_logfile(-1) == 0); + } + pmclog_close(parser); + close(kq); + close(reader); + close(fd); + + ATF_REQUIRE_MSG(what == NULL, "%s failed: %s", what, strerror(error)); + ATF_REQUIRE_MSG(error == 0, "reading the log failed: %s", + strerror(error)); + ATF_CHECK_MSG(sampled && !dropped, "IBS-FETCH log: sampled %d, " + "dropped %d", sampled, dropped); +} + +ATF_TC(getmsr_rejected); +ATF_TC_HEAD(getmsr_rejected, tc) +{ + atf_tc_set_md_var(tc, "descr", + "pmc_get_msr() fails with ENOSYS or EINVAL for an IBS-FETCH PMC"); + atf_tc_set_md_var(tc, "require.user", "root"); +} +ATF_TC_BODY(getmsr_rejected, tc) +{ + pmc_id_t id; + uint32_t msr; + int error, rc; + + skip_unless_ibs(); + (void)pin_cpu(); + id = alloc_attach_fetch(getpid(), IBS_RATE); + errno = 0; + rc = pmc_get_msr(id, &msr); + error = errno; + ATF_CHECK(pmc_detach(id, getpid()) == 0); + amd_test_release_pmc(id); + /* IBS has no GETMSR method; the sampling-mode check may come first. */ + ATF_CHECK_MSG(rc == -1 && (error == ENOSYS || error == EINVAL), + "pmc_get_msr() returned %d, errno %d (%s)", rc, error, + strerror(error)); +} + +ATF_TP_ADD_TCS(tp) +{ + ATF_TP_ADD_TC(tp, class_info); + ATF_TP_ADD_TC(tp, class_and_event_names); + ATF_TP_ADD_TC(tp, pmcinfo_rows); + ATF_TP_ADD_TC(tp, alloc_system_sampling); + ATF_TP_ADD_TC(tp, alloc_refusals); + ATF_TP_ADD_TC(tp, fetch_attach_detach); + ATF_TP_ADD_TC(tp, fetch_self_count); + ATF_TP_ADD_TC(tp, fetch_child_samples); + ATF_TP_ADD_TC(tp, getmsr_rejected); + + return (atf_no_error()); +} diff --git a/tests/sys/pmc/amd/pmc_rowalloc_test.c b/tests/sys/pmc/amd/pmc_rowalloc_test.c new file mode 100644 index 000000000000..c578046e8128 --- /dev/null +++ b/tests/sys/pmc/amd/pmc_rowalloc_test.c @@ -0,0 +1,286 @@ +/* + * Copyright (c) 2026 Advanced Micro Devices, Inc. + * + * Author: Davi C.A + * Author: Osvaldo Janeri Filho + * + * SPDX-License-Identifier: BSD-2-Clause + */ + *** 809 LINES SKIPPED ***