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