mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-11-24 03:00:54 +07:00
Tracing updates for 5.9
- The biggest news in that the tracing ring buffer can now time events that
interrupted other ring buffer events. Before this change, if an interrupt
came in while recording another event, and that interrupt also had an
event, those events would all have the same time stamp as the event it
interrupted. Now, with the new design, those events will have a unique time
stamp and rightfully display the time for those events that were recorded
while interrupting another event.
- Bootconfig how has an "override" operator that lets the users have a
default config, but then add options to override the default.
- A fix was made to properly filter function graph tracing to the ftrace
PIDs. This came in at the end of the -rc cycle, and needs to be backported.
- Several clean ups, performance updates, and minor fixes as well.
-----BEGIN PGP SIGNATURE-----
iIoEABYIADIWIQRRSw7ePDh/lE+zeZMp5XQQmuv6qgUCXy3GOBQccm9zdGVkdEBn
b29kbWlzLm9yZwAKCRAp5XQQmuv6qphsAP9ci1jtrC2+cMBMCNKb/AFpA/nDaKsD
hpsDzvD0YPOmCAEA9QbZset8wUNG49R4FexP7egQ8Ad2S6Oa5f60jWleDQY=
=lH+q
-----END PGP SIGNATURE-----
Merge tag 'trace-v5.9' of git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux-trace
Pull tracing updates from Steven Rostedt:
- The biggest news in that the tracing ring buffer can now time events
that interrupted other ring buffer events.
Before this change, if an interrupt came in while recording another
event, and that interrupt also had an event, those events would all
have the same time stamp as the event it interrupted.
Now, with the new design, those events will have a unique time stamp
and rightfully display the time for those events that were recorded
while interrupting another event.
- Bootconfig how has an "override" operator that lets the users have a
default config, but then add options to override the default.
- A fix was made to properly filter function graph tracing to the
ftrace PIDs. This came in at the end of the -rc cycle, and needs to
be backported.
- Several clean ups, performance updates, and minor fixes as well.
* tag 'trace-v5.9' of git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux-trace: (39 commits)
tracing: Add trace_array_init_printk() to initialize instance trace_printk() buffers
kprobes: Fix compiler warning for !CONFIG_KPROBES_ON_FTRACE
tracing: Use trace_sched_process_free() instead of exit() for pid tracing
bootconfig: Fix to find the initargs correctly
Documentation: bootconfig: Add bootconfig override operator
tools/bootconfig: Add testcases for value override operator
lib/bootconfig: Add override operator support
kprobes: Remove show_registers() function prototype
tracing/uprobe: Remove dead code in trace_uprobe_register()
kprobes: Fix NULL pointer dereference at kprobe_ftrace_handler
ftrace: Fix ftrace_trace_task return value
tracepoint: Use __used attribute definitions from compiler_attributes.h
tracepoint: Mark __tracepoint_string's __used
trace : Have tracing buffer info use kvzalloc instead of kzalloc
tracing: Remove outdated comment in stack handling
ftrace: Do not let direct or IPMODIFY ftrace_ops be added to module and set trampolines
ftrace: Setup correct FTRACE_FL_REGS flags for module
tracing/hwlat: Honor the tracing_cpumask
tracing/hwlat: Drop the duplicate assignment in start_kthread()
tracing: Save one trace_event->type by using __TRACE_LAST_TYPE
...
This commit is contained in:
Linus Torvalds
commit
32663c78c1
@ -71,6 +71,16 @@ For example,::
|
||||
foo = bar, baz
|
||||
foo = qux # !ERROR! we can not re-define same key
|
||||
|
||||
If you want to update the value, you must use the override operator
|
||||
``:=`` explicitly. For example::
|
||||
|
||||
foo = bar, baz
|
||||
foo := qux
|
||||
|
||||
then, the ``qux`` is assigned to ``foo`` key. This is useful for
|
||||
overriding the default value by adding (partial) custom bootconfigs
|
||||
without parsing the default bootconfig.
|
||||
|
||||
If you want to append the value to existing key as an array member,
|
||||
you can use ``+=`` operator. For example::
|
||||
|
||||
@ -84,6 +94,7 @@ For example, following config is NOT allowed.::
|
||||
|
||||
foo = value1
|
||||
foo.bar = value2 # !ERROR! subkey "bar" and value "value1" can NOT co-exist
|
||||
foo.bar := value2 # !ERROR! even with the override operator, this is NOT allowed.
|
||||
|
||||
|
||||
Comments
|
||||
|
||||
@ -286,6 +286,7 @@ extern void ftrace_regs_caller_ret(void);
|
||||
extern void ftrace_caller_end(void);
|
||||
extern void ftrace_caller_op_ptr(void);
|
||||
extern void ftrace_regs_caller_op_ptr(void);
|
||||
extern void ftrace_regs_caller_jmp(void);
|
||||
|
||||
/* movq function_trace_op(%rip), %rdx */
|
||||
/* 0x48 0x8b 0x15 <offset-to-ftrace_trace_op (4 bytes)> */
|
||||
@ -316,6 +317,7 @@ create_trampoline(struct ftrace_ops *ops, unsigned int *tramp_size)
|
||||
unsigned long end_offset;
|
||||
unsigned long op_offset;
|
||||
unsigned long call_offset;
|
||||
unsigned long jmp_offset;
|
||||
unsigned long offset;
|
||||
unsigned long npages;
|
||||
unsigned long size;
|
||||
@ -333,11 +335,13 @@ create_trampoline(struct ftrace_ops *ops, unsigned int *tramp_size)
|
||||
end_offset = (unsigned long)ftrace_regs_caller_end;
|
||||
op_offset = (unsigned long)ftrace_regs_caller_op_ptr;
|
||||
call_offset = (unsigned long)ftrace_regs_call;
|
||||
jmp_offset = (unsigned long)ftrace_regs_caller_jmp;
|
||||
} else {
|
||||
start_offset = (unsigned long)ftrace_caller;
|
||||
end_offset = (unsigned long)ftrace_caller_end;
|
||||
op_offset = (unsigned long)ftrace_caller_op_ptr;
|
||||
call_offset = (unsigned long)ftrace_call;
|
||||
jmp_offset = 0;
|
||||
}
|
||||
|
||||
size = end_offset - start_offset;
|
||||
@ -367,10 +371,14 @@ create_trampoline(struct ftrace_ops *ops, unsigned int *tramp_size)
|
||||
if (WARN_ON(ret < 0))
|
||||
goto fail;
|
||||
|
||||
/* No need to test direct calls on created trampolines */
|
||||
if (ops->flags & FTRACE_OPS_FL_SAVE_REGS) {
|
||||
ip = trampoline + (ftrace_regs_caller_ret - ftrace_regs_caller);
|
||||
ret = copy_from_kernel_nofault(ip, (void *)retq, RET_SIZE);
|
||||
if (WARN_ON(ret < 0))
|
||||
/* NOP the jnz 1f; but make sure it's a 2 byte jnz */
|
||||
ip = trampoline + (jmp_offset - start_offset);
|
||||
if (WARN_ON(*(char *)ip != 0x75))
|
||||
goto fail;
|
||||
ret = copy_from_kernel_nofault(ip, ideal_nops[2], 2);
|
||||
if (ret < 0)
|
||||
goto fail;
|
||||
}
|
||||
|
||||
|
||||
@ -241,22 +241,10 @@ SYM_INNER_LABEL(ftrace_regs_call, SYM_L_GLOBAL)
|
||||
*/
|
||||
movq ORIG_RAX(%rsp), %rax
|
||||
testq %rax, %rax
|
||||
jz 1f
|
||||
SYM_INNER_LABEL(ftrace_regs_caller_jmp, SYM_L_GLOBAL)
|
||||
jnz 1f
|
||||
|
||||
/* Swap the flags with orig_rax */
|
||||
movq MCOUNT_REG_SIZE(%rsp), %rdi
|
||||
movq %rdi, MCOUNT_REG_SIZE-8(%rsp)
|
||||
movq %rax, MCOUNT_REG_SIZE(%rsp)
|
||||
|
||||
restore_mcount_regs 8
|
||||
/* Restore flags */
|
||||
popfq
|
||||
|
||||
SYM_INNER_LABEL(ftrace_regs_caller_ret, SYM_L_GLOBAL);
|
||||
UNWIND_HINT_RET_OFFSET
|
||||
jmp ftrace_epilogue
|
||||
|
||||
1: restore_mcount_regs
|
||||
restore_mcount_regs
|
||||
/* Restore flags */
|
||||
popfq
|
||||
|
||||
@ -269,6 +257,17 @@ SYM_INNER_LABEL(ftrace_regs_caller_ret, SYM_L_GLOBAL);
|
||||
SYM_INNER_LABEL(ftrace_regs_caller_end, SYM_L_GLOBAL)
|
||||
jmp ftrace_epilogue
|
||||
|
||||
/* Swap the flags with orig_rax */
|
||||
1: movq MCOUNT_REG_SIZE(%rsp), %rdi
|
||||
movq %rdi, MCOUNT_REG_SIZE-8(%rsp)
|
||||
movq %rax, MCOUNT_REG_SIZE(%rsp)
|
||||
|
||||
restore_mcount_regs 8
|
||||
/* Restore flags */
|
||||
popfq
|
||||
UNWIND_HINT_RET_OFFSET
|
||||
jmp ftrace_epilogue
|
||||
|
||||
SYM_FUNC_END(ftrace_regs_caller)
|
||||
|
||||
|
||||
|
||||
@ -227,7 +227,6 @@ extern int arch_prepare_kprobe(struct kprobe *p);
|
||||
extern void arch_arm_kprobe(struct kprobe *p);
|
||||
extern void arch_disarm_kprobe(struct kprobe *p);
|
||||
extern int arch_init_kprobes(void);
|
||||
extern void show_registers(struct pt_regs *regs);
|
||||
extern void kprobes_inc_nmissed_count(struct kprobe *p);
|
||||
extern bool arch_within_kprobe_blacklist(unsigned long addr);
|
||||
extern int arch_populate_kprobe_blacklist(void);
|
||||
|
||||
@ -143,6 +143,7 @@ bool ring_buffer_iter_dropped(struct ring_buffer_iter *iter);
|
||||
unsigned long ring_buffer_size(struct trace_buffer *buffer, int cpu);
|
||||
|
||||
void ring_buffer_reset_cpu(struct trace_buffer *buffer, int cpu);
|
||||
void ring_buffer_reset_online_cpus(struct trace_buffer *buffer);
|
||||
void ring_buffer_reset(struct trace_buffer *buffer);
|
||||
|
||||
#ifdef CONFIG_RING_BUFFER_ALLOW_SWAP
|
||||
|
||||
@ -29,6 +29,7 @@ struct trace_array;
|
||||
void trace_printk_init_buffers(void);
|
||||
int trace_array_printk(struct trace_array *tr, unsigned long ip,
|
||||
const char *fmt, ...);
|
||||
int trace_array_init_printk(struct trace_array *tr);
|
||||
void trace_array_put(struct trace_array *tr);
|
||||
struct trace_array *trace_array_get_by_name(const char *name);
|
||||
int trace_array_destroy(struct trace_array *tr);
|
||||
|
||||
@ -116,8 +116,7 @@ static inline struct tracepoint *tracepoint_ptr_deref(tracepoint_ptr_t *p)
|
||||
|
||||
#define __TRACEPOINT_ENTRY(name) \
|
||||
static tracepoint_ptr_t __tracepoint_ptr_##name __used \
|
||||
__attribute__((section("__tracepoints_ptrs"))) = \
|
||||
&__tracepoint_##name
|
||||
__section(__tracepoints_ptrs) = &__tracepoint_##name
|
||||
#endif
|
||||
|
||||
#endif /* _LINUX_TRACEPOINT_H */
|
||||
@ -280,9 +279,9 @@ static inline struct tracepoint *tracepoint_ptr_deref(tracepoint_ptr_t *p)
|
||||
*/
|
||||
#define DEFINE_TRACE_FN(name, reg, unreg) \
|
||||
static const char __tpstrtab_##name[] \
|
||||
__attribute__((section("__tracepoints_strings"))) = #name; \
|
||||
struct tracepoint __tracepoint_##name \
|
||||
__attribute__((section("__tracepoints"), used)) = \
|
||||
__section(__tracepoints_strings) = #name; \
|
||||
struct tracepoint __tracepoint_##name __used \
|
||||
__section(__tracepoints) = \
|
||||
{ __tpstrtab_##name, STATIC_KEY_INIT_FALSE, reg, unreg, NULL };\
|
||||
__TRACEPOINT_ENTRY(name);
|
||||
|
||||
@ -361,7 +360,7 @@ static inline struct tracepoint *tracepoint_ptr_deref(tracepoint_ptr_t *p)
|
||||
static const char *___tp_str __tracepoint_string = str; \
|
||||
___tp_str; \
|
||||
})
|
||||
#define __tracepoint_string __attribute__((section("__tracepoint_str")))
|
||||
#define __tracepoint_string __used __section(__tracepoint_str)
|
||||
#else
|
||||
/*
|
||||
* tracepoint_string() is used to save the string address for userspace
|
||||
|
||||
@ -210,8 +210,7 @@ TRACE_MAKE_SYSTEM_STR();
|
||||
#define DEFINE_EVENT(template, name, proto, args)
|
||||
|
||||
#undef DEFINE_EVENT_PRINT
|
||||
#define DEFINE_EVENT_PRINT(template, name, proto, args, print) \
|
||||
DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args))
|
||||
#define DEFINE_EVENT_PRINT(template, name, proto, args, print)
|
||||
|
||||
#undef TRACE_EVENT_FLAGS
|
||||
#define TRACE_EVENT_FLAGS(event, flag)
|
||||
@ -443,12 +442,8 @@ static struct trace_event_fields trace_event_fields_##call[] = { \
|
||||
tstruct \
|
||||
{} };
|
||||
|
||||
#undef DEFINE_EVENT
|
||||
#define DEFINE_EVENT(template, name, proto, args)
|
||||
|
||||
#undef DEFINE_EVENT_PRINT
|
||||
#define DEFINE_EVENT_PRINT(template, name, proto, args, print) \
|
||||
DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args))
|
||||
#define DEFINE_EVENT_PRINT(template, name, proto, args, print)
|
||||
|
||||
#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
|
||||
|
||||
@ -523,13 +518,6 @@ static inline notrace int trace_event_get_offsets_##call( \
|
||||
return __data_size; \
|
||||
}
|
||||
|
||||
#undef DEFINE_EVENT
|
||||
#define DEFINE_EVENT(template, name, proto, args)
|
||||
|
||||
#undef DEFINE_EVENT_PRINT
|
||||
#define DEFINE_EVENT_PRINT(template, name, proto, args, print) \
|
||||
DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args))
|
||||
|
||||
#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
|
||||
|
||||
/*
|
||||
@ -721,9 +709,6 @@ static inline void ftrace_test_probe_##call(void) \
|
||||
check_trace_callback_type_##call(trace_event_raw_event_##template); \
|
||||
}
|
||||
|
||||
#undef DEFINE_EVENT_PRINT
|
||||
#define DEFINE_EVENT_PRINT(template, name, proto, args, print)
|
||||
|
||||
#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
|
||||
|
||||
#undef __entry
|
||||
|
||||
12
init/main.c
12
init/main.c
@ -388,8 +388,6 @@ static int __init bootconfig_params(char *param, char *val,
|
||||
{
|
||||
if (strcmp(param, "bootconfig") == 0) {
|
||||
bootconfig_found = true;
|
||||
} else if (strcmp(param, "--") == 0) {
|
||||
initargs_found = true;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
@ -400,19 +398,23 @@ static void __init setup_boot_config(const char *cmdline)
|
||||
const char *msg;
|
||||
int pos;
|
||||
u32 size, csum;
|
||||
char *data, *copy;
|
||||
char *data, *copy, *err;
|
||||
int ret;
|
||||
|
||||
/* Cut out the bootconfig data even if we have no bootconfig option */
|
||||
data = get_boot_config_from_initrd(&size, &csum);
|
||||
|
||||
strlcpy(tmp_cmdline, boot_command_line, COMMAND_LINE_SIZE);
|
||||
parse_args("bootconfig", tmp_cmdline, NULL, 0, 0, 0, NULL,
|
||||
err = parse_args("bootconfig", tmp_cmdline, NULL, 0, 0, 0, NULL,
|
||||
bootconfig_params);
|
||||
|
||||
if (!bootconfig_found)
|
||||
if (IS_ERR(err) || !bootconfig_found)
|
||||
return;
|
||||
|
||||
/* parse_args() stops at '--' and returns an address */
|
||||
if (err)
|
||||
initargs_found = true;
|
||||
|
||||
if (!data) {
|
||||
pr_err("'bootconfig' found on command line, but no bootconfig found\n");
|
||||
return;
|
||||
|
||||
@ -1111,9 +1111,20 @@ static int disarm_kprobe_ftrace(struct kprobe *p)
|
||||
ipmodify ? &kprobe_ipmodify_enabled : &kprobe_ftrace_enabled);
|
||||
}
|
||||
#else /* !CONFIG_KPROBES_ON_FTRACE */
|
||||
#define prepare_kprobe(p) arch_prepare_kprobe(p)
|
||||
#define arm_kprobe_ftrace(p) (-ENODEV)
|
||||
#define disarm_kprobe_ftrace(p) (-ENODEV)
|
||||
static inline int prepare_kprobe(struct kprobe *p)
|
||||
{
|
||||
return arch_prepare_kprobe(p);
|
||||
}
|
||||
|
||||
static inline int arm_kprobe_ftrace(struct kprobe *p)
|
||||
{
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
static inline int disarm_kprobe_ftrace(struct kprobe *p)
|
||||
{
|
||||
return -ENODEV;
|
||||
}
|
||||
#endif
|
||||
|
||||
/* Arm a kprobe with text_mutex */
|
||||
@ -2145,6 +2156,13 @@ static void kill_kprobe(struct kprobe *p)
|
||||
* the original probed function (which will be freed soon) any more.
|
||||
*/
|
||||
arch_remove_kprobe(p);
|
||||
|
||||
/*
|
||||
* The module is going away. We should disarm the kprobe which
|
||||
* is using ftrace.
|
||||
*/
|
||||
if (kprobe_ftrace(p))
|
||||
disarm_kprobe_ftrace(p);
|
||||
}
|
||||
|
||||
/* Disable one kprobe */
|
||||
|
||||
@ -139,9 +139,6 @@ static inline void ftrace_ops_init(struct ftrace_ops *ops)
|
||||
#endif
|
||||
}
|
||||
|
||||
#define FTRACE_PID_IGNORE -1
|
||||
#define FTRACE_PID_TRACE -2
|
||||
|
||||
static void ftrace_pid_func(unsigned long ip, unsigned long parent_ip,
|
||||
struct ftrace_ops *op, struct pt_regs *regs)
|
||||
{
|
||||
@ -2388,6 +2385,14 @@ struct ftrace_ops direct_ops = {
|
||||
.flags = FTRACE_OPS_FL_IPMODIFY | FTRACE_OPS_FL_RECURSION_SAFE
|
||||
| FTRACE_OPS_FL_DIRECT | FTRACE_OPS_FL_SAVE_REGS
|
||||
| FTRACE_OPS_FL_PERMANENT,
|
||||
/*
|
||||
* By declaring the main trampoline as this trampoline
|
||||
* it will never have one allocated for it. Allocated
|
||||
* trampolines should not call direct functions.
|
||||
* The direct_ops should only be called by the builtin
|
||||
* ftrace_regs_caller trampoline.
|
||||
*/
|
||||
.trampoline = FTRACE_REGS_ADDR,
|
||||
};
|
||||
#endif /* CONFIG_DYNAMIC_FTRACE_WITH_DIRECT_CALLS */
|
||||
|
||||
@ -6255,8 +6260,19 @@ static int referenced_filters(struct dyn_ftrace *rec)
|
||||
int cnt = 0;
|
||||
|
||||
for (ops = ftrace_ops_list; ops != &ftrace_list_end; ops = ops->next) {
|
||||
if (ops_references_rec(ops, rec))
|
||||
if (ops_references_rec(ops, rec)) {
|
||||
if (WARN_ON_ONCE(ops->flags & FTRACE_OPS_FL_DIRECT))
|
||||
continue;
|
||||
if (WARN_ON_ONCE(ops->flags & FTRACE_OPS_FL_IPMODIFY))
|
||||
continue;
|
||||
cnt++;
|
||||
if (ops->flags & FTRACE_OPS_FL_SAVE_REGS)
|
||||
rec->flags |= FTRACE_FL_REGS;
|
||||
if (cnt == 1 && ops->trampoline)
|
||||
rec->flags |= FTRACE_FL_TRAMP;
|
||||
else
|
||||
rec->flags &= ~FTRACE_FL_TRAMP;
|
||||
}
|
||||
}
|
||||
|
||||
return cnt;
|
||||
@ -6435,8 +6451,8 @@ void ftrace_module_enable(struct module *mod)
|
||||
if (ftrace_start_up)
|
||||
cnt += referenced_filters(rec);
|
||||
|
||||
/* This clears FTRACE_FL_DISABLED */
|
||||
rec->flags = cnt;
|
||||
rec->flags &= ~FTRACE_FL_DISABLED;
|
||||
rec->flags += cnt;
|
||||
|
||||
if (ftrace_start_up && cnt) {
|
||||
int failed = __ftrace_replace_code(rec, 1);
|
||||
@ -7066,12 +7082,12 @@ void ftrace_pid_follow_fork(struct trace_array *tr, bool enable)
|
||||
if (enable) {
|
||||
register_trace_sched_process_fork(ftrace_pid_follow_sched_process_fork,
|
||||
tr);
|
||||
register_trace_sched_process_exit(ftrace_pid_follow_sched_process_exit,
|
||||
register_trace_sched_process_free(ftrace_pid_follow_sched_process_exit,
|
||||
tr);
|
||||
} else {
|
||||
unregister_trace_sched_process_fork(ftrace_pid_follow_sched_process_fork,
|
||||
tr);
|
||||
unregister_trace_sched_process_exit(ftrace_pid_follow_sched_process_exit,
|
||||
unregister_trace_sched_process_free(ftrace_pid_follow_sched_process_exit,
|
||||
tr);
|
||||
}
|
||||
}
|
||||
|
||||
@ -270,6 +270,9 @@ EXPORT_SYMBOL_GPL(ring_buffer_event_data);
|
||||
#define for_each_buffer_cpu(buffer, cpu) \
|
||||
for_each_cpu(cpu, buffer->cpumask)
|
||||
|
||||
#define for_each_online_buffer_cpu(buffer, cpu) \
|
||||
for_each_cpu_and(cpu, buffer->cpumask, cpu_online_mask)
|
||||
|
||||
#define TS_SHIFT 27
|
||||
#define TS_MASK ((1ULL << TS_SHIFT) - 1)
|
||||
#define TS_DELTA_TEST (~TS_MASK)
|
||||
@ -413,11 +416,26 @@ struct rb_irq_work {
|
||||
struct rb_event_info {
|
||||
u64 ts;
|
||||
u64 delta;
|
||||
u64 before;
|
||||
u64 after;
|
||||
unsigned long length;
|
||||
struct buffer_page *tail_page;
|
||||
int add_timestamp;
|
||||
};
|
||||
|
||||
/*
|
||||
* Used for the add_timestamp
|
||||
* NONE
|
||||
* EXTEND - wants a time extend
|
||||
* ABSOLUTE - the buffer requests all events to have absolute time stamps
|
||||
* FORCE - force a full time stamp.
|
||||
*/
|
||||
enum {
|
||||
RB_ADD_STAMP_NONE = 0,
|
||||
RB_ADD_STAMP_EXTEND = BIT(1),
|
||||
RB_ADD_STAMP_ABSOLUTE = BIT(2),
|
||||
RB_ADD_STAMP_FORCE = BIT(3)
|
||||
};
|
||||
/*
|
||||
* Used for which event context the event is in.
|
||||
* NMI = 0
|
||||
@ -435,6 +453,28 @@ enum {
|
||||
RB_CTX_MAX
|
||||
};
|
||||
|
||||
#if BITS_PER_LONG == 32
|
||||
#define RB_TIME_32
|
||||
#endif
|
||||
|
||||
/* To test on 64 bit machines */
|
||||
//#define RB_TIME_32
|
||||
|
||||
#ifdef RB_TIME_32
|
||||
|
||||
struct rb_time_struct {
|
||||
local_t cnt;
|
||||
local_t top;
|
||||
local_t bottom;
|
||||
};
|
||||
#else
|
||||
#include <asm/local64.h>
|
||||
struct rb_time_struct {
|
||||
local64_t time;
|
||||
};
|
||||
#endif
|
||||
typedef struct rb_time_struct rb_time_t;
|
||||
|
||||
/*
|
||||
* head_page == tail_page && head == tail then buffer is empty.
|
||||
*/
|
||||
@ -470,7 +510,8 @@ struct ring_buffer_per_cpu {
|
||||
size_t shortest_full;
|
||||
unsigned long read;
|
||||
unsigned long read_bytes;
|
||||
u64 write_stamp;
|
||||
rb_time_t write_stamp;
|
||||
rb_time_t before_stamp;
|
||||
u64 read_stamp;
|
||||
/* ring buffer pages to update, > 0 to add, < 0 to remove */
|
||||
long nr_pages_to_update;
|
||||
@ -513,6 +554,189 @@ struct ring_buffer_iter {
|
||||
int missed_events;
|
||||
};
|
||||
|
||||
#ifdef RB_TIME_32
|
||||
|
||||
/*
|
||||
* On 32 bit machines, local64_t is very expensive. As the ring
|
||||
* buffer doesn't need all the features of a true 64 bit atomic,
|
||||
* on 32 bit, it uses these functions (64 still uses local64_t).
|
||||
*
|
||||
* For the ring buffer, 64 bit required operations for the time is
|
||||
* the following:
|
||||
*
|
||||
* - Only need 59 bits (uses 60 to make it even).
|
||||
* - Reads may fail if it interrupted a modification of the time stamp.
|
||||
* It will succeed if it did not interrupt another write even if
|
||||
* the read itself is interrupted by a write.
|
||||
* It returns whether it was successful or not.
|
||||
*
|
||||
* - Writes always succeed and will overwrite other writes and writes
|
||||
* that were done by events interrupting the current write.
|
||||
*
|
||||
* - A write followed by a read of the same time stamp will always succeed,
|
||||
* but may not contain the same value.
|
||||
*
|
||||
* - A cmpxchg will fail if it interrupted another write or cmpxchg.
|
||||
* Other than that, it acts like a normal cmpxchg.
|
||||
*
|
||||
* The 60 bit time stamp is broken up by 30 bits in a top and bottom half
|
||||
* (bottom being the least significant 30 bits of the 60 bit time stamp).
|
||||
*
|
||||
* The two most significant bits of each half holds a 2 bit counter (0-3).
|
||||
* Each update will increment this counter by one.
|
||||
* When reading the top and bottom, if the two counter bits match then the
|
||||
* top and bottom together make a valid 60 bit number.
|
||||
*/
|
||||
#define RB_TIME_SHIFT 30
|
||||
#define RB_TIME_VAL_MASK ((1 << RB_TIME_SHIFT) - 1)
|
||||
|
||||
static inline int rb_time_cnt(unsigned long val)
|
||||
{
|
||||
return (val >> RB_TIME_SHIFT) & 3;
|
||||
}
|
||||
|
||||
static inline u64 rb_time_val(unsigned long top, unsigned long bottom)
|
||||
{
|
||||
u64 val;
|
||||
|
||||
val = top & RB_TIME_VAL_MASK;
|
||||
val <<= RB_TIME_SHIFT;
|
||||
val |= bottom & RB_TIME_VAL_MASK;
|
||||
|
||||
return val;
|
||||
}
|
||||
|
||||
static inline bool __rb_time_read(rb_time_t *t, u64 *ret, unsigned long *cnt)
|
||||
{
|
||||
unsigned long top, bottom;
|
||||
unsigned long c;
|
||||
|
||||
/*
|
||||
* If the read is interrupted by a write, then the cnt will
|
||||
* be different. Loop until both top and bottom have been read
|
||||
* without interruption.
|
||||
*/
|
||||
do {
|
||||
c = local_read(&t->cnt);
|
||||
top = local_read(&t->top);
|
||||
bottom = local_read(&t->bottom);
|
||||
} while (c != local_read(&t->cnt));
|
||||
|
||||
*cnt = rb_time_cnt(top);
|
||||
|
||||
/* If top and bottom counts don't match, this interrupted a write */
|
||||
if (*cnt != rb_time_cnt(bottom))
|
||||
return false;
|
||||
|
||||
*ret = rb_time_val(top, bottom);
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool rb_time_read(rb_time_t *t, u64 *ret)
|
||||
{
|
||||
unsigned long cnt;
|
||||
|
||||
return __rb_time_read(t, ret, &cnt);
|
||||
}
|
||||
|
||||
static inline unsigned long rb_time_val_cnt(unsigned long val, unsigned long cnt)
|
||||
{
|
||||
return (val & RB_TIME_VAL_MASK) | ((cnt & 3) << RB_TIME_SHIFT);
|
||||
}
|
||||
|
||||
static inline void rb_time_split(u64 val, unsigned long *top, unsigned long *bottom)
|
||||
{
|
||||
*top = (unsigned long)((val >> RB_TIME_SHIFT) & RB_TIME_VAL_MASK);
|
||||
*bottom = (unsigned long)(val & RB_TIME_VAL_MASK);
|
||||
}
|
||||
|
||||
static inline void rb_time_val_set(local_t *t, unsigned long val, unsigned long cnt)
|
||||
{
|
||||
val = rb_time_val_cnt(val, cnt);
|
||||
local_set(t, val);
|
||||
}
|
||||
|
||||
static void rb_time_set(rb_time_t *t, u64 val)
|
||||
{
|
||||
unsigned long cnt, top, bottom;
|
||||
|
||||
rb_time_split(val, &top, &bottom);
|
||||
|
||||
/* Writes always succeed with a valid number even if it gets interrupted. */
|
||||
do {
|
||||
cnt = local_inc_return(&t->cnt);
|
||||
rb_time_val_set(&t->top, top, cnt);
|
||||
rb_time_val_set(&t->bottom, bottom, cnt);
|
||||
} while (cnt != local_read(&t->cnt));
|
||||
}
|
||||
|
||||
static inline bool
|
||||
rb_time_read_cmpxchg(local_t *l, unsigned long expect, unsigned long set)
|
||||
{
|
||||
unsigned long ret;
|
||||
|
||||
ret = local_cmpxchg(l, expect, set);
|
||||
return ret == expect;
|
||||
}
|
||||
|
||||
static int rb_time_cmpxchg(rb_time_t *t, u64 expect, u64 set)
|
||||
{
|
||||
unsigned long cnt, top, bottom;
|
||||
unsigned long cnt2, top2, bottom2;
|
||||
u64 val;
|
||||
|
||||
/* The cmpxchg always fails if it interrupted an update */
|
||||
if (!__rb_time_read(t, &val, &cnt2))
|
||||
return false;
|
||||
|
||||
if (val != expect)
|
||||
return false;
|
||||
|
||||
cnt = local_read(&t->cnt);
|
||||
if ((cnt & 3) != cnt2)
|
||||
return false;
|
||||
|
||||
cnt2 = cnt + 1;
|
||||
|
||||
rb_time_split(val, &top, &bottom);
|
||||
top = rb_time_val_cnt(top, cnt);
|
||||
bottom = rb_time_val_cnt(bottom, cnt);
|
||||
|
||||
rb_time_split(set, &top2, &bottom2);
|
||||
top2 = rb_time_val_cnt(top2, cnt2);
|
||||
bottom2 = rb_time_val_cnt(bottom2, cnt2);
|
||||
|
||||
if (!rb_time_read_cmpxchg(&t->cnt, cnt, cnt2))
|
||||
return false;
|
||||
if (!rb_time_read_cmpxchg(&t->top, top, top2))
|
||||
return false;
|
||||
if (!rb_time_read_cmpxchg(&t->bottom, bottom, bottom2))
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
#else /* 64 bits */
|
||||
|
||||
/* local64_t always succeeds */
|
||||
|
||||
static inline bool rb_time_read(rb_time_t *t, u64 *ret)
|
||||
{
|
||||
*ret = local64_read(&t->time);
|
||||
return true;
|
||||
}
|
||||
static void rb_time_set(rb_time_t *t, u64 val)
|
||||
{
|
||||
local64_set(&t->time, val);
|
||||
}
|
||||
|
||||
static bool rb_time_cmpxchg(rb_time_t *t, u64 expect, u64 set)
|
||||
{
|
||||
u64 val;
|
||||
val = local64_cmpxchg(&t->time, expect, set);
|
||||
return val == expect;
|
||||
}
|
||||
#endif
|
||||
|
||||
/**
|
||||
* ring_buffer_nr_pages - get the number of buffer pages in the ring buffer
|
||||
* @buffer: The ring_buffer to get the number of pages from
|
||||
@ -746,8 +970,16 @@ __poll_t ring_buffer_poll_wait(struct trace_buffer *buffer, int cpu,
|
||||
|
||||
static inline u64 rb_time_stamp(struct trace_buffer *buffer)
|
||||
{
|
||||
u64 ts;
|
||||
|
||||
/* Skip retpolines :-( */
|
||||
if (IS_ENABLED(CONFIG_RETPOLINE) && likely(buffer->clock == trace_clock_local))
|
||||
ts = trace_clock_local();
|
||||
else
|
||||
ts = buffer->clock();
|
||||
|
||||
/* shift to debug/test normalization and TIME_EXTENTS */
|
||||
return buffer->clock() << DEBUG_SHIFT;
|
||||
return ts << DEBUG_SHIFT;
|
||||
}
|
||||
|
||||
u64 ring_buffer_time_stamp(struct trace_buffer *buffer, int cpu)
|
||||
@ -2372,8 +2604,8 @@ rb_move_tail(struct ring_buffer_per_cpu *cpu_buffer,
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* Slow path, do not inline */
|
||||
static noinline struct ring_buffer_event *
|
||||
/* Slow path */
|
||||
static struct ring_buffer_event *
|
||||
rb_add_time_stamp(struct ring_buffer_event *event, u64 delta, bool abs)
|
||||
{
|
||||
if (abs)
|
||||
@ -2397,6 +2629,66 @@ rb_add_time_stamp(struct ring_buffer_event *event, u64 delta, bool abs)
|
||||
static inline bool rb_event_is_commit(struct ring_buffer_per_cpu *cpu_buffer,
|
||||
struct ring_buffer_event *event);
|
||||
|
||||
#ifndef CONFIG_HAVE_UNSTABLE_SCHED_CLOCK
|
||||
static inline bool sched_clock_stable(void)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
#endif
|
||||
|
||||
static void
|
||||
rb_check_timestamp(struct ring_buffer_per_cpu *cpu_buffer,
|
||||
struct rb_event_info *info)
|
||||
{
|
||||
u64 write_stamp;
|
||||
|
||||
WARN_ONCE(1, "Delta way too big! %llu ts=%llu before=%llu after=%llu write stamp=%llu\n%s",
|
||||
(unsigned long long)info->delta,
|
||||
(unsigned long long)info->ts,
|
||||
(unsigned long long)info->before,
|
||||
(unsigned long long)info->after,
|
||||
(unsigned long long)(rb_time_read(&cpu_buffer->write_stamp, &write_stamp) ? write_stamp : 0),
|
||||
sched_clock_stable() ? "" :
|
||||
"If you just came from a suspend/resume,\n"
|
||||
"please switch to the trace global clock:\n"
|
||||
" echo global > /sys/kernel/debug/tracing/trace_clock\n"
|
||||
"or add trace_clock=global to the kernel command line\n");
|
||||
}
|
||||
|
||||
static void rb_add_timestamp(struct ring_buffer_per_cpu *cpu_buffer,
|
||||
struct ring_buffer_event **event,
|
||||
struct rb_event_info *info,
|
||||
u64 *delta,
|
||||
unsigned int *length)
|
||||
{
|
||||
bool abs = info->add_timestamp &
|
||||
(RB_ADD_STAMP_FORCE | RB_ADD_STAMP_ABSOLUTE);
|
||||
|
||||
if (unlikely(info->delta > (1ULL << 59))) {
|
||||
/* did the clock go backwards */
|
||||
if (info->before == info->after && info->before > info->ts) {
|
||||
/* not interrupted */
|
||||
static int once;
|
||||
|
||||
/*
|
||||
* This is possible with a recalibrating of the TSC.
|
||||
* Do not produce a call stack, but just report it.
|
||||
*/
|
||||
if (!once) {
|
||||
once++;
|
||||
pr_warn("Ring buffer clock went backwards: %llu -> %llu\n",
|
||||
info->before, info->ts);
|
||||
}
|
||||
} else
|
||||
rb_check_timestamp(cpu_buffer, info);
|
||||
if (!abs)
|
||||
info->delta = 0;
|
||||
}
|
||||
*event = rb_add_time_stamp(*event, info->delta, abs);
|
||||
*length -= RB_LEN_TIME_EXTEND;
|
||||
*delta = 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* rb_update_event - update event type and data
|
||||
* @cpu_buffer: The per cpu buffer of the @event
|
||||
@ -2416,21 +2708,12 @@ rb_update_event(struct ring_buffer_per_cpu *cpu_buffer,
|
||||
unsigned length = info->length;
|
||||
u64 delta = info->delta;
|
||||
|
||||
/* Only a commit updates the timestamp */
|
||||
if (unlikely(!rb_event_is_commit(cpu_buffer, event)))
|
||||
delta = 0;
|
||||
|
||||
/*
|
||||
* If we need to add a timestamp, then we
|
||||
* add it to the start of the reserved space.
|
||||
*/
|
||||
if (unlikely(info->add_timestamp)) {
|
||||
bool abs = ring_buffer_time_stamp_abs(cpu_buffer->buffer);
|
||||
|
||||
event = rb_add_time_stamp(event, abs ? info->delta : delta, abs);
|
||||
length -= RB_LEN_TIME_EXTEND;
|
||||
delta = 0;
|
||||
}
|
||||
if (unlikely(info->add_timestamp))
|
||||
rb_add_timestamp(cpu_buffer, &event, info, &delta, &length);
|
||||
|
||||
event->time_delta = delta;
|
||||
length -= RB_EVNT_HDR_SIZE;
|
||||
@ -2473,12 +2756,38 @@ static unsigned rb_calculate_event_length(unsigned length)
|
||||
return length;
|
||||
}
|
||||
|
||||
#ifndef CONFIG_HAVE_UNSTABLE_SCHED_CLOCK
|
||||
static inline bool sched_clock_stable(void)
|
||||
static __always_inline bool
|
||||
rb_event_is_commit(struct ring_buffer_per_cpu *cpu_buffer,
|
||||
struct ring_buffer_event *event)
|
||||
{
|
||||
return true;
|
||||
unsigned long addr = (unsigned long)event;
|
||||
unsigned long index;
|
||||
|
||||
index = rb_event_index(event);
|
||||
addr &= PAGE_MASK;
|
||||
|
||||
return cpu_buffer->commit_page->page == (void *)addr &&
|
||||
rb_commit_index(cpu_buffer) == index;
|
||||
}
|
||||
|
||||
static u64 rb_time_delta(struct ring_buffer_event *event)
|
||||
{
|
||||
switch (event->type_len) {
|
||||
case RINGBUF_TYPE_PADDING:
|
||||
return 0;
|
||||
|
||||
case RINGBUF_TYPE_TIME_EXTEND:
|
||||
return ring_buffer_event_time_stamp(event);
|
||||
|
||||
case RINGBUF_TYPE_TIME_STAMP:
|
||||
return 0;
|
||||
|
||||
case RINGBUF_TYPE_DATA:
|
||||
return event->time_delta;
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
static inline int
|
||||
rb_try_to_discard(struct ring_buffer_per_cpu *cpu_buffer,
|
||||
@ -2488,6 +2797,8 @@ rb_try_to_discard(struct ring_buffer_per_cpu *cpu_buffer,
|
||||
struct buffer_page *bpage;
|
||||
unsigned long index;
|
||||
unsigned long addr;
|
||||
u64 write_stamp;
|
||||
u64 delta;
|
||||
|
||||
new_index = rb_event_index(event);
|
||||
old_index = new_index + rb_event_ts_length(event);
|
||||
@ -2496,10 +2807,32 @@ rb_try_to_discard(struct ring_buffer_per_cpu *cpu_buffer,
|
||||
|
||||
bpage = READ_ONCE(cpu_buffer->tail_page);
|
||||
|
||||
delta = rb_time_delta(event);
|
||||
|
||||
if (!rb_time_read(&cpu_buffer->write_stamp, &write_stamp))
|
||||
return 0;
|
||||
|
||||
/* Make sure the write stamp is read before testing the location */
|
||||
barrier();
|
||||
|
||||
if (bpage->page == (void *)addr && rb_page_write(bpage) == old_index) {
|
||||
unsigned long write_mask =
|
||||
local_read(&bpage->write) & ~RB_WRITE_MASK;
|
||||
unsigned long event_length = rb_event_length(event);
|
||||
|
||||
/* Something came in, can't discard */
|
||||
if (!rb_time_cmpxchg(&cpu_buffer->write_stamp,
|
||||
write_stamp, write_stamp - delta))
|
||||
return 0;
|
||||
|
||||
/*
|
||||
* If an event were to come in now, it would see that the
|
||||
* write_stamp and the before_stamp are different, and assume
|
||||
* that this event just added itself before updating
|
||||
* the write stamp. The interrupting event will fix the
|
||||
* write stamp for us, and use the before stamp as its delta.
|
||||
*/
|
||||
|
||||
/*
|
||||
* This is on the tail page. It is possible that
|
||||
* a write could come in and move the tail page
|
||||
@ -2551,10 +2884,6 @@ rb_set_commit_to_write(struct ring_buffer_per_cpu *cpu_buffer)
|
||||
local_set(&cpu_buffer->commit_page->page->commit,
|
||||
rb_page_write(cpu_buffer->commit_page));
|
||||
rb_inc_page(cpu_buffer, &cpu_buffer->commit_page);
|
||||
/* Only update the write stamp if the page has an event */
|
||||
if (rb_page_write(cpu_buffer->commit_page))
|
||||
cpu_buffer->write_stamp =
|
||||
cpu_buffer->commit_page->page->time_stamp;
|
||||
/* add barrier to keep gcc from optimizing too much */
|
||||
barrier();
|
||||
}
|
||||
@ -2626,54 +2955,10 @@ static inline void rb_event_discard(struct ring_buffer_event *event)
|
||||
event->time_delta = 1;
|
||||
}
|
||||
|
||||
static __always_inline bool
|
||||
rb_event_is_commit(struct ring_buffer_per_cpu *cpu_buffer,
|
||||
struct ring_buffer_event *event)
|
||||
{
|
||||
unsigned long addr = (unsigned long)event;
|
||||
unsigned long index;
|
||||
|
||||
index = rb_event_index(event);
|
||||
addr &= PAGE_MASK;
|
||||
|
||||
return cpu_buffer->commit_page->page == (void *)addr &&
|
||||
rb_commit_index(cpu_buffer) == index;
|
||||
}
|
||||
|
||||
static __always_inline void
|
||||
rb_update_write_stamp(struct ring_buffer_per_cpu *cpu_buffer,
|
||||
struct ring_buffer_event *event)
|
||||
{
|
||||
u64 delta;
|
||||
|
||||
/*
|
||||
* The event first in the commit queue updates the
|
||||
* time stamp.
|
||||
*/
|
||||
if (rb_event_is_commit(cpu_buffer, event)) {
|
||||
/*
|
||||
* A commit event that is first on a page
|
||||
* updates the write timestamp with the page stamp
|
||||
*/
|
||||
if (!rb_event_index(event))
|
||||
cpu_buffer->write_stamp =
|
||||
cpu_buffer->commit_page->page->time_stamp;
|
||||
else if (event->type_len == RINGBUF_TYPE_TIME_EXTEND) {
|
||||
delta = ring_buffer_event_time_stamp(event);
|
||||
cpu_buffer->write_stamp += delta;
|
||||
} else if (event->type_len == RINGBUF_TYPE_TIME_STAMP) {
|
||||
delta = ring_buffer_event_time_stamp(event);
|
||||
cpu_buffer->write_stamp = delta;
|
||||
} else
|
||||
cpu_buffer->write_stamp += event->time_delta;
|
||||
}
|
||||
}
|
||||
|
||||
static void rb_commit(struct ring_buffer_per_cpu *cpu_buffer,
|
||||
struct ring_buffer_event *event)
|
||||
{
|
||||
local_inc(&cpu_buffer->entries);
|
||||
rb_update_write_stamp(cpu_buffer, event);
|
||||
rb_end_commit(cpu_buffer);
|
||||
}
|
||||
|
||||
@ -2864,58 +3149,138 @@ int ring_buffer_unlock_commit(struct trace_buffer *buffer,
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(ring_buffer_unlock_commit);
|
||||
|
||||
static noinline void
|
||||
rb_handle_timestamp(struct ring_buffer_per_cpu *cpu_buffer,
|
||||
struct rb_event_info *info)
|
||||
{
|
||||
WARN_ONCE(info->delta > (1ULL << 59),
|
||||
KERN_WARNING "Delta way too big! %llu ts=%llu write stamp = %llu\n%s",
|
||||
(unsigned long long)info->delta,
|
||||
(unsigned long long)info->ts,
|
||||
(unsigned long long)cpu_buffer->write_stamp,
|
||||
sched_clock_stable() ? "" :
|
||||
"If you just came from a suspend/resume,\n"
|
||||
"please switch to the trace global clock:\n"
|
||||
" echo global > /sys/kernel/debug/tracing/trace_clock\n"
|
||||
"or add trace_clock=global to the kernel command line\n");
|
||||
info->add_timestamp = 1;
|
||||
}
|
||||
|
||||
static struct ring_buffer_event *
|
||||
__rb_reserve_next(struct ring_buffer_per_cpu *cpu_buffer,
|
||||
struct rb_event_info *info)
|
||||
{
|
||||
struct ring_buffer_event *event;
|
||||
struct buffer_page *tail_page;
|
||||
unsigned long tail, write;
|
||||
|
||||
/*
|
||||
* If the time delta since the last event is too big to
|
||||
* hold in the time field of the event, then we append a
|
||||
* TIME EXTEND event ahead of the data event.
|
||||
*/
|
||||
if (unlikely(info->add_timestamp))
|
||||
info->length += RB_LEN_TIME_EXTEND;
|
||||
unsigned long tail, write, w;
|
||||
bool a_ok;
|
||||
bool b_ok;
|
||||
|
||||
/* Don't let the compiler play games with cpu_buffer->tail_page */
|
||||
tail_page = info->tail_page = READ_ONCE(cpu_buffer->tail_page);
|
||||
write = local_add_return(info->length, &tail_page->write);
|
||||
|
||||
/*A*/ w = local_read(&tail_page->write) & RB_WRITE_MASK;
|
||||
barrier();
|
||||
b_ok = rb_time_read(&cpu_buffer->before_stamp, &info->before);
|
||||
a_ok = rb_time_read(&cpu_buffer->write_stamp, &info->after);
|
||||
barrier();
|
||||
info->ts = rb_time_stamp(cpu_buffer->buffer);
|
||||
|
||||
if ((info->add_timestamp & RB_ADD_STAMP_ABSOLUTE)) {
|
||||
info->delta = info->ts;
|
||||
} else {
|
||||
/*
|
||||
* If interrupting an event time update, we may need an
|
||||
* absolute timestamp.
|
||||
* Don't bother if this is the start of a new page (w == 0).
|
||||
*/
|
||||
if (unlikely(!a_ok || !b_ok || (info->before != info->after && w))) {
|
||||
info->add_timestamp |= RB_ADD_STAMP_FORCE | RB_ADD_STAMP_EXTEND;
|
||||
info->length += RB_LEN_TIME_EXTEND;
|
||||
} else {
|
||||
info->delta = info->ts - info->after;
|
||||
if (unlikely(test_time_stamp(info->delta))) {
|
||||
info->add_timestamp |= RB_ADD_STAMP_EXTEND;
|
||||
info->length += RB_LEN_TIME_EXTEND;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*B*/ rb_time_set(&cpu_buffer->before_stamp, info->ts);
|
||||
|
||||
/*C*/ write = local_add_return(info->length, &tail_page->write);
|
||||
|
||||
/* set write to only the index of the write */
|
||||
write &= RB_WRITE_MASK;
|
||||
|
||||
tail = write - info->length;
|
||||
|
||||
/* See if we shot pass the end of this buffer page */
|
||||
if (unlikely(write > BUF_PAGE_SIZE)) {
|
||||
if (tail != w) {
|
||||
/* before and after may now different, fix it up*/
|
||||
b_ok = rb_time_read(&cpu_buffer->before_stamp, &info->before);
|
||||
a_ok = rb_time_read(&cpu_buffer->write_stamp, &info->after);
|
||||
if (a_ok && b_ok && info->before != info->after)
|
||||
(void)rb_time_cmpxchg(&cpu_buffer->before_stamp,
|
||||
info->before, info->after);
|
||||
}
|
||||
return rb_move_tail(cpu_buffer, tail, info);
|
||||
}
|
||||
|
||||
if (likely(tail == w)) {
|
||||
u64 save_before;
|
||||
bool s_ok;
|
||||
|
||||
/* Nothing interrupted us between A and C */
|
||||
/*D*/ rb_time_set(&cpu_buffer->write_stamp, info->ts);
|
||||
barrier();
|
||||
/*E*/ s_ok = rb_time_read(&cpu_buffer->before_stamp, &save_before);
|
||||
RB_WARN_ON(cpu_buffer, !s_ok);
|
||||
if (likely(!(info->add_timestamp &
|
||||
(RB_ADD_STAMP_FORCE | RB_ADD_STAMP_ABSOLUTE))))
|
||||
/* This did not interrupt any time update */
|
||||
info->delta = info->ts - info->after;
|
||||
else
|
||||
/* Just use full timestamp for inerrupting event */
|
||||
info->delta = info->ts;
|
||||
barrier();
|
||||
if (unlikely(info->ts != save_before)) {
|
||||
/* SLOW PATH - Interrupted between C and E */
|
||||
|
||||
a_ok = rb_time_read(&cpu_buffer->write_stamp, &info->after);
|
||||
RB_WARN_ON(cpu_buffer, !a_ok);
|
||||
|
||||
/* Write stamp must only go forward */
|
||||
if (save_before > info->after) {
|
||||
/*
|
||||
* We do not care about the result, only that
|
||||
* it gets updated atomically.
|
||||
*/
|
||||
(void)rb_time_cmpxchg(&cpu_buffer->write_stamp,
|
||||
info->after, save_before);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
u64 ts;
|
||||
/* SLOW PATH - Interrupted between A and C */
|
||||
a_ok = rb_time_read(&cpu_buffer->write_stamp, &info->after);
|
||||
/* Was interrupted before here, write_stamp must be valid */
|
||||
RB_WARN_ON(cpu_buffer, !a_ok);
|
||||
ts = rb_time_stamp(cpu_buffer->buffer);
|
||||
barrier();
|
||||
/*E*/ if (write == (local_read(&tail_page->write) & RB_WRITE_MASK) &&
|
||||
info->after < ts) {
|
||||
/* Nothing came after this event between C and E */
|
||||
info->delta = ts - info->after;
|
||||
(void)rb_time_cmpxchg(&cpu_buffer->write_stamp,
|
||||
info->after, info->ts);
|
||||
info->ts = ts;
|
||||
} else {
|
||||
/*
|
||||
* Interrupted beween C and E:
|
||||
* Lost the previous events time stamp. Just set the
|
||||
* delta to zero, and this will be the same time as
|
||||
* the event this event interrupted. And the events that
|
||||
* came after this will still be correct (as they would
|
||||
* have built their delta on the previous event.
|
||||
*/
|
||||
info->delta = 0;
|
||||
}
|
||||
info->add_timestamp &= ~RB_ADD_STAMP_FORCE;
|
||||
}
|
||||
|
||||
/*
|
||||
* If this is the first commit on the page, then it has the same
|
||||
* timestamp as the page itself.
|
||||
*/
|
||||
if (!tail && !ring_buffer_time_stamp_abs(cpu_buffer->buffer))
|
||||
if (unlikely(!tail && !(info->add_timestamp &
|
||||
(RB_ADD_STAMP_FORCE | RB_ADD_STAMP_ABSOLUTE))))
|
||||
info->delta = 0;
|
||||
|
||||
/* See if we shot pass the end of this buffer page */
|
||||
if (unlikely(write > BUF_PAGE_SIZE))
|
||||
return rb_move_tail(cpu_buffer, tail, info);
|
||||
|
||||
/* We reserved something on the buffer */
|
||||
|
||||
event = __rb_page_index(tail_page, tail);
|
||||
@ -2927,7 +3292,7 @@ __rb_reserve_next(struct ring_buffer_per_cpu *cpu_buffer,
|
||||
* If this is the first commit on the page, then update
|
||||
* its timestamp.
|
||||
*/
|
||||
if (!tail)
|
||||
if (unlikely(!tail))
|
||||
tail_page->page->time_stamp = info->ts;
|
||||
|
||||
/* account for these added bytes */
|
||||
@ -2944,9 +3309,10 @@ rb_reserve_next_event(struct trace_buffer *buffer,
|
||||
struct ring_buffer_event *event;
|
||||
struct rb_event_info info;
|
||||
int nr_loops = 0;
|
||||
u64 diff;
|
||||
int add_ts_default;
|
||||
|
||||
rb_start_commit(cpu_buffer);
|
||||
/* The commit page can not change after this */
|
||||
|
||||
#ifdef CONFIG_RING_BUFFER_ALLOW_SWAP
|
||||
/*
|
||||
@ -2964,8 +3330,16 @@ rb_reserve_next_event(struct trace_buffer *buffer,
|
||||
#endif
|
||||
|
||||
info.length = rb_calculate_event_length(length);
|
||||
|
||||
if (ring_buffer_time_stamp_abs(cpu_buffer->buffer)) {
|
||||
add_ts_default = RB_ADD_STAMP_ABSOLUTE;
|
||||
info.length += RB_LEN_TIME_EXTEND;
|
||||
} else {
|
||||
add_ts_default = RB_ADD_STAMP_NONE;
|
||||
}
|
||||
|
||||
again:
|
||||
info.add_timestamp = 0;
|
||||
info.add_timestamp = add_ts_default;
|
||||
info.delta = 0;
|
||||
|
||||
/*
|
||||
@ -2980,35 +3354,16 @@ rb_reserve_next_event(struct trace_buffer *buffer,
|
||||
if (RB_WARN_ON(cpu_buffer, ++nr_loops > 1000))
|
||||
goto out_fail;
|
||||
|
||||
info.ts = rb_time_stamp(cpu_buffer->buffer);
|
||||
diff = info.ts - cpu_buffer->write_stamp;
|
||||
|
||||
/* make sure this diff is calculated here */
|
||||
barrier();
|
||||
|
||||
if (ring_buffer_time_stamp_abs(buffer)) {
|
||||
info.delta = info.ts;
|
||||
rb_handle_timestamp(cpu_buffer, &info);
|
||||
} else /* Did the write stamp get updated already? */
|
||||
if (likely(info.ts >= cpu_buffer->write_stamp)) {
|
||||
info.delta = diff;
|
||||
if (unlikely(test_time_stamp(info.delta)))
|
||||
rb_handle_timestamp(cpu_buffer, &info);
|
||||
}
|
||||
|
||||
event = __rb_reserve_next(cpu_buffer, &info);
|
||||
|
||||
if (unlikely(PTR_ERR(event) == -EAGAIN)) {
|
||||
if (info.add_timestamp)
|
||||
if (info.add_timestamp & (RB_ADD_STAMP_FORCE | RB_ADD_STAMP_EXTEND))
|
||||
info.length -= RB_LEN_TIME_EXTEND;
|
||||
goto again;
|
||||
}
|
||||
|
||||
if (!event)
|
||||
goto out_fail;
|
||||
|
||||
if (likely(event))
|
||||
return event;
|
||||
|
||||
out_fail:
|
||||
rb_end_commit(cpu_buffer);
|
||||
return NULL;
|
||||
@ -3154,11 +3509,6 @@ void ring_buffer_discard_commit(struct trace_buffer *buffer,
|
||||
if (rb_try_to_discard(cpu_buffer, event))
|
||||
goto out;
|
||||
|
||||
/*
|
||||
* The commit is still visible by the reader, so we
|
||||
* must still update the timestamp.
|
||||
*/
|
||||
rb_update_write_stamp(cpu_buffer, event);
|
||||
out:
|
||||
rb_end_commit(cpu_buffer);
|
||||
|
||||
@ -4475,8 +4825,8 @@ rb_reset_cpu(struct ring_buffer_per_cpu *cpu_buffer)
|
||||
cpu_buffer->read = 0;
|
||||
cpu_buffer->read_bytes = 0;
|
||||
|
||||
cpu_buffer->write_stamp = 0;
|
||||
cpu_buffer->read_stamp = 0;
|
||||
rb_time_set(&cpu_buffer->write_stamp, 0);
|
||||
rb_time_set(&cpu_buffer->before_stamp, 0);
|
||||
|
||||
cpu_buffer->lost_events = 0;
|
||||
cpu_buffer->last_overrun = 0;
|
||||
@ -4484,25 +4834,11 @@ rb_reset_cpu(struct ring_buffer_per_cpu *cpu_buffer)
|
||||
rb_head_page_activate(cpu_buffer);
|
||||
}
|
||||
|
||||
/**
|
||||
* ring_buffer_reset_cpu - reset a ring buffer per CPU buffer
|
||||
* @buffer: The ring buffer to reset a per cpu buffer of
|
||||
* @cpu: The CPU buffer to be reset
|
||||
*/
|
||||
void ring_buffer_reset_cpu(struct trace_buffer *buffer, int cpu)
|
||||
/* Must have disabled the cpu buffer then done a synchronize_rcu */
|
||||
static void reset_disabled_cpu_buffer(struct ring_buffer_per_cpu *cpu_buffer)
|
||||
{
|
||||
struct ring_buffer_per_cpu *cpu_buffer = buffer->buffers[cpu];
|
||||
unsigned long flags;
|
||||
|
||||
if (!cpumask_test_cpu(cpu, buffer->cpumask))
|
||||
return;
|
||||
|
||||
atomic_inc(&cpu_buffer->resize_disabled);
|
||||
atomic_inc(&cpu_buffer->record_disabled);
|
||||
|
||||
/* Make sure all commits have finished */
|
||||
synchronize_rcu();
|
||||
|
||||
raw_spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
|
||||
|
||||
if (RB_WARN_ON(cpu_buffer, local_read(&cpu_buffer->committing)))
|
||||
@ -4516,22 +4852,90 @@ void ring_buffer_reset_cpu(struct trace_buffer *buffer, int cpu)
|
||||
|
||||
out:
|
||||
raw_spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
|
||||
}
|
||||
|
||||
/**
|
||||
* ring_buffer_reset_cpu - reset a ring buffer per CPU buffer
|
||||
* @buffer: The ring buffer to reset a per cpu buffer of
|
||||
* @cpu: The CPU buffer to be reset
|
||||
*/
|
||||
void ring_buffer_reset_cpu(struct trace_buffer *buffer, int cpu)
|
||||
{
|
||||
struct ring_buffer_per_cpu *cpu_buffer = buffer->buffers[cpu];
|
||||
|
||||
if (!cpumask_test_cpu(cpu, buffer->cpumask))
|
||||
return;
|
||||
|
||||
atomic_inc(&cpu_buffer->resize_disabled);
|
||||
atomic_inc(&cpu_buffer->record_disabled);
|
||||
|
||||
/* Make sure all commits have finished */
|
||||
synchronize_rcu();
|
||||
|
||||
reset_disabled_cpu_buffer(cpu_buffer);
|
||||
|
||||
atomic_dec(&cpu_buffer->record_disabled);
|
||||
atomic_dec(&cpu_buffer->resize_disabled);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(ring_buffer_reset_cpu);
|
||||
|
||||
/**
|
||||
* ring_buffer_reset_cpu - reset a ring buffer per CPU buffer
|
||||
* @buffer: The ring buffer to reset a per cpu buffer of
|
||||
* @cpu: The CPU buffer to be reset
|
||||
*/
|
||||
void ring_buffer_reset_online_cpus(struct trace_buffer *buffer)
|
||||
{
|
||||
struct ring_buffer_per_cpu *cpu_buffer;
|
||||
int cpu;
|
||||
|
||||
for_each_online_buffer_cpu(buffer, cpu) {
|
||||
cpu_buffer = buffer->buffers[cpu];
|
||||
|
||||
atomic_inc(&cpu_buffer->resize_disabled);
|
||||
atomic_inc(&cpu_buffer->record_disabled);
|
||||
}
|
||||
|
||||
/* Make sure all commits have finished */
|
||||
synchronize_rcu();
|
||||
|
||||
for_each_online_buffer_cpu(buffer, cpu) {
|
||||
cpu_buffer = buffer->buffers[cpu];
|
||||
|
||||
reset_disabled_cpu_buffer(cpu_buffer);
|
||||
|
||||
atomic_dec(&cpu_buffer->record_disabled);
|
||||
atomic_dec(&cpu_buffer->resize_disabled);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* ring_buffer_reset - reset a ring buffer
|
||||
* @buffer: The ring buffer to reset all cpu buffers
|
||||
*/
|
||||
void ring_buffer_reset(struct trace_buffer *buffer)
|
||||
{
|
||||
struct ring_buffer_per_cpu *cpu_buffer;
|
||||
int cpu;
|
||||
|
||||
for_each_buffer_cpu(buffer, cpu)
|
||||
ring_buffer_reset_cpu(buffer, cpu);
|
||||
for_each_buffer_cpu(buffer, cpu) {
|
||||
cpu_buffer = buffer->buffers[cpu];
|
||||
|
||||
atomic_inc(&cpu_buffer->resize_disabled);
|
||||
atomic_inc(&cpu_buffer->record_disabled);
|
||||
}
|
||||
|
||||
/* Make sure all commits have finished */
|
||||
synchronize_rcu();
|
||||
|
||||
for_each_buffer_cpu(buffer, cpu) {
|
||||
cpu_buffer = buffer->buffers[cpu];
|
||||
|
||||
reset_disabled_cpu_buffer(cpu_buffer);
|
||||
|
||||
atomic_dec(&cpu_buffer->record_disabled);
|
||||
atomic_dec(&cpu_buffer->resize_disabled);
|
||||
}
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(ring_buffer_reset);
|
||||
|
||||
|
||||
@ -2002,7 +2002,6 @@ static void tracing_reset_cpu(struct array_buffer *buf, int cpu)
|
||||
void tracing_reset_online_cpus(struct array_buffer *buf)
|
||||
{
|
||||
struct trace_buffer *buffer = buf->buffer;
|
||||
int cpu;
|
||||
|
||||
if (!buffer)
|
||||
return;
|
||||
@ -2014,8 +2013,7 @@ void tracing_reset_online_cpus(struct array_buffer *buf)
|
||||
|
||||
buf->time_start = buffer_ftrace_now(buf, buf->cpu);
|
||||
|
||||
for_each_online_cpu(cpu)
|
||||
ring_buffer_reset_cpu(buffer, cpu);
|
||||
ring_buffer_reset_online_cpus(buffer);
|
||||
|
||||
ring_buffer_record_enable(buffer);
|
||||
}
|
||||
@ -2931,12 +2929,6 @@ static void __ftrace_trace_stack(struct trace_buffer *buffer,
|
||||
skip++;
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Since events can happen in NMIs there's no safe way to
|
||||
* use the per cpu ftrace_stacks. We reserve it and if an interrupt
|
||||
* or NMI comes in, it will just have to use the default
|
||||
* FTRACE_STACK_SIZE.
|
||||
*/
|
||||
preempt_disable_notrace();
|
||||
|
||||
stackidx = __this_cpu_inc_return(ftrace_stack_reserve) - 1;
|
||||
@ -3136,6 +3128,9 @@ static int alloc_percpu_trace_buffer(void)
|
||||
{
|
||||
struct trace_buffer_struct *buffers;
|
||||
|
||||
if (trace_percpu_buffer)
|
||||
return 0;
|
||||
|
||||
buffers = alloc_percpu(struct trace_buffer_struct);
|
||||
if (MEM_FAIL(!buffers, "Could not allocate percpu trace_printk buffer"))
|
||||
return -ENOMEM;
|
||||
@ -3338,6 +3333,26 @@ int trace_array_vprintk(struct trace_array *tr,
|
||||
return __trace_array_vprintk(tr->array_buffer.buffer, ip, fmt, args);
|
||||
}
|
||||
|
||||
/**
|
||||
* trace_array_printk - Print a message to a specific instance
|
||||
* @tr: The instance trace_array descriptor
|
||||
* @ip: The instruction pointer that this is called from.
|
||||
* @fmt: The format to print (printf format)
|
||||
*
|
||||
* If a subsystem sets up its own instance, they have the right to
|
||||
* printk strings into their tracing instance buffer using this
|
||||
* function. Note, this function will not write into the top level
|
||||
* buffer (use trace_printk() for that), as writing into the top level
|
||||
* buffer should only have events that can be individually disabled.
|
||||
* trace_printk() is only used for debugging a kernel, and should not
|
||||
* be ever encorporated in normal use.
|
||||
*
|
||||
* trace_array_printk() can be used, as it will not add noise to the
|
||||
* top level tracing buffer.
|
||||
*
|
||||
* Note, trace_array_init_printk() must be called on @tr before this
|
||||
* can be used.
|
||||
*/
|
||||
__printf(3, 0)
|
||||
int trace_array_printk(struct trace_array *tr,
|
||||
unsigned long ip, const char *fmt, ...)
|
||||
@ -3345,12 +3360,16 @@ int trace_array_printk(struct trace_array *tr,
|
||||
int ret;
|
||||
va_list ap;
|
||||
|
||||
if (!(global_trace.trace_flags & TRACE_ITER_PRINTK))
|
||||
return 0;
|
||||
|
||||
if (!tr)
|
||||
return -ENOENT;
|
||||
|
||||
/* This is only allowed for created instances */
|
||||
if (tr == &global_trace)
|
||||
return 0;
|
||||
|
||||
if (!(tr->trace_flags & TRACE_ITER_PRINTK))
|
||||
return 0;
|
||||
|
||||
va_start(ap, fmt);
|
||||
ret = trace_array_vprintk(tr, ip, fmt, ap);
|
||||
va_end(ap);
|
||||
@ -3358,6 +3377,27 @@ int trace_array_printk(struct trace_array *tr,
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(trace_array_printk);
|
||||
|
||||
/**
|
||||
* trace_array_init_printk - Initialize buffers for trace_array_printk()
|
||||
* @tr: The trace array to initialize the buffers for
|
||||
*
|
||||
* As trace_array_printk() only writes into instances, they are OK to
|
||||
* have in the kernel (unlike trace_printk()). This needs to be called
|
||||
* before trace_array_printk() can be used on a trace_array.
|
||||
*/
|
||||
int trace_array_init_printk(struct trace_array *tr)
|
||||
{
|
||||
if (!tr)
|
||||
return -ENOENT;
|
||||
|
||||
/* This is only allowed for created instances */
|
||||
if (tr == &global_trace)
|
||||
return -EINVAL;
|
||||
|
||||
return alloc_percpu_trace_buffer();
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(trace_array_init_printk);
|
||||
|
||||
__printf(3, 4)
|
||||
int trace_array_printk_buf(struct trace_buffer *buffer,
|
||||
unsigned long ip, const char *fmt, ...)
|
||||
@ -5886,7 +5926,7 @@ int tracing_set_tracer(struct trace_array *tr, const char *buf)
|
||||
}
|
||||
|
||||
/* If trace pipe files are being read, we can't change the tracer */
|
||||
if (tr->current_trace->ref) {
|
||||
if (tr->trace_ref) {
|
||||
ret = -EBUSY;
|
||||
goto out;
|
||||
}
|
||||
@ -6102,7 +6142,7 @@ static int tracing_open_pipe(struct inode *inode, struct file *filp)
|
||||
|
||||
nonseekable_open(inode, filp);
|
||||
|
||||
tr->current_trace->ref++;
|
||||
tr->trace_ref++;
|
||||
out:
|
||||
mutex_unlock(&trace_types_lock);
|
||||
return ret;
|
||||
@ -6121,7 +6161,7 @@ static int tracing_release_pipe(struct inode *inode, struct file *file)
|
||||
|
||||
mutex_lock(&trace_types_lock);
|
||||
|
||||
tr->current_trace->ref--;
|
||||
tr->trace_ref--;
|
||||
|
||||
if (iter->trace->pipe_close)
|
||||
iter->trace->pipe_close(iter);
|
||||
@ -7405,7 +7445,7 @@ static int tracing_buffers_open(struct inode *inode, struct file *filp)
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
info = kzalloc(sizeof(*info), GFP_KERNEL);
|
||||
info = kvzalloc(sizeof(*info), GFP_KERNEL);
|
||||
if (!info) {
|
||||
trace_array_put(tr);
|
||||
return -ENOMEM;
|
||||
@ -7423,7 +7463,7 @@ static int tracing_buffers_open(struct inode *inode, struct file *filp)
|
||||
|
||||
filp->private_data = info;
|
||||
|
||||
tr->current_trace->ref++;
|
||||
tr->trace_ref++;
|
||||
|
||||
mutex_unlock(&trace_types_lock);
|
||||
|
||||
@ -7524,14 +7564,14 @@ static int tracing_buffers_release(struct inode *inode, struct file *file)
|
||||
|
||||
mutex_lock(&trace_types_lock);
|
||||
|
||||
iter->tr->current_trace->ref--;
|
||||
iter->tr->trace_ref--;
|
||||
|
||||
__trace_array_put(iter->tr);
|
||||
|
||||
if (info->spare)
|
||||
ring_buffer_free_read_page(iter->array_buffer->buffer,
|
||||
info->spare_cpu, info->spare);
|
||||
kfree(info);
|
||||
kvfree(info);
|
||||
|
||||
mutex_unlock(&trace_types_lock);
|
||||
|
||||
@ -8732,7 +8772,7 @@ static int __remove_instance(struct trace_array *tr)
|
||||
int i;
|
||||
|
||||
/* Reference counter for a newly created trace array = 1. */
|
||||
if (tr->ref > 1 || (tr->current_trace && tr->current_trace->ref))
|
||||
if (tr->ref > 1 || (tr->current_trace && tr->trace_ref))
|
||||
return -EBUSY;
|
||||
|
||||
list_del(&tr->list);
|
||||
|
||||
@ -356,6 +356,7 @@ struct trace_array {
|
||||
struct trace_event_file *trace_marker_file;
|
||||
cpumask_var_t tracing_cpumask; /* only trace on set CPUs */
|
||||
int ref;
|
||||
int trace_ref;
|
||||
#ifdef CONFIG_FUNCTION_TRACER
|
||||
struct ftrace_ops *ops;
|
||||
struct trace_pid_list __rcu *function_pids;
|
||||
@ -547,7 +548,6 @@ struct tracer {
|
||||
struct tracer *next;
|
||||
struct tracer_flags *flags;
|
||||
int enabled;
|
||||
int ref;
|
||||
bool print_max;
|
||||
bool allow_instances;
|
||||
#ifdef CONFIG_TRACER_MAX_TRACE
|
||||
@ -1103,6 +1103,10 @@ print_graph_function_flags(struct trace_iterator *iter, u32 flags)
|
||||
extern struct list_head ftrace_pids;
|
||||
|
||||
#ifdef CONFIG_FUNCTION_TRACER
|
||||
|
||||
#define FTRACE_PID_IGNORE -1
|
||||
#define FTRACE_PID_TRACE -2
|
||||
|
||||
struct ftrace_func_command {
|
||||
struct list_head list;
|
||||
char *name;
|
||||
@ -1114,7 +1118,8 @@ struct ftrace_func_command {
|
||||
extern bool ftrace_filter_param __initdata;
|
||||
static inline int ftrace_trace_task(struct trace_array *tr)
|
||||
{
|
||||
return !this_cpu_read(tr->array_buffer.data->ftrace_ignore_pid);
|
||||
return this_cpu_read(tr->array_buffer.data->ftrace_ignore_pid) !=
|
||||
FTRACE_PID_IGNORE;
|
||||
}
|
||||
extern int ftrace_is_dead(void);
|
||||
int ftrace_create_function_files(struct trace_array *tr,
|
||||
|
||||
@ -538,12 +538,12 @@ void trace_event_follow_fork(struct trace_array *tr, bool enable)
|
||||
if (enable) {
|
||||
register_trace_prio_sched_process_fork(event_filter_pid_sched_process_fork,
|
||||
tr, INT_MIN);
|
||||
register_trace_prio_sched_process_exit(event_filter_pid_sched_process_exit,
|
||||
register_trace_prio_sched_process_free(event_filter_pid_sched_process_exit,
|
||||
tr, INT_MAX);
|
||||
} else {
|
||||
unregister_trace_sched_process_fork(event_filter_pid_sched_process_fork,
|
||||
tr);
|
||||
unregister_trace_sched_process_exit(event_filter_pid_sched_process_exit,
|
||||
unregister_trace_sched_process_free(event_filter_pid_sched_process_exit,
|
||||
tr);
|
||||
}
|
||||
}
|
||||
|
||||
@ -283,6 +283,7 @@ static bool disable_migrate;
|
||||
static void move_to_next_cpu(void)
|
||||
{
|
||||
struct cpumask *current_mask = &save_cpumask;
|
||||
struct trace_array *tr = hwlat_trace;
|
||||
int next_cpu;
|
||||
|
||||
if (disable_migrate)
|
||||
@ -296,7 +297,7 @@ static void move_to_next_cpu(void)
|
||||
goto disable;
|
||||
|
||||
get_online_cpus();
|
||||
cpumask_and(current_mask, cpu_online_mask, tracing_buffer_mask);
|
||||
cpumask_and(current_mask, cpu_online_mask, tr->tracing_cpumask);
|
||||
next_cpu = cpumask_next(smp_processor_id(), current_mask);
|
||||
put_online_cpus();
|
||||
|
||||
@ -371,9 +372,8 @@ static int start_kthread(struct trace_array *tr)
|
||||
return 0;
|
||||
|
||||
/* Just pick the first CPU on first iteration */
|
||||
current_mask = &save_cpumask;
|
||||
get_online_cpus();
|
||||
cpumask_and(current_mask, cpu_online_mask, tracing_buffer_mask);
|
||||
cpumask_and(current_mask, cpu_online_mask, tr->tracing_cpumask);
|
||||
put_online_cpus();
|
||||
next_cpu = cpumask_first(current_mask);
|
||||
|
||||
|
||||
@ -20,7 +20,7 @@ DECLARE_RWSEM(trace_event_sem);
|
||||
|
||||
static struct hlist_head event_hash[EVENT_HASHSIZE] __read_mostly;
|
||||
|
||||
static int next_event_type = __TRACE_LAST_TYPE + 1;
|
||||
static int next_event_type = __TRACE_LAST_TYPE;
|
||||
|
||||
enum print_line_t trace_print_bputs_msg_only(struct trace_iterator *iter)
|
||||
{
|
||||
@ -675,11 +675,11 @@ static LIST_HEAD(ftrace_event_list);
|
||||
static int trace_search_list(struct list_head **list)
|
||||
{
|
||||
struct trace_event *e;
|
||||
int last = __TRACE_LAST_TYPE;
|
||||
int next = __TRACE_LAST_TYPE;
|
||||
|
||||
if (list_empty(&ftrace_event_list)) {
|
||||
*list = &ftrace_event_list;
|
||||
return last + 1;
|
||||
return next;
|
||||
}
|
||||
|
||||
/*
|
||||
@ -687,17 +687,17 @@ static int trace_search_list(struct list_head **list)
|
||||
* lets see if somebody freed one.
|
||||
*/
|
||||
list_for_each_entry(e, &ftrace_event_list, list) {
|
||||
if (e->type != last + 1)
|
||||
if (e->type != next)
|
||||
break;
|
||||
last++;
|
||||
next++;
|
||||
}
|
||||
|
||||
/* Did we used up all 65 thousand events??? */
|
||||
if ((last + 1) > TRACE_EVENT_TYPE_MAX)
|
||||
if (next > TRACE_EVENT_TYPE_MAX)
|
||||
return 0;
|
||||
|
||||
*list = &e->list;
|
||||
return last + 1;
|
||||
return next;
|
||||
}
|
||||
|
||||
void trace_event_read_lock(void)
|
||||
|
||||
@ -1456,7 +1456,6 @@ trace_uprobe_register(struct trace_event_call *event, enum trace_reg type,
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int uprobe_dispatcher(struct uprobe_consumer *con, struct pt_regs *regs)
|
||||
|
||||
@ -329,22 +329,30 @@ const char * __init xbc_node_find_next_key_value(struct xbc_node *root,
|
||||
|
||||
/* XBC parse and tree build */
|
||||
|
||||
static int __init xbc_init_node(struct xbc_node *node, char *data, u32 flag)
|
||||
{
|
||||
unsigned long offset = data - xbc_data;
|
||||
|
||||
if (WARN_ON(offset >= XBC_DATA_MAX))
|
||||
return -EINVAL;
|
||||
|
||||
node->data = (u16)offset | flag;
|
||||
node->child = 0;
|
||||
node->next = 0;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct xbc_node * __init xbc_add_node(char *data, u32 flag)
|
||||
{
|
||||
struct xbc_node *node;
|
||||
unsigned long offset;
|
||||
|
||||
if (xbc_node_num == XBC_NODE_MAX)
|
||||
return NULL;
|
||||
|
||||
node = &xbc_nodes[xbc_node_num++];
|
||||
offset = data - xbc_data;
|
||||
node->data = (u16)offset;
|
||||
if (WARN_ON(offset >= XBC_DATA_MAX))
|
||||
if (xbc_init_node(node, data, flag) < 0)
|
||||
return NULL;
|
||||
node->data |= flag;
|
||||
node->child = 0;
|
||||
node->next = 0;
|
||||
|
||||
return node;
|
||||
}
|
||||
@ -603,7 +611,9 @@ static int __init xbc_parse_kv(char **k, char *v, int op)
|
||||
if (c < 0)
|
||||
return c;
|
||||
|
||||
if (!xbc_add_sibling(v, XBC_VALUE))
|
||||
if (op == ':' && child) {
|
||||
xbc_init_node(child, v, XBC_VALUE);
|
||||
} else if (!xbc_add_sibling(v, XBC_VALUE))
|
||||
return -ENOMEM;
|
||||
|
||||
if (c == ',') { /* Array */
|
||||
@ -787,7 +797,7 @@ int __init xbc_init(char *buf, const char **emsg, int *epos)
|
||||
|
||||
p = buf;
|
||||
do {
|
||||
q = strpbrk(p, "{}=+;\n#");
|
||||
q = strpbrk(p, "{}=+;:\n#");
|
||||
if (!q) {
|
||||
p = skip_spaces(p);
|
||||
if (*p != '\0')
|
||||
@ -798,9 +808,12 @@ int __init xbc_init(char *buf, const char **emsg, int *epos)
|
||||
c = *q;
|
||||
*q++ = '\0';
|
||||
switch (c) {
|
||||
case ':':
|
||||
case '+':
|
||||
if (*q++ != '=') {
|
||||
ret = xbc_parse_error("Wrong '+' operator",
|
||||
ret = xbc_parse_error(c == '+' ?
|
||||
"Wrong '+' operator" :
|
||||
"Wrong ':' operator",
|
||||
q - 2);
|
||||
break;
|
||||
}
|
||||
|
||||
3
tools/bootconfig/samples/bad-override.bconf
Normal file
3
tools/bootconfig/samples/bad-override.bconf
Normal file
@ -0,0 +1,3 @@
|
||||
key.subkey = value
|
||||
# We can not override pre-defined subkeys with value
|
||||
key := value
|
||||
3
tools/bootconfig/samples/bad-override2.bconf
Normal file
3
tools/bootconfig/samples/bad-override2.bconf
Normal file
@ -0,0 +1,3 @@
|
||||
key = value
|
||||
# We can not override pre-defined value with subkey
|
||||
key.subkey := value
|
||||
6
tools/bootconfig/samples/good-override.bconf
Normal file
6
tools/bootconfig/samples/good-override.bconf
Normal file
@ -0,0 +1,6 @@
|
||||
# Override the value
|
||||
key.word = 1,2,4
|
||||
key.word := 2,3
|
||||
|
||||
# No pre-defined key
|
||||
key.new.word := "new"
|
||||
@ -117,6 +117,19 @@ xpass grep -q "bar" $OUTFILE
|
||||
xpass grep -q "baz" $OUTFILE
|
||||
xpass grep -q "qux" $OUTFILE
|
||||
|
||||
echo "Override same-key values"
|
||||
cat > $TEMPCONF << EOF
|
||||
key = bar, baz
|
||||
key := qux
|
||||
EOF
|
||||
echo > $INITRD
|
||||
|
||||
xpass $BOOTCONF -a $TEMPCONF $INITRD
|
||||
$BOOTCONF $INITRD > $OUTFILE
|
||||
xfail grep -q "bar" $OUTFILE
|
||||
xfail grep -q "baz" $OUTFILE
|
||||
xpass grep -q "qux" $OUTFILE
|
||||
|
||||
echo "Double/single quotes test"
|
||||
echo "key = '\"string\"';" > $TEMPCONF
|
||||
$BOOTCONF -a $TEMPCONF $INITRD
|
||||
|
||||
Loading…
Reference in New Issue
Block a user