linux/tools/bpf/bpftool/main.h
<<
>>
Prefs
   1/* SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) */
   2/* Copyright (C) 2017-2018 Netronome Systems, Inc. */
   3
   4#ifndef __BPF_TOOL_H
   5#define __BPF_TOOL_H
   6
   7/* BFD and kernel.h both define GCC_VERSION, differently */
   8#undef GCC_VERSION
   9#include <stdbool.h>
  10#include <stdio.h>
  11#include <stdlib.h>
  12#include <linux/bpf.h>
  13#include <linux/compiler.h>
  14#include <linux/kernel.h>
  15
  16#include <bpf/hashmap.h>
  17#include <bpf/libbpf.h>
  18
  19#include "json_writer.h"
  20
  21/* Make sure we do not use kernel-only integer typedefs */
  22#pragma GCC poison u8 u16 u32 u64 s8 s16 s32 s64
  23
  24static inline __u64 ptr_to_u64(const void *ptr)
  25{
  26        return (__u64)(unsigned long)ptr;
  27}
  28
  29static inline void *u64_to_ptr(__u64 ptr)
  30{
  31        return (void *)(unsigned long)ptr;
  32}
  33
  34#define NEXT_ARG()      ({ argc--; argv++; if (argc < 0) usage(); })
  35#define NEXT_ARGP()     ({ (*argc)--; (*argv)++; if (*argc < 0) usage(); })
  36#define BAD_ARG()       ({ p_err("what is '%s'?", *argv); -1; })
  37#define GET_ARG()       ({ argc--; *argv++; })
  38#define REQ_ARGS(cnt)                                                   \
  39        ({                                                              \
  40                int _cnt = (cnt);                                       \
  41                bool _res;                                              \
  42                                                                        \
  43                if (argc < _cnt) {                                      \
  44                        p_err("'%s' needs at least %d arguments, %d found", \
  45                              argv[-1], _cnt, argc);                    \
  46                        _res = false;                                   \
  47                } else {                                                \
  48                        _res = true;                                    \
  49                }                                                       \
  50                _res;                                                   \
  51        })
  52
  53#define ERR_MAX_LEN     1024
  54
  55#define BPF_TAG_FMT     "%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx"
  56
  57#define HELP_SPEC_PROGRAM                                               \
  58        "PROG := { id PROG_ID | pinned FILE | tag PROG_TAG | name PROG_NAME }"
  59#define HELP_SPEC_OPTIONS                                               \
  60        "OPTIONS := { {-j|--json} [{-p|--pretty}] | {-d|--debug} | {-l|--legacy}"
  61#define HELP_SPEC_MAP                                                   \
  62        "MAP := { id MAP_ID | pinned FILE | name MAP_NAME }"
  63#define HELP_SPEC_LINK                                                  \
  64        "LINK := { id LINK_ID | pinned FILE }"
  65
  66extern const char * const prog_type_name[];
  67extern const size_t prog_type_name_size;
  68
  69extern const char * const attach_type_name[__MAX_BPF_ATTACH_TYPE];
  70
  71extern const char * const map_type_name[];
  72extern const size_t map_type_name_size;
  73
  74/* keep in sync with the definition in skeleton/pid_iter.bpf.c */
  75enum bpf_obj_type {
  76        BPF_OBJ_UNKNOWN,
  77        BPF_OBJ_PROG,
  78        BPF_OBJ_MAP,
  79        BPF_OBJ_LINK,
  80        BPF_OBJ_BTF,
  81};
  82
  83extern const char *bin_name;
  84
  85extern json_writer_t *json_wtr;
  86extern bool json_output;
  87extern bool show_pinned;
  88extern bool show_pids;
  89extern bool block_mount;
  90extern bool verifier_logs;
  91extern bool relaxed_maps;
  92extern bool use_loader;
  93extern bool legacy_libbpf;
  94extern struct btf *base_btf;
  95extern struct hashmap *refs_table;
  96
  97void __printf(1, 2) p_err(const char *fmt, ...);
  98void __printf(1, 2) p_info(const char *fmt, ...);
  99
 100bool is_prefix(const char *pfx, const char *str);
 101int detect_common_prefix(const char *arg, ...);
 102void fprint_hex(FILE *f, void *arg, unsigned int n, const char *sep);
 103void usage(void) __noreturn;
 104
 105void set_max_rlimit(void);
 106
 107int mount_tracefs(const char *target);
 108
 109struct obj_ref {
 110        int pid;
 111        char comm[16];
 112};
 113
 114struct obj_refs {
 115        int ref_cnt;
 116        bool has_bpf_cookie;
 117        struct obj_ref *refs;
 118        __u64 bpf_cookie;
 119};
 120
 121struct btf;
 122struct bpf_line_info;
 123
 124int build_pinned_obj_table(struct hashmap *table,
 125                           enum bpf_obj_type type);
 126void delete_pinned_obj_table(struct hashmap *table);
 127__weak int build_obj_refs_table(struct hashmap **table,
 128                                enum bpf_obj_type type);
 129__weak void delete_obj_refs_table(struct hashmap *table);
 130__weak void emit_obj_refs_json(struct hashmap *table, __u32 id,
 131                               json_writer_t *json_wtr);
 132__weak void emit_obj_refs_plain(struct hashmap *table, __u32 id,
 133                                const char *prefix);
 134void print_dev_plain(__u32 ifindex, __u64 ns_dev, __u64 ns_inode);
 135void print_dev_json(__u32 ifindex, __u64 ns_dev, __u64 ns_inode);
 136
 137struct cmd {
 138        const char *cmd;
 139        int (*func)(int argc, char **argv);
 140};
 141
 142int cmd_select(const struct cmd *cmds, int argc, char **argv,
 143               int (*help)(int argc, char **argv));
 144
 145#define MAX_PROG_FULL_NAME 128
 146void get_prog_full_name(const struct bpf_prog_info *prog_info, int prog_fd,
 147                        char *name_buff, size_t buff_len);
 148
 149int get_fd_type(int fd);
 150const char *get_fd_type_name(enum bpf_obj_type type);
 151char *get_fdinfo(int fd, const char *key);
 152int open_obj_pinned(const char *path, bool quiet);
 153int open_obj_pinned_any(const char *path, enum bpf_obj_type exp_type);
 154int mount_bpffs_for_pin(const char *name);
 155int do_pin_any(int argc, char **argv, int (*get_fd_by_id)(int *, char ***));
 156int do_pin_fd(int fd, const char *name);
 157
 158/* commands available in bootstrap mode */
 159int do_gen(int argc, char **argv);
 160int do_btf(int argc, char **argv);
 161
 162/* non-bootstrap only commands */
 163int do_prog(int argc, char **arg) __weak;
 164int do_map(int argc, char **arg) __weak;
 165int do_link(int argc, char **arg) __weak;
 166int do_event_pipe(int argc, char **argv) __weak;
 167int do_cgroup(int argc, char **arg) __weak;
 168int do_perf(int argc, char **arg) __weak;
 169int do_net(int argc, char **arg) __weak;
 170int do_tracelog(int argc, char **arg) __weak;
 171int do_feature(int argc, char **argv) __weak;
 172int do_struct_ops(int argc, char **argv) __weak;
 173int do_iter(int argc, char **argv) __weak;
 174
 175int parse_u32_arg(int *argc, char ***argv, __u32 *val, const char *what);
 176int prog_parse_fd(int *argc, char ***argv);
 177int prog_parse_fds(int *argc, char ***argv, int **fds);
 178int map_parse_fd(int *argc, char ***argv);
 179int map_parse_fds(int *argc, char ***argv, int **fds);
 180int map_parse_fd_and_info(int *argc, char ***argv, void *info, __u32 *info_len);
 181
 182struct bpf_prog_linfo;
 183#ifdef HAVE_LIBBFD_SUPPORT
 184void disasm_print_insn(unsigned char *image, ssize_t len, int opcodes,
 185                       const char *arch, const char *disassembler_options,
 186                       const struct btf *btf,
 187                       const struct bpf_prog_linfo *prog_linfo,
 188                       __u64 func_ksym, unsigned int func_idx,
 189                       bool linum);
 190int disasm_init(void);
 191#else
 192static inline
 193void disasm_print_insn(unsigned char *image, ssize_t len, int opcodes,
 194                       const char *arch, const char *disassembler_options,
 195                       const struct btf *btf,
 196                       const struct bpf_prog_linfo *prog_linfo,
 197                       __u64 func_ksym, unsigned int func_idx,
 198                       bool linum)
 199{
 200}
 201static inline int disasm_init(void)
 202{
 203        p_err("No libbfd support");
 204        return -1;
 205}
 206#endif
 207void print_data_json(uint8_t *data, size_t len);
 208void print_hex_data_json(uint8_t *data, size_t len);
 209
 210unsigned int get_page_size(void);
 211unsigned int get_possible_cpus(void);
 212const char *
 213ifindex_to_bfd_params(__u32 ifindex, __u64 ns_dev, __u64 ns_ino,
 214                      const char **opt);
 215
 216struct btf_dumper {
 217        const struct btf *btf;
 218        json_writer_t *jw;
 219        bool is_plain_text;
 220        bool prog_id_as_func_ptr;
 221};
 222
 223/* btf_dumper_type - print data along with type information
 224 * @d: an instance containing context for dumping types
 225 * @type_id: index in btf->types array. this points to the type to be dumped
 226 * @data: pointer the actual data, i.e. the values to be printed
 227 *
 228 * Returns zero on success and negative error code otherwise
 229 */
 230int btf_dumper_type(const struct btf_dumper *d, __u32 type_id,
 231                    const void *data);
 232void btf_dumper_type_only(const struct btf *btf, __u32 func_type_id,
 233                          char *func_only, int size);
 234
 235void btf_dump_linfo_plain(const struct btf *btf,
 236                          const struct bpf_line_info *linfo,
 237                          const char *prefix, bool linum);
 238void btf_dump_linfo_json(const struct btf *btf,
 239                         const struct bpf_line_info *linfo, bool linum);
 240
 241struct nlattr;
 242struct ifinfomsg;
 243struct tcmsg;
 244int do_xdp_dump(struct ifinfomsg *ifinfo, struct nlattr **tb);
 245int do_filter_dump(struct tcmsg *ifinfo, struct nlattr **tb, const char *kind,
 246                   const char *devname, int ifindex);
 247
 248int print_all_levels(__maybe_unused enum libbpf_print_level level,
 249                     const char *format, va_list args);
 250
 251size_t hash_fn_for_key_as_id(const void *key, void *ctx);
 252bool equal_fn_for_key_as_id(const void *k1, const void *k2, void *ctx);
 253
 254static inline void *u32_as_hash_field(__u32 x)
 255{
 256        return (void *)(uintptr_t)x;
 257}
 258
 259static inline __u32 hash_field_as_u32(const void *x)
 260{
 261        return (__u32)(uintptr_t)x;
 262}
 263
 264static inline bool hashmap__empty(struct hashmap *map)
 265{
 266        return map ? hashmap__size(map) == 0 : true;
 267}
 268
 269#endif
 270