Commit 1bc19105 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'trace-v5.18' of git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux-trace 

Pull tracing updates from Steven Rostedt:

 - New user_events interface. User space can register an event with the
   kernel describing the format of the event. Then it will receive a
   byte in a page mapping that it can check against. A privileged task
   can then enable that event like any other event, which will change
   the mapped byte to true, telling the user space application to start
   writing the event to the tracing buffer.

 - Add new "ftrace_boot_snapshot" kernel command line parameter. When
   set, the tracing buffer will be saved in the snapshot buffer at boot
   up when the kernel hands things over to user space. This will keep
   the traces that happened at boot up available even if user space boot
   up has tracing as well.

 - Have TRACE_EVENT_ENUM() also update trace event field type
   descriptions. Thus if a static array defines its size with an enum,
   the user space trace event parsers can still know how to parse that
   array.

 - Add new TRACE_CUSTOM_EVENT() macro. This acts the same as the
   TRACE_EVENT() macro, but will attach to an existing tracepoint. This
   will make one tracepoint be able to trace different content and not
   be stuck at only what the original TRACE_EVENT() macro exports.

 - Fixes to tracing error logging.

 - Better saving of cmdlines to PIDs when tracing (use the wakeup events
   for mapping).

* tag 'trace-v5.18' of git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux-trace: (30 commits)
  tracing: Have type enum modifications copy the strings
  user_events: Add trace event call as root for low permission cases
  tracing/user_events: Use alloc_pages instead of kzalloc() for register pages
  tracing: Add snapshot at end of kernel boot up
  tracing: Have TRACE_DEFINE_ENUM affect trace event types as well
  tracing: Fix strncpy warning in trace_events_synth.c
  user_events: Prevent dyn_event delete racing with ioctl add/delete
  tracing: Add TRACE_CUSTOM_EVENT() macro
  tracing: Move the defines to create TRACE_EVENTS into their own files
  tracing: Add sample code for custom trace events
  tracing: Allow custom events to be added to the tracefs directory
  tracing: Fix last_cmd_set() string management in histogram code
  user_events: Fix potential uninitialized pointer while parsing field
  tracing: Fix allocation of last_cmd in last_cmd_set()
  user_events: Add documentation file
  user_events: Add sample code for typical usage
  user_events: Add self-test for validator boundaries
  user_events: Add self-test for perf_event integration
  user_events: Add self-test for dynamic_events integration
  user_events: Add self-test for ftrace integration
  ...
parents 20f463fb 795301d3

Documentation/admin-guide/kernel-parameters.txt

+8 −0
Original line number Diff line number Diff line
@@ -1465,6 +1465,14 @@ 
			as early as possible in order to facilitate early

			boot debugging.



	ftrace_boot_snapshot

			[FTRACE] On boot up, a snapshot will be taken of the

			ftrace ring buffer that can be read at:

			/sys/kernel/tracing/snapshot.

			This is useful if you need tracing information from kernel

			boot up that is likely to be overridden by user space

			start up functionality.



	ftrace_dump_on_oops[=orig_cpu]

			[FTRACE] will dump the trace buffers on oops.

			If no parameter is passed, ftrace will dump

Documentation/trace/index.rst

+1 −0
Original line number Diff line number Diff line
@@ -30,3 +30,4 @@ Linux Tracing Technologies 
   stm

   sys-t

   coresight/index

   user_events

Documentation/trace/user_events.rst

0 → 100644
+216 −0
Original line number Diff line number Diff line 
=========================================

user_events: User-based Event Tracing

=========================================



:Author: Beau Belgrave



Overview

--------

User based trace events allow user processes to create events and trace data

that can be viewed via existing tools, such as ftrace, perf and eBPF.

To enable this feature, build your kernel with CONFIG_USER_EVENTS=y.



Programs can view status of the events via

/sys/kernel/debug/tracing/user_events_status and can both register and write

data out via /sys/kernel/debug/tracing/user_events_data.



Programs can also use /sys/kernel/debug/tracing/dynamic_events to register and

delete user based events via the u: prefix. The format of the command to

dynamic_events is the same as the ioctl with the u: prefix applied.



Typically programs will register a set of events that they wish to expose to

tools that can read trace_events (such as ftrace and perf). The registration

process gives back two ints to the program for each event. The first int is the

status index. This index describes which byte in the

/sys/kernel/debug/tracing/user_events_status file represents this event. The

second int is the write index. This index describes the data when a write() or

writev() is called on the /sys/kernel/debug/tracing/user_events_data file.



The structures referenced in this document are contained with the

/include/uap/linux/user_events.h file in the source tree.



**NOTE:** *Both user_events_status and user_events_data are under the tracefs

filesystem and may be mounted at different paths than above.*



Registering

-----------

Registering within a user process is done via ioctl() out to the

/sys/kernel/debug/tracing/user_events_data file. The command to issue is

DIAG_IOCSREG.



This command takes a struct user_reg as an argument::



  struct user_reg {

        u32 size;

        u64 name_args;

        u32 status_index;

        u32 write_index;

  };



The struct user_reg requires two inputs, the first is the size of the structure

to ensure forward and backward compatibility. The second is the command string

to issue for registering. Upon success two outputs are set, the status index

and the write index.



User based events show up under tracefs like any other event under the

subsystem named "user_events". This means tools that wish to attach to the

events need to use /sys/kernel/debug/tracing/events/user_events/[name]/enable

or perf record -e user_events:[name] when attaching/recording.



**NOTE:** *The write_index returned is only valid for the FD that was used*



Command Format

^^^^^^^^^^^^^^

The command string format is as follows::



  name[:FLAG1[,FLAG2...]] [Field1[;Field2...]]



Supported Flags

^^^^^^^^^^^^^^^

**BPF_ITER** - EBPF programs attached to this event will get the raw iovec

struct instead of any data copies for max performance.



Field Format

^^^^^^^^^^^^

::



  type name [size]



Basic types are supported (__data_loc, u32, u64, int, char, char[20], etc).

User programs are encouraged to use clearly sized types like u32.



**NOTE:** *Long is not supported since size can vary between user and kernel.*



The size is only valid for types that start with a struct prefix.

This allows user programs to describe custom structs out to tools, if required.



For example, a struct in C that looks like this::



  struct mytype {

    char data[20];

  };



Would be represented by the following field::



  struct mytype myname 20



Deleting

-----------

Deleting an event from within a user process is done via ioctl() out to the

/sys/kernel/debug/tracing/user_events_data file. The command to issue is

DIAG_IOCSDEL.



This command only requires a single string specifying the event to delete by

its name. Delete will only succeed if there are no references left to the

event (in both user and kernel space). User programs should use a separate file

to request deletes than the one used for registration due to this.



Status

------

When tools attach/record user based events the status of the event is updated

in realtime. This allows user programs to only incur the cost of the write() or

writev() calls when something is actively attached to the event.



User programs call mmap() on /sys/kernel/debug/tracing/user_events_status to

check the status for each event that is registered. The byte to check in the

file is given back after the register ioctl() via user_reg.status_index.

Currently the size of user_events_status is a single page, however, custom

kernel configurations can change this size to allow more user based events. In

all cases the size of the file is a multiple of a page size.



For example, if the register ioctl() gives back a status_index of 3 you would

check byte 3 of the returned mmap data to see if anything is attached to that

event.



Administrators can easily check the status of all registered events by reading

the user_events_status file directly via a terminal. The output is as follows::



  Byte:Name [# Comments]

  ...



  Active: ActiveCount

  Busy: BusyCount

  Max: MaxCount



For example, on a system that has a single event the output looks like this::



  1:test



  Active: 1

  Busy: 0

  Max: 4096



If a user enables the user event via ftrace, the output would change to this::



  1:test # Used by ftrace



  Active: 1

  Busy: 1

  Max: 4096



**NOTE:** *A status index of 0 will never be returned. This allows user

programs to have an index that can be used on error cases.*



Status Bits

^^^^^^^^^^^

The byte being checked will be non-zero if anything is attached. Programs can

check specific bits in the byte to see what mechanism has been attached.



The following values are defined to aid in checking what has been attached:



**EVENT_STATUS_FTRACE** - Bit set if ftrace has been attached (Bit 0).



**EVENT_STATUS_PERF** - Bit set if perf/eBPF has been attached (Bit 1).



Writing Data

------------

After registering an event the same fd that was used to register can be used

to write an entry for that event. The write_index returned must be at the start

of the data, then the remaining data is treated as the payload of the event.



For example, if write_index returned was 1 and I wanted to write out an int

payload of the event. Then the data would have to be 8 bytes (2 ints) in size,

with the first 4 bytes being equal to 1 and the last 4 bytes being equal to the

value I want as the payload.



In memory this would look like this::



  int index;

  int payload;



User programs might have well known structs that they wish to use to emit out

as payloads. In those cases writev() can be used, with the first vector being

the index and the following vector(s) being the actual event payload.



For example, if I have a struct like this::



  struct payload {

        int src;

        int dst;

        int flags;

  };



It's advised for user programs to do the following::



  struct iovec io[2];

  struct payload e;



  io[0].iov_base = &write_index;

  io[0].iov_len = sizeof(write_index);

  io[1].iov_base = &e;

  io[1].iov_len = sizeof(e);



  writev(fd, (const struct iovec*)io, 2);



**NOTE:** *The write_index is not emitted out into the trace being recorded.*



EBPF

----

EBPF programs that attach to a user-based event tracepoint are given a pointer

to a struct user_bpf_context. The bpf context contains the data type (which can

be a user or kernel buffer, or can be a pointer to the iovec) and the data

length that was emitted (minus the write_index).



Example Code

------------

See sample code in samples/user_events.

include/linux/ftrace.h

+10 −1
Original line number Diff line number Diff line
@@ -30,6 +30,12 @@ 
#define ARCH_SUPPORTS_FTRACE_OPS 0

#endif



#ifdef CONFIG_TRACING

extern void ftrace_boot_snapshot(void);

#else

static inline void ftrace_boot_snapshot(void) { }

#endif



#ifdef CONFIG_FUNCTION_TRACER

struct ftrace_ops;

struct ftrace_regs;
@@ -215,7 +221,10 @@ struct ftrace_ops_hash { 
void ftrace_free_init_mem(void);

void ftrace_free_mem(struct module *mod, void *start, void *end);

#else

static inline void ftrace_free_init_mem(void) { }

static inline void ftrace_free_init_mem(void)

{

	ftrace_boot_snapshot();

}

static inline void ftrace_free_mem(struct module *mod, void *start, void *end) { }

#endif

include/linux/trace_events.h

+23 −1
Original line number Diff line number Diff line
@@ -315,6 +315,7 @@ enum { 
	TRACE_EVENT_FL_KPROBE_BIT,

	TRACE_EVENT_FL_UPROBE_BIT,

	TRACE_EVENT_FL_EPROBE_BIT,

	TRACE_EVENT_FL_CUSTOM_BIT,

};



/*
@@ -328,6 +329,9 @@ enum { 
 *  KPROBE        - Event is a kprobe

 *  UPROBE        - Event is a uprobe

 *  EPROBE        - Event is an event probe

 *  CUSTOM        - Event is a custom event (to be attached to an exsiting tracepoint)

 *                   This is set when the custom event has not been attached

 *                   to a tracepoint yet, then it is cleared when it is.

 */

enum {

	TRACE_EVENT_FL_FILTERED		= (1 << TRACE_EVENT_FL_FILTERED_BIT),
@@ -339,6 +343,7 @@ enum { 
	TRACE_EVENT_FL_KPROBE		= (1 << TRACE_EVENT_FL_KPROBE_BIT),

	TRACE_EVENT_FL_UPROBE		= (1 << TRACE_EVENT_FL_UPROBE_BIT),

	TRACE_EVENT_FL_EPROBE		= (1 << TRACE_EVENT_FL_EPROBE_BIT),

	TRACE_EVENT_FL_CUSTOM		= (1 << TRACE_EVENT_FL_CUSTOM_BIT),

};



#define TRACE_EVENT_FL_UKPROBE (TRACE_EVENT_FL_KPROBE | TRACE_EVENT_FL_UPROBE)
@@ -440,7 +445,9 @@ static inline bool bpf_prog_array_valid(struct trace_event_call *call) 
static inline const char *

trace_event_name(struct trace_event_call *call)

{

	if (call->flags & TRACE_EVENT_FL_TRACEPOINT)

	if (call->flags & TRACE_EVENT_FL_CUSTOM)

		return call->name;

	else if (call->flags & TRACE_EVENT_FL_TRACEPOINT)

		return call->tp ? call->tp->name : NULL;

	else

		return call->name;
@@ -903,3 +910,18 @@ perf_trace_buf_submit(void *raw_data, int size, int rctx, u16 type, 
#endif



#endif /* _LINUX_TRACE_EVENT_H */



/*

 * Note: we keep the TRACE_CUSTOM_EVENT outside the include file ifdef protection.

 *  This is due to the way trace custom events work. If a file includes two

 *  trace event headers under one "CREATE_CUSTOM_TRACE_EVENTS" the first include

 *  will override the TRACE_CUSTOM_EVENT and break the second include.

 */



#ifndef TRACE_CUSTOM_EVENT



#define DECLARE_CUSTOM_EVENT_CLASS(name, proto, args, tstruct, assign, print)

#define DEFINE_CUSTOM_EVENT(template, name, proto, args)

#define TRACE_CUSTOM_EVENT(name, proto, args, struct, assign, print)



#endif /* ifdef TRACE_CUSTOM_EVENT (see note above) */