tools/bpf/bpftool/btf_dumper.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Copyright (c) 2018 Facebook */
   3
   4 #include <ctype.h>
   5 #include <stdio.h> /* for (FILE *) used by json_writer */
   6 #include <string.h>
   7 #include <asm/byteorder.h>
   8 #include <linux/bitops.h>
   9 #include <linux/btf.h>
  10 #include <linux/err.h>
  11
  12 #include "btf.h"
  13 #include "json_writer.h"
  14 #include "main.h"
  15
  16 #define BITS_PER_BYTE_MASK (BITS_PER_BYTE - 1)
  17 #define BITS_PER_BYTE_MASKED(bits) ((bits) & BITS_PER_BYTE_MASK)
  18 #define BITS_ROUNDDOWN_BYTES(bits) ((bits) >> 3)
  19 #define BITS_ROUNDUP_BYTES(bits) \
  20         (BITS_ROUNDDOWN_BYTES(bits) + !!BITS_PER_BYTE_MASKED(bits))
  21
  22 static int btf_dumper_do_type(const struct btf_dumper *d, __u32 type_id,
  23                               __u8 bit_offset, const void *data);
  24
  25 static void btf_dumper_ptr(const void *data, json_writer_t *jw,
  26                            bool is_plain_text)
  27 {
  28         if (is_plain_text)
  29                 jsonw_printf(jw, "%p", *(void **)data);
  30         else
  31                 jsonw_printf(jw, "%lu", *(unsigned long *)data);
  32 }
  33
  34 static int btf_dumper_modifier(const struct btf_dumper *d, __u32 type_id,
  35                                __u8 bit_offset, const void *data)
  36 {
  37         int actual_type_id;
  38
  39         actual_type_id = btf__resolve_type(d->btf, type_id);
  40         if (actual_type_id < 0)
  41                 return actual_type_id;
  42
  43         return btf_dumper_do_type(d, actual_type_id, bit_offset, data);
  44 }
  45
  46 static void btf_dumper_enum(const void *data, json_writer_t *jw)
  47 {
  48         jsonw_printf(jw, "%d", *(int *)data);
  49 }
  50
  51 static int btf_dumper_array(const struct btf_dumper *d, __u32 type_id,
  52                             const void *data)
  53 {
  54         const struct btf_type *t = btf__type_by_id(d->btf, type_id);
  55         struct btf_array *arr = (struct btf_array *)(t + 1);
  56         long long elem_size;
  57         int ret = 0;
  58         __u32 i;
  59
  60         elem_size = btf__resolve_size(d->btf, arr->type);
  61         if (elem_size < 0)
  62                 return elem_size;
  63
  64         jsonw_start_array(d->jw);
  65         for (i = 0; i < arr->nelems; i++) {
  66                 ret = btf_dumper_do_type(d, arr->type, 0,
  67                                          data + i * elem_size);
  68                 if (ret)
  69                         break;
  70         }
  71
  72         jsonw_end_array(d->jw);
  73         return ret;
  74 }
  75
  76 static void btf_dumper_int_bits(__u32 int_type, __u8 bit_offset,
  77                                 const void *data, json_writer_t *jw,
  78                                 bool is_plain_text)
  79 {
  80         int left_shift_bits, right_shift_bits;
  81         int nr_bits = BTF_INT_BITS(int_type);
  82         int total_bits_offset;
  83         int bytes_to_copy;
  84         int bits_to_copy;
  85         __u64 print_num;
  86
  87         total_bits_offset = bit_offset + BTF_INT_OFFSET(int_type);
  88         data += BITS_ROUNDDOWN_BYTES(total_bits_offset);
  89         bit_offset = BITS_PER_BYTE_MASKED(total_bits_offset);
  90         bits_to_copy = bit_offset + nr_bits;
  91         bytes_to_copy = BITS_ROUNDUP_BYTES(bits_to_copy);
  92
  93         print_num = 0;
  94         memcpy(&print_num, data, bytes_to_copy);
  95 #if defined(__BIG_ENDIAN_BITFIELD)
  96         left_shift_bits = bit_offset;
  97 #elif defined(__LITTLE_ENDIAN_BITFIELD)
  98         left_shift_bits = 64 - bits_to_copy;
  99 #else
 100 #error neither big nor little endian
 101 #endif
 102         right_shift_bits = 64 - nr_bits;
 103
 104         print_num <<= left_shift_bits;
 105         print_num >>= right_shift_bits;
 106         if (is_plain_text)
 107                 jsonw_printf(jw, "0x%llx", print_num);
 108         else
 109                 jsonw_printf(jw, "%llu", print_num);
 110 }
 111
 112 static int btf_dumper_int(const struct btf_type *t, __u8 bit_offset,
 113                           const void *data, json_writer_t *jw,
 114                           bool is_plain_text)
 115 {
 116         __u32 *int_type;
 117         __u32 nr_bits;
 118
 119         int_type = (__u32 *)(t + 1);
 120         nr_bits = BTF_INT_BITS(*int_type);
 121         /* if this is bit field */
 122         if (bit_offset || BTF_INT_OFFSET(*int_type) ||
 123             BITS_PER_BYTE_MASKED(nr_bits)) {
 124                 btf_dumper_int_bits(*int_type, bit_offset, data, jw,
 125                                     is_plain_text);
 126                 return 0;
 127         }
 128
 129         switch (BTF_INT_ENCODING(*int_type)) {
 130         case 0:
 131                 if (BTF_INT_BITS(*int_type) == 64)
 132                         jsonw_printf(jw, "%llu", *(__u64 *)data);
 133                 else if (BTF_INT_BITS(*int_type) == 32)
 134                         jsonw_printf(jw, "%u", *(__u32 *)data);
 135                 else if (BTF_INT_BITS(*int_type) == 16)
 136                         jsonw_printf(jw, "%hu", *(__u16 *)data);
 137                 else if (BTF_INT_BITS(*int_type) == 8)
 138                         jsonw_printf(jw, "%hhu", *(__u8 *)data);
 139                 else
 140                         btf_dumper_int_bits(*int_type, bit_offset, data, jw,
 141                                             is_plain_text);
 142                 break;
 143         case BTF_INT_SIGNED:
 144                 if (BTF_INT_BITS(*int_type) == 64)
 145                         jsonw_printf(jw, "%lld", *(long long *)data);
 146                 else if (BTF_INT_BITS(*int_type) == 32)
 147                         jsonw_printf(jw, "%d", *(int *)data);
 148                 else if (BTF_INT_BITS(*int_type) == 16)
 149                         jsonw_printf(jw, "%hd", *(short *)data);
 150                 else if (BTF_INT_BITS(*int_type) == 8)
 151                         jsonw_printf(jw, "%hhd", *(char *)data);
 152                 else
 153                         btf_dumper_int_bits(*int_type, bit_offset, data, jw,
 154                                             is_plain_text);
 155                 break;
 156         case BTF_INT_CHAR:
 157                 if (isprint(*(char *)data))
 158                         jsonw_printf(jw, "\"%c\"", *(char *)data);
 159                 else
 160                         if (is_plain_text)
 161                                 jsonw_printf(jw, "0x%hhx", *(char *)data);
 162                         else
 163                                 jsonw_printf(jw, "\"\\u00%02hhx\"",
 164                                              *(char *)data);
 165                 break;
 166         case BTF_INT_BOOL:
 167                 jsonw_bool(jw, *(bool *)data);
 168                 break;
 169         default:
 170                 /* shouldn't happen */
 171                 return -EINVAL;
 172         }
 173
 174         return 0;
 175 }
 176
 177 static int btf_dumper_struct(const struct btf_dumper *d, __u32 type_id,
 178                              const void *data)
 179 {
 180         const struct btf_type *t;
 181         struct btf_member *m;
 182         const void *data_off;
 183         int ret = 0;
 184         int i, vlen;
 185
 186         t = btf__type_by_id(d->btf, type_id);
 187         if (!t)
 188                 return -EINVAL;
 189
 190         vlen = BTF_INFO_VLEN(t->info);
 191         jsonw_start_object(d->jw);
 192         m = (struct btf_member *)(t + 1);
 193
 194         for (i = 0; i < vlen; i++) {
 195                 data_off = data + BITS_ROUNDDOWN_BYTES(m[i].offset);
 196                 jsonw_name(d->jw, btf__name_by_offset(d->btf, m[i].name_off));
 197                 ret = btf_dumper_do_type(d, m[i].type,
 198                                          BITS_PER_BYTE_MASKED(m[i].offset),
 199                                          data_off);
 200                 if (ret)
 201                         break;
 202         }
 203
 204         jsonw_end_object(d->jw);
 205
 206         return ret;
 207 }
 208
 209 static int btf_dumper_do_type(const struct btf_dumper *d, __u32 type_id,
 210                               __u8 bit_offset, const void *data)
 211 {
 212         const struct btf_type *t = btf__type_by_id(d->btf, type_id);
 213
 214         switch (BTF_INFO_KIND(t->info)) {
 215         case BTF_KIND_INT:
 216                 return btf_dumper_int(t, bit_offset, data, d->jw,
 217                                      d->is_plain_text);
 218         case BTF_KIND_STRUCT:
 219         case BTF_KIND_UNION:
 220                 return btf_dumper_struct(d, type_id, data);
 221         case BTF_KIND_ARRAY:
 222                 return btf_dumper_array(d, type_id, data);
 223         case BTF_KIND_ENUM:
 224                 btf_dumper_enum(data, d->jw);
 225                 return 0;
 226         case BTF_KIND_PTR:
 227                 btf_dumper_ptr(data, d->jw, d->is_plain_text);
 228                 return 0;
 229         case BTF_KIND_UNKN:
 230                 jsonw_printf(d->jw, "(unknown)");
 231                 return 0;
 232         case BTF_KIND_FWD:
 233                 /* map key or value can't be forward */
 234                 jsonw_printf(d->jw, "(fwd-kind-invalid)");
 235                 return -EINVAL;
 236         case BTF_KIND_TYPEDEF:
 237         case BTF_KIND_VOLATILE:
 238         case BTF_KIND_CONST:
 239         case BTF_KIND_RESTRICT:
 240                 return btf_dumper_modifier(d, type_id, bit_offset, data);
 241         default:
 242                 jsonw_printf(d->jw, "(unsupported-kind");
 243                 return -EINVAL;
 244         }
 245 }
 246
 247 int btf_dumper_type(const struct btf_dumper *d, __u32 type_id,
 248                     const void *data)
 249 {
 250         return btf_dumper_do_type(d, type_id, 0, data);
 251 }