/*

 * devlink.c	Devlink tool

 *

 *              This program is free software; you can redistribute it and/or

 *              modify it under the terms of the GNU General Public License

 *              as published by the Free Software Foundation; either version

 *              2 of the License, or (at your option) any later version.

 *

 * Authors:     Jiri Pirko <jiri@mellanox.com>

 */

#include <stdio.h>

#include <stdlib.h>

#include <stdarg.h>

#include <string.h>

#include <stdbool.h>

#include <unistd.h>

#include <getopt.h>

#include <limits.h>

#include <errno.h>

#include <inttypes.h>

#include <signal.h>

#include <time.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#include <sys/sysinfo.h>

#define _LINUX_SYSINFO_H /* avoid collision with musl header */

#include <linux/genetlink.h>

#include <linux/devlink.h>

#include <linux/netlink.h>

#include <libmnl/libmnl.h>

#include <netinet/ether.h>

#include <sys/select.h>

#include <sys/socket.h>

#include <sys/types.h>

#include <rt_names.h>

#include "version.h"

#include "list.h"

#include "mnlg.h"

#include "json_print.h"

#include "utils.h"

#include "namespace.h"

#define ESWITCH_MODE_LEGACY "legacy"

#define ESWITCH_MODE_SWITCHDEV "switchdev"

#define ESWITCH_INLINE_MODE_NONE "none"

#define ESWITCH_INLINE_MODE_LINK "link"

#define ESWITCH_INLINE_MODE_NETWORK "network"

#define ESWITCH_INLINE_MODE_TRANSPORT "transport"

#define ESWITCH_ENCAP_MODE_NONE "none"

#define ESWITCH_ENCAP_MODE_BASIC "basic"

#define PARAM_CMODE_RUNTIME_STR "runtime"

#define PARAM_CMODE_DRIVERINIT_STR "driverinit"

#define PARAM_CMODE_PERMANENT_STR "permanent"

#define DL_ARGS_REQUIRED_MAX_ERR_LEN 80

#define HEALTH_REPORTER_STATE_HEALTHY_STR "healthy"

#define HEALTH_REPORTER_STATE_ERROR_STR "error"

#define HEALTH_REPORTER_TIMESTAMP_FMT_LEN 80

static int g_new_line_count;

static int g_indent_level;

static bool g_indent_newline;

#define INDENT_STR_STEP 2

#define INDENT_STR_MAXLEN 32

static char g_indent_str[INDENT_STR_MAXLEN + 1] = "";

static void __attribute__((format(printf, 1, 2)))

pr_err(const char *fmt, ...)

{

	va_list ap;

	va_start(ap, fmt);

	vfprintf(stderr, fmt, ap);

	va_end(ap);

}

static void __attribute__((format(printf, 1, 2)))

pr_out(const char *fmt, ...)

{

	va_list ap;

	if (g_indent_newline) {

		printf("%s", g_indent_str);

		g_indent_newline = false;

	}

	va_start(ap, fmt);

	vprintf(fmt, ap);

	va_end(ap);

	g_new_line_count = 0;

}

static void __attribute__((format(printf, 2, 3)))

pr_out_sp(unsigned int num, const char *fmt, ...)

{

	va_list ap;

	int ret;

	va_start(ap, fmt);

	ret = vprintf(fmt, ap);

	va_end(ap);

	if (ret < num)

		printf("%*s", num - ret, "");

	g_new_line_count = 0;			\

}

static void __attribute__((format(printf, 1, 2)))

pr_out_tty(const char *fmt, ...)

{

	va_list ap;

	if (!isatty(STDOUT_FILENO))

		return;

	va_start(ap, fmt);

	vprintf(fmt, ap);

	va_end(ap);

}

static void __pr_out_indent_inc(void)

{

	if (g_indent_level + INDENT_STR_STEP > INDENT_STR_MAXLEN)

		return;

	g_indent_level += INDENT_STR_STEP;

	memset(g_indent_str, ' ', sizeof(g_indent_str));

	g_indent_str[g_indent_level] = '\0';

}

static void __pr_out_indent_dec(void)

{

	if (g_indent_level - INDENT_STR_STEP < 0)

		return;

	g_indent_level -= INDENT_STR_STEP;

	g_indent_str[g_indent_level] = '\0';

}

static void __pr_out_newline(void)

{

	if (g_new_line_count < 1) {

		pr_out("\n");

		g_indent_newline = true;

	}

	g_new_line_count++;

}

static int _mnlg_socket_recv_run(struct mnlg_socket *nlg,

				 mnl_cb_t data_cb, void *data)

{

	int err;

	err = mnlg_socket_recv_run(nlg, data_cb, data);

	if (err < 0) {

		pr_err("devlink answers: %s\n", strerror(errno));

		return -errno;

	}

	return 0;

}

static void dummy_signal_handler(int signum)

{

}

static int _mnlg_socket_recv_run_intr(struct mnlg_socket *nlg,

				      mnl_cb_t data_cb, void *data)

{

	struct sigaction act, oact;

	int err;

	act.sa_handler = dummy_signal_handler;

	sigemptyset(&act.sa_mask);

	act.sa_flags = SA_NODEFER;

	sigaction(SIGINT, &act, &oact;;

	err = mnlg_socket_recv_run(nlg, data_cb, data);

	sigaction(SIGINT, &oact, NULL);

	if (err < 0 && errno != EINTR) {

		pr_err("devlink answers: %s\n", strerror(errno));

		return -errno;

	}

	return 0;

}

static int _mnlg_socket_send(struct mnlg_socket *nlg,

			     const struct nlmsghdr *nlh)

{

	int err;

	err = mnlg_socket_send(nlg, nlh);

	if (err < 0) {

		pr_err("Failed to call mnlg_socket_send\n");

		return -errno;

	}

	return 0;

}

static int _mnlg_socket_sndrcv(struct mnlg_socket *nlg,

			       const struct nlmsghdr *nlh,

			       mnl_cb_t data_cb, void *data)

{

	int err;

	err = _mnlg_socket_send(nlg, nlh);

	if (err)

		return err;

	return _mnlg_socket_recv_run(nlg, data_cb, data);

}

static int _mnlg_socket_group_add(struct mnlg_socket *nlg,

				  const char *group_name)

{

	int err;

	err = mnlg_socket_group_add(nlg, group_name);

	if (err < 0) {

		pr_err("Failed to call mnlg_socket_group_add\n");

		return -errno;

	}

	return 0;

}

struct ifname_map {

	struct list_head list;

	char *bus_name;

	char *dev_name;

	uint32_t port_index;

	char *ifname;

};

static struct ifname_map *ifname_map_alloc(const char *bus_name,

					   const char *dev_name,

					   uint32_t port_index,

					   const char *ifname)

{

	struct ifname_map *ifname_map;

	ifname_map = calloc(1, sizeof(*ifname_map));

	if (!ifname_map)

		return NULL;

	ifname_map->bus_name = strdup(bus_name);

	ifname_map->dev_name = strdup(dev_name);

	ifname_map->port_index = port_index;

	ifname_map->ifname = strdup(ifname);

	if (!ifname_map->bus_name || !ifname_map->dev_name ||

	    !ifname_map->ifname) {

		free(ifname_map->ifname);

		free(ifname_map->dev_name);

		free(ifname_map->bus_name);

		free(ifname_map);

		return NULL;

	}

	return ifname_map;

}

static void ifname_map_free(struct ifname_map *ifname_map)

{

	free(ifname_map->ifname);

	free(ifname_map->dev_name);

	free(ifname_map->bus_name);

	free(ifname_map);

}

#define DL_OPT_HANDLE		BIT(0)

#define DL_OPT_HANDLEP		BIT(1)

#define DL_OPT_PORT_TYPE	BIT(2)

#define DL_OPT_PORT_COUNT	BIT(3)

#define DL_OPT_SB		BIT(4)

#define DL_OPT_SB_POOL		BIT(5)

#define DL_OPT_SB_SIZE		BIT(6)

#define DL_OPT_SB_TYPE		BIT(7)

#define DL_OPT_SB_THTYPE	BIT(8)

#define DL_OPT_SB_TH		BIT(9)

#define DL_OPT_SB_TC		BIT(10)

#define DL_OPT_ESWITCH_MODE	BIT(11)

#define DL_OPT_ESWITCH_INLINE_MODE	BIT(12)

#define DL_OPT_DPIPE_TABLE_NAME	BIT(13)

#define DL_OPT_DPIPE_TABLE_COUNTERS	BIT(14)

#define DL_OPT_ESWITCH_ENCAP_MODE	BIT(15)

#define DL_OPT_RESOURCE_PATH	BIT(16)

#define DL_OPT_RESOURCE_SIZE	BIT(17)

#define DL_OPT_PARAM_NAME	BIT(18)

#define DL_OPT_PARAM_VALUE	BIT(19)

#define DL_OPT_PARAM_CMODE	BIT(20)

#define DL_OPT_HANDLE_REGION		BIT(21)

#define DL_OPT_REGION_SNAPSHOT_ID	BIT(22)

#define DL_OPT_REGION_ADDRESS		BIT(23)

#define DL_OPT_REGION_LENGTH		BIT(24)

#define DL_OPT_FLASH_FILE_NAME	BIT(25)

#define DL_OPT_FLASH_COMPONENT	BIT(26)

#define DL_OPT_HEALTH_REPORTER_NAME	BIT(27)

#define DL_OPT_HEALTH_REPORTER_GRACEFUL_PERIOD	BIT(28)

#define DL_OPT_HEALTH_REPORTER_AUTO_RECOVER	BIT(29)

#define DL_OPT_TRAP_NAME		BIT(30)

#define DL_OPT_TRAP_ACTION		BIT(31)

#define DL_OPT_TRAP_GROUP_NAME		BIT(32)

#define DL_OPT_NETNS	BIT(33)

#define DL_OPT_TRAP_POLICER_ID		BIT(34)

#define DL_OPT_TRAP_POLICER_RATE	BIT(35)

#define DL_OPT_TRAP_POLICER_BURST	BIT(36)

#define DL_OPT_HEALTH_REPORTER_AUTO_DUMP     BIT(37)

#define DL_OPT_PORT_FUNCTION_HW_ADDR BIT(38)

struct dl_opts {

	uint64_t present; /* flags of present items */

	char *bus_name;

	char *dev_name;

	uint32_t port_index;

	enum devlink_port_type port_type;

	uint32_t port_count;

	uint32_t sb_index;

	uint16_t sb_pool_index;

	uint32_t sb_pool_size;

	enum devlink_sb_pool_type sb_pool_type;

	enum devlink_sb_threshold_type sb_pool_thtype;

	uint32_t sb_threshold;

	uint16_t sb_tc_index;

	enum devlink_eswitch_mode eswitch_mode;

	enum devlink_eswitch_inline_mode eswitch_inline_mode;

	const char *dpipe_table_name;

	bool dpipe_counters_enabled;

	enum devlink_eswitch_encap_mode eswitch_encap_mode;

	const char *resource_path;

	uint64_t resource_size;

	uint32_t resource_id;

	bool resource_id_valid;

	const char *param_name;

	const char *param_value;

	enum devlink_param_cmode cmode;

	char *region_name;

	uint32_t region_snapshot_id;

	uint64_t region_address;

	uint64_t region_length;

	const char *flash_file_name;

	const char *flash_component;

	const char *reporter_name;

	uint64_t reporter_graceful_period;

	bool reporter_auto_recover;

	bool reporter_auto_dump;

	const char *trap_name;

	const char *trap_group_name;

	enum devlink_trap_action trap_action;

	bool netns_is_pid;

	uint32_t netns;

	uint32_t trap_policer_id;

	uint64_t trap_policer_rate;

	uint64_t trap_policer_burst;

	char port_function_hw_addr[MAX_ADDR_LEN];

	uint32_t port_function_hw_addr_len;

};

struct dl {

	struct mnlg_socket *nlg;

	struct list_head ifname_map_list;

	int argc;

	char **argv;

	bool no_nice_names;

	struct dl_opts opts;

	bool json_output;

	bool pretty_output;

	bool verbose;

	bool stats;

	struct {

		bool present;

		char *bus_name;

		char *dev_name;

		uint32_t port_index;

	} arr_last;

};

static int dl_argc(struct dl *dl)

{

	return dl->argc;

}

static char *dl_argv(struct dl *dl)

{

	if (dl_argc(dl) == 0)

		return NULL;

	return *dl->argv;

}

static void dl_arg_inc(struct dl *dl)

{

	if (dl_argc(dl) == 0)

		return;

	dl->argc--;

	dl->argv++;

}

static void dl_arg_dec(struct dl *dl)

{

	dl->argc++;

	dl->argv--;

}

static char *dl_argv_next(struct dl *dl)

{

	char *ret;

	if (dl_argc(dl) == 0)

		return NULL;

	ret = *dl->argv;

	dl_arg_inc(dl);

	return ret;

}

static char *dl_argv_index(struct dl *dl, unsigned int index)

{

	if (index >= dl_argc(dl))

		return NULL;

	return dl->argv[index];

}

static int strcmpx(const char *str1, const char *str2)

{

	if (strlen(str1) > strlen(str2))

		return -1;

	return strncmp(str1, str2, strlen(str1));

}

static bool dl_argv_match(struct dl *dl, const char *pattern)

{

	if (dl_argc(dl) == 0)

		return false;

	return strcmpx(dl_argv(dl), pattern) == 0;

}

static bool dl_no_arg(struct dl *dl)

{

	return dl_argc(dl) == 0;

}

static void __pr_out_indent_newline(struct dl *dl)

{

	if (!g_indent_newline && !dl->json_output)

		pr_out(" ");

}

static bool is_binary_eol(int i)

{

	return !(i%16);

}

static void pr_out_binary_value(struct dl *dl, uint8_t *data, uint32_t len)

{

	int i = 0;

	while (i < len) {

		if (dl->json_output)

			print_int(PRINT_JSON, NULL, NULL, data[i]);

		else

			pr_out("%02x ", data[i]);

		i++;

		if (!dl->json_output && is_binary_eol(i))

			__pr_out_newline();

	}

	if (!dl->json_output && !is_binary_eol(i))

		__pr_out_newline();

}

static void pr_out_name(struct dl *dl, const char *name)

{

	__pr_out_indent_newline(dl);

	if (dl->json_output)

		print_string(PRINT_JSON, name, NULL, NULL);

	else

		pr_out("%s:", name);

}

static void pr_out_u64(struct dl *dl, const char *name, uint64_t val)

{

	__pr_out_indent_newline(dl);

	if (val == (uint64_t) -1)

		return print_string_name_value(name, "unlimited");

	if (dl->json_output)

		print_u64(PRINT_JSON, name, NULL, val);

	else

		pr_out("%s %"PRIu64, name, val);

}

static void pr_out_section_start(struct dl *dl, const char *name)

{

	if (dl->json_output) {

		open_json_object(NULL);

		open_json_object(name);

	}

}

static void pr_out_section_end(struct dl *dl)

{

	if (dl->json_output) {

		if (dl->arr_last.present)

			close_json_array(PRINT_JSON, NULL);

		close_json_object();

		close_json_object();

	}

}

static void pr_out_array_start(struct dl *dl, const char *name)

{

	if (dl->json_output) {

		open_json_array(PRINT_JSON, name);

	} else {

		__pr_out_indent_inc();

		__pr_out_newline();

		pr_out("%s:", name);

		__pr_out_indent_inc();

		__pr_out_newline();

	}

}

static void pr_out_array_end(struct dl *dl)

{

	if (dl->json_output) {

		close_json_array(PRINT_JSON, NULL);

	} else {

		__pr_out_indent_dec();

		__pr_out_indent_dec();

	}

}

static void pr_out_object_start(struct dl *dl, const char *name)

{

	if (dl->json_output) {

		open_json_object(name);

	} else {

		__pr_out_indent_inc();

		__pr_out_newline();

		pr_out("%s:", name);

		__pr_out_indent_inc();

		__pr_out_newline();

	}

}

static void pr_out_object_end(struct dl *dl)

{

	if (dl->json_output) {

		close_json_object();

	} else {

		__pr_out_indent_dec();

		__pr_out_indent_dec();

	}

}

static void pr_out_entry_start(struct dl *dl)

{

	if (dl->json_output)

		open_json_object(NULL);

}

static void pr_out_entry_end(struct dl *dl)

{

	if (dl->json_output)

		close_json_object();

	else

		__pr_out_newline();

}

static void check_indent_newline(struct dl *dl)

{

	__pr_out_indent_newline(dl);

	if (g_indent_newline && !is_json_context()) {

		printf("%s", g_indent_str);

		g_indent_newline = false;

	}

	g_new_line_count = 0;

}

static const enum mnl_attr_data_type devlink_policy[DEVLINK_ATTR_MAX + 1] = {

	[DEVLINK_ATTR_BUS_NAME] = MNL_TYPE_NUL_STRING,

	[DEVLINK_ATTR_DEV_NAME] = MNL_TYPE_NUL_STRING,

	[DEVLINK_ATTR_PORT_INDEX] = MNL_TYPE_U32,

	[DEVLINK_ATTR_PORT_TYPE] = MNL_TYPE_U16,

	[DEVLINK_ATTR_PORT_DESIRED_TYPE] = MNL_TYPE_U16,

	[DEVLINK_ATTR_PORT_NETDEV_IFINDEX] = MNL_TYPE_U32,

	[DEVLINK_ATTR_PORT_NETDEV_NAME] = MNL_TYPE_NUL_STRING,

	[DEVLINK_ATTR_PORT_IBDEV_NAME] = MNL_TYPE_NUL_STRING,

	[DEVLINK_ATTR_PORT_LANES] = MNL_TYPE_U32,

	[DEVLINK_ATTR_PORT_SPLITTABLE] = MNL_TYPE_U8,

	[DEVLINK_ATTR_SB_INDEX] = MNL_TYPE_U32,

	[DEVLINK_ATTR_SB_SIZE] = MNL_TYPE_U32,

	[DEVLINK_ATTR_SB_INGRESS_POOL_COUNT] = MNL_TYPE_U16,

	[DEVLINK_ATTR_SB_EGRESS_POOL_COUNT] = MNL_TYPE_U16,

	[DEVLINK_ATTR_SB_INGRESS_TC_COUNT] = MNL_TYPE_U16,

	[DEVLINK_ATTR_SB_EGRESS_TC_COUNT] = MNL_TYPE_U16,

	[DEVLINK_ATTR_SB_POOL_INDEX] = MNL_TYPE_U16,

	[DEVLINK_ATTR_SB_POOL_TYPE] = MNL_TYPE_U8,

	[DEVLINK_ATTR_SB_POOL_SIZE] = MNL_TYPE_U32,

	[DEVLINK_ATTR_SB_POOL_THRESHOLD_TYPE] = MNL_TYPE_U8,

	[DEVLINK_ATTR_SB_THRESHOLD] = MNL_TYPE_U32,

	[DEVLINK_ATTR_SB_TC_INDEX] = MNL_TYPE_U16,

	[DEVLINK_ATTR_SB_OCC_CUR] = MNL_TYPE_U32,

	[DEVLINK_ATTR_SB_OCC_MAX] = MNL_TYPE_U32,

	[DEVLINK_ATTR_ESWITCH_MODE] = MNL_TYPE_U16,

	[DEVLINK_ATTR_ESWITCH_INLINE_MODE] = MNL_TYPE_U8,

	[DEVLINK_ATTR_ESWITCH_ENCAP_MODE] = MNL_TYPE_U8,

	[DEVLINK_ATTR_DPIPE_TABLES] = MNL_TYPE_NESTED,

	[DEVLINK_ATTR_DPIPE_TABLE] = MNL_TYPE_NESTED,

	[DEVLINK_ATTR_DPIPE_TABLE_NAME] = MNL_TYPE_STRING,

	[DEVLINK_ATTR_DPIPE_TABLE_SIZE] = MNL_TYPE_U64,

	[DEVLINK_ATTR_DPIPE_TABLE_MATCHES] = MNL_TYPE_NESTED,

	[DEVLINK_ATTR_DPIPE_TABLE_ACTIONS] = MNL_TYPE_NESTED,

	[DEVLINK_ATTR_DPIPE_TABLE_COUNTERS_ENABLED] =  MNL_TYPE_U8,

	[DEVLINK_ATTR_DPIPE_ENTRIES] = MNL_TYPE_NESTED,

	[DEVLINK_ATTR_DPIPE_ENTRY] = MNL_TYPE_NESTED,

	[DEVLINK_ATTR_DPIPE_ENTRY_INDEX] = MNL_TYPE_U64,

	[DEVLINK_ATTR_DPIPE_ENTRY_MATCH_VALUES] = MNL_TYPE_NESTED,

	[DEVLINK_ATTR_DPIPE_ENTRY_ACTION_VALUES] = MNL_TYPE_NESTED,

	[DEVLINK_ATTR_DPIPE_ENTRY_COUNTER] = MNL_TYPE_U64,

	[DEVLINK_ATTR_DPIPE_MATCH] = MNL_TYPE_NESTED,

	[DEVLINK_ATTR_DPIPE_MATCH_VALUE] = MNL_TYPE_NESTED,

	[DEVLINK_ATTR_DPIPE_MATCH_TYPE] = MNL_TYPE_U32,

	[DEVLINK_ATTR_DPIPE_ACTION] = MNL_TYPE_NESTED,

	[DEVLINK_ATTR_DPIPE_ACTION_VALUE] = MNL_TYPE_NESTED,

	[DEVLINK_ATTR_DPIPE_ACTION_TYPE] = MNL_TYPE_U32,

	[DEVLINK_ATTR_DPIPE_VALUE_MAPPING] = MNL_TYPE_U32,

	[DEVLINK_ATTR_DPIPE_HEADERS] = MNL_TYPE_NESTED,

	[DEVLINK_ATTR_DPIPE_HEADER] = MNL_TYPE_NESTED,

	[DEVLINK_ATTR_DPIPE_HEADER_NAME] = MNL_TYPE_STRING,

	[DEVLINK_ATTR_DPIPE_HEADER_ID] = MNL_TYPE_U32,

	[DEVLINK_ATTR_DPIPE_HEADER_FIELDS] = MNL_TYPE_NESTED,

	[DEVLINK_ATTR_DPIPE_HEADER_GLOBAL] = MNL_TYPE_U8,

	[DEVLINK_ATTR_DPIPE_HEADER_INDEX] = MNL_TYPE_U32,

	[DEVLINK_ATTR_DPIPE_FIELD] = MNL_TYPE_NESTED,

	[DEVLINK_ATTR_DPIPE_FIELD_NAME] = MNL_TYPE_STRING,

	[DEVLINK_ATTR_DPIPE_FIELD_ID] = MNL_TYPE_U32,

	[DEVLINK_ATTR_DPIPE_FIELD_BITWIDTH] = MNL_TYPE_U32,

	[DEVLINK_ATTR_DPIPE_FIELD_MAPPING_TYPE] = MNL_TYPE_U32,

	[DEVLINK_ATTR_PARAM] = MNL_TYPE_NESTED,

	[DEVLINK_ATTR_PARAM_NAME] = MNL_TYPE_STRING,

	[DEVLINK_ATTR_PARAM_TYPE] = MNL_TYPE_U8,

	[DEVLINK_ATTR_PARAM_VALUES_LIST] = MNL_TYPE_NESTED,

	[DEVLINK_ATTR_PARAM_VALUE] = MNL_TYPE_NESTED,

	[DEVLINK_ATTR_PARAM_VALUE_CMODE] = MNL_TYPE_U8,

	[DEVLINK_ATTR_REGION_NAME] = MNL_TYPE_STRING,

	[DEVLINK_ATTR_REGION_SIZE] = MNL_TYPE_U64,

	[DEVLINK_ATTR_REGION_SNAPSHOTS] = MNL_TYPE_NESTED,

	[DEVLINK_ATTR_REGION_SNAPSHOT] = MNL_TYPE_NESTED,

	[DEVLINK_ATTR_REGION_SNAPSHOT_ID] = MNL_TYPE_U32,

	[DEVLINK_ATTR_REGION_CHUNKS] = MNL_TYPE_NESTED,

	[DEVLINK_ATTR_REGION_CHUNK] = MNL_TYPE_NESTED,

	[DEVLINK_ATTR_REGION_CHUNK_DATA] = MNL_TYPE_BINARY,

	[DEVLINK_ATTR_REGION_CHUNK_ADDR] = MNL_TYPE_U64,

	[DEVLINK_ATTR_REGION_CHUNK_LEN] = MNL_TYPE_U64,

	[DEVLINK_ATTR_INFO_DRIVER_NAME] = MNL_TYPE_STRING,

	[DEVLINK_ATTR_INFO_SERIAL_NUMBER] = MNL_TYPE_STRING,

	[DEVLINK_ATTR_INFO_BOARD_SERIAL_NUMBER] = MNL_TYPE_STRING,

	[DEVLINK_ATTR_INFO_VERSION_FIXED] = MNL_TYPE_NESTED,

	[DEVLINK_ATTR_INFO_VERSION_RUNNING] = MNL_TYPE_NESTED,

	[DEVLINK_ATTR_INFO_VERSION_STORED] = MNL_TYPE_NESTED,

	[DEVLINK_ATTR_INFO_VERSION_NAME] = MNL_TYPE_STRING,

	[DEVLINK_ATTR_INFO_VERSION_VALUE] = MNL_TYPE_STRING,

	[DEVLINK_ATTR_HEALTH_REPORTER] = MNL_TYPE_NESTED,

	[DEVLINK_ATTR_HEALTH_REPORTER_NAME] = MNL_TYPE_STRING,

	[DEVLINK_ATTR_HEALTH_REPORTER_STATE] = MNL_TYPE_U8,

	[DEVLINK_ATTR_HEALTH_REPORTER_ERR_COUNT] = MNL_TYPE_U64,

	[DEVLINK_ATTR_HEALTH_REPORTER_RECOVER_COUNT] = MNL_TYPE_U64,

	[DEVLINK_ATTR_HEALTH_REPORTER_DUMP_TS] = MNL_TYPE_U64,

	[DEVLINK_ATTR_HEALTH_REPORTER_GRACEFUL_PERIOD] = MNL_TYPE_U64,

	[DEVLINK_ATTR_FLASH_UPDATE_COMPONENT] = MNL_TYPE_STRING,

	[DEVLINK_ATTR_FLASH_UPDATE_STATUS_MSG] = MNL_TYPE_STRING,

	[DEVLINK_ATTR_FLASH_UPDATE_STATUS_DONE] = MNL_TYPE_U64,

	[DEVLINK_ATTR_FLASH_UPDATE_STATUS_TOTAL] = MNL_TYPE_U64,

	[DEVLINK_ATTR_STATS] = MNL_TYPE_NESTED,

	[DEVLINK_ATTR_TRAP_NAME] = MNL_TYPE_STRING,

	[DEVLINK_ATTR_TRAP_ACTION] = MNL_TYPE_U8,

	[DEVLINK_ATTR_TRAP_TYPE] = MNL_TYPE_U8,

	[DEVLINK_ATTR_TRAP_GENERIC] = MNL_TYPE_FLAG,

	[DEVLINK_ATTR_TRAP_METADATA] = MNL_TYPE_NESTED,

	[DEVLINK_ATTR_TRAP_GROUP_NAME] = MNL_TYPE_STRING,

	[DEVLINK_ATTR_RELOAD_FAILED] = MNL_TYPE_U8,

	[DEVLINK_ATTR_TRAP_POLICER_ID] = MNL_TYPE_U32,

	[DEVLINK_ATTR_TRAP_POLICER_RATE] = MNL_TYPE_U64,

	[DEVLINK_ATTR_TRAP_POLICER_BURST] = MNL_TYPE_U64,

};

static const enum mnl_attr_data_type

devlink_stats_policy[DEVLINK_ATTR_STATS_MAX + 1] = {

	[DEVLINK_ATTR_STATS_RX_PACKETS] = MNL_TYPE_U64,

	[DEVLINK_ATTR_STATS_RX_BYTES] = MNL_TYPE_U64,

	[DEVLINK_ATTR_STATS_RX_DROPPED] = MNL_TYPE_U64,

};

static int attr_cb(const struct nlattr *attr, void *data)

{

	const struct nlattr **tb = data;

	int type;

	if (mnl_attr_type_valid(attr, DEVLINK_ATTR_MAX) < 0)

		return MNL_CB_OK;

	type = mnl_attr_get_type(attr);

	if (mnl_attr_validate(attr, devlink_policy[type]) < 0)

		return MNL_CB_ERROR;

	tb[type] = attr;

	return MNL_CB_OK;

}

static int attr_stats_cb(const struct nlattr *attr, void *data)

{

	const struct nlattr **tb = data;

	int type;

	/* Allow the tool to work on top of newer kernels that might contain

	 * more attributes.

	 */

	if (mnl_attr_type_valid(attr, DEVLINK_ATTR_STATS_MAX) < 0)

		return MNL_CB_OK;

	type = mnl_attr_get_type(attr);

	if (mnl_attr_validate(attr, devlink_stats_policy[type]) < 0)

		return MNL_CB_ERROR;

	tb[type] = attr;

	return MNL_CB_OK;

}

static const enum mnl_attr_data_type

devlink_function_policy[DEVLINK_PORT_FUNCTION_ATTR_MAX + 1] = {

	[DEVLINK_PORT_FUNCTION_ATTR_HW_ADDR ] = MNL_TYPE_BINARY,

};

static int function_attr_cb(const struct nlattr *attr, void *data)

{

	const struct nlattr **tb = data;

	int type;

	/* Allow the tool to work on top of newer kernels that might contain

	 * more attributes.

	 */

	if (mnl_attr_type_valid(attr, DEVLINK_PORT_FUNCTION_ATTR_MAX) < 0)

		return MNL_CB_OK;

	type = mnl_attr_get_type(attr);

	if (mnl_attr_validate(attr, devlink_function_policy[type]) < 0)

		return MNL_CB_ERROR;

	tb[type] = attr;

	return MNL_CB_OK;

}

static int ifname_map_cb(const struct nlmsghdr *nlh, void *data)

{

	struct nlattr *tb[DEVLINK_ATTR_MAX + 1] = {};

	struct genlmsghdr *genl = mnl_nlmsg_get_payload(nlh);

	struct dl *dl = data;

	struct ifname_map *ifname_map;

	const char *bus_name;

	const char *dev_name;

	uint32_t port_ifindex;

	const char *port_ifname;

	mnl_attr_parse(nlh, sizeof(*genl), attr_cb, tb);

	if (!tb[DEVLINK_ATTR_BUS_NAME] || !tb[DEVLINK_ATTR_DEV_NAME] ||

	    !tb[DEVLINK_ATTR_PORT_INDEX])

		return MNL_CB_ERROR;

	if (!tb[DEVLINK_ATTR_PORT_NETDEV_NAME])

		return MNL_CB_OK;

	bus_name = mnl_attr_get_str(tb[DEVLINK_ATTR_BUS_NAME]);

	dev_name = mnl_attr_get_str(tb[DEVLINK_ATTR_DEV_NAME]);

	port_ifindex = mnl_attr_get_u32(tb[DEVLINK_ATTR_PORT_INDEX]);

	port_ifname = mnl_attr_get_str(tb[DEVLINK_ATTR_PORT_NETDEV_NAME]);

	ifname_map = ifname_map_alloc(bus_name, dev_name,

				      port_ifindex, port_ifname);

	if (!ifname_map)

		return MNL_CB_ERROR;

	list_add(&ifname_map->list, &dl->ifname_map_list);

	return MNL_CB_OK;

}

static void ifname_map_fini(struct dl *dl)

{

	struct ifname_map *ifname_map, *tmp;

	list_for_each_entry_safe(ifname_map, tmp,

				 &dl->ifname_map_list, list) {

		list_del(&ifname_map->list);

		ifname_map_free(ifname_map);

	}

}

static int ifname_map_init(struct dl *dl)

{

	struct nlmsghdr *nlh;

	int err;

	INIT_LIST_HEAD(&dl->ifname_map_list);

	nlh = mnlg_msg_prepare(dl->nlg, DEVLINK_CMD_PORT_GET,

			       NLM_F_REQUEST | NLM_F_ACK | NLM_F_DUMP);

	err = _mnlg_socket_sndrcv(dl->nlg, nlh, ifname_map_cb, dl);

	if (err) {

		ifname_map_fini(dl);

		return err;

	}

	return 0;

}

static int ifname_map_lookup(struct dl *dl, const char *ifname,

			     char **p_bus_name, char **p_dev_name,

			     uint32_t *p_port_index)

{

	struct ifname_map *ifname_map;

	list_for_each_entry(ifname_map, &dl->ifname_map_list, list) {

		if (strcmp(ifname, ifname_map->ifname) == 0) {

			*p_bus_name = ifname_map->bus_name;

			*p_dev_name = ifname_map->dev_name;

			*p_port_index = ifname_map->port_index;

			return 0;

		}

	}

	return -ENOENT;

}

static int ifname_map_rev_lookup(struct dl *dl, const char *bus_name,

				 const char *dev_name, uint32_t port_index,

				 char **p_ifname)

{

	struct ifname_map *ifname_map;

	list_for_each_entry(ifname_map, &dl->ifname_map_list, list) {

		if (strcmp(bus_name, ifname_map->bus_name) == 0 &&

		    strcmp(dev_name, ifname_map->dev_name) == 0 &&

		    port_index == ifname_map->port_index) {

			*p_ifname = ifname_map->ifname;

			return 0;

		}

	}

	return -ENOENT;

}

static unsigned int strslashcount(char *str)

{

	unsigned int count = 0;

	char *pos = str;

	while ((pos = strchr(pos, '/'))) {

		count++;

		pos++;

	}

	return count;

}

static int strslashrsplit(char *str, char **before, char **after)

{

	char *slash;

	slash = strrchr(str, '/');

	if (!slash)

		return -EINVAL;

	*slash = '\0';

	*before = str;

	*after = slash + 1;

	return 0;

}

static int strtouint64_t(const char *str, uint64_t *p_val)

{

	char *endptr;

	unsigned long long int val;

	val = strtoull(str, &endptr, 10);

	if (endptr == str || *endptr != '\0')

		return -EINVAL;

	if (val > ULONG_MAX)

		return -ERANGE;

	*p_val = val;

	return 0;