xdp_stat = &rx_ring->rx_stats.xdp_pass;
                break;
        default:
-               bpf_warn_invalid_xdp_action(verdict);
+               bpf_warn_invalid_xdp_action(rx_ring->netdev, xdp_prog, verdict);
                xdp_stat = &rx_ring->rx_stats.xdp_invalid;
        }
 
 
                *event |= BNXT_REDIRECT_EVENT;
                break;
        default:
-               bpf_warn_invalid_xdp_action(act);
+               bpf_warn_invalid_xdp_action(bp->dev, xdp_prog, act);
                fallthrough;
        case XDP_ABORTED:
                trace_xdp_exception(bp->dev, xdp_prog, act);
 
                nicvf_xdp_sq_append_pkt(nic, sq, (u64)xdp.data, dma_addr, len);
                return true;
        default:
-               bpf_warn_invalid_xdp_action(action);
+               bpf_warn_invalid_xdp_action(nic->netdev, prog, action);
                fallthrough;
        case XDP_ABORTED:
                trace_xdp_exception(nic->netdev, prog, action);
 
                }
                break;
        default:
-               bpf_warn_invalid_xdp_action(xdp_act);
+               bpf_warn_invalid_xdp_action(priv->net_dev, xdp_prog, xdp_act);
                fallthrough;
        case XDP_ABORTED:
                trace_xdp_exception(priv->net_dev, xdp_prog, xdp_act);
 
                dpaa2_eth_xdp_enqueue(priv, ch, fd, vaddr, rx_fq->flowid);
                break;
        default:
-               bpf_warn_invalid_xdp_action(xdp_act);
+               bpf_warn_invalid_xdp_action(priv->net_dev, xdp_prog, xdp_act);
                fallthrough;
        case XDP_ABORTED:
                trace_xdp_exception(priv->net_dev, xdp_prog, xdp_act);
 
 
                switch (xdp_act) {
                default:
-                       bpf_warn_invalid_xdp_action(xdp_act);
+                       bpf_warn_invalid_xdp_action(rx_ring->ndev, prog, xdp_act);
                        fallthrough;
                case XDP_ABORTED:
                        trace_xdp_exception(rx_ring->ndev, prog, xdp_act);
 
                result = I40E_XDP_REDIR;
                break;
        default:
-               bpf_warn_invalid_xdp_action(act);
+               bpf_warn_invalid_xdp_action(rx_ring->netdev, xdp_prog, act);
                fallthrough;
        case XDP_ABORTED:
 out_failure:
 
                        goto out_failure;
                break;
        default:
-               bpf_warn_invalid_xdp_action(act);
+               bpf_warn_invalid_xdp_action(rx_ring->netdev, xdp_prog, act);
                fallthrough;
        case XDP_ABORTED:
 out_failure:
 
                        goto out_failure;
                return ICE_XDP_REDIR;
        default:
-               bpf_warn_invalid_xdp_action(act);
+               bpf_warn_invalid_xdp_action(rx_ring->netdev, xdp_prog, act);
                fallthrough;
        case XDP_ABORTED:
 out_failure:
 
                        goto out_failure;
                break;
        default:
-               bpf_warn_invalid_xdp_action(act);
+               bpf_warn_invalid_xdp_action(rx_ring->netdev, xdp_prog, act);
                fallthrough;
        case XDP_ABORTED:
 out_failure:
 
                result = IGB_XDP_REDIR;
                break;
        default:
-               bpf_warn_invalid_xdp_action(act);
+               bpf_warn_invalid_xdp_action(adapter->netdev, xdp_prog, act);
                fallthrough;
        case XDP_ABORTED:
 out_failure:
 
                return IGC_XDP_REDIRECT;
                break;
        default:
-               bpf_warn_invalid_xdp_action(act);
+               bpf_warn_invalid_xdp_action(adapter->netdev, prog, act);
                fallthrough;
        case XDP_ABORTED:
 out_failure:
 
                result = IXGBE_XDP_REDIR;
                break;
        default:
-               bpf_warn_invalid_xdp_action(act);
+               bpf_warn_invalid_xdp_action(rx_ring->netdev, xdp_prog, act);
                fallthrough;
        case XDP_ABORTED:
 out_failure:
 
                        goto out_failure;
                break;
        default:
-               bpf_warn_invalid_xdp_action(act);
+               bpf_warn_invalid_xdp_action(rx_ring->netdev, xdp_prog, act);
                fallthrough;
        case XDP_ABORTED:
 out_failure:
 
                        goto out_failure;
                break;
        default:
-               bpf_warn_invalid_xdp_action(act);
+               bpf_warn_invalid_xdp_action(rx_ring->netdev, xdp_prog, act);
                fallthrough;
        case XDP_ABORTED:
 out_failure:
 
                        mvneta_xdp_put_buff(pp, rxq, xdp, sinfo, sync);
                break;
        default:
-               bpf_warn_invalid_xdp_action(act);
+               bpf_warn_invalid_xdp_action(pp->dev, prog, act);
                fallthrough;
        case XDP_ABORTED:
                trace_xdp_exception(pp->dev, prog, act);
 
                }
                break;
        default:
-               bpf_warn_invalid_xdp_action(act);
+               bpf_warn_invalid_xdp_action(port->dev, prog, act);
                fallthrough;
        case XDP_ABORTED:
                trace_xdp_exception(port->dev, prog, act);
 
                put_page(page);
                break;
        default:
-               bpf_warn_invalid_xdp_action(act);
+               bpf_warn_invalid_xdp_action(pfvf->netdev, prog, act);
                break;
        case XDP_ABORTED:
                trace_xdp_exception(pfvf->netdev, prog, act);
 
                                trace_xdp_exception(dev, xdp_prog, act);
                                goto xdp_drop_no_cnt; /* Drop on xmit failure */
                        default:
-                               bpf_warn_invalid_xdp_action(act);
+                               bpf_warn_invalid_xdp_action(dev, xdp_prog, act);
                                fallthrough;
                        case XDP_ABORTED:
                                trace_xdp_exception(dev, xdp_prog, act);
 
                rq->stats->xdp_redirect++;
                return true;
        default:
-               bpf_warn_invalid_xdp_action(act);
+               bpf_warn_invalid_xdp_action(rq->netdev, prog, act);
                fallthrough;
        case XDP_ABORTED:
 xdp_abort:
 
                break;
 
        default:
-               bpf_warn_invalid_xdp_action(act);
+               bpf_warn_invalid_xdp_action(ndev, prog, act);
        }
 
 out:
 
                                                            xdp_prog, act);
                                continue;
                        default:
-                               bpf_warn_invalid_xdp_action(act);
+                               bpf_warn_invalid_xdp_action(dp->netdev, xdp_prog, act);
                                fallthrough;
                        case XDP_ABORTED:
                                trace_xdp_exception(dp->netdev, xdp_prog, act);
 
                qede_rx_bd_ring_consume(rxq);
                break;
        default:
-               bpf_warn_invalid_xdp_action(act);
+               bpf_warn_invalid_xdp_action(edev->ndev, prog, act);
                fallthrough;
        case XDP_ABORTED:
                trace_xdp_exception(edev->ndev, prog, act);
 
                break;
 
        default:
-               bpf_warn_invalid_xdp_action(xdp_act);
+               bpf_warn_invalid_xdp_action(efx->net_dev, xdp_prog, xdp_act);
                efx_free_rx_buffers(rx_queue, rx_buf, 1);
                channel->n_rx_xdp_bad_drops++;
                trace_xdp_exception(efx->net_dev, xdp_prog, xdp_act);
 
                }
                break;
        default:
-               bpf_warn_invalid_xdp_action(act);
+               bpf_warn_invalid_xdp_action(priv->ndev, prog, act);
                fallthrough;
        case XDP_ABORTED:
                trace_xdp_exception(priv->ndev, prog, act);
 
                        res = STMMAC_XDP_REDIRECT;
                break;
        default:
-               bpf_warn_invalid_xdp_action(act);
+               bpf_warn_invalid_xdp_action(priv->dev, prog, act);
                fallthrough;
        case XDP_ABORTED:
                trace_xdp_exception(priv->dev, prog, act);
 
                xdp_do_flush_map();
                break;
        default:
-               bpf_warn_invalid_xdp_action(act);
+               bpf_warn_invalid_xdp_action(ndev, prog, act);
                fallthrough;
        case XDP_ABORTED:
                trace_xdp_exception(ndev, prog, act);
 
                break;
 
        default:
-               bpf_warn_invalid_xdp_action(act);
+               bpf_warn_invalid_xdp_action(ndev, prog, act);
        }
 
 out:
 
        case XDP_PASS:
                break;
        default:
-               bpf_warn_invalid_xdp_action(act);
+               bpf_warn_invalid_xdp_action(tun->dev, xdp_prog, act);
                fallthrough;
        case XDP_ABORTED:
                trace_xdp_exception(tun->dev, xdp_prog, act);
 
                        rcu_read_unlock();
                        goto xdp_xmit;
                default:
-                       bpf_warn_invalid_xdp_action(act);
+                       bpf_warn_invalid_xdp_action(rq->dev, xdp_prog, act);
                        fallthrough;
                case XDP_ABORTED:
                        trace_xdp_exception(rq->dev, xdp_prog, act);
                rcu_read_unlock();
                goto xdp_xmit;
        default:
-               bpf_warn_invalid_xdp_action(act);
+               bpf_warn_invalid_xdp_action(rq->dev, xdp_prog, act);
                fallthrough;
        case XDP_ABORTED:
                trace_xdp_exception(rq->dev, xdp_prog, act);
 
                        rcu_read_unlock();
                        goto xdp_xmit;
                default:
-                       bpf_warn_invalid_xdp_action(act);
+                       bpf_warn_invalid_xdp_action(vi->dev, xdp_prog, act);
                        fallthrough;
                case XDP_ABORTED:
                        trace_xdp_exception(vi->dev, xdp_prog, act);
                        rcu_read_unlock();
                        goto xdp_xmit;
                default:
-                       bpf_warn_invalid_xdp_action(act);
+                       bpf_warn_invalid_xdp_action(vi->dev, xdp_prog, act);
                        fallthrough;
                case XDP_ABORTED:
                        trace_xdp_exception(vi->dev, xdp_prog, act);
 
                break;
 
        default:
-               bpf_warn_invalid_xdp_action(act);
+               bpf_warn_invalid_xdp_action(queue->info->netdev, prog, act);
        }
 
        return act;
 
  */
 #define xdp_do_flush_map xdp_do_flush
 
-void bpf_warn_invalid_xdp_action(u32 act);
+void bpf_warn_invalid_xdp_action(struct net_device *dev, struct bpf_prog *prog, u32 act);
 
 #ifdef CONFIG_INET
 struct sock *bpf_run_sk_reuseport(struct sock_reuseport *reuse, struct sock *sk,
 
                        }
                        return;
                default:
-                       bpf_warn_invalid_xdp_action(act);
+                       bpf_warn_invalid_xdp_action(NULL, rcpu->prog, act);
                        fallthrough;
                case XDP_ABORTED:
                        trace_xdp_exception(skb->dev, rcpu->prog, act);
                        }
                        break;
                default:
-                       bpf_warn_invalid_xdp_action(act);
+                       bpf_warn_invalid_xdp_action(NULL, rcpu->prog, act);
                        fallthrough;
                case XDP_DROP:
                        xdp_return_frame(xdpf);
 
                                frames[nframes++] = xdpf;
                        break;
                default:
-                       bpf_warn_invalid_xdp_action(act);
+                       bpf_warn_invalid_xdp_action(NULL, xdp_prog, act);
                        fallthrough;
                case XDP_ABORTED:
                        trace_xdp_exception(dev, xdp_prog, act);
                __skb_push(skb, skb->mac_len);
                break;
        default:
-               bpf_warn_invalid_xdp_action(act);
+               bpf_warn_invalid_xdp_action(NULL, dst->xdp_prog, act);
                fallthrough;
        case XDP_ABORTED:
                trace_xdp_exception(dst->dev, dst->xdp_prog, act);
 
        case XDP_PASS:
                break;
        default:
-               bpf_warn_invalid_xdp_action(act);
+               bpf_warn_invalid_xdp_action(skb->dev, xdp_prog, act);
                fallthrough;
        case XDP_ABORTED:
                trace_xdp_exception(skb->dev, xdp_prog, act);
 
        return __is_valid_xdp_access(off, size);
 }
 
-void bpf_warn_invalid_xdp_action(u32 act)
+void bpf_warn_invalid_xdp_action(struct net_device *dev, struct bpf_prog *prog, u32 act)
 {
        const u32 act_max = XDP_REDIRECT;
 
-       pr_warn_once("%s XDP return value %u, expect packet loss!\n",
+       pr_warn_once("%s XDP return value %u on prog %s (id %d) dev %s, expect packet loss!\n",
                     act > act_max ? "Illegal" : "Driver unsupported",
-                    act);
+                    act, prog->aux->name, prog->aux->id, dev ? dev->name : "N/A");
 }
 EXPORT_SYMBOL_GPL(bpf_warn_invalid_xdp_action);