Commit 37e65dc1 authored by David S. Miller's avatar David S. Miller
Browse files

Merge tag 'rxrpc-rewrite-20170105' of... 

Merge tag 'rxrpc-rewrite-20170105' of git://git.kernel.org/pub/scm/linux/kernel/git/dhowells/linux-fs



David Howells says:

====================
rxrpc: Update tracing and proc interfaces

This set of patches fixes and extends tracing:

 (1) Fix the handling of enum-to-string translations so that external
     tracing tools can make use of it by using TRACE_DEFINE_ENUM.

 (2) Extend a couple of tracepoints to export some extra available
     information and add three new tracepoints to allow monitoring of
     received DATA packets, call disconnection and improper/implicit call
     termination.

and adds a bit more procfs-exported information:

 (3) Show a call's hard-ACK cursors in /proc/net/rxrpc_calls.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 5e6eb456 3e018daf

include/trace/events/rxrpc.h

+492 −26
Original line number Diff line number Diff line
@@ -16,6 +16,386 @@ 


#include <linux/tracepoint.h>



/*

 * Define enums for tracing information.

 *

 * These should all be kept sorted, making it easier to match the string

 * mapping tables further on.

 */

#ifndef __RXRPC_DECLARE_TRACE_ENUMS_ONCE_ONLY

#define __RXRPC_DECLARE_TRACE_ENUMS_ONCE_ONLY



enum rxrpc_skb_trace {

	rxrpc_skb_rx_cleaned,

	rxrpc_skb_rx_freed,

	rxrpc_skb_rx_got,

	rxrpc_skb_rx_lost,

	rxrpc_skb_rx_purged,

	rxrpc_skb_rx_received,

	rxrpc_skb_rx_rotated,

	rxrpc_skb_rx_seen,

	rxrpc_skb_tx_cleaned,

	rxrpc_skb_tx_freed,

	rxrpc_skb_tx_got,

	rxrpc_skb_tx_new,

	rxrpc_skb_tx_rotated,

	rxrpc_skb_tx_seen,

};



enum rxrpc_conn_trace {

	rxrpc_conn_got,

	rxrpc_conn_new_client,

	rxrpc_conn_new_service,

	rxrpc_conn_put_client,

	rxrpc_conn_put_service,

	rxrpc_conn_queued,

	rxrpc_conn_seen,

};



enum rxrpc_client_trace {

	rxrpc_client_activate_chans,

	rxrpc_client_alloc,

	rxrpc_client_chan_activate,

	rxrpc_client_chan_disconnect,

	rxrpc_client_chan_pass,

	rxrpc_client_chan_unstarted,

	rxrpc_client_cleanup,

	rxrpc_client_count,

	rxrpc_client_discard,

	rxrpc_client_duplicate,

	rxrpc_client_exposed,

	rxrpc_client_replace,

	rxrpc_client_to_active,

	rxrpc_client_to_culled,

	rxrpc_client_to_idle,

	rxrpc_client_to_inactive,

	rxrpc_client_to_upgrade,

	rxrpc_client_to_waiting,

	rxrpc_client_uncount,

};



enum rxrpc_call_trace {

	rxrpc_call_connected,

	rxrpc_call_error,

	rxrpc_call_got,

	rxrpc_call_got_kernel,

	rxrpc_call_got_userid,

	rxrpc_call_new_client,

	rxrpc_call_new_service,

	rxrpc_call_put,

	rxrpc_call_put_kernel,

	rxrpc_call_put_noqueue,

	rxrpc_call_put_userid,

	rxrpc_call_queued,

	rxrpc_call_queued_ref,

	rxrpc_call_release,

	rxrpc_call_seen,

};



enum rxrpc_transmit_trace {

	rxrpc_transmit_await_reply,

	rxrpc_transmit_end,

	rxrpc_transmit_queue,

	rxrpc_transmit_queue_last,

	rxrpc_transmit_rotate,

	rxrpc_transmit_rotate_last,

	rxrpc_transmit_wait,

};



enum rxrpc_receive_trace {

	rxrpc_receive_end,

	rxrpc_receive_front,

	rxrpc_receive_incoming,

	rxrpc_receive_queue,

	rxrpc_receive_queue_last,

	rxrpc_receive_rotate,

};



enum rxrpc_recvmsg_trace {

	rxrpc_recvmsg_cont,

	rxrpc_recvmsg_data_return,

	rxrpc_recvmsg_dequeue,

	rxrpc_recvmsg_enter,

	rxrpc_recvmsg_full,

	rxrpc_recvmsg_hole,

	rxrpc_recvmsg_next,

	rxrpc_recvmsg_return,

	rxrpc_recvmsg_terminal,

	rxrpc_recvmsg_to_be_accepted,

	rxrpc_recvmsg_wait,

};



enum rxrpc_rtt_tx_trace {

	rxrpc_rtt_tx_data,

	rxrpc_rtt_tx_ping,

};



enum rxrpc_rtt_rx_trace {

	rxrpc_rtt_rx_ping_response,

	rxrpc_rtt_rx_requested_ack,

};



enum rxrpc_timer_trace {

	rxrpc_timer_begin,

	rxrpc_timer_expired,

	rxrpc_timer_init_for_reply,

	rxrpc_timer_init_for_send_reply,

	rxrpc_timer_set_for_ack,

	rxrpc_timer_set_for_ping,

	rxrpc_timer_set_for_resend,

	rxrpc_timer_set_for_send,

};



enum rxrpc_propose_ack_trace {

	rxrpc_propose_ack_client_tx_end,

	rxrpc_propose_ack_input_data,

	rxrpc_propose_ack_ping_for_lost_ack,

	rxrpc_propose_ack_ping_for_lost_reply,

	rxrpc_propose_ack_ping_for_params,

	rxrpc_propose_ack_processing_op,

	rxrpc_propose_ack_respond_to_ack,

	rxrpc_propose_ack_respond_to_ping,

	rxrpc_propose_ack_retry_tx,

	rxrpc_propose_ack_rotate_rx,

	rxrpc_propose_ack_terminal_ack,

};



enum rxrpc_propose_ack_outcome {

	rxrpc_propose_ack_subsume,

	rxrpc_propose_ack_update,

	rxrpc_propose_ack_use,

};



enum rxrpc_congest_change {

	rxrpc_cong_begin_retransmission,

	rxrpc_cong_cleared_nacks,

	rxrpc_cong_new_low_nack,

	rxrpc_cong_no_change,

	rxrpc_cong_progress,

	rxrpc_cong_retransmit_again,

	rxrpc_cong_rtt_window_end,

	rxrpc_cong_saw_nack,

};



#endif /* end __RXRPC_DECLARE_TRACE_ENUMS_ONCE_ONLY */



/*

 * Declare tracing information enums and their string mappings for display.

 */

#define rxrpc_skb_traces \

	EM(rxrpc_skb_rx_cleaned,		"Rx CLN") \

	EM(rxrpc_skb_rx_freed,			"Rx FRE") \

	EM(rxrpc_skb_rx_got,			"Rx GOT") \

	EM(rxrpc_skb_rx_lost,			"Rx *L*") \

	EM(rxrpc_skb_rx_purged,			"Rx PUR") \

	EM(rxrpc_skb_rx_received,		"Rx RCV") \

	EM(rxrpc_skb_rx_rotated,		"Rx ROT") \

	EM(rxrpc_skb_rx_seen,			"Rx SEE") \

	EM(rxrpc_skb_tx_cleaned,		"Tx CLN") \

	EM(rxrpc_skb_tx_freed,			"Tx FRE") \

	EM(rxrpc_skb_tx_got,			"Tx GOT") \

	EM(rxrpc_skb_tx_new,			"Tx NEW") \

	EM(rxrpc_skb_tx_rotated,		"Tx ROT") \

	E_(rxrpc_skb_tx_seen,			"Tx SEE")



#define rxrpc_conn_traces \

	EM(rxrpc_conn_got,			"GOT") \

	EM(rxrpc_conn_new_client,		"NWc") \

	EM(rxrpc_conn_new_service,		"NWs") \

	EM(rxrpc_conn_put_client,		"PTc") \

	EM(rxrpc_conn_put_service,		"PTs") \

	EM(rxrpc_conn_queued,			"QUE") \

	E_(rxrpc_conn_seen,			"SEE")



#define rxrpc_client_traces \

	EM(rxrpc_client_activate_chans,		"Activa") \

	EM(rxrpc_client_alloc,			"Alloc ") \

	EM(rxrpc_client_chan_activate,		"ChActv") \

	EM(rxrpc_client_chan_disconnect,	"ChDisc") \

	EM(rxrpc_client_chan_pass,		"ChPass") \

	EM(rxrpc_client_chan_unstarted,		"ChUnst") \

	EM(rxrpc_client_cleanup,		"Clean ") \

	EM(rxrpc_client_count,			"Count ") \

	EM(rxrpc_client_discard,		"Discar") \

	EM(rxrpc_client_duplicate,		"Duplic") \

	EM(rxrpc_client_exposed,		"Expose") \

	EM(rxrpc_client_replace,		"Replac") \

	EM(rxrpc_client_to_active,		"->Actv") \

	EM(rxrpc_client_to_culled,		"->Cull") \

	EM(rxrpc_client_to_idle,		"->Idle") \

	EM(rxrpc_client_to_inactive,		"->Inac") \

	EM(rxrpc_client_to_upgrade,		"->Upgd") \

	EM(rxrpc_client_to_waiting,		"->Wait") \

	E_(rxrpc_client_uncount,		"Uncoun")



#define rxrpc_conn_cache_states \

	EM(RXRPC_CONN_CLIENT_INACTIVE,		"Inac") \

	EM(RXRPC_CONN_CLIENT_WAITING,		"Wait") \

	EM(RXRPC_CONN_CLIENT_ACTIVE,		"Actv") \

	EM(RXRPC_CONN_CLIENT_CULLED,		"Cull") \

	E_(RXRPC_CONN_CLIENT_IDLE,		"Idle") \



#define rxrpc_call_traces \

	EM(rxrpc_call_connected,		"CON") \

	EM(rxrpc_call_error,			"*E*") \

	EM(rxrpc_call_got,			"GOT") \

	EM(rxrpc_call_got_kernel,		"Gke") \

	EM(rxrpc_call_got_userid,		"Gus") \

	EM(rxrpc_call_new_client,		"NWc") \

	EM(rxrpc_call_new_service,		"NWs") \

	EM(rxrpc_call_put,			"PUT") \

	EM(rxrpc_call_put_kernel,		"Pke") \

	EM(rxrpc_call_put_noqueue,		"PNQ") \

	EM(rxrpc_call_put_userid,		"Pus") \

	EM(rxrpc_call_queued,			"QUE") \

	EM(rxrpc_call_queued_ref,		"QUR") \

	EM(rxrpc_call_release,			"RLS") \

	E_(rxrpc_call_seen,			"SEE")



#define rxrpc_transmit_traces \

	EM(rxrpc_transmit_await_reply,		"AWR") \

	EM(rxrpc_transmit_end,			"END") \

	EM(rxrpc_transmit_queue,		"QUE") \

	EM(rxrpc_transmit_queue_last,		"QLS") \

	EM(rxrpc_transmit_rotate,		"ROT") \

	EM(rxrpc_transmit_rotate_last,		"RLS") \

	E_(rxrpc_transmit_wait,			"WAI")



#define rxrpc_receive_traces \

	EM(rxrpc_receive_end,			"END") \

	EM(rxrpc_receive_front,			"FRN") \

	EM(rxrpc_receive_incoming,		"INC") \

	EM(rxrpc_receive_queue,			"QUE") \

	EM(rxrpc_receive_queue_last,		"QLS") \

	E_(rxrpc_receive_rotate,		"ROT")



#define rxrpc_recvmsg_traces \

	EM(rxrpc_recvmsg_cont,			"CONT") \

	EM(rxrpc_recvmsg_data_return,		"DATA") \

	EM(rxrpc_recvmsg_dequeue,		"DEQU") \

	EM(rxrpc_recvmsg_enter,			"ENTR") \

	EM(rxrpc_recvmsg_full,			"FULL") \

	EM(rxrpc_recvmsg_hole,			"HOLE") \

	EM(rxrpc_recvmsg_next,			"NEXT") \

	EM(rxrpc_recvmsg_return,		"RETN") \

	EM(rxrpc_recvmsg_terminal,		"TERM") \

	EM(rxrpc_recvmsg_to_be_accepted,	"TBAC") \

	E_(rxrpc_recvmsg_wait,			"WAIT")



#define rxrpc_rtt_tx_traces \

	EM(rxrpc_rtt_tx_data,			"DATA") \

	E_(rxrpc_rtt_tx_ping,			"PING")



#define rxrpc_rtt_rx_traces \

	EM(rxrpc_rtt_rx_ping_response,		"PONG") \

	E_(rxrpc_rtt_rx_requested_ack,		"RACK")



#define rxrpc_timer_traces \

	EM(rxrpc_timer_begin,			"Begin ") \

	EM(rxrpc_timer_expired,			"*EXPR*") \

	EM(rxrpc_timer_init_for_reply,		"IniRpl") \

	EM(rxrpc_timer_init_for_send_reply,	"SndRpl") \

	EM(rxrpc_timer_set_for_ack,		"SetAck") \

	EM(rxrpc_timer_set_for_ping,		"SetPng") \

	EM(rxrpc_timer_set_for_resend,		"SetRTx") \

	E_(rxrpc_timer_set_for_send,		"SetTx ")



#define rxrpc_propose_ack_traces \

	EM(rxrpc_propose_ack_client_tx_end,	"ClTxEnd") \

	EM(rxrpc_propose_ack_input_data,	"DataIn ") \

	EM(rxrpc_propose_ack_ping_for_lost_ack,	"LostAck") \

	EM(rxrpc_propose_ack_ping_for_lost_reply, "LostRpl") \

	EM(rxrpc_propose_ack_ping_for_params,	"Params ") \

	EM(rxrpc_propose_ack_processing_op,	"ProcOp ") \

	EM(rxrpc_propose_ack_respond_to_ack,	"Rsp2Ack") \

	EM(rxrpc_propose_ack_respond_to_ping,	"Rsp2Png") \

	EM(rxrpc_propose_ack_retry_tx,		"RetryTx") \

	EM(rxrpc_propose_ack_rotate_rx,		"RxAck  ") \

	E_(rxrpc_propose_ack_terminal_ack,	"ClTerm ")



#define rxrpc_propose_ack_outcomes \

	EM(rxrpc_propose_ack_subsume,		" Subsume") \

	EM(rxrpc_propose_ack_update,		" Update") \

	E_(rxrpc_propose_ack_use,		"")



#define rxrpc_congest_modes \

	EM(RXRPC_CALL_CONGEST_AVOIDANCE,	"CongAvoid") \

	EM(RXRPC_CALL_FAST_RETRANSMIT,		"FastReTx ") \

	EM(RXRPC_CALL_PACKET_LOSS,		"PktLoss  ") \

	E_(RXRPC_CALL_SLOW_START,		"SlowStart")



#define rxrpc_congest_changes \

	EM(rxrpc_cong_begin_retransmission,	" Retrans") \

	EM(rxrpc_cong_cleared_nacks,		" Cleared") \

	EM(rxrpc_cong_new_low_nack,		" NewLowN") \

	EM(rxrpc_cong_no_change,		"") \

	EM(rxrpc_cong_progress,			" Progres") \

	EM(rxrpc_cong_retransmit_again,		" ReTxAgn") \

	EM(rxrpc_cong_rtt_window_end,		" RttWinE") \

	E_(rxrpc_cong_saw_nack,			" SawNack")



#define rxrpc_pkts \

	EM(0,					"?00") \

	EM(RXRPC_PACKET_TYPE_DATA,		"DATA") \

	EM(RXRPC_PACKET_TYPE_ACK,		"ACK") \

	EM(RXRPC_PACKET_TYPE_BUSY,		"BUSY") \

	EM(RXRPC_PACKET_TYPE_ABORT,		"ABORT") \

	EM(RXRPC_PACKET_TYPE_ACKALL,		"ACKALL") \

	EM(RXRPC_PACKET_TYPE_CHALLENGE,		"CHALL") \

	EM(RXRPC_PACKET_TYPE_RESPONSE,		"RESP") \

	EM(RXRPC_PACKET_TYPE_DEBUG,		"DEBUG") \

	EM(9,					"?09") \

	EM(10,					"?10") \

	EM(11,					"?11") \

	EM(12,					"?12") \

	EM(RXRPC_PACKET_TYPE_VERSION,		"VERSION") \

	EM(14,					"?14") \

	E_(15,					"?15")



#define rxrpc_ack_names \

	EM(0,					"-0-") \

	EM(RXRPC_ACK_REQUESTED,			"REQ") \

	EM(RXRPC_ACK_DUPLICATE,			"DUP") \

	EM(RXRPC_ACK_OUT_OF_SEQUENCE,		"OOS") \

	EM(RXRPC_ACK_EXCEEDS_WINDOW,		"WIN") \

	EM(RXRPC_ACK_NOSPACE,			"MEM") \

	EM(RXRPC_ACK_PING,			"PNG") \

	EM(RXRPC_ACK_PING_RESPONSE,		"PNR") \

	EM(RXRPC_ACK_DELAY,			"DLY") \

	EM(RXRPC_ACK_IDLE,			"IDL") \

	E_(RXRPC_ACK__INVALID,			"-?-")



/*

 * Export enum symbols via userspace.

 */

#undef EM

#undef E_

#define EM(a, b) TRACE_DEFINE_ENUM(a);

#define E_(a, b) TRACE_DEFINE_ENUM(a);



rxrpc_skb_traces;

rxrpc_conn_traces;

rxrpc_client_traces;

rxrpc_call_traces;

rxrpc_transmit_traces;

rxrpc_receive_traces;

rxrpc_recvmsg_traces;

rxrpc_rtt_tx_traces;

rxrpc_rtt_rx_traces;

rxrpc_timer_traces;

rxrpc_propose_ack_traces;

rxrpc_propose_ack_outcomes;

rxrpc_congest_changes;



/*

 * Now redefine the EM() and E_() macros to map the enums to the strings that

 * will be printed in the output.

 */

#undef EM

#undef E_

#define EM(a, b)	{ a, b },

#define E_(a, b)	{ a, b }



TRACE_EVENT(rxrpc_conn,

	    TP_PROTO(struct rxrpc_connection *conn, enum rxrpc_conn_trace op,

		     int usage, const void *where),
@@ -38,7 +418,7 @@ TRACE_EVENT(rxrpc_conn, 


	    TP_printk("C=%p %s u=%d sp=%pSR",

		      __entry->conn,

		      rxrpc_conn_traces[__entry->op],

		      __print_symbolic(__entry->op, rxrpc_conn_traces),

		      __entry->usage,

		      __entry->where)

	    );
@@ -70,8 +450,8 @@ TRACE_EVENT(rxrpc_client, 
	    TP_printk("C=%p h=%2d %s %s i=%08x u=%d",

		      __entry->conn,

		      __entry->channel,

		      rxrpc_client_traces[__entry->op],

		      rxrpc_conn_cache_states[__entry->cs],

		      __print_symbolic(__entry->op, rxrpc_client_traces),

		      __print_symbolic(__entry->cs, rxrpc_conn_cache_states),

		      __entry->cid,

		      __entry->usage)

	    );
@@ -100,7 +480,7 @@ TRACE_EVENT(rxrpc_call, 


	    TP_printk("c=%p %s u=%d sp=%pSR a=%p",

		      __entry->call,

		      rxrpc_call_traces[__entry->op],

		      __print_symbolic(__entry->op, rxrpc_call_traces),

		      __entry->usage,

		      __entry->where,

		      __entry->aux)
@@ -130,7 +510,7 @@ TRACE_EVENT(rxrpc_skb, 


	    TP_printk("s=%p %s u=%d m=%d p=%pSR",

		      __entry->skb,

		      rxrpc_skb_traces[__entry->op],

		      __print_symbolic(__entry->op, rxrpc_skb_traces),

		      __entry->usage,

		      __entry->mod_count,

		      __entry->where)
@@ -154,7 +534,8 @@ TRACE_EVENT(rxrpc_rx_packet, 
		      __entry->hdr.callNumber, __entry->hdr.serviceId,

		      __entry->hdr.serial, __entry->hdr.seq,

		      __entry->hdr.type, __entry->hdr.flags,

		      __entry->hdr.type <= 15 ? rxrpc_pkts[__entry->hdr.type] : "?UNK")

		      __entry->hdr.type <= 15 ?

		      __print_symbolic(__entry->hdr.type, rxrpc_pkts) : "?UNK")

	    );



TRACE_EVENT(rxrpc_rx_done,
@@ -214,6 +595,7 @@ TRACE_EVENT(rxrpc_transmit, 
		    __field(enum rxrpc_transmit_trace,	why		)

		    __field(rxrpc_seq_t,		tx_hard_ack	)

		    __field(rxrpc_seq_t,		tx_top		)

		    __field(int,			tx_winsize	)

			     ),



	    TP_fast_assign(
@@ -221,38 +603,81 @@ TRACE_EVENT(rxrpc_transmit, 
		    __entry->why = why;

		    __entry->tx_hard_ack = call->tx_hard_ack;

		    __entry->tx_top = call->tx_top;

		    __entry->tx_winsize = call->tx_winsize;

			   ),



	    TP_printk("c=%p %s f=%08x n=%u",

	    TP_printk("c=%p %s f=%08x n=%u/%u",

		      __entry->call,

		      rxrpc_transmit_traces[__entry->why],

		      __print_symbolic(__entry->why, rxrpc_transmit_traces),

		      __entry->tx_hard_ack + 1,

		      __entry->tx_top - __entry->tx_hard_ack)

		      __entry->tx_top - __entry->tx_hard_ack,

		      __entry->tx_winsize)

	    );



TRACE_EVENT(rxrpc_rx_data,

	    TP_PROTO(struct rxrpc_call *call, rxrpc_seq_t seq,

		     rxrpc_serial_t serial, u8 flags, u8 anno),



	    TP_ARGS(call, seq, serial, flags, anno),



	    TP_STRUCT__entry(

		    __field(struct rxrpc_call *,	call		)

		    __field(rxrpc_seq_t,		seq		)

		    __field(rxrpc_serial_t,		serial		)

		    __field(u8,				flags		)

		    __field(u8,				anno		)

			     ),



	    TP_fast_assign(

		    __entry->call = call;

		    __entry->seq = seq;

		    __entry->serial = serial;

		    __entry->flags = flags;

		    __entry->anno = anno;

			   ),



	    TP_printk("c=%p DATA %08x q=%08x fl=%02x a=%02x",

		      __entry->call,

		      __entry->serial,

		      __entry->seq,

		      __entry->flags,

		      __entry->anno)

	    );



TRACE_EVENT(rxrpc_rx_ack,

	    TP_PROTO(struct rxrpc_call *call, rxrpc_seq_t first, u8 reason, u8 n_acks),

	    TP_PROTO(struct rxrpc_call *call,

		     rxrpc_serial_t serial, rxrpc_serial_t ack_serial,

		     rxrpc_seq_t first, rxrpc_seq_t prev, u8 reason, u8 n_acks),



	    TP_ARGS(call, first, reason, n_acks),

	    TP_ARGS(call, serial, ack_serial, first, prev, reason, n_acks),



	    TP_STRUCT__entry(

		    __field(struct rxrpc_call *,	call		)

		    __field(rxrpc_serial_t,		serial		)

		    __field(rxrpc_serial_t,		ack_serial	)

		    __field(rxrpc_seq_t,		first		)

		    __field(rxrpc_seq_t,		prev		)

		    __field(u8,				reason		)

		    __field(u8,				n_acks		)

			     ),



	    TP_fast_assign(

		    __entry->call = call;

		    __entry->serial = serial;

		    __entry->ack_serial = ack_serial;

		    __entry->first = first;

		    __entry->prev = prev;

		    __entry->reason = reason;

		    __entry->n_acks = n_acks;

			   ),



	    TP_printk("c=%p %s f=%08x n=%u",

	    TP_printk("c=%p %08x %s r=%08x f=%08x p=%08x n=%u",

		      __entry->call,

		      rxrpc_ack_names[__entry->reason],

		      __entry->serial,

		      __print_symbolic(__entry->reason, rxrpc_ack_names),

		      __entry->ack_serial,

		      __entry->first,

		      __entry->prev,

		      __entry->n_acks)

	    );
@@ -317,7 +742,7 @@ TRACE_EVENT(rxrpc_tx_ack, 
	    TP_printk(" c=%p ACK  %08x %s f=%08x r=%08x n=%u",

		      __entry->call,

		      __entry->serial,

		      rxrpc_ack_names[__entry->reason],

		      __print_symbolic(__entry->reason, rxrpc_ack_names),

		      __entry->ack_first,

		      __entry->ack_serial,

		      __entry->n_acks)
@@ -349,7 +774,7 @@ TRACE_EVENT(rxrpc_receive, 


	    TP_printk("c=%p %s r=%08x q=%08x w=%08x-%08x",

		      __entry->call,

		      rxrpc_receive_traces[__entry->why],

		      __print_symbolic(__entry->why, rxrpc_receive_traces),

		      __entry->serial,

		      __entry->seq,

		      __entry->hard_ack,
@@ -383,7 +808,7 @@ TRACE_EVENT(rxrpc_recvmsg, 


	    TP_printk("c=%p %s q=%08x o=%u l=%u ret=%d",

		      __entry->call,

		      rxrpc_recvmsg_traces[__entry->why],

		      __print_symbolic(__entry->why, rxrpc_recvmsg_traces),

		      __entry->seq,

		      __entry->offset,

		      __entry->len,
@@ -410,7 +835,7 @@ TRACE_EVENT(rxrpc_rtt_tx, 


	    TP_printk("c=%p %s sr=%08x",

		      __entry->call,

		      rxrpc_rtt_tx_traces[__entry->why],

		      __print_symbolic(__entry->why, rxrpc_rtt_tx_traces),

		      __entry->send_serial)

	    );
@@ -443,7 +868,7 @@ TRACE_EVENT(rxrpc_rtt_rx, 


	    TP_printk("c=%p %s sr=%08x rr=%08x rtt=%lld nr=%u avg=%lld",

		      __entry->call,

		      rxrpc_rtt_rx_traces[__entry->why],

		      __print_symbolic(__entry->why, rxrpc_rtt_rx_traces),

		      __entry->send_serial,

		      __entry->resp_serial,

		      __entry->rtt,
@@ -481,7 +906,7 @@ TRACE_EVENT(rxrpc_timer, 


	    TP_printk("c=%p %s x=%lld a=%lld r=%lld t=%ld",

		      __entry->call,

		      rxrpc_timer_traces[__entry->why],

		      __print_symbolic(__entry->why, rxrpc_timer_traces),

		      ktime_to_ns(ktime_sub(__entry->expire_at, __entry->now)),

		      ktime_to_ns(ktime_sub(__entry->ack_at, __entry->now)),

		      ktime_to_ns(ktime_sub(__entry->resend_at, __entry->now)),
@@ -506,7 +931,8 @@ TRACE_EVENT(rxrpc_rx_lose, 
		      __entry->hdr.callNumber, __entry->hdr.serviceId,

		      __entry->hdr.serial, __entry->hdr.seq,

		      __entry->hdr.type, __entry->hdr.flags,

		      __entry->hdr.type <= 15 ? rxrpc_pkts[__entry->hdr.type] : "?UNK")

		      __entry->hdr.type <= 15 ?

		      __print_symbolic(__entry->hdr.type, rxrpc_pkts) : "?UNK")

	    );



TRACE_EVENT(rxrpc_propose_ack,
@@ -539,12 +965,12 @@ TRACE_EVENT(rxrpc_propose_ack, 


	    TP_printk("c=%p %s %s r=%08x i=%u b=%u%s",

		      __entry->call,

		      rxrpc_propose_ack_traces[__entry->why],

		      rxrpc_ack_names[__entry->ack_reason],

		      __print_symbolic(__entry->why, rxrpc_propose_ack_traces),

		      __print_symbolic(__entry->ack_reason, rxrpc_ack_names),

		      __entry->serial,

		      __entry->immediate,

		      __entry->background,

		      rxrpc_propose_ack_outcomes[__entry->outcome])

		      __print_symbolic(__entry->outcome, rxrpc_propose_ack_outcomes))

	    );



TRACE_EVENT(rxrpc_retransmit,
@@ -603,9 +1029,9 @@ TRACE_EVENT(rxrpc_congest, 
	    TP_printk("c=%p %08x %s %08x %s cw=%u ss=%u nr=%u,%u nw=%u,%u r=%u b=%u u=%u d=%u l=%x%s%s%s",

		      __entry->call,

		      __entry->ack_serial,

		      rxrpc_ack_names[__entry->sum.ack_reason],

		      __print_symbolic(__entry->sum.ack_reason, rxrpc_ack_names),

		      __entry->hard_ack,

		      rxrpc_congest_modes[__entry->sum.mode],

		      __print_symbolic(__entry->sum.mode, rxrpc_congest_modes),

		      __entry->sum.cwnd,

		      __entry->sum.ssthresh,

		      __entry->sum.nr_acks, __entry->sum.nr_nacks,
@@ -615,10 +1041,50 @@ TRACE_EVENT(rxrpc_congest, 
		      __entry->sum.cumulative_acks,

		      __entry->sum.dup_acks,

		      __entry->lowest_nak, __entry->sum.new_low_nack ? "!" : "",

		      rxrpc_congest_changes[__entry->change],

		      __print_symbolic(__entry->change, rxrpc_congest_changes),

		      __entry->sum.retrans_timeo ? " rTxTo" : "")

	    );



TRACE_EVENT(rxrpc_disconnect_call,

	    TP_PROTO(struct rxrpc_call *call),



	    TP_ARGS(call),



	    TP_STRUCT__entry(

		    __field(struct rxrpc_call *,	call		)

		    __field(u32,			abort_code	)

			     ),



	    TP_fast_assign(

		    __entry->call = call;

		    __entry->abort_code = call->abort_code;

			   ),



	    TP_printk("c=%p ab=%08x",

		      __entry->call,

		      __entry->abort_code)

	    );



TRACE_EVENT(rxrpc_improper_term,

	    TP_PROTO(struct rxrpc_call *call),



	    TP_ARGS(call),



	    TP_STRUCT__entry(

		    __field(struct rxrpc_call *,	call		)

		    __field(u32,			abort_code	)

			     ),



	    TP_fast_assign(

		    __entry->call = call;

		    __entry->abort_code = call->abort_code;

			   ),



	    TP_printk("c=%p ab=%08x",

		      __entry->call,

		      __entry->abort_code)

	    );



#endif /* _TRACE_RXRPC_H */



/* This part must be outside protection */

net/rxrpc/ar-internal.h

+0 −194
Original line number Diff line number Diff line
@@ -593,200 +593,6 @@ struct rxrpc_ack_summary { 
	u8			cumulative_acks;

};



enum rxrpc_skb_trace {

	rxrpc_skb_rx_cleaned,

	rxrpc_skb_rx_freed,

	rxrpc_skb_rx_got,

	rxrpc_skb_rx_lost,

	rxrpc_skb_rx_received,

	rxrpc_skb_rx_rotated,

	rxrpc_skb_rx_purged,

	rxrpc_skb_rx_seen,

	rxrpc_skb_tx_cleaned,

	rxrpc_skb_tx_freed,

	rxrpc_skb_tx_got,

	rxrpc_skb_tx_new,

	rxrpc_skb_tx_rotated,

	rxrpc_skb_tx_seen,

	rxrpc_skb__nr_trace

};



extern const char rxrpc_skb_traces[rxrpc_skb__nr_trace][7];



enum rxrpc_conn_trace {

	rxrpc_conn_new_client,

	rxrpc_conn_new_service,

	rxrpc_conn_queued,

	rxrpc_conn_seen,

	rxrpc_conn_got,

	rxrpc_conn_put_client,

	rxrpc_conn_put_service,

	rxrpc_conn__nr_trace

};



extern const char rxrpc_conn_traces[rxrpc_conn__nr_trace][4];



enum rxrpc_client_trace {

	rxrpc_client_activate_chans,

	rxrpc_client_alloc,

	rxrpc_client_chan_activate,

	rxrpc_client_chan_disconnect,

	rxrpc_client_chan_pass,

	rxrpc_client_chan_unstarted,

	rxrpc_client_cleanup,

	rxrpc_client_count,

	rxrpc_client_discard,

	rxrpc_client_duplicate,

	rxrpc_client_exposed,

	rxrpc_client_replace,

	rxrpc_client_to_active,

	rxrpc_client_to_culled,

	rxrpc_client_to_idle,

	rxrpc_client_to_inactive,

	rxrpc_client_to_waiting,

	rxrpc_client_uncount,

	rxrpc_client__nr_trace

};



extern const char rxrpc_client_traces[rxrpc_client__nr_trace][7];

extern const char rxrpc_conn_cache_states[RXRPC_CONN__NR_CACHE_STATES][5];



enum rxrpc_call_trace {

	rxrpc_call_new_client,

	rxrpc_call_new_service,

	rxrpc_call_queued,

	rxrpc_call_queued_ref,

	rxrpc_call_seen,

	rxrpc_call_connected,

	rxrpc_call_release,

	rxrpc_call_got,

	rxrpc_call_got_userid,

	rxrpc_call_got_kernel,

	rxrpc_call_put,

	rxrpc_call_put_userid,

	rxrpc_call_put_kernel,

	rxrpc_call_put_noqueue,

	rxrpc_call_error,

	rxrpc_call__nr_trace

};



extern const char rxrpc_call_traces[rxrpc_call__nr_trace][4];



enum rxrpc_transmit_trace {

	rxrpc_transmit_wait,

	rxrpc_transmit_queue,

	rxrpc_transmit_queue_last,

	rxrpc_transmit_rotate,

	rxrpc_transmit_rotate_last,

	rxrpc_transmit_await_reply,

	rxrpc_transmit_end,

	rxrpc_transmit__nr_trace

};



extern const char rxrpc_transmit_traces[rxrpc_transmit__nr_trace][4];



enum rxrpc_receive_trace {

	rxrpc_receive_incoming,

	rxrpc_receive_queue,

	rxrpc_receive_queue_last,

	rxrpc_receive_front,

	rxrpc_receive_rotate,

	rxrpc_receive_end,

	rxrpc_receive__nr_trace

};



extern const char rxrpc_receive_traces[rxrpc_receive__nr_trace][4];



enum rxrpc_recvmsg_trace {

	rxrpc_recvmsg_enter,

	rxrpc_recvmsg_wait,

	rxrpc_recvmsg_dequeue,

	rxrpc_recvmsg_hole,

	rxrpc_recvmsg_next,

	rxrpc_recvmsg_cont,

	rxrpc_recvmsg_full,

	rxrpc_recvmsg_data_return,

	rxrpc_recvmsg_terminal,

	rxrpc_recvmsg_to_be_accepted,

	rxrpc_recvmsg_return,

	rxrpc_recvmsg__nr_trace

};



extern const char rxrpc_recvmsg_traces[rxrpc_recvmsg__nr_trace][5];



enum rxrpc_rtt_tx_trace {

	rxrpc_rtt_tx_ping,

	rxrpc_rtt_tx_data,

	rxrpc_rtt_tx__nr_trace

};



extern const char rxrpc_rtt_tx_traces[rxrpc_rtt_tx__nr_trace][5];



enum rxrpc_rtt_rx_trace {

	rxrpc_rtt_rx_ping_response,

	rxrpc_rtt_rx_requested_ack,

	rxrpc_rtt_rx__nr_trace

};



extern const char rxrpc_rtt_rx_traces[rxrpc_rtt_rx__nr_trace][5];



enum rxrpc_timer_trace {

	rxrpc_timer_begin,

	rxrpc_timer_init_for_reply,

	rxrpc_timer_init_for_send_reply,

	rxrpc_timer_expired,

	rxrpc_timer_set_for_ack,

	rxrpc_timer_set_for_ping,

	rxrpc_timer_set_for_resend,

	rxrpc_timer_set_for_send,

	rxrpc_timer__nr_trace

};



extern const char rxrpc_timer_traces[rxrpc_timer__nr_trace][8];



enum rxrpc_propose_ack_trace {

	rxrpc_propose_ack_client_tx_end,

	rxrpc_propose_ack_input_data,

	rxrpc_propose_ack_ping_for_lost_ack,

	rxrpc_propose_ack_ping_for_lost_reply,

	rxrpc_propose_ack_ping_for_params,

	rxrpc_propose_ack_processing_op,

	rxrpc_propose_ack_respond_to_ack,

	rxrpc_propose_ack_respond_to_ping,

	rxrpc_propose_ack_retry_tx,

	rxrpc_propose_ack_rotate_rx,

	rxrpc_propose_ack_terminal_ack,

	rxrpc_propose_ack__nr_trace

};



enum rxrpc_propose_ack_outcome {

	rxrpc_propose_ack_use,

	rxrpc_propose_ack_update,

	rxrpc_propose_ack_subsume,

	rxrpc_propose_ack__nr_outcomes

};



extern const char rxrpc_propose_ack_traces[rxrpc_propose_ack__nr_trace][8];

extern const char *const rxrpc_propose_ack_outcomes[rxrpc_propose_ack__nr_outcomes];



enum rxrpc_congest_change {

	rxrpc_cong_begin_retransmission,

	rxrpc_cong_cleared_nacks,

	rxrpc_cong_new_low_nack,

	rxrpc_cong_no_change,

	rxrpc_cong_progress,

	rxrpc_cong_retransmit_again,

	rxrpc_cong_rtt_window_end,

	rxrpc_cong_saw_nack,

	rxrpc_congest__nr_change

};



extern const char rxrpc_congest_modes[NR__RXRPC_CONGEST_MODES][10];

extern const char rxrpc_congest_changes[rxrpc_congest__nr_change][9];



extern const char *const rxrpc_pkts[];

extern const char rxrpc_ack_names[RXRPC_ACK__INVALID + 1][4];



#include <trace/events/rxrpc.h>



/*

net/rxrpc/call_object.c

+0 −18
Original line number Diff line number Diff line
@@ -43,24 +43,6 @@ const char *const rxrpc_call_completions[NR__RXRPC_CALL_COMPLETIONS] = { 
	[RXRPC_CALL_NETWORK_ERROR]		= "NetError",

};



const char rxrpc_call_traces[rxrpc_call__nr_trace][4] = {

	[rxrpc_call_new_client]		= "NWc",

	[rxrpc_call_new_service]	= "NWs",

	[rxrpc_call_queued]		= "QUE",

	[rxrpc_call_queued_ref]		= "QUR",

	[rxrpc_call_connected]		= "CON",

	[rxrpc_call_release]		= "RLS",

	[rxrpc_call_seen]		= "SEE",

	[rxrpc_call_got]		= "GOT",

	[rxrpc_call_got_userid]		= "Gus",

	[rxrpc_call_got_kernel]		= "Gke",

	[rxrpc_call_put]		= "PUT",

	[rxrpc_call_put_userid]		= "Pus",

	[rxrpc_call_put_kernel]		= "Pke",

	[rxrpc_call_put_noqueue]	= "PNQ",

	[rxrpc_call_error]		= "*E*",

};



struct kmem_cache *rxrpc_call_jar;

LIST_HEAD(rxrpc_calls);

DEFINE_RWLOCK(rxrpc_call_lock);

net/rxrpc/conn_client.c

+0 −8

File changed.

Preview size limit exceeded, changes collapsed.

net/rxrpc/conn_object.c

+1 −0

File changed.

Preview size limit exceeded, changes collapsed.

CRA Git | Maintained and supported by SUSTech CRA and CCSE