1 | // SPDX-License-Identifier: GPL-2.0 |
2 | #include <linux/types.h> |
3 | #include <string.h> |
4 | |
5 | #include "debug.h" |
6 | #include "tests/tests.h" |
7 | #include "arch-tests.h" |
8 | #include "../../../../arch/x86/include/asm/insn.h" |
9 | |
10 | #include "intel-pt-decoder/intel-pt-insn-decoder.h" |
11 | |
12 | struct test_data { |
13 | u8 data[MAX_INSN_SIZE]; |
14 | int expected_length; |
15 | int expected_rel; |
16 | const char *expected_op_str; |
17 | const char *expected_branch_str; |
18 | const char *asm_rep; |
19 | }; |
20 | |
21 | const struct test_data test_data_32[] = { |
22 | #include "insn-x86-dat-32.c" |
23 | {{0x0f, 0x01, 0xee}, 3, 0, NULL, NULL, "0f 01 ee \trdpkru" }, |
24 | {{0x0f, 0x01, 0xef}, 3, 0, NULL, NULL, "0f 01 ef \twrpkru" }, |
25 | {{0}, 0, 0, NULL, NULL, NULL}, |
26 | }; |
27 | |
28 | const struct test_data test_data_64[] = { |
29 | #include "insn-x86-dat-64.c" |
30 | {{0x0f, 0x01, 0xee}, 3, 0, NULL, NULL, "0f 01 ee \trdpkru" }, |
31 | {{0x0f, 0x01, 0xef}, 3, 0, NULL, NULL, "0f 01 ef \twrpkru" }, |
32 | {{0xf2, 0x0f, 0x01, 0xca}, 4, 0, "erets" , "indirect" , "f2 0f 01 ca \terets" }, |
33 | {{0xf3, 0x0f, 0x01, 0xca}, 4, 0, "eretu" , "indirect" , "f3 0f 01 ca \teretu" }, |
34 | {{0}, 0, 0, NULL, NULL, NULL}, |
35 | }; |
36 | |
37 | static int get_op(const char *op_str) |
38 | { |
39 | struct val_data { |
40 | const char *name; |
41 | int val; |
42 | } vals[] = { |
43 | {"other" , INTEL_PT_OP_OTHER}, |
44 | {"call" , INTEL_PT_OP_CALL}, |
45 | {"ret" , INTEL_PT_OP_RET}, |
46 | {"jcc" , INTEL_PT_OP_JCC}, |
47 | {"jmp" , INTEL_PT_OP_JMP}, |
48 | {"loop" , INTEL_PT_OP_LOOP}, |
49 | {"iret" , INTEL_PT_OP_IRET}, |
50 | {"int" , INTEL_PT_OP_INT}, |
51 | {"syscall" , INTEL_PT_OP_SYSCALL}, |
52 | {"sysret" , INTEL_PT_OP_SYSRET}, |
53 | {"vmentry" , INTEL_PT_OP_VMENTRY}, |
54 | {"erets" , INTEL_PT_OP_ERETS}, |
55 | {"eretu" , INTEL_PT_OP_ERETU}, |
56 | {NULL, 0}, |
57 | }; |
58 | struct val_data *val; |
59 | |
60 | if (!op_str || !strlen(op_str)) |
61 | return 0; |
62 | |
63 | for (val = vals; val->name; val++) { |
64 | if (!strcmp(val->name, op_str)) |
65 | return val->val; |
66 | } |
67 | |
68 | pr_debug("Failed to get op\n" ); |
69 | |
70 | return -1; |
71 | } |
72 | |
73 | static int get_branch(const char *branch_str) |
74 | { |
75 | struct val_data { |
76 | const char *name; |
77 | int val; |
78 | } vals[] = { |
79 | {"no_branch" , INTEL_PT_BR_NO_BRANCH}, |
80 | {"indirect" , INTEL_PT_BR_INDIRECT}, |
81 | {"conditional" , INTEL_PT_BR_CONDITIONAL}, |
82 | {"unconditional" , INTEL_PT_BR_UNCONDITIONAL}, |
83 | {NULL, 0}, |
84 | }; |
85 | struct val_data *val; |
86 | |
87 | if (!branch_str || !strlen(branch_str)) |
88 | return 0; |
89 | |
90 | for (val = vals; val->name; val++) { |
91 | if (!strcmp(val->name, branch_str)) |
92 | return val->val; |
93 | } |
94 | |
95 | pr_debug("Failed to get branch\n" ); |
96 | |
97 | return -1; |
98 | } |
99 | |
100 | static int test_data_item(const struct test_data *dat, int x86_64) |
101 | { |
102 | struct intel_pt_insn intel_pt_insn; |
103 | int op, branch, ret; |
104 | struct insn insn; |
105 | |
106 | ret = insn_decode(insn: &insn, kaddr: dat->data, MAX_INSN_SIZE, |
107 | m: x86_64 ? INSN_MODE_64 : INSN_MODE_32); |
108 | if (ret < 0) { |
109 | pr_debug("Failed to decode: %s\n" , dat->asm_rep); |
110 | return -1; |
111 | } |
112 | |
113 | if (insn.length != dat->expected_length) { |
114 | pr_debug("Failed to decode length (%d vs expected %d): %s\n" , |
115 | insn.length, dat->expected_length, dat->asm_rep); |
116 | return -1; |
117 | } |
118 | |
119 | op = get_op(op_str: dat->expected_op_str); |
120 | branch = get_branch(branch_str: dat->expected_branch_str); |
121 | |
122 | if (intel_pt_get_insn(dat->data, MAX_INSN_SIZE, x86_64, &intel_pt_insn)) { |
123 | pr_debug("Intel PT failed to decode: %s\n" , dat->asm_rep); |
124 | return -1; |
125 | } |
126 | |
127 | if ((int)intel_pt_insn.op != op) { |
128 | pr_debug("Failed to decode 'op' value (%d vs expected %d): %s\n" , |
129 | intel_pt_insn.op, op, dat->asm_rep); |
130 | return -1; |
131 | } |
132 | |
133 | if ((int)intel_pt_insn.branch != branch) { |
134 | pr_debug("Failed to decode 'branch' value (%d vs expected %d): %s\n" , |
135 | intel_pt_insn.branch, branch, dat->asm_rep); |
136 | return -1; |
137 | } |
138 | |
139 | if (intel_pt_insn.rel != dat->expected_rel) { |
140 | pr_debug("Failed to decode 'rel' value (%#x vs expected %#x): %s\n" , |
141 | intel_pt_insn.rel, dat->expected_rel, dat->asm_rep); |
142 | return -1; |
143 | } |
144 | |
145 | pr_debug("Decoded ok: %s\n" , dat->asm_rep); |
146 | |
147 | return 0; |
148 | } |
149 | |
150 | static int test_data_set(const struct test_data *dat_set, int x86_64) |
151 | { |
152 | const struct test_data *dat; |
153 | int ret = 0; |
154 | |
155 | for (dat = dat_set; dat->expected_length; dat++) { |
156 | if (test_data_item(dat, x86_64)) |
157 | ret = -1; |
158 | } |
159 | |
160 | return ret; |
161 | } |
162 | |
163 | /** |
164 | * test__insn_x86 - test x86 instruction decoder - new instructions. |
165 | * |
166 | * This function implements a test that decodes a selection of instructions and |
167 | * checks the results. The Intel PT function that further categorizes |
168 | * instructions (i.e. intel_pt_get_insn()) is also checked. |
169 | * |
170 | * The instructions are originally in insn-x86-dat-src.c which has been |
171 | * processed by scripts gen-insn-x86-dat.sh and gen-insn-x86-dat.awk to produce |
172 | * insn-x86-dat-32.c and insn-x86-dat-64.c which are included into this program. |
173 | * i.e. to add new instructions to the test, edit insn-x86-dat-src.c, run the |
174 | * gen-insn-x86-dat.sh script, make perf, and then run the test. |
175 | * |
176 | * If the test passes %0 is returned, otherwise %-1 is returned. Use the |
177 | * verbose (-v) option to see all the instructions and whether or not they |
178 | * decoded successfully. |
179 | */ |
180 | int test__insn_x86(struct test_suite *test __maybe_unused, int subtest __maybe_unused) |
181 | { |
182 | int ret = 0; |
183 | |
184 | if (test_data_set(dat_set: test_data_32, x86_64: 0)) |
185 | ret = -1; |
186 | |
187 | if (test_data_set(dat_set: test_data_64, x86_64: 1)) |
188 | ret = -1; |
189 | |
190 | return ret; |
191 | } |
192 | |