Merge tag 'probes-v6.6' of git://git.kernel.org/pub/scm/linux/kernel/git/trace/linux-trace

 f:fprobes/myprobe vfs_read count=count pos=pos

It also chooses the fetch type from BTF information. For example, in the above

example, the ``count`` is unsigned long, and the ``pos`` is a pointer. Thus, both

are converted to 64bit unsigned long, but only ``pos`` has "%Lx" print-format as

below ::

example, the ``count`` is unsigned long, and the ``pos`` is a pointer. Thus,

both are converted to 64bit unsigned long, but only ``pos`` has "%Lx"

print-format as below ::

 # cat events/fprobes/myprobe/format

 name: myprobe

 # cat dynamic_events

 f:fprobes/myprobe vfs_read file=file buf=buf count=count pos=pos

BTF also affects the ``$retval``. If user doesn't set any type, the retval type is

automatically picked from the BTF. If the function returns ``void``, ``$retval``

is rejected.

BTF also affects the ``$retval``. If user doesn't set any type, the retval

type is automatically picked from the BTF. If the function returns ``void``,

``$retval`` is rejected.

You can access the data fields of a data structure using allow operator ``->``

(for pointer type) and dot operator ``.`` (for data structure type.)::

# echo 't sched_switch preempt prev_pid=prev->pid next_pid=next->pid' >> dynamic_events

The field access operators, ``->`` and ``.`` can be combined for accessing deeper

members and other structure members pointed by the member. e.g. ``foo->bar.baz->qux``

If there is non-name union member, you can directly access it as the C code does.

For example::

 struct {

	union {

	int a;

	int b;

	};

 } *foo;

To access ``a`` and ``b``, use ``foo->a`` and ``foo->b`` in this case.

This data field access is available for the return value via ``$retval``,

e.g. ``$retval->name``.

For these BTF arguments and fields, ``:string`` and ``:ustring`` change the

behavior. If these are used for BTF argument or field, it checks whether

the BTF type of the argument or the data field is ``char *`` or ``char []``,

or not.  If not, it rejects applying the string types. Also, with the BTF

support, you don't need a memory dereference operator (``+0(PTR)``) for

accessing the string pointed by a ``PTR``. It automatically adds the memory

dereference operator according to the BTF type. e.g. ::

# echo 't sched_switch prev->comm:string' >> dynamic_events

# echo 'f getname_flags%return $retval->name:string' >> dynamic_events

The ``prev->comm`` is an embedded char array in the data structure, and

``$retval->name`` is a char pointer in the data structure. But in both

cases, you can use ``:string`` type to get the string.

Usage examples

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

structure pointed by the ``prev`` and ``next`` arguments.

For example, usually ``task_struct::start_time`` is not traced, but with this

traceprobe event, you can trace it as below.

traceprobe event, you can trace that field as below.

::

  # echo 't sched_switch comm=+1896(next):string start_time=+1728(next):u64' > dynamic_events

  # echo 't sched_switch comm=next->comm:string next->start_time' > dynamic_events

  # head -n 20 trace | tail

 #           TASK-PID     CPU#  |||||  TIMESTAMP  FUNCTION

 #              | |         |   |||||     |         |

           <idle>-0       [000] d..3.  5606.690317: sched_switch: (__probestub_sched_switch+0x4/0x10) comm="kworker/0:1" usage=1 start_time=137000000

      kworker/0:1-14      [000] d..3.  5606.690339: sched_switch: (__probestub_sched_switch+0x4/0x10) comm="swapper/0" usage=2 start_time=0

           <idle>-0       [000] d..3.  5606.692368: sched_switch: (__probestub_sched_switch+0x4/0x10) comm="kworker/0:1" usage=1 start_time=137000000

Currently, to find the offset of a specific field in the data structure,

you need to build kernel with debuginfo and run `perf probe` command with

`-D` option. e.g.

::

 # perf probe -D "__probestub_sched_switch next->comm:string next->start_time"

 p:probe/__probestub_sched_switch __probestub_sched_switch+0 comm=+1896(%cx):string start_time=+1728(%cx):u64

And replace the ``%cx`` with the ``next``.

int btf_check_and_fixup_fields(const struct btf *btf, struct btf_record *rec);

bool btf_type_is_void(const struct btf_type *t);

s32 btf_find_by_name_kind(const struct btf *btf, const char *name, u8 kind);

s32 bpf_find_btf_id(const char *name, u32 kind, struct btf **btf_p);

const struct btf_type *btf_type_skip_modifiers(const struct btf *btf,

					       u32 id, u32 *res_id);

const struct btf_type *btf_type_resolve_ptr(const struct btf *btf,

	return -ENOENT;

}

static s32 bpf_find_btf_id(const char *name, u32 kind, struct btf **btf_p)

s32 bpf_find_btf_id(const char *name, u32 kind, struct btf **btf_p)

{

	struct btf *btf;

	s32 ret;

		return -ENOMEM;

	for (i = 0; i < rp->maxactive; i++) {

		inst = kzalloc(sizeof(struct kretprobe_instance) +

			       rp->data_size, GFP_KERNEL);

		inst = kzalloc(struct_size(inst, data, rp->data_size), GFP_KERNEL);

		if (inst == NULL) {

			rethook_free(rp->rh);

			rp->rh = NULL;

	rp->rph->rp = rp;

	for (i = 0; i < rp->maxactive; i++) {

		inst = kzalloc(sizeof(struct kretprobe_instance) +

			       rp->data_size, GFP_KERNEL);

		inst = kzalloc(struct_size(inst, data, rp->data_size), GFP_KERNEL);

		if (inst == NULL) {

			refcount_set(&rp->rph->ref, i);

			free_rp_inst(rp);

endif

obj-$(CONFIG_DYNAMIC_EVENTS) += trace_dynevent.o

obj-$(CONFIG_PROBE_EVENTS) += trace_probe.o

obj-$(CONFIG_PROBE_EVENTS_BTF_ARGS) += trace_btf.o

obj-$(CONFIG_UPROBE_EVENTS) += trace_uprobe.o

obj-$(CONFIG_BOOTTIME_TRACING) += trace_boot.o

obj-$(CONFIG_FTRACE_RECORD_RECURSION) += trace_recursion_record.o