net/xfrm/trace_iptfs.h

/* SPDX-License-Identifier: GPL-2.0 */
/* xfrm_trace_iptfs.h
 *
 * August 12 2023, Christian Hopps <chopps@labn.net>
 *
 * Copyright (c) 2023, LabN Consulting, L.L.C.
 */

#undef TRACE_SYSTEM
#define TRACE_SYSTEM iptfs

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

#include <linux/kernel.h>
#include <linux/skbuff.h>
#include <linux/tracepoint.h>
#include <net/ip.h>

struct xfrm_iptfs_data;

TRACE_EVENT(iptfs_egress_recv,
	    TP_PROTO(struct sk_buff *skb, struct xfrm_iptfs_data *xtfs, u16 blkoff),
	    TP_ARGS(skb, xtfs, blkoff),
	    TP_STRUCT__entry(__field(struct sk_buff *, skb)
			     __field(void *, head)
			     __field(void *, head_pg_addr)
			     __field(void *, pg0addr)
			     __field(u32, skb_len)
			     __field(u32, data_len)
			     __field(u32, headroom)
			     __field(u32, tailroom)
			     __field(u32, tail)
			     __field(u32, end)
			     __field(u32, pg0off)
			     __field(u8, head_frag)
			     __field(u8, frag_list)
			     __field(u8, nr_frags)
			     __field(u16, blkoff)),
	    TP_fast_assign(__entry->skb = skb;
			   __entry->head = skb->head;
			   __entry->skb_len = skb->len;
			   __entry->data_len = skb->data_len;
			   __entry->headroom = skb_headroom(skb);
			   __entry->tailroom = skb_tailroom(skb);
			   __entry->tail = (u32)skb->tail;
			   __entry->end = (u32)skb->end;
			   __entry->head_frag = skb->head_frag;
			   __entry->frag_list = (bool)skb_shinfo(skb)->frag_list;
			   __entry->nr_frags = skb_shinfo(skb)->nr_frags;
			   __entry->blkoff = blkoff;
			   __entry->head_pg_addr = page_address(virt_to_head_page(skb->head));
			   __entry->pg0addr = (__entry->nr_frags
					       ? page_address(netmem_to_page(skb_shinfo(skb)->frags[0].netmem))
					       : NULL);
			   __entry->pg0off = (__entry->nr_frags
					      ? skb_shinfo(skb)->frags[0].offset
					      : 0);
		    ),
	    TP_printk("EGRESS: skb=%p len=%u data_len=%u headroom=%u head_frag=%u frag_list=%u nr_frags=%u blkoff=%u\n\t\ttailroom=%u tail=%u end=%u head=%p hdpgaddr=%p pg0->addr=%p pg0->data=%p pg0->off=%u",
		      __entry->skb, __entry->skb_len, __entry->data_len, __entry->headroom,
		      __entry->head_frag, __entry->frag_list, __entry->nr_frags, __entry->blkoff,
		      __entry->tailroom, __entry->tail, __entry->end, __entry->head,
		      __entry->head_pg_addr, __entry->pg0addr, __entry->pg0addr + __entry->pg0off,
		      __entry->pg0off)
	)

DECLARE_EVENT_CLASS(iptfs_ingress_preq_event,
		    TP_PROTO(struct sk_buff *skb, struct xfrm_iptfs_data *xtfs,
			     u32 pmtu, u8 was_gso),
		    TP_ARGS(skb, xtfs, pmtu, was_gso),
		    TP_STRUCT__entry(__field(struct sk_buff *, skb)
				     __field(u32, skb_len)
				     __field(u32, data_len)
				     __field(u32, pmtu)
				     __field(u32, queue_size)
				     __field(u32, proto_seq)
				     __field(u8, proto)
				     __field(u8, was_gso)
			    ),
		    TP_fast_assign(__entry->skb = skb;
				   __entry->skb_len = skb->len;
				   __entry->data_len = skb->data_len;
				   __entry->queue_size =
					xtfs->cfg.max_queue_size - xtfs->queue_size;
				   __entry->proto = __trace_ip_proto(ip_hdr(skb));
				   __entry->proto_seq = __trace_ip_proto_seq(ip_hdr(skb));
				   __entry->pmtu = pmtu;
				   __entry->was_gso = was_gso;
			    ),
		    TP_printk("INGRPREQ: skb=%p len=%u data_len=%u qsize=%u proto=%u proto_seq=%u pmtu=%u was_gso=%u",
			      __entry->skb, __entry->skb_len, __entry->data_len,
			      __entry->queue_size, __entry->proto, __entry->proto_seq,
			      __entry->pmtu, __entry->was_gso));

DEFINE_EVENT(iptfs_ingress_preq_event, iptfs_enqueue,
	     TP_PROTO(struct sk_buff *skb, struct xfrm_iptfs_data *xtfs, u32 pmtu, u8 was_gso),
	     TP_ARGS(skb, xtfs, pmtu, was_gso));

DEFINE_EVENT(iptfs_ingress_preq_event, iptfs_no_queue_space,
	     TP_PROTO(struct sk_buff *skb, struct xfrm_iptfs_data *xtfs, u32 pmtu, u8 was_gso),
	     TP_ARGS(skb, xtfs, pmtu, was_gso));

DEFINE_EVENT(iptfs_ingress_preq_event, iptfs_too_big,
	     TP_PROTO(struct sk_buff *skb, struct xfrm_iptfs_data *xtfs, u32 pmtu, u8 was_gso),
	     TP_ARGS(skb, xtfs, pmtu, was_gso));

DECLARE_EVENT_CLASS(iptfs_ingress_postq_event,
		    TP_PROTO(struct sk_buff *skb, u32 mtu, u16 blkoff, struct iphdr *iph),
		    TP_ARGS(skb, mtu, blkoff, iph),
		    TP_STRUCT__entry(__field(struct sk_buff *, skb)
				     __field(u32, skb_len)
				     __field(u32, data_len)
				     __field(u32, mtu)
				     __field(u32, proto_seq)
				     __field(u16, blkoff)
				     __field(u8, proto)),
		    TP_fast_assign(__entry->skb = skb;
				   __entry->skb_len = skb->len;
				   __entry->data_len = skb->data_len;
				   __entry->mtu = mtu;
				   __entry->blkoff = blkoff;
				   __entry->proto = iph ? __trace_ip_proto(iph) : 0;
				   __entry->proto_seq = iph ? __trace_ip_proto_seq(iph) : 0;
			    ),
		    TP_printk("INGRPSTQ: skb=%p len=%u data_len=%u mtu=%u blkoff=%u proto=%u proto_seq=%u",
			      __entry->skb, __entry->skb_len, __entry->data_len, __entry->mtu,
			      __entry->blkoff, __entry->proto, __entry->proto_seq));

DEFINE_EVENT(iptfs_ingress_postq_event, iptfs_first_dequeue,
	     TP_PROTO(struct sk_buff *skb, u32 mtu, u16 blkoff,
		      struct iphdr *iph),
	     TP_ARGS(skb, mtu, blkoff, iph));

DEFINE_EVENT(iptfs_ingress_postq_event, iptfs_first_fragmenting,
	     TP_PROTO(struct sk_buff *skb, u32 mtu, u16 blkoff,
		      struct iphdr *iph),
	     TP_ARGS(skb, mtu, blkoff, iph));

DEFINE_EVENT(iptfs_ingress_postq_event, iptfs_first_final_fragment,
	     TP_PROTO(struct sk_buff *skb, u32 mtu, u16 blkoff,
		      struct iphdr *iph),
	     TP_ARGS(skb, mtu, blkoff, iph));

DEFINE_EVENT(iptfs_ingress_postq_event, iptfs_first_toobig,
	     TP_PROTO(struct sk_buff *skb, u32 mtu, u16 blkoff,
		      struct iphdr *iph),
	     TP_ARGS(skb, mtu, blkoff, iph));

TRACE_EVENT(iptfs_ingress_nth_peek,
	    TP_PROTO(struct sk_buff *skb, u32 remaining),
	    TP_ARGS(skb, remaining),
	    TP_STRUCT__entry(__field(struct sk_buff *, skb)
			     __field(u32, skb_len)
			     __field(u32, remaining)),
	    TP_fast_assign(__entry->skb = skb;
			   __entry->skb_len = skb->len;
			   __entry->remaining = remaining;
		    ),
	    TP_printk("INGRPSTQ: NTHPEEK: skb=%p len=%u remaining=%u",
		      __entry->skb, __entry->skb_len, __entry->remaining));

TRACE_EVENT(iptfs_ingress_nth_add, TP_PROTO(struct sk_buff *skb, u8 share_ok),
	    TP_ARGS(skb, share_ok),
	    TP_STRUCT__entry(__field(struct sk_buff *, skb)
			     __field(u32, skb_len)
			     __field(u32, data_len)
			     __field(u8, share_ok)
			     __field(u8, head_frag)
			     __field(u8, pp_recycle)
			     __field(u8, cloned)
			     __field(u8, shared)
			     __field(u8, nr_frags)
			     __field(u8, frag_list)
		    ),
	    TP_fast_assign(__entry->skb = skb;
			   __entry->skb_len = skb->len;
			   __entry->data_len = skb->data_len;
			   __entry->share_ok = share_ok;
			   __entry->head_frag = skb->head_frag;
			   __entry->pp_recycle = skb->pp_recycle;
			   __entry->cloned = skb_cloned(skb);
			   __entry->shared = skb_shared(skb);
			   __entry->nr_frags = skb_shinfo(skb)->nr_frags;
			   __entry->frag_list = (bool)skb_shinfo(skb)->frag_list;
		    ),
	    TP_printk("INGRPSTQ: NTHADD: skb=%p len=%u data_len=%u share_ok=%u head_frag=%u pp_recycle=%u cloned=%u shared=%u nr_frags=%u frag_list=%u",
		      __entry->skb, __entry->skb_len, __entry->data_len, __entry->share_ok,
		      __entry->head_frag, __entry->pp_recycle, __entry->cloned, __entry->shared,
		      __entry->nr_frags, __entry->frag_list));

DECLARE_EVENT_CLASS(iptfs_timer_event,
		    TP_PROTO(struct xfrm_iptfs_data *xtfs, u64 time_val),
		    TP_ARGS(xtfs, time_val),
		    TP_STRUCT__entry(__field(u64, time_val)
				     __field(u64, set_time)),
		    TP_fast_assign(__entry->time_val = time_val;
				   __entry->set_time = xtfs->iptfs_settime;
			    ),
		    TP_printk("TIMER: set_time=%llu time_val=%llu",
			      __entry->set_time, __entry->time_val));

DEFINE_EVENT(iptfs_timer_event, iptfs_timer_start,
	     TP_PROTO(struct xfrm_iptfs_data *xtfs, u64 time_val),
	     TP_ARGS(xtfs, time_val));

DEFINE_EVENT(iptfs_timer_event, iptfs_timer_expire,
	     TP_PROTO(struct xfrm_iptfs_data *xtfs, u64 time_val),
	     TP_ARGS(xtfs, time_val));

#endif /* _TRACE_IPTFS_H */

/* This part must be outside protection */
#undef TRACE_INCLUDE_PATH
#define TRACE_INCLUDE_PATH ../../net/xfrm
#undef TRACE_INCLUDE_FILE
#define TRACE_INCLUDE_FILE trace_iptfs
#include <trace/define_trace.h>