// SPDX-License-Identifier: GPL-2.0

/*

* ring buffer based function tracer

*

* Copyright (C) 2007-2012 Steven Rostedt <srostedt@redhat.com>

* Copyright (C) 2008 Ingo Molnar <mingo@redhat.com>

*

* Originally taken from the RT patch by:

* Arnaldo Carvalho de Melo <acme@redhat.com>

*

* Based on code from the latency_tracer, that is:

* Copyright (C) 2004-2006 Ingo Molnar

* Copyright (C) 2004 Nadia Yvette Chambers

*/

#include <linux/ring_buffer.h>

#include <linux/utsname.h>

#include <linux/stacktrace.h>

#include <linux/writeback.h>

#include <linux/kallsyms.h>

#include <linux/security.h>

#include <linux/seq_file.h>

#include <linux/irqflags.h>

#include <linux/syscalls.h>

#include <linux/debugfs.h>

#include <linux/tracefs.h>

#include <linux/pagemap.h>

#include <linux/hardirq.h>

#include <linux/linkage.h>

#include <linux/uaccess.h>

#include <linux/cleanup.h>

#include <linux/vmalloc.h>

#include <linux/ftrace.h>

#include <linux/module.h>

#include <linux/percpu.h>

#include <linux/splice.h>

#include <linux/kdebug.h>

#include <linux/string.h>

#include <linux/mount.h>

#include <linux/rwsem.h>

#include <linux/slab.h>

#include <linux/ctype.h>

#include <linux/init.h>

#include <linux/panic_notifier.h>

#include <linux/poll.h>

#include <linux/nmi.h>

#include <linux/fs.h>

#include <linux/trace.h>

#include <linux/sched/clock.h>

#include <linux/sched/rt.h>

#include <linux/irq_work.h>

#include <linux/workqueue.h>

#include <linux/sort.h>

#include <linux/io.h> /* vmap_page_range() */

#include <linux/fs_context.h>

#include <asm/setup.h> /* COMMAND_LINE_SIZE */

#include "trace.h"

#include "trace_output.h"

#ifdef CONFIG_FTRACE_STARTUP_TEST

/*

* We need to change this state when a selftest is running.

* A selftest will lurk into the ring-buffer to count the

* entries inserted during the selftest although some concurrent

* insertions into the ring-buffer such as trace_printk could occurred

* at the same time, giving false positive or negative results.

*/

bool __read_mostly tracing_selftest_running;

/*

* If boot-time tracing including tracers/events via kernel cmdline

* is running, we do not want to run SELFTEST.

*/

bool __read_mostly tracing_selftest_disabled;

void __init disable_tracing_selftest(const char *reason)

{

if (!tracing_selftest_disabled) {

tracing_selftest_disabled = true;

pr_info("Ftrace startup test is disabled due to %s\n", reason);

}

}

#else

#define tracing_selftest_disabled 0

#endif

/* Pipe tracepoints to printk */

static struct trace_iterator *tracepoint_print_iter;

int tracepoint_printk;

static bool tracepoint_printk_stop_on_boot __initdata;

static bool traceoff_after_boot __initdata;

static DEFINE_STATIC_KEY_FALSE(tracepoint_printk_key);

/* Store tracers and their flags per instance */

struct tracers {

struct list_head list;

struct tracer *tracer;

struct tracer_flags *flags;

};

/*

* To prevent the comm cache from being overwritten when no

* tracing is active, only save the comm when a trace event

* occurred.

*/

DEFINE_PER_CPU(bool, trace_taskinfo_save);

/*

* Kill all tracing for good (never come back).

* It is initialized to 1 but will turn to zero if the initialization

* of the tracer is successful. But that is the only place that sets

* this back to zero.

*/

int tracing_disabled = 1;

cpumask_var_t __read_mostly tracing_buffer_mask;

#define MAX_TRACER_SIZE 100

/*

* ftrace_dump_on_oops - variable to dump ftrace buffer on oops

*

* If there is an oops (or kernel panic) and the ftrace_dump_on_oops

* is set, then ftrace_dump is called. This will output the contents

* of the ftrace buffers to the console. This is very useful for

* capturing traces that lead to crashes and outputting it to a

* serial console.

*

* It is default off, but you can enable it with either specifying

* "ftrace_dump_on_oops" in the kernel command line, or setting

* /proc/sys/kernel/ftrace_dump_on_oops

* Set 1 if you want to dump buffers of all CPUs

* Set 2 if you want to dump the buffer of the CPU that triggered oops

* Set instance name if you want to dump the specific trace instance

* Multiple instance dump is also supported, and instances are separated

* by commas.

*/

/* Set to string format zero to disable by default */

static char ftrace_dump_on_oops[MAX_TRACER_SIZE] = "0";

/* When set, tracing will stop when a WARN*() is hit */

static int __disable_trace_on_warning;

int tracepoint_printk_sysctl(const struct ctl_table *table, int write,

void *buffer, size_t *lenp, loff_t *ppos);

static const struct ctl_table trace_sysctl_table[] = {

{

.procname = "ftrace_dump_on_oops",

.data = &ftrace_dump_on_oops,

.maxlen = MAX_TRACER_SIZE,

.mode = 0644,

.proc_handler = proc_dostring,

},

{

.procname = "traceoff_on_warning",

.data = &__disable_trace_on_warning,

.maxlen = sizeof(__disable_trace_on_warning),

.mode = 0644,

.proc_handler = proc_dointvec,

},

{

.procname = "tracepoint_printk",

.data = &tracepoint_printk,

.maxlen = sizeof(tracepoint_printk),

.mode = 0644,

.proc_handler = tracepoint_printk_sysctl,

},

};

static int __init init_trace_sysctls(void)

{

register_sysctl_init("kernel", trace_sysctl_table);

return 0;

}

subsys_initcall(init_trace_sysctls);

#ifdef CONFIG_TRACE_EVAL_MAP_FILE

/* Map of enums to their values, for "eval_map" file */

struct trace_eval_map_head {

struct module *mod;

unsigned long length;

};

union trace_eval_map_item;

struct trace_eval_map_tail {

/*

* "end" is first and points to NULL as it must be different

* than "mod" or "eval_string"

*/

union trace_eval_map_item *next;

const char *end; /* points to NULL */

};

static DEFINE_MUTEX(trace_eval_mutex);

/*

* The trace_eval_maps are saved in an array with two extra elements,

* one at the beginning, and one at the end. The beginning item contains

* the count of the saved maps (head.length), and the module they

* belong to if not built in (head.mod). The ending item contains a

* pointer to the next array of saved eval_map items.

*/

union trace_eval_map_item {

struct trace_eval_map map;

struct trace_eval_map_head head;

struct trace_eval_map_tail tail;

};

static union trace_eval_map_item *trace_eval_maps;

#endif /* CONFIG_TRACE_EVAL_MAP_FILE */

int tracing_set_tracer(struct trace_array *tr, const char *buf);

static void ftrace_trace_userstack(struct trace_array *tr,

struct trace_buffer *buffer,

unsigned int trace_ctx);

static char bootup_tracer_buf[MAX_TRACER_SIZE] __initdata;

static char *default_bootup_tracer;

static char boot_instance_info[COMMAND_LINE_SIZE] __initdata;

static int boot_instance_index;

/*

* Repeated boot parameters, including Bootconfig array expansions, need

* to stay in the delimiter form that the existing parser consumes.

*/

void __init trace_append_boot_param(char *buf, const char *str, char sep,

int size)

{

int len, needed, str_len;

if (!*str)

return;

len = strlen(buf);

str_len = strlen(str);

needed = len + str_len + 1;

/* For continuation, account for the separator. */

if (len)

needed++;

if (needed > size)

return;

if (len)

buf[len++] = sep;

strscpy(buf + len, str, size - len);

}

static int __init set_cmdline_ftrace(char *str)

{

strscpy(bootup_tracer_buf, str, MAX_TRACER_SIZE);

default_bootup_tracer = bootup_tracer_buf;

/* We are using ftrace early, expand it */

trace_set_ring_buffer_expanded(NULL);

return 1;

}

__setup("ftrace=", set_cmdline_ftrace);

int ftrace_dump_on_oops_enabled(void)

{

if (!strcmp("0", ftrace_dump_on_oops))

return 0;

else

return 1;

}

static int __init set_ftrace_dump_on_oops(char *str)

{

if (!*str) {

strscpy(ftrace_dump_on_oops, "1", MAX_TRACER_SIZE);

return 1;

}

if (*str == ',') {

strscpy(ftrace_dump_on_oops, "1", MAX_TRACER_SIZE);

strscpy(ftrace_dump_on_oops + 1, str, MAX_TRACER_SIZE - 1);

return 1;

}

if (*str++ == '=') {

strscpy(ftrace_dump_on_oops, str, MAX_TRACER_SIZE);

return 1;

}

return 0;

}

__setup("ftrace_dump_on_oops", set_ftrace_dump_on_oops);

static int __init stop_trace_on_warning(char *str)

{

if ((strcmp(str, "=0") != 0 && strcmp(str, "=off") != 0))

__disable_trace_on_warning = 1;

return 1;

}

__setup("traceoff_on_warning", stop_trace_on_warning);

static int __init boot_instance(char *str)

{

char *slot = boot_instance_info + boot_instance_index;

int left = sizeof(boot_instance_info) - boot_instance_index;

int ret;

if (strlen(str) >= left)

return -1;

ret = snprintf(slot, left, "%s\t", str);

boot_instance_index += ret;

return 1;

}

__setup("trace_instance=", boot_instance);

static char trace_boot_options_buf[MAX_TRACER_SIZE] __initdata;

static int __init set_trace_boot_options(char *str)

{

trace_append_boot_param(trace_boot_options_buf, str, ',',

MAX_TRACER_SIZE);

return 1;

}

__setup("trace_options=", set_trace_boot_options);

static char trace_boot_clock_buf[MAX_TRACER_SIZE] __initdata;

static char *trace_boot_clock __initdata;

static int __init set_trace_boot_clock(char *str)

{

strscpy(trace_boot_clock_buf, str, MAX_TRACER_SIZE);

trace_boot_clock = trace_boot_clock_buf;

return 1;

}

__setup("trace_clock=", set_trace_boot_clock);

static int __init set_tracepoint_printk(char *str)

{

/* Ignore the "tp_printk_stop_on_boot" param */

if (*str == '_')

return 0;

if ((strcmp(str, "=0") != 0 && strcmp(str, "=off") != 0))

tracepoint_printk = 1;

return 1;

}

__setup("tp_printk", set_tracepoint_printk);

static int __init set_tracepoint_printk_stop(char *str)

{

tracepoint_printk_stop_on_boot = true;

return 1;

}

__setup("tp_printk_stop_on_boot", set_tracepoint_printk_stop);

static int __init set_traceoff_after_boot(char *str)

{

traceoff_after_boot = true;

return 1;

}

__setup("traceoff_after_boot", set_traceoff_after_boot);

unsigned long long ns2usecs(u64 nsec)

{

nsec += 500;

do_div(nsec, 1000);

return nsec;

}

static void

trace_process_export(struct trace_export *export,

struct ring_buffer_event *event, int flag)

{

struct trace_entry *entry;

unsigned int size = 0;

if (export->flags & flag) {

entry = ring_buffer_event_data(event);

size = ring_buffer_event_length(event);

export->write(export, entry, size);

}

}

static DEFINE_MUTEX(ftrace_export_lock);

static struct trace_export __rcu *ftrace_exports_list __read_mostly;

static DEFINE_STATIC_KEY_FALSE(trace_function_exports_enabled);

static DEFINE_STATIC_KEY_FALSE(trace_event_exports_enabled);

static DEFINE_STATIC_KEY_FALSE(trace_marker_exports_enabled);

static inline void ftrace_exports_enable(struct trace_export *export)

{

if (export->flags & TRACE_EXPORT_FUNCTION)

static_branch_inc(&trace_function_exports_enabled);

if (export->flags & TRACE_EXPORT_EVENT)

static_branch_inc(&trace_event_exports_enabled);

if (export->flags & TRACE_EXPORT_MARKER)

static_branch_inc(&trace_marker_exports_enabled);

}

static inline void ftrace_exports_disable(struct trace_export *export)

{

if (export->flags & TRACE_EXPORT_FUNCTION)

static_branch_dec(&trace_function_exports_enabled);

if (export->flags & TRACE_EXPORT_EVENT)

static_branch_dec(&trace_event_exports_enabled);

if (export->flags & TRACE_EXPORT_MARKER)

static_branch_dec(&trace_marker_exports_enabled);

}

static void ftrace_exports(struct ring_buffer_event *event, int flag)

{

struct trace_export *export;

guard(preempt_notrace)();

export = rcu_dereference_raw_check(ftrace_exports_list);

while (export) {

trace_process_export(export, event, flag);

export = rcu_dereference_raw_check(export->next);

}

}

static inline void

add_trace_export(struct trace_export **list, struct trace_export *export)

{

rcu_assign_pointer(export->next, *list);

/*

* We are entering export into the list but another

* CPU might be walking that list. We need to make sure

* the export->next pointer is valid before another CPU sees

* the export pointer included into the list.

*/

rcu_assign_pointer(*list, export);

}

static inline int

rm_trace_export(struct trace_export **list, struct trace_export *export)

{

struct trace_export **p;

for (p = list; *p != NULL; p = &(*p)->next)

if (*p == export)

break;

if (*p != export)

return -1;

rcu_assign_pointer(*p, (*p)->next);

return 0;

}

static inline void

add_ftrace_export(struct trace_export **list, struct trace_export *export)

{

ftrace_exports_enable(export);

add_trace_export(list, export);

}

static inline int

rm_ftrace_export(struct trace_export **list, struct trace_export *export)

{

int ret;

ret = rm_trace_export(list, export);

ftrace_exports_disable(export);

return ret;

}

int register_ftrace_export(struct trace_export *export)

{

if (WARN_ON_ONCE(!export->write))

return -1;

guard(mutex)(&ftrace_export_lock);

add_ftrace_export(&ftrace_exports_list, export);

return 0;

}

EXPORT_SYMBOL_GPL(register_ftrace_export);

int unregister_ftrace_export(struct trace_export *export)

{

guard(mutex)(&ftrace_export_lock);

return rm_ftrace_export(&ftrace_exports_list, export);

}

EXPORT_SYMBOL_GPL(unregister_ftrace_export);

/* trace_flags holds trace_options default values */

#define TRACE_DEFAULT_FLAGS \

(FUNCTION_DEFAULT_FLAGS | FPROFILE_DEFAULT_FLAGS | \

TRACE_ITER(PRINT_PARENT) | TRACE_ITER(PRINTK) | \

TRACE_ITER(ANNOTATE) | TRACE_ITER(CONTEXT_INFO) | \

TRACE_ITER(RECORD_CMD) | TRACE_ITER(OVERWRITE) | \

TRACE_ITER(IRQ_INFO) | TRACE_ITER(MARKERS) | \

TRACE_ITER(HASH_PTR) | TRACE_ITER(TRACE_PRINTK) | \

TRACE_ITER(COPY_MARKER))

/* trace_options that are only supported by global_trace */

#define TOP_LEVEL_TRACE_FLAGS (TRACE_ITER(PRINTK) | \

TRACE_ITER(PRINTK_MSGONLY) | TRACE_ITER(RECORD_CMD) | \

TRACE_ITER(PROF_TEXT_OFFSET) | FPROFILE_DEFAULT_FLAGS)

/* trace_flags that are default zero for instances */

#define ZEROED_TRACE_FLAGS \

(TRACE_ITER(EVENT_FORK) | TRACE_ITER(FUNC_FORK) | TRACE_ITER(TRACE_PRINTK) | \

TRACE_ITER(COPY_MARKER))

/*

* The global_trace is the descriptor that holds the top-level tracing

* buffers for the live tracing.

*/

static struct trace_array global_trace = {

.trace_flags = TRACE_DEFAULT_FLAGS,

};

struct trace_array *printk_trace = &global_trace;

/* List of trace_arrays interested in the top level trace_marker */

static LIST_HEAD(marker_copies);

static void update_printk_trace(struct trace_array *tr)

{

if (printk_trace == tr)

return;

printk_trace->trace_flags &= ~TRACE_ITER(TRACE_PRINTK);

printk_trace = tr;

tr->trace_flags |= TRACE_ITER(TRACE_PRINTK);

}

/* Returns true if the status of tr changed */

static bool update_marker_trace(struct trace_array *tr, int enabled)

{

lockdep_assert_held(&event_mutex);

if (enabled) {

if (tr->trace_flags & TRACE_ITER(COPY_MARKER))

return false;

list_add_rcu(&tr->marker_list, &marker_copies);

tr->trace_flags |= TRACE_ITER(COPY_MARKER);

return true;

}

if (!(tr->trace_flags & TRACE_ITER(COPY_MARKER)))

return false;

list_del_rcu(&tr->marker_list);

tr->trace_flags &= ~TRACE_ITER(COPY_MARKER);

return true;

}

void trace_set_ring_buffer_expanded(struct trace_array *tr)

{

if (!tr)

tr = &global_trace;

tr->ring_buffer_expanded = true;

}

static void trace_array_autoremove(struct work_struct *work)

{

struct trace_array *tr = container_of(work, struct trace_array, autoremove_work);

trace_array_destroy(tr);

}

static struct workqueue_struct *autoremove_wq;

static void trace_array_kick_autoremove(struct trace_array *tr)

{

if (autoremove_wq)

queue_work(autoremove_wq, &tr->autoremove_work);

}

static void trace_array_cancel_autoremove(struct trace_array *tr)

{

/*

* Since this can be called inside trace_array_autoremove(),

* it has to avoid deadlock of the workqueue.

*/

if (work_pending(&tr->autoremove_work))

cancel_work_sync(&tr->autoremove_work);

}

static void trace_array_init_autoremove(struct trace_array *tr)

{

INIT_WORK(&tr->autoremove_work, trace_array_autoremove);

}

static void trace_array_start_autoremove(void)

{

if (autoremove_wq)

return;

autoremove_wq = alloc_workqueue("tr_autoremove_wq",

WQ_UNBOUND | WQ_HIGHPRI, 0);

if (!autoremove_wq)

pr_warn("Unable to allocate tr_autoremove_wq. autoremove disabled.\n");

}

LIST_HEAD(ftrace_trace_arrays);

static int __trace_array_get(struct trace_array *this_tr)

{

/* When free_on_close is set, this is not available anymore. */

if (autoremove_wq && this_tr->free_on_close)

return -ENODEV;

this_tr->ref++;

return 0;

}

int trace_array_get(struct trace_array *this_tr)

{

struct trace_array *tr;

guard(mutex)(&trace_types_lock);

list_for_each_entry(tr, &ftrace_trace_arrays, list) {

if (tr == this_tr) {

return __trace_array_get(tr);

}

}

return -ENODEV;

}

static void __trace_array_put(struct trace_array *this_tr)

{

WARN_ON(!this_tr->ref);

this_tr->ref--;

/*

* When free_on_close is set, prepare removing the array

* when the last reference is released.

*/

if (this_tr->ref == 1 && this_tr->free_on_close)

trace_array_kick_autoremove(this_tr);

}

/**

* trace_array_put - Decrement the reference counter for this trace array.

* @this_tr : pointer to the trace array

*

* NOTE: Use this when we no longer need the trace array returned by

* trace_array_get_by_name(). This ensures the trace array can be later

* destroyed.

*

*/

void trace_array_put(struct trace_array *this_tr)

{

if (!this_tr)

return;

guard(mutex)(&trace_types_lock);

__trace_array_put(this_tr);

}

EXPORT_SYMBOL_GPL(trace_array_put);

int tracing_check_open_get_tr(struct trace_array *tr)

{

int ret;

ret = security_locked_down(LOCKDOWN_TRACEFS);

if (ret)

return ret;

if (tracing_disabled)

return -ENODEV;

if (tr && trace_array_get(tr) < 0)

return -ENODEV;

return 0;

}

static u64 buffer_ftrace_now(struct array_buffer *buf, int cpu)

{

u64 ts;

/* Early boot up does not have a buffer yet */

if (!buf->buffer)

return trace_clock_local();

ts = ring_buffer_time_stamp(buf->buffer);

ring_buffer_normalize_time_stamp(buf->buffer, cpu, &ts);

return ts;

}

u64 ftrace_now(int cpu)

{

return buffer_ftrace_now(&global_trace.array_buffer, cpu);

}

/**

* tracing_is_enabled - Show if global_trace has been enabled

*

* Shows if the global trace has been enabled or not. It uses the

* mirror flag "buffer_disabled" to be used in fast paths such as for

* the irqsoff tracer. But it may be inaccurate due to races. If you

* need to know the accurate state, use tracing_is_on() which is a little

* slower, but accurate.

*/

int tracing_is_enabled(void)

{

/*

* For quick access (irqsoff uses this in fast path), just

* return the mirror variable of the state of the ring buffer.

* It's a little racy, but we don't really care.

*/

return !global_trace.buffer_disabled;

}

/*

* trace_buf_size is the size in bytes that is allocated

* for a buffer. Note, the number of bytes is always rounded

* to page size.

*

* This number is purposely set to a low number of 16384.

* If the dump on oops happens, it will be much appreciated

* to not have to wait for all that output. Anyway this can be

* boot time and run time configurable.

*/

#define TRACE_BUF_SIZE_DEFAULT 1441792UL /* 16384 * 88 (sizeof(entry)) */

static unsigned long trace_buf_size = TRACE_BUF_SIZE_DEFAULT;

/* trace_types holds a link list of available tracers. */

static struct tracer *trace_types __read_mostly;

/*

* trace_types_lock is used to protect the trace_types list.

*/

DEFINE_MUTEX(trace_types_lock);

/*

* serialize the access of the ring buffer

*

* ring buffer serializes readers, but it is low level protection.

* The validity of the events (which returns by ring_buffer_peek() ..etc)

* are not protected by ring buffer.

*

* The content of events may become garbage if we allow other process consumes

* these events concurrently:

* A) the page of the consumed events may become a normal page

* (not reader page) in ring buffer, and this page will be rewritten

* by events producer.

* B) The page of the consumed events may become a page for splice_read,

* and this page will be returned to system.

*

* These primitives allow multi process access to different cpu ring buffer

* concurrently.

*

* These primitives don't distinguish read-only and read-consume access.

* Multi read-only access are also serialized.

*/

#ifdef CONFIG_SMP

static DECLARE_RWSEM(all_cpu_access_lock);

static DEFINE_PER_CPU(struct mutex, cpu_access_lock);

static inline void trace_access_lock(int cpu)

{

if (cpu == RING_BUFFER_ALL_CPUS) {

/* gain it for accessing the whole ring buffer. */

down_write(&all_cpu_access_lock);

} else {

/* gain it for accessing a cpu ring buffer. */

/* Firstly block other trace_access_lock(RING_BUFFER_ALL_CPUS). */

down_read(&all_cpu_access_lock);

/* Secondly block other access to this @cpu ring buffer. */

mutex_lock(&per_cpu(cpu_access_lock, cpu));

}

}

static inline void trace_access_unlock(int cpu)

{

if (cpu == RING_BUFFER_ALL_CPUS) {

up_write(&all_cpu_access_lock);

} else {

mutex_unlock(&per_cpu(cpu_access_lock, cpu));

up_read(&all_cpu_access_lock);

}

}

static inline void trace_access_lock_init(void)

{

int cpu;

for_each_possible_cpu(cpu)

mutex_init(&per_cpu(cpu_access_lock, cpu));

}

#else

static DEFINE_MUTEX(access_lock);

static inline void trace_access_lock(int cpu)

{

(void)cpu;

mutex_lock(&access_lock);

}

static inline void trace_access_unlock(int cpu)

{

(void)cpu;

mutex_unlock(&access_lock);

}

static inline void trace_access_lock_init(void)

{

}

#endif

void tracer_tracing_on(struct trace_array *tr)

{

if (tr->array_buffer.buffer)

ring_buffer_record_on(tr->array_buffer.buffer);

/*

* This flag is looked at when buffers haven't been allocated

* yet, or by some tracers (like irqsoff), that just want to

* know if the ring buffer has been disabled, but it can handle

* races of where it gets disabled but we still do a record.

* As the check is in the fast path of the tracers, it is more

* important to be fast than accurate.

*/

tr->buffer_disabled = 0;

}

/**

* tracing_on - enable tracing buffers

*

* This function enables tracing buffers that may have been

* disabled with tracing_off.

*/

void tracing_on(void)

{

tracer_tracing_on(&global_trace);

}

EXPORT_SYMBOL_GPL(tracing_on);

#ifdef CONFIG_TRACER_SNAPSHOT

/**

* tracing_snapshot - take a snapshot of the current buffer.

*

* This causes a swap between the snapshot buffer and the current live

* tracing buffer. You can use this to take snapshots of the live

* trace when some condition is triggered, but continue to trace.

*

* Note, make sure to allocate the snapshot with either

* a tracing_snapshot_alloc(), or by doing it manually

* with: echo 1 > /sys/kernel/tracing/snapshot

*

* If the snapshot buffer is not allocated, it will stop tracing.

* Basically making a permanent snapshot.

*/

void tracing_snapshot(void)

{

struct trace_array *tr = &global_trace;

tracing_snapshot_instance(tr);

}

EXPORT_SYMBOL_GPL(tracing_snapshot);

/**

* tracing_alloc_snapshot - allocate snapshot buffer.

*

* This only allocates the snapshot buffer if it isn't already

* allocated - it doesn't also take a snapshot.

*

* This is meant to be used in cases where the snapshot buffer needs

* to be set up for events that can't sleep but need to be able to

* trigger a snapshot.

*/

int tracing_alloc_snapshot(void)

{

struct trace_array *tr = &global_trace;

int ret;

ret = tracing_alloc_snapshot_instance(tr);

WARN_ON(ret < 0);

return ret;

}

#else

void tracing_snapshot(void)

{

WARN_ONCE(1, "Snapshot feature not enabled, but internal snapshot used");

}

EXPORT_SYMBOL_GPL(tracing_snapshot);

void tracing_snapshot_alloc(void)

{

/* Give warning */

tracing_snapshot();

}

EXPORT_SYMBOL_GPL(tracing_snapshot_alloc);

#endif /* CONFIG_TRACER_SNAPSHOT */

void tracer_tracing_off(struct trace_array *tr)

{

if (tr->array_buffer.buffer)

ring_buffer_record_off(tr->array_buffer.buffer);

/*

* This flag is looked at when buffers haven't been allocated

* yet, or by some tracers (like irqsoff), that just want to

* know if the ring buffer has been disabled, but it can handle

* races of where it gets disabled but we still do a record.

* As the check is in the fast path of the tracers, it is more

* important to be fast than accurate.

*/

tr->buffer_disabled = 1;

}

/**

* tracer_tracing_disable() - temporary disable the buffer from write

* @tr: The trace array to disable its buffer for

*

* Expects trace_tracing_enable() to re-enable tracing.

* The difference between this and tracer_tracing_off() is that this

* is a counter and can nest, whereas, tracer_tracing_off() can

* be called multiple times and a single trace_tracing_on() will

* enable it.

*/

void tracer_tracing_disable(struct trace_array *tr)

{

if (WARN_ON_ONCE(!tr->array_buffer.buffer))

return;

ring_buffer_record_disable(tr->array_buffer.buffer);

}

/**

* tracer_tracing_enable() - counter part of tracer_tracing_disable()

* @tr: The trace array that had tracer_tracincg_disable() called on it

*

* This is called after tracer_tracing_disable() has been called on @tr,

* when it's safe to re-enable tracing.

*/

void tracer_tracing_enable(struct trace_array *tr)

{

if (WARN_ON_ONCE(!tr->array_buffer.buffer))

return;

ring_buffer_record_enable(tr->array_buffer.buffer);

}

/**

* tracing_off - turn off tracing buffers

*

* This function stops the tracing buffers from recording data.

* It does not disable any overhead the tracers themselves may

* be causing. This function simply causes all recording to

* the ring buffers to fail.

*/

void tracing_off(void)

{

tracer_tracing_off(&global_trace);

}

EXPORT_SYMBOL_GPL(tracing_off);

void disable_trace_on_warning(void)

{

if (__disable_trace_on_warning) {

struct trace_array *tr = READ_ONCE(printk_trace);

trace_array_printk_buf(global_trace.array_buffer.buffer, _THIS_IP_,

"Disabling tracing due to warning\n");

tracing_off();

/* Disable trace_printk() buffer too */

if (tr != &global_trace) {

trace_array_printk_buf(tr->array_buffer.buffer, _THIS_IP_,

"Disabling tracing due to warning\n");

tracer_tracing_off(tr);

}

}

}

/**

* tracer_tracing_is_on - show real state of ring buffer enabled

* @tr : the trace array to know if ring buffer is enabled

*

* Shows real state of the ring buffer if it is enabled or not.

*/

bool tracer_tracing_is_on(struct trace_array *tr)

{

if (tr->array_buffer.buffer)