selftests/bpf: Add profiler test

Additional information about selftest failures are

documented here.

profiler[23] test failures with clang/llvm <12.0.0

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

With clang/llvm <12.0.0, the profiler[23] test may fail.

The symptom looks like

.. code-block:: c

  // r9 is a pointer to map_value

  // r7 is a scalar

  17:       bf 96 00 00 00 00 00 00 r6 = r9

  18:       0f 76 00 00 00 00 00 00 r6 += r7

  math between map_value pointer and register with unbounded min value is not allowed

  // the instructions below will not be seen in the verifier log

  19:       a5 07 01 00 01 01 00 00 if r7 < 257 goto +1

  20:       bf 96 00 00 00 00 00 00 r6 = r9

  // r6 is used here

The verifier will reject such code with above error.

At insn 18 the r7 is indeed unbounded. The later insn 19 checks the bounds and

the insn 20 undoes map_value addition. It is currently impossible for the

verifier to understand such speculative pointer arithmetic.

Hence

    https://reviews.llvm.org/D85570

addresses it on the compiler side. It was committed on llvm 12.

The corresponding C code

.. code-block:: c

  for (int i = 0; i < MAX_CGROUPS_PATH_DEPTH; i++) {

          filepart_length = bpf_probe_read_str(payload, ...);

          if (filepart_length <= MAX_PATH) {

                  barrier_var(filepart_length); // workaround

                  payload += filepart_length;

          }

  }

bpf_iter test failures with clang/llvm 10.0.0

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

// SPDX-License-Identifier: GPL-2.0

/* Copyright (c) 2020 Facebook */

#include <test_progs.h>

#include "progs/profiler.h"

#include "profiler1.skel.h"

#include "profiler2.skel.h"

#include "profiler3.skel.h"

static int sanity_run(struct bpf_program *prog)

{

	struct bpf_prog_test_run_attr test_attr = {};

	__u64 args[] = {1, 2, 3};

	__u32 duration = 0;

	int err, prog_fd;

	prog_fd = bpf_program__fd(prog);

	test_attr.prog_fd = prog_fd;

	test_attr.ctx_in = args;

	test_attr.ctx_size_in = sizeof(args);

	err = bpf_prog_test_run_xattr(&test_attr);

	if (CHECK(err || test_attr.retval, "test_run",

		  "err %d errno %d retval %d duration %d\n",

		  err, errno, test_attr.retval, duration))

		return -1;

	return 0;

}

void test_test_profiler(void)

{

	struct profiler1 *profiler1_skel = NULL;

	struct profiler2 *profiler2_skel = NULL;

	struct profiler3 *profiler3_skel = NULL;

	__u32 duration = 0;

	int err;

	profiler1_skel = profiler1__open_and_load();

	if (CHECK(!profiler1_skel, "profiler1_skel_load", "profiler1 skeleton failed\n"))

		goto cleanup;

	err = profiler1__attach(profiler1_skel);

	if (CHECK(err, "profiler1_attach", "profiler1 attach failed: %d\n", err))

		goto cleanup;

	if (sanity_run(profiler1_skel->progs.raw_tracepoint__sched_process_exec))

		goto cleanup;

	profiler2_skel = profiler2__open_and_load();

	if (CHECK(!profiler2_skel, "profiler2_skel_load", "profiler2 skeleton failed\n"))

		goto cleanup;

	err = profiler2__attach(profiler2_skel);

	if (CHECK(err, "profiler2_attach", "profiler2 attach failed: %d\n", err))

		goto cleanup;

	if (sanity_run(profiler2_skel->progs.raw_tracepoint__sched_process_exec))

		goto cleanup;

	profiler3_skel = profiler3__open_and_load();

	if (CHECK(!profiler3_skel, "profiler3_skel_load", "profiler3 skeleton failed\n"))

		goto cleanup;

	err = profiler3__attach(profiler3_skel);

	if (CHECK(err, "profiler3_attach", "profiler3 attach failed: %d\n", err))

		goto cleanup;

	if (sanity_run(profiler3_skel->progs.raw_tracepoint__sched_process_exec))

		goto cleanup;

cleanup:

	profiler1__destroy(profiler1_skel);

	profiler2__destroy(profiler2_skel);

	profiler3__destroy(profiler3_skel);

}

// SPDX-License-Identifier: GPL-2.0

/* Copyright (c) 2020 Facebook */

#pragma once

#define TASK_COMM_LEN 16

#define MAX_ANCESTORS 4

#define MAX_PATH 256

#define KILL_TARGET_LEN 64

#define CTL_MAXNAME 10

#define MAX_ARGS_LEN 4096

#define MAX_FILENAME_LEN 512

#define MAX_ENVIRON_LEN 8192

#define MAX_PATH_DEPTH 32

#define MAX_FILEPATH_LENGTH (MAX_PATH_DEPTH * MAX_PATH)

#define MAX_CGROUPS_PATH_DEPTH 8

#define MAX_METADATA_PAYLOAD_LEN TASK_COMM_LEN

#define MAX_CGROUP_PAYLOAD_LEN \

	(MAX_PATH * 2 + (MAX_PATH * MAX_CGROUPS_PATH_DEPTH))

#define MAX_CAP_PAYLOAD_LEN (MAX_METADATA_PAYLOAD_LEN + MAX_CGROUP_PAYLOAD_LEN)

#define MAX_SYSCTL_PAYLOAD_LEN \

	(MAX_METADATA_PAYLOAD_LEN + MAX_CGROUP_PAYLOAD_LEN + CTL_MAXNAME + MAX_PATH)

#define MAX_KILL_PAYLOAD_LEN \

	(MAX_METADATA_PAYLOAD_LEN + MAX_CGROUP_PAYLOAD_LEN + TASK_COMM_LEN + \

	 KILL_TARGET_LEN)

#define MAX_EXEC_PAYLOAD_LEN \

	(MAX_METADATA_PAYLOAD_LEN + MAX_CGROUP_PAYLOAD_LEN + MAX_FILENAME_LEN + \

	 MAX_ARGS_LEN + MAX_ENVIRON_LEN)

#define MAX_FILEMOD_PAYLOAD_LEN \

	(MAX_METADATA_PAYLOAD_LEN + MAX_CGROUP_PAYLOAD_LEN + MAX_FILEPATH_LENGTH + \

	 MAX_FILEPATH_LENGTH)

enum data_type {

	INVALID_EVENT,

	EXEC_EVENT,

	FORK_EVENT,

	KILL_EVENT,

	SYSCTL_EVENT,

	FILEMOD_EVENT,

	MAX_DATA_TYPE_EVENT

};

enum filemod_type {

	FMOD_OPEN,

	FMOD_LINK,

	FMOD_SYMLINK,

};

struct ancestors_data_t {

	pid_t ancestor_pids[MAX_ANCESTORS];

	uint32_t ancestor_exec_ids[MAX_ANCESTORS];

	uint64_t ancestor_start_times[MAX_ANCESTORS];

	uint32_t num_ancestors;

};

struct var_metadata_t {

	enum data_type type;

	pid_t pid;

	uint32_t exec_id;

	uid_t uid;

	gid_t gid;

	uint64_t start_time;

	uint32_t cpu_id;

	uint64_t bpf_stats_num_perf_events;

	uint64_t bpf_stats_start_ktime_ns;

	uint8_t comm_length;

};

struct cgroup_data_t {

	ino_t cgroup_root_inode;

	ino_t cgroup_proc_inode;

	uint64_t cgroup_root_mtime;

	uint64_t cgroup_proc_mtime;

	uint16_t cgroup_root_length;

	uint16_t cgroup_proc_length;

	uint16_t cgroup_full_length;

	int cgroup_full_path_root_pos;

};

struct var_sysctl_data_t {

	struct var_metadata_t meta;

	struct cgroup_data_t cgroup_data;

	struct ancestors_data_t ancestors_info;

	uint8_t sysctl_val_length;

	uint16_t sysctl_path_length;

	char payload[MAX_SYSCTL_PAYLOAD_LEN];

};

struct var_kill_data_t {

	struct var_metadata_t meta;

	struct cgroup_data_t cgroup_data;

	struct ancestors_data_t ancestors_info;

	pid_t kill_target_pid;

	int kill_sig;

	uint32_t kill_count;

	uint64_t last_kill_time;

	uint8_t kill_target_name_length;

	uint8_t kill_target_cgroup_proc_length;

	char payload[MAX_KILL_PAYLOAD_LEN];

	size_t payload_length;

};

struct var_exec_data_t {

	struct var_metadata_t meta;

	struct cgroup_data_t cgroup_data;

	pid_t parent_pid;

	uint32_t parent_exec_id;

	uid_t parent_uid;

	uint64_t parent_start_time;

	uint16_t bin_path_length;

	uint16_t cmdline_length;

	uint16_t environment_length;

	char payload[MAX_EXEC_PAYLOAD_LEN];

};

struct var_fork_data_t {

	struct var_metadata_t meta;

	pid_t parent_pid;

	uint32_t parent_exec_id;

	uint64_t parent_start_time;

	char payload[MAX_METADATA_PAYLOAD_LEN];

};

struct var_filemod_data_t {

	struct var_metadata_t meta;

	struct cgroup_data_t cgroup_data;

	enum filemod_type fmod_type;

	unsigned int dst_flags;

	uint32_t src_device_id;

	uint32_t dst_device_id;

	ino_t src_inode;

	ino_t dst_inode;

	uint16_t src_filepath_length;

	uint16_t dst_filepath_length;

	char payload[MAX_FILEMOD_PAYLOAD_LEN];

};

struct profiler_config_struct {

	bool fetch_cgroups_from_bpf;

	ino_t cgroup_fs_inode;

	ino_t cgroup_login_session_inode;

	uint64_t kill_signals_mask;

	ino_t inode_filter;

	uint32_t stale_info_secs;

	bool use_variable_buffers;

	bool read_environ_from_exec;

	bool enable_cgroup_v1_resolver;

};

struct bpf_func_stats_data {

	uint64_t time_elapsed_ns;

	uint64_t num_executions;

	uint64_t num_perf_events;

};

struct bpf_func_stats_ctx {

	uint64_t start_time_ns;

	struct bpf_func_stats_data* bpf_func_stats_data_val;

};

enum bpf_function_id {

	profiler_bpf_proc_sys_write,

	profiler_bpf_sched_process_exec,

	profiler_bpf_sched_process_exit,

	profiler_bpf_sys_enter_kill,

	profiler_bpf_do_filp_open_ret,

	profiler_bpf_sched_process_fork,

	profiler_bpf_vfs_link,

	profiler_bpf_vfs_symlink,

	profiler_bpf_max_function_id

};

// SPDX-License-Identifier: GPL-2.0

/* Copyright (c) 2020 Facebook */

#define barrier_var(var) asm volatile("" : "=r"(var) : "0"(var))

#define UNROLL

#define INLINE __always_inline

#include "profiler.inc.h"