tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
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(__u8, scaling_ratio)
222 __field(__u16, sport)
223 __field(__u16, dport)
224 __field(__u16, family)
225 __array(__u8, saddr, 4)
226 __array(__u8, daddr, 4)
227 __array(__u8, saddr_v6, 16)
228 __array(__u8, daddr_v6, 16)
229 __field(const void *, skaddr)
230 __field(__u64, sock_cookie)
231 ),
232
233 TP_fast_assign(
234 struct inet_sock *inet = inet_sk(sk);
235 struct tcp_sock *tp = tcp_sk(sk);
236 __be32 *p32;
237
238 __entry->time = time;
239 __entry->rtt_us = tp->rcv_rtt_est.rtt_us >> 3;
240 __entry->copied = tp->copied_seq - tp->rcvq_space.seq;
241 __entry->inq = tp->rcv_nxt - tp->copied_seq;
242 __entry->space = tp->rcvq_space.space;
243 __entry->ooo_space = RB_EMPTY_ROOT(&tp->out_of_order_queue) ? 0 :
244 TCP_SKB_CB(tp->ooo_last_skb)->end_seq -
245 tp->rcv_nxt;
246
247 __entry->rcvbuf = sk->sk_rcvbuf;
248 __entry->scaling_ratio = tp->scaling_ratio;
249 __entry->sport = ntohs(inet->inet_sport);
250 __entry->dport = ntohs(inet->inet_dport);
251 __entry->family = sk->sk_family;
252
253 p32 = (__be32 *) __entry->saddr;
254 *p32 = inet->inet_saddr;
255
256 p32 = (__be32 *) __entry->daddr;
257 *p32 = inet->inet_daddr;
258
259 TP_STORE_ADDRS(__entry, inet->inet_saddr, inet->inet_daddr,
260 sk->sk_v6_rcv_saddr, sk->sk_v6_daddr);
261
262 __entry->skaddr = sk;
263 __entry->sock_cookie = sock_gen_cookie(sk);
264 ),
265
266 TP_printk("time=%u rtt_us=%u copied=%u inq=%u space=%u ooo=%u scaling_ratio=%u rcvbuf=%u "
267 "family=%s sport=%hu dport=%hu saddr=%pI4 daddr=%pI4 "
268 "saddrv6=%pI6c daddrv6=%pI6c skaddr=%p sock_cookie=%llx",
269 __entry->time, __entry->rtt_us, __entry->copied,
270 __entry->inq, __entry->space, __entry->ooo_space,
271 __entry->scaling_ratio, __entry->rcvbuf,
272 show_family_name(__entry->family),
273 __entry->sport, __entry->dport,
274 __entry->saddr, __entry->daddr,
275 __entry->saddr_v6, __entry->daddr_v6,
276 __entry->skaddr,
277 __entry->sock_cookie)
278);
279
280TRACE_EVENT(tcp_retransmit_synack,
281
282 TP_PROTO(const struct sock *sk, const struct request_sock *req),
283
284 TP_ARGS(sk, req),
285
286 TP_STRUCT__entry(
287 __field(const void *, skaddr)
288 __field(const void *, req)
289 __field(__u16, sport)
290 __field(__u16, dport)
291 __field(__u16, family)
292 __array(__u8, saddr, 4)
293 __array(__u8, daddr, 4)
294 __array(__u8, saddr_v6, 16)
295 __array(__u8, daddr_v6, 16)
296 ),
297
298 TP_fast_assign(
299 struct inet_request_sock *ireq = inet_rsk(req);
300 __be32 *p32;
301
302 __entry->skaddr = sk;
303 __entry->req = req;
304
305 __entry->sport = ireq->ir_num;
306 __entry->dport = ntohs(ireq->ir_rmt_port);
307 __entry->family = sk->sk_family;
308
309 p32 = (__be32 *) __entry->saddr;
310 *p32 = ireq->ir_loc_addr;
311
312 p32 = (__be32 *) __entry->daddr;
313 *p32 = ireq->ir_rmt_addr;
314
315 TP_STORE_ADDRS(__entry, ireq->ir_loc_addr, ireq->ir_rmt_addr,
316 ireq->ir_v6_loc_addr, ireq->ir_v6_rmt_addr);
317 ),
318
319 TP_printk("family=%s sport=%hu dport=%hu saddr=%pI4 daddr=%pI4 saddrv6=%pI6c daddrv6=%pI6c",
320 show_family_name(__entry->family),
321 __entry->sport, __entry->dport,
322 __entry->saddr, __entry->daddr,
323 __entry->saddr_v6, __entry->daddr_v6)
324);
325
326TRACE_EVENT(tcp_sendmsg_locked,
327 TP_PROTO(const struct sock *sk, const struct msghdr *msg,
328 const struct sk_buff *skb, int size_goal),
329
330 TP_ARGS(sk, msg, skb, size_goal),
331
332 TP_STRUCT__entry(
333 __field(const void *, skb_addr)
334 __field(int, skb_len)
335 __field(int, msg_left)
336 __field(int, size_goal)
337 ),
338
339 TP_fast_assign(
340 __entry->skb_addr = skb;
341 __entry->skb_len = skb ? skb->len : 0;
342 __entry->msg_left = msg_data_left(msg);
343 __entry->size_goal = size_goal;
344 ),
345
346 TP_printk("skb_addr %p skb_len %d msg_left %d size_goal %d",
347 __entry->skb_addr, __entry->skb_len, __entry->msg_left,
348 __entry->size_goal));
349
350DECLARE_TRACE(tcp_cwnd_reduction,
351 TP_PROTO(const struct sock *sk, int newly_acked_sacked,
352 int newly_lost, int flag),
353 TP_ARGS(sk, newly_acked_sacked, newly_lost, flag)
354);
355
356#include <trace/events/net_probe_common.h>
357
358TRACE_EVENT(tcp_probe,
359
360 TP_PROTO(struct sock *sk, const struct sk_buff *skb),
361
362 TP_ARGS(sk, skb),
363
364 TP_STRUCT__entry(
365 /* sockaddr_in6 is always bigger than sockaddr_in */
366 __array(__u8, saddr, sizeof(struct sockaddr_in6))
367 __array(__u8, daddr, sizeof(struct sockaddr_in6))
368 __field(__u16, sport)
369 __field(__u16, dport)
370 __field(__u16, family)
371 __field(__u32, mark)
372 __field(__u16, data_len)
373 __field(__u32, snd_nxt)
374 __field(__u32, snd_una)
375 __field(__u32, snd_cwnd)
376 __field(__u32, ssthresh)
377 __field(__u32, snd_wnd)
378 __field(__u32, srtt)
379 __field(__u32, rcv_wnd)
380 __field(__u64, sock_cookie)
381 __field(const void *, skbaddr)
382 __field(const void *, skaddr)
383 ),
384
385 TP_fast_assign(
386 const struct tcphdr *th = (const struct tcphdr *)skb->data;
387 const struct inet_sock *inet = inet_sk(sk);
388 const struct tcp_sock *tp = tcp_sk(sk);
389
390 memset(__entry->saddr, 0, sizeof(struct sockaddr_in6));
391 memset(__entry->daddr, 0, sizeof(struct sockaddr_in6));
392
393 TP_STORE_ADDR_PORTS(__entry, inet, sk);
394
395 /* For filtering use */
396 __entry->sport = ntohs(inet->inet_sport);
397 __entry->dport = ntohs(inet->inet_dport);
398 __entry->mark = skb->mark;
399 __entry->family = sk->sk_family;
400
401 __entry->data_len = skb->len - __tcp_hdrlen(th);
402 __entry->snd_nxt = tp->snd_nxt;
403 __entry->snd_una = tp->snd_una;
404 __entry->snd_cwnd = tcp_snd_cwnd(tp);
405 __entry->snd_wnd = tp->snd_wnd;
406 __entry->rcv_wnd = tp->rcv_wnd;
407 __entry->ssthresh = tcp_current_ssthresh(sk);
408 __entry->srtt = tp->srtt_us >> 3;
409 __entry->sock_cookie = sock_gen_cookie(sk);
410
411 __entry->skbaddr = skb;
412 __entry->skaddr = sk;
413 ),
414
415 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",
416 show_family_name(__entry->family),
417 __entry->saddr, __entry->daddr, __entry->mark,
418 __entry->data_len, __entry->snd_nxt, __entry->snd_una,
419 __entry->snd_cwnd, __entry->ssthresh, __entry->snd_wnd,
420 __entry->srtt, __entry->rcv_wnd, __entry->sock_cookie,
421 __entry->skbaddr, __entry->skaddr)
422);
423
424/*
425 * tcp event with only skb
426 */
427DECLARE_EVENT_CLASS(tcp_event_skb,
428
429 TP_PROTO(const struct sk_buff *skb),
430
431 TP_ARGS(skb),
432
433 TP_STRUCT__entry(
434 __field(const void *, skbaddr)
435 __array(__u8, saddr, sizeof(struct sockaddr_in6))
436 __array(__u8, daddr, sizeof(struct sockaddr_in6))
437 ),
438
439 TP_fast_assign(
440 const struct tcphdr *th = (const struct tcphdr *)skb->data;
441 __entry->skbaddr = skb;
442
443 memset(__entry->saddr, 0, sizeof(struct sockaddr_in6));
444 memset(__entry->daddr, 0, sizeof(struct sockaddr_in6));
445
446 TP_STORE_ADDR_PORTS_SKB(skb, th, __entry->saddr, __entry->daddr);
447 ),
448
449 TP_printk("skbaddr=%p src=%pISpc dest=%pISpc",
450 __entry->skbaddr, __entry->saddr, __entry->daddr)
451);
452
453DEFINE_EVENT(tcp_event_skb, tcp_bad_csum,
454
455 TP_PROTO(const struct sk_buff *skb),
456
457 TP_ARGS(skb)
458);
459
460TRACE_EVENT(tcp_cong_state_set,
461
462 TP_PROTO(struct sock *sk, const u8 ca_state),
463
464 TP_ARGS(sk, ca_state),
465
466 TP_STRUCT__entry(
467 __field(const void *, skaddr)
468 __field(__u16, sport)
469 __field(__u16, dport)
470 __field(__u16, family)
471 __array(__u8, saddr, 4)
472 __array(__u8, daddr, 4)
473 __array(__u8, saddr_v6, 16)
474 __array(__u8, daddr_v6, 16)
475 __field(__u8, cong_state)
476 ),
477
478 TP_fast_assign(
479 struct inet_sock *inet = inet_sk(sk);
480 __be32 *p32;
481
482 __entry->skaddr = sk;
483
484 __entry->sport = ntohs(inet->inet_sport);
485 __entry->dport = ntohs(inet->inet_dport);
486 __entry->family = sk->sk_family;
487
488 p32 = (__be32 *) __entry->saddr;
489 *p32 = inet->inet_saddr;
490
491 p32 = (__be32 *) __entry->daddr;
492 *p32 = inet->inet_daddr;
493
494 TP_STORE_ADDRS(__entry, inet->inet_saddr, inet->inet_daddr,
495 sk->sk_v6_rcv_saddr, sk->sk_v6_daddr);
496
497 __entry->cong_state = ca_state;
498 ),
499
500 TP_printk("family=%s sport=%hu dport=%hu saddr=%pI4 daddr=%pI4 saddrv6=%pI6c daddrv6=%pI6c cong_state=%u",
501 show_family_name(__entry->family),
502 __entry->sport, __entry->dport,
503 __entry->saddr, __entry->daddr,
504 __entry->saddr_v6, __entry->daddr_v6,
505 __entry->cong_state)
506);
507
508DECLARE_EVENT_CLASS(tcp_hash_event,
509
510 TP_PROTO(const struct sock *sk, const struct sk_buff *skb),
511
512 TP_ARGS(sk, skb),
513
514 TP_STRUCT__entry(
515 __field(__u64, net_cookie)
516 __field(const void *, skbaddr)
517 __field(const void *, skaddr)
518 __field(int, state)
519
520 /* sockaddr_in6 is always bigger than sockaddr_in */
521 __array(__u8, saddr, sizeof(struct sockaddr_in6))
522 __array(__u8, daddr, sizeof(struct sockaddr_in6))
523 __field(int, l3index)
524
525 __field(__u16, sport)
526 __field(__u16, dport)
527 __field(__u16, family)
528
529 __field(bool, fin)
530 __field(bool, syn)
531 __field(bool, rst)
532 __field(bool, psh)
533 __field(bool, ack)
534 ),
535
536 TP_fast_assign(
537 const struct tcphdr *th = (const struct tcphdr *)skb->data;
538
539 __entry->net_cookie = sock_net(sk)->net_cookie;
540 __entry->skbaddr = skb;
541 __entry->skaddr = sk;
542 __entry->state = sk->sk_state;
543
544 memset(__entry->saddr, 0, sizeof(struct sockaddr_in6));
545 memset(__entry->daddr, 0, sizeof(struct sockaddr_in6));
546 TP_STORE_ADDR_PORTS_SKB(skb, th, __entry->saddr, __entry->daddr);
547 __entry->l3index = inet_sdif(skb) ? inet_iif(skb) : 0;
548
549 /* For filtering use */
550 __entry->sport = ntohs(th->source);
551 __entry->dport = ntohs(th->dest);
552 __entry->family = sk->sk_family;
553
554 __entry->fin = th->fin;
555 __entry->syn = th->syn;
556 __entry->rst = th->rst;
557 __entry->psh = th->psh;
558 __entry->ack = th->ack;
559 ),
560
561 TP_printk("net=%llu state=%s family=%s src=%pISpc dest=%pISpc L3index=%d [%c%c%c%c%c]",
562 __entry->net_cookie,
563 show_tcp_state_name(__entry->state),
564 show_family_name(__entry->family),
565 __entry->saddr, __entry->daddr,
566 __entry->l3index,
567 __entry->fin ? 'F' : ' ',
568 __entry->syn ? 'S' : ' ',
569 __entry->rst ? 'R' : ' ',
570 __entry->psh ? 'P' : ' ',
571 __entry->ack ? '.' : ' ')
572);
573
574DEFINE_EVENT(tcp_hash_event, tcp_hash_bad_header,
575
576 TP_PROTO(const struct sock *sk, const struct sk_buff *skb),
577 TP_ARGS(sk, skb)
578);
579
580DEFINE_EVENT(tcp_hash_event, tcp_hash_md5_required,
581
582 TP_PROTO(const struct sock *sk, const struct sk_buff *skb),
583 TP_ARGS(sk, skb)
584);
585
586DEFINE_EVENT(tcp_hash_event, tcp_hash_md5_unexpected,
587
588 TP_PROTO(const struct sock *sk, const struct sk_buff *skb),
589 TP_ARGS(sk, skb)
590);
591
592DEFINE_EVENT(tcp_hash_event, tcp_hash_md5_mismatch,
593
594 TP_PROTO(const struct sock *sk, const struct sk_buff *skb),
595 TP_ARGS(sk, skb)
596);
597
598DEFINE_EVENT(tcp_hash_event, tcp_hash_ao_required,
599
600 TP_PROTO(const struct sock *sk, const struct sk_buff *skb),
601 TP_ARGS(sk, skb)
602);
603
604DECLARE_EVENT_CLASS(tcp_ao_event,
605
606 TP_PROTO(const struct sock *sk, const struct sk_buff *skb,
607 const __u8 keyid, const __u8 rnext, const __u8 maclen),
608
609 TP_ARGS(sk, skb, keyid, rnext, maclen),
610
611 TP_STRUCT__entry(
612 __field(__u64, net_cookie)
613 __field(const void *, skbaddr)
614 __field(const void *, skaddr)
615 __field(int, state)
616
617 /* sockaddr_in6 is always bigger than sockaddr_in */
618 __array(__u8, saddr, sizeof(struct sockaddr_in6))
619 __array(__u8, daddr, sizeof(struct sockaddr_in6))
620 __field(int, l3index)
621
622 __field(__u16, sport)
623 __field(__u16, dport)
624 __field(__u16, family)
625
626 __field(bool, fin)
627 __field(bool, syn)
628 __field(bool, rst)
629 __field(bool, psh)
630 __field(bool, ack)
631
632 __field(__u8, keyid)
633 __field(__u8, rnext)
634 __field(__u8, maclen)
635 ),
636
637 TP_fast_assign(
638 const struct tcphdr *th = (const struct tcphdr *)skb->data;
639
640 __entry->net_cookie = sock_net(sk)->net_cookie;
641 __entry->skbaddr = skb;
642 __entry->skaddr = sk;
643 __entry->state = sk->sk_state;
644
645 memset(__entry->saddr, 0, sizeof(struct sockaddr_in6));
646 memset(__entry->daddr, 0, sizeof(struct sockaddr_in6));
647 TP_STORE_ADDR_PORTS_SKB(skb, th, __entry->saddr, __entry->daddr);
648 __entry->l3index = inet_sdif(skb) ? inet_iif(skb) : 0;
649
650 /* For filtering use */
651 __entry->sport = ntohs(th->source);
652 __entry->dport = ntohs(th->dest);
653 __entry->family = sk->sk_family;
654
655 __entry->fin = th->fin;
656 __entry->syn = th->syn;
657 __entry->rst = th->rst;
658 __entry->psh = th->psh;
659 __entry->ack = th->ack;
660
661 __entry->keyid = keyid;
662 __entry->rnext = rnext;
663 __entry->maclen = maclen;
664 ),
665
666 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",
667 __entry->net_cookie,
668 show_tcp_state_name(__entry->state),
669 show_family_name(__entry->family),
670 __entry->saddr, __entry->daddr,
671 __entry->l3index,
672 __entry->fin ? 'F' : ' ',
673 __entry->syn ? 'S' : ' ',
674 __entry->rst ? 'R' : ' ',
675 __entry->psh ? 'P' : ' ',
676 __entry->ack ? '.' : ' ',
677 __entry->keyid, __entry->rnext, __entry->maclen)
678);
679
680DEFINE_EVENT(tcp_ao_event, tcp_ao_handshake_failure,
681 TP_PROTO(const struct sock *sk, const struct sk_buff *skb,
682 const __u8 keyid, const __u8 rnext, const __u8 maclen),
683 TP_ARGS(sk, skb, keyid, rnext, maclen)
684);
685
686#ifdef CONFIG_TCP_AO
687DEFINE_EVENT(tcp_ao_event, tcp_ao_wrong_maclen,
688 TP_PROTO(const struct sock *sk, const struct sk_buff *skb,
689 const __u8 keyid, const __u8 rnext, const __u8 maclen),
690 TP_ARGS(sk, skb, keyid, rnext, maclen)
691);
692
693DEFINE_EVENT(tcp_ao_event, tcp_ao_mismatch,
694 TP_PROTO(const struct sock *sk, const struct sk_buff *skb,
695 const __u8 keyid, const __u8 rnext, const __u8 maclen),
696 TP_ARGS(sk, skb, keyid, rnext, maclen)
697);
698
699DEFINE_EVENT(tcp_ao_event, tcp_ao_key_not_found,
700 TP_PROTO(const struct sock *sk, const struct sk_buff *skb,
701 const __u8 keyid, const __u8 rnext, const __u8 maclen),
702 TP_ARGS(sk, skb, keyid, rnext, maclen)
703);
704
705DEFINE_EVENT(tcp_ao_event, tcp_ao_rnext_request,
706 TP_PROTO(const struct sock *sk, const struct sk_buff *skb,
707 const __u8 keyid, const __u8 rnext, const __u8 maclen),
708 TP_ARGS(sk, skb, keyid, rnext, maclen)
709);
710
711DECLARE_EVENT_CLASS(tcp_ao_event_sk,
712
713 TP_PROTO(const struct sock *sk, const __u8 keyid, const __u8 rnext),
714
715 TP_ARGS(sk, keyid, rnext),
716
717 TP_STRUCT__entry(
718 __field(__u64, net_cookie)
719 __field(const void *, skaddr)
720 __field(int, state)
721
722 /* sockaddr_in6 is always bigger than sockaddr_in */
723 __array(__u8, saddr, sizeof(struct sockaddr_in6))
724 __array(__u8, daddr, sizeof(struct sockaddr_in6))
725
726 __field(__u16, sport)
727 __field(__u16, dport)
728 __field(__u16, family)
729
730 __field(__u8, keyid)
731 __field(__u8, rnext)
732 ),
733
734 TP_fast_assign(
735 const struct inet_sock *inet = inet_sk(sk);
736
737 __entry->net_cookie = sock_net(sk)->net_cookie;
738 __entry->skaddr = sk;
739 __entry->state = sk->sk_state;
740
741 memset(__entry->saddr, 0, sizeof(struct sockaddr_in6));
742 memset(__entry->daddr, 0, sizeof(struct sockaddr_in6));
743 TP_STORE_ADDR_PORTS(__entry, inet, sk);
744
745 /* For filtering use */
746 __entry->sport = ntohs(inet->inet_sport);
747 __entry->dport = ntohs(inet->inet_dport);
748 __entry->family = sk->sk_family;
749
750 __entry->keyid = keyid;
751 __entry->rnext = rnext;
752 ),
753
754 TP_printk("net=%llu state=%s family=%s src=%pISpc dest=%pISpc keyid=%u rnext=%u",
755 __entry->net_cookie,
756 show_tcp_state_name(__entry->state),
757 show_family_name(__entry->family),
758 __entry->saddr, __entry->daddr,
759 __entry->keyid, __entry->rnext)
760);
761
762DEFINE_EVENT(tcp_ao_event_sk, tcp_ao_synack_no_key,
763 TP_PROTO(const struct sock *sk, const __u8 keyid, const __u8 rnext),
764 TP_ARGS(sk, keyid, rnext)
765);
766
767DECLARE_EVENT_CLASS(tcp_ao_event_sne,
768
769 TP_PROTO(const struct sock *sk, __u32 new_sne),
770
771 TP_ARGS(sk, new_sne),
772
773 TP_STRUCT__entry(
774 __field(__u64, net_cookie)
775 __field(const void *, skaddr)
776 __field(int, state)
777
778 /* sockaddr_in6 is always bigger than sockaddr_in */
779 __array(__u8, saddr, sizeof(struct sockaddr_in6))
780 __array(__u8, daddr, sizeof(struct sockaddr_in6))
781
782 __field(__u16, sport)
783 __field(__u16, dport)
784 __field(__u16, family)
785
786 __field(__u32, new_sne)
787 ),
788
789 TP_fast_assign(
790 const struct inet_sock *inet = inet_sk(sk);
791
792 __entry->net_cookie = sock_net(sk)->net_cookie;
793 __entry->skaddr = sk;
794 __entry->state = sk->sk_state;
795
796 memset(__entry->saddr, 0, sizeof(struct sockaddr_in6));
797 memset(__entry->daddr, 0, sizeof(struct sockaddr_in6));
798 TP_STORE_ADDR_PORTS(__entry, inet, sk);
799
800 /* For filtering use */
801 __entry->sport = ntohs(inet->inet_sport);
802 __entry->dport = ntohs(inet->inet_dport);
803 __entry->family = sk->sk_family;
804
805 __entry->new_sne = new_sne;
806 ),
807
808 TP_printk("net=%llu state=%s family=%s src=%pISpc dest=%pISpc sne=%u",
809 __entry->net_cookie,
810 show_tcp_state_name(__entry->state),
811 show_family_name(__entry->family),
812 __entry->saddr, __entry->daddr,
813 __entry->new_sne)
814);
815
816DEFINE_EVENT(tcp_ao_event_sne, tcp_ao_snd_sne_update,
817 TP_PROTO(const struct sock *sk, __u32 new_sne),
818 TP_ARGS(sk, new_sne)
819);
820
821DEFINE_EVENT(tcp_ao_event_sne, tcp_ao_rcv_sne_update,
822 TP_PROTO(const struct sock *sk, __u32 new_sne),
823 TP_ARGS(sk, new_sne)
824);
825#endif /* CONFIG_TCP_AO */
826
827#endif /* _TRACE_TCP_H */
828
829/* This part must be outside protection */
830#include <trace/define_trace.h>