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 <arpa/inet.h>
  8#include <linux/bpf.h>
  9#include <linux/if_ether.h>
 10#include <linux/pkt_cls.h>
 11#include <linux/rtnetlink.h>
 12#include <linux/netdev.h>
 13#include <sys/socket.h>
 14#include <errno.h>
 15#include <time.h>
 16
 17#include "bpf.h"
 18#include "libbpf.h"
 19#include "libbpf_internal.h"
 20#include "nlattr.h"
 21
 22#ifndef SOL_NETLINK
 23#define SOL_NETLINK 270
 24#endif
 25
 26typedef int (*libbpf_dump_nlmsg_t)(void *cookie, void *msg, struct nlattr **tb);
 27
 28typedef int (*__dump_nlmsg_t)(struct nlmsghdr *nlmsg, libbpf_dump_nlmsg_t,
 29			      void *cookie);
 30
 31struct xdp_link_info {
 32	__u32 prog_id;
 33	__u32 drv_prog_id;
 34	__u32 hw_prog_id;
 35	__u32 skb_prog_id;
 36	__u8 attach_mode;
 37};
 38
 39struct xdp_id_md {
 40	int ifindex;
 41	__u32 flags;
 42	struct xdp_link_info info;
 43	__u64 feature_flags;
 44};
 45
 46struct xdp_features_md {
 47	int ifindex;
 48	__u32 xdp_zc_max_segs;
 49	__u64 flags;
 50};
 51
 52static int libbpf_netlink_open(__u32 *nl_pid, int proto)
 53{
 54	struct sockaddr_nl sa;
 55	socklen_t addrlen;
 56	int one = 1, ret;
 57	int sock;
 58
 59	memset(&sa, 0, sizeof(sa));
 60	sa.nl_family = AF_NETLINK;
 61
 62	sock = socket(AF_NETLINK, SOCK_RAW | SOCK_CLOEXEC, proto);
 63	if (sock < 0)
 64		return -errno;
 65
 66	if (setsockopt(sock, SOL_NETLINK, NETLINK_EXT_ACK,
 67		       &one, sizeof(one)) < 0) {
 68		pr_warn("Netlink error reporting not supported\n");
 69	}
 70
 71	if (bind(sock, (struct sockaddr *)&sa, sizeof(sa)) < 0) {
 72		ret = -errno;
 73		goto cleanup;
 74	}
 75
 76	addrlen = sizeof(sa);
 77	if (getsockname(sock, (struct sockaddr *)&sa, &addrlen) < 0) {
 78		ret = -errno;
 79		goto cleanup;
 80	}
 81
 82	if (addrlen != sizeof(sa)) {
 83		ret = -LIBBPF_ERRNO__INTERNAL;
 84		goto cleanup;
 85	}
 86
 87	*nl_pid = sa.nl_pid;
 88	return sock;
 89
 90cleanup:
 91	close(sock);
 92	return ret;
 93}
 94
 95static void libbpf_netlink_close(int sock)
 96{
 97	close(sock);
 98}
 99
100enum {
101	NL_CONT,
102	NL_NEXT,
103	NL_DONE,
104};
105
106static int netlink_recvmsg(int sock, struct msghdr *mhdr, int flags)
107{
108	int len;
109
110	do {
111		len = recvmsg(sock, mhdr, flags);
112	} while (len < 0 && (errno == EINTR || errno == EAGAIN));
113
114	if (len < 0)
115		return -errno;
116	return len;
117}
118
119static int alloc_iov(struct iovec *iov, int len)
120{
121	void *nbuf;
122
123	nbuf = realloc(iov->iov_base, len);
124	if (!nbuf)
125		return -ENOMEM;
126
127	iov->iov_base = nbuf;
128	iov->iov_len = len;
129	return 0;
130}
131
132static int libbpf_netlink_recv(int sock, __u32 nl_pid, int seq,
133			       __dump_nlmsg_t _fn, libbpf_dump_nlmsg_t fn,
134			       void *cookie)
135{
136	struct iovec iov = {};
137	struct msghdr mhdr = {
138		.msg_iov = &iov,
139		.msg_iovlen = 1,
140	};
141	bool multipart = true;
142	struct nlmsgerr *err;
143	struct nlmsghdr *nh;
144	int len, ret;
145
146	ret = alloc_iov(&iov, 8192);
147	if (ret)
148		goto done;
149
150	while (multipart) {
151start:
152		multipart = false;
153		len = netlink_recvmsg(sock, &mhdr, MSG_PEEK | MSG_TRUNC);
154		if (len < 0) {
155			ret = len;
156			goto done;
157		}
158
159		if (len > iov.iov_len) {
160			ret = alloc_iov(&iov, len);
161			if (ret)
162				goto done;
163		}
164
165		len = netlink_recvmsg(sock, &mhdr, 0);
166		if (len < 0) {
167			ret = len;
168			goto done;
169		}
170
171		if (len == 0)
172			break;
173
174		for (nh = (struct nlmsghdr *)iov.iov_base; NLMSG_OK(nh, len);
175		     nh = NLMSG_NEXT(nh, len)) {
176			if (nh->nlmsg_pid != nl_pid) {
177				ret = -LIBBPF_ERRNO__WRNGPID;
178				goto done;
179			}
180			if (nh->nlmsg_seq != seq) {
181				ret = -LIBBPF_ERRNO__INVSEQ;
182				goto done;
183			}
184			if (nh->nlmsg_flags & NLM_F_MULTI)
185				multipart = true;
186			switch (nh->nlmsg_type) {
187			case NLMSG_ERROR:
188				err = (struct nlmsgerr *)NLMSG_DATA(nh);
189				if (!err->error)
190					continue;
191				ret = err->error;
192				libbpf_nla_dump_errormsg(nh);
193				goto done;
194			case NLMSG_DONE:
195				ret = 0;
196				goto done;
197			default:
198				break;
199			}
200			if (_fn) {
201				ret = _fn(nh, fn, cookie);
202				switch (ret) {
203				case NL_CONT:
204					break;
205				case NL_NEXT:
206					goto start;
207				case NL_DONE:
208					ret = 0;
209					goto done;
210				default:
211					goto done;
212				}
213			}
214		}
215		if (len)
216			pr_warn("Invalid message or trailing data in Netlink response: %d bytes left\n", len);
217	}
218	ret = 0;
219done:
220	free(iov.iov_base);
221	return ret;
222}
223
224static int libbpf_netlink_send_recv(struct libbpf_nla_req *req,
225				    int proto, __dump_nlmsg_t parse_msg,
226				    libbpf_dump_nlmsg_t parse_attr,
227				    void *cookie)
228{
229	__u32 nl_pid = 0;
230	int sock, ret;
231
232	sock = libbpf_netlink_open(&nl_pid, proto);
233	if (sock < 0)
234		return sock;
235
236	req->nh.nlmsg_pid = 0;
237	req->nh.nlmsg_seq = time(NULL);
238
239	if (send(sock, req, req->nh.nlmsg_len, 0) < 0) {
240		ret = -errno;
241		goto out;
242	}
243
244	ret = libbpf_netlink_recv(sock, nl_pid, req->nh.nlmsg_seq,
245				  parse_msg, parse_attr, cookie);
246out:
247	libbpf_netlink_close(sock);
248	return ret;
249}
250
251static int parse_genl_family_id(struct nlmsghdr *nh, libbpf_dump_nlmsg_t fn,
252				void *cookie)
253{
254	struct genlmsghdr *gnl = NLMSG_DATA(nh);
255	struct nlattr *na = (struct nlattr *)((void *)gnl + GENL_HDRLEN);
256	struct nlattr *tb[CTRL_ATTR_FAMILY_ID + 1];
257	__u16 *id = cookie;
258
259	libbpf_nla_parse(tb, CTRL_ATTR_FAMILY_ID, na,
260			 NLMSG_PAYLOAD(nh, sizeof(*gnl)), NULL);
261	if (!tb[CTRL_ATTR_FAMILY_ID])
262		return NL_CONT;
263
264	*id = libbpf_nla_getattr_u16(tb[CTRL_ATTR_FAMILY_ID]);
265	return NL_DONE;
266}
267
268static int libbpf_netlink_resolve_genl_family_id(const char *name,
269						 __u16 len, __u16 *id)
270{
271	struct libbpf_nla_req req = {
272		.nh.nlmsg_len	= NLMSG_LENGTH(GENL_HDRLEN),
273		.nh.nlmsg_type	= GENL_ID_CTRL,
274		.nh.nlmsg_flags	= NLM_F_REQUEST,
275		.gnl.cmd	= CTRL_CMD_GETFAMILY,
276		.gnl.version	= 2,
277	};
278	int err;
279
280	err = nlattr_add(&req, CTRL_ATTR_FAMILY_NAME, name, len);
281	if (err < 0)
282		return err;
283
284	return libbpf_netlink_send_recv(&req, NETLINK_GENERIC,
285					parse_genl_family_id, NULL, id);
286}
287
288static int __bpf_set_link_xdp_fd_replace(int ifindex, int fd, int old_fd,
289					 __u32 flags)
290{
291	struct nlattr *nla;
292	int ret;
293	struct libbpf_nla_req req;
294
295	memset(&req, 0, sizeof(req));
296	req.nh.nlmsg_len      = NLMSG_LENGTH(sizeof(struct ifinfomsg));
297	req.nh.nlmsg_flags    = NLM_F_REQUEST | NLM_F_ACK;
298	req.nh.nlmsg_type     = RTM_SETLINK;
299	req.ifinfo.ifi_family = AF_UNSPEC;
300	req.ifinfo.ifi_index  = ifindex;
301
302	nla = nlattr_begin_nested(&req, IFLA_XDP);
303	if (!nla)
304		return -EMSGSIZE;
305	ret = nlattr_add(&req, IFLA_XDP_FD, &fd, sizeof(fd));
306	if (ret < 0)
307		return ret;
308	if (flags) {
309		ret = nlattr_add(&req, IFLA_XDP_FLAGS, &flags, sizeof(flags));
310		if (ret < 0)
311			return ret;
312	}
313	if (flags & XDP_FLAGS_REPLACE) {
314		ret = nlattr_add(&req, IFLA_XDP_EXPECTED_FD, &old_fd,
315				 sizeof(old_fd));
316		if (ret < 0)
317			return ret;
318	}
319	nlattr_end_nested(&req, nla);
320
321	return libbpf_netlink_send_recv(&req, NETLINK_ROUTE, NULL, NULL, NULL);
322}
323
324int bpf_xdp_attach(int ifindex, int prog_fd, __u32 flags, const struct bpf_xdp_attach_opts *opts)
325{
326	int old_prog_fd, err;
327
328	if (!OPTS_VALID(opts, bpf_xdp_attach_opts))
329		return libbpf_err(-EINVAL);
330
331	old_prog_fd = OPTS_GET(opts, old_prog_fd, 0);
332	if (old_prog_fd)
333		flags |= XDP_FLAGS_REPLACE;
334	else
335		old_prog_fd = -1;
336
337	err = __bpf_set_link_xdp_fd_replace(ifindex, prog_fd, old_prog_fd, flags);
338	return libbpf_err(err);
339}
340
341int bpf_xdp_detach(int ifindex, __u32 flags, const struct bpf_xdp_attach_opts *opts)
342{
343	return bpf_xdp_attach(ifindex, -1, flags, opts);
344}
345
346static int __dump_link_nlmsg(struct nlmsghdr *nlh,
347			     libbpf_dump_nlmsg_t dump_link_nlmsg, void *cookie)
348{
349	struct nlattr *tb[IFLA_MAX + 1], *attr;
350	struct ifinfomsg *ifi = NLMSG_DATA(nlh);
351	int len;
352
353	len = nlh->nlmsg_len - NLMSG_LENGTH(sizeof(*ifi));
354	attr = (struct nlattr *) ((void *) ifi + NLMSG_ALIGN(sizeof(*ifi)));
355
356	if (libbpf_nla_parse(tb, IFLA_MAX, attr, len, NULL) != 0)
357		return -LIBBPF_ERRNO__NLPARSE;
358
359	return dump_link_nlmsg(cookie, ifi, tb);
360}
361
362static int get_xdp_info(void *cookie, void *msg, struct nlattr **tb)
363{
364	struct nlattr *xdp_tb[IFLA_XDP_MAX + 1];
365	struct xdp_id_md *xdp_id = cookie;
366	struct ifinfomsg *ifinfo = msg;
367	int ret;
368
369	if (xdp_id->ifindex && xdp_id->ifindex != ifinfo->ifi_index)
370		return 0;
371
372	if (!tb[IFLA_XDP])
373		return 0;
374
375	ret = libbpf_nla_parse_nested(xdp_tb, IFLA_XDP_MAX, tb[IFLA_XDP], NULL);
376	if (ret)
377		return ret;
378
379	if (!xdp_tb[IFLA_XDP_ATTACHED])
380		return 0;
381
382	xdp_id->info.attach_mode = libbpf_nla_getattr_u8(
383		xdp_tb[IFLA_XDP_ATTACHED]);
384
385	if (xdp_id->info.attach_mode == XDP_ATTACHED_NONE)
386		return 0;
387
388	if (xdp_tb[IFLA_XDP_PROG_ID])
389		xdp_id->info.prog_id = libbpf_nla_getattr_u32(
390			xdp_tb[IFLA_XDP_PROG_ID]);
391
392	if (xdp_tb[IFLA_XDP_SKB_PROG_ID])
393		xdp_id->info.skb_prog_id = libbpf_nla_getattr_u32(
394			xdp_tb[IFLA_XDP_SKB_PROG_ID]);
395
396	if (xdp_tb[IFLA_XDP_DRV_PROG_ID])
397		xdp_id->info.drv_prog_id = libbpf_nla_getattr_u32(
398			xdp_tb[IFLA_XDP_DRV_PROG_ID]);
399
400	if (xdp_tb[IFLA_XDP_HW_PROG_ID])
401		xdp_id->info.hw_prog_id = libbpf_nla_getattr_u32(
402			xdp_tb[IFLA_XDP_HW_PROG_ID]);
403
404	return 0;
405}
406
407static int parse_xdp_features(struct nlmsghdr *nh, libbpf_dump_nlmsg_t fn,
408			      void *cookie)
409{
410	struct genlmsghdr *gnl = NLMSG_DATA(nh);
411	struct nlattr *na = (struct nlattr *)((void *)gnl + GENL_HDRLEN);
412	struct nlattr *tb[NETDEV_CMD_MAX + 1];
413	struct xdp_features_md *md = cookie;
414	__u32 ifindex;
415
416	libbpf_nla_parse(tb, NETDEV_CMD_MAX, na,
417			 NLMSG_PAYLOAD(nh, sizeof(*gnl)), NULL);
418
419	if (!tb[NETDEV_A_DEV_IFINDEX] || !tb[NETDEV_A_DEV_XDP_FEATURES])
420		return NL_CONT;
421
422	ifindex = libbpf_nla_getattr_u32(tb[NETDEV_A_DEV_IFINDEX]);
423	if (ifindex != md->ifindex)
424		return NL_CONT;
425
426	md->flags = libbpf_nla_getattr_u64(tb[NETDEV_A_DEV_XDP_FEATURES]);
427	if (tb[NETDEV_A_DEV_XDP_ZC_MAX_SEGS])
428		md->xdp_zc_max_segs =
429			libbpf_nla_getattr_u32(tb[NETDEV_A_DEV_XDP_ZC_MAX_SEGS]);
430	return NL_DONE;
431}
432
433int bpf_xdp_query(int ifindex, int xdp_flags, struct bpf_xdp_query_opts *opts)
434{
435	struct libbpf_nla_req req = {
436		.nh.nlmsg_len      = NLMSG_LENGTH(sizeof(struct ifinfomsg)),
437		.nh.nlmsg_type     = RTM_GETLINK,
438		.nh.nlmsg_flags    = NLM_F_DUMP | NLM_F_REQUEST,
439		.ifinfo.ifi_family = AF_PACKET,
440	};
441	struct xdp_id_md xdp_id = {};
442	struct xdp_features_md md = {
443		.ifindex = ifindex,
444	};
445	__u16 id;
446	int err;
447
448	if (!OPTS_VALID(opts, bpf_xdp_query_opts))
449		return libbpf_err(-EINVAL);
450
451	if (xdp_flags & ~XDP_FLAGS_MASK)
452		return libbpf_err(-EINVAL);
453
454	/* Check whether the single {HW,DRV,SKB} mode is set */
455	xdp_flags &= XDP_FLAGS_SKB_MODE | XDP_FLAGS_DRV_MODE | XDP_FLAGS_HW_MODE;
456	if (xdp_flags & (xdp_flags - 1))
457		return libbpf_err(-EINVAL);
458
459	xdp_id.ifindex = ifindex;
460	xdp_id.flags = xdp_flags;
461
462	err = libbpf_netlink_send_recv(&req, NETLINK_ROUTE, __dump_link_nlmsg,
463				       get_xdp_info, &xdp_id);
464	if (err)
465		return libbpf_err(err);
466
467	OPTS_SET(opts, prog_id, xdp_id.info.prog_id);
468	OPTS_SET(opts, drv_prog_id, xdp_id.info.drv_prog_id);
469	OPTS_SET(opts, hw_prog_id, xdp_id.info.hw_prog_id);
470	OPTS_SET(opts, skb_prog_id, xdp_id.info.skb_prog_id);
471	OPTS_SET(opts, attach_mode, xdp_id.info.attach_mode);
472
473	if (!OPTS_HAS(opts, feature_flags))
474		return 0;
475
476	err = libbpf_netlink_resolve_genl_family_id("netdev", sizeof("netdev"), &id);
477	if (err < 0) {
478		if (err == -ENOENT) {
479			opts->feature_flags = 0;
480			goto skip_feature_flags;
481		}
482		return libbpf_err(err);
483	}
484
485	memset(&req, 0, sizeof(req));
486	req.nh.nlmsg_len = NLMSG_LENGTH(GENL_HDRLEN);
487	req.nh.nlmsg_flags = NLM_F_REQUEST;
488	req.nh.nlmsg_type = id;
489	req.gnl.cmd = NETDEV_CMD_DEV_GET;
490	req.gnl.version = 2;
491
492	err = nlattr_add(&req, NETDEV_A_DEV_IFINDEX, &ifindex, sizeof(ifindex));
493	if (err < 0)
494		return libbpf_err(err);
495
496	err = libbpf_netlink_send_recv(&req, NETLINK_GENERIC,
497				       parse_xdp_features, NULL, &md);
498	if (err)
499		return libbpf_err(err);
500
501	OPTS_SET(opts, feature_flags, md.flags);
502	OPTS_SET(opts, xdp_zc_max_segs, md.xdp_zc_max_segs);
503
504skip_feature_flags:
505	return 0;
506}
507
508int bpf_xdp_query_id(int ifindex, int flags, __u32 *prog_id)
509{
510	LIBBPF_OPTS(bpf_xdp_query_opts, opts);
511	int ret;
512
513	ret = bpf_xdp_query(ifindex, flags, &opts);
514	if (ret)
515		return libbpf_err(ret);
516
517	flags &= XDP_FLAGS_MODES;
518
519	if (opts.attach_mode != XDP_ATTACHED_MULTI && !flags)
520		*prog_id = opts.prog_id;
521	else if (flags & XDP_FLAGS_DRV_MODE)
522		*prog_id = opts.drv_prog_id;
523	else if (flags & XDP_FLAGS_HW_MODE)
524		*prog_id = opts.hw_prog_id;
525	else if (flags & XDP_FLAGS_SKB_MODE)
526		*prog_id = opts.skb_prog_id;
527	else
528		*prog_id = 0;
529
530	return 0;
531}
532
533
534typedef int (*qdisc_config_t)(struct libbpf_nla_req *req, const struct bpf_tc_hook *hook);
535
536static int clsact_config(struct libbpf_nla_req *req, const struct bpf_tc_hook *hook)
537{
538	req->tc.tcm_parent = TC_H_CLSACT;
539	req->tc.tcm_handle = TC_H_MAKE(TC_H_CLSACT, 0);
540
541	return nlattr_add(req, TCA_KIND, "clsact", sizeof("clsact"));
542}
543
544static int qdisc_config(struct libbpf_nla_req *req, const struct bpf_tc_hook *hook)
545{
546	const char *qdisc = OPTS_GET(hook, qdisc, NULL);
547
548	req->tc.tcm_parent = OPTS_GET(hook, parent, TC_H_ROOT);
549	req->tc.tcm_handle = OPTS_GET(hook, handle, 0);
550
551	return nlattr_add(req, TCA_KIND, qdisc, strlen(qdisc) + 1);
552}
553
554static int attach_point_to_config(struct bpf_tc_hook *hook,
555				  qdisc_config_t *config)
556{
557	switch (OPTS_GET(hook, attach_point, 0)) {
558	case BPF_TC_INGRESS:
559	case BPF_TC_EGRESS:
560	case BPF_TC_INGRESS | BPF_TC_EGRESS:
561		if (OPTS_GET(hook, parent, 0))
562			return -EINVAL;
563		*config = &clsact_config;
564		return 0;
565	case BPF_TC_CUSTOM:
566		return -EOPNOTSUPP;
567	case BPF_TC_QDISC:
568		*config = &qdisc_config;
569		return 0;
570	default:
571		return -EINVAL;
572	}
573}
574
575static int tc_get_tcm_parent(enum bpf_tc_attach_point attach_point,
576			     __u32 *parent)
577{
578	switch (attach_point) {
579	case BPF_TC_INGRESS:
580	case BPF_TC_EGRESS:
581		if (*parent)
582			return -EINVAL;
583		*parent = TC_H_MAKE(TC_H_CLSACT,
584				    attach_point == BPF_TC_INGRESS ?
585				    TC_H_MIN_INGRESS : TC_H_MIN_EGRESS);
586		break;
587	case BPF_TC_CUSTOM:
588		if (!*parent)
589			return -EINVAL;
590		break;
591	default:
592		return -EINVAL;
593	}
594	return 0;
595}
596
597static int tc_qdisc_modify(struct bpf_tc_hook *hook, int cmd, int flags)
598{
599	qdisc_config_t config;
600	int ret;
601	struct libbpf_nla_req req;
602
603	ret = attach_point_to_config(hook, &config);
604	if (ret < 0)
605		return ret;
606
607	memset(&req, 0, sizeof(req));
608	req.nh.nlmsg_len   = NLMSG_LENGTH(sizeof(struct tcmsg));
609	req.nh.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK | flags;
610	req.nh.nlmsg_type  = cmd;
611	req.tc.tcm_family  = AF_UNSPEC;
612	req.tc.tcm_ifindex = OPTS_GET(hook, ifindex, 0);
613
614	ret = config(&req, hook);
615	if (ret < 0)
616		return ret;
617
618	return libbpf_netlink_send_recv(&req, NETLINK_ROUTE, NULL, NULL, NULL);
619}
620
621static int tc_qdisc_create_excl(struct bpf_tc_hook *hook)
622{
623	return tc_qdisc_modify(hook, RTM_NEWQDISC, NLM_F_CREATE | NLM_F_EXCL);
624}
625
626static int tc_qdisc_delete(struct bpf_tc_hook *hook)
627{
628	return tc_qdisc_modify(hook, RTM_DELQDISC, 0);
629}
630
631int bpf_tc_hook_create(struct bpf_tc_hook *hook)
632{
633	int ret;
634
635	if (!hook || !OPTS_VALID(hook, bpf_tc_hook) ||
636	    OPTS_GET(hook, ifindex, 0) <= 0)
637		return libbpf_err(-EINVAL);
638
639	ret = tc_qdisc_create_excl(hook);
640	return libbpf_err(ret);
641}
642
643static int __bpf_tc_detach(const struct bpf_tc_hook *hook,
644			   const struct bpf_tc_opts *opts,
645			   const bool flush);
646
647int bpf_tc_hook_destroy(struct bpf_tc_hook *hook)
648{
649	if (!hook || !OPTS_VALID(hook, bpf_tc_hook) ||
650	    OPTS_GET(hook, ifindex, 0) <= 0)
651		return libbpf_err(-EINVAL);
652
653	switch (OPTS_GET(hook, attach_point, 0)) {
654	case BPF_TC_INGRESS:
655	case BPF_TC_EGRESS:
656		return libbpf_err(__bpf_tc_detach(hook, NULL, true));
657	case BPF_TC_QDISC:
658	case BPF_TC_INGRESS | BPF_TC_EGRESS:
659		return libbpf_err(tc_qdisc_delete(hook));
660	case BPF_TC_CUSTOM:
661		return libbpf_err(-EOPNOTSUPP);
662	default:
663		return libbpf_err(-EINVAL);
664	}
665}
666
667struct bpf_cb_ctx {
668	struct bpf_tc_opts *opts;
669	bool processed;
670};
671
672static int __get_tc_info(void *cookie, struct tcmsg *tc, struct nlattr **tb,
673			 bool unicast)
674{
675	struct nlattr *tbb[TCA_BPF_MAX + 1];
676	struct bpf_cb_ctx *info = cookie;
677
678	if (!info || !info->opts)
679		return -EINVAL;
680	if (unicast && info->processed)
681		return -EINVAL;
682	if (!tb[TCA_OPTIONS])
683		return NL_CONT;
684
685	libbpf_nla_parse_nested(tbb, TCA_BPF_MAX, tb[TCA_OPTIONS], NULL);
686	if (!tbb[TCA_BPF_ID])
687		return -EINVAL;
688
689	OPTS_SET(info->opts, prog_id, libbpf_nla_getattr_u32(tbb[TCA_BPF_ID]));
690	OPTS_SET(info->opts, handle, tc->tcm_handle);
691	OPTS_SET(info->opts, priority, TC_H_MAJ(tc->tcm_info) >> 16);
692
693	info->processed = true;
694	return unicast ? NL_NEXT : NL_DONE;
695}
696
697static int get_tc_info(struct nlmsghdr *nh, libbpf_dump_nlmsg_t fn,
698		       void *cookie)
699{
700	struct tcmsg *tc = NLMSG_DATA(nh);
701	struct nlattr *tb[TCA_MAX + 1];
702
703	libbpf_nla_parse(tb, TCA_MAX,
704			 (struct nlattr *)((void *)tc + NLMSG_ALIGN(sizeof(*tc))),
705			 NLMSG_PAYLOAD(nh, sizeof(*tc)), NULL);
706	if (!tb[TCA_KIND])
707		return NL_CONT;
708	return __get_tc_info(cookie, tc, tb, nh->nlmsg_flags & NLM_F_ECHO);
709}
710
711static int tc_add_fd_and_name(struct libbpf_nla_req *req, int fd)
712{
713	struct bpf_prog_info info;
714	__u32 info_len = sizeof(info);
715	char name[256];
716	int len, ret;
717
718	memset(&info, 0, info_len);
719	ret = bpf_prog_get_info_by_fd(fd, &info, &info_len);
720	if (ret < 0)
721		return ret;
722
723	ret = nlattr_add(req, TCA_BPF_FD, &fd, sizeof(fd));
724	if (ret < 0)
725		return ret;
726	len = snprintf(name, sizeof(name), "%s:[%u]", info.name, info.id);
727	if (len < 0)
728		return -errno;
729	if (len >= sizeof(name))
730		return -ENAMETOOLONG;
731	return nlattr_add(req, TCA_BPF_NAME, name, len + 1);
732}
733
734int bpf_tc_attach(const struct bpf_tc_hook *hook, struct bpf_tc_opts *opts)
735{
736	__u32 protocol, bpf_flags, handle, priority, parent, prog_id, flags;
737	int ret, ifindex, attach_point, prog_fd;
738	struct bpf_cb_ctx info = {};
739	struct libbpf_nla_req req;
740	struct nlattr *nla;
741
742	if (!hook || !opts ||
743	    !OPTS_VALID(hook, bpf_tc_hook) ||
744	    !OPTS_VALID(opts, bpf_tc_opts))
745		return libbpf_err(-EINVAL);
746
747	ifindex      = OPTS_GET(hook, ifindex, 0);
748	parent       = OPTS_GET(hook, parent, 0);
749	attach_point = OPTS_GET(hook, attach_point, 0);
750
751	handle       = OPTS_GET(opts, handle, 0);
752	priority     = OPTS_GET(opts, priority, 0);
753	prog_fd      = OPTS_GET(opts, prog_fd, 0);
754	prog_id      = OPTS_GET(opts, prog_id, 0);
755	flags        = OPTS_GET(opts, flags, 0);
756
757	if (ifindex <= 0 || !prog_fd || prog_id)
758		return libbpf_err(-EINVAL);
759	if (priority > UINT16_MAX)
760		return libbpf_err(-EINVAL);
761	if (flags & ~BPF_TC_F_REPLACE)
762		return libbpf_err(-EINVAL);
763
764	flags = (flags & BPF_TC_F_REPLACE) ? NLM_F_REPLACE : NLM_F_EXCL;
765	protocol = ETH_P_ALL;
766
767	memset(&req, 0, sizeof(req));
768	req.nh.nlmsg_len   = NLMSG_LENGTH(sizeof(struct tcmsg));
769	req.nh.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK | NLM_F_CREATE |
770			     NLM_F_ECHO | flags;
771	req.nh.nlmsg_type  = RTM_NEWTFILTER;
772	req.tc.tcm_family  = AF_UNSPEC;
773	req.tc.tcm_ifindex = ifindex;
774	req.tc.tcm_handle  = handle;
775	req.tc.tcm_info    = TC_H_MAKE(priority << 16, htons(protocol));
776
777	ret = tc_get_tcm_parent(attach_point, &parent);
778	if (ret < 0)
779		return libbpf_err(ret);
780	req.tc.tcm_parent = parent;
781
782	ret = nlattr_add(&req, TCA_KIND, "bpf", sizeof("bpf"));
783	if (ret < 0)
784		return libbpf_err(ret);
785	nla = nlattr_begin_nested(&req, TCA_OPTIONS);
786	if (!nla)
787		return libbpf_err(-EMSGSIZE);
788	ret = tc_add_fd_and_name(&req, prog_fd);
789	if (ret < 0)
790		return libbpf_err(ret);
791	bpf_flags = TCA_BPF_FLAG_ACT_DIRECT;
792	ret = nlattr_add(&req, TCA_BPF_FLAGS, &bpf_flags, sizeof(bpf_flags));
793	if (ret < 0)
794		return libbpf_err(ret);
795	nlattr_end_nested(&req, nla);
796
797	info.opts = opts;
798
799	ret = libbpf_netlink_send_recv(&req, NETLINK_ROUTE, get_tc_info, NULL,
800				       &info);
801	if (ret < 0)
802		return libbpf_err(ret);
803	if (!info.processed)
804		return libbpf_err(-ENOENT);
805	return ret;
806}
807
808static int __bpf_tc_detach(const struct bpf_tc_hook *hook,
809			   const struct bpf_tc_opts *opts,
810			   const bool flush)
811{
812	__u32 protocol = 0, handle, priority, parent, prog_id, flags;
813	int ret, ifindex, attach_point, prog_fd;
814	struct libbpf_nla_req req;
815
816	if (!hook ||
817	    !OPTS_VALID(hook, bpf_tc_hook) ||
818	    !OPTS_VALID(opts, bpf_tc_opts))
819		return -EINVAL;
820
821	ifindex      = OPTS_GET(hook, ifindex, 0);
822	parent       = OPTS_GET(hook, parent, 0);
823	attach_point = OPTS_GET(hook, attach_point, 0);
824
825	handle       = OPTS_GET(opts, handle, 0);
826	priority     = OPTS_GET(opts, priority, 0);
827	prog_fd      = OPTS_GET(opts, prog_fd, 0);
828	prog_id      = OPTS_GET(opts, prog_id, 0);
829	flags        = OPTS_GET(opts, flags, 0);
830
831	if (ifindex <= 0 || flags || prog_fd || prog_id)
832		return -EINVAL;
833	if (priority > UINT16_MAX)
834		return -EINVAL;
835	if (!flush) {
836		if (!handle || !priority)
837			return -EINVAL;
838		protocol = ETH_P_ALL;
839	} else {
840		if (handle || priority)
841			return -EINVAL;
842	}
843
844	memset(&req, 0, sizeof(req));
845	req.nh.nlmsg_len   = NLMSG_LENGTH(sizeof(struct tcmsg));
846	req.nh.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK;
847	req.nh.nlmsg_type  = RTM_DELTFILTER;
848	req.tc.tcm_family  = AF_UNSPEC;
849	req.tc.tcm_ifindex = ifindex;
850	if (!flush) {
851		req.tc.tcm_handle = handle;
852		req.tc.tcm_info   = TC_H_MAKE(priority << 16, htons(protocol));
853	}
854
855	ret = tc_get_tcm_parent(attach_point, &parent);
856	if (ret < 0)
857		return ret;
858	req.tc.tcm_parent = parent;
859
860	if (!flush) {
861		ret = nlattr_add(&req, TCA_KIND, "bpf", sizeof("bpf"));
862		if (ret < 0)
863			return ret;
864	}
865
866	return libbpf_netlink_send_recv(&req, NETLINK_ROUTE, NULL, NULL, NULL);
867}
868
869int bpf_tc_detach(const struct bpf_tc_hook *hook,
870		  const struct bpf_tc_opts *opts)
871{
872	int ret;
873
874	if (!opts)
875		return libbpf_err(-EINVAL);
876
877	ret = __bpf_tc_detach(hook, opts, false);
878	return libbpf_err(ret);
879}
880
881int bpf_tc_query(const struct bpf_tc_hook *hook, struct bpf_tc_opts *opts)
882{
883	__u32 protocol, handle, priority, parent, prog_id, flags;
884	int ret, ifindex, attach_point, prog_fd;
885	struct bpf_cb_ctx info = {};
886	struct libbpf_nla_req req;
887
888	if (!hook || !opts ||
889	    !OPTS_VALID(hook, bpf_tc_hook) ||
890	    !OPTS_VALID(opts, bpf_tc_opts))
891		return libbpf_err(-EINVAL);
892
893	ifindex      = OPTS_GET(hook, ifindex, 0);
894	parent       = OPTS_GET(hook, parent, 0);
895	attach_point = OPTS_GET(hook, attach_point, 0);
896
897	handle       = OPTS_GET(opts, handle, 0);
898	priority     = OPTS_GET(opts, priority, 0);
899	prog_fd      = OPTS_GET(opts, prog_fd, 0);
900	prog_id      = OPTS_GET(opts, prog_id, 0);
901	flags        = OPTS_GET(opts, flags, 0);
902
903	if (ifindex <= 0 || flags || prog_fd || prog_id ||
904	    !handle || !priority)
905		return libbpf_err(-EINVAL);
906	if (priority > UINT16_MAX)
907		return libbpf_err(-EINVAL);
908
909	protocol = ETH_P_ALL;
910
911	memset(&req, 0, sizeof(req));
912	req.nh.nlmsg_len   = NLMSG_LENGTH(sizeof(struct tcmsg));
913	req.nh.nlmsg_flags = NLM_F_REQUEST;
914	req.nh.nlmsg_type  = RTM_GETTFILTER;
915	req.tc.tcm_family  = AF_UNSPEC;
916	req.tc.tcm_ifindex = ifindex;
917	req.tc.tcm_handle  = handle;
918	req.tc.tcm_info    = TC_H_MAKE(priority << 16, htons(protocol));
919
920	ret = tc_get_tcm_parent(attach_point, &parent);
921	if (ret < 0)
922		return libbpf_err(ret);
923	req.tc.tcm_parent = parent;
924
925	ret = nlattr_add(&req, TCA_KIND, "bpf", sizeof("bpf"));
926	if (ret < 0)
927		return libbpf_err(ret);
928
929	info.opts = opts;
930
931	ret = libbpf_netlink_send_recv(&req, NETLINK_ROUTE, get_tc_info, NULL,
932				       &info);
933	if (ret < 0)
934		return libbpf_err(ret);
935	if (!info.processed)
936		return libbpf_err(-ENOENT);
937	return ret;
938}