1// SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) 2// Copyright (C) 2018 Facebook 3 4#ifndef _GNU_SOURCE 5#define _GNU_SOURCE 6#endif 7#include <errno.h> 8#include <fcntl.h> 9#include <stdlib.h> 10#include <string.h> 11#include <time.h> 12#include <unistd.h> 13#include <bpf/bpf.h> 14#include <bpf/libbpf.h> 15#include <net/if.h> 16#include <linux/rtnetlink.h> 17#include <linux/socket.h> 18#include <linux/tc_act/tc_bpf.h> 19#include <sys/socket.h> 20#include <sys/stat.h> 21#include <sys/types.h> 22 23#include "bpf/nlattr.h" 24#include "main.h" 25#include "netlink_dumper.h" 26 27#ifndef SOL_NETLINK 28#define SOL_NETLINK 270 29#endif 30 31struct ip_devname_ifindex { 32 char devname[64]; 33 int ifindex; 34}; 35 36struct bpf_netdev_t { 37 struct ip_devname_ifindex *devices; 38 int used_len; 39 int array_len; 40 int filter_idx; 41}; 42 43struct tc_kind_handle { 44 char kind[64]; 45 int handle; 46}; 47 48struct bpf_tcinfo_t { 49 struct tc_kind_handle *handle_array; 50 int used_len; 51 int array_len; 52 bool is_qdisc; 53}; 54 55struct bpf_filter_t { 56 const char *kind; 57 const char *devname; 58 int ifindex; 59}; 60 61struct bpf_attach_info { 62 __u32 flow_dissector_id; 63}; 64 65enum net_attach_type { 66 NET_ATTACH_TYPE_XDP, 67 NET_ATTACH_TYPE_XDP_GENERIC, 68 NET_ATTACH_TYPE_XDP_DRIVER, 69 NET_ATTACH_TYPE_XDP_OFFLOAD, 70}; 71 72static const char * const attach_type_strings[] = { 73 [NET_ATTACH_TYPE_XDP] = "xdp", 74 [NET_ATTACH_TYPE_XDP_GENERIC] = "xdpgeneric", 75 [NET_ATTACH_TYPE_XDP_DRIVER] = "xdpdrv", 76 [NET_ATTACH_TYPE_XDP_OFFLOAD] = "xdpoffload", 77}; 78 79static const char * const attach_loc_strings[] = { 80 [BPF_TCX_INGRESS] = "tcx/ingress", 81 [BPF_TCX_EGRESS] = "tcx/egress", 82}; 83 84const size_t net_attach_type_size = ARRAY_SIZE(attach_type_strings); 85 86static enum net_attach_type parse_attach_type(const char *str) 87{ 88 enum net_attach_type type; 89 90 for (type = 0; type < net_attach_type_size; type++) { 91 if (attach_type_strings[type] && 92 is_prefix(str, attach_type_strings[type])) 93 return type; 94 } 95 96 return net_attach_type_size; 97} 98 99typedef int (*dump_nlmsg_t)(void *cookie, void *msg, struct nlattr **tb); 100 101typedef int (*__dump_nlmsg_t)(struct nlmsghdr *nlmsg, dump_nlmsg_t, void *cookie); 102 103static int netlink_open(__u32 *nl_pid) 104{ 105 struct sockaddr_nl sa; 106 socklen_t addrlen; 107 int one = 1, ret; 108 int sock; 109 110 memset(&sa, 0, sizeof(sa)); 111 sa.nl_family = AF_NETLINK; 112 113 sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE); 114 if (sock < 0) 115 return -errno; 116 117 if (setsockopt(sock, SOL_NETLINK, NETLINK_EXT_ACK, 118 &one, sizeof(one)) < 0) { 119 p_err("Netlink error reporting not supported"); 120 } 121 122 if (bind(sock, (struct sockaddr *)&sa, sizeof(sa)) < 0) { 123 ret = -errno; 124 goto cleanup; 125 } 126 127 addrlen = sizeof(sa); 128 if (getsockname(sock, (struct sockaddr *)&sa, &addrlen) < 0) { 129 ret = -errno; 130 goto cleanup; 131 } 132 133 if (addrlen != sizeof(sa)) { 134 ret = -LIBBPF_ERRNO__INTERNAL; 135 goto cleanup; 136 } 137 138 *nl_pid = sa.nl_pid; 139 return sock; 140 141cleanup: 142 close(sock); 143 return ret; 144} 145 146static int netlink_recv(int sock, __u32 nl_pid, __u32 seq, 147 __dump_nlmsg_t _fn, dump_nlmsg_t fn, 148 void *cookie) 149{ 150 bool multipart = true; 151 struct nlmsgerr *err; 152 struct nlmsghdr *nh; 153 char buf[4096]; 154 int len, ret; 155 156 while (multipart) { 157 multipart = false; 158 len = recv(sock, buf, sizeof(buf), 0); 159 if (len < 0) { 160 ret = -errno; 161 goto done; 162 } 163 164 if (len == 0) 165 break; 166 167 for (nh = (struct nlmsghdr *)buf; NLMSG_OK(nh, (unsigned int)len); 168 nh = NLMSG_NEXT(nh, len)) { 169 if (nh->nlmsg_pid != nl_pid) { 170 ret = -LIBBPF_ERRNO__WRNGPID; 171 goto done; 172 } 173 if (nh->nlmsg_seq != seq) { 174 ret = -LIBBPF_ERRNO__INVSEQ; 175 goto done; 176 } 177 if (nh->nlmsg_flags & NLM_F_MULTI) 178 multipart = true; 179 switch (nh->nlmsg_type) { 180 case NLMSG_ERROR: 181 err = (struct nlmsgerr *)NLMSG_DATA(nh); 182 if (!err->error) 183 continue; 184 ret = err->error; 185 libbpf_nla_dump_errormsg(nh); 186 goto done; 187 case NLMSG_DONE: 188 return 0; 189 default: 190 break; 191 } 192 if (_fn) { 193 ret = _fn(nh, fn, cookie); 194 if (ret) 195 return ret; 196 } 197 } 198 } 199 ret = 0; 200done: 201 return ret; 202} 203 204static int __dump_class_nlmsg(struct nlmsghdr *nlh, 205 dump_nlmsg_t dump_class_nlmsg, 206 void *cookie) 207{ 208 struct nlattr *tb[TCA_MAX + 1], *attr; 209 struct tcmsg *t = NLMSG_DATA(nlh); 210 int len; 211 212 len = nlh->nlmsg_len - NLMSG_LENGTH(sizeof(*t)); 213 attr = (struct nlattr *) ((void *) t + NLMSG_ALIGN(sizeof(*t))); 214 if (libbpf_nla_parse(tb, TCA_MAX, attr, len, NULL) != 0) 215 return -LIBBPF_ERRNO__NLPARSE; 216 217 return dump_class_nlmsg(cookie, t, tb); 218} 219 220static int netlink_get_class(int sock, unsigned int nl_pid, int ifindex, 221 dump_nlmsg_t dump_class_nlmsg, void *cookie) 222{ 223 struct { 224 struct nlmsghdr nlh; 225 struct tcmsg t; 226 } req = { 227 .nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct tcmsg)), 228 .nlh.nlmsg_type = RTM_GETTCLASS, 229 .nlh.nlmsg_flags = NLM_F_DUMP | NLM_F_REQUEST, 230 .t.tcm_family = AF_UNSPEC, 231 .t.tcm_ifindex = ifindex, 232 }; 233 int seq = time(NULL); 234 235 req.nlh.nlmsg_seq = seq; 236 if (send(sock, &req, req.nlh.nlmsg_len, 0) < 0) 237 return -errno; 238 239 return netlink_recv(sock, nl_pid, seq, __dump_class_nlmsg, 240 dump_class_nlmsg, cookie); 241} 242 243static int __dump_qdisc_nlmsg(struct nlmsghdr *nlh, 244 dump_nlmsg_t dump_qdisc_nlmsg, 245 void *cookie) 246{ 247 struct nlattr *tb[TCA_MAX + 1], *attr; 248 struct tcmsg *t = NLMSG_DATA(nlh); 249 int len; 250 251 len = nlh->nlmsg_len - NLMSG_LENGTH(sizeof(*t)); 252 attr = (struct nlattr *) ((void *) t + NLMSG_ALIGN(sizeof(*t))); 253 if (libbpf_nla_parse(tb, TCA_MAX, attr, len, NULL) != 0) 254 return -LIBBPF_ERRNO__NLPARSE; 255 256 return dump_qdisc_nlmsg(cookie, t, tb); 257} 258 259static int netlink_get_qdisc(int sock, unsigned int nl_pid, int ifindex, 260 dump_nlmsg_t dump_qdisc_nlmsg, void *cookie) 261{ 262 struct { 263 struct nlmsghdr nlh; 264 struct tcmsg t; 265 } req = { 266 .nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct tcmsg)), 267 .nlh.nlmsg_type = RTM_GETQDISC, 268 .nlh.nlmsg_flags = NLM_F_DUMP | NLM_F_REQUEST, 269 .t.tcm_family = AF_UNSPEC, 270 .t.tcm_ifindex = ifindex, 271 }; 272 int seq = time(NULL); 273 274 req.nlh.nlmsg_seq = seq; 275 if (send(sock, &req, req.nlh.nlmsg_len, 0) < 0) 276 return -errno; 277 278 return netlink_recv(sock, nl_pid, seq, __dump_qdisc_nlmsg, 279 dump_qdisc_nlmsg, cookie); 280} 281 282static int __dump_filter_nlmsg(struct nlmsghdr *nlh, 283 dump_nlmsg_t dump_filter_nlmsg, 284 void *cookie) 285{ 286 struct nlattr *tb[TCA_MAX + 1], *attr; 287 struct tcmsg *t = NLMSG_DATA(nlh); 288 int len; 289 290 len = nlh->nlmsg_len - NLMSG_LENGTH(sizeof(*t)); 291 attr = (struct nlattr *) ((void *) t + NLMSG_ALIGN(sizeof(*t))); 292 if (libbpf_nla_parse(tb, TCA_MAX, attr, len, NULL) != 0) 293 return -LIBBPF_ERRNO__NLPARSE; 294 295 return dump_filter_nlmsg(cookie, t, tb); 296} 297 298static int netlink_get_filter(int sock, unsigned int nl_pid, int ifindex, int handle, 299 dump_nlmsg_t dump_filter_nlmsg, void *cookie) 300{ 301 struct { 302 struct nlmsghdr nlh; 303 struct tcmsg t; 304 } req = { 305 .nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct tcmsg)), 306 .nlh.nlmsg_type = RTM_GETTFILTER, 307 .nlh.nlmsg_flags = NLM_F_DUMP | NLM_F_REQUEST, 308 .t.tcm_family = AF_UNSPEC, 309 .t.tcm_ifindex = ifindex, 310 .t.tcm_parent = handle, 311 }; 312 int seq = time(NULL); 313 314 req.nlh.nlmsg_seq = seq; 315 if (send(sock, &req, req.nlh.nlmsg_len, 0) < 0) 316 return -errno; 317 318 return netlink_recv(sock, nl_pid, seq, __dump_filter_nlmsg, 319 dump_filter_nlmsg, cookie); 320} 321 322static int __dump_link_nlmsg(struct nlmsghdr *nlh, 323 dump_nlmsg_t dump_link_nlmsg, void *cookie) 324{ 325 struct nlattr *tb[IFLA_MAX + 1], *attr; 326 struct ifinfomsg *ifi = NLMSG_DATA(nlh); 327 int len; 328 329 len = nlh->nlmsg_len - NLMSG_LENGTH(sizeof(*ifi)); 330 attr = (struct nlattr *) ((void *) ifi + NLMSG_ALIGN(sizeof(*ifi))); 331 if (libbpf_nla_parse(tb, IFLA_MAX, attr, len, NULL) != 0) 332 return -LIBBPF_ERRNO__NLPARSE; 333 334 return dump_link_nlmsg(cookie, ifi, tb); 335} 336 337static int netlink_get_link(int sock, unsigned int nl_pid, 338 dump_nlmsg_t dump_link_nlmsg, void *cookie) 339{ 340 struct { 341 struct nlmsghdr nlh; 342 struct ifinfomsg ifm; 343 } req = { 344 .nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg)), 345 .nlh.nlmsg_type = RTM_GETLINK, 346 .nlh.nlmsg_flags = NLM_F_DUMP | NLM_F_REQUEST, 347 .ifm.ifi_family = AF_PACKET, 348 }; 349 int seq = time(NULL); 350 351 req.nlh.nlmsg_seq = seq; 352 if (send(sock, &req, req.nlh.nlmsg_len, 0) < 0) 353 return -errno; 354 355 return netlink_recv(sock, nl_pid, seq, __dump_link_nlmsg, 356 dump_link_nlmsg, cookie); 357} 358 359static int dump_link_nlmsg(void *cookie, void *msg, struct nlattr **tb) 360{ 361 struct bpf_netdev_t *netinfo = cookie; 362 struct ifinfomsg *ifinfo = msg; 363 364 if (netinfo->filter_idx > 0 && netinfo->filter_idx != ifinfo->ifi_index) 365 return 0; 366 367 if (netinfo->used_len == netinfo->array_len) { 368 netinfo->devices = realloc(netinfo->devices, 369 (netinfo->array_len + 16) * 370 sizeof(struct ip_devname_ifindex)); 371 if (!netinfo->devices) 372 return -ENOMEM; 373 374 netinfo->array_len += 16; 375 } 376 netinfo->devices[netinfo->used_len].ifindex = ifinfo->ifi_index; 377 snprintf(netinfo->devices[netinfo->used_len].devname, 378 sizeof(netinfo->devices[netinfo->used_len].devname), 379 "%s", 380 tb[IFLA_IFNAME] 381 ? libbpf_nla_getattr_str(tb[IFLA_IFNAME]) 382 : ""); 383 netinfo->used_len++; 384 385 return do_xdp_dump(ifinfo, tb); 386} 387 388static int dump_class_qdisc_nlmsg(void *cookie, void *msg, struct nlattr **tb) 389{ 390 struct bpf_tcinfo_t *tcinfo = cookie; 391 struct tcmsg *info = msg; 392 393 if (tcinfo->is_qdisc) { 394 /* skip clsact qdisc */ 395 if (tb[TCA_KIND] && 396 strcmp(libbpf_nla_data(tb[TCA_KIND]), "clsact") == 0) 397 return 0; 398 if (info->tcm_handle == 0) 399 return 0; 400 } 401 402 if (tcinfo->used_len == tcinfo->array_len) { 403 tcinfo->handle_array = realloc(tcinfo->handle_array, 404 (tcinfo->array_len + 16) * sizeof(struct tc_kind_handle)); 405 if (!tcinfo->handle_array) 406 return -ENOMEM; 407 408 tcinfo->array_len += 16; 409 } 410 tcinfo->handle_array[tcinfo->used_len].handle = info->tcm_handle; 411 snprintf(tcinfo->handle_array[tcinfo->used_len].kind, 412 sizeof(tcinfo->handle_array[tcinfo->used_len].kind), 413 "%s", 414 tb[TCA_KIND] 415 ? libbpf_nla_getattr_str(tb[TCA_KIND]) 416 : "unknown"); 417 tcinfo->used_len++; 418 419 return 0; 420} 421 422static int dump_filter_nlmsg(void *cookie, void *msg, struct nlattr **tb) 423{ 424 const struct bpf_filter_t *filter_info = cookie; 425 426 return do_filter_dump((struct tcmsg *)msg, tb, filter_info->kind, 427 filter_info->devname, filter_info->ifindex); 428} 429 430static int __show_dev_tc_bpf_name(__u32 id, char *name, size_t len) 431{ 432 struct bpf_prog_info info = {}; 433 __u32 ilen = sizeof(info); 434 int fd, ret; 435 436 fd = bpf_prog_get_fd_by_id(id); 437 if (fd < 0) 438 return fd; 439 ret = bpf_obj_get_info_by_fd(fd, &info, &ilen); 440 if (ret < 0) 441 goto out; 442 ret = -ENOENT; 443 if (info.name[0]) { 444 get_prog_full_name(&info, fd, name, len); 445 ret = 0; 446 } 447out: 448 close(fd); 449 return ret; 450} 451 452static void __show_dev_tc_bpf(const struct ip_devname_ifindex *dev, 453 const enum bpf_attach_type loc) 454{ 455 __u32 prog_flags[64] = {}, link_flags[64] = {}, i, j; 456 __u32 prog_ids[64] = {}, link_ids[64] = {}; 457 LIBBPF_OPTS(bpf_prog_query_opts, optq); 458 char prog_name[MAX_PROG_FULL_NAME]; 459 int ret; 460 461 optq.prog_ids = prog_ids; 462 optq.prog_attach_flags = prog_flags; 463 optq.link_ids = link_ids; 464 optq.link_attach_flags = link_flags; 465 optq.count = ARRAY_SIZE(prog_ids); 466 467 ret = bpf_prog_query_opts(dev->ifindex, loc, &optq); 468 if (ret) 469 return; 470 for (i = 0; i < optq.count; i++) { 471 NET_START_OBJECT; 472 NET_DUMP_STR("devname", "%s", dev->devname); 473 NET_DUMP_UINT("ifindex", "(%u)", dev->ifindex); 474 NET_DUMP_STR("kind", " %s", attach_loc_strings[loc]); 475 ret = __show_dev_tc_bpf_name(prog_ids[i], prog_name, 476 sizeof(prog_name)); 477 if (!ret) 478 NET_DUMP_STR("name", " %s", prog_name); 479 NET_DUMP_UINT("prog_id", " prog_id %u ", prog_ids[i]); 480 if (prog_flags[i] || json_output) { 481 NET_START_ARRAY("prog_flags", "%s "); 482 for (j = 0; prog_flags[i] && j < 32; j++) { 483 if (!(prog_flags[i] & (1 << j))) 484 continue; 485 NET_DUMP_UINT_ONLY(1 << j); 486 } 487 NET_END_ARRAY(""); 488 } 489 if (link_ids[i] || json_output) { 490 NET_DUMP_UINT("link_id", "link_id %u ", link_ids[i]); 491 if (link_flags[i] || json_output) { 492 NET_START_ARRAY("link_flags", "%s "); 493 for (j = 0; link_flags[i] && j < 32; j++) { 494 if (!(link_flags[i] & (1 << j))) 495 continue; 496 NET_DUMP_UINT_ONLY(1 << j); 497 } 498 NET_END_ARRAY(""); 499 } 500 } 501 NET_END_OBJECT_FINAL; 502 } 503} 504 505static void show_dev_tc_bpf(struct ip_devname_ifindex *dev) 506{ 507 __show_dev_tc_bpf(dev, BPF_TCX_INGRESS); 508 __show_dev_tc_bpf(dev, BPF_TCX_EGRESS); 509} 510 511static int show_dev_tc_bpf_classic(int sock, unsigned int nl_pid, 512 struct ip_devname_ifindex *dev) 513{ 514 struct bpf_filter_t filter_info; 515 struct bpf_tcinfo_t tcinfo; 516 int i, handle, ret = 0; 517 518 tcinfo.handle_array = NULL; 519 tcinfo.used_len = 0; 520 tcinfo.array_len = 0; 521 522 tcinfo.is_qdisc = false; 523 ret = netlink_get_class(sock, nl_pid, dev->ifindex, 524 dump_class_qdisc_nlmsg, &tcinfo); 525 if (ret) 526 goto out; 527 528 tcinfo.is_qdisc = true; 529 ret = netlink_get_qdisc(sock, nl_pid, dev->ifindex, 530 dump_class_qdisc_nlmsg, &tcinfo); 531 if (ret) 532 goto out; 533 534 filter_info.devname = dev->devname; 535 filter_info.ifindex = dev->ifindex; 536 for (i = 0; i < tcinfo.used_len; i++) { 537 filter_info.kind = tcinfo.handle_array[i].kind; 538 ret = netlink_get_filter(sock, nl_pid, dev->ifindex, 539 tcinfo.handle_array[i].handle, 540 dump_filter_nlmsg, &filter_info); 541 if (ret) 542 goto out; 543 } 544 545 /* root, ingress and egress handle */ 546 handle = TC_H_ROOT; 547 filter_info.kind = "root"; 548 ret = netlink_get_filter(sock, nl_pid, dev->ifindex, handle, 549 dump_filter_nlmsg, &filter_info); 550 if (ret) 551 goto out; 552 553 handle = TC_H_MAKE(TC_H_CLSACT, TC_H_MIN_INGRESS); 554 filter_info.kind = "clsact/ingress"; 555 ret = netlink_get_filter(sock, nl_pid, dev->ifindex, handle, 556 dump_filter_nlmsg, &filter_info); 557 if (ret) 558 goto out; 559 560 handle = TC_H_MAKE(TC_H_CLSACT, TC_H_MIN_EGRESS); 561 filter_info.kind = "clsact/egress"; 562 ret = netlink_get_filter(sock, nl_pid, dev->ifindex, handle, 563 dump_filter_nlmsg, &filter_info); 564 if (ret) 565 goto out; 566 567out: 568 free(tcinfo.handle_array); 569 return 0; 570} 571 572static int query_flow_dissector(struct bpf_attach_info *attach_info) 573{ 574 __u32 attach_flags; 575 __u32 prog_ids[1]; 576 __u32 prog_cnt; 577 int err; 578 int fd; 579 580 fd = open("/proc/self/ns/net", O_RDONLY); 581 if (fd < 0) { 582 p_err("can't open /proc/self/ns/net: %s", 583 strerror(errno)); 584 return -1; 585 } 586 prog_cnt = ARRAY_SIZE(prog_ids); 587 err = bpf_prog_query(fd, BPF_FLOW_DISSECTOR, 0, 588 &attach_flags, prog_ids, &prog_cnt); 589 close(fd); 590 if (err) { 591 if (errno == EINVAL) { 592 /* Older kernel's don't support querying 593 * flow dissector programs. 594 */ 595 errno = 0; 596 return 0; 597 } 598 p_err("can't query prog: %s", strerror(errno)); 599 return -1; 600 } 601 602 if (prog_cnt == 1) 603 attach_info->flow_dissector_id = prog_ids[0]; 604 605 return 0; 606} 607 608static int net_parse_dev(int *argc, char ***argv) 609{ 610 int ifindex; 611 612 if (is_prefix(**argv, "dev")) { 613 NEXT_ARGP(); 614 615 ifindex = if_nametoindex(**argv); 616 if (!ifindex) 617 p_err("invalid devname %s", **argv); 618 619 NEXT_ARGP(); 620 } else { 621 p_err("expected 'dev', got: '%s'?", **argv); 622 return -1; 623 } 624 625 return ifindex; 626} 627 628static int do_attach_detach_xdp(int progfd, enum net_attach_type attach_type, 629 int ifindex, bool overwrite) 630{ 631 __u32 flags = 0; 632 633 if (!overwrite) 634 flags = XDP_FLAGS_UPDATE_IF_NOEXIST; 635 if (attach_type == NET_ATTACH_TYPE_XDP_GENERIC) 636 flags |= XDP_FLAGS_SKB_MODE; 637 if (attach_type == NET_ATTACH_TYPE_XDP_DRIVER) 638 flags |= XDP_FLAGS_DRV_MODE; 639 if (attach_type == NET_ATTACH_TYPE_XDP_OFFLOAD) 640 flags |= XDP_FLAGS_HW_MODE; 641 642 return bpf_xdp_attach(ifindex, progfd, flags, NULL); 643} 644 645static int do_attach(int argc, char **argv) 646{ 647 enum net_attach_type attach_type; 648 int progfd, ifindex, err = 0; 649 bool overwrite = false; 650 651 /* parse attach args */ 652 if (!REQ_ARGS(5)) 653 return -EINVAL; 654 655 attach_type = parse_attach_type(*argv); 656 if (attach_type == net_attach_type_size) { 657 p_err("invalid net attach/detach type: %s", *argv); 658 return -EINVAL; 659 } 660 NEXT_ARG(); 661 662 progfd = prog_parse_fd(&argc, &argv); 663 if (progfd < 0) 664 return -EINVAL; 665 666 ifindex = net_parse_dev(&argc, &argv); 667 if (ifindex < 1) { 668 err = -EINVAL; 669 goto cleanup; 670 } 671 672 if (argc) { 673 if (is_prefix(*argv, "overwrite")) { 674 overwrite = true; 675 } else { 676 p_err("expected 'overwrite', got: '%s'?", *argv); 677 err = -EINVAL; 678 goto cleanup; 679 } 680 } 681 682 /* attach xdp prog */ 683 if (is_prefix("xdp", attach_type_strings[attach_type])) 684 err = do_attach_detach_xdp(progfd, attach_type, ifindex, 685 overwrite); 686 if (err) { 687 p_err("interface %s attach failed: %s", 688 attach_type_strings[attach_type], strerror(-err)); 689 goto cleanup; 690 } 691 692 if (json_output) 693 jsonw_null(json_wtr); 694cleanup: 695 close(progfd); 696 return err; 697} 698 699static int do_detach(int argc, char **argv) 700{ 701 enum net_attach_type attach_type; 702 int progfd, ifindex, err = 0; 703 704 /* parse detach args */ 705 if (!REQ_ARGS(3)) 706 return -EINVAL; 707 708 attach_type = parse_attach_type(*argv); 709 if (attach_type == net_attach_type_size) { 710 p_err("invalid net attach/detach type: %s", *argv); 711 return -EINVAL; 712 } 713 NEXT_ARG(); 714 715 ifindex = net_parse_dev(&argc, &argv); 716 if (ifindex < 1) 717 return -EINVAL; 718 719 /* detach xdp prog */ 720 progfd = -1; 721 if (is_prefix("xdp", attach_type_strings[attach_type])) 722 err = do_attach_detach_xdp(progfd, attach_type, ifindex, NULL); 723 724 if (err < 0) { 725 p_err("interface %s detach failed: %s", 726 attach_type_strings[attach_type], strerror(-err)); 727 return err; 728 } 729 730 if (json_output) 731 jsonw_null(json_wtr); 732 733 return 0; 734} 735 736static int netfilter_link_compar(const void *a, const void *b) 737{ 738 const struct bpf_link_info *nfa = a; 739 const struct bpf_link_info *nfb = b; 740 int delta; 741 742 delta = nfa->netfilter.pf - nfb->netfilter.pf; 743 if (delta) 744 return delta; 745 746 delta = nfa->netfilter.hooknum - nfb->netfilter.hooknum; 747 if (delta) 748 return delta; 749 750 if (nfa->netfilter.priority < nfb->netfilter.priority) 751 return -1; 752 if (nfa->netfilter.priority > nfb->netfilter.priority) 753 return 1; 754 755 return nfa->netfilter.flags - nfb->netfilter.flags; 756} 757 758static void show_link_netfilter(void) 759{ 760 unsigned int nf_link_len = 0, nf_link_count = 0; 761 struct bpf_link_info *nf_link_info = NULL; 762 __u32 id = 0; 763 764 while (true) { 765 struct bpf_link_info info; 766 int fd, err; 767 __u32 len; 768 769 err = bpf_link_get_next_id(id, &id); 770 if (err) { 771 if (errno == ENOENT) 772 break; 773 p_err("can't get next link: %s (id %d)", strerror(errno), id); 774 break; 775 } 776 777 fd = bpf_link_get_fd_by_id(id); 778 if (fd < 0) { 779 p_err("can't get link by id (%u): %s", id, strerror(errno)); 780 continue; 781 } 782 783 memset(&info, 0, sizeof(info)); 784 len = sizeof(info); 785 786 err = bpf_link_get_info_by_fd(fd, &info, &len); 787 788 close(fd); 789 790 if (err) { 791 p_err("can't get link info for fd %d: %s", fd, strerror(errno)); 792 continue; 793 } 794 795 if (info.type != BPF_LINK_TYPE_NETFILTER) 796 continue; 797 798 if (nf_link_count >= nf_link_len) { 799 static const unsigned int max_link_count = INT_MAX / sizeof(info); 800 struct bpf_link_info *expand; 801 802 if (nf_link_count > max_link_count) { 803 p_err("cannot handle more than %u links\n", max_link_count); 804 break; 805 } 806 807 nf_link_len += 16; 808 809 expand = realloc(nf_link_info, nf_link_len * sizeof(info)); 810 if (!expand) { 811 p_err("realloc: %s", strerror(errno)); 812 break; 813 } 814 815 nf_link_info = expand; 816 } 817 818 nf_link_info[nf_link_count] = info; 819 nf_link_count++; 820 } 821 822 qsort(nf_link_info, nf_link_count, sizeof(*nf_link_info), netfilter_link_compar); 823 824 for (id = 0; id < nf_link_count; id++) { 825 NET_START_OBJECT; 826 if (json_output) 827 netfilter_dump_json(&nf_link_info[id], json_wtr); 828 else 829 netfilter_dump_plain(&nf_link_info[id]); 830 831 NET_DUMP_UINT("id", " prog_id %u", nf_link_info[id].prog_id); 832 NET_END_OBJECT; 833 } 834 835 free(nf_link_info); 836} 837 838static int do_show(int argc, char **argv) 839{ 840 struct bpf_attach_info attach_info = {}; 841 int i, sock, ret, filter_idx = -1; 842 struct bpf_netdev_t dev_array; 843 unsigned int nl_pid = 0; 844 char err_buf[256]; 845 846 if (argc == 2) { 847 filter_idx = net_parse_dev(&argc, &argv); 848 if (filter_idx < 1) 849 return -1; 850 } else if (argc != 0) { 851 usage(); 852 } 853 854 ret = query_flow_dissector(&attach_info); 855 if (ret) 856 return -1; 857 858 sock = netlink_open(&nl_pid); 859 if (sock < 0) { 860 fprintf(stderr, "failed to open netlink sock\n"); 861 return -1; 862 } 863 864 dev_array.devices = NULL; 865 dev_array.used_len = 0; 866 dev_array.array_len = 0; 867 dev_array.filter_idx = filter_idx; 868 869 if (json_output) 870 jsonw_start_array(json_wtr); 871 NET_START_OBJECT; 872 NET_START_ARRAY("xdp", "%s:\n"); 873 ret = netlink_get_link(sock, nl_pid, dump_link_nlmsg, &dev_array); 874 NET_END_ARRAY("\n"); 875 876 if (!ret) { 877 NET_START_ARRAY("tc", "%s:\n"); 878 for (i = 0; i < dev_array.used_len; i++) { 879 show_dev_tc_bpf(&dev_array.devices[i]); 880 ret = show_dev_tc_bpf_classic(sock, nl_pid, 881 &dev_array.devices[i]); 882 if (ret) 883 break; 884 } 885 NET_END_ARRAY("\n"); 886 } 887 888 NET_START_ARRAY("flow_dissector", "%s:\n"); 889 if (attach_info.flow_dissector_id > 0) 890 NET_DUMP_UINT("id", "id %u", attach_info.flow_dissector_id); 891 NET_END_ARRAY("\n"); 892 893 NET_START_ARRAY("netfilter", "%s:\n"); 894 show_link_netfilter(); 895 NET_END_ARRAY("\n"); 896 897 NET_END_OBJECT; 898 if (json_output) 899 jsonw_end_array(json_wtr); 900 901 if (ret) { 902 if (json_output) 903 jsonw_null(json_wtr); 904 libbpf_strerror(ret, err_buf, sizeof(err_buf)); 905 fprintf(stderr, "Error: %s\n", err_buf); 906 } 907 free(dev_array.devices); 908 close(sock); 909 return ret; 910} 911 912static int do_help(int argc, char **argv) 913{ 914 if (json_output) { 915 jsonw_null(json_wtr); 916 return 0; 917 } 918 919 fprintf(stderr, 920 "Usage: %1$s %2$s { show | list } [dev <devname>]\n" 921 " %1$s %2$s attach ATTACH_TYPE PROG dev <devname> [ overwrite ]\n" 922 " %1$s %2$s detach ATTACH_TYPE dev <devname>\n" 923 " %1$s %2$s help\n" 924 "\n" 925 " " HELP_SPEC_PROGRAM "\n" 926 " ATTACH_TYPE := { xdp | xdpgeneric | xdpdrv | xdpoffload }\n" 927 " " HELP_SPEC_OPTIONS " }\n" 928 "\n" 929 "Note: Only xdp, tcx, tc, flow_dissector and netfilter attachments\n" 930 " are currently supported.\n" 931 " For progs attached to cgroups, use \"bpftool cgroup\"\n" 932 " to dump program attachments. For program types\n" 933 " sk_{filter,skb,msg,reuseport} and lwt/seg6, please\n" 934 " consult iproute2.\n" 935 "", 936 bin_name, argv[-2]); 937 938 return 0; 939} 940 941static const struct cmd cmds[] = { 942 { "show", do_show }, 943 { "list", do_show }, 944 { "attach", do_attach }, 945 { "detach", do_detach }, 946 { "help", do_help }, 947 { 0 } 948}; 949 950int do_net(int argc, char **argv) 951{ 952 return cmd_select(cmds, argc, argv, do_help); 953} 954