1// SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause)
2#include "debug.h"
3#include "evlist.h"
4#include "hwmon_pmu.h"
5#include "parse-events.h"
6#include "tests.h"
7#include <errno.h>
8#include <fcntl.h>
9#include <sys/stat.h>
10#include <linux/compiler.h>
11#include <linux/kernel.h>
12#include <linux/string.h>
13
14static const struct test_event {
15 const char *name;
16 const char *alias;
17 union hwmon_pmu_event_key key;
18} test_events[] = {
19 {
20 "temp_test_hwmon_event1",
21 "temp1",
22 .key = {
23 .num = 1,
24 .type = 10
25 },
26 },
27 {
28 "temp_test_hwmon_event2",
29 "temp2",
30 .key = {
31 .num = 2,
32 .type = 10
33 },
34 },
35};
36
37/* Cleanup test PMU directory. */
38static int test_pmu_put(const char *dir, struct perf_pmu *hwm)
39{
40 char buf[PATH_MAX + 20];
41 int ret;
42
43 if (scnprintf(buf, size: sizeof(buf), fmt: "rm -fr %s", dir) < 0) {
44 pr_err("Failure to set up buffer for \"%s\"\n", dir);
45 return -EINVAL;
46 }
47 ret = system(buf);
48 if (ret)
49 pr_err("Failure to \"%s\"\n", buf);
50
51 list_del(&hwm->list);
52 perf_pmu__delete(hwm);
53 return ret;
54}
55
56/*
57 * Prepare test PMU directory data, normally exported by kernel at
58 * /sys/class/hwmon/hwmon<number>/. Give as input a buffer to hold the file
59 * path, the result is PMU loaded using that directory.
60 */
61static struct perf_pmu *test_pmu_get(char *dir, size_t sz)
62{
63 const char *test_hwmon_name_nl = "A test hwmon PMU\n";
64 const char *test_hwmon_name = "A test hwmon PMU";
65 /* Simulated hwmon items. */
66 const struct test_item {
67 const char *name;
68 const char *value;
69 } test_items[] = {
70 { "temp1_label", "test hwmon event1\n", },
71 { "temp1_input", "40000\n", },
72 { "temp2_label", "test hwmon event2\n", },
73 { "temp2_input", "50000\n", },
74 };
75 int hwmon_dirfd = -1, test_dirfd = -1, file;
76 struct perf_pmu *hwm = NULL;
77 ssize_t len;
78
79 /* Create equivalent of sysfs mount point. */
80 scnprintf(buf: dir, size: sz, fmt: "/tmp/perf-hwmon-pmu-test-XXXXXX");
81 if (!mkdtemp(dir)) {
82 pr_err("mkdtemp failed\n");
83 dir[0] = '\0';
84 return NULL;
85 }
86 test_dirfd = open(dir, O_PATH|O_DIRECTORY);
87 if (test_dirfd < 0) {
88 pr_err("Failed to open test directory \"%s\"\n", dir);
89 goto err_out;
90 }
91
92 /* Create the test hwmon directory and give it a name. */
93 if (mkdirat(test_dirfd, "hwmon1234", 0755) < 0) {
94 pr_err("Failed to mkdir hwmon directory\n");
95 goto err_out;
96 }
97 strncat(p: dir, q: "/hwmon1234", count: sz - strlen(dir));
98 hwmon_dirfd = open(dir, O_PATH|O_DIRECTORY);
99 if (hwmon_dirfd < 0) {
100 pr_err("Failed to open test hwmon directory \"%s\"\n", dir);
101 goto err_out;
102 }
103 file = openat(hwmon_dirfd, "name", O_WRONLY | O_CREAT, 0600);
104 if (file < 0) {
105 pr_err("Failed to open for writing file \"name\"\n");
106 goto err_out;
107 }
108 len = strlen(test_hwmon_name_nl);
109 if (write(file, test_hwmon_name_nl, len) < len) {
110 close(file);
111 pr_err("Failed to write to 'name' file\n");
112 goto err_out;
113 }
114 close(file);
115
116 /* Create test hwmon files. */
117 for (size_t i = 0; i < ARRAY_SIZE(test_items); i++) {
118 const struct test_item *item = &test_items[i];
119
120 file = openat(hwmon_dirfd, item->name, O_WRONLY | O_CREAT, 0600);
121 if (file < 0) {
122 pr_err("Failed to open for writing file \"%s\"\n", item->name);
123 goto err_out;
124 }
125
126 if (write(file, item->value, strlen(item->value)) < 0) {
127 pr_err("Failed to write to file \"%s\"\n", item->name);
128 close(file);
129 goto err_out;
130 }
131 close(file);
132 }
133
134 /* Make the PMU reading the files created above. */
135 hwm = perf_pmus__add_test_hwmon_pmu(dir, "hwmon1234", test_hwmon_name);
136 if (!hwm)
137 pr_err("Test hwmon creation failed\n");
138
139err_out:
140 if (!hwm) {
141 test_pmu_put(dir, hwm);
142 }
143 if (test_dirfd >= 0)
144 close(test_dirfd);
145 if (hwmon_dirfd >= 0)
146 close(hwmon_dirfd);
147 return hwm;
148}
149
150static int do_test(size_t i, bool with_pmu, bool with_alias)
151{
152 const char *test_event = with_alias ? test_events[i].alias : test_events[i].name;
153 struct evlist *evlist = evlist__new();
154 struct evsel *evsel;
155 struct parse_events_error err;
156 int ret;
157 char str[128];
158 bool found = false;
159
160 if (!evlist) {
161 pr_err("evlist allocation failed\n");
162 return TEST_FAIL;
163 }
164
165 if (with_pmu)
166 snprintf(buf: str, size: sizeof(str), fmt: "hwmon_a_test_hwmon_pmu/%s/", test_event);
167 else
168 strlcpy(str, test_event, sizeof(str));
169
170 pr_debug("Testing '%s'\n", str);
171 parse_events_error__init(&err);
172 ret = parse_events(evlist, str, &err);
173 if (ret) {
174 pr_debug("FAILED %s:%d failed to parse event '%s', err %d\n",
175 __FILE__, __LINE__, str, ret);
176 parse_events_error__print(&err, str);
177 ret = TEST_FAIL;
178 goto out;
179 }
180
181 ret = TEST_OK;
182 if (with_pmu ? (evlist->core.nr_entries != 1) : (evlist->core.nr_entries < 1)) {
183 pr_debug("FAILED %s:%d Unexpected number of events for '%s' of %d\n",
184 __FILE__, __LINE__, str, evlist->core.nr_entries);
185 ret = TEST_FAIL;
186 goto out;
187 }
188
189 evlist__for_each_entry(evlist, evsel) {
190 if (!evsel->pmu || !evsel->pmu->name ||
191 strcmp(evsel->pmu->name, "hwmon_a_test_hwmon_pmu"))
192 continue;
193
194 if (evsel->core.attr.config != (u64)test_events[i].key.type_and_num) {
195 pr_debug("FAILED %s:%d Unexpected config for '%s', %lld != %ld\n",
196 __FILE__, __LINE__, str,
197 evsel->core.attr.config,
198 test_events[i].key.type_and_num);
199 ret = TEST_FAIL;
200 goto out;
201 }
202 found = true;
203 }
204
205 if (!found) {
206 pr_debug("FAILED %s:%d Didn't find hwmon event '%s' in parsed evsels\n",
207 __FILE__, __LINE__, str);
208 ret = TEST_FAIL;
209 }
210
211out:
212 parse_events_error__exit(&err);
213 evlist__delete(evlist);
214 return ret;
215}
216
217static int test__hwmon_pmu(bool with_pmu)
218{
219 char dir[PATH_MAX];
220 struct perf_pmu *pmu = test_pmu_get(dir, sz: sizeof(dir));
221 int ret = TEST_OK;
222
223 if (!pmu)
224 return TEST_FAIL;
225
226 for (size_t i = 0; i < ARRAY_SIZE(test_events); i++) {
227 ret = do_test(i, with_pmu, /*with_alias=*/false);
228
229 if (ret != TEST_OK)
230 break;
231
232 ret = do_test(i, with_pmu, /*with_alias=*/true);
233
234 if (ret != TEST_OK)
235 break;
236 }
237 test_pmu_put(dir, hwm: pmu);
238 return ret;
239}
240
241static int test__hwmon_pmu_without_pmu(struct test_suite *test __maybe_unused,
242 int subtest __maybe_unused)
243{
244 return test__hwmon_pmu(/*with_pmu=*/false);
245}
246
247static int test__hwmon_pmu_with_pmu(struct test_suite *test __maybe_unused,
248 int subtest __maybe_unused)
249{
250 return test__hwmon_pmu(/*with_pmu=*/true);
251}
252
253static int test__parse_hwmon_filename(struct test_suite *test __maybe_unused,
254 int subtest __maybe_unused)
255{
256 const struct hwmon_parse_test {
257 const char *filename;
258 enum hwmon_type type;
259 int number;
260 enum hwmon_item item;
261 bool alarm;
262 bool parse_ok;
263 } tests[] = {
264 {
265 .filename = "cpu0_accuracy",
266 .type = HWMON_TYPE_CPU,
267 .number = 0,
268 .item = HWMON_ITEM_ACCURACY,
269 .alarm = false,
270 .parse_ok = true,
271 },
272 {
273 .filename = "temp1_input",
274 .type = HWMON_TYPE_TEMP,
275 .number = 1,
276 .item = HWMON_ITEM_INPUT,
277 .alarm = false,
278 .parse_ok = true,
279 },
280 {
281 .filename = "fan2_vid",
282 .type = HWMON_TYPE_FAN,
283 .number = 2,
284 .item = HWMON_ITEM_VID,
285 .alarm = false,
286 .parse_ok = true,
287 },
288 {
289 .filename = "power3_crit_alarm",
290 .type = HWMON_TYPE_POWER,
291 .number = 3,
292 .item = HWMON_ITEM_CRIT,
293 .alarm = true,
294 .parse_ok = true,
295 },
296 {
297 .filename = "intrusion4_average_interval_min_alarm",
298 .type = HWMON_TYPE_INTRUSION,
299 .number = 4,
300 .item = HWMON_ITEM_AVERAGE_INTERVAL_MIN,
301 .alarm = true,
302 .parse_ok = true,
303 },
304 {
305 .filename = "badtype5_baditem",
306 .type = HWMON_TYPE_NONE,
307 .number = 5,
308 .item = HWMON_ITEM_NONE,
309 .alarm = false,
310 .parse_ok = false,
311 },
312 {
313 .filename = "humidity6_baditem",
314 .type = HWMON_TYPE_NONE,
315 .number = 6,
316 .item = HWMON_ITEM_NONE,
317 .alarm = false,
318 .parse_ok = false,
319 },
320 };
321
322 for (size_t i = 0; i < ARRAY_SIZE(tests); i++) {
323 enum hwmon_type type;
324 int number;
325 enum hwmon_item item;
326 bool alarm;
327
328 TEST_ASSERT_EQUAL("parse_hwmon_filename",
329 parse_hwmon_filename(
330 tests[i].filename,
331 &type,
332 &number,
333 &item,
334 &alarm),
335 tests[i].parse_ok
336 );
337 if (tests[i].parse_ok) {
338 TEST_ASSERT_EQUAL("parse_hwmon_filename type", type, tests[i].type);
339 TEST_ASSERT_EQUAL("parse_hwmon_filename number", number, tests[i].number);
340 TEST_ASSERT_EQUAL("parse_hwmon_filename item", item, tests[i].item);
341 TEST_ASSERT_EQUAL("parse_hwmon_filename alarm", alarm, tests[i].alarm);
342 }
343 }
344 return TEST_OK;
345}
346
347static struct test_case tests__hwmon_pmu[] = {
348 TEST_CASE("Basic parsing test", parse_hwmon_filename),
349 TEST_CASE("Parsing without PMU name", hwmon_pmu_without_pmu),
350 TEST_CASE("Parsing with PMU name", hwmon_pmu_with_pmu),
351 { .name = NULL, }
352};
353
354struct test_suite suite__hwmon_pmu = {
355 .desc = "Hwmon PMU",
356 .test_cases = tests__hwmon_pmu,
357};
358

source code of linux/tools/perf/tests/hwmon_pmu.c