ftrace.c 31.4 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
/*
 * Infrastructure for profiling code inserted by 'gcc -pg'.
 *
 * Copyright (C) 2007-2008 Steven Rostedt <srostedt@redhat.com>
 * Copyright (C) 2004-2008 Ingo Molnar <mingo@redhat.com>
 *
 * Originally ported from the -rt patch by:
 *   Copyright (C) 2007 Arnaldo Carvalho de Melo <acme@redhat.com>
 *
 * Based on code in the latency_tracer, that is:
 *
 *  Copyright (C) 2004-2006 Ingo Molnar
 *  Copyright (C) 2004 William Lee Irwin III
 */

16 17 18
#include <linux/stop_machine.h>
#include <linux/clocksource.h>
#include <linux/kallsyms.h>
19 20
#include <linux/seq_file.h>
#include <linux/debugfs.h>
21
#include <linux/hardirq.h>
I
Ingo Molnar 已提交
22
#include <linux/kthread.h>
23
#include <linux/uaccess.h>
24
#include <linux/kprobes.h>
I
Ingo Molnar 已提交
25
#include <linux/ftrace.h>
26
#include <linux/sysctl.h>
27
#include <linux/ctype.h>
28 29
#include <linux/list.h>

30 31
#include <asm/ftrace.h>

32
#include "trace.h"
33

34 35 36 37 38 39 40 41 42 43 44 45
#define FTRACE_WARN_ON(cond)			\
	do {					\
		if (WARN_ON(cond))		\
			ftrace_kill();		\
	} while (0)

#define FTRACE_WARN_ON_ONCE(cond)		\
	do {					\
		if (WARN_ON_ONCE(cond))		\
			ftrace_kill();		\
	} while (0)

46 47
/* ftrace_enabled is a method to turn ftrace on or off */
int ftrace_enabled __read_mostly;
48
static int last_ftrace_enabled;
49

50 51 52
/* Quick disabling of function tracer. */
int function_trace_stop;

53 54 55 56 57 58
/*
 * ftrace_disabled is set when an anomaly is discovered.
 * ftrace_disabled is much stronger than ftrace_enabled.
 */
static int ftrace_disabled __read_mostly;

59
static DEFINE_SPINLOCK(ftrace_lock);
60 61
static DEFINE_MUTEX(ftrace_sysctl_lock);

62 63 64 65 66 67 68
static struct ftrace_ops ftrace_list_end __read_mostly =
{
	.func = ftrace_stub,
};

static struct ftrace_ops *ftrace_list __read_mostly = &ftrace_list_end;
ftrace_func_t ftrace_trace_function __read_mostly = ftrace_stub;
69
ftrace_func_t __ftrace_trace_function __read_mostly = ftrace_stub;
70

I
Ingo Molnar 已提交
71
static void ftrace_list_func(unsigned long ip, unsigned long parent_ip)
72 73 74 75 76 77 78 79 80 81 82 83 84 85 86
{
	struct ftrace_ops *op = ftrace_list;

	/* in case someone actually ports this to alpha! */
	read_barrier_depends();

	while (op != &ftrace_list_end) {
		/* silly alpha */
		read_barrier_depends();
		op->func(ip, parent_ip);
		op = op->next;
	};
}

/**
87
 * clear_ftrace_function - reset the ftrace function
88
 *
89 90
 * This NULLs the ftrace function and in essence stops
 * tracing.  There may be lag
91
 */
92
void clear_ftrace_function(void)
93
{
94
	ftrace_trace_function = ftrace_stub;
95
	__ftrace_trace_function = ftrace_stub;
96 97
}

98 99 100 101 102 103 104 105 106 107 108 109 110 111
#ifndef CONFIG_HAVE_FUNCTION_TRACE_MCOUNT_TEST
/*
 * For those archs that do not test ftrace_trace_stop in their
 * mcount call site, we need to do it from C.
 */
static void ftrace_test_stop_func(unsigned long ip, unsigned long parent_ip)
{
	if (function_trace_stop)
		return;

	__ftrace_trace_function(ip, parent_ip);
}
#endif

I
Ingo Molnar 已提交
112
static int __register_ftrace_function(struct ftrace_ops *ops)
113
{
114
	/* should not be called from interrupt context */
115
	spin_lock(&ftrace_lock);
116 117 118 119 120 121 122 123 124 125

	ops->next = ftrace_list;
	/*
	 * We are entering ops into the ftrace_list but another
	 * CPU might be walking that list. We need to make sure
	 * the ops->next pointer is valid before another CPU sees
	 * the ops pointer included into the ftrace_list.
	 */
	smp_wmb();
	ftrace_list = ops;
126

127 128 129 130 131
	if (ftrace_enabled) {
		/*
		 * For one func, simply call it directly.
		 * For more than one func, call the chain.
		 */
132
#ifdef CONFIG_HAVE_FUNCTION_TRACE_MCOUNT_TEST
133 134 135 136
		if (ops->next == &ftrace_list_end)
			ftrace_trace_function = ops->func;
		else
			ftrace_trace_function = ftrace_list_func;
137 138 139 140 141 142 143
#else
		if (ops->next == &ftrace_list_end)
			__ftrace_trace_function = ops->func;
		else
			__ftrace_trace_function = ftrace_list_func;
		ftrace_trace_function = ftrace_test_stop_func;
#endif
144
	}
145 146

	spin_unlock(&ftrace_lock);
147 148 149 150

	return 0;
}

I
Ingo Molnar 已提交
151
static int __unregister_ftrace_function(struct ftrace_ops *ops)
152 153 154 155
{
	struct ftrace_ops **p;
	int ret = 0;

156
	/* should not be called from interrupt context */
157
	spin_lock(&ftrace_lock);
158 159

	/*
160 161
	 * If we are removing the last function, then simply point
	 * to the ftrace_stub.
162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179
	 */
	if (ftrace_list == ops && ops->next == &ftrace_list_end) {
		ftrace_trace_function = ftrace_stub;
		ftrace_list = &ftrace_list_end;
		goto out;
	}

	for (p = &ftrace_list; *p != &ftrace_list_end; p = &(*p)->next)
		if (*p == ops)
			break;

	if (*p != ops) {
		ret = -1;
		goto out;
	}

	*p = (*p)->next;

180 181
	if (ftrace_enabled) {
		/* If we only have one func left, then call that directly */
182
		if (ftrace_list->next == &ftrace_list_end)
183 184
			ftrace_trace_function = ftrace_list->func;
	}
185 186

 out:
187 188 189 190 191 192
	spin_unlock(&ftrace_lock);

	return ret;
}

#ifdef CONFIG_DYNAMIC_FTRACE
193
#ifndef CONFIG_FTRACE_MCOUNT_RECORD
S
Steven Rostedt 已提交
194
# error Dynamic ftrace depends on MCOUNT_RECORD
195 196
#endif

197 198 199 200 201 202 203 204
/*
 * Since MCOUNT_ADDR may point to mcount itself, we do not want
 * to get it confused by reading a reference in the code as we
 * are parsing on objcopy output of text. Use a variable for
 * it instead.
 */
static unsigned long mcount_addr = MCOUNT_ADDR;

205 206 207 208 209 210 211 212
enum {
	FTRACE_ENABLE_CALLS		= (1 << 0),
	FTRACE_DISABLE_CALLS		= (1 << 1),
	FTRACE_UPDATE_TRACE_FUNC	= (1 << 2),
	FTRACE_ENABLE_MCOUNT		= (1 << 3),
	FTRACE_DISABLE_MCOUNT		= (1 << 4),
};

213 214
static int ftrace_filtered;

S
Steven Rostedt 已提交
215
static LIST_HEAD(ftrace_new_addrs);
216

217
static DEFINE_MUTEX(ftrace_regex_lock);
218

219 220
struct ftrace_page {
	struct ftrace_page	*next;
221
	unsigned long		index;
222
	struct dyn_ftrace	records[];
223
};
224 225 226 227 228 229 230 231 232 233

#define ENTRIES_PER_PAGE \
  ((PAGE_SIZE - sizeof(struct ftrace_page)) / sizeof(struct dyn_ftrace))

/* estimate from running different kernels */
#define NR_TO_INIT		10000

static struct ftrace_page	*ftrace_pages_start;
static struct ftrace_page	*ftrace_pages;

234 235
static struct dyn_ftrace *ftrace_free_records;

A
Abhishek Sagar 已提交
236 237

#ifdef CONFIG_KPROBES
238 239 240

static int frozen_record_count;

A
Abhishek Sagar 已提交
241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266
static inline void freeze_record(struct dyn_ftrace *rec)
{
	if (!(rec->flags & FTRACE_FL_FROZEN)) {
		rec->flags |= FTRACE_FL_FROZEN;
		frozen_record_count++;
	}
}

static inline void unfreeze_record(struct dyn_ftrace *rec)
{
	if (rec->flags & FTRACE_FL_FROZEN) {
		rec->flags &= ~FTRACE_FL_FROZEN;
		frozen_record_count--;
	}
}

static inline int record_frozen(struct dyn_ftrace *rec)
{
	return rec->flags & FTRACE_FL_FROZEN;
}
#else
# define freeze_record(rec)			({ 0; })
# define unfreeze_record(rec)			({ 0; })
# define record_frozen(rec)			({ 0; })
#endif /* CONFIG_KPROBES */

I
Ingo Molnar 已提交
267
static void ftrace_free_rec(struct dyn_ftrace *rec)
268 269 270 271 272 273
{
	rec->ip = (unsigned long)ftrace_free_records;
	ftrace_free_records = rec;
	rec->flags |= FTRACE_FL_FREE;
}

274 275 276 277 278 279 280 281
void ftrace_release(void *start, unsigned long size)
{
	struct dyn_ftrace *rec;
	struct ftrace_page *pg;
	unsigned long s = (unsigned long)start;
	unsigned long e = s + size;
	int i;

282
	if (ftrace_disabled || !start)
283 284
		return;

285
	/* should not be called from interrupt context */
286 287 288 289 290 291 292 293 294 295 296 297 298
	spin_lock(&ftrace_lock);

	for (pg = ftrace_pages_start; pg; pg = pg->next) {
		for (i = 0; i < pg->index; i++) {
			rec = &pg->records[i];

			if ((rec->ip >= s) && (rec->ip < e))
				ftrace_free_rec(rec);
		}
	}
	spin_unlock(&ftrace_lock);
}

I
Ingo Molnar 已提交
299
static struct dyn_ftrace *ftrace_alloc_dyn_node(unsigned long ip)
300
{
301 302 303 304 305 306 307
	struct dyn_ftrace *rec;

	/* First check for freed records */
	if (ftrace_free_records) {
		rec = ftrace_free_records;

		if (unlikely(!(rec->flags & FTRACE_FL_FREE))) {
308
			FTRACE_WARN_ON_ONCE(1);
309 310 311 312 313 314 315 316 317
			ftrace_free_records = NULL;
			return NULL;
		}

		ftrace_free_records = (void *)rec->ip;
		memset(rec, 0, sizeof(*rec));
		return rec;
	}

318
	if (ftrace_pages->index == ENTRIES_PER_PAGE) {
S
Steven Rostedt 已提交
319 320 321 322 323 324 325
		if (!ftrace_pages->next) {
			/* allocate another page */
			ftrace_pages->next =
				(void *)get_zeroed_page(GFP_KERNEL);
			if (!ftrace_pages->next)
				return NULL;
		}
326 327 328 329 330 331
		ftrace_pages = ftrace_pages->next;
	}

	return &ftrace_pages->records[ftrace_pages->index++];
}

S
Steven Rostedt 已提交
332
static struct dyn_ftrace *
333
ftrace_record_ip(unsigned long ip)
334
{
S
Steven Rostedt 已提交
335
	struct dyn_ftrace *rec;
336

337
	if (ftrace_disabled)
S
Steven Rostedt 已提交
338
		return NULL;
339

S
Steven Rostedt 已提交
340 341 342
	rec = ftrace_alloc_dyn_node(ip);
	if (!rec)
		return NULL;
343

S
Steven Rostedt 已提交
344
	rec->ip = ip;
345

S
Steven Rostedt 已提交
346
	list_add(&rec->list, &ftrace_new_addrs);
347

S
Steven Rostedt 已提交
348
	return rec;
349 350
}

351 352 353 354 355 356 357 358 359 360
static void print_ip_ins(const char *fmt, unsigned char *p)
{
	int i;

	printk(KERN_CONT "%s", fmt);

	for (i = 0; i < MCOUNT_INSN_SIZE; i++)
		printk(KERN_CONT "%s%02x", i ? ":" : "", p[i]);
}

361
static void ftrace_bug(int failed, unsigned long ip)
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 387
{
	switch (failed) {
	case -EFAULT:
		FTRACE_WARN_ON_ONCE(1);
		pr_info("ftrace faulted on modifying ");
		print_ip_sym(ip);
		break;
	case -EINVAL:
		FTRACE_WARN_ON_ONCE(1);
		pr_info("ftrace failed to modify ");
		print_ip_sym(ip);
		print_ip_ins(" actual: ", (unsigned char *)ip);
		printk(KERN_CONT "\n");
		break;
	case -EPERM:
		FTRACE_WARN_ON_ONCE(1);
		pr_info("ftrace faulted on writing ");
		print_ip_sym(ip);
		break;
	default:
		FTRACE_WARN_ON_ONCE(1);
		pr_info("ftrace faulted on unknown error ");
		print_ip_sym(ip);
	}
}

388
#define FTRACE_ADDR ((long)(ftrace_caller))
389

390
static int
391
__ftrace_replace_code(struct dyn_ftrace *rec, int enable)
392
{
393
	unsigned long ip, fl;
394 395 396

	ip = rec->ip;

S
Steven Rostedt 已提交
397 398 399 400 401 402 403 404 405 406 407 408 409 410 411
	/*
	 * If this record is not to be traced and
	 * it is not enabled then do nothing.
	 *
	 * If this record is not to be traced and
	 * it is enabled then disabled it.
	 *
	 */
	if (rec->flags & FTRACE_FL_NOTRACE) {
		if (rec->flags & FTRACE_FL_ENABLED)
			rec->flags &= ~FTRACE_FL_ENABLED;
		else
			return 0;

	} else if (ftrace_filtered && enable) {
412
		/*
S
Steven Rostedt 已提交
413
		 * Filtering is on:
414
		 */
415

S
Steven Rostedt 已提交
416
		fl = rec->flags & (FTRACE_FL_FILTER | FTRACE_FL_ENABLED);
417

S
Steven Rostedt 已提交
418 419
		/* Record is filtered and enabled, do nothing */
		if (fl == (FTRACE_FL_FILTER | FTRACE_FL_ENABLED))
420
			return 0;
421

S
Steven Rostedt 已提交
422 423 424 425 426 427
		/* Record is not filtered and is not enabled do nothing */
		if (!fl)
			return 0;

		/* Record is not filtered but enabled, disable it */
		if (fl == FTRACE_FL_ENABLED)
428
			rec->flags &= ~FTRACE_FL_ENABLED;
S
Steven Rostedt 已提交
429 430
		else
		/* Otherwise record is filtered but not enabled, enable it */
431 432
			rec->flags |= FTRACE_FL_ENABLED;
	} else {
S
Steven Rostedt 已提交
433
		/* Disable or not filtered */
434

435
		if (enable) {
S
Steven Rostedt 已提交
436
			/* if record is enabled, do nothing */
437
			if (rec->flags & FTRACE_FL_ENABLED)
438
				return 0;
S
Steven Rostedt 已提交
439

440
			rec->flags |= FTRACE_FL_ENABLED;
S
Steven Rostedt 已提交
441

442
		} else {
S
Steven Rostedt 已提交
443 444

			/* if record is not enabled do nothing */
445
			if (!(rec->flags & FTRACE_FL_ENABLED))
446
				return 0;
S
Steven Rostedt 已提交
447

448 449 450 451
			rec->flags &= ~FTRACE_FL_ENABLED;
		}
	}

S
Steven Rostedt 已提交
452
	if (rec->flags & FTRACE_FL_ENABLED)
453 454 455
		return ftrace_make_call(rec, FTRACE_ADDR);
	else
		return ftrace_make_nop(NULL, rec, FTRACE_ADDR);
456 457
}

I
Ingo Molnar 已提交
458
static void ftrace_replace_code(int enable)
459
{
460
	int i, failed;
461 462 463 464 465 466 467
	struct dyn_ftrace *rec;
	struct ftrace_page *pg;

	for (pg = ftrace_pages_start; pg; pg = pg->next) {
		for (i = 0; i < pg->index; i++) {
			rec = &pg->records[i];

468 469 470 471 472 473
			/*
			 * Skip over free records and records that have
			 * failed.
			 */
			if (rec->flags & FTRACE_FL_FREE ||
			    rec->flags & FTRACE_FL_FAILED)
474 475
				continue;

476
			/* ignore updates to this record's mcount site */
477 478
			if (get_kprobe((void *)rec->ip)) {
				freeze_record(rec);
479
				continue;
480 481 482
			} else {
				unfreeze_record(rec);
			}
483

484
			failed = __ftrace_replace_code(rec, enable);
485 486 487
			if (failed && (rec->flags & FTRACE_FL_CONVERTED)) {
				rec->flags |= FTRACE_FL_FAILED;
				if ((system_state == SYSTEM_BOOTING) ||
488
				    !core_kernel_text(rec->ip)) {
489
					ftrace_free_rec(rec);
490
				} else
491
					ftrace_bug(failed, rec->ip);
492
			}
493 494 495 496
		}
	}
}

497
static int
498
ftrace_code_disable(struct module *mod, struct dyn_ftrace *rec)
499 500
{
	unsigned long ip;
501
	int ret;
502 503 504

	ip = rec->ip;

505
	ret = ftrace_make_nop(mod, rec, mcount_addr);
506
	if (ret) {
507
		ftrace_bug(ret, ip);
508
		rec->flags |= FTRACE_FL_FAILED;
509
		return 0;
510
	}
511
	return 1;
512 513
}

I
Ingo Molnar 已提交
514
static int __ftrace_modify_code(void *data)
515
{
516 517
	int *command = data;

518
	if (*command & FTRACE_ENABLE_CALLS)
519
		ftrace_replace_code(1);
520
	else if (*command & FTRACE_DISABLE_CALLS)
521 522 523 524 525 526
		ftrace_replace_code(0);

	if (*command & FTRACE_UPDATE_TRACE_FUNC)
		ftrace_update_ftrace_func(ftrace_trace_function);

	return 0;
527 528
}

I
Ingo Molnar 已提交
529
static void ftrace_run_update_code(int command)
530
{
R
Rusty Russell 已提交
531
	stop_machine(__ftrace_modify_code, &command, NULL);
532 533
}

534
static ftrace_func_t saved_ftrace_func;
535
static int ftrace_start_up;
S
Steven Rostedt 已提交
536
static DEFINE_MUTEX(ftrace_start_lock);
537

I
Ingo Molnar 已提交
538
static void ftrace_startup(void)
539
{
540 541
	int command = 0;

542 543 544
	if (unlikely(ftrace_disabled))
		return;

S
Steven Rostedt 已提交
545
	mutex_lock(&ftrace_start_lock);
546
	ftrace_start_up++;
S
Steven Rostedt 已提交
547
	command |= FTRACE_ENABLE_CALLS;
548 549 550 551 552 553 554

	if (saved_ftrace_func != ftrace_trace_function) {
		saved_ftrace_func = ftrace_trace_function;
		command |= FTRACE_UPDATE_TRACE_FUNC;
	}

	if (!command || !ftrace_enabled)
555 556
		goto out;

557
	ftrace_run_update_code(command);
558
 out:
S
Steven Rostedt 已提交
559
	mutex_unlock(&ftrace_start_lock);
560 561
}

I
Ingo Molnar 已提交
562
static void ftrace_shutdown(void)
563
{
564 565
	int command = 0;

566 567 568
	if (unlikely(ftrace_disabled))
		return;

S
Steven Rostedt 已提交
569
	mutex_lock(&ftrace_start_lock);
570 571
	ftrace_start_up--;
	if (!ftrace_start_up)
572
		command |= FTRACE_DISABLE_CALLS;
573

574 575 576 577
	if (saved_ftrace_func != ftrace_trace_function) {
		saved_ftrace_func = ftrace_trace_function;
		command |= FTRACE_UPDATE_TRACE_FUNC;
	}
578

579 580 581 582
	if (!command || !ftrace_enabled)
		goto out;

	ftrace_run_update_code(command);
583
 out:
S
Steven Rostedt 已提交
584
	mutex_unlock(&ftrace_start_lock);
585 586
}

I
Ingo Molnar 已提交
587
static void ftrace_startup_sysctl(void)
588
{
589 590
	int command = FTRACE_ENABLE_MCOUNT;

591 592 593
	if (unlikely(ftrace_disabled))
		return;

S
Steven Rostedt 已提交
594
	mutex_lock(&ftrace_start_lock);
595 596
	/* Force update next time */
	saved_ftrace_func = NULL;
597 598
	/* ftrace_start_up is true if we want ftrace running */
	if (ftrace_start_up)
599 600 601
		command |= FTRACE_ENABLE_CALLS;

	ftrace_run_update_code(command);
S
Steven Rostedt 已提交
602
	mutex_unlock(&ftrace_start_lock);
603 604
}

I
Ingo Molnar 已提交
605
static void ftrace_shutdown_sysctl(void)
606
{
607 608
	int command = FTRACE_DISABLE_MCOUNT;

609 610 611
	if (unlikely(ftrace_disabled))
		return;

S
Steven Rostedt 已提交
612
	mutex_lock(&ftrace_start_lock);
613 614
	/* ftrace_start_up is true if ftrace is running */
	if (ftrace_start_up)
615 616 617
		command |= FTRACE_DISABLE_CALLS;

	ftrace_run_update_code(command);
S
Steven Rostedt 已提交
618
	mutex_unlock(&ftrace_start_lock);
619 620
}

621 622 623 624
static cycle_t		ftrace_update_time;
static unsigned long	ftrace_update_cnt;
unsigned long		ftrace_update_tot_cnt;

625
static int ftrace_update_code(struct module *mod)
626
{
S
Steven Rostedt 已提交
627
	struct dyn_ftrace *p, *t;
628
	cycle_t start, stop;
629

I
Ingo Molnar 已提交
630
	start = ftrace_now(raw_smp_processor_id());
631 632
	ftrace_update_cnt = 0;

S
Steven Rostedt 已提交
633
	list_for_each_entry_safe(p, t, &ftrace_new_addrs, list) {
634

S
Steven Rostedt 已提交
635 636 637
		/* If something went wrong, bail without enabling anything */
		if (unlikely(ftrace_disabled))
			return -1;
638

S
Steven Rostedt 已提交
639
		list_del_init(&p->list);
640

S
Steven Rostedt 已提交
641
		/* convert record (i.e, patch mcount-call with NOP) */
642
		if (ftrace_code_disable(mod, p)) {
S
Steven Rostedt 已提交
643 644 645 646
			p->flags |= FTRACE_FL_CONVERTED;
			ftrace_update_cnt++;
		} else
			ftrace_free_rec(p);
647 648
	}

I
Ingo Molnar 已提交
649
	stop = ftrace_now(raw_smp_processor_id());
650 651 652
	ftrace_update_time = stop - start;
	ftrace_update_tot_cnt += ftrace_update_cnt;

653 654 655
	return 0;
}

656
static int __init ftrace_dyn_table_alloc(unsigned long num_to_init)
657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682
{
	struct ftrace_page *pg;
	int cnt;
	int i;

	/* allocate a few pages */
	ftrace_pages_start = (void *)get_zeroed_page(GFP_KERNEL);
	if (!ftrace_pages_start)
		return -1;

	/*
	 * Allocate a few more pages.
	 *
	 * TODO: have some parser search vmlinux before
	 *   final linking to find all calls to ftrace.
	 *   Then we can:
	 *    a) know how many pages to allocate.
	 *     and/or
	 *    b) set up the table then.
	 *
	 *  The dynamic code is still necessary for
	 *  modules.
	 */

	pg = ftrace_pages = ftrace_pages_start;

683
	cnt = num_to_init / ENTRIES_PER_PAGE;
S
Steven Rostedt 已提交
684
	pr_info("ftrace: allocating %ld entries in %d pages\n",
685
		num_to_init, cnt);
686 687 688 689 690 691 692 693 694 695 696 697 698 699

	for (i = 0; i < cnt; i++) {
		pg->next = (void *)get_zeroed_page(GFP_KERNEL);

		/* If we fail, we'll try later anyway */
		if (!pg->next)
			break;

		pg = pg->next;
	}

	return 0;
}

700 701 702
enum {
	FTRACE_ITER_FILTER	= (1 << 0),
	FTRACE_ITER_CONT	= (1 << 1),
703
	FTRACE_ITER_NOTRACE	= (1 << 2),
704
	FTRACE_ITER_FAILURES	= (1 << 3),
705 706 707 708 709 710 711 712 713 714 715 716 717 718
};

#define FTRACE_BUFF_MAX (KSYM_SYMBOL_LEN+4) /* room for wildcards */

struct ftrace_iterator {
	loff_t			pos;
	struct ftrace_page	*pg;
	unsigned		idx;
	unsigned		flags;
	unsigned char		buffer[FTRACE_BUFF_MAX+1];
	unsigned		buffer_idx;
	unsigned		filtered;
};

I
Ingo Molnar 已提交
719
static void *
720 721 722 723 724 725 726
t_next(struct seq_file *m, void *v, loff_t *pos)
{
	struct ftrace_iterator *iter = m->private;
	struct dyn_ftrace *rec = NULL;

	(*pos)++;

727 728
	/* should not be called from interrupt context */
	spin_lock(&ftrace_lock);
729 730 731 732 733 734 735 736 737
 retry:
	if (iter->idx >= iter->pg->index) {
		if (iter->pg->next) {
			iter->pg = iter->pg->next;
			iter->idx = 0;
			goto retry;
		}
	} else {
		rec = &iter->pg->records[iter->idx++];
738 739 740
		if ((rec->flags & FTRACE_FL_FREE) ||

		    (!(iter->flags & FTRACE_ITER_FAILURES) &&
741 742 743
		     (rec->flags & FTRACE_FL_FAILED)) ||

		    ((iter->flags & FTRACE_ITER_FAILURES) &&
744
		     !(rec->flags & FTRACE_FL_FAILED)) ||
745

S
Steven Rostedt 已提交
746 747 748
		    ((iter->flags & FTRACE_ITER_FILTER) &&
		     !(rec->flags & FTRACE_FL_FILTER)) ||

749 750
		    ((iter->flags & FTRACE_ITER_NOTRACE) &&
		     !(rec->flags & FTRACE_FL_NOTRACE))) {
751 752 753 754
			rec = NULL;
			goto retry;
		}
	}
755
	spin_unlock(&ftrace_lock);
756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804

	iter->pos = *pos;

	return rec;
}

static void *t_start(struct seq_file *m, loff_t *pos)
{
	struct ftrace_iterator *iter = m->private;
	void *p = NULL;
	loff_t l = -1;

	if (*pos != iter->pos) {
		for (p = t_next(m, p, &l); p && l < *pos; p = t_next(m, p, &l))
			;
	} else {
		l = *pos;
		p = t_next(m, p, &l);
	}

	return p;
}

static void t_stop(struct seq_file *m, void *p)
{
}

static int t_show(struct seq_file *m, void *v)
{
	struct dyn_ftrace *rec = v;
	char str[KSYM_SYMBOL_LEN];

	if (!rec)
		return 0;

	kallsyms_lookup(rec->ip, NULL, NULL, NULL, str);

	seq_printf(m, "%s\n", str);

	return 0;
}

static struct seq_operations show_ftrace_seq_ops = {
	.start = t_start,
	.next = t_next,
	.stop = t_stop,
	.show = t_show,
};

I
Ingo Molnar 已提交
805
static int
806 807 808 809 810
ftrace_avail_open(struct inode *inode, struct file *file)
{
	struct ftrace_iterator *iter;
	int ret;

811 812 813
	if (unlikely(ftrace_disabled))
		return -ENODEV;

814 815 816 817 818 819 820 821 822 823
	iter = kzalloc(sizeof(*iter), GFP_KERNEL);
	if (!iter)
		return -ENOMEM;

	iter->pg = ftrace_pages_start;
	iter->pos = -1;

	ret = seq_open(file, &show_ftrace_seq_ops);
	if (!ret) {
		struct seq_file *m = file->private_data;
I
Ingo Molnar 已提交
824

825
		m->private = iter;
I
Ingo Molnar 已提交
826
	} else {
827
		kfree(iter);
I
Ingo Molnar 已提交
828
	}
829 830 831 832 833 834 835 836 837 838 839

	return ret;
}

int ftrace_avail_release(struct inode *inode, struct file *file)
{
	struct seq_file *m = (struct seq_file *)file->private_data;
	struct ftrace_iterator *iter = m->private;

	seq_release(inode, file);
	kfree(iter);
I
Ingo Molnar 已提交
840

841 842 843
	return 0;
}

844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861
static int
ftrace_failures_open(struct inode *inode, struct file *file)
{
	int ret;
	struct seq_file *m;
	struct ftrace_iterator *iter;

	ret = ftrace_avail_open(inode, file);
	if (!ret) {
		m = (struct seq_file *)file->private_data;
		iter = (struct ftrace_iterator *)m->private;
		iter->flags = FTRACE_ITER_FAILURES;
	}

	return ret;
}


862
static void ftrace_filter_reset(int enable)
863 864 865
{
	struct ftrace_page *pg;
	struct dyn_ftrace *rec;
866
	unsigned long type = enable ? FTRACE_FL_FILTER : FTRACE_FL_NOTRACE;
867 868
	unsigned i;

869 870
	/* should not be called from interrupt context */
	spin_lock(&ftrace_lock);
871 872
	if (enable)
		ftrace_filtered = 0;
873 874 875 876 877 878
	pg = ftrace_pages_start;
	while (pg) {
		for (i = 0; i < pg->index; i++) {
			rec = &pg->records[i];
			if (rec->flags & FTRACE_FL_FAILED)
				continue;
879
			rec->flags &= ~type;
880 881 882
		}
		pg = pg->next;
	}
883
	spin_unlock(&ftrace_lock);
884 885
}

I
Ingo Molnar 已提交
886
static int
887
ftrace_regex_open(struct inode *inode, struct file *file, int enable)
888 889 890 891
{
	struct ftrace_iterator *iter;
	int ret = 0;

892 893 894
	if (unlikely(ftrace_disabled))
		return -ENODEV;

895 896 897 898
	iter = kzalloc(sizeof(*iter), GFP_KERNEL);
	if (!iter)
		return -ENOMEM;

899
	mutex_lock(&ftrace_regex_lock);
900 901
	if ((file->f_mode & FMODE_WRITE) &&
	    !(file->f_flags & O_APPEND))
902
		ftrace_filter_reset(enable);
903 904 905 906

	if (file->f_mode & FMODE_READ) {
		iter->pg = ftrace_pages_start;
		iter->pos = -1;
907 908
		iter->flags = enable ? FTRACE_ITER_FILTER :
			FTRACE_ITER_NOTRACE;
909 910 911 912 913 914 915 916 917

		ret = seq_open(file, &show_ftrace_seq_ops);
		if (!ret) {
			struct seq_file *m = file->private_data;
			m->private = iter;
		} else
			kfree(iter);
	} else
		file->private_data = iter;
918
	mutex_unlock(&ftrace_regex_lock);
919 920 921 922

	return ret;
}

923 924 925 926 927 928 929 930 931 932 933 934
static int
ftrace_filter_open(struct inode *inode, struct file *file)
{
	return ftrace_regex_open(inode, file, 1);
}

static int
ftrace_notrace_open(struct inode *inode, struct file *file)
{
	return ftrace_regex_open(inode, file, 0);
}

I
Ingo Molnar 已提交
935
static ssize_t
936
ftrace_regex_read(struct file *file, char __user *ubuf,
937 938 939 940 941 942 943 944
		       size_t cnt, loff_t *ppos)
{
	if (file->f_mode & FMODE_READ)
		return seq_read(file, ubuf, cnt, ppos);
	else
		return -EPERM;
}

I
Ingo Molnar 已提交
945
static loff_t
946
ftrace_regex_lseek(struct file *file, loff_t offset, int origin)
947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964
{
	loff_t ret;

	if (file->f_mode & FMODE_READ)
		ret = seq_lseek(file, offset, origin);
	else
		file->f_pos = ret = 1;

	return ret;
}

enum {
	MATCH_FULL,
	MATCH_FRONT_ONLY,
	MATCH_MIDDLE_ONLY,
	MATCH_END_ONLY,
};

I
Ingo Molnar 已提交
965
static void
966
ftrace_match(unsigned char *buff, int len, int enable)
967 968 969 970 971 972
{
	char str[KSYM_SYMBOL_LEN];
	char *search = NULL;
	struct ftrace_page *pg;
	struct dyn_ftrace *rec;
	int type = MATCH_FULL;
973
	unsigned long flag = enable ? FTRACE_FL_FILTER : FTRACE_FL_NOTRACE;
974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994
	unsigned i, match = 0, search_len = 0;

	for (i = 0; i < len; i++) {
		if (buff[i] == '*') {
			if (!i) {
				search = buff + i + 1;
				type = MATCH_END_ONLY;
				search_len = len - (i + 1);
			} else {
				if (type == MATCH_END_ONLY) {
					type = MATCH_MIDDLE_ONLY;
				} else {
					match = i;
					type = MATCH_FRONT_ONLY;
				}
				buff[i] = 0;
				break;
			}
		}
	}

995 996
	/* should not be called from interrupt context */
	spin_lock(&ftrace_lock);
997 998
	if (enable)
		ftrace_filtered = 1;
999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028
	pg = ftrace_pages_start;
	while (pg) {
		for (i = 0; i < pg->index; i++) {
			int matched = 0;
			char *ptr;

			rec = &pg->records[i];
			if (rec->flags & FTRACE_FL_FAILED)
				continue;
			kallsyms_lookup(rec->ip, NULL, NULL, NULL, str);
			switch (type) {
			case MATCH_FULL:
				if (strcmp(str, buff) == 0)
					matched = 1;
				break;
			case MATCH_FRONT_ONLY:
				if (memcmp(str, buff, match) == 0)
					matched = 1;
				break;
			case MATCH_MIDDLE_ONLY:
				if (strstr(str, search))
					matched = 1;
				break;
			case MATCH_END_ONLY:
				ptr = strstr(str, search);
				if (ptr && (ptr[search_len] == 0))
					matched = 1;
				break;
			}
			if (matched)
1029
				rec->flags |= flag;
1030 1031 1032
		}
		pg = pg->next;
	}
1033
	spin_unlock(&ftrace_lock);
1034 1035
}

I
Ingo Molnar 已提交
1036
static ssize_t
1037 1038
ftrace_regex_write(struct file *file, const char __user *ubuf,
		   size_t cnt, loff_t *ppos, int enable)
1039 1040 1041 1042 1043 1044 1045 1046 1047
{
	struct ftrace_iterator *iter;
	char ch;
	size_t read = 0;
	ssize_t ret;

	if (!cnt || cnt < 0)
		return 0;

1048
	mutex_lock(&ftrace_regex_lock);
1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102

	if (file->f_mode & FMODE_READ) {
		struct seq_file *m = file->private_data;
		iter = m->private;
	} else
		iter = file->private_data;

	if (!*ppos) {
		iter->flags &= ~FTRACE_ITER_CONT;
		iter->buffer_idx = 0;
	}

	ret = get_user(ch, ubuf++);
	if (ret)
		goto out;
	read++;
	cnt--;

	if (!(iter->flags & ~FTRACE_ITER_CONT)) {
		/* skip white space */
		while (cnt && isspace(ch)) {
			ret = get_user(ch, ubuf++);
			if (ret)
				goto out;
			read++;
			cnt--;
		}

		if (isspace(ch)) {
			file->f_pos += read;
			ret = read;
			goto out;
		}

		iter->buffer_idx = 0;
	}

	while (cnt && !isspace(ch)) {
		if (iter->buffer_idx < FTRACE_BUFF_MAX)
			iter->buffer[iter->buffer_idx++] = ch;
		else {
			ret = -EINVAL;
			goto out;
		}
		ret = get_user(ch, ubuf++);
		if (ret)
			goto out;
		read++;
		cnt--;
	}

	if (isspace(ch)) {
		iter->filtered++;
		iter->buffer[iter->buffer_idx] = 0;
1103
		ftrace_match(iter->buffer, iter->buffer_idx, enable);
1104 1105 1106 1107 1108 1109 1110 1111 1112
		iter->buffer_idx = 0;
	} else
		iter->flags |= FTRACE_ITER_CONT;


	file->f_pos += read;

	ret = read;
 out:
1113
	mutex_unlock(&ftrace_regex_lock);
1114 1115 1116 1117

	return ret;
}

1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145
static ssize_t
ftrace_filter_write(struct file *file, const char __user *ubuf,
		    size_t cnt, loff_t *ppos)
{
	return ftrace_regex_write(file, ubuf, cnt, ppos, 1);
}

static ssize_t
ftrace_notrace_write(struct file *file, const char __user *ubuf,
		     size_t cnt, loff_t *ppos)
{
	return ftrace_regex_write(file, ubuf, cnt, ppos, 0);
}

static void
ftrace_set_regex(unsigned char *buf, int len, int reset, int enable)
{
	if (unlikely(ftrace_disabled))
		return;

	mutex_lock(&ftrace_regex_lock);
	if (reset)
		ftrace_filter_reset(enable);
	if (buf)
		ftrace_match(buf, len, enable);
	mutex_unlock(&ftrace_regex_lock);
}

1146 1147 1148 1149 1150 1151 1152 1153 1154
/**
 * ftrace_set_filter - set a function to filter on in ftrace
 * @buf - the string that holds the function filter text.
 * @len - the length of the string.
 * @reset - non zero to reset all filters before applying this filter.
 *
 * Filters denote which functions should be enabled when tracing is enabled.
 * If @buf is NULL and reset is set, all functions will be enabled for tracing.
 */
I
Ingo Molnar 已提交
1155
void ftrace_set_filter(unsigned char *buf, int len, int reset)
1156
{
1157 1158
	ftrace_set_regex(buf, len, reset, 1);
}
1159

1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172
/**
 * ftrace_set_notrace - set a function to not trace in ftrace
 * @buf - the string that holds the function notrace text.
 * @len - the length of the string.
 * @reset - non zero to reset all filters before applying this filter.
 *
 * Notrace Filters denote which functions should not be enabled when tracing
 * is enabled. If @buf is NULL and reset is set, all functions will be enabled
 * for tracing.
 */
void ftrace_set_notrace(unsigned char *buf, int len, int reset)
{
	ftrace_set_regex(buf, len, reset, 0);
1173 1174
}

I
Ingo Molnar 已提交
1175
static int
1176
ftrace_regex_release(struct inode *inode, struct file *file, int enable)
1177 1178 1179 1180
{
	struct seq_file *m = (struct seq_file *)file->private_data;
	struct ftrace_iterator *iter;

1181
	mutex_lock(&ftrace_regex_lock);
1182 1183 1184 1185 1186 1187 1188 1189 1190 1191
	if (file->f_mode & FMODE_READ) {
		iter = m->private;

		seq_release(inode, file);
	} else
		iter = file->private_data;

	if (iter->buffer_idx) {
		iter->filtered++;
		iter->buffer[iter->buffer_idx] = 0;
1192
		ftrace_match(iter->buffer, iter->buffer_idx, enable);
1193 1194 1195
	}

	mutex_lock(&ftrace_sysctl_lock);
S
Steven Rostedt 已提交
1196
	mutex_lock(&ftrace_start_lock);
1197
	if (ftrace_start_up && ftrace_enabled)
1198
		ftrace_run_update_code(FTRACE_ENABLE_CALLS);
S
Steven Rostedt 已提交
1199
	mutex_unlock(&ftrace_start_lock);
1200 1201 1202
	mutex_unlock(&ftrace_sysctl_lock);

	kfree(iter);
1203
	mutex_unlock(&ftrace_regex_lock);
1204 1205 1206
	return 0;
}

1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218
static int
ftrace_filter_release(struct inode *inode, struct file *file)
{
	return ftrace_regex_release(inode, file, 1);
}

static int
ftrace_notrace_release(struct inode *inode, struct file *file)
{
	return ftrace_regex_release(inode, file, 0);
}

1219 1220 1221 1222 1223 1224 1225
static struct file_operations ftrace_avail_fops = {
	.open = ftrace_avail_open,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = ftrace_avail_release,
};

1226 1227 1228 1229 1230 1231 1232
static struct file_operations ftrace_failures_fops = {
	.open = ftrace_failures_open,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = ftrace_avail_release,
};

1233 1234
static struct file_operations ftrace_filter_fops = {
	.open = ftrace_filter_open,
1235
	.read = ftrace_regex_read,
1236
	.write = ftrace_filter_write,
1237
	.llseek = ftrace_regex_lseek,
1238 1239 1240
	.release = ftrace_filter_release,
};

1241 1242 1243 1244 1245 1246 1247 1248
static struct file_operations ftrace_notrace_fops = {
	.open = ftrace_notrace_open,
	.read = ftrace_regex_read,
	.write = ftrace_notrace_write,
	.llseek = ftrace_regex_lseek,
	.release = ftrace_notrace_release,
};

1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261
static __init int ftrace_init_debugfs(void)
{
	struct dentry *d_tracer;
	struct dentry *entry;

	d_tracer = tracing_init_dentry();

	entry = debugfs_create_file("available_filter_functions", 0444,
				    d_tracer, NULL, &ftrace_avail_fops);
	if (!entry)
		pr_warning("Could not create debugfs "
			   "'available_filter_functions' entry\n");

1262 1263 1264 1265 1266
	entry = debugfs_create_file("failures", 0444,
				    d_tracer, NULL, &ftrace_failures_fops);
	if (!entry)
		pr_warning("Could not create debugfs 'failures' entry\n");

1267 1268 1269 1270 1271
	entry = debugfs_create_file("set_ftrace_filter", 0644, d_tracer,
				    NULL, &ftrace_filter_fops);
	if (!entry)
		pr_warning("Could not create debugfs "
			   "'set_ftrace_filter' entry\n");
1272 1273 1274 1275 1276 1277

	entry = debugfs_create_file("set_ftrace_notrace", 0644, d_tracer,
				    NULL, &ftrace_notrace_fops);
	if (!entry)
		pr_warning("Could not create debugfs "
			   "'set_ftrace_notrace' entry\n");
1278

1279 1280 1281 1282 1283
	return 0;
}

fs_initcall(ftrace_init_debugfs);

1284 1285
static int ftrace_convert_nops(struct module *mod,
			       unsigned long *start,
1286 1287 1288 1289 1290 1291
			       unsigned long *end)
{
	unsigned long *p;
	unsigned long addr;
	unsigned long flags;

S
Steven Rostedt 已提交
1292
	mutex_lock(&ftrace_start_lock);
1293 1294 1295
	p = start;
	while (p < end) {
		addr = ftrace_call_adjust(*p++);
1296 1297 1298 1299 1300 1301 1302 1303
		/*
		 * Some architecture linkers will pad between
		 * the different mcount_loc sections of different
		 * object files to satisfy alignments.
		 * Skip any NULL pointers.
		 */
		if (!addr)
			continue;
1304 1305 1306
		ftrace_record_ip(addr);
	}

S
Steven Rostedt 已提交
1307
	/* disable interrupts to prevent kstop machine */
1308
	local_irq_save(flags);
1309
	ftrace_update_code(mod);
1310
	local_irq_restore(flags);
S
Steven Rostedt 已提交
1311
	mutex_unlock(&ftrace_start_lock);
1312 1313 1314 1315

	return 0;
}

1316 1317
void ftrace_init_module(struct module *mod,
			unsigned long *start, unsigned long *end)
1318
{
1319
	if (ftrace_disabled || start == end)
1320
		return;
1321
	ftrace_convert_nops(mod, start, end);
1322 1323
}

1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350
extern unsigned long __start_mcount_loc[];
extern unsigned long __stop_mcount_loc[];

void __init ftrace_init(void)
{
	unsigned long count, addr, flags;
	int ret;

	/* Keep the ftrace pointer to the stub */
	addr = (unsigned long)ftrace_stub;

	local_irq_save(flags);
	ftrace_dyn_arch_init(&addr);
	local_irq_restore(flags);

	/* ftrace_dyn_arch_init places the return code in addr */
	if (addr)
		goto failed;

	count = __stop_mcount_loc - __start_mcount_loc;

	ret = ftrace_dyn_table_alloc(count);
	if (ret)
		goto failed;

	last_ftrace_enabled = ftrace_enabled = 1;

1351 1352
	ret = ftrace_convert_nops(NULL,
				  __start_mcount_loc,
1353 1354 1355 1356 1357 1358 1359
				  __stop_mcount_loc);

	return;
 failed:
	ftrace_disabled = 1;
}

1360
#else
1361 1362 1363 1364 1365 1366 1367 1368

static int __init ftrace_nodyn_init(void)
{
	ftrace_enabled = 1;
	return 0;
}
device_initcall(ftrace_nodyn_init);

I
Ingo Molnar 已提交
1369 1370 1371 1372
# define ftrace_startup()		do { } while (0)
# define ftrace_shutdown()		do { } while (0)
# define ftrace_startup_sysctl()	do { } while (0)
# define ftrace_shutdown_sysctl()	do { } while (0)
1373 1374
#endif /* CONFIG_DYNAMIC_FTRACE */

S
Steven Rostedt 已提交
1375
/**
1376
 * ftrace_kill - kill ftrace
S
Steven Rostedt 已提交
1377 1378 1379 1380 1381
 *
 * This function should be used by panic code. It stops ftrace
 * but in a not so nice way. If you need to simply kill ftrace
 * from a non-atomic section, use ftrace_kill.
 */
1382
void ftrace_kill(void)
S
Steven Rostedt 已提交
1383 1384 1385 1386 1387 1388
{
	ftrace_disabled = 1;
	ftrace_enabled = 0;
	clear_ftrace_function();
}

1389
/**
1390 1391
 * register_ftrace_function - register a function for profiling
 * @ops - ops structure that holds the function for profiling.
1392
 *
1393 1394 1395 1396 1397 1398
 * Register a function to be called by all functions in the
 * kernel.
 *
 * Note: @ops->func and all the functions it calls must be labeled
 *       with "notrace", otherwise it will go into a
 *       recursive loop.
1399
 */
1400
int register_ftrace_function(struct ftrace_ops *ops)
1401
{
1402 1403
	int ret;

1404 1405 1406
	if (unlikely(ftrace_disabled))
		return -1;

1407 1408
	mutex_lock(&ftrace_sysctl_lock);
	ret = __register_ftrace_function(ops);
1409
	ftrace_startup();
1410 1411 1412
	mutex_unlock(&ftrace_sysctl_lock);

	return ret;
1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424
}

/**
 * unregister_ftrace_function - unresgister a function for profiling.
 * @ops - ops structure that holds the function to unregister
 *
 * Unregister a function that was added to be called by ftrace profiling.
 */
int unregister_ftrace_function(struct ftrace_ops *ops)
{
	int ret;

1425
	mutex_lock(&ftrace_sysctl_lock);
1426
	ret = __unregister_ftrace_function(ops);
1427
	ftrace_shutdown();
1428 1429 1430 1431 1432
	mutex_unlock(&ftrace_sysctl_lock);

	return ret;
}

I
Ingo Molnar 已提交
1433
int
1434
ftrace_enable_sysctl(struct ctl_table *table, int write,
1435
		     struct file *file, void __user *buffer, size_t *lenp,
1436 1437 1438 1439
		     loff_t *ppos)
{
	int ret;

1440 1441 1442
	if (unlikely(ftrace_disabled))
		return -ENODEV;

1443 1444
	mutex_lock(&ftrace_sysctl_lock);

1445
	ret  = proc_dointvec(table, write, file, buffer, lenp, ppos);
1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472

	if (ret || !write || (last_ftrace_enabled == ftrace_enabled))
		goto out;

	last_ftrace_enabled = ftrace_enabled;

	if (ftrace_enabled) {

		ftrace_startup_sysctl();

		/* we are starting ftrace again */
		if (ftrace_list != &ftrace_list_end) {
			if (ftrace_list->next == &ftrace_list_end)
				ftrace_trace_function = ftrace_list->func;
			else
				ftrace_trace_function = ftrace_list_func;
		}

	} else {
		/* stopping ftrace calls (just send to ftrace_stub) */
		ftrace_trace_function = ftrace_stub;

		ftrace_shutdown_sysctl();
	}

 out:
	mutex_unlock(&ftrace_sysctl_lock);
1473
	return ret;
1474
}
1475

1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491
#ifdef CONFIG_FUNCTION_RET_TRACER
trace_function_return_t ftrace_function_return =
			(trace_function_return_t)ftrace_stub;
void register_ftrace_return(trace_function_return_t func)
{
	ftrace_function_return = func;
}

void unregister_ftrace_return(void)
{
	ftrace_function_return = (trace_function_return_t)ftrace_stub;
}
#endif