From 120f9c488ba7d291f899f1ec2f77e0ae33efcd88 Mon Sep 17 00:00:00 2001

From: Kamal Heib <kheib@redhat.com>

Date: Thu, 9 Nov 2017 04:44:32 -0500

Subject: [PATCH] devlink: Add support for pipeline debug (dpipe)

Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=1456539

commit 153c1a9b21e5b7b78e066de2b93a4edb8c3dc498

Author: Arkadi Sharshevsky <arkadis@mellanox.com>

Date:   Wed May 3 13:25:23 2017 +0200

    devlink: Add support for pipeline debug (dpipe)

    Add support for pipeline debug (dpipe). The headers are used both the

    gain visibillity into the headers supported by the hardware, and to

    build the headers/field database which is used by other commands.

    Examples:

    First we can see the headers supported by the hardware:

    $devlink dpipe header show pci/0000:03:00.0

    pci/0000:03:00.0:

      name mlxsw_meta

      field:

        name erif_port bitwidth 32 mapping_type ifindex

        name l3_forward bitwidth 1

        name l3_drop bitwidth 1

    Note that mapping_type is presented only if relevant. Also the header/

    field id's are reported by the kernel they are not shown by default.

    They can be observed by using the -v option. Also the headers scope

    (global/local) is specified.

    $devlink -v dpipe header show pci/0000:03:00.0

    pci/0000:03:00.0:

      name mlxsw_meta id 0 global false

      field:

        name erif_port id 0 bitwidth 32 mapping_type ifindex

        name l3_forward id 1 bitwidth 1

        name l3_drop id 2 bitwidth 1

    Second we can examine the tables supported by the hardware. In order

    to dump all the tables no table name should be provided:

    $devlink dpipe table show pci/0000:03:00.0

    In order to examine specific table its name have to be specified:

    $devlink dpipe table show pci/0000:03:00.0 name erif

    pci/0000:03:00.0:

      name mlxsw_erif size 800 counters_enabled true

      match:

        type field_exact header mlxsw_meta field erif_port mapping ifindex

      action:

        type field_modify header mlxsw_meta field l3_forward

        type field_modify header mlxsw_meta field l3_drop

    To enable/disable counters on the table:

    $devlink dpipe table set pci/0000:03:00.0 name erif counters enable

    $devlink dpipe table set pci/0000:03:00.0 name erif counters disable

    In order to see the current entries in the hardware for specific table:

    $devlink dpipe table dump pci/0000:03:00.0 name erif

    pci/0000:03:00.0:

      index 0 counter 0

      match_value:

        type field_exact header mlxsw_meta field erif_port mapping ifindex mapping_value 383 value 0

      action_value:

        type field_modify header mlxsw_meta field l3_forward value 1

      index 1 counter 0

      match_value:

        type field_exact header mlxsw_meta field erif_port mapping ifindex mapping_value 381 value 1

      action_value:

        type field_modify header mlxsw_meta field l3_forward value 1

    In the above example the table contains two entries which does match

    on erif port and forwards the packet or drop it (currently only the

    forward count is implemented). The counter values are provided for

    example. In case the counting is not enabled on the table the counters

    will not be available.

    Signed-off-by: Arkadi Sharshevsky <arkadis@mellanox.com>

    Signed-off-by: Jiri Pirko <jiri@mellanox.com>

Signed-off-by: Kamal Heib <kheib@redhat.com>

---

 devlink/devlink.c | 1353 +++++++++++++++++++++++++++++++++++++++++++++++++----

 1 file changed, 1254 insertions(+), 99 deletions(-)

diff --git a/devlink/devlink.c b/devlink/devlink.c

index 35220d8..e22ee0a 100644

--- a/devlink/devlink.c

+++ b/devlink/devlink.c

@@ -34,7 +34,15 @@

 #define ESWITCH_INLINE_MODE_TRANSPORT "transport"

 #define pr_err(args...) fprintf(stderr, ##args)

-#define pr_out(args...) fprintf(stdout, ##args)

+#define pr_out(args...)						\

+	do {							\

+		if (g_indent_newline) {				\

+			fprintf(stdout, "%s", g_indent_str);	\

+			g_indent_newline = false;		\

+		}						\

+		fprintf(stdout, ##args);			\

+	} while (0)

+

 #define pr_out_sp(num, args...)					\

 	do {							\

 		int ret = fprintf(stdout, ##args);		\

@@ -42,6 +50,35 @@

 			fprintf(stdout, "%*s", num - ret, "");	\

 	} while (0)

+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 __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)

+{

+	pr_out("\n");

+	g_indent_newline = true;

+}

+

 static int _mnlg_socket_recv_run(struct mnlg_socket *nlg,

 				 mnl_cb_t data_cb, void *data)

 {

@@ -137,6 +174,8 @@ static void ifname_map_free(struct ifname_map *ifname_map)

 #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)

 struct dl_opts {

 	uint32_t present; /* flags of present items */

@@ -154,6 +193,8 @@ struct dl_opts {

 	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_enable;

 };

 struct dl {

@@ -166,6 +207,7 @@ struct dl {

 	json_writer_t *jw;

 	bool json_output;

 	bool pretty_output;

+	bool verbose;

 	struct {

 		bool present;

 		char *bus_name;

@@ -257,6 +299,38 @@ static const enum mnl_attr_data_type devlink_policy[DEVLINK_ATTR_MAX + 1] = {

 	[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_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,

 };

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

@@ -666,6 +740,20 @@ static int eswitch_inline_mode_get(const char *typestr,

 	return 0;

 }

+static int dpipe_counters_enable_get(const char *typestr,

+				     bool *counters_enable)

+{

+	if (strcmp(typestr, "enable") == 0) {

+		*counters_enable = 1;

+	} else if (strcmp(typestr, "disable") == 0) {

+		*counters_enable = 0;

+	} else {

+		pr_err("Unknown counter_state \"%s\"\n", typestr);

+		return -EINVAL;

+	}

+	return 0;

+}

+

 static int dl_argv_parse(struct dl *dl, uint32_t o_required,

 			 uint32_t o_optional)

 {

@@ -800,6 +888,27 @@ static int dl_argv_parse(struct dl *dl, uint32_t o_required,

 			if (err)

 				return err;

 			o_found |= DL_OPT_ESWITCH_INLINE_MODE;

+		} else if (dl_argv_match(dl, "name") &&

+			   (o_all & DL_OPT_DPIPE_TABLE_NAME)) {

+			dl_arg_inc(dl);

+			err = dl_argv_str(dl, &opts->dpipe_table_name);

+			if (err)

+				return err;

+			o_found |= DL_OPT_DPIPE_TABLE_NAME;

+		} else if (dl_argv_match(dl, "counters") &&

+			   (o_all & DL_OPT_DPIPE_TABLE_COUNTERS)) {

+			const char *typestr;

+

+			dl_arg_inc(dl);

+			err = dl_argv_str(dl, &typestr);

+			if (err)

+				return err;

+			err = dpipe_counters_enable_get(typestr,

+							&opts->dpipe_counters_enable);

+			if (err)

+				return err;

+			o_found |= DL_OPT_DPIPE_TABLE_COUNTERS;

+

 		} else {

 			pr_err("Unknown option \"%s\"\n", dl_argv(dl));

 			return -EINVAL;

@@ -866,6 +975,17 @@ static int dl_argv_parse(struct dl *dl, uint32_t o_required,

 		return -EINVAL;

 	}

+	if ((o_required & DL_OPT_DPIPE_TABLE_NAME) &&

+	    !(o_found & DL_OPT_DPIPE_TABLE_NAME)) {

+		pr_err("Dpipe table name expected\n");

+		return -EINVAL;

+	}

+

+	if ((o_required & DL_OPT_DPIPE_TABLE_COUNTERS) &&

+	    !(o_found & DL_OPT_DPIPE_TABLE_COUNTERS)) {

+		pr_err("Dpipe table counter state expected\n");

+		return -EINVAL;

+	}

 	return 0;

 }

@@ -915,6 +1035,12 @@ static void dl_opts_put(struct nlmsghdr *nlh, struct dl *dl)

 	if (opts->present & DL_OPT_ESWITCH_INLINE_MODE)

 		mnl_attr_put_u8(nlh, DEVLINK_ATTR_ESWITCH_INLINE_MODE,

 				opts->eswitch_inline_mode);

+	if (opts->present & DL_OPT_DPIPE_TABLE_NAME)

+		mnl_attr_put_strz(nlh, DEVLINK_ATTR_DPIPE_TABLE_NAME,

+				  opts->dpipe_table_name);

+	if (opts->present & DL_OPT_DPIPE_TABLE_COUNTERS)

+		mnl_attr_put_u8(nlh, DEVLINK_ATTR_DPIPE_TABLE_COUNTERS_ENABLED,

+				opts->dpipe_counters_enable);

 }

 static int dl_argv_parse_put(struct nlmsghdr *nlh, struct dl *dl,

@@ -1033,7 +1159,19 @@ static void __pr_out_handle_start(struct dl *dl, struct nlattr **tb,

 			jsonw_start_object(dl->jw);

 		}

 	} else {

-		pr_out("%s%s", buf, content ? ":" : "");

+		if (array) {

+			if (should_arr_last_handle_end(dl, bus_name, dev_name))

+				__pr_out_indent_dec();

+			if (should_arr_last_handle_start(dl, bus_name,

+							 dev_name)) {

+				pr_out("%s%s", buf, content ? ":" : "");

+				__pr_out_newline();

+				__pr_out_indent_inc();

+				arr_last_handle_set(dl, bus_name, dev_name);

+			}

+		} else {

+			pr_out("%s%s", buf, content ? ":" : "");

+		}

 	}

 }

@@ -1047,7 +1185,7 @@ static void pr_out_handle_end(struct dl *dl)

 	if (dl->json_output)

 		jsonw_end_object(dl->jw);

 	else

-		pr_out("\n");

+		__pr_out_newline();

 }

 static void pr_out_handle(struct dl *dl, struct nlattr **tb)

@@ -1163,18 +1301,26 @@ static void pr_out_port_handle_end(struct dl *dl)

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

 {

-	if (dl->json_output)

+	if (dl->json_output) {

 		jsonw_string_field(dl->jw, name, val);

-	else

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

+	} else {

+		if (g_indent_newline)

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

+		else

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

+	}

 }

 static void pr_out_uint(struct dl *dl, const char *name, unsigned int val)

 {

-	if (dl->json_output)

+	if (dl->json_output) {

 		jsonw_uint_field(dl->jw, name, val);

-	else

-		pr_out(" %s %u", name, val);

+	} else {

+		if (g_indent_newline)

+			pr_out("%s %u", name, val);

+		else

+			pr_out(" %s %u", name, val);

+	}

 }

 static void pr_out_dev(struct dl *dl, struct nlattr **tb)

@@ -1201,6 +1347,42 @@ static void pr_out_section_end(struct dl *dl)

 	}

 }

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

+{

+	if (dl->json_output) {

+		jsonw_name(dl->jw, name);

+		jsonw_start_array(dl->jw);

+	} else {

+		if (!g_indent_newline)

+			__pr_out_newline();

+		pr_out("%s:", name);

+		__pr_out_newline();

+		__pr_out_indent_inc();

+	}

+}

+

+static void pr_out_array_end(struct dl *dl)

+{

+	if (dl->json_output)

+		jsonw_end_array(dl->jw);

+	else

+		__pr_out_indent_dec();

+}

+

+static void pr_out_entry_start(struct dl *dl)

+{

+	if (dl->json_output)

+		jsonw_start_object(dl->jw);

+}

+

+static void pr_out_entry_end(struct dl *dl)

+{

+	if (dl->json_output)

+		jsonw_end_object(dl->jw);

+	else

+		__pr_out_newline();

+}

+

 static const char *eswitch_mode_name(uint32_t mode)

 {

 	switch (mode) {

@@ -2423,129 +2605,1102 @@ static int cmd_mon(struct dl *dl)

 	return -ENOENT;

 }

-static void help(void)

+struct dpipe_field {

+	char *name;

+	unsigned int id;

+	unsigned int bitwidth;

+	enum devlink_dpipe_field_mapping_type mapping_type;

+};

+

+struct dpipe_header {

+	struct list_head list;

+	char *name;

+	unsigned int id;

+	struct dpipe_field *fields;

+	unsigned int fields_count;

+};

+

+struct dpipe_ctx {

+	struct dl *dl;

+	int err;

+	struct list_head global_headers;

+	struct list_head local_headers;

+	bool print_headers;

+};

+

+static struct dpipe_header *dpipe_header_alloc(unsigned int fields_count)

 {

-	pr_err("Usage: devlink [ OPTIONS ] OBJECT { COMMAND | help }\n"

-	       "where  OBJECT := { dev | port | sb | monitor }\n"

-	       "       OPTIONS := { -V[ersion] | -n[no-nice-names] | -j[json] | -p[pretty] }\n");

+	struct dpipe_header *header;

+

+	header = calloc(1, sizeof(struct dpipe_header));

+	if (!header)

+		return NULL;

+	header->fields = calloc(fields_count, sizeof(struct dpipe_field));

+	if (!header->fields)

+		goto err_fields_alloc;

+	header->fields_count = fields_count;

+	return header;

+

+err_fields_alloc:

+	free(header);

+	return NULL;

 }

-static int dl_cmd(struct dl *dl)

+static void dpipe_header_free(struct dpipe_header *header)

 {

-	if (dl_argv_match(dl, "help") || dl_no_arg(dl)) {

-		help();

-		return 0;

-	} else if (dl_argv_match(dl, "dev")) {

-		dl_arg_inc(dl);

-		return cmd_dev(dl);

-	} else if (dl_argv_match(dl, "port")) {

-		dl_arg_inc(dl);

-		return cmd_port(dl);

-	} else if (dl_argv_match(dl, "sb")) {

-		dl_arg_inc(dl);

-		return cmd_sb(dl);

-	} else if (dl_argv_match(dl, "monitor")) {

-		dl_arg_inc(dl);

-		return cmd_mon(dl);

+	free(header->fields);

+	free(header);

+}

+

+static void dpipe_header_clear(struct dpipe_header *header)

+{

+	struct dpipe_field *field;

+	int i;

+

+	for (i = 0; i < header->fields_count; i++) {

+		field = &header->fields[i];

+		free(field->name);

 	}

-	pr_err("Object \"%s\" not found\n", dl_argv(dl));

-	return -ENOENT;

+	free(header->name);

 }

-static int dl_init(struct dl *dl, int argc, char **argv)

+static void dpipe_header_add(struct dpipe_ctx *ctx,

+			     struct dpipe_header *header, bool global)

 {

-	int err;

+	if (global)

+		list_add(&header->list, &ctx->global_headers);

+	else

+		list_add(&header->list, &ctx->local_headers);

+}

-	dl->argc = argc;

-	dl->argv = argv;

+static void dpipe_header_del(struct dpipe_header *header)

+{

+	list_del(&header->list);

+}

-	dl->nlg = mnlg_socket_open(DEVLINK_GENL_NAME, DEVLINK_GENL_VERSION);

-	if (!dl->nlg) {

-		pr_err("Failed to connect to devlink Netlink\n");

-		return -errno;

+static struct dpipe_ctx *dpipe_ctx_alloc(struct dl *dl)

+{

+	struct dpipe_ctx *ctx;

+

+	ctx = calloc(1, sizeof(struct dpipe_ctx));

+	if (!ctx)

+		return NULL;

+	ctx->dl = dl;

+	INIT_LIST_HEAD(&ctx->global_headers);

+	INIT_LIST_HEAD(&ctx->local_headers);

+	return ctx;

+}

+

+static void dpipe_ctx_free(struct dpipe_ctx *ctx)

+{

+	free(ctx);

+}

+

+static void dpipe_ctx_clear(struct dpipe_ctx *ctx)

+{

+	struct dpipe_header *header, *tmp;

+

+	list_for_each_entry_safe(header, tmp, &ctx->global_headers,

+				 list) {

+		dpipe_header_del(header);

+		dpipe_header_clear(header);

+		dpipe_header_free(header);

+	}

+	list_for_each_entry_safe(header, tmp, &ctx->local_headers,

+				 list) {

+		dpipe_header_del(header);

+		dpipe_header_clear(header);

+		dpipe_header_free(header);

 	}

+}

-	err = ifname_map_init(dl);

-	if (err) {

-		pr_err("Failed to create index map\n");

-		goto err_ifname_map_create;

+static const char *dpipe_header_id2s(struct dpipe_ctx *ctx,

+				     uint32_t header_id, bool global)

+{

+	struct list_head *header_list;

+	struct dpipe_header *header;

+

+	if (global)

+		header_list = &ctx->global_headers;

+	else

+		header_list = &ctx->local_headers;

+	list_for_each_entry(header, header_list, list) {

+		if (header->id != header_id)

+			continue;

+		return header->name;

 	}

-	if (dl->json_output) {

-		dl->jw = jsonw_new(stdout);

-		if (!dl->jw) {

-			pr_err("Failed to create JSON writer\n");

-			goto err_json_new;

-		}

-		jsonw_pretty(dl->jw, dl->pretty_output);

+	return NULL;

+}

+

+static const char *dpipe_field_id2s(struct dpipe_ctx *ctx,

+				    uint32_t header_id,

+				    uint32_t field_id, bool global)

+{

+	struct list_head *header_list;

+	struct dpipe_header *header;

+

+	if (global)

+		header_list = &ctx->global_headers;

+	else

+		header_list = &ctx->local_headers;

+	list_for_each_entry(header, header_list, list) {

+		if (header->id != header_id)

+			continue;

+		return header->fields[field_id].name;

 	}

-	return 0;

+	return NULL;

+}

-err_json_new:

-	ifname_map_fini(dl);

-err_ifname_map_create:

-	mnlg_socket_close(dl->nlg);

-	return err;

+static const char *

+dpipe_field_mapping_e2s(enum devlink_dpipe_field_mapping_type mapping_type)

+{

+	switch (mapping_type) {

+	case DEVLINK_DPIPE_FIELD_MAPPING_TYPE_NONE:

+		return NULL;

+	case DEVLINK_DPIPE_FIELD_MAPPING_TYPE_IFINDEX:

+		return "ifindex";

+	default:

+		return "<unknown>";

+	}

 }

-static void dl_fini(struct dl *dl)

+static const char *

+dpipe_mapping_get(struct dpipe_ctx *ctx, uint32_t header_id,

+		  uint32_t field_id, bool global)

 {

-	if (dl->json_output)

-		jsonw_destroy(&dl->jw);

-	ifname_map_fini(dl);

-	mnlg_socket_close(dl->nlg);

+	enum devlink_dpipe_field_mapping_type mapping_type;

+	struct list_head *header_list;

+	struct dpipe_header *header;

+

+	if (global)

+		header_list = &ctx->global_headers;

+	else

+		header_list = &ctx->local_headers;

+	list_for_each_entry(header, header_list, list) {

+		if (header->id != header_id)

+			continue;

+		mapping_type = header->fields[field_id].mapping_type;

+		return dpipe_field_mapping_e2s(mapping_type);

+	}

+	return NULL;

 }

-static struct dl *dl_alloc(void)

+static void pr_out_dpipe_fields(struct dpipe_ctx *ctx,

+				struct dpipe_field *fields,

+				unsigned int field_count)

 {

-	struct dl *dl;

+	struct dpipe_field *field;

+	int i;

-	dl = calloc(1, sizeof(*dl));

-	if (!dl)

-		return NULL;

-	return dl;

+	for (i = 0; i < field_count; i++) {

+		field = &fields[i];

+		pr_out_entry_start(ctx->dl);

+		pr_out_str(ctx->dl, "name", field->name);

+		if (ctx->dl->verbose)

+			pr_out_uint(ctx->dl, "id", field->id);

+		pr_out_uint(ctx->dl, "bitwidth", field->bitwidth);

+		if (field->mapping_type)

+			pr_out_str(ctx->dl, "mapping_type",

+				   dpipe_field_mapping_e2s(field->mapping_type));

+		pr_out_entry_end(ctx->dl);

+	}

 }

-static void dl_free(struct dl *dl)

+static void

+pr_out_dpipe_header(struct dpipe_ctx *ctx, struct nlattr **tb,

+		    struct dpipe_header *header, bool global)

 {

-	free(dl);

+	pr_out_handle_start_arr(ctx->dl, tb);

+	pr_out_str(ctx->dl, "name", header->name);

+	if (ctx->dl->verbose) {

+		pr_out_uint(ctx->dl, "id", header->id);

+		pr_out_str(ctx->dl, "global",

+			   global ? "true" : "false");

+	}

+	pr_out_array_start(ctx->dl, "field");

+	pr_out_dpipe_fields(ctx, header->fields,

+			    header->fields_count);

+	pr_out_array_end(ctx->dl);

+	pr_out_handle_end(ctx->dl);

 }

-int main(int argc, char **argv)

+static void pr_out_dpipe_headers(struct dpipe_ctx *ctx,

+				 struct nlattr **tb)

 {

-	static const struct option long_options[] = {

-		{ "Version",		no_argument,		NULL, 'V' },

-		{ "no-nice-names",	no_argument,		NULL, 'n' },

-		{ "json",		no_argument,		NULL, 'j' },

-		{ "pretty",		no_argument,		NULL, 'p' },

-		{ NULL, 0, NULL, 0 }

-	};

-	struct dl *dl;

-	int opt;

+	struct dpipe_header *header;

+

+	list_for_each_entry(header, &ctx->local_headers, list)

+		pr_out_dpipe_header(ctx, tb, header, false);

+

+	list_for_each_entry(header, &ctx->global_headers, list)

+		pr_out_dpipe_header(ctx, tb, header, true);

+}

+

+static int dpipe_header_field_get(struct nlattr *nl, struct dpipe_field *field)

+{

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

+	const char *name;

 	int err;

-	int ret;

-	dl = dl_alloc();

-	if (!dl) {

-		pr_err("Failed to allocate memory for devlink\n");

-		return EXIT_FAILURE;

+	err = mnl_attr_parse_nested(nl, attr_cb, nla_field);

+	if (err != MNL_CB_OK)