Merge branch 'drop_monitor-for-offloaded-paths'

Ido Schimmel says:

====================
Add drop monitor for offloaded data paths

Users have several ways to debug the kernel and understand why a packet
was dropped. For example, using drop monitor and perf. Both utilities
trace kfree_skb(), which is the function called when a packet is freed
as part of a failure. The information provided by these tools is
invaluable when trying to understand the cause of a packet loss.

In recent years, large portions of the kernel data path were offloaded
to capable devices. Today, it is possible to perform L2 and L3
forwarding in hardware, as well as tunneling (IP-in-IP and VXLAN).
Different TC classifiers and actions are also offloaded to capable
devices, at both ingress and egress.

However, when the data path is offloaded it is not possible to achieve
the same level of introspection since packets are dropped by the
underlying device and never reach the kernel.

This patchset aims to solve this by allowing users to monitor packets
that the underlying device decided to drop along with relevant metadata
such as the drop reason and ingress port.

The above is achieved by exposing a fundamental capability of devices
capable of data path offloading - packet trapping. In much the same way
as drop monitor registers its probe function with the kfree_skb()
tracepoint, the device is instructed to pass to the CPU (trap) packets
that it decided to drop in various places in the pipeline.

The configuration of the device to pass such packets to the CPU is
performed using devlink, as it is not specific to a port, but rather to
a device. In the future, we plan to control the policing of such packets
using devlink, in order not to overwhelm the CPU.

While devlink is used as the control path, the dropped packets are
passed along with metadata to drop monitor, which reports them to
userspace as netlink events. This allows users to use the same interface
for the monitoring of both software and hardware drops.

Logically, the solution looks as follows:

                                    Netlink event: Packet w/ metadata
                                                   Or a summary of recent drops
                                  ^
                                  |
         Userspace                |
        +---------------------------------------------------+
         Kernel                   |
                                  |
                          +-------+--------+
                          |                |
                          |  drop_monitor  |
                          |                |
                          +-------^--------+
                                  |
                                  |
                                  |
                             +----+----+
                             |         |      Kernel's Rx path
                             | devlink |      (non-drop traps)
                             |         |
                             +----^----+      ^
                                  |           |
                                  +-----------+
                                  |
                          +-------+-------+
                          |               |
                          | Device driver |
                          |               |
                          +-------^-------+
         Kernel                   |
        +---------------------------------------------------+
         Hardware                 |
                                  | Trapped packet
                                  |
                               +--+---+
                               |      |
                               | ASIC |
                               |      |
                               +------+

In order to reduce the patch count, this patchset only includes
integration with netdevsim. A follow-up patchset will add devlink-trap
support in mlxsw.

Patches #1-#7 extend drop monitor to also monitor hardware originated
drops.

Patches #8-#10 add the devlink-trap infrastructure.

Patches #11-#12 add devlink-trap support in netdevsim.

Patches #13-#16 add tests for the generic infrastructure over netdevsim.

Example
=======

Instantiate netdevsim
---------------------

List supported traps
--------------------

netdevsim/netdevsim10:
  name source_mac_is_multicast type drop generic true action drop group l2_drops
  name vlan_tag_mismatch type drop generic true action drop group l2_drops
  name ingress_vlan_filter type drop generic true action drop group l2_drops
  name ingress_spanning_tree_filter type drop generic true action drop group l2_drops
  name port_list_is_empty type drop generic true action drop group l2_drops
  name port_loopback_filter type drop generic true action drop group l2_drops
  name fid_miss type exception generic false action trap group l2_drops
  name blackhole_route type drop generic true action drop group l3_drops
  name ttl_value_is_too_small type exception generic true action trap group l3_drops
  name tail_drop type drop generic true action drop group buffer_drops

Enable a trap
-------------

Query statistics
----------------

netdevsim/netdevsim10:
  name blackhole_route type drop generic true action trap group l3_drops
    stats:
        rx:
          bytes 7384 packets 52

Monitor dropped packets
-----------------------

dropwatch> set alertmode packet
Setting alert mode
Alert mode successfully set
dropwatch> set sw true
setting software drops monitoring to 1
dropwatch> set hw true
setting hardware drops monitoring to 1
dropwatch> start
Enabling monitoring...
Kernel monitoring activated.
Issue Ctrl-C to stop monitoring
drop at: ttl_value_is_too_small (l3_drops)
origin: hardware
input port ifindex: 55
input port name: eth0
timestamp: Mon Aug 12 10:52:20 2019 445911505 nsec
protocol: 0x800
length: 142
original length: 142

drop at: ip6_mc_input+0x8b8/0xef8 (0xffffffff9e2bb0e8)
origin: software
input port ifindex: 4
timestamp: Mon Aug 12 10:53:37 2019 024444587 nsec
protocol: 0x86dd
length: 110
original length: 110

Future plans
============

* Provide more drop reasons as well as more metadata
* Add dropmon support to libpcap, so that tcpdump/tshark could
  specifically listen on dropmon traffic, instead of capturing all
  netlink packets via nlmon interface

Changes in v3:
* Place test with the rest of the netdevsim tests
* Fix test to load netdevsim module
* Move devlink helpers from the test to devlink_lib.sh. Will be used
  by mlxsw tests
* Re-order netdevsim includes in alphabetical order
* Fix reverse xmas tree in netdevsim
* Remove double include in netdevsim

Changes in v2:
* Use drop monitor to report dropped packets instead of devlink
* Add drop monitor patches
* Add test cases
====================

Signed-off-by: David S. Miller <davem@davemloft.net>

1 files changed, 1075 insertions, 5 deletions

diff --git a/net/core/devlink.c b/net/core/devlink.c
index d3dbb904bf3b..650f36379203 100644
--- a/net/core/devlink.c
+++ b/net/core/devlink.c
@@ -18,6 +18,8 @@
 #include <linux/spinlock.h>
 #include <linux/refcount.h>
 #include <linux/workqueue.h>
+#include <linux/u64_stats_sync.h>
+#include <linux/timekeeping.h>
 #include <rdma/ib_verbs.h>
 #include <net/netlink.h>
 #include <net/genetlink.h>
@@ -25,6 +27,7 @@
 #include <net/net_namespace.h>
 #include <net/sock.h>
 #include <net/devlink.h>
+#include <net/drop_monitor.h>
 #define CREATE_TRACE_POINTS
 #include <trace/events/devlink.h>
 
@@ -551,7 +554,7 @@ static int devlink_nl_port_fill(struct sk_buff *msg, struct devlink *devlink,
         if (nla_put_u32(msg, DEVLINK_ATTR_PORT_INDEX, devlink_port->index))
                 goto nla_put_failure;
 
-        spin_lock(&devlink_port->type_lock);
+        spin_lock_bh(&devlink_port->type_lock);
         if (nla_put_u16(msg, DEVLINK_ATTR_PORT_TYPE, devlink_port->type))
                 goto nla_put_failure_type_locked;
         if (devlink_port->desired_type != DEVLINK_PORT_TYPE_NOTSET &&
@@ -576,7 +579,7 @@ static int devlink_nl_port_fill(struct sk_buff *msg, struct devlink *devlink,
                                    ibdev->name))
                         goto nla_put_failure_type_locked;
         }
-        spin_unlock(&devlink_port->type_lock);
+        spin_unlock_bh(&devlink_port->type_lock);
         if (devlink_nl_port_attrs_put(msg, devlink_port))
                 goto nla_put_failure;
 
@@ -584,7 +587,7 @@ static int devlink_nl_port_fill(struct sk_buff *msg, struct devlink *devlink,
         return 0;
 
 nla_put_failure_type_locked:
-        spin_unlock(&devlink_port->type_lock);
+        spin_unlock_bh(&devlink_port->type_lock);
 nla_put_failure:
         genlmsg_cancel(msg, hdr);
         return -EMSGSIZE;
@@ -5154,6 +5157,571 @@ devlink_nl_cmd_health_reporter_dump_clear_doit(struct sk_buff *skb,
         return 0;
 }
 
+struct devlink_stats {
+        u64 rx_bytes;
+        u64 rx_packets;
+        struct u64_stats_sync syncp;
+};
+
+/**
+ * struct devlink_trap_group_item - Packet trap group attributes.
+ * @group: Immutable packet trap group attributes.
+ * @refcount: Number of trap items using the group.
+ * @list: trap_group_list member.
+ * @stats: Trap group statistics.
+ *
+ * Describes packet trap group attributes. Created by devlink during trap
+ * registration.
+ */
+struct devlink_trap_group_item {
+        const struct devlink_trap_group *group;
+        refcount_t refcount;
+        struct list_head list;
+        struct devlink_stats __percpu *stats;
+};
+
+/**
+ * struct devlink_trap_item - Packet trap attributes.
+ * @trap: Immutable packet trap attributes.
+ * @group_item: Associated group item.
+ * @list: trap_list member.
+ * @action: Trap action.
+ * @stats: Trap statistics.
+ * @priv: Driver private information.
+ *
+ * Describes both mutable and immutable packet trap attributes. Created by
+ * devlink during trap registration and used for all trap related operations.
+ */
+struct devlink_trap_item {
+        const struct devlink_trap *trap;
+        struct devlink_trap_group_item *group_item;
+        struct list_head list;
+        enum devlink_trap_action action;
+        struct devlink_stats __percpu *stats;
+        void *priv;
+};
+
+static struct devlink_trap_item *
+devlink_trap_item_lookup(struct devlink *devlink, const char *name)
+{
+        struct devlink_trap_item *trap_item;
+
+        list_for_each_entry(trap_item, &devlink->trap_list, list) {
+                if (!strcmp(trap_item->trap->name, name))
+                        return trap_item;
+        }
+
+        return NULL;
+}
+
+static struct devlink_trap_item *
+devlink_trap_item_get_from_info(struct devlink *devlink,
+                                struct genl_info *info)
+{
+        struct nlattr *attr;
+
+        if (!info->attrs[DEVLINK_ATTR_TRAP_NAME])
+                return NULL;
+        attr = info->attrs[DEVLINK_ATTR_TRAP_NAME];
+
+        return devlink_trap_item_lookup(devlink, nla_data(attr));
+}
+
+static int
+devlink_trap_action_get_from_info(struct genl_info *info,
+                                  enum devlink_trap_action *p_trap_action)
+{
+        u8 val;
+
+        val = nla_get_u8(info->attrs[DEVLINK_ATTR_TRAP_ACTION]);
+        switch (val) {
+        case DEVLINK_TRAP_ACTION_DROP: /* fall-through */
+        case DEVLINK_TRAP_ACTION_TRAP:
+                *p_trap_action = val;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static int devlink_trap_metadata_put(struct sk_buff *msg,
+                                     const struct devlink_trap *trap)
+{
+        struct nlattr *attr;
+
+        attr = nla_nest_start(msg, DEVLINK_ATTR_TRAP_METADATA);
+        if (!attr)
+                return -EMSGSIZE;
+
+        if ((trap->metadata_cap & DEVLINK_TRAP_METADATA_TYPE_F_IN_PORT) &&
+            nla_put_flag(msg, DEVLINK_ATTR_TRAP_METADATA_TYPE_IN_PORT))
+                goto nla_put_failure;
+
+        nla_nest_end(msg, attr);
+
+        return 0;
+
+nla_put_failure:
+        nla_nest_cancel(msg, attr);
+        return -EMSGSIZE;
+}
+
+static void devlink_trap_stats_read(struct devlink_stats __percpu *trap_stats,
+                                    struct devlink_stats *stats)
+{
+        int i;
+
+        memset(stats, 0, sizeof(*stats));
+        for_each_possible_cpu(i) {
+                struct devlink_stats *cpu_stats;
+                u64 rx_packets, rx_bytes;
+                unsigned int start;
+
+                cpu_stats = per_cpu_ptr(trap_stats, i);
+                do {
+                        start = u64_stats_fetch_begin_irq(&cpu_stats->syncp);
+                        rx_packets = cpu_stats->rx_packets;
+                        rx_bytes = cpu_stats->rx_bytes;
+                } while (u64_stats_fetch_retry_irq(&cpu_stats->syncp, start));
+
+                stats->rx_packets += rx_packets;
+                stats->rx_bytes += rx_bytes;
+        }
+}
+
+static int devlink_trap_stats_put(struct sk_buff *msg,
+                                  struct devlink_stats __percpu *trap_stats)
+{
+        struct devlink_stats stats;
+        struct nlattr *attr;
+
+        devlink_trap_stats_read(trap_stats, &stats);
+
+        attr = nla_nest_start(msg, DEVLINK_ATTR_STATS);
+        if (!attr)
+                return -EMSGSIZE;
+
+        if (nla_put_u64_64bit(msg, DEVLINK_ATTR_STATS_RX_PACKETS,
+                              stats.rx_packets, DEVLINK_ATTR_PAD))
+                goto nla_put_failure;
+
+        if (nla_put_u64_64bit(msg, DEVLINK_ATTR_STATS_RX_BYTES,
+                              stats.rx_bytes, DEVLINK_ATTR_PAD))
+                goto nla_put_failure;
+
+        nla_nest_end(msg, attr);
+
+        return 0;
+
+nla_put_failure:
+        nla_nest_cancel(msg, attr);
+        return -EMSGSIZE;
+}
+
+static int devlink_nl_trap_fill(struct sk_buff *msg, struct devlink *devlink,
+                                const struct devlink_trap_item *trap_item,
+                                enum devlink_command cmd, u32 portid, u32 seq,
+                                int flags)
+{
+        struct devlink_trap_group_item *group_item = trap_item->group_item;
+        void *hdr;
+        int err;
+
+        hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
+        if (!hdr)
+                return -EMSGSIZE;
+
+        if (devlink_nl_put_handle(msg, devlink))
+                goto nla_put_failure;
+
+        if (nla_put_string(msg, DEVLINK_ATTR_TRAP_GROUP_NAME,
+                           group_item->group->name))
+                goto nla_put_failure;
+
+        if (nla_put_string(msg, DEVLINK_ATTR_TRAP_NAME, trap_item->trap->name))
+                goto nla_put_failure;
+
+        if (nla_put_u8(msg, DEVLINK_ATTR_TRAP_TYPE, trap_item->trap->type))
+                goto nla_put_failure;
+
+        if (trap_item->trap->generic &&
+            nla_put_flag(msg, DEVLINK_ATTR_TRAP_GENERIC))
+                goto nla_put_failure;
+
+        if (nla_put_u8(msg, DEVLINK_ATTR_TRAP_ACTION, trap_item->action))
+                goto nla_put_failure;
+
+        err = devlink_trap_metadata_put(msg, trap_item->trap);
+        if (err)
+                goto nla_put_failure;
+
+        err = devlink_trap_stats_put(msg, trap_item->stats);
+        if (err)
+                goto nla_put_failure;
+
+        genlmsg_end(msg, hdr);
+
+        return 0;
+
+nla_put_failure:
+        genlmsg_cancel(msg, hdr);
+        return -EMSGSIZE;
+}
+
+static int devlink_nl_cmd_trap_get_doit(struct sk_buff *skb,
+                                        struct genl_info *info)
+{
+        struct netlink_ext_ack *extack = info->extack;
+        struct devlink *devlink = info->user_ptr[0];
+        struct devlink_trap_item *trap_item;
+        struct sk_buff *msg;
+        int err;
+
+        if (list_empty(&devlink->trap_list))
+                return -EOPNOTSUPP;
+
+        trap_item = devlink_trap_item_get_from_info(devlink, info);
+        if (!trap_item) {
+                NL_SET_ERR_MSG_MOD(extack, "Device did not register this trap");
+                return -ENOENT;
+        }
+
+        msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
+        if (!msg)
+                return -ENOMEM;
+
+        err = devlink_nl_trap_fill(msg, devlink, trap_item,
+                                   DEVLINK_CMD_TRAP_NEW, info->snd_portid,
+                                   info->snd_seq, 0);
+        if (err)
+                goto err_trap_fill;
+
+        return genlmsg_reply(msg, info);
+
+err_trap_fill:
+        nlmsg_free(msg);
+        return err;
+}
+
+static int devlink_nl_cmd_trap_get_dumpit(struct sk_buff *msg,
+                                          struct netlink_callback *cb)
+{
+        struct devlink_trap_item *trap_item;
+        struct devlink *devlink;
+        int start = cb->args[0];
+        int idx = 0;
+        int err;
+
+        mutex_lock(&devlink_mutex);
+        list_for_each_entry(devlink, &devlink_list, list) {
+                if (!net_eq(devlink_net(devlink), sock_net(msg->sk)))
+                        continue;
+                mutex_lock(&devlink->lock);
+                list_for_each_entry(trap_item, &devlink->trap_list, list) {
+                        if (idx < start) {
+                                idx++;
+                                continue;
+                        }
+                        err = devlink_nl_trap_fill(msg, devlink, trap_item,
+                                                   DEVLINK_CMD_TRAP_NEW,
+                                                   NETLINK_CB(cb->skb).portid,
+                                                   cb->nlh->nlmsg_seq,
+                                                   NLM_F_MULTI);
+                        if (err) {
+                                mutex_unlock(&devlink->lock);
+                                goto out;
+                        }
+                        idx++;
+                }
+                mutex_unlock(&devlink->lock);
+        }
+out:
+        mutex_unlock(&devlink_mutex);
+
+        cb->args[0] = idx;
+        return msg->len;
+}
+
+static int __devlink_trap_action_set(struct devlink *devlink,
+                                     struct devlink_trap_item *trap_item,
+                                     enum devlink_trap_action trap_action,
+                                     struct netlink_ext_ack *extack)
+{
+        int err;
+
+        if (trap_item->action != trap_action &&
+            trap_item->trap->type != DEVLINK_TRAP_TYPE_DROP) {
+                NL_SET_ERR_MSG_MOD(extack, "Cannot change action of non-drop traps. Skipping");
+                return 0;
+        }
+
+        err = devlink->ops->trap_action_set(devlink, trap_item->trap,
+                                            trap_action);
+        if (err)
+                return err;
+
+        trap_item->action = trap_action;
+
+        return 0;
+}
+
+static int devlink_trap_action_set(struct devlink *devlink,
+                                   struct devlink_trap_item *trap_item,
+                                   struct genl_info *info)
+{
+        enum devlink_trap_action trap_action;
+        int err;
+
+        if (!info->attrs[DEVLINK_ATTR_TRAP_ACTION])
+                return 0;
+
+        err = devlink_trap_action_get_from_info(info, &trap_action);
+        if (err) {
+                NL_SET_ERR_MSG_MOD(info->extack, "Invalid trap action");
+                return -EINVAL;
+        }
+
+        return __devlink_trap_action_set(devlink, trap_item, trap_action,
+                                         info->extack);
+}
+
+static int devlink_nl_cmd_trap_set_doit(struct sk_buff *skb,
+                                        struct genl_info *info)
+{
+        struct netlink_ext_ack *extack = info->extack;
+        struct devlink *devlink = info->user_ptr[0];
+        struct devlink_trap_item *trap_item;
+        int err;
+
+        if (list_empty(&devlink->trap_list))
+                return -EOPNOTSUPP;
+
+        trap_item = devlink_trap_item_get_from_info(devlink, info);
+        if (!trap_item) {
+                NL_SET_ERR_MSG_MOD(extack, "Device did not register this trap");
+                return -ENOENT;
+        }
+
+        err = devlink_trap_action_set(devlink, trap_item, info);
+        if (err)
+                return err;
+
+        return 0;
+}
+
+static struct devlink_trap_group_item *
+devlink_trap_group_item_lookup(struct devlink *devlink, const char *name)
+{
+        struct devlink_trap_group_item *group_item;
+
+        list_for_each_entry(group_item, &devlink->trap_group_list, list) {
+                if (!strcmp(group_item->group->name, name))
+                        return group_item;
+        }
+
+        return NULL;
+}
+
+static struct devlink_trap_group_item *
+devlink_trap_group_item_get_from_info(struct devlink *devlink,
+                                      struct genl_info *info)
+{
+        char *name;
+
+        if (!info->attrs[DEVLINK_ATTR_TRAP_GROUP_NAME])
+                return NULL;
+        name = nla_data(info->attrs[DEVLINK_ATTR_TRAP_GROUP_NAME]);
+
+        return devlink_trap_group_item_lookup(devlink, name);
+}
+
+static int
+devlink_nl_trap_group_fill(struct sk_buff *msg, struct devlink *devlink,
+                           const struct devlink_trap_group_item *group_item,
+                           enum devlink_command cmd, u32 portid, u32 seq,
+                           int flags)
+{
+        void *hdr;
+        int err;
+
+        hdr = genlmsg_put(msg, portid, seq, &devlink_nl_family, flags, cmd);
+        if (!hdr)
+                return -EMSGSIZE;
+
+        if (devlink_nl_put_handle(msg, devlink))
+                goto nla_put_failure;
+
+        if (nla_put_string(msg, DEVLINK_ATTR_TRAP_GROUP_NAME,
+                           group_item->group->name))
+                goto nla_put_failure;
+
+        if (group_item->group->generic &&
+            nla_put_flag(msg, DEVLINK_ATTR_TRAP_GENERIC))
+                goto nla_put_failure;
+
+        err = devlink_trap_stats_put(msg, group_item->stats);
+        if (err)
+                goto nla_put_failure;
+
+        genlmsg_end(msg, hdr);
+
+        return 0;
+
+nla_put_failure:
+        genlmsg_cancel(msg, hdr);
+        return -EMSGSIZE;
+}
+
+static int devlink_nl_cmd_trap_group_get_doit(struct sk_buff *skb,
+                                              struct genl_info *info)
+{
+        struct netlink_ext_ack *extack = info->extack;
+        struct devlink *devlink = info->user_ptr[0];
+        struct devlink_trap_group_item *group_item;
+        struct sk_buff *msg;
+        int err;
+
+        if (list_empty(&devlink->trap_group_list))
+                return -EOPNOTSUPP;
+
+        group_item = devlink_trap_group_item_get_from_info(devlink, info);
+        if (!group_item) {
+                NL_SET_ERR_MSG_MOD(extack, "Device did not register this trap group");
+                return -ENOENT;
+        }
+
+        msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
+        if (!msg)
+                return -ENOMEM;
+
+        err = devlink_nl_trap_group_fill(msg, devlink, group_item,
+                                         DEVLINK_CMD_TRAP_GROUP_NEW,
+                                         info->snd_portid, info->snd_seq, 0);
+        if (err)
+                goto err_trap_group_fill;
+
+        return genlmsg_reply(msg, info);
+
+err_trap_group_fill:
+        nlmsg_free(msg);
+        return err;
+}
+
+static int devlink_nl_cmd_trap_group_get_dumpit(struct sk_buff *msg,
+                                                struct netlink_callback *cb)
+{
+        enum devlink_command cmd = DEVLINK_CMD_TRAP_GROUP_NEW;
+        struct devlink_trap_group_item *group_item;
+        u32 portid = NETLINK_CB(cb->skb).portid;
+        struct devlink *devlink;
+        int start = cb->args[0];
+        int idx = 0;
+        int err;
+
+        mutex_lock(&devlink_mutex);
+        list_for_each_entry(devlink, &devlink_list, list) {
+                if (!net_eq(devlink_net(devlink), sock_net(msg->sk)))
+                        continue;
+                mutex_lock(&devlink->lock);
+                list_for_each_entry(group_item, &devlink->trap_group_list,
+                                    list) {
+                        if (idx < start) {
+                                idx++;
+                                continue;
+                        }
+                        err = devlink_nl_trap_group_fill(msg, devlink,
+                                                         group_item, cmd,
+                                                         portid,
+                                                         cb->nlh->nlmsg_seq,
+                                                         NLM_F_MULTI);
+                        if (err) {
+                                mutex_unlock(&devlink->lock);
+                                goto out;
+                        }
+                        idx++;
+                }
+                mutex_unlock(&devlink->lock);
+        }
+out:
+        mutex_unlock(&devlink_mutex);
+
+        cb->args[0] = idx;
+        return msg->len;
+}
+
+static int
+__devlink_trap_group_action_set(struct devlink *devlink,
+                                struct devlink_trap_group_item *group_item,
+                                enum devlink_trap_action trap_action,
+                                struct netlink_ext_ack *extack)
+{
+        const char *group_name = group_item->group->name;
+        struct devlink_trap_item *trap_item;
+        int err;
+
+        list_for_each_entry(trap_item, &devlink->trap_list, list) {
+                if (strcmp(trap_item->trap->group.name, group_name))
+                        continue;
+                err = __devlink_trap_action_set(devlink, trap_item,
+                                                trap_action, extack);
+                if (err)
+                        return err;
+        }
+
+        return 0;
+}
+
+static int
+devlink_trap_group_action_set(struct devlink *devlink,
+                              struct devlink_trap_group_item *group_item,
+                              struct genl_info *info)
+{
+        enum devlink_trap_action trap_action;
+        int err;
+
+        if (!info->attrs[DEVLINK_ATTR_TRAP_ACTION])
+                return 0;
+
+        err = devlink_trap_action_get_from_info(info, &trap_action);
+        if (err) {
+                NL_SET_ERR_MSG_MOD(info->extack, "Invalid trap action");
+                return -EINVAL;
+        }
+
+        err = __devlink_trap_group_action_set(devlink, group_item, trap_action,
+                                              info->extack);
+        if (err)
+                return err;
+
+        return 0;
+}
+
+static int devlink_nl_cmd_trap_group_set_doit(struct sk_buff *skb,
+                                              struct genl_info *info)
+{
+        struct netlink_ext_ack *extack = info->extack;
+        struct devlink *devlink = info->user_ptr[0];
+        struct devlink_trap_group_item *group_item;
+        int err;
+
+        if (list_empty(&devlink->trap_group_list))
+                return -EOPNOTSUPP;
+
+        group_item = devlink_trap_group_item_get_from_info(devlink, info);
+        if (!group_item) {
+                NL_SET_ERR_MSG_MOD(extack, "Device did not register this trap group");
+                return -ENOENT;
+        }
+
+        err = devlink_trap_group_action_set(devlink, group_item, info);
+        if (err)
+                return err;
+
+        return 0;
+}
+
 static const struct nla_policy devlink_nl_policy[DEVLINK_ATTR_MAX + 1] = {
         [DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING },
         [DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING },
@@ -5184,6 +5752,9 @@ static const struct nla_policy devlink_nl_policy[DEVLINK_ATTR_MAX + 1] = {
         [DEVLINK_ATTR_HEALTH_REPORTER_AUTO_RECOVER] = { .type = NLA_U8 },
         [DEVLINK_ATTR_FLASH_UPDATE_FILE_NAME] = { .type = NLA_NUL_STRING },
         [DEVLINK_ATTR_FLASH_UPDATE_COMPONENT] = { .type = NLA_NUL_STRING },
+        [DEVLINK_ATTR_TRAP_NAME] = { .type = NLA_NUL_STRING },
+        [DEVLINK_ATTR_TRAP_ACTION] = { .type = NLA_U8 },
+        [DEVLINK_ATTR_TRAP_GROUP_NAME] = { .type = NLA_NUL_STRING },
 };
 
 static const struct genl_ops devlink_nl_ops[] = {
@@ -5483,6 +6054,32 @@ static const struct genl_ops devlink_nl_ops[] = {
                 .flags = GENL_ADMIN_PERM,
                 .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK,
         },
+        {
+                .cmd = DEVLINK_CMD_TRAP_GET,
+                .doit = devlink_nl_cmd_trap_get_doit,
+                .dumpit = devlink_nl_cmd_trap_get_dumpit,
+                .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK,
+                /* can be retrieved by unprivileged users */
+        },
+        {
+                .cmd = DEVLINK_CMD_TRAP_SET,
+                .doit = devlink_nl_cmd_trap_set_doit,
+                .flags = GENL_ADMIN_PERM,
+                .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK,
+        },
+        {
+                .cmd = DEVLINK_CMD_TRAP_GROUP_GET,
+                .doit = devlink_nl_cmd_trap_group_get_doit,
+                .dumpit = devlink_nl_cmd_trap_group_get_dumpit,
+                .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK,
+                /* can be retrieved by unprivileged users */
+        },
+        {
+                .cmd = DEVLINK_CMD_TRAP_GROUP_SET,
+                .doit = devlink_nl_cmd_trap_group_set_doit,
+                .flags = GENL_ADMIN_PERM,
+                .internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK,
+        },
 };
 
 static struct genl_family devlink_nl_family __ro_after_init = {
@@ -5528,6 +6125,8 @@ struct devlink *devlink_alloc(const struct devlink_ops *ops, size_t priv_size)
         INIT_LIST_HEAD(&devlink->param_list);
         INIT_LIST_HEAD(&devlink->region_list);
         INIT_LIST_HEAD(&devlink->reporter_list);
+        INIT_LIST_HEAD(&devlink->trap_list);
+        INIT_LIST_HEAD(&devlink->trap_group_list);
         mutex_init(&devlink->lock);
         mutex_init(&devlink->reporters_lock);
         return devlink;
@@ -5574,6 +6173,8 @@ void devlink_free(struct devlink *devlink)
 {
         mutex_destroy(&devlink->reporters_lock);
         mutex_destroy(&devlink->lock);
+        WARN_ON(!list_empty(&devlink->trap_group_list));
+        WARN_ON(!list_empty(&devlink->trap_list));
         WARN_ON(!list_empty(&devlink->reporter_list));
         WARN_ON(!list_empty(&devlink->region_list));
         WARN_ON(!list_empty(&devlink->param_list));
@@ -5678,10 +6279,10 @@ static void __devlink_port_type_set(struct devlink_port *devlink_port,
         if (WARN_ON(!devlink_port->registered))
                 return;
         devlink_port_type_warn_cancel(devlink_port);
-        spin_lock(&devlink_port->type_lock);
+        spin_lock_bh(&devlink_port->type_lock);
         devlink_port->type = type;
         devlink_port->type_dev = type_dev;
-        spin_unlock(&devlink_port->type_lock);
+        spin_unlock_bh(&devlink_port->type_lock);
         devlink_port_notify(devlink_port, DEVLINK_CMD_PORT_NEW);
 }
 
@@ -6834,6 +7435,475 @@ unlock:
 }
 EXPORT_SYMBOL_GPL(devlink_region_snapshot_create);
 
+#define DEVLINK_TRAP(_id, _type)                                              \
+        {                                                                     \
+                .type = DEVLINK_TRAP_TYPE_##_type,                            \
+                .id = DEVLINK_TRAP_GENERIC_ID_##_id,                          \
+                .name = DEVLINK_TRAP_GENERIC_NAME_##_id,                      \
+        }
+
+static const struct devlink_trap devlink_trap_generic[] = {
+        DEVLINK_TRAP(SMAC_MC, DROP),
+        DEVLINK_TRAP(VLAN_TAG_MISMATCH, DROP),
+        DEVLINK_TRAP(INGRESS_VLAN_FILTER, DROP),
+        DEVLINK_TRAP(INGRESS_STP_FILTER, DROP),
+        DEVLINK_TRAP(EMPTY_TX_LIST, DROP),
+        DEVLINK_TRAP(PORT_LOOPBACK_FILTER, DROP),
+        DEVLINK_TRAP(BLACKHOLE_ROUTE, DROP),
+        DEVLINK_TRAP(TTL_ERROR, EXCEPTION),
+        DEVLINK_TRAP(TAIL_DROP, DROP),
+};
+
+#define DEVLINK_TRAP_GROUP(_id)                                               \
+        {                                                                     \
+                .id = DEVLINK_TRAP_GROUP_GENERIC_ID_##_id,                    \
+                .name = DEVLINK_TRAP_GROUP_GENERIC_NAME_##_id,                \
+        }
+
+static const struct devlink_trap_group devlink_trap_group_generic[] = {
+        DEVLINK_TRAP_GROUP(L2_DROPS),
+        DEVLINK_TRAP_GROUP(L3_DROPS),
+        DEVLINK_TRAP_GROUP(BUFFER_DROPS),
+};
+
+static int devlink_trap_generic_verify(const struct devlink_trap *trap)
+{
+        if (trap->id > DEVLINK_TRAP_GENERIC_ID_MAX)
+                return -EINVAL;
+
+        if (strcmp(trap->name, devlink_trap_generic[trap->id].name))
+                return -EINVAL;
+
+        if (trap->type != devlink_trap_generic[trap->id].type)
+                return -EINVAL;
+
+        return 0;
+}
+
+static int devlink_trap_driver_verify(const struct devlink_trap *trap)
+{
+        int i;
+
+        if (trap->id <= DEVLINK_TRAP_GENERIC_ID_MAX)
+                return -EINVAL;
+
+        for (i = 0; i < ARRAY_SIZE(devlink_trap_generic); i++) {
+                if (!strcmp(trap->name, devlink_trap_generic[i].name))
+                        return -EEXIST;
+        }
+
+        return 0;
+}
+
+static int devlink_trap_verify(const struct devlink_trap *trap)
+{
+        if (!trap || !trap->name || !trap->group.name)
+                return -EINVAL;
+
+        if (trap->generic)
+                return devlink_trap_generic_verify(trap);
+        else
+                return devlink_trap_driver_verify(trap);
+}
+
+static int
+devlink_trap_group_generic_verify(const struct devlink_trap_group *group)
+{
+        if (group->id > DEVLINK_TRAP_GROUP_GENERIC_ID_MAX)
+                return -EINVAL;
+
+        if (strcmp(group->name, devlink_trap_group_generic[group->id].name))
+                return -EINVAL;
+
+        return 0;
+}
+
+static int
+devlink_trap_group_driver_verify(const struct devlink_trap_group *group)
+{
+        int i;
+
+        if (group->id <= DEVLINK_TRAP_GROUP_GENERIC_ID_MAX)
+                return -EINVAL;
+
+        for (i = 0; i < ARRAY_SIZE(devlink_trap_group_generic); i++) {
+                if (!strcmp(group->name, devlink_trap_group_generic[i].name))
+                        return -EEXIST;
+        }
+
+        return 0;
+}
+
+static int devlink_trap_group_verify(const struct devlink_trap_group *group)
+{
+        if (group->generic)
+                return devlink_trap_group_generic_verify(group);
+        else
+                return devlink_trap_group_driver_verify(group);
+}
+
+static void
+devlink_trap_group_notify(struct devlink *devlink,
+                          const struct devlink_trap_group_item *group_item,
+                          enum devlink_command cmd)
+{
+        struct sk_buff *msg;
+        int err;
+
+        WARN_ON_ONCE(cmd != DEVLINK_CMD_TRAP_GROUP_NEW &&
+                     cmd != DEVLINK_CMD_TRAP_GROUP_DEL);
+
+        msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
+        if (!msg)
+                return;
+
+        err = devlink_nl_trap_group_fill(msg, devlink, group_item, cmd, 0, 0,
+                                         0);
+        if (err) {
+                nlmsg_free(msg);
+                return;
+        }
+
+        genlmsg_multicast_netns(&devlink_nl_family, devlink_net(devlink),
+                                msg, 0, DEVLINK_MCGRP_CONFIG, GFP_KERNEL);
+}
+
+static struct devlink_trap_group_item *
+devlink_trap_group_item_create(struct devlink *devlink,
+                               const struct devlink_trap_group *group)
+{
+        struct devlink_trap_group_item *group_item;
+        int err;
+
+        err = devlink_trap_group_verify(group);
+        if (err)
+                return ERR_PTR(err);
+
+        group_item = kzalloc(sizeof(*group_item), GFP_KERNEL);
+        if (!group_item)
+                return ERR_PTR(-ENOMEM);
+
+        group_item->stats = netdev_alloc_pcpu_stats(struct devlink_stats);
+        if (!group_item->stats) {
+                err = -ENOMEM;
+                goto err_stats_alloc;
+        }
+
+        group_item->group = group;
+        refcount_set(&group_item->refcount, 1);
+
+        if (devlink->ops->trap_group_init) {
+                err = devlink->ops->trap_group_init(devlink, group);
+                if (err)
+                        goto err_group_init;
+        }
+
+        list_add_tail(&group_item->list, &devlink->trap_group_list);
+        devlink_trap_group_notify(devlink, group_item,
+                                  DEVLINK_CMD_TRAP_GROUP_NEW);
+
+        return group_item;
+
+err_group_init:
+        free_percpu(group_item->stats);
+err_stats_alloc:
+        kfree(group_item);
+        return ERR_PTR(err);
+}
+
+static void
+devlink_trap_group_item_destroy(struct devlink *devlink,
+                                struct devlink_trap_group_item *group_item)
+{
+        devlink_trap_group_notify(devlink, group_item,
+                                  DEVLINK_CMD_TRAP_GROUP_DEL);
+        list_del(&group_item->list);
+        free_percpu(group_item->stats);
+        kfree(group_item);
+}
+
+static struct devlink_trap_group_item *
+devlink_trap_group_item_get(struct devlink *devlink,
+                            const struct devlink_trap_group *group)
+{
+        struct devlink_trap_group_item *group_item;
+
+        group_item = devlink_trap_group_item_lookup(devlink, group->name);
+        if (group_item) {
+                refcount_inc(&group_item->refcount);
+                return group_item;
+        }
+
+        return devlink_trap_group_item_create(devlink, group);
+}
+
+static void
+devlink_trap_group_item_put(struct devlink *devlink,
+                            struct devlink_trap_group_item *group_item)
+{
+        if (!refcount_dec_and_test(&group_item->refcount))
+                return;
+
+        devlink_trap_group_item_destroy(devlink, group_item);
+}
+
+static int
+devlink_trap_item_group_link(struct devlink *devlink,
+                             struct devlink_trap_item *trap_item)
+{
+        struct devlink_trap_group_item *group_item;
+
+        group_item = devlink_trap_group_item_get(devlink,
+                                                 &trap_item->trap->group);
+        if (IS_ERR(group_item))
+                return PTR_ERR(group_item);
+
+        trap_item->group_item = group_item;
+
+        return 0;
+}
+
+static void
+devlink_trap_item_group_unlink(struct devlink *devlink,
+                               struct devlink_trap_item *trap_item)
+{
+        devlink_trap_group_item_put(devlink, trap_item->group_item);
+}
+
+static void devlink_trap_notify(struct devlink *devlink,
+                                const struct devlink_trap_item *trap_item,
+                                enum devlink_command cmd)
+{
+        struct sk_buff *msg;
+        int err;
+
+        WARN_ON_ONCE(cmd != DEVLINK_CMD_TRAP_NEW &&
+                     cmd != DEVLINK_CMD_TRAP_DEL);
+
+        msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
+        if (!msg)
+                return;
+
+        err = devlink_nl_trap_fill(msg, devlink, trap_item, cmd, 0, 0, 0);
+        if (err) {
+                nlmsg_free(msg);
+                return;
+        }
+
+        genlmsg_multicast_netns(&devlink_nl_family, devlink_net(devlink),
+                                msg, 0, DEVLINK_MCGRP_CONFIG, GFP_KERNEL);
+}
+
+static int
+devlink_trap_register(struct devlink *devlink,
+                      const struct devlink_trap *trap, void *priv)
+{
+        struct devlink_trap_item *trap_item;
+        int err;
+
+        if (devlink_trap_item_lookup(devlink, trap->name))
+                return -EEXIST;
+
+        trap_item = kzalloc(sizeof(*trap_item), GFP_KERNEL);
+        if (!trap_item)
+                return -ENOMEM;
+
+        trap_item->stats = netdev_alloc_pcpu_stats(struct devlink_stats);
+        if (!trap_item->stats) {
+                err = -ENOMEM;
+                goto err_stats_alloc;
+        }
+
+        trap_item->trap = trap;
+        trap_item->action = trap->init_action;
+        trap_item->priv = priv;
+
+        err = devlink_trap_item_group_link(devlink, trap_item);
+        if (err)
+                goto err_group_link;
+
+        err = devlink->ops->trap_init(devlink, trap, trap_item);
+        if (err)
+                goto err_trap_init;
+
+        list_add_tail(&trap_item->list, &devlink->trap_list);
+        devlink_trap_notify(devlink, trap_item, DEVLINK_CMD_TRAP_NEW);
+
+        return 0;
+
+err_trap_init:
+        devlink_trap_item_group_unlink(devlink, trap_item);
+err_group_link:
+        free_percpu(trap_item->stats);
+err_stats_alloc:
+        kfree(trap_item);
+        return err;
+}
+
+static void devlink_trap_unregister(struct devlink *devlink,
+                                    const struct devlink_trap *trap)
+{
+        struct devlink_trap_item *trap_item;
+
+        trap_item = devlink_trap_item_lookup(devlink, trap->name);
+        if (WARN_ON_ONCE(!trap_item))
+                return;
+
+        devlink_trap_notify(devlink, trap_item, DEVLINK_CMD_TRAP_DEL);
+        list_del(&trap_item->list);
+        if (devlink->ops->trap_fini)
+                devlink->ops->trap_fini(devlink, trap, trap_item);
+        devlink_trap_item_group_unlink(devlink, trap_item);
+        free_percpu(trap_item->stats);
+        kfree(trap_item);
+}
+
+static void devlink_trap_disable(struct devlink *devlink,
+                                 const struct devlink_trap *trap)
+{
+        struct devlink_trap_item *trap_item;
+
+        trap_item = devlink_trap_item_lookup(devlink, trap->name);
+        if (WARN_ON_ONCE(!trap_item))
+                return;
+
+        devlink->ops->trap_action_set(devlink, trap, DEVLINK_TRAP_ACTION_DROP);
+        trap_item->action = DEVLINK_TRAP_ACTION_DROP;
+}
+
+/**
+ * devlink_traps_register - Register packet traps with devlink.
+ * @devlink: devlink.
+ * @traps: Packet traps.
+ * @traps_count: Count of provided packet traps.
+ * @priv: Driver private information.
+ *
+ * Return: Non-zero value on failure.
+ */
+int devlink_traps_register(struct devlink *devlink,
+                           const struct devlink_trap *traps,
+                           size_t traps_count, void *priv)
+{
+        int i, err;
+
+        if (!devlink->ops->trap_init || !devlink->ops->trap_action_set)
+                return -EINVAL;
+
+        mutex_lock(&devlink->lock);
+        for (i = 0; i < traps_count; i++) {
+                const struct devlink_trap *trap = &traps[i];
+
+                err = devlink_trap_verify(trap);
+                if (err)
+                        goto err_trap_verify;
+
+                err = devlink_trap_register(devlink, trap, priv);
+                if (err)
+                        goto err_trap_register;
+        }
+        mutex_unlock(&devlink->lock);
+
+        return 0;
+
+err_trap_register:
+err_trap_verify:
+        for (i--; i >= 0; i--)
+                devlink_trap_unregister(devlink, &traps[i]);
+        mutex_unlock(&devlink->lock);
+        return err;
+}
+EXPORT_SYMBOL_GPL(devlink_traps_register);
+
+/**
+ * devlink_traps_unregister - Unregister packet traps from devlink.
+ * @devlink: devlink.
+ * @traps: Packet traps.
+ * @traps_count: Count of provided packet traps.
+ */
+void devlink_traps_unregister(struct devlink *devlink,
+                              const struct devlink_trap *traps,
+                              size_t traps_count)
+{
+        int i;
+
+        mutex_lock(&devlink->lock);
+        /* Make sure we do not have any packets in-flight while unregistering
+         * traps by disabling all of them and waiting for a grace period.
+         */
+        for (i = traps_count - 1; i >= 0; i--)
+                devlink_trap_disable(devlink, &traps[i]);
+        synchronize_rcu();
+        for (i = traps_count - 1; i >= 0; i--)
+                devlink_trap_unregister(devlink, &traps[i]);
+        mutex_unlock(&devlink->lock);
+}
+EXPORT_SYMBOL_GPL(devlink_traps_unregister);
+
+static void
+devlink_trap_stats_update(struct devlink_stats __percpu *trap_stats,
+                          size_t skb_len)
+{
+        struct devlink_stats *stats;
+
+        stats = this_cpu_ptr(trap_stats);
+        u64_stats_update_begin(&stats->syncp);
+        stats->rx_bytes += skb_len;
+        stats->rx_packets++;
+        u64_stats_update_end(&stats->syncp);
+}
+
+static void
+devlink_trap_report_metadata_fill(struct net_dm_hw_metadata *hw_metadata,
+                                  const struct devlink_trap_item *trap_item,
+                                  struct devlink_port *in_devlink_port)
+{
+        struct devlink_trap_group_item *group_item = trap_item->group_item;
+
+        hw_metadata->trap_group_name = group_item->group->name;
+        hw_metadata->trap_name = trap_item->trap->name;
+
+        spin_lock(&in_devlink_port->type_lock);
+        if (in_devlink_port->type == DEVLINK_PORT_TYPE_ETH)
+                hw_metadata->input_dev = in_devlink_port->type_dev;
+        spin_unlock(&in_devlink_port->type_lock);
+}
+
+/**
+ * devlink_trap_report - Report trapped packet to drop monitor.
+ * @devlink: devlink.
+ * @skb: Trapped packet.
+ * @trap_ctx: Trap context.
+ * @in_devlink_port: Input devlink port.
+ */
+void devlink_trap_report(struct devlink *devlink, struct sk_buff *skb,
+                         void *trap_ctx, struct devlink_port *in_devlink_port)
+{
+        struct devlink_trap_item *trap_item = trap_ctx;
+        struct net_dm_hw_metadata hw_metadata = {};
+
+        devlink_trap_stats_update(trap_item->stats, skb->len);
+        devlink_trap_stats_update(trap_item->group_item->stats, skb->len);
+
+        devlink_trap_report_metadata_fill(&hw_metadata, trap_item,
+                                          in_devlink_port);
+        net_dm_hw_report(skb, &hw_metadata);
+}
+EXPORT_SYMBOL_GPL(devlink_trap_report);
+
+/**
+ * devlink_trap_ctx_priv - Trap context to driver private information.
+ * @trap_ctx: Trap context.
+ *
+ * Return: Driver private information passed during registration.
+ */
+void *devlink_trap_ctx_priv(void *trap_ctx)
+{
+        struct devlink_trap_item *trap_item = trap_ctx;
+
+        return trap_item->priv;
+}
+EXPORT_SYMBOL_GPL(devlink_trap_ctx_priv);
+
 static void __devlink_compat_running_version(struct devlink *devlink,
                                              char *buf, size_t len)
 {