tools/lib/bpf/netlink.c

   1 // SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause)
   2 /* Copyright (c) 2018 Facebook */
   3
   4 #include <stdlib.h>
   5 #include <memory.h>
   6 #include <unistd.h>
   7 #include <linux/bpf.h>
   8 #include <linux/rtnetlink.h>
   9 #include <sys/socket.h>
  10 #include <errno.h>
  11 #include <time.h>
  12
  13 #include "bpf.h"
  14 #include "libbpf.h"
  15 #include "libbpf_internal.h"
  16 #include "nlattr.h"
  17
  18 /* make sure libbpf doesn't use kernel-only integer typedefs */
  19 #pragma GCC poison u8 u16 u32 u64 s8 s16 s32 s64
  20
  21 #ifndef SOL_NETLINK
  22 #define SOL_NETLINK 270
  23 #endif
  24
  25 typedef int (*__dump_nlmsg_t)(struct nlmsghdr *nlmsg, libbpf_dump_nlmsg_t,
  26                               void *cookie);
  27
  28 struct xdp_id_md {
  29         int ifindex;
  30         __u32 flags;
  31         struct xdp_link_info info;
  32 };
  33
  34 int libbpf_netlink_open(__u32 *nl_pid)
  35 {
  36         struct sockaddr_nl sa;
  37         socklen_t addrlen;
  38         int one = 1, ret;
  39         int sock;
  40
  41         memset(&sa, 0, sizeof(sa));
  42         sa.nl_family = AF_NETLINK;
  43
  44         sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
  45         if (sock < 0)
  46                 return -errno;
  47
  48         if (setsockopt(sock, SOL_NETLINK, NETLINK_EXT_ACK,
  49                        &one, sizeof(one)) < 0) {
  50                 pr_warn("Netlink error reporting not supported\n");
  51         }
  52
  53         if (bind(sock, (struct sockaddr *)&sa, sizeof(sa)) < 0) {
  54                 ret = -errno;
  55                 goto cleanup;
  56         }
  57
  58         addrlen = sizeof(sa);
  59         if (getsockname(sock, (struct sockaddr *)&sa, &addrlen) < 0) {
  60                 ret = -errno;
  61                 goto cleanup;
  62         }
  63
  64         if (addrlen != sizeof(sa)) {
  65                 ret = -LIBBPF_ERRNO__INTERNAL;
  66                 goto cleanup;
  67         }
  68
  69         *nl_pid = sa.nl_pid;
  70         return sock;
  71
  72 cleanup:
  73         close(sock);
  74         return ret;
  75 }
  76
  77 static int bpf_netlink_recv(int sock, __u32 nl_pid, int seq,
  78                             __dump_nlmsg_t _fn, libbpf_dump_nlmsg_t fn,
  79                             void *cookie)
  80 {
  81         bool multipart = true;
  82         struct nlmsgerr *err;
  83         struct nlmsghdr *nh;
  84         char buf[4096];
  85         int len, ret;
  86
  87         while (multipart) {
  88                 multipart = false;
  89                 len = recv(sock, buf, sizeof(buf), 0);
  90                 if (len < 0) {
  91                         ret = -errno;
  92                         goto done;
  93                 }
  94
  95                 if (len == 0)
  96                         break;
  97
  98                 for (nh = (struct nlmsghdr *)buf; NLMSG_OK(nh, len);
  99                      nh = NLMSG_NEXT(nh, len)) {
 100                         if (nh->nlmsg_pid != nl_pid) {
 101                                 ret = -LIBBPF_ERRNO__WRNGPID;
 102                                 goto done;
 103                         }
 104                         if (nh->nlmsg_seq != seq) {
 105                                 ret = -LIBBPF_ERRNO__INVSEQ;
 106                                 goto done;
 107                         }
 108                         if (nh->nlmsg_flags & NLM_F_MULTI)
 109                                 multipart = true;
 110                         switch (nh->nlmsg_type) {
 111                         case NLMSG_ERROR:
 112                                 err = (struct nlmsgerr *)NLMSG_DATA(nh);
 113                                 if (!err->error)
 114                                         continue;
 115                                 ret = err->error;
 116                                 libbpf_nla_dump_errormsg(nh);
 117                                 goto done;
 118                         case NLMSG_DONE:
 119                                 return 0;
 120                         default:
 121                                 break;
 122                         }
 123                         if (_fn) {
 124                                 ret = _fn(nh, fn, cookie);
 125                                 if (ret)
 126                                         return ret;
 127                         }
 128                 }
 129         }
 130         ret = 0;
 131 done:
 132         return ret;
 133 }
 134
 135 static int __bpf_set_link_xdp_fd_replace(int ifindex, int fd, int old_fd,
 136                                          __u32 flags)
 137 {
 138         int sock, seq = 0, ret;
 139         struct nlattr *nla, *nla_xdp;
 140         struct {
 141                 struct nlmsghdr  nh;
 142                 struct ifinfomsg ifinfo;
 143                 char             attrbuf[64];
 144         } req;
 145         __u32 nl_pid;
 146
 147         sock = libbpf_netlink_open(&nl_pid);
 148         if (sock < 0)
 149                 return sock;
 150
 151         memset(&req, 0, sizeof(req));
 152         req.nh.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg));
 153         req.nh.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK;
 154         req.nh.nlmsg_type = RTM_SETLINK;
 155         req.nh.nlmsg_pid = 0;
 156         req.nh.nlmsg_seq = ++seq;
 157         req.ifinfo.ifi_family = AF_UNSPEC;
 158         req.ifinfo.ifi_index = ifindex;
 159
 160         /* started nested attribute for XDP */
 161         nla = (struct nlattr *)(((char *)&req)
 162                                 + NLMSG_ALIGN(req.nh.nlmsg_len));
 163         nla->nla_type = NLA_F_NESTED | IFLA_XDP;
 164         nla->nla_len = NLA_HDRLEN;
 165
 166         /* add XDP fd */
 167         nla_xdp = (struct nlattr *)((char *)nla + nla->nla_len);
 168         nla_xdp->nla_type = IFLA_XDP_FD;
 169         nla_xdp->nla_len = NLA_HDRLEN + sizeof(int);
 170         memcpy((char *)nla_xdp + NLA_HDRLEN, &fd, sizeof(fd));
 171         nla->nla_len += nla_xdp->nla_len;
 172
 173         /* if user passed in any flags, add those too */
 174         if (flags) {
 175                 nla_xdp = (struct nlattr *)((char *)nla + nla->nla_len);
 176                 nla_xdp->nla_type = IFLA_XDP_FLAGS;
 177                 nla_xdp->nla_len = NLA_HDRLEN + sizeof(flags);
 178                 memcpy((char *)nla_xdp + NLA_HDRLEN, &flags, sizeof(flags));
 179                 nla->nla_len += nla_xdp->nla_len;
 180         }
 181
 182         if (flags & XDP_FLAGS_REPLACE) {
 183                 nla_xdp = (struct nlattr *)((char *)nla + nla->nla_len);
 184                 nla_xdp->nla_type = IFLA_XDP_EXPECTED_FD;
 185                 nla_xdp->nla_len = NLA_HDRLEN + sizeof(old_fd);
 186                 memcpy((char *)nla_xdp + NLA_HDRLEN, &old_fd, sizeof(old_fd));
 187                 nla->nla_len += nla_xdp->nla_len;
 188         }
 189
 190         req.nh.nlmsg_len += NLA_ALIGN(nla->nla_len);
 191
 192         if (send(sock, &req, req.nh.nlmsg_len, 0) < 0) {
 193                 ret = -errno;
 194                 goto cleanup;
 195         }
 196         ret = bpf_netlink_recv(sock, nl_pid, seq, NULL, NULL, NULL);
 197
 198 cleanup:
 199         close(sock);
 200         return ret;
 201 }
 202
 203 int bpf_set_link_xdp_fd_opts(int ifindex, int fd, __u32 flags,
 204                              const struct bpf_xdp_set_link_opts *opts)
 205 {
 206         int old_fd = -1;
 207
 208         if (!OPTS_VALID(opts, bpf_xdp_set_link_opts))
 209                 return -EINVAL;
 210
 211         if (OPTS_HAS(opts, old_fd)) {
 212                 old_fd = OPTS_GET(opts, old_fd, -1);
 213                 flags |= XDP_FLAGS_REPLACE;
 214         }
 215
 216         return __bpf_set_link_xdp_fd_replace(ifindex, fd,
 217                                              old_fd,
 218                                              flags);
 219 }
 220
 221 int bpf_set_link_xdp_fd(int ifindex, int fd, __u32 flags)
 222 {
 223         return __bpf_set_link_xdp_fd_replace(ifindex, fd, 0, flags);
 224 }
 225
 226 static int __dump_link_nlmsg(struct nlmsghdr *nlh,
 227                              libbpf_dump_nlmsg_t dump_link_nlmsg, void *cookie)
 228 {
 229         struct nlattr *tb[IFLA_MAX + 1], *attr;
 230         struct ifinfomsg *ifi = NLMSG_DATA(nlh);
 231         int len;
 232
 233         len = nlh->nlmsg_len - NLMSG_LENGTH(sizeof(*ifi));
 234         attr = (struct nlattr *) ((void *) ifi + NLMSG_ALIGN(sizeof(*ifi)));
 235         if (libbpf_nla_parse(tb, IFLA_MAX, attr, len, NULL) != 0)
 236                 return -LIBBPF_ERRNO__NLPARSE;
 237
 238         return dump_link_nlmsg(cookie, ifi, tb);
 239 }
 240
 241 static int get_xdp_info(void *cookie, void *msg, struct nlattr **tb)
 242 {
 243         struct nlattr *xdp_tb[IFLA_XDP_MAX + 1];
 244         struct xdp_id_md *xdp_id = cookie;
 245         struct ifinfomsg *ifinfo = msg;
 246         int ret;
 247
 248         if (xdp_id->ifindex && xdp_id->ifindex != ifinfo->ifi_index)
 249                 return 0;
 250
 251         if (!tb[IFLA_XDP])
 252                 return 0;
 253
 254         ret = libbpf_nla_parse_nested(xdp_tb, IFLA_XDP_MAX, tb[IFLA_XDP], NULL);
 255         if (ret)
 256                 return ret;
 257
 258         if (!xdp_tb[IFLA_XDP_ATTACHED])
 259                 return 0;
 260
 261         xdp_id->info.attach_mode = libbpf_nla_getattr_u8(
 262                 xdp_tb[IFLA_XDP_ATTACHED]);
 263
 264         if (xdp_id->info.attach_mode == XDP_ATTACHED_NONE)
 265                 return 0;
 266
 267         if (xdp_tb[IFLA_XDP_PROG_ID])
 268                 xdp_id->info.prog_id = libbpf_nla_getattr_u32(
 269                         xdp_tb[IFLA_XDP_PROG_ID]);
 270
 271         if (xdp_tb[IFLA_XDP_SKB_PROG_ID])
 272                 xdp_id->info.skb_prog_id = libbpf_nla_getattr_u32(
 273                         xdp_tb[IFLA_XDP_SKB_PROG_ID]);
 274
 275         if (xdp_tb[IFLA_XDP_DRV_PROG_ID])
 276                 xdp_id->info.drv_prog_id = libbpf_nla_getattr_u32(
 277                         xdp_tb[IFLA_XDP_DRV_PROG_ID]);
 278
 279         if (xdp_tb[IFLA_XDP_HW_PROG_ID])
 280                 xdp_id->info.hw_prog_id = libbpf_nla_getattr_u32(
 281                         xdp_tb[IFLA_XDP_HW_PROG_ID]);
 282
 283         return 0;
 284 }
 285
 286 int bpf_get_link_xdp_info(int ifindex, struct xdp_link_info *info,
 287                           size_t info_size, __u32 flags)
 288 {
 289         struct xdp_id_md xdp_id = {};
 290         int sock, ret;
 291         __u32 nl_pid;
 292         __u32 mask;
 293
 294         if (flags & ~XDP_FLAGS_MASK || !info_size)
 295                 return -EINVAL;
 296
 297         /* Check whether the single {HW,DRV,SKB} mode is set */
 298         flags &= (XDP_FLAGS_SKB_MODE | XDP_FLAGS_DRV_MODE | XDP_FLAGS_HW_MODE);
 299         mask = flags - 1;
 300         if (flags && flags & mask)
 301                 return -EINVAL;
 302
 303         sock = libbpf_netlink_open(&nl_pid);
 304         if (sock < 0)
 305                 return sock;
 306
 307         xdp_id.ifindex = ifindex;
 308         xdp_id.flags = flags;
 309
 310         ret = libbpf_nl_get_link(sock, nl_pid, get_xdp_info, &xdp_id);
 311         if (!ret) {
 312                 size_t sz = min(info_size, sizeof(xdp_id.info));
 313
 314                 memcpy(info, &xdp_id.info, sz);
 315                 memset((void *) info + sz, 0, info_size - sz);
 316         }
 317
 318         close(sock);
 319         return ret;
 320 }
 321
 322 static __u32 get_xdp_id(struct xdp_link_info *info, __u32 flags)
 323 {
 324         if (info->attach_mode != XDP_ATTACHED_MULTI)
 325                 return info->prog_id;
 326         if (flags & XDP_FLAGS_DRV_MODE)
 327                 return info->drv_prog_id;
 328         if (flags & XDP_FLAGS_HW_MODE)
 329                 return info->hw_prog_id;
 330         if (flags & XDP_FLAGS_SKB_MODE)
 331                 return info->skb_prog_id;
 332
 333         return 0;
 334 }
 335
 336 int bpf_get_link_xdp_id(int ifindex, __u32 *prog_id, __u32 flags)
 337 {
 338         struct xdp_link_info info;
 339         int ret;
 340
 341         ret = bpf_get_link_xdp_info(ifindex, &info, sizeof(info), flags);
 342         if (!ret)
 343                 *prog_id = get_xdp_id(&info, flags);
 344
 345         return ret;
 346 }
 347
 348 int libbpf_nl_get_link(int sock, unsigned int nl_pid,
 349                        libbpf_dump_nlmsg_t dump_link_nlmsg, void *cookie)
 350 {
 351         struct {
 352                 struct nlmsghdr nlh;
 353                 struct ifinfomsg ifm;
 354         } req = {
 355                 .nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg)),
 356                 .nlh.nlmsg_type = RTM_GETLINK,
 357                 .nlh.nlmsg_flags = NLM_F_DUMP | NLM_F_REQUEST,
 358                 .ifm.ifi_family = AF_PACKET,
 359         };
 360         int seq = time(NULL);
 361
 362         req.nlh.nlmsg_seq = seq;
 363         if (send(sock, &req, req.nlh.nlmsg_len, 0) < 0)
 364                 return -errno;
 365
 366         return bpf_netlink_recv(sock, nl_pid, seq, __dump_link_nlmsg,
 367                                 dump_link_nlmsg, cookie);
 368 }
 369
 370 static int __dump_class_nlmsg(struct nlmsghdr *nlh,
 371                               libbpf_dump_nlmsg_t dump_class_nlmsg,
 372                               void *cookie)
 373 {
 374         struct nlattr *tb[TCA_MAX + 1], *attr;
 375         struct tcmsg *t = NLMSG_DATA(nlh);
 376         int len;
 377
 378         len = nlh->nlmsg_len - NLMSG_LENGTH(sizeof(*t));
 379         attr = (struct nlattr *) ((void *) t + NLMSG_ALIGN(sizeof(*t)));
 380         if (libbpf_nla_parse(tb, TCA_MAX, attr, len, NULL) != 0)
 381                 return -LIBBPF_ERRNO__NLPARSE;
 382
 383         return dump_class_nlmsg(cookie, t, tb);
 384 }
 385
 386 int libbpf_nl_get_class(int sock, unsigned int nl_pid, int ifindex,
 387                         libbpf_dump_nlmsg_t dump_class_nlmsg, void *cookie)
 388 {
 389         struct {
 390                 struct nlmsghdr nlh;
 391                 struct tcmsg t;
 392         } req = {
 393                 .nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct tcmsg)),
 394                 .nlh.nlmsg_type = RTM_GETTCLASS,
 395                 .nlh.nlmsg_flags = NLM_F_DUMP | NLM_F_REQUEST,
 396                 .t.tcm_family = AF_UNSPEC,
 397                 .t.tcm_ifindex = ifindex,
 398         };
 399         int seq = time(NULL);
 400
 401         req.nlh.nlmsg_seq = seq;
 402         if (send(sock, &req, req.nlh.nlmsg_len, 0) < 0)
 403                 return -errno;
 404
 405         return bpf_netlink_recv(sock, nl_pid, seq, __dump_class_nlmsg,
 406                                 dump_class_nlmsg, cookie);
 407 }
 408
 409 static int __dump_qdisc_nlmsg(struct nlmsghdr *nlh,
 410                               libbpf_dump_nlmsg_t dump_qdisc_nlmsg,
 411                               void *cookie)
 412 {
 413         struct nlattr *tb[TCA_MAX + 1], *attr;
 414         struct tcmsg *t = NLMSG_DATA(nlh);
 415         int len;
 416
 417         len = nlh->nlmsg_len - NLMSG_LENGTH(sizeof(*t));
 418         attr = (struct nlattr *) ((void *) t + NLMSG_ALIGN(sizeof(*t)));
 419         if (libbpf_nla_parse(tb, TCA_MAX, attr, len, NULL) != 0)
 420                 return -LIBBPF_ERRNO__NLPARSE;
 421
 422         return dump_qdisc_nlmsg(cookie, t, tb);
 423 }
 424
 425 int libbpf_nl_get_qdisc(int sock, unsigned int nl_pid, int ifindex,
 426                         libbpf_dump_nlmsg_t dump_qdisc_nlmsg, void *cookie)
 427 {
 428         struct {
 429                 struct nlmsghdr nlh;
 430                 struct tcmsg t;
 431         } req = {
 432                 .nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct tcmsg)),
 433                 .nlh.nlmsg_type = RTM_GETQDISC,
 434                 .nlh.nlmsg_flags = NLM_F_DUMP | NLM_F_REQUEST,
 435                 .t.tcm_family = AF_UNSPEC,
 436                 .t.tcm_ifindex = ifindex,
 437         };
 438         int seq = time(NULL);
 439
 440         req.nlh.nlmsg_seq = seq;
 441         if (send(sock, &req, req.nlh.nlmsg_len, 0) < 0)
 442                 return -errno;
 443
 444         return bpf_netlink_recv(sock, nl_pid, seq, __dump_qdisc_nlmsg,
 445                                 dump_qdisc_nlmsg, cookie);
 446 }
 447
 448 static int __dump_filter_nlmsg(struct nlmsghdr *nlh,
 449                                libbpf_dump_nlmsg_t dump_filter_nlmsg,
 450                                void *cookie)
 451 {
 452         struct nlattr *tb[TCA_MAX + 1], *attr;
 453         struct tcmsg *t = NLMSG_DATA(nlh);
 454         int len;
 455
 456         len = nlh->nlmsg_len - NLMSG_LENGTH(sizeof(*t));
 457         attr = (struct nlattr *) ((void *) t + NLMSG_ALIGN(sizeof(*t)));
 458         if (libbpf_nla_parse(tb, TCA_MAX, attr, len, NULL) != 0)
 459                 return -LIBBPF_ERRNO__NLPARSE;
 460
 461         return dump_filter_nlmsg(cookie, t, tb);
 462 }
 463
 464 int libbpf_nl_get_filter(int sock, unsigned int nl_pid, int ifindex, int handle,
 465                          libbpf_dump_nlmsg_t dump_filter_nlmsg, void *cookie)
 466 {
 467         struct {
 468                 struct nlmsghdr nlh;
 469                 struct tcmsg t;
 470         } req = {
 471                 .nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct tcmsg)),
 472                 .nlh.nlmsg_type = RTM_GETTFILTER,
 473                 .nlh.nlmsg_flags = NLM_F_DUMP | NLM_F_REQUEST,
 474                 .t.tcm_family = AF_UNSPEC,
 475                 .t.tcm_ifindex = ifindex,
 476                 .t.tcm_parent = handle,
 477         };
 478         int seq = time(NULL);
 479
 480         req.nlh.nlmsg_seq = seq;
 481         if (send(sock, &req, req.nlh.nlmsg_len, 0) < 0)
 482                 return -errno;
 483
 484         return bpf_netlink_recv(sock, nl_pid, seq, __dump_filter_nlmsg,
 485                                 dump_filter_nlmsg, cookie);
 486 }