[ceph.git] / ceph / src / spdk / dpdk / test / test / test_table_acl.c

/* SPDX-License-Identifier: BSD-3-Clause
 * Copyright(c) 2010-2014 Intel Corporation
 */

#include <rte_hexdump.h>
#include "test_table.h"
#include "test_table_acl.h"

#define IPv4(a, b, c, d) ((uint32_t)(((a) & 0xff) << 24) |		\
	(((b) & 0xff) << 16) |						\
	(((c) & 0xff) << 8) |						\
	((d) & 0xff))

/*
 * Rule and trace formats definitions.
 **/

struct ipv4_5tuple {
	uint8_t  proto;
	uint32_t ip_src;
	uint32_t ip_dst;
	uint16_t port_src;
	uint16_t port_dst;
};

enum {
	PROTO_FIELD_IPV4,
	SRC_FIELD_IPV4,
	DST_FIELD_IPV4,
	SRCP_FIELD_IPV4,
	DSTP_FIELD_IPV4,
	NUM_FIELDS_IPV4
};

struct rte_acl_field_def ipv4_defs[NUM_FIELDS_IPV4] = {
	{
		.type = RTE_ACL_FIELD_TYPE_BITMASK,
		.size = sizeof(uint8_t),
		.field_index = PROTO_FIELD_IPV4,
		.input_index = PROTO_FIELD_IPV4,
		.offset = offsetof(struct ipv4_5tuple, proto),
	},
	{
		.type = RTE_ACL_FIELD_TYPE_MASK,
		.size = sizeof(uint32_t),
		.field_index = SRC_FIELD_IPV4,
		.input_index = SRC_FIELD_IPV4,
		.offset = offsetof(struct ipv4_5tuple, ip_src),
	},
	{
		.type = RTE_ACL_FIELD_TYPE_MASK,
		.size = sizeof(uint32_t),
		.field_index = DST_FIELD_IPV4,
		.input_index = DST_FIELD_IPV4,
		.offset = offsetof(struct ipv4_5tuple, ip_dst),
	},
	{
		.type = RTE_ACL_FIELD_TYPE_RANGE,
		.size = sizeof(uint16_t),
		.field_index = SRCP_FIELD_IPV4,
		.input_index = SRCP_FIELD_IPV4,
		.offset = offsetof(struct ipv4_5tuple, port_src),
	},
	{
		.type = RTE_ACL_FIELD_TYPE_RANGE,
		.size = sizeof(uint16_t),
		.field_index = DSTP_FIELD_IPV4,
		.input_index = SRCP_FIELD_IPV4,
		.offset = offsetof(struct ipv4_5tuple, port_dst),
	},
};

struct rte_table_acl_rule_add_params table_acl_IPv4_rule;

typedef int (*parse_5tuple)(char *text,
	struct rte_table_acl_rule_add_params *rule);

/*
* The order of the fields in the rule string after the initial '@'
*/
enum {
	CB_FLD_SRC_ADDR,
	CB_FLD_DST_ADDR,
	CB_FLD_SRC_PORT_RANGE,
	CB_FLD_DST_PORT_RANGE,
	CB_FLD_PROTO,
	CB_FLD_NUM,
};


#define GET_CB_FIELD(in, fd, base, lim, dlm)				\
do {									\
	unsigned long val;						\
	char *end;							\
									\
	errno = 0;							\
	val = strtoul((in), &end, (base));				\
	if (errno != 0 || end[0] != (dlm) || val > (lim))		\
		return -EINVAL;						\
	(fd) = (typeof(fd)) val;					\
	(in) = end + 1;							\
} while (0)


static int
parse_ipv4_net(const char *in, uint32_t *addr, uint32_t *mask_len)
{
	uint8_t a, b, c, d, m;

	GET_CB_FIELD(in, a, 0, UINT8_MAX, '.');
	GET_CB_FIELD(in, b, 0, UINT8_MAX, '.');
	GET_CB_FIELD(in, c, 0, UINT8_MAX, '.');
	GET_CB_FIELD(in, d, 0, UINT8_MAX, '/');
	GET_CB_FIELD(in, m, 0, sizeof(uint32_t) * CHAR_BIT, 0);

	addr[0] = IPv4(a, b, c, d);
	mask_len[0] = m;

	return 0;
}

static int
parse_port_range(const char *in, uint16_t *port_low, uint16_t *port_high)
{
	uint16_t a, b;

	GET_CB_FIELD(in, a, 0, UINT16_MAX, ':');
	GET_CB_FIELD(in, b, 0, UINT16_MAX, 0);

	port_low[0] = a;
	port_high[0] = b;

	return 0;
}

static int
parse_cb_ipv4_rule(char *str, struct rte_table_acl_rule_add_params *v)
{
	int i, rc;
	char *s, *sp, *in[CB_FLD_NUM];
	static const char *dlm = " \t\n";

	/*
	** Skip leading '@'
	*/
	if (strchr(str, '@') != str)
		return -EINVAL;

	s = str + 1;

	/*
	* Populate the 'in' array with the location of each
	* field in the string we're parsing
	*/
	for (i = 0; i != DIM(in); i++) {
		in[i] = strtok_r(s, dlm, &sp);
		if (in[i] == NULL)
			return -EINVAL;
		s = NULL;
	}

	/* Parse x.x.x.x/x */
	rc = parse_ipv4_net(in[CB_FLD_SRC_ADDR],
		&v->field_value[SRC_FIELD_IPV4].value.u32,
		&v->field_value[SRC_FIELD_IPV4].mask_range.u32);
	if (rc != 0) {
		RTE_LOG(ERR, PIPELINE, "failed to read src address/mask: %s\n",
			in[CB_FLD_SRC_ADDR]);
		return rc;
	}

	printf("V=%u, mask=%u\n", v->field_value[SRC_FIELD_IPV4].value.u32,
		v->field_value[SRC_FIELD_IPV4].mask_range.u32);

	/* Parse x.x.x.x/x */
	rc = parse_ipv4_net(in[CB_FLD_DST_ADDR],
		&v->field_value[DST_FIELD_IPV4].value.u32,
		&v->field_value[DST_FIELD_IPV4].mask_range.u32);
	if (rc != 0) {
		RTE_LOG(ERR, PIPELINE, "failed to read dest address/mask: %s\n",
			in[CB_FLD_DST_ADDR]);
		return rc;
	}

	printf("V=%u, mask=%u\n", v->field_value[DST_FIELD_IPV4].value.u32,
	v->field_value[DST_FIELD_IPV4].mask_range.u32);
	/* Parse n:n */
	rc = parse_port_range(in[CB_FLD_SRC_PORT_RANGE],
		&v->field_value[SRCP_FIELD_IPV4].value.u16,
		&v->field_value[SRCP_FIELD_IPV4].mask_range.u16);
	if (rc != 0) {
		RTE_LOG(ERR, PIPELINE, "failed to read source port range: %s\n",
			in[CB_FLD_SRC_PORT_RANGE]);
		return rc;
	}

	printf("V=%u, mask=%u\n", v->field_value[SRCP_FIELD_IPV4].value.u16,
		v->field_value[SRCP_FIELD_IPV4].mask_range.u16);
	/* Parse n:n */
	rc = parse_port_range(in[CB_FLD_DST_PORT_RANGE],
		&v->field_value[DSTP_FIELD_IPV4].value.u16,
		&v->field_value[DSTP_FIELD_IPV4].mask_range.u16);
	if (rc != 0) {
		RTE_LOG(ERR, PIPELINE, "failed to read dest port range: %s\n",
			in[CB_FLD_DST_PORT_RANGE]);
		return rc;
	}

	printf("V=%u, mask=%u\n", v->field_value[DSTP_FIELD_IPV4].value.u16,
		v->field_value[DSTP_FIELD_IPV4].mask_range.u16);
	/* parse 0/0xnn */
	GET_CB_FIELD(in[CB_FLD_PROTO],
		v->field_value[PROTO_FIELD_IPV4].value.u8,
		0, UINT8_MAX, '/');
	GET_CB_FIELD(in[CB_FLD_PROTO],
		v->field_value[PROTO_FIELD_IPV4].mask_range.u8,
		0, UINT8_MAX, 0);

	printf("V=%u, mask=%u\n",
		(unsigned int)v->field_value[PROTO_FIELD_IPV4].value.u8,
		v->field_value[PROTO_FIELD_IPV4].mask_range.u8);
	return 0;
}

static int
parse_cb_ipv4_rule_del(char *str, struct rte_table_acl_rule_delete_params *v)
{
	int i, rc;
	char *s, *sp, *in[CB_FLD_NUM];
	static const char *dlm = " \t\n";

	/*
	** Skip leading '@'
	*/
	if (strchr(str, '@') != str)
		return -EINVAL;

	s = str + 1;

	/*
	* Populate the 'in' array with the location of each
	* field in the string we're parsing
	*/
	for (i = 0; i != DIM(in); i++) {
		in[i] = strtok_r(s, dlm, &sp);
		if (in[i] == NULL)
			return -EINVAL;
		s = NULL;
	}

	/* Parse x.x.x.x/x */
	rc = parse_ipv4_net(in[CB_FLD_SRC_ADDR],
		&v->field_value[SRC_FIELD_IPV4].value.u32,
		&v->field_value[SRC_FIELD_IPV4].mask_range.u32);
	if (rc != 0) {
		RTE_LOG(ERR, PIPELINE, "failed to read src address/mask: %s\n",
			in[CB_FLD_SRC_ADDR]);
		return rc;
	}

	printf("V=%u, mask=%u\n", v->field_value[SRC_FIELD_IPV4].value.u32,
		v->field_value[SRC_FIELD_IPV4].mask_range.u32);

	/* Parse x.x.x.x/x */
	rc = parse_ipv4_net(in[CB_FLD_DST_ADDR],
		&v->field_value[DST_FIELD_IPV4].value.u32,
		&v->field_value[DST_FIELD_IPV4].mask_range.u32);
	if (rc != 0) {
		RTE_LOG(ERR, PIPELINE, "failed to read dest address/mask: %s\n",
			in[CB_FLD_DST_ADDR]);
		return rc;
	}

	printf("V=%u, mask=%u\n", v->field_value[DST_FIELD_IPV4].value.u32,
	v->field_value[DST_FIELD_IPV4].mask_range.u32);
	/* Parse n:n */
	rc = parse_port_range(in[CB_FLD_SRC_PORT_RANGE],
		&v->field_value[SRCP_FIELD_IPV4].value.u16,
		&v->field_value[SRCP_FIELD_IPV4].mask_range.u16);
	if (rc != 0) {
		RTE_LOG(ERR, PIPELINE, "failed to read source port range: %s\n",
			in[CB_FLD_SRC_PORT_RANGE]);
		return rc;
	}

	printf("V=%u, mask=%u\n", v->field_value[SRCP_FIELD_IPV4].value.u16,
		v->field_value[SRCP_FIELD_IPV4].mask_range.u16);
	/* Parse n:n */
	rc = parse_port_range(in[CB_FLD_DST_PORT_RANGE],
		&v->field_value[DSTP_FIELD_IPV4].value.u16,
		&v->field_value[DSTP_FIELD_IPV4].mask_range.u16);
	if (rc != 0) {
		RTE_LOG(ERR, PIPELINE, "failed to read dest port range: %s\n",
			in[CB_FLD_DST_PORT_RANGE]);
		return rc;
	}

	printf("V=%u, mask=%u\n", v->field_value[DSTP_FIELD_IPV4].value.u16,
		v->field_value[DSTP_FIELD_IPV4].mask_range.u16);
	/* parse 0/0xnn */
	GET_CB_FIELD(in[CB_FLD_PROTO],
		v->field_value[PROTO_FIELD_IPV4].value.u8,
		0, UINT8_MAX, '/');
	GET_CB_FIELD(in[CB_FLD_PROTO],
		v->field_value[PROTO_FIELD_IPV4].mask_range.u8,
		0, UINT8_MAX, 0);

	printf("V=%u, mask=%u\n",
		(unsigned int)v->field_value[PROTO_FIELD_IPV4].value.u8,
		v->field_value[PROTO_FIELD_IPV4].mask_range.u8);
	return 0;
}

/*
 * The format for these rules DO NOT need the port ranges to be
 * separated by ' : ', just ':'. It's a lot more readable and
 * cleaner, IMO.
 */
char lines[][128] = {
	"@0.0.0.0/0 0.0.0.0/0 0:65535 0:65535 2/0xff", /* Protocol check */
	"@192.168.3.1/32 0.0.0.0/0 0:65535 0:65535 0/0", /* Src IP checl */
	"@0.0.0.0/0 10.4.4.1/32 0:65535 0:65535 0/0", /* dst IP check */
	"@0.0.0.0/0 0.0.0.0/0 105:105 0:65535 0/0", /* src port check */
	"@0.0.0.0/0 0.0.0.0/0 0:65535 206:206 0/0", /* dst port check */
};

char line[128];


static int
setup_acl_pipeline(void)
{
	int ret;
	int i;
	struct rte_pipeline_params pipeline_params = {
		.name = "PIPELINE",
		.socket_id = 0,
	};
	uint32_t n;
	struct rte_table_acl_rule_add_params rule_params;
	struct rte_pipeline_table_acl_rule_delete_params *delete_params;
	parse_5tuple parser;
	char acl_name[64];

	/* Pipeline configuration */
	p = rte_pipeline_create(&pipeline_params);
	if (p == NULL) {
		RTE_LOG(INFO, PIPELINE, "%s: Failed to configure pipeline\n",
			__func__);
		goto fail;
	}

	/* Input port configuration */
	for (i = 0; i < N_PORTS; i++) {
		struct rte_port_ring_reader_params port_ring_params = {
			.ring = rings_rx[i],
		};

		struct rte_pipeline_port_in_params port_params = {
			.ops = &rte_port_ring_reader_ops,
			.arg_create = (void *) &port_ring_params,
			.f_action = NULL,
			.burst_size = BURST_SIZE,
		};

		/* Put in action for some ports */
		if (i)
			port_params.f_action = port_in_action;

		ret = rte_pipeline_port_in_create(p, &port_params,
			&port_in_id[i]);
		if (ret) {
			rte_panic("Unable to configure input port %d, ret:%d\n",
				i, ret);
			goto fail;
		}
	}

	/* output Port configuration */
	for (i = 0; i < N_PORTS; i++) {
		struct rte_port_ring_writer_params port_ring_params = {
			.ring = rings_tx[i],
			.tx_burst_sz = BURST_SIZE,
		};

		struct rte_pipeline_port_out_params port_params = {
			.ops = &rte_port_ring_writer_ops,
			.arg_create = (void *) &port_ring_params,
			.f_action = NULL,
			.arg_ah = NULL,
		};


		if (rte_pipeline_port_out_create(p, &port_params,
			&port_out_id[i])) {
			rte_panic("Unable to configure output port %d\n", i);
			goto fail;
		}
	}

	/* Table configuration  */
	for (i = 0; i < N_PORTS; i++) {
		struct rte_pipeline_table_params table_params;

		/* Set up defaults for stub */
		table_params.ops = &rte_table_stub_ops;
		table_params.arg_create = NULL;
		table_params.f_action_hit = action_handler_hit;
		table_params.f_action_miss = NULL;
		table_params.action_data_size = 0;

		RTE_LOG(INFO, PIPELINE, "miss_action=%x\n",
			table_entry_miss_action);

		printf("RTE_ACL_RULE_SZ(%zu) = %zu\n", DIM(ipv4_defs),
			RTE_ACL_RULE_SZ(DIM(ipv4_defs)));

		struct rte_table_acl_params acl_params;

		acl_params.n_rules = 1 << 5;
		acl_params.n_rule_fields = DIM(ipv4_defs);
		snprintf(acl_name, sizeof(acl_name), "ACL%d", i);
		acl_params.name = acl_name;
		memcpy(acl_params.field_format, ipv4_defs, sizeof(ipv4_defs));

		table_params.ops = &rte_table_acl_ops;
		table_params.arg_create = &acl_params;

		if (rte_pipeline_table_create(p, &table_params, &table_id[i])) {
			rte_panic("Unable to configure table %u\n", i);
			goto fail;
		}

		if (connect_miss_action_to_table) {
			if (rte_pipeline_table_create(p, &table_params,
				&table_id[i+2])) {
				rte_panic("Unable to configure table %u\n", i);
				goto fail;
			}
		}
	}

	for (i = 0; i < N_PORTS; i++) {
		if (rte_pipeline_port_in_connect_to_table(p, port_in_id[i],
			table_id[i])) {
			rte_panic("Unable to connect input port %u to "
				"table %u\n",
				port_in_id[i],  table_id[i]);
			goto fail;
		}
	}

	/* Add bulk entries to tables */
	for (i = 0; i < N_PORTS; i++) {
		struct rte_table_acl_rule_add_params keys[5];
		struct rte_pipeline_table_entry entries[5];
		struct rte_table_acl_rule_add_params *key_array[5];
		struct rte_pipeline_table_entry *table_entries[5];
		int key_found[5];
		struct rte_pipeline_table_entry *table_entries_ptr[5];
		struct rte_pipeline_table_entry entries_ptr[5];

		parser = parse_cb_ipv4_rule;
		for (n = 0; n < 5; n++) {
			memset(&keys[n], 0, sizeof(struct rte_table_acl_rule_add_params));
			key_array[n] = &keys[n];

			snprintf(line, sizeof(line), "%s", lines[n]);
			printf("PARSING [%s]\n", line);

			ret = parser(line, &keys[n]);
			if (ret != 0) {
				RTE_LOG(ERR, PIPELINE,
					"line %u: parse_cb_ipv4vlan_rule"
					" failed, error code: %d (%s)\n",
					n, ret, strerror(-ret));
				return ret;
			}

			keys[n].priority = RTE_ACL_MAX_PRIORITY - n - 1;

			entries[n].action = RTE_PIPELINE_ACTION_PORT;
			entries[n].port_id = port_out_id[i^1];
			table_entries[n] = &entries[n];
			table_entries_ptr[n] = &entries_ptr[n];
		}

		ret = rte_pipeline_table_entry_add_bulk(p, table_id[i],
				(void **)key_array, table_entries, 5, key_found, table_entries_ptr);
		if (ret < 0) {
			rte_panic("Add entry bulk to table %u failed (%d)\n",
				table_id[i], ret);
			goto fail;
		}
	}

	/* Delete bulk entries from tables */
	for (i = 0; i < N_PORTS; i++) {
		struct rte_table_acl_rule_delete_params keys[5];
		struct rte_table_acl_rule_delete_params *key_array[5];
		struct rte_pipeline_table_entry *table_entries[5];
		int key_found[5];

		memset(table_entries, 0, sizeof(table_entries));

		for (n = 0; n < 5; n++) {
			memset(&keys[n], 0, sizeof(struct rte_table_acl_rule_delete_params));
			key_array[n] = &keys[n];

			snprintf(line, sizeof(line), "%s", lines[n]);
			printf("PARSING [%s]\n", line);

			ret = parse_cb_ipv4_rule_del(line, &keys[n]);
			if (ret != 0) {
				RTE_LOG(ERR, PIPELINE,
					"line %u: parse_cb_ipv4vlan_rule"
					" failed, error code: %d (%s)\n",
					n, ret, strerror(-ret));
				return ret;
			}
		}

		ret = rte_pipeline_table_entry_delete_bulk(p, table_id[i],
			(void **)key_array, 5, key_found, table_entries);
		if (ret < 0) {
			rte_panic("Delete bulk entries from table %u failed (%d)\n",
				table_id[i], ret);
			goto fail;
		} else
			printf("Bulk deleted rules.\n");
	}

	/* Add entries to tables */
	for (i = 0; i < N_PORTS; i++) {
		struct rte_pipeline_table_entry table_entry = {
			.action = RTE_PIPELINE_ACTION_PORT,
			{.port_id = port_out_id[i^1]},
		};
		int key_found;
		struct rte_pipeline_table_entry *entry_ptr;

		memset(&rule_params, 0, sizeof(rule_params));
		parser = parse_cb_ipv4_rule;

		for (n = 1; n <= 5; n++) {
			snprintf(line, sizeof(line), "%s", lines[n-1]);
			printf("PARSING [%s]\n", line);

			ret = parser(line, &rule_params);
			if (ret != 0) {
				RTE_LOG(ERR, PIPELINE,
					"line %u: parse_cb_ipv4vlan_rule"
					" failed, error code: %d (%s)\n",
					n, ret, strerror(-ret));
				return ret;
			}

			rule_params.priority = RTE_ACL_MAX_PRIORITY - n;

			ret = rte_pipeline_table_entry_add(p, table_id[i],
				&rule_params,
				&table_entry, &key_found, &entry_ptr);
			if (ret < 0) {
				rte_panic("Add entry to table %u failed (%d)\n",
					table_id[i], ret);
				goto fail;
			}
		}

		/* delete a few rules */
		for (n = 2; n <= 3; n++) {
			snprintf(line, sizeof(line), "%s", lines[n-1]);
			printf("PARSING [%s]\n", line);

			ret = parser(line, &rule_params);
			if (ret != 0) {
				RTE_LOG(ERR, PIPELINE, "line %u: parse rule "
					" failed, error code: %d (%s)\n",
					n, ret, strerror(-ret));
				return ret;
			}

			delete_params = (struct
				rte_pipeline_table_acl_rule_delete_params *)
				&(rule_params.field_value[0]);
			ret = rte_pipeline_table_entry_delete(p, table_id[i],
				delete_params, &key_found, NULL);
			if (ret < 0) {
				rte_panic("Add entry to table %u failed (%d)\n",
					table_id[i], ret);
				goto fail;
			} else
				printf("Deleted Rule.\n");
		}


		/* Try to add duplicates */
		for (n = 1; n <= 5; n++) {
			snprintf(line, sizeof(line), "%s", lines[n-1]);
			printf("PARSING [%s]\n", line);

			ret = parser(line, &rule_params);
			if (ret != 0) {
				RTE_LOG(ERR, PIPELINE, "line %u: parse rule"
					" failed, error code: %d (%s)\n",
					n, ret, strerror(-ret));
				return ret;
			}

			rule_params.priority = RTE_ACL_MAX_PRIORITY - n;

			ret = rte_pipeline_table_entry_add(p, table_id[i],
				&rule_params,
				&table_entry, &key_found, &entry_ptr);
			if (ret < 0) {
				rte_panic("Add entry to table %u failed (%d)\n",
					table_id[i], ret);
				goto fail;
			}
		}
	}

	/* Enable input ports */
	for (i = 0; i < N_PORTS ; i++)
		if (rte_pipeline_port_in_enable(p, port_in_id[i]))
			rte_panic("Unable to enable input port %u\n",
				port_in_id[i]);

	/* Check pipeline consistency */
	if (rte_pipeline_check(p) < 0) {
		rte_panic("Pipeline consistency check failed\n");
		goto fail;
	}

	return  0;
fail:

	return -1;
}

static int
test_pipeline_single_filter(int expected_count)
{
	int i, j, ret, tx_count;
	struct ipv4_5tuple five_tuple;

	/* Allocate a few mbufs and manually insert into the rings. */
	for (i = 0; i < N_PORTS; i++) {
		for (j = 0; j < 8; j++) {
			struct rte_mbuf *mbuf;

			mbuf = rte_pktmbuf_alloc(pool);
			if (mbuf == NULL)
				/* this will cause test failure after cleanup
				 * of already enqueued mbufs, as the mbuf
				 * counts won't match */
				break;
			memset(rte_pktmbuf_mtod(mbuf, char *), 0x00,
				sizeof(struct ipv4_5tuple));

			five_tuple.proto = j;
			five_tuple.ip_src = rte_bswap32(IPv4(192, 168, j, 1));
			five_tuple.ip_dst = rte_bswap32(IPv4(10, 4, j, 1));
			five_tuple.port_src = rte_bswap16(100 + j);
			five_tuple.port_dst = rte_bswap16(200 + j);

			memcpy(rte_pktmbuf_mtod(mbuf, char *), &five_tuple,
				sizeof(struct ipv4_5tuple));
			RTE_LOG(INFO, PIPELINE, "%s: Enqueue onto ring %d\n",
				__func__, i);
			rte_ring_enqueue(rings_rx[i], mbuf);
		}
	}

	/* Run pipeline once */
	for (i = 0; i< N_PORTS; i++)
		rte_pipeline_run(p);

	rte_pipeline_flush(p);

	tx_count = 0;

	for (i = 0; i < N_PORTS; i++) {
		void *objs[RING_TX_SIZE];
		struct rte_mbuf *mbuf;

		ret = rte_ring_sc_dequeue_burst(rings_tx[i], objs, 10, NULL);
		if (ret <= 0) {
			printf("Got no objects from ring %d - error code %d\n",
				i, ret);
		} else {
			printf("Got %d object(s) from ring %d!\n", ret, i);
			for (j = 0; j < ret; j++) {
				mbuf = objs[j];
				rte_hexdump(stdout, "mbuf",
					rte_pktmbuf_mtod(mbuf, char *), 64);
				rte_pktmbuf_free(mbuf);
			}
			tx_count += ret;
		}
	}

	if (tx_count != expected_count) {
		RTE_LOG(INFO, PIPELINE,
			"%s: Unexpected packets for ACL test, "
			"expected %d, got %d\n",
			__func__, expected_count, tx_count);
		goto fail;
	}

	rte_pipeline_free(p);

	return  0;
fail:
	return -1;

}

int
test_table_acl(void)
{


	override_hit_mask = 0xFF; /* All packets are a hit */

	setup_acl_pipeline();
	if (test_pipeline_single_filter(10) < 0)
		return -1;

	return 0;
}
Commit	Line	Data
11fdf7f2 TL	1	/* SPDX-License-Identifier: BSD-3-Clause
11fdf7f2 TL	2	* Copyright(c) 2010-2014 Intel Corporation
7c673cae FG	3	*/
	4
	5	#include <rte_hexdump.h>
	6	#include "test_table.h"
	7	#include "test_table_acl.h"
	8
	9	#define IPv4(a, b, c, d) ((uint32_t)(((a) & 0xff) << 24) \| \
	10	(((b) & 0xff) << 16) \| \
	11	(((c) & 0xff) << 8) \| \
	12	((d) & 0xff))
	13
	14	/*
	15	* Rule and trace formats definitions.
	16	**/
	17
	18	struct ipv4_5tuple {
	19	uint8_t proto;
	20	uint32_t ip_src;
	21	uint32_t ip_dst;
	22	uint16_t port_src;
	23	uint16_t port_dst;
	24	};
	25
	26	enum {
	27	PROTO_FIELD_IPV4,
	28	SRC_FIELD_IPV4,
	29	DST_FIELD_IPV4,
	30	SRCP_FIELD_IPV4,
	31	DSTP_FIELD_IPV4,
	32	NUM_FIELDS_IPV4
	33	};
	34
	35	struct rte_acl_field_def ipv4_defs[NUM_FIELDS_IPV4] = {
	36	{
	37	.type = RTE_ACL_FIELD_TYPE_BITMASK,
	38	.size = sizeof(uint8_t),
	39	.field_index = PROTO_FIELD_IPV4,
	40	.input_index = PROTO_FIELD_IPV4,
	41	.offset = offsetof(struct ipv4_5tuple, proto),
	42	},
	43	{
	44	.type = RTE_ACL_FIELD_TYPE_MASK,
	45	.size = sizeof(uint32_t),
	46	.field_index = SRC_FIELD_IPV4,
	47	.input_index = SRC_FIELD_IPV4,
	48	.offset = offsetof(struct ipv4_5tuple, ip_src),
	49	},
	50	{
	51	.type = RTE_ACL_FIELD_TYPE_MASK,
	52	.size = sizeof(uint32_t),
	53	.field_index = DST_FIELD_IPV4,
	54	.input_index = DST_FIELD_IPV4,
	55	.offset = offsetof(struct ipv4_5tuple, ip_dst),
	56	},
	57	{
	58	.type = RTE_ACL_FIELD_TYPE_RANGE,
	59	.size = sizeof(uint16_t),
	60	.field_index = SRCP_FIELD_IPV4,
	61	.input_index = SRCP_FIELD_IPV4,
	62	.offset = offsetof(struct ipv4_5tuple, port_src),
	63	},
	64	{
	65	.type = RTE_ACL_FIELD_TYPE_RANGE,
	66	.size = sizeof(uint16_t),
67	.field_index = DSTP_FIELD_IPV4,
68	.input_index = SRCP_FIELD_IPV4,
69	.offset = offsetof(struct ipv4_5tuple, port_dst),
70	},
71	};
72
73	struct rte_table_acl_rule_add_params table_acl_IPv4_rule;
74
75	typedef int (parse_5tuple)(char text,
76	struct rte_table_acl_rule_add_params *rule);
77
78	/*
79	* The order of the fields in the rule string after the initial '@'
80	*/
81	enum {
82	CB_FLD_SRC_ADDR,
83	CB_FLD_DST_ADDR,
84	CB_FLD_SRC_PORT_RANGE,
85	CB_FLD_DST_PORT_RANGE,
86	CB_FLD_PROTO,
87	CB_FLD_NUM,
88	};
89
90
91	#define GET_CB_FIELD(in, fd, base, lim, dlm) \
92	do { \
93	unsigned long val; \
94	char *end; \
95	\
96	errno = 0; \
97	val = strtoul((in), &end, (base)); \
98	if (errno != 0 \|\| end[0] != (dlm) \|\| val > (lim)) \
99	return -EINVAL; \
100	(fd) = (typeof(fd)) val; \
101	(in) = end + 1; \
102	} while (0)
103
104
105
106
107	static int
108	parse_ipv4_net(const char in, uint32_t addr, uint32_t *mask_len)
109	{
110	uint8_t a, b, c, d, m;
111
112	GET_CB_FIELD(in, a, 0, UINT8_MAX, '.');
113	GET_CB_FIELD(in, b, 0, UINT8_MAX, '.');
114	GET_CB_FIELD(in, c, 0, UINT8_MAX, '.');
115	GET_CB_FIELD(in, d, 0, UINT8_MAX, '/');
116	GET_CB_FIELD(in, m, 0, sizeof(uint32_t) * CHAR_BIT, 0);
117
118	addr[0] = IPv4(a, b, c, d);
119	mask_len[0] = m;
120
121	return 0;
122	}
123
124	static int
125	parse_port_range(const char in, uint16_t port_low, uint16_t *port_high)
126	{
127	uint16_t a, b;
128
129	GET_CB_FIELD(in, a, 0, UINT16_MAX, ':');
130	GET_CB_FIELD(in, b, 0, UINT16_MAX, 0);
131
132	port_low[0] = a;
133	port_high[0] = b;
134
135	return 0;
136	}
137
138	static int
139	parse_cb_ipv4_rule(char str, struct rte_table_acl_rule_add_params v)
140	{
141	int i, rc;
142	char s, sp, *in[CB_FLD_NUM];
143	static const char *dlm = " \t\n";
144
145	/*
146	** Skip leading '@'
147	*/
148	if (strchr(str, '@') != str)
149	return -EINVAL;
150
151	s = str + 1;
152
153	/*
154	* Populate the 'in' array with the location of each
155	* field in the string we're parsing
156	*/
157	for (i = 0; i != DIM(in); i++) {
158	in[i] = strtok_r(s, dlm, &sp);
159	if (in[i] == NULL)
160	return -EINVAL;
161	s = NULL;
162	}
163
164	/* Parse x.x.x.x/x */
165	rc = parse_ipv4_net(in[CB_FLD_SRC_ADDR],
166	&v->field_value[SRC_FIELD_IPV4].value.u32,
167	&v->field_value[SRC_FIELD_IPV4].mask_range.u32);
168	if (rc != 0) {
169	RTE_LOG(ERR, PIPELINE, "failed to read src address/mask: %s\n",
170	in[CB_FLD_SRC_ADDR]);
171	return rc;
172	}
173
174	printf("V=%u, mask=%u\n", v->field_value[SRC_FIELD_IPV4].value.u32,
175	v->field_value[SRC_FIELD_IPV4].mask_range.u32);
176
177	/* Parse x.x.x.x/x */
178	rc = parse_ipv4_net(in[CB_FLD_DST_ADDR],
179	&v->field_value[DST_FIELD_IPV4].value.u32,
180	&v->field_value[DST_FIELD_IPV4].mask_range.u32);
181	if (rc != 0) {
182	RTE_LOG(ERR, PIPELINE, "failed to read dest address/mask: %s\n",
183	in[CB_FLD_DST_ADDR]);
184	return rc;
185	}
186
187	printf("V=%u, mask=%u\n", v->field_value[DST_FIELD_IPV4].value.u32,
188	v->field_value[DST_FIELD_IPV4].mask_range.u32);
189	/* Parse n:n */
190	rc = parse_port_range(in[CB_FLD_SRC_PORT_RANGE],
191	&v->field_value[SRCP_FIELD_IPV4].value.u16,
192	&v->field_value[SRCP_FIELD_IPV4].mask_range.u16);
193	if (rc != 0) {
194	RTE_LOG(ERR, PIPELINE, "failed to read source port range: %s\n",
195	in[CB_FLD_SRC_PORT_RANGE]);
196	return rc;
197	}
198
199	printf("V=%u, mask=%u\n", v->field_value[SRCP_FIELD_IPV4].value.u16,
200	v->field_value[SRCP_FIELD_IPV4].mask_range.u16);
201	/* Parse n:n */
202	rc = parse_port_range(in[CB_FLD_DST_PORT_RANGE],
203	&v->field_value[DSTP_FIELD_IPV4].value.u16,
204	&v->field_value[DSTP_FIELD_IPV4].mask_range.u16);
205	if (rc != 0) {
206	RTE_LOG(ERR, PIPELINE, "failed to read dest port range: %s\n",
207	in[CB_FLD_DST_PORT_RANGE]);
208	return rc;
209	}
210
211	printf("V=%u, mask=%u\n", v->field_value[DSTP_FIELD_IPV4].value.u16,
212	v->field_value[DSTP_FIELD_IPV4].mask_range.u16);
213	/* parse 0/0xnn */
214	GET_CB_FIELD(in[CB_FLD_PROTO],
215	v->field_value[PROTO_FIELD_IPV4].value.u8,
216	0, UINT8_MAX, '/');
217	GET_CB_FIELD(in[CB_FLD_PROTO],
218	v->field_value[PROTO_FIELD_IPV4].mask_range.u8,
219	0, UINT8_MAX, 0);
220
221	printf("V=%u, mask=%u\n",
222	(unsigned int)v->field_value[PROTO_FIELD_IPV4].value.u8,
223	v->field_value[PROTO_FIELD_IPV4].mask_range.u8);
224	return 0;
225	}
226
227	static int
228	parse_cb_ipv4_rule_del(char str, struct rte_table_acl_rule_delete_params v)
229	{
230	int i, rc;
231	char s, sp, *in[CB_FLD_NUM];
232	static const char *dlm = " \t\n";
233
234	/*
235	** Skip leading '@'
236	*/
237	if (strchr(str, '@') != str)
238	return -EINVAL;
239
240	s = str + 1;
241
242	/*
243	* Populate the 'in' array with the location of each
244	* field in the string we're parsing
245	*/
246	for (i = 0; i != DIM(in); i++) {
247	in[i] = strtok_r(s, dlm, &sp);
248	if (in[i] == NULL)
249	return -EINVAL;
250	s = NULL;
251	}
252
253	/* Parse x.x.x.x/x */
254	rc = parse_ipv4_net(in[CB_FLD_SRC_ADDR],
255	&v->field_value[SRC_FIELD_IPV4].value.u32,
256	&v->field_value[SRC_FIELD_IPV4].mask_range.u32);
257	if (rc != 0) {
258	RTE_LOG(ERR, PIPELINE, "failed to read src address/mask: %s\n",
259	in[CB_FLD_SRC_ADDR]);
260	return rc;
261	}
262
263	printf("V=%u, mask=%u\n", v->field_value[SRC_FIELD_IPV4].value.u32,
264	v->field_value[SRC_FIELD_IPV4].mask_range.u32);
265
266	/* Parse x.x.x.x/x */
267	rc = parse_ipv4_net(in[CB_FLD_DST_ADDR],
268	&v->field_value[DST_FIELD_IPV4].value.u32,
269	&v->field_value[DST_FIELD_IPV4].mask_range.u32);
270	if (rc != 0) {
271	RTE_LOG(ERR, PIPELINE, "failed to read dest address/mask: %s\n",
272	in[CB_FLD_DST_ADDR]);
273	return rc;
274	}
275
276	printf("V=%u, mask=%u\n", v->field_value[DST_FIELD_IPV4].value.u32,
277	v->field_value[DST_FIELD_IPV4].mask_range.u32);
278	/* Parse n:n */
279	rc = parse_port_range(in[CB_FLD_SRC_PORT_RANGE],
280	&v->field_value[SRCP_FIELD_IPV4].value.u16,
281	&v->field_value[SRCP_FIELD_IPV4].mask_range.u16);
282	if (rc != 0) {
283	RTE_LOG(ERR, PIPELINE, "failed to read source port range: %s\n",
284	in[CB_FLD_SRC_PORT_RANGE]);
285	return rc;
286	}
287
288	printf("V=%u, mask=%u\n", v->field_value[SRCP_FIELD_IPV4].value.u16,
289	v->field_value[SRCP_FIELD_IPV4].mask_range.u16);
290	/* Parse n:n */
291	rc = parse_port_range(in[CB_FLD_DST_PORT_RANGE],
292	&v->field_value[DSTP_FIELD_IPV4].value.u16,
293	&v->field_value[DSTP_FIELD_IPV4].mask_range.u16);
294	if (rc != 0) {
295	RTE_LOG(ERR, PIPELINE, "failed to read dest port range: %s\n",
296	in[CB_FLD_DST_PORT_RANGE]);
297	return rc;
298	}
299
300	printf("V=%u, mask=%u\n", v->field_value[DSTP_FIELD_IPV4].value.u16,
301	v->field_value[DSTP_FIELD_IPV4].mask_range.u16);
302	/* parse 0/0xnn */
303	GET_CB_FIELD(in[CB_FLD_PROTO],
304	v->field_value[PROTO_FIELD_IPV4].value.u8,
305	0, UINT8_MAX, '/');
306	GET_CB_FIELD(in[CB_FLD_PROTO],
307	v->field_value[PROTO_FIELD_IPV4].mask_range.u8,
308	0, UINT8_MAX, 0);
309
310	printf("V=%u, mask=%u\n",
311	(unsigned int)v->field_value[PROTO_FIELD_IPV4].value.u8,
312	v->field_value[PROTO_FIELD_IPV4].mask_range.u8);
313	return 0;
314	}
315
316	/*
317	* The format for these rules DO NOT need the port ranges to be
318	* separated by ' : ', just ':'. It's a lot more readable and
319	* cleaner, IMO.
320	*/
321	char lines[][128] = {
322	"@0.0.0.0/0 0.0.0.0/0 0:65535 0:65535 2/0xff", /* Protocol check */
323	"@192.168.3.1/32 0.0.0.0/0 0:65535 0:65535 0/0", /* Src IP checl */
324	"@0.0.0.0/0 10.4.4.1/32 0:65535 0:65535 0/0", /* dst IP check */
325	"@0.0.0.0/0 0.0.0.0/0 105:105 0:65535 0/0", /* src port check */
326	"@0.0.0.0/0 0.0.0.0/0 0:65535 206:206 0/0", /* dst port check */
327	};
328
329	char line[128];
330
331
332	static int
333	setup_acl_pipeline(void)
334	{
335	int ret;
336	int i;
337	struct rte_pipeline_params pipeline_params = {
338	.name = "PIPELINE",
339	.socket_id = 0,
340	};
341	uint32_t n;
342	struct rte_table_acl_rule_add_params rule_params;
343	struct rte_pipeline_table_acl_rule_delete_params *delete_params;
344	parse_5tuple parser;
345	char acl_name[64];
346
347	/* Pipeline configuration */
348	p = rte_pipeline_create(&pipeline_params);
349	if (p == NULL) {
350	RTE_LOG(INFO, PIPELINE, "%s: Failed to configure pipeline\n",
351	__func__);
352	goto fail;
353	}
354
355	/* Input port configuration */
356	for (i = 0; i < N_PORTS; i++) {
357	struct rte_port_ring_reader_params port_ring_params = {
358	.ring = rings_rx[i],
359	};
360
361	struct rte_pipeline_port_in_params port_params = {
362	.ops = &rte_port_ring_reader_ops,
363	.arg_create = (void *) &port_ring_params,
364	.f_action = NULL,
365	.burst_size = BURST_SIZE,
366	};
367
368	/* Put in action for some ports */
369	if (i)
370	port_params.f_action = port_in_action;
371
372	ret = rte_pipeline_port_in_create(p, &port_params,
373	&port_in_id[i]);
374	if (ret) {
375	rte_panic("Unable to configure input port %d, ret:%d\n",
376	i, ret);
377	goto fail;
378	}
379	}
380
381	/* output Port configuration */
382	for (i = 0; i < N_PORTS; i++) {
383	struct rte_port_ring_writer_params port_ring_params = {
384	.ring = rings_tx[i],
385	.tx_burst_sz = BURST_SIZE,
386	};
387
388	struct rte_pipeline_port_out_params port_params = {
389	.ops = &rte_port_ring_writer_ops,
390	.arg_create = (void *) &port_ring_params,
391	.f_action = NULL,
392	.arg_ah = NULL,
393	};
394
395
396	if (rte_pipeline_port_out_create(p, &port_params,
397	&port_out_id[i])) {
398	rte_panic("Unable to configure output port %d\n", i);
399	goto fail;
400	}
401	}
402
403	/* Table configuration */
404	for (i = 0; i < N_PORTS; i++) {
405	struct rte_pipeline_table_params table_params;
406
407	/* Set up defaults for stub */
408	table_params.ops = &rte_table_stub_ops;
409	table_params.arg_create = NULL;
410	table_params.f_action_hit = action_handler_hit;
411	table_params.f_action_miss = NULL;
412	table_params.action_data_size = 0;
413
414	RTE_LOG(INFO, PIPELINE, "miss_action=%x\n",
415	table_entry_miss_action);
416
417	printf("RTE_ACL_RULE_SZ(%zu) = %zu\n", DIM(ipv4_defs),
418	RTE_ACL_RULE_SZ(DIM(ipv4_defs)));
419
420	struct rte_table_acl_params acl_params;
421
422	acl_params.n_rules = 1 << 5;
423	acl_params.n_rule_fields = DIM(ipv4_defs);
424	snprintf(acl_name, sizeof(acl_name), "ACL%d", i);
425	acl_params.name = acl_name;
426	memcpy(acl_params.field_format, ipv4_defs, sizeof(ipv4_defs));
427
428	table_params.ops = &rte_table_acl_ops;
429	table_params.arg_create = &acl_params;
430
431	if (rte_pipeline_table_create(p, &table_params, &table_id[i])) {
432	rte_panic("Unable to configure table %u\n", i);
433	goto fail;
434	}
435
436	if (connect_miss_action_to_table) {
437	if (rte_pipeline_table_create(p, &table_params,
438	&table_id[i+2])) {
439	rte_panic("Unable to configure table %u\n", i);
440	goto fail;
441	}
442	}
443	}
444
445	for (i = 0; i < N_PORTS; i++) {
446	if (rte_pipeline_port_in_connect_to_table(p, port_in_id[i],
447	table_id[i])) {
448	rte_panic("Unable to connect input port %u to "
449	"table %u\n",
450	port_in_id[i], table_id[i]);
451	goto fail;
452	}
453	}
454
455	/* Add bulk entries to tables */
456	for (i = 0; i < N_PORTS; i++) {
457	struct rte_table_acl_rule_add_params keys[5];
458	struct rte_pipeline_table_entry entries[5];
459	struct rte_table_acl_rule_add_params *key_array[5];
460	struct rte_pipeline_table_entry *table_entries[5];
461	int key_found[5];
462	struct rte_pipeline_table_entry *table_entries_ptr[5];
463	struct rte_pipeline_table_entry entries_ptr[5];
464
465	parser = parse_cb_ipv4_rule;
466	for (n = 0; n < 5; n++) {
467	memset(&keys[n], 0, sizeof(struct rte_table_acl_rule_add_params));
468	key_array[n] = &keys[n];
469
470	snprintf(line, sizeof(line), "%s", lines[n]);
471	printf("PARSING [%s]\n", line);
472
473	ret = parser(line, &keys[n]);
474	if (ret != 0) {
475	RTE_LOG(ERR, PIPELINE,
476	"line %u: parse_cb_ipv4vlan_rule"
477	" failed, error code: %d (%s)\n",
478	n, ret, strerror(-ret));
479	return ret;
480	}
481
482	keys[n].priority = RTE_ACL_MAX_PRIORITY - n - 1;
483
484	entries[n].action = RTE_PIPELINE_ACTION_PORT;
485	entries[n].port_id = port_out_id[i^1];
486	table_entries[n] = &entries[n];
487	table_entries_ptr[n] = &entries_ptr[n];
488	}
489
490	ret = rte_pipeline_table_entry_add_bulk(p, table_id[i],
491	(void **)key_array, table_entries, 5, key_found, table_entries_ptr);
492	if (ret < 0) {
493	rte_panic("Add entry bulk to table %u failed (%d)\n",
494	table_id[i], ret);
495	goto fail;
496	}
497	}
498
499	/* Delete bulk entries from tables */
500	for (i = 0; i < N_PORTS; i++) {
501	struct rte_table_acl_rule_delete_params keys[5];
502	struct rte_table_acl_rule_delete_params *key_array[5];
503	struct rte_pipeline_table_entry *table_entries[5];
504	int key_found[5];
505
11fdf7f2 TL	506	memset(table_entries, 0, sizeof(table_entries));
11fdf7f2 TL	507
7c673cae FG	508	for (n = 0; n < 5; n++) {
	509	memset(&keys[n], 0, sizeof(struct rte_table_acl_rule_delete_params));
	510	key_array[n] = &keys[n];
	511
	512	snprintf(line, sizeof(line), "%s", lines[n]);
	513	printf("PARSING [%s]\n", line);
	514
	515	ret = parse_cb_ipv4_rule_del(line, &keys[n]);
	516	if (ret != 0) {
	517	RTE_LOG(ERR, PIPELINE,
	518	"line %u: parse_cb_ipv4vlan_rule"
	519	" failed, error code: %d (%s)\n",
	520	n, ret, strerror(-ret));
	521	return ret;
	522	}
	523	}
	524
	525	ret = rte_pipeline_table_entry_delete_bulk(p, table_id[i],
	526	(void **)key_array, 5, key_found, table_entries);
	527	if (ret < 0) {
	528	rte_panic("Delete bulk entries from table %u failed (%d)\n",
	529	table_id[i], ret);
	530	goto fail;
	531	} else
	532	printf("Bulk deleted rules.\n");
	533	}
	534
	535	/* Add entries to tables */
	536	for (i = 0; i < N_PORTS; i++) {
	537	struct rte_pipeline_table_entry table_entry = {
	538	.action = RTE_PIPELINE_ACTION_PORT,
	539	{.port_id = port_out_id[i^1]},
	540	};
	541	int key_found;
	542	struct rte_pipeline_table_entry *entry_ptr;
	543
	544	memset(&rule_params, 0, sizeof(rule_params));
	545	parser = parse_cb_ipv4_rule;
	546
	547	for (n = 1; n <= 5; n++) {
	548	snprintf(line, sizeof(line), "%s", lines[n-1]);
	549	printf("PARSING [%s]\n", line);
	550
	551	ret = parser(line, &rule_params);
	552	if (ret != 0) {
	553	RTE_LOG(ERR, PIPELINE,
	554	"line %u: parse_cb_ipv4vlan_rule"
	555	" failed, error code: %d (%s)\n",
	556	n, ret, strerror(-ret));
	557	return ret;
	558	}
	559
	560	rule_params.priority = RTE_ACL_MAX_PRIORITY - n;
	561
	562	ret = rte_pipeline_table_entry_add(p, table_id[i],
	563	&rule_params,
	564	&table_entry, &key_found, &entry_ptr);
	565	if (ret < 0) {
	566	rte_panic("Add entry to table %u failed (%d)\n",
	567	table_id[i], ret);
	568	goto fail;
	569	}
	570	}
	571
572	/* delete a few rules */
573	for (n = 2; n <= 3; n++) {
574	snprintf(line, sizeof(line), "%s", lines[n-1]);
575	printf("PARSING [%s]\n", line);
576
577	ret = parser(line, &rule_params);
578	if (ret != 0) {
579	RTE_LOG(ERR, PIPELINE, "line %u: parse rule "
580	" failed, error code: %d (%s)\n",
581	n, ret, strerror(-ret));
582	return ret;
583	}
584
585	delete_params = (struct
586	rte_pipeline_table_acl_rule_delete_params *)
587	&(rule_params.field_value[0]);
588	ret = rte_pipeline_table_entry_delete(p, table_id[i],
589	delete_params, &key_found, NULL);
590	if (ret < 0) {
591	rte_panic("Add entry to table %u failed (%d)\n",
592	table_id[i], ret);
593	goto fail;
594	} else
595	printf("Deleted Rule.\n");
596	}
597
598
599	/* Try to add duplicates */
600	for (n = 1; n <= 5; n++) {
601	snprintf(line, sizeof(line), "%s", lines[n-1]);
602	printf("PARSING [%s]\n", line);
603
604	ret = parser(line, &rule_params);
605	if (ret != 0) {
606	RTE_LOG(ERR, PIPELINE, "line %u: parse rule"
607	" failed, error code: %d (%s)\n",
608	n, ret, strerror(-ret));
609	return ret;
610	}
611
612	rule_params.priority = RTE_ACL_MAX_PRIORITY - n;
613
614	ret = rte_pipeline_table_entry_add(p, table_id[i],
615	&rule_params,
616	&table_entry, &key_found, &entry_ptr);
617	if (ret < 0) {
618	rte_panic("Add entry to table %u failed (%d)\n",
619	table_id[i], ret);
620	goto fail;
621	}
622	}
623	}
624
625	/* Enable input ports */
626	for (i = 0; i < N_PORTS ; i++)
627	if (rte_pipeline_port_in_enable(p, port_in_id[i]))
628	rte_panic("Unable to enable input port %u\n",
629	port_in_id[i]);
630
631	/* Check pipeline consistency */
632	if (rte_pipeline_check(p) < 0) {
633	rte_panic("Pipeline consistency check failed\n");
634	goto fail;
635	}
636
637	return 0;
638	fail:
639
640	return -1;
641	}
642
643	static int
644	test_pipeline_single_filter(int expected_count)
645	{
646	int i, j, ret, tx_count;
647	struct ipv4_5tuple five_tuple;
648
649	/* Allocate a few mbufs and manually insert into the rings. */
650	for (i = 0; i < N_PORTS; i++) {
651	for (j = 0; j < 8; j++) {
652	struct rte_mbuf *mbuf;
653
654	mbuf = rte_pktmbuf_alloc(pool);
655	if (mbuf == NULL)
656	/* this will cause test failure after cleanup
657	* of already enqueued mbufs, as the mbuf
658	* counts won't match */
659	break;
660	memset(rte_pktmbuf_mtod(mbuf, char *), 0x00,
661	sizeof(struct ipv4_5tuple));
662
663	five_tuple.proto = j;
664	five_tuple.ip_src = rte_bswap32(IPv4(192, 168, j, 1));
665	five_tuple.ip_dst = rte_bswap32(IPv4(10, 4, j, 1));
666	five_tuple.port_src = rte_bswap16(100 + j);
667	five_tuple.port_dst = rte_bswap16(200 + j);
668
669	memcpy(rte_pktmbuf_mtod(mbuf, char *), &five_tuple,
670	sizeof(struct ipv4_5tuple));
671	RTE_LOG(INFO, PIPELINE, "%s: Enqueue onto ring %d\n",
672	__func__, i);
673	rte_ring_enqueue(rings_rx[i], mbuf);
674	}
675	}
676
677	/* Run pipeline once */
678	for (i = 0; i< N_PORTS; i++)
679	rte_pipeline_run(p);
680
681	rte_pipeline_flush(p);
682
683	tx_count = 0;
684
685	for (i = 0; i < N_PORTS; i++) {
686	void *objs[RING_TX_SIZE];
687	struct rte_mbuf *mbuf;
688
11fdf7f2	689	ret = rte_ring_sc_dequeue_burst(rings_tx[i], objs, 10, NULL);
7c673cae FG	690	if (ret <= 0) {
	691	printf("Got no objects from ring %d - error code %d\n",
	692	i, ret);
	693	} else {
	694	printf("Got %d object(s) from ring %d!\n", ret, i);
	695	for (j = 0; j < ret; j++) {
11fdf7f2	696	mbuf = objs[j];
7c673cae FG	697	rte_hexdump(stdout, "mbuf",
	698	rte_pktmbuf_mtod(mbuf, char *), 64);
	699	rte_pktmbuf_free(mbuf);
	700	}
	701	tx_count += ret;
	702	}
	703	}
	704
	705	if (tx_count != expected_count) {
	706	RTE_LOG(INFO, PIPELINE,
	707	"%s: Unexpected packets for ACL test, "
	708	"expected %d, got %d\n",
	709	__func__, expected_count, tx_count);
	710	goto fail;
	711	}
	712
	713	rte_pipeline_free(p);
	714
	715	return 0;
	716	fail:
	717	return -1;
	718
	719	}
	720
	721	int
	722	test_table_acl(void)
	723	{
	724
	725
	726	override_hit_mask = 0xFF; /* All packets are a hit */
	727
	728	setup_acl_pipeline();
	729	if (test_pipeline_single_filter(10) < 0)
	730	return -1;
	731
	732	return 0;
	733	}