Commit 31ffe249 authored by David S. Miller's avatar David S. Miller
Browse files

net: Temporarily backout SKB sources tracer. 



Steven Rostedt has suggested that Neil work with the tracing
folks, trying to use TRACE_EVENT as the mechanism for
implementation.  And if that doesn't workout we can investigate
other solutions such as that one which was tried here.

This reverts the following 2 commits:

5a165657
("net: skb ftracer - Add config option to enable new ftracer (v3)")

9ec04da7
("net: skb ftracer - Add actual ftrace code to kernel (v3)")

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent f656f398

kernel/trace/Kconfig

+0 −11
Original line number Diff line number Diff line
@@ -234,17 +234,6 @@ config BOOT_TRACER 
	  You must pass in initcall_debug and ftrace=initcall to the kernel

	  command line to enable this on bootup.



config SKB_SOURCES_TRACER

	bool "Trace skb source information"

	depends on NET

	select GENERIC_TRACER

	help

	   This tracer helps developers/sysadmins correlate skb allocation and

	   consumption.  The idea being that some processes will primarily consume data

	   that was allocated on certain numa nodes.  By being able to visualize which

	   nodes the data was allocated on, a sysadmin or developer can optimize the

	   scheduling of those processes to cut back on cross node chatter.



config TRACE_BRANCH_PROFILING

	bool

	select GENERIC_TRACER

kernel/trace/Makefile

+0 −1
Original line number Diff line number Diff line
@@ -49,7 +49,6 @@ obj-$(CONFIG_BLK_DEV_IO_TRACE) += blktrace.o 
ifeq ($(CONFIG_BLOCK),y)

obj-$(CONFIG_EVENT_TRACING) += blktrace.o

endif

obj-$(CONFIG_SKB_SOURCES_TRACER) += trace_skb_sources.o

obj-$(CONFIG_EVENT_TRACING) += trace_events.o

obj-$(CONFIG_EVENT_TRACING) += trace_export.o

obj-$(CONFIG_FTRACE_SYSCALLS) += trace_syscalls.o

kernel/trace/trace.h

+0 −19
Original line number Diff line number Diff line
@@ -11,7 +11,6 @@ 
#include <trace/boot.h>

#include <linux/kmemtrace.h>

#include <trace/power.h>

#include <trace/events/skb.h>



#include <linux/trace_seq.h>

#include <linux/ftrace_event.h>
@@ -41,7 +40,6 @@ enum trace_type { 
	TRACE_KMEM_FREE,

	TRACE_POWER,

	TRACE_BLK,

	TRACE_SKB_SOURCE,



	__TRACE_LAST_TYPE,

};
@@ -173,21 +171,6 @@ struct trace_power { 
	struct power_trace	state_data;

};



struct skb_record {

	pid_t pid;		/* pid of the copying process */

	int anid;		/* node where skb was allocated */

	int cnid;		/* node to which skb was copied in userspace */

	char ifname[IFNAMSIZ];	/* Name of the receiving interface */

	int rx_queue;		/* The rx queue the skb was received on */

	int ccpu;		/* Cpu the application got this frame from */

	int len;		/* length of the data copied */

};



struct trace_skb_event {

	struct trace_entry	ent;

	struct skb_record	event_data;

};



enum kmemtrace_type_id {

	KMEMTRACE_TYPE_KMALLOC = 0,	/* kmalloc() or kfree(). */

	KMEMTRACE_TYPE_CACHE,		/* kmem_cache_*(). */
@@ -340,8 +323,6 @@ extern void __ftrace_bad_type(void); 
			  TRACE_SYSCALL_ENTER);				\

		IF_ASSIGN(var, ent, struct syscall_trace_exit,		\

			  TRACE_SYSCALL_EXIT);				\

		IF_ASSIGN(var, ent, struct trace_skb_event,		\

			  TRACE_SKB_SOURCE);				\

		__ftrace_bad_type();					\

	} while (0)

kernel/trace/trace_skb_sources.c

deleted100644 → 0
+0 −154
Original line number Diff line number Diff line 
/*

 * ring buffer based tracer for analyzing per-socket skb sources

 *

 * Neil Horman <nhorman@tuxdriver.com>

 * Copyright (C) 2009

 *

 *

 */



#include <linux/init.h>

#include <linux/debugfs.h>

#include <trace/events/skb.h>

#include <linux/kallsyms.h>

#include <linux/module.h>

#include <linux/hardirq.h>

#include <linux/netdevice.h>

#include <net/sock.h>



#include "trace.h"

#include "trace_output.h"



EXPORT_TRACEPOINT_SYMBOL_GPL(skb_copy_datagram_iovec);



static struct trace_array *skb_trace;

static int __read_mostly trace_skb_source_enabled;



static void probe_skb_dequeue(const struct sk_buff *skb, int len)

{

	struct ring_buffer_event *event;

	struct trace_skb_event *entry;

	struct trace_array *tr = skb_trace;

	struct net_device *dev;



	if (!trace_skb_source_enabled)

		return;



	if (in_interrupt())

		return;



	event = trace_buffer_lock_reserve(tr, TRACE_SKB_SOURCE,

					  sizeof(*entry), 0, 0);

	if (!event)

		return;

	entry = ring_buffer_event_data(event);



	entry->event_data.pid = current->pid;

	entry->event_data.anid = page_to_nid(virt_to_page(skb->data));

	entry->event_data.cnid = cpu_to_node(smp_processor_id());

	entry->event_data.len = len;

	entry->event_data.rx_queue = skb->queue_mapping;

	entry->event_data.ccpu = smp_processor_id();



	dev = dev_get_by_index(sock_net(skb->sk), skb->iif);

	if (dev) {

		memcpy(entry->event_data.ifname, dev->name, IFNAMSIZ);

		dev_put(dev);

	} else {

		strcpy(entry->event_data.ifname, "Unknown");

	}



	trace_buffer_unlock_commit(tr, event, 0, 0);

}



static int tracing_skb_source_register(void)

{

	int ret;



	ret = register_trace_skb_copy_datagram_iovec(probe_skb_dequeue);

	if (ret)

		pr_info("skb source trace: Couldn't activate dequeue tracepoint");



	return ret;

}



static void start_skb_source_trace(struct trace_array *tr)

{

	trace_skb_source_enabled = 1;

}



static void stop_skb_source_trace(struct trace_array *tr)

{

	trace_skb_source_enabled = 0;

}



static void skb_source_trace_reset(struct trace_array *tr)

{

	trace_skb_source_enabled = 0;

	unregister_trace_skb_copy_datagram_iovec(probe_skb_dequeue);

}





static int skb_source_trace_init(struct trace_array *tr)

{

	int cpu;

	skb_trace = tr;



	trace_skb_source_enabled = 1;

	tracing_skb_source_register();



	for_each_cpu(cpu, cpu_possible_mask)

		tracing_reset(tr, cpu);

	return 0;

}



static enum print_line_t skb_source_print_line(struct trace_iterator *iter)

{

	int ret = 0;

	struct trace_entry *entry = iter->ent;

	struct trace_skb_event *event;

	struct skb_record *record;

	struct trace_seq *s = &iter->seq;



	trace_assign_type(event, entry);

	record = &event->event_data;

	if (entry->type != TRACE_SKB_SOURCE)

		return TRACE_TYPE_UNHANDLED;



	ret = trace_seq_printf(s, "	%d	%d	%d	%s	%d	%d	%d\n",

			record->pid,

			record->anid,

			record->cnid,

			record->ifname,

			record->rx_queue,

			record->ccpu,

			record->len);



	if (!ret)

		return TRACE_TYPE_PARTIAL_LINE;



	return TRACE_TYPE_HANDLED;

}



static void skb_source_print_header(struct seq_file *s)

{

	seq_puts(s, "#	PID	ANID	CNID	IFC	RXQ	CCPU	LEN\n");

	seq_puts(s, "#	 |	 |	 |	 |	 |	 |	 |\n");

}



static struct tracer skb_source_tracer __read_mostly =

{

	.name		= "skb_sources",

	.init		= skb_source_trace_init,

	.start		= start_skb_source_trace,

	.stop		= stop_skb_source_trace,

	.reset		= skb_source_trace_reset,

	.print_line	= skb_source_print_line,

	.print_header	= skb_source_print_header,

};



static int init_skb_source_trace(void)

{

	return register_tracer(&skb_source_tracer);

}

device_initcall(init_skb_source_trace);

CRA Git | Maintained and supported by SUSTech CRA and CCSE