cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

main.h (7975B)


      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
    105int mount_tracefs(const char *target);
    106
    107struct obj_ref {
    108	int pid;
    109	char comm[16];
    110};
    111
    112struct obj_refs {
    113	int ref_cnt;
    114	bool has_bpf_cookie;
    115	struct obj_ref *refs;
    116	__u64 bpf_cookie;
    117};
    118
    119struct btf;
    120struct bpf_line_info;
    121
    122int build_pinned_obj_table(struct hashmap *table,
    123			   enum bpf_obj_type type);
    124void delete_pinned_obj_table(struct hashmap *table);
    125__weak int build_obj_refs_table(struct hashmap **table,
    126				enum bpf_obj_type type);
    127__weak void delete_obj_refs_table(struct hashmap *table);
    128__weak void emit_obj_refs_json(struct hashmap *table, __u32 id,
    129			       json_writer_t *json_wtr);
    130__weak void emit_obj_refs_plain(struct hashmap *table, __u32 id,
    131				const char *prefix);
    132void print_dev_plain(__u32 ifindex, __u64 ns_dev, __u64 ns_inode);
    133void print_dev_json(__u32 ifindex, __u64 ns_dev, __u64 ns_inode);
    134
    135struct cmd {
    136	const char *cmd;
    137	int (*func)(int argc, char **argv);
    138};
    139
    140int cmd_select(const struct cmd *cmds, int argc, char **argv,
    141	       int (*help)(int argc, char **argv));
    142
    143#define MAX_PROG_FULL_NAME 128
    144void get_prog_full_name(const struct bpf_prog_info *prog_info, int prog_fd,
    145			char *name_buff, size_t buff_len);
    146
    147int get_fd_type(int fd);
    148const char *get_fd_type_name(enum bpf_obj_type type);
    149char *get_fdinfo(int fd, const char *key);
    150int open_obj_pinned(const char *path, bool quiet);
    151int open_obj_pinned_any(const char *path, enum bpf_obj_type exp_type);
    152int mount_bpffs_for_pin(const char *name);
    153int do_pin_any(int argc, char **argv, int (*get_fd_by_id)(int *, char ***));
    154int do_pin_fd(int fd, const char *name);
    155
    156/* commands available in bootstrap mode */
    157int do_gen(int argc, char **argv);
    158int do_btf(int argc, char **argv);
    159
    160/* non-bootstrap only commands */
    161int do_prog(int argc, char **arg) __weak;
    162int do_map(int argc, char **arg) __weak;
    163int do_link(int argc, char **arg) __weak;
    164int do_event_pipe(int argc, char **argv) __weak;
    165int do_cgroup(int argc, char **arg) __weak;
    166int do_perf(int argc, char **arg) __weak;
    167int do_net(int argc, char **arg) __weak;
    168int do_tracelog(int argc, char **arg) __weak;
    169int do_feature(int argc, char **argv) __weak;
    170int do_struct_ops(int argc, char **argv) __weak;
    171int do_iter(int argc, char **argv) __weak;
    172
    173int parse_u32_arg(int *argc, char ***argv, __u32 *val, const char *what);
    174int prog_parse_fd(int *argc, char ***argv);
    175int prog_parse_fds(int *argc, char ***argv, int **fds);
    176int map_parse_fd(int *argc, char ***argv);
    177int map_parse_fds(int *argc, char ***argv, int **fds);
    178int map_parse_fd_and_info(int *argc, char ***argv, void *info, __u32 *info_len);
    179
    180struct bpf_prog_linfo;
    181#ifdef HAVE_LIBBFD_SUPPORT
    182void disasm_print_insn(unsigned char *image, ssize_t len, int opcodes,
    183		       const char *arch, const char *disassembler_options,
    184		       const struct btf *btf,
    185		       const struct bpf_prog_linfo *prog_linfo,
    186		       __u64 func_ksym, unsigned int func_idx,
    187		       bool linum);
    188int disasm_init(void);
    189#else
    190static inline
    191void disasm_print_insn(unsigned char *image, ssize_t len, int opcodes,
    192		       const char *arch, const char *disassembler_options,
    193		       const struct btf *btf,
    194		       const struct bpf_prog_linfo *prog_linfo,
    195		       __u64 func_ksym, unsigned int func_idx,
    196		       bool linum)
    197{
    198}
    199static inline int disasm_init(void)
    200{
    201	p_err("No libbfd support");
    202	return -1;
    203}
    204#endif
    205void print_data_json(uint8_t *data, size_t len);
    206void print_hex_data_json(uint8_t *data, size_t len);
    207
    208unsigned int get_page_size(void);
    209unsigned int get_possible_cpus(void);
    210const char *
    211ifindex_to_bfd_params(__u32 ifindex, __u64 ns_dev, __u64 ns_ino,
    212		      const char **opt);
    213
    214struct btf_dumper {
    215	const struct btf *btf;
    216	json_writer_t *jw;
    217	bool is_plain_text;
    218	bool prog_id_as_func_ptr;
    219};
    220
    221/* btf_dumper_type - print data along with type information
    222 * @d: an instance containing context for dumping types
    223 * @type_id: index in btf->types array. this points to the type to be dumped
    224 * @data: pointer the actual data, i.e. the values to be printed
    225 *
    226 * Returns zero on success and negative error code otherwise
    227 */
    228int btf_dumper_type(const struct btf_dumper *d, __u32 type_id,
    229		    const void *data);
    230void btf_dumper_type_only(const struct btf *btf, __u32 func_type_id,
    231			  char *func_only, int size);
    232
    233void btf_dump_linfo_plain(const struct btf *btf,
    234			  const struct bpf_line_info *linfo,
    235			  const char *prefix, bool linum);
    236void btf_dump_linfo_json(const struct btf *btf,
    237			 const struct bpf_line_info *linfo, bool linum);
    238
    239struct nlattr;
    240struct ifinfomsg;
    241struct tcmsg;
    242int do_xdp_dump(struct ifinfomsg *ifinfo, struct nlattr **tb);
    243int do_filter_dump(struct tcmsg *ifinfo, struct nlattr **tb, const char *kind,
    244		   const char *devname, int ifindex);
    245
    246int print_all_levels(__maybe_unused enum libbpf_print_level level,
    247		     const char *format, va_list args);
    248
    249size_t hash_fn_for_key_as_id(const void *key, void *ctx);
    250bool equal_fn_for_key_as_id(const void *k1, const void *k2, void *ctx);
    251
    252static inline void *u32_as_hash_field(__u32 x)
    253{
    254	return (void *)(uintptr_t)x;
    255}
    256
    257static inline __u32 hash_field_as_u32(const void *x)
    258{
    259	return (__u32)(uintptr_t)x;
    260}
    261
    262static inline bool hashmap__empty(struct hashmap *map)
    263{
    264	return map ? hashmap__size(map) == 0 : true;
    265}
    266
    267#endif