[lttng-modules.git] / include / instrumentation / events / net.h

/* SPDX-License-Identifier: GPL-2.0-only */
#undef TRACE_SYSTEM
#define TRACE_SYSTEM net

#if !defined(LTTNG_TRACE_NET_H) || defined(TRACE_HEADER_MULTI_READ)
#define LTTNG_TRACE_NET_H

#include <lttng/tracepoint-event.h>
#include <linux/skbuff.h>
#include <linux/netdevice.h>
#include <linux/ip.h>
#include <linux/ipv6.h>
#include <linux/tcp.h>
#include <linux/udp.h>
#include <linux/icmp.h>
#include <lttng/kernel-version.h>
#include <lttng/endian.h>
#include <net/sock.h>

#ifndef ONCE_LTTNG_NET_H
#define ONCE_LTTNG_NET_H

static inline unsigned char __has_network_hdr(struct sk_buff *skb)
{
	/*
	 * If the header is not set yet, the network header will point
	 * to the head.
	 */
	return skb_network_header(skb) != skb->head;
}

enum transport_header_types {
	TH_NONE = 0,
	TH_TCP = 1,
	TH_UDP = 2,
	TH_ICMP = 3,
};

static inline enum transport_header_types __get_transport_header_type_ip(struct sk_buff *skb)
{
	switch (ip_hdr(skb)->protocol) {
	case IPPROTO_TCP:
		return TH_TCP;
	case IPPROTO_UDP:
		return TH_UDP;
	case IPPROTO_ICMP:
		return TH_ICMP;
	}
	return TH_NONE;
}

static inline enum transport_header_types __get_transport_header_type_ipv6(struct sk_buff *skb)
{
	switch (ipv6_hdr(skb)->nexthdr) {
	case IPPROTO_TCP:
		return TH_TCP;
	case IPPROTO_UDP:
		return TH_UDP;
	case IPPROTO_ICMP:
		return TH_ICMP;
	}
	return TH_NONE;
}

static inline enum transport_header_types __get_transport_header_type(struct sk_buff *skb)
{
	if (__has_network_hdr(skb)) {
		/*
		 * When both transport and network headers are set,
		 * transport header is greater than network header,
		 * otherwise it points to head.
		 */
		if (skb->transport_header > skb->network_header) {
			/*
			 * Get the transport protocol from the network
			 * header's data. This method works both for
			 * sent and received packets.
			 */
			if (skb->protocol == htons(ETH_P_IP)) {
				return __get_transport_header_type_ip(skb);
			} else if(skb->protocol == htons(ETH_P_IPV6)) {
				return __get_transport_header_type_ipv6(skb);
			}
		}
		/* Fallthrough for other cases where header is not recognized. */
	}
	return TH_NONE;
}

enum network_header_types {
	NH_NONE,
	NH_IPV4,
	NH_IPV6,
};

static inline unsigned char __get_network_header_type(struct sk_buff *skb)
{
	if (__has_network_hdr(skb)) {
		if (skb->protocol == htons(ETH_P_IPV6))
			return NH_IPV6;
		else if (skb->protocol == htons(ETH_P_IP))
			return NH_IPV4;
		/* Fallthrough for other header types. */
	}
	return NH_NONE;
}

#endif

#ifdef LTTNG_CREATE_FIELD_METADATA

static const struct lttng_kernel_event_field *emptyfields[] = {
};

/* Structures for transport headers. */

static const struct lttng_kernel_event_field *tcpfields[] = {
	[0] = lttng_kernel_static_event_field("source_port",
		lttng_kernel_static_type_integer_from_type(uint16_t, __BIG_ENDIAN, 10),
		false, false, false),
	[1] = lttng_kernel_static_event_field("dest_port",
		lttng_kernel_static_type_integer_from_type(uint16_t, __BIG_ENDIAN, 10),
		false, false, false),
	[2] = lttng_kernel_static_event_field("seq",
		lttng_kernel_static_type_integer_from_type(uint32_t, __BIG_ENDIAN, 10),
		false, false, false),
	[3] = lttng_kernel_static_event_field("ack_seq",
		lttng_kernel_static_type_integer_from_type(uint32_t, __BIG_ENDIAN, 10),
		false, false, false),
	[4] = lttng_kernel_static_event_field("data_offset",
		lttng_kernel_static_type_integer(4, 4, 0, __BIG_ENDIAN, 10),
		false, false, false),
	[5] = lttng_kernel_static_event_field("reserved",
		lttng_kernel_static_type_integer(3, 1, 0, __BIG_ENDIAN, 10),
		false, false, false),
	[6] = lttng_kernel_static_event_field("flags",
		lttng_kernel_static_type_integer(9, 1, 0, __BIG_ENDIAN, 16),
		false, false, false),
	[7] = lttng_kernel_static_event_field("window_size",
		lttng_kernel_static_type_integer_from_type(uint16_t, __BIG_ENDIAN, 10),
		false, false, false),
	[8] = lttng_kernel_static_event_field("checksum",
		lttng_kernel_static_type_integer_from_type(uint16_t, __BIG_ENDIAN, 16),
		false, false, false),
	[9] = lttng_kernel_static_event_field("urg_ptr",
		lttng_kernel_static_type_integer_from_type(uint16_t, __BIG_ENDIAN, 10),
		false, false, false),
};

static const struct lttng_kernel_event_field *udpfields[] = {
	[0] = lttng_kernel_static_event_field("source_port",
		lttng_kernel_static_type_integer_from_type(uint16_t, __BIG_ENDIAN, 10),
		false, false, false),
	[1] = lttng_kernel_static_event_field("dest_port",
		lttng_kernel_static_type_integer_from_type(uint16_t, __BIG_ENDIAN, 10),
		false, false, false),
	[2] = lttng_kernel_static_event_field("len",
		lttng_kernel_static_type_integer_from_type(uint16_t, __BIG_ENDIAN, 10),
		false, false, false),
	[3] = lttng_kernel_static_event_field("check",
		lttng_kernel_static_type_integer_from_type(uint16_t, __BIG_ENDIAN, 10),
		false, false, false),
};

static const struct lttng_kernel_event_field *icmpfields[] = {
	[0] = lttng_kernel_static_event_field("type",
		lttng_kernel_static_type_integer_from_type(uint8_t, __BIG_ENDIAN, 10),
		false, false, false),
	[1] = lttng_kernel_static_event_field("code",
		lttng_kernel_static_type_integer_from_type(uint8_t, __BIG_ENDIAN, 10),
		false, false, false),
	[2] = lttng_kernel_static_event_field("checksum",
		lttng_kernel_static_type_integer_from_type(uint16_t, __BIG_ENDIAN, 10),
		false, false, false),
	[3] = lttng_kernel_static_event_field("gateway",
		lttng_kernel_static_type_integer_from_type(uint32_t, __BIG_ENDIAN, 10),
		false, false, false),
};

static const struct lttng_kernel_event_field *transport_fields[] = {
	[0] = lttng_kernel_static_event_field("unknown",
		lttng_kernel_static_type_struct(ARRAY_SIZE(emptyfields), emptyfields, 0),
		false, false, true),
	[1] = lttng_kernel_static_event_field("tcp",
		lttng_kernel_static_type_struct(ARRAY_SIZE(tcpfields), tcpfields, 0),
		false, false, true),
	[2] = lttng_kernel_static_event_field("udp",
		lttng_kernel_static_type_struct(ARRAY_SIZE(udpfields), udpfields, 0),
		false, false, true),
	[3] = lttng_kernel_static_event_field("icmp",
		lttng_kernel_static_type_struct(ARRAY_SIZE(icmpfields), icmpfields, 0),
		false, false, true),
};

#endif /* LTTNG_CREATE_FIELD_METADATA */

LTTNG_TRACEPOINT_ENUM(proto_transport_header_type,
	TP_ENUM_VALUES(
		ctf_enum_range("_unknown", 0, IPPROTO_ICMP - 1)
		ctf_enum_value("_icmp", IPPROTO_ICMP)
		ctf_enum_range("_unknown", IPPROTO_ICMP + 1, IPPROTO_TCP - 1)
		ctf_enum_value("_tcp", IPPROTO_TCP)
		ctf_enum_range("_unknown", IPPROTO_TCP + 1, IPPROTO_UDP - 1)
		ctf_enum_value("_udp", IPPROTO_UDP)
		ctf_enum_range("_unknown", IPPROTO_UDP + 1, 255)
	)
)

LTTNG_TRACEPOINT_ENUM(transport_header_type,
	TP_ENUM_VALUES(
		ctf_enum_value("_unknown", TH_NONE)
		ctf_enum_value("_tcp", TH_TCP)
		ctf_enum_value("_udp", TH_UDP)
		ctf_enum_value("_icmp", TH_ICMP)
	)
)

#ifdef LTTNG_CREATE_FIELD_METADATA

/* Structures for network headers. */

static const struct lttng_kernel_event_field *ipv4fields[] = {
	[0] = lttng_kernel_static_event_field("version",
		lttng_kernel_static_type_integer(4, 4, 0, __BIG_ENDIAN, 10),
		false, false, false),
	[1] = lttng_kernel_static_event_field("ihl",
		lttng_kernel_static_type_integer(4, 4, 0, __BIG_ENDIAN, 10),
		false, false, false),
	[2] = lttng_kernel_static_event_field("tos",
		lttng_kernel_static_type_integer_from_type(uint8_t, __BIG_ENDIAN, 10),
		false, false, false),
	[3] = lttng_kernel_static_event_field("tot_len",
		lttng_kernel_static_type_integer_from_type(uint16_t, __BIG_ENDIAN, 10),
		false, false, false),
	[4] = lttng_kernel_static_event_field("id",
		lttng_kernel_static_type_integer_from_type(uint16_t, __BIG_ENDIAN, 16),
		false, false, false),
	[5] = lttng_kernel_static_event_field("frag_off",
		lttng_kernel_static_type_integer_from_type(uint16_t, __BIG_ENDIAN, 10),
		false, false, false),
	[6] = lttng_kernel_static_event_field("ttl",
		lttng_kernel_static_type_integer_from_type(uint8_t, __BIG_ENDIAN, 10),
		false, false, false),
	[7] = lttng_kernel_static_event_field("protocol",
		lttng_kernel_static_type_enum(&__enum_proto_transport_header_type,
			lttng_kernel_static_type_integer_from_type(uint8_t, __BIG_ENDIAN, 10)),
		false, false, false),
	[8] = lttng_kernel_static_event_field("checksum",
		lttng_kernel_static_type_integer_from_type(uint16_t, __BIG_ENDIAN, 16),
		false, false, false),
	[9] = lttng_kernel_static_event_field("saddr",
		lttng_kernel_static_type_array(4,
			lttng_kernel_static_type_integer_from_type(uint8_t, __BIG_ENDIAN, 10),
			lttng_alignof(uint8_t), none),
		false, false, false),
	[10] = lttng_kernel_static_event_field("daddr",
		lttng_kernel_static_type_array(4,
			lttng_kernel_static_type_integer_from_type(uint8_t, __BIG_ENDIAN, 10),
			lttng_alignof(uint8_t), none),
		false, false, false),
	[11] = lttng_kernel_static_event_field("transport_header_type",
		lttng_kernel_static_type_enum(&__enum_transport_header_type,
			lttng_kernel_static_type_integer_from_type(uint8_t, __BYTE_ORDER, 10)),
		false, false, false),
	[12] = lttng_kernel_static_event_field("transport_header",
		lttng_kernel_static_type_variant(ARRAY_SIZE(transport_fields), transport_fields,
			"transport_header_type", 0),
		false, false, false),
};

static const struct lttng_kernel_event_field *ipv6fields[] = {
	[0] = lttng_kernel_static_event_field("version",
		lttng_kernel_static_type_integer(4, 4, 0, __BIG_ENDIAN, 10),
		false, false, false),
	[1] = lttng_kernel_static_event_field("prio",
		lttng_kernel_static_type_integer(4, 4, 0, __BIG_ENDIAN, 10),
		false, false, false),
	[2] = lttng_kernel_static_event_field("flow_lbl",
		lttng_kernel_static_type_array(3, lttng_kernel_static_type_integer_from_type(uint8_t, __BIG_ENDIAN, 16), lttng_alignof(uint8_t), none),
		false, false, false),
	[3] = lttng_kernel_static_event_field("payload_len",
		lttng_kernel_static_type_integer_from_type(uint16_t, __BIG_ENDIAN, 10),
		false, false, false),
	[4] = lttng_kernel_static_event_field("nexthdr",
		lttng_kernel_static_type_enum(&__enum_proto_transport_header_type,
			lttng_kernel_static_type_integer_from_type(uint8_t, __BIG_ENDIAN, 10)),
		false, false, false),
	[5] = lttng_kernel_static_event_field("hop_limit",
		lttng_kernel_static_type_integer_from_type(uint8_t, __BIG_ENDIAN, 10),
		false, false, false),
	[6] = lttng_kernel_static_event_field("saddr",
		lttng_kernel_static_type_array(8, lttng_kernel_static_type_integer_from_type(uint16_t, __BIG_ENDIAN, 16), lttng_alignof(uint16_t), none),
		false, false, false),
	[7] = lttng_kernel_static_event_field("daddr",
		lttng_kernel_static_type_array(8, lttng_kernel_static_type_integer_from_type(uint16_t, __BIG_ENDIAN, 16), lttng_alignof(uint16_t), none),
		false, false, false),
	[8] = lttng_kernel_static_event_field("transport_header_type",
		lttng_kernel_static_type_enum(&__enum_transport_header_type,
			lttng_kernel_static_type_integer_from_type(uint8_t, __BYTE_ORDER, 10)),
		false, false, false),
	[9] = lttng_kernel_static_event_field("transport_header",
		lttng_kernel_static_type_variant(ARRAY_SIZE(transport_fields),
			transport_fields, "transport_header_type", 0),
		false, false, false),
};

static const struct lttng_kernel_event_field *network_fields[] = {
	[0] = lttng_kernel_static_event_field("unknown",
		lttng_kernel_static_type_struct(0, emptyfields, 0),
		false, false, false),
	[1] = lttng_kernel_static_event_field("ipv4",
		lttng_kernel_static_type_struct(ARRAY_SIZE(ipv4fields), ipv4fields, 0),
		false, false, false),
	[2] = lttng_kernel_static_event_field("ipv6",
		lttng_kernel_static_type_struct(ARRAY_SIZE(ipv6fields), ipv6fields, 0),
		false, false, false),
};

#endif /* LTTNG_CREATE_FIELD_METADATA */

LTTNG_TRACEPOINT_ENUM(net_network_header,
	TP_ENUM_VALUES(
		ctf_enum_value("_unknown", NH_NONE)
		ctf_enum_value("_ipv4", NH_IPV4)
		ctf_enum_value("_ipv6", NH_IPV6)
	)
)

LTTNG_TRACEPOINT_EVENT(net_dev_xmit,

	TP_PROTO(struct sk_buff *skb,
		 int rc,
		 struct net_device *dev,
		 unsigned int skb_len),

	TP_ARGS(skb, rc, dev, skb_len),

	TP_FIELDS(
		ctf_integer_hex(void *, skbaddr, skb)
		ctf_integer(int, rc, rc)
		ctf_integer(unsigned int, len, skb_len)
		ctf_string(name, dev->name)
	)
)

LTTNG_TRACEPOINT_EVENT_CLASS(net_dev_template,

	TP_PROTO(struct sk_buff *skb),

	TP_ARGS(skb),

	TP_FIELDS(
		ctf_integer_hex(void *, skbaddr, skb)
		ctf_integer(unsigned int, len, skb->len)
		ctf_string(name, skb->dev->name)
		ctf_enum(net_network_header, unsigned char,
			network_header_type, __get_network_header_type(skb))
		ctf_custom_field(
			ctf_custom_type(
				lttng_kernel_static_type_variant(ARRAY_SIZE(network_fields),
					network_fields, "network_header_type", 0)
			),
			network_header,
			ctf_custom_code(
				bool has_network_header = false;

				/* Copy the network header. */
				switch (__get_network_header_type(skb)) {
				case NH_IPV4: {
					ctf_align(uint16_t)
					ctf_array_type(uint8_t, ip_hdr(skb),
							sizeof(struct iphdr))
					has_network_header = true;
					break;
				}
				case NH_IPV6: {
					ctf_align(uint16_t)
					ctf_array_type(uint8_t, ipv6_hdr(skb),
							sizeof(struct ipv6hdr))
					has_network_header = true;
					break;
				}
				default:
					/*
					 * For any other network header
					 * type, there is nothing to do.
					 */
					break;
				}

				if (has_network_header) {
					enum transport_header_types th_type =
						__get_transport_header_type(skb);

					/* Transport header type field. */
					ctf_integer_type(unsigned char, th_type)

					/* Copy the transport header. */
					switch (th_type) {
					case TH_TCP: {
						ctf_align(uint32_t)
						ctf_array_type(uint8_t, tcp_hdr(skb),
								sizeof(struct tcphdr))
						break;
					}
					case TH_UDP: {
						ctf_align(uint32_t)
						ctf_array_type(uint8_t, udp_hdr(skb),
								sizeof(struct udphdr))
						break;
					}
					case TH_ICMP: {
						ctf_align(uint32_t)
						ctf_array_type(uint8_t, icmp_hdr(skb),
								sizeof(struct icmphdr))
						break;
					}
					default:
						/*
						* For any other transport header type,
						* there is nothing to do.
						*/
						break;
					}
				}
			)
		)
	)
)

LTTNG_TRACEPOINT_EVENT_INSTANCE(net_dev_template, net_dev_queue,

	TP_PROTO(struct sk_buff *skb),

	TP_ARGS(skb)
)

LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_template,

	netif_receive_skb,

	net_if_receive_skb,

	TP_PROTO(struct sk_buff *skb),

	TP_ARGS(skb)
)

LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_template,

	netif_rx,

	net_if_rx,

	TP_PROTO(struct sk_buff *skb),

	TP_ARGS(skb)
)

#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,14,0))

/* Trace events for the receive entry points */
LTTNG_TRACEPOINT_EVENT_CLASS(net_dev_receive_entry_template,

	TP_PROTO(const struct sk_buff *skb),

	TP_ARGS(skb),

	TP_FIELDS(
		ctf_integer_hex(const void *, skbaddr, skb)
	)
)

LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_receive_entry_template,

	napi_gro_frags_entry,

	net_napi_gro_frags_entry,

	TP_PROTO(const struct sk_buff *skb),

	TP_ARGS(skb)
)

LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_receive_entry_template,

	napi_gro_receive_entry,

	net_napi_gro_receive_entry,

	TP_PROTO(const struct sk_buff *skb),

	TP_ARGS(skb)
)

LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_receive_entry_template,

	netif_receive_skb_entry,

	net_if_receive_skb_entry,

	TP_PROTO(const struct sk_buff *skb),

	TP_ARGS(skb)
)

LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_receive_entry_template,

	netif_rx_entry,

	net_if_rx_entry,

	TP_PROTO(const struct sk_buff *skb),

	TP_ARGS(skb)
)

LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_receive_entry_template,

	netif_rx_ni_entry,

	net_if_rx_ni_entry,

	TP_PROTO(const struct sk_buff *skb),

	TP_ARGS(skb)
)

#endif /* kernel > 3.14 */

#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,19,0))

LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_receive_entry_template,

	netif_receive_skb_list_entry,

	net_if_receive_skb_list_entry,

	TP_PROTO(const struct sk_buff *skb),

	TP_ARGS(skb)
)

#endif /* kernel > 4.19 */

#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,0,0))

/* Trace events for the receive exit points */
LTTNG_TRACEPOINT_EVENT_CLASS(net_dev_receive_exit_template,

	TP_PROTO(int ret),

	TP_ARGS(ret),

	TP_FIELDS(
		ctf_integer(int, ret, ret)
	)
)

LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_receive_exit_template,

	napi_gro_frags_exit,

	net_napi_gro_frags_exit,

	TP_PROTO(int ret),

	TP_ARGS(ret)
)

LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_receive_exit_template,

	napi_gro_receive_exit,

	net_napi_gro_receive_exit,

	TP_PROTO(int ret),

	TP_ARGS(ret)
)

LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_receive_exit_template,

	netif_receive_skb_exit,

	net_if_receive_skb_exit,

	TP_PROTO(int ret),

	TP_ARGS(ret)
)

LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_receive_exit_template,

	netif_rx_exit,

	net_if_rx_exit,

	TP_PROTO(int ret),

	TP_ARGS(ret)
)

LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_receive_exit_template,

	netif_rx_ni_exit,

	net_if_rx_ni_exit,

	TP_PROTO(int ret),

	TP_ARGS(ret)
)

LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_receive_exit_template,

	netif_receive_skb_list_exit,

	net_if_receive_skb_list_exit,

	TP_PROTO(int ret),

	TP_ARGS(ret)
)

#endif /* kernel > 5.0.0 */

#endif /* LTTNG_TRACE_NET_H */

/* This part must be outside protection */
#include <lttng/define_trace.h>
Commit	Line	Data
b7cdc182	1	/* SPDX-License-Identifier: GPL-2.0-only */
b283666f PW	2	#undef TRACE_SYSTEM
	3	#define TRACE_SYSTEM net
	4
3bc29f0a MD	5	#if !defined(LTTNG_TRACE_NET_H) \|\| defined(TRACE_HEADER_MULTI_READ)
3bc29f0a MD	6	#define LTTNG_TRACE_NET_H
b283666f	7
3b4aafcb	8	#include <lttng/tracepoint-event.h>
b283666f PW	9	#include <linux/skbuff.h>
	10	#include <linux/netdevice.h>
	11	#include <linux/ip.h>
e5990fd4 GB	12	#include <linux/ipv6.h>
e5990fd4 GB	13	#include <linux/tcp.h>
f6dd81c5 FW	14	#include <linux/udp.h>
f6dd81c5 FW	15	#include <linux/icmp.h>
5f4c791e	16	#include <lttng/kernel-version.h>
2df37e95	17	#include <lttng/endian.h>
e5990fd4 GB	18	#include <net/sock.h>
	19
	20	#ifndef ONCE_LTTNG_NET_H
	21	#define ONCE_LTTNG_NET_H
	22
	23	static inline unsigned char __has_network_hdr(struct sk_buff *skb)
	24	{
	25	/*
aa900596 MD	26	* If the header is not set yet, the network header will point
aa900596 MD	27	* to the head.
e5990fd4 GB	28	*/
	29	return skb_network_header(skb) != skb->head;
	30	}
	31
9cf9736a	32	enum transport_header_types {
0910ab71 MD	33	TH_NONE = 0,
0910ab71 MD	34	TH_TCP = 1,
f6dd81c5 FW	35	TH_UDP = 2,
f6dd81c5 FW	36	TH_ICMP = 3,
9cf9736a GB	37	};
9cf9736a GB	38
f6dd81c5 FW	39	static inline enum transport_header_types __get_transport_header_type_ip(struct sk_buff *skb)
	40	{
	41	switch (ip_hdr(skb)->protocol) {
	42	case IPPROTO_TCP:
	43	return TH_TCP;
	44	case IPPROTO_UDP:
	45	return TH_UDP;
	46	case IPPROTO_ICMP:
	47	return TH_ICMP;
	48	}
	49	return TH_NONE;
	50	}
	51
	52	static inline enum transport_header_types __get_transport_header_type_ipv6(struct sk_buff *skb)
	53	{
	54	switch (ipv6_hdr(skb)->nexthdr) {
	55	case IPPROTO_TCP:
	56	return TH_TCP;
	57	case IPPROTO_UDP:
	58	return TH_UDP;
	59	case IPPROTO_ICMP:
	60	return TH_ICMP;
	61	}
	62	return TH_NONE;
	63	}
	64
0910ab71	65	static inline enum transport_header_types __get_transport_header_type(struct sk_buff *skb)
9cf9736a GB	66	{
	67	if (__has_network_hdr(skb)) {
	68	/*
aa900596 MD	69	* When both transport and network headers are set,
	70	* transport header is greater than network header,
	71	* otherwise it points to head.
9cf9736a GB	72	*/
	73	if (skb->transport_header > skb->network_header) {
	74	/*
aa900596 MD	75	* Get the transport protocol from the network
	76	* header's data. This method works both for
	77	* sent and received packets.
9cf9736a	78	*/
f6dd81c5 FW	79	if (skb->protocol == htons(ETH_P_IP)) {
	80	return __get_transport_header_type_ip(skb);
	81	} else if(skb->protocol == htons(ETH_P_IPV6)) {
	82	return __get_transport_header_type_ipv6(skb);
	83	}
9cf9736a	84	}
f6dd81c5	85	/* Fallthrough for other cases where header is not recognized. */
9cf9736a GB	86	}
	87	return TH_NONE;
	88	}
	89
e5990fd4 GB	90	enum network_header_types {
	91	NH_NONE,
	92	NH_IPV4,
	93	NH_IPV6,
	94	};
	95
	96	static inline unsigned char __get_network_header_type(struct sk_buff *skb)
	97	{
	98	if (__has_network_hdr(skb)) {
	99	if (skb->protocol == htons(ETH_P_IPV6))
	100	return NH_IPV6;
	101	else if (skb->protocol == htons(ETH_P_IP))
	102	return NH_IPV4;
	103	/* Fallthrough for other header types. */
	104	}
	105	return NH_NONE;
	106	}
	107
	108	#endif
	109
437d5aa5 MD	110	#ifdef LTTNG_CREATE_FIELD_METADATA
	111
	112	static const struct lttng_kernel_event_field *emptyfields[] = {
	113	};
	114
	115	/* Structures for transport headers. */
	116
	117	static const struct lttng_kernel_event_field *tcpfields[] = {
	118	[0] = lttng_kernel_static_event_field("source_port",
	119	lttng_kernel_static_type_integer_from_type(uint16_t, __BIG_ENDIAN, 10),
	120	false, false, false),
	121	[1] = lttng_kernel_static_event_field("dest_port",
	122	lttng_kernel_static_type_integer_from_type(uint16_t, __BIG_ENDIAN, 10),
	123	false, false, false),
	124	[2] = lttng_kernel_static_event_field("seq",
	125	lttng_kernel_static_type_integer_from_type(uint32_t, __BIG_ENDIAN, 10),
	126	false, false, false),
	127	[3] = lttng_kernel_static_event_field("ack_seq",
	128	lttng_kernel_static_type_integer_from_type(uint32_t, __BIG_ENDIAN, 10),
	129	false, false, false),
	130	[4] = lttng_kernel_static_event_field("data_offset",
	131	lttng_kernel_static_type_integer(4, 4, 0, __BIG_ENDIAN, 10),
	132	false, false, false),
	133	[5] = lttng_kernel_static_event_field("reserved",
	134	lttng_kernel_static_type_integer(3, 1, 0, __BIG_ENDIAN, 10),
	135	false, false, false),
	136	[6] = lttng_kernel_static_event_field("flags",
	137	lttng_kernel_static_type_integer(9, 1, 0, __BIG_ENDIAN, 16),
	138	false, false, false),
	139	[7] = lttng_kernel_static_event_field("window_size",
	140	lttng_kernel_static_type_integer_from_type(uint16_t, __BIG_ENDIAN, 10),
	141	false, false, false),
	142	[8] = lttng_kernel_static_event_field("checksum",
	143	lttng_kernel_static_type_integer_from_type(uint16_t, __BIG_ENDIAN, 16),
	144	false, false, false),
	145	[9] = lttng_kernel_static_event_field("urg_ptr",
	146	lttng_kernel_static_type_integer_from_type(uint16_t, __BIG_ENDIAN, 10),
	147	false, false, false),
	148	};
	149
	150	static const struct lttng_kernel_event_field *udpfields[] = {
	151	[0] = lttng_kernel_static_event_field("source_port",
	152	lttng_kernel_static_type_integer_from_type(uint16_t, __BIG_ENDIAN, 10),
	153	false, false, false),
	154	[1] = lttng_kernel_static_event_field("dest_port",
	155	lttng_kernel_static_type_integer_from_type(uint16_t, __BIG_ENDIAN, 10),
	156	false, false, false),
	157	[2] = lttng_kernel_static_event_field("len",
	158	lttng_kernel_static_type_integer_from_type(uint16_t, __BIG_ENDIAN, 10),
	159	false, false, false),
	160	[3] = lttng_kernel_static_event_field("check",
	161	lttng_kernel_static_type_integer_from_type(uint16_t, __BIG_ENDIAN, 10),
	162	false, false, false),
	163	};
	164
	165	static const struct lttng_kernel_event_field *icmpfields[] = {
	166	[0] = lttng_kernel_static_event_field("type",
	167	lttng_kernel_static_type_integer_from_type(uint8_t, __BIG_ENDIAN, 10),
	168	false, false, false),
	169	[1] = lttng_kernel_static_event_field("code",
	170	lttng_kernel_static_type_integer_from_type(uint8_t, __BIG_ENDIAN, 10),
	171	false, false, false),
	172	[2] = lttng_kernel_static_event_field("checksum",
	173	lttng_kernel_static_type_integer_from_type(uint16_t, __BIG_ENDIAN, 10),
174	false, false, false),
175	[3] = lttng_kernel_static_event_field("gateway",
176	lttng_kernel_static_type_integer_from_type(uint32_t, __BIG_ENDIAN, 10),
177	false, false, false),
178	};
179
180	static const struct lttng_kernel_event_field *transport_fields[] = {
181	[0] = lttng_kernel_static_event_field("unknown",
182	lttng_kernel_static_type_struct(ARRAY_SIZE(emptyfields), emptyfields, 0),
183	false, false, true),
184	[1] = lttng_kernel_static_event_field("tcp",
185	lttng_kernel_static_type_struct(ARRAY_SIZE(tcpfields), tcpfields, 0),
186	false, false, true),
187	[2] = lttng_kernel_static_event_field("udp",
188	lttng_kernel_static_type_struct(ARRAY_SIZE(udpfields), udpfields, 0),
189	false, false, true),
190	[3] = lttng_kernel_static_event_field("icmp",
191	lttng_kernel_static_type_struct(ARRAY_SIZE(icmpfields), icmpfields, 0),
192	false, false, true),
193	};
194
195	#endif /* LTTNG_CREATE_FIELD_METADATA */
196
197	LTTNG_TRACEPOINT_ENUM(proto_transport_header_type,
198	TP_ENUM_VALUES(
199	ctf_enum_range("_unknown", 0, IPPROTO_ICMP - 1)
200	ctf_enum_value("_icmp", IPPROTO_ICMP)
201	ctf_enum_range("_unknown", IPPROTO_ICMP + 1, IPPROTO_TCP - 1)
202	ctf_enum_value("_tcp", IPPROTO_TCP)
203	ctf_enum_range("_unknown", IPPROTO_TCP + 1, IPPROTO_UDP - 1)
204	ctf_enum_value("_udp", IPPROTO_UDP)
205	ctf_enum_range("_unknown", IPPROTO_UDP + 1, 255)
206	)
207	)
208
209	LTTNG_TRACEPOINT_ENUM(transport_header_type,
210	TP_ENUM_VALUES(
211	ctf_enum_value("_unknown", TH_NONE)
212	ctf_enum_value("_tcp", TH_TCP)
213	ctf_enum_value("_udp", TH_UDP)
214	ctf_enum_value("_icmp", TH_ICMP)
215	)
216	)
217
218	#ifdef LTTNG_CREATE_FIELD_METADATA
219
220	/* Structures for network headers. */
221
222	static const struct lttng_kernel_event_field *ipv4fields[] = {
223	[0] = lttng_kernel_static_event_field("version",
224	lttng_kernel_static_type_integer(4, 4, 0, __BIG_ENDIAN, 10),
225	false, false, false),
226	[1] = lttng_kernel_static_event_field("ihl",
227	lttng_kernel_static_type_integer(4, 4, 0, __BIG_ENDIAN, 10),
228	false, false, false),
229	[2] = lttng_kernel_static_event_field("tos",
230	lttng_kernel_static_type_integer_from_type(uint8_t, __BIG_ENDIAN, 10),
231	false, false, false),
232	[3] = lttng_kernel_static_event_field("tot_len",
233	lttng_kernel_static_type_integer_from_type(uint16_t, __BIG_ENDIAN, 10),
234	false, false, false),
235	[4] = lttng_kernel_static_event_field("id",
236	lttng_kernel_static_type_integer_from_type(uint16_t, __BIG_ENDIAN, 16),
237	false, false, false),
238	[5] = lttng_kernel_static_event_field("frag_off",
239	lttng_kernel_static_type_integer_from_type(uint16_t, __BIG_ENDIAN, 10),
240	false, false, false),
241	[6] = lttng_kernel_static_event_field("ttl",
242	lttng_kernel_static_type_integer_from_type(uint8_t, __BIG_ENDIAN, 10),
243	false, false, false),
244	[7] = lttng_kernel_static_event_field("protocol",
245	lttng_kernel_static_type_enum(&__enum_proto_transport_header_type,
246	lttng_kernel_static_type_integer_from_type(uint8_t, __BIG_ENDIAN, 10)),
247	false, false, false),
248	[8] = lttng_kernel_static_event_field("checksum",
249	lttng_kernel_static_type_integer_from_type(uint16_t, __BIG_ENDIAN, 16),
250	false, false, false),
251	[9] = lttng_kernel_static_event_field("saddr",
252	lttng_kernel_static_type_array(4,
253	lttng_kernel_static_type_integer_from_type(uint8_t, __BIG_ENDIAN, 10),
254	lttng_alignof(uint8_t), none),
255	false, false, false),
256	[10] = lttng_kernel_static_event_field("daddr",
257	lttng_kernel_static_type_array(4,
258	lttng_kernel_static_type_integer_from_type(uint8_t, __BIG_ENDIAN, 10),
259	lttng_alignof(uint8_t), none),
260	false, false, false),
261	[11] = lttng_kernel_static_event_field("transport_header_type",
262	lttng_kernel_static_type_enum(&__enum_transport_header_type,
263	lttng_kernel_static_type_integer_from_type(uint8_t, __BYTE_ORDER, 10)),
264	false, false, false),
265	[12] = lttng_kernel_static_event_field("transport_header",
266	lttng_kernel_static_type_variant(ARRAY_SIZE(transport_fields), transport_fields,
267	"transport_header_type", 0),
268	false, false, false),
269	};
270
271	static const struct lttng_kernel_event_field *ipv6fields[] = {
272	[0] = lttng_kernel_static_event_field("version",
273	lttng_kernel_static_type_integer(4, 4, 0, __BIG_ENDIAN, 10),
274	false, false, false),
275	[1] = lttng_kernel_static_event_field("prio",
276	lttng_kernel_static_type_integer(4, 4, 0, __BIG_ENDIAN, 10),
277	false, false, false),
278	[2] = lttng_kernel_static_event_field("flow_lbl",
279	lttng_kernel_static_type_array(3, lttng_kernel_static_type_integer_from_type(uint8_t, __BIG_ENDIAN, 16), lttng_alignof(uint8_t), none),
280	false, false, false),
281	[3] = lttng_kernel_static_event_field("payload_len",
282	lttng_kernel_static_type_integer_from_type(uint16_t, __BIG_ENDIAN, 10),
283	false, false, false),
284	[4] = lttng_kernel_static_event_field("nexthdr",
285	lttng_kernel_static_type_enum(&__enum_proto_transport_header_type,
286	lttng_kernel_static_type_integer_from_type(uint8_t, __BIG_ENDIAN, 10)),
287	false, false, false),
288	[5] = lttng_kernel_static_event_field("hop_limit",
289	lttng_kernel_static_type_integer_from_type(uint8_t, __BIG_ENDIAN, 10),
290	false, false, false),
291	[6] = lttng_kernel_static_event_field("saddr",
292	lttng_kernel_static_type_array(8, lttng_kernel_static_type_integer_from_type(uint16_t, __BIG_ENDIAN, 16), lttng_alignof(uint16_t), none),
293	false, false, false),
294	[7] = lttng_kernel_static_event_field("daddr",
295	lttng_kernel_static_type_array(8, lttng_kernel_static_type_integer_from_type(uint16_t, __BIG_ENDIAN, 16), lttng_alignof(uint16_t), none),
296	false, false, false),
297	[8] = lttng_kernel_static_event_field("transport_header_type",
298	lttng_kernel_static_type_enum(&__enum_transport_header_type,
299	lttng_kernel_static_type_integer_from_type(uint8_t, __BYTE_ORDER, 10)),
300	false, false, false),
301	[9] = lttng_kernel_static_event_field("transport_header",
302	lttng_kernel_static_type_variant(ARRAY_SIZE(transport_fields),
303	transport_fields, "transport_header_type", 0),
304	false, false, false),
305	};
306
307	static const struct lttng_kernel_event_field *network_fields[] = {
308	[0] = lttng_kernel_static_event_field("unknown",
309	lttng_kernel_static_type_struct(0, emptyfields, 0),
310	false, false, false),
311	[1] = lttng_kernel_static_event_field("ipv4",
312	lttng_kernel_static_type_struct(ARRAY_SIZE(ipv4fields), ipv4fields, 0),
313	false, false, false),
314	[2] = lttng_kernel_static_event_field("ipv6",
315	lttng_kernel_static_type_struct(ARRAY_SIZE(ipv6fields), ipv6fields, 0),
316	false, false, false),
317	};
318
319	#endif /* LTTNG_CREATE_FIELD_METADATA */
320
e5990fd4 GB	321	LTTNG_TRACEPOINT_ENUM(net_network_header,
	322	TP_ENUM_VALUES(
	323	ctf_enum_value("_unknown", NH_NONE)
	324	ctf_enum_value("_ipv4", NH_IPV4)
	325	ctf_enum_value("_ipv6", NH_IPV6)
	326	)
	327	)
b283666f	328
3bc29f0a	329	LTTNG_TRACEPOINT_EVENT(net_dev_xmit,
b283666f PW	330
	331	TP_PROTO(struct sk_buff *skb,
	332	int rc,
	333	struct net_device *dev,
	334	unsigned int skb_len),
	335
	336	TP_ARGS(skb, rc, dev, skb_len),
	337
f127e61e	338	TP_FIELDS(
fa91fcac	339	ctf_integer_hex(void *, skbaddr, skb)
f127e61e	340	ctf_integer(int, rc, rc)
974c0969	341	ctf_integer(unsigned int, len, skb_len)
f127e61e	342	ctf_string(name, dev->name)
f127e61e	343	)
b283666f PW	344	)
b283666f PW	345
3bc29f0a	346	LTTNG_TRACEPOINT_EVENT_CLASS(net_dev_template,
b283666f PW	347
	348	TP_PROTO(struct sk_buff *skb),
	349
	350	TP_ARGS(skb),
	351
f127e61e	352	TP_FIELDS(
fa91fcac	353	ctf_integer_hex(void *, skbaddr, skb)
f127e61e MD	354	ctf_integer(unsigned int, len, skb->len)
f127e61e MD	355	ctf_string(name, skb->dev->name)
e5990fd4 GB	356	ctf_enum(net_network_header, unsigned char,
	357	network_header_type, __get_network_header_type(skb))
	358	ctf_custom_field(
	359	ctf_custom_type(
437d5aa5 MD	360	lttng_kernel_static_type_variant(ARRAY_SIZE(network_fields),
437d5aa5 MD	361	network_fields, "network_header_type", 0)
e5990fd4 GB	362	),
	363	network_header,
	364	ctf_custom_code(
0910ab71 MD	365	bool has_network_header = false;
0910ab71 MD	366
aa900596	367	/* Copy the network header. */
e5990fd4 GB	368	switch (__get_network_header_type(skb)) {
	369	case NH_IPV4: {
	370	ctf_align(uint16_t)
	371	ctf_array_type(uint8_t, ip_hdr(skb),
	372	sizeof(struct iphdr))
0910ab71	373	has_network_header = true;
e5990fd4 GB	374	break;
	375	}
	376	case NH_IPV6: {
	377	ctf_align(uint16_t)
	378	ctf_array_type(uint8_t, ipv6_hdr(skb),
	379	sizeof(struct ipv6hdr))
0910ab71	380	has_network_header = true;
e5990fd4 GB	381	break;
	382	}
	383	default:
aa900596 MD	384	/*
	385	* For any other network header
	386	* type, there is nothing to do.
	387	*/
e5990fd4 GB	388	break;
e5990fd4 GB	389	}
9cf9736a	390
0910ab71 MD	391	if (has_network_header) {
	392	enum transport_header_types th_type =
	393	__get_transport_header_type(skb);
	394
	395	/* Transport header type field. */
	396	ctf_integer_type(unsigned char, th_type)
	397
	398	/* Copy the transport header. */
f6dd81c5 FW	399	switch (th_type) {
f6dd81c5 FW	400	case TH_TCP: {
0910ab71 MD	401	ctf_align(uint32_t)
	402	ctf_array_type(uint8_t, tcp_hdr(skb),
	403	sizeof(struct tcphdr))
f6dd81c5 FW	404	break;
	405	}
	406	case TH_UDP: {
	407	ctf_align(uint32_t)
	408	ctf_array_type(uint8_t, udp_hdr(skb),
	409	sizeof(struct udphdr))
	410	break;
	411	}
	412	case TH_ICMP: {
	413	ctf_align(uint32_t)
	414	ctf_array_type(uint8_t, icmp_hdr(skb),
	415	sizeof(struct icmphdr))
	416	break;
	417	}
	418	default:
	419	/*
	420	* For any other transport header type,
	421	* there is nothing to do.
	422	*/
	423	break;
0910ab71	424	}
9cf9736a	425	}
e5990fd4 GB	426	)
e5990fd4 GB	427	)
f127e61e	428	)
b283666f PW	429	)
b283666f PW	430
3bc29f0a	431	LTTNG_TRACEPOINT_EVENT_INSTANCE(net_dev_template, net_dev_queue,
b283666f PW	432
	433	TP_PROTO(struct sk_buff *skb),
	434
	435	TP_ARGS(skb)
	436	)
	437
b7f5408a MD	438	LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_template,
	439
	440	netif_receive_skb,
	441
	442	net_if_receive_skb,
b283666f PW	443
	444	TP_PROTO(struct sk_buff *skb),
	445
	446	TP_ARGS(skb)
	447	)
	448
b7f5408a MD	449	LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_template,
	450
	451	netif_rx,
	452
	453	net_if_rx,
b283666f PW	454
	455	TP_PROTO(struct sk_buff *skb),
	456
	457	TP_ARGS(skb)
	458	)
e9d818b9	459
5f4c791e	460	#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,14,0))
e9d818b9 GB	461
	462	/* Trace events for the receive entry points */
	463	LTTNG_TRACEPOINT_EVENT_CLASS(net_dev_receive_entry_template,
	464
	465	TP_PROTO(const struct sk_buff *skb),
	466
	467	TP_ARGS(skb),
	468
	469	TP_FIELDS(
	470	ctf_integer_hex(const void *, skbaddr, skb)
	471	)
	472	)
	473
	474	LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_receive_entry_template,
	475
	476	napi_gro_frags_entry,
	477
	478	net_napi_gro_frags_entry,
	479
	480	TP_PROTO(const struct sk_buff *skb),
	481
	482	TP_ARGS(skb)
	483	)
	484
	485	LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_receive_entry_template,
	486
	487	napi_gro_receive_entry,
	488
	489	net_napi_gro_receive_entry,
	490
	491	TP_PROTO(const struct sk_buff *skb),
	492
	493	TP_ARGS(skb)
	494	)
	495
	496	LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_receive_entry_template,
	497
	498	netif_receive_skb_entry,
	499
	500	net_if_receive_skb_entry,
	501
	502	TP_PROTO(const struct sk_buff *skb),
	503
	504	TP_ARGS(skb)
	505	)
	506
	507	LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_receive_entry_template,
	508
	509	netif_rx_entry,
	510
	511	net_if_rx_entry,
	512
	513	TP_PROTO(const struct sk_buff *skb),
	514
	515	TP_ARGS(skb)
	516	)
	517
	518	LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_receive_entry_template,
	519
	520	netif_rx_ni_entry,
	521
	522	net_if_rx_ni_entry,
	523
	524	TP_PROTO(const struct sk_buff *skb),
525
526	TP_ARGS(skb)
527	)
528
529	#endif /* kernel > 3.14 */
530
5f4c791e	531	#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,19,0))
e9d818b9 GB	532
	533	LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_receive_entry_template,
	534
	535	netif_receive_skb_list_entry,
	536
	537	net_if_receive_skb_list_entry,
	538
	539	TP_PROTO(const struct sk_buff *skb),
	540
	541	TP_ARGS(skb)
	542	)
	543
	544	#endif /* kernel > 4.19 */
	545
5f4c791e	546	#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,0,0))
e9d818b9 GB	547
	548	/* Trace events for the receive exit points */
	549	LTTNG_TRACEPOINT_EVENT_CLASS(net_dev_receive_exit_template,
	550
	551	TP_PROTO(int ret),
	552
	553	TP_ARGS(ret),
	554
	555	TP_FIELDS(
	556	ctf_integer(int, ret, ret)
	557	)
	558	)
	559
	560	LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_receive_exit_template,
	561
	562	napi_gro_frags_exit,
	563
	564	net_napi_gro_frags_exit,
	565
	566	TP_PROTO(int ret),
	567
	568	TP_ARGS(ret)
	569	)
	570
	571	LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_receive_exit_template,
	572
	573	napi_gro_receive_exit,
	574
	575	net_napi_gro_receive_exit,
	576
	577	TP_PROTO(int ret),
	578
	579	TP_ARGS(ret)
	580	)
	581
	582	LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_receive_exit_template,
	583
	584	netif_receive_skb_exit,
	585
	586	net_if_receive_skb_exit,
	587
	588	TP_PROTO(int ret),
	589
	590	TP_ARGS(ret)
	591	)
	592
	593	LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_receive_exit_template,
	594
	595	netif_rx_exit,
	596
	597	net_if_rx_exit,
	598
	599	TP_PROTO(int ret),
	600
	601	TP_ARGS(ret)
	602	)
	603
	604	LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_receive_exit_template,
	605
	606	netif_rx_ni_exit,
	607
	608	net_if_rx_ni_exit,
	609
	610	TP_PROTO(int ret),
611
612	TP_ARGS(ret)
613	)
614
615	LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(net_dev_receive_exit_template,
616
617	netif_receive_skb_list_exit,
618
619	net_if_receive_skb_list_exit,
620
621	TP_PROTO(int ret),
622
623	TP_ARGS(ret)
624	)
625
626	#endif /* kernel > 5.0.0 */
627
3bc29f0a	628	#endif /* LTTNG_TRACE_NET_H */
b283666f PW	629
b283666f PW	630	/* This part must be outside protection */
3b4aafcb	631	#include <lttng/define_trace.h>