2018-03-02 02:01:18 +00:00
|
|
|
// SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
|
2018-12-13 03:59:25 +00:00
|
|
|
/* Copyright (C) 2018 Netronome Systems, Inc. */
|
2018-03-02 02:01:18 +00:00
|
|
|
|
|
|
|
#include <linux/list.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
|
|
|
|
|
|
|
#include "cfg.h"
|
|
|
|
#include "main.h"
|
2018-03-02 02:01:21 +00:00
|
|
|
#include "xlated_dumper.h"
|
2018-03-02 02:01:18 +00:00
|
|
|
|
|
|
|
struct cfg {
|
|
|
|
struct list_head funcs;
|
|
|
|
int func_num;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct func_node {
|
|
|
|
struct list_head l;
|
2018-03-02 02:01:19 +00:00
|
|
|
struct list_head bbs;
|
2018-03-02 02:01:18 +00:00
|
|
|
struct bpf_insn *start;
|
|
|
|
struct bpf_insn *end;
|
|
|
|
int idx;
|
2018-03-02 02:01:19 +00:00
|
|
|
int bb_num;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct bb_node {
|
|
|
|
struct list_head l;
|
2018-03-02 02:01:20 +00:00
|
|
|
struct list_head e_prevs;
|
|
|
|
struct list_head e_succs;
|
2018-03-02 02:01:19 +00:00
|
|
|
struct bpf_insn *head;
|
|
|
|
struct bpf_insn *tail;
|
|
|
|
int idx;
|
2018-03-02 02:01:18 +00:00
|
|
|
};
|
|
|
|
|
2018-03-02 02:01:20 +00:00
|
|
|
#define EDGE_FLAG_EMPTY 0x0
|
|
|
|
#define EDGE_FLAG_FALLTHROUGH 0x1
|
|
|
|
#define EDGE_FLAG_JUMP 0x2
|
|
|
|
struct edge_node {
|
|
|
|
struct list_head l;
|
|
|
|
struct bb_node *src;
|
|
|
|
struct bb_node *dst;
|
|
|
|
int flags;
|
|
|
|
};
|
|
|
|
|
|
|
|
#define ENTRY_BLOCK_INDEX 0
|
|
|
|
#define EXIT_BLOCK_INDEX 1
|
|
|
|
#define NUM_FIXED_BLOCKS 2
|
2018-03-02 02:01:18 +00:00
|
|
|
#define func_prev(func) list_prev_entry(func, l)
|
|
|
|
#define func_next(func) list_next_entry(func, l)
|
2018-03-02 02:01:19 +00:00
|
|
|
#define bb_prev(bb) list_prev_entry(bb, l)
|
|
|
|
#define bb_next(bb) list_next_entry(bb, l)
|
2018-03-02 02:01:20 +00:00
|
|
|
#define entry_bb(func) func_first_bb(func)
|
|
|
|
#define exit_bb(func) func_last_bb(func)
|
2018-03-02 02:01:18 +00:00
|
|
|
#define cfg_first_func(cfg) \
|
|
|
|
list_first_entry(&cfg->funcs, struct func_node, l)
|
|
|
|
#define cfg_last_func(cfg) \
|
|
|
|
list_last_entry(&cfg->funcs, struct func_node, l)
|
2018-03-02 02:01:19 +00:00
|
|
|
#define func_first_bb(func) \
|
|
|
|
list_first_entry(&func->bbs, struct bb_node, l)
|
|
|
|
#define func_last_bb(func) \
|
|
|
|
list_last_entry(&func->bbs, struct bb_node, l)
|
2018-03-02 02:01:18 +00:00
|
|
|
|
|
|
|
static struct func_node *cfg_append_func(struct cfg *cfg, struct bpf_insn *insn)
|
|
|
|
{
|
|
|
|
struct func_node *new_func, *func;
|
|
|
|
|
|
|
|
list_for_each_entry(func, &cfg->funcs, l) {
|
|
|
|
if (func->start == insn)
|
|
|
|
return func;
|
|
|
|
else if (func->start > insn)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
func = func_prev(func);
|
|
|
|
new_func = calloc(1, sizeof(*new_func));
|
|
|
|
if (!new_func) {
|
|
|
|
p_err("OOM when allocating FUNC node");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
new_func->start = insn;
|
|
|
|
new_func->idx = cfg->func_num;
|
|
|
|
list_add(&new_func->l, &func->l);
|
|
|
|
cfg->func_num++;
|
|
|
|
|
|
|
|
return new_func;
|
|
|
|
}
|
|
|
|
|
2018-03-02 02:01:19 +00:00
|
|
|
static struct bb_node *func_append_bb(struct func_node *func,
|
|
|
|
struct bpf_insn *insn)
|
|
|
|
{
|
|
|
|
struct bb_node *new_bb, *bb;
|
|
|
|
|
|
|
|
list_for_each_entry(bb, &func->bbs, l) {
|
|
|
|
if (bb->head == insn)
|
|
|
|
return bb;
|
|
|
|
else if (bb->head > insn)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
bb = bb_prev(bb);
|
|
|
|
new_bb = calloc(1, sizeof(*new_bb));
|
|
|
|
if (!new_bb) {
|
|
|
|
p_err("OOM when allocating BB node");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
new_bb->head = insn;
|
2018-03-02 02:01:20 +00:00
|
|
|
INIT_LIST_HEAD(&new_bb->e_prevs);
|
|
|
|
INIT_LIST_HEAD(&new_bb->e_succs);
|
2018-03-02 02:01:19 +00:00
|
|
|
list_add(&new_bb->l, &bb->l);
|
|
|
|
|
|
|
|
return new_bb;
|
|
|
|
}
|
|
|
|
|
2018-03-02 02:01:20 +00:00
|
|
|
static struct bb_node *func_insert_dummy_bb(struct list_head *after)
|
|
|
|
{
|
|
|
|
struct bb_node *bb;
|
|
|
|
|
|
|
|
bb = calloc(1, sizeof(*bb));
|
|
|
|
if (!bb) {
|
|
|
|
p_err("OOM when allocating BB node");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
INIT_LIST_HEAD(&bb->e_prevs);
|
|
|
|
INIT_LIST_HEAD(&bb->e_succs);
|
|
|
|
list_add(&bb->l, after);
|
|
|
|
|
|
|
|
return bb;
|
|
|
|
}
|
|
|
|
|
2018-03-02 02:01:18 +00:00
|
|
|
static bool cfg_partition_funcs(struct cfg *cfg, struct bpf_insn *cur,
|
|
|
|
struct bpf_insn *end)
|
|
|
|
{
|
|
|
|
struct func_node *func, *last_func;
|
|
|
|
|
|
|
|
func = cfg_append_func(cfg, cur);
|
|
|
|
if (!func)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
for (; cur < end; cur++) {
|
|
|
|
if (cur->code != (BPF_JMP | BPF_CALL))
|
|
|
|
continue;
|
|
|
|
if (cur->src_reg != BPF_PSEUDO_CALL)
|
|
|
|
continue;
|
|
|
|
func = cfg_append_func(cfg, cur + cur->off + 1);
|
|
|
|
if (!func)
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
last_func = cfg_last_func(cfg);
|
|
|
|
last_func->end = end - 1;
|
|
|
|
func = cfg_first_func(cfg);
|
|
|
|
list_for_each_entry_from(func, &last_func->l, l) {
|
|
|
|
func->end = func_next(func)->start - 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2020-05-11 16:15:33 +00:00
|
|
|
static bool is_jmp_insn(__u8 code)
|
2019-01-26 17:26:03 +00:00
|
|
|
{
|
|
|
|
return BPF_CLASS(code) == BPF_JMP || BPF_CLASS(code) == BPF_JMP32;
|
|
|
|
}
|
|
|
|
|
2018-03-02 02:01:19 +00:00
|
|
|
static bool func_partition_bb_head(struct func_node *func)
|
|
|
|
{
|
|
|
|
struct bpf_insn *cur, *end;
|
|
|
|
struct bb_node *bb;
|
|
|
|
|
|
|
|
cur = func->start;
|
|
|
|
end = func->end;
|
|
|
|
INIT_LIST_HEAD(&func->bbs);
|
|
|
|
bb = func_append_bb(func, cur);
|
|
|
|
if (!bb)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
for (; cur <= end; cur++) {
|
2019-01-26 17:26:03 +00:00
|
|
|
if (is_jmp_insn(cur->code)) {
|
2020-05-11 16:15:33 +00:00
|
|
|
__u8 opcode = BPF_OP(cur->code);
|
2018-03-02 02:01:19 +00:00
|
|
|
|
|
|
|
if (opcode == BPF_EXIT || opcode == BPF_CALL)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
bb = func_append_bb(func, cur + cur->off + 1);
|
|
|
|
if (!bb)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
if (opcode != BPF_JA) {
|
|
|
|
bb = func_append_bb(func, cur + 1);
|
|
|
|
if (!bb)
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void func_partition_bb_tail(struct func_node *func)
|
|
|
|
{
|
2018-03-02 02:01:20 +00:00
|
|
|
unsigned int bb_idx = NUM_FIXED_BLOCKS;
|
2018-03-02 02:01:19 +00:00
|
|
|
struct bb_node *bb, *last;
|
|
|
|
|
|
|
|
last = func_last_bb(func);
|
|
|
|
last->tail = func->end;
|
|
|
|
bb = func_first_bb(func);
|
|
|
|
list_for_each_entry_from(bb, &last->l, l) {
|
|
|
|
bb->tail = bb_next(bb)->head - 1;
|
|
|
|
bb->idx = bb_idx++;
|
|
|
|
}
|
|
|
|
|
|
|
|
last->idx = bb_idx++;
|
|
|
|
func->bb_num = bb_idx;
|
|
|
|
}
|
|
|
|
|
2018-03-02 02:01:20 +00:00
|
|
|
static bool func_add_special_bb(struct func_node *func)
|
|
|
|
{
|
|
|
|
struct bb_node *bb;
|
|
|
|
|
|
|
|
bb = func_insert_dummy_bb(&func->bbs);
|
|
|
|
if (!bb)
|
|
|
|
return true;
|
|
|
|
bb->idx = ENTRY_BLOCK_INDEX;
|
|
|
|
|
|
|
|
bb = func_insert_dummy_bb(&func_last_bb(func)->l);
|
|
|
|
if (!bb)
|
|
|
|
return true;
|
|
|
|
bb->idx = EXIT_BLOCK_INDEX;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2018-03-02 02:01:19 +00:00
|
|
|
static bool func_partition_bb(struct func_node *func)
|
|
|
|
{
|
|
|
|
if (func_partition_bb_head(func))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
func_partition_bb_tail(func);
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2018-03-02 02:01:20 +00:00
|
|
|
static struct bb_node *func_search_bb_with_head(struct func_node *func,
|
|
|
|
struct bpf_insn *insn)
|
|
|
|
{
|
|
|
|
struct bb_node *bb;
|
|
|
|
|
|
|
|
list_for_each_entry(bb, &func->bbs, l) {
|
|
|
|
if (bb->head == insn)
|
|
|
|
return bb;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct edge_node *new_edge(struct bb_node *src, struct bb_node *dst,
|
|
|
|
int flags)
|
|
|
|
{
|
|
|
|
struct edge_node *e;
|
|
|
|
|
|
|
|
e = calloc(1, sizeof(*e));
|
|
|
|
if (!e) {
|
|
|
|
p_err("OOM when allocating edge node");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (src)
|
|
|
|
e->src = src;
|
|
|
|
if (dst)
|
|
|
|
e->dst = dst;
|
|
|
|
|
|
|
|
e->flags |= flags;
|
|
|
|
|
|
|
|
return e;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool func_add_bb_edges(struct func_node *func)
|
|
|
|
{
|
|
|
|
struct bpf_insn *insn;
|
|
|
|
struct edge_node *e;
|
|
|
|
struct bb_node *bb;
|
|
|
|
|
|
|
|
bb = entry_bb(func);
|
|
|
|
e = new_edge(bb, bb_next(bb), EDGE_FLAG_FALLTHROUGH);
|
|
|
|
if (!e)
|
|
|
|
return true;
|
|
|
|
list_add_tail(&e->l, &bb->e_succs);
|
|
|
|
|
|
|
|
bb = exit_bb(func);
|
|
|
|
e = new_edge(bb_prev(bb), bb, EDGE_FLAG_FALLTHROUGH);
|
|
|
|
if (!e)
|
|
|
|
return true;
|
|
|
|
list_add_tail(&e->l, &bb->e_prevs);
|
|
|
|
|
|
|
|
bb = entry_bb(func);
|
|
|
|
bb = bb_next(bb);
|
|
|
|
list_for_each_entry_from(bb, &exit_bb(func)->l, l) {
|
|
|
|
e = new_edge(bb, NULL, EDGE_FLAG_EMPTY);
|
|
|
|
if (!e)
|
|
|
|
return true;
|
|
|
|
e->src = bb;
|
|
|
|
|
|
|
|
insn = bb->tail;
|
2019-01-26 17:26:03 +00:00
|
|
|
if (!is_jmp_insn(insn->code) ||
|
2018-03-02 02:01:20 +00:00
|
|
|
BPF_OP(insn->code) == BPF_EXIT) {
|
|
|
|
e->dst = bb_next(bb);
|
|
|
|
e->flags |= EDGE_FLAG_FALLTHROUGH;
|
|
|
|
list_add_tail(&e->l, &bb->e_succs);
|
|
|
|
continue;
|
|
|
|
} else if (BPF_OP(insn->code) == BPF_JA) {
|
|
|
|
e->dst = func_search_bb_with_head(func,
|
|
|
|
insn + insn->off + 1);
|
|
|
|
e->flags |= EDGE_FLAG_JUMP;
|
|
|
|
list_add_tail(&e->l, &bb->e_succs);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
e->dst = bb_next(bb);
|
|
|
|
e->flags |= EDGE_FLAG_FALLTHROUGH;
|
|
|
|
list_add_tail(&e->l, &bb->e_succs);
|
|
|
|
|
|
|
|
e = new_edge(bb, NULL, EDGE_FLAG_JUMP);
|
|
|
|
if (!e)
|
|
|
|
return true;
|
|
|
|
e->src = bb;
|
|
|
|
e->dst = func_search_bb_with_head(func, insn + insn->off + 1);
|
|
|
|
list_add_tail(&e->l, &bb->e_succs);
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2018-03-02 02:01:18 +00:00
|
|
|
static bool cfg_build(struct cfg *cfg, struct bpf_insn *insn, unsigned int len)
|
|
|
|
{
|
|
|
|
int cnt = len / sizeof(*insn);
|
2018-03-02 02:01:19 +00:00
|
|
|
struct func_node *func;
|
2018-03-02 02:01:18 +00:00
|
|
|
|
|
|
|
INIT_LIST_HEAD(&cfg->funcs);
|
|
|
|
|
2018-03-02 02:01:19 +00:00
|
|
|
if (cfg_partition_funcs(cfg, insn, insn + cnt))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
list_for_each_entry(func, &cfg->funcs, l) {
|
2018-03-02 02:01:20 +00:00
|
|
|
if (func_partition_bb(func) || func_add_special_bb(func))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
if (func_add_bb_edges(func))
|
2018-03-02 02:01:19 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
2018-03-02 02:01:18 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void cfg_destroy(struct cfg *cfg)
|
|
|
|
{
|
|
|
|
struct func_node *func, *func2;
|
|
|
|
|
|
|
|
list_for_each_entry_safe(func, func2, &cfg->funcs, l) {
|
2018-03-02 02:01:19 +00:00
|
|
|
struct bb_node *bb, *bb2;
|
|
|
|
|
|
|
|
list_for_each_entry_safe(bb, bb2, &func->bbs, l) {
|
2018-03-02 02:01:20 +00:00
|
|
|
struct edge_node *e, *e2;
|
|
|
|
|
|
|
|
list_for_each_entry_safe(e, e2, &bb->e_prevs, l) {
|
|
|
|
list_del(&e->l);
|
|
|
|
free(e);
|
|
|
|
}
|
|
|
|
|
|
|
|
list_for_each_entry_safe(e, e2, &bb->e_succs, l) {
|
|
|
|
list_del(&e->l);
|
|
|
|
free(e);
|
|
|
|
}
|
|
|
|
|
2018-03-02 02:01:19 +00:00
|
|
|
list_del(&bb->l);
|
|
|
|
free(bb);
|
|
|
|
}
|
|
|
|
|
2018-03-02 02:01:18 +00:00
|
|
|
list_del(&func->l);
|
|
|
|
free(func);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
bpftool: Support inline annotations when dumping the CFG of a program
We support dumping the control flow graph of loaded programs to the DOT
format with bpftool, but so far this feature wouldn't display the source
code lines available through BTF along with the eBPF bytecode. Let's add
support for these annotations, to make it easier to read the graph.
In prog.c, we move the call to dump_xlated_cfg() in order to pass and
use the full struct dump_data, instead of creating a minimal one in
draw_bb_node().
We pass the pointer to this struct down to dump_xlated_for_graph() in
xlated_dumper.c, where most of the logics is added. We deal with BTF
mostly like we do for plain or JSON output, except that we cannot use a
"nr_skip" value to skip a given number of linfo records (we don't
process the BPF instructions linearly, and apart from the root of the
graph we don't know how many records we should skip, so we just store
the last linfo and make sure the new one we find is different before
printing it).
When printing the source instructions to the label of a DOT graph node,
there are a few subtleties to address. We want some special newline
markers, and there are some characters that we must escape. To deal with
them, we introduce a new dedicated function btf_dump_linfo_dotlabel() in
btf_dumper.c. We'll reuse this function in a later commit to format the
filepath, line, and column references as well.
Signed-off-by: Quentin Monnet <quentin@isovalent.com>
Link: https://lore.kernel.org/r/20230405132120.59886-4-quentin@isovalent.com
Signed-off-by: Alexei Starovoitov <ast@kernel.org>
2023-04-05 13:21:16 +00:00
|
|
|
static void
|
2023-04-05 13:21:19 +00:00
|
|
|
draw_bb_node(struct func_node *func, struct bb_node *bb, struct dump_data *dd,
|
|
|
|
bool opcodes, bool linum)
|
2018-03-02 02:01:21 +00:00
|
|
|
{
|
|
|
|
const char *shape;
|
|
|
|
|
|
|
|
if (bb->idx == ENTRY_BLOCK_INDEX || bb->idx == EXIT_BLOCK_INDEX)
|
|
|
|
shape = "Mdiamond";
|
|
|
|
else
|
|
|
|
shape = "record";
|
|
|
|
|
|
|
|
printf("\tfn_%d_bb_%d [shape=%s,style=filled,label=\"",
|
|
|
|
func->idx, bb->idx, shape);
|
|
|
|
|
|
|
|
if (bb->idx == ENTRY_BLOCK_INDEX) {
|
|
|
|
printf("ENTRY");
|
|
|
|
} else if (bb->idx == EXIT_BLOCK_INDEX) {
|
|
|
|
printf("EXIT");
|
|
|
|
} else {
|
|
|
|
unsigned int start_idx;
|
bpftool: Support inline annotations when dumping the CFG of a program
We support dumping the control flow graph of loaded programs to the DOT
format with bpftool, but so far this feature wouldn't display the source
code lines available through BTF along with the eBPF bytecode. Let's add
support for these annotations, to make it easier to read the graph.
In prog.c, we move the call to dump_xlated_cfg() in order to pass and
use the full struct dump_data, instead of creating a minimal one in
draw_bb_node().
We pass the pointer to this struct down to dump_xlated_for_graph() in
xlated_dumper.c, where most of the logics is added. We deal with BTF
mostly like we do for plain or JSON output, except that we cannot use a
"nr_skip" value to skip a given number of linfo records (we don't
process the BPF instructions linearly, and apart from the root of the
graph we don't know how many records we should skip, so we just store
the last linfo and make sure the new one we find is different before
printing it).
When printing the source instructions to the label of a DOT graph node,
there are a few subtleties to address. We want some special newline
markers, and there are some characters that we must escape. To deal with
them, we introduce a new dedicated function btf_dump_linfo_dotlabel() in
btf_dumper.c. We'll reuse this function in a later commit to format the
filepath, line, and column references as well.
Signed-off-by: Quentin Monnet <quentin@isovalent.com>
Link: https://lore.kernel.org/r/20230405132120.59886-4-quentin@isovalent.com
Signed-off-by: Alexei Starovoitov <ast@kernel.org>
2023-04-05 13:21:16 +00:00
|
|
|
printf("{\\\n");
|
2018-03-02 02:01:21 +00:00
|
|
|
start_idx = bb->head - func->start;
|
2023-04-05 13:21:19 +00:00
|
|
|
dump_xlated_for_graph(dd, bb->head, bb->tail, start_idx,
|
|
|
|
opcodes, linum);
|
2018-03-02 02:01:21 +00:00
|
|
|
printf("}");
|
|
|
|
}
|
|
|
|
|
|
|
|
printf("\"];\n\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
static void draw_bb_succ_edges(struct func_node *func, struct bb_node *bb)
|
|
|
|
{
|
|
|
|
const char *style = "\"solid,bold\"";
|
|
|
|
const char *color = "black";
|
|
|
|
int func_idx = func->idx;
|
|
|
|
struct edge_node *e;
|
|
|
|
int weight = 10;
|
|
|
|
|
|
|
|
if (list_empty(&bb->e_succs))
|
|
|
|
return;
|
|
|
|
|
|
|
|
list_for_each_entry(e, &bb->e_succs, l) {
|
|
|
|
printf("\tfn_%d_bb_%d:s -> fn_%d_bb_%d:n [style=%s, color=%s, weight=%d, constraint=true",
|
|
|
|
func_idx, e->src->idx, func_idx, e->dst->idx,
|
|
|
|
style, color, weight);
|
|
|
|
printf("];\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-04-05 13:21:19 +00:00
|
|
|
static void
|
|
|
|
func_output_bb_def(struct func_node *func, struct dump_data *dd,
|
|
|
|
bool opcodes, bool linum)
|
2018-03-02 02:01:21 +00:00
|
|
|
{
|
|
|
|
struct bb_node *bb;
|
|
|
|
|
|
|
|
list_for_each_entry(bb, &func->bbs, l) {
|
2023-04-05 13:21:19 +00:00
|
|
|
draw_bb_node(func, bb, dd, opcodes, linum);
|
2018-03-02 02:01:21 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void func_output_edges(struct func_node *func)
|
|
|
|
{
|
|
|
|
int func_idx = func->idx;
|
|
|
|
struct bb_node *bb;
|
|
|
|
|
|
|
|
list_for_each_entry(bb, &func->bbs, l) {
|
|
|
|
draw_bb_succ_edges(func, bb);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Add an invisible edge from ENTRY to EXIT, this is to
|
|
|
|
* improve the graph layout.
|
|
|
|
*/
|
|
|
|
printf("\tfn_%d_bb_%d:s -> fn_%d_bb_%d:n [style=\"invis\", constraint=true];\n",
|
|
|
|
func_idx, ENTRY_BLOCK_INDEX, func_idx, EXIT_BLOCK_INDEX);
|
|
|
|
}
|
|
|
|
|
2023-04-05 13:21:19 +00:00
|
|
|
static void
|
|
|
|
cfg_dump(struct cfg *cfg, struct dump_data *dd, bool opcodes, bool linum)
|
2018-03-02 02:01:21 +00:00
|
|
|
{
|
|
|
|
struct func_node *func;
|
|
|
|
|
|
|
|
printf("digraph \"DOT graph for eBPF program\" {\n");
|
|
|
|
list_for_each_entry(func, &cfg->funcs, l) {
|
|
|
|
printf("subgraph \"cluster_%d\" {\n\tstyle=\"dashed\";\n\tcolor=\"black\";\n\tlabel=\"func_%d ()\";\n",
|
|
|
|
func->idx, func->idx);
|
2023-04-05 13:21:19 +00:00
|
|
|
func_output_bb_def(func, dd, opcodes, linum);
|
2018-03-02 02:01:21 +00:00
|
|
|
func_output_edges(func);
|
|
|
|
printf("}\n");
|
|
|
|
}
|
|
|
|
printf("}\n");
|
|
|
|
}
|
|
|
|
|
2023-04-05 13:21:19 +00:00
|
|
|
void dump_xlated_cfg(struct dump_data *dd, void *buf, unsigned int len,
|
|
|
|
bool opcodes, bool linum)
|
2018-03-02 02:01:18 +00:00
|
|
|
{
|
|
|
|
struct bpf_insn *insn = buf;
|
|
|
|
struct cfg cfg;
|
|
|
|
|
|
|
|
memset(&cfg, 0, sizeof(cfg));
|
|
|
|
if (cfg_build(&cfg, insn, len))
|
|
|
|
return;
|
|
|
|
|
2023-04-05 13:21:19 +00:00
|
|
|
cfg_dump(&cfg, dd, opcodes, linum);
|
2018-03-02 02:01:21 +00:00
|
|
|
|
2018-03-02 02:01:18 +00:00
|
|
|
cfg_destroy(&cfg);
|
|
|
|
}
|