xref: /openbmc/linux/arch/s390/kernel/ftrace.c (revision 92a2c6b2)
1 /*
2  * Dynamic function tracer architecture backend.
3  *
4  * Copyright IBM Corp. 2009,2014
5  *
6  *   Author(s): Heiko Carstens <heiko.carstens@de.ibm.com>,
7  *		Martin Schwidefsky <schwidefsky@de.ibm.com>
8  */
9 
10 #include <linux/moduleloader.h>
11 #include <linux/hardirq.h>
12 #include <linux/uaccess.h>
13 #include <linux/ftrace.h>
14 #include <linux/kernel.h>
15 #include <linux/types.h>
16 #include <linux/kprobes.h>
17 #include <trace/syscall.h>
18 #include <asm/asm-offsets.h>
19 #include <asm/cacheflush.h>
20 #include "entry.h"
21 
22 /*
23  * The mcount code looks like this:
24  *	stg	%r14,8(%r15)		# offset 0
25  *	larl	%r1,<&counter>		# offset 6
26  *	brasl	%r14,_mcount		# offset 12
27  *	lg	%r14,8(%r15)		# offset 18
28  * Total length is 24 bytes. Only the first instruction will be patched
29  * by ftrace_make_call / ftrace_make_nop.
30  * The enabled ftrace code block looks like this:
31  * >	brasl	%r0,ftrace_caller	# offset 0
32  *	larl	%r1,<&counter>		# offset 6
33  *	brasl	%r14,_mcount		# offset 12
34  *	lg	%r14,8(%r15)		# offset 18
35  * The ftrace function gets called with a non-standard C function call ABI
36  * where r0 contains the return address. It is also expected that the called
37  * function only clobbers r0 and r1, but restores r2-r15.
38  * For module code we can't directly jump to ftrace caller, but need a
39  * trampoline (ftrace_plt), which clobbers also r1.
40  * The return point of the ftrace function has offset 24, so execution
41  * continues behind the mcount block.
42  * The disabled ftrace code block looks like this:
43  * >	jg	.+24			# offset 0
44  *	larl	%r1,<&counter>		# offset 6
45  *	brasl	%r14,_mcount		# offset 12
46  *	lg	%r14,8(%r15)		# offset 18
47  * The jg instruction branches to offset 24 to skip as many instructions
48  * as possible.
49  * In case we use gcc's hotpatch feature the original and also the disabled
50  * function prologue contains only a single six byte instruction and looks
51  * like this:
52  * >	brcl	0,0			# offset 0
53  * To enable ftrace the code gets patched like above and afterwards looks
54  * like this:
55  * >	brasl	%r0,ftrace_caller	# offset 0
56  */
57 
58 unsigned long ftrace_plt;
59 
60 int ftrace_modify_call(struct dyn_ftrace *rec, unsigned long old_addr,
61 		       unsigned long addr)
62 {
63 	return 0;
64 }
65 
66 int ftrace_make_nop(struct module *mod, struct dyn_ftrace *rec,
67 		    unsigned long addr)
68 {
69 	struct ftrace_insn orig, new, old;
70 
71 	if (probe_kernel_read(&old, (void *) rec->ip, sizeof(old)))
72 		return -EFAULT;
73 	if (addr == MCOUNT_ADDR) {
74 		/* Initial code replacement */
75 #ifdef CC_USING_HOTPATCH
76 		/* We expect to see brcl 0,0 */
77 		ftrace_generate_nop_insn(&orig);
78 #else
79 		/* We expect to see stg r14,8(r15) */
80 		orig.opc = 0xe3e0;
81 		orig.disp = 0xf0080024;
82 #endif
83 		ftrace_generate_nop_insn(&new);
84 	} else if (old.opc == BREAKPOINT_INSTRUCTION) {
85 		/*
86 		 * If we find a breakpoint instruction, a kprobe has been
87 		 * placed at the beginning of the function. We write the
88 		 * constant KPROBE_ON_FTRACE_NOP into the remaining four
89 		 * bytes of the original instruction so that the kprobes
90 		 * handler can execute a nop, if it reaches this breakpoint.
91 		 */
92 		new.opc = orig.opc = BREAKPOINT_INSTRUCTION;
93 		orig.disp = KPROBE_ON_FTRACE_CALL;
94 		new.disp = KPROBE_ON_FTRACE_NOP;
95 	} else {
96 		/* Replace ftrace call with a nop. */
97 		ftrace_generate_call_insn(&orig, rec->ip);
98 		ftrace_generate_nop_insn(&new);
99 	}
100 	/* Verify that the to be replaced code matches what we expect. */
101 	if (memcmp(&orig, &old, sizeof(old)))
102 		return -EINVAL;
103 	if (probe_kernel_write((void *) rec->ip, &new, sizeof(new)))
104 		return -EPERM;
105 	return 0;
106 }
107 
108 int ftrace_make_call(struct dyn_ftrace *rec, unsigned long addr)
109 {
110 	struct ftrace_insn orig, new, old;
111 
112 	if (probe_kernel_read(&old, (void *) rec->ip, sizeof(old)))
113 		return -EFAULT;
114 	if (old.opc == BREAKPOINT_INSTRUCTION) {
115 		/*
116 		 * If we find a breakpoint instruction, a kprobe has been
117 		 * placed at the beginning of the function. We write the
118 		 * constant KPROBE_ON_FTRACE_CALL into the remaining four
119 		 * bytes of the original instruction so that the kprobes
120 		 * handler can execute a brasl if it reaches this breakpoint.
121 		 */
122 		new.opc = orig.opc = BREAKPOINT_INSTRUCTION;
123 		orig.disp = KPROBE_ON_FTRACE_NOP;
124 		new.disp = KPROBE_ON_FTRACE_CALL;
125 	} else {
126 		/* Replace nop with an ftrace call. */
127 		ftrace_generate_nop_insn(&orig);
128 		ftrace_generate_call_insn(&new, rec->ip);
129 	}
130 	/* Verify that the to be replaced code matches what we expect. */
131 	if (memcmp(&orig, &old, sizeof(old)))
132 		return -EINVAL;
133 	if (probe_kernel_write((void *) rec->ip, &new, sizeof(new)))
134 		return -EPERM;
135 	return 0;
136 }
137 
138 int ftrace_update_ftrace_func(ftrace_func_t func)
139 {
140 	return 0;
141 }
142 
143 int __init ftrace_dyn_arch_init(void)
144 {
145 	return 0;
146 }
147 
148 static int __init ftrace_plt_init(void)
149 {
150 	unsigned int *ip;
151 
152 	ftrace_plt = (unsigned long) module_alloc(PAGE_SIZE);
153 	if (!ftrace_plt)
154 		panic("cannot allocate ftrace plt\n");
155 	ip = (unsigned int *) ftrace_plt;
156 	ip[0] = 0x0d10e310; /* basr 1,0; lg 1,10(1); br 1 */
157 	ip[1] = 0x100a0004;
158 	ip[2] = 0x07f10000;
159 	ip[3] = FTRACE_ADDR >> 32;
160 	ip[4] = FTRACE_ADDR & 0xffffffff;
161 	set_memory_ro(ftrace_plt, 1);
162 	return 0;
163 }
164 device_initcall(ftrace_plt_init);
165 
166 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
167 /*
168  * Hook the return address and push it in the stack of return addresses
169  * in current thread info.
170  */
171 unsigned long prepare_ftrace_return(unsigned long parent, unsigned long ip)
172 {
173 	struct ftrace_graph_ent trace;
174 
175 	if (unlikely(ftrace_graph_is_dead()))
176 		goto out;
177 	if (unlikely(atomic_read(&current->tracing_graph_pause)))
178 		goto out;
179 	ip = (ip & PSW_ADDR_INSN) - MCOUNT_INSN_SIZE;
180 	trace.func = ip;
181 	trace.depth = current->curr_ret_stack + 1;
182 	/* Only trace if the calling function expects to. */
183 	if (!ftrace_graph_entry(&trace))
184 		goto out;
185 	if (ftrace_push_return_trace(parent, ip, &trace.depth, 0) == -EBUSY)
186 		goto out;
187 	parent = (unsigned long) return_to_handler;
188 out:
189 	return parent;
190 }
191 NOKPROBE_SYMBOL(prepare_ftrace_return);
192 
193 /*
194  * Patch the kernel code at ftrace_graph_caller location. The instruction
195  * there is branch relative on condition. To enable the ftrace graph code
196  * block, we simply patch the mask field of the instruction to zero and
197  * turn the instruction into a nop.
198  * To disable the ftrace graph code the mask field will be patched to
199  * all ones, which turns the instruction into an unconditional branch.
200  */
201 int ftrace_enable_ftrace_graph_caller(void)
202 {
203 	u8 op = 0x04; /* set mask field to zero */
204 
205 	return probe_kernel_write(__va(ftrace_graph_caller)+1, &op, sizeof(op));
206 }
207 
208 int ftrace_disable_ftrace_graph_caller(void)
209 {
210 	u8 op = 0xf4; /* set mask field to all ones */
211 
212 	return probe_kernel_write(__va(ftrace_graph_caller)+1, &op, sizeof(op));
213 }
214 
215 #endif /* CONFIG_FUNCTION_GRAPH_TRACER */
216