Merge branch 'tracing-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/linux-2.6-tip
* 'tracing-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/linux-2.6-tip: (40 commits) tracing: Separate raw syscall from syscall tracer ring-buffer-benchmark: Add parameters to set produce/consumer priorities tracing, function tracer: Clean up strstrip() usage ring-buffer benchmark: Run producer/consumer threads at nice +19 tracing: Remove the stale include/trace/power.h tracing: Only print objcopy version warning once from recordmcount tracing: Prevent build warning: 'ftrace_graph_buf' defined but not used ring-buffer: Move access to commit_page up into function used tracing: do not disable interrupts for trace_clock_local ring-buffer: Add multiple iterations between benchmark timestamps kprobes: Sanitize struct kretprobe_instance allocations tracing: Fix to use __always_unused attribute compiler: Introduce __always_unused tracing: Exit with error if a weak function is used in recordmcount.pl tracing: Move conditional into update_funcs() in recordmcount.pl tracing: Add regex for weak functions in recordmcount.pl tracing: Move mcount section search to front of loop in recordmcount.pl tracing: Fix objcopy revision check in recordmcount.pl tracing: Check absolute path of input file in recordmcount.pl tracing: Correct the check for number of arguments in recordmcount.pl ...
This commit is contained in:
Linus Torvalds
commit
96fa2b508d
28 changed files with 856 additions and 518 deletions
|
|
@ -778,6 +778,13 @@ and is between 256 and 4096 characters. It is defined in the file
|
|||
by the set_ftrace_notrace file in the debugfs
|
||||
tracing directory.
|
||||
|
||||
ftrace_graph_filter=[function-list]
|
||||
[FTRACE] Limit the top level callers functions traced
|
||||
by the function graph tracer at boot up.
|
||||
function-list is a comma separated list of functions
|
||||
that can be changed at run time by the
|
||||
set_graph_function file in the debugfs tracing directory.
|
||||
|
||||
gamecon.map[2|3]=
|
||||
[HW,JOY] Multisystem joystick and NES/SNES/PSX pad
|
||||
support via parallel port (up to 5 devices per port)
|
||||
|
|
|
|||
|
|
@ -213,10 +213,19 @@ If you can't trace NMI functions, then skip this option.
|
|||
<details to be filled>
|
||||
|
||||
|
||||
HAVE_FTRACE_SYSCALLS
|
||||
HAVE_SYSCALL_TRACEPOINTS
|
||||
---------------------
|
||||
|
||||
<details to be filled>
|
||||
You need very few things to get the syscalls tracing in an arch.
|
||||
|
||||
- Have a NR_syscalls variable in <asm/unistd.h> that provides the number
|
||||
of syscalls supported by the arch.
|
||||
- Implement arch_syscall_addr() that resolves a syscall address from a
|
||||
syscall number.
|
||||
- Support the TIF_SYSCALL_TRACEPOINT thread flags
|
||||
- Put the trace_sys_enter() and trace_sys_exit() tracepoints calls from ptrace
|
||||
in the ptrace syscalls tracing path.
|
||||
- Tag this arch as HAVE_SYSCALL_TRACEPOINTS.
|
||||
|
||||
|
||||
HAVE_FTRACE_MCOUNT_RECORD
|
||||
|
|
|
|||
1
Makefile
1
Makefile
|
|
@ -379,6 +379,7 @@ export RCS_TAR_IGNORE := --exclude SCCS --exclude BitKeeper --exclude .svn --exc
|
|||
PHONY += scripts_basic
|
||||
scripts_basic:
|
||||
$(Q)$(MAKE) $(build)=scripts/basic
|
||||
$(Q)rm -f .tmp_quiet_recordmcount
|
||||
|
||||
# To avoid any implicit rule to kick in, define an empty command.
|
||||
scripts/basic/%: scripts_basic ;
|
||||
|
|
|
|||
|
|
@ -203,73 +203,10 @@ out:
|
|||
|
||||
#ifdef CONFIG_FTRACE_SYSCALLS
|
||||
|
||||
extern unsigned long __start_syscalls_metadata[];
|
||||
extern unsigned long __stop_syscalls_metadata[];
|
||||
extern unsigned int sys_call_table[];
|
||||
|
||||
static struct syscall_metadata **syscalls_metadata;
|
||||
|
||||
struct syscall_metadata *syscall_nr_to_meta(int nr)
|
||||
unsigned long __init arch_syscall_addr(int nr)
|
||||
{
|
||||
if (!syscalls_metadata || nr >= NR_syscalls || nr < 0)
|
||||
return NULL;
|
||||
|
||||
return syscalls_metadata[nr];
|
||||
return (unsigned long)sys_call_table[nr];
|
||||
}
|
||||
|
||||
int syscall_name_to_nr(char *name)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (!syscalls_metadata)
|
||||
return -1;
|
||||
for (i = 0; i < NR_syscalls; i++)
|
||||
if (syscalls_metadata[i])
|
||||
if (!strcmp(syscalls_metadata[i]->name, name))
|
||||
return i;
|
||||
return -1;
|
||||
}
|
||||
|
||||
void set_syscall_enter_id(int num, int id)
|
||||
{
|
||||
syscalls_metadata[num]->enter_id = id;
|
||||
}
|
||||
|
||||
void set_syscall_exit_id(int num, int id)
|
||||
{
|
||||
syscalls_metadata[num]->exit_id = id;
|
||||
}
|
||||
|
||||
static struct syscall_metadata *find_syscall_meta(unsigned long syscall)
|
||||
{
|
||||
struct syscall_metadata *start;
|
||||
struct syscall_metadata *stop;
|
||||
char str[KSYM_SYMBOL_LEN];
|
||||
|
||||
start = (struct syscall_metadata *)__start_syscalls_metadata;
|
||||
stop = (struct syscall_metadata *)__stop_syscalls_metadata;
|
||||
kallsyms_lookup(syscall, NULL, NULL, NULL, str);
|
||||
|
||||
for ( ; start < stop; start++) {
|
||||
if (start->name && !strcmp(start->name + 3, str + 3))
|
||||
return start;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static int __init arch_init_ftrace_syscalls(void)
|
||||
{
|
||||
struct syscall_metadata *meta;
|
||||
int i;
|
||||
syscalls_metadata = kzalloc(sizeof(*syscalls_metadata) * NR_syscalls,
|
||||
GFP_KERNEL);
|
||||
if (!syscalls_metadata)
|
||||
return -ENOMEM;
|
||||
for (i = 0; i < NR_syscalls; i++) {
|
||||
meta = find_syscall_meta((unsigned long)sys_call_table[i]);
|
||||
syscalls_metadata[i] = meta;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
arch_initcall(arch_init_ftrace_syscalls);
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -1185,17 +1185,14 @@ END(ftrace_graph_caller)
|
|||
|
||||
.globl return_to_handler
|
||||
return_to_handler:
|
||||
pushl $0
|
||||
pushl %eax
|
||||
pushl %ecx
|
||||
pushl %edx
|
||||
movl %ebp, %eax
|
||||
call ftrace_return_to_handler
|
||||
movl %eax, 0xc(%esp)
|
||||
movl %eax, %ecx
|
||||
popl %edx
|
||||
popl %ecx
|
||||
popl %eax
|
||||
ret
|
||||
jmp *%ecx
|
||||
#endif
|
||||
|
||||
.section .rodata,"a"
|
||||
|
|
|
|||
|
|
@ -155,11 +155,11 @@ GLOBAL(return_to_handler)
|
|||
|
||||
call ftrace_return_to_handler
|
||||
|
||||
movq %rax, 16(%rsp)
|
||||
movq %rax, %rdi
|
||||
movq 8(%rsp), %rdx
|
||||
movq (%rsp), %rax
|
||||
addq $16, %rsp
|
||||
retq
|
||||
addq $24, %rsp
|
||||
jmp *%rdi
|
||||
#endif
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -9,6 +9,8 @@
|
|||
* the dangers of modifying code on the run.
|
||||
*/
|
||||
|
||||
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
||||
|
||||
#include <linux/spinlock.h>
|
||||
#include <linux/hardirq.h>
|
||||
#include <linux/uaccess.h>
|
||||
|
|
@ -336,15 +338,15 @@ int __init ftrace_dyn_arch_init(void *data)
|
|||
|
||||
switch (faulted) {
|
||||
case 0:
|
||||
pr_info("ftrace: converting mcount calls to 0f 1f 44 00 00\n");
|
||||
pr_info("converting mcount calls to 0f 1f 44 00 00\n");
|
||||
memcpy(ftrace_nop, ftrace_test_p6nop, MCOUNT_INSN_SIZE);
|
||||
break;
|
||||
case 1:
|
||||
pr_info("ftrace: converting mcount calls to 66 66 66 66 90\n");
|
||||
pr_info("converting mcount calls to 66 66 66 66 90\n");
|
||||
memcpy(ftrace_nop, ftrace_test_nop5, MCOUNT_INSN_SIZE);
|
||||
break;
|
||||
case 2:
|
||||
pr_info("ftrace: converting mcount calls to jmp . + 5\n");
|
||||
pr_info("converting mcount calls to jmp . + 5\n");
|
||||
memcpy(ftrace_nop, ftrace_test_jmp, MCOUNT_INSN_SIZE);
|
||||
break;
|
||||
}
|
||||
|
|
@ -468,82 +470,10 @@ void prepare_ftrace_return(unsigned long *parent, unsigned long self_addr,
|
|||
|
||||
#ifdef CONFIG_FTRACE_SYSCALLS
|
||||
|
||||
extern unsigned long __start_syscalls_metadata[];
|
||||
extern unsigned long __stop_syscalls_metadata[];
|
||||
extern unsigned long *sys_call_table;
|
||||
|
||||
static struct syscall_metadata **syscalls_metadata;
|
||||
|
||||
static struct syscall_metadata *find_syscall_meta(unsigned long *syscall)
|
||||
unsigned long __init arch_syscall_addr(int nr)
|
||||
{
|
||||
struct syscall_metadata *start;
|
||||
struct syscall_metadata *stop;
|
||||
char str[KSYM_SYMBOL_LEN];
|
||||
|
||||
|
||||
start = (struct syscall_metadata *)__start_syscalls_metadata;
|
||||
stop = (struct syscall_metadata *)__stop_syscalls_metadata;
|
||||
kallsyms_lookup((unsigned long) syscall, NULL, NULL, NULL, str);
|
||||
|
||||
for ( ; start < stop; start++) {
|
||||
if (start->name && !strcmp(start->name, str))
|
||||
return start;
|
||||
}
|
||||
return NULL;
|
||||
return (unsigned long)(&sys_call_table)[nr];
|
||||
}
|
||||
|
||||
struct syscall_metadata *syscall_nr_to_meta(int nr)
|
||||
{
|
||||
if (!syscalls_metadata || nr >= NR_syscalls || nr < 0)
|
||||
return NULL;
|
||||
|
||||
return syscalls_metadata[nr];
|
||||
}
|
||||
|
||||
int syscall_name_to_nr(char *name)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (!syscalls_metadata)
|
||||
return -1;
|
||||
|
||||
for (i = 0; i < NR_syscalls; i++) {
|
||||
if (syscalls_metadata[i]) {
|
||||
if (!strcmp(syscalls_metadata[i]->name, name))
|
||||
return i;
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
void set_syscall_enter_id(int num, int id)
|
||||
{
|
||||
syscalls_metadata[num]->enter_id = id;
|
||||
}
|
||||
|
||||
void set_syscall_exit_id(int num, int id)
|
||||
{
|
||||
syscalls_metadata[num]->exit_id = id;
|
||||
}
|
||||
|
||||
static int __init arch_init_ftrace_syscalls(void)
|
||||
{
|
||||
int i;
|
||||
struct syscall_metadata *meta;
|
||||
unsigned long **psys_syscall_table = &sys_call_table;
|
||||
|
||||
syscalls_metadata = kzalloc(sizeof(*syscalls_metadata) *
|
||||
NR_syscalls, GFP_KERNEL);
|
||||
if (!syscalls_metadata) {
|
||||
WARN_ON(1);
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
for (i = 0; i < NR_syscalls; i++) {
|
||||
meta = find_syscall_meta(psys_syscall_table[i]);
|
||||
syscalls_metadata[i] = meta;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
arch_initcall(arch_init_ftrace_syscalls);
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -1,12 +1,13 @@
|
|||
/*
|
||||
* Written by Pekka Paalanen, 2008-2009 <pq@iki.fi>
|
||||
*/
|
||||
|
||||
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
||||
|
||||
#include <linux/module.h>
|
||||
#include <linux/io.h>
|
||||
#include <linux/mmiotrace.h>
|
||||
|
||||
#define MODULE_NAME "testmmiotrace"
|
||||
|
||||
static unsigned long mmio_address;
|
||||
module_param(mmio_address, ulong, 0);
|
||||
MODULE_PARM_DESC(mmio_address, " Start address of the mapping of 16 kB "
|
||||
|
|
@ -30,7 +31,7 @@ static unsigned v32(unsigned i)
|
|||
static void do_write_test(void __iomem *p)
|
||||
{
|
||||
unsigned int i;
|
||||
pr_info(MODULE_NAME ": write test.\n");
|
||||
pr_info("write test.\n");
|
||||
mmiotrace_printk("Write test.\n");
|
||||
|
||||
for (i = 0; i < 256; i++)
|
||||
|
|
@ -47,7 +48,7 @@ static void do_read_test(void __iomem *p)
|
|||
{
|
||||
unsigned int i;
|
||||
unsigned errs[3] = { 0 };
|
||||
pr_info(MODULE_NAME ": read test.\n");
|
||||
pr_info("read test.\n");
|
||||
mmiotrace_printk("Read test.\n");
|
||||
|
||||
for (i = 0; i < 256; i++)
|
||||
|
|
@ -68,7 +69,7 @@ static void do_read_test(void __iomem *p)
|
|||
|
||||
static void do_read_far_test(void __iomem *p)
|
||||
{
|
||||
pr_info(MODULE_NAME ": read far test.\n");
|
||||
pr_info("read far test.\n");
|
||||
mmiotrace_printk("Read far test.\n");
|
||||
|
||||
ioread32(p + read_far);
|
||||
|
|
@ -78,7 +79,7 @@ static void do_test(unsigned long size)
|
|||
{
|
||||
void __iomem *p = ioremap_nocache(mmio_address, size);
|
||||
if (!p) {
|
||||
pr_err(MODULE_NAME ": could not ioremap, aborting.\n");
|
||||
pr_err("could not ioremap, aborting.\n");
|
||||
return;
|
||||
}
|
||||
mmiotrace_printk("ioremap returned %p.\n", p);
|
||||
|
|
@ -94,24 +95,22 @@ static int __init init(void)
|
|||
unsigned long size = (read_far) ? (8 << 20) : (16 << 10);
|
||||
|
||||
if (mmio_address == 0) {
|
||||
pr_err(MODULE_NAME ": you have to use the module argument "
|
||||
"mmio_address.\n");
|
||||
pr_err(MODULE_NAME ": DO NOT LOAD THIS MODULE UNLESS"
|
||||
" YOU REALLY KNOW WHAT YOU ARE DOING!\n");
|
||||
pr_err("you have to use the module argument mmio_address.\n");
|
||||
pr_err("DO NOT LOAD THIS MODULE UNLESS YOU REALLY KNOW WHAT YOU ARE DOING!\n");
|
||||
return -ENXIO;
|
||||
}
|
||||
|
||||
pr_warning(MODULE_NAME ": WARNING: mapping %lu kB @ 0x%08lx in PCI "
|
||||
"address space, and writing 16 kB of rubbish in there.\n",
|
||||
size >> 10, mmio_address);
|
||||
pr_warning("WARNING: mapping %lu kB @ 0x%08lx in PCI address space, "
|
||||
"and writing 16 kB of rubbish in there.\n",
|
||||
size >> 10, mmio_address);
|
||||
do_test(size);
|
||||
pr_info(MODULE_NAME ": All done.\n");
|
||||
pr_info("All done.\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void __exit cleanup(void)
|
||||
{
|
||||
pr_debug(MODULE_NAME ": unloaded.\n");
|
||||
pr_debug("unloaded.\n");
|
||||
}
|
||||
|
||||
module_init(init);
|
||||
|
|
|
|||
|
|
@ -79,6 +79,7 @@
|
|||
#define noinline __attribute__((noinline))
|
||||
#define __attribute_const__ __attribute__((__const__))
|
||||
#define __maybe_unused __attribute__((unused))
|
||||
#define __always_unused __attribute__((unused))
|
||||
|
||||
#define __gcc_header(x) #x
|
||||
#define _gcc_header(x) __gcc_header(linux/compiler-gcc##x.h)
|
||||
|
|
|
|||
|
|
@ -218,6 +218,10 @@ void ftrace_likely_update(struct ftrace_branch_data *f, int val, int expect);
|
|||
# define __maybe_unused /* unimplemented */
|
||||
#endif
|
||||
|
||||
#ifndef __always_unused
|
||||
# define __always_unused /* unimplemented */
|
||||
#endif
|
||||
|
||||
#ifndef noinline
|
||||
#define noinline
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -24,8 +24,21 @@ static inline int reacquire_kernel_lock(struct task_struct *task)
|
|||
return 0;
|
||||
}
|
||||
|
||||
extern void __lockfunc lock_kernel(void) __acquires(kernel_lock);
|
||||
extern void __lockfunc unlock_kernel(void) __releases(kernel_lock);
|
||||
extern void __lockfunc
|
||||
_lock_kernel(const char *func, const char *file, int line)
|
||||
__acquires(kernel_lock);
|
||||
|
||||
extern void __lockfunc
|
||||
_unlock_kernel(const char *func, const char *file, int line)
|
||||
__releases(kernel_lock);
|
||||
|
||||
#define lock_kernel() do { \
|
||||
_lock_kernel(__func__, __FILE__, __LINE__); \
|
||||
} while (0)
|
||||
|
||||
#define unlock_kernel() do { \
|
||||
_unlock_kernel(__func__, __FILE__, __LINE__); \
|
||||
} while (0)
|
||||
|
||||
/*
|
||||
* Various legacy drivers don't really need the BKL in a specific
|
||||
|
|
@ -41,8 +54,8 @@ static inline void cycle_kernel_lock(void)
|
|||
|
||||
#else
|
||||
|
||||
#define lock_kernel() do { } while(0)
|
||||
#define unlock_kernel() do { } while(0)
|
||||
#define lock_kernel()
|
||||
#define unlock_kernel()
|
||||
#define release_kernel_lock(task) do { } while(0)
|
||||
#define cycle_kernel_lock() do { } while(0)
|
||||
#define reacquire_kernel_lock(task) 0
|
||||
|
|
|
|||
61
include/trace/events/bkl.h
Normal file
61
include/trace/events/bkl.h
Normal file
|
|
@ -0,0 +1,61 @@
|
|||
#undef TRACE_SYSTEM
|
||||
#define TRACE_SYSTEM bkl
|
||||
|
||||
#if !defined(_TRACE_BKL_H) || defined(TRACE_HEADER_MULTI_READ)
|
||||
#define _TRACE_BKL_H
|
||||
|
||||
#include <linux/tracepoint.h>
|
||||
|
||||
TRACE_EVENT(lock_kernel,
|
||||
|
||||
TP_PROTO(const char *func, const char *file, int line),
|
||||
|
||||
TP_ARGS(func, file, line),
|
||||
|
||||
TP_STRUCT__entry(
|
||||
__field( int, lock_depth )
|
||||
__field_ext( const char *, func, FILTER_PTR_STRING )
|
||||
__field_ext( const char *, file, FILTER_PTR_STRING )
|
||||
__field( int, line )
|
||||
),
|
||||
|
||||
TP_fast_assign(
|
||||
/* We want to record the lock_depth after lock is acquired */
|
||||
__entry->lock_depth = current->lock_depth + 1;
|
||||
__entry->func = func;
|
||||
__entry->file = file;
|
||||
__entry->line = line;
|
||||
),
|
||||
|
||||
TP_printk("depth: %d, %s:%d %s()", __entry->lock_depth,
|
||||
__entry->file, __entry->line, __entry->func)
|
||||
);
|
||||
|
||||
TRACE_EVENT(unlock_kernel,
|
||||
|
||||
TP_PROTO(const char *func, const char *file, int line),
|
||||
|
||||
TP_ARGS(func, file, line),
|
||||
|
||||
TP_STRUCT__entry(
|
||||
__field(int, lock_depth)
|
||||
__field(const char *, func)
|
||||
__field(const char *, file)
|
||||
__field(int, line)
|
||||
),
|
||||
|
||||
TP_fast_assign(
|
||||
__entry->lock_depth = current->lock_depth;
|
||||
__entry->func = func;
|
||||
__entry->file = file;
|
||||
__entry->line = line;
|
||||
),
|
||||
|
||||
TP_printk("depth: %d, %s:%d %s()", __entry->lock_depth,
|
||||
__entry->file, __entry->line, __entry->func)
|
||||
);
|
||||
|
||||
#endif /* _TRACE_BKL_H */
|
||||
|
||||
/* This part must be outside protection */
|
||||
#include <trace/define_trace.h>
|
||||
|
|
@ -1,5 +1,6 @@
|
|||
#undef TRACE_SYSTEM
|
||||
#define TRACE_SYSTEM syscalls
|
||||
#define TRACE_SYSTEM raw_syscalls
|
||||
#define TRACE_INCLUDE_FILE syscalls
|
||||
|
||||
#if !defined(_TRACE_EVENTS_SYSCALLS_H) || defined(TRACE_HEADER_MULTI_READ)
|
||||
#define _TRACE_EVENTS_SYSCALLS_H
|
||||
|
|
|
|||
|
|
@ -1,32 +0,0 @@
|
|||
#ifndef _TRACE_POWER_H
|
||||
#define _TRACE_POWER_H
|
||||
|
||||
#include <linux/ktime.h>
|
||||
#include <linux/tracepoint.h>
|
||||
|
||||
enum {
|
||||
POWER_NONE = 0,
|
||||
POWER_CSTATE = 1,
|
||||
POWER_PSTATE = 2,
|
||||
};
|
||||
|
||||
struct power_trace {
|
||||
ktime_t stamp;
|
||||
ktime_t end;
|
||||
int type;
|
||||
int state;
|
||||
};
|
||||
|
||||
DECLARE_TRACE(power_start,
|
||||
TP_PROTO(struct power_trace *it, unsigned int type, unsigned int state),
|
||||
TP_ARGS(it, type, state));
|
||||
|
||||
DECLARE_TRACE(power_mark,
|
||||
TP_PROTO(struct power_trace *it, unsigned int type, unsigned int state),
|
||||
TP_ARGS(it, type, state));
|
||||
|
||||
DECLARE_TRACE(power_end,
|
||||
TP_PROTO(struct power_trace *it),
|
||||
TP_ARGS(it));
|
||||
|
||||
#endif /* _TRACE_POWER_H */
|
||||
|
|
@ -33,7 +33,7 @@ struct syscall_metadata {
|
|||
};
|
||||
|
||||
#ifdef CONFIG_FTRACE_SYSCALLS
|
||||
extern struct syscall_metadata *syscall_nr_to_meta(int nr);
|
||||
extern unsigned long arch_syscall_addr(int nr);
|
||||
extern int syscall_name_to_nr(char *name);
|
||||
void set_syscall_enter_id(int num, int id);
|
||||
void set_syscall_exit_id(int num, int id);
|
||||
|
|
|
|||
|
|
@ -1014,9 +1014,9 @@ int __kprobes register_kretprobe(struct kretprobe *rp)
|
|||
/* Pre-allocate memory for max kretprobe instances */
|
||||
if (rp->maxactive <= 0) {
|
||||
#ifdef CONFIG_PREEMPT
|
||||
rp->maxactive = max(10, 2 * NR_CPUS);
|
||||
rp->maxactive = max(10, 2 * num_possible_cpus());
|
||||
#else
|
||||
rp->maxactive = NR_CPUS;
|
||||
rp->maxactive = num_possible_cpus();
|
||||
#endif
|
||||
}
|
||||
spin_lock_init(&rp->lock);
|
||||
|
|
|
|||
|
|
@ -60,6 +60,13 @@ static int last_ftrace_enabled;
|
|||
/* Quick disabling of function tracer. */
|
||||
int function_trace_stop;
|
||||
|
||||
/* List for set_ftrace_pid's pids. */
|
||||
LIST_HEAD(ftrace_pids);
|
||||
struct ftrace_pid {
|
||||
struct list_head list;
|
||||
struct pid *pid;
|
||||
};
|
||||
|
||||
/*
|
||||
* ftrace_disabled is set when an anomaly is discovered.
|
||||
* ftrace_disabled is much stronger than ftrace_enabled.
|
||||
|
|
@ -78,6 +85,10 @@ ftrace_func_t ftrace_trace_function __read_mostly = ftrace_stub;
|
|||
ftrace_func_t __ftrace_trace_function __read_mostly = ftrace_stub;
|
||||
ftrace_func_t ftrace_pid_function __read_mostly = ftrace_stub;
|
||||
|
||||
#ifdef CONFIG_FUNCTION_GRAPH_TRACER
|
||||
static int ftrace_set_func(unsigned long *array, int *idx, char *buffer);
|
||||
#endif
|
||||
|
||||
static void ftrace_list_func(unsigned long ip, unsigned long parent_ip)
|
||||
{
|
||||
struct ftrace_ops *op = ftrace_list;
|
||||
|
|
@ -155,7 +166,7 @@ static int __register_ftrace_function(struct ftrace_ops *ops)
|
|||
else
|
||||
func = ftrace_list_func;
|
||||
|
||||
if (ftrace_pid_trace) {
|
||||
if (!list_empty(&ftrace_pids)) {
|
||||
set_ftrace_pid_function(func);
|
||||
func = ftrace_pid_func;
|
||||
}
|
||||
|
|
@ -203,7 +214,7 @@ static int __unregister_ftrace_function(struct ftrace_ops *ops)
|
|||
if (ftrace_list->next == &ftrace_list_end) {
|
||||
ftrace_func_t func = ftrace_list->func;
|
||||
|
||||
if (ftrace_pid_trace) {
|
||||
if (!list_empty(&ftrace_pids)) {
|
||||
set_ftrace_pid_function(func);
|
||||
func = ftrace_pid_func;
|
||||
}
|
||||
|
|
@ -231,7 +242,7 @@ static void ftrace_update_pid_func(void)
|
|||
func = __ftrace_trace_function;
|
||||
#endif
|
||||
|
||||
if (ftrace_pid_trace) {
|
||||
if (!list_empty(&ftrace_pids)) {
|
||||
set_ftrace_pid_function(func);
|
||||
func = ftrace_pid_func;
|
||||
} else {
|
||||
|
|
@ -821,8 +832,6 @@ static __init void ftrace_profile_debugfs(struct dentry *d_tracer)
|
|||
}
|
||||
#endif /* CONFIG_FUNCTION_PROFILER */
|
||||
|
||||
/* set when tracing only a pid */
|
||||
struct pid *ftrace_pid_trace;
|
||||
static struct pid * const ftrace_swapper_pid = &init_struct_pid;
|
||||
|
||||
#ifdef CONFIG_DYNAMIC_FTRACE
|
||||
|
|
@ -1261,12 +1270,34 @@ static int ftrace_update_code(struct module *mod)
|
|||
ftrace_new_addrs = p->newlist;
|
||||
p->flags = 0L;
|
||||
|
||||
/* convert record (i.e, patch mcount-call with NOP) */
|
||||
if (ftrace_code_disable(mod, p)) {
|
||||
p->flags |= FTRACE_FL_CONVERTED;
|
||||
ftrace_update_cnt++;
|
||||
} else
|
||||
/*
|
||||
* Do the initial record convertion from mcount jump
|
||||
* to the NOP instructions.
|
||||
*/
|
||||
if (!ftrace_code_disable(mod, p)) {
|
||||
ftrace_free_rec(p);
|
||||
continue;
|
||||
}
|
||||
|
||||
p->flags |= FTRACE_FL_CONVERTED;
|
||||
ftrace_update_cnt++;
|
||||
|
||||
/*
|
||||
* If the tracing is enabled, go ahead and enable the record.
|
||||
*
|
||||
* The reason not to enable the record immediatelly is the
|
||||
* inherent check of ftrace_make_nop/ftrace_make_call for
|
||||
* correct previous instructions. Making first the NOP
|
||||
* conversion puts the module to the correct state, thus
|
||||
* passing the ftrace_make_call check.
|
||||
*/
|
||||
if (ftrace_start_up) {
|
||||
int failed = __ftrace_replace_code(p, 1);
|
||||
if (failed) {
|
||||
ftrace_bug(failed, p->ip);
|
||||
ftrace_free_rec(p);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
stop = ftrace_now(raw_smp_processor_id());
|
||||
|
|
@ -1656,60 +1687,6 @@ ftrace_regex_lseek(struct file *file, loff_t offset, int origin)
|
|||
return ret;
|
||||
}
|
||||
|
||||
enum {
|
||||
MATCH_FULL,
|
||||
MATCH_FRONT_ONLY,
|
||||
MATCH_MIDDLE_ONLY,
|
||||
MATCH_END_ONLY,
|
||||
};
|
||||
|
||||
/*
|
||||
* (static function - no need for kernel doc)
|
||||
*
|
||||
* Pass in a buffer containing a glob and this function will
|
||||
* set search to point to the search part of the buffer and
|
||||
* return the type of search it is (see enum above).
|
||||
* This does modify buff.
|
||||
*
|
||||
* Returns enum type.
|
||||
* search returns the pointer to use for comparison.
|
||||
* not returns 1 if buff started with a '!'
|
||||
* 0 otherwise.
|
||||
*/
|
||||
static int
|
||||
ftrace_setup_glob(char *buff, int len, char **search, int *not)
|
||||
{
|
||||
int type = MATCH_FULL;
|
||||
int i;
|
||||
|
||||
if (buff[0] == '!') {
|
||||
*not = 1;
|
||||
buff++;
|
||||
len--;
|
||||
} else
|
||||
*not = 0;
|
||||
|
||||
*search = buff;
|
||||
|
||||
for (i = 0; i < len; i++) {
|
||||
if (buff[i] == '*') {
|
||||
if (!i) {
|
||||
*search = buff + 1;
|
||||
type = MATCH_END_ONLY;
|
||||
} else {
|
||||
if (type == MATCH_END_ONLY)
|
||||
type = MATCH_MIDDLE_ONLY;
|
||||
else
|
||||
type = MATCH_FRONT_ONLY;
|
||||
buff[i] = 0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return type;
|
||||
}
|
||||
|
||||
static int ftrace_match(char *str, char *regex, int len, int type)
|
||||
{
|
||||
int matched = 0;
|
||||
|
|
@ -1758,7 +1735,7 @@ static void ftrace_match_records(char *buff, int len, int enable)
|
|||
int not;
|
||||
|
||||
flag = enable ? FTRACE_FL_FILTER : FTRACE_FL_NOTRACE;
|
||||
type = ftrace_setup_glob(buff, len, &search, ¬);
|
||||
type = filter_parse_regex(buff, len, &search, ¬);
|
||||
|
||||
search_len = strlen(search);
|
||||
|
||||
|
|
@ -1826,7 +1803,7 @@ static void ftrace_match_module_records(char *buff, char *mod, int enable)
|
|||
}
|
||||
|
||||
if (strlen(buff)) {
|
||||
type = ftrace_setup_glob(buff, strlen(buff), &search, ¬);
|
||||
type = filter_parse_regex(buff, strlen(buff), &search, ¬);
|
||||
search_len = strlen(search);
|
||||
}
|
||||
|
||||
|
|
@ -1991,7 +1968,7 @@ register_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops,
|
|||
int count = 0;
|
||||
char *search;
|
||||
|
||||
type = ftrace_setup_glob(glob, strlen(glob), &search, ¬);
|
||||
type = filter_parse_regex(glob, strlen(glob), &search, ¬);
|
||||
len = strlen(search);
|
||||
|
||||
/* we do not support '!' for function probes */
|
||||
|
|
@ -2068,7 +2045,7 @@ __unregister_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops,
|
|||
else if (glob) {
|
||||
int not;
|
||||
|
||||
type = ftrace_setup_glob(glob, strlen(glob), &search, ¬);
|
||||
type = filter_parse_regex(glob, strlen(glob), &search, ¬);
|
||||
len = strlen(search);
|
||||
|
||||
/* we do not support '!' for function probes */
|
||||
|
|
@ -2312,6 +2289,32 @@ static int __init set_ftrace_filter(char *str)
|
|||
}
|
||||
__setup("ftrace_filter=", set_ftrace_filter);
|
||||
|
||||
#ifdef CONFIG_FUNCTION_GRAPH_TRACER
|
||||
static char ftrace_graph_buf[FTRACE_FILTER_SIZE] __initdata;
|
||||
static int __init set_graph_function(char *str)
|
||||
{
|
||||
strlcpy(ftrace_graph_buf, str, FTRACE_FILTER_SIZE);
|
||||
return 1;
|
||||
}
|
||||
__setup("ftrace_graph_filter=", set_graph_function);
|
||||
|
||||
static void __init set_ftrace_early_graph(char *buf)
|
||||
{
|
||||
int ret;
|
||||
char *func;
|
||||
|
||||
while (buf) {
|
||||
func = strsep(&buf, ",");
|
||||
/* we allow only one expression at a time */
|
||||
ret = ftrace_set_func(ftrace_graph_funcs, &ftrace_graph_count,
|
||||
func);
|
||||
if (ret)
|
||||
printk(KERN_DEBUG "ftrace: function %s not "
|
||||
"traceable\n", func);
|
||||
}
|
||||
}
|
||||
#endif /* CONFIG_FUNCTION_GRAPH_TRACER */
|
||||
|
||||
static void __init set_ftrace_early_filter(char *buf, int enable)
|
||||
{
|
||||
char *func;
|
||||
|
|
@ -2328,6 +2331,10 @@ static void __init set_ftrace_early_filters(void)
|
|||
set_ftrace_early_filter(ftrace_filter_buf, 1);
|
||||
if (ftrace_notrace_buf[0])
|
||||
set_ftrace_early_filter(ftrace_notrace_buf, 0);
|
||||
#ifdef CONFIG_FUNCTION_GRAPH_TRACER
|
||||
if (ftrace_graph_buf[0])
|
||||
set_ftrace_early_graph(ftrace_graph_buf);
|
||||
#endif /* CONFIG_FUNCTION_GRAPH_TRACER */
|
||||
}
|
||||
|
||||
static int
|
||||
|
|
@ -2513,7 +2520,7 @@ ftrace_set_func(unsigned long *array, int *idx, char *buffer)
|
|||
return -ENODEV;
|
||||
|
||||
/* decode regex */
|
||||
type = ftrace_setup_glob(buffer, strlen(buffer), &search, ¬);
|
||||
type = filter_parse_regex(buffer, strlen(buffer), &search, ¬);
|
||||
if (not)
|
||||
return -EINVAL;
|
||||
|
||||
|
|
@ -2624,7 +2631,7 @@ static __init int ftrace_init_dyn_debugfs(struct dentry *d_tracer)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int ftrace_convert_nops(struct module *mod,
|
||||
static int ftrace_process_locs(struct module *mod,
|
||||
unsigned long *start,
|
||||
unsigned long *end)
|
||||
{
|
||||
|
|
@ -2684,7 +2691,7 @@ static void ftrace_init_module(struct module *mod,
|
|||
{
|
||||
if (ftrace_disabled || start == end)
|
||||
return;
|
||||
ftrace_convert_nops(mod, start, end);
|
||||
ftrace_process_locs(mod, start, end);
|
||||
}
|
||||
|
||||
static int ftrace_module_notify(struct notifier_block *self,
|
||||
|
|
@ -2745,7 +2752,7 @@ void __init ftrace_init(void)
|
|||
|
||||
last_ftrace_enabled = ftrace_enabled = 1;
|
||||
|
||||
ret = ftrace_convert_nops(NULL,
|
||||
ret = ftrace_process_locs(NULL,
|
||||
__start_mcount_loc,
|
||||
__stop_mcount_loc);
|
||||
|
||||
|
|
@ -2778,23 +2785,6 @@ static inline void ftrace_startup_enable(int command) { }
|
|||
# define ftrace_shutdown_sysctl() do { } while (0)
|
||||
#endif /* CONFIG_DYNAMIC_FTRACE */
|
||||
|
||||
static ssize_t
|
||||
ftrace_pid_read(struct file *file, char __user *ubuf,
|
||||
size_t cnt, loff_t *ppos)
|
||||
{
|
||||
char buf[64];
|
||||
int r;
|
||||
|
||||
if (ftrace_pid_trace == ftrace_swapper_pid)
|
||||
r = sprintf(buf, "swapper tasks\n");
|
||||
else if (ftrace_pid_trace)
|
||||
r = sprintf(buf, "%u\n", pid_vnr(ftrace_pid_trace));
|
||||
else
|
||||
r = sprintf(buf, "no pid\n");
|
||||
|
||||
return simple_read_from_buffer(ubuf, cnt, ppos, buf, r);
|
||||
}
|
||||
|
||||
static void clear_ftrace_swapper(void)
|
||||
{
|
||||
struct task_struct *p;
|
||||
|
|
@ -2845,14 +2835,12 @@ static void set_ftrace_pid(struct pid *pid)
|
|||
rcu_read_unlock();
|
||||
}
|
||||
|
||||
static void clear_ftrace_pid_task(struct pid **pid)
|
||||
static void clear_ftrace_pid_task(struct pid *pid)
|
||||
{
|
||||
if (*pid == ftrace_swapper_pid)
|
||||
if (pid == ftrace_swapper_pid)
|
||||
clear_ftrace_swapper();
|
||||
else
|
||||
clear_ftrace_pid(*pid);
|
||||
|
||||
*pid = NULL;
|
||||
clear_ftrace_pid(pid);
|
||||
}
|
||||
|
||||
static void set_ftrace_pid_task(struct pid *pid)
|
||||
|
|
@ -2863,12 +2851,141 @@ static void set_ftrace_pid_task(struct pid *pid)
|
|||
set_ftrace_pid(pid);
|
||||
}
|
||||
|
||||
static int ftrace_pid_add(int p)
|
||||
{
|
||||
struct pid *pid;
|
||||
struct ftrace_pid *fpid;
|
||||
int ret = -EINVAL;
|
||||
|
||||
mutex_lock(&ftrace_lock);
|
||||
|
||||
if (!p)
|
||||
pid = ftrace_swapper_pid;
|
||||
else
|
||||
pid = find_get_pid(p);
|
||||
|
||||
if (!pid)
|
||||
goto out;
|
||||
|
||||
ret = 0;
|
||||
|
||||
list_for_each_entry(fpid, &ftrace_pids, list)
|
||||
if (fpid->pid == pid)
|
||||
goto out_put;
|
||||
|
||||
ret = -ENOMEM;
|
||||
|
||||
fpid = kmalloc(sizeof(*fpid), GFP_KERNEL);
|
||||
if (!fpid)
|
||||
goto out_put;
|
||||
|
||||
list_add(&fpid->list, &ftrace_pids);
|
||||
fpid->pid = pid;
|
||||
|
||||
set_ftrace_pid_task(pid);
|
||||
|
||||
ftrace_update_pid_func();
|
||||
ftrace_startup_enable(0);
|
||||
|
||||
mutex_unlock(&ftrace_lock);
|
||||
return 0;
|
||||
|
||||
out_put:
|
||||
if (pid != ftrace_swapper_pid)
|
||||
put_pid(pid);
|
||||
|
||||
out:
|
||||
mutex_unlock(&ftrace_lock);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static void ftrace_pid_reset(void)
|
||||
{
|
||||
struct ftrace_pid *fpid, *safe;
|
||||
|
||||
mutex_lock(&ftrace_lock);
|
||||
list_for_each_entry_safe(fpid, safe, &ftrace_pids, list) {
|
||||
struct pid *pid = fpid->pid;
|
||||
|
||||
clear_ftrace_pid_task(pid);
|
||||
|
||||
list_del(&fpid->list);
|
||||
kfree(fpid);
|
||||
}
|
||||
|
||||
ftrace_update_pid_func();
|
||||
ftrace_startup_enable(0);
|
||||
|
||||
mutex_unlock(&ftrace_lock);
|
||||
}
|
||||
|
||||
static void *fpid_start(struct seq_file *m, loff_t *pos)
|
||||
{
|
||||
mutex_lock(&ftrace_lock);
|
||||
|
||||
if (list_empty(&ftrace_pids) && (!*pos))
|
||||
return (void *) 1;
|
||||
|
||||
return seq_list_start(&ftrace_pids, *pos);
|
||||
}
|
||||
|
||||
static void *fpid_next(struct seq_file *m, void *v, loff_t *pos)
|
||||
{
|
||||
if (v == (void *)1)
|
||||
return NULL;
|
||||
|
||||
return seq_list_next(v, &ftrace_pids, pos);
|
||||
}
|
||||
|
||||
static void fpid_stop(struct seq_file *m, void *p)
|
||||
{
|
||||
mutex_unlock(&ftrace_lock);
|
||||
}
|
||||
|
||||
static int fpid_show(struct seq_file *m, void *v)
|
||||
{
|
||||
const struct ftrace_pid *fpid = list_entry(v, struct ftrace_pid, list);
|
||||
|
||||
if (v == (void *)1) {
|
||||
seq_printf(m, "no pid\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (fpid->pid == ftrace_swapper_pid)
|
||||
seq_printf(m, "swapper tasks\n");
|
||||
else
|
||||
seq_printf(m, "%u\n", pid_vnr(fpid->pid));
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct seq_operations ftrace_pid_sops = {
|
||||
.start = fpid_start,
|
||||
.next = fpid_next,
|
||||
.stop = fpid_stop,
|
||||
.show = fpid_show,
|
||||
};
|
||||
|
||||
static int
|
||||
ftrace_pid_open(struct inode *inode, struct file *file)
|
||||
{
|
||||
int ret = 0;
|
||||
|
||||
if ((file->f_mode & FMODE_WRITE) &&
|
||||
(file->f_flags & O_TRUNC))
|
||||
ftrace_pid_reset();
|
||||
|
||||
if (file->f_mode & FMODE_READ)
|
||||
ret = seq_open(file, &ftrace_pid_sops);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static ssize_t
|
||||
ftrace_pid_write(struct file *filp, const char __user *ubuf,
|
||||
size_t cnt, loff_t *ppos)
|
||||
{
|
||||
struct pid *pid;
|
||||
char buf[64];
|
||||
char buf[64], *tmp;
|
||||
long val;
|
||||
int ret;
|
||||
|
||||
|
|
@ -2880,57 +2997,38 @@ ftrace_pid_write(struct file *filp, const char __user *ubuf,
|
|||
|
||||
buf[cnt] = 0;
|
||||
|
||||
ret = strict_strtol(buf, 10, &val);
|
||||
/*
|
||||
* Allow "echo > set_ftrace_pid" or "echo -n '' > set_ftrace_pid"
|
||||
* to clean the filter quietly.
|
||||
*/
|
||||
tmp = strstrip(buf);
|
||||
if (strlen(tmp) == 0)
|
||||
return 1;
|
||||
|
||||
ret = strict_strtol(tmp, 10, &val);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
mutex_lock(&ftrace_lock);
|
||||
if (val < 0) {
|
||||
/* disable pid tracing */
|
||||
if (!ftrace_pid_trace)
|
||||
goto out;
|
||||
ret = ftrace_pid_add(val);
|
||||
|
||||
clear_ftrace_pid_task(&ftrace_pid_trace);
|
||||
return ret ? ret : cnt;
|
||||
}
|
||||
|
||||
} else {
|
||||
/* swapper task is special */
|
||||
if (!val) {
|
||||
pid = ftrace_swapper_pid;
|
||||
if (pid == ftrace_pid_trace)
|
||||
goto out;
|
||||
} else {
|
||||
pid = find_get_pid(val);
|
||||
static int
|
||||
ftrace_pid_release(struct inode *inode, struct file *file)
|
||||
{
|
||||
if (file->f_mode & FMODE_READ)
|
||||
seq_release(inode, file);
|
||||
|
||||
if (pid == ftrace_pid_trace) {
|
||||
put_pid(pid);
|
||||
goto out;
|
||||
}
|
||||
}
|
||||
|
||||
if (ftrace_pid_trace)
|
||||
clear_ftrace_pid_task(&ftrace_pid_trace);
|
||||
|
||||
if (!pid)
|
||||
goto out;
|
||||
|
||||
ftrace_pid_trace = pid;
|
||||
|
||||
set_ftrace_pid_task(ftrace_pid_trace);
|
||||
}
|
||||
|
||||
/* update the function call */
|
||||
ftrace_update_pid_func();
|
||||
ftrace_startup_enable(0);
|
||||
|
||||
out:
|
||||
mutex_unlock(&ftrace_lock);
|
||||
|
||||
return cnt;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct file_operations ftrace_pid_fops = {
|
||||
.read = ftrace_pid_read,
|
||||
.write = ftrace_pid_write,
|
||||
.open = ftrace_pid_open,
|
||||
.write = ftrace_pid_write,
|
||||
.read = seq_read,
|
||||
.llseek = seq_lseek,
|
||||
.release = ftrace_pid_release,
|
||||
};
|
||||
|
||||
static __init int ftrace_init_debugfs(void)
|
||||
|
|
@ -3293,4 +3391,3 @@ void ftrace_graph_stop(void)
|
|||
ftrace_stop();
|
||||
}
|
||||
#endif
|
||||
|
||||
|
|
|
|||
|
|
@ -1787,9 +1787,9 @@ rb_reset_tail(struct ring_buffer_per_cpu *cpu_buffer,
|
|||
static struct ring_buffer_event *
|
||||
rb_move_tail(struct ring_buffer_per_cpu *cpu_buffer,
|
||||
unsigned long length, unsigned long tail,
|
||||
struct buffer_page *commit_page,
|
||||
struct buffer_page *tail_page, u64 *ts)
|
||||
{
|
||||
struct buffer_page *commit_page = cpu_buffer->commit_page;
|
||||
struct ring_buffer *buffer = cpu_buffer->buffer;
|
||||
struct buffer_page *next_page;
|
||||
int ret;
|
||||
|
|
@ -1892,13 +1892,10 @@ static struct ring_buffer_event *
|
|||
__rb_reserve_next(struct ring_buffer_per_cpu *cpu_buffer,
|
||||
unsigned type, unsigned long length, u64 *ts)
|
||||
{
|
||||
struct buffer_page *tail_page, *commit_page;
|
||||
struct buffer_page *tail_page;
|
||||
struct ring_buffer_event *event;
|
||||
unsigned long tail, write;
|
||||
|
||||
commit_page = cpu_buffer->commit_page;
|
||||
/* we just need to protect against interrupts */
|
||||
barrier();
|
||||
tail_page = cpu_buffer->tail_page;
|
||||
write = local_add_return(length, &tail_page->write);
|
||||
|
||||
|
|
@ -1909,7 +1906,7 @@ __rb_reserve_next(struct ring_buffer_per_cpu *cpu_buffer,
|
|||
/* See if we shot pass the end of this buffer page */
|
||||
if (write > BUF_PAGE_SIZE)
|
||||
return rb_move_tail(cpu_buffer, length, tail,
|
||||
commit_page, tail_page, ts);
|
||||
tail_page, ts);
|
||||
|
||||
/* We reserved something on the buffer */
|
||||
|
||||
|
|
|
|||
|
|
@ -35,6 +35,28 @@ static int disable_reader;
|
|||
module_param(disable_reader, uint, 0644);
|
||||
MODULE_PARM_DESC(disable_reader, "only run producer");
|
||||
|
||||
static int write_iteration = 50;
|
||||
module_param(write_iteration, uint, 0644);
|
||||
MODULE_PARM_DESC(write_iteration, "# of writes between timestamp readings");
|
||||
|
||||
static int producer_nice = 19;
|
||||
static int consumer_nice = 19;
|
||||
|
||||
static int producer_fifo = -1;
|
||||
static int consumer_fifo = -1;
|
||||
|
||||
module_param(producer_nice, uint, 0644);
|
||||
MODULE_PARM_DESC(producer_nice, "nice prio for producer");
|
||||
|
||||
module_param(consumer_nice, uint, 0644);
|
||||
MODULE_PARM_DESC(consumer_nice, "nice prio for consumer");
|
||||
|
||||
module_param(producer_fifo, uint, 0644);
|
||||
MODULE_PARM_DESC(producer_fifo, "fifo prio for producer");
|
||||
|
||||
module_param(consumer_fifo, uint, 0644);
|
||||
MODULE_PARM_DESC(consumer_fifo, "fifo prio for consumer");
|
||||
|
||||
static int read_events;
|
||||
|
||||
static int kill_test;
|
||||
|
|
@ -208,15 +230,18 @@ static void ring_buffer_producer(void)
|
|||
do {
|
||||
struct ring_buffer_event *event;
|
||||
int *entry;
|
||||
int i;
|
||||
|
||||
event = ring_buffer_lock_reserve(buffer, 10);
|
||||
if (!event) {
|
||||
missed++;
|
||||
} else {
|
||||
hit++;
|
||||
entry = ring_buffer_event_data(event);
|
||||
*entry = smp_processor_id();
|
||||
ring_buffer_unlock_commit(buffer, event);
|
||||
for (i = 0; i < write_iteration; i++) {
|
||||
event = ring_buffer_lock_reserve(buffer, 10);
|
||||
if (!event) {
|
||||
missed++;
|
||||
} else {
|
||||
hit++;
|
||||
entry = ring_buffer_event_data(event);
|
||||
*entry = smp_processor_id();
|
||||
ring_buffer_unlock_commit(buffer, event);
|
||||
}
|
||||
}
|
||||
do_gettimeofday(&end_tv);
|
||||
|
||||
|
|
@ -263,6 +288,27 @@ static void ring_buffer_producer(void)
|
|||
|
||||
if (kill_test)
|
||||
trace_printk("ERROR!\n");
|
||||
|
||||
if (!disable_reader) {
|
||||
if (consumer_fifo < 0)
|
||||
trace_printk("Running Consumer at nice: %d\n",
|
||||
consumer_nice);
|
||||
else
|
||||
trace_printk("Running Consumer at SCHED_FIFO %d\n",
|
||||
consumer_fifo);
|
||||
}
|
||||
if (producer_fifo < 0)
|
||||
trace_printk("Running Producer at nice: %d\n",
|
||||
producer_nice);
|
||||
else
|
||||
trace_printk("Running Producer at SCHED_FIFO %d\n",
|
||||
producer_fifo);
|
||||
|
||||
/* Let the user know that the test is running at low priority */
|
||||
if (producer_fifo < 0 && consumer_fifo < 0 &&
|
||||
producer_nice == 19 && consumer_nice == 19)
|
||||
trace_printk("WARNING!!! This test is running at lowest priority.\n");
|
||||
|
||||
trace_printk("Time: %lld (usecs)\n", time);
|
||||
trace_printk("Overruns: %lld\n", overruns);
|
||||
if (disable_reader)
|
||||
|
|
@ -392,6 +438,27 @@ static int __init ring_buffer_benchmark_init(void)
|
|||
if (IS_ERR(producer))
|
||||
goto out_kill;
|
||||
|
||||
/*
|
||||
* Run them as low-prio background tasks by default:
|
||||
*/
|
||||
if (!disable_reader) {
|
||||
if (consumer_fifo >= 0) {
|
||||
struct sched_param param = {
|
||||
.sched_priority = consumer_fifo
|
||||
};
|
||||
sched_setscheduler(consumer, SCHED_FIFO, ¶m);
|
||||
} else
|
||||
set_user_nice(consumer, consumer_nice);
|
||||
}
|
||||
|
||||
if (producer_fifo >= 0) {
|
||||
struct sched_param param = {
|
||||
.sched_priority = consumer_fifo
|
||||
};
|
||||
sched_setscheduler(producer, SCHED_FIFO, ¶m);
|
||||
} else
|
||||
set_user_nice(producer, producer_nice);
|
||||
|
||||
return 0;
|
||||
|
||||
out_kill:
|
||||
|
|
|
|||
|
|
@ -129,7 +129,7 @@ static int tracing_set_tracer(const char *buf);
|
|||
static char bootup_tracer_buf[MAX_TRACER_SIZE] __initdata;
|
||||
static char *default_bootup_tracer;
|
||||
|
||||
static int __init set_ftrace(char *str)
|
||||
static int __init set_cmdline_ftrace(char *str)
|
||||
{
|
||||
strncpy(bootup_tracer_buf, str, MAX_TRACER_SIZE);
|
||||
default_bootup_tracer = bootup_tracer_buf;
|
||||
|
|
@ -137,7 +137,7 @@ static int __init set_ftrace(char *str)
|
|||
ring_buffer_expanded = 1;
|
||||
return 1;
|
||||
}
|
||||
__setup("ftrace=", set_ftrace);
|
||||
__setup("ftrace=", set_cmdline_ftrace);
|
||||
|
||||
static int __init set_ftrace_dump_on_oops(char *str)
|
||||
{
|
||||
|
|
|
|||
Some files were not shown because too many files have changed in this diff Show more
Loading…
Reference in a new issue