projects/linux·blob master · refs

839 lines · 21.7 KiB

1/* SPDX-License-Identifier: GPL-2.0 */
2#undef TRACE_SYSTEM
3#define TRACE_SYSTEM tcp
4
5#if !defined(_TRACE_TCP_H) || defined(TRACE_HEADER_MULTI_READ)
6#define _TRACE_TCP_H
7
8#include <linux/ipv6.h>
9#include <linux/tcp.h>
10#include <linux/tracepoint.h>
11#include <net/ipv6.h>
12#include <net/tcp.h>
13#include <linux/sock_diag.h>
14#include <net/rstreason.h>
15
16TRACE_EVENT(tcp_retransmit_skb,
17
18 TP_PROTO(const struct sock *sk, const struct sk_buff *skb, int err),
19
20 TP_ARGS(sk, skb, err),
21
22 TP_STRUCT__entry(
23 __field(const void *, skbaddr)
24 __field(const void *, skaddr)
25 __field(int, state)
26 __field(__u16, sport)
27 __field(__u16, dport)
28 __field(__u16, family)
29 __array(__u8, saddr, 4)
30 __array(__u8, daddr, 4)
31 __array(__u8, saddr_v6, 16)
32 __array(__u8, daddr_v6, 16)
33 __field(int, err)
34 ),
35
36 TP_fast_assign(
37 const struct inet_sock *inet = inet_sk(sk);
38 __be32 *p32;
39
40 __entry->skbaddr = skb;
41 __entry->skaddr = sk;
42 __entry->state = sk->sk_state;
43
44 __entry->sport = ntohs(inet->inet_sport);
45 __entry->dport = ntohs(inet->inet_dport);
46 __entry->family = sk->sk_family;
47
48 p32 = (__be32 *) __entry->saddr;
49 *p32 = inet->inet_saddr;
50
51 p32 = (__be32 *) __entry->daddr;
52 *p32 = inet->inet_daddr;
53
54 TP_STORE_ADDRS(__entry, inet->inet_saddr, inet->inet_daddr,
55 sk->sk_v6_rcv_saddr, sk->sk_v6_daddr);
56
57 __entry->err = err;
58 ),
59
60 TP_printk("skbaddr=%p skaddr=%p family=%s sport=%hu dport=%hu saddr=%pI4 daddr=%pI4 saddrv6=%pI6c daddrv6=%pI6c state=%s err=%d",
61 __entry->skbaddr, __entry->skaddr,
62 show_family_name(__entry->family),
63 __entry->sport, __entry->dport, __entry->saddr, __entry->daddr,
64 __entry->saddr_v6, __entry->daddr_v6,
65 show_tcp_state_name(__entry->state),
66 __entry->err)
67);
68
69#undef FN
70#define FN(reason) TRACE_DEFINE_ENUM(SK_RST_REASON_##reason);
71DEFINE_RST_REASON(FN, FN)
72
73#undef FN
74#undef FNe
75#define FN(reason) { SK_RST_REASON_##reason, #reason },
76#define FNe(reason) { SK_RST_REASON_##reason, #reason }
77
78/*
79 * skb of trace_tcp_send_reset is the skb that caused RST. In case of
80 * active reset, skb should be NULL
81 */
82TRACE_EVENT(tcp_send_reset,
83
84 TP_PROTO(const struct sock *sk,
85 const struct sk_buff *skb__nullable,
86 const enum sk_rst_reason reason),
87
88 TP_ARGS(sk, skb__nullable, reason),
89
90 TP_STRUCT__entry(
91 __field(const void *, skbaddr)
92 __field(const void *, skaddr)
93 __field(int, state)
94 __field(enum sk_rst_reason, reason)
95 __array(__u8, saddr, sizeof(struct sockaddr_in6))
96 __array(__u8, daddr, sizeof(struct sockaddr_in6))
97 ),
98
99 TP_fast_assign(
100 __entry->skbaddr = skb__nullable;
101 __entry->skaddr = sk;
102 /* Zero means unknown state. */
103 __entry->state = sk ? sk->sk_state : 0;
104
105 memset(__entry->saddr, 0, sizeof(struct sockaddr_in6));
106 memset(__entry->daddr, 0, sizeof(struct sockaddr_in6));
107
108 if (sk && sk_fullsock(sk)) {
109 const struct inet_sock *inet = inet_sk(sk);
110
111 TP_STORE_ADDR_PORTS(__entry, inet, sk);
112 } else if (skb__nullable) {
113 const struct tcphdr *th = (const struct tcphdr *)skb__nullable->data;
114 /*
115 * We should reverse the 4-tuple of skb, so later
116 * it can print the right flow direction of rst.
117 */
118 TP_STORE_ADDR_PORTS_SKB(skb__nullable, th, entry->daddr, entry->saddr);
119 }
120 __entry->reason = reason;
121 ),
122
123 TP_printk("skbaddr=%p skaddr=%p src=%pISpc dest=%pISpc state=%s reason=%s",
124 __entry->skbaddr, __entry->skaddr,
125 __entry->saddr, __entry->daddr,
126 __entry->state ? show_tcp_state_name(__entry->state) : "UNKNOWN",
127 __print_symbolic(__entry->reason, DEFINE_RST_REASON(FN, FNe)))
128);
129
130#undef FN
131#undef FNe
132
133/*
134 * tcp event with arguments sk
135 *
136 * Note: this class requires a valid sk pointer.
137 */
138DECLARE_EVENT_CLASS(tcp_event_sk,
139
140 TP_PROTO(struct sock *sk),
141
142 TP_ARGS(sk),
143
144 TP_STRUCT__entry(
145 __field(const void *, skaddr)
146 __field(__u16, sport)
147 __field(__u16, dport)
148 __field(__u16, family)
149 __array(__u8, saddr, 4)
150 __array(__u8, daddr, 4)
151 __array(__u8, saddr_v6, 16)
152 __array(__u8, daddr_v6, 16)
153 __field(__u64, sock_cookie)
154 ),
155
156 TP_fast_assign(
157 struct inet_sock *inet = inet_sk(sk);
158 __be32 *p32;
159
160 __entry->skaddr = sk;
161
162 __entry->sport = ntohs(inet->inet_sport);
163 __entry->dport = ntohs(inet->inet_dport);
164 __entry->family = sk->sk_family;
165
166 p32 = (__be32 *) __entry->saddr;
167 *p32 = inet->inet_saddr;
168
169 p32 = (__be32 *) __entry->daddr;
170 *p32 = inet->inet_daddr;
171
172 TP_STORE_ADDRS(__entry, inet->inet_saddr, inet->inet_daddr,
173 sk->sk_v6_rcv_saddr, sk->sk_v6_daddr);
174
175 __entry->sock_cookie = sock_gen_cookie(sk);
176 ),
177
178 TP_printk("family=%s sport=%hu dport=%hu saddr=%pI4 daddr=%pI4 saddrv6=%pI6c daddrv6=%pI6c sock_cookie=%llx",
179 show_family_name(__entry->family),
180 __entry->sport, __entry->dport,
181 __entry->saddr, __entry->daddr,
182 __entry->saddr_v6, __entry->daddr_v6,
183 __entry->sock_cookie)
184);
185
186DEFINE_EVENT(tcp_event_sk, tcp_receive_reset,
187
188 TP_PROTO(struct sock *sk),
189
190 TP_ARGS(sk)
191);
192
193DEFINE_EVENT(tcp_event_sk, tcp_destroy_sock,
194
195 TP_PROTO(struct sock *sk),
196
197 TP_ARGS(sk)
198);
199
200DEFINE_EVENT(tcp_event_sk, tcp_rcv_space_adjust,
201
202 TP_PROTO(struct sock *sk),
203
204 TP_ARGS(sk)
205);
206
207TRACE_EVENT(tcp_rcvbuf_grow,
208
209 TP_PROTO(struct sock *sk, int time),
210
211 TP_ARGS(sk, time),
212
213 TP_STRUCT__entry(
214 __field(int, time)
215 __field(__u32, rtt_us)
216 __field(__u32, copied)
217 __field(__u32, inq)
218 __field(__u32, space)
219 __field(__u32, ooo_space)
220 __field(__u32, rcvbuf)
221 __field(__u32, rcv_ssthresh)
222 __field(__u32, window_clamp)
223 __field(__u32, rcv_wnd)
224 __field(__u8, scaling_ratio)
225 __field(__u16, sport)
226 __field(__u16, dport)
227 __field(__u16, family)
228 __array(__u8, saddr, 4)
229 __array(__u8, daddr, 4)
230 __array(__u8, saddr_v6, 16)
231 __array(__u8, daddr_v6, 16)
232 __field(const void *, skaddr)
233 __field(__u64, sock_cookie)
234 ),
235
236 TP_fast_assign(
237 struct inet_sock *inet = inet_sk(sk);
238 struct tcp_sock *tp = tcp_sk(sk);
239 __be32 *p32;
240
241 __entry->time = time;
242 __entry->rtt_us = tp->rcv_rtt_est.rtt_us >> 3;
243 __entry->copied = tp->copied_seq - tp->rcvq_space.seq;
244 __entry->inq = tp->rcv_nxt - tp->copied_seq;
245 __entry->space = tp->rcvq_space.space;
246 __entry->ooo_space = RB_EMPTY_ROOT(&tp->out_of_order_queue) ? 0 :
247 TCP_SKB_CB(tp->ooo_last_skb)->end_seq -
248 tp->rcv_nxt;
249
250 __entry->rcvbuf = sk->sk_rcvbuf;
251 __entry->rcv_ssthresh = tp->rcv_ssthresh;
252 __entry->window_clamp = tp->window_clamp;
253 __entry->rcv_wnd = tp->rcv_wnd;
254 __entry->scaling_ratio = tp->scaling_ratio;
255 __entry->sport = ntohs(inet->inet_sport);
256 __entry->dport = ntohs(inet->inet_dport);
257 __entry->family = sk->sk_family;
258
259 p32 = (__be32 *) __entry->saddr;
260 *p32 = inet->inet_saddr;
261
262 p32 = (__be32 *) __entry->daddr;
263 *p32 = inet->inet_daddr;
264
265 TP_STORE_ADDRS(__entry, inet->inet_saddr, inet->inet_daddr,
266 sk->sk_v6_rcv_saddr, sk->sk_v6_daddr);
267
268 __entry->skaddr = sk;
269 __entry->sock_cookie = sock_gen_cookie(sk);
270 ),
271
272 TP_printk("time=%u rtt_us=%u copied=%u inq=%u space=%u ooo=%u scaling_ratio=%u rcvbuf=%u "
273 "rcv_ssthresh=%u window_clamp=%u rcv_wnd=%u "
274 "family=%s sport=%hu dport=%hu saddr=%pI4 daddr=%pI4 "
275 "saddrv6=%pI6c daddrv6=%pI6c skaddr=%p sock_cookie=%llx",
276 __entry->time, __entry->rtt_us, __entry->copied,
277 __entry->inq, __entry->space, __entry->ooo_space,
278 __entry->scaling_ratio, __entry->rcvbuf,
279 __entry->rcv_ssthresh, __entry->window_clamp,
280 __entry->rcv_wnd,
281 show_family_name(__entry->family),
282 __entry->sport, __entry->dport,
283 __entry->saddr, __entry->daddr,
284 __entry->saddr_v6, __entry->daddr_v6,
285 __entry->skaddr,
286 __entry->sock_cookie)
287);
288
289TRACE_EVENT(tcp_retransmit_synack,
290
291 TP_PROTO(const struct sock *sk, const struct request_sock *req),
292
293 TP_ARGS(sk, req),
294
295 TP_STRUCT__entry(
296 __field(const void *, skaddr)
297 __field(const void *, req)
298 __field(__u16, sport)
299 __field(__u16, dport)
300 __field(__u16, family)
301 __array(__u8, saddr, 4)
302 __array(__u8, daddr, 4)
303 __array(__u8, saddr_v6, 16)
304 __array(__u8, daddr_v6, 16)
305 ),
306
307 TP_fast_assign(
308 const struct inet_request_sock *ireq = inet_rsk(req);
309 __be32 *p32;
310
311 __entry->skaddr = sk;
312 __entry->req = req;
313
314 __entry->sport = ireq->ir_num;
315 __entry->dport = ntohs(ireq->ir_rmt_port);
316 __entry->family = sk->sk_family;
317
318 p32 = (__be32 *) __entry->saddr;
319 *p32 = ireq->ir_loc_addr;
320
321 p32 = (__be32 *) __entry->daddr;
322 *p32 = ireq->ir_rmt_addr;
323
324 TP_STORE_ADDRS(__entry, ireq->ir_loc_addr, ireq->ir_rmt_addr,
325 ireq->ir_v6_loc_addr, ireq->ir_v6_rmt_addr);
326 ),
327
328 TP_printk("family=%s sport=%hu dport=%hu saddr=%pI4 daddr=%pI4 saddrv6=%pI6c daddrv6=%pI6c",
329 show_family_name(__entry->family),
330 __entry->sport, __entry->dport,
331 __entry->saddr, __entry->daddr,
332 __entry->saddr_v6, __entry->daddr_v6)
333);
334
335TRACE_EVENT(tcp_sendmsg_locked,
336 TP_PROTO(const struct sock *sk, const struct msghdr *msg,
337 const struct sk_buff *skb, int size_goal),
338
339 TP_ARGS(sk, msg, skb, size_goal),
340
341 TP_STRUCT__entry(
342 __field(const void *, skb_addr)
343 __field(int, skb_len)
344 __field(int, msg_left)
345 __field(int, size_goal)
346 ),
347
348 TP_fast_assign(
349 __entry->skb_addr = skb;
350 __entry->skb_len = skb ? skb->len : 0;
351 __entry->msg_left = msg_data_left(msg);
352 __entry->size_goal = size_goal;
353 ),
354
355 TP_printk("skb_addr %p skb_len %d msg_left %d size_goal %d",
356 __entry->skb_addr, __entry->skb_len, __entry->msg_left,
357 __entry->size_goal));
358
359DECLARE_TRACE(tcp_cwnd_reduction,
360 TP_PROTO(const struct sock *sk, int newly_acked_sacked,
361 int newly_lost, int flag),
362 TP_ARGS(sk, newly_acked_sacked, newly_lost, flag)
363);
364
365#include <trace/events/net_probe_common.h>
366
367TRACE_EVENT(tcp_probe,
368
369 TP_PROTO(struct sock *sk, const struct sk_buff *skb),
370
371 TP_ARGS(sk, skb),
372
373 TP_STRUCT__entry(
374 /* sockaddr_in6 is always bigger than sockaddr_in */
375 __array(__u8, saddr, sizeof(struct sockaddr_in6))
376 __array(__u8, daddr, sizeof(struct sockaddr_in6))
377 __field(__u16, sport)
378 __field(__u16, dport)
379 __field(__u16, family)
380 __field(__u32, mark)
381 __field(__u16, data_len)
382 __field(__u32, snd_nxt)
383 __field(__u32, snd_una)
384 __field(__u32, snd_cwnd)
385 __field(__u32, ssthresh)
386 __field(__u32, snd_wnd)
387 __field(__u32, srtt)
388 __field(__u32, rcv_wnd)
389 __field(__u64, sock_cookie)
390 __field(const void *, skbaddr)
391 __field(const void *, skaddr)
392 ),
393
394 TP_fast_assign(
395 const struct tcphdr *th = (const struct tcphdr *)skb->data;
396 const struct inet_sock *inet = inet_sk(sk);
397 const struct tcp_sock *tp = tcp_sk(sk);
398
399 memset(__entry->saddr, 0, sizeof(struct sockaddr_in6));
400 memset(__entry->daddr, 0, sizeof(struct sockaddr_in6));
401
402 TP_STORE_ADDR_PORTS(__entry, inet, sk);
403
404 /* For filtering use */
405 __entry->sport = ntohs(inet->inet_sport);
406 __entry->dport = ntohs(inet->inet_dport);
407 __entry->mark = skb->mark;
408 __entry->family = sk->sk_family;
409
410 __entry->data_len = skb->len - __tcp_hdrlen(th);
411 __entry->snd_nxt = tp->snd_nxt;
412 __entry->snd_una = tp->snd_una;
413 __entry->snd_cwnd = tcp_snd_cwnd(tp);
414 __entry->snd_wnd = tp->snd_wnd;
415 __entry->rcv_wnd = tp->rcv_wnd;
416 __entry->ssthresh = tcp_current_ssthresh(sk);
417 __entry->srtt = tp->srtt_us >> 3;
418 __entry->sock_cookie = sock_gen_cookie(sk);
419
420 __entry->skbaddr = skb;
421 __entry->skaddr = sk;
422 ),
423
424 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 skbaddr=%p skaddr=%p",
425 show_family_name(__entry->family),
426 __entry->saddr, __entry->daddr, __entry->mark,
427 __entry->data_len, __entry->snd_nxt, __entry->snd_una,
428 __entry->snd_cwnd, __entry->ssthresh, __entry->snd_wnd,
429 __entry->srtt, __entry->rcv_wnd, __entry->sock_cookie,
430 __entry->skbaddr, __entry->skaddr)
431);
432
433/*
434 * tcp event with only skb
435 */
436DECLARE_EVENT_CLASS(tcp_event_skb,
437
438 TP_PROTO(const struct sk_buff *skb),
439
440 TP_ARGS(skb),
441
442 TP_STRUCT__entry(
443 __field(const void *, skbaddr)
444 __array(__u8, saddr, sizeof(struct sockaddr_in6))
445 __array(__u8, daddr, sizeof(struct sockaddr_in6))
446 ),
447
448 TP_fast_assign(
449 const struct tcphdr *th = (const struct tcphdr *)skb->data;
450 __entry->skbaddr = skb;
451
452 memset(__entry->saddr, 0, sizeof(struct sockaddr_in6));
453 memset(__entry->daddr, 0, sizeof(struct sockaddr_in6));
454
455 TP_STORE_ADDR_PORTS_SKB(skb, th, __entry->saddr, __entry->daddr);
456 ),
457
458 TP_printk("skbaddr=%p src=%pISpc dest=%pISpc",
459 __entry->skbaddr, __entry->saddr, __entry->daddr)
460);
461
462DEFINE_EVENT(tcp_event_skb, tcp_bad_csum,
463
464 TP_PROTO(const struct sk_buff *skb),
465
466 TP_ARGS(skb)
467);
468
469TRACE_EVENT(tcp_cong_state_set,
470
471 TP_PROTO(struct sock *sk, const u8 ca_state),
472
473 TP_ARGS(sk, ca_state),
474
475 TP_STRUCT__entry(
476 __field(const void *, skaddr)
477 __field(__u16, sport)
478 __field(__u16, dport)
479 __field(__u16, family)
480 __array(__u8, saddr, 4)
481 __array(__u8, daddr, 4)
482 __array(__u8, saddr_v6, 16)
483 __array(__u8, daddr_v6, 16)
484 __field(__u8, cong_state)
485 ),
486
487 TP_fast_assign(
488 struct inet_sock *inet = inet_sk(sk);
489 __be32 *p32;
490
491 __entry->skaddr = sk;
492
493 __entry->sport = ntohs(inet->inet_sport);
494 __entry->dport = ntohs(inet->inet_dport);
495 __entry->family = sk->sk_family;
496
497 p32 = (__be32 *) __entry->saddr;
498 *p32 = inet->inet_saddr;
499
500 p32 = (__be32 *) __entry->daddr;
501 *p32 = inet->inet_daddr;
502
503 TP_STORE_ADDRS(__entry, inet->inet_saddr, inet->inet_daddr,
504 sk->sk_v6_rcv_saddr, sk->sk_v6_daddr);
505
506 __entry->cong_state = ca_state;
507 ),
508
509 TP_printk("family=%s sport=%hu dport=%hu saddr=%pI4 daddr=%pI4 saddrv6=%pI6c daddrv6=%pI6c cong_state=%u",
510 show_family_name(__entry->family),
511 __entry->sport, __entry->dport,
512 __entry->saddr, __entry->daddr,
513 __entry->saddr_v6, __entry->daddr_v6,
514 __entry->cong_state)
515);
516
517DECLARE_EVENT_CLASS(tcp_hash_event,
518
519 TP_PROTO(const struct sock *sk, const struct sk_buff *skb),
520
521 TP_ARGS(sk, skb),
522
523 TP_STRUCT__entry(
524 __field(__u64, net_cookie)
525 __field(const void *, skbaddr)
526 __field(const void *, skaddr)
527 __field(int, state)
528
529 /* sockaddr_in6 is always bigger than sockaddr_in */
530 __array(__u8, saddr, sizeof(struct sockaddr_in6))
531 __array(__u8, daddr, sizeof(struct sockaddr_in6))
532 __field(int, l3index)
533
534 __field(__u16, sport)
535 __field(__u16, dport)
536 __field(__u16, family)
537
538 __field(bool, fin)
539 __field(bool, syn)
540 __field(bool, rst)
541 __field(bool, psh)
542 __field(bool, ack)
543 ),
544
545 TP_fast_assign(
546 const struct tcphdr *th = (const struct tcphdr *)skb->data;
547
548 __entry->net_cookie = sock_net(sk)->net_cookie;
549 __entry->skbaddr = skb;
550 __entry->skaddr = sk;
551 __entry->state = sk->sk_state;
552
553 memset(__entry->saddr, 0, sizeof(struct sockaddr_in6));
554 memset(__entry->daddr, 0, sizeof(struct sockaddr_in6));
555 TP_STORE_ADDR_PORTS_SKB(skb, th, __entry->saddr, __entry->daddr);
556 __entry->l3index = inet_sdif(skb) ? inet_iif(skb) : 0;
557
558 /* For filtering use */
559 __entry->sport = ntohs(th->source);
560 __entry->dport = ntohs(th->dest);
561 __entry->family = sk->sk_family;
562
563 __entry->fin = th->fin;
564 __entry->syn = th->syn;
565 __entry->rst = th->rst;
566 __entry->psh = th->psh;
567 __entry->ack = th->ack;
568 ),
569
570 TP_printk("net=%llu state=%s family=%s src=%pISpc dest=%pISpc L3index=%d [%c%c%c%c%c]",
571 __entry->net_cookie,
572 show_tcp_state_name(__entry->state),
573 show_family_name(__entry->family),
574 __entry->saddr, __entry->daddr,
575 __entry->l3index,
576 __entry->fin ? 'F' : ' ',
577 __entry->syn ? 'S' : ' ',
578 __entry->rst ? 'R' : ' ',
579 __entry->psh ? 'P' : ' ',
580 __entry->ack ? '.' : ' ')
581);
582
583DEFINE_EVENT(tcp_hash_event, tcp_hash_bad_header,
584
585 TP_PROTO(const struct sock *sk, const struct sk_buff *skb),
586 TP_ARGS(sk, skb)
587);
588
589DEFINE_EVENT(tcp_hash_event, tcp_hash_md5_required,
590
591 TP_PROTO(const struct sock *sk, const struct sk_buff *skb),
592 TP_ARGS(sk, skb)
593);
594
595DEFINE_EVENT(tcp_hash_event, tcp_hash_md5_unexpected,
596
597 TP_PROTO(const struct sock *sk, const struct sk_buff *skb),
598 TP_ARGS(sk, skb)
599);
600
601DEFINE_EVENT(tcp_hash_event, tcp_hash_md5_mismatch,
602
603 TP_PROTO(const struct sock *sk, const struct sk_buff *skb),
604 TP_ARGS(sk, skb)
605);
606
607DEFINE_EVENT(tcp_hash_event, tcp_hash_ao_required,
608
609 TP_PROTO(const struct sock *sk, const struct sk_buff *skb),
610 TP_ARGS(sk, skb)
611);
612
613DECLARE_EVENT_CLASS(tcp_ao_event,
614
615 TP_PROTO(const struct sock *sk, const struct sk_buff *skb,
616 const __u8 keyid, const __u8 rnext, const __u8 maclen),
617
618 TP_ARGS(sk, skb, keyid, rnext, maclen),
619
620 TP_STRUCT__entry(
621 __field(__u64, net_cookie)
622 __field(const void *, skbaddr)
623 __field(const void *, skaddr)
624 __field(int, state)
625
626 /* sockaddr_in6 is always bigger than sockaddr_in */
627 __array(__u8, saddr, sizeof(struct sockaddr_in6))
628 __array(__u8, daddr, sizeof(struct sockaddr_in6))
629 __field(int, l3index)
630
631 __field(__u16, sport)
632 __field(__u16, dport)
633 __field(__u16, family)
634
635 __field(bool, fin)
636 __field(bool, syn)
637 __field(bool, rst)
638 __field(bool, psh)
639 __field(bool, ack)
640
641 __field(__u8, keyid)
642 __field(__u8, rnext)
643 __field(__u8, maclen)
644 ),
645
646 TP_fast_assign(
647 const struct tcphdr *th = (const struct tcphdr *)skb->data;
648
649 __entry->net_cookie = sock_net(sk)->net_cookie;
650 __entry->skbaddr = skb;
651 __entry->skaddr = sk;
652 __entry->state = sk->sk_state;
653
654 memset(__entry->saddr, 0, sizeof(struct sockaddr_in6));
655 memset(__entry->daddr, 0, sizeof(struct sockaddr_in6));
656 TP_STORE_ADDR_PORTS_SKB(skb, th, __entry->saddr, __entry->daddr);
657 __entry->l3index = inet_sdif(skb) ? inet_iif(skb) : 0;
658
659 /* For filtering use */
660 __entry->sport = ntohs(th->source);
661 __entry->dport = ntohs(th->dest);
662 __entry->family = sk->sk_family;
663
664 __entry->fin = th->fin;
665 __entry->syn = th->syn;
666 __entry->rst = th->rst;
667 __entry->psh = th->psh;
668 __entry->ack = th->ack;
669
670 __entry->keyid = keyid;
671 __entry->rnext = rnext;
672 __entry->maclen = maclen;
673 ),
674
675 TP_printk("net=%llu state=%s family=%s src=%pISpc dest=%pISpc L3index=%d [%c%c%c%c%c] keyid=%u rnext=%u maclen=%u",
676 __entry->net_cookie,
677 show_tcp_state_name(__entry->state),
678 show_family_name(__entry->family),
679 __entry->saddr, __entry->daddr,
680 __entry->l3index,
681 __entry->fin ? 'F' : ' ',
682 __entry->syn ? 'S' : ' ',
683 __entry->rst ? 'R' : ' ',
684 __entry->psh ? 'P' : ' ',
685 __entry->ack ? '.' : ' ',
686 __entry->keyid, __entry->rnext, __entry->maclen)
687);
688
689DEFINE_EVENT(tcp_ao_event, tcp_ao_handshake_failure,
690 TP_PROTO(const struct sock *sk, const struct sk_buff *skb,
691 const __u8 keyid, const __u8 rnext, const __u8 maclen),
692 TP_ARGS(sk, skb, keyid, rnext, maclen)
693);
694
695#ifdef CONFIG_TCP_AO
696DEFINE_EVENT(tcp_ao_event, tcp_ao_wrong_maclen,
697 TP_PROTO(const struct sock *sk, const struct sk_buff *skb,
698 const __u8 keyid, const __u8 rnext, const __u8 maclen),
699 TP_ARGS(sk, skb, keyid, rnext, maclen)
700);
701
702DEFINE_EVENT(tcp_ao_event, tcp_ao_mismatch,
703 TP_PROTO(const struct sock *sk, const struct sk_buff *skb,
704 const __u8 keyid, const __u8 rnext, const __u8 maclen),
705 TP_ARGS(sk, skb, keyid, rnext, maclen)
706);
707
708DEFINE_EVENT(tcp_ao_event, tcp_ao_key_not_found,
709 TP_PROTO(const struct sock *sk, const struct sk_buff *skb,
710 const __u8 keyid, const __u8 rnext, const __u8 maclen),
711 TP_ARGS(sk, skb, keyid, rnext, maclen)
712);
713
714DEFINE_EVENT(tcp_ao_event, tcp_ao_rnext_request,
715 TP_PROTO(const struct sock *sk, const struct sk_buff *skb,
716 const __u8 keyid, const __u8 rnext, const __u8 maclen),
717 TP_ARGS(sk, skb, keyid, rnext, maclen)
718);
719
720DECLARE_EVENT_CLASS(tcp_ao_event_sk,
721
722 TP_PROTO(const struct sock *sk, const __u8 keyid, const __u8 rnext),
723
724 TP_ARGS(sk, keyid, rnext),
725
726 TP_STRUCT__entry(
727 __field(__u64, net_cookie)
728 __field(const void *, skaddr)
729 __field(int, state)
730
731 /* sockaddr_in6 is always bigger than sockaddr_in */
732 __array(__u8, saddr, sizeof(struct sockaddr_in6))
733 __array(__u8, daddr, sizeof(struct sockaddr_in6))
734
735 __field(__u16, sport)
736 __field(__u16, dport)
737 __field(__u16, family)
738
739 __field(__u8, keyid)
740 __field(__u8, rnext)
741 ),
742
743 TP_fast_assign(
744 const struct inet_sock *inet = inet_sk(sk);
745
746 __entry->net_cookie = sock_net(sk)->net_cookie;
747 __entry->skaddr = sk;
748 __entry->state = sk->sk_state;
749
750 memset(__entry->saddr, 0, sizeof(struct sockaddr_in6));
751 memset(__entry->daddr, 0, sizeof(struct sockaddr_in6));
752 TP_STORE_ADDR_PORTS(__entry, inet, sk);
753
754 /* For filtering use */
755 __entry->sport = ntohs(inet->inet_sport);
756 __entry->dport = ntohs(inet->inet_dport);
757 __entry->family = sk->sk_family;
758
759 __entry->keyid = keyid;
760 __entry->rnext = rnext;
761 ),
762
763 TP_printk("net=%llu state=%s family=%s src=%pISpc dest=%pISpc keyid=%u rnext=%u",
764 __entry->net_cookie,
765 show_tcp_state_name(__entry->state),
766 show_family_name(__entry->family),
767 __entry->saddr, __entry->daddr,
768 __entry->keyid, __entry->rnext)
769);
770
771DEFINE_EVENT(tcp_ao_event_sk, tcp_ao_synack_no_key,
772 TP_PROTO(const struct sock *sk, const __u8 keyid, const __u8 rnext),
773 TP_ARGS(sk, keyid, rnext)
774);
775
776DECLARE_EVENT_CLASS(tcp_ao_event_sne,
777
778 TP_PROTO(const struct sock *sk, __u32 new_sne),
779
780 TP_ARGS(sk, new_sne),
781
782 TP_STRUCT__entry(
783 __field(__u64, net_cookie)
784 __field(const void *, skaddr)
785 __field(int, state)
786
787 /* sockaddr_in6 is always bigger than sockaddr_in */
788 __array(__u8, saddr, sizeof(struct sockaddr_in6))
789 __array(__u8, daddr, sizeof(struct sockaddr_in6))
790
791 __field(__u16, sport)
792 __field(__u16, dport)
793 __field(__u16, family)
794
795 __field(__u32, new_sne)
796 ),
797
798 TP_fast_assign(
799 const struct inet_sock *inet = inet_sk(sk);
800
801 __entry->net_cookie = sock_net(sk)->net_cookie;
802 __entry->skaddr = sk;
803 __entry->state = sk->sk_state;
804
805 memset(__entry->saddr, 0, sizeof(struct sockaddr_in6));
806 memset(__entry->daddr, 0, sizeof(struct sockaddr_in6));
807 TP_STORE_ADDR_PORTS(__entry, inet, sk);
808
809 /* For filtering use */
810 __entry->sport = ntohs(inet->inet_sport);
811 __entry->dport = ntohs(inet->inet_dport);
812 __entry->family = sk->sk_family;
813
814 __entry->new_sne = new_sne;
815 ),
816
817 TP_printk("net=%llu state=%s family=%s src=%pISpc dest=%pISpc sne=%u",
818 __entry->net_cookie,
819 show_tcp_state_name(__entry->state),
820 show_family_name(__entry->family),
821 __entry->saddr, __entry->daddr,
822 __entry->new_sne)
823);
824
825DEFINE_EVENT(tcp_ao_event_sne, tcp_ao_snd_sne_update,
826 TP_PROTO(const struct sock *sk, __u32 new_sne),
827 TP_ARGS(sk, new_sne)
828);
829
830DEFINE_EVENT(tcp_ao_event_sne, tcp_ao_rcv_sne_update,
831 TP_PROTO(const struct sock *sk, __u32 new_sne),
832 TP_ARGS(sk, new_sne)
833);
834#endif /* CONFIG_TCP_AO */
835
836#endif /* _TRACE_TCP_H */
837
838/* This part must be outside protection */
839#include <trace/define_trace.h>