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:

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

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

Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
David S. Miller 2009-08-26 16:32:37 -07:00
parent f656f39801
commit 31ffe249e5
4 changed files with 0 additions and 185 deletions

View file

@ -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

View file

@ -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

View file

@ -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)

View file

@ -1,154 +0,0 @@
/*
* 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);