1d2912cb1SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-only
2fca08f32SWang Nan /*
3fca08f32SWang Nan * arch/arm/kernel/kprobes-test.c
4fca08f32SWang Nan *
5fca08f32SWang Nan * Copyright (C) 2011 Jon Medhurst <tixy@yxit.co.uk>.
6fca08f32SWang Nan */
7fca08f32SWang Nan
8fca08f32SWang Nan /*
9fca08f32SWang Nan * This file contains test code for ARM kprobes.
10fca08f32SWang Nan *
11fca08f32SWang Nan * The top level function run_all_tests() executes tests for all of the
12fca08f32SWang Nan * supported instruction sets: ARM, 16-bit Thumb, and 32-bit Thumb. These tests
13fca08f32SWang Nan * fall into two categories; run_api_tests() checks basic functionality of the
14fca08f32SWang Nan * kprobes API, and run_test_cases() is a comprehensive test for kprobes
15fca08f32SWang Nan * instruction decoding and simulation.
16fca08f32SWang Nan *
17fca08f32SWang Nan * run_test_cases() first checks the kprobes decoding table for self consistency
18fca08f32SWang Nan * (using table_test()) then executes a series of test cases for each of the CPU
19fca08f32SWang Nan * instruction forms. coverage_start() and coverage_end() are used to verify
20fca08f32SWang Nan * that these test cases cover all of the possible combinations of instructions
21fca08f32SWang Nan * described by the kprobes decoding tables.
22fca08f32SWang Nan *
23fca08f32SWang Nan * The individual test cases are in kprobes-test-arm.c and kprobes-test-thumb.c
24fca08f32SWang Nan * which use the macros defined in kprobes-test.h. The rest of this
25fca08f32SWang Nan * documentation will describe the operation of the framework used by these
26fca08f32SWang Nan * test cases.
27fca08f32SWang Nan */
28fca08f32SWang Nan
29fca08f32SWang Nan /*
30fca08f32SWang Nan * TESTING METHODOLOGY
31fca08f32SWang Nan * -------------------
32fca08f32SWang Nan *
33fca08f32SWang Nan * The methodology used to test an ARM instruction 'test_insn' is to use
34fca08f32SWang Nan * inline assembler like:
35fca08f32SWang Nan *
36fca08f32SWang Nan * test_before: nop
37fca08f32SWang Nan * test_case: test_insn
38fca08f32SWang Nan * test_after: nop
39fca08f32SWang Nan *
40fca08f32SWang Nan * When the test case is run a kprobe is placed of each nop. The
41fca08f32SWang Nan * post-handler of the test_before probe is used to modify the saved CPU
42fca08f32SWang Nan * register context to that which we require for the test case. The
43fca08f32SWang Nan * pre-handler of the of the test_after probe saves a copy of the CPU
44fca08f32SWang Nan * register context. In this way we can execute test_insn with a specific
45fca08f32SWang Nan * register context and see the results afterwards.
46fca08f32SWang Nan *
47fca08f32SWang Nan * To actually test the kprobes instruction emulation we perform the above
48fca08f32SWang Nan * step a second time but with an additional kprobe on the test_case
49fca08f32SWang Nan * instruction itself. If the emulation is accurate then the results seen
50fca08f32SWang Nan * by the test_after probe will be identical to the first run which didn't
51fca08f32SWang Nan * have a probe on test_case.
52fca08f32SWang Nan *
53fca08f32SWang Nan * Each test case is run several times with a variety of variations in the
54fca08f32SWang Nan * flags value of stored in CPSR, and for Thumb code, different ITState.
55fca08f32SWang Nan *
56fca08f32SWang Nan * For instructions which can modify PC, a second test_after probe is used
57fca08f32SWang Nan * like this:
58fca08f32SWang Nan *
59fca08f32SWang Nan * test_before: nop
60fca08f32SWang Nan * test_case: test_insn
61fca08f32SWang Nan * test_after: nop
62fca08f32SWang Nan * b test_done
63fca08f32SWang Nan * test_after2: nop
64fca08f32SWang Nan * test_done:
65fca08f32SWang Nan *
66fca08f32SWang Nan * The test case is constructed such that test_insn branches to
67fca08f32SWang Nan * test_after2, or, if testing a conditional instruction, it may just
68fca08f32SWang Nan * continue to test_after. The probes inserted at both locations let us
69fca08f32SWang Nan * determine which happened. A similar approach is used for testing
70fca08f32SWang Nan * backwards branches...
71fca08f32SWang Nan *
72fca08f32SWang Nan * b test_before
73fca08f32SWang Nan * b test_done @ helps to cope with off by 1 branches
74fca08f32SWang Nan * test_after2: nop
75fca08f32SWang Nan * b test_done
76fca08f32SWang Nan * test_before: nop
77fca08f32SWang Nan * test_case: test_insn
78fca08f32SWang Nan * test_after: nop
79fca08f32SWang Nan * test_done:
80fca08f32SWang Nan *
81fca08f32SWang Nan * The macros used to generate the assembler instructions describe above
82fca08f32SWang Nan * are TEST_INSTRUCTION, TEST_BRANCH_F (branch forwards) and TEST_BRANCH_B
83fca08f32SWang Nan * (branch backwards). In these, the local variables numbered 1, 50, 2 and
84fca08f32SWang Nan * 99 represent: test_before, test_case, test_after2 and test_done.
85fca08f32SWang Nan *
86fca08f32SWang Nan * FRAMEWORK
87fca08f32SWang Nan * ---------
88fca08f32SWang Nan *
89fca08f32SWang Nan * Each test case is wrapped between the pair of macros TESTCASE_START and
90fca08f32SWang Nan * TESTCASE_END. As well as performing the inline assembler boilerplate,
91fca08f32SWang Nan * these call out to the kprobes_test_case_start() and
92fca08f32SWang Nan * kprobes_test_case_end() functions which drive the execution of the test
93fca08f32SWang Nan * case. The specific arguments to use for each test case are stored as
94fca08f32SWang Nan * inline data constructed using the various TEST_ARG_* macros. Putting
95fca08f32SWang Nan * this all together, a simple test case may look like:
96fca08f32SWang Nan *
97fca08f32SWang Nan * TESTCASE_START("Testing mov r0, r7")
98fca08f32SWang Nan * TEST_ARG_REG(7, 0x12345678) // Set r7=0x12345678
99fca08f32SWang Nan * TEST_ARG_END("")
100fca08f32SWang Nan * TEST_INSTRUCTION("mov r0, r7")
101fca08f32SWang Nan * TESTCASE_END
102fca08f32SWang Nan *
103fca08f32SWang Nan * Note, in practice the single convenience macro TEST_R would be used for this
104fca08f32SWang Nan * instead.
105fca08f32SWang Nan *
106fca08f32SWang Nan * The above would expand to assembler looking something like:
107fca08f32SWang Nan *
108fca08f32SWang Nan * @ TESTCASE_START
109fca08f32SWang Nan * bl __kprobes_test_case_start
110fca08f32SWang Nan * .pushsection .rodata
111fca08f32SWang Nan * "10:
112fca08f32SWang Nan * .ascii "mov r0, r7" @ text title for test case
113fca08f32SWang Nan * .byte 0
114fca08f32SWang Nan * .popsection
115fca08f32SWang Nan * @ start of inline data...
116fca08f32SWang Nan * .word 10b @ pointer to title in .rodata section
117fca08f32SWang Nan *
118fca08f32SWang Nan * @ TEST_ARG_REG
119fca08f32SWang Nan * .byte ARG_TYPE_REG
120fca08f32SWang Nan * .byte 7
121fca08f32SWang Nan * .short 0
122fca08f32SWang Nan * .word 0x1234567
123fca08f32SWang Nan *
124fca08f32SWang Nan * @ TEST_ARG_END
125fca08f32SWang Nan * .byte ARG_TYPE_END
126fca08f32SWang Nan * .byte TEST_ISA @ flags, including ISA being tested
127fca08f32SWang Nan * .short 50f-0f @ offset of 'test_before'
128fca08f32SWang Nan * .short 2f-0f @ offset of 'test_after2' (if relevent)
129fca08f32SWang Nan * .short 99f-0f @ offset of 'test_done'
130fca08f32SWang Nan * @ start of test case code...
131fca08f32SWang Nan * 0:
132fca08f32SWang Nan * .code TEST_ISA @ switch to ISA being tested
133fca08f32SWang Nan *
134fca08f32SWang Nan * @ TEST_INSTRUCTION
135fca08f32SWang Nan * 50: nop @ location for 'test_before' probe
136fca08f32SWang Nan * 1: mov r0, r7 @ the test case instruction 'test_insn'
137fca08f32SWang Nan * nop @ location for 'test_after' probe
138fca08f32SWang Nan *
139fca08f32SWang Nan * // TESTCASE_END
140fca08f32SWang Nan * 2:
141fca08f32SWang Nan * 99: bl __kprobes_test_case_end_##TEST_ISA
142fca08f32SWang Nan * .code NONMAL_ISA
143fca08f32SWang Nan *
144fca08f32SWang Nan * When the above is execute the following happens...
145fca08f32SWang Nan *
146fca08f32SWang Nan * __kprobes_test_case_start() is an assembler wrapper which sets up space
147fca08f32SWang Nan * for a stack buffer and calls the C function kprobes_test_case_start().
148fca08f32SWang Nan * This C function will do some initial processing of the inline data and
149fca08f32SWang Nan * setup some global state. It then inserts the test_before and test_after
150fca08f32SWang Nan * kprobes and returns a value which causes the assembler wrapper to jump
151fca08f32SWang Nan * to the start of the test case code, (local label '0').
152fca08f32SWang Nan *
153fca08f32SWang Nan * When the test case code executes, the test_before probe will be hit and
154fca08f32SWang Nan * test_before_post_handler will call setup_test_context(). This fills the
155fca08f32SWang Nan * stack buffer and CPU registers with a test pattern and then processes
156fca08f32SWang Nan * the test case arguments. In our example there is one TEST_ARG_REG which
157fca08f32SWang Nan * indicates that R7 should be loaded with the value 0x12345678.
158fca08f32SWang Nan *
159fca08f32SWang Nan * When the test_before probe ends, the test case continues and executes
160fca08f32SWang Nan * the "mov r0, r7" instruction. It then hits the test_after probe and the
161fca08f32SWang Nan * pre-handler for this (test_after_pre_handler) will save a copy of the
162fca08f32SWang Nan * CPU register context. This should now have R0 holding the same value as
163fca08f32SWang Nan * R7.
164fca08f32SWang Nan *
165fca08f32SWang Nan * Finally we get to the call to __kprobes_test_case_end_{32,16}. This is
166fca08f32SWang Nan * an assembler wrapper which switches back to the ISA used by the test
167fca08f32SWang Nan * code and calls the C function kprobes_test_case_end().
168fca08f32SWang Nan *
169fca08f32SWang Nan * For each run through the test case, test_case_run_count is incremented
170fca08f32SWang Nan * by one. For even runs, kprobes_test_case_end() saves a copy of the
171fca08f32SWang Nan * register and stack buffer contents from the test case just run. It then
172fca08f32SWang Nan * inserts a kprobe on the test case instruction 'test_insn' and returns a
173fca08f32SWang Nan * value to cause the test case code to be re-run.
174fca08f32SWang Nan *
175fca08f32SWang Nan * For odd numbered runs, kprobes_test_case_end() compares the register and
176fca08f32SWang Nan * stack buffer contents to those that were saved on the previous even
177fca08f32SWang Nan * numbered run (the one without the kprobe on test_insn). These should be
178fca08f32SWang Nan * the same if the kprobe instruction simulation routine is correct.
179fca08f32SWang Nan *
180fca08f32SWang Nan * The pair of test case runs is repeated with different combinations of
181fca08f32SWang Nan * flag values in CPSR and, for Thumb, different ITState. This is
182fca08f32SWang Nan * controlled by test_context_cpsr().
183fca08f32SWang Nan *
184fca08f32SWang Nan * BUILDING TEST CASES
185fca08f32SWang Nan * -------------------
186fca08f32SWang Nan *
187fca08f32SWang Nan *
188fca08f32SWang Nan * As an aid to building test cases, the stack buffer is initialised with
189fca08f32SWang Nan * some special values:
190fca08f32SWang Nan *
191fca08f32SWang Nan * [SP+13*4] Contains SP+120. This can be used to test instructions
192fca08f32SWang Nan * which load a value into SP.
193fca08f32SWang Nan *
194fca08f32SWang Nan * [SP+15*4] When testing branching instructions using TEST_BRANCH_{F,B},
195fca08f32SWang Nan * this holds the target address of the branch, 'test_after2'.
196fca08f32SWang Nan * This can be used to test instructions which load a PC value
197fca08f32SWang Nan * from memory.
198fca08f32SWang Nan */
199fca08f32SWang Nan
200fca08f32SWang Nan #include <linux/kernel.h>
201fca08f32SWang Nan #include <linux/module.h>
202fca08f32SWang Nan #include <linux/slab.h>
203e6017571SIngo Molnar #include <linux/sched/clock.h>
204fca08f32SWang Nan #include <linux/kprobes.h>
205fca08f32SWang Nan #include <linux/errno.h>
206fca08f32SWang Nan #include <linux/stddef.h>
207fca08f32SWang Nan #include <linux/bug.h>
208fca08f32SWang Nan #include <asm/opcodes.h>
209fca08f32SWang Nan
210fca08f32SWang Nan #include "core.h"
211fca08f32SWang Nan #include "test-core.h"
212fca08f32SWang Nan #include "../decode-arm.h"
213fca08f32SWang Nan #include "../decode-thumb.h"
214fca08f32SWang Nan
215fca08f32SWang Nan
216fca08f32SWang Nan #define BENCHMARKING 1
217fca08f32SWang Nan
218fca08f32SWang Nan
219fca08f32SWang Nan /*
220fca08f32SWang Nan * Test basic API
221fca08f32SWang Nan */
222fca08f32SWang Nan
223fca08f32SWang Nan static bool test_regs_ok;
224fca08f32SWang Nan static int test_func_instance;
225fca08f32SWang Nan static int pre_handler_called;
226fca08f32SWang Nan static int post_handler_called;
227fca08f32SWang Nan static int kretprobe_handler_called;
228fca08f32SWang Nan static int tests_failed;
229fca08f32SWang Nan
230fca08f32SWang Nan #define FUNC_ARG1 0x12345678
231fca08f32SWang Nan #define FUNC_ARG2 0xabcdef
232fca08f32SWang Nan
233fca08f32SWang Nan
234fca08f32SWang Nan #ifndef CONFIG_THUMB2_KERNEL
235fca08f32SWang Nan
236fb892bd0SJon Medhurst #define RET(reg) "mov pc, "#reg
237fb892bd0SJon Medhurst
238fca08f32SWang Nan long arm_func(long r0, long r1);
239fca08f32SWang Nan
__arm_kprobes_test_func(void)240fca08f32SWang Nan static void __used __naked __arm_kprobes_test_func(void)
241fca08f32SWang Nan {
242fca08f32SWang Nan __asm__ __volatile__ (
243fca08f32SWang Nan ".arm \n\t"
244fca08f32SWang Nan ".type arm_func, %%function \n\t"
245fca08f32SWang Nan "arm_func: \n\t"
246fca08f32SWang Nan "adds r0, r0, r1 \n\t"
247fb892bd0SJon Medhurst "mov pc, lr \n\t"
248fca08f32SWang Nan ".code "NORMAL_ISA /* Back to Thumb if necessary */
249fca08f32SWang Nan : : : "r0", "r1", "cc"
250fca08f32SWang Nan );
251fca08f32SWang Nan }
252fca08f32SWang Nan
253fca08f32SWang Nan #else /* CONFIG_THUMB2_KERNEL */
254fca08f32SWang Nan
255fb892bd0SJon Medhurst #define RET(reg) "bx "#reg
256fb892bd0SJon Medhurst
257fca08f32SWang Nan long thumb16_func(long r0, long r1);
258fca08f32SWang Nan long thumb32even_func(long r0, long r1);
259fca08f32SWang Nan long thumb32odd_func(long r0, long r1);
260fca08f32SWang Nan
__thumb_kprobes_test_funcs(void)261fca08f32SWang Nan static void __used __naked __thumb_kprobes_test_funcs(void)
262fca08f32SWang Nan {
263fca08f32SWang Nan __asm__ __volatile__ (
264fca08f32SWang Nan ".type thumb16_func, %%function \n\t"
265fca08f32SWang Nan "thumb16_func: \n\t"
266fca08f32SWang Nan "adds.n r0, r0, r1 \n\t"
267fca08f32SWang Nan "bx lr \n\t"
268fca08f32SWang Nan
269fca08f32SWang Nan ".align \n\t"
270fca08f32SWang Nan ".type thumb32even_func, %%function \n\t"
271fca08f32SWang Nan "thumb32even_func: \n\t"
272fca08f32SWang Nan "adds.w r0, r0, r1 \n\t"
273fca08f32SWang Nan "bx lr \n\t"
274fca08f32SWang Nan
275fca08f32SWang Nan ".align \n\t"
276fca08f32SWang Nan "nop.n \n\t"
277fca08f32SWang Nan ".type thumb32odd_func, %%function \n\t"
278fca08f32SWang Nan "thumb32odd_func: \n\t"
279fca08f32SWang Nan "adds.w r0, r0, r1 \n\t"
280fca08f32SWang Nan "bx lr \n\t"
281fca08f32SWang Nan
282fca08f32SWang Nan : : : "r0", "r1", "cc"
283fca08f32SWang Nan );
284fca08f32SWang Nan }
285fca08f32SWang Nan
286fca08f32SWang Nan #endif /* CONFIG_THUMB2_KERNEL */
287fca08f32SWang Nan
288fca08f32SWang Nan
call_test_func(long (* func)(long,long),bool check_test_regs)289fca08f32SWang Nan static int call_test_func(long (*func)(long, long), bool check_test_regs)
290fca08f32SWang Nan {
291fca08f32SWang Nan long ret;
292fca08f32SWang Nan
293fca08f32SWang Nan ++test_func_instance;
294fca08f32SWang Nan test_regs_ok = false;
295fca08f32SWang Nan
296fca08f32SWang Nan ret = (*func)(FUNC_ARG1, FUNC_ARG2);
297fca08f32SWang Nan if (ret != FUNC_ARG1 + FUNC_ARG2) {
298fca08f32SWang Nan pr_err("FAIL: call_test_func: func returned %lx\n", ret);
299fca08f32SWang Nan return false;
300fca08f32SWang Nan }
301fca08f32SWang Nan
302fca08f32SWang Nan if (check_test_regs && !test_regs_ok) {
303fca08f32SWang Nan pr_err("FAIL: test regs not OK\n");
304fca08f32SWang Nan return false;
305fca08f32SWang Nan }
306fca08f32SWang Nan
307fca08f32SWang Nan return true;
308fca08f32SWang Nan }
309fca08f32SWang Nan
pre_handler(struct kprobe * p,struct pt_regs * regs)310fca08f32SWang Nan static int __kprobes pre_handler(struct kprobe *p, struct pt_regs *regs)
311fca08f32SWang Nan {
312fca08f32SWang Nan pre_handler_called = test_func_instance;
313fca08f32SWang Nan if (regs->ARM_r0 == FUNC_ARG1 && regs->ARM_r1 == FUNC_ARG2)
314fca08f32SWang Nan test_regs_ok = true;
315fca08f32SWang Nan return 0;
316fca08f32SWang Nan }
317fca08f32SWang Nan
post_handler(struct kprobe * p,struct pt_regs * regs,unsigned long flags)318fca08f32SWang Nan static void __kprobes post_handler(struct kprobe *p, struct pt_regs *regs,
319fca08f32SWang Nan unsigned long flags)
320fca08f32SWang Nan {
321fca08f32SWang Nan post_handler_called = test_func_instance;
322fca08f32SWang Nan if (regs->ARM_r0 != FUNC_ARG1 + FUNC_ARG2 || regs->ARM_r1 != FUNC_ARG2)
323fca08f32SWang Nan test_regs_ok = false;
324fca08f32SWang Nan }
325fca08f32SWang Nan
326fca08f32SWang Nan static struct kprobe the_kprobe = {
327fca08f32SWang Nan .addr = 0,
328fca08f32SWang Nan .pre_handler = pre_handler,
329fca08f32SWang Nan .post_handler = post_handler
330fca08f32SWang Nan };
331fca08f32SWang Nan
test_kprobe(long (* func)(long,long))332fca08f32SWang Nan static int test_kprobe(long (*func)(long, long))
333fca08f32SWang Nan {
334fca08f32SWang Nan int ret;
335fca08f32SWang Nan
336fca08f32SWang Nan the_kprobe.addr = (kprobe_opcode_t *)func;
337fca08f32SWang Nan ret = register_kprobe(&the_kprobe);
338fca08f32SWang Nan if (ret < 0) {
339fca08f32SWang Nan pr_err("FAIL: register_kprobe failed with %d\n", ret);
340fca08f32SWang Nan return ret;
341fca08f32SWang Nan }
342fca08f32SWang Nan
343fca08f32SWang Nan ret = call_test_func(func, true);
344fca08f32SWang Nan
345fca08f32SWang Nan unregister_kprobe(&the_kprobe);
346fca08f32SWang Nan the_kprobe.flags = 0; /* Clear disable flag to allow reuse */
347fca08f32SWang Nan
348fca08f32SWang Nan if (!ret)
349fca08f32SWang Nan return -EINVAL;
350fca08f32SWang Nan if (pre_handler_called != test_func_instance) {
351fca08f32SWang Nan pr_err("FAIL: kprobe pre_handler not called\n");
352fca08f32SWang Nan return -EINVAL;
353fca08f32SWang Nan }
354fca08f32SWang Nan if (post_handler_called != test_func_instance) {
355fca08f32SWang Nan pr_err("FAIL: kprobe post_handler not called\n");
356fca08f32SWang Nan return -EINVAL;
357fca08f32SWang Nan }
358fca08f32SWang Nan if (!call_test_func(func, false))
359fca08f32SWang Nan return -EINVAL;
360fca08f32SWang Nan if (pre_handler_called == test_func_instance ||
361fca08f32SWang Nan post_handler_called == test_func_instance) {
362fca08f32SWang Nan pr_err("FAIL: probe called after unregistering\n");
363fca08f32SWang Nan return -EINVAL;
364fca08f32SWang Nan }
365fca08f32SWang Nan
366fca08f32SWang Nan return 0;
367fca08f32SWang Nan }
368fca08f32SWang Nan
369fca08f32SWang Nan static int __kprobes
kretprobe_handler(struct kretprobe_instance * ri,struct pt_regs * regs)370fca08f32SWang Nan kretprobe_handler(struct kretprobe_instance *ri, struct pt_regs *regs)
371fca08f32SWang Nan {
372fca08f32SWang Nan kretprobe_handler_called = test_func_instance;
373fca08f32SWang Nan if (regs_return_value(regs) == FUNC_ARG1 + FUNC_ARG2)
374fca08f32SWang Nan test_regs_ok = true;
375fca08f32SWang Nan return 0;
376fca08f32SWang Nan }
377fca08f32SWang Nan
378fca08f32SWang Nan static struct kretprobe the_kretprobe = {
379fca08f32SWang Nan .handler = kretprobe_handler,
380fca08f32SWang Nan };
381fca08f32SWang Nan
test_kretprobe(long (* func)(long,long))382fca08f32SWang Nan static int test_kretprobe(long (*func)(long, long))
383fca08f32SWang Nan {
384fca08f32SWang Nan int ret;
385fca08f32SWang Nan
386fca08f32SWang Nan the_kretprobe.kp.addr = (kprobe_opcode_t *)func;
387fca08f32SWang Nan ret = register_kretprobe(&the_kretprobe);
388fca08f32SWang Nan if (ret < 0) {
389fca08f32SWang Nan pr_err("FAIL: register_kretprobe failed with %d\n", ret);
390fca08f32SWang Nan return ret;
391fca08f32SWang Nan }
392fca08f32SWang Nan
393fca08f32SWang Nan ret = call_test_func(func, true);
394fca08f32SWang Nan
395fca08f32SWang Nan unregister_kretprobe(&the_kretprobe);
396fca08f32SWang Nan the_kretprobe.kp.flags = 0; /* Clear disable flag to allow reuse */
397fca08f32SWang Nan
398fca08f32SWang Nan if (!ret)
399fca08f32SWang Nan return -EINVAL;
400fca08f32SWang Nan if (kretprobe_handler_called != test_func_instance) {
401fca08f32SWang Nan pr_err("FAIL: kretprobe handler not called\n");
402fca08f32SWang Nan return -EINVAL;
403fca08f32SWang Nan }
404fca08f32SWang Nan if (!call_test_func(func, false))
405fca08f32SWang Nan return -EINVAL;
4064650209bSMasami Hiramatsu if (kretprobe_handler_called == test_func_instance) {
407fca08f32SWang Nan pr_err("FAIL: kretprobe called after unregistering\n");
408fca08f32SWang Nan return -EINVAL;
409fca08f32SWang Nan }
410fca08f32SWang Nan
411fca08f32SWang Nan return 0;
412fca08f32SWang Nan }
413fca08f32SWang Nan
run_api_tests(long (* func)(long,long))414fca08f32SWang Nan static int run_api_tests(long (*func)(long, long))
415fca08f32SWang Nan {
416fca08f32SWang Nan int ret;
417fca08f32SWang Nan
418fca08f32SWang Nan pr_info(" kprobe\n");
419fca08f32SWang Nan ret = test_kprobe(func);
420fca08f32SWang Nan if (ret < 0)
421fca08f32SWang Nan return ret;
422fca08f32SWang Nan
423fca08f32SWang Nan pr_info(" kretprobe\n");
424fca08f32SWang Nan ret = test_kretprobe(func);
425fca08f32SWang Nan if (ret < 0)
426fca08f32SWang Nan return ret;
427fca08f32SWang Nan
428fca08f32SWang Nan return 0;
429fca08f32SWang Nan }
430fca08f32SWang Nan
431fca08f32SWang Nan
432fca08f32SWang Nan /*
433fca08f32SWang Nan * Benchmarking
434fca08f32SWang Nan */
435fca08f32SWang Nan
436fca08f32SWang Nan #if BENCHMARKING
437fca08f32SWang Nan
benchmark_nop(void)438fca08f32SWang Nan static void __naked benchmark_nop(void)
439fca08f32SWang Nan {
440fca08f32SWang Nan __asm__ __volatile__ (
441fca08f32SWang Nan "nop \n\t"
442fb892bd0SJon Medhurst RET(lr)" \n\t"
443fca08f32SWang Nan );
444fca08f32SWang Nan }
445fca08f32SWang Nan
446fca08f32SWang Nan #ifdef CONFIG_THUMB2_KERNEL
447fca08f32SWang Nan #define wide ".w"
448fca08f32SWang Nan #else
449fca08f32SWang Nan #define wide
450fca08f32SWang Nan #endif
451fca08f32SWang Nan
benchmark_pushpop1(void)452fca08f32SWang Nan static void __naked benchmark_pushpop1(void)
453fca08f32SWang Nan {
454fca08f32SWang Nan __asm__ __volatile__ (
455fca08f32SWang Nan "stmdb"wide" sp!, {r3-r11,lr} \n\t"
456fca08f32SWang Nan "ldmia"wide" sp!, {r3-r11,pc}"
457fca08f32SWang Nan );
458fca08f32SWang Nan }
459fca08f32SWang Nan
benchmark_pushpop2(void)460fca08f32SWang Nan static void __naked benchmark_pushpop2(void)
461fca08f32SWang Nan {
462fca08f32SWang Nan __asm__ __volatile__ (
463fca08f32SWang Nan "stmdb"wide" sp!, {r0-r8,lr} \n\t"
464fca08f32SWang Nan "ldmia"wide" sp!, {r0-r8,pc}"
465fca08f32SWang Nan );
466fca08f32SWang Nan }
467fca08f32SWang Nan
benchmark_pushpop3(void)468fca08f32SWang Nan static void __naked benchmark_pushpop3(void)
469fca08f32SWang Nan {
470fca08f32SWang Nan __asm__ __volatile__ (
471fca08f32SWang Nan "stmdb"wide" sp!, {r4,lr} \n\t"
472fca08f32SWang Nan "ldmia"wide" sp!, {r4,pc}"
473fca08f32SWang Nan );
474fca08f32SWang Nan }
475fca08f32SWang Nan
benchmark_pushpop4(void)476fca08f32SWang Nan static void __naked benchmark_pushpop4(void)
477fca08f32SWang Nan {
478fca08f32SWang Nan __asm__ __volatile__ (
479fca08f32SWang Nan "stmdb"wide" sp!, {r0,lr} \n\t"
480fca08f32SWang Nan "ldmia"wide" sp!, {r0,pc}"
481fca08f32SWang Nan );
482fca08f32SWang Nan }
483fca08f32SWang Nan
484fca08f32SWang Nan
485fca08f32SWang Nan #ifdef CONFIG_THUMB2_KERNEL
486fca08f32SWang Nan
benchmark_pushpop_thumb(void)487fca08f32SWang Nan static void __naked benchmark_pushpop_thumb(void)
488fca08f32SWang Nan {
489fca08f32SWang Nan __asm__ __volatile__ (
490fca08f32SWang Nan "push.n {r0-r7,lr} \n\t"
491fca08f32SWang Nan "pop.n {r0-r7,pc}"
492fca08f32SWang Nan );
493fca08f32SWang Nan }
494fca08f32SWang Nan
495fca08f32SWang Nan #endif
496fca08f32SWang Nan
497fca08f32SWang Nan static int __kprobes
benchmark_pre_handler(struct kprobe * p,struct pt_regs * regs)498fca08f32SWang Nan benchmark_pre_handler(struct kprobe *p, struct pt_regs *regs)
499fca08f32SWang Nan {
500fca08f32SWang Nan return 0;
501fca08f32SWang Nan }
502fca08f32SWang Nan
benchmark(void (* fn)(void))503fca08f32SWang Nan static int benchmark(void(*fn)(void))
504fca08f32SWang Nan {
505fca08f32SWang Nan unsigned n, i, t, t0;
506fca08f32SWang Nan
507fca08f32SWang Nan for (n = 1000; ; n *= 2) {
508fca08f32SWang Nan t0 = sched_clock();
509fca08f32SWang Nan for (i = n; i > 0; --i)
510fca08f32SWang Nan fn();
511fca08f32SWang Nan t = sched_clock() - t0;
512fca08f32SWang Nan if (t >= 250000000)
513fca08f32SWang Nan break; /* Stop once we took more than 0.25 seconds */
514fca08f32SWang Nan }
515fca08f32SWang Nan return t / n; /* Time for one iteration in nanoseconds */
516fca08f32SWang Nan };
517fca08f32SWang Nan
kprobe_benchmark(void (* fn)(void),unsigned offset)518fca08f32SWang Nan static int kprobe_benchmark(void(*fn)(void), unsigned offset)
519fca08f32SWang Nan {
520fca08f32SWang Nan struct kprobe k = {
521fca08f32SWang Nan .addr = (kprobe_opcode_t *)((uintptr_t)fn + offset),
522fca08f32SWang Nan .pre_handler = benchmark_pre_handler,
523fca08f32SWang Nan };
524fca08f32SWang Nan
525fca08f32SWang Nan int ret = register_kprobe(&k);
526fca08f32SWang Nan if (ret < 0) {
527fca08f32SWang Nan pr_err("FAIL: register_kprobe failed with %d\n", ret);
528fca08f32SWang Nan return ret;
529fca08f32SWang Nan }
530fca08f32SWang Nan
531fca08f32SWang Nan ret = benchmark(fn);
532fca08f32SWang Nan
533fca08f32SWang Nan unregister_kprobe(&k);
534fca08f32SWang Nan return ret;
535fca08f32SWang Nan };
536fca08f32SWang Nan
537fca08f32SWang Nan struct benchmarks {
538fca08f32SWang Nan void (*fn)(void);
539fca08f32SWang Nan unsigned offset;
540fca08f32SWang Nan const char *title;
541fca08f32SWang Nan };
542fca08f32SWang Nan
run_benchmarks(void)543fca08f32SWang Nan static int run_benchmarks(void)
544fca08f32SWang Nan {
545fca08f32SWang Nan int ret;
546fca08f32SWang Nan struct benchmarks list[] = {
547fca08f32SWang Nan {&benchmark_nop, 0, "nop"},
548fca08f32SWang Nan /*
549fca08f32SWang Nan * benchmark_pushpop{1,3} will have the optimised
550fca08f32SWang Nan * instruction emulation, whilst benchmark_pushpop{2,4} will
551fca08f32SWang Nan * be the equivalent unoptimised instructions.
552fca08f32SWang Nan */
553fca08f32SWang Nan {&benchmark_pushpop1, 0, "stmdb sp!, {r3-r11,lr}"},
554fca08f32SWang Nan {&benchmark_pushpop1, 4, "ldmia sp!, {r3-r11,pc}"},
555fca08f32SWang Nan {&benchmark_pushpop2, 0, "stmdb sp!, {r0-r8,lr}"},
556fca08f32SWang Nan {&benchmark_pushpop2, 4, "ldmia sp!, {r0-r8,pc}"},
557fca08f32SWang Nan {&benchmark_pushpop3, 0, "stmdb sp!, {r4,lr}"},
558fca08f32SWang Nan {&benchmark_pushpop3, 4, "ldmia sp!, {r4,pc}"},
559fca08f32SWang Nan {&benchmark_pushpop4, 0, "stmdb sp!, {r0,lr}"},
560fca08f32SWang Nan {&benchmark_pushpop4, 4, "ldmia sp!, {r0,pc}"},
561fca08f32SWang Nan #ifdef CONFIG_THUMB2_KERNEL
562fca08f32SWang Nan {&benchmark_pushpop_thumb, 0, "push.n {r0-r7,lr}"},
563fca08f32SWang Nan {&benchmark_pushpop_thumb, 2, "pop.n {r0-r7,pc}"},
564fca08f32SWang Nan #endif
565fca08f32SWang Nan {0}
566fca08f32SWang Nan };
567fca08f32SWang Nan
568fca08f32SWang Nan struct benchmarks *b;
569fca08f32SWang Nan for (b = list; b->fn; ++b) {
570fca08f32SWang Nan ret = kprobe_benchmark(b->fn, b->offset);
571fca08f32SWang Nan if (ret < 0)
572fca08f32SWang Nan return ret;
573fca08f32SWang Nan pr_info(" %dns for kprobe %s\n", ret, b->title);
574fca08f32SWang Nan }
575fca08f32SWang Nan
576fca08f32SWang Nan pr_info("\n");
577fca08f32SWang Nan return 0;
578fca08f32SWang Nan }
579fca08f32SWang Nan
580fca08f32SWang Nan #endif /* BENCHMARKING */
581fca08f32SWang Nan
582fca08f32SWang Nan
583fca08f32SWang Nan /*
584fca08f32SWang Nan * Decoding table self-consistency tests
585fca08f32SWang Nan */
586fca08f32SWang Nan
587fca08f32SWang Nan static const int decode_struct_sizes[NUM_DECODE_TYPES] = {
588fca08f32SWang Nan [DECODE_TYPE_TABLE] = sizeof(struct decode_table),
589fca08f32SWang Nan [DECODE_TYPE_CUSTOM] = sizeof(struct decode_custom),
590fca08f32SWang Nan [DECODE_TYPE_SIMULATE] = sizeof(struct decode_simulate),
591fca08f32SWang Nan [DECODE_TYPE_EMULATE] = sizeof(struct decode_emulate),
592fca08f32SWang Nan [DECODE_TYPE_OR] = sizeof(struct decode_or),
593fca08f32SWang Nan [DECODE_TYPE_REJECT] = sizeof(struct decode_reject)
594fca08f32SWang Nan };
595fca08f32SWang Nan
table_iter(const union decode_item * table,int (* fn)(const struct decode_header *,void *),void * args)596fca08f32SWang Nan static int table_iter(const union decode_item *table,
597fca08f32SWang Nan int (*fn)(const struct decode_header *, void *),
598fca08f32SWang Nan void *args)
599fca08f32SWang Nan {
600fca08f32SWang Nan const struct decode_header *h = (struct decode_header *)table;
601fca08f32SWang Nan int result;
602fca08f32SWang Nan
603fca08f32SWang Nan for (;;) {
604fca08f32SWang Nan enum decode_type type = h->type_regs.bits & DECODE_TYPE_MASK;
605fca08f32SWang Nan
606fca08f32SWang Nan if (type == DECODE_TYPE_END)
607fca08f32SWang Nan return 0;
608fca08f32SWang Nan
609fca08f32SWang Nan result = fn(h, args);
610fca08f32SWang Nan if (result)
611fca08f32SWang Nan return result;
612fca08f32SWang Nan
613fca08f32SWang Nan h = (struct decode_header *)
614fca08f32SWang Nan ((uintptr_t)h + decode_struct_sizes[type]);
615fca08f32SWang Nan
616fca08f32SWang Nan }
617fca08f32SWang Nan }
618fca08f32SWang Nan
table_test_fail(const struct decode_header * h,const char * message)619fca08f32SWang Nan static int table_test_fail(const struct decode_header *h, const char* message)
620fca08f32SWang Nan {
621fca08f32SWang Nan
622fca08f32SWang Nan pr_err("FAIL: kprobes test failure \"%s\" (mask %08x, value %08x)\n",
623fca08f32SWang Nan message, h->mask.bits, h->value.bits);
624fca08f32SWang Nan return -EINVAL;
625fca08f32SWang Nan }
626fca08f32SWang Nan
627fca08f32SWang Nan struct table_test_args {
628fca08f32SWang Nan const union decode_item *root_table;
629fca08f32SWang Nan u32 parent_mask;
630fca08f32SWang Nan u32 parent_value;
631fca08f32SWang Nan };
632fca08f32SWang Nan
table_test_fn(const struct decode_header * h,void * args)633fca08f32SWang Nan static int table_test_fn(const struct decode_header *h, void *args)
634fca08f32SWang Nan {
635fca08f32SWang Nan struct table_test_args *a = (struct table_test_args *)args;
636fca08f32SWang Nan enum decode_type type = h->type_regs.bits & DECODE_TYPE_MASK;
637fca08f32SWang Nan
638fca08f32SWang Nan if (h->value.bits & ~h->mask.bits)
639fca08f32SWang Nan return table_test_fail(h, "Match value has bits not in mask");
640fca08f32SWang Nan
641fca08f32SWang Nan if ((h->mask.bits & a->parent_mask) != a->parent_mask)
642fca08f32SWang Nan return table_test_fail(h, "Mask has bits not in parent mask");
643fca08f32SWang Nan
644fca08f32SWang Nan if ((h->value.bits ^ a->parent_value) & a->parent_mask)
645fca08f32SWang Nan return table_test_fail(h, "Value is inconsistent with parent");
646fca08f32SWang Nan
647fca08f32SWang Nan if (type == DECODE_TYPE_TABLE) {
648fca08f32SWang Nan struct decode_table *d = (struct decode_table *)h;
649fca08f32SWang Nan struct table_test_args args2 = *a;
650fca08f32SWang Nan args2.parent_mask = h->mask.bits;
651fca08f32SWang Nan args2.parent_value = h->value.bits;
652fca08f32SWang Nan return table_iter(d->table.table, table_test_fn, &args2);
653fca08f32SWang Nan }
654fca08f32SWang Nan
655fca08f32SWang Nan return 0;
656fca08f32SWang Nan }
657fca08f32SWang Nan
table_test(const union decode_item * table)658fca08f32SWang Nan static int table_test(const union decode_item *table)
659fca08f32SWang Nan {
660fca08f32SWang Nan struct table_test_args args = {
661fca08f32SWang Nan .root_table = table,
662fca08f32SWang Nan .parent_mask = 0,
663fca08f32SWang Nan .parent_value = 0
664fca08f32SWang Nan };
665fca08f32SWang Nan return table_iter(args.root_table, table_test_fn, &args);
666fca08f32SWang Nan }
667fca08f32SWang Nan
668fca08f32SWang Nan
669fca08f32SWang Nan /*
670fca08f32SWang Nan * Decoding table test coverage analysis
671fca08f32SWang Nan *
672fca08f32SWang Nan * coverage_start() builds a coverage_table which contains a list of
673fca08f32SWang Nan * coverage_entry's to match each entry in the specified kprobes instruction
674fca08f32SWang Nan * decoding table.
675fca08f32SWang Nan *
676fca08f32SWang Nan * When test cases are run, coverage_add() is called to process each case.
677fca08f32SWang Nan * This looks up the corresponding entry in the coverage_table and sets it as
678fca08f32SWang Nan * being matched, as well as clearing the regs flag appropriate for the test.
679fca08f32SWang Nan *
680fca08f32SWang Nan * After all test cases have been run, coverage_end() is called to check that
681fca08f32SWang Nan * all entries in coverage_table have been matched and that all regs flags are
682fca08f32SWang Nan * cleared. I.e. that all possible combinations of instructions described by
683fca08f32SWang Nan * the kprobes decoding tables have had a test case executed for them.
684fca08f32SWang Nan */
685fca08f32SWang Nan
686fca08f32SWang Nan bool coverage_fail;
687fca08f32SWang Nan
688fca08f32SWang Nan #define MAX_COVERAGE_ENTRIES 256
689fca08f32SWang Nan
690fca08f32SWang Nan struct coverage_entry {
691fca08f32SWang Nan const struct decode_header *header;
692fca08f32SWang Nan unsigned regs;
693fca08f32SWang Nan unsigned nesting;
694fca08f32SWang Nan char matched;
695fca08f32SWang Nan };
696fca08f32SWang Nan
697fca08f32SWang Nan struct coverage_table {
698fca08f32SWang Nan struct coverage_entry *base;
699fca08f32SWang Nan unsigned num_entries;
700fca08f32SWang Nan unsigned nesting;
701fca08f32SWang Nan };
702fca08f32SWang Nan
703fca08f32SWang Nan struct coverage_table coverage;
704fca08f32SWang Nan
705fca08f32SWang Nan #define COVERAGE_ANY_REG (1<<0)
706fca08f32SWang Nan #define COVERAGE_SP (1<<1)
707fca08f32SWang Nan #define COVERAGE_PC (1<<2)
708fca08f32SWang Nan #define COVERAGE_PCWB (1<<3)
709fca08f32SWang Nan
710fca08f32SWang Nan static const char coverage_register_lookup[16] = {
711fca08f32SWang Nan [REG_TYPE_ANY] = COVERAGE_ANY_REG | COVERAGE_SP | COVERAGE_PC,
712fca08f32SWang Nan [REG_TYPE_SAMEAS16] = COVERAGE_ANY_REG,
713fca08f32SWang Nan [REG_TYPE_SP] = COVERAGE_SP,
714fca08f32SWang Nan [REG_TYPE_PC] = COVERAGE_PC,
715fca08f32SWang Nan [REG_TYPE_NOSP] = COVERAGE_ANY_REG | COVERAGE_SP,
716fca08f32SWang Nan [REG_TYPE_NOSPPC] = COVERAGE_ANY_REG | COVERAGE_SP | COVERAGE_PC,
717fca08f32SWang Nan [REG_TYPE_NOPC] = COVERAGE_ANY_REG | COVERAGE_PC,
718fca08f32SWang Nan [REG_TYPE_NOPCWB] = COVERAGE_ANY_REG | COVERAGE_PC | COVERAGE_PCWB,
719fca08f32SWang Nan [REG_TYPE_NOPCX] = COVERAGE_ANY_REG,
720fca08f32SWang Nan [REG_TYPE_NOSPPCX] = COVERAGE_ANY_REG | COVERAGE_SP,
721fca08f32SWang Nan };
722fca08f32SWang Nan
coverage_start_registers(const struct decode_header * h)723*1b9c3ddcSArnd Bergmann static unsigned coverage_start_registers(const struct decode_header *h)
724fca08f32SWang Nan {
725fca08f32SWang Nan unsigned regs = 0;
726fca08f32SWang Nan int i;
727fca08f32SWang Nan for (i = 0; i < 20; i += 4) {
728fca08f32SWang Nan int r = (h->type_regs.bits >> (DECODE_TYPE_BITS + i)) & 0xf;
729fca08f32SWang Nan regs |= coverage_register_lookup[r] << i;
730fca08f32SWang Nan }
731fca08f32SWang Nan return regs;
732fca08f32SWang Nan }
733fca08f32SWang Nan
coverage_start_fn(const struct decode_header * h,void * args)734fca08f32SWang Nan static int coverage_start_fn(const struct decode_header *h, void *args)
735fca08f32SWang Nan {
736fca08f32SWang Nan struct coverage_table *coverage = (struct coverage_table *)args;
737fca08f32SWang Nan enum decode_type type = h->type_regs.bits & DECODE_TYPE_MASK;
738fca08f32SWang Nan struct coverage_entry *entry = coverage->base + coverage->num_entries;
739fca08f32SWang Nan
740fca08f32SWang Nan if (coverage->num_entries == MAX_COVERAGE_ENTRIES - 1) {
741fca08f32SWang Nan pr_err("FAIL: Out of space for test coverage data");
742fca08f32SWang Nan return -ENOMEM;
743fca08f32SWang Nan }
744fca08f32SWang Nan
745fca08f32SWang Nan ++coverage->num_entries;
746fca08f32SWang Nan
747fca08f32SWang Nan entry->header = h;
748fca08f32SWang Nan entry->regs = coverage_start_registers(h);
749fca08f32SWang Nan entry->nesting = coverage->nesting;
750fca08f32SWang Nan entry->matched = false;
751fca08f32SWang Nan
752fca08f32SWang Nan if (type == DECODE_TYPE_TABLE) {
753fca08f32SWang Nan struct decode_table *d = (struct decode_table *)h;
754fca08f32SWang Nan int ret;
755fca08f32SWang Nan ++coverage->nesting;
756fca08f32SWang Nan ret = table_iter(d->table.table, coverage_start_fn, coverage);
757fca08f32SWang Nan --coverage->nesting;
758fca08f32SWang Nan return ret;
759fca08f32SWang Nan }
760fca08f32SWang Nan
761fca08f32SWang Nan return 0;
762fca08f32SWang Nan }
763fca08f32SWang Nan
coverage_start(const union decode_item * table)764fca08f32SWang Nan static int coverage_start(const union decode_item *table)
765fca08f32SWang Nan {
7666da2ec56SKees Cook coverage.base = kmalloc_array(MAX_COVERAGE_ENTRIES,
7676da2ec56SKees Cook sizeof(struct coverage_entry),
7686da2ec56SKees Cook GFP_KERNEL);
769fca08f32SWang Nan coverage.num_entries = 0;
770fca08f32SWang Nan coverage.nesting = 0;
771fca08f32SWang Nan return table_iter(table, coverage_start_fn, &coverage);
772fca08f32SWang Nan }
773fca08f32SWang Nan
774fca08f32SWang Nan static void
coverage_add_registers(struct coverage_entry * entry,kprobe_opcode_t insn)775fca08f32SWang Nan coverage_add_registers(struct coverage_entry *entry, kprobe_opcode_t insn)
776fca08f32SWang Nan {
777fca08f32SWang Nan int regs = entry->header->type_regs.bits >> DECODE_TYPE_BITS;
778fca08f32SWang Nan int i;
779fca08f32SWang Nan for (i = 0; i < 20; i += 4) {
780fca08f32SWang Nan enum decode_reg_type reg_type = (regs >> i) & 0xf;
781fca08f32SWang Nan int reg = (insn >> i) & 0xf;
782fca08f32SWang Nan int flag;
783fca08f32SWang Nan
784fca08f32SWang Nan if (!reg_type)
785fca08f32SWang Nan continue;
786fca08f32SWang Nan
787fca08f32SWang Nan if (reg == 13)
788fca08f32SWang Nan flag = COVERAGE_SP;
789fca08f32SWang Nan else if (reg == 15)
790fca08f32SWang Nan flag = COVERAGE_PC;
791fca08f32SWang Nan else
792fca08f32SWang Nan flag = COVERAGE_ANY_REG;
793fca08f32SWang Nan entry->regs &= ~(flag << i);
794fca08f32SWang Nan
795fca08f32SWang Nan switch (reg_type) {
796fca08f32SWang Nan
797fca08f32SWang Nan case REG_TYPE_NONE:
798fca08f32SWang Nan case REG_TYPE_ANY:
799fca08f32SWang Nan case REG_TYPE_SAMEAS16:
800fca08f32SWang Nan break;
801fca08f32SWang Nan
802fca08f32SWang Nan case REG_TYPE_SP:
803fca08f32SWang Nan if (reg != 13)
804fca08f32SWang Nan return;
805fca08f32SWang Nan break;
806fca08f32SWang Nan
807fca08f32SWang Nan case REG_TYPE_PC:
808fca08f32SWang Nan if (reg != 15)
809fca08f32SWang Nan return;
810fca08f32SWang Nan break;
811fca08f32SWang Nan
812fca08f32SWang Nan case REG_TYPE_NOSP:
813fca08f32SWang Nan if (reg == 13)
814fca08f32SWang Nan return;
815fca08f32SWang Nan break;
816fca08f32SWang Nan
817fca08f32SWang Nan case REG_TYPE_NOSPPC:
818fca08f32SWang Nan case REG_TYPE_NOSPPCX:
819fca08f32SWang Nan if (reg == 13 || reg == 15)
820fca08f32SWang Nan return;
821fca08f32SWang Nan break;
822fca08f32SWang Nan
823fca08f32SWang Nan case REG_TYPE_NOPCWB:
824fca08f32SWang Nan if (!is_writeback(insn))
825fca08f32SWang Nan break;
826fca08f32SWang Nan if (reg == 15) {
827fca08f32SWang Nan entry->regs &= ~(COVERAGE_PCWB << i);
828fca08f32SWang Nan return;
829fca08f32SWang Nan }
830fca08f32SWang Nan break;
831fca08f32SWang Nan
832fca08f32SWang Nan case REG_TYPE_NOPC:
833fca08f32SWang Nan case REG_TYPE_NOPCX:
834fca08f32SWang Nan if (reg == 15)
835fca08f32SWang Nan return;
836fca08f32SWang Nan break;
837fca08f32SWang Nan }
838fca08f32SWang Nan
839fca08f32SWang Nan }
840fca08f32SWang Nan }
841fca08f32SWang Nan
coverage_add(kprobe_opcode_t insn)842fca08f32SWang Nan static void coverage_add(kprobe_opcode_t insn)
843fca08f32SWang Nan {
844fca08f32SWang Nan struct coverage_entry *entry = coverage.base;
845fca08f32SWang Nan struct coverage_entry *end = coverage.base + coverage.num_entries;
846fca08f32SWang Nan bool matched = false;
847fca08f32SWang Nan unsigned nesting = 0;
848fca08f32SWang Nan
849fca08f32SWang Nan for (; entry < end; ++entry) {
850fca08f32SWang Nan const struct decode_header *h = entry->header;
851fca08f32SWang Nan enum decode_type type = h->type_regs.bits & DECODE_TYPE_MASK;
852fca08f32SWang Nan
853fca08f32SWang Nan if (entry->nesting > nesting)
854fca08f32SWang Nan continue; /* Skip sub-table we didn't match */
855fca08f32SWang Nan
856fca08f32SWang Nan if (entry->nesting < nesting)
857fca08f32SWang Nan break; /* End of sub-table we were scanning */
858fca08f32SWang Nan
859fca08f32SWang Nan if (!matched) {
860fca08f32SWang Nan if ((insn & h->mask.bits) != h->value.bits)
861fca08f32SWang Nan continue;
862fca08f32SWang Nan entry->matched = true;
863fca08f32SWang Nan }
864fca08f32SWang Nan
865fca08f32SWang Nan switch (type) {
866fca08f32SWang Nan
867fca08f32SWang Nan case DECODE_TYPE_TABLE:
868fca08f32SWang Nan ++nesting;
869fca08f32SWang Nan break;
870fca08f32SWang Nan
871fca08f32SWang Nan case DECODE_TYPE_CUSTOM:
872fca08f32SWang Nan case DECODE_TYPE_SIMULATE:
873fca08f32SWang Nan case DECODE_TYPE_EMULATE:
874fca08f32SWang Nan coverage_add_registers(entry, insn);
875fca08f32SWang Nan return;
876fca08f32SWang Nan
877fca08f32SWang Nan case DECODE_TYPE_OR:
878fca08f32SWang Nan matched = true;
879fca08f32SWang Nan break;
880fca08f32SWang Nan
881fca08f32SWang Nan case DECODE_TYPE_REJECT:
882fca08f32SWang Nan default:
883fca08f32SWang Nan return;
884fca08f32SWang Nan }
885fca08f32SWang Nan
886fca08f32SWang Nan }
887fca08f32SWang Nan }
888fca08f32SWang Nan
coverage_end(void)889fca08f32SWang Nan static void coverage_end(void)
890fca08f32SWang Nan {
891fca08f32SWang Nan struct coverage_entry *entry = coverage.base;
892fca08f32SWang Nan struct coverage_entry *end = coverage.base + coverage.num_entries;
893fca08f32SWang Nan
894fca08f32SWang Nan for (; entry < end; ++entry) {
895fca08f32SWang Nan u32 mask = entry->header->mask.bits;
896fca08f32SWang Nan u32 value = entry->header->value.bits;
897fca08f32SWang Nan
898fca08f32SWang Nan if (entry->regs) {
899fca08f32SWang Nan pr_err("FAIL: Register test coverage missing for %08x %08x (%05x)\n",
900fca08f32SWang Nan mask, value, entry->regs);
901fca08f32SWang Nan coverage_fail = true;
902fca08f32SWang Nan }
903fca08f32SWang Nan if (!entry->matched) {
904fca08f32SWang Nan pr_err("FAIL: Test coverage entry missing for %08x %08x\n",
905fca08f32SWang Nan mask, value);
906fca08f32SWang Nan coverage_fail = true;
907fca08f32SWang Nan }
908fca08f32SWang Nan }
909fca08f32SWang Nan
910fca08f32SWang Nan kfree(coverage.base);
911fca08f32SWang Nan }
912fca08f32SWang Nan
913fca08f32SWang Nan
914fca08f32SWang Nan /*
915fca08f32SWang Nan * Framework for instruction set test cases
916fca08f32SWang Nan */
917fca08f32SWang Nan
__kprobes_test_case_start(void)918fca08f32SWang Nan void __naked __kprobes_test_case_start(void)
919fca08f32SWang Nan {
920fca08f32SWang Nan __asm__ __volatile__ (
921974310d0SJon Medhurst "mov r2, sp \n\t"
922974310d0SJon Medhurst "bic r3, r2, #7 \n\t"
923974310d0SJon Medhurst "mov sp, r3 \n\t"
924974310d0SJon Medhurst "stmdb sp!, {r2-r11} \n\t"
925fca08f32SWang Nan "sub sp, sp, #"__stringify(TEST_MEMORY_SIZE)"\n\t"
926fca08f32SWang Nan "bic r0, lr, #1 @ r0 = inline data \n\t"
927fca08f32SWang Nan "mov r1, sp \n\t"
928fca08f32SWang Nan "bl kprobes_test_case_start \n\t"
929fb892bd0SJon Medhurst RET(r0)" \n\t"
930fca08f32SWang Nan );
931fca08f32SWang Nan }
932fca08f32SWang Nan
933fca08f32SWang Nan #ifndef CONFIG_THUMB2_KERNEL
934fca08f32SWang Nan
__kprobes_test_case_end_32(void)935fca08f32SWang Nan void __naked __kprobes_test_case_end_32(void)
936fca08f32SWang Nan {
937fca08f32SWang Nan __asm__ __volatile__ (
938fca08f32SWang Nan "mov r4, lr \n\t"
939fca08f32SWang Nan "bl kprobes_test_case_end \n\t"
940fca08f32SWang Nan "cmp r0, #0 \n\t"
941fca08f32SWang Nan "movne pc, r0 \n\t"
942fca08f32SWang Nan "mov r0, r4 \n\t"
943fca08f32SWang Nan "add sp, sp, #"__stringify(TEST_MEMORY_SIZE)"\n\t"
944974310d0SJon Medhurst "ldmia sp!, {r2-r11} \n\t"
945974310d0SJon Medhurst "mov sp, r2 \n\t"
946fca08f32SWang Nan "mov pc, r0 \n\t"
947fca08f32SWang Nan );
948fca08f32SWang Nan }
949fca08f32SWang Nan
950fca08f32SWang Nan #else /* CONFIG_THUMB2_KERNEL */
951fca08f32SWang Nan
__kprobes_test_case_end_16(void)952fca08f32SWang Nan void __naked __kprobes_test_case_end_16(void)
953fca08f32SWang Nan {
954fca08f32SWang Nan __asm__ __volatile__ (
955fca08f32SWang Nan "mov r4, lr \n\t"
956fca08f32SWang Nan "bl kprobes_test_case_end \n\t"
957fca08f32SWang Nan "cmp r0, #0 \n\t"
958fca08f32SWang Nan "bxne r0 \n\t"
959fca08f32SWang Nan "mov r0, r4 \n\t"
960fca08f32SWang Nan "add sp, sp, #"__stringify(TEST_MEMORY_SIZE)"\n\t"
961974310d0SJon Medhurst "ldmia sp!, {r2-r11} \n\t"
962974310d0SJon Medhurst "mov sp, r2 \n\t"
963fca08f32SWang Nan "bx r0 \n\t"
964fca08f32SWang Nan );
965fca08f32SWang Nan }
966fca08f32SWang Nan
__kprobes_test_case_end_32(void)967fca08f32SWang Nan void __naked __kprobes_test_case_end_32(void)
968fca08f32SWang Nan {
969fca08f32SWang Nan __asm__ __volatile__ (
970fca08f32SWang Nan ".arm \n\t"
971fca08f32SWang Nan "orr lr, lr, #1 @ will return to Thumb code \n\t"
972fca08f32SWang Nan "ldr pc, 1f \n\t"
973fca08f32SWang Nan "1: \n\t"
974fca08f32SWang Nan ".word __kprobes_test_case_end_16 \n\t"
975fca08f32SWang Nan );
976fca08f32SWang Nan }
977fca08f32SWang Nan
978fca08f32SWang Nan #endif
979fca08f32SWang Nan
980fca08f32SWang Nan
981fca08f32SWang Nan int kprobe_test_flags;
982fca08f32SWang Nan int kprobe_test_cc_position;
983fca08f32SWang Nan
984fca08f32SWang Nan static int test_try_count;
985fca08f32SWang Nan static int test_pass_count;
986fca08f32SWang Nan static int test_fail_count;
987fca08f32SWang Nan
988fca08f32SWang Nan static struct pt_regs initial_regs;
989fca08f32SWang Nan static struct pt_regs expected_regs;
990fca08f32SWang Nan static struct pt_regs result_regs;
991fca08f32SWang Nan
992fca08f32SWang Nan static u32 expected_memory[TEST_MEMORY_SIZE/sizeof(u32)];
993fca08f32SWang Nan
994fca08f32SWang Nan static const char *current_title;
995fca08f32SWang Nan static struct test_arg *current_args;
996fca08f32SWang Nan static u32 *current_stack;
997fca08f32SWang Nan static uintptr_t current_branch_target;
998fca08f32SWang Nan
999fca08f32SWang Nan static uintptr_t current_code_start;
1000fca08f32SWang Nan static kprobe_opcode_t current_instruction;
1001fca08f32SWang Nan
1002fca08f32SWang Nan
1003fca08f32SWang Nan #define TEST_CASE_PASSED -1
1004fca08f32SWang Nan #define TEST_CASE_FAILED -2
1005fca08f32SWang Nan
1006fca08f32SWang Nan static int test_case_run_count;
1007fca08f32SWang Nan static bool test_case_is_thumb;
1008fca08f32SWang Nan static int test_instance;
1009fca08f32SWang Nan
test_check_cc(int cc,unsigned long cpsr)1010fca08f32SWang Nan static unsigned long test_check_cc(int cc, unsigned long cpsr)
1011fca08f32SWang Nan {
1012fca08f32SWang Nan int ret = arm_check_condition(cc << 28, cpsr);
1013fca08f32SWang Nan
1014fca08f32SWang Nan return (ret != ARM_OPCODE_CONDTEST_FAIL);
1015fca08f32SWang Nan }
1016fca08f32SWang Nan
1017fca08f32SWang Nan static int is_last_scenario;
1018fca08f32SWang Nan static int probe_should_run; /* 0 = no, 1 = yes, -1 = unknown */
1019fca08f32SWang Nan static int memory_needs_checking;
1020fca08f32SWang Nan
test_context_cpsr(int scenario)1021fca08f32SWang Nan static unsigned long test_context_cpsr(int scenario)
1022fca08f32SWang Nan {
1023fca08f32SWang Nan unsigned long cpsr;
1024fca08f32SWang Nan
1025fca08f32SWang Nan probe_should_run = 1;
1026fca08f32SWang Nan
1027fca08f32SWang Nan /* Default case is that we cycle through 16 combinations of flags */
1028fca08f32SWang Nan cpsr = (scenario & 0xf) << 28; /* N,Z,C,V flags */
1029fca08f32SWang Nan cpsr |= (scenario & 0xf) << 16; /* GE flags */
1030fca08f32SWang Nan cpsr |= (scenario & 0x1) << 27; /* Toggle Q flag */
1031fca08f32SWang Nan
1032fca08f32SWang Nan if (!test_case_is_thumb) {
1033fca08f32SWang Nan /* Testing ARM code */
1034fca08f32SWang Nan int cc = current_instruction >> 28;
1035fca08f32SWang Nan
1036fca08f32SWang Nan probe_should_run = test_check_cc(cc, cpsr) != 0;
1037fca08f32SWang Nan if (scenario == 15)
1038fca08f32SWang Nan is_last_scenario = true;
1039fca08f32SWang Nan
1040fca08f32SWang Nan } else if (kprobe_test_flags & TEST_FLAG_NO_ITBLOCK) {
1041fca08f32SWang Nan /* Testing Thumb code without setting ITSTATE */
1042fca08f32SWang Nan if (kprobe_test_cc_position) {
1043fca08f32SWang Nan int cc = (current_instruction >> kprobe_test_cc_position) & 0xf;
1044fca08f32SWang Nan probe_should_run = test_check_cc(cc, cpsr) != 0;
1045fca08f32SWang Nan }
1046fca08f32SWang Nan
1047fca08f32SWang Nan if (scenario == 15)
1048fca08f32SWang Nan is_last_scenario = true;
1049fca08f32SWang Nan
1050fca08f32SWang Nan } else if (kprobe_test_flags & TEST_FLAG_FULL_ITBLOCK) {
1051fca08f32SWang Nan /* Testing Thumb code with all combinations of ITSTATE */
1052fca08f32SWang Nan unsigned x = (scenario >> 4);
1053fca08f32SWang Nan unsigned cond_base = x % 7; /* ITSTATE<7:5> */
1054fca08f32SWang Nan unsigned mask = x / 7 + 2; /* ITSTATE<4:0>, bits reversed */
1055fca08f32SWang Nan
1056fca08f32SWang Nan if (mask > 0x1f) {
1057fca08f32SWang Nan /* Finish by testing state from instruction 'itt al' */
1058fca08f32SWang Nan cond_base = 7;
1059fca08f32SWang Nan mask = 0x4;
1060fca08f32SWang Nan if ((scenario & 0xf) == 0xf)
1061fca08f32SWang Nan is_last_scenario = true;
1062fca08f32SWang Nan }
1063fca08f32SWang Nan
1064fca08f32SWang Nan cpsr |= cond_base << 13; /* ITSTATE<7:5> */
1065fca08f32SWang Nan cpsr |= (mask & 0x1) << 12; /* ITSTATE<4> */
1066fca08f32SWang Nan cpsr |= (mask & 0x2) << 10; /* ITSTATE<3> */
1067fca08f32SWang Nan cpsr |= (mask & 0x4) << 8; /* ITSTATE<2> */
1068fca08f32SWang Nan cpsr |= (mask & 0x8) << 23; /* ITSTATE<1> */
1069fca08f32SWang Nan cpsr |= (mask & 0x10) << 21; /* ITSTATE<0> */
1070fca08f32SWang Nan
1071fca08f32SWang Nan probe_should_run = test_check_cc((cpsr >> 12) & 0xf, cpsr) != 0;
1072fca08f32SWang Nan
1073fca08f32SWang Nan } else {
1074fca08f32SWang Nan /* Testing Thumb code with several combinations of ITSTATE */
1075fca08f32SWang Nan switch (scenario) {
1076fca08f32SWang Nan case 16: /* Clear NZCV flags and 'it eq' state (false as Z=0) */
1077fca08f32SWang Nan cpsr = 0x00000800;
1078fca08f32SWang Nan probe_should_run = 0;
1079fca08f32SWang Nan break;
1080fca08f32SWang Nan case 17: /* Set NZCV flags and 'it vc' state (false as V=1) */
1081fca08f32SWang Nan cpsr = 0xf0007800;
1082fca08f32SWang Nan probe_should_run = 0;
1083fca08f32SWang Nan break;
1084fca08f32SWang Nan case 18: /* Clear NZCV flags and 'it ls' state (true as C=0) */
1085fca08f32SWang Nan cpsr = 0x00009800;
1086fca08f32SWang Nan break;
1087fca08f32SWang Nan case 19: /* Set NZCV flags and 'it cs' state (true as C=1) */
1088fca08f32SWang Nan cpsr = 0xf0002800;
1089fca08f32SWang Nan is_last_scenario = true;
1090fca08f32SWang Nan break;
1091fca08f32SWang Nan }
1092fca08f32SWang Nan }
1093fca08f32SWang Nan
1094fca08f32SWang Nan return cpsr;
1095fca08f32SWang Nan }
1096fca08f32SWang Nan
setup_test_context(struct pt_regs * regs)1097fca08f32SWang Nan static void setup_test_context(struct pt_regs *regs)
1098fca08f32SWang Nan {
1099fca08f32SWang Nan int scenario = test_case_run_count>>1;
1100fca08f32SWang Nan unsigned long val;
1101fca08f32SWang Nan struct test_arg *args;
1102fca08f32SWang Nan int i;
1103fca08f32SWang Nan
1104fca08f32SWang Nan is_last_scenario = false;
1105fca08f32SWang Nan memory_needs_checking = false;
1106fca08f32SWang Nan
1107fca08f32SWang Nan /* Initialise test memory on stack */
1108fca08f32SWang Nan val = (scenario & 1) ? VALM : ~VALM;
1109fca08f32SWang Nan for (i = 0; i < TEST_MEMORY_SIZE / sizeof(current_stack[0]); ++i)
1110fca08f32SWang Nan current_stack[i] = val + (i << 8);
1111fca08f32SWang Nan /* Put target of branch on stack for tests which load PC from memory */
1112fca08f32SWang Nan if (current_branch_target)
1113fca08f32SWang Nan current_stack[15] = current_branch_target;
1114fca08f32SWang Nan /* Put a value for SP on stack for tests which load SP from memory */
1115fca08f32SWang Nan current_stack[13] = (u32)current_stack + 120;
1116fca08f32SWang Nan
1117fca08f32SWang Nan /* Initialise register values to their default state */
1118fca08f32SWang Nan val = (scenario & 2) ? VALR : ~VALR;
1119fca08f32SWang Nan for (i = 0; i < 13; ++i)
1120fca08f32SWang Nan regs->uregs[i] = val ^ (i << 8);
1121fca08f32SWang Nan regs->ARM_lr = val ^ (14 << 8);
1122fca08f32SWang Nan regs->ARM_cpsr &= ~(APSR_MASK | PSR_IT_MASK);
1123fca08f32SWang Nan regs->ARM_cpsr |= test_context_cpsr(scenario);
1124fca08f32SWang Nan
1125fca08f32SWang Nan /* Perform testcase specific register setup */
1126fca08f32SWang Nan args = current_args;
1127fca08f32SWang Nan for (; args[0].type != ARG_TYPE_END; ++args)
1128fca08f32SWang Nan switch (args[0].type) {
1129fca08f32SWang Nan case ARG_TYPE_REG: {
1130fca08f32SWang Nan struct test_arg_regptr *arg =
1131fca08f32SWang Nan (struct test_arg_regptr *)args;
1132fca08f32SWang Nan regs->uregs[arg->reg] = arg->val;
1133fca08f32SWang Nan break;
1134fca08f32SWang Nan }
1135fca08f32SWang Nan case ARG_TYPE_PTR: {
1136fca08f32SWang Nan struct test_arg_regptr *arg =
1137fca08f32SWang Nan (struct test_arg_regptr *)args;
1138fca08f32SWang Nan regs->uregs[arg->reg] =
1139fca08f32SWang Nan (unsigned long)current_stack + arg->val;
1140fca08f32SWang Nan memory_needs_checking = true;
11418d257e95SJon Medhurst (Tixy) /*
11428d257e95SJon Medhurst (Tixy) * Test memory at an address below SP is in danger of
11438d257e95SJon Medhurst (Tixy) * being altered by an interrupt occurring and pushing
11448d257e95SJon Medhurst (Tixy) * data onto the stack. Disable interrupts to stop this.
11458d257e95SJon Medhurst (Tixy) */
11468d257e95SJon Medhurst (Tixy) if (arg->reg == 13)
11478d257e95SJon Medhurst (Tixy) regs->ARM_cpsr |= PSR_I_BIT;
1148fca08f32SWang Nan break;
1149fca08f32SWang Nan }
1150fca08f32SWang Nan case ARG_TYPE_MEM: {
1151fca08f32SWang Nan struct test_arg_mem *arg = (struct test_arg_mem *)args;
1152fca08f32SWang Nan current_stack[arg->index] = arg->val;
1153fca08f32SWang Nan break;
1154fca08f32SWang Nan }
1155fca08f32SWang Nan default:
1156fca08f32SWang Nan break;
1157fca08f32SWang Nan }
1158fca08f32SWang Nan }
1159fca08f32SWang Nan
1160fca08f32SWang Nan struct test_probe {
1161fca08f32SWang Nan struct kprobe kprobe;
1162fca08f32SWang Nan bool registered;
1163fca08f32SWang Nan int hit;
1164fca08f32SWang Nan };
1165fca08f32SWang Nan
unregister_test_probe(struct test_probe * probe)1166fca08f32SWang Nan static void unregister_test_probe(struct test_probe *probe)
1167fca08f32SWang Nan {
1168fca08f32SWang Nan if (probe->registered) {
1169fca08f32SWang Nan unregister_kprobe(&probe->kprobe);
1170fca08f32SWang Nan probe->kprobe.flags = 0; /* Clear disable flag to allow reuse */
1171fca08f32SWang Nan }
1172fca08f32SWang Nan probe->registered = false;
1173fca08f32SWang Nan }
1174fca08f32SWang Nan
register_test_probe(struct test_probe * probe)1175fca08f32SWang Nan static int register_test_probe(struct test_probe *probe)
1176fca08f32SWang Nan {
1177fca08f32SWang Nan int ret;
1178fca08f32SWang Nan
1179fca08f32SWang Nan if (probe->registered)
1180fca08f32SWang Nan BUG();
1181fca08f32SWang Nan
1182fca08f32SWang Nan ret = register_kprobe(&probe->kprobe);
1183fca08f32SWang Nan if (ret >= 0) {
1184fca08f32SWang Nan probe->registered = true;
1185fca08f32SWang Nan probe->hit = -1;
1186fca08f32SWang Nan }
1187fca08f32SWang Nan return ret;
1188fca08f32SWang Nan }
1189fca08f32SWang Nan
1190fca08f32SWang Nan static int __kprobes
test_before_pre_handler(struct kprobe * p,struct pt_regs * regs)1191fca08f32SWang Nan test_before_pre_handler(struct kprobe *p, struct pt_regs *regs)
1192fca08f32SWang Nan {
1193fca08f32SWang Nan container_of(p, struct test_probe, kprobe)->hit = test_instance;
1194fca08f32SWang Nan return 0;
1195fca08f32SWang Nan }
1196fca08f32SWang Nan
1197fca08f32SWang Nan static void __kprobes
test_before_post_handler(struct kprobe * p,struct pt_regs * regs,unsigned long flags)1198fca08f32SWang Nan test_before_post_handler(struct kprobe *p, struct pt_regs *regs,
1199fca08f32SWang Nan unsigned long flags)
1200fca08f32SWang Nan {
1201fca08f32SWang Nan setup_test_context(regs);
1202fca08f32SWang Nan initial_regs = *regs;
1203fca08f32SWang Nan initial_regs.ARM_cpsr &= ~PSR_IGNORE_BITS;
1204fca08f32SWang Nan }
1205fca08f32SWang Nan
1206fca08f32SWang Nan static int __kprobes
test_case_pre_handler(struct kprobe * p,struct pt_regs * regs)1207fca08f32SWang Nan test_case_pre_handler(struct kprobe *p, struct pt_regs *regs)
1208fca08f32SWang Nan {
1209fca08f32SWang Nan container_of(p, struct test_probe, kprobe)->hit = test_instance;
1210fca08f32SWang Nan return 0;
1211fca08f32SWang Nan }
1212fca08f32SWang Nan
1213fca08f32SWang Nan static int __kprobes
test_after_pre_handler(struct kprobe * p,struct pt_regs * regs)1214fca08f32SWang Nan test_after_pre_handler(struct kprobe *p, struct pt_regs *regs)
1215fca08f32SWang Nan {
12164cd872d9SJon Medhurst (Tixy) struct test_arg *args;
12174cd872d9SJon Medhurst (Tixy)
1218fca08f32SWang Nan if (container_of(p, struct test_probe, kprobe)->hit == test_instance)
1219fca08f32SWang Nan return 0; /* Already run for this test instance */
1220fca08f32SWang Nan
1221fca08f32SWang Nan result_regs = *regs;
12224cd872d9SJon Medhurst (Tixy)
12234cd872d9SJon Medhurst (Tixy) /* Mask out results which are indeterminate */
1224fca08f32SWang Nan result_regs.ARM_cpsr &= ~PSR_IGNORE_BITS;
12254cd872d9SJon Medhurst (Tixy) for (args = current_args; args[0].type != ARG_TYPE_END; ++args)
12264cd872d9SJon Medhurst (Tixy) if (args[0].type == ARG_TYPE_REG_MASKED) {
12274cd872d9SJon Medhurst (Tixy) struct test_arg_regptr *arg =
12284cd872d9SJon Medhurst (Tixy) (struct test_arg_regptr *)args;
12294cd872d9SJon Medhurst (Tixy) result_regs.uregs[arg->reg] &= arg->val;
12304cd872d9SJon Medhurst (Tixy) }
1231fca08f32SWang Nan
1232fca08f32SWang Nan /* Undo any changes done to SP by the test case */
1233fca08f32SWang Nan regs->ARM_sp = (unsigned long)current_stack;
12348d257e95SJon Medhurst (Tixy) /* Enable interrupts in case setup_test_context disabled them */
12358d257e95SJon Medhurst (Tixy) regs->ARM_cpsr &= ~PSR_I_BIT;
1236fca08f32SWang Nan
1237fca08f32SWang Nan container_of(p, struct test_probe, kprobe)->hit = test_instance;
1238fca08f32SWang Nan return 0;
1239fca08f32SWang Nan }
1240fca08f32SWang Nan
1241fca08f32SWang Nan static struct test_probe test_before_probe = {
1242fca08f32SWang Nan .kprobe.pre_handler = test_before_pre_handler,
1243fca08f32SWang Nan .kprobe.post_handler = test_before_post_handler,
1244fca08f32SWang Nan };
1245fca08f32SWang Nan
1246fca08f32SWang Nan static struct test_probe test_case_probe = {
1247fca08f32SWang Nan .kprobe.pre_handler = test_case_pre_handler,
1248fca08f32SWang Nan };
1249fca08f32SWang Nan
1250fca08f32SWang Nan static struct test_probe test_after_probe = {
1251fca08f32SWang Nan .kprobe.pre_handler = test_after_pre_handler,
1252fca08f32SWang Nan };
1253fca08f32SWang Nan
1254fca08f32SWang Nan static struct test_probe test_after2_probe = {
1255fca08f32SWang Nan .kprobe.pre_handler = test_after_pre_handler,
1256fca08f32SWang Nan };
1257fca08f32SWang Nan
test_case_cleanup(void)1258fca08f32SWang Nan static void test_case_cleanup(void)
1259fca08f32SWang Nan {
1260fca08f32SWang Nan unregister_test_probe(&test_before_probe);
1261fca08f32SWang Nan unregister_test_probe(&test_case_probe);
1262fca08f32SWang Nan unregister_test_probe(&test_after_probe);
1263fca08f32SWang Nan unregister_test_probe(&test_after2_probe);
1264fca08f32SWang Nan }
1265fca08f32SWang Nan
print_registers(struct pt_regs * regs)1266fca08f32SWang Nan static void print_registers(struct pt_regs *regs)
1267fca08f32SWang Nan {
1268fca08f32SWang Nan pr_err("r0 %08lx | r1 %08lx | r2 %08lx | r3 %08lx\n",
1269fca08f32SWang Nan regs->ARM_r0, regs->ARM_r1, regs->ARM_r2, regs->ARM_r3);
1270fca08f32SWang Nan pr_err("r4 %08lx | r5 %08lx | r6 %08lx | r7 %08lx\n",
1271fca08f32SWang Nan regs->ARM_r4, regs->ARM_r5, regs->ARM_r6, regs->ARM_r7);
1272fca08f32SWang Nan pr_err("r8 %08lx | r9 %08lx | r10 %08lx | r11 %08lx\n",
1273fca08f32SWang Nan regs->ARM_r8, regs->ARM_r9, regs->ARM_r10, regs->ARM_fp);
1274fca08f32SWang Nan pr_err("r12 %08lx | sp %08lx | lr %08lx | pc %08lx\n",
1275fca08f32SWang Nan regs->ARM_ip, regs->ARM_sp, regs->ARM_lr, regs->ARM_pc);
1276fca08f32SWang Nan pr_err("cpsr %08lx\n", regs->ARM_cpsr);
1277fca08f32SWang Nan }
1278fca08f32SWang Nan
print_memory(u32 * mem,size_t size)1279fca08f32SWang Nan static void print_memory(u32 *mem, size_t size)
1280fca08f32SWang Nan {
1281fca08f32SWang Nan int i;
1282fca08f32SWang Nan for (i = 0; i < size / sizeof(u32); i += 4)
1283fca08f32SWang Nan pr_err("%08x %08x %08x %08x\n", mem[i], mem[i+1],
1284fca08f32SWang Nan mem[i+2], mem[i+3]);
1285fca08f32SWang Nan }
1286fca08f32SWang Nan
expected_memory_size(u32 * sp)1287fca08f32SWang Nan static size_t expected_memory_size(u32 *sp)
1288fca08f32SWang Nan {
1289fca08f32SWang Nan size_t size = sizeof(expected_memory);
1290fca08f32SWang Nan int offset = (uintptr_t)sp - (uintptr_t)current_stack;
1291fca08f32SWang Nan if (offset > 0)
1292fca08f32SWang Nan size -= offset;
1293fca08f32SWang Nan return size;
1294fca08f32SWang Nan }
1295fca08f32SWang Nan
test_case_failed(const char * message)1296fca08f32SWang Nan static void test_case_failed(const char *message)
1297fca08f32SWang Nan {
1298fca08f32SWang Nan test_case_cleanup();
1299fca08f32SWang Nan
1300fca08f32SWang Nan pr_err("FAIL: %s\n", message);
1301fca08f32SWang Nan pr_err("FAIL: Test %s\n", current_title);
1302fca08f32SWang Nan pr_err("FAIL: Scenario %d\n", test_case_run_count >> 1);
1303fca08f32SWang Nan }
1304fca08f32SWang Nan
next_instruction(unsigned long pc)1305fca08f32SWang Nan static unsigned long next_instruction(unsigned long pc)
1306fca08f32SWang Nan {
1307fca08f32SWang Nan #ifdef CONFIG_THUMB2_KERNEL
1308fca08f32SWang Nan if ((pc & 1) &&
1309fca08f32SWang Nan !is_wide_instruction(__mem_to_opcode_thumb16(*(u16 *)(pc - 1))))
1310fca08f32SWang Nan return pc + 2;
1311fca08f32SWang Nan else
1312fca08f32SWang Nan #endif
1313fca08f32SWang Nan return pc + 4;
1314fca08f32SWang Nan }
1315fca08f32SWang Nan
kprobes_test_case_start(const char ** title,void * stack)1316fca08f32SWang Nan static uintptr_t __used kprobes_test_case_start(const char **title, void *stack)
1317fca08f32SWang Nan {
1318fca08f32SWang Nan struct test_arg *args;
1319fca08f32SWang Nan struct test_arg_end *end_arg;
1320fca08f32SWang Nan unsigned long test_code;
1321fca08f32SWang Nan
1322fca08f32SWang Nan current_title = *title++;
1323fca08f32SWang Nan args = (struct test_arg *)title;
1324fca08f32SWang Nan current_args = args;
1325fca08f32SWang Nan current_stack = stack;
1326fca08f32SWang Nan
1327fca08f32SWang Nan ++test_try_count;
1328fca08f32SWang Nan
1329fca08f32SWang Nan while (args->type != ARG_TYPE_END)
1330fca08f32SWang Nan ++args;
1331fca08f32SWang Nan end_arg = (struct test_arg_end *)args;
1332fca08f32SWang Nan
1333fca08f32SWang Nan test_code = (unsigned long)(args + 1); /* Code starts after args */
1334fca08f32SWang Nan
1335fca08f32SWang Nan test_case_is_thumb = end_arg->flags & ARG_FLAG_THUMB;
1336fca08f32SWang Nan if (test_case_is_thumb)
1337fca08f32SWang Nan test_code |= 1;
1338fca08f32SWang Nan
1339fca08f32SWang Nan current_code_start = test_code;
1340fca08f32SWang Nan
1341fca08f32SWang Nan current_branch_target = 0;
1342fca08f32SWang Nan if (end_arg->branch_offset != end_arg->end_offset)
1343fca08f32SWang Nan current_branch_target = test_code + end_arg->branch_offset;
1344fca08f32SWang Nan
1345fca08f32SWang Nan test_code += end_arg->code_offset;
1346fca08f32SWang Nan test_before_probe.kprobe.addr = (kprobe_opcode_t *)test_code;
1347fca08f32SWang Nan
1348fca08f32SWang Nan test_code = next_instruction(test_code);
1349fca08f32SWang Nan test_case_probe.kprobe.addr = (kprobe_opcode_t *)test_code;
1350fca08f32SWang Nan
1351fca08f32SWang Nan if (test_case_is_thumb) {
1352fca08f32SWang Nan u16 *p = (u16 *)(test_code & ~1);
1353fca08f32SWang Nan current_instruction = __mem_to_opcode_thumb16(p[0]);
1354fca08f32SWang Nan if (is_wide_instruction(current_instruction)) {
1355fca08f32SWang Nan u16 instr2 = __mem_to_opcode_thumb16(p[1]);
1356fca08f32SWang Nan current_instruction = __opcode_thumb32_compose(current_instruction, instr2);
1357fca08f32SWang Nan }
1358fca08f32SWang Nan } else {
1359fca08f32SWang Nan current_instruction = __mem_to_opcode_arm(*(u32 *)test_code);
1360fca08f32SWang Nan }
1361fca08f32SWang Nan
1362fca08f32SWang Nan if (current_title[0] == '.')
1363fca08f32SWang Nan verbose("%s\n", current_title);
1364fca08f32SWang Nan else
1365fca08f32SWang Nan verbose("%s\t@ %0*x\n", current_title,
1366fca08f32SWang Nan test_case_is_thumb ? 4 : 8,
1367fca08f32SWang Nan current_instruction);
1368fca08f32SWang Nan
1369fca08f32SWang Nan test_code = next_instruction(test_code);
1370fca08f32SWang Nan test_after_probe.kprobe.addr = (kprobe_opcode_t *)test_code;
1371fca08f32SWang Nan
1372fca08f32SWang Nan if (kprobe_test_flags & TEST_FLAG_NARROW_INSTR) {
1373fca08f32SWang Nan if (!test_case_is_thumb ||
1374fca08f32SWang Nan is_wide_instruction(current_instruction)) {
1375fca08f32SWang Nan test_case_failed("expected 16-bit instruction");
1376fca08f32SWang Nan goto fail;
1377fca08f32SWang Nan }
1378fca08f32SWang Nan } else {
1379fca08f32SWang Nan if (test_case_is_thumb &&
1380fca08f32SWang Nan !is_wide_instruction(current_instruction)) {
1381fca08f32SWang Nan test_case_failed("expected 32-bit instruction");
1382fca08f32SWang Nan goto fail;
1383fca08f32SWang Nan }
1384fca08f32SWang Nan }
1385fca08f32SWang Nan
1386fca08f32SWang Nan coverage_add(current_instruction);
1387fca08f32SWang Nan
1388fca08f32SWang Nan if (end_arg->flags & ARG_FLAG_UNSUPPORTED) {
1389fca08f32SWang Nan if (register_test_probe(&test_case_probe) < 0)
1390fca08f32SWang Nan goto pass;
1391fca08f32SWang Nan test_case_failed("registered probe for unsupported instruction");
1392fca08f32SWang Nan goto fail;
1393fca08f32SWang Nan }
1394fca08f32SWang Nan
1395fca08f32SWang Nan if (end_arg->flags & ARG_FLAG_SUPPORTED) {
1396fca08f32SWang Nan if (register_test_probe(&test_case_probe) >= 0)
1397fca08f32SWang Nan goto pass;
1398fca08f32SWang Nan test_case_failed("couldn't register probe for supported instruction");
1399fca08f32SWang Nan goto fail;
1400fca08f32SWang Nan }
1401fca08f32SWang Nan
1402fca08f32SWang Nan if (register_test_probe(&test_before_probe) < 0) {
1403fca08f32SWang Nan test_case_failed("register test_before_probe failed");
1404fca08f32SWang Nan goto fail;
1405fca08f32SWang Nan }
1406fca08f32SWang Nan if (register_test_probe(&test_after_probe) < 0) {
1407fca08f32SWang Nan test_case_failed("register test_after_probe failed");
1408fca08f32SWang Nan goto fail;
1409fca08f32SWang Nan }
1410fca08f32SWang Nan if (current_branch_target) {
1411fca08f32SWang Nan test_after2_probe.kprobe.addr =
1412fca08f32SWang Nan (kprobe_opcode_t *)current_branch_target;
1413fca08f32SWang Nan if (register_test_probe(&test_after2_probe) < 0) {
1414fca08f32SWang Nan test_case_failed("register test_after2_probe failed");
1415fca08f32SWang Nan goto fail;
1416fca08f32SWang Nan }
1417fca08f32SWang Nan }
1418fca08f32SWang Nan
1419fca08f32SWang Nan /* Start first run of test case */
1420fca08f32SWang Nan test_case_run_count = 0;
1421fca08f32SWang Nan ++test_instance;
1422fca08f32SWang Nan return current_code_start;
1423fca08f32SWang Nan pass:
1424fca08f32SWang Nan test_case_run_count = TEST_CASE_PASSED;
1425fca08f32SWang Nan return (uintptr_t)test_after_probe.kprobe.addr;
1426fca08f32SWang Nan fail:
1427fca08f32SWang Nan test_case_run_count = TEST_CASE_FAILED;
1428fca08f32SWang Nan return (uintptr_t)test_after_probe.kprobe.addr;
1429fca08f32SWang Nan }
1430fca08f32SWang Nan
check_test_results(void)1431fca08f32SWang Nan static bool check_test_results(void)
1432fca08f32SWang Nan {
1433fca08f32SWang Nan size_t mem_size = 0;
1434fca08f32SWang Nan u32 *mem = 0;
1435fca08f32SWang Nan
1436fca08f32SWang Nan if (memcmp(&expected_regs, &result_regs, sizeof(expected_regs))) {
1437fca08f32SWang Nan test_case_failed("registers differ");
1438fca08f32SWang Nan goto fail;
1439fca08f32SWang Nan }
1440fca08f32SWang Nan
1441fca08f32SWang Nan if (memory_needs_checking) {
1442fca08f32SWang Nan mem = (u32 *)result_regs.ARM_sp;
1443fca08f32SWang Nan mem_size = expected_memory_size(mem);
1444fca08f32SWang Nan if (memcmp(expected_memory, mem, mem_size)) {
1445fca08f32SWang Nan test_case_failed("test memory differs");
1446fca08f32SWang Nan goto fail;
1447fca08f32SWang Nan }
1448fca08f32SWang Nan }
1449fca08f32SWang Nan
1450fca08f32SWang Nan return true;
1451fca08f32SWang Nan
1452fca08f32SWang Nan fail:
1453fca08f32SWang Nan pr_err("initial_regs:\n");
1454fca08f32SWang Nan print_registers(&initial_regs);
1455fca08f32SWang Nan pr_err("expected_regs:\n");
1456fca08f32SWang Nan print_registers(&expected_regs);
1457fca08f32SWang Nan pr_err("result_regs:\n");
1458fca08f32SWang Nan print_registers(&result_regs);
1459fca08f32SWang Nan
1460fca08f32SWang Nan if (mem) {
1461fca08f32SWang Nan pr_err("expected_memory:\n");
1462fca08f32SWang Nan print_memory(expected_memory, mem_size);
1463fca08f32SWang Nan pr_err("result_memory:\n");
1464fca08f32SWang Nan print_memory(mem, mem_size);
1465fca08f32SWang Nan }
1466fca08f32SWang Nan
1467fca08f32SWang Nan return false;
1468fca08f32SWang Nan }
1469fca08f32SWang Nan
kprobes_test_case_end(void)1470fca08f32SWang Nan static uintptr_t __used kprobes_test_case_end(void)
1471fca08f32SWang Nan {
1472fca08f32SWang Nan if (test_case_run_count < 0) {
1473fca08f32SWang Nan if (test_case_run_count == TEST_CASE_PASSED)
1474fca08f32SWang Nan /* kprobes_test_case_start did all the needed testing */
1475fca08f32SWang Nan goto pass;
1476fca08f32SWang Nan else
1477fca08f32SWang Nan /* kprobes_test_case_start failed */
1478fca08f32SWang Nan goto fail;
1479fca08f32SWang Nan }
1480fca08f32SWang Nan
1481fca08f32SWang Nan if (test_before_probe.hit != test_instance) {
1482fca08f32SWang Nan test_case_failed("test_before_handler not run");
1483fca08f32SWang Nan goto fail;
1484fca08f32SWang Nan }
1485fca08f32SWang Nan
1486fca08f32SWang Nan if (test_after_probe.hit != test_instance &&
1487fca08f32SWang Nan test_after2_probe.hit != test_instance) {
1488fca08f32SWang Nan test_case_failed("test_after_handler not run");
1489fca08f32SWang Nan goto fail;
1490fca08f32SWang Nan }
1491fca08f32SWang Nan
1492fca08f32SWang Nan /*
1493fca08f32SWang Nan * Even numbered test runs ran without a probe on the test case so
1494fca08f32SWang Nan * we can gather reference results. The subsequent odd numbered run
1495fca08f32SWang Nan * will have the probe inserted.
1496fca08f32SWang Nan */
1497fca08f32SWang Nan if ((test_case_run_count & 1) == 0) {
1498fca08f32SWang Nan /* Save results from run without probe */
1499fca08f32SWang Nan u32 *mem = (u32 *)result_regs.ARM_sp;
1500fca08f32SWang Nan expected_regs = result_regs;
1501fca08f32SWang Nan memcpy(expected_memory, mem, expected_memory_size(mem));
1502fca08f32SWang Nan
1503fca08f32SWang Nan /* Insert probe onto test case instruction */
1504fca08f32SWang Nan if (register_test_probe(&test_case_probe) < 0) {
1505fca08f32SWang Nan test_case_failed("register test_case_probe failed");
1506fca08f32SWang Nan goto fail;
1507fca08f32SWang Nan }
1508fca08f32SWang Nan } else {
1509fca08f32SWang Nan /* Check probe ran as expected */
1510fca08f32SWang Nan if (probe_should_run == 1) {
1511fca08f32SWang Nan if (test_case_probe.hit != test_instance) {
1512fca08f32SWang Nan test_case_failed("test_case_handler not run");
1513fca08f32SWang Nan goto fail;
1514fca08f32SWang Nan }
1515fca08f32SWang Nan } else if (probe_should_run == 0) {
1516fca08f32SWang Nan if (test_case_probe.hit == test_instance) {
1517fca08f32SWang Nan test_case_failed("test_case_handler ran");
1518fca08f32SWang Nan goto fail;
1519fca08f32SWang Nan }
1520fca08f32SWang Nan }
1521fca08f32SWang Nan
1522fca08f32SWang Nan /* Remove probe for any subsequent reference run */
1523fca08f32SWang Nan unregister_test_probe(&test_case_probe);
1524fca08f32SWang Nan
1525fca08f32SWang Nan if (!check_test_results())
1526fca08f32SWang Nan goto fail;
1527fca08f32SWang Nan
1528fca08f32SWang Nan if (is_last_scenario)
1529fca08f32SWang Nan goto pass;
1530fca08f32SWang Nan }
1531fca08f32SWang Nan
1532fca08f32SWang Nan /* Do next test run */
1533fca08f32SWang Nan ++test_case_run_count;
1534fca08f32SWang Nan ++test_instance;
1535fca08f32SWang Nan return current_code_start;
1536fca08f32SWang Nan fail:
1537fca08f32SWang Nan ++test_fail_count;
1538fca08f32SWang Nan goto end;
1539fca08f32SWang Nan pass:
1540fca08f32SWang Nan ++test_pass_count;
1541fca08f32SWang Nan end:
1542fca08f32SWang Nan test_case_cleanup();
1543fca08f32SWang Nan return 0;
1544fca08f32SWang Nan }
1545fca08f32SWang Nan
1546fca08f32SWang Nan
1547fca08f32SWang Nan /*
1548fca08f32SWang Nan * Top level test functions
1549fca08f32SWang Nan */
1550fca08f32SWang Nan
run_test_cases(void (* tests)(void),const union decode_item * table)1551fca08f32SWang Nan static int run_test_cases(void (*tests)(void), const union decode_item *table)
1552fca08f32SWang Nan {
1553fca08f32SWang Nan int ret;
1554fca08f32SWang Nan
1555fca08f32SWang Nan pr_info(" Check decoding tables\n");
1556fca08f32SWang Nan ret = table_test(table);
1557fca08f32SWang Nan if (ret)
1558fca08f32SWang Nan return ret;
1559fca08f32SWang Nan
1560fca08f32SWang Nan pr_info(" Run test cases\n");
1561fca08f32SWang Nan ret = coverage_start(table);
1562fca08f32SWang Nan if (ret)
1563fca08f32SWang Nan return ret;
1564fca08f32SWang Nan
1565fca08f32SWang Nan tests();
1566fca08f32SWang Nan
1567fca08f32SWang Nan coverage_end();
1568fca08f32SWang Nan return 0;
1569fca08f32SWang Nan }
1570fca08f32SWang Nan
1571fca08f32SWang Nan
run_all_tests(void)1572fca08f32SWang Nan static int __init run_all_tests(void)
1573fca08f32SWang Nan {
1574fca08f32SWang Nan int ret = 0;
1575fca08f32SWang Nan
1576fca08f32SWang Nan pr_info("Beginning kprobe tests...\n");
1577fca08f32SWang Nan
1578fca08f32SWang Nan #ifndef CONFIG_THUMB2_KERNEL
1579fca08f32SWang Nan
1580fca08f32SWang Nan pr_info("Probe ARM code\n");
1581fca08f32SWang Nan ret = run_api_tests(arm_func);
1582fca08f32SWang Nan if (ret)
1583fca08f32SWang Nan goto out;
1584fca08f32SWang Nan
1585fca08f32SWang Nan pr_info("ARM instruction simulation\n");
1586fca08f32SWang Nan ret = run_test_cases(kprobe_arm_test_cases, probes_decode_arm_table);
1587fca08f32SWang Nan if (ret)
1588fca08f32SWang Nan goto out;
1589fca08f32SWang Nan
1590fca08f32SWang Nan #else /* CONFIG_THUMB2_KERNEL */
1591fca08f32SWang Nan
1592fca08f32SWang Nan pr_info("Probe 16-bit Thumb code\n");
1593fca08f32SWang Nan ret = run_api_tests(thumb16_func);
1594fca08f32SWang Nan if (ret)
1595fca08f32SWang Nan goto out;
1596fca08f32SWang Nan
1597fca08f32SWang Nan pr_info("Probe 32-bit Thumb code, even halfword\n");
1598fca08f32SWang Nan ret = run_api_tests(thumb32even_func);
1599fca08f32SWang Nan if (ret)
1600fca08f32SWang Nan goto out;
1601fca08f32SWang Nan
1602fca08f32SWang Nan pr_info("Probe 32-bit Thumb code, odd halfword\n");
1603fca08f32SWang Nan ret = run_api_tests(thumb32odd_func);
1604fca08f32SWang Nan if (ret)
1605fca08f32SWang Nan goto out;
1606fca08f32SWang Nan
1607fca08f32SWang Nan pr_info("16-bit Thumb instruction simulation\n");
1608fca08f32SWang Nan ret = run_test_cases(kprobe_thumb16_test_cases,
1609fca08f32SWang Nan probes_decode_thumb16_table);
1610fca08f32SWang Nan if (ret)
1611fca08f32SWang Nan goto out;
1612fca08f32SWang Nan
1613fca08f32SWang Nan pr_info("32-bit Thumb instruction simulation\n");
1614fca08f32SWang Nan ret = run_test_cases(kprobe_thumb32_test_cases,
1615fca08f32SWang Nan probes_decode_thumb32_table);
1616fca08f32SWang Nan if (ret)
1617fca08f32SWang Nan goto out;
1618fca08f32SWang Nan #endif
1619fca08f32SWang Nan
1620fca08f32SWang Nan pr_info("Total instruction simulation tests=%d, pass=%d fail=%d\n",
1621fca08f32SWang Nan test_try_count, test_pass_count, test_fail_count);
1622fca08f32SWang Nan if (test_fail_count) {
1623fca08f32SWang Nan ret = -EINVAL;
1624fca08f32SWang Nan goto out;
1625fca08f32SWang Nan }
1626fca08f32SWang Nan
1627fca08f32SWang Nan #if BENCHMARKING
1628fca08f32SWang Nan pr_info("Benchmarks\n");
1629fca08f32SWang Nan ret = run_benchmarks();
1630fca08f32SWang Nan if (ret)
1631fca08f32SWang Nan goto out;
1632fca08f32SWang Nan #endif
1633fca08f32SWang Nan
1634fca08f32SWang Nan #if __LINUX_ARM_ARCH__ >= 7
1635fca08f32SWang Nan /* We are able to run all test cases so coverage should be complete */
1636fca08f32SWang Nan if (coverage_fail) {
1637fca08f32SWang Nan pr_err("FAIL: Test coverage checks failed\n");
1638fca08f32SWang Nan ret = -EINVAL;
1639fca08f32SWang Nan goto out;
1640fca08f32SWang Nan }
1641fca08f32SWang Nan #endif
1642fca08f32SWang Nan
1643fca08f32SWang Nan out:
1644fca08f32SWang Nan if (ret == 0)
1645fca08f32SWang Nan ret = tests_failed;
1646fca08f32SWang Nan if (ret == 0)
1647fca08f32SWang Nan pr_info("Finished kprobe tests OK\n");
1648fca08f32SWang Nan else
1649fca08f32SWang Nan pr_err("kprobe tests failed\n");
1650fca08f32SWang Nan
1651fca08f32SWang Nan return ret;
1652fca08f32SWang Nan }
1653fca08f32SWang Nan
1654fca08f32SWang Nan
1655fca08f32SWang Nan /*
1656fca08f32SWang Nan * Module setup
1657fca08f32SWang Nan */
1658fca08f32SWang Nan
1659fca08f32SWang Nan #ifdef MODULE
1660fca08f32SWang Nan
kprobe_test_exit(void)1661fca08f32SWang Nan static void __exit kprobe_test_exit(void)
1662fca08f32SWang Nan {
1663fca08f32SWang Nan }
1664fca08f32SWang Nan
1665fca08f32SWang Nan module_init(run_all_tests)
1666fca08f32SWang Nan module_exit(kprobe_test_exit)
1667fca08f32SWang Nan MODULE_LICENSE("GPL");
1668fca08f32SWang Nan
1669fca08f32SWang Nan #else /* !MODULE */
1670fca08f32SWang Nan
1671fca08f32SWang Nan late_initcall(run_all_tests);
1672fca08f32SWang Nan
1673fca08f32SWang Nan #endif
1674