include/trace/events/tcp.h

   1 #undef TRACE_SYSTEM
   2 #define TRACE_SYSTEM tcp
   3
   4 #if !defined(_TRACE_TCP_H) || defined(TRACE_HEADER_MULTI_READ)
   5 #define _TRACE_TCP_H
   6
   7 #include <linux/ipv6.h>
   8 #include <linux/tcp.h>
   9 #include <linux/tracepoint.h>
  10 #include <net/ipv6.h>
  11
  12 #define tcp_state_name(state)   { state, #state }
  13 #define show_tcp_state_name(val)                        \
  14         __print_symbolic(val,                           \
  15                 tcp_state_name(TCP_ESTABLISHED),        \
  16                 tcp_state_name(TCP_SYN_SENT),           \
  17                 tcp_state_name(TCP_SYN_RECV),           \
  18                 tcp_state_name(TCP_FIN_WAIT1),          \
  19                 tcp_state_name(TCP_FIN_WAIT2),          \
  20                 tcp_state_name(TCP_TIME_WAIT),          \
  21                 tcp_state_name(TCP_CLOSE),              \
  22                 tcp_state_name(TCP_CLOSE_WAIT),         \
  23                 tcp_state_name(TCP_LAST_ACK),           \
  24                 tcp_state_name(TCP_LISTEN),             \
  25                 tcp_state_name(TCP_CLOSING),            \
  26                 tcp_state_name(TCP_NEW_SYN_RECV))
  27
  28 #define TP_STORE_V4MAPPED(__entry, saddr, daddr)                \
  29         do {                                                    \
  30                 struct in6_addr *pin6;                          \
  31                                                                 \
  32                 pin6 = (struct in6_addr *)__entry->saddr_v6;    \
  33                 ipv6_addr_set_v4mapped(saddr, pin6);            \
  34                 pin6 = (struct in6_addr *)__entry->daddr_v6;    \
  35                 ipv6_addr_set_v4mapped(daddr, pin6);            \
  36         } while (0)
  37
  38 #if IS_ENABLED(CONFIG_IPV6)
  39 #define TP_STORE_ADDRS(__entry, saddr, daddr, saddr6, daddr6)           \
  40         do {                                                            \
  41                 if (sk->sk_family == AF_INET6) {                        \
  42                         struct in6_addr *pin6;                          \
  43                                                                         \
  44                         pin6 = (struct in6_addr *)__entry->saddr_v6;    \
  45                         *pin6 = saddr6;                                 \
  46                         pin6 = (struct in6_addr *)__entry->daddr_v6;    \
  47                         *pin6 = daddr6;                                 \
  48                 } else {                                                \
  49                         TP_STORE_V4MAPPED(__entry, saddr, daddr);       \
  50                 }                                                       \
  51         } while (0)
  52 #else
  53 #define TP_STORE_ADDRS(__entry, saddr, daddr, saddr6, daddr6)   \
  54         TP_STORE_V4MAPPED(__entry, saddr, daddr)
  55 #endif
  56
  57 /*
  58  * tcp event with arguments sk and skb
  59  *
  60  * Note: this class requires a valid sk pointer; while skb pointer could
  61  *       be NULL.
  62  */
  63 DECLARE_EVENT_CLASS(tcp_event_sk_skb,
  64
  65         TP_PROTO(const struct sock *sk, const struct sk_buff *skb),
  66
  67         TP_ARGS(sk, skb),
  68
  69         TP_STRUCT__entry(
  70                 __field(const void *, skbaddr)
  71                 __field(const void *, skaddr)
  72                 __field(__u16, sport)
  73                 __field(__u16, dport)
  74                 __array(__u8, saddr, 4)
  75                 __array(__u8, daddr, 4)
  76                 __array(__u8, saddr_v6, 16)
  77                 __array(__u8, daddr_v6, 16)
  78         ),
  79
  80         TP_fast_assign(
  81                 struct inet_sock *inet = inet_sk(sk);
  82                 __be32 *p32;
  83
  84                 __entry->skbaddr = skb;
  85                 __entry->skaddr = sk;
  86
  87                 __entry->sport = ntohs(inet->inet_sport);
  88                 __entry->dport = ntohs(inet->inet_dport);
  89
  90                 p32 = (__be32 *) __entry->saddr;
  91                 *p32 = inet->inet_saddr;
  92
  93                 p32 = (__be32 *) __entry->daddr;
  94                 *p32 =  inet->inet_daddr;
  95
  96                 TP_STORE_ADDRS(__entry, inet->inet_saddr, inet->inet_daddr,
  97                               sk->sk_v6_rcv_saddr, sk->sk_v6_daddr);
  98         ),
  99
 100         TP_printk("sport=%hu dport=%hu saddr=%pI4 daddr=%pI4 saddrv6=%pI6c daddrv6=%pI6c",
 101                   __entry->sport, __entry->dport, __entry->saddr, __entry->daddr,
 102                   __entry->saddr_v6, __entry->daddr_v6)
 103 );
 104
 105 DEFINE_EVENT(tcp_event_sk_skb, tcp_retransmit_skb,
 106
 107         TP_PROTO(const struct sock *sk, const struct sk_buff *skb),
 108
 109         TP_ARGS(sk, skb)
 110 );
 111
 112 /*
 113  * skb of trace_tcp_send_reset is the skb that caused RST. In case of
 114  * active reset, skb should be NULL
 115  */
 116 DEFINE_EVENT(tcp_event_sk_skb, tcp_send_reset,
 117
 118         TP_PROTO(const struct sock *sk, const struct sk_buff *skb),
 119
 120         TP_ARGS(sk, skb)
 121 );
 122
 123 /*
 124  * tcp event with arguments sk
 125  *
 126  * Note: this class requires a valid sk pointer.
 127  */
 128 DECLARE_EVENT_CLASS(tcp_event_sk,
 129
 130         TP_PROTO(const struct sock *sk),
 131
 132         TP_ARGS(sk),
 133
 134         TP_STRUCT__entry(
 135                 __field(const void *, skaddr)
 136                 __field(__u16, sport)
 137                 __field(__u16, dport)
 138                 __array(__u8, saddr, 4)
 139                 __array(__u8, daddr, 4)
 140                 __array(__u8, saddr_v6, 16)
 141                 __array(__u8, daddr_v6, 16)
 142         ),
 143
 144         TP_fast_assign(
 145                 struct inet_sock *inet = inet_sk(sk);
 146                 __be32 *p32;
 147
 148                 __entry->skaddr = sk;
 149
 150                 __entry->sport = ntohs(inet->inet_sport);
 151                 __entry->dport = ntohs(inet->inet_dport);
 152
 153                 p32 = (__be32 *) __entry->saddr;
 154                 *p32 = inet->inet_saddr;
 155
 156                 p32 = (__be32 *) __entry->daddr;
 157                 *p32 =  inet->inet_daddr;
 158
 159                 TP_STORE_ADDRS(__entry, inet->inet_saddr, inet->inet_daddr,
 160                                sk->sk_v6_rcv_saddr, sk->sk_v6_daddr);
 161         ),
 162
 163         TP_printk("sport=%hu dport=%hu saddr=%pI4 daddr=%pI4 saddrv6=%pI6c daddrv6=%pI6c",
 164                   __entry->sport, __entry->dport,
 165                   __entry->saddr, __entry->daddr,
 166                   __entry->saddr_v6, __entry->daddr_v6)
 167 );
 168
 169 DEFINE_EVENT(tcp_event_sk, tcp_receive_reset,
 170
 171         TP_PROTO(const struct sock *sk),
 172
 173         TP_ARGS(sk)
 174 );
 175
 176 DEFINE_EVENT(tcp_event_sk, tcp_destroy_sock,
 177
 178         TP_PROTO(const struct sock *sk),
 179
 180         TP_ARGS(sk)
 181 );
 182
 183 TRACE_EVENT(tcp_set_state,
 184
 185         TP_PROTO(const struct sock *sk, const int oldstate, const int newstate),
 186
 187         TP_ARGS(sk, oldstate, newstate),
 188
 189         TP_STRUCT__entry(
 190                 __field(const void *, skaddr)
 191                 __field(int, oldstate)
 192                 __field(int, newstate)
 193                 __field(__u16, sport)
 194                 __field(__u16, dport)
 195                 __array(__u8, saddr, 4)
 196                 __array(__u8, daddr, 4)
 197                 __array(__u8, saddr_v6, 16)
 198                 __array(__u8, daddr_v6, 16)
 199         ),
 200
 201         TP_fast_assign(
 202                 struct inet_sock *inet = inet_sk(sk);
 203                 __be32 *p32;
 204
 205                 __entry->skaddr = sk;
 206                 __entry->oldstate = oldstate;
 207                 __entry->newstate = newstate;
 208
 209                 __entry->sport = ntohs(inet->inet_sport);
 210                 __entry->dport = ntohs(inet->inet_dport);
 211
 212                 p32 = (__be32 *) __entry->saddr;
 213                 *p32 = inet->inet_saddr;
 214
 215                 p32 = (__be32 *) __entry->daddr;
 216                 *p32 =  inet->inet_daddr;
 217
 218                 TP_STORE_ADDRS(__entry, inet->inet_saddr, inet->inet_daddr,
 219                                sk->sk_v6_rcv_saddr, sk->sk_v6_daddr);
 220         ),
 221
 222         TP_printk("sport=%hu dport=%hu saddr=%pI4 daddr=%pI4 saddrv6=%pI6c daddrv6=%pI6c oldstate=%s newstate=%s",
 223                   __entry->sport, __entry->dport,
 224                   __entry->saddr, __entry->daddr,
 225                   __entry->saddr_v6, __entry->daddr_v6,
 226                   show_tcp_state_name(__entry->oldstate),
 227                   show_tcp_state_name(__entry->newstate))
 228 );
 229
 230 TRACE_EVENT(tcp_retransmit_synack,
 231
 232         TP_PROTO(const struct sock *sk, const struct request_sock *req),
 233
 234         TP_ARGS(sk, req),
 235
 236         TP_STRUCT__entry(
 237                 __field(const void *, skaddr)
 238                 __field(const void *, req)
 239                 __field(__u16, sport)
 240                 __field(__u16, dport)
 241                 __array(__u8, saddr, 4)
 242                 __array(__u8, daddr, 4)
 243                 __array(__u8, saddr_v6, 16)
 244                 __array(__u8, daddr_v6, 16)
 245         ),
 246
 247         TP_fast_assign(
 248                 struct inet_request_sock *ireq = inet_rsk(req);
 249                 __be32 *p32;
 250
 251                 __entry->skaddr = sk;
 252                 __entry->req = req;
 253
 254                 __entry->sport = ireq->ir_num;
 255                 __entry->dport = ntohs(ireq->ir_rmt_port);
 256
 257                 p32 = (__be32 *) __entry->saddr;
 258                 *p32 = ireq->ir_loc_addr;
 259
 260                 p32 = (__be32 *) __entry->daddr;
 261                 *p32 = ireq->ir_rmt_addr;
 262
 263                 TP_STORE_ADDRS(__entry, ireq->ir_loc_addr, ireq->ir_rmt_addr,
 264                               ireq->ir_v6_loc_addr, ireq->ir_v6_rmt_addr);
 265         ),
 266
 267         TP_printk("sport=%hu dport=%hu saddr=%pI4 daddr=%pI4 saddrv6=%pI6c daddrv6=%pI6c",
 268                   __entry->sport, __entry->dport,
 269                   __entry->saddr, __entry->daddr,
 270                   __entry->saddr_v6, __entry->daddr_v6)
 271 );
 272
 273 #endif /* _TRACE_TCP_H */
 274
 275 /* This part must be outside protection */
 276 #include <trace/define_trace.h>