mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-27 11:19:37 +00:00
![Alexei Starovoitov](/assets/img/avatar_default.png)
Prepare light skeleton to be used in the kernel module and in the user space. The look and feel of lskel.h is mostly the same with the difference that for user space the skel->rodata is the same pointer before and after skel_load operation, while in the kernel the skel->rodata after skel_open and the skel->rodata after skel_load are different pointers. Typical usage of skeleton remains the same for kernel and user space: skel = my_bpf__open(); skel->rodata->my_global_var = init_val; err = my_bpf__load(skel); err = my_bpf__attach(skel); // access skel->rodata->my_global_var; // access skel->bss->another_var; Signed-off-by: Alexei Starovoitov <ast@kernel.org> Signed-off-by: Daniel Borkmann <daniel@iogearbox.net> Acked-by: Yonghong Song <yhs@fb.com> Acked-by: Andrii Nakryiko <andrii@kernel.org> Link: https://lore.kernel.org/bpf/20220209232001.27490-3-alexei.starovoitov@gmail.com
1121 lines
37 KiB
C
1121 lines
37 KiB
C
// SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause)
|
|
/* Copyright (c) 2021 Facebook */
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <errno.h>
|
|
#include <linux/filter.h>
|
|
#include <sys/param.h>
|
|
#include "btf.h"
|
|
#include "bpf.h"
|
|
#include "libbpf.h"
|
|
#include "libbpf_internal.h"
|
|
#include "hashmap.h"
|
|
#include "bpf_gen_internal.h"
|
|
#include "skel_internal.h"
|
|
#include <asm/byteorder.h>
|
|
|
|
#define MAX_USED_MAPS 64
|
|
#define MAX_USED_PROGS 32
|
|
#define MAX_KFUNC_DESCS 256
|
|
#define MAX_FD_ARRAY_SZ (MAX_USED_MAPS + MAX_KFUNC_DESCS)
|
|
|
|
/* The following structure describes the stack layout of the loader program.
|
|
* In addition R6 contains the pointer to context.
|
|
* R7 contains the result of the last sys_bpf command (typically error or FD).
|
|
* R9 contains the result of the last sys_close command.
|
|
*
|
|
* Naming convention:
|
|
* ctx - bpf program context
|
|
* stack - bpf program stack
|
|
* blob - bpf_attr-s, strings, insns, map data.
|
|
* All the bytes that loader prog will use for read/write.
|
|
*/
|
|
struct loader_stack {
|
|
__u32 btf_fd;
|
|
__u32 inner_map_fd;
|
|
__u32 prog_fd[MAX_USED_PROGS];
|
|
};
|
|
|
|
#define stack_off(field) \
|
|
(__s16)(-sizeof(struct loader_stack) + offsetof(struct loader_stack, field))
|
|
|
|
#define attr_field(attr, field) (attr + offsetof(union bpf_attr, field))
|
|
|
|
static int blob_fd_array_off(struct bpf_gen *gen, int index)
|
|
{
|
|
return gen->fd_array + index * sizeof(int);
|
|
}
|
|
|
|
static int realloc_insn_buf(struct bpf_gen *gen, __u32 size)
|
|
{
|
|
size_t off = gen->insn_cur - gen->insn_start;
|
|
void *insn_start;
|
|
|
|
if (gen->error)
|
|
return gen->error;
|
|
if (size > INT32_MAX || off + size > INT32_MAX) {
|
|
gen->error = -ERANGE;
|
|
return -ERANGE;
|
|
}
|
|
insn_start = realloc(gen->insn_start, off + size);
|
|
if (!insn_start) {
|
|
gen->error = -ENOMEM;
|
|
free(gen->insn_start);
|
|
gen->insn_start = NULL;
|
|
return -ENOMEM;
|
|
}
|
|
gen->insn_start = insn_start;
|
|
gen->insn_cur = insn_start + off;
|
|
return 0;
|
|
}
|
|
|
|
static int realloc_data_buf(struct bpf_gen *gen, __u32 size)
|
|
{
|
|
size_t off = gen->data_cur - gen->data_start;
|
|
void *data_start;
|
|
|
|
if (gen->error)
|
|
return gen->error;
|
|
if (size > INT32_MAX || off + size > INT32_MAX) {
|
|
gen->error = -ERANGE;
|
|
return -ERANGE;
|
|
}
|
|
data_start = realloc(gen->data_start, off + size);
|
|
if (!data_start) {
|
|
gen->error = -ENOMEM;
|
|
free(gen->data_start);
|
|
gen->data_start = NULL;
|
|
return -ENOMEM;
|
|
}
|
|
gen->data_start = data_start;
|
|
gen->data_cur = data_start + off;
|
|
return 0;
|
|
}
|
|
|
|
static void emit(struct bpf_gen *gen, struct bpf_insn insn)
|
|
{
|
|
if (realloc_insn_buf(gen, sizeof(insn)))
|
|
return;
|
|
memcpy(gen->insn_cur, &insn, sizeof(insn));
|
|
gen->insn_cur += sizeof(insn);
|
|
}
|
|
|
|
static void emit2(struct bpf_gen *gen, struct bpf_insn insn1, struct bpf_insn insn2)
|
|
{
|
|
emit(gen, insn1);
|
|
emit(gen, insn2);
|
|
}
|
|
|
|
static int add_data(struct bpf_gen *gen, const void *data, __u32 size);
|
|
static void emit_sys_close_blob(struct bpf_gen *gen, int blob_off);
|
|
|
|
void bpf_gen__init(struct bpf_gen *gen, int log_level, int nr_progs, int nr_maps)
|
|
{
|
|
size_t stack_sz = sizeof(struct loader_stack), nr_progs_sz;
|
|
int i;
|
|
|
|
gen->fd_array = add_data(gen, NULL, MAX_FD_ARRAY_SZ * sizeof(int));
|
|
gen->log_level = log_level;
|
|
/* save ctx pointer into R6 */
|
|
emit(gen, BPF_MOV64_REG(BPF_REG_6, BPF_REG_1));
|
|
|
|
/* bzero stack */
|
|
emit(gen, BPF_MOV64_REG(BPF_REG_1, BPF_REG_10));
|
|
emit(gen, BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, -stack_sz));
|
|
emit(gen, BPF_MOV64_IMM(BPF_REG_2, stack_sz));
|
|
emit(gen, BPF_MOV64_IMM(BPF_REG_3, 0));
|
|
emit(gen, BPF_EMIT_CALL(BPF_FUNC_probe_read_kernel));
|
|
|
|
/* amount of stack actually used, only used to calculate iterations, not stack offset */
|
|
nr_progs_sz = offsetof(struct loader_stack, prog_fd[nr_progs]);
|
|
/* jump over cleanup code */
|
|
emit(gen, BPF_JMP_IMM(BPF_JA, 0, 0,
|
|
/* size of cleanup code below (including map fd cleanup) */
|
|
(nr_progs_sz / 4) * 3 + 2 +
|
|
/* 6 insns for emit_sys_close_blob,
|
|
* 6 insns for debug_regs in emit_sys_close_blob
|
|
*/
|
|
nr_maps * (6 + (gen->log_level ? 6 : 0))));
|
|
|
|
/* remember the label where all error branches will jump to */
|
|
gen->cleanup_label = gen->insn_cur - gen->insn_start;
|
|
/* emit cleanup code: close all temp FDs */
|
|
for (i = 0; i < nr_progs_sz; i += 4) {
|
|
emit(gen, BPF_LDX_MEM(BPF_W, BPF_REG_1, BPF_REG_10, -stack_sz + i));
|
|
emit(gen, BPF_JMP_IMM(BPF_JSLE, BPF_REG_1, 0, 1));
|
|
emit(gen, BPF_EMIT_CALL(BPF_FUNC_sys_close));
|
|
}
|
|
for (i = 0; i < nr_maps; i++)
|
|
emit_sys_close_blob(gen, blob_fd_array_off(gen, i));
|
|
/* R7 contains the error code from sys_bpf. Copy it into R0 and exit. */
|
|
emit(gen, BPF_MOV64_REG(BPF_REG_0, BPF_REG_7));
|
|
emit(gen, BPF_EXIT_INSN());
|
|
}
|
|
|
|
static int add_data(struct bpf_gen *gen, const void *data, __u32 size)
|
|
{
|
|
__u32 size8 = roundup(size, 8);
|
|
__u64 zero = 0;
|
|
void *prev;
|
|
|
|
if (realloc_data_buf(gen, size8))
|
|
return 0;
|
|
prev = gen->data_cur;
|
|
if (data) {
|
|
memcpy(gen->data_cur, data, size);
|
|
memcpy(gen->data_cur + size, &zero, size8 - size);
|
|
} else {
|
|
memset(gen->data_cur, 0, size8);
|
|
}
|
|
gen->data_cur += size8;
|
|
return prev - gen->data_start;
|
|
}
|
|
|
|
/* Get index for map_fd/btf_fd slot in reserved fd_array, or in data relative
|
|
* to start of fd_array. Caller can decide if it is usable or not.
|
|
*/
|
|
static int add_map_fd(struct bpf_gen *gen)
|
|
{
|
|
if (gen->nr_maps == MAX_USED_MAPS) {
|
|
pr_warn("Total maps exceeds %d\n", MAX_USED_MAPS);
|
|
gen->error = -E2BIG;
|
|
return 0;
|
|
}
|
|
return gen->nr_maps++;
|
|
}
|
|
|
|
static int add_kfunc_btf_fd(struct bpf_gen *gen)
|
|
{
|
|
int cur;
|
|
|
|
if (gen->nr_fd_array == MAX_KFUNC_DESCS) {
|
|
cur = add_data(gen, NULL, sizeof(int));
|
|
return (cur - gen->fd_array) / sizeof(int);
|
|
}
|
|
return MAX_USED_MAPS + gen->nr_fd_array++;
|
|
}
|
|
|
|
static int insn_bytes_to_bpf_size(__u32 sz)
|
|
{
|
|
switch (sz) {
|
|
case 8: return BPF_DW;
|
|
case 4: return BPF_W;
|
|
case 2: return BPF_H;
|
|
case 1: return BPF_B;
|
|
default: return -1;
|
|
}
|
|
}
|
|
|
|
/* *(u64 *)(blob + off) = (u64)(void *)(blob + data) */
|
|
static void emit_rel_store(struct bpf_gen *gen, int off, int data)
|
|
{
|
|
emit2(gen, BPF_LD_IMM64_RAW_FULL(BPF_REG_0, BPF_PSEUDO_MAP_IDX_VALUE,
|
|
0, 0, 0, data));
|
|
emit2(gen, BPF_LD_IMM64_RAW_FULL(BPF_REG_1, BPF_PSEUDO_MAP_IDX_VALUE,
|
|
0, 0, 0, off));
|
|
emit(gen, BPF_STX_MEM(BPF_DW, BPF_REG_1, BPF_REG_0, 0));
|
|
}
|
|
|
|
static void move_blob2blob(struct bpf_gen *gen, int off, int size, int blob_off)
|
|
{
|
|
emit2(gen, BPF_LD_IMM64_RAW_FULL(BPF_REG_2, BPF_PSEUDO_MAP_IDX_VALUE,
|
|
0, 0, 0, blob_off));
|
|
emit(gen, BPF_LDX_MEM(insn_bytes_to_bpf_size(size), BPF_REG_0, BPF_REG_2, 0));
|
|
emit2(gen, BPF_LD_IMM64_RAW_FULL(BPF_REG_1, BPF_PSEUDO_MAP_IDX_VALUE,
|
|
0, 0, 0, off));
|
|
emit(gen, BPF_STX_MEM(insn_bytes_to_bpf_size(size), BPF_REG_1, BPF_REG_0, 0));
|
|
}
|
|
|
|
static void move_blob2ctx(struct bpf_gen *gen, int ctx_off, int size, int blob_off)
|
|
{
|
|
emit2(gen, BPF_LD_IMM64_RAW_FULL(BPF_REG_1, BPF_PSEUDO_MAP_IDX_VALUE,
|
|
0, 0, 0, blob_off));
|
|
emit(gen, BPF_LDX_MEM(insn_bytes_to_bpf_size(size), BPF_REG_0, BPF_REG_1, 0));
|
|
emit(gen, BPF_STX_MEM(insn_bytes_to_bpf_size(size), BPF_REG_6, BPF_REG_0, ctx_off));
|
|
}
|
|
|
|
static void move_ctx2blob(struct bpf_gen *gen, int off, int size, int ctx_off,
|
|
bool check_non_zero)
|
|
{
|
|
emit(gen, BPF_LDX_MEM(insn_bytes_to_bpf_size(size), BPF_REG_0, BPF_REG_6, ctx_off));
|
|
if (check_non_zero)
|
|
/* If value in ctx is zero don't update the blob.
|
|
* For example: when ctx->map.max_entries == 0, keep default max_entries from bpf.c
|
|
*/
|
|
emit(gen, BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 3));
|
|
emit2(gen, BPF_LD_IMM64_RAW_FULL(BPF_REG_1, BPF_PSEUDO_MAP_IDX_VALUE,
|
|
0, 0, 0, off));
|
|
emit(gen, BPF_STX_MEM(insn_bytes_to_bpf_size(size), BPF_REG_1, BPF_REG_0, 0));
|
|
}
|
|
|
|
static void move_stack2blob(struct bpf_gen *gen, int off, int size, int stack_off)
|
|
{
|
|
emit(gen, BPF_LDX_MEM(insn_bytes_to_bpf_size(size), BPF_REG_0, BPF_REG_10, stack_off));
|
|
emit2(gen, BPF_LD_IMM64_RAW_FULL(BPF_REG_1, BPF_PSEUDO_MAP_IDX_VALUE,
|
|
0, 0, 0, off));
|
|
emit(gen, BPF_STX_MEM(insn_bytes_to_bpf_size(size), BPF_REG_1, BPF_REG_0, 0));
|
|
}
|
|
|
|
static void move_stack2ctx(struct bpf_gen *gen, int ctx_off, int size, int stack_off)
|
|
{
|
|
emit(gen, BPF_LDX_MEM(insn_bytes_to_bpf_size(size), BPF_REG_0, BPF_REG_10, stack_off));
|
|
emit(gen, BPF_STX_MEM(insn_bytes_to_bpf_size(size), BPF_REG_6, BPF_REG_0, ctx_off));
|
|
}
|
|
|
|
static void emit_sys_bpf(struct bpf_gen *gen, int cmd, int attr, int attr_size)
|
|
{
|
|
emit(gen, BPF_MOV64_IMM(BPF_REG_1, cmd));
|
|
emit2(gen, BPF_LD_IMM64_RAW_FULL(BPF_REG_2, BPF_PSEUDO_MAP_IDX_VALUE,
|
|
0, 0, 0, attr));
|
|
emit(gen, BPF_MOV64_IMM(BPF_REG_3, attr_size));
|
|
emit(gen, BPF_EMIT_CALL(BPF_FUNC_sys_bpf));
|
|
/* remember the result in R7 */
|
|
emit(gen, BPF_MOV64_REG(BPF_REG_7, BPF_REG_0));
|
|
}
|
|
|
|
static bool is_simm16(__s64 value)
|
|
{
|
|
return value == (__s64)(__s16)value;
|
|
}
|
|
|
|
static void emit_check_err(struct bpf_gen *gen)
|
|
{
|
|
__s64 off = -(gen->insn_cur - gen->insn_start - gen->cleanup_label) / 8 - 1;
|
|
|
|
/* R7 contains result of last sys_bpf command.
|
|
* if (R7 < 0) goto cleanup;
|
|
*/
|
|
if (is_simm16(off)) {
|
|
emit(gen, BPF_JMP_IMM(BPF_JSLT, BPF_REG_7, 0, off));
|
|
} else {
|
|
gen->error = -ERANGE;
|
|
emit(gen, BPF_JMP_IMM(BPF_JA, 0, 0, -1));
|
|
}
|
|
}
|
|
|
|
/* reg1 and reg2 should not be R1 - R5. They can be R0, R6 - R10 */
|
|
static void emit_debug(struct bpf_gen *gen, int reg1, int reg2,
|
|
const char *fmt, va_list args)
|
|
{
|
|
char buf[1024];
|
|
int addr, len, ret;
|
|
|
|
if (!gen->log_level)
|
|
return;
|
|
ret = vsnprintf(buf, sizeof(buf), fmt, args);
|
|
if (ret < 1024 - 7 && reg1 >= 0 && reg2 < 0)
|
|
/* The special case to accommodate common debug_ret():
|
|
* to avoid specifying BPF_REG_7 and adding " r=%%d" to
|
|
* prints explicitly.
|
|
*/
|
|
strcat(buf, " r=%d");
|
|
len = strlen(buf) + 1;
|
|
addr = add_data(gen, buf, len);
|
|
|
|
emit2(gen, BPF_LD_IMM64_RAW_FULL(BPF_REG_1, BPF_PSEUDO_MAP_IDX_VALUE,
|
|
0, 0, 0, addr));
|
|
emit(gen, BPF_MOV64_IMM(BPF_REG_2, len));
|
|
if (reg1 >= 0)
|
|
emit(gen, BPF_MOV64_REG(BPF_REG_3, reg1));
|
|
if (reg2 >= 0)
|
|
emit(gen, BPF_MOV64_REG(BPF_REG_4, reg2));
|
|
emit(gen, BPF_EMIT_CALL(BPF_FUNC_trace_printk));
|
|
}
|
|
|
|
static void debug_regs(struct bpf_gen *gen, int reg1, int reg2, const char *fmt, ...)
|
|
{
|
|
va_list args;
|
|
|
|
va_start(args, fmt);
|
|
emit_debug(gen, reg1, reg2, fmt, args);
|
|
va_end(args);
|
|
}
|
|
|
|
static void debug_ret(struct bpf_gen *gen, const char *fmt, ...)
|
|
{
|
|
va_list args;
|
|
|
|
va_start(args, fmt);
|
|
emit_debug(gen, BPF_REG_7, -1, fmt, args);
|
|
va_end(args);
|
|
}
|
|
|
|
static void __emit_sys_close(struct bpf_gen *gen)
|
|
{
|
|
emit(gen, BPF_JMP_IMM(BPF_JSLE, BPF_REG_1, 0,
|
|
/* 2 is the number of the following insns
|
|
* * 6 is additional insns in debug_regs
|
|
*/
|
|
2 + (gen->log_level ? 6 : 0)));
|
|
emit(gen, BPF_MOV64_REG(BPF_REG_9, BPF_REG_1));
|
|
emit(gen, BPF_EMIT_CALL(BPF_FUNC_sys_close));
|
|
debug_regs(gen, BPF_REG_9, BPF_REG_0, "close(%%d) = %%d");
|
|
}
|
|
|
|
static void emit_sys_close_stack(struct bpf_gen *gen, int stack_off)
|
|
{
|
|
emit(gen, BPF_LDX_MEM(BPF_W, BPF_REG_1, BPF_REG_10, stack_off));
|
|
__emit_sys_close(gen);
|
|
}
|
|
|
|
static void emit_sys_close_blob(struct bpf_gen *gen, int blob_off)
|
|
{
|
|
emit2(gen, BPF_LD_IMM64_RAW_FULL(BPF_REG_0, BPF_PSEUDO_MAP_IDX_VALUE,
|
|
0, 0, 0, blob_off));
|
|
emit(gen, BPF_LDX_MEM(BPF_W, BPF_REG_1, BPF_REG_0, 0));
|
|
__emit_sys_close(gen);
|
|
}
|
|
|
|
int bpf_gen__finish(struct bpf_gen *gen, int nr_progs, int nr_maps)
|
|
{
|
|
int i;
|
|
|
|
if (nr_progs < gen->nr_progs || nr_maps != gen->nr_maps) {
|
|
pr_warn("nr_progs %d/%d nr_maps %d/%d mismatch\n",
|
|
nr_progs, gen->nr_progs, nr_maps, gen->nr_maps);
|
|
gen->error = -EFAULT;
|
|
return gen->error;
|
|
}
|
|
emit_sys_close_stack(gen, stack_off(btf_fd));
|
|
for (i = 0; i < gen->nr_progs; i++)
|
|
move_stack2ctx(gen,
|
|
sizeof(struct bpf_loader_ctx) +
|
|
sizeof(struct bpf_map_desc) * gen->nr_maps +
|
|
sizeof(struct bpf_prog_desc) * i +
|
|
offsetof(struct bpf_prog_desc, prog_fd), 4,
|
|
stack_off(prog_fd[i]));
|
|
for (i = 0; i < gen->nr_maps; i++)
|
|
move_blob2ctx(gen,
|
|
sizeof(struct bpf_loader_ctx) +
|
|
sizeof(struct bpf_map_desc) * i +
|
|
offsetof(struct bpf_map_desc, map_fd), 4,
|
|
blob_fd_array_off(gen, i));
|
|
emit(gen, BPF_MOV64_IMM(BPF_REG_0, 0));
|
|
emit(gen, BPF_EXIT_INSN());
|
|
pr_debug("gen: finish %d\n", gen->error);
|
|
if (!gen->error) {
|
|
struct gen_loader_opts *opts = gen->opts;
|
|
|
|
opts->insns = gen->insn_start;
|
|
opts->insns_sz = gen->insn_cur - gen->insn_start;
|
|
opts->data = gen->data_start;
|
|
opts->data_sz = gen->data_cur - gen->data_start;
|
|
}
|
|
return gen->error;
|
|
}
|
|
|
|
void bpf_gen__free(struct bpf_gen *gen)
|
|
{
|
|
if (!gen)
|
|
return;
|
|
free(gen->data_start);
|
|
free(gen->insn_start);
|
|
free(gen);
|
|
}
|
|
|
|
void bpf_gen__load_btf(struct bpf_gen *gen, const void *btf_raw_data,
|
|
__u32 btf_raw_size)
|
|
{
|
|
int attr_size = offsetofend(union bpf_attr, btf_log_level);
|
|
int btf_data, btf_load_attr;
|
|
union bpf_attr attr;
|
|
|
|
memset(&attr, 0, attr_size);
|
|
pr_debug("gen: load_btf: size %d\n", btf_raw_size);
|
|
btf_data = add_data(gen, btf_raw_data, btf_raw_size);
|
|
|
|
attr.btf_size = btf_raw_size;
|
|
btf_load_attr = add_data(gen, &attr, attr_size);
|
|
|
|
/* populate union bpf_attr with user provided log details */
|
|
move_ctx2blob(gen, attr_field(btf_load_attr, btf_log_level), 4,
|
|
offsetof(struct bpf_loader_ctx, log_level), false);
|
|
move_ctx2blob(gen, attr_field(btf_load_attr, btf_log_size), 4,
|
|
offsetof(struct bpf_loader_ctx, log_size), false);
|
|
move_ctx2blob(gen, attr_field(btf_load_attr, btf_log_buf), 8,
|
|
offsetof(struct bpf_loader_ctx, log_buf), false);
|
|
/* populate union bpf_attr with a pointer to the BTF data */
|
|
emit_rel_store(gen, attr_field(btf_load_attr, btf), btf_data);
|
|
/* emit BTF_LOAD command */
|
|
emit_sys_bpf(gen, BPF_BTF_LOAD, btf_load_attr, attr_size);
|
|
debug_ret(gen, "btf_load size %d", btf_raw_size);
|
|
emit_check_err(gen);
|
|
/* remember btf_fd in the stack, if successful */
|
|
emit(gen, BPF_STX_MEM(BPF_W, BPF_REG_10, BPF_REG_7, stack_off(btf_fd)));
|
|
}
|
|
|
|
void bpf_gen__map_create(struct bpf_gen *gen,
|
|
enum bpf_map_type map_type,
|
|
const char *map_name,
|
|
__u32 key_size, __u32 value_size, __u32 max_entries,
|
|
struct bpf_map_create_opts *map_attr, int map_idx)
|
|
{
|
|
int attr_size = offsetofend(union bpf_attr, map_extra);
|
|
bool close_inner_map_fd = false;
|
|
int map_create_attr, idx;
|
|
union bpf_attr attr;
|
|
|
|
memset(&attr, 0, attr_size);
|
|
attr.map_type = map_type;
|
|
attr.key_size = key_size;
|
|
attr.value_size = value_size;
|
|
attr.map_flags = map_attr->map_flags;
|
|
attr.map_extra = map_attr->map_extra;
|
|
if (map_name)
|
|
libbpf_strlcpy(attr.map_name, map_name, sizeof(attr.map_name));
|
|
attr.numa_node = map_attr->numa_node;
|
|
attr.map_ifindex = map_attr->map_ifindex;
|
|
attr.max_entries = max_entries;
|
|
attr.btf_key_type_id = map_attr->btf_key_type_id;
|
|
attr.btf_value_type_id = map_attr->btf_value_type_id;
|
|
|
|
pr_debug("gen: map_create: %s idx %d type %d value_type_id %d\n",
|
|
attr.map_name, map_idx, map_type, attr.btf_value_type_id);
|
|
|
|
map_create_attr = add_data(gen, &attr, attr_size);
|
|
if (attr.btf_value_type_id)
|
|
/* populate union bpf_attr with btf_fd saved in the stack earlier */
|
|
move_stack2blob(gen, attr_field(map_create_attr, btf_fd), 4,
|
|
stack_off(btf_fd));
|
|
switch (attr.map_type) {
|
|
case BPF_MAP_TYPE_ARRAY_OF_MAPS:
|
|
case BPF_MAP_TYPE_HASH_OF_MAPS:
|
|
move_stack2blob(gen, attr_field(map_create_attr, inner_map_fd), 4,
|
|
stack_off(inner_map_fd));
|
|
close_inner_map_fd = true;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
/* conditionally update max_entries */
|
|
if (map_idx >= 0)
|
|
move_ctx2blob(gen, attr_field(map_create_attr, max_entries), 4,
|
|
sizeof(struct bpf_loader_ctx) +
|
|
sizeof(struct bpf_map_desc) * map_idx +
|
|
offsetof(struct bpf_map_desc, max_entries),
|
|
true /* check that max_entries != 0 */);
|
|
/* emit MAP_CREATE command */
|
|
emit_sys_bpf(gen, BPF_MAP_CREATE, map_create_attr, attr_size);
|
|
debug_ret(gen, "map_create %s idx %d type %d value_size %d value_btf_id %d",
|
|
attr.map_name, map_idx, map_type, value_size,
|
|
attr.btf_value_type_id);
|
|
emit_check_err(gen);
|
|
/* remember map_fd in the stack, if successful */
|
|
if (map_idx < 0) {
|
|
/* This bpf_gen__map_create() function is called with map_idx >= 0
|
|
* for all maps that libbpf loading logic tracks.
|
|
* It's called with -1 to create an inner map.
|
|
*/
|
|
emit(gen, BPF_STX_MEM(BPF_W, BPF_REG_10, BPF_REG_7,
|
|
stack_off(inner_map_fd)));
|
|
} else if (map_idx != gen->nr_maps) {
|
|
gen->error = -EDOM; /* internal bug */
|
|
return;
|
|
} else {
|
|
/* add_map_fd does gen->nr_maps++ */
|
|
idx = add_map_fd(gen);
|
|
emit2(gen, BPF_LD_IMM64_RAW_FULL(BPF_REG_1, BPF_PSEUDO_MAP_IDX_VALUE,
|
|
0, 0, 0, blob_fd_array_off(gen, idx)));
|
|
emit(gen, BPF_STX_MEM(BPF_W, BPF_REG_1, BPF_REG_7, 0));
|
|
}
|
|
if (close_inner_map_fd)
|
|
emit_sys_close_stack(gen, stack_off(inner_map_fd));
|
|
}
|
|
|
|
void bpf_gen__record_attach_target(struct bpf_gen *gen, const char *attach_name,
|
|
enum bpf_attach_type type)
|
|
{
|
|
const char *prefix;
|
|
int kind, ret;
|
|
|
|
btf_get_kernel_prefix_kind(type, &prefix, &kind);
|
|
gen->attach_kind = kind;
|
|
ret = snprintf(gen->attach_target, sizeof(gen->attach_target), "%s%s",
|
|
prefix, attach_name);
|
|
if (ret == sizeof(gen->attach_target))
|
|
gen->error = -ENOSPC;
|
|
}
|
|
|
|
static void emit_find_attach_target(struct bpf_gen *gen)
|
|
{
|
|
int name, len = strlen(gen->attach_target) + 1;
|
|
|
|
pr_debug("gen: find_attach_tgt %s %d\n", gen->attach_target, gen->attach_kind);
|
|
name = add_data(gen, gen->attach_target, len);
|
|
|
|
emit2(gen, BPF_LD_IMM64_RAW_FULL(BPF_REG_1, BPF_PSEUDO_MAP_IDX_VALUE,
|
|
0, 0, 0, name));
|
|
emit(gen, BPF_MOV64_IMM(BPF_REG_2, len));
|
|
emit(gen, BPF_MOV64_IMM(BPF_REG_3, gen->attach_kind));
|
|
emit(gen, BPF_MOV64_IMM(BPF_REG_4, 0));
|
|
emit(gen, BPF_EMIT_CALL(BPF_FUNC_btf_find_by_name_kind));
|
|
emit(gen, BPF_MOV64_REG(BPF_REG_7, BPF_REG_0));
|
|
debug_ret(gen, "find_by_name_kind(%s,%d)",
|
|
gen->attach_target, gen->attach_kind);
|
|
emit_check_err(gen);
|
|
/* if successful, btf_id is in lower 32-bit of R7 and
|
|
* btf_obj_fd is in upper 32-bit
|
|
*/
|
|
}
|
|
|
|
void bpf_gen__record_extern(struct bpf_gen *gen, const char *name, bool is_weak,
|
|
bool is_typeless, int kind, int insn_idx)
|
|
{
|
|
struct ksym_relo_desc *relo;
|
|
|
|
relo = libbpf_reallocarray(gen->relos, gen->relo_cnt + 1, sizeof(*relo));
|
|
if (!relo) {
|
|
gen->error = -ENOMEM;
|
|
return;
|
|
}
|
|
gen->relos = relo;
|
|
relo += gen->relo_cnt;
|
|
relo->name = name;
|
|
relo->is_weak = is_weak;
|
|
relo->is_typeless = is_typeless;
|
|
relo->kind = kind;
|
|
relo->insn_idx = insn_idx;
|
|
gen->relo_cnt++;
|
|
}
|
|
|
|
/* returns existing ksym_desc with ref incremented, or inserts a new one */
|
|
static struct ksym_desc *get_ksym_desc(struct bpf_gen *gen, struct ksym_relo_desc *relo)
|
|
{
|
|
struct ksym_desc *kdesc;
|
|
int i;
|
|
|
|
for (i = 0; i < gen->nr_ksyms; i++) {
|
|
if (!strcmp(gen->ksyms[i].name, relo->name)) {
|
|
gen->ksyms[i].ref++;
|
|
return &gen->ksyms[i];
|
|
}
|
|
}
|
|
kdesc = libbpf_reallocarray(gen->ksyms, gen->nr_ksyms + 1, sizeof(*kdesc));
|
|
if (!kdesc) {
|
|
gen->error = -ENOMEM;
|
|
return NULL;
|
|
}
|
|
gen->ksyms = kdesc;
|
|
kdesc = &gen->ksyms[gen->nr_ksyms++];
|
|
kdesc->name = relo->name;
|
|
kdesc->kind = relo->kind;
|
|
kdesc->ref = 1;
|
|
kdesc->off = 0;
|
|
kdesc->insn = 0;
|
|
return kdesc;
|
|
}
|
|
|
|
/* Overwrites BPF_REG_{0, 1, 2, 3, 4, 7}
|
|
* Returns result in BPF_REG_7
|
|
*/
|
|
static void emit_bpf_find_by_name_kind(struct bpf_gen *gen, struct ksym_relo_desc *relo)
|
|
{
|
|
int name_off, len = strlen(relo->name) + 1;
|
|
|
|
name_off = add_data(gen, relo->name, len);
|
|
emit2(gen, BPF_LD_IMM64_RAW_FULL(BPF_REG_1, BPF_PSEUDO_MAP_IDX_VALUE,
|
|
0, 0, 0, name_off));
|
|
emit(gen, BPF_MOV64_IMM(BPF_REG_2, len));
|
|
emit(gen, BPF_MOV64_IMM(BPF_REG_3, relo->kind));
|
|
emit(gen, BPF_MOV64_IMM(BPF_REG_4, 0));
|
|
emit(gen, BPF_EMIT_CALL(BPF_FUNC_btf_find_by_name_kind));
|
|
emit(gen, BPF_MOV64_REG(BPF_REG_7, BPF_REG_0));
|
|
debug_ret(gen, "find_by_name_kind(%s,%d)", relo->name, relo->kind);
|
|
}
|
|
|
|
/* Overwrites BPF_REG_{0, 1, 2, 3, 4, 7}
|
|
* Returns result in BPF_REG_7
|
|
* Returns u64 symbol addr in BPF_REG_9
|
|
*/
|
|
static void emit_bpf_kallsyms_lookup_name(struct bpf_gen *gen, struct ksym_relo_desc *relo)
|
|
{
|
|
int name_off, len = strlen(relo->name) + 1, res_off;
|
|
|
|
name_off = add_data(gen, relo->name, len);
|
|
res_off = add_data(gen, NULL, 8); /* res is u64 */
|
|
emit2(gen, BPF_LD_IMM64_RAW_FULL(BPF_REG_1, BPF_PSEUDO_MAP_IDX_VALUE,
|
|
0, 0, 0, name_off));
|
|
emit(gen, BPF_MOV64_IMM(BPF_REG_2, len));
|
|
emit(gen, BPF_MOV64_IMM(BPF_REG_3, 0));
|
|
emit2(gen, BPF_LD_IMM64_RAW_FULL(BPF_REG_4, BPF_PSEUDO_MAP_IDX_VALUE,
|
|
0, 0, 0, res_off));
|
|
emit(gen, BPF_MOV64_REG(BPF_REG_7, BPF_REG_4));
|
|
emit(gen, BPF_EMIT_CALL(BPF_FUNC_kallsyms_lookup_name));
|
|
emit(gen, BPF_LDX_MEM(BPF_DW, BPF_REG_9, BPF_REG_7, 0));
|
|
emit(gen, BPF_MOV64_REG(BPF_REG_7, BPF_REG_0));
|
|
debug_ret(gen, "kallsyms_lookup_name(%s,%d)", relo->name, relo->kind);
|
|
}
|
|
|
|
/* Expects:
|
|
* BPF_REG_8 - pointer to instruction
|
|
*
|
|
* We need to reuse BTF fd for same symbol otherwise each relocation takes a new
|
|
* index, while kernel limits total kfunc BTFs to 256. For duplicate symbols,
|
|
* this would mean a new BTF fd index for each entry. By pairing symbol name
|
|
* with index, we get the insn->imm, insn->off pairing that kernel uses for
|
|
* kfunc_tab, which becomes the effective limit even though all of them may
|
|
* share same index in fd_array (such that kfunc_btf_tab has 1 element).
|
|
*/
|
|
static void emit_relo_kfunc_btf(struct bpf_gen *gen, struct ksym_relo_desc *relo, int insn)
|
|
{
|
|
struct ksym_desc *kdesc;
|
|
int btf_fd_idx;
|
|
|
|
kdesc = get_ksym_desc(gen, relo);
|
|
if (!kdesc)
|
|
return;
|
|
/* try to copy from existing bpf_insn */
|
|
if (kdesc->ref > 1) {
|
|
move_blob2blob(gen, insn + offsetof(struct bpf_insn, imm), 4,
|
|
kdesc->insn + offsetof(struct bpf_insn, imm));
|
|
move_blob2blob(gen, insn + offsetof(struct bpf_insn, off), 2,
|
|
kdesc->insn + offsetof(struct bpf_insn, off));
|
|
goto log;
|
|
}
|
|
/* remember insn offset, so we can copy BTF ID and FD later */
|
|
kdesc->insn = insn;
|
|
emit_bpf_find_by_name_kind(gen, relo);
|
|
if (!relo->is_weak)
|
|
emit_check_err(gen);
|
|
/* get index in fd_array to store BTF FD at */
|
|
btf_fd_idx = add_kfunc_btf_fd(gen);
|
|
if (btf_fd_idx > INT16_MAX) {
|
|
pr_warn("BTF fd off %d for kfunc %s exceeds INT16_MAX, cannot process relocation\n",
|
|
btf_fd_idx, relo->name);
|
|
gen->error = -E2BIG;
|
|
return;
|
|
}
|
|
kdesc->off = btf_fd_idx;
|
|
/* jump to success case */
|
|
emit(gen, BPF_JMP_IMM(BPF_JSGE, BPF_REG_7, 0, 3));
|
|
/* set value for imm, off as 0 */
|
|
emit(gen, BPF_ST_MEM(BPF_W, BPF_REG_8, offsetof(struct bpf_insn, imm), 0));
|
|
emit(gen, BPF_ST_MEM(BPF_H, BPF_REG_8, offsetof(struct bpf_insn, off), 0));
|
|
/* skip success case for ret < 0 */
|
|
emit(gen, BPF_JMP_IMM(BPF_JA, 0, 0, 10));
|
|
/* store btf_id into insn[insn_idx].imm */
|
|
emit(gen, BPF_STX_MEM(BPF_W, BPF_REG_8, BPF_REG_7, offsetof(struct bpf_insn, imm)));
|
|
/* obtain fd in BPF_REG_9 */
|
|
emit(gen, BPF_MOV64_REG(BPF_REG_9, BPF_REG_7));
|
|
emit(gen, BPF_ALU64_IMM(BPF_RSH, BPF_REG_9, 32));
|
|
/* jump to fd_array store if fd denotes module BTF */
|
|
emit(gen, BPF_JMP_IMM(BPF_JNE, BPF_REG_9, 0, 2));
|
|
/* set the default value for off */
|
|
emit(gen, BPF_ST_MEM(BPF_H, BPF_REG_8, offsetof(struct bpf_insn, off), 0));
|
|
/* skip BTF fd store for vmlinux BTF */
|
|
emit(gen, BPF_JMP_IMM(BPF_JA, 0, 0, 4));
|
|
/* load fd_array slot pointer */
|
|
emit2(gen, BPF_LD_IMM64_RAW_FULL(BPF_REG_0, BPF_PSEUDO_MAP_IDX_VALUE,
|
|
0, 0, 0, blob_fd_array_off(gen, btf_fd_idx)));
|
|
/* store BTF fd in slot */
|
|
emit(gen, BPF_STX_MEM(BPF_W, BPF_REG_0, BPF_REG_9, 0));
|
|
/* store index into insn[insn_idx].off */
|
|
emit(gen, BPF_ST_MEM(BPF_H, BPF_REG_8, offsetof(struct bpf_insn, off), btf_fd_idx));
|
|
log:
|
|
if (!gen->log_level)
|
|
return;
|
|
emit(gen, BPF_LDX_MEM(BPF_W, BPF_REG_7, BPF_REG_8,
|
|
offsetof(struct bpf_insn, imm)));
|
|
emit(gen, BPF_LDX_MEM(BPF_H, BPF_REG_9, BPF_REG_8,
|
|
offsetof(struct bpf_insn, off)));
|
|
debug_regs(gen, BPF_REG_7, BPF_REG_9, " func (%s:count=%d): imm: %%d, off: %%d",
|
|
relo->name, kdesc->ref);
|
|
emit2(gen, BPF_LD_IMM64_RAW_FULL(BPF_REG_0, BPF_PSEUDO_MAP_IDX_VALUE,
|
|
0, 0, 0, blob_fd_array_off(gen, kdesc->off)));
|
|
emit(gen, BPF_LDX_MEM(BPF_W, BPF_REG_9, BPF_REG_0, 0));
|
|
debug_regs(gen, BPF_REG_9, -1, " func (%s:count=%d): btf_fd",
|
|
relo->name, kdesc->ref);
|
|
}
|
|
|
|
static void emit_ksym_relo_log(struct bpf_gen *gen, struct ksym_relo_desc *relo,
|
|
int ref)
|
|
{
|
|
if (!gen->log_level)
|
|
return;
|
|
emit(gen, BPF_LDX_MEM(BPF_W, BPF_REG_7, BPF_REG_8,
|
|
offsetof(struct bpf_insn, imm)));
|
|
emit(gen, BPF_LDX_MEM(BPF_H, BPF_REG_9, BPF_REG_8, sizeof(struct bpf_insn) +
|
|
offsetof(struct bpf_insn, imm)));
|
|
debug_regs(gen, BPF_REG_7, BPF_REG_9, " var t=%d w=%d (%s:count=%d): imm[0]: %%d, imm[1]: %%d",
|
|
relo->is_typeless, relo->is_weak, relo->name, ref);
|
|
emit(gen, BPF_LDX_MEM(BPF_B, BPF_REG_9, BPF_REG_8, offsetofend(struct bpf_insn, code)));
|
|
debug_regs(gen, BPF_REG_9, -1, " var t=%d w=%d (%s:count=%d): insn.reg",
|
|
relo->is_typeless, relo->is_weak, relo->name, ref);
|
|
}
|
|
|
|
/* Expects:
|
|
* BPF_REG_8 - pointer to instruction
|
|
*/
|
|
static void emit_relo_ksym_typeless(struct bpf_gen *gen,
|
|
struct ksym_relo_desc *relo, int insn)
|
|
{
|
|
struct ksym_desc *kdesc;
|
|
|
|
kdesc = get_ksym_desc(gen, relo);
|
|
if (!kdesc)
|
|
return;
|
|
/* try to copy from existing ldimm64 insn */
|
|
if (kdesc->ref > 1) {
|
|
move_blob2blob(gen, insn + offsetof(struct bpf_insn, imm), 4,
|
|
kdesc->insn + offsetof(struct bpf_insn, imm));
|
|
move_blob2blob(gen, insn + sizeof(struct bpf_insn) + offsetof(struct bpf_insn, imm), 4,
|
|
kdesc->insn + sizeof(struct bpf_insn) + offsetof(struct bpf_insn, imm));
|
|
goto log;
|
|
}
|
|
/* remember insn offset, so we can copy ksym addr later */
|
|
kdesc->insn = insn;
|
|
/* skip typeless ksym_desc in fd closing loop in cleanup_relos */
|
|
kdesc->typeless = true;
|
|
emit_bpf_kallsyms_lookup_name(gen, relo);
|
|
emit(gen, BPF_JMP_IMM(BPF_JEQ, BPF_REG_7, -ENOENT, 1));
|
|
emit_check_err(gen);
|
|
/* store lower half of addr into insn[insn_idx].imm */
|
|
emit(gen, BPF_STX_MEM(BPF_W, BPF_REG_8, BPF_REG_9, offsetof(struct bpf_insn, imm)));
|
|
/* store upper half of addr into insn[insn_idx + 1].imm */
|
|
emit(gen, BPF_ALU64_IMM(BPF_RSH, BPF_REG_9, 32));
|
|
emit(gen, BPF_STX_MEM(BPF_W, BPF_REG_8, BPF_REG_9,
|
|
sizeof(struct bpf_insn) + offsetof(struct bpf_insn, imm)));
|
|
log:
|
|
emit_ksym_relo_log(gen, relo, kdesc->ref);
|
|
}
|
|
|
|
static __u32 src_reg_mask(void)
|
|
{
|
|
#if defined(__LITTLE_ENDIAN_BITFIELD)
|
|
return 0x0f; /* src_reg,dst_reg,... */
|
|
#elif defined(__BIG_ENDIAN_BITFIELD)
|
|
return 0xf0; /* dst_reg,src_reg,... */
|
|
#else
|
|
#error "Unsupported bit endianness, cannot proceed"
|
|
#endif
|
|
}
|
|
|
|
/* Expects:
|
|
* BPF_REG_8 - pointer to instruction
|
|
*/
|
|
static void emit_relo_ksym_btf(struct bpf_gen *gen, struct ksym_relo_desc *relo, int insn)
|
|
{
|
|
struct ksym_desc *kdesc;
|
|
__u32 reg_mask;
|
|
|
|
kdesc = get_ksym_desc(gen, relo);
|
|
if (!kdesc)
|
|
return;
|
|
/* try to copy from existing ldimm64 insn */
|
|
if (kdesc->ref > 1) {
|
|
move_blob2blob(gen, insn + offsetof(struct bpf_insn, imm), 4,
|
|
kdesc->insn + offsetof(struct bpf_insn, imm));
|
|
move_blob2blob(gen, insn + sizeof(struct bpf_insn) + offsetof(struct bpf_insn, imm), 4,
|
|
kdesc->insn + sizeof(struct bpf_insn) + offsetof(struct bpf_insn, imm));
|
|
/* jump over src_reg adjustment if imm is not 0, reuse BPF_REG_0 from move_blob2blob */
|
|
emit(gen, BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 3));
|
|
goto clear_src_reg;
|
|
}
|
|
/* remember insn offset, so we can copy BTF ID and FD later */
|
|
kdesc->insn = insn;
|
|
emit_bpf_find_by_name_kind(gen, relo);
|
|
if (!relo->is_weak)
|
|
emit_check_err(gen);
|
|
/* jump to success case */
|
|
emit(gen, BPF_JMP_IMM(BPF_JSGE, BPF_REG_7, 0, 3));
|
|
/* set values for insn[insn_idx].imm, insn[insn_idx + 1].imm as 0 */
|
|
emit(gen, BPF_ST_MEM(BPF_W, BPF_REG_8, offsetof(struct bpf_insn, imm), 0));
|
|
emit(gen, BPF_ST_MEM(BPF_W, BPF_REG_8, sizeof(struct bpf_insn) + offsetof(struct bpf_insn, imm), 0));
|
|
/* skip success case for ret < 0 */
|
|
emit(gen, BPF_JMP_IMM(BPF_JA, 0, 0, 4));
|
|
/* store btf_id into insn[insn_idx].imm */
|
|
emit(gen, BPF_STX_MEM(BPF_W, BPF_REG_8, BPF_REG_7, offsetof(struct bpf_insn, imm)));
|
|
/* store btf_obj_fd into insn[insn_idx + 1].imm */
|
|
emit(gen, BPF_ALU64_IMM(BPF_RSH, BPF_REG_7, 32));
|
|
emit(gen, BPF_STX_MEM(BPF_W, BPF_REG_8, BPF_REG_7,
|
|
sizeof(struct bpf_insn) + offsetof(struct bpf_insn, imm)));
|
|
/* skip src_reg adjustment */
|
|
emit(gen, BPF_JMP_IMM(BPF_JSGE, BPF_REG_7, 0, 3));
|
|
clear_src_reg:
|
|
/* clear bpf_object__relocate_data's src_reg assignment, otherwise we get a verifier failure */
|
|
reg_mask = src_reg_mask();
|
|
emit(gen, BPF_LDX_MEM(BPF_B, BPF_REG_9, BPF_REG_8, offsetofend(struct bpf_insn, code)));
|
|
emit(gen, BPF_ALU32_IMM(BPF_AND, BPF_REG_9, reg_mask));
|
|
emit(gen, BPF_STX_MEM(BPF_B, BPF_REG_8, BPF_REG_9, offsetofend(struct bpf_insn, code)));
|
|
|
|
emit_ksym_relo_log(gen, relo, kdesc->ref);
|
|
}
|
|
|
|
void bpf_gen__record_relo_core(struct bpf_gen *gen,
|
|
const struct bpf_core_relo *core_relo)
|
|
{
|
|
struct bpf_core_relo *relos;
|
|
|
|
relos = libbpf_reallocarray(gen->core_relos, gen->core_relo_cnt + 1, sizeof(*relos));
|
|
if (!relos) {
|
|
gen->error = -ENOMEM;
|
|
return;
|
|
}
|
|
gen->core_relos = relos;
|
|
relos += gen->core_relo_cnt;
|
|
memcpy(relos, core_relo, sizeof(*relos));
|
|
gen->core_relo_cnt++;
|
|
}
|
|
|
|
static void emit_relo(struct bpf_gen *gen, struct ksym_relo_desc *relo, int insns)
|
|
{
|
|
int insn;
|
|
|
|
pr_debug("gen: emit_relo (%d): %s at %d\n", relo->kind, relo->name, relo->insn_idx);
|
|
insn = insns + sizeof(struct bpf_insn) * relo->insn_idx;
|
|
emit2(gen, BPF_LD_IMM64_RAW_FULL(BPF_REG_8, BPF_PSEUDO_MAP_IDX_VALUE, 0, 0, 0, insn));
|
|
switch (relo->kind) {
|
|
case BTF_KIND_VAR:
|
|
if (relo->is_typeless)
|
|
emit_relo_ksym_typeless(gen, relo, insn);
|
|
else
|
|
emit_relo_ksym_btf(gen, relo, insn);
|
|
break;
|
|
case BTF_KIND_FUNC:
|
|
emit_relo_kfunc_btf(gen, relo, insn);
|
|
break;
|
|
default:
|
|
pr_warn("Unknown relocation kind '%d'\n", relo->kind);
|
|
gen->error = -EDOM;
|
|
return;
|
|
}
|
|
}
|
|
|
|
static void emit_relos(struct bpf_gen *gen, int insns)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < gen->relo_cnt; i++)
|
|
emit_relo(gen, gen->relos + i, insns);
|
|
}
|
|
|
|
static void cleanup_core_relo(struct bpf_gen *gen)
|
|
{
|
|
if (!gen->core_relo_cnt)
|
|
return;
|
|
free(gen->core_relos);
|
|
gen->core_relo_cnt = 0;
|
|
gen->core_relos = NULL;
|
|
}
|
|
|
|
static void cleanup_relos(struct bpf_gen *gen, int insns)
|
|
{
|
|
int i, insn;
|
|
|
|
for (i = 0; i < gen->nr_ksyms; i++) {
|
|
/* only close fds for typed ksyms and kfuncs */
|
|
if (gen->ksyms[i].kind == BTF_KIND_VAR && !gen->ksyms[i].typeless) {
|
|
/* close fd recorded in insn[insn_idx + 1].imm */
|
|
insn = gen->ksyms[i].insn;
|
|
insn += sizeof(struct bpf_insn) + offsetof(struct bpf_insn, imm);
|
|
emit_sys_close_blob(gen, insn);
|
|
} else if (gen->ksyms[i].kind == BTF_KIND_FUNC) {
|
|
emit_sys_close_blob(gen, blob_fd_array_off(gen, gen->ksyms[i].off));
|
|
if (gen->ksyms[i].off < MAX_FD_ARRAY_SZ)
|
|
gen->nr_fd_array--;
|
|
}
|
|
}
|
|
if (gen->nr_ksyms) {
|
|
free(gen->ksyms);
|
|
gen->nr_ksyms = 0;
|
|
gen->ksyms = NULL;
|
|
}
|
|
if (gen->relo_cnt) {
|
|
free(gen->relos);
|
|
gen->relo_cnt = 0;
|
|
gen->relos = NULL;
|
|
}
|
|
cleanup_core_relo(gen);
|
|
}
|
|
|
|
void bpf_gen__prog_load(struct bpf_gen *gen,
|
|
enum bpf_prog_type prog_type, const char *prog_name,
|
|
const char *license, struct bpf_insn *insns, size_t insn_cnt,
|
|
struct bpf_prog_load_opts *load_attr, int prog_idx)
|
|
{
|
|
int prog_load_attr, license_off, insns_off, func_info, line_info, core_relos;
|
|
int attr_size = offsetofend(union bpf_attr, core_relo_rec_size);
|
|
union bpf_attr attr;
|
|
|
|
memset(&attr, 0, attr_size);
|
|
pr_debug("gen: prog_load: type %d insns_cnt %zd progi_idx %d\n",
|
|
prog_type, insn_cnt, prog_idx);
|
|
/* add license string to blob of bytes */
|
|
license_off = add_data(gen, license, strlen(license) + 1);
|
|
/* add insns to blob of bytes */
|
|
insns_off = add_data(gen, insns, insn_cnt * sizeof(struct bpf_insn));
|
|
|
|
attr.prog_type = prog_type;
|
|
attr.expected_attach_type = load_attr->expected_attach_type;
|
|
attr.attach_btf_id = load_attr->attach_btf_id;
|
|
attr.prog_ifindex = load_attr->prog_ifindex;
|
|
attr.kern_version = 0;
|
|
attr.insn_cnt = (__u32)insn_cnt;
|
|
attr.prog_flags = load_attr->prog_flags;
|
|
|
|
attr.func_info_rec_size = load_attr->func_info_rec_size;
|
|
attr.func_info_cnt = load_attr->func_info_cnt;
|
|
func_info = add_data(gen, load_attr->func_info,
|
|
attr.func_info_cnt * attr.func_info_rec_size);
|
|
|
|
attr.line_info_rec_size = load_attr->line_info_rec_size;
|
|
attr.line_info_cnt = load_attr->line_info_cnt;
|
|
line_info = add_data(gen, load_attr->line_info,
|
|
attr.line_info_cnt * attr.line_info_rec_size);
|
|
|
|
attr.core_relo_rec_size = sizeof(struct bpf_core_relo);
|
|
attr.core_relo_cnt = gen->core_relo_cnt;
|
|
core_relos = add_data(gen, gen->core_relos,
|
|
attr.core_relo_cnt * attr.core_relo_rec_size);
|
|
|
|
libbpf_strlcpy(attr.prog_name, prog_name, sizeof(attr.prog_name));
|
|
prog_load_attr = add_data(gen, &attr, attr_size);
|
|
|
|
/* populate union bpf_attr with a pointer to license */
|
|
emit_rel_store(gen, attr_field(prog_load_attr, license), license_off);
|
|
|
|
/* populate union bpf_attr with a pointer to instructions */
|
|
emit_rel_store(gen, attr_field(prog_load_attr, insns), insns_off);
|
|
|
|
/* populate union bpf_attr with a pointer to func_info */
|
|
emit_rel_store(gen, attr_field(prog_load_attr, func_info), func_info);
|
|
|
|
/* populate union bpf_attr with a pointer to line_info */
|
|
emit_rel_store(gen, attr_field(prog_load_attr, line_info), line_info);
|
|
|
|
/* populate union bpf_attr with a pointer to core_relos */
|
|
emit_rel_store(gen, attr_field(prog_load_attr, core_relos), core_relos);
|
|
|
|
/* populate union bpf_attr fd_array with a pointer to data where map_fds are saved */
|
|
emit_rel_store(gen, attr_field(prog_load_attr, fd_array), gen->fd_array);
|
|
|
|
/* populate union bpf_attr with user provided log details */
|
|
move_ctx2blob(gen, attr_field(prog_load_attr, log_level), 4,
|
|
offsetof(struct bpf_loader_ctx, log_level), false);
|
|
move_ctx2blob(gen, attr_field(prog_load_attr, log_size), 4,
|
|
offsetof(struct bpf_loader_ctx, log_size), false);
|
|
move_ctx2blob(gen, attr_field(prog_load_attr, log_buf), 8,
|
|
offsetof(struct bpf_loader_ctx, log_buf), false);
|
|
/* populate union bpf_attr with btf_fd saved in the stack earlier */
|
|
move_stack2blob(gen, attr_field(prog_load_attr, prog_btf_fd), 4,
|
|
stack_off(btf_fd));
|
|
if (gen->attach_kind) {
|
|
emit_find_attach_target(gen);
|
|
/* populate union bpf_attr with btf_id and btf_obj_fd found by helper */
|
|
emit2(gen, BPF_LD_IMM64_RAW_FULL(BPF_REG_0, BPF_PSEUDO_MAP_IDX_VALUE,
|
|
0, 0, 0, prog_load_attr));
|
|
emit(gen, BPF_STX_MEM(BPF_W, BPF_REG_0, BPF_REG_7,
|
|
offsetof(union bpf_attr, attach_btf_id)));
|
|
emit(gen, BPF_ALU64_IMM(BPF_RSH, BPF_REG_7, 32));
|
|
emit(gen, BPF_STX_MEM(BPF_W, BPF_REG_0, BPF_REG_7,
|
|
offsetof(union bpf_attr, attach_btf_obj_fd)));
|
|
}
|
|
emit_relos(gen, insns_off);
|
|
/* emit PROG_LOAD command */
|
|
emit_sys_bpf(gen, BPF_PROG_LOAD, prog_load_attr, attr_size);
|
|
debug_ret(gen, "prog_load %s insn_cnt %d", attr.prog_name, attr.insn_cnt);
|
|
/* successful or not, close btf module FDs used in extern ksyms and attach_btf_obj_fd */
|
|
cleanup_relos(gen, insns_off);
|
|
if (gen->attach_kind) {
|
|
emit_sys_close_blob(gen,
|
|
attr_field(prog_load_attr, attach_btf_obj_fd));
|
|
gen->attach_kind = 0;
|
|
}
|
|
emit_check_err(gen);
|
|
/* remember prog_fd in the stack, if successful */
|
|
emit(gen, BPF_STX_MEM(BPF_W, BPF_REG_10, BPF_REG_7,
|
|
stack_off(prog_fd[gen->nr_progs])));
|
|
gen->nr_progs++;
|
|
}
|
|
|
|
void bpf_gen__map_update_elem(struct bpf_gen *gen, int map_idx, void *pvalue,
|
|
__u32 value_size)
|
|
{
|
|
int attr_size = offsetofend(union bpf_attr, flags);
|
|
int map_update_attr, value, key;
|
|
union bpf_attr attr;
|
|
int zero = 0;
|
|
|
|
memset(&attr, 0, attr_size);
|
|
pr_debug("gen: map_update_elem: idx %d\n", map_idx);
|
|
|
|
value = add_data(gen, pvalue, value_size);
|
|
key = add_data(gen, &zero, sizeof(zero));
|
|
|
|
/* if (map_desc[map_idx].initial_value) {
|
|
* if (ctx->flags & BPF_SKEL_KERNEL)
|
|
* bpf_probe_read_kernel(value, value_size, initial_value);
|
|
* else
|
|
* bpf_copy_from_user(value, value_size, initial_value);
|
|
* }
|
|
*/
|
|
emit(gen, BPF_LDX_MEM(BPF_DW, BPF_REG_3, BPF_REG_6,
|
|
sizeof(struct bpf_loader_ctx) +
|
|
sizeof(struct bpf_map_desc) * map_idx +
|
|
offsetof(struct bpf_map_desc, initial_value)));
|
|
emit(gen, BPF_JMP_IMM(BPF_JEQ, BPF_REG_3, 0, 8));
|
|
emit2(gen, BPF_LD_IMM64_RAW_FULL(BPF_REG_1, BPF_PSEUDO_MAP_IDX_VALUE,
|
|
0, 0, 0, value));
|
|
emit(gen, BPF_MOV64_IMM(BPF_REG_2, value_size));
|
|
emit(gen, BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_6,
|
|
offsetof(struct bpf_loader_ctx, flags)));
|
|
emit(gen, BPF_JMP_IMM(BPF_JSET, BPF_REG_0, BPF_SKEL_KERNEL, 2));
|
|
emit(gen, BPF_EMIT_CALL(BPF_FUNC_copy_from_user));
|
|
emit(gen, BPF_JMP_IMM(BPF_JA, 0, 0, 1));
|
|
emit(gen, BPF_EMIT_CALL(BPF_FUNC_probe_read_kernel));
|
|
|
|
map_update_attr = add_data(gen, &attr, attr_size);
|
|
move_blob2blob(gen, attr_field(map_update_attr, map_fd), 4,
|
|
blob_fd_array_off(gen, map_idx));
|
|
emit_rel_store(gen, attr_field(map_update_attr, key), key);
|
|
emit_rel_store(gen, attr_field(map_update_attr, value), value);
|
|
/* emit MAP_UPDATE_ELEM command */
|
|
emit_sys_bpf(gen, BPF_MAP_UPDATE_ELEM, map_update_attr, attr_size);
|
|
debug_ret(gen, "update_elem idx %d value_size %d", map_idx, value_size);
|
|
emit_check_err(gen);
|
|
}
|
|
|
|
void bpf_gen__populate_outer_map(struct bpf_gen *gen, int outer_map_idx, int slot,
|
|
int inner_map_idx)
|
|
{
|
|
int attr_size = offsetofend(union bpf_attr, flags);
|
|
int map_update_attr, key;
|
|
union bpf_attr attr;
|
|
|
|
memset(&attr, 0, attr_size);
|
|
pr_debug("gen: populate_outer_map: outer %d key %d inner %d\n",
|
|
outer_map_idx, slot, inner_map_idx);
|
|
|
|
key = add_data(gen, &slot, sizeof(slot));
|
|
|
|
map_update_attr = add_data(gen, &attr, attr_size);
|
|
move_blob2blob(gen, attr_field(map_update_attr, map_fd), 4,
|
|
blob_fd_array_off(gen, outer_map_idx));
|
|
emit_rel_store(gen, attr_field(map_update_attr, key), key);
|
|
emit_rel_store(gen, attr_field(map_update_attr, value),
|
|
blob_fd_array_off(gen, inner_map_idx));
|
|
|
|
/* emit MAP_UPDATE_ELEM command */
|
|
emit_sys_bpf(gen, BPF_MAP_UPDATE_ELEM, map_update_attr, attr_size);
|
|
debug_ret(gen, "populate_outer_map outer %d key %d inner %d",
|
|
outer_map_idx, slot, inner_map_idx);
|
|
emit_check_err(gen);
|
|
}
|
|
|
|
void bpf_gen__map_freeze(struct bpf_gen *gen, int map_idx)
|
|
{
|
|
int attr_size = offsetofend(union bpf_attr, map_fd);
|
|
int map_freeze_attr;
|
|
union bpf_attr attr;
|
|
|
|
memset(&attr, 0, attr_size);
|
|
pr_debug("gen: map_freeze: idx %d\n", map_idx);
|
|
map_freeze_attr = add_data(gen, &attr, attr_size);
|
|
move_blob2blob(gen, attr_field(map_freeze_attr, map_fd), 4,
|
|
blob_fd_array_off(gen, map_idx));
|
|
/* emit MAP_FREEZE command */
|
|
emit_sys_bpf(gen, BPF_MAP_FREEZE, map_freeze_attr, attr_size);
|
|
debug_ret(gen, "map_freeze");
|
|
emit_check_err(gen);
|
|
}
|