tools/bpf/bpftool/main.c

   1 /*
   2  * Copyright (C) 2017-2018 Netronome Systems, Inc.
   3  *
   4  * This software is dual licensed under the GNU General License Version 2,
   5  * June 1991 as shown in the file COPYING in the top-level directory of this
   6  * source tree or the BSD 2-Clause License provided below.  You have the
   7  * option to license this software under the complete terms of either license.
   8  *
   9  * The BSD 2-Clause License:
  10  *
  11  *     Redistribution and use in source and binary forms, with or
  12  *     without modification, are permitted provided that the following
  13  *     conditions are met:
  14  *
  15  *      1. Redistributions of source code must retain the above
  16  *         copyright notice, this list of conditions and the following
  17  *         disclaimer.
  18  *
  19  *      2. Redistributions in binary form must reproduce the above
  20  *         copyright notice, this list of conditions and the following
  21  *         disclaimer in the documentation and/or other materials
  22  *         provided with the distribution.
  23  *
  24  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  25  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  26  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  27  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  28  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  29  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  30  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  31  * SOFTWARE.
  32  */
  33
  34 #include <bfd.h>
  35 #include <ctype.h>
  36 #include <errno.h>
  37 #include <getopt.h>
  38 #include <linux/bpf.h>
  39 #include <stdio.h>
  40 #include <stdlib.h>
  41 #include <string.h>
  42
  43 #include <bpf.h>
  44
  45 #include "main.h"
  46
  47 #define BATCH_LINE_LEN_MAX 65536
  48 #define BATCH_ARG_NB_MAX 4096
  49
  50 const char *bin_name;
  51 static int last_argc;
  52 static char **last_argv;
  53 static int (*last_do_help)(int argc, char **argv);
  54 json_writer_t *json_wtr;
  55 bool pretty_output;
  56 bool json_output;
  57 bool show_pinned;
  58 struct pinned_obj_table prog_table;
  59 struct pinned_obj_table map_table;
  60
  61 static void __noreturn clean_and_exit(int i)
  62 {
  63         if (json_output)
  64                 jsonw_destroy(&json_wtr);
  65
  66         exit(i);
  67 }
  68
  69 void usage(void)
  70 {
  71         last_do_help(last_argc - 1, last_argv + 1);
  72
  73         clean_and_exit(-1);
  74 }
  75
  76 static int do_help(int argc, char **argv)
  77 {
  78         if (json_output) {
  79                 jsonw_null(json_wtr);
  80                 return 0;
  81         }
  82
  83         fprintf(stderr,
  84                 "Usage: %s [OPTIONS] OBJECT { COMMAND | help }\n"
  85                 "       %s batch file FILE\n"
  86                 "       %s version\n"
  87                 "\n"
  88                 "       OBJECT := { prog | map | cgroup | perf }\n"
  89                 "       " HELP_SPEC_OPTIONS "\n"
  90                 "",
  91                 bin_name, bin_name, bin_name);
  92
  93         return 0;
  94 }
  95
  96 static int do_version(int argc, char **argv)
  97 {
  98         if (json_output) {
  99                 jsonw_start_object(json_wtr);
 100                 jsonw_name(json_wtr, "version");
 101                 jsonw_printf(json_wtr, "\"%s\"", BPFTOOL_VERSION);
 102                 jsonw_end_object(json_wtr);
 103         } else {
 104                 printf("%s v%s\n", bin_name, BPFTOOL_VERSION);
 105         }
 106         return 0;
 107 }
 108
 109 int cmd_select(const struct cmd *cmds, int argc, char **argv,
 110                int (*help)(int argc, char **argv))
 111 {
 112         unsigned int i;
 113
 114         last_argc = argc;
 115         last_argv = argv;
 116         last_do_help = help;
 117
 118         if (argc < 1 && cmds[0].func)
 119                 return cmds[0].func(argc, argv);
 120
 121         for (i = 0; cmds[i].func; i++)
 122                 if (is_prefix(*argv, cmds[i].cmd))
 123                         return cmds[i].func(argc - 1, argv + 1);
 124
 125         help(argc - 1, argv + 1);
 126
 127         return -1;
 128 }
 129
 130 bool is_prefix(const char *pfx, const char *str)
 131 {
 132         if (!pfx)
 133                 return false;
 134         if (strlen(str) < strlen(pfx))
 135                 return false;
 136
 137         return !memcmp(str, pfx, strlen(pfx));
 138 }
 139
 140 void fprint_hex(FILE *f, void *arg, unsigned int n, const char *sep)
 141 {
 142         unsigned char *data = arg;
 143         unsigned int i;
 144
 145         for (i = 0; i < n; i++) {
 146                 const char *pfx = "";
 147
 148                 if (!i)
 149                         /* nothing */;
 150                 else if (!(i % 16))
 151                         fprintf(f, "\n");
 152                 else if (!(i % 8))
 153                         fprintf(f, "  ");
 154                 else
 155                         pfx = sep;
 156
 157                 fprintf(f, "%s%02hhx", i ? pfx : "", data[i]);
 158         }
 159 }
 160
 161 /* Split command line into argument vector. */
 162 static int make_args(char *line, char *n_argv[], int maxargs, int cmd_nb)
 163 {
 164         static const char ws[] = " \t\r\n";
 165         char *cp = line;
 166         int n_argc = 0;
 167
 168         while (*cp) {
 169                 /* Skip leading whitespace. */
 170                 cp += strspn(cp, ws);
 171
 172                 if (*cp == '\0')
 173                         break;
 174
 175                 if (n_argc >= (maxargs - 1)) {
 176                         p_err("too many arguments to command %d", cmd_nb);
 177                         return -1;
 178                 }
 179
 180                 /* Word begins with quote. */
 181                 if (*cp == '\'' || *cp == '"') {
 182                         char quote = *cp++;
 183
 184                         n_argv[n_argc++] = cp;
 185                         /* Find ending quote. */
 186                         cp = strchr(cp, quote);
 187                         if (!cp) {
 188                                 p_err("unterminated quoted string in command %d",
 189                                       cmd_nb);
 190                                 return -1;
 191                         }
 192                 } else {
 193                         n_argv[n_argc++] = cp;
 194
 195                         /* Find end of word. */
 196                         cp += strcspn(cp, ws);
 197                         if (*cp == '\0')
 198                                 break;
 199                 }
 200
 201                 /* Separate words. */
 202                 *cp++ = 0;
 203         }
 204         n_argv[n_argc] = NULL;
 205
 206         return n_argc;
 207 }
 208
 209 static int do_batch(int argc, char **argv);
 210
 211 static const struct cmd cmds[] = {
 212         { "help",       do_help },
 213         { "batch",      do_batch },
 214         { "prog",       do_prog },
 215         { "map",        do_map },
 216         { "cgroup",     do_cgroup },
 217         { "perf",       do_perf },
 218         { "version",    do_version },
 219         { 0 }
 220 };
 221
 222 static int do_batch(int argc, char **argv)
 223 {
 224         char buf[BATCH_LINE_LEN_MAX], contline[BATCH_LINE_LEN_MAX];
 225         char *n_argv[BATCH_ARG_NB_MAX];
 226         unsigned int lines = 0;
 227         int n_argc;
 228         FILE *fp;
 229         char *cp;
 230         int err;
 231         int i;
 232
 233         if (argc < 2) {
 234                 p_err("too few parameters for batch");
 235                 return -1;
 236         } else if (!is_prefix(*argv, "file")) {
 237                 p_err("expected 'file', got: %s", *argv);
 238                 return -1;
 239         } else if (argc > 2) {
 240                 p_err("too many parameters for batch");
 241                 return -1;
 242         }
 243         NEXT_ARG();
 244
 245         if (!strcmp(*argv, "-"))
 246                 fp = stdin;
 247         else
 248                 fp = fopen(*argv, "r");
 249         if (!fp) {
 250                 p_err("Can't open file (%s): %s", *argv, strerror(errno));
 251                 return -1;
 252         }
 253
 254         if (json_output)
 255                 jsonw_start_array(json_wtr);
 256         while (fgets(buf, sizeof(buf), fp)) {
 257                 cp = strchr(buf, '#');
 258                 if (cp)
 259                         *cp = '\0';
 260
 261                 if (strlen(buf) == sizeof(buf) - 1) {
 262                         errno = E2BIG;
 263                         break;
 264                 }
 265
 266                 /* Append continuation lines if any (coming after a line ending
 267                  * with '\' in the batch file).
 268                  */
 269                 while ((cp = strstr(buf, "\\\n")) != NULL) {
 270                         if (!fgets(contline, sizeof(contline), fp) ||
 271                             strlen(contline) == 0) {
 272                                 p_err("missing continuation line on command %d",
 273                                       lines);
 274                                 err = -1;
 275                                 goto err_close;
 276                         }
 277
 278                         cp = strchr(contline, '#');
 279                         if (cp)
 280                                 *cp = '\0';
 281
 282                         if (strlen(buf) + strlen(contline) + 1 > sizeof(buf)) {
 283                                 p_err("command %d is too long", lines);
 284                                 err = -1;
 285                                 goto err_close;
 286                         }
 287                         buf[strlen(buf) - 2] = '\0';
 288                         strcat(buf, contline);
 289                 }
 290
 291                 n_argc = make_args(buf, n_argv, BATCH_ARG_NB_MAX, lines);
 292                 if (!n_argc)
 293                         continue;
 294                 if (n_argc < 0) {
 295                         err = n_argc;
 296                         goto err_close;
 297                 }
 298
 299                 if (json_output) {
 300                         jsonw_start_object(json_wtr);
 301                         jsonw_name(json_wtr, "command");
 302                         jsonw_start_array(json_wtr);
 303                         for (i = 0; i < n_argc; i++)
 304                                 jsonw_string(json_wtr, n_argv[i]);
 305                         jsonw_end_array(json_wtr);
 306                         jsonw_name(json_wtr, "output");
 307                 }
 308
 309                 err = cmd_select(cmds, n_argc, n_argv, do_help);
 310
 311                 if (json_output)
 312                         jsonw_end_object(json_wtr);
 313
 314                 if (err)
 315                         goto err_close;
 316
 317                 lines++;
 318         }
 319
 320         if (errno && errno != ENOENT) {
 321                 p_err("reading batch file failed: %s", strerror(errno));
 322                 err = -1;
 323         } else {
 324                 p_info("processed %d commands", lines);
 325                 err = 0;
 326         }
 327 err_close:
 328         if (fp != stdin)
 329                 fclose(fp);
 330
 331         if (json_output)
 332                 jsonw_end_array(json_wtr);
 333
 334         return err;
 335 }
 336
 337 int main(int argc, char **argv)
 338 {
 339         static const struct option options[] = {
 340                 { "json",       no_argument,    NULL,   'j' },
 341                 { "help",       no_argument,    NULL,   'h' },
 342                 { "pretty",     no_argument,    NULL,   'p' },
 343                 { "version",    no_argument,    NULL,   'V' },
 344                 { "bpffs",      no_argument,    NULL,   'f' },
 345                 { 0 }
 346         };
 347         int opt, ret;
 348
 349         last_do_help = do_help;
 350         pretty_output = false;
 351         json_output = false;
 352         show_pinned = false;
 353         bin_name = argv[0];
 354
 355         hash_init(prog_table.table);
 356         hash_init(map_table.table);
 357
 358         opterr = 0;
 359         while ((opt = getopt_long(argc, argv, "Vhpjf",
 360                                   options, NULL)) >= 0) {
 361                 switch (opt) {
 362                 case 'V':
 363                         return do_version(argc, argv);
 364                 case 'h':
 365                         return do_help(argc, argv);
 366                 case 'p':
 367                         pretty_output = true;
 368                         /* fall through */
 369                 case 'j':
 370                         if (!json_output) {
 371                                 json_wtr = jsonw_new(stdout);
 372                                 if (!json_wtr) {
 373                                         p_err("failed to create JSON writer");
 374                                         return -1;
 375                                 }
 376                                 json_output = true;
 377                         }
 378                         jsonw_pretty(json_wtr, pretty_output);
 379                         break;
 380                 case 'f':
 381                         show_pinned = true;
 382                         break;
 383                 default:
 384                         p_err("unrecognized option '%s'", argv[optind - 1]);
 385                         if (json_output)
 386                                 clean_and_exit(-1);
 387                         else
 388                                 usage();
 389                 }
 390         }
 391
 392         argc -= optind;
 393         argv += optind;
 394         if (argc < 0)
 395                 usage();
 396
 397         bfd_init();
 398
 399         ret = cmd_select(cmds, argc, argv, do_help);
 400
 401         if (json_output)
 402                 jsonw_destroy(&json_wtr);
 403
 404         if (show_pinned) {
 405                 delete_pinned_obj_table(&prog_table);
 406                 delete_pinned_obj_table(&map_table);
 407         }
 408
 409         return ret;
 410 }