Back to home page

OSCL-LXR
 
 

     

0001 /* SPDX-License-Identifier: GPL-2.0 */
0002 #undef TRACE_SYSTEM
0003 #define TRACE_SYSTEM tcp
0004 
0005 #if !defined(_TRACE_TCP_H) || defined(TRACE_HEADER_MULTI_READ)
0006 #define _TRACE_TCP_H
0007 
0008 #include <linux/ipv6.h>
0009 #include <linux/tcp.h>
0010 #include <linux/tracepoint.h>
0011 #include <net/ipv6.h>
0012 #include <net/tcp.h>
0013 #include <linux/sock_diag.h>
0014 
0015 #define TP_STORE_V4MAPPED(__entry, saddr, daddr)        \
0016     do {                            \
0017         struct in6_addr *pin6;              \
0018                                 \
0019         pin6 = (struct in6_addr *)__entry->saddr_v6;    \
0020         ipv6_addr_set_v4mapped(saddr, pin6);        \
0021         pin6 = (struct in6_addr *)__entry->daddr_v6;    \
0022         ipv6_addr_set_v4mapped(daddr, pin6);        \
0023     } while (0)
0024 
0025 #if IS_ENABLED(CONFIG_IPV6)
0026 #define TP_STORE_ADDRS(__entry, saddr, daddr, saddr6, daddr6)       \
0027     do {                                \
0028         if (sk->sk_family == AF_INET6) {            \
0029             struct in6_addr *pin6;              \
0030                                     \
0031             pin6 = (struct in6_addr *)__entry->saddr_v6;    \
0032             *pin6 = saddr6;                 \
0033             pin6 = (struct in6_addr *)__entry->daddr_v6;    \
0034             *pin6 = daddr6;                 \
0035         } else {                        \
0036             TP_STORE_V4MAPPED(__entry, saddr, daddr);   \
0037         }                           \
0038     } while (0)
0039 #else
0040 #define TP_STORE_ADDRS(__entry, saddr, daddr, saddr6, daddr6)   \
0041     TP_STORE_V4MAPPED(__entry, saddr, daddr)
0042 #endif
0043 
0044 /*
0045  * tcp event with arguments sk and skb
0046  *
0047  * Note: this class requires a valid sk pointer; while skb pointer could
0048  *       be NULL.
0049  */
0050 DECLARE_EVENT_CLASS(tcp_event_sk_skb,
0051 
0052     TP_PROTO(const struct sock *sk, const struct sk_buff *skb),
0053 
0054     TP_ARGS(sk, skb),
0055 
0056     TP_STRUCT__entry(
0057         __field(const void *, skbaddr)
0058         __field(const void *, skaddr)
0059         __field(int, state)
0060         __field(__u16, sport)
0061         __field(__u16, dport)
0062         __field(__u16, family)
0063         __array(__u8, saddr, 4)
0064         __array(__u8, daddr, 4)
0065         __array(__u8, saddr_v6, 16)
0066         __array(__u8, daddr_v6, 16)
0067     ),
0068 
0069     TP_fast_assign(
0070         struct inet_sock *inet = inet_sk(sk);
0071         __be32 *p32;
0072 
0073         __entry->skbaddr = skb;
0074         __entry->skaddr = sk;
0075         __entry->state = sk->sk_state;
0076 
0077         __entry->sport = ntohs(inet->inet_sport);
0078         __entry->dport = ntohs(inet->inet_dport);
0079         __entry->family = sk->sk_family;
0080 
0081         p32 = (__be32 *) __entry->saddr;
0082         *p32 = inet->inet_saddr;
0083 
0084         p32 = (__be32 *) __entry->daddr;
0085         *p32 =  inet->inet_daddr;
0086 
0087         TP_STORE_ADDRS(__entry, inet->inet_saddr, inet->inet_daddr,
0088                   sk->sk_v6_rcv_saddr, sk->sk_v6_daddr);
0089     ),
0090 
0091     TP_printk("family=%s sport=%hu dport=%hu saddr=%pI4 daddr=%pI4 saddrv6=%pI6c daddrv6=%pI6c state=%s",
0092           show_family_name(__entry->family),
0093           __entry->sport, __entry->dport, __entry->saddr, __entry->daddr,
0094           __entry->saddr_v6, __entry->daddr_v6,
0095           show_tcp_state_name(__entry->state))
0096 );
0097 
0098 DEFINE_EVENT(tcp_event_sk_skb, tcp_retransmit_skb,
0099 
0100     TP_PROTO(const struct sock *sk, const struct sk_buff *skb),
0101 
0102     TP_ARGS(sk, skb)
0103 );
0104 
0105 /*
0106  * skb of trace_tcp_send_reset is the skb that caused RST. In case of
0107  * active reset, skb should be NULL
0108  */
0109 DEFINE_EVENT(tcp_event_sk_skb, tcp_send_reset,
0110 
0111     TP_PROTO(const struct sock *sk, const struct sk_buff *skb),
0112 
0113     TP_ARGS(sk, skb)
0114 );
0115 
0116 /*
0117  * tcp event with arguments sk
0118  *
0119  * Note: this class requires a valid sk pointer.
0120  */
0121 DECLARE_EVENT_CLASS(tcp_event_sk,
0122 
0123     TP_PROTO(struct sock *sk),
0124 
0125     TP_ARGS(sk),
0126 
0127     TP_STRUCT__entry(
0128         __field(const void *, skaddr)
0129         __field(__u16, sport)
0130         __field(__u16, dport)
0131         __field(__u16, family)
0132         __array(__u8, saddr, 4)
0133         __array(__u8, daddr, 4)
0134         __array(__u8, saddr_v6, 16)
0135         __array(__u8, daddr_v6, 16)
0136         __field(__u64, sock_cookie)
0137     ),
0138 
0139     TP_fast_assign(
0140         struct inet_sock *inet = inet_sk(sk);
0141         __be32 *p32;
0142 
0143         __entry->skaddr = sk;
0144 
0145         __entry->sport = ntohs(inet->inet_sport);
0146         __entry->dport = ntohs(inet->inet_dport);
0147         __entry->family = sk->sk_family;
0148 
0149         p32 = (__be32 *) __entry->saddr;
0150         *p32 = inet->inet_saddr;
0151 
0152         p32 = (__be32 *) __entry->daddr;
0153         *p32 =  inet->inet_daddr;
0154 
0155         TP_STORE_ADDRS(__entry, inet->inet_saddr, inet->inet_daddr,
0156                    sk->sk_v6_rcv_saddr, sk->sk_v6_daddr);
0157 
0158         __entry->sock_cookie = sock_gen_cookie(sk);
0159     ),
0160 
0161     TP_printk("family=%s sport=%hu dport=%hu saddr=%pI4 daddr=%pI4 saddrv6=%pI6c daddrv6=%pI6c sock_cookie=%llx",
0162           show_family_name(__entry->family),
0163           __entry->sport, __entry->dport,
0164           __entry->saddr, __entry->daddr,
0165           __entry->saddr_v6, __entry->daddr_v6,
0166           __entry->sock_cookie)
0167 );
0168 
0169 DEFINE_EVENT(tcp_event_sk, tcp_receive_reset,
0170 
0171     TP_PROTO(struct sock *sk),
0172 
0173     TP_ARGS(sk)
0174 );
0175 
0176 DEFINE_EVENT(tcp_event_sk, tcp_destroy_sock,
0177 
0178     TP_PROTO(struct sock *sk),
0179 
0180     TP_ARGS(sk)
0181 );
0182 
0183 DEFINE_EVENT(tcp_event_sk, tcp_rcv_space_adjust,
0184 
0185     TP_PROTO(struct sock *sk),
0186 
0187     TP_ARGS(sk)
0188 );
0189 
0190 TRACE_EVENT(tcp_retransmit_synack,
0191 
0192     TP_PROTO(const struct sock *sk, const struct request_sock *req),
0193 
0194     TP_ARGS(sk, req),
0195 
0196     TP_STRUCT__entry(
0197         __field(const void *, skaddr)
0198         __field(const void *, req)
0199         __field(__u16, sport)
0200         __field(__u16, dport)
0201         __field(__u16, family)
0202         __array(__u8, saddr, 4)
0203         __array(__u8, daddr, 4)
0204         __array(__u8, saddr_v6, 16)
0205         __array(__u8, daddr_v6, 16)
0206     ),
0207 
0208     TP_fast_assign(
0209         struct inet_request_sock *ireq = inet_rsk(req);
0210         __be32 *p32;
0211 
0212         __entry->skaddr = sk;
0213         __entry->req = req;
0214 
0215         __entry->sport = ireq->ir_num;
0216         __entry->dport = ntohs(ireq->ir_rmt_port);
0217         __entry->family = sk->sk_family;
0218 
0219         p32 = (__be32 *) __entry->saddr;
0220         *p32 = ireq->ir_loc_addr;
0221 
0222         p32 = (__be32 *) __entry->daddr;
0223         *p32 = ireq->ir_rmt_addr;
0224 
0225         TP_STORE_ADDRS(__entry, ireq->ir_loc_addr, ireq->ir_rmt_addr,
0226                   ireq->ir_v6_loc_addr, ireq->ir_v6_rmt_addr);
0227     ),
0228 
0229     TP_printk("family=%s sport=%hu dport=%hu saddr=%pI4 daddr=%pI4 saddrv6=%pI6c daddrv6=%pI6c",
0230           show_family_name(__entry->family),
0231           __entry->sport, __entry->dport,
0232           __entry->saddr, __entry->daddr,
0233           __entry->saddr_v6, __entry->daddr_v6)
0234 );
0235 
0236 #include <trace/events/net_probe_common.h>
0237 
0238 TRACE_EVENT(tcp_probe,
0239 
0240     TP_PROTO(struct sock *sk, struct sk_buff *skb),
0241 
0242     TP_ARGS(sk, skb),
0243 
0244     TP_STRUCT__entry(
0245         /* sockaddr_in6 is always bigger than sockaddr_in */
0246         __array(__u8, saddr, sizeof(struct sockaddr_in6))
0247         __array(__u8, daddr, sizeof(struct sockaddr_in6))
0248         __field(__u16, sport)
0249         __field(__u16, dport)
0250         __field(__u16, family)
0251         __field(__u32, mark)
0252         __field(__u16, data_len)
0253         __field(__u32, snd_nxt)
0254         __field(__u32, snd_una)
0255         __field(__u32, snd_cwnd)
0256         __field(__u32, ssthresh)
0257         __field(__u32, snd_wnd)
0258         __field(__u32, srtt)
0259         __field(__u32, rcv_wnd)
0260         __field(__u64, sock_cookie)
0261     ),
0262 
0263     TP_fast_assign(
0264         const struct tcphdr *th = (const struct tcphdr *)skb->data;
0265         const struct inet_sock *inet = inet_sk(sk);
0266         const struct tcp_sock *tp = tcp_sk(sk);
0267 
0268         memset(__entry->saddr, 0, sizeof(struct sockaddr_in6));
0269         memset(__entry->daddr, 0, sizeof(struct sockaddr_in6));
0270 
0271         TP_STORE_ADDR_PORTS(__entry, inet, sk);
0272 
0273         /* For filtering use */
0274         __entry->sport = ntohs(inet->inet_sport);
0275         __entry->dport = ntohs(inet->inet_dport);
0276         __entry->mark = skb->mark;
0277         __entry->family = sk->sk_family;
0278 
0279         __entry->data_len = skb->len - __tcp_hdrlen(th);
0280         __entry->snd_nxt = tp->snd_nxt;
0281         __entry->snd_una = tp->snd_una;
0282         __entry->snd_cwnd = tcp_snd_cwnd(tp);
0283         __entry->snd_wnd = tp->snd_wnd;
0284         __entry->rcv_wnd = tp->rcv_wnd;
0285         __entry->ssthresh = tcp_current_ssthresh(sk);
0286         __entry->srtt = tp->srtt_us >> 3;
0287         __entry->sock_cookie = sock_gen_cookie(sk);
0288     ),
0289 
0290     TP_printk("family=%s src=%pISpc dest=%pISpc mark=%#x data_len=%d snd_nxt=%#x snd_una=%#x snd_cwnd=%u ssthresh=%u snd_wnd=%u srtt=%u rcv_wnd=%u sock_cookie=%llx",
0291           show_family_name(__entry->family),
0292           __entry->saddr, __entry->daddr, __entry->mark,
0293           __entry->data_len, __entry->snd_nxt, __entry->snd_una,
0294           __entry->snd_cwnd, __entry->ssthresh, __entry->snd_wnd,
0295           __entry->srtt, __entry->rcv_wnd, __entry->sock_cookie)
0296 );
0297 
0298 #define TP_STORE_ADDR_PORTS_SKB_V4(__entry, skb)            \
0299     do {                                \
0300         const struct tcphdr *th = (const struct tcphdr *)skb->data; \
0301         struct sockaddr_in *v4 = (void *)__entry->saddr;    \
0302                                     \
0303         v4->sin_family = AF_INET;               \
0304         v4->sin_port = th->source;              \
0305         v4->sin_addr.s_addr = ip_hdr(skb)->saddr;       \
0306         v4 = (void *)__entry->daddr;                \
0307         v4->sin_family = AF_INET;               \
0308         v4->sin_port = th->dest;                \
0309         v4->sin_addr.s_addr = ip_hdr(skb)->daddr;       \
0310     } while (0)
0311 
0312 #if IS_ENABLED(CONFIG_IPV6)
0313 
0314 #define TP_STORE_ADDR_PORTS_SKB(__entry, skb)               \
0315     do {                                \
0316         const struct iphdr *iph = ip_hdr(skb);          \
0317                                     \
0318         if (iph->version == 6) {                \
0319             const struct tcphdr *th = (const struct tcphdr *)skb->data; \
0320             struct sockaddr_in6 *v6 = (void *)__entry->saddr; \
0321                                     \
0322             v6->sin6_family = AF_INET6;         \
0323             v6->sin6_port = th->source;         \
0324             v6->sin6_addr = ipv6_hdr(skb)->saddr;       \
0325             v6 = (void *)__entry->daddr;            \
0326             v6->sin6_family = AF_INET6;         \
0327             v6->sin6_port = th->dest;           \
0328             v6->sin6_addr = ipv6_hdr(skb)->daddr;       \
0329         } else                          \
0330             TP_STORE_ADDR_PORTS_SKB_V4(__entry, skb);   \
0331     } while (0)
0332 
0333 #else
0334 
0335 #define TP_STORE_ADDR_PORTS_SKB(__entry, skb)       \
0336     TP_STORE_ADDR_PORTS_SKB_V4(__entry, skb)
0337 
0338 #endif
0339 
0340 /*
0341  * tcp event with only skb
0342  */
0343 DECLARE_EVENT_CLASS(tcp_event_skb,
0344 
0345     TP_PROTO(const struct sk_buff *skb),
0346 
0347     TP_ARGS(skb),
0348 
0349     TP_STRUCT__entry(
0350         __field(const void *, skbaddr)
0351         __array(__u8, saddr, sizeof(struct sockaddr_in6))
0352         __array(__u8, daddr, sizeof(struct sockaddr_in6))
0353     ),
0354 
0355     TP_fast_assign(
0356         __entry->skbaddr = skb;
0357 
0358         memset(__entry->saddr, 0, sizeof(struct sockaddr_in6));
0359         memset(__entry->daddr, 0, sizeof(struct sockaddr_in6));
0360 
0361         TP_STORE_ADDR_PORTS_SKB(__entry, skb);
0362     ),
0363 
0364     TP_printk("src=%pISpc dest=%pISpc", __entry->saddr, __entry->daddr)
0365 );
0366 
0367 DEFINE_EVENT(tcp_event_skb, tcp_bad_csum,
0368 
0369     TP_PROTO(const struct sk_buff *skb),
0370 
0371     TP_ARGS(skb)
0372 );
0373 
0374 TRACE_EVENT(tcp_cong_state_set,
0375 
0376     TP_PROTO(struct sock *sk, const u8 ca_state),
0377 
0378     TP_ARGS(sk, ca_state),
0379 
0380     TP_STRUCT__entry(
0381         __field(const void *, skaddr)
0382         __field(__u16, sport)
0383         __field(__u16, dport)
0384         __array(__u8, saddr, 4)
0385         __array(__u8, daddr, 4)
0386         __array(__u8, saddr_v6, 16)
0387         __array(__u8, daddr_v6, 16)
0388         __field(__u8, cong_state)
0389     ),
0390 
0391     TP_fast_assign(
0392         struct inet_sock *inet = inet_sk(sk);
0393         __be32 *p32;
0394 
0395         __entry->skaddr = sk;
0396 
0397         __entry->sport = ntohs(inet->inet_sport);
0398         __entry->dport = ntohs(inet->inet_dport);
0399 
0400         p32 = (__be32 *) __entry->saddr;
0401         *p32 = inet->inet_saddr;
0402 
0403         p32 = (__be32 *) __entry->daddr;
0404         *p32 =  inet->inet_daddr;
0405 
0406         TP_STORE_ADDRS(__entry, inet->inet_saddr, inet->inet_daddr,
0407                sk->sk_v6_rcv_saddr, sk->sk_v6_daddr);
0408 
0409         __entry->cong_state = ca_state;
0410     ),
0411 
0412     TP_printk("sport=%hu dport=%hu saddr=%pI4 daddr=%pI4 saddrv6=%pI6c daddrv6=%pI6c cong_state=%u",
0413           __entry->sport, __entry->dport,
0414           __entry->saddr, __entry->daddr,
0415           __entry->saddr_v6, __entry->daddr_v6,
0416           __entry->cong_state)
0417 );
0418 
0419 #endif /* _TRACE_TCP_H */
0420 
0421 /* This part must be outside protection */
0422 #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!