Back to home page

OSCL-LXR
 
 

     

0001 /* SPDX-License-Identifier: GPL-2.0 */
0002 #undef TRACE_SYSTEM
0003 #define TRACE_SYSTEM net
0004 
0005 #if !defined(_TRACE_NET_H) || defined(TRACE_HEADER_MULTI_READ)
0006 #define _TRACE_NET_H
0007 
0008 #include <linux/skbuff.h>
0009 #include <linux/netdevice.h>
0010 #include <linux/if_vlan.h>
0011 #include <linux/ip.h>
0012 #include <linux/tracepoint.h>
0013 
0014 TRACE_EVENT(net_dev_start_xmit,
0015 
0016     TP_PROTO(const struct sk_buff *skb, const struct net_device *dev),
0017 
0018     TP_ARGS(skb, dev),
0019 
0020     TP_STRUCT__entry(
0021         __string(   name,           dev->name   )
0022         __field(    u16,            queue_mapping   )
0023         __field(    const void *,       skbaddr     )
0024         __field(    bool,           vlan_tagged )
0025         __field(    u16,            vlan_proto  )
0026         __field(    u16,            vlan_tci    )
0027         __field(    u16,            protocol    )
0028         __field(    u8,         ip_summed   )
0029         __field(    unsigned int,       len     )
0030         __field(    unsigned int,       data_len    )
0031         __field(    int,            network_offset  )
0032         __field(    bool,           transport_offset_valid)
0033         __field(    int,            transport_offset)
0034         __field(    u8,         tx_flags    )
0035         __field(    u16,            gso_size    )
0036         __field(    u16,            gso_segs    )
0037         __field(    u16,            gso_type    )
0038     ),
0039 
0040     TP_fast_assign(
0041         __assign_str(name, dev->name);
0042         __entry->queue_mapping = skb->queue_mapping;
0043         __entry->skbaddr = skb;
0044         __entry->vlan_tagged = skb_vlan_tag_present(skb);
0045         __entry->vlan_proto = ntohs(skb->vlan_proto);
0046         __entry->vlan_tci = skb_vlan_tag_get(skb);
0047         __entry->protocol = ntohs(skb->protocol);
0048         __entry->ip_summed = skb->ip_summed;
0049         __entry->len = skb->len;
0050         __entry->data_len = skb->data_len;
0051         __entry->network_offset = skb_network_offset(skb);
0052         __entry->transport_offset_valid =
0053             skb_transport_header_was_set(skb);
0054         __entry->transport_offset = skb_transport_offset(skb);
0055         __entry->tx_flags = skb_shinfo(skb)->tx_flags;
0056         __entry->gso_size = skb_shinfo(skb)->gso_size;
0057         __entry->gso_segs = skb_shinfo(skb)->gso_segs;
0058         __entry->gso_type = skb_shinfo(skb)->gso_type;
0059     ),
0060 
0061     TP_printk("dev=%s queue_mapping=%u skbaddr=%p vlan_tagged=%d vlan_proto=0x%04x vlan_tci=0x%04x protocol=0x%04x ip_summed=%d len=%u data_len=%u network_offset=%d transport_offset_valid=%d transport_offset=%d tx_flags=%d gso_size=%d gso_segs=%d gso_type=%#x",
0062           __get_str(name), __entry->queue_mapping, __entry->skbaddr,
0063           __entry->vlan_tagged, __entry->vlan_proto, __entry->vlan_tci,
0064           __entry->protocol, __entry->ip_summed, __entry->len,
0065           __entry->data_len,
0066           __entry->network_offset, __entry->transport_offset_valid,
0067           __entry->transport_offset, __entry->tx_flags,
0068           __entry->gso_size, __entry->gso_segs, __entry->gso_type)
0069 );
0070 
0071 TRACE_EVENT(net_dev_xmit,
0072 
0073     TP_PROTO(struct sk_buff *skb,
0074          int rc,
0075          struct net_device *dev,
0076          unsigned int skb_len),
0077 
0078     TP_ARGS(skb, rc, dev, skb_len),
0079 
0080     TP_STRUCT__entry(
0081         __field(    void *,     skbaddr     )
0082         __field(    unsigned int,   len     )
0083         __field(    int,        rc      )
0084         __string(   name,       dev->name   )
0085     ),
0086 
0087     TP_fast_assign(
0088         __entry->skbaddr = skb;
0089         __entry->len = skb_len;
0090         __entry->rc = rc;
0091         __assign_str(name, dev->name);
0092     ),
0093 
0094     TP_printk("dev=%s skbaddr=%p len=%u rc=%d",
0095         __get_str(name), __entry->skbaddr, __entry->len, __entry->rc)
0096 );
0097 
0098 TRACE_EVENT(net_dev_xmit_timeout,
0099 
0100     TP_PROTO(struct net_device *dev,
0101          int queue_index),
0102 
0103     TP_ARGS(dev, queue_index),
0104 
0105     TP_STRUCT__entry(
0106         __string(   name,       dev->name   )
0107         __string(   driver,     netdev_drivername(dev))
0108         __field(    int,        queue_index )
0109     ),
0110 
0111     TP_fast_assign(
0112         __assign_str(name, dev->name);
0113         __assign_str(driver, netdev_drivername(dev));
0114         __entry->queue_index = queue_index;
0115     ),
0116 
0117     TP_printk("dev=%s driver=%s queue=%d",
0118         __get_str(name), __get_str(driver), __entry->queue_index)
0119 );
0120 
0121 DECLARE_EVENT_CLASS(net_dev_template,
0122 
0123     TP_PROTO(struct sk_buff *skb),
0124 
0125     TP_ARGS(skb),
0126 
0127     TP_STRUCT__entry(
0128         __field(    void *,     skbaddr     )
0129         __field(    unsigned int,   len     )
0130         __string(   name,       skb->dev->name  )
0131     ),
0132 
0133     TP_fast_assign(
0134         __entry->skbaddr = skb;
0135         __entry->len = skb->len;
0136         __assign_str(name, skb->dev->name);
0137     ),
0138 
0139     TP_printk("dev=%s skbaddr=%p len=%u",
0140         __get_str(name), __entry->skbaddr, __entry->len)
0141 )
0142 
0143 DEFINE_EVENT(net_dev_template, net_dev_queue,
0144 
0145     TP_PROTO(struct sk_buff *skb),
0146 
0147     TP_ARGS(skb)
0148 );
0149 
0150 DEFINE_EVENT(net_dev_template, netif_receive_skb,
0151 
0152     TP_PROTO(struct sk_buff *skb),
0153 
0154     TP_ARGS(skb)
0155 );
0156 
0157 DEFINE_EVENT(net_dev_template, netif_rx,
0158 
0159     TP_PROTO(struct sk_buff *skb),
0160 
0161     TP_ARGS(skb)
0162 );
0163 
0164 DECLARE_EVENT_CLASS(net_dev_rx_verbose_template,
0165 
0166     TP_PROTO(const struct sk_buff *skb),
0167 
0168     TP_ARGS(skb),
0169 
0170     TP_STRUCT__entry(
0171         __string(   name,           skb->dev->name  )
0172         __field(    unsigned int,       napi_id     )
0173         __field(    u16,            queue_mapping   )
0174         __field(    const void *,       skbaddr     )
0175         __field(    bool,           vlan_tagged )
0176         __field(    u16,            vlan_proto  )
0177         __field(    u16,            vlan_tci    )
0178         __field(    u16,            protocol    )
0179         __field(    u8,         ip_summed   )
0180         __field(    u32,            hash        )
0181         __field(    bool,           l4_hash     )
0182         __field(    unsigned int,       len     )
0183         __field(    unsigned int,       data_len    )
0184         __field(    unsigned int,       truesize    )
0185         __field(    bool,           mac_header_valid)
0186         __field(    int,            mac_header  )
0187         __field(    unsigned char,      nr_frags    )
0188         __field(    u16,            gso_size    )
0189         __field(    u16,            gso_type    )
0190     ),
0191 
0192     TP_fast_assign(
0193         __assign_str(name, skb->dev->name);
0194 #ifdef CONFIG_NET_RX_BUSY_POLL
0195         __entry->napi_id = skb->napi_id;
0196 #else
0197         __entry->napi_id = 0;
0198 #endif
0199         __entry->queue_mapping = skb->queue_mapping;
0200         __entry->skbaddr = skb;
0201         __entry->vlan_tagged = skb_vlan_tag_present(skb);
0202         __entry->vlan_proto = ntohs(skb->vlan_proto);
0203         __entry->vlan_tci = skb_vlan_tag_get(skb);
0204         __entry->protocol = ntohs(skb->protocol);
0205         __entry->ip_summed = skb->ip_summed;
0206         __entry->hash = skb->hash;
0207         __entry->l4_hash = skb->l4_hash;
0208         __entry->len = skb->len;
0209         __entry->data_len = skb->data_len;
0210         __entry->truesize = skb->truesize;
0211         __entry->mac_header_valid = skb_mac_header_was_set(skb);
0212         __entry->mac_header = skb_mac_header(skb) - skb->data;
0213         __entry->nr_frags = skb_shinfo(skb)->nr_frags;
0214         __entry->gso_size = skb_shinfo(skb)->gso_size;
0215         __entry->gso_type = skb_shinfo(skb)->gso_type;
0216     ),
0217 
0218     TP_printk("dev=%s napi_id=%#x queue_mapping=%u skbaddr=%p vlan_tagged=%d vlan_proto=0x%04x vlan_tci=0x%04x protocol=0x%04x ip_summed=%d hash=0x%08x l4_hash=%d len=%u data_len=%u truesize=%u mac_header_valid=%d mac_header=%d nr_frags=%d gso_size=%d gso_type=%#x",
0219           __get_str(name), __entry->napi_id, __entry->queue_mapping,
0220           __entry->skbaddr, __entry->vlan_tagged, __entry->vlan_proto,
0221           __entry->vlan_tci, __entry->protocol, __entry->ip_summed,
0222           __entry->hash, __entry->l4_hash, __entry->len,
0223           __entry->data_len, __entry->truesize,
0224           __entry->mac_header_valid, __entry->mac_header,
0225           __entry->nr_frags, __entry->gso_size, __entry->gso_type)
0226 );
0227 
0228 DEFINE_EVENT(net_dev_rx_verbose_template, napi_gro_frags_entry,
0229 
0230     TP_PROTO(const struct sk_buff *skb),
0231 
0232     TP_ARGS(skb)
0233 );
0234 
0235 DEFINE_EVENT(net_dev_rx_verbose_template, napi_gro_receive_entry,
0236 
0237     TP_PROTO(const struct sk_buff *skb),
0238 
0239     TP_ARGS(skb)
0240 );
0241 
0242 DEFINE_EVENT(net_dev_rx_verbose_template, netif_receive_skb_entry,
0243 
0244     TP_PROTO(const struct sk_buff *skb),
0245 
0246     TP_ARGS(skb)
0247 );
0248 
0249 DEFINE_EVENT(net_dev_rx_verbose_template, netif_receive_skb_list_entry,
0250 
0251     TP_PROTO(const struct sk_buff *skb),
0252 
0253     TP_ARGS(skb)
0254 );
0255 
0256 DEFINE_EVENT(net_dev_rx_verbose_template, netif_rx_entry,
0257 
0258     TP_PROTO(const struct sk_buff *skb),
0259 
0260     TP_ARGS(skb)
0261 );
0262 
0263 DECLARE_EVENT_CLASS(net_dev_rx_exit_template,
0264 
0265     TP_PROTO(int ret),
0266 
0267     TP_ARGS(ret),
0268 
0269     TP_STRUCT__entry(
0270         __field(int,    ret)
0271     ),
0272 
0273     TP_fast_assign(
0274         __entry->ret = ret;
0275     ),
0276 
0277     TP_printk("ret=%d", __entry->ret)
0278 );
0279 
0280 DEFINE_EVENT(net_dev_rx_exit_template, napi_gro_frags_exit,
0281 
0282     TP_PROTO(int ret),
0283 
0284     TP_ARGS(ret)
0285 );
0286 
0287 DEFINE_EVENT(net_dev_rx_exit_template, napi_gro_receive_exit,
0288 
0289     TP_PROTO(int ret),
0290 
0291     TP_ARGS(ret)
0292 );
0293 
0294 DEFINE_EVENT(net_dev_rx_exit_template, netif_receive_skb_exit,
0295 
0296     TP_PROTO(int ret),
0297 
0298     TP_ARGS(ret)
0299 );
0300 
0301 DEFINE_EVENT(net_dev_rx_exit_template, netif_rx_exit,
0302 
0303     TP_PROTO(int ret),
0304 
0305     TP_ARGS(ret)
0306 );
0307 
0308 DEFINE_EVENT(net_dev_rx_exit_template, netif_receive_skb_list_exit,
0309 
0310     TP_PROTO(int ret),
0311 
0312     TP_ARGS(ret)
0313 );
0314 
0315 #endif /* _TRACE_NET_H */
0316 
0317 /* This part must be outside protection */
0318 #include <trace/define_trace.h>
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!