instrumentation/events/lttng-module/net.h

   1 #undef TRACE_SYSTEM
   2 #define TRACE_SYSTEM net
   3
   4 #if !defined(LTTNG_TRACE_NET_H) || defined(TRACE_HEADER_MULTI_READ)
   5 #define LTTNG_TRACE_NET_H
   6
   7 #include <probes/lttng-tracepoint-event.h>
   8 #include <linux/skbuff.h>
   9 #include <linux/netdevice.h>
  10 #include <linux/ip.h>
  11 #include <linux/ipv6.h>
  12 #include <linux/tcp.h>
  13 #include <linux/version.h>
  14 #include <lttng-endian.h>
  15 #include <net/sock.h>
  16
  17 #ifndef ONCE_LTTNG_NET_H
  18 #define ONCE_LTTNG_NET_H
  19
  20 static inline unsigned char __has_network_hdr(struct sk_buff *skb)
  21 {
  22         /*
  23          * If the header is not set yet, the network header will point
  24          * to the head.
  25          */
  26         return skb_network_header(skb) != skb->head;
  27 }
  28
  29 static struct lttng_event_field emptyfields[] = {
  30 };
  31
  32 /* Structures for transport headers. */
  33
  34 static struct lttng_event_field tcpfields[] = {
  35         [0] = {
  36                 .name = "source_port",
  37                 .type = __type_integer(uint16_t, 0, 0, 0,
  38                                 __BIG_ENDIAN, 10, none),
  39         },
  40         [1] = {
  41                 .name = "dest_port",
  42                 .type = __type_integer(uint16_t, 0, 0, 0,
  43                                 __BIG_ENDIAN, 10, none),
  44         },
  45         [2] = {
  46                 .name = "seq",
  47                 .type = __type_integer(uint32_t, 0, 0, 0,
  48                                 __BIG_ENDIAN, 10, none),
  49         },
  50         [3] = {
  51                 .name = "ack_seq",
  52                 .type = __type_integer(uint32_t, 0, 0, 0,
  53                                 __BIG_ENDIAN, 10, none),
  54         },
  55         [4] = {
  56                 .name = "data_offset",
  57                 .type = __type_integer(uint8_t, 4, 4, 0,
  58                                 __BIG_ENDIAN, 10, none),
  59         },
  60         [5] = {
  61                 .name = "reserved",
  62                 .type = __type_integer(uint8_t, 3, 1, 0,
  63                                 __BIG_ENDIAN, 10, none),
  64         },
  65         [6] = {
  66                 .name = "flags",
  67                 .type = __type_integer(uint8_t, 9, 1, 0,
  68                                 __BIG_ENDIAN, 16, none),
  69         },
  70         [7] = {
  71                 .name = "window_size",
  72                 .type = __type_integer(uint16_t, 0, 0, 0,
  73                                 __BIG_ENDIAN, 10, none),
  74         },
  75         [8] = {
  76                 .name = "checksum",
  77                 .type = __type_integer(uint16_t, 0, 0, 0,
  78                                 __BIG_ENDIAN, 16, none),
  79         },
  80         [9] = {
  81                 .name = "urg_ptr",
  82                 .type = __type_integer(uint16_t, 0, 0, 0,
  83                                 __BIG_ENDIAN, 10, none),
  84         },
  85 };
  86
  87 static struct lttng_event_field transport_fields[] = {
  88         [0] = {
  89                 .name = "unknown",
  90                 .type = {
  91                         .atype = atype_struct,
  92                         .u._struct.nr_fields = ARRAY_SIZE(emptyfields),
  93                         .u._struct.fields = emptyfields,
  94                 },
  95         },
  96         [1] = {
  97                 .name = "tcp",
  98                 .type = {
  99                         .atype = atype_struct,
 100                         .u._struct.nr_fields = ARRAY_SIZE(tcpfields),
 101                         .u._struct.fields = tcpfields,
 102                 },
 103         },
 104 };
 105
 106 enum transport_header_types {
 107         TH_NONE = 0,
 108         TH_TCP = 1,
 109 };
 110
 111 static inline enum transport_header_types __get_transport_header_type(struct sk_buff *skb)
 112 {
 113         if (__has_network_hdr(skb)) {
 114                 /*
 115                  * When both transport and network headers are set,
 116                  * transport header is greater than network header,
 117                  * otherwise it points to head.
 118                  */
 119                 if (skb->transport_header > skb->network_header) {
 120                         /*
 121                          * Get the transport protocol from the network
 122                          * header's data. This method works both for
 123                          * sent and received packets.
 124                          */
 125                         if ((skb->protocol == htons(ETH_P_IP) &&
 126                                         ip_hdr(skb)->protocol == IPPROTO_TCP) ||
 127                                 (skb->protocol == htons(ETH_P_IPV6) &&
 128                                         ipv6_hdr(skb)->nexthdr == IPPROTO_TCP))
 129                                 return TH_TCP;
 130                 }
 131                 /* Fallthrough for other cases where header is not TCP. */
 132         }
 133         return TH_NONE;
 134 }
 135
 136 static struct lttng_enum_entry transport_enum_entries[] = {
 137         [0] = {
 138                 .start = { .value = TH_NONE, .signedness = 0, },
 139                 .end = { .value = TH_NONE, .signedness = 0, },
 140                 .string = "_unknown",
 141         },
 142         [1] = {
 143                 .start = { .value = TH_TCP, .signedness = 0, },
 144                 .end = { .value = TH_TCP, .signedness = 0, },
 145                 .string = "_tcp",
 146         },
 147 };
 148
 149 static const struct lttng_enum_desc transport_header_type = {
 150         .name = "transport_header_type",
 151         .entries = transport_enum_entries,
 152         .nr_entries = ARRAY_SIZE(transport_enum_entries),
 153 };
 154
 155 /* Structures for network headers. */
 156
 157 static struct lttng_event_field ipv4fields[] = {
 158         [0] = {
 159                 .name = "version",
 160                 .type = __type_integer(uint8_t, 4, 4, 0,
 161                                 __BIG_ENDIAN, 10, none),
 162         },
 163         [1] = {
 164                 .name = "ihl",
 165                 .type = __type_integer(uint8_t, 4, 4, 0,
 166                                 __BIG_ENDIAN, 10, none),
 167         },
 168         [2] = {
 169                 .name = "tos",
 170                 .type = __type_integer(uint8_t, 0, 0, 0,
 171                                 __BIG_ENDIAN, 10, none),
 172         },
 173         [3] = {
 174                 .name = "tot_len",
 175                 .type = __type_integer(uint16_t, 0, 0, 0,
 176                                 __BIG_ENDIAN, 10, none),
 177         },
 178         [4] = {
 179                 .name = "id",
 180                 .type = __type_integer(uint16_t, 0, 0, 0,
 181                                 __BIG_ENDIAN, 16, none),
 182         },
 183         [5] = {
 184                 .name = "frag_off",
 185                 .type = __type_integer(uint16_t, 0, 0, 0,
 186                                 __BIG_ENDIAN, 10, none),
 187         },
 188         [6] = {
 189                 .name = "ttl",
 190                 .type = __type_integer(uint8_t, 0, 0, 0,
 191                                 __BIG_ENDIAN, 10, none),
 192         },
 193         [7] = {
 194                 .name = "protocol",
 195                 .type = {
 196                         .atype = atype_enum,
 197                         .u.basic.enumeration.desc = &transport_header_type,
 198                         .u.basic.enumeration.container_type = {
 199                                 .size = 8,
 200                                 .alignment = 8,
 201                                 .signedness = 0,
 202                                 .reverse_byte_order =
 203                                         __BIG_ENDIAN != __BYTE_ORDER,
 204                                 .base = 10,
 205                                 .encoding = lttng_encode_none,
 206                         },
 207                 },
 208         },
 209         [8] = {
 210                 .name = "checksum",
 211                 .type = __type_integer(uint16_t, 0, 0, 0,
 212                                 __BIG_ENDIAN, 16, none),
 213         },
 214         [9] = {
 215                 .name = "saddr",
 216                 .type = {
 217                         .atype = atype_array,
 218                         .u.array.elem_type =
 219                                 __type_integer(uint8_t, 0, 0, 0,
 220                                         __BIG_ENDIAN, 10, none),
 221                         .u.array.length = 4,
 222                         .u.array.elem_alignment = lttng_alignof(uint8_t),
 223                 },
 224         },
 225         [10] = {
 226                 .name = "daddr",
 227                 .type = {
 228                         .atype = atype_array,
 229                         .u.array.elem_type =
 230                                 __type_integer(uint8_t, 0, 0, 0,
 231                                         __BIG_ENDIAN, 10, none),
 232                         .u.array.length = 4,
 233                         .u.array.elem_alignment = lttng_alignof(uint8_t),
 234                 },
 235         },
 236         [11] = {
 237                 .name = "transport_header_type",
 238                 .type = {
 239                         .atype = atype_enum,
 240                         .u.basic.enumeration.desc = &transport_header_type,
 241                         .u.basic.enumeration.container_type = {
 242                                 .size = 8,
 243                                 .alignment = 8,
 244                                 .signedness = 0,
 245                                 .reverse_byte_order = 0,
 246                                 .base = 10,
 247                                 .encoding = lttng_encode_none,
 248                         },
 249                 },
 250         },
 251         [12] = {
 252                 .name = "transport_header",
 253                 .type = {
 254                         .atype = atype_variant,
 255                         .u.variant.tag_name = "transport_header_type",
 256                         .u.variant.choices = transport_fields,
 257                         .u.variant.nr_choices = ARRAY_SIZE(transport_fields),
 258                 },
 259         },
 260 };
 261
 262 static struct lttng_event_field ipv6fields[] = {
 263         [0] = {
 264                 .name = "version",
 265                 .type = __type_integer(uint8_t, 4, 4, 0,
 266                                 __BIG_ENDIAN, 10, none),
 267         },
 268         [1] = {
 269                 .name = "prio",
 270                 .type = __type_integer(uint8_t, 4, 4, 0,
 271                                 __BIG_ENDIAN, 10, none),
 272         },
 273         [2] = {
 274                 .name = "flow_lbl",
 275                 .type = {
 276                         .atype = atype_array,
 277                         .u.array.elem_type =
 278                                 __type_integer(uint8_t, 0, 0, 0,
 279                                         __BIG_ENDIAN, 16, none),
 280                         .u.array.length = 3,
 281                         .u.array.elem_alignment = lttng_alignof(uint8_t),
 282                 },
 283         },
 284         [3] = {
 285                 .name = "payload_len",
 286                 .type = __type_integer(uint16_t, 0, 0, 0,
 287                                 __BIG_ENDIAN, 10, none),
 288         },
 289         [4] = {
 290                 .name = "nexthdr",
 291                 .type = {
 292                         .atype = atype_enum,
 293                         .u.basic.enumeration.desc = &transport_header_type,
 294                         .u.basic.enumeration.container_type = {
 295                                 .size = 8,
 296                                 .alignment = 8,
 297                                 .signedness = 0,
 298                                 .reverse_byte_order =
 299                                         __BIG_ENDIAN != __BYTE_ORDER,
 300                                 .base = 10,
 301                                 .encoding = lttng_encode_none,
 302                         },
 303                 },
 304         },
 305         [5] = {
 306                 .name = "hop_limit",
 307                 .type = __type_integer(uint8_t, 0, 0, 0,
 308                                 __BIG_ENDIAN, 10, none),
 309         },
 310         [6] = {
 311                 .name = "saddr",
 312                 .type = {
 313                         .atype = atype_array,
 314                         .u.array.elem_type =
 315                                 __type_integer(uint16_t, 0, 0, 0,
 316                                         __BIG_ENDIAN, 16, none),
 317                         .u.array.length = 8,
 318                         .u.array.elem_alignment = lttng_alignof(uint16_t),
 319                 },
 320         },
 321         [7] = {
 322                 .name = "daddr",
 323                 .type = {
 324                         .atype = atype_array,
 325                         .u.array.elem_type =
 326                                 __type_integer(uint16_t, 0, 0, 0,
 327                                         __BIG_ENDIAN, 16, none),
 328                         .u.array.length = 8,
 329                         .u.array.elem_alignment = lttng_alignof(uint16_t),
 330                 },
 331         },
 332         [8] = {
 333                 .name = "transport_header_type",
 334                 .type = {
 335                         .atype = atype_enum,
 336                         .u.basic.enumeration.desc = &transport_header_type,
 337                         .u.basic.enumeration.container_type = {
 338                                 .size = 8,
 339                                 .alignment = 8,
 340                                 .signedness = 0,
 341                                 .reverse_byte_order = 0,
 342                                 .base = 10,
 343                                 .encoding = lttng_encode_none,
 344                         },
 345                 },
 346         },
 347         [9] = {
 348                 .name = "transport_header",
 349                 .type = {
 350                         .atype = atype_variant,
 351                         .u.variant.tag_name = "transport_header_type",
 352                         .u.variant.choices = transport_fields,
 353                         .u.variant.nr_choices = ARRAY_SIZE(transport_fields),
 354                 },
 355         },
 356 };
 357
 358 static struct lttng_event_field network_fields[] = {
 359         [0] = {
 360                 .name = "unknown",
 361                 .type = {
 362                         .atype = atype_struct,
 363                         .u._struct.nr_fields = 0,
 364                         .u._struct.fields = emptyfields,
 365                 },
 366         },
 367         [1] = {
 368                 .name = "ipv4",
 369                 .type = {
 370                         .atype = atype_struct,
 371                         .u._struct.nr_fields = ARRAY_SIZE(ipv4fields),
 372                         .u._struct.fields = ipv4fields,
 373                 },
 374         },
 375         [2] = {
 376                 .name = "ipv6",
 377                 .type = {
 378                         .atype = atype_struct,
 379                         .u._struct.nr_fields = ARRAY_SIZE(ipv6fields),
 380                         .u._struct.fields = ipv6fields,
 381                 },
 382         },
 383 };
 384
 385 enum network_header_types {
 386         NH_NONE,
 387         NH_IPV4,
 388         NH_IPV6,
 389 };
 390
 391 static inline unsigned char __get_network_header_type(struct sk_buff *skb)
 392 {
 393         if (__has_network_hdr(skb)) {
 394                 if (skb->protocol == htons(ETH_P_IPV6))
 395                         return NH_IPV6;
 396                 else if (skb->protocol == htons(ETH_P_IP))
 397                         return NH_IPV4;
 398                 /* Fallthrough for other header types. */
 399         }
 400         return NH_NONE;
 401 }
 402
 403 #endif
 404
 405 LTTNG_TRACEPOINT_ENUM(net_network_header,
 406         TP_ENUM_VALUES(
 407                 ctf_enum_value("_unknown", NH_NONE)
 408                 ctf_enum_value("_ipv4", NH_IPV4)
 409                 ctf_enum_value("_ipv6", NH_IPV6)
 410         )
 411 )
 412
 413 LTTNG_TRACEPOINT_EVENT(net_dev_xmit,
 414
 415 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,40))
 416         TP_PROTO(struct sk_buff *skb,
 417                  int rc,
 418                  struct net_device *dev,
 419                  unsigned int skb_len),
 420
 421         TP_ARGS(skb, rc, dev, skb_len),
 422 #else
 423         TP_PROTO(struct sk_buff *skb,
 424                  int rc),
 425
 426         TP_ARGS(skb, rc),
 427 #endif
 428
 429         TP_FIELDS(
 430                 ctf_integer_hex(void *, skbaddr, skb)
 431                 ctf_integer(int, rc, rc)
 432 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,40))
 433                 ctf_integer(unsigned int, len, skb_len)
 434                 ctf_string(name, dev->name)
 435 #else
 436                 ctf_integer(unsigned int, len, skb->len)
 437                 ctf_string(name, skb->dev->name)
 438 #endif
 439         )
 440 )
 441
 442 LTTNG_TRACEPOINT_EVENT_CLASS(net_dev_template,
 443
 444         TP_PROTO(struct sk_buff *skb),
 445
 446         TP_ARGS(skb),
 447
 448         TP_FIELDS(
 449                 ctf_integer_hex(void *, skbaddr, skb)
 450                 ctf_integer(unsigned int, len, skb->len)
 451                 ctf_string(name, skb->dev->name)
 452                 ctf_enum(net_network_header, unsigned char,
 453                         network_header_type, __get_network_header_type(skb))
 454                 ctf_custom_field(
 455                         ctf_custom_type(
 456                                 .atype = atype_variant,
 457                                 .u.variant.tag_name = "network_header_type",
 458                                 .u.variant.choices = network_fields,
 459                                 .u.variant.nr_choices =
 460                                         ARRAY_SIZE(network_fields),
 461                         ),
 462                         network_header,
 463                         ctf_custom_code(
 464                                 bool has_network_header = false;
 465
 466                                 /* Copy the network header. */
 467                                 switch (__get_network_header_type(skb)) {
 468                                 case NH_IPV4: {
 469                                         ctf_align(uint16_t)
 470                                         ctf_array_type(uint8_t, ip_hdr(skb),
 471                                                         sizeof(struct iphdr))
 472                                         has_network_header = true;
 473                                         break;
 474                                 }
 475                                 case NH_IPV6: {
 476                                         ctf_align(uint16_t)
 477                                         ctf_array_type(uint8_t, ipv6_hdr(skb),
 478                                                         sizeof(struct ipv6hdr))
 479                                         has_network_header = true;
 480                                         break;
 481                                 }
 482                                 default:
 483                                         /*
 484                                          * For any other network header
 485                                          * type, there is nothing to do.
 486                                          */
 487                                         break;
 488                                 }
 489
 490                                 if (has_network_header) {
 491                                         enum transport_header_types th_type =
 492                                                 __get_transport_header_type(skb);
 493
 494                                         /* Transport header type field. */
 495                                         ctf_integer_type(unsigned char, th_type)
 496
 497                                         /* Copy the transport header. */
 498                                         if (th_type == TH_TCP) {
 499                                                 ctf_align(uint32_t)
 500                                                 ctf_array_type(uint8_t, tcp_hdr(skb),
 501                                                                 sizeof(struct tcphdr))
 502                                         }
 503                                         /*
 504                                          * For any other transport header type,
 505                                          * there is nothing to do.
 506                                          */
 507                                 }
 508                         )
 509                 )
 510         )
 511 )
 512
 513 LTTNG_TRACEPOINT_EVENT_INSTANCE(net_dev_template, net_dev_queue,
 514
 515         TP_PROTO(struct sk_buff *skb),
 516
 517         TP_ARGS(skb)
 518 )
 519
 520 LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_template,
 521
 522         netif_receive_skb,
 523
 524         net_if_receive_skb,
 525
 526         TP_PROTO(struct sk_buff *skb),
 527
 528         TP_ARGS(skb)
 529 )
 530
 531 LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_template,
 532
 533         netif_rx,
 534
 535         net_if_rx,
 536
 537         TP_PROTO(struct sk_buff *skb),
 538
 539         TP_ARGS(skb)
 540 )
 541 #endif /* LTTNG_TRACE_NET_H */
 542
 543 /* This part must be outside protection */
 544 #include <probes/define_trace.h>