ftrace.c 10.8 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
/*
 * Code for replacing ftrace calls with jumps.
 *
 * Copyright (C) 2007-2008 Steven Rostedt <srostedt@redhat.com>
 *
 * Thanks goes to Ingo Molnar, for suggesting the idea.
 * Mathieu Desnoyers, for suggesting postponing the modifications.
 * Arjan van de Ven, for keeping me straight, and explaining to me
 * the dangers of modifying code on the run.
 */

#include <linux/spinlock.h>
#include <linux/hardirq.h>
14
#include <linux/uaccess.h>
15
16
#include <linux/ftrace.h>
#include <linux/percpu.h>
17
#include <linux/sched.h>
18
19
20
#include <linux/init.h>
#include <linux/list.h>

21
#include <asm/cacheflush.h>
22
#include <asm/ftrace.h>
23
#include <linux/ftrace.h>
24
#include <asm/nops.h>
25
#include <asm/nmi.h>
26
27


28
#ifdef CONFIG_DYNAMIC_FTRACE
29

30
31
32
33
34
35
36
37
38
39
40
41
int ftrace_arch_code_modify_prepare(void)
{
	set_kernel_text_rw();
	return 0;
}

int ftrace_arch_code_modify_post_process(void)
{
	set_kernel_text_ro();
	return 0;
}

42
union ftrace_code_union {
43
	char code[MCOUNT_INSN_SIZE];
44
45
46
47
48
49
	struct {
		char e8;
		int offset;
	} __attribute__((packed));
};

50
static int ftrace_calc_offset(long ip, long addr)
51
52
53
{
	return (int)(addr - ip);
}
54

55
static unsigned char *ftrace_call_replace(unsigned long ip, unsigned long addr)
56
57
{
	static union ftrace_code_union calc;
58

59
	calc.e8		= 0xe8;
60
	calc.offset	= ftrace_calc_offset(ip + MCOUNT_INSN_SIZE, addr);
61
62
63
64
65
66

	/*
	 * No locking needed, this must be called via kstop_machine
	 * which in essence is like running on a uniprocessor machine.
	 */
	return calc.code;
67
68
}

69
70
71
72
73
74
75
76
77
78
79
/*
 * Modifying code must take extra care. On an SMP machine, if
 * the code being modified is also being executed on another CPU
 * that CPU will have undefined results and possibly take a GPF.
 * We use kstop_machine to stop other CPUS from exectuing code.
 * But this does not stop NMIs from happening. We still need
 * to protect against that. We separate out the modification of
 * the code to take care of this.
 *
 * Two buffers are added: An IP buffer and a "code" buffer.
 *
80
 * 1) Put the instruction pointer into the IP buffer
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
 *    and the new code into the "code" buffer.
 * 2) Set a flag that says we are modifying code
 * 3) Wait for any running NMIs to finish.
 * 4) Write the code
 * 5) clear the flag.
 * 6) Wait for any running NMIs to finish.
 *
 * If an NMI is executed, the first thing it does is to call
 * "ftrace_nmi_enter". This will check if the flag is set to write
 * and if it is, it will write what is in the IP and "code" buffers.
 *
 * The trick is, it does not matter if everyone is writing the same
 * content to the code location. Also, if a CPU is executing code
 * it is OK to write to that code location if the contents being written
 * are the same as what exists.
 */

98
static atomic_t nmi_running = ATOMIC_INIT(0);
99
100
101
102
static int mod_code_status;		/* holds return value of text write */
static int mod_code_write;		/* set when NMI should do the write */
static void *mod_code_ip;		/* holds the IP to write to */
static void *mod_code_newcode;		/* holds the text to write to the IP */
103

104
105
static unsigned nmi_wait_count;
static atomic_t nmi_update_count = ATOMIC_INIT(0);
Steven Rostedt's avatar
Steven Rostedt committed
106
107
108
109
110
111
112
113
114
115
116

int ftrace_arch_read_dyn_info(char *buf, int size)
{
	int r;

	r = snprintf(buf, size, "%u %u",
		     nmi_wait_count,
		     atomic_read(&nmi_update_count));
	return r;
}

117
118
119
120
121
122
123
124
125
126
static void ftrace_mod_code(void)
{
	/*
	 * Yes, more than one CPU process can be writing to mod_code_status.
	 *    (and the code itself)
	 * But if one were to fail, then they all should, and if one were
	 * to succeed, then they all should.
	 */
	mod_code_status = probe_kernel_write(mod_code_ip, mod_code_newcode,
					     MCOUNT_INSN_SIZE);
127
128
129
130

	/* if we fail, then kill any new writers */
	if (mod_code_status)
		mod_code_write = 0;
131
132
}

133
void ftrace_nmi_enter(void)
134
{
135
136
	atomic_inc(&nmi_running);
	/* Must have nmi_running seen before reading write flag */
137
	smp_mb();
Steven Rostedt's avatar
Steven Rostedt committed
138
	if (mod_code_write) {
139
		ftrace_mod_code();
Steven Rostedt's avatar
Steven Rostedt committed
140
141
		atomic_inc(&nmi_update_count);
	}
142
143
}

144
void ftrace_nmi_exit(void)
145
{
146
	/* Finish all executions before clearing nmi_running */
147
	smp_wmb();
148
	atomic_dec(&nmi_running);
149
150
151
152
}

static void wait_for_nmi(void)
{
153
	if (!atomic_read(&nmi_running))
154
		return;
Steven Rostedt's avatar
Steven Rostedt committed
155

156
	do {
157
		cpu_relax();
158
	} while (atomic_read(&nmi_running));
Steven Rostedt's avatar
Steven Rostedt committed
159

160
	nmi_wait_count++;
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
}

static int
do_ftrace_mod_code(unsigned long ip, void *new_code)
{
	mod_code_ip = (void *)ip;
	mod_code_newcode = new_code;

	/* The buffers need to be visible before we let NMIs write them */
	smp_wmb();

	mod_code_write = 1;

	/* Make sure write bit is visible before we wait on NMIs */
	smp_mb();

	wait_for_nmi();

	/* Make sure all running NMIs have finished before we write the code */
	smp_mb();

	ftrace_mod_code();

	/* Make sure the write happens before clearing the bit */
	smp_wmb();

	mod_code_write = 0;

	/* make sure NMIs see the cleared bit */
	smp_mb();

	wait_for_nmi();

	return mod_code_status;
}


198
199
200
201


static unsigned char ftrace_nop[MCOUNT_INSN_SIZE];

202
static unsigned char *ftrace_nop_replace(void)
203
204
205
206
{
	return ftrace_nop;
}

207
static int
208
209
210
ftrace_modify_code(unsigned long ip, unsigned char *old_code,
		   unsigned char *new_code)
{
211
	unsigned char replaced[MCOUNT_INSN_SIZE];
212
213
214
215

	/*
	 * Note: Due to modules and __init, code can
	 *  disappear and change, we need to protect against faulting
216
	 *  as well as code changing. We do this by using the
Steven Rostedt's avatar
Steven Rostedt committed
217
	 *  probe_kernel_* functions.
218
219
	 *
	 * No real locking needed, this code is run through
220
	 * kstop_machine, or before SMP starts.
221
	 */
222
223

	/* read the text we want to modify */
Steven Rostedt's avatar
Steven Rostedt committed
224
	if (probe_kernel_read(replaced, (void *)ip, MCOUNT_INSN_SIZE))
225
		return -EFAULT;
226

227
	/* Make sure it is what we expect it to be */
228
	if (memcmp(replaced, old_code, MCOUNT_INSN_SIZE) != 0)
229
		return -EINVAL;
230

231
	/* replace the text with the new text */
232
	if (do_ftrace_mod_code(ip, new_code))
233
		return -EPERM;
234
235

	sync_core();
236

237
	return 0;
238
239
}

240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
int ftrace_make_nop(struct module *mod,
		    struct dyn_ftrace *rec, unsigned long addr)
{
	unsigned char *new, *old;
	unsigned long ip = rec->ip;

	old = ftrace_call_replace(ip, addr);
	new = ftrace_nop_replace();

	return ftrace_modify_code(rec->ip, old, new);
}

int ftrace_make_call(struct dyn_ftrace *rec, unsigned long addr)
{
	unsigned char *new, *old;
	unsigned long ip = rec->ip;

	old = ftrace_nop_replace();
	new = ftrace_call_replace(ip, addr);

	return ftrace_modify_code(rec->ip, old, new);
}

263
int ftrace_update_ftrace_func(ftrace_func_t func)
264
265
{
	unsigned long ip = (unsigned long)(&ftrace_call);
266
	unsigned char old[MCOUNT_INSN_SIZE], *new;
267
268
	int ret;

269
	memcpy(old, &ftrace_call, MCOUNT_INSN_SIZE);
270
271
272
273
274
275
276
	new = ftrace_call_replace(ip, (unsigned long)func);
	ret = ftrace_modify_code(ip, old, new);

	return ret;
}

int __init ftrace_dyn_arch_init(void *data)
277
{
278
279
280
281
	extern const unsigned char ftrace_test_p6nop[];
	extern const unsigned char ftrace_test_nop5[];
	extern const unsigned char ftrace_test_jmp[];
	int faulted = 0;
282

283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
	/*
	 * There is no good nop for all x86 archs.
	 * We will default to using the P6_NOP5, but first we
	 * will test to make sure that the nop will actually
	 * work on this CPU. If it faults, we will then
	 * go to a lesser efficient 5 byte nop. If that fails
	 * we then just use a jmp as our nop. This isn't the most
	 * efficient nop, but we can not use a multi part nop
	 * since we would then risk being preempted in the middle
	 * of that nop, and if we enabled tracing then, it might
	 * cause a system crash.
	 *
	 * TODO: check the cpuid to determine the best nop.
	 */
	asm volatile (
		"ftrace_test_jmp:"
		"jmp ftrace_test_p6nop\n"
300
301
302
		"nop\n"
		"nop\n"
		"nop\n"  /* 2 byte jmp + 3 bytes */
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
		"ftrace_test_p6nop:"
		P6_NOP5
		"jmp 1f\n"
		"ftrace_test_nop5:"
		".byte 0x66,0x66,0x66,0x66,0x90\n"
		"1:"
		".section .fixup, \"ax\"\n"
		"2:	movl $1, %0\n"
		"	jmp ftrace_test_nop5\n"
		"3:	movl $2, %0\n"
		"	jmp 1b\n"
		".previous\n"
		_ASM_EXTABLE(ftrace_test_p6nop, 2b)
		_ASM_EXTABLE(ftrace_test_nop5, 3b)
		: "=r"(faulted) : "0" (faulted));

	switch (faulted) {
	case 0:
		pr_info("ftrace: converting mcount calls to 0f 1f 44 00 00\n");
322
		memcpy(ftrace_nop, ftrace_test_p6nop, MCOUNT_INSN_SIZE);
323
324
325
		break;
	case 1:
		pr_info("ftrace: converting mcount calls to 66 66 66 66 90\n");
326
		memcpy(ftrace_nop, ftrace_test_nop5, MCOUNT_INSN_SIZE);
327
328
		break;
	case 2:
329
		pr_info("ftrace: converting mcount calls to jmp . + 5\n");
330
		memcpy(ftrace_nop, ftrace_test_jmp, MCOUNT_INSN_SIZE);
331
332
333
334
335
		break;
	}

	/* The return code is retured via data */
	*(unsigned long *)data = 0;
336

337
338
	return 0;
}
339
#endif
340

341
#ifdef CONFIG_FUNCTION_GRAPH_TRACER
342

343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
#ifdef CONFIG_DYNAMIC_FTRACE
extern void ftrace_graph_call(void);

static int ftrace_mod_jmp(unsigned long ip,
			  int old_offset, int new_offset)
{
	unsigned char code[MCOUNT_INSN_SIZE];

	if (probe_kernel_read(code, (void *)ip, MCOUNT_INSN_SIZE))
		return -EFAULT;

	if (code[0] != 0xe9 || old_offset != *(int *)(&code[1]))
		return -EINVAL;

	*(int *)(&code[1]) = new_offset;

	if (do_ftrace_mod_code(ip, &code))
		return -EPERM;

	return 0;
}

int ftrace_enable_ftrace_graph_caller(void)
{
	unsigned long ip = (unsigned long)(&ftrace_graph_call);
	int old_offset, new_offset;

	old_offset = (unsigned long)(&ftrace_stub) - (ip + MCOUNT_INSN_SIZE);
	new_offset = (unsigned long)(&ftrace_graph_caller) - (ip + MCOUNT_INSN_SIZE);

	return ftrace_mod_jmp(ip, old_offset, new_offset);
}

int ftrace_disable_ftrace_graph_caller(void)
{
	unsigned long ip = (unsigned long)(&ftrace_graph_call);
	int old_offset, new_offset;

	old_offset = (unsigned long)(&ftrace_graph_caller) - (ip + MCOUNT_INSN_SIZE);
	new_offset = (unsigned long)(&ftrace_stub) - (ip + MCOUNT_INSN_SIZE);

	return ftrace_mod_jmp(ip, old_offset, new_offset);
}

387
388
389
390
391
392
393
394
395
396
397
#endif /* !CONFIG_DYNAMIC_FTRACE */

/*
 * Hook the return address and push it in the stack of return addrs
 * in current thread info.
 */
void prepare_ftrace_return(unsigned long *parent, unsigned long self_addr)
{
	unsigned long old;
	unsigned long long calltime;
	int faulted;
398
	struct ftrace_graph_ent trace;
399
400
401
402
	unsigned long return_hooker = (unsigned long)
				&return_to_handler;

	/* Nmi's are currently unsupported */
403
	if (unlikely(in_nmi()))
404
405
406
		return;

	if (unlikely(atomic_read(&current->tracing_graph_pause)))
407
408
409
410
411
412
413
414
		return;

	/*
	 * Protect against fault, even if it shouldn't
	 * happen. This tool is too much intrusive to
	 * ignore such a protection.
	 */
	asm volatile(
415
416
		"1: " _ASM_MOV " (%[parent]), %[old]\n"
		"2: " _ASM_MOV " %[return_hooker], (%[parent])\n"
417
		"   movl $0, %[faulted]\n"
418
		"3:\n"
419
420

		".section .fixup, \"ax\"\n"
421
422
		"4: movl $1, %[faulted]\n"
		"   jmp 3b\n"
423
424
		".previous\n"

425
426
		_ASM_EXTABLE(1b, 4b)
		_ASM_EXTABLE(2b, 4b)
427

428
429
		: [old] "=r" (old), [faulted] "=r" (faulted)
		: [parent] "r" (parent), [return_hooker] "r" (return_hooker)
430
431
432
		: "memory"
	);

433
434
435
	if (unlikely(faulted)) {
		ftrace_graph_stop();
		WARN_ON(1);
436
437
438
		return;
	}

439
	calltime = trace_clock_local();
440

441
	if (ftrace_push_return_trace(old, calltime,
442
				self_addr, &trace.depth) == -EBUSY) {
443
		*parent = old;
444
445
446
447
448
		return;
	}

	trace.func = self_addr;

449
450
451
452
453
	/* Only trace if the calling function expects to */
	if (!ftrace_graph_entry(&trace)) {
		current->curr_ret_stack--;
		*parent = old;
	}
454
}
455
#endif /* CONFIG_FUNCTION_GRAPH_TRACER */