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 TRACE_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); 71 DEFINE_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 */ 82 TRACE_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 */ 138 DECLARE_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 186 DEFINE_EVENT(tcp_event_sk, tcp_receive_reset, 187 188 TP_PROTO(struct sock *sk), 189 190 TP_ARGS(sk) 191 ); 192 193 DEFINE_EVENT(tcp_event_sk, tcp_destroy_sock, 194 195 TP_PROTO(struct sock *sk), 196 197 TP_ARGS(sk) 198 ); 199 200 DEFINE_EVENT(tcp_event_sk, tcp_rcv_space_adjust, 201 202 TP_PROTO(struct sock *sk), 203 204 TP_ARGS(sk) 205 ); 206 207 TRACE_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 280 TRACE_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 326 TRACE_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 350 DECLARE_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 358 TRACE_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 */ 427 DECLARE_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 453 DEFINE_EVENT(tcp_event_skb, tcp_bad_csum, 454 455 TP_PROTO(const struct sk_buff *skb), 456 457 TP_ARGS(skb) 458 ); 459 460 TRACE_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 508 DECLARE_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 574 DEFINE_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 580 DEFINE_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 586 DEFINE_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 592 DEFINE_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 598 DEFINE_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 604 DECLARE_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 680 DEFINE_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 687 DEFINE_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 693 DEFINE_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 699 DEFINE_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 705 DEFINE_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 711 DECLARE_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 762 DEFINE_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 767 DECLARE_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 816 DEFINE_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 821 DEFINE_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> 831