linux/tools/net/ynl/tests/netdev.c

// SPDX-License-Identifier: GPL-2.0
#include <stdio.h>
#include <string.h>

#include <ynl.h>

#include <net/if.h>

#include <kselftest_harness.h>

#include "netdev-user.h"
#include "rt-link-user.h"

static void netdev_print_device(struct __test_metadata *_metadata,
				struct netdev_dev_get_rsp *d, unsigned int op)
{
	char ifname[IF_NAMESIZE];
	const char *name;

	EXPECT_TRUE((bool)d->_present.ifindex);
	if (!d->_present.ifindex)
		return;

	name = if_indextoname(d->ifindex, ifname);
	EXPECT_TRUE((bool)name);
	if (name)
		ksft_print_msg("%8s[%d]\t", name, d->ifindex);
	else
		ksft_print_msg("[%d]\t", d->ifindex);

	EXPECT_TRUE((bool)d->_present.xdp_features);
	if (!d->_present.xdp_features)
		return;

	printf("xdp-features (%llx):", d->xdp_features);
	for (int i = 0; d->xdp_features >= 1U << i; i++) {
		if (d->xdp_features & (1U << i))
			printf(" %s", netdev_xdp_act_str(1 << i));
	}

	printf(" xdp-rx-metadata-features (%llx):",
	       d->xdp_rx_metadata_features);
	for (int i = 0; d->xdp_rx_metadata_features >= 1U << i; i++) {
		if (d->xdp_rx_metadata_features & (1U << i))
			printf(" %s",
			       netdev_xdp_rx_metadata_str(1 << i));
	}

	printf(" xsk-features (%llx):", d->xsk_features);
	for (int i = 0; d->xsk_features >= 1U << i; i++) {
		if (d->xsk_features & (1U << i))
			printf(" %s", netdev_xsk_flags_str(1 << i));
	}

	printf(" xdp-zc-max-segs=%u", d->xdp_zc_max_segs);

	name = netdev_op_str(op);
	if (name)
		printf(" (ntf: %s)", name);
	printf("\n");
}

static int veth_create(struct ynl_sock *ys_link)
{
	struct rt_link_getlink_ntf *ntf_gl;
	struct rt_link_newlink_req *req;
	struct ynl_ntf_base_type *ntf;
	int ret;

	req = rt_link_newlink_req_alloc();
	if (!req)
		return -1;

	rt_link_newlink_req_set_nlflags(req, NLM_F_CREATE | NLM_F_ECHO);
	rt_link_newlink_req_set_linkinfo_kind(req, "veth");

	ret = rt_link_newlink(ys_link, req);
	rt_link_newlink_req_free(req);
	if (ret)
		return -1;

	if (!ynl_has_ntf(ys_link))
		return 0;

	ntf = ynl_ntf_dequeue(ys_link);
	if (!ntf || ntf->cmd != RTM_NEWLINK) {
		ynl_ntf_free(ntf);
		return 0;
	}
	ntf_gl = (void *)ntf;
	ret = ntf_gl->obj._hdr.ifi_index;
	ynl_ntf_free(ntf);

	return ret;
}

static void veth_delete(struct __test_metadata *_metadata,
			struct ynl_sock *ys_link, int ifindex)
{
	struct rt_link_dellink_req *req;

	req = rt_link_dellink_req_alloc();
	ASSERT_NE(NULL, req);

	req->_hdr.ifi_index = ifindex;
	EXPECT_EQ(0, rt_link_dellink(ys_link, req));
	rt_link_dellink_req_free(req);
}

FIXTURE(netdev)
{
	struct ynl_sock *ys;
	struct ynl_sock *ys_link;
};

FIXTURE_SETUP(netdev)
{
	struct ynl_error yerr;

	self->ys = ynl_sock_create(&ynl_netdev_family, &yerr);
	ASSERT_NE(NULL, self->ys) {
		TH_LOG("Failed to create YNL netdev socket: %s", yerr.msg);
	}
}

FIXTURE_TEARDOWN(netdev)
{
	if (self->ys_link)
		ynl_sock_destroy(self->ys_link);
	ynl_sock_destroy(self->ys);
}

TEST_F(netdev, dump)
{
	struct netdev_dev_get_list *devs;

	devs = netdev_dev_get_dump(self->ys);
	ASSERT_NE(NULL, devs) {
		TH_LOG("dump failed: %s", self->ys->err.msg);
	}

	if (ynl_dump_empty(devs)) {
		netdev_dev_get_list_free(devs);
		SKIP(return, "no entries in dump");
	}

	ynl_dump_foreach(devs, d)
		netdev_print_device(_metadata, d, 0);

	netdev_dev_get_list_free(devs);
}

TEST_F(netdev, get)
{
	struct netdev_dev_get_list *devs;
	struct netdev_dev_get_req *req;
	struct netdev_dev_get_rsp *dev;
	int ifindex = 0;

	devs = netdev_dev_get_dump(self->ys);
	ASSERT_NE(NULL, devs) {
		TH_LOG("dump failed: %s", self->ys->err.msg);
	}

	ynl_dump_foreach(devs, d) {
		if (d->_present.ifindex) {
			ifindex = d->ifindex;
			break;
		}
	}
	netdev_dev_get_list_free(devs);

	if (!ifindex)
		SKIP(return, "no device to query");

	req = netdev_dev_get_req_alloc();
	ASSERT_NE(NULL, req);
	netdev_dev_get_req_set_ifindex(req, ifindex);

	dev = netdev_dev_get(self->ys, req);
	netdev_dev_get_req_free(req);
	ASSERT_NE(NULL, dev) {
		TH_LOG("dev_get failed: %s", self->ys->err.msg);
	}

	netdev_print_device(_metadata, dev, 0);
	netdev_dev_get_rsp_free(dev);
}

TEST_F(netdev, ntf_check)
{
	struct ynl_ntf_base_type *ntf;
	int veth_ifindex;
	bool received;
	int ret;

	ret = ynl_subscribe(self->ys, "mgmt");
	ASSERT_EQ(0, ret) {
		TH_LOG("subscribe failed: %s", self->ys->err.msg);
	}

	self->ys_link = ynl_sock_create(&ynl_rt_link_family, NULL);
	ASSERT_NE(NULL, self->ys_link)
		TH_LOG("failed to create rt-link socket");

	veth_ifindex = veth_create(self->ys_link);
	ASSERT_GT(veth_ifindex, 0)
		TH_LOG("failed to create veth");

	ynl_ntf_check(self->ys);

	ntf = ynl_ntf_dequeue(self->ys);
	received = ntf;
	if (ntf) {
		netdev_print_device(_metadata,
				    (struct netdev_dev_get_rsp *)&ntf->data,
				    ntf->cmd);
		ynl_ntf_free(ntf);
	}

	/* Drain any remaining notifications */
	while ((ntf = ynl_ntf_dequeue(self->ys)))
		ynl_ntf_free(ntf);

	veth_delete(_metadata, self->ys_link, veth_ifindex);

	ASSERT_TRUE(received)
		TH_LOG("no notification received");
}

TEST_HARNESS_MAIN