![Linus Torvalds](/assets/img/avatar_default.png)
Pull networking updates from David Miller: 1) Add Maglev hashing scheduler to IPVS, from Inju Song. 2) Lots of new TC subsystem tests from Roman Mashak. 3) Add TCP zero copy receive and fix delayed acks and autotuning with SO_RCVLOWAT, from Eric Dumazet. 4) Add XDP_REDIRECT support to mlx5 driver, from Jesper Dangaard Brouer. 5) Add ttl inherit support to vxlan, from Hangbin Liu. 6) Properly separate ipv6 routes into their logically independant components. fib6_info for the routing table, and fib6_nh for sets of nexthops, which thus can be shared. From David Ahern. 7) Add bpf_xdp_adjust_tail helper, which can be used to generate ICMP messages from XDP programs. From Nikita V. Shirokov. 8) Lots of long overdue cleanups to the r8169 driver, from Heiner Kallweit. 9) Add BTF ("BPF Type Format"), from Martin KaFai Lau. 10) Add traffic condition monitoring to iwlwifi, from Luca Coelho. 11) Plumb extack down into fib_rules, from Roopa Prabhu. 12) Add Flower classifier offload support to igb, from Vinicius Costa Gomes. 13) Add UDP GSO support, from Willem de Bruijn. 14) Add documentation for eBPF helpers, from Quentin Monnet. 15) Add TLS tx offload to mlx5, from Ilya Lesokhin. 16) Allow applications to be given the number of bytes available to read on a socket via a control message returned from recvmsg(), from Soheil Hassas Yeganeh. 17) Add x86_32 eBPF JIT compiler, from Wang YanQing. 18) Add AF_XDP sockets, with zerocopy support infrastructure as well. From Björn Töpel. 19) Remove indirect load support from all of the BPF JITs and handle these operations in the verifier by translating them into native BPF instead. From Daniel Borkmann. 20) Add GRO support to ipv6 gre tunnels, from Eran Ben Elisha. 21) Allow XDP programs to do lookups in the main kernel routing tables for forwarding. From David Ahern. 22) Allow drivers to store hardware state into an ELF section of kernel dump vmcore files, and use it in cxgb4. From Rahul Lakkireddy. 23) Various RACK and loss detection improvements in TCP, from Yuchung Cheng. 24) Add TCP SACK compression, from Eric Dumazet. 25) Add User Mode Helper support and basic bpfilter infrastructure, from Alexei Starovoitov. 26) Support ports and protocol values in RTM_GETROUTE, from Roopa Prabhu. 27) Support bulking in ->ndo_xdp_xmit() API, from Jesper Dangaard Brouer. 28) Add lots of forwarding selftests, from Petr Machata. 29) Add generic network device failover driver, from Sridhar Samudrala. * ra.kernel.org:/pub/scm/linux/kernel/git/davem/net-next: (1959 commits) strparser: Add __strp_unpause and use it in ktls. rxrpc: Fix terminal retransmission connection ID to include the channel net: hns3: Optimize PF CMDQ interrupt switching process net: hns3: Fix for VF mailbox receiving unknown message net: hns3: Fix for VF mailbox cannot receiving PF response bnx2x: use the right constant Revert "net: sched: cls: Fix offloading when ingress dev is vxlan" net: dsa: b53: Fix for brcm tag issue in Cygnus SoC enic: fix UDP rss bits netdev-FAQ: clarify DaveM's position for stable backports rtnetlink: validate attributes in do_setlink() mlxsw: Add extack messages for port_{un, }split failures netdevsim: Add extack error message for devlink reload devlink: Add extack to reload and port_{un, }split operations net: metrics: add proper netlink validation ipmr: fix error path when ipmr_new_table fails ip6mr: only set ip6mr_table from setsockopt when ip6mr_new_table succeeds net: hns3: remove unused hclgevf_cfg_func_mta_filter netfilter: provide udp*_lib_lookup for nf_tproxy qed*: Utilize FW 8.37.2.0 ...
633 lines
20 KiB
C
633 lines
20 KiB
C
/* SPDX-License-Identifier: GPL-2.0 */
|
|
|
|
#ifndef _LINUX_TRACE_EVENT_H
|
|
#define _LINUX_TRACE_EVENT_H
|
|
|
|
#include <linux/ring_buffer.h>
|
|
#include <linux/trace_seq.h>
|
|
#include <linux/percpu.h>
|
|
#include <linux/hardirq.h>
|
|
#include <linux/perf_event.h>
|
|
#include <linux/tracepoint.h>
|
|
|
|
struct trace_array;
|
|
struct trace_buffer;
|
|
struct tracer;
|
|
struct dentry;
|
|
struct bpf_prog;
|
|
|
|
const char *trace_print_flags_seq(struct trace_seq *p, const char *delim,
|
|
unsigned long flags,
|
|
const struct trace_print_flags *flag_array);
|
|
|
|
const char *trace_print_symbols_seq(struct trace_seq *p, unsigned long val,
|
|
const struct trace_print_flags *symbol_array);
|
|
|
|
#if BITS_PER_LONG == 32
|
|
const char *trace_print_flags_seq_u64(struct trace_seq *p, const char *delim,
|
|
unsigned long long flags,
|
|
const struct trace_print_flags_u64 *flag_array);
|
|
|
|
const char *trace_print_symbols_seq_u64(struct trace_seq *p,
|
|
unsigned long long val,
|
|
const struct trace_print_flags_u64
|
|
*symbol_array);
|
|
#endif
|
|
|
|
const char *trace_print_bitmask_seq(struct trace_seq *p, void *bitmask_ptr,
|
|
unsigned int bitmask_size);
|
|
|
|
const char *trace_print_hex_seq(struct trace_seq *p,
|
|
const unsigned char *buf, int len,
|
|
bool concatenate);
|
|
|
|
const char *trace_print_array_seq(struct trace_seq *p,
|
|
const void *buf, int count,
|
|
size_t el_size);
|
|
|
|
struct trace_iterator;
|
|
struct trace_event;
|
|
|
|
int trace_raw_output_prep(struct trace_iterator *iter,
|
|
struct trace_event *event);
|
|
|
|
/*
|
|
* The trace entry - the most basic unit of tracing. This is what
|
|
* is printed in the end as a single line in the trace output, such as:
|
|
*
|
|
* bash-15816 [01] 235.197585: idle_cpu <- irq_enter
|
|
*/
|
|
struct trace_entry {
|
|
unsigned short type;
|
|
unsigned char flags;
|
|
unsigned char preempt_count;
|
|
int pid;
|
|
};
|
|
|
|
#define TRACE_EVENT_TYPE_MAX \
|
|
((1 << (sizeof(((struct trace_entry *)0)->type) * 8)) - 1)
|
|
|
|
/*
|
|
* Trace iterator - used by printout routines who present trace
|
|
* results to users and which routines might sleep, etc:
|
|
*/
|
|
struct trace_iterator {
|
|
struct trace_array *tr;
|
|
struct tracer *trace;
|
|
struct trace_buffer *trace_buffer;
|
|
void *private;
|
|
int cpu_file;
|
|
struct mutex mutex;
|
|
struct ring_buffer_iter **buffer_iter;
|
|
unsigned long iter_flags;
|
|
|
|
/* trace_seq for __print_flags() and __print_symbolic() etc. */
|
|
struct trace_seq tmp_seq;
|
|
|
|
cpumask_var_t started;
|
|
|
|
/* it's true when current open file is snapshot */
|
|
bool snapshot;
|
|
|
|
/* The below is zeroed out in pipe_read */
|
|
struct trace_seq seq;
|
|
struct trace_entry *ent;
|
|
unsigned long lost_events;
|
|
int leftover;
|
|
int ent_size;
|
|
int cpu;
|
|
u64 ts;
|
|
|
|
loff_t pos;
|
|
long idx;
|
|
|
|
/* All new field here will be zeroed out in pipe_read */
|
|
};
|
|
|
|
enum trace_iter_flags {
|
|
TRACE_FILE_LAT_FMT = 1,
|
|
TRACE_FILE_ANNOTATE = 2,
|
|
TRACE_FILE_TIME_IN_NS = 4,
|
|
};
|
|
|
|
|
|
typedef enum print_line_t (*trace_print_func)(struct trace_iterator *iter,
|
|
int flags, struct trace_event *event);
|
|
|
|
struct trace_event_functions {
|
|
trace_print_func trace;
|
|
trace_print_func raw;
|
|
trace_print_func hex;
|
|
trace_print_func binary;
|
|
};
|
|
|
|
struct trace_event {
|
|
struct hlist_node node;
|
|
struct list_head list;
|
|
int type;
|
|
struct trace_event_functions *funcs;
|
|
};
|
|
|
|
extern int register_trace_event(struct trace_event *event);
|
|
extern int unregister_trace_event(struct trace_event *event);
|
|
|
|
/* Return values for print_line callback */
|
|
enum print_line_t {
|
|
TRACE_TYPE_PARTIAL_LINE = 0, /* Retry after flushing the seq */
|
|
TRACE_TYPE_HANDLED = 1,
|
|
TRACE_TYPE_UNHANDLED = 2, /* Relay to other output functions */
|
|
TRACE_TYPE_NO_CONSUME = 3 /* Handled but ask to not consume */
|
|
};
|
|
|
|
enum print_line_t trace_handle_return(struct trace_seq *s);
|
|
|
|
void tracing_generic_entry_update(struct trace_entry *entry,
|
|
unsigned long flags,
|
|
int pc);
|
|
struct trace_event_file;
|
|
|
|
struct ring_buffer_event *
|
|
trace_event_buffer_lock_reserve(struct ring_buffer **current_buffer,
|
|
struct trace_event_file *trace_file,
|
|
int type, unsigned long len,
|
|
unsigned long flags, int pc);
|
|
|
|
#define TRACE_RECORD_CMDLINE BIT(0)
|
|
#define TRACE_RECORD_TGID BIT(1)
|
|
|
|
void tracing_record_taskinfo(struct task_struct *task, int flags);
|
|
void tracing_record_taskinfo_sched_switch(struct task_struct *prev,
|
|
struct task_struct *next, int flags);
|
|
|
|
void tracing_record_cmdline(struct task_struct *task);
|
|
void tracing_record_tgid(struct task_struct *task);
|
|
|
|
int trace_output_call(struct trace_iterator *iter, char *name, char *fmt, ...);
|
|
|
|
struct event_filter;
|
|
|
|
enum trace_reg {
|
|
TRACE_REG_REGISTER,
|
|
TRACE_REG_UNREGISTER,
|
|
#ifdef CONFIG_PERF_EVENTS
|
|
TRACE_REG_PERF_REGISTER,
|
|
TRACE_REG_PERF_UNREGISTER,
|
|
TRACE_REG_PERF_OPEN,
|
|
TRACE_REG_PERF_CLOSE,
|
|
/*
|
|
* These (ADD/DEL) use a 'boolean' return value, where 1 (true) means a
|
|
* custom action was taken and the default action is not to be
|
|
* performed.
|
|
*/
|
|
TRACE_REG_PERF_ADD,
|
|
TRACE_REG_PERF_DEL,
|
|
#endif
|
|
};
|
|
|
|
struct trace_event_call;
|
|
|
|
struct trace_event_class {
|
|
const char *system;
|
|
void *probe;
|
|
#ifdef CONFIG_PERF_EVENTS
|
|
void *perf_probe;
|
|
#endif
|
|
int (*reg)(struct trace_event_call *event,
|
|
enum trace_reg type, void *data);
|
|
int (*define_fields)(struct trace_event_call *);
|
|
struct list_head *(*get_fields)(struct trace_event_call *);
|
|
struct list_head fields;
|
|
int (*raw_init)(struct trace_event_call *);
|
|
};
|
|
|
|
extern int trace_event_reg(struct trace_event_call *event,
|
|
enum trace_reg type, void *data);
|
|
|
|
struct trace_event_buffer {
|
|
struct ring_buffer *buffer;
|
|
struct ring_buffer_event *event;
|
|
struct trace_event_file *trace_file;
|
|
void *entry;
|
|
unsigned long flags;
|
|
int pc;
|
|
};
|
|
|
|
void *trace_event_buffer_reserve(struct trace_event_buffer *fbuffer,
|
|
struct trace_event_file *trace_file,
|
|
unsigned long len);
|
|
|
|
void trace_event_buffer_commit(struct trace_event_buffer *fbuffer);
|
|
|
|
enum {
|
|
TRACE_EVENT_FL_FILTERED_BIT,
|
|
TRACE_EVENT_FL_CAP_ANY_BIT,
|
|
TRACE_EVENT_FL_NO_SET_FILTER_BIT,
|
|
TRACE_EVENT_FL_IGNORE_ENABLE_BIT,
|
|
TRACE_EVENT_FL_TRACEPOINT_BIT,
|
|
TRACE_EVENT_FL_KPROBE_BIT,
|
|
TRACE_EVENT_FL_UPROBE_BIT,
|
|
};
|
|
|
|
/*
|
|
* Event flags:
|
|
* FILTERED - The event has a filter attached
|
|
* CAP_ANY - Any user can enable for perf
|
|
* NO_SET_FILTER - Set when filter has error and is to be ignored
|
|
* IGNORE_ENABLE - For trace internal events, do not enable with debugfs file
|
|
* TRACEPOINT - Event is a tracepoint
|
|
* KPROBE - Event is a kprobe
|
|
* UPROBE - Event is a uprobe
|
|
*/
|
|
enum {
|
|
TRACE_EVENT_FL_FILTERED = (1 << TRACE_EVENT_FL_FILTERED_BIT),
|
|
TRACE_EVENT_FL_CAP_ANY = (1 << TRACE_EVENT_FL_CAP_ANY_BIT),
|
|
TRACE_EVENT_FL_NO_SET_FILTER = (1 << TRACE_EVENT_FL_NO_SET_FILTER_BIT),
|
|
TRACE_EVENT_FL_IGNORE_ENABLE = (1 << TRACE_EVENT_FL_IGNORE_ENABLE_BIT),
|
|
TRACE_EVENT_FL_TRACEPOINT = (1 << TRACE_EVENT_FL_TRACEPOINT_BIT),
|
|
TRACE_EVENT_FL_KPROBE = (1 << TRACE_EVENT_FL_KPROBE_BIT),
|
|
TRACE_EVENT_FL_UPROBE = (1 << TRACE_EVENT_FL_UPROBE_BIT),
|
|
};
|
|
|
|
#define TRACE_EVENT_FL_UKPROBE (TRACE_EVENT_FL_KPROBE | TRACE_EVENT_FL_UPROBE)
|
|
|
|
struct trace_event_call {
|
|
struct list_head list;
|
|
struct trace_event_class *class;
|
|
union {
|
|
char *name;
|
|
/* Set TRACE_EVENT_FL_TRACEPOINT flag when using "tp" */
|
|
struct tracepoint *tp;
|
|
};
|
|
struct trace_event event;
|
|
char *print_fmt;
|
|
struct event_filter *filter;
|
|
void *mod;
|
|
void *data;
|
|
/*
|
|
* bit 0: filter_active
|
|
* bit 1: allow trace by non root (cap any)
|
|
* bit 2: failed to apply filter
|
|
* bit 3: trace internal event (do not enable)
|
|
* bit 4: Event was enabled by module
|
|
* bit 5: use call filter rather than file filter
|
|
* bit 6: Event is a tracepoint
|
|
*/
|
|
int flags; /* static flags of different events */
|
|
|
|
#ifdef CONFIG_PERF_EVENTS
|
|
int perf_refcount;
|
|
struct hlist_head __percpu *perf_events;
|
|
struct bpf_prog_array __rcu *prog_array;
|
|
|
|
int (*perf_perm)(struct trace_event_call *,
|
|
struct perf_event *);
|
|
#endif
|
|
};
|
|
|
|
#ifdef CONFIG_PERF_EVENTS
|
|
static inline bool bpf_prog_array_valid(struct trace_event_call *call)
|
|
{
|
|
/*
|
|
* This inline function checks whether call->prog_array
|
|
* is valid or not. The function is called in various places,
|
|
* outside rcu_read_lock/unlock, as a heuristic to speed up execution.
|
|
*
|
|
* If this function returns true, and later call->prog_array
|
|
* becomes false inside rcu_read_lock/unlock region,
|
|
* we bail out then. If this function return false,
|
|
* there is a risk that we might miss a few events if the checking
|
|
* were delayed until inside rcu_read_lock/unlock region and
|
|
* call->prog_array happened to become non-NULL then.
|
|
*
|
|
* Here, READ_ONCE() is used instead of rcu_access_pointer().
|
|
* rcu_access_pointer() requires the actual definition of
|
|
* "struct bpf_prog_array" while READ_ONCE() only needs
|
|
* a declaration of the same type.
|
|
*/
|
|
return !!READ_ONCE(call->prog_array);
|
|
}
|
|
#endif
|
|
|
|
static inline const char *
|
|
trace_event_name(struct trace_event_call *call)
|
|
{
|
|
if (call->flags & TRACE_EVENT_FL_TRACEPOINT)
|
|
return call->tp ? call->tp->name : NULL;
|
|
else
|
|
return call->name;
|
|
}
|
|
|
|
struct trace_array;
|
|
struct trace_subsystem_dir;
|
|
|
|
enum {
|
|
EVENT_FILE_FL_ENABLED_BIT,
|
|
EVENT_FILE_FL_RECORDED_CMD_BIT,
|
|
EVENT_FILE_FL_RECORDED_TGID_BIT,
|
|
EVENT_FILE_FL_FILTERED_BIT,
|
|
EVENT_FILE_FL_NO_SET_FILTER_BIT,
|
|
EVENT_FILE_FL_SOFT_MODE_BIT,
|
|
EVENT_FILE_FL_SOFT_DISABLED_BIT,
|
|
EVENT_FILE_FL_TRIGGER_MODE_BIT,
|
|
EVENT_FILE_FL_TRIGGER_COND_BIT,
|
|
EVENT_FILE_FL_PID_FILTER_BIT,
|
|
EVENT_FILE_FL_WAS_ENABLED_BIT,
|
|
};
|
|
|
|
/*
|
|
* Event file flags:
|
|
* ENABLED - The event is enabled
|
|
* RECORDED_CMD - The comms should be recorded at sched_switch
|
|
* RECORDED_TGID - The tgids should be recorded at sched_switch
|
|
* FILTERED - The event has a filter attached
|
|
* NO_SET_FILTER - Set when filter has error and is to be ignored
|
|
* SOFT_MODE - The event is enabled/disabled by SOFT_DISABLED
|
|
* SOFT_DISABLED - When set, do not trace the event (even though its
|
|
* tracepoint may be enabled)
|
|
* TRIGGER_MODE - When set, invoke the triggers associated with the event
|
|
* TRIGGER_COND - When set, one or more triggers has an associated filter
|
|
* PID_FILTER - When set, the event is filtered based on pid
|
|
* WAS_ENABLED - Set when enabled to know to clear trace on module removal
|
|
*/
|
|
enum {
|
|
EVENT_FILE_FL_ENABLED = (1 << EVENT_FILE_FL_ENABLED_BIT),
|
|
EVENT_FILE_FL_RECORDED_CMD = (1 << EVENT_FILE_FL_RECORDED_CMD_BIT),
|
|
EVENT_FILE_FL_RECORDED_TGID = (1 << EVENT_FILE_FL_RECORDED_TGID_BIT),
|
|
EVENT_FILE_FL_FILTERED = (1 << EVENT_FILE_FL_FILTERED_BIT),
|
|
EVENT_FILE_FL_NO_SET_FILTER = (1 << EVENT_FILE_FL_NO_SET_FILTER_BIT),
|
|
EVENT_FILE_FL_SOFT_MODE = (1 << EVENT_FILE_FL_SOFT_MODE_BIT),
|
|
EVENT_FILE_FL_SOFT_DISABLED = (1 << EVENT_FILE_FL_SOFT_DISABLED_BIT),
|
|
EVENT_FILE_FL_TRIGGER_MODE = (1 << EVENT_FILE_FL_TRIGGER_MODE_BIT),
|
|
EVENT_FILE_FL_TRIGGER_COND = (1 << EVENT_FILE_FL_TRIGGER_COND_BIT),
|
|
EVENT_FILE_FL_PID_FILTER = (1 << EVENT_FILE_FL_PID_FILTER_BIT),
|
|
EVENT_FILE_FL_WAS_ENABLED = (1 << EVENT_FILE_FL_WAS_ENABLED_BIT),
|
|
};
|
|
|
|
struct trace_event_file {
|
|
struct list_head list;
|
|
struct trace_event_call *event_call;
|
|
struct event_filter __rcu *filter;
|
|
struct dentry *dir;
|
|
struct trace_array *tr;
|
|
struct trace_subsystem_dir *system;
|
|
struct list_head triggers;
|
|
|
|
/*
|
|
* 32 bit flags:
|
|
* bit 0: enabled
|
|
* bit 1: enabled cmd record
|
|
* bit 2: enable/disable with the soft disable bit
|
|
* bit 3: soft disabled
|
|
* bit 4: trigger enabled
|
|
*
|
|
* Note: The bits must be set atomically to prevent races
|
|
* from other writers. Reads of flags do not need to be in
|
|
* sync as they occur in critical sections. But the way flags
|
|
* is currently used, these changes do not affect the code
|
|
* except that when a change is made, it may have a slight
|
|
* delay in propagating the changes to other CPUs due to
|
|
* caching and such. Which is mostly OK ;-)
|
|
*/
|
|
unsigned long flags;
|
|
atomic_t sm_ref; /* soft-mode reference counter */
|
|
atomic_t tm_ref; /* trigger-mode reference counter */
|
|
};
|
|
|
|
#define __TRACE_EVENT_FLAGS(name, value) \
|
|
static int __init trace_init_flags_##name(void) \
|
|
{ \
|
|
event_##name.flags |= value; \
|
|
return 0; \
|
|
} \
|
|
early_initcall(trace_init_flags_##name);
|
|
|
|
#define __TRACE_EVENT_PERF_PERM(name, expr...) \
|
|
static int perf_perm_##name(struct trace_event_call *tp_event, \
|
|
struct perf_event *p_event) \
|
|
{ \
|
|
return ({ expr; }); \
|
|
} \
|
|
static int __init trace_init_perf_perm_##name(void) \
|
|
{ \
|
|
event_##name.perf_perm = &perf_perm_##name; \
|
|
return 0; \
|
|
} \
|
|
early_initcall(trace_init_perf_perm_##name);
|
|
|
|
#define PERF_MAX_TRACE_SIZE 2048
|
|
|
|
#define MAX_FILTER_STR_VAL 256 /* Should handle KSYM_SYMBOL_LEN */
|
|
|
|
enum event_trigger_type {
|
|
ETT_NONE = (0),
|
|
ETT_TRACE_ONOFF = (1 << 0),
|
|
ETT_SNAPSHOT = (1 << 1),
|
|
ETT_STACKTRACE = (1 << 2),
|
|
ETT_EVENT_ENABLE = (1 << 3),
|
|
ETT_EVENT_HIST = (1 << 4),
|
|
ETT_HIST_ENABLE = (1 << 5),
|
|
};
|
|
|
|
extern int filter_match_preds(struct event_filter *filter, void *rec);
|
|
|
|
extern enum event_trigger_type
|
|
event_triggers_call(struct trace_event_file *file, void *rec,
|
|
struct ring_buffer_event *event);
|
|
extern void
|
|
event_triggers_post_call(struct trace_event_file *file,
|
|
enum event_trigger_type tt);
|
|
|
|
bool trace_event_ignore_this_pid(struct trace_event_file *trace_file);
|
|
|
|
/**
|
|
* trace_trigger_soft_disabled - do triggers and test if soft disabled
|
|
* @file: The file pointer of the event to test
|
|
*
|
|
* If any triggers without filters are attached to this event, they
|
|
* will be called here. If the event is soft disabled and has no
|
|
* triggers that require testing the fields, it will return true,
|
|
* otherwise false.
|
|
*/
|
|
static inline bool
|
|
trace_trigger_soft_disabled(struct trace_event_file *file)
|
|
{
|
|
unsigned long eflags = file->flags;
|
|
|
|
if (!(eflags & EVENT_FILE_FL_TRIGGER_COND)) {
|
|
if (eflags & EVENT_FILE_FL_TRIGGER_MODE)
|
|
event_triggers_call(file, NULL, NULL);
|
|
if (eflags & EVENT_FILE_FL_SOFT_DISABLED)
|
|
return true;
|
|
if (eflags & EVENT_FILE_FL_PID_FILTER)
|
|
return trace_event_ignore_this_pid(file);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
#ifdef CONFIG_BPF_EVENTS
|
|
unsigned int trace_call_bpf(struct trace_event_call *call, void *ctx);
|
|
int perf_event_attach_bpf_prog(struct perf_event *event, struct bpf_prog *prog);
|
|
void perf_event_detach_bpf_prog(struct perf_event *event);
|
|
int perf_event_query_prog_array(struct perf_event *event, void __user *info);
|
|
int bpf_probe_register(struct bpf_raw_event_map *btp, struct bpf_prog *prog);
|
|
int bpf_probe_unregister(struct bpf_raw_event_map *btp, struct bpf_prog *prog);
|
|
struct bpf_raw_event_map *bpf_find_raw_tracepoint(const char *name);
|
|
int bpf_get_perf_event_info(const struct perf_event *event, u32 *prog_id,
|
|
u32 *fd_type, const char **buf,
|
|
u64 *probe_offset, u64 *probe_addr);
|
|
#else
|
|
static inline unsigned int trace_call_bpf(struct trace_event_call *call, void *ctx)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
static inline int
|
|
perf_event_attach_bpf_prog(struct perf_event *event, struct bpf_prog *prog)
|
|
{
|
|
return -EOPNOTSUPP;
|
|
}
|
|
|
|
static inline void perf_event_detach_bpf_prog(struct perf_event *event) { }
|
|
|
|
static inline int
|
|
perf_event_query_prog_array(struct perf_event *event, void __user *info)
|
|
{
|
|
return -EOPNOTSUPP;
|
|
}
|
|
static inline int bpf_probe_register(struct bpf_raw_event_map *btp, struct bpf_prog *p)
|
|
{
|
|
return -EOPNOTSUPP;
|
|
}
|
|
static inline int bpf_probe_unregister(struct bpf_raw_event_map *btp, struct bpf_prog *p)
|
|
{
|
|
return -EOPNOTSUPP;
|
|
}
|
|
static inline struct bpf_raw_event_map *bpf_find_raw_tracepoint(const char *name)
|
|
{
|
|
return NULL;
|
|
}
|
|
static inline int bpf_get_perf_event_info(const struct perf_event *event,
|
|
u32 *prog_id, u32 *fd_type,
|
|
const char **buf, u64 *probe_offset,
|
|
u64 *probe_addr)
|
|
{
|
|
return -EOPNOTSUPP;
|
|
}
|
|
#endif
|
|
|
|
enum {
|
|
FILTER_OTHER = 0,
|
|
FILTER_STATIC_STRING,
|
|
FILTER_DYN_STRING,
|
|
FILTER_PTR_STRING,
|
|
FILTER_TRACE_FN,
|
|
FILTER_COMM,
|
|
FILTER_CPU,
|
|
};
|
|
|
|
extern int trace_event_raw_init(struct trace_event_call *call);
|
|
extern int trace_define_field(struct trace_event_call *call, const char *type,
|
|
const char *name, int offset, int size,
|
|
int is_signed, int filter_type);
|
|
extern int trace_add_event_call(struct trace_event_call *call);
|
|
extern int trace_remove_event_call(struct trace_event_call *call);
|
|
extern int trace_event_get_offsets(struct trace_event_call *call);
|
|
|
|
#define is_signed_type(type) (((type)(-1)) < (type)1)
|
|
|
|
int trace_set_clr_event(const char *system, const char *event, int set);
|
|
|
|
/*
|
|
* The double __builtin_constant_p is because gcc will give us an error
|
|
* if we try to allocate the static variable to fmt if it is not a
|
|
* constant. Even with the outer if statement optimizing out.
|
|
*/
|
|
#define event_trace_printk(ip, fmt, args...) \
|
|
do { \
|
|
__trace_printk_check_format(fmt, ##args); \
|
|
tracing_record_cmdline(current); \
|
|
if (__builtin_constant_p(fmt)) { \
|
|
static const char *trace_printk_fmt \
|
|
__attribute__((section("__trace_printk_fmt"))) = \
|
|
__builtin_constant_p(fmt) ? fmt : NULL; \
|
|
\
|
|
__trace_bprintk(ip, trace_printk_fmt, ##args); \
|
|
} else \
|
|
__trace_printk(ip, fmt, ##args); \
|
|
} while (0)
|
|
|
|
#ifdef CONFIG_PERF_EVENTS
|
|
struct perf_event;
|
|
|
|
DECLARE_PER_CPU(struct pt_regs, perf_trace_regs);
|
|
DECLARE_PER_CPU(int, bpf_kprobe_override);
|
|
|
|
extern int perf_trace_init(struct perf_event *event);
|
|
extern void perf_trace_destroy(struct perf_event *event);
|
|
extern int perf_trace_add(struct perf_event *event, int flags);
|
|
extern void perf_trace_del(struct perf_event *event, int flags);
|
|
#ifdef CONFIG_KPROBE_EVENTS
|
|
extern int perf_kprobe_init(struct perf_event *event, bool is_retprobe);
|
|
extern void perf_kprobe_destroy(struct perf_event *event);
|
|
extern int bpf_get_kprobe_info(const struct perf_event *event,
|
|
u32 *fd_type, const char **symbol,
|
|
u64 *probe_offset, u64 *probe_addr,
|
|
bool perf_type_tracepoint);
|
|
#endif
|
|
#ifdef CONFIG_UPROBE_EVENTS
|
|
extern int perf_uprobe_init(struct perf_event *event, bool is_retprobe);
|
|
extern void perf_uprobe_destroy(struct perf_event *event);
|
|
extern int bpf_get_uprobe_info(const struct perf_event *event,
|
|
u32 *fd_type, const char **filename,
|
|
u64 *probe_offset, bool perf_type_tracepoint);
|
|
#endif
|
|
extern int ftrace_profile_set_filter(struct perf_event *event, int event_id,
|
|
char *filter_str);
|
|
extern void ftrace_profile_free_filter(struct perf_event *event);
|
|
void perf_trace_buf_update(void *record, u16 type);
|
|
void *perf_trace_buf_alloc(int size, struct pt_regs **regs, int *rctxp);
|
|
|
|
void bpf_trace_run1(struct bpf_prog *prog, u64 arg1);
|
|
void bpf_trace_run2(struct bpf_prog *prog, u64 arg1, u64 arg2);
|
|
void bpf_trace_run3(struct bpf_prog *prog, u64 arg1, u64 arg2,
|
|
u64 arg3);
|
|
void bpf_trace_run4(struct bpf_prog *prog, u64 arg1, u64 arg2,
|
|
u64 arg3, u64 arg4);
|
|
void bpf_trace_run5(struct bpf_prog *prog, u64 arg1, u64 arg2,
|
|
u64 arg3, u64 arg4, u64 arg5);
|
|
void bpf_trace_run6(struct bpf_prog *prog, u64 arg1, u64 arg2,
|
|
u64 arg3, u64 arg4, u64 arg5, u64 arg6);
|
|
void bpf_trace_run7(struct bpf_prog *prog, u64 arg1, u64 arg2,
|
|
u64 arg3, u64 arg4, u64 arg5, u64 arg6, u64 arg7);
|
|
void bpf_trace_run8(struct bpf_prog *prog, u64 arg1, u64 arg2,
|
|
u64 arg3, u64 arg4, u64 arg5, u64 arg6, u64 arg7,
|
|
u64 arg8);
|
|
void bpf_trace_run9(struct bpf_prog *prog, u64 arg1, u64 arg2,
|
|
u64 arg3, u64 arg4, u64 arg5, u64 arg6, u64 arg7,
|
|
u64 arg8, u64 arg9);
|
|
void bpf_trace_run10(struct bpf_prog *prog, u64 arg1, u64 arg2,
|
|
u64 arg3, u64 arg4, u64 arg5, u64 arg6, u64 arg7,
|
|
u64 arg8, u64 arg9, u64 arg10);
|
|
void bpf_trace_run11(struct bpf_prog *prog, u64 arg1, u64 arg2,
|
|
u64 arg3, u64 arg4, u64 arg5, u64 arg6, u64 arg7,
|
|
u64 arg8, u64 arg9, u64 arg10, u64 arg11);
|
|
void bpf_trace_run12(struct bpf_prog *prog, u64 arg1, u64 arg2,
|
|
u64 arg3, u64 arg4, u64 arg5, u64 arg6, u64 arg7,
|
|
u64 arg8, u64 arg9, u64 arg10, u64 arg11, u64 arg12);
|
|
void perf_trace_run_bpf_submit(void *raw_data, int size, int rctx,
|
|
struct trace_event_call *call, u64 count,
|
|
struct pt_regs *regs, struct hlist_head *head,
|
|
struct task_struct *task);
|
|
|
|
static inline void
|
|
perf_trace_buf_submit(void *raw_data, int size, int rctx, u16 type,
|
|
u64 count, struct pt_regs *regs, void *head,
|
|
struct task_struct *task)
|
|
{
|
|
perf_tp_event(type, count, raw_data, size, regs, head, rctx, task);
|
|
}
|
|
|
|
#endif
|
|
|
|
#endif /* _LINUX_TRACE_EVENT_H */
|