diff mbox series

[v5,11/17] net/ionic: add Rx filters support

Message ID 20200119155356.20403-12-cardigliano@ntop.org (mailing list archive)
State Accepted, archived
Delegated to: Ferruh Yigit
Headers show
Series Introduces net/ionic PMD | expand

Checks

Context Check Description
ci/Intel-compilation success Compilation OK
ci/checkpatch success coding style OK

Commit Message

Alfredo Cardigliano Jan. 19, 2020, 3:53 p.m. UTC
Add support for managing RX filters based on MAC and VLAN.
Hardware cannot provide the list of filters, thus we keep
a local list.
Add support for promisc and allmulticast modes.

Signed-off-by: Alfredo Cardigliano <cardigliano@ntop.org>
Reviewed-by: Shannon Nelson <snelson@pensando.io>
---
 doc/guides/nics/features/ionic.ini  |   4 +
 drivers/net/ionic/Makefile          |   1 +
 drivers/net/ionic/ionic_ethdev.c    |   8 +
 drivers/net/ionic/ionic_lif.c       | 253 +++++++++++++++++++++++++++-
 drivers/net/ionic/ionic_lif.h       |  16 ++
 drivers/net/ionic/ionic_rx_filter.c | 139 +++++++++++++++
 drivers/net/ionic/ionic_rx_filter.h |  47 ++++++
 drivers/net/ionic/meson.build       |   1 +
 8 files changed, 462 insertions(+), 7 deletions(-)
 create mode 100644 drivers/net/ionic/ionic_rx_filter.c
 create mode 100644 drivers/net/ionic/ionic_rx_filter.h

Comments

Ferruh Yigit Jan. 20, 2020, 4:57 p.m. UTC | #1
On 1/19/2020 3:53 PM, Alfredo Cardigliano wrote:
> Add support for managing RX filters based on MAC and VLAN.
> Hardware cannot provide the list of filters, thus we keep
> a local list.
> Add support for promisc and allmulticast modes.
> 
> Signed-off-by: Alfredo Cardigliano <cardigliano@ntop.org>
> Reviewed-by: Shannon Nelson <snelson@pensando.io>

<...>

> +int
> +ionic_rx_filter_save(struct ionic_lif *lif, uint32_t flow_id,
> +		uint16_t rxq_index, struct ionic_admin_ctx *ctx)
> +{
> +	struct ionic_rx_filter *f;
> +	uint32_t key;
> +
> +	f = rte_zmalloc("ionic", sizeof(*f), 0);
> +
> +	if (!f)
> +		return -ENOMEM;
> +
> +	f->flow_id = flow_id;
> +	f->filter_id = ctx->comp.rx_filter_add.filter_id;
> +	f->rxq_index = rxq_index;
> +	memcpy(&f->cmd, &ctx->cmd, sizeof(f->cmd));
> +
> +	switch (f->cmd.match) {
> +	case IONIC_RX_FILTER_MATCH_VLAN:
> +		key = f->cmd.vlan.vlan & IONIC_RX_FILTER_HLISTS_MASK;
> +		break;
> +	case IONIC_RX_FILTER_MATCH_MAC:
> +		key = *(uint32_t *)f->cmd.mac.addr &
> +			IONIC_RX_FILTER_HLISTS_MASK;

Raslan reported a build error on this line [1] with gcc 5.4-6ubuntu. I will
update the code as [2] please verify the result in next-net.

@Raslan, I can't re-procude the warning, can you please re-test the next-net
after change?

[1]
 /tmp/dpdk/drivers/net/ionic/ionic_rx_filter.c: In function 'ionic_rx_filter_save':
 /tmp/dpdk/drivers/net/ionic/ionic_rx_filter.c:85:3: error: dereferencing
type-punned pointer will break strict-aliasing rules [-Werror=strict-aliasing]
    key = *(uint32_t *)f->cmd.mac.addr &
    ^

[2]
 diff --git a/drivers/net/ionic/ionic_rx_filter.c
b/drivers/net/ionic/ionic_rx_filter.c
 index 00b5cee49..f75b81a27 100644
 --- a/drivers/net/ionic/ionic_rx_filter.c
 +++ b/drivers/net/ionic/ionic_rx_filter.c
 @@ -82,8 +82,8 @@ ionic_rx_filter_save(struct ionic_lif *lif, uint32_t flow_id,
                 key = f->cmd.vlan.vlan & IONIC_RX_FILTER_HLISTS_MASK;
                 break;
         case IONIC_RX_FILTER_MATCH_MAC:
 -               key = *(uint32_t *)f->cmd.mac.addr &
 -                       IONIC_RX_FILTER_HLISTS_MASK;
 +               memcpy(&key, f->cmd.mac.addr, sizeof(key));
 +               key &= IONIC_RX_FILTER_HLISTS_MASK;
                 break;
         case IONIC_RX_FILTER_MATCH_MAC_VLAN:
                 key = f->cmd.mac_vlan.vlan & IONIC_RX_FILTER_HLISTS_MASK;
Raslan Darawsheh Jan. 21, 2020, 7:43 a.m. UTC | #2
Hi,

> -----Original Message-----
> From: Ferruh Yigit <ferruh.yigit@intel.com>
> Sent: Monday, January 20, 2020 6:58 PM
> To: Alfredo Cardigliano <cardigliano@ntop.org>; John McNamara
> <john.mcnamara@intel.com>; Marko Kovacevic
> <marko.kovacevic@intel.com>
> Cc: dev@dpdk.org; Raslan Darawsheh <rasland@mellanox.com>
> Subject: Re: [dpdk-dev] [PATCH v5 11/17] net/ionic: add Rx filters support
> 
> On 1/19/2020 3:53 PM, Alfredo Cardigliano wrote:
> > Add support for managing RX filters based on MAC and VLAN.
> > Hardware cannot provide the list of filters, thus we keep
> > a local list.
> > Add support for promisc and allmulticast modes.
> >
> > Signed-off-by: Alfredo Cardigliano <cardigliano@ntop.org>
> > Reviewed-by: Shannon Nelson <snelson@pensando.io>
> 
> <...>
> 
> > +int
> > +ionic_rx_filter_save(struct ionic_lif *lif, uint32_t flow_id,
> > +		uint16_t rxq_index, struct ionic_admin_ctx *ctx)
> > +{
> > +	struct ionic_rx_filter *f;
> > +	uint32_t key;
> > +
> > +	f = rte_zmalloc("ionic", sizeof(*f), 0);
> > +
> > +	if (!f)
> > +		return -ENOMEM;
> > +
> > +	f->flow_id = flow_id;
> > +	f->filter_id = ctx->comp.rx_filter_add.filter_id;
> > +	f->rxq_index = rxq_index;
> > +	memcpy(&f->cmd, &ctx->cmd, sizeof(f->cmd));
> > +
> > +	switch (f->cmd.match) {
> > +	case IONIC_RX_FILTER_MATCH_VLAN:
> > +		key = f->cmd.vlan.vlan & IONIC_RX_FILTER_HLISTS_MASK;
> > +		break;
> > +	case IONIC_RX_FILTER_MATCH_MAC:
> > +		key = *(uint32_t *)f->cmd.mac.addr &
> > +			IONIC_RX_FILTER_HLISTS_MASK;
> 
> Raslan reported a build error on this line [1] with gcc 5.4-6ubuntu. I will
> update the code as [2] please verify the result in next-net.
> 
> @Raslan, I can't re-procude the warning, can you please re-test the next-net
> after change?
> 

I've just verified that with this fix we don't have this error anymore.

> [1]
>  /tmp/dpdk/drivers/net/ionic/ionic_rx_filter.c: In function
> 'ionic_rx_filter_save':
>  /tmp/dpdk/drivers/net/ionic/ionic_rx_filter.c:85:3: error: dereferencing
> type-punned pointer will break strict-aliasing rules [-Werror=strict-aliasing]
>     key = *(uint32_t *)f->cmd.mac.addr &
>     ^
> 
> [2]
>  diff --git a/drivers/net/ionic/ionic_rx_filter.c
> b/drivers/net/ionic/ionic_rx_filter.c
>  index 00b5cee49..f75b81a27 100644
>  --- a/drivers/net/ionic/ionic_rx_filter.c
>  +++ b/drivers/net/ionic/ionic_rx_filter.c
>  @@ -82,8 +82,8 @@ ionic_rx_filter_save(struct ionic_lif *lif, uint32_t
> flow_id,
>                  key = f->cmd.vlan.vlan & IONIC_RX_FILTER_HLISTS_MASK;
>                  break;
>          case IONIC_RX_FILTER_MATCH_MAC:
>  -               key = *(uint32_t *)f->cmd.mac.addr &
>  -                       IONIC_RX_FILTER_HLISTS_MASK;
>  +               memcpy(&key, f->cmd.mac.addr, sizeof(key));
>  +               key &= IONIC_RX_FILTER_HLISTS_MASK;
>                  break;
>          case IONIC_RX_FILTER_MATCH_MAC_VLAN:
>                  key = f->cmd.mac_vlan.vlan & IONIC_RX_FILTER_HLISTS_MASK;

Kindest regards
Raslan Darawsheh
diff mbox series

Patch

diff --git a/doc/guides/nics/features/ionic.ini b/doc/guides/nics/features/ionic.ini
index c69e5cbed..3dd5dab45 100644
--- a/doc/guides/nics/features/ionic.ini
+++ b/doc/guides/nics/features/ionic.ini
@@ -8,6 +8,10 @@  Speed capabilities   = Y
 Link status          = Y
 Link status event    = Y
 MTU update           = Y
+Promiscuous mode     = Y
+Allmulticast mode    = Y
+Unicast MAC filter   = Y
+VLAN filter          = Y
 Linux UIO            = Y
 Linux VFIO           = Y
 x86-64               = Y
diff --git a/drivers/net/ionic/Makefile b/drivers/net/ionic/Makefile
index 2dc88cdd5..2b7cbaf9e 100644
--- a/drivers/net/ionic/Makefile
+++ b/drivers/net/ionic/Makefile
@@ -24,6 +24,7 @@  LDLIBS += -lrte_bus_pci
 # all source are stored in SRCS-y
 #
 SRCS-$(CONFIG_RTE_LIBRTE_IONIC_PMD) += ionic_mac_api.c
+SRCS-$(CONFIG_RTE_LIBRTE_IONIC_PMD) += ionic_rx_filter.c
 SRCS-$(CONFIG_RTE_LIBRTE_IONIC_PMD) += ionic_dev.c
 SRCS-$(CONFIG_RTE_LIBRTE_IONIC_PMD) += ionic_ethdev.c
 SRCS-$(CONFIG_RTE_LIBRTE_IONIC_PMD) += ionic_lif.c
diff --git a/drivers/net/ionic/ionic_ethdev.c b/drivers/net/ionic/ionic_ethdev.c
index e2c9d1d68..0cb551c73 100644
--- a/drivers/net/ionic/ionic_ethdev.c
+++ b/drivers/net/ionic/ionic_ethdev.c
@@ -49,6 +49,14 @@  static const struct eth_dev_ops ionic_eth_dev_ops = {
 	.link_update            = ionic_dev_link_update,
 	.dev_set_link_up        = ionic_dev_set_link_up,
 	.dev_set_link_down      = ionic_dev_set_link_down,
+	.mac_addr_add           = ionic_dev_add_mac,
+	.mac_addr_remove        = ionic_dev_remove_mac,
+	.mac_addr_set           = ionic_dev_set_mac,
+	.vlan_filter_set        = ionic_dev_vlan_filter_set,
+	.promiscuous_enable     = ionic_dev_promiscuous_enable,
+	.promiscuous_disable    = ionic_dev_promiscuous_disable,
+	.allmulticast_enable    = ionic_dev_allmulticast_enable,
+	.allmulticast_disable   = ionic_dev_allmulticast_disable,
 };
 
 /*
diff --git a/drivers/net/ionic/ionic_lif.c b/drivers/net/ionic/ionic_lif.c
index 66038bbdb..1214ebf93 100644
--- a/drivers/net/ionic/ionic_lif.c
+++ b/drivers/net/ionic/ionic_lif.c
@@ -9,6 +9,7 @@ 
 #include "ionic_logs.h"
 #include "ionic_lif.h"
 #include "ionic_ethdev.h"
+#include "ionic_rx_filter.h"
 
 static int ionic_lif_addr_add(struct ionic_lif *lif, const uint8_t *addr);
 static int ionic_lif_addr_del(struct ionic_lif *lif, const uint8_t *addr);
@@ -83,23 +84,200 @@  ionic_lif_reset(struct ionic_lif *lif)
 }
 
 static int
-ionic_lif_addr_add(struct ionic_lif *lif __rte_unused,
-		const uint8_t *addr __rte_unused)
+ionic_lif_addr_add(struct ionic_lif *lif, const uint8_t *addr)
 {
-	IONIC_PRINT(INFO, "%s: stubbed", __func__);
+	struct ionic_admin_ctx ctx = {
+		.pending_work = true,
+		.cmd.rx_filter_add = {
+			.opcode = IONIC_CMD_RX_FILTER_ADD,
+			.match = IONIC_RX_FILTER_MATCH_MAC,
+		},
+	};
+	int err;
+
+	memcpy(ctx.cmd.rx_filter_add.mac.addr, addr, RTE_ETHER_ADDR_LEN);
+
+	err = ionic_adminq_post_wait(lif, &ctx);
+	if (err)
+		return err;
+
+	IONIC_PRINT(INFO, "rx_filter add (id %d)",
+		ctx.comp.rx_filter_add.filter_id);
+
+	return ionic_rx_filter_save(lif, 0, IONIC_RXQ_INDEX_ANY, &ctx);
+}
+
+static int
+ionic_lif_addr_del(struct ionic_lif *lif, const uint8_t *addr)
+{
+	struct ionic_admin_ctx ctx = {
+		.pending_work = true,
+		.cmd.rx_filter_del = {
+			.opcode = IONIC_CMD_RX_FILTER_DEL,
+		},
+	};
+	struct ionic_rx_filter *f;
+	int err;
+
+	IONIC_PRINT_CALL();
+
+	rte_spinlock_lock(&lif->rx_filters.lock);
+
+	f = ionic_rx_filter_by_addr(lif, addr);
+	if (!f) {
+		rte_spinlock_unlock(&lif->rx_filters.lock);
+		return -ENOENT;
+	}
+
+	ctx.cmd.rx_filter_del.filter_id = f->filter_id;
+	ionic_rx_filter_free(f);
+
+	rte_spinlock_unlock(&lif->rx_filters.lock);
+
+	err = ionic_adminq_post_wait(lif, &ctx);
+	if (err)
+		return err;
+
+	IONIC_PRINT(INFO, "rx_filter del (id %d)",
+		ctx.cmd.rx_filter_del.filter_id);
 
 	return 0;
 }
 
+int
+ionic_dev_add_mac(struct rte_eth_dev *eth_dev,
+		struct rte_ether_addr *mac_addr,
+		uint32_t index __rte_unused, uint32_t pool __rte_unused)
+{
+	struct ionic_lif *lif = IONIC_ETH_DEV_TO_LIF(eth_dev);
+
+	IONIC_PRINT_CALL();
+
+	return ionic_lif_addr_add(lif, (const uint8_t *)mac_addr);
+}
+
+void
+ionic_dev_remove_mac(struct rte_eth_dev *eth_dev, uint32_t index __rte_unused)
+{
+	struct ionic_lif *lif = IONIC_ETH_DEV_TO_LIF(eth_dev);
+	struct ionic_adapter *adapter = lif->adapter;
+
+	IONIC_PRINT_CALL();
+
+	if (index >= adapter->max_mac_addrs) {
+		IONIC_PRINT(WARNING,
+			"Index %u is above MAC filter limit %u",
+			index, adapter->max_mac_addrs);
+		return;
+	}
+
+	if (!rte_is_valid_assigned_ether_addr(&eth_dev->data->mac_addrs[index]))
+		return;
+
+	ionic_lif_addr_del(lif, (const uint8_t *)
+		&eth_dev->data->mac_addrs[index]);
+}
+
+int
+ionic_dev_set_mac(struct rte_eth_dev *eth_dev, struct rte_ether_addr *mac_addr)
+{
+	struct ionic_lif *lif = IONIC_ETH_DEV_TO_LIF(eth_dev);
+
+	IONIC_PRINT_CALL();
+
+	if (mac_addr == NULL) {
+		IONIC_PRINT(NOTICE, "New mac is null");
+		return -1;
+	}
+
+	if (!rte_is_zero_ether_addr((struct rte_ether_addr *)lif->mac_addr)) {
+		IONIC_PRINT(INFO, "Deleting mac addr %pM",
+			lif->mac_addr);
+		ionic_lif_addr_del(lif, lif->mac_addr);
+		memset(lif->mac_addr, 0, RTE_ETHER_ADDR_LEN);
+	}
+
+	IONIC_PRINT(INFO, "Updating mac addr");
+
+	rte_ether_addr_copy(mac_addr, (struct rte_ether_addr *)lif->mac_addr);
+
+	return ionic_lif_addr_add(lif, (const uint8_t *)mac_addr);
+}
+
 static int
-ionic_lif_addr_del(struct ionic_lif *lif __rte_unused,
-		const uint8_t *addr __rte_unused)
+ionic_vlan_rx_add_vid(struct ionic_lif *lif, uint16_t vid)
 {
-	IONIC_PRINT(INFO, "%s: stubbed", __func__);
+	struct ionic_admin_ctx ctx = {
+		.pending_work = true,
+		.cmd.rx_filter_add = {
+			.opcode = IONIC_CMD_RX_FILTER_ADD,
+			.match = IONIC_RX_FILTER_MATCH_VLAN,
+			.vlan.vlan = vid,
+		},
+	};
+	int err;
+
+	err = ionic_adminq_post_wait(lif, &ctx);
+	if (err)
+		return err;
+
+	IONIC_PRINT(INFO, "rx_filter add VLAN %d (id %d)", vid,
+		ctx.comp.rx_filter_add.filter_id);
+
+	return ionic_rx_filter_save(lif, 0, IONIC_RXQ_INDEX_ANY, &ctx);
+}
+
+static int
+ionic_vlan_rx_kill_vid(struct ionic_lif *lif, uint16_t vid)
+{
+	struct ionic_admin_ctx ctx = {
+		.pending_work = true,
+		.cmd.rx_filter_del = {
+			.opcode = IONIC_CMD_RX_FILTER_DEL,
+		},
+	};
+	struct ionic_rx_filter *f;
+	int err;
+
+	IONIC_PRINT_CALL();
+
+	rte_spinlock_lock(&lif->rx_filters.lock);
+
+	f = ionic_rx_filter_by_vlan(lif, vid);
+	if (!f) {
+		rte_spinlock_unlock(&lif->rx_filters.lock);
+		return -ENOENT;
+	}
+
+	ctx.cmd.rx_filter_del.filter_id = f->filter_id;
+	ionic_rx_filter_free(f);
+	rte_spinlock_unlock(&lif->rx_filters.lock);
+
+	err = ionic_adminq_post_wait(lif, &ctx);
+	if (err)
+		return err;
+
+	IONIC_PRINT(INFO, "rx_filter del VLAN %d (id %d)", vid,
+		ctx.cmd.rx_filter_del.filter_id);
 
 	return 0;
 }
 
+int
+ionic_dev_vlan_filter_set(struct rte_eth_dev *eth_dev, uint16_t vlan_id,
+		int on)
+{
+	struct ionic_lif *lif = IONIC_ETH_DEV_TO_LIF(eth_dev);
+	int err;
+
+	if (on)
+		err = ionic_vlan_rx_add_vid(lif, vlan_id);
+	else
+		err = ionic_vlan_rx_kill_vid(lif, vlan_id);
+
+	return err;
+}
+
 static void
 ionic_lif_rx_mode(struct ionic_lif *lif, uint32_t rx_mode)
 {
@@ -138,6 +316,59 @@  ionic_set_rx_mode(struct ionic_lif *lif, uint32_t rx_mode)
 	}
 }
 
+int
+ionic_dev_promiscuous_enable(struct rte_eth_dev *eth_dev)
+{
+	struct ionic_lif *lif = IONIC_ETH_DEV_TO_LIF(eth_dev);
+	uint32_t rx_mode = lif->rx_mode;
+
+	IONIC_PRINT_CALL();
+
+	rx_mode |= IONIC_RX_MODE_F_PROMISC;
+
+	ionic_set_rx_mode(lif, rx_mode);
+
+	return 0;
+}
+
+int
+ionic_dev_promiscuous_disable(struct rte_eth_dev *eth_dev)
+{
+	struct ionic_lif *lif = IONIC_ETH_DEV_TO_LIF(eth_dev);
+	uint32_t rx_mode = lif->rx_mode;
+
+	rx_mode &= ~IONIC_RX_MODE_F_PROMISC;
+
+	ionic_set_rx_mode(lif, rx_mode);
+
+	return 0;
+}
+
+int
+ionic_dev_allmulticast_enable(struct rte_eth_dev *eth_dev)
+{
+	struct ionic_lif *lif = IONIC_ETH_DEV_TO_LIF(eth_dev);
+	uint32_t rx_mode = lif->rx_mode;
+
+	rx_mode |= IONIC_RX_MODE_F_ALLMULTI;
+
+	ionic_set_rx_mode(lif, rx_mode);
+
+	return 0;
+}
+
+int
+ionic_dev_allmulticast_disable(struct rte_eth_dev *eth_dev)
+{
+	struct ionic_lif *lif = IONIC_ETH_DEV_TO_LIF(eth_dev);
+	uint32_t rx_mode = lif->rx_mode;
+
+	rx_mode &= ~IONIC_RX_MODE_F_ALLMULTI;
+
+	ionic_set_rx_mode(lif, rx_mode);
+
+	return 0;
+}
 
 int
 ionic_lif_change_mtu(struct ionic_lif *lif, int new_mtu)
@@ -840,16 +1071,23 @@  ionic_lif_init(struct ionic_lif *lif)
 	if (err)
 		goto err_out_notifyq_deinit;
 
-	err = ionic_station_set(lif);
+	err = ionic_rx_filters_init(lif);
 	if (err)
 		goto err_out_notifyq_deinit;
 
+	err = ionic_station_set(lif);
+	if (err)
+		goto err_out_rx_filter_deinit;
+
 	ionic_lif_set_name(lif);
 
 	lif->state |= IONIC_LIF_F_INITED;
 
 	return 0;
 
+err_out_rx_filter_deinit:
+	ionic_rx_filters_deinit(lif);
+
 err_out_notifyq_deinit:
 	ionic_lif_qcq_deinit(lif, lif->notifyqcq);
 
@@ -865,6 +1103,7 @@  ionic_lif_deinit(struct ionic_lif *lif)
 	if (!(lif->state & IONIC_LIF_F_INITED))
 		return;
 
+	ionic_rx_filters_deinit(lif);
 	ionic_lif_qcq_deinit(lif, lif->notifyqcq);
 	ionic_lif_qcq_deinit(lif, lif->adminqcq);
 
diff --git a/drivers/net/ionic/ionic_lif.h b/drivers/net/ionic/ionic_lif.h
index 9dbc54e27..e0863c5de 100644
--- a/drivers/net/ionic/ionic_lif.h
+++ b/drivers/net/ionic/ionic_lif.h
@@ -12,6 +12,7 @@ 
 
 #include "ionic_osdep.h"
 #include "ionic_dev.h"
+#include "ionic_rx_filter.h"
 
 #define IONIC_ADMINQ_LENGTH	16	/* must be a power of two */
 #define IONIC_NOTIFYQ_LENGTH	64	/* must be a power of two */
@@ -53,6 +54,7 @@  struct ionic_lif {
 	rte_spinlock_t adminq_service_lock;
 	struct ionic_qcq *adminqcq;
 	struct ionic_qcq *notifyqcq;
+	struct ionic_rx_filters rx_filters;
 	struct ionic_doorbell __iomem *kern_dbpage;
 	uint64_t last_eid;
 	uint64_t features;
@@ -91,6 +93,20 @@  int ionic_qcq_service(struct ionic_qcq *qcq, int budget, ionic_cq_cb cb,
 
 int ionic_lif_change_mtu(struct ionic_lif *lif, int new_mtu);
 
+int ionic_dev_add_mac(struct rte_eth_dev *eth_dev,
+	struct rte_ether_addr *mac_addr,
+	uint32_t index __rte_unused, uint32_t pool __rte_unused);
+void ionic_dev_remove_mac(struct rte_eth_dev *eth_dev,
+	uint32_t index __rte_unused);
+int ionic_dev_set_mac(struct rte_eth_dev *eth_dev,
+	struct rte_ether_addr *mac_addr);
+int ionic_dev_vlan_filter_set(struct rte_eth_dev *eth_dev, uint16_t vlan_id,
+	int on);
+int ionic_dev_promiscuous_enable(struct rte_eth_dev *dev);
+int ionic_dev_promiscuous_disable(struct rte_eth_dev *dev);
+int ionic_dev_allmulticast_enable(struct rte_eth_dev *dev);
+int ionic_dev_allmulticast_disable(struct rte_eth_dev *dev);
+
 void ionic_qcq_free(struct ionic_qcq *qcq);
 
 int ionic_qcq_enable(struct ionic_qcq *qcq);
diff --git a/drivers/net/ionic/ionic_rx_filter.c b/drivers/net/ionic/ionic_rx_filter.c
new file mode 100644
index 000000000..00b5cee49
--- /dev/null
+++ b/drivers/net/ionic/ionic_rx_filter.c
@@ -0,0 +1,139 @@ 
+/* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0)
+ * Copyright(c) 2018-2019 Pensando Systems, Inc. All rights reserved.
+ */
+
+#include <errno.h>
+
+#include <rte_malloc.h>
+
+#include "ionic_lif.h"
+#include "ionic_rx_filter.h"
+
+void
+ionic_rx_filter_free(struct ionic_rx_filter *f)
+{
+	LIST_REMOVE(f, by_id);
+	LIST_REMOVE(f, by_hash);
+	rte_free(f);
+}
+
+int
+ionic_rx_filter_del(struct ionic_lif *lif, struct ionic_rx_filter *f)
+{
+	struct ionic_admin_ctx ctx = {
+		.pending_work = true,
+		.cmd.rx_filter_del = {
+			.opcode = IONIC_CMD_RX_FILTER_DEL,
+			.filter_id = f->filter_id,
+		},
+	};
+
+	return ionic_adminq_post(lif, &ctx);
+}
+
+int
+ionic_rx_filters_init(struct ionic_lif *lif)
+{
+	uint32_t i;
+
+	rte_spinlock_init(&lif->rx_filters.lock);
+
+	for (i = 0; i < IONIC_RX_FILTER_HLISTS; i++) {
+		LIST_INIT(&lif->rx_filters.by_hash[i]);
+		LIST_INIT(&lif->rx_filters.by_id[i]);
+	}
+
+	return 0;
+}
+
+void
+ionic_rx_filters_deinit(struct ionic_lif *lif)
+{
+	struct ionic_rx_filter *f;
+	uint32_t i;
+
+	for (i = 0; i < IONIC_RX_FILTER_HLISTS; i++) {
+		while (!LIST_EMPTY(&lif->rx_filters.by_id[i])) {
+			f = LIST_FIRST(&lif->rx_filters.by_id[i]);
+			ionic_rx_filter_free(f);
+		}
+	}
+}
+
+int
+ionic_rx_filter_save(struct ionic_lif *lif, uint32_t flow_id,
+		uint16_t rxq_index, struct ionic_admin_ctx *ctx)
+{
+	struct ionic_rx_filter *f;
+	uint32_t key;
+
+	f = rte_zmalloc("ionic", sizeof(*f), 0);
+
+	if (!f)
+		return -ENOMEM;
+
+	f->flow_id = flow_id;
+	f->filter_id = ctx->comp.rx_filter_add.filter_id;
+	f->rxq_index = rxq_index;
+	memcpy(&f->cmd, &ctx->cmd, sizeof(f->cmd));
+
+	switch (f->cmd.match) {
+	case IONIC_RX_FILTER_MATCH_VLAN:
+		key = f->cmd.vlan.vlan & IONIC_RX_FILTER_HLISTS_MASK;
+		break;
+	case IONIC_RX_FILTER_MATCH_MAC:
+		key = *(uint32_t *)f->cmd.mac.addr &
+			IONIC_RX_FILTER_HLISTS_MASK;
+		break;
+	case IONIC_RX_FILTER_MATCH_MAC_VLAN:
+		key = f->cmd.mac_vlan.vlan & IONIC_RX_FILTER_HLISTS_MASK;
+		break;
+	default:
+		return -EINVAL;
+	}
+
+	rte_spinlock_lock(&lif->rx_filters.lock);
+
+	LIST_INSERT_HEAD(&lif->rx_filters.by_hash[key], f, by_hash);
+
+	key = f->filter_id & IONIC_RX_FILTER_HLISTS_MASK;
+
+	LIST_INSERT_HEAD(&lif->rx_filters.by_id[key], f, by_id);
+
+	rte_spinlock_unlock(&lif->rx_filters.lock);
+
+	return 0;
+}
+
+struct ionic_rx_filter *
+ionic_rx_filter_by_vlan(struct ionic_lif *lif, uint16_t vid)
+{
+	uint32_t key = vid & IONIC_RX_FILTER_HLISTS_MASK;
+	struct ionic_rx_filter *f;
+
+	LIST_FOREACH(f, &lif->rx_filters.by_hash[key], by_hash) {
+		if (f->cmd.match != IONIC_RX_FILTER_MATCH_VLAN)
+			continue;
+		if (f->cmd.vlan.vlan == vid)
+			return f;
+	}
+
+	return NULL;
+}
+
+struct ionic_rx_filter *
+ionic_rx_filter_by_addr(struct ionic_lif *lif, const uint8_t *addr)
+{
+	const uint32_t key = *(const uint32_t *)addr &
+		IONIC_RX_FILTER_HLISTS_MASK;
+	struct ionic_rx_filter *f;
+
+	LIST_FOREACH(f, &lif->rx_filters.by_hash[key], by_hash) {
+		if (f->cmd.match != IONIC_RX_FILTER_MATCH_MAC)
+			continue;
+		if (memcmp(addr, f->cmd.mac.addr, RTE_ETHER_ADDR_LEN) == 0)
+			return f;
+	}
+
+	return NULL;
+}
diff --git a/drivers/net/ionic/ionic_rx_filter.h b/drivers/net/ionic/ionic_rx_filter.h
new file mode 100644
index 000000000..6204a7b53
--- /dev/null
+++ b/drivers/net/ionic/ionic_rx_filter.h
@@ -0,0 +1,47 @@ 
+/* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0)
+ * Copyright(c) 2018-2019 Pensando Systems, Inc. All rights reserved.
+ */
+
+#ifndef _IONIC_RX_FILTER_H_
+#define _IONIC_RX_FILTER_H_
+
+#include <rte_spinlock.h>
+
+#include "ionic_osdep.h"
+#include "ionic_if.h"
+
+#define IONIC_RXQ_INDEX_ANY		(0xFFFF)
+struct ionic_rx_filter {
+	uint32_t flow_id;
+	uint32_t filter_id;
+	uint16_t rxq_index;
+	struct ionic_rx_filter_add_cmd cmd;
+	LIST_ENTRY(ionic_rx_filter) by_hash;
+	LIST_ENTRY(ionic_rx_filter) by_id;
+};
+
+#define IONIC_RX_FILTER_HLISTS	(1 << 10)
+#define IONIC_RX_FILTER_HLISTS_MASK	(IONIC_RX_FILTER_HLISTS - 1)
+struct ionic_rx_filters {
+	rte_spinlock_t lock;
+	LIST_HEAD(rx_filters_by_hash, ionic_rx_filter)
+		by_hash[IONIC_RX_FILTER_HLISTS]; /* by pkt hash */
+	LIST_HEAD(rx_filters_by_id,   ionic_rx_filter)
+		by_id[IONIC_RX_FILTER_HLISTS];   /* by filter_id */
+};
+
+struct ionic_admin_ctx;
+struct ionic_lif;
+
+void ionic_rx_filter_free(struct ionic_rx_filter *f);
+int ionic_rx_filter_del(struct ionic_lif *lif, struct ionic_rx_filter *f);
+int ionic_rx_filters_init(struct ionic_lif *lif);
+void ionic_rx_filters_deinit(struct ionic_lif *lif);
+int ionic_rx_filter_save(struct ionic_lif *lif, uint32_t flow_id,
+	uint16_t rxq_index, struct ionic_admin_ctx *ctx);
+struct ionic_rx_filter *ionic_rx_filter_by_vlan(struct ionic_lif *lif,
+	uint16_t vid);
+struct ionic_rx_filter *ionic_rx_filter_by_addr(struct ionic_lif *lif,
+	const uint8_t *addr);
+
+#endif /* _IONIC_RX_FILTER_H_ */
diff --git a/drivers/net/ionic/meson.build b/drivers/net/ionic/meson.build
index f28016105..ec7246753 100644
--- a/drivers/net/ionic/meson.build
+++ b/drivers/net/ionic/meson.build
@@ -3,6 +3,7 @@ 
 
 sources = files(
 	'ionic_mac_api.c',
+	'ionic_rx_filter.c',
 	'ionic_dev.c',
 	'ionic_ethdev.c',
 	'ionic_lif.c',