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