Merge branch 'netdev_tracing'

Ben Hutchings says:

====================
Improve tracing at the driver/core boundary

These patches add static tracpeoints at the driver/core boundary which
record various skb fields likely to be useful for datapath debugging.
On the TX side the boundary is where the core calls ndo_start_xmit, and
on the RX side it is where any of the various exported receive functions
is called.

The set of skb fields is mostly based on what I thought would be
interesting for sfc.

These patches are basically the same as what I sent as an RFC in
November, but rebased.  They now depend on 'net: core: explicitly select
a txq before doing l2 forwarding', so please merge net into net-next
before trying to apply them.  The first patch fixes a code formatting
error left behind after that fix.
====================

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

1 files changed, 64 insertions, 41 deletions

diff --git a/net/core/dev.c b/net/core/dev.c
index 2bee80591f9a..20c834e3c7ca 100644
--- a/net/core/dev.c
+++ b/net/core/dev.c
@@ -147,6 +147,8 @@ struct list_head ptype_base[PTYPE_HASH_SIZE] __read_mostly;
 struct list_head ptype_all __read_mostly;       /* Taps */
 static struct list_head offload_base __read_mostly;
 
+static int netif_rx_internal(struct sk_buff *skb);
+
 /*
  * The @dev_base_head list is protected by @dev_base_lock and the rtnl
  * semaphore.
@@ -1698,7 +1700,7 @@ int dev_forward_skb(struct net_device *dev, struct sk_buff *skb)
         skb_scrub_packet(skb, true);
         skb->protocol = eth_type_trans(skb, dev);
 
-        return netif_rx(skb);
+        return netif_rx_internal(skb);
 }
 EXPORT_SYMBOL_GPL(dev_forward_skb);
 
@@ -2596,8 +2598,8 @@ int dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev,
                         dev_queue_xmit_nit(skb, dev);
 
                 skb_len = skb->len;
-                        rc = ops->ndo_start_xmit(skb, dev);
-
+                trace_net_dev_start_xmit(skb, dev);
+                rc = ops->ndo_start_xmit(skb, dev);
                 trace_net_dev_xmit(skb, rc, dev, skb_len);
                 if (rc == NETDEV_TX_OK)
                         txq_trans_update(txq);
@@ -2615,6 +2617,7 @@ gso:
                         dev_queue_xmit_nit(nskb, dev);
 
                 skb_len = nskb->len;
+                trace_net_dev_start_xmit(nskb, dev);
                 rc = ops->ndo_start_xmit(nskb, dev);
                 trace_net_dev_xmit(nskb, rc, dev, skb_len);
                 if (unlikely(rc != NETDEV_TX_OK)) {
@@ -3218,22 +3221,7 @@ enqueue:
         return NET_RX_DROP;
 }
 
-/**
- *      netif_rx        -       post buffer to the network code
- *      @skb: buffer to post
- *
- *      This function receives a packet from a device driver and queues it for
- *      the upper (protocol) levels to process.  It always succeeds. The buffer
- *      may be dropped during processing for congestion control or by the
- *      protocol layers.
- *
- *      return values:
- *      NET_RX_SUCCESS  (no congestion)
- *      NET_RX_DROP     (packet was dropped)
- *
- */
-
-int netif_rx(struct sk_buff *skb)
+static int netif_rx_internal(struct sk_buff *skb)
 {
         int ret;
 
@@ -3269,14 +3257,38 @@ int netif_rx(struct sk_buff *skb)
         }
         return ret;
 }
+
+/**
+ *      netif_rx        -       post buffer to the network code
+ *      @skb: buffer to post
+ *
+ *      This function receives a packet from a device driver and queues it for
+ *      the upper (protocol) levels to process.  It always succeeds. The buffer
+ *      may be dropped during processing for congestion control or by the
+ *      protocol layers.
+ *
+ *      return values:
+ *      NET_RX_SUCCESS  (no congestion)
+ *      NET_RX_DROP     (packet was dropped)
+ *
+ */
+
+int netif_rx(struct sk_buff *skb)
+{
+        trace_netif_rx_entry(skb);
+
+        return netif_rx_internal(skb);
+}
 EXPORT_SYMBOL(netif_rx);
 
 int netif_rx_ni(struct sk_buff *skb)
 {
         int err;
 
+        trace_netif_rx_ni_entry(skb);
+
         preempt_disable();
-        err = netif_rx(skb);
+        err = netif_rx_internal(skb);
         if (local_softirq_pending())
                 do_softirq();
         preempt_enable();
@@ -3661,22 +3673,7 @@ static int __netif_receive_skb(struct sk_buff *skb)
         return ret;
 }
 
-/**
- *      netif_receive_skb - process receive buffer from network
- *      @skb: buffer to process
- *
- *      netif_receive_skb() is the main receive data processing function.
- *      It always succeeds. The buffer may be dropped during processing
- *      for congestion control or by the protocol layers.
- *
- *      This function may only be called from softirq context and interrupts
- *      should be enabled.
- *
- *      Return values (usually ignored):
- *      NET_RX_SUCCESS: no congestion
- *      NET_RX_DROP: packet was dropped
- */
-int netif_receive_skb(struct sk_buff *skb)
+static int netif_receive_skb_internal(struct sk_buff *skb)
 {
         net_timestamp_check(netdev_tstamp_prequeue, skb);
 
@@ -3702,6 +3699,28 @@ int netif_receive_skb(struct sk_buff *skb)
 #endif
         return __netif_receive_skb(skb);
 }
+
+/**
+ *      netif_receive_skb - process receive buffer from network
+ *      @skb: buffer to process
+ *
+ *      netif_receive_skb() is the main receive data processing function.
+ *      It always succeeds. The buffer may be dropped during processing
+ *      for congestion control or by the protocol layers.
+ *
+ *      This function may only be called from softirq context and interrupts
+ *      should be enabled.
+ *
+ *      Return values (usually ignored):
+ *      NET_RX_SUCCESS: no congestion
+ *      NET_RX_DROP: packet was dropped
+ */
+int netif_receive_skb(struct sk_buff *skb)
+{
+        trace_netif_receive_skb_entry(skb);
+
+        return netif_receive_skb_internal(skb);
+}
 EXPORT_SYMBOL(netif_receive_skb);
 
 /* Network device is going away, flush any packets still pending
@@ -3763,7 +3782,7 @@ static int napi_gro_complete(struct sk_buff *skb)
         }
 
 out:
-        return netif_receive_skb(skb);
+        return netif_receive_skb_internal(skb);
 }
 
 /* napi->gro_list contains packets ordered by age.
@@ -3971,7 +3990,7 @@ static gro_result_t napi_skb_finish(gro_result_t ret, struct sk_buff *skb)
 {
         switch (ret) {
         case GRO_NORMAL:
-                if (netif_receive_skb(skb))
+                if (netif_receive_skb_internal(skb))
                         ret = GRO_DROP;
                 break;
 
@@ -3996,6 +4015,8 @@ static gro_result_t napi_skb_finish(gro_result_t ret, struct sk_buff *skb)
 
 gro_result_t napi_gro_receive(struct napi_struct *napi, struct sk_buff *skb)
 {
+        trace_napi_gro_receive_entry(skb);
+
         return napi_skb_finish(dev_gro_receive(napi, skb), skb);
 }
 EXPORT_SYMBOL(napi_gro_receive);
@@ -4029,7 +4050,7 @@ static gro_result_t napi_frags_finish(struct napi_struct *napi, struct sk_buff *
 {
         switch (ret) {
         case GRO_NORMAL:
-                if (netif_receive_skb(skb))
+                if (netif_receive_skb_internal(skb))
                         ret = GRO_DROP;
                 break;
 
@@ -4068,6 +4089,8 @@ gro_result_t napi_gro_frags(struct napi_struct *napi)
         if (!skb)
                 return GRO_DROP;
 
+        trace_napi_gro_frags_entry(skb);
+
         return napi_frags_finish(napi, skb, dev_gro_receive(napi, skb));
 }
 EXPORT_SYMBOL(napi_gro_frags);
@@ -6620,11 +6643,11 @@ static int dev_cpu_callback(struct notifier_block *nfb,
 
         /* Process offline CPU's input_pkt_queue */
         while ((skb = __skb_dequeue(&oldsd->process_queue))) {
-                netif_rx(skb);
+                netif_rx_internal(skb);
                 input_queue_head_incr(oldsd);
         }
         while ((skb = __skb_dequeue(&oldsd->input_pkt_queue))) {
-                netif_rx(skb);
+                netif_rx_internal(skb);
                 input_queue_head_incr(oldsd);
         }