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, 701 insertions, 23 deletions

diff --git a/net/core/drop_monitor.c b/net/core/drop_monitor.c
index 39e094907391..bfc024024aa3 100644
--- a/net/core/drop_monitor.c
+++ b/net/core/drop_monitor.c
@@ -26,6 +26,7 @@
 #include <linux/bitops.h>
 #include <linux/slab.h>
 #include <linux/module.h>
+#include <net/drop_monitor.h>
 #include <net/genetlink.h>
 #include <net/netevent.h>
 
@@ -43,6 +44,7 @@
  * netlink alerts
  */
 static int trace_state = TRACE_OFF;
+static bool monitor_hw;
 
 /* net_dm_mutex
  *
@@ -56,9 +58,26 @@ struct net_dm_stats {
         struct u64_stats_sync syncp;
 };
 
+#define NET_DM_MAX_HW_TRAP_NAME_LEN 40
+
+struct net_dm_hw_entry {
+        char trap_name[NET_DM_MAX_HW_TRAP_NAME_LEN];
+        u32 count;
+};
+
+struct net_dm_hw_entries {
+        u32 num_entries;
+        struct net_dm_hw_entry entries[0];
+};
+
 struct per_cpu_dm_data {
-        spinlock_t              lock;   /* Protects 'skb' and 'send_timer' */
-        struct sk_buff          *skb;
+        spinlock_t              lock;   /* Protects 'skb', 'hw_entries' and
+                                         * 'send_timer'
+                                         */
+        union {
+                struct sk_buff                  *skb;
+                struct net_dm_hw_entries        *hw_entries;
+        };
         struct sk_buff_head     drop_queue;
         struct work_struct      dm_alert_work;
         struct timer_list       send_timer;
@@ -76,6 +95,7 @@ struct dm_hw_stat_delta {
 static struct genl_family net_drop_monitor_family;
 
 static DEFINE_PER_CPU(struct per_cpu_dm_data, dm_cpu_data);
+static DEFINE_PER_CPU(struct per_cpu_dm_data, dm_hw_cpu_data);
 
 static int dm_hit_limit = 64;
 static int dm_delay = 1;
@@ -92,10 +112,16 @@ struct net_dm_alert_ops {
         void (*napi_poll_probe)(void *ignore, struct napi_struct *napi,
                                 int work, int budget);
         void (*work_item_func)(struct work_struct *work);
+        void (*hw_work_item_func)(struct work_struct *work);
+        void (*hw_probe)(struct sk_buff *skb,
+                         const struct net_dm_hw_metadata *hw_metadata);
 };
 
 struct net_dm_skb_cb {
-        void *pc;
+        union {
+                struct net_dm_hw_metadata *hw_metadata;
+                void *pc;
+        };
 };
 
 #define NET_DM_SKB_CB(__skb) ((struct net_dm_skb_cb *)&((__skb)->cb[0]))
@@ -266,10 +292,190 @@ static void trace_napi_poll_hit(void *ignore, struct napi_struct *napi,
         rcu_read_unlock();
 }
 
+static struct net_dm_hw_entries *
+net_dm_hw_reset_per_cpu_data(struct per_cpu_dm_data *hw_data)
+{
+        struct net_dm_hw_entries *hw_entries;
+        unsigned long flags;
+
+        hw_entries = kzalloc(struct_size(hw_entries, entries, dm_hit_limit),
+                             GFP_KERNEL);
+        if (!hw_entries) {
+                /* If the memory allocation failed, we try to perform another
+                 * allocation in 1/10 second. Otherwise, the probe function
+                 * will constantly bail out.
+                 */
+                mod_timer(&hw_data->send_timer, jiffies + HZ / 10);
+        }
+
+        spin_lock_irqsave(&hw_data->lock, flags);
+        swap(hw_data->hw_entries, hw_entries);
+        spin_unlock_irqrestore(&hw_data->lock, flags);
+
+        return hw_entries;
+}
+
+static int net_dm_hw_entry_put(struct sk_buff *msg,
+                               const struct net_dm_hw_entry *hw_entry)
+{
+        struct nlattr *attr;
+
+        attr = nla_nest_start(msg, NET_DM_ATTR_HW_ENTRY);
+        if (!attr)
+                return -EMSGSIZE;
+
+        if (nla_put_string(msg, NET_DM_ATTR_HW_TRAP_NAME, hw_entry->trap_name))
+                goto nla_put_failure;
+
+        if (nla_put_u32(msg, NET_DM_ATTR_HW_TRAP_COUNT, hw_entry->count))
+                goto nla_put_failure;
+
+        nla_nest_end(msg, attr);
+
+        return 0;
+
+nla_put_failure:
+        nla_nest_cancel(msg, attr);
+        return -EMSGSIZE;
+}
+
+static int net_dm_hw_entries_put(struct sk_buff *msg,
+                                 const struct net_dm_hw_entries *hw_entries)
+{
+        struct nlattr *attr;
+        int i;
+
+        attr = nla_nest_start(msg, NET_DM_ATTR_HW_ENTRIES);
+        if (!attr)
+                return -EMSGSIZE;
+
+        for (i = 0; i < hw_entries->num_entries; i++) {
+                int rc;
+
+                rc = net_dm_hw_entry_put(msg, &hw_entries->entries[i]);
+                if (rc)
+                        goto nla_put_failure;
+        }
+
+        nla_nest_end(msg, attr);
+
+        return 0;
+
+nla_put_failure:
+        nla_nest_cancel(msg, attr);
+        return -EMSGSIZE;
+}
+
+static int
+net_dm_hw_summary_report_fill(struct sk_buff *msg,
+                              const struct net_dm_hw_entries *hw_entries)
+{
+        struct net_dm_alert_msg anc_hdr = { 0 };
+        void *hdr;
+        int rc;
+
+        hdr = genlmsg_put(msg, 0, 0, &net_drop_monitor_family, 0,
+                          NET_DM_CMD_ALERT);
+        if (!hdr)
+                return -EMSGSIZE;
+
+        /* We need to put the ancillary header in order not to break user
+         * space.
+         */
+        if (nla_put(msg, NLA_UNSPEC, sizeof(anc_hdr), &anc_hdr))
+                goto nla_put_failure;
+
+        rc = net_dm_hw_entries_put(msg, hw_entries);
+        if (rc)
+                goto nla_put_failure;
+
+        genlmsg_end(msg, hdr);
+
+        return 0;
+
+nla_put_failure:
+        genlmsg_cancel(msg, hdr);
+        return -EMSGSIZE;
+}
+
+static void net_dm_hw_summary_work(struct work_struct *work)
+{
+        struct net_dm_hw_entries *hw_entries;
+        struct per_cpu_dm_data *hw_data;
+        struct sk_buff *msg;
+        int rc;
+
+        hw_data = container_of(work, struct per_cpu_dm_data, dm_alert_work);
+
+        hw_entries = net_dm_hw_reset_per_cpu_data(hw_data);
+        if (!hw_entries)
+                return;
+
+        msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
+        if (!msg)
+                goto out;
+
+        rc = net_dm_hw_summary_report_fill(msg, hw_entries);
+        if (rc) {
+                nlmsg_free(msg);
+                goto out;
+        }
+
+        genlmsg_multicast(&net_drop_monitor_family, msg, 0, 0, GFP_KERNEL);
+
+out:
+        kfree(hw_entries);
+}
+
+static void
+net_dm_hw_summary_probe(struct sk_buff *skb,
+                        const struct net_dm_hw_metadata *hw_metadata)
+{
+        struct net_dm_hw_entries *hw_entries;
+        struct net_dm_hw_entry *hw_entry;
+        struct per_cpu_dm_data *hw_data;
+        unsigned long flags;
+        int i;
+
+        hw_data = this_cpu_ptr(&dm_hw_cpu_data);
+        spin_lock_irqsave(&hw_data->lock, flags);
+        hw_entries = hw_data->hw_entries;
+
+        if (!hw_entries)
+                goto out;
+
+        for (i = 0; i < hw_entries->num_entries; i++) {
+                hw_entry = &hw_entries->entries[i];
+                if (!strncmp(hw_entry->trap_name, hw_metadata->trap_name,
+                             NET_DM_MAX_HW_TRAP_NAME_LEN - 1)) {
+                        hw_entry->count++;
+                        goto out;
+                }
+        }
+        if (WARN_ON_ONCE(hw_entries->num_entries == dm_hit_limit))
+                goto out;
+
+        hw_entry = &hw_entries->entries[hw_entries->num_entries];
+        strlcpy(hw_entry->trap_name, hw_metadata->trap_name,
+                NET_DM_MAX_HW_TRAP_NAME_LEN - 1);
+        hw_entry->count = 1;
+        hw_entries->num_entries++;
+
+        if (!timer_pending(&hw_data->send_timer)) {
+                hw_data->send_timer.expires = jiffies + dm_delay * HZ;
+                add_timer(&hw_data->send_timer);
+        }
+
+out:
+        spin_unlock_irqrestore(&hw_data->lock, flags);
+}
+
 static const struct net_dm_alert_ops net_dm_alert_summary_ops = {
         .kfree_skb_probe        = trace_kfree_skb_hit,
         .napi_poll_probe        = trace_napi_poll_hit,
         .work_item_func         = send_dm_alert,
+        .hw_work_item_func      = net_dm_hw_summary_work,
+        .hw_probe               = net_dm_hw_summary_probe,
 };
 
 static void net_dm_packet_trace_kfree_skb_hit(void *ignore,
@@ -323,7 +529,9 @@ static size_t net_dm_in_port_size(void)
                /* NET_DM_ATTR_IN_PORT nest */
         return nla_total_size(0) +
                /* NET_DM_ATTR_PORT_NETDEV_IFINDEX */
-               nla_total_size(sizeof(u32));
+               nla_total_size(sizeof(u32)) +
+               /* NET_DM_ATTR_PORT_NETDEV_NAME */
+               nla_total_size(IFNAMSIZ + 1);
 }
 
 #define NET_DM_MAX_SYMBOL_LEN 40
@@ -335,6 +543,8 @@ static size_t net_dm_packet_report_size(size_t payload_len)
         size = nlmsg_msg_size(GENL_HDRLEN + net_drop_monitor_family.hdrsize);
 
         return NLMSG_ALIGN(size) +
+               /* NET_DM_ATTR_ORIGIN */
+               nla_total_size(sizeof(u16)) +
                /* NET_DM_ATTR_PC */
                nla_total_size(sizeof(u64)) +
                /* NET_DM_ATTR_SYMBOL */
@@ -351,7 +561,8 @@ static size_t net_dm_packet_report_size(size_t payload_len)
                nla_total_size(payload_len);
 }
 
-static int net_dm_packet_report_in_port_put(struct sk_buff *msg, int ifindex)
+static int net_dm_packet_report_in_port_put(struct sk_buff *msg, int ifindex,
+                                            const char *name)
 {
         struct nlattr *attr;
 
@@ -363,6 +574,9 @@ static int net_dm_packet_report_in_port_put(struct sk_buff *msg, int ifindex)
             nla_put_u32(msg, NET_DM_ATTR_PORT_NETDEV_IFINDEX, ifindex))
                 goto nla_put_failure;
 
+        if (name && nla_put_string(msg, NET_DM_ATTR_PORT_NETDEV_NAME, name))
+                goto nla_put_failure;
+
         nla_nest_end(msg, attr);
 
         return 0;
@@ -387,6 +601,9 @@ static int net_dm_packet_report_fill(struct sk_buff *msg, struct sk_buff *skb,
         if (!hdr)
                 return -EMSGSIZE;
 
+        if (nla_put_u16(msg, NET_DM_ATTR_ORIGIN, NET_DM_ORIGIN_SW))
+                goto nla_put_failure;
+
         if (nla_put_u64_64bit(msg, NET_DM_ATTR_PC, pc, NET_DM_ATTR_PAD))
                 goto nla_put_failure;
 
@@ -394,7 +611,7 @@ static int net_dm_packet_report_fill(struct sk_buff *msg, struct sk_buff *skb,
         if (nla_put_string(msg, NET_DM_ATTR_SYMBOL, buf))
                 goto nla_put_failure;
 
-        rc = net_dm_packet_report_in_port_put(msg, skb->skb_iif);
+        rc = net_dm_packet_report_in_port_put(msg, skb->skb_iif, NULL);
         if (rc)
                 goto nla_put_failure;
 
@@ -481,10 +698,250 @@ static void net_dm_packet_work(struct work_struct *work)
                 net_dm_packet_report(skb);
 }
 
+static size_t
+net_dm_hw_packet_report_size(size_t payload_len,
+                             const struct net_dm_hw_metadata *hw_metadata)
+{
+        size_t size;
+
+        size = nlmsg_msg_size(GENL_HDRLEN + net_drop_monitor_family.hdrsize);
+
+        return NLMSG_ALIGN(size) +
+               /* NET_DM_ATTR_ORIGIN */
+               nla_total_size(sizeof(u16)) +
+               /* NET_DM_ATTR_HW_TRAP_GROUP_NAME */
+               nla_total_size(strlen(hw_metadata->trap_group_name) + 1) +
+               /* NET_DM_ATTR_HW_TRAP_NAME */
+               nla_total_size(strlen(hw_metadata->trap_name) + 1) +
+               /* NET_DM_ATTR_IN_PORT */
+               net_dm_in_port_size() +
+               /* NET_DM_ATTR_TIMESTAMP */
+               nla_total_size(sizeof(struct timespec)) +
+               /* NET_DM_ATTR_ORIG_LEN */
+               nla_total_size(sizeof(u32)) +
+               /* NET_DM_ATTR_PROTO */
+               nla_total_size(sizeof(u16)) +
+               /* NET_DM_ATTR_PAYLOAD */
+               nla_total_size(payload_len);
+}
+
+static int net_dm_hw_packet_report_fill(struct sk_buff *msg,
+                                        struct sk_buff *skb, size_t payload_len)
+{
+        struct net_dm_hw_metadata *hw_metadata;
+        struct nlattr *attr;
+        struct timespec ts;
+        void *hdr;
+
+        hw_metadata = NET_DM_SKB_CB(skb)->hw_metadata;
+
+        hdr = genlmsg_put(msg, 0, 0, &net_drop_monitor_family, 0,
+                          NET_DM_CMD_PACKET_ALERT);
+        if (!hdr)
+                return -EMSGSIZE;
+
+        if (nla_put_u16(msg, NET_DM_ATTR_ORIGIN, NET_DM_ORIGIN_HW))
+                goto nla_put_failure;
+
+        if (nla_put_string(msg, NET_DM_ATTR_HW_TRAP_GROUP_NAME,
+                           hw_metadata->trap_group_name))
+                goto nla_put_failure;
+
+        if (nla_put_string(msg, NET_DM_ATTR_HW_TRAP_NAME,
+                           hw_metadata->trap_name))
+                goto nla_put_failure;
+
+        if (hw_metadata->input_dev) {
+                struct net_device *dev = hw_metadata->input_dev;
+                int rc;
+
+                rc = net_dm_packet_report_in_port_put(msg, dev->ifindex,
+                                                      dev->name);
+                if (rc)
+                        goto nla_put_failure;
+        }
+
+        if (ktime_to_timespec_cond(skb->tstamp, &ts) &&
+            nla_put(msg, NET_DM_ATTR_TIMESTAMP, sizeof(ts), &ts))
+                goto nla_put_failure;
+
+        if (nla_put_u32(msg, NET_DM_ATTR_ORIG_LEN, skb->len))
+                goto nla_put_failure;
+
+        if (!payload_len)
+                goto out;
+
+        if (nla_put_u16(msg, NET_DM_ATTR_PROTO, be16_to_cpu(skb->protocol)))
+                goto nla_put_failure;
+
+        attr = skb_put(msg, nla_total_size(payload_len));
+        attr->nla_type = NET_DM_ATTR_PAYLOAD;
+        attr->nla_len = nla_attr_size(payload_len);
+        if (skb_copy_bits(skb, 0, nla_data(attr), payload_len))
+                goto nla_put_failure;
+
+out:
+        genlmsg_end(msg, hdr);
+
+        return 0;
+
+nla_put_failure:
+        genlmsg_cancel(msg, hdr);
+        return -EMSGSIZE;
+}
+
+static struct net_dm_hw_metadata *
+net_dm_hw_metadata_clone(const struct net_dm_hw_metadata *hw_metadata)
+{
+        struct net_dm_hw_metadata *n_hw_metadata;
+        const char *trap_group_name;
+        const char *trap_name;
+
+        n_hw_metadata = kmalloc(sizeof(*hw_metadata), GFP_ATOMIC);
+        if (!n_hw_metadata)
+                return NULL;
+
+        trap_group_name = kmemdup(hw_metadata->trap_group_name,
+                                  strlen(hw_metadata->trap_group_name) + 1,
+                                  GFP_ATOMIC | __GFP_ZERO);
+        if (!trap_group_name)
+                goto free_hw_metadata;
+        n_hw_metadata->trap_group_name = trap_group_name;
+
+        trap_name = kmemdup(hw_metadata->trap_name,
+                            strlen(hw_metadata->trap_name) + 1,
+                            GFP_ATOMIC | __GFP_ZERO);
+        if (!trap_name)
+                goto free_trap_group;
+        n_hw_metadata->trap_name = trap_name;
+
+        n_hw_metadata->input_dev = hw_metadata->input_dev;
+        if (n_hw_metadata->input_dev)
+                dev_hold(n_hw_metadata->input_dev);
+
+        return n_hw_metadata;
+
+free_trap_group:
+        kfree(trap_group_name);
+free_hw_metadata:
+        kfree(n_hw_metadata);
+        return NULL;
+}
+
+static void
+net_dm_hw_metadata_free(const struct net_dm_hw_metadata *hw_metadata)
+{
+        if (hw_metadata->input_dev)
+                dev_put(hw_metadata->input_dev);
+        kfree(hw_metadata->trap_name);
+        kfree(hw_metadata->trap_group_name);
+        kfree(hw_metadata);
+}
+
+static void net_dm_hw_packet_report(struct sk_buff *skb)
+{
+        struct net_dm_hw_metadata *hw_metadata;
+        struct sk_buff *msg;
+        size_t payload_len;
+        int rc;
+
+        if (skb->data > skb_mac_header(skb))
+                skb_push(skb, skb->data - skb_mac_header(skb));
+        else
+                skb_pull(skb, skb_mac_header(skb) - skb->data);
+
+        payload_len = min_t(size_t, skb->len, NET_DM_MAX_PACKET_SIZE);
+        if (net_dm_trunc_len)
+                payload_len = min_t(size_t, net_dm_trunc_len, payload_len);
+
+        hw_metadata = NET_DM_SKB_CB(skb)->hw_metadata;
+        msg = nlmsg_new(net_dm_hw_packet_report_size(payload_len, hw_metadata),
+                        GFP_KERNEL);
+        if (!msg)
+                goto out;
+
+        rc = net_dm_hw_packet_report_fill(msg, skb, payload_len);
+        if (rc) {
+                nlmsg_free(msg);
+                goto out;
+        }
+
+        genlmsg_multicast(&net_drop_monitor_family, msg, 0, 0, GFP_KERNEL);
+
+out:
+        net_dm_hw_metadata_free(NET_DM_SKB_CB(skb)->hw_metadata);
+        consume_skb(skb);
+}
+
+static void net_dm_hw_packet_work(struct work_struct *work)
+{
+        struct per_cpu_dm_data *hw_data;
+        struct sk_buff_head list;
+        struct sk_buff *skb;
+        unsigned long flags;
+
+        hw_data = container_of(work, struct per_cpu_dm_data, dm_alert_work);
+
+        __skb_queue_head_init(&list);
+
+        spin_lock_irqsave(&hw_data->drop_queue.lock, flags);
+        skb_queue_splice_tail_init(&hw_data->drop_queue, &list);
+        spin_unlock_irqrestore(&hw_data->drop_queue.lock, flags);
+
+        while ((skb = __skb_dequeue(&list)))
+                net_dm_hw_packet_report(skb);
+}
+
+static void
+net_dm_hw_packet_probe(struct sk_buff *skb,
+                       const struct net_dm_hw_metadata *hw_metadata)
+{
+        struct net_dm_hw_metadata *n_hw_metadata;
+        ktime_t tstamp = ktime_get_real();
+        struct per_cpu_dm_data *hw_data;
+        struct sk_buff *nskb;
+        unsigned long flags;
+
+        nskb = skb_clone(skb, GFP_ATOMIC);
+        if (!nskb)
+                return;
+
+        n_hw_metadata = net_dm_hw_metadata_clone(hw_metadata);
+        if (!n_hw_metadata)
+                goto free;
+
+        NET_DM_SKB_CB(nskb)->hw_metadata = n_hw_metadata;
+        nskb->tstamp = tstamp;
+
+        hw_data = this_cpu_ptr(&dm_hw_cpu_data);
+
+        spin_lock_irqsave(&hw_data->drop_queue.lock, flags);
+        if (skb_queue_len(&hw_data->drop_queue) < net_dm_queue_len)
+                __skb_queue_tail(&hw_data->drop_queue, nskb);
+        else
+                goto unlock_free;
+        spin_unlock_irqrestore(&hw_data->drop_queue.lock, flags);
+
+        schedule_work(&hw_data->dm_alert_work);
+
+        return;
+
+unlock_free:
+        spin_unlock_irqrestore(&hw_data->drop_queue.lock, flags);
+        u64_stats_update_begin(&hw_data->stats.syncp);
+        hw_data->stats.dropped++;
+        u64_stats_update_end(&hw_data->stats.syncp);
+        net_dm_hw_metadata_free(n_hw_metadata);
+free:
+        consume_skb(nskb);
+}
+
 static const struct net_dm_alert_ops net_dm_alert_packet_ops = {
         .kfree_skb_probe        = net_dm_packet_trace_kfree_skb_hit,
         .napi_poll_probe        = net_dm_packet_trace_napi_poll_hit,
         .work_item_func         = net_dm_packet_work,
+        .hw_work_item_func      = net_dm_hw_packet_work,
+        .hw_probe               = net_dm_hw_packet_probe,
 };
 
 static const struct net_dm_alert_ops *net_dm_alert_ops_arr[] = {
@@ -492,6 +949,85 @@ static const struct net_dm_alert_ops *net_dm_alert_ops_arr[] = {
         [NET_DM_ALERT_MODE_PACKET]      = &net_dm_alert_packet_ops,
 };
 
+void net_dm_hw_report(struct sk_buff *skb,
+                      const struct net_dm_hw_metadata *hw_metadata)
+{
+        rcu_read_lock();
+
+        if (!monitor_hw)
+                goto out;
+
+        net_dm_alert_ops_arr[net_dm_alert_mode]->hw_probe(skb, hw_metadata);
+
+out:
+        rcu_read_unlock();
+}
+EXPORT_SYMBOL_GPL(net_dm_hw_report);
+
+static int net_dm_hw_monitor_start(struct netlink_ext_ack *extack)
+{
+        const struct net_dm_alert_ops *ops;
+        int cpu;
+
+        if (monitor_hw) {
+                NL_SET_ERR_MSG_MOD(extack, "Hardware monitoring already enabled");
+                return -EAGAIN;
+        }
+
+        ops = net_dm_alert_ops_arr[net_dm_alert_mode];
+
+        if (!try_module_get(THIS_MODULE)) {
+                NL_SET_ERR_MSG_MOD(extack, "Failed to take reference on module");
+                return -ENODEV;
+        }
+
+        for_each_possible_cpu(cpu) {
+                struct per_cpu_dm_data *hw_data = &per_cpu(dm_hw_cpu_data, cpu);
+                struct net_dm_hw_entries *hw_entries;
+
+                INIT_WORK(&hw_data->dm_alert_work, ops->hw_work_item_func);
+                timer_setup(&hw_data->send_timer, sched_send_work, 0);
+                hw_entries = net_dm_hw_reset_per_cpu_data(hw_data);
+                kfree(hw_entries);
+        }
+
+        monitor_hw = true;
+
+        return 0;
+}
+
+static void net_dm_hw_monitor_stop(struct netlink_ext_ack *extack)
+{
+        int cpu;
+
+        if (!monitor_hw)
+                NL_SET_ERR_MSG_MOD(extack, "Hardware monitoring already disabled");
+
+        monitor_hw = false;
+
+        /* After this call returns we are guaranteed that no CPU is processing
+         * any hardware drops.
+         */
+        synchronize_rcu();
+
+        for_each_possible_cpu(cpu) {
+                struct per_cpu_dm_data *hw_data = &per_cpu(dm_hw_cpu_data, cpu);
+                struct sk_buff *skb;
+
+                del_timer_sync(&hw_data->send_timer);
+                cancel_work_sync(&hw_data->dm_alert_work);
+                while ((skb = __skb_dequeue(&hw_data->drop_queue))) {
+                        struct net_dm_hw_metadata *hw_metadata;
+
+                        hw_metadata = NET_DM_SKB_CB(skb)->hw_metadata;
+                        net_dm_hw_metadata_free(hw_metadata);
+                        consume_skb(skb);
+                }
+        }
+
+        module_put(THIS_MODULE);
+}
+
 static int net_dm_trace_on_set(struct netlink_ext_ack *extack)
 {
         const struct net_dm_alert_ops *ops;
@@ -604,6 +1140,11 @@ static int set_all_monitor_traces(int state, struct netlink_ext_ack *extack)
         return rc;
 }
 
+static bool net_dm_is_monitoring(void)
+{
+        return trace_state == TRACE_ON || monitor_hw;
+}
+
 static int net_dm_alert_mode_get_from_info(struct genl_info *info,
                                            enum net_dm_alert_mode *p_alert_mode)
 {
@@ -665,8 +1206,8 @@ static int net_dm_cmd_config(struct sk_buff *skb,
         struct netlink_ext_ack *extack = info->extack;
         int rc;
 
-        if (trace_state == TRACE_ON) {
-                NL_SET_ERR_MSG_MOD(extack, "Cannot configure drop monitor while tracing is on");
+        if (net_dm_is_monitoring()) {
+                NL_SET_ERR_MSG_MOD(extack, "Cannot configure drop monitor during monitoring");
                 return -EBUSY;
         }
 
@@ -681,14 +1222,61 @@ static int net_dm_cmd_config(struct sk_buff *skb,
         return 0;
 }
 
+static int net_dm_monitor_start(bool set_sw, bool set_hw,
+                                struct netlink_ext_ack *extack)
+{
+        bool sw_set = false;
+        int rc;
+
+        if (set_sw) {
+                rc = set_all_monitor_traces(TRACE_ON, extack);
+                if (rc)
+                        return rc;
+                sw_set = true;
+        }
+
+        if (set_hw) {
+                rc = net_dm_hw_monitor_start(extack);
+                if (rc)
+                        goto err_monitor_hw;
+        }
+
+        return 0;
+
+err_monitor_hw:
+        if (sw_set)
+                set_all_monitor_traces(TRACE_OFF, extack);
+        return rc;
+}
+
+static void net_dm_monitor_stop(bool set_sw, bool set_hw,
+                                struct netlink_ext_ack *extack)
+{
+        if (set_hw)
+                net_dm_hw_monitor_stop(extack);
+        if (set_sw)
+                set_all_monitor_traces(TRACE_OFF, extack);
+}
+
 static int net_dm_cmd_trace(struct sk_buff *skb,
                         struct genl_info *info)
 {
+        bool set_sw = !!info->attrs[NET_DM_ATTR_SW_DROPS];
+        bool set_hw = !!info->attrs[NET_DM_ATTR_HW_DROPS];
+        struct netlink_ext_ack *extack = info->extack;
+
+        /* To maintain backward compatibility, we start / stop monitoring of
+         * software drops if no flag is specified.
+         */
+        if (!set_sw && !set_hw)
+                set_sw = true;
+
         switch (info->genlhdr->cmd) {
         case NET_DM_CMD_START:
-                return set_all_monitor_traces(TRACE_ON, info->extack);
+                return net_dm_monitor_start(set_sw, set_hw, extack);
         case NET_DM_CMD_STOP:
-                return set_all_monitor_traces(TRACE_OFF, info->extack);
+                net_dm_monitor_stop(set_sw, set_hw, extack);
+                return 0;
         }
 
         return -EOPNOTSUPP;
@@ -785,6 +1373,50 @@ nla_put_failure:
         return -EMSGSIZE;
 }
 
+static void net_dm_hw_stats_read(struct net_dm_stats *stats)
+{
+        int cpu;
+
+        memset(stats, 0, sizeof(*stats));
+        for_each_possible_cpu(cpu) {
+                struct per_cpu_dm_data *hw_data = &per_cpu(dm_hw_cpu_data, cpu);
+                struct net_dm_stats *cpu_stats = &hw_data->stats;
+                unsigned int start;
+                u64 dropped;
+
+                do {
+                        start = u64_stats_fetch_begin_irq(&cpu_stats->syncp);
+                        dropped = cpu_stats->dropped;
+                } while (u64_stats_fetch_retry_irq(&cpu_stats->syncp, start));
+
+                stats->dropped += dropped;
+        }
+}
+
+static int net_dm_hw_stats_put(struct sk_buff *msg)
+{
+        struct net_dm_stats stats;
+        struct nlattr *attr;
+
+        net_dm_hw_stats_read(&stats);
+
+        attr = nla_nest_start(msg, NET_DM_ATTR_HW_STATS);
+        if (!attr)
+                return -EMSGSIZE;
+
+        if (nla_put_u64_64bit(msg, NET_DM_ATTR_STATS_DROPPED,
+                              stats.dropped, NET_DM_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 net_dm_stats_fill(struct sk_buff *msg, struct genl_info *info)
 {
         void *hdr;
@@ -799,6 +1431,10 @@ static int net_dm_stats_fill(struct sk_buff *msg, struct genl_info *info)
         if (rc)
                 goto nla_put_failure;
 
+        rc = net_dm_hw_stats_put(msg);
+        if (rc)
+                goto nla_put_failure;
+
         genlmsg_end(msg, hdr);
 
         return 0;
@@ -872,6 +1508,8 @@ static const struct nla_policy net_dm_nl_policy[NET_DM_ATTR_MAX + 1] = {
         [NET_DM_ATTR_ALERT_MODE] = { .type = NLA_U8 },
         [NET_DM_ATTR_TRUNC_LEN] = { .type = NLA_U32 },
         [NET_DM_ATTR_QUEUE_LEN] = { .type = NLA_U32 },
+        [NET_DM_ATTR_SW_DROPS]  = {. type = NLA_FLAG },
+        [NET_DM_ATTR_HW_DROPS]  = {. type = NLA_FLAG },
 };
 
 static const struct genl_ops dropmon_ops[] = {
@@ -934,9 +1572,57 @@ static struct notifier_block dropmon_net_notifier = {
         .notifier_call = dropmon_net_event
 };
 
-static int __init init_net_drop_monitor(void)
+static void __net_dm_cpu_data_init(struct per_cpu_dm_data *data)
+{
+        spin_lock_init(&data->lock);
+        skb_queue_head_init(&data->drop_queue);
+        u64_stats_init(&data->stats.syncp);
+}
+
+static void __net_dm_cpu_data_fini(struct per_cpu_dm_data *data)
+{
+        WARN_ON(!skb_queue_empty(&data->drop_queue));
+}
+
+static void net_dm_cpu_data_init(int cpu)
 {
         struct per_cpu_dm_data *data;
+
+        data = &per_cpu(dm_cpu_data, cpu);
+        __net_dm_cpu_data_init(data);
+}
+
+static void net_dm_cpu_data_fini(int cpu)
+{
+        struct per_cpu_dm_data *data;
+
+        data = &per_cpu(dm_cpu_data, cpu);
+        /* At this point, we should have exclusive access
+         * to this struct and can free the skb inside it.
+         */
+        consume_skb(data->skb);
+        __net_dm_cpu_data_fini(data);
+}
+
+static void net_dm_hw_cpu_data_init(int cpu)
+{
+        struct per_cpu_dm_data *hw_data;
+
+        hw_data = &per_cpu(dm_hw_cpu_data, cpu);
+        __net_dm_cpu_data_init(hw_data);
+}
+
+static void net_dm_hw_cpu_data_fini(int cpu)
+{
+        struct per_cpu_dm_data *hw_data;
+
+        hw_data = &per_cpu(dm_hw_cpu_data, cpu);
+        kfree(hw_data->hw_entries);
+        __net_dm_cpu_data_fini(hw_data);
+}
+
+static int __init init_net_drop_monitor(void)
+{
         int cpu, rc;
 
         pr_info("Initializing network drop monitor service\n");
@@ -962,10 +1648,8 @@ static int __init init_net_drop_monitor(void)
         rc = 0;
 
         for_each_possible_cpu(cpu) {
-                data = &per_cpu(dm_cpu_data, cpu);
-                spin_lock_init(&data->lock);
-                skb_queue_head_init(&data->drop_queue);
-                u64_stats_init(&data->stats.syncp);
+                net_dm_cpu_data_init(cpu);
+                net_dm_hw_cpu_data_init(cpu);
         }
 
         goto out;
@@ -978,7 +1662,6 @@ out:
 
 static void exit_net_drop_monitor(void)
 {
-        struct per_cpu_dm_data *data;
         int cpu;
 
         BUG_ON(unregister_netdevice_notifier(&dropmon_net_notifier));
@@ -989,13 +1672,8 @@ static void exit_net_drop_monitor(void)
          */
 
         for_each_possible_cpu(cpu) {
-                data = &per_cpu(dm_cpu_data, cpu);
-                /*
-                 * At this point, we should have exclusive access
-                 * to this struct and can free the skb inside it
-                 */
-                kfree_skb(data->skb);
-                WARN_ON(!skb_queue_empty(&data->drop_queue));
+                net_dm_hw_cpu_data_fini(cpu);
+                net_dm_cpu_data_fini(cpu);
         }
 
         BUG_ON(genl_unregister_family(&net_drop_monitor_family));