tools/bpf/bpftool/map.c

   1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
   2 /* Copyright (C) 2017-2018 Netronome Systems, Inc. */
   3
   4 #include <assert.h>
   5 #include <errno.h>
   6 #include <fcntl.h>
   7 #include <linux/err.h>
   8 #include <linux/kernel.h>
   9 #include <net/if.h>
  10 #include <stdbool.h>
  11 #include <stdio.h>
  12 #include <stdlib.h>
  13 #include <string.h>
  14 #include <unistd.h>
  15 #include <sys/types.h>
  16 #include <sys/stat.h>
  17
  18 #include <bpf.h>
  19
  20 #include "btf.h"
  21 #include "json_writer.h"
  22 #include "main.h"
  23
  24 const char * const map_type_name[] = {
  25         [BPF_MAP_TYPE_UNSPEC]                   = "unspec",
  26         [BPF_MAP_TYPE_HASH]                     = "hash",
  27         [BPF_MAP_TYPE_ARRAY]                    = "array",
  28         [BPF_MAP_TYPE_PROG_ARRAY]               = "prog_array",
  29         [BPF_MAP_TYPE_PERF_EVENT_ARRAY]         = "perf_event_array",
  30         [BPF_MAP_TYPE_PERCPU_HASH]              = "percpu_hash",
  31         [BPF_MAP_TYPE_PERCPU_ARRAY]             = "percpu_array",
  32         [BPF_MAP_TYPE_STACK_TRACE]              = "stack_trace",
  33         [BPF_MAP_TYPE_CGROUP_ARRAY]             = "cgroup_array",
  34         [BPF_MAP_TYPE_LRU_HASH]                 = "lru_hash",
  35         [BPF_MAP_TYPE_LRU_PERCPU_HASH]          = "lru_percpu_hash",
  36         [BPF_MAP_TYPE_LPM_TRIE]                 = "lpm_trie",
  37         [BPF_MAP_TYPE_ARRAY_OF_MAPS]            = "array_of_maps",
  38         [BPF_MAP_TYPE_HASH_OF_MAPS]             = "hash_of_maps",
  39         [BPF_MAP_TYPE_DEVMAP]                   = "devmap",
  40         [BPF_MAP_TYPE_SOCKMAP]                  = "sockmap",
  41         [BPF_MAP_TYPE_CPUMAP]                   = "cpumap",
  42         [BPF_MAP_TYPE_XSKMAP]                   = "xskmap",
  43         [BPF_MAP_TYPE_SOCKHASH]                 = "sockhash",
  44         [BPF_MAP_TYPE_CGROUP_STORAGE]           = "cgroup_storage",
  45         [BPF_MAP_TYPE_REUSEPORT_SOCKARRAY]      = "reuseport_sockarray",
  46         [BPF_MAP_TYPE_PERCPU_CGROUP_STORAGE]    = "percpu_cgroup_storage",
  47         [BPF_MAP_TYPE_QUEUE]                    = "queue",
  48         [BPF_MAP_TYPE_STACK]                    = "stack",
  49 };
  50
  51 const size_t map_type_name_size = ARRAY_SIZE(map_type_name);
  52
  53 static bool map_is_per_cpu(__u32 type)
  54 {
  55         return type == BPF_MAP_TYPE_PERCPU_HASH ||
  56                type == BPF_MAP_TYPE_PERCPU_ARRAY ||
  57                type == BPF_MAP_TYPE_LRU_PERCPU_HASH ||
  58                type == BPF_MAP_TYPE_PERCPU_CGROUP_STORAGE;
  59 }
  60
  61 static bool map_is_map_of_maps(__u32 type)
  62 {
  63         return type == BPF_MAP_TYPE_ARRAY_OF_MAPS ||
  64                type == BPF_MAP_TYPE_HASH_OF_MAPS;
  65 }
  66
  67 static bool map_is_map_of_progs(__u32 type)
  68 {
  69         return type == BPF_MAP_TYPE_PROG_ARRAY;
  70 }
  71
  72 static int map_type_from_str(const char *type)
  73 {
  74         unsigned int i;
  75
  76         for (i = 0; i < ARRAY_SIZE(map_type_name); i++)
  77                 /* Don't allow prefixing in case of possible future shadowing */
  78                 if (map_type_name[i] && !strcmp(map_type_name[i], type))
  79                         return i;
  80         return -1;
  81 }
  82
  83 static void *alloc_value(struct bpf_map_info *info)
  84 {
  85         if (map_is_per_cpu(info->type))
  86                 return malloc(round_up(info->value_size, 8) *
  87                               get_possible_cpus());
  88         else
  89                 return malloc(info->value_size);
  90 }
  91
  92 int map_parse_fd(int *argc, char ***argv)
  93 {
  94         int fd;
  95
  96         if (is_prefix(**argv, "id")) {
  97                 unsigned int id;
  98                 char *endptr;
  99
 100                 NEXT_ARGP();
 101
 102                 id = strtoul(**argv, &endptr, 0);
 103                 if (*endptr) {
 104                         p_err("can't parse %s as ID", **argv);
 105                         return -1;
 106                 }
 107                 NEXT_ARGP();
 108
 109                 fd = bpf_map_get_fd_by_id(id);
 110                 if (fd < 0)
 111                         p_err("get map by id (%u): %s", id, strerror(errno));
 112                 return fd;
 113         } else if (is_prefix(**argv, "pinned")) {
 114                 char *path;
 115
 116                 NEXT_ARGP();
 117
 118                 path = **argv;
 119                 NEXT_ARGP();
 120
 121                 return open_obj_pinned_any(path, BPF_OBJ_MAP);
 122         }
 123
 124         p_err("expected 'id' or 'pinned', got: '%s'?", **argv);
 125         return -1;
 126 }
 127
 128 int map_parse_fd_and_info(int *argc, char ***argv, void *info, __u32 *info_len)
 129 {
 130         int err;
 131         int fd;
 132
 133         fd = map_parse_fd(argc, argv);
 134         if (fd < 0)
 135                 return -1;
 136
 137         err = bpf_obj_get_info_by_fd(fd, info, info_len);
 138         if (err) {
 139                 p_err("can't get map info: %s", strerror(errno));
 140                 close(fd);
 141                 return err;
 142         }
 143
 144         return fd;
 145 }
 146
 147 static int do_dump_btf(const struct btf_dumper *d,
 148                        struct bpf_map_info *map_info, void *key,
 149                        void *value)
 150 {
 151         int ret;
 152
 153         /* start of key-value pair */
 154         jsonw_start_object(d->jw);
 155
 156         jsonw_name(d->jw, "key");
 157
 158         ret = btf_dumper_type(d, map_info->btf_key_type_id, key);
 159         if (ret)
 160                 goto err_end_obj;
 161
 162         if (!map_is_per_cpu(map_info->type)) {
 163                 jsonw_name(d->jw, "value");
 164                 ret = btf_dumper_type(d, map_info->btf_value_type_id, value);
 165         } else {
 166                 unsigned int i, n, step;
 167
 168                 jsonw_name(d->jw, "values");
 169                 jsonw_start_array(d->jw);
 170                 n = get_possible_cpus();
 171                 step = round_up(map_info->value_size, 8);
 172                 for (i = 0; i < n; i++) {
 173                         jsonw_start_object(d->jw);
 174                         jsonw_int_field(d->jw, "cpu", i);
 175                         jsonw_name(d->jw, "value");
 176                         ret = btf_dumper_type(d, map_info->btf_value_type_id,
 177                                               value + i * step);
 178                         jsonw_end_object(d->jw);
 179                         if (ret)
 180                                 break;
 181                 }
 182                 jsonw_end_array(d->jw);
 183         }
 184
 185 err_end_obj:
 186         /* end of key-value pair */
 187         jsonw_end_object(d->jw);
 188
 189         return ret;
 190 }
 191
 192 static json_writer_t *get_btf_writer(void)
 193 {
 194         json_writer_t *jw = jsonw_new(stdout);
 195
 196         if (!jw)
 197                 return NULL;
 198         jsonw_pretty(jw, true);
 199
 200         return jw;
 201 }
 202
 203 static void print_entry_json(struct bpf_map_info *info, unsigned char *key,
 204                              unsigned char *value, struct btf *btf)
 205 {
 206         jsonw_start_object(json_wtr);
 207
 208         if (!map_is_per_cpu(info->type)) {
 209                 jsonw_name(json_wtr, "key");
 210                 print_hex_data_json(key, info->key_size);
 211                 jsonw_name(json_wtr, "value");
 212                 print_hex_data_json(value, info->value_size);
 213                 if (btf) {
 214                         struct btf_dumper d = {
 215                                 .btf = btf,
 216                                 .jw = json_wtr,
 217                                 .is_plain_text = false,
 218                         };
 219
 220                         jsonw_name(json_wtr, "formatted");
 221                         do_dump_btf(&d, info, key, value);
 222                 }
 223         } else {
 224                 unsigned int i, n, step;
 225
 226                 n = get_possible_cpus();
 227                 step = round_up(info->value_size, 8);
 228
 229                 jsonw_name(json_wtr, "key");
 230                 print_hex_data_json(key, info->key_size);
 231
 232                 jsonw_name(json_wtr, "values");
 233                 jsonw_start_array(json_wtr);
 234                 for (i = 0; i < n; i++) {
 235                         jsonw_start_object(json_wtr);
 236
 237                         jsonw_int_field(json_wtr, "cpu", i);
 238
 239                         jsonw_name(json_wtr, "value");
 240                         print_hex_data_json(value + i * step,
 241                                             info->value_size);
 242
 243                         jsonw_end_object(json_wtr);
 244                 }
 245                 jsonw_end_array(json_wtr);
 246                 if (btf) {
 247                         struct btf_dumper d = {
 248                                 .btf = btf,
 249                                 .jw = json_wtr,
 250                                 .is_plain_text = false,
 251                         };
 252
 253                         jsonw_name(json_wtr, "formatted");
 254                         do_dump_btf(&d, info, key, value);
 255                 }
 256         }
 257
 258         jsonw_end_object(json_wtr);
 259 }
 260
 261 static void print_entry_error(struct bpf_map_info *info, unsigned char *key,
 262                               const char *value)
 263 {
 264         int value_size = strlen(value);
 265         bool single_line, break_names;
 266
 267         break_names = info->key_size > 16 || value_size > 16;
 268         single_line = info->key_size + value_size <= 24 && !break_names;
 269
 270         printf("key:%c", break_names ? '\n' : ' ');
 271         fprint_hex(stdout, key, info->key_size, " ");
 272
 273         printf(single_line ? "  " : "\n");
 274
 275         printf("value:%c%s", break_names ? '\n' : ' ', value);
 276
 277         printf("\n");
 278 }
 279
 280 static void print_entry_plain(struct bpf_map_info *info, unsigned char *key,
 281                               unsigned char *value)
 282 {
 283         if (!map_is_per_cpu(info->type)) {
 284                 bool single_line, break_names;
 285
 286                 break_names = info->key_size > 16 || info->value_size > 16;
 287                 single_line = info->key_size + info->value_size <= 24 &&
 288                         !break_names;
 289
 290                 if (info->key_size) {
 291                         printf("key:%c", break_names ? '\n' : ' ');
 292                         fprint_hex(stdout, key, info->key_size, " ");
 293
 294                         printf(single_line ? "  " : "\n");
 295                 }
 296
 297                 if (info->value_size) {
 298                         printf("value:%c", break_names ? '\n' : ' ');
 299                         if (value)
 300                                 fprint_hex(stdout, value, info->value_size,
 301                                            " ");
 302                         else
 303                                 printf("<no entry>");
 304                 }
 305
 306                 printf("\n");
 307         } else {
 308                 unsigned int i, n, step;
 309
 310                 n = get_possible_cpus();
 311                 step = round_up(info->value_size, 8);
 312
 313                 if (info->key_size) {
 314                         printf("key:\n");
 315                         fprint_hex(stdout, key, info->key_size, " ");
 316                         printf("\n");
 317                 }
 318                 if (info->value_size) {
 319                         for (i = 0; i < n; i++) {
 320                                 printf("value (CPU %02d):%c",
 321                                        i, info->value_size > 16 ? '\n' : ' ');
 322                                 if (value)
 323                                         fprint_hex(stdout, value + i * step,
 324                                                    info->value_size, " ");
 325                                 else
 326                                         printf("<no entry>");
 327                                 printf("\n");
 328                         }
 329                 }
 330         }
 331 }
 332
 333 static char **parse_bytes(char **argv, const char *name, unsigned char *val,
 334                           unsigned int n)
 335 {
 336         unsigned int i = 0, base = 0;
 337         char *endptr;
 338
 339         if (is_prefix(*argv, "hex")) {
 340                 base = 16;
 341                 argv++;
 342         }
 343
 344         while (i < n && argv[i]) {
 345                 val[i] = strtoul(argv[i], &endptr, base);
 346                 if (*endptr) {
 347                         p_err("error parsing byte: %s", argv[i]);
 348                         return NULL;
 349                 }
 350                 i++;
 351         }
 352
 353         if (i != n) {
 354                 p_err("%s expected %d bytes got %d", name, n, i);
 355                 return NULL;
 356         }
 357
 358         return argv + i;
 359 }
 360
 361 /* on per cpu maps we must copy the provided value on all value instances */
 362 static void fill_per_cpu_value(struct bpf_map_info *info, void *value)
 363 {
 364         unsigned int i, n, step;
 365
 366         if (!map_is_per_cpu(info->type))
 367                 return;
 368
 369         n = get_possible_cpus();
 370         step = round_up(info->value_size, 8);
 371         for (i = 1; i < n; i++)
 372                 memcpy(value + i * step, value, info->value_size);
 373 }
 374
 375 static int parse_elem(char **argv, struct bpf_map_info *info,
 376                       void *key, void *value, __u32 key_size, __u32 value_size,
 377                       __u32 *flags, __u32 **value_fd)
 378 {
 379         if (!*argv) {
 380                 if (!key && !value)
 381                         return 0;
 382                 p_err("did not find %s", key ? "key" : "value");
 383                 return -1;
 384         }
 385
 386         if (is_prefix(*argv, "key")) {
 387                 if (!key) {
 388                         if (key_size)
 389                                 p_err("duplicate key");
 390                         else
 391                                 p_err("unnecessary key");
 392                         return -1;
 393                 }
 394
 395                 argv = parse_bytes(argv + 1, "key", key, key_size);
 396                 if (!argv)
 397                         return -1;
 398
 399                 return parse_elem(argv, info, NULL, value, key_size, value_size,
 400                                   flags, value_fd);
 401         } else if (is_prefix(*argv, "value")) {
 402                 int fd;
 403
 404                 if (!value) {
 405                         if (value_size)
 406                                 p_err("duplicate value");
 407                         else
 408                                 p_err("unnecessary value");
 409                         return -1;
 410                 }
 411
 412                 argv++;
 413
 414                 if (map_is_map_of_maps(info->type)) {
 415                         int argc = 2;
 416
 417                         if (value_size != 4) {
 418                                 p_err("value smaller than 4B for map in map?");
 419                                 return -1;
 420                         }
 421                         if (!argv[0] || !argv[1]) {
 422                                 p_err("not enough value arguments for map in map");
 423                                 return -1;
 424                         }
 425
 426                         fd = map_parse_fd(&argc, &argv);
 427                         if (fd < 0)
 428                                 return -1;
 429
 430                         *value_fd = value;
 431                         **value_fd = fd;
 432                 } else if (map_is_map_of_progs(info->type)) {
 433                         int argc = 2;
 434
 435                         if (value_size != 4) {
 436                                 p_err("value smaller than 4B for map of progs?");
 437                                 return -1;
 438                         }
 439                         if (!argv[0] || !argv[1]) {
 440                                 p_err("not enough value arguments for map of progs");
 441                                 return -1;
 442                         }
 443                         if (is_prefix(*argv, "id"))
 444                                 p_info("Warning: updating program array via MAP_ID, make sure this map is kept open\n"
 445                                        "         by some process or pinned otherwise update will be lost");
 446
 447                         fd = prog_parse_fd(&argc, &argv);
 448                         if (fd < 0)
 449                                 return -1;
 450
 451                         *value_fd = value;
 452                         **value_fd = fd;
 453                 } else {
 454                         argv = parse_bytes(argv, "value", value, value_size);
 455                         if (!argv)
 456                                 return -1;
 457
 458                         fill_per_cpu_value(info, value);
 459                 }
 460
 461                 return parse_elem(argv, info, key, NULL, key_size, value_size,
 462                                   flags, NULL);
 463         } else if (is_prefix(*argv, "any") || is_prefix(*argv, "noexist") ||
 464                    is_prefix(*argv, "exist")) {
 465                 if (!flags) {
 466                         p_err("flags specified multiple times: %s", *argv);
 467                         return -1;
 468                 }
 469
 470                 if (is_prefix(*argv, "any"))
 471                         *flags = BPF_ANY;
 472                 else if (is_prefix(*argv, "noexist"))
 473                         *flags = BPF_NOEXIST;
 474                 else if (is_prefix(*argv, "exist"))
 475                         *flags = BPF_EXIST;
 476
 477                 return parse_elem(argv + 1, info, key, value, key_size,
 478                                   value_size, NULL, value_fd);
 479         }
 480
 481         p_err("expected key or value, got: %s", *argv);
 482         return -1;
 483 }
 484
 485 static int show_map_close_json(int fd, struct bpf_map_info *info)
 486 {
 487         char *memlock;
 488
 489         memlock = get_fdinfo(fd, "memlock");
 490
 491         jsonw_start_object(json_wtr);
 492
 493         jsonw_uint_field(json_wtr, "id", info->id);
 494         if (info->type < ARRAY_SIZE(map_type_name))
 495                 jsonw_string_field(json_wtr, "type",
 496                                    map_type_name[info->type]);
 497         else
 498                 jsonw_uint_field(json_wtr, "type", info->type);
 499
 500         if (*info->name)
 501                 jsonw_string_field(json_wtr, "name", info->name);
 502
 503         jsonw_name(json_wtr, "flags");
 504         jsonw_printf(json_wtr, "%d", info->map_flags);
 505
 506         print_dev_json(info->ifindex, info->netns_dev, info->netns_ino);
 507
 508         jsonw_uint_field(json_wtr, "bytes_key", info->key_size);
 509         jsonw_uint_field(json_wtr, "bytes_value", info->value_size);
 510         jsonw_uint_field(json_wtr, "max_entries", info->max_entries);
 511
 512         if (memlock)
 513                 jsonw_int_field(json_wtr, "bytes_memlock", atoi(memlock));
 514         free(memlock);
 515
 516         if (info->type == BPF_MAP_TYPE_PROG_ARRAY) {
 517                 char *owner_prog_type = get_fdinfo(fd, "owner_prog_type");
 518                 char *owner_jited = get_fdinfo(fd, "owner_jited");
 519
 520                 if (owner_prog_type) {
 521                         unsigned int prog_type = atoi(owner_prog_type);
 522
 523                         if (prog_type < ARRAY_SIZE(prog_type_name))
 524                                 jsonw_string_field(json_wtr, "owner_prog_type",
 525                                                    prog_type_name[prog_type]);
 526                         else
 527                                 jsonw_uint_field(json_wtr, "owner_prog_type",
 528                                                  prog_type);
 529                 }
 530                 if (owner_jited)
 531                         jsonw_bool_field(json_wtr, "owner_jited",
 532                                          !!atoi(owner_jited));
 533
 534                 free(owner_prog_type);
 535                 free(owner_jited);
 536         }
 537         close(fd);
 538
 539         if (!hash_empty(map_table.table)) {
 540                 struct pinned_obj *obj;
 541
 542                 jsonw_name(json_wtr, "pinned");
 543                 jsonw_start_array(json_wtr);
 544                 hash_for_each_possible(map_table.table, obj, hash, info->id) {
 545                         if (obj->id == info->id)
 546                                 jsonw_string(json_wtr, obj->path);
 547                 }
 548                 jsonw_end_array(json_wtr);
 549         }
 550
 551         jsonw_end_object(json_wtr);
 552
 553         return 0;
 554 }
 555
 556 static int show_map_close_plain(int fd, struct bpf_map_info *info)
 557 {
 558         char *memlock;
 559
 560         memlock = get_fdinfo(fd, "memlock");
 561
 562         printf("%u: ", info->id);
 563         if (info->type < ARRAY_SIZE(map_type_name))
 564                 printf("%s  ", map_type_name[info->type]);
 565         else
 566                 printf("type %u  ", info->type);
 567
 568         if (*info->name)
 569                 printf("name %s  ", info->name);
 570
 571         printf("flags 0x%x", info->map_flags);
 572         print_dev_plain(info->ifindex, info->netns_dev, info->netns_ino);
 573         printf("\n");
 574         printf("\tkey %uB  value %uB  max_entries %u",
 575                info->key_size, info->value_size, info->max_entries);
 576
 577         if (memlock)
 578                 printf("  memlock %sB", memlock);
 579         free(memlock);
 580
 581         if (info->type == BPF_MAP_TYPE_PROG_ARRAY) {
 582                 char *owner_prog_type = get_fdinfo(fd, "owner_prog_type");
 583                 char *owner_jited = get_fdinfo(fd, "owner_jited");
 584
 585                 if (owner_prog_type || owner_jited)
 586                         printf("\n\t");
 587                 if (owner_prog_type) {
 588                         unsigned int prog_type = atoi(owner_prog_type);
 589
 590                         if (prog_type < ARRAY_SIZE(prog_type_name))
 591                                 printf("owner_prog_type %s  ",
 592                                        prog_type_name[prog_type]);
 593                         else
 594                                 printf("owner_prog_type %d  ", prog_type);
 595                 }
 596                 if (owner_jited)
 597                         printf("owner%s jited",
 598                                atoi(owner_jited) ? "" : " not");
 599
 600                 free(owner_prog_type);
 601                 free(owner_jited);
 602         }
 603         close(fd);
 604
 605         printf("\n");
 606         if (!hash_empty(map_table.table)) {
 607                 struct pinned_obj *obj;
 608
 609                 hash_for_each_possible(map_table.table, obj, hash, info->id) {
 610                         if (obj->id == info->id)
 611                                 printf("\tpinned %s\n", obj->path);
 612                 }
 613         }
 614         return 0;
 615 }
 616
 617 static int do_show(int argc, char **argv)
 618 {
 619         struct bpf_map_info info = {};
 620         __u32 len = sizeof(info);
 621         __u32 id = 0;
 622         int err;
 623         int fd;
 624
 625         if (show_pinned)
 626                 build_pinned_obj_table(&map_table, BPF_OBJ_MAP);
 627
 628         if (argc == 2) {
 629                 fd = map_parse_fd_and_info(&argc, &argv, &info, &len);
 630                 if (fd < 0)
 631                         return -1;
 632
 633                 if (json_output)
 634                         return show_map_close_json(fd, &info);
 635                 else
 636                         return show_map_close_plain(fd, &info);
 637         }
 638
 639         if (argc)
 640                 return BAD_ARG();
 641
 642         if (json_output)
 643                 jsonw_start_array(json_wtr);
 644         while (true) {
 645                 err = bpf_map_get_next_id(id, &id);
 646                 if (err) {
 647                         if (errno == ENOENT)
 648                                 break;
 649                         p_err("can't get next map: %s%s", strerror(errno),
 650                               errno == EINVAL ? " -- kernel too old?" : "");
 651                         break;
 652                 }
 653
 654                 fd = bpf_map_get_fd_by_id(id);
 655                 if (fd < 0) {
 656                         if (errno == ENOENT)
 657                                 continue;
 658                         p_err("can't get map by id (%u): %s",
 659                               id, strerror(errno));
 660                         break;
 661                 }
 662
 663                 err = bpf_obj_get_info_by_fd(fd, &info, &len);
 664                 if (err) {
 665                         p_err("can't get map info: %s", strerror(errno));
 666                         close(fd);
 667                         break;
 668                 }
 669
 670                 if (json_output)
 671                         show_map_close_json(fd, &info);
 672                 else
 673                         show_map_close_plain(fd, &info);
 674         }
 675         if (json_output)
 676                 jsonw_end_array(json_wtr);
 677
 678         return errno == ENOENT ? 0 : -1;
 679 }
 680
 681 static int dump_map_elem(int fd, void *key, void *value,
 682                          struct bpf_map_info *map_info, struct btf *btf,
 683                          json_writer_t *btf_wtr)
 684 {
 685         int num_elems = 0;
 686         int lookup_errno;
 687
 688         if (!bpf_map_lookup_elem(fd, key, value)) {
 689                 if (json_output) {
 690                         print_entry_json(map_info, key, value, btf);
 691                 } else {
 692                         if (btf) {
 693                                 struct btf_dumper d = {
 694                                         .btf = btf,
 695                                         .jw = btf_wtr,
 696                                         .is_plain_text = true,
 697                                 };
 698
 699                                 do_dump_btf(&d, map_info, key, value);
 700                         } else {
 701                                 print_entry_plain(map_info, key, value);
 702                         }
 703                         num_elems++;
 704                 }
 705                 return num_elems;
 706         }
 707
 708         /* lookup error handling */
 709         lookup_errno = errno;
 710
 711         if (map_is_map_of_maps(map_info->type) ||
 712             map_is_map_of_progs(map_info->type))
 713                 return 0;
 714
 715         if (json_output) {
 716                 jsonw_name(json_wtr, "key");
 717                 print_hex_data_json(key, map_info->key_size);
 718                 jsonw_name(json_wtr, "value");
 719                 jsonw_start_object(json_wtr);
 720                 jsonw_string_field(json_wtr, "error", strerror(lookup_errno));
 721                 jsonw_end_object(json_wtr);
 722         } else {
 723                 if (errno == ENOENT)
 724                         print_entry_plain(map_info, key, NULL);
 725                 else
 726                         print_entry_error(map_info, key,
 727                                           strerror(lookup_errno));
 728         }
 729
 730         return 0;
 731 }
 732
 733 static int do_dump(int argc, char **argv)
 734 {
 735         struct bpf_map_info info = {};
 736         void *key, *value, *prev_key;
 737         unsigned int num_elems = 0;
 738         __u32 len = sizeof(info);
 739         json_writer_t *btf_wtr;
 740         struct btf *btf = NULL;
 741         int err;
 742         int fd;
 743
 744         if (argc != 2)
 745                 usage();
 746
 747         fd = map_parse_fd_and_info(&argc, &argv, &info, &len);
 748         if (fd < 0)
 749                 return -1;
 750
 751         key = malloc(info.key_size);
 752         value = alloc_value(&info);
 753         if (!key || !value) {
 754                 p_err("mem alloc failed");
 755                 err = -1;
 756                 goto exit_free;
 757         }
 758
 759         prev_key = NULL;
 760
 761         err = btf__get_from_id(info.btf_id, &btf);
 762         if (err) {
 763                 p_err("failed to get btf");
 764                 goto exit_free;
 765         }
 766
 767         if (json_output)
 768                 jsonw_start_array(json_wtr);
 769         else
 770                 if (btf) {
 771                         btf_wtr = get_btf_writer();
 772                         if (!btf_wtr) {
 773                                 p_info("failed to create json writer for btf. falling back to plain output");
 774                                 btf__free(btf);
 775                                 btf = NULL;
 776                         } else {
 777                                 jsonw_start_array(btf_wtr);
 778                         }
 779                 }
 780
 781         while (true) {
 782                 err = bpf_map_get_next_key(fd, prev_key, key);
 783                 if (err) {
 784                         if (errno == ENOENT)
 785                                 err = 0;
 786                         break;
 787                 }
 788                 num_elems += dump_map_elem(fd, key, value, &info, btf, btf_wtr);
 789                 prev_key = key;
 790         }
 791
 792         if (json_output)
 793                 jsonw_end_array(json_wtr);
 794         else if (btf) {
 795                 jsonw_end_array(btf_wtr);
 796                 jsonw_destroy(&btf_wtr);
 797         } else {
 798                 printf("Found %u element%s\n", num_elems,
 799                        num_elems != 1 ? "s" : "");
 800         }
 801
 802 exit_free:
 803         free(key);
 804         free(value);
 805         close(fd);
 806         btf__free(btf);
 807
 808         return err;
 809 }
 810
 811 static int alloc_key_value(struct bpf_map_info *info, void **key, void **value)
 812 {
 813         *key = NULL;
 814         *value = NULL;
 815
 816         if (info->key_size) {
 817                 *key = malloc(info->key_size);
 818                 if (!*key) {
 819                         p_err("key mem alloc failed");
 820                         return -1;
 821                 }
 822         }
 823
 824         if (info->value_size) {
 825                 *value = alloc_value(info);
 826                 if (!*value) {
 827                         p_err("value mem alloc failed");
 828                         free(*key);
 829                         *key = NULL;
 830                         return -1;
 831                 }
 832         }
 833
 834         return 0;
 835 }
 836
 837 static int do_update(int argc, char **argv)
 838 {
 839         struct bpf_map_info info = {};
 840         __u32 len = sizeof(info);
 841         __u32 *value_fd = NULL;
 842         __u32 flags = BPF_ANY;
 843         void *key, *value;
 844         int fd, err;
 845
 846         if (argc < 2)
 847                 usage();
 848
 849         fd = map_parse_fd_and_info(&argc, &argv, &info, &len);
 850         if (fd < 0)
 851                 return -1;
 852
 853         err = alloc_key_value(&info, &key, &value);
 854         if (err)
 855                 goto exit_free;
 856
 857         err = parse_elem(argv, &info, key, value, info.key_size,
 858                          info.value_size, &flags, &value_fd);
 859         if (err)
 860                 goto exit_free;
 861
 862         err = bpf_map_update_elem(fd, key, value, flags);
 863         if (err) {
 864                 p_err("update failed: %s", strerror(errno));
 865                 goto exit_free;
 866         }
 867
 868 exit_free:
 869         if (value_fd)
 870                 close(*value_fd);
 871         free(key);
 872         free(value);
 873         close(fd);
 874
 875         if (!err && json_output)
 876                 jsonw_null(json_wtr);
 877         return err;
 878 }
 879
 880 static void print_key_value(struct bpf_map_info *info, void *key,
 881                             void *value)
 882 {
 883         json_writer_t *btf_wtr;
 884         struct btf *btf = NULL;
 885         int err;
 886
 887         err = btf__get_from_id(info->btf_id, &btf);
 888         if (err) {
 889                 p_err("failed to get btf");
 890                 return;
 891         }
 892
 893         if (json_output) {
 894                 print_entry_json(info, key, value, btf);
 895         } else if (btf) {
 896                 /* if here json_wtr wouldn't have been initialised,
 897                  * so let's create separate writer for btf
 898                  */
 899                 btf_wtr = get_btf_writer();
 900                 if (!btf_wtr) {
 901                         p_info("failed to create json writer for btf. falling back to plain output");
 902                         btf__free(btf);
 903                         btf = NULL;
 904                         print_entry_plain(info, key, value);
 905                 } else {
 906                         struct btf_dumper d = {
 907                                 .btf = btf,
 908                                 .jw = btf_wtr,
 909                                 .is_plain_text = true,
 910                         };
 911
 912                         do_dump_btf(&d, info, key, value);
 913                         jsonw_destroy(&btf_wtr);
 914                 }
 915         } else {
 916                 print_entry_plain(info, key, value);
 917         }
 918         btf__free(btf);
 919 }
 920
 921 static int do_lookup(int argc, char **argv)
 922 {
 923         struct bpf_map_info info = {};
 924         __u32 len = sizeof(info);
 925         void *key, *value;
 926         int err;
 927         int fd;
 928
 929         if (argc < 2)
 930                 usage();
 931
 932         fd = map_parse_fd_and_info(&argc, &argv, &info, &len);
 933         if (fd < 0)
 934                 return -1;
 935
 936         err = alloc_key_value(&info, &key, &value);
 937         if (err)
 938                 goto exit_free;
 939
 940         err = parse_elem(argv, &info, key, NULL, info.key_size, 0, NULL, NULL);
 941         if (err)
 942                 goto exit_free;
 943
 944         err = bpf_map_lookup_elem(fd, key, value);
 945         if (err) {
 946                 if (errno == ENOENT) {
 947                         if (json_output) {
 948                                 jsonw_null(json_wtr);
 949                         } else {
 950                                 printf("key:\n");
 951                                 fprint_hex(stdout, key, info.key_size, " ");
 952                                 printf("\n\nNot found\n");
 953                         }
 954                 } else {
 955                         p_err("lookup failed: %s", strerror(errno));
 956                 }
 957
 958                 goto exit_free;
 959         }
 960
 961         /* here means bpf_map_lookup_elem() succeeded */
 962         print_key_value(&info, key, value);
 963
 964 exit_free:
 965         free(key);
 966         free(value);
 967         close(fd);
 968
 969         return err;
 970 }
 971
 972 static int do_getnext(int argc, char **argv)
 973 {
 974         struct bpf_map_info info = {};
 975         __u32 len = sizeof(info);
 976         void *key, *nextkey;
 977         int err;
 978         int fd;
 979
 980         if (argc < 2)
 981                 usage();
 982
 983         fd = map_parse_fd_and_info(&argc, &argv, &info, &len);
 984         if (fd < 0)
 985                 return -1;
 986
 987         key = malloc(info.key_size);
 988         nextkey = malloc(info.key_size);
 989         if (!key || !nextkey) {
 990                 p_err("mem alloc failed");
 991                 err = -1;
 992                 goto exit_free;
 993         }
 994
 995         if (argc) {
 996                 err = parse_elem(argv, &info, key, NULL, info.key_size, 0,
 997                                  NULL, NULL);
 998                 if (err)
 999                         goto exit_free;
1000         } else {
1001                 free(key);
1002                 key = NULL;
1003         }
1004
1005         err = bpf_map_get_next_key(fd, key, nextkey);
1006         if (err) {
1007                 p_err("can't get next key: %s", strerror(errno));
1008                 goto exit_free;
1009         }
1010
1011         if (json_output) {
1012                 jsonw_start_object(json_wtr);
1013                 if (key) {
1014                         jsonw_name(json_wtr, "key");
1015                         print_hex_data_json(key, info.key_size);
1016                 } else {
1017                         jsonw_null_field(json_wtr, "key");
1018                 }
1019                 jsonw_name(json_wtr, "next_key");
1020                 print_hex_data_json(nextkey, info.key_size);
1021                 jsonw_end_object(json_wtr);
1022         } else {
1023                 if (key) {
1024                         printf("key:\n");
1025                         fprint_hex(stdout, key, info.key_size, " ");
1026                         printf("\n");
1027                 } else {
1028                         printf("key: None\n");
1029                 }
1030                 printf("next key:\n");
1031                 fprint_hex(stdout, nextkey, info.key_size, " ");
1032                 printf("\n");
1033         }
1034
1035 exit_free:
1036         free(nextkey);
1037         free(key);
1038         close(fd);
1039
1040         return err;
1041 }
1042
1043 static int do_delete(int argc, char **argv)
1044 {
1045         struct bpf_map_info info = {};
1046         __u32 len = sizeof(info);
1047         void *key;
1048         int err;
1049         int fd;
1050
1051         if (argc < 2)
1052                 usage();
1053
1054         fd = map_parse_fd_and_info(&argc, &argv, &info, &len);
1055         if (fd < 0)
1056                 return -1;
1057
1058         key = malloc(info.key_size);
1059         if (!key) {
1060                 p_err("mem alloc failed");
1061                 err = -1;
1062                 goto exit_free;
1063         }
1064
1065         err = parse_elem(argv, &info, key, NULL, info.key_size, 0, NULL, NULL);
1066         if (err)
1067                 goto exit_free;
1068
1069         err = bpf_map_delete_elem(fd, key);
1070         if (err)
1071                 p_err("delete failed: %s", strerror(errno));
1072
1073 exit_free:
1074         free(key);
1075         close(fd);
1076
1077         if (!err && json_output)
1078                 jsonw_null(json_wtr);
1079         return err;
1080 }
1081
1082 static int do_pin(int argc, char **argv)
1083 {
1084         int err;
1085
1086         err = do_pin_any(argc, argv, bpf_map_get_fd_by_id);
1087         if (!err && json_output)
1088                 jsonw_null(json_wtr);
1089         return err;
1090 }
1091
1092 static int do_create(int argc, char **argv)
1093 {
1094         struct bpf_create_map_attr attr = { NULL, };
1095         const char *pinfile;
1096         int err, fd;
1097
1098         if (!REQ_ARGS(7))
1099                 return -1;
1100         pinfile = GET_ARG();
1101
1102         while (argc) {
1103                 if (!REQ_ARGS(2))
1104                         return -1;
1105
1106                 if (is_prefix(*argv, "type")) {
1107                         NEXT_ARG();
1108
1109                         if (attr.map_type) {
1110                                 p_err("map type already specified");
1111                                 return -1;
1112                         }
1113
1114                         attr.map_type = map_type_from_str(*argv);
1115                         if ((int)attr.map_type < 0) {
1116                                 p_err("unrecognized map type: %s", *argv);
1117                                 return -1;
1118                         }
1119                         NEXT_ARG();
1120                 } else if (is_prefix(*argv, "name")) {
1121                         NEXT_ARG();
1122                         attr.name = GET_ARG();
1123                 } else if (is_prefix(*argv, "key")) {
1124                         if (parse_u32_arg(&argc, &argv, &attr.key_size,
1125                                           "key size"))
1126                                 return -1;
1127                 } else if (is_prefix(*argv, "value")) {
1128                         if (parse_u32_arg(&argc, &argv, &attr.value_size,
1129                                           "value size"))
1130                                 return -1;
1131                 } else if (is_prefix(*argv, "entries")) {
1132                         if (parse_u32_arg(&argc, &argv, &attr.max_entries,
1133                                           "max entries"))
1134                                 return -1;
1135                 } else if (is_prefix(*argv, "flags")) {
1136                         if (parse_u32_arg(&argc, &argv, &attr.map_flags,
1137                                           "flags"))
1138                                 return -1;
1139                 } else if (is_prefix(*argv, "dev")) {
1140                         NEXT_ARG();
1141
1142                         if (attr.map_ifindex) {
1143                                 p_err("offload device already specified");
1144                                 return -1;
1145                         }
1146
1147                         attr.map_ifindex = if_nametoindex(*argv);
1148                         if (!attr.map_ifindex) {
1149                                 p_err("unrecognized netdevice '%s': %s",
1150                                       *argv, strerror(errno));
1151                                 return -1;
1152                         }
1153                         NEXT_ARG();
1154                 } else {
1155                         p_err("unknown arg %s", *argv);
1156                         return -1;
1157                 }
1158         }
1159
1160         if (!attr.name) {
1161                 p_err("map name not specified");
1162                 return -1;
1163         }
1164
1165         set_max_rlimit();
1166
1167         fd = bpf_create_map_xattr(&attr);
1168         if (fd < 0) {
1169                 p_err("map create failed: %s", strerror(errno));
1170                 return -1;
1171         }
1172
1173         err = do_pin_fd(fd, pinfile);
1174         close(fd);
1175         if (err)
1176                 return err;
1177
1178         if (json_output)
1179                 jsonw_null(json_wtr);
1180         return 0;
1181 }
1182
1183 static int do_pop_dequeue(int argc, char **argv)
1184 {
1185         struct bpf_map_info info = {};
1186         __u32 len = sizeof(info);
1187         void *key, *value;
1188         int err;
1189         int fd;
1190
1191         if (argc < 2)
1192                 usage();
1193
1194         fd = map_parse_fd_and_info(&argc, &argv, &info, &len);
1195         if (fd < 0)
1196                 return -1;
1197
1198         err = alloc_key_value(&info, &key, &value);
1199         if (err)
1200                 goto exit_free;
1201
1202         err = bpf_map_lookup_and_delete_elem(fd, key, value);
1203         if (err) {
1204                 if (errno == ENOENT) {
1205                         if (json_output)
1206                                 jsonw_null(json_wtr);
1207                         else
1208                                 printf("Error: empty map\n");
1209                 } else {
1210                         p_err("pop failed: %s", strerror(errno));
1211                 }
1212
1213                 goto exit_free;
1214         }
1215
1216         print_key_value(&info, key, value);
1217
1218 exit_free:
1219         free(key);
1220         free(value);
1221         close(fd);
1222
1223         return err;
1224 }
1225
1226 static int do_help(int argc, char **argv)
1227 {
1228         if (json_output) {
1229                 jsonw_null(json_wtr);
1230                 return 0;
1231         }
1232
1233         fprintf(stderr,
1234                 "Usage: %s %s { show | list }   [MAP]\n"
1235                 "       %s %s create     FILE type TYPE key KEY_SIZE value VALUE_SIZE \\\n"
1236                 "                              entries MAX_ENTRIES name NAME [flags FLAGS] \\\n"
1237                 "                              [dev NAME]\n"
1238                 "       %s %s dump       MAP\n"
1239                 "       %s %s update     MAP [key DATA] [value VALUE] [UPDATE_FLAGS]\n"
1240                 "       %s %s lookup     MAP [key DATA]\n"
1241                 "       %s %s getnext    MAP [key DATA]\n"
1242                 "       %s %s delete     MAP  key DATA\n"
1243                 "       %s %s pin        MAP  FILE\n"
1244                 "       %s %s event_pipe MAP [cpu N index M]\n"
1245                 "       %s %s peek       MAP\n"
1246                 "       %s %s push       MAP value VALUE\n"
1247                 "       %s %s pop        MAP\n"
1248                 "       %s %s enqueue    MAP value VALUE\n"
1249                 "       %s %s dequeue    MAP\n"
1250                 "       %s %s help\n"
1251                 "\n"
1252                 "       " HELP_SPEC_MAP "\n"
1253                 "       DATA := { [hex] BYTES }\n"
1254                 "       " HELP_SPEC_PROGRAM "\n"
1255                 "       VALUE := { DATA | MAP | PROG }\n"
1256                 "       UPDATE_FLAGS := { any | exist | noexist }\n"
1257                 "       TYPE := { hash | array | prog_array | perf_event_array | percpu_hash |\n"
1258                 "                 percpu_array | stack_trace | cgroup_array | lru_hash |\n"
1259                 "                 lru_percpu_hash | lpm_trie | array_of_maps | hash_of_maps |\n"
1260                 "                 devmap | sockmap | cpumap | xskmap | sockhash |\n"
1261                 "                 cgroup_storage | reuseport_sockarray | percpu_cgroup_storage }\n"
1262                 "       " HELP_SPEC_OPTIONS "\n"
1263                 "",
1264                 bin_name, argv[-2], bin_name, argv[-2], bin_name, argv[-2],
1265                 bin_name, argv[-2], bin_name, argv[-2], bin_name, argv[-2],
1266                 bin_name, argv[-2], bin_name, argv[-2], bin_name, argv[-2],
1267                 bin_name, argv[-2], bin_name, argv[-2], bin_name, argv[-2],
1268                 bin_name, argv[-2], bin_name, argv[-2], bin_name, argv[-2]);
1269
1270         return 0;
1271 }
1272
1273 static const struct cmd cmds[] = {
1274         { "show",       do_show },
1275         { "list",       do_show },
1276         { "help",       do_help },
1277         { "dump",       do_dump },
1278         { "update",     do_update },
1279         { "lookup",     do_lookup },
1280         { "getnext",    do_getnext },
1281         { "delete",     do_delete },
1282         { "pin",        do_pin },
1283         { "event_pipe", do_event_pipe },
1284         { "create",     do_create },
1285         { "peek",       do_lookup },
1286         { "push",       do_update },
1287         { "enqueue",    do_update },
1288         { "pop",        do_pop_dequeue },
1289         { "dequeue",    do_pop_dequeue },
1290         { 0 }
1291 };
1292
1293 int do_map(int argc, char **argv)
1294 {
1295         return cmd_select(cmds, argc, argv, do_help);
1296 }