netlink/pause.c - pub/scm/network/ethtool/ethtool - Git at Google

 /*
  * pause.c - netlink implementation of pause commands
  *
  * Implementation of "ethtool -a <dev>" and "ethtool -A <dev> ..."
  */

 #include <errno.h>
 #include <inttypes.h>
 #include <string.h>
 #include <stdio.h>

 #include "../internal.h"
 #include "../common.h"
 #include "netlink.h"
 #include "bitset.h"
 #include "parser.h"

 /* PAUSE_GET */

 struct pause_autoneg_status {
 	bool	pause;
 	bool	asym_pause;
 };

 static void pause_autoneg_walker(unsigned int idx,
 				 const char *name __maybe_unused, bool val,
 				 void *data)
 {
 	struct pause_autoneg_status *status = data;

 	if (idx == ETHTOOL_LINK_MODE_Pause_BIT)
 		status->pause = val;
 	if (idx == ETHTOOL_LINK_MODE_Asym_Pause_BIT)
 		status->asym_pause = val;
 }

 static int pause_autoneg_cb(const struct nlmsghdr *nlhdr, void *data)
 {
 	const struct nlattr *tb[ETHTOOL_A_LINKMODES_MAX + 1] = {};
 	DECLARE_ATTR_TB_INFO(tb);
 	struct pause_autoneg_status ours = {};
 	struct pause_autoneg_status peer = {};
 	struct nl_context *nlctx = data;
 	uint8_t rx_status = false;
 	uint8_t tx_status = false;
 	bool silent;
 	int err_ret;
 	int ret;

 	silent = nlctx->is_dump || nlctx->is_monitor;
 	err_ret = silent ? MNL_CB_OK : MNL_CB_ERROR;
 	ret = mnl_attr_parse(nlhdr, GENL_HDRLEN, attr_cb, &tb_info);
 	if (ret < 0)
 		return err_ret;

 	if (!tb[ETHTOOL_A_LINKMODES_OURS] || !tb[ETHTOOL_A_LINKMODES_PEER])
 		return MNL_CB_OK;
 	ret = walk_bitset(tb[ETHTOOL_A_LINKMODES_OURS], NULL,
 			  pause_autoneg_walker, &ours);
 	if (ret < 0)
 		return err_ret;
 	ret = walk_bitset(tb[ETHTOOL_A_LINKMODES_PEER], NULL,
 			  pause_autoneg_walker, &peer);
 	if (ret < 0)
 		return err_ret;

 	if (ours.pause && peer.pause) {
 		rx_status = true;
 		tx_status = true;
 	} else if (ours.asym_pause && peer.asym_pause) {
 		if (ours.pause)
 			rx_status = true;
 		else if (peer.pause)
 			tx_status = true;
 	}

 	open_json_object("negotiated");
 	show_bool_val("rx", "RX negotiated: %s\n", &rx_status);
 	show_bool_val("tx", "TX negotiated: %s\n", &tx_status);
 	close_json_object();

 	return MNL_CB_OK;
 }

 static int show_pause_autoneg_status(struct nl_context *nlctx)
 {
 	const char *saved_devname;
 	int ret;

 	saved_devname = nlctx->ctx->devname;
 	nlctx->ctx->devname = nlctx->devname;
 	ret = netlink_init_ethnl2_socket(nlctx);
 	if (ret < 0)
 		goto out;

 	ret = nlsock_prep_get_request(nlctx->ethnl2_socket,
 				      ETHTOOL_MSG_LINKMODES_GET,
 				      ETHTOOL_A_LINKMODES_HEADER,
 				      ETHTOOL_FLAG_COMPACT_BITSETS);
 	if (ret < 0)
 		goto out;
 	ret = nlsock_send_get_request(nlctx->ethnl2_socket, pause_autoneg_cb);

 out:
 	nlctx->ctx->devname = saved_devname;
 	return ret;
 }

 static int show_pause_stats(const struct nlattr *nest)
 {
 	const struct nlattr *tb[ETHTOOL_A_PAUSE_STAT_MAX + 1] = {};
 	DECLARE_ATTR_TB_INFO(tb);
 	static const struct {
 		unsigned int attr;
 		char *name;
 	} stats[] = {
 		{ ETHTOOL_A_PAUSE_STAT_TX_FRAMES, "tx_pause_frames" },
 		{ ETHTOOL_A_PAUSE_STAT_RX_FRAMES, "rx_pause_frames" },
 	};
 	bool header = false;
 	unsigned int i;
 	size_t n;
 	int ret;

 	ret = mnl_attr_parse_nested(nest, attr_cb, &tb_info);
 	if (ret < 0)
 		return ret;

 	open_json_object("statistics");
 	for (i = 0; i < ARRAY_SIZE(stats); i++) {
 		char fmt[32];

 		if (!tb[stats[i].attr])
 			continue;

 		if (!header && !is_json_context()) {
 			printf("Statistics:\n");
 			header = true;
 		}

 		if (mnl_attr_validate(tb[stats[i].attr], MNL_TYPE_U64)) {
 			fprintf(stderr, "malformed netlink message (statistic)\n");
 			goto err_close_stats;
 		}

 		n = snprintf(fmt, sizeof(fmt), "  %s: %%" PRIu64 "\n",
 			     stats[i].name);
 		if (n >= sizeof(fmt)) {
 			fprintf(stderr, "internal error - malformed label\n");
 			goto err_close_stats;
 		}

 		print_u64(PRINT_ANY, stats[i].name, fmt,
 			  mnl_attr_get_u64(tb[stats[i].attr]));
 	}
 	close_json_object();

 	return 0;

 err_close_stats:
 	close_json_object();
 	return -1;
 }

 int pause_reply_cb(const struct nlmsghdr *nlhdr, void *data)
 {
 	const struct nlattr *tb[ETHTOOL_A_PAUSE_MAX + 1] = {};
 	DECLARE_ATTR_TB_INFO(tb);
 	struct nl_context *nlctx = data;
 	bool silent;
 	int err_ret;
 	int ret;

 	silent = nlctx->is_dump || nlctx->is_monitor;
 	err_ret = silent ? MNL_CB_OK : MNL_CB_ERROR;
 	ret = mnl_attr_parse(nlhdr, GENL_HDRLEN, attr_cb, &tb_info);
 	if (ret < 0)
 		return err_ret;
 	nlctx->devname = get_dev_name(tb[ETHTOOL_A_PAUSE_HEADER]);
 	if (!dev_ok(nlctx))
 		return err_ret;

 	if (silent)
 		print_nl();

 	open_json_object(NULL);

 	print_string(PRINT_ANY, "ifname", "Pause parameters for %s:\n",
 		     nlctx->devname);

 	show_bool("autonegotiate", "Autonegotiate:\t%s\n",
 		  tb[ETHTOOL_A_PAUSE_AUTONEG]);
 	show_bool("rx", "RX:\t\t%s\n", tb[ETHTOOL_A_PAUSE_RX]);
 	show_bool("tx", "TX:\t\t%s\n", tb[ETHTOOL_A_PAUSE_TX]);

 	if (!nlctx->is_monitor && tb[ETHTOOL_A_PAUSE_AUTONEG] &&
 	    mnl_attr_get_u8(tb[ETHTOOL_A_PAUSE_AUTONEG])) {
 		ret = show_pause_autoneg_status(nlctx);
 		if (ret < 0)
 			goto err_close_dev;
 	}
 	if (tb[ETHTOOL_A_PAUSE_STATS]) {
 		ret = show_pause_stats(tb[ETHTOOL_A_PAUSE_STATS]);
 		if (ret < 0)
 			goto err_close_dev;
 	}
 	if (!silent)
 		print_nl();

 	close_json_object();

 	return MNL_CB_OK;

 err_close_dev:
 	close_json_object();
 	return err_ret;
 }

 static const struct lookup_entry_u32 stats_src_values[] = {
 	{ .arg = "aggregate",	.val = ETHTOOL_MAC_STATS_SRC_AGGREGATE },
 	{ .arg = "emac",	.val = ETHTOOL_MAC_STATS_SRC_EMAC },
 	{ .arg = "pmac",	.val = ETHTOOL_MAC_STATS_SRC_PMAC },
 	{}
 };

 static const struct param_parser gpause_params[] = {
 	{
 		.arg		= "--src",
 		.type		= ETHTOOL_A_PAUSE_STATS_SRC,
 		.handler	= nl_parse_lookup_u32,
 		.handler_data	= stats_src_values,
 		.min_argc	= 1,
 	},
 	{}
 };

 int nl_gpause(struct cmd_context *ctx)
 {
 	struct nl_context *nlctx = ctx->nlctx;
 	struct nl_socket *nlsk = nlctx->ethnl_socket;
 	u32 flags;
 	int ret;

 	if (netlink_cmd_check(ctx, ETHTOOL_MSG_PAUSE_GET, true))
 		return -EOPNOTSUPP;

 	flags = get_stats_flag(nlctx, ETHTOOL_MSG_PAUSE_GET,
 			       ETHTOOL_A_PAUSE_HEADER);
 	ret = nlsock_prep_get_request(nlsk, ETHTOOL_MSG_PAUSE_GET,
 				      ETHTOOL_A_PAUSE_HEADER, flags);
 	if (ret < 0)
 		return ret;

 	nlctx->cmd = "-a";
 	nlctx->argp = ctx->argp;
 	nlctx->argc = ctx->argc;
 	nlctx->devname = ctx->devname;
 	nlsk = nlctx->ethnl_socket;

 	ret = nl_parser(nlctx, gpause_params, NULL, PARSER_GROUP_NONE, NULL);
 	if (ret < 0)
 		return 1;

 	new_json_obj(ctx->json);
 	ret = nlsock_send_get_request(nlsk, pause_reply_cb);
 	delete_json_obj();
 	return ret;
 }

 /* PAUSE_SET */

 static const struct param_parser spause_params[] = {
 	{
 		.arg		= "autoneg",
 		.type		= ETHTOOL_A_PAUSE_AUTONEG,
 		.handler	= nl_parse_u8bool,
 		.min_argc	= 1,
 	},
 	{
 		.arg		= "rx",
 		.type		= ETHTOOL_A_PAUSE_RX,
 		.handler	= nl_parse_u8bool,
 		.min_argc	= 1,
 	},
 	{
 		.arg		= "tx",
 		.type		= ETHTOOL_A_PAUSE_TX,
 		.handler	= nl_parse_u8bool,
 		.min_argc	= 1,
 	},
 	{}
 };

 int nl_spause(struct cmd_context *ctx)
 {
 	struct nl_context *nlctx = ctx->nlctx;
 	struct nl_msg_buff *msgbuff;
 	struct nl_socket *nlsk;
 	int ret;

 	if (netlink_cmd_check(ctx, ETHTOOL_MSG_PAUSE_SET, false))
 		return -EOPNOTSUPP;

 	nlctx->cmd = "-A";
 	nlctx->argp = ctx->argp;
 	nlctx->argc = ctx->argc;
 	nlctx->devname = ctx->devname;
 	nlsk = nlctx->ethnl_socket;
 	msgbuff = &nlsk->msgbuff;

 	ret = msg_init(nlctx, msgbuff, ETHTOOL_MSG_PAUSE_SET,
 		       NLM_F_REQUEST | NLM_F_ACK);
 	if (ret < 0)
 		return 2;
 	if (ethnla_fill_header(msgbuff, ETHTOOL_A_PAUSE_HEADER,
 			       ctx->devname, 0))
 		return -EMSGSIZE;

 	ret = nl_parser(nlctx, spause_params, NULL, PARSER_GROUP_NONE, NULL);
 	if (ret < 0)
 		return 1;

 	ret = nlsock_sendmsg(nlsk, NULL);
 	if (ret < 0)
 		return 76;
 	ret = nlsock_process_reply(nlsk, nomsg_reply_cb, nlctx);
 	if (ret == 0)
 		return 0;
 	else
 		return nlctx->exit_code ?: 76;
 }
	/*
	* pause.c - netlink implementation of pause commands
	*
	* Implementation of "ethtool -a <dev>" and "ethtool -A <dev> ..."
	*/

	#include <errno.h>
	#include <inttypes.h>
	#include <string.h>
	#include <stdio.h>

	#include "../internal.h"
	#include "../common.h"
	#include "netlink.h"
	#include "bitset.h"
	#include "parser.h"

	/* PAUSE_GET */

	struct pause_autoneg_status {
	bool pause;
	bool asym_pause;
	};

	static void pause_autoneg_walker(unsigned int idx,
	const char *name __maybe_unused, bool val,
	void *data)
	{
	struct pause_autoneg_status *status = data;

	if (idx == ETHTOOL_LINK_MODE_Pause_BIT)
	status->pause = val;
	if (idx == ETHTOOL_LINK_MODE_Asym_Pause_BIT)
	status->asym_pause = val;
	}

	static int pause_autoneg_cb(const struct nlmsghdr nlhdr, void data)
	{
	const struct nlattr *tb[ETHTOOL_A_LINKMODES_MAX + 1] = {};
	DECLARE_ATTR_TB_INFO(tb);
	struct pause_autoneg_status ours = {};
	struct pause_autoneg_status peer = {};
	struct nl_context *nlctx = data;
	uint8_t rx_status = false;
	uint8_t tx_status = false;
	bool silent;
	int err_ret;
	int ret;

	silent = nlctx->is_dump \|\| nlctx->is_monitor;
	err_ret = silent ? MNL_CB_OK : MNL_CB_ERROR;
	ret = mnl_attr_parse(nlhdr, GENL_HDRLEN, attr_cb, &tb_info);
	if (ret < 0)
	return err_ret;

	if (!tb[ETHTOOL_A_LINKMODES_OURS] \|\| !tb[ETHTOOL_A_LINKMODES_PEER])
	return MNL_CB_OK;
	ret = walk_bitset(tb[ETHTOOL_A_LINKMODES_OURS], NULL,
	pause_autoneg_walker, &ours);
	if (ret < 0)
	return err_ret;
	ret = walk_bitset(tb[ETHTOOL_A_LINKMODES_PEER], NULL,
	pause_autoneg_walker, &peer);
	if (ret < 0)
	return err_ret;

	if (ours.pause && peer.pause) {
	rx_status = true;
	tx_status = true;
	} else if (ours.asym_pause && peer.asym_pause) {
	if (ours.pause)
	rx_status = true;
	else if (peer.pause)
	tx_status = true;
	}

	open_json_object("negotiated");
	show_bool_val("rx", "RX negotiated: %s\n", &rx_status);
	show_bool_val("tx", "TX negotiated: %s\n", &tx_status);
	close_json_object();

	return MNL_CB_OK;
	}

	static int show_pause_autoneg_status(struct nl_context *nlctx)
	{
	const char *saved_devname;
	int ret;

	saved_devname = nlctx->ctx->devname;
	nlctx->ctx->devname = nlctx->devname;
	ret = netlink_init_ethnl2_socket(nlctx);
	if (ret < 0)
	goto out;

	ret = nlsock_prep_get_request(nlctx->ethnl2_socket,
	ETHTOOL_MSG_LINKMODES_GET,
	ETHTOOL_A_LINKMODES_HEADER,
	ETHTOOL_FLAG_COMPACT_BITSETS);
	if (ret < 0)
	goto out;
	ret = nlsock_send_get_request(nlctx->ethnl2_socket, pause_autoneg_cb);

	out:
	nlctx->ctx->devname = saved_devname;
	return ret;
	}

	static int show_pause_stats(const struct nlattr *nest)
	{
	const struct nlattr *tb[ETHTOOL_A_PAUSE_STAT_MAX + 1] = {};
	DECLARE_ATTR_TB_INFO(tb);
	static const struct {
	unsigned int attr;
	char *name;
	} stats[] = {
	{ ETHTOOL_A_PAUSE_STAT_TX_FRAMES, "tx_pause_frames" },
	{ ETHTOOL_A_PAUSE_STAT_RX_FRAMES, "rx_pause_frames" },
	};
	bool header = false;
	unsigned int i;
	size_t n;
	int ret;

	ret = mnl_attr_parse_nested(nest, attr_cb, &tb_info);
	if (ret < 0)
	return ret;

	open_json_object("statistics");
	for (i = 0; i < ARRAY_SIZE(stats); i++) {
	char fmt[32];

	if (!tb[stats[i].attr])
	continue;

	if (!header && !is_json_context()) {
	printf("Statistics:\n");
	header = true;
	}

	if (mnl_attr_validate(tb[stats[i].attr], MNL_TYPE_U64)) {
	fprintf(stderr, "malformed netlink message (statistic)\n");
	goto err_close_stats;
	}

	n = snprintf(fmt, sizeof(fmt), " %s: %%" PRIu64 "\n",
	stats[i].name);
	if (n >= sizeof(fmt)) {
	fprintf(stderr, "internal error - malformed label\n");
	goto err_close_stats;
	}

	print_u64(PRINT_ANY, stats[i].name, fmt,
	mnl_attr_get_u64(tb[stats[i].attr]));
	}
	close_json_object();

	return 0;

	err_close_stats:
	close_json_object();
	return -1;
	}

	int pause_reply_cb(const struct nlmsghdr nlhdr, void data)
	{
	const struct nlattr *tb[ETHTOOL_A_PAUSE_MAX + 1] = {};
	DECLARE_ATTR_TB_INFO(tb);
	struct nl_context *nlctx = data;
	bool silent;
	int err_ret;
	int ret;

	silent = nlctx->is_dump \|\| nlctx->is_monitor;
	err_ret = silent ? MNL_CB_OK : MNL_CB_ERROR;
	ret = mnl_attr_parse(nlhdr, GENL_HDRLEN, attr_cb, &tb_info);
	if (ret < 0)
	return err_ret;
	nlctx->devname = get_dev_name(tb[ETHTOOL_A_PAUSE_HEADER]);
	if (!dev_ok(nlctx))
	return err_ret;

	if (silent)
	print_nl();

	open_json_object(NULL);

	print_string(PRINT_ANY, "ifname", "Pause parameters for %s:\n",
	nlctx->devname);

	show_bool("autonegotiate", "Autonegotiate:\t%s\n",
	tb[ETHTOOL_A_PAUSE_AUTONEG]);
	show_bool("rx", "RX:\t\t%s\n", tb[ETHTOOL_A_PAUSE_RX]);
	show_bool("tx", "TX:\t\t%s\n", tb[ETHTOOL_A_PAUSE_TX]);

	if (!nlctx->is_monitor && tb[ETHTOOL_A_PAUSE_AUTONEG] &&
	mnl_attr_get_u8(tb[ETHTOOL_A_PAUSE_AUTONEG])) {
	ret = show_pause_autoneg_status(nlctx);
	if (ret < 0)
	goto err_close_dev;
	}
	if (tb[ETHTOOL_A_PAUSE_STATS]) {
	ret = show_pause_stats(tb[ETHTOOL_A_PAUSE_STATS]);
	if (ret < 0)
	goto err_close_dev;
	}
	if (!silent)
	print_nl();

	close_json_object();

	return MNL_CB_OK;

	err_close_dev:
	close_json_object();
	return err_ret;
	}

	static const struct lookup_entry_u32 stats_src_values[] = {
	{ .arg = "aggregate", .val = ETHTOOL_MAC_STATS_SRC_AGGREGATE },
	{ .arg = "emac", .val = ETHTOOL_MAC_STATS_SRC_EMAC },
	{ .arg = "pmac", .val = ETHTOOL_MAC_STATS_SRC_PMAC },
	{}
	};

	static const struct param_parser gpause_params[] = {
	{
	.arg = "--src",
	.type = ETHTOOL_A_PAUSE_STATS_SRC,
	.handler = nl_parse_lookup_u32,
	.handler_data = stats_src_values,
	.min_argc = 1,
	},
	{}
	};

	int nl_gpause(struct cmd_context *ctx)
	{
	struct nl_context *nlctx = ctx->nlctx;
	struct nl_socket *nlsk = nlctx->ethnl_socket;
	u32 flags;
	int ret;

	if (netlink_cmd_check(ctx, ETHTOOL_MSG_PAUSE_GET, true))
	return -EOPNOTSUPP;

	flags = get_stats_flag(nlctx, ETHTOOL_MSG_PAUSE_GET,
	ETHTOOL_A_PAUSE_HEADER);
	ret = nlsock_prep_get_request(nlsk, ETHTOOL_MSG_PAUSE_GET,
	ETHTOOL_A_PAUSE_HEADER, flags);
	if (ret < 0)
	return ret;

	nlctx->cmd = "-a";
	nlctx->argp = ctx->argp;
	nlctx->argc = ctx->argc;
	nlctx->devname = ctx->devname;
	nlsk = nlctx->ethnl_socket;

	ret = nl_parser(nlctx, gpause_params, NULL, PARSER_GROUP_NONE, NULL);
	if (ret < 0)
	return 1;

	new_json_obj(ctx->json);
	ret = nlsock_send_get_request(nlsk, pause_reply_cb);
	delete_json_obj();
	return ret;
	}

	/* PAUSE_SET */

	static const struct param_parser spause_params[] = {
	{
	.arg = "autoneg",
	.type = ETHTOOL_A_PAUSE_AUTONEG,
	.handler = nl_parse_u8bool,
	.min_argc = 1,
	},
	{
	.arg = "rx",
	.type = ETHTOOL_A_PAUSE_RX,
	.handler = nl_parse_u8bool,
	.min_argc = 1,
	},
	{
	.arg = "tx",
	.type = ETHTOOL_A_PAUSE_TX,
	.handler = nl_parse_u8bool,
	.min_argc = 1,
	},
	{}
	};

	int nl_spause(struct cmd_context *ctx)
	{
	struct nl_context *nlctx = ctx->nlctx;
	struct nl_msg_buff *msgbuff;
	struct nl_socket *nlsk;
	int ret;

	if (netlink_cmd_check(ctx, ETHTOOL_MSG_PAUSE_SET, false))
	return -EOPNOTSUPP;

	nlctx->cmd = "-A";
	nlctx->argp = ctx->argp;
	nlctx->argc = ctx->argc;
	nlctx->devname = ctx->devname;
	nlsk = nlctx->ethnl_socket;
	msgbuff = &nlsk->msgbuff;

	ret = msg_init(nlctx, msgbuff, ETHTOOL_MSG_PAUSE_SET,
	NLM_F_REQUEST \| NLM_F_ACK);
	if (ret < 0)
	return 2;
	if (ethnla_fill_header(msgbuff, ETHTOOL_A_PAUSE_HEADER,
	ctx->devname, 0))
	return -EMSGSIZE;

	ret = nl_parser(nlctx, spause_params, NULL, PARSER_GROUP_NONE, NULL);
	if (ret < 0)
	return 1;

	ret = nlsock_sendmsg(nlsk, NULL);
	if (ret < 0)
	return 76;
	ret = nlsock_process_reply(nlsk, nomsg_reply_cb, nlctx);
	if (ret == 0)
	return 0;
	else
	return nlctx->exit_code ?: 76;
	}