Commit 9a36a6bc authored by David Howells's avatar David Howells
Browse files

rxrpc: trace: Don't use __builtin_return_address for sk_buff tracing 



In rxrpc tracing, use enums to generate lists of points of interest rather
than __builtin_return_address() for the sk_buff tracepoint.

Signed-off-by: default avatarDavid Howells <dhowells@redhat.com>
cc: Marc Dionne <marc.dionne@auristor.com>
cc: linux-afs@lists.infradead.org
parent fa3492ab

include/trace/events/rxrpc.h

+33 −24
Original line number Diff line number Diff line
@@ -17,19 +17,31 @@ 
 * Declare tracing information enums and their string mappings for display.

 */

#define rxrpc_skb_traces \

	EM(rxrpc_skb_ack,			"ACK") \

	EM(rxrpc_skb_cleaned,			"CLN") \

	EM(rxrpc_skb_cloned_jumbo,		"CLJ") \

	EM(rxrpc_skb_freed,			"FRE") \

	EM(rxrpc_skb_got,			"GOT") \

	EM(rxrpc_skb_lost,			"*L*") \

	EM(rxrpc_skb_new,			"NEW") \

	EM(rxrpc_skb_purged,			"PUR") \

	EM(rxrpc_skb_received,			"RCV") \

	EM(rxrpc_skb_rotated,			"ROT") \

	EM(rxrpc_skb_seen,			"SEE") \

	EM(rxrpc_skb_unshared,			"UNS") \

	E_(rxrpc_skb_unshared_nomem,		"US0")

	EM(rxrpc_skb_eaten_by_unshare,		"ETN unshare  ") \

	EM(rxrpc_skb_eaten_by_unshare_nomem,	"ETN unshar-nm") \

	EM(rxrpc_skb_get_ack,			"GET ack      ") \

	EM(rxrpc_skb_get_conn_work,		"GET conn-work") \

	EM(rxrpc_skb_get_to_recvmsg,		"GET to-recv  ") \

	EM(rxrpc_skb_get_to_recvmsg_oos,	"GET to-recv-o") \

	EM(rxrpc_skb_new_encap_rcv,		"NEW encap-rcv") \

	EM(rxrpc_skb_new_error_report,		"NEW error-rpt") \

	EM(rxrpc_skb_new_jumbo_subpacket,	"NEW jumbo-sub") \

	EM(rxrpc_skb_new_unshared,		"NEW unshared ") \

	EM(rxrpc_skb_put_ack,			"PUT ack      ") \

	EM(rxrpc_skb_put_conn_work,		"PUT conn-work") \

	EM(rxrpc_skb_put_error_report,		"PUT error-rep") \

	EM(rxrpc_skb_put_input,			"PUT input    ") \

	EM(rxrpc_skb_put_jumbo_subpacket,	"PUT jumbo-sub") \

	EM(rxrpc_skb_put_lose,			"PUT lose     ") \

	EM(rxrpc_skb_put_purge,			"PUT purge    ") \

	EM(rxrpc_skb_put_rotate,		"PUT rotate   ") \

	EM(rxrpc_skb_put_unknown,		"PUT unknown  ") \

	EM(rxrpc_skb_see_conn_work,		"SEE conn-work") \

	EM(rxrpc_skb_see_local_work,		"SEE locl-work") \

	EM(rxrpc_skb_see_recvmsg,		"SEE recvmsg  ") \

	EM(rxrpc_skb_see_reject,		"SEE reject   ") \

	EM(rxrpc_skb_see_rotate,		"SEE rotate   ") \

	E_(rxrpc_skb_see_version,		"SEE version  ")



#define rxrpc_local_traces \

	EM(rxrpc_local_free,			"FREE        ") \
@@ -582,33 +594,30 @@ TRACE_EVENT(rxrpc_call, 
	    );



TRACE_EVENT(rxrpc_skb,

	    TP_PROTO(struct sk_buff *skb, enum rxrpc_skb_trace op,

		     int usage, int mod_count, const void *where),

	    TP_PROTO(struct sk_buff *skb, int usage, int mod_count,

		     enum rxrpc_skb_trace why),



	    TP_ARGS(skb, op, usage, mod_count, where),

	    TP_ARGS(skb, usage, mod_count, why),



	    TP_STRUCT__entry(

		    __field(struct sk_buff *,		skb		)

		    __field(enum rxrpc_skb_trace,	op		)

		    __field(int,			usage		)

		    __field(int,			mod_count	)

		    __field(const void *,		where		)

		    __field(enum rxrpc_skb_trace,	why		)

			     ),



	    TP_fast_assign(

		    __entry->skb = skb;

		    __entry->op = op;

		    __entry->usage = usage;

		    __entry->mod_count = mod_count;

		    __entry->where = where;

		    __entry->why = why;

			   ),



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

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

		      __entry->skb,

		      __print_symbolic(__entry->op, rxrpc_skb_traces),

		      __print_symbolic(__entry->why, rxrpc_skb_traces),

		      __entry->usage,

		      __entry->mod_count,

		      __entry->where)

		      __entry->mod_count)

	    );



TRACE_EVENT(rxrpc_rx_packet,

net/rxrpc/call_event.c

+2 −2
Original line number Diff line number Diff line
@@ -153,7 +153,7 @@ static void rxrpc_resend(struct rxrpc_call *call, unsigned long now_j) 
		spin_lock_bh(&call->acks_ack_lock);

		ack_skb = call->acks_soft_tbl;

		if (ack_skb) {

			rxrpc_get_skb(ack_skb, rxrpc_skb_ack);

			rxrpc_get_skb(ack_skb, rxrpc_skb_get_ack);

			ack = (void *)ack_skb->data + sizeof(struct rxrpc_wire_header);

		}

		spin_unlock_bh(&call->acks_ack_lock);
@@ -251,7 +251,7 @@ static void rxrpc_resend(struct rxrpc_call *call, unsigned long now_j) 
no_further_resend:

	spin_unlock(&call->tx_lock);

no_resend:

	rxrpc_free_skb(ack_skb, rxrpc_skb_freed);

	rxrpc_free_skb(ack_skb, rxrpc_skb_put_ack);



	resend_at = nsecs_to_jiffies(ktime_to_ns(ktime_sub(now, oldest)));

	resend_at += jiffies + rxrpc_get_rto_backoff(call->peer,

net/rxrpc/call_object.c

+1 −1
Original line number Diff line number Diff line
@@ -663,7 +663,7 @@ void rxrpc_cleanup_call(struct rxrpc_call *call) 
		rxrpc_put_txbuf(txb, rxrpc_txbuf_put_cleaned);

	}

	rxrpc_put_txbuf(call->tx_pending, rxrpc_txbuf_put_cleaned);

	rxrpc_free_skb(call->acks_soft_tbl, rxrpc_skb_cleaned);

	rxrpc_free_skb(call->acks_soft_tbl, rxrpc_skb_put_ack);



	call_rcu(&call->rcu, rxrpc_rcu_destroy_call);

}

net/rxrpc/conn_event.c

+3 −3
Original line number Diff line number Diff line
@@ -437,7 +437,7 @@ static void rxrpc_do_process_connection(struct rxrpc_connection *conn) 
	/* go through the conn-level event packets, releasing the ref on this

	 * connection that each one has when we've finished with it */

	while ((skb = skb_dequeue(&conn->rx_queue))) {

		rxrpc_see_skb(skb, rxrpc_skb_seen);

		rxrpc_see_skb(skb, rxrpc_skb_see_conn_work);

		ret = rxrpc_process_event(conn, skb, &abort_code);

		switch (ret) {

		case -EPROTO:
@@ -449,7 +449,7 @@ static void rxrpc_do_process_connection(struct rxrpc_connection *conn) 
			goto requeue_and_leave;

		case -ECONNABORTED:

		default:

			rxrpc_free_skb(skb, rxrpc_skb_freed);

			rxrpc_free_skb(skb, rxrpc_skb_put_conn_work);

			break;

		}

	}
@@ -463,7 +463,7 @@ static void rxrpc_do_process_connection(struct rxrpc_connection *conn) 
protocol_error:

	if (rxrpc_abort_connection(conn, ret, abort_code) < 0)

		goto requeue_and_leave;

	rxrpc_free_skb(skb, rxrpc_skb_freed);

	rxrpc_free_skb(skb, rxrpc_skb_put_conn_work);

	return;

}

net/rxrpc/input.c

+18 −18
Original line number Diff line number Diff line
@@ -485,7 +485,7 @@ static void rxrpc_input_data_one(struct rxrpc_call *call, struct sk_buff *skb) 
					rxrpc_propose_ack_input_data);



err_free:

	rxrpc_free_skb(skb, rxrpc_skb_freed);

	rxrpc_free_skb(skb, rxrpc_skb_put_input);

}



/*
@@ -513,7 +513,7 @@ static bool rxrpc_input_split_jumbo(struct rxrpc_call *call, struct sk_buff *skb 
			kdebug("couldn't clone");

			return false;

		}

		rxrpc_new_skb(jskb, rxrpc_skb_cloned_jumbo);

		rxrpc_new_skb(jskb, rxrpc_skb_new_jumbo_subpacket);

		jsp = rxrpc_skb(jskb);

		jsp->offset = offset;

		jsp->len = RXRPC_JUMBO_DATALEN;
@@ -553,7 +553,7 @@ static void rxrpc_input_data(struct rxrpc_call *call, struct sk_buff *skb) 


	state = READ_ONCE(call->state);

	if (state >= RXRPC_CALL_COMPLETE) {

		rxrpc_free_skb(skb, rxrpc_skb_freed);

		rxrpc_free_skb(skb, rxrpc_skb_put_input);

		return;

	}
@@ -563,14 +563,14 @@ static void rxrpc_input_data(struct rxrpc_call *call, struct sk_buff *skb) 
	if (sp->hdr.securityIndex != 0) {

		struct sk_buff *nskb = skb_unshare(skb, GFP_ATOMIC);

		if (!nskb) {

			rxrpc_eaten_skb(skb, rxrpc_skb_unshared_nomem);

			rxrpc_eaten_skb(skb, rxrpc_skb_eaten_by_unshare_nomem);

			return;

		}



		if (nskb != skb) {

			rxrpc_eaten_skb(skb, rxrpc_skb_received);

			rxrpc_eaten_skb(skb, rxrpc_skb_eaten_by_unshare);

			skb = nskb;

			rxrpc_new_skb(skb, rxrpc_skb_unshared);

			rxrpc_new_skb(skb, rxrpc_skb_new_unshared);

			sp = rxrpc_skb(skb);

		}

	}
@@ -609,7 +609,7 @@ static void rxrpc_input_data(struct rxrpc_call *call, struct sk_buff *skb) 
	rxrpc_notify_socket(call);



	spin_unlock(&call->input_lock);

	rxrpc_free_skb(skb, rxrpc_skb_freed);

	rxrpc_free_skb(skb, rxrpc_skb_put_input);

	_leave(" [queued]");

}
@@ -994,8 +994,8 @@ static void rxrpc_input_ack(struct rxrpc_call *call, struct sk_buff *skb) 
out:

	spin_unlock(&call->input_lock);

out_not_locked:

	rxrpc_free_skb(skb_put, rxrpc_skb_freed);

	rxrpc_free_skb(skb_old, rxrpc_skb_freed);

	rxrpc_free_skb(skb_put, rxrpc_skb_put_input);

	rxrpc_free_skb(skb_old, rxrpc_skb_put_ack);

}



/*
@@ -1075,7 +1075,7 @@ static void rxrpc_input_call_packet(struct rxrpc_call *call, 
		break;

	}



	rxrpc_free_skb(skb, rxrpc_skb_freed);

	rxrpc_free_skb(skb, rxrpc_skb_put_input);

no_free:

	_leave("");

}
@@ -1137,7 +1137,7 @@ static void rxrpc_post_packet_to_local(struct rxrpc_local *local, 
		skb_queue_tail(&local->event_queue, skb);

		rxrpc_queue_local(local);

	} else {

		rxrpc_free_skb(skb, rxrpc_skb_freed);

		rxrpc_free_skb(skb, rxrpc_skb_put_input);

	}

}
@@ -1150,7 +1150,7 @@ static void rxrpc_reject_packet(struct rxrpc_local *local, struct sk_buff *skb) 
		skb_queue_tail(&local->reject_queue, skb);

		rxrpc_queue_local(local);

	} else {

		rxrpc_free_skb(skb, rxrpc_skb_freed);

		rxrpc_free_skb(skb, rxrpc_skb_put_input);

	}

}
@@ -1228,7 +1228,7 @@ int rxrpc_input_packet(struct sock *udp_sk, struct sk_buff *skb) 
	if (skb->tstamp == 0)

		skb->tstamp = ktime_get_real();



	rxrpc_new_skb(skb, rxrpc_skb_received);

	rxrpc_new_skb(skb, rxrpc_skb_new_encap_rcv);



	skb_pull(skb, sizeof(struct udphdr));
@@ -1245,7 +1245,7 @@ int rxrpc_input_packet(struct sock *udp_sk, struct sk_buff *skb) 
		static int lose;

		if ((lose++ & 7) == 7) {

			trace_rxrpc_rx_lose(sp);

			rxrpc_free_skb(skb, rxrpc_skb_lost);

			rxrpc_free_skb(skb, rxrpc_skb_put_lose);

			return 0;

		}

	}
@@ -1286,14 +1286,14 @@ int rxrpc_input_packet(struct sock *udp_sk, struct sk_buff *skb) 
		if (sp->hdr.securityIndex != 0) {

			struct sk_buff *nskb = skb_unshare(skb, GFP_ATOMIC);

			if (!nskb) {

				rxrpc_eaten_skb(skb, rxrpc_skb_unshared_nomem);

				rxrpc_eaten_skb(skb, rxrpc_skb_eaten_by_unshare_nomem);

				goto out;

			}



			if (nskb != skb) {

				rxrpc_eaten_skb(skb, rxrpc_skb_received);

				rxrpc_eaten_skb(skb, rxrpc_skb_eaten_by_unshare);

				skb = nskb;

				rxrpc_new_skb(skb, rxrpc_skb_unshared);

				rxrpc_new_skb(skb, rxrpc_skb_new_unshared);

				sp = rxrpc_skb(skb);

			}

		}
@@ -1434,7 +1434,7 @@ int rxrpc_input_packet(struct sock *udp_sk, struct sk_buff *skb) 
	goto out;



discard:

	rxrpc_free_skb(skb, rxrpc_skb_freed);

	rxrpc_free_skb(skb, rxrpc_skb_put_input);

out:

	trace_rxrpc_rx_done(0, 0);

	return 0;