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_rcvbuf_grow, 217 218 TP_PROTO(struct sock *sk, int time), 219 220 TP_ARGS(sk, time), 221 222 TP_STRUCT__entry( 223 __field(int, time) 224 __field(__u32, rtt_us) 225 __field(__u32, copied) 226 __field(__u32, inq) 227 __field(__u32, space) 228 __field(__u32, ooo_space) 229 __field(__u32, rcvbuf) 230 __field(__u8, scaling_ratio) 231 __field(__u16, sport) 232 __field(__u16, dport) 233 __field(__u16, family) 234 __array(__u8, saddr, 4) 235 __array(__u8, daddr, 4) 236 __array(__u8, saddr_v6, 16) 237 __array(__u8, daddr_v6, 16) 238 __field(const void *, skaddr) 239 __field(__u64, sock_cookie) 240 ), 241 242 TP_fast_assign( 243 struct inet_sock *inet = inet_sk(sk); 244 struct tcp_sock *tp = tcp_sk(sk); 245 __be32 *p32; 246 247 __entry->time = time; 248 __entry->rtt_us = tp->rcv_rtt_est.rtt_us >> 3; 249 __entry->copied = tp->copied_seq - tp->rcvq_space.seq; 250 __entry->inq = tp->rcv_nxt - tp->copied_seq; 251 __entry->space = tp->rcvq_space.space; 252 __entry->ooo_space = RB_EMPTY_ROOT(&tp->out_of_order_queue) ? 0 : 253 TCP_SKB_CB(tp->ooo_last_skb)->end_seq - 254 tp->rcv_nxt; 255 256 __entry->rcvbuf = sk->sk_rcvbuf; 257 __entry->scaling_ratio = tp->scaling_ratio; 258 __entry->sport = ntohs(inet->inet_sport); 259 __entry->dport = ntohs(inet->inet_dport); 260 __entry->family = sk->sk_family; 261 262 p32 = (__be32 *) __entry->saddr; 263 *p32 = inet->inet_saddr; 264 265 p32 = (__be32 *) __entry->daddr; 266 *p32 = inet->inet_daddr; 267 268 TP_STORE_ADDRS(__entry, inet->inet_saddr, inet->inet_daddr, 269 sk->sk_v6_rcv_saddr, sk->sk_v6_daddr); 270 271 __entry->skaddr = sk; 272 __entry->sock_cookie = sock_gen_cookie(sk); 273 ), 274 275 TP_printk("time=%u rtt_us=%u copied=%u inq=%u space=%u ooo=%u scaling_ratio=%u rcvbuf=%u " 276 "family=%s sport=%hu dport=%hu saddr=%pI4 daddr=%pI4 " 277 "saddrv6=%pI6c daddrv6=%pI6c skaddr=%p sock_cookie=%llx", 278 __entry->time, __entry->rtt_us, __entry->copied, 279 __entry->inq, __entry->space, __entry->ooo_space, 280 __entry->scaling_ratio, __entry->rcvbuf, 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 289 TRACE_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 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 335 TRACE_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 359 DECLARE_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 367 TRACE_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 */ 436 DECLARE_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 462 DEFINE_EVENT(tcp_event_skb, tcp_bad_csum, 463 464 TP_PROTO(const struct sk_buff *skb), 465 466 TP_ARGS(skb) 467 ); 468 469 TRACE_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 517 DECLARE_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 583 DEFINE_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 589 DEFINE_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 595 DEFINE_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 601 DEFINE_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 607 DEFINE_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 613 DECLARE_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 689 DEFINE_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 DEFINE_EVENT(tcp_ao_event, tcp_ao_wrong_maclen, 696 TP_PROTO(const struct sock *sk, const struct sk_buff *skb, 697 const __u8 keyid, const __u8 rnext, const __u8 maclen), 698 TP_ARGS(sk, skb, keyid, rnext, maclen) 699 ); 700 701 DEFINE_EVENT(tcp_ao_event, tcp_ao_mismatch, 702 TP_PROTO(const struct sock *sk, const struct sk_buff *skb, 703 const __u8 keyid, const __u8 rnext, const __u8 maclen), 704 TP_ARGS(sk, skb, keyid, rnext, maclen) 705 ); 706 707 DEFINE_EVENT(tcp_ao_event, tcp_ao_key_not_found, 708 TP_PROTO(const struct sock *sk, const struct sk_buff *skb, 709 const __u8 keyid, const __u8 rnext, const __u8 maclen), 710 TP_ARGS(sk, skb, keyid, rnext, maclen) 711 ); 712 713 DEFINE_EVENT(tcp_ao_event, tcp_ao_rnext_request, 714 TP_PROTO(const struct sock *sk, const struct sk_buff *skb, 715 const __u8 keyid, const __u8 rnext, const __u8 maclen), 716 TP_ARGS(sk, skb, keyid, rnext, maclen) 717 ); 718 719 DECLARE_EVENT_CLASS(tcp_ao_event_sk, 720 721 TP_PROTO(const struct sock *sk, const __u8 keyid, const __u8 rnext), 722 723 TP_ARGS(sk, keyid, rnext), 724 725 TP_STRUCT__entry( 726 __field(__u64, net_cookie) 727 __field(const void *, skaddr) 728 __field(int, state) 729 730 /* sockaddr_in6 is always bigger than sockaddr_in */ 731 __array(__u8, saddr, sizeof(struct sockaddr_in6)) 732 __array(__u8, daddr, sizeof(struct sockaddr_in6)) 733 734 __field(__u16, sport) 735 __field(__u16, dport) 736 __field(__u16, family) 737 738 __field(__u8, keyid) 739 __field(__u8, rnext) 740 ), 741 742 TP_fast_assign( 743 const struct inet_sock *inet = inet_sk(sk); 744 745 __entry->net_cookie = sock_net(sk)->net_cookie; 746 __entry->skaddr = sk; 747 __entry->state = sk->sk_state; 748 749 memset(__entry->saddr, 0, sizeof(struct sockaddr_in6)); 750 memset(__entry->daddr, 0, sizeof(struct sockaddr_in6)); 751 TP_STORE_ADDR_PORTS(__entry, inet, sk); 752 753 /* For filtering use */ 754 __entry->sport = ntohs(inet->inet_sport); 755 __entry->dport = ntohs(inet->inet_dport); 756 __entry->family = sk->sk_family; 757 758 __entry->keyid = keyid; 759 __entry->rnext = rnext; 760 ), 761 762 TP_printk("net=%llu state=%s family=%s src=%pISpc dest=%pISpc keyid=%u rnext=%u", 763 __entry->net_cookie, 764 show_tcp_state_name(__entry->state), 765 show_family_name(__entry->family), 766 __entry->saddr, __entry->daddr, 767 __entry->keyid, __entry->rnext) 768 ); 769 770 DEFINE_EVENT(tcp_ao_event_sk, tcp_ao_synack_no_key, 771 TP_PROTO(const struct sock *sk, const __u8 keyid, const __u8 rnext), 772 TP_ARGS(sk, keyid, rnext) 773 ); 774 775 DECLARE_EVENT_CLASS(tcp_ao_event_sne, 776 777 TP_PROTO(const struct sock *sk, __u32 new_sne), 778 779 TP_ARGS(sk, new_sne), 780 781 TP_STRUCT__entry( 782 __field(__u64, net_cookie) 783 __field(const void *, skaddr) 784 __field(int, state) 785 786 /* sockaddr_in6 is always bigger than sockaddr_in */ 787 __array(__u8, saddr, sizeof(struct sockaddr_in6)) 788 __array(__u8, daddr, sizeof(struct sockaddr_in6)) 789 790 __field(__u16, sport) 791 __field(__u16, dport) 792 __field(__u16, family) 793 794 __field(__u32, new_sne) 795 ), 796 797 TP_fast_assign( 798 const struct inet_sock *inet = inet_sk(sk); 799 800 __entry->net_cookie = sock_net(sk)->net_cookie; 801 __entry->skaddr = sk; 802 __entry->state = sk->sk_state; 803 804 memset(__entry->saddr, 0, sizeof(struct sockaddr_in6)); 805 memset(__entry->daddr, 0, sizeof(struct sockaddr_in6)); 806 TP_STORE_ADDR_PORTS(__entry, inet, sk); 807 808 /* For filtering use */ 809 __entry->sport = ntohs(inet->inet_sport); 810 __entry->dport = ntohs(inet->inet_dport); 811 __entry->family = sk->sk_family; 812 813 __entry->new_sne = new_sne; 814 ), 815 816 TP_printk("net=%llu state=%s family=%s src=%pISpc dest=%pISpc sne=%u", 817 __entry->net_cookie, 818 show_tcp_state_name(__entry->state), 819 show_family_name(__entry->family), 820 __entry->saddr, __entry->daddr, 821 __entry->new_sne) 822 ); 823 824 DEFINE_EVENT(tcp_ao_event_sne, tcp_ao_snd_sne_update, 825 TP_PROTO(const struct sock *sk, __u32 new_sne), 826 TP_ARGS(sk, new_sne) 827 ); 828 829 DEFINE_EVENT(tcp_ao_event_sne, tcp_ao_rcv_sne_update, 830 TP_PROTO(const struct sock *sk, __u32 new_sne), 831 TP_ARGS(sk, new_sne) 832 ); 833 834 #endif /* _TRACE_TCP_H */ 835 836 /* This part must be outside protection */ 837 #include <trace/define_trace.h> 838