sample-parsing.c

  1// SPDX-License-Identifier: GPL-2.0
  2#include <stdbool.h>
  3#include <inttypes.h>
  4#include <stdlib.h>
  5#include <string.h>
  6#include <linux/bitops.h>
  7#include <linux/kernel.h>
  8#include <linux/types.h>
  9
 10#include "map_symbol.h"
 11#include "branch.h"
 12#include "event.h"
 13#include "evsel.h"
 14#include "debug.h"
 15#include "util/synthetic-events.h"
 16#include "util/util.h"
 17
 18#include "tests.h"
 19
 20#define COMP(m) do {					\
 21	if (s1->m != s2->m) {				\
 22		pr_debug("Samples differ at '"#m"'\n");	\
 23		return false;				\
 24	}						\
 25} while (0)
 26
 27#define MCOMP(m) do {					\
 28	if (memcmp(&s1->m, &s2->m, sizeof(s1->m))) {	\
 29		pr_debug("Samples differ at '"#m"'\n");	\
 30		return false;				\
 31	}						\
 32} while (0)
 33
 34/*
 35 * Hardcode the expected values for branch_entry flags.
 36 * These are based on the input value (213) specified
 37 * in branch_stack variable.
 38 */
 39#define BS_EXPECTED_BE	0xa000d00000000000
 40#define BS_EXPECTED_LE	0x1aa00000000
 41#define FLAG(s)	s->branch_stack->entries[i].flags
 42
 43static bool samples_same(struct perf_sample *s1,
 44			 struct perf_sample *s2,
 45			 u64 type, u64 read_format, bool needs_swap)
 46{
 47	size_t i;
 48
 49	if (type & PERF_SAMPLE_IDENTIFIER)
 50		COMP(id);
 51
 52	if (type & PERF_SAMPLE_IP)
 53		COMP(ip);
 54
 55	if (type & PERF_SAMPLE_TID) {
 56		COMP(pid);
 57		COMP(tid);
 58	}
 59
 60	if (type & PERF_SAMPLE_TIME)
 61		COMP(time);
 62
 63	if (type & PERF_SAMPLE_ADDR)
 64		COMP(addr);
 65
 66	if (type & PERF_SAMPLE_ID)
 67		COMP(id);
 68
 69	if (type & PERF_SAMPLE_STREAM_ID)
 70		COMP(stream_id);
 71
 72	if (type & PERF_SAMPLE_CPU)
 73		COMP(cpu);
 74
 75	if (type & PERF_SAMPLE_PERIOD)
 76		COMP(period);
 77
 78	if (type & PERF_SAMPLE_READ) {
 79		if (read_format & PERF_FORMAT_GROUP)
 80			COMP(read.group.nr);
 81		else
 82			COMP(read.one.value);
 83		if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED)
 84			COMP(read.time_enabled);
 85		if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING)
 86			COMP(read.time_running);
 87		/* PERF_FORMAT_ID is forced for PERF_SAMPLE_READ */
 88		if (read_format & PERF_FORMAT_GROUP) {
 89			for (i = 0; i < s1->read.group.nr; i++) {
 90				/* FIXME: check values without LOST */
 91				if (read_format & PERF_FORMAT_LOST)
 92					MCOMP(read.group.values[i]);
 93			}
 94		} else {
 95			COMP(read.one.id);
 96			if (read_format & PERF_FORMAT_LOST)
 97				COMP(read.one.lost);
 98		}
 99	}
100
101	if (type & PERF_SAMPLE_CALLCHAIN) {
102		COMP(callchain->nr);
103		for (i = 0; i < s1->callchain->nr; i++)
104			COMP(callchain->ips[i]);
105	}
106
107	if (type & PERF_SAMPLE_RAW) {
108		COMP(raw_size);
109		if (memcmp(s1->raw_data, s2->raw_data, s1->raw_size)) {
110			pr_debug("Samples differ at 'raw_data'\n");
111			return false;
112		}
113	}
114
115	if (type & PERF_SAMPLE_BRANCH_STACK) {
116		COMP(branch_stack->nr);
117		COMP(branch_stack->hw_idx);
118		for (i = 0; i < s1->branch_stack->nr; i++) {
119			if (needs_swap)
120				return ((host_is_bigendian()) ?
121					(FLAG(s2).value == BS_EXPECTED_BE) :
122					(FLAG(s2).value == BS_EXPECTED_LE));
123			else
124				MCOMP(branch_stack->entries[i]);
125		}
126	}
127
128	if (type & PERF_SAMPLE_REGS_USER) {
129		struct regs_dump *s1_regs = perf_sample__user_regs(s1);
130		struct regs_dump *s2_regs = perf_sample__user_regs(s2);
131		size_t sz = hweight_long(s1_regs->mask) * sizeof(u64);
132
133		COMP(user_regs->mask);
134		COMP(user_regs->abi);
135		if (s1_regs->abi &&
136		    (!s1_regs->regs || !s2_regs->regs ||
137		     memcmp(s1_regs->regs, s2_regs->regs, sz))) {
138			pr_debug("Samples differ at 'user_regs'\n");
139			return false;
140		}
141	}
142
143	if (type & PERF_SAMPLE_STACK_USER) {
144		COMP(user_stack.size);
145		if (memcmp(s1->user_stack.data, s2->user_stack.data,
146			   s1->user_stack.size)) {
147			pr_debug("Samples differ at 'user_stack'\n");
148			return false;
149		}
150	}
151
152	if (type & PERF_SAMPLE_WEIGHT)
153		COMP(weight);
154
155	if (type & PERF_SAMPLE_WEIGHT_STRUCT) {
156		COMP(weight);
157		COMP(ins_lat);
158		COMP(weight3);
159	}
160
161	if (type & PERF_SAMPLE_DATA_SRC)
162		COMP(data_src);
163
164	if (type & PERF_SAMPLE_TRANSACTION)
165		COMP(transaction);
166
167	if (type & PERF_SAMPLE_REGS_INTR) {
168		struct regs_dump *s1_regs = perf_sample__intr_regs(s1);
169		struct regs_dump *s2_regs = perf_sample__intr_regs(s2);
170		size_t sz = hweight_long(s1_regs->mask) * sizeof(u64);
171
172		COMP(intr_regs->mask);
173		COMP(intr_regs->abi);
174		if (s1_regs->abi &&
175		    (!s1_regs->regs || !s2_regs->regs ||
176		     memcmp(s1_regs->regs, s2_regs->regs, sz))) {
177			pr_debug("Samples differ at 'intr_regs'\n");
178			return false;
179		}
180	}
181
182	if (type & PERF_SAMPLE_PHYS_ADDR)
183		COMP(phys_addr);
184
185	if (type & PERF_SAMPLE_CGROUP)
186		COMP(cgroup);
187
188	if (type & PERF_SAMPLE_DATA_PAGE_SIZE)
189		COMP(data_page_size);
190
191	if (type & PERF_SAMPLE_CODE_PAGE_SIZE)
192		COMP(code_page_size);
193
194	if (type & PERF_SAMPLE_AUX) {
195		COMP(aux_sample.size);
196		if (memcmp(s1->aux_sample.data, s2->aux_sample.data,
197			   s1->aux_sample.size)) {
198			pr_debug("Samples differ at 'aux_sample'\n");
199			return false;
200		}
201	}
202
203	return true;
204}
205
206static int do_test(u64 sample_type, u64 sample_regs, u64 read_format)
207{
208	struct evsel evsel = {
209		.needs_swap = false,
210		.core = {
211			. attr = {
212				.sample_type = sample_type,
213				.read_format = read_format,
214			},
215		},
216	};
217	union perf_event *event;
218	union {
219		struct ip_callchain callchain;
220		u64 data[64];
221	} callchain = {
222		/* 3 ips */
223		.data = {3, 201, 202, 203},
224	};
225	union {
226		struct branch_stack branch_stack;
227		u64 data[64];
228	} branch_stack = {
229		/* 1 branch_entry */
230		.data = {1, -1ULL, 211, 212, 213},
231	};
232	u64 regs[64];
233	const u32 raw_data[] = {0x12345678, 0x0a0b0c0d, 0x11020304, 0x05060708, 0 };
234	const u64 data[] = {0x2211443366558877ULL, 0, 0xaabbccddeeff4321ULL};
235	const u64 aux_data[] = {0xa55a, 0, 0xeeddee, 0x0282028202820282};
236	struct regs_dump user_regs = {
237		.abi	= PERF_SAMPLE_REGS_ABI_64,
238		.mask	= sample_regs,
239		.regs	= regs,
240	};
241	struct regs_dump intr_regs = {
242		.abi	= PERF_SAMPLE_REGS_ABI_64,
243		.mask	= sample_regs,
244		.regs	= regs,
245	};
246	struct perf_sample sample = {
247		.ip		= 101,
248		.pid		= 102,
249		.tid		= 103,
250		.time		= 104,
251		.addr		= 105,
252		.id		= 106,
253		.stream_id	= 107,
254		.period		= 108,
255		.weight		= 109,
256		.cpu		= 110,
257		.raw_size	= sizeof(raw_data),
258		.data_src	= 111,
259		.transaction	= 112,
260		.raw_data	= (void *)raw_data,
261		.callchain	= &callchain.callchain,
262		.no_hw_idx      = false,
263		.branch_stack	= &branch_stack.branch_stack,
264		.user_regs	= &user_regs,
265		.user_stack	= {
266			.size	= sizeof(data),
267			.data	= (void *)data,
268		},
269		.read		= {
270			.time_enabled = 0x030a59d664fca7deULL,
271			.time_running = 0x011b6ae553eb98edULL,
272		},
273		.intr_regs	= &intr_regs,
274		.phys_addr	= 113,
275		.cgroup		= 114,
276		.data_page_size = 115,
277		.code_page_size = 116,
278		.ins_lat	= 117,
279		.weight3	= 118,
280		.aux_sample	= {
281			.size	= sizeof(aux_data),
282			.data	= (void *)aux_data,
283		},
284	};
285	struct sample_read_value values[] = {{1, 5, 0}, {9, 3, 0}, {2, 7, 0}, {6, 4, 1},};
286	struct perf_sample sample_out, sample_out_endian;
287	size_t i, sz, bufsz;
288	int err, ret = -1;
289
290	perf_sample__init(&sample_out, /*all=*/false);
291	perf_sample__init(&sample_out_endian, /*all=*/false);
292	if (sample_type & PERF_SAMPLE_REGS_USER)
293		evsel.core.attr.sample_regs_user = sample_regs;
294
295	if (sample_type & PERF_SAMPLE_REGS_INTR)
296		evsel.core.attr.sample_regs_intr = sample_regs;
297
298	if (sample_type & PERF_SAMPLE_BRANCH_STACK)
299		evsel.core.attr.branch_sample_type |= PERF_SAMPLE_BRANCH_HW_INDEX;
300
301	for (i = 0; i < sizeof(regs); i++)
302		*(i + (u8 *)regs) = i & 0xfe;
303
304	if (read_format & PERF_FORMAT_GROUP) {
305		sample.read.group.nr     = 4;
306		sample.read.group.values = values;
307	} else {
308		sample.read.one.value = 0x08789faeb786aa87ULL;
309		sample.read.one.id    = 99;
310		sample.read.one.lost  = 1;
311	}
312
313	sz = perf_event__sample_event_size(&sample, sample_type, read_format);
314	bufsz = sz + 4096; /* Add a bit for overrun checking */
315	event = malloc(bufsz);
316	if (!event) {
317		pr_debug("malloc failed\n");
318		return -1;
319	}
320
321	memset(event, 0xff, bufsz);
322	event->header.type = PERF_RECORD_SAMPLE;
323	event->header.misc = 0;
324	event->header.size = sz;
325
326	err = perf_event__synthesize_sample(event, sample_type, read_format,
327					    &sample);
328	if (err) {
329		pr_debug("%s failed for sample_type %#"PRIx64", error %d\n",
330			 "perf_event__synthesize_sample", sample_type, err);
331		goto out_free;
332	}
333
334	/* The data does not contain 0xff so we use that to check the size */
335	for (i = bufsz; i > 0; i--) {
336		if (*(i - 1 + (u8 *)event) != 0xff)
337			break;
338	}
339	if (i != sz) {
340		pr_debug("Event size mismatch: actual %zu vs expected %zu\n",
341			 i, sz);
342		goto out_free;
343	}
344
345	evsel.sample_size = __evsel__sample_size(sample_type);
346
347	err = evsel__parse_sample(&evsel, event, &sample_out);
348	if (err) {
349		pr_debug("%s failed for sample_type %#"PRIx64", error %d\n",
350			 "evsel__parse_sample", sample_type, err);
351		goto out_free;
352	}
353
354	if (!samples_same(&sample, &sample_out, sample_type, read_format, evsel.needs_swap)) {
355		pr_debug("parsing failed for sample_type %#"PRIx64"\n",
356			 sample_type);
357		goto out_free;
358	}
359
360	if (sample_type == PERF_SAMPLE_BRANCH_STACK) {
361		evsel.needs_swap = true;
362		evsel.sample_size = __evsel__sample_size(sample_type);
363		err = evsel__parse_sample(&evsel, event, &sample_out_endian);
364		if (err) {
365			pr_debug("%s failed for sample_type %#"PRIx64", error %d\n",
366				 "evsel__parse_sample", sample_type, err);
367			goto out_free;
368		}
369
370		if (!samples_same(&sample, &sample_out_endian, sample_type, read_format, evsel.needs_swap)) {
371			pr_debug("parsing failed for sample_type %#"PRIx64"\n",
372				 sample_type);
373			goto out_free;
374		}
375	}
376
377	ret = 0;
378out_free:
379	free(event);
380	perf_sample__exit(&sample_out_endian);
381	perf_sample__exit(&sample_out);
382	if (ret && read_format)
383		pr_debug("read_format %#"PRIx64"\n", read_format);
384	return ret;
385}
386
387/**
388 * test__sample_parsing - test sample parsing.
389 *
390 * This function implements a test that synthesizes a sample event, parses it
391 * and then checks that the parsed sample matches the original sample.  The test
392 * checks sample format bits separately and together.  If the test passes %0 is
393 * returned, otherwise %-1 is returned.
394 */
395static int test__sample_parsing(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
396{
397	const u64 rf[] = {4, 5, 6, 7, 12, 13, 14, 15, 20, 21, 22, 28, 29, 30, 31};
398	u64 sample_type;
399	u64 sample_regs;
400	size_t i;
401	int err;
402
403	/*
404	 * Fail the test if it has not been updated when new sample format bits
405	 * were added.  Please actually update the test rather than just change
406	 * the condition below.
407	 */
408	if (PERF_SAMPLE_MAX > PERF_SAMPLE_WEIGHT_STRUCT << 1) {
409		pr_debug("sample format has changed, some new PERF_SAMPLE_ bit was introduced - test needs updating\n");
410		return -1;
411	}
412
413	/* Test each sample format bit separately */
414	for (sample_type = 1; sample_type != PERF_SAMPLE_MAX;
415	     sample_type <<= 1) {
416		/* Test read_format variations */
417		if (sample_type == PERF_SAMPLE_READ) {
418			for (i = 0; i < ARRAY_SIZE(rf); i++) {
419				err = do_test(sample_type, 0, rf[i]);
420				if (err)
421					return err;
422			}
423			continue;
424		}
425		sample_regs = 0;
426
427		if (sample_type == PERF_SAMPLE_REGS_USER)
428			sample_regs = 0x3fff;
429
430		if (sample_type == PERF_SAMPLE_REGS_INTR)
431			sample_regs = 0xff0fff;
432
433		err = do_test(sample_type, sample_regs, 0);
434		if (err)
435			return err;
436	}
437
438	/*
439	 * Test all sample format bits together
440	 * Note: PERF_SAMPLE_WEIGHT and PERF_SAMPLE_WEIGHT_STRUCT cannot
441	 *       be set simultaneously.
442	 */
443	sample_type = (PERF_SAMPLE_MAX - 1) & ~PERF_SAMPLE_WEIGHT;
444	sample_regs = 0x3fff; /* shared yb intr and user regs */
445	for (i = 0; i < ARRAY_SIZE(rf); i++) {
446		err = do_test(sample_type, sample_regs, rf[i]);
447		if (err)
448			return err;
449	}
450	sample_type = (PERF_SAMPLE_MAX - 1) & ~PERF_SAMPLE_WEIGHT_STRUCT;
451	for (i = 0; i < ARRAY_SIZE(rf); i++) {
452		err = do_test(sample_type, sample_regs, rf[i]);
453		if (err)
454			return err;
455	}
456
457	return 0;
458}
459
460DEFINE_SUITE("Sample parsing", sample_parsing);