1 // SPDX-License-Identifier: GPL-2.0
2 #include <errno.h>
3 #include <regex.h>
4 #include <string.h>
5 #include <sys/auxv.h>
6 #include <linux/kernel.h>
7 #include <linux/zalloc.h>
8
9 #include "perf_regs.h"
10 #include "../../../perf-sys.h"
11 #include "../../../util/debug.h"
12 #include "../../../util/event.h"
13 #include "../../../util/perf_regs.h"
14
15 #ifndef HWCAP_SVE
16 #define HWCAP_SVE (1 << 22)
17 #endif
18
19 static const struct sample_reg sample_reg_masks[] = {
20 SMPL_REG(x0, PERF_REG_ARM64_X0),
21 SMPL_REG(x1, PERF_REG_ARM64_X1),
22 SMPL_REG(x2, PERF_REG_ARM64_X2),
23 SMPL_REG(x3, PERF_REG_ARM64_X3),
24 SMPL_REG(x4, PERF_REG_ARM64_X4),
25 SMPL_REG(x5, PERF_REG_ARM64_X5),
26 SMPL_REG(x6, PERF_REG_ARM64_X6),
27 SMPL_REG(x7, PERF_REG_ARM64_X7),
28 SMPL_REG(x8, PERF_REG_ARM64_X8),
29 SMPL_REG(x9, PERF_REG_ARM64_X9),
30 SMPL_REG(x10, PERF_REG_ARM64_X10),
31 SMPL_REG(x11, PERF_REG_ARM64_X11),
32 SMPL_REG(x12, PERF_REG_ARM64_X12),
33 SMPL_REG(x13, PERF_REG_ARM64_X13),
34 SMPL_REG(x14, PERF_REG_ARM64_X14),
35 SMPL_REG(x15, PERF_REG_ARM64_X15),
36 SMPL_REG(x16, PERF_REG_ARM64_X16),
37 SMPL_REG(x17, PERF_REG_ARM64_X17),
38 SMPL_REG(x18, PERF_REG_ARM64_X18),
39 SMPL_REG(x19, PERF_REG_ARM64_X19),
40 SMPL_REG(x20, PERF_REG_ARM64_X20),
41 SMPL_REG(x21, PERF_REG_ARM64_X21),
42 SMPL_REG(x22, PERF_REG_ARM64_X22),
43 SMPL_REG(x23, PERF_REG_ARM64_X23),
44 SMPL_REG(x24, PERF_REG_ARM64_X24),
45 SMPL_REG(x25, PERF_REG_ARM64_X25),
46 SMPL_REG(x26, PERF_REG_ARM64_X26),
47 SMPL_REG(x27, PERF_REG_ARM64_X27),
48 SMPL_REG(x28, PERF_REG_ARM64_X28),
49 SMPL_REG(x29, PERF_REG_ARM64_X29),
50 SMPL_REG(lr, PERF_REG_ARM64_LR),
51 SMPL_REG(sp, PERF_REG_ARM64_SP),
52 SMPL_REG(pc, PERF_REG_ARM64_PC),
53 SMPL_REG(vg, PERF_REG_ARM64_VG),
54 SMPL_REG_END
55 };
56
57 /* %xNUM */
58 #define SDT_OP_REGEX1 "^(x[1-2]?[0-9]|3[0-1])$"
59
60 /* [sp], [sp, NUM] */
61 #define SDT_OP_REGEX2 "^\\[sp(, )?([0-9]+)?\\]$"
62
63 static regex_t sdt_op_regex1, sdt_op_regex2;
64
65 static int sdt_init_op_regex(void)
66 {
67 static int initialized;
68 int ret = 0;
69
70 if (initialized)
71 return 0;
72
73 ret = regcomp(&sdt_op_regex1, SDT_OP_REGEX1, REG_EXTENDED);
74 if (ret)
75 goto error;
76
77 ret = regcomp(&sdt_op_regex2, SDT_OP_REGEX2, REG_EXTENDED);
78 if (ret)
79 goto free_regex1;
80
81 initialized = 1;
82 return 0;
83
84 free_regex1:
85 regfree(&sdt_op_regex1);
86 error:
87 pr_debug4("Regex compilation error.\n");
88 return ret;
89 }
90
91 /*
92 * SDT marker arguments on Arm64 uses %xREG or [sp, NUM], currently
93 * support these two formats.
94 */
95 int arch_sdt_arg_parse_op(char *old_op, char **new_op)
96 {
97 int ret, new_len;
98 regmatch_t rm[5];
99
100 ret = sdt_init_op_regex();
101 if (ret < 0)
102 return ret;
103
104 if (!regexec(&sdt_op_regex1, old_op, 3, rm, 0)) {
105 /* Extract xNUM */
106 new_len = 2; /* % NULL */
107 new_len += (int)(rm[1].rm_eo - rm[1].rm_so);
108
109 *new_op = zalloc(new_len);
110 if (!*new_op)
111 return -ENOMEM;
112
113 scnprintf(*new_op, new_len, "%%%.*s",
114 (int)(rm[1].rm_eo - rm[1].rm_so), old_op + rm[1].rm_so);
115 } else if (!regexec(&sdt_op_regex2, old_op, 5, rm, 0)) {
116 /* [sp], [sp, NUM] or [sp,NUM] */
117 new_len = 7; /* + ( % s p ) NULL */
118
119 /* If the argument is [sp], need to fill offset '' */
120 if (rm[2].rm_so == -1)
121 new_len += 1;
122 else
123 new_len += (int)(rm[2].rm_eo - rm[2].rm_so);
124
125 *new_op = zalloc(new_len);
126 if (!*new_op)
127 return -ENOMEM;
128
129 if (rm[2].rm_so == -1)
130 scnprintf(*new_op, new_len, "+0(%%sp)");
131 else
132 scnprintf(*new_op, new_len, "+%.*s(%%sp)",
133 (int)(rm[2].rm_eo - rm[2].rm_so),
134 old_op + rm[2].rm_so);
135 } else {
136 pr_debug4("Skipping unsupported SDT argument: %s\n", old_op);
137 return SDT_ARG_SKIP;
138 }
139
140 return SDT_ARG_VALID;
141 }
142
143 uint64_t arch__intr_reg_mask(void)
144 {
145 return PERF_REGS_MASK;
146 }
147
148 uint64_t arch__user_reg_mask(void)
149 {
150 struct perf_event_attr attr = {
151 .type = PERF_TYPE_HARDWARE,
152 .config = PERF_COUNT_HW_CPU_CYCLES,
153 .sample_type = PERF_SAMPLE_REGS_USER,
154 .disabled = 1,
155 .exclude_kernel = 1,
156 .sample_period = 1,
157 .sample_regs_user = PERF_REGS_MASK
158 };
159 int fd;
160
161 if (getauxval(AT_HWCAP) & HWCAP_SVE)
162 attr.sample_regs_user |= SMPL_REG_MASK(PERF_REG_ARM64_VG);
163
164 /*
165 * Check if the pmu supports perf extended regs, before
166 * returning the register mask to sample.
167 */
168 if (attr.sample_regs_user != PERF_REGS_MASK) {
169 event_attr_init(&attr);
170 fd = sys_perf_event_open(&attr, 0, -1, -1, 0);
171 if (fd != -1) {
172 close(fd);
173 return attr.sample_regs_user;
174 }
175 }
176 return PERF_REGS_MASK;
177 }
178
179 const struct sample_reg *arch__sample_reg_masks(void)
180 {
181 return sample_reg_masks;
182 }
183
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.