1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) 2 /* Copyright (C) 2017-2018 Netronome Systems, Inc. */ 3 4 #include <ctype.h> 5 #include <errno.h> 6 #include <getopt.h> 7 #include <linux/bpf.h> 8 #include <stdio.h> 9 #include <stdlib.h> 10 #include <string.h> 11 12 #include <bpf/bpf.h> 13 #include <bpf/libbpf.h> 14 15 #include "main.h" 16 17 #define BATCH_LINE_LEN_MAX 65536 18 #define BATCH_ARG_NB_MAX 4096 19 20 const char *bin_name; 21 static int last_argc; 22 static char **last_argv; 23 static int (*last_do_help)(int argc, char **argv); 24 json_writer_t *json_wtr; 25 bool pretty_output; 26 bool json_output; 27 bool show_pinned; 28 bool block_mount; 29 bool verifier_logs; 30 bool relaxed_maps; 31 struct pinned_obj_table prog_table; 32 struct pinned_obj_table map_table; 33 struct pinned_obj_table link_table; 34 35 static void __noreturn clean_and_exit(int i) 36 { 37 if (json_output) 38 jsonw_destroy(&json_wtr); 39 40 exit(i); 41 } 42 43 void usage(void) 44 { 45 last_do_help(last_argc - 1, last_argv + 1); 46 47 clean_and_exit(-1); 48 } 49 50 static int do_help(int argc, char **argv) 51 { 52 if (json_output) { 53 jsonw_null(json_wtr); 54 return 0; 55 } 56 57 fprintf(stderr, 58 "Usage: %s [OPTIONS] OBJECT { COMMAND | help }\n" 59 " %s batch file FILE\n" 60 " %s version\n" 61 "\n" 62 " OBJECT := { prog | map | link | cgroup | perf | net | feature | btf | gen | struct_ops }\n" 63 " " HELP_SPEC_OPTIONS "\n" 64 "", 65 bin_name, bin_name, bin_name); 66 67 return 0; 68 } 69 70 static int do_version(int argc, char **argv) 71 { 72 if (json_output) { 73 jsonw_start_object(json_wtr); 74 jsonw_name(json_wtr, "version"); 75 jsonw_printf(json_wtr, "\"%s\"", BPFTOOL_VERSION); 76 jsonw_end_object(json_wtr); 77 } else { 78 printf("%s v%s\n", bin_name, BPFTOOL_VERSION); 79 } 80 return 0; 81 } 82 83 int cmd_select(const struct cmd *cmds, int argc, char **argv, 84 int (*help)(int argc, char **argv)) 85 { 86 unsigned int i; 87 88 last_argc = argc; 89 last_argv = argv; 90 last_do_help = help; 91 92 if (argc < 1 && cmds[0].func) 93 return cmds[0].func(argc, argv); 94 95 for (i = 0; cmds[i].func; i++) 96 if (is_prefix(*argv, cmds[i].cmd)) 97 return cmds[i].func(argc - 1, argv + 1); 98 99 help(argc - 1, argv + 1); 100 101 return -1; 102 } 103 104 bool is_prefix(const char *pfx, const char *str) 105 { 106 if (!pfx) 107 return false; 108 if (strlen(str) < strlen(pfx)) 109 return false; 110 111 return !memcmp(str, pfx, strlen(pfx)); 112 } 113 114 /* Last argument MUST be NULL pointer */ 115 int detect_common_prefix(const char *arg, ...) 116 { 117 unsigned int count = 0; 118 const char *ref; 119 char msg[256]; 120 va_list ap; 121 122 snprintf(msg, sizeof(msg), "ambiguous prefix: '%s' could be '", arg); 123 va_start(ap, arg); 124 while ((ref = va_arg(ap, const char *))) { 125 if (!is_prefix(arg, ref)) 126 continue; 127 count++; 128 if (count > 1) 129 strncat(msg, "' or '", sizeof(msg) - strlen(msg) - 1); 130 strncat(msg, ref, sizeof(msg) - strlen(msg) - 1); 131 } 132 va_end(ap); 133 strncat(msg, "'", sizeof(msg) - strlen(msg) - 1); 134 135 if (count >= 2) { 136 p_err("%s", msg); 137 return -1; 138 } 139 140 return 0; 141 } 142 143 void fprint_hex(FILE *f, void *arg, unsigned int n, const char *sep) 144 { 145 unsigned char *data = arg; 146 unsigned int i; 147 148 for (i = 0; i < n; i++) { 149 const char *pfx = ""; 150 151 if (!i) 152 /* nothing */; 153 else if (!(i % 16)) 154 fprintf(f, "\n"); 155 else if (!(i % 8)) 156 fprintf(f, " "); 157 else 158 pfx = sep; 159 160 fprintf(f, "%s%02hhx", i ? pfx : "", data[i]); 161 } 162 } 163 164 /* Split command line into argument vector. */ 165 static int make_args(char *line, char *n_argv[], int maxargs, int cmd_nb) 166 { 167 static const char ws[] = " \t\r\n"; 168 char *cp = line; 169 int n_argc = 0; 170 171 while (*cp) { 172 /* Skip leading whitespace. */ 173 cp += strspn(cp, ws); 174 175 if (*cp == '\0') 176 break; 177 178 if (n_argc >= (maxargs - 1)) { 179 p_err("too many arguments to command %d", cmd_nb); 180 return -1; 181 } 182 183 /* Word begins with quote. */ 184 if (*cp == '\'' || *cp == '"') { 185 char quote = *cp++; 186 187 n_argv[n_argc++] = cp; 188 /* Find ending quote. */ 189 cp = strchr(cp, quote); 190 if (!cp) { 191 p_err("unterminated quoted string in command %d", 192 cmd_nb); 193 return -1; 194 } 195 } else { 196 n_argv[n_argc++] = cp; 197 198 /* Find end of word. */ 199 cp += strcspn(cp, ws); 200 if (*cp == '\0') 201 break; 202 } 203 204 /* Separate words. */ 205 *cp++ = 0; 206 } 207 n_argv[n_argc] = NULL; 208 209 return n_argc; 210 } 211 212 static int do_batch(int argc, char **argv); 213 214 static const struct cmd cmds[] = { 215 { "help", do_help }, 216 { "batch", do_batch }, 217 { "prog", do_prog }, 218 { "map", do_map }, 219 { "link", do_link }, 220 { "cgroup", do_cgroup }, 221 { "perf", do_perf }, 222 { "net", do_net }, 223 { "feature", do_feature }, 224 { "btf", do_btf }, 225 { "gen", do_gen }, 226 { "struct_ops", do_struct_ops }, 227 { "version", do_version }, 228 { 0 } 229 }; 230 231 static int do_batch(int argc, char **argv) 232 { 233 char buf[BATCH_LINE_LEN_MAX], contline[BATCH_LINE_LEN_MAX]; 234 char *n_argv[BATCH_ARG_NB_MAX]; 235 unsigned int lines = 0; 236 int n_argc; 237 FILE *fp; 238 char *cp; 239 int err; 240 int i; 241 242 if (argc < 2) { 243 p_err("too few parameters for batch"); 244 return -1; 245 } else if (!is_prefix(*argv, "file")) { 246 p_err("expected 'file', got: %s", *argv); 247 return -1; 248 } else if (argc > 2) { 249 p_err("too many parameters for batch"); 250 return -1; 251 } 252 NEXT_ARG(); 253 254 if (!strcmp(*argv, "-")) 255 fp = stdin; 256 else 257 fp = fopen(*argv, "r"); 258 if (!fp) { 259 p_err("Can't open file (%s): %s", *argv, strerror(errno)); 260 return -1; 261 } 262 263 if (json_output) 264 jsonw_start_array(json_wtr); 265 while (fgets(buf, sizeof(buf), fp)) { 266 cp = strchr(buf, '#'); 267 if (cp) 268 *cp = '\0'; 269 270 if (strlen(buf) == sizeof(buf) - 1) { 271 errno = E2BIG; 272 break; 273 } 274 275 /* Append continuation lines if any (coming after a line ending 276 * with '\' in the batch file). 277 */ 278 while ((cp = strstr(buf, "\\\n")) != NULL) { 279 if (!fgets(contline, sizeof(contline), fp) || 280 strlen(contline) == 0) { 281 p_err("missing continuation line on command %d", 282 lines); 283 err = -1; 284 goto err_close; 285 } 286 287 cp = strchr(contline, '#'); 288 if (cp) 289 *cp = '\0'; 290 291 if (strlen(buf) + strlen(contline) + 1 > sizeof(buf)) { 292 p_err("command %d is too long", lines); 293 err = -1; 294 goto err_close; 295 } 296 buf[strlen(buf) - 2] = '\0'; 297 strcat(buf, contline); 298 } 299 300 n_argc = make_args(buf, n_argv, BATCH_ARG_NB_MAX, lines); 301 if (!n_argc) 302 continue; 303 if (n_argc < 0) 304 goto err_close; 305 306 if (json_output) { 307 jsonw_start_object(json_wtr); 308 jsonw_name(json_wtr, "command"); 309 jsonw_start_array(json_wtr); 310 for (i = 0; i < n_argc; i++) 311 jsonw_string(json_wtr, n_argv[i]); 312 jsonw_end_array(json_wtr); 313 jsonw_name(json_wtr, "output"); 314 } 315 316 err = cmd_select(cmds, n_argc, n_argv, do_help); 317 318 if (json_output) 319 jsonw_end_object(json_wtr); 320 321 if (err) 322 goto err_close; 323 324 lines++; 325 } 326 327 if (errno && errno != ENOENT) { 328 p_err("reading batch file failed: %s", strerror(errno)); 329 err = -1; 330 } else { 331 if (!json_output) 332 printf("processed %d commands\n", lines); 333 err = 0; 334 } 335 err_close: 336 if (fp != stdin) 337 fclose(fp); 338 339 if (json_output) 340 jsonw_end_array(json_wtr); 341 342 return err; 343 } 344 345 int main(int argc, char **argv) 346 { 347 static const struct option options[] = { 348 { "json", no_argument, NULL, 'j' }, 349 { "help", no_argument, NULL, 'h' }, 350 { "pretty", no_argument, NULL, 'p' }, 351 { "version", no_argument, NULL, 'V' }, 352 { "bpffs", no_argument, NULL, 'f' }, 353 { "mapcompat", no_argument, NULL, 'm' }, 354 { "nomount", no_argument, NULL, 'n' }, 355 { "debug", no_argument, NULL, 'd' }, 356 { 0 } 357 }; 358 int opt, ret; 359 360 last_do_help = do_help; 361 pretty_output = false; 362 json_output = false; 363 show_pinned = false; 364 block_mount = false; 365 bin_name = argv[0]; 366 367 hash_init(prog_table.table); 368 hash_init(map_table.table); 369 hash_init(link_table.table); 370 371 opterr = 0; 372 while ((opt = getopt_long(argc, argv, "Vhpjfmnd", 373 options, NULL)) >= 0) { 374 switch (opt) { 375 case 'V': 376 return do_version(argc, argv); 377 case 'h': 378 return do_help(argc, argv); 379 case 'p': 380 pretty_output = true; 381 /* fall through */ 382 case 'j': 383 if (!json_output) { 384 json_wtr = jsonw_new(stdout); 385 if (!json_wtr) { 386 p_err("failed to create JSON writer"); 387 return -1; 388 } 389 json_output = true; 390 } 391 jsonw_pretty(json_wtr, pretty_output); 392 break; 393 case 'f': 394 show_pinned = true; 395 break; 396 case 'm': 397 relaxed_maps = true; 398 break; 399 case 'n': 400 block_mount = true; 401 break; 402 case 'd': 403 libbpf_set_print(print_all_levels); 404 verifier_logs = true; 405 break; 406 default: 407 p_err("unrecognized option '%s'", argv[optind - 1]); 408 if (json_output) 409 clean_and_exit(-1); 410 else 411 usage(); 412 } 413 } 414 415 argc -= optind; 416 argv += optind; 417 if (argc < 0) 418 usage(); 419 420 ret = cmd_select(cmds, argc, argv, do_help); 421 422 if (json_output) 423 jsonw_destroy(&json_wtr); 424 425 if (show_pinned) { 426 delete_pinned_obj_table(&prog_table); 427 delete_pinned_obj_table(&map_table); 428 delete_pinned_obj_table(&link_table); 429 } 430 431 return ret; 432 } 433