linux/drivers/infiniband/hw/irdma/trace_cm.h

/* SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB */
/* Copyright (c) 2019 - 2021 Intel Corporation */
#if !defined(__TRACE_CM_H) || defined(TRACE_HEADER_MULTI_READ)
#define __TRACE_CM_H

#include <linux/tracepoint.h>
#include <linux/trace_seq.h>

#include "main.h"

const char *print_ip_addr(struct trace_seq *p, u32 *addr, u16 port, bool ivp4);
const char *parse_iw_event_type(enum iw_cm_event_type iw_type);
const char *parse_cm_event_type(enum irdma_cm_event_type cm_type);
const char *parse_cm_state(enum irdma_cm_node_state);
#define __print_ip_addr(addr, port, ipv4) …

#undef TRACE_SYSTEM
#define TRACE_SYSTEM …

TRACE_EVENT(irdma_create_listen,
	    TP_PROTO(struct irdma_device *iwdev, struct irdma_cm_info *cm_info),
	    TP_ARGS(iwdev, cm_info),
	    TP_STRUCT__entry(__field(struct irdma_device *, iwdev)
			     __dynamic_array(u32, laddr, 4)
			     __field(u16, lport)
			     __field(bool, ipv4)
		    ),
	    TP_fast_assign(__entry->iwdev = iwdev;
			   __entry->lport = cm_info->loc_port;
			   __entry->ipv4 = cm_info->ipv4;
			   memcpy(__get_dynamic_array(laddr),
				  cm_info->loc_addr, 4);
		    ),
	    TP_printk("iwdev=%p  loc: %s",
		      __entry->iwdev,
		      __print_ip_addr(__get_dynamic_array(laddr),
				      __entry->lport, __entry->ipv4)
		    )
);

TRACE_EVENT(irdma_dec_refcnt_listen,
	    TP_PROTO(struct irdma_cm_listener *listener, void *caller),
	    TP_ARGS(listener, caller),
	    TP_STRUCT__entry(__field(struct irdma_device *, iwdev)
		    __field(u32, refcnt)
		    __dynamic_array(u32, laddr, 4)
		    __field(u16, lport)
		    __field(bool, ipv4)
		    __field(void *, caller)
		    ),
	    TP_fast_assign(__entry->iwdev = listener->iwdev;
			   __entry->lport = listener->loc_port;
			   __entry->ipv4 = listener->ipv4;
			   memcpy(__get_dynamic_array(laddr),
				  listener->loc_addr, 4);
		    ),
	    TP_printk("iwdev=%p  caller=%pS  loc: %s",
		      __entry->iwdev,
		      __entry->caller,
		      __print_ip_addr(__get_dynamic_array(laddr),
				      __entry->lport, __entry->ipv4)
		    )
);

DECLARE_EVENT_CLASS(listener_template,
		    TP_PROTO(struct irdma_cm_listener *listener),
		    TP_ARGS(listener),
		    TP_STRUCT__entry(__field(struct irdma_device *, iwdev)
				     __field(u16, lport)
				     __field(u16, vlan_id)
				     __field(bool, ipv4)
				     __field(enum irdma_cm_listener_state,
					     state)
				     __dynamic_array(u32, laddr, 4)
			    ),
		    TP_fast_assign(__entry->iwdev = listener->iwdev;
				   __entry->lport = listener->loc_port;
				   __entry->vlan_id = listener->vlan_id;
				   __entry->ipv4 = listener->ipv4;
				   __entry->state = listener->listener_state;
				   memcpy(__get_dynamic_array(laddr),
					  listener->loc_addr, 4);
			    ),
		    TP_printk("iwdev=%p  vlan=%d  loc: %s",
			      __entry->iwdev,
			      __entry->vlan_id,
			      __print_ip_addr(__get_dynamic_array(laddr),
					      __entry->lport, __entry->ipv4)
			    )
);

DEFINE_EVENT(listener_template, irdma_find_listener,
	     TP_PROTO(struct irdma_cm_listener *listener),
	     TP_ARGS(listener));

DEFINE_EVENT(listener_template, irdma_del_multiple_qhash,
	     TP_PROTO(struct irdma_cm_listener *listener),
	     TP_ARGS(listener));

TRACE_EVENT(irdma_negotiate_mpa_v2,
	    TP_PROTO(struct irdma_cm_node *cm_node),
	    TP_ARGS(cm_node),
	    TP_STRUCT__entry(__field(struct irdma_cm_node *, cm_node)
			     __field(u16, ord_size)
			     __field(u16, ird_size)
		    ),
	    TP_fast_assign(__entry->cm_node = cm_node;
			   __entry->ord_size = cm_node->ord_size;
			   __entry->ird_size = cm_node->ird_size;
		    ),
	    TP_printk("MPVA2 Negotiated cm_node=%p ORD:[%d], IRD:[%d]",
		      __entry->cm_node,
		      __entry->ord_size,
		      __entry->ird_size
		    )
);

DECLARE_EVENT_CLASS(tos_template,
		    TP_PROTO(struct irdma_device *iwdev, u8 tos, u8 user_pri),
		    TP_ARGS(iwdev, tos, user_pri),
		    TP_STRUCT__entry(__field(struct irdma_device *, iwdev)
				     __field(u8, tos)
				     __field(u8, user_pri)
			    ),
		    TP_fast_assign(__entry->iwdev = iwdev;
				   __entry->tos = tos;
				   __entry->user_pri = user_pri;
			    ),
		    TP_printk("iwdev=%p  TOS:[%d]  UP:[%d]",
			      __entry->iwdev,
			      __entry->tos,
			      __entry->user_pri
			    )
);

DEFINE_EVENT(tos_template, irdma_listener_tos,
	     TP_PROTO(struct irdma_device *iwdev, u8 tos, u8 user_pri),
	     TP_ARGS(iwdev, tos, user_pri));

DEFINE_EVENT(tos_template, irdma_dcb_tos,
	     TP_PROTO(struct irdma_device *iwdev, u8 tos, u8 user_pri),
	     TP_ARGS(iwdev, tos, user_pri));

DECLARE_EVENT_CLASS(qhash_template,
		    TP_PROTO(struct irdma_device *iwdev,
			     struct irdma_cm_listener *listener,
			     const char *dev_addr),
		    TP_ARGS(iwdev, listener, dev_addr),
		    TP_STRUCT__entry(__field(struct irdma_device *, iwdev)
				     __field(u16, lport)
				     __field(u16, vlan_id)
				     __field(bool, ipv4)
				     __dynamic_array(u32, laddr, 4)
				     __dynamic_array(u32, mac, ETH_ALEN)
			    ),
		    TP_fast_assign(__entry->iwdev = iwdev;
				   __entry->lport = listener->loc_port;
				   __entry->vlan_id = listener->vlan_id;
				   __entry->ipv4 = listener->ipv4;
				   memcpy(__get_dynamic_array(laddr),
					  listener->loc_addr, 4);
				   ether_addr_copy(__get_dynamic_array(mac),
						   dev_addr);
			    ),
		    TP_printk("iwdev=%p  vlan=%d  MAC=%6phC  loc: %s",
			      __entry->iwdev,
			      __entry->vlan_id,
			      __get_dynamic_array(mac),
			      __print_ip_addr(__get_dynamic_array(laddr),
					      __entry->lport, __entry->ipv4)
		    )
);

DEFINE_EVENT(qhash_template, irdma_add_mqh_6,
	     TP_PROTO(struct irdma_device *iwdev,
		      struct irdma_cm_listener *listener,
		      const char *dev_addr),
	     TP_ARGS(iwdev, listener, dev_addr));

DEFINE_EVENT(qhash_template, irdma_add_mqh_4,
	     TP_PROTO(struct irdma_device *iwdev,
		      struct irdma_cm_listener *listener,
		      const char *dev_addr),
	     TP_ARGS(iwdev, listener, dev_addr));

TRACE_EVENT(irdma_addr_resolve,
	    TP_PROTO(struct irdma_device *iwdev, char *dev_addr),
	    TP_ARGS(iwdev, dev_addr),
	    TP_STRUCT__entry(__field(struct irdma_device *, iwdev)
		    __dynamic_array(u8, mac, ETH_ALEN)
		    ),
	    TP_fast_assign(__entry->iwdev = iwdev;
		    ether_addr_copy(__get_dynamic_array(mac), dev_addr);
		    ),
	    TP_printk("iwdev=%p   MAC=%6phC", __entry->iwdev,
		      __get_dynamic_array(mac)
		    )
);

TRACE_EVENT(irdma_send_cm_event,
	    TP_PROTO(struct irdma_cm_node *cm_node, struct iw_cm_id *cm_id,
		     enum iw_cm_event_type type, int status, void *caller),
	    TP_ARGS(cm_node, cm_id, type, status, caller),
	    TP_STRUCT__entry(__field(struct irdma_device *, iwdev)
			     __field(struct irdma_cm_node *, cm_node)
			     __field(struct iw_cm_id *, cm_id)
			     __field(u32, refcount)
			     __field(u16, lport)
			     __field(u16, rport)
			     __field(enum irdma_cm_node_state, state)
			     __field(bool, ipv4)
			     __field(u16, vlan_id)
			     __field(int, accel)
			     __field(enum iw_cm_event_type, type)
			     __field(int, status)
			     __field(void *, caller)
			     __dynamic_array(u32, laddr, 4)
			     __dynamic_array(u32, raddr, 4)
		    ),
	    TP_fast_assign(__entry->iwdev = cm_node->iwdev;
			   __entry->cm_node = cm_node;
			   __entry->cm_id = cm_id;
			   __entry->refcount = refcount_read(&cm_node->refcnt);
			   __entry->state = cm_node->state;
			   __entry->lport = cm_node->loc_port;
			   __entry->rport = cm_node->rem_port;
			   __entry->ipv4 = cm_node->ipv4;
			   __entry->vlan_id = cm_node->vlan_id;
			   __entry->accel = cm_node->accelerated;
			   __entry->type = type;
			   __entry->status = status;
			   __entry->caller = caller;
			   memcpy(__get_dynamic_array(laddr),
				  cm_node->loc_addr, 4);
			   memcpy(__get_dynamic_array(raddr),
				  cm_node->rem_addr, 4);
		    ),
	    TP_printk("iwdev=%p  caller=%pS  cm_id=%p  node=%p  refcnt=%d  vlan_id=%d  accel=%d  state=%s  event_type=%s  status=%d  loc: %s  rem: %s",
		      __entry->iwdev,
		      __entry->caller,
		      __entry->cm_id,
		      __entry->cm_node,
		      __entry->refcount,
		      __entry->vlan_id,
		      __entry->accel,
		      parse_cm_state(__entry->state),
		      parse_iw_event_type(__entry->type),
		      __entry->status,
		      __print_ip_addr(__get_dynamic_array(laddr),
				      __entry->lport, __entry->ipv4),
		      __print_ip_addr(__get_dynamic_array(raddr),
				      __entry->rport, __entry->ipv4)
		    )
);

TRACE_EVENT(irdma_send_cm_event_no_node,
	    TP_PROTO(struct iw_cm_id *cm_id, enum iw_cm_event_type type,
		     int status, void *caller),
	    TP_ARGS(cm_id, type, status, caller),
	    TP_STRUCT__entry(__field(struct iw_cm_id *, cm_id)
			     __field(enum iw_cm_event_type, type)
			     __field(int, status)
			     __field(void *, caller)
		    ),
	    TP_fast_assign(__entry->cm_id = cm_id;
			   __entry->type = type;
			   __entry->status = status;
			   __entry->caller = caller;
		    ),
	    TP_printk("cm_id=%p  caller=%pS  event_type=%s  status=%d",
		      __entry->cm_id,
		      __entry->caller,
		      parse_iw_event_type(__entry->type),
		      __entry->status
		    )
);

DECLARE_EVENT_CLASS(cm_node_template,
		    TP_PROTO(struct irdma_cm_node *cm_node,
			     enum irdma_cm_event_type type, void *caller),
		    TP_ARGS(cm_node, type, caller),
		    TP_STRUCT__entry(__field(struct irdma_device *, iwdev)
				     __field(struct irdma_cm_node *, cm_node)
				     __field(u32, refcount)
				     __field(u16, lport)
				     __field(u16, rport)
				     __field(enum irdma_cm_node_state, state)
				     __field(bool, ipv4)
				     __field(u16, vlan_id)
				     __field(int, accel)
				     __field(enum irdma_cm_event_type, type)
				     __field(void *, caller)
				     __dynamic_array(u32, laddr, 4)
				     __dynamic_array(u32, raddr, 4)
			    ),
		    TP_fast_assign(__entry->iwdev = cm_node->iwdev;
				   __entry->cm_node = cm_node;
				   __entry->refcount = refcount_read(&cm_node->refcnt);
				   __entry->state = cm_node->state;
				   __entry->lport = cm_node->loc_port;
				   __entry->rport = cm_node->rem_port;
				   __entry->ipv4 = cm_node->ipv4;
				   __entry->vlan_id = cm_node->vlan_id;
				   __entry->accel = cm_node->accelerated;
				   __entry->type = type;
				   __entry->caller = caller;
				   memcpy(__get_dynamic_array(laddr),
					  cm_node->loc_addr, 4);
				   memcpy(__get_dynamic_array(raddr),
					  cm_node->rem_addr, 4);
			    ),
		    TP_printk("iwdev=%p  caller=%pS  node=%p  refcnt=%d  vlan_id=%d  accel=%d  state=%s  event_type=%s  loc: %s  rem: %s",
			      __entry->iwdev,
			      __entry->caller,
			      __entry->cm_node,
			      __entry->refcount,
			      __entry->vlan_id,
			      __entry->accel,
			      parse_cm_state(__entry->state),
			      parse_cm_event_type(__entry->type),
			      __print_ip_addr(__get_dynamic_array(laddr),
					      __entry->lport, __entry->ipv4),
			      __print_ip_addr(__get_dynamic_array(raddr),
					      __entry->rport, __entry->ipv4)
		    )
);

DEFINE_EVENT(cm_node_template, irdma_create_event,
	     TP_PROTO(struct irdma_cm_node *cm_node,
		      enum irdma_cm_event_type type, void *caller),
	     TP_ARGS(cm_node, type, caller));

DEFINE_EVENT(cm_node_template, irdma_accept,
	     TP_PROTO(struct irdma_cm_node *cm_node,
		      enum irdma_cm_event_type type, void *caller),
	     TP_ARGS(cm_node, type, caller));

DEFINE_EVENT(cm_node_template, irdma_connect,
	     TP_PROTO(struct irdma_cm_node *cm_node,
		      enum irdma_cm_event_type type, void *caller),
	     TP_ARGS(cm_node, type, caller));

DEFINE_EVENT(cm_node_template, irdma_reject,
	     TP_PROTO(struct irdma_cm_node *cm_node,
		      enum irdma_cm_event_type type, void *caller),
	     TP_ARGS(cm_node, type, caller));

DEFINE_EVENT(cm_node_template, irdma_find_node,
	     TP_PROTO(struct irdma_cm_node *cm_node,
		      enum irdma_cm_event_type type, void *caller),
	     TP_ARGS(cm_node, type, caller));

DEFINE_EVENT(cm_node_template, irdma_send_reset,
	     TP_PROTO(struct irdma_cm_node *cm_node,
		      enum irdma_cm_event_type type, void *caller),
	     TP_ARGS(cm_node, type, caller));

DEFINE_EVENT(cm_node_template, irdma_rem_ref_cm_node,
	     TP_PROTO(struct irdma_cm_node *cm_node,
		      enum irdma_cm_event_type type, void *caller),
	     TP_ARGS(cm_node, type, caller));

DEFINE_EVENT(cm_node_template, irdma_cm_event_handler,
	     TP_PROTO(struct irdma_cm_node *cm_node,
		      enum irdma_cm_event_type type, void *caller),
	     TP_ARGS(cm_node, type, caller));

TRACE_EVENT(open_err_template,
	    TP_PROTO(struct irdma_cm_node *cm_node, bool reset, void *caller),
	    TP_ARGS(cm_node, reset, caller),
	    TP_STRUCT__entry(__field(struct irdma_device *, iwdev)
			     __field(struct irdma_cm_node *, cm_node)
			     __field(enum irdma_cm_node_state, state)
			     __field(bool, reset)
			     __field(void *, caller)
		    ),
	    TP_fast_assign(__entry->iwdev = cm_node->iwdev;
			   __entry->cm_node = cm_node;
			   __entry->state = cm_node->state;
			   __entry->reset = reset;
			   __entry->caller = caller;
		    ),
	    TP_printk("iwdev=%p  caller=%pS  node%p reset=%d  state=%s",
		      __entry->iwdev,
		      __entry->caller,
		      __entry->cm_node,
		      __entry->reset,
		      parse_cm_state(__entry->state)
		    )
);

DEFINE_EVENT(open_err_template, irdma_active_open_err,
	     TP_PROTO(struct irdma_cm_node *cm_node, bool reset, void *caller),
	     TP_ARGS(cm_node, reset, caller));

DEFINE_EVENT(open_err_template, irdma_passive_open_err,
	     TP_PROTO(struct irdma_cm_node *cm_node, bool reset, void *caller),
	     TP_ARGS(cm_node, reset, caller));

DECLARE_EVENT_CLASS(cm_node_ah_template,
		    TP_PROTO(struct irdma_cm_node *cm_node),
		    TP_ARGS(cm_node),
		    TP_STRUCT__entry(__field(struct irdma_device *, iwdev)
				     __field(struct irdma_cm_node *, cm_node)
				     __field(struct irdma_sc_ah *, ah)
				     __field(u32, refcount)
				     __field(u16, lport)
				     __field(u16, rport)
				     __field(enum irdma_cm_node_state, state)
				     __field(bool, ipv4)
				     __field(u16, vlan_id)
				     __field(int, accel)
				     __dynamic_array(u32, laddr, 4)
				     __dynamic_array(u32, raddr, 4)
			    ),
		    TP_fast_assign(__entry->iwdev = cm_node->iwdev;
				   __entry->cm_node = cm_node;
				   __entry->ah = cm_node->ah;
				   __entry->refcount = refcount_read(&cm_node->refcnt);
				   __entry->lport = cm_node->loc_port;
				   __entry->rport = cm_node->rem_port;
				   __entry->state = cm_node->state;
				   __entry->ipv4 = cm_node->ipv4;
				   __entry->vlan_id = cm_node->vlan_id;
				   __entry->accel = cm_node->accelerated;
				   memcpy(__get_dynamic_array(laddr),
					  cm_node->loc_addr, 4);
				   memcpy(__get_dynamic_array(raddr),
					  cm_node->rem_addr, 4);
			    ),
		    TP_printk("iwdev=%p  node=%p  ah=%p  refcnt=%d  vlan_id=%d  accel=%d  state=%s loc: %s  rem: %s",
			      __entry->iwdev,
			      __entry->cm_node,
			      __entry->ah,
			      __entry->refcount,
			      __entry->vlan_id,
			      __entry->accel,
			      parse_cm_state(__entry->state),
			      __print_ip_addr(__get_dynamic_array(laddr),
					      __entry->lport, __entry->ipv4),
			      __print_ip_addr(__get_dynamic_array(raddr),
					      __entry->rport, __entry->ipv4)
		    )
);

DEFINE_EVENT(cm_node_ah_template, irdma_cm_free_ah,
	     TP_PROTO(struct irdma_cm_node *cm_node),
	     TP_ARGS(cm_node));

DEFINE_EVENT(cm_node_ah_template, irdma_create_ah,
	     TP_PROTO(struct irdma_cm_node *cm_node),
	     TP_ARGS(cm_node));

#endif  /* __TRACE_CM_H */

#undef TRACE_INCLUDE_PATH
#undef TRACE_INCLUDE_FILE
#define TRACE_INCLUDE_PATH …
#define TRACE_INCLUDE_FILE …
#include <trace/define_trace.h>