Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 723cbe07 authored by Eduard - Gabriel Munteanu's avatar Eduard - Gabriel Munteanu Committed by Ingo Molnar
Browse files

kmemtrace: Remove the relay version of kmemtrace 



Impact: cleanup

kmemtrace now uses ftrace. This patch removes the relay version.

Signed-off-by: default avatarEduard - Gabriel Munteanu <eduard.munteanu@linux360.ro>
Signed-off-by: default avatarIngo Molnar <mingo@elte.hu>
parent f09eac90

kernel/trace/Kconfig

+0 −2
Original line number Diff line number Diff line
@@ -267,8 +267,6 @@ config HW_BRANCH_TRACER 
config KMEMTRACE

	bool "Trace SLAB allocations"

	select TRACING

	select MARKERS

	select RELAY

	help

	  kmemtrace provides tracing for slab allocator functions, such as

	  kmalloc, kfree, kmem_cache_alloc, kmem_cache_free etc.. Collected

mm/Makefile

+0 −1
Original line number Diff line number Diff line
@@ -35,4 +35,3 @@ obj-$(CONFIG_MIGRATION) += migrate.o 
obj-$(CONFIG_SMP) += allocpercpu.o

obj-$(CONFIG_QUICKLIST) += quicklist.o

obj-$(CONFIG_CGROUP_MEM_RES_CTLR) += memcontrol.o page_cgroup.o
 
obj-$(CONFIG_KMEMTRACE) += kmemtrace.o

mm/kmemtrace.c

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

 * Copyright (C) 2008 Pekka Enberg, Eduard - Gabriel Munteanu

 *

 * This file is released under GPL version 2.

 */



#include <linux/string.h>

#include <linux/debugfs.h>

#include <linux/relay.h>

#include <linux/module.h>

#include <linux/marker.h>

#include <linux/gfp.h>

#include <trace/kmemtrace.h>



#define KMEMTRACE_SUBBUF_SIZE		524288

#define KMEMTRACE_DEF_N_SUBBUFS		20



static struct rchan *kmemtrace_chan;

static u32 kmemtrace_buf_overruns;



static unsigned int kmemtrace_n_subbufs;



/* disabled by default */

static unsigned int kmemtrace_enabled;



/*

 * The sequence number is used for reordering kmemtrace packets

 * in userspace, since they are logged as per-CPU data.

 *

 * atomic_t should always be a 32-bit signed integer. Wraparound is not

 * likely to occur, but userspace can deal with it by expecting a certain

 * sequence number in the next packet that will be read.

 */

static atomic_t kmemtrace_seq_num;



#define KMEMTRACE_ABI_VERSION		1



static u32 kmemtrace_abi_version __read_mostly = KMEMTRACE_ABI_VERSION;



enum kmemtrace_event_id {

	KMEMTRACE_EVENT_ALLOC = 0,

	KMEMTRACE_EVENT_FREE,

};



struct kmemtrace_event {

	u8		event_id;

	u8		type_id;

	u16		event_size;

	s32		seq_num;

	u64		call_site;

	u64		ptr;

} __attribute__ ((__packed__));



struct kmemtrace_stats_alloc {

	u64		bytes_req;

	u64		bytes_alloc;

	u32		gfp_flags;

	s32		numa_node;

} __attribute__ ((__packed__));



static void kmemtrace_probe_alloc(void *probe_data, void *call_data,

				  const char *format, va_list *args)

{

	unsigned long flags;

	struct kmemtrace_event *ev;

	struct kmemtrace_stats_alloc *stats;

	void *buf;



	local_irq_save(flags);



	buf = relay_reserve(kmemtrace_chan,

			    sizeof(struct kmemtrace_event) +

			    sizeof(struct kmemtrace_stats_alloc));

	if (!buf)

		goto failed;



	/*

	 * Don't convert this to use structure initializers,

	 * C99 does not guarantee the rvalues evaluation order.

	 */



	ev = buf;

	ev->event_id = KMEMTRACE_EVENT_ALLOC;

	ev->type_id = va_arg(*args, int);

	ev->event_size = sizeof(struct kmemtrace_event) +

			 sizeof(struct kmemtrace_stats_alloc);

	ev->seq_num = atomic_add_return(1, &kmemtrace_seq_num);

	ev->call_site = va_arg(*args, unsigned long);

	ev->ptr = va_arg(*args, unsigned long);



	stats = buf + sizeof(struct kmemtrace_event);

	stats->bytes_req = va_arg(*args, unsigned long);

	stats->bytes_alloc = va_arg(*args, unsigned long);

	stats->gfp_flags = va_arg(*args, unsigned long);

	stats->numa_node = va_arg(*args, int);



failed:

	local_irq_restore(flags);

}



static void kmemtrace_probe_free(void *probe_data, void *call_data,

				 const char *format, va_list *args)

{

	unsigned long flags;

	struct kmemtrace_event *ev;



	local_irq_save(flags);



	ev = relay_reserve(kmemtrace_chan, sizeof(struct kmemtrace_event));

	if (!ev)

		goto failed;



	/*

	 * Don't convert this to use structure initializers,

	 * C99 does not guarantee the rvalues evaluation order.

	 */

	ev->event_id = KMEMTRACE_EVENT_FREE;

	ev->type_id = va_arg(*args, int);

	ev->event_size = sizeof(struct kmemtrace_event);

	ev->seq_num = atomic_add_return(1, &kmemtrace_seq_num);

	ev->call_site = va_arg(*args, unsigned long);

	ev->ptr = va_arg(*args, unsigned long);



failed:

	local_irq_restore(flags);

}



static struct dentry *

kmemtrace_create_buf_file(const char *filename, struct dentry *parent,

			  int mode, struct rchan_buf *buf, int *is_global)

{

	return debugfs_create_file(filename, mode, parent, buf,

				   &relay_file_operations);

}



static int kmemtrace_remove_buf_file(struct dentry *dentry)

{

	debugfs_remove(dentry);



	return 0;

}



static int kmemtrace_subbuf_start(struct rchan_buf *buf,

				  void *subbuf,

				  void *prev_subbuf,

				  size_t prev_padding)

{

	if (relay_buf_full(buf)) {

		/*

		 * We know it's not SMP-safe, but neither

		 * debugfs_create_u32() is.

		 */

		kmemtrace_buf_overruns++;

		return 0;

	}



	return 1;

}



static struct rchan_callbacks relay_callbacks = {

	.create_buf_file = kmemtrace_create_buf_file,

	.remove_buf_file = kmemtrace_remove_buf_file,

	.subbuf_start = kmemtrace_subbuf_start,

};



static struct dentry *kmemtrace_dir;

static struct dentry *kmemtrace_overruns_dentry;

static struct dentry *kmemtrace_abi_version_dentry;



static struct dentry *kmemtrace_enabled_dentry;



static int kmemtrace_start_probes(void)

{

	int err;



	err = marker_probe_register("kmemtrace_alloc", "type_id %d "

				    "call_site %lu ptr %lu "

				    "bytes_req %lu bytes_alloc %lu "

				    "gfp_flags %lu node %d",

				    kmemtrace_probe_alloc, NULL);

	if (err)

		return err;

	err = marker_probe_register("kmemtrace_free", "type_id %d "

				    "call_site %lu ptr %lu",

				    kmemtrace_probe_free, NULL);



	return err;

}



static void kmemtrace_stop_probes(void)

{

	marker_probe_unregister("kmemtrace_alloc",

				kmemtrace_probe_alloc, NULL);

	marker_probe_unregister("kmemtrace_free",

				kmemtrace_probe_free, NULL);

}



static int kmemtrace_enabled_get(void *data, u64 *val)

{

	*val = *((int *) data);



	return 0;

}



static int kmemtrace_enabled_set(void *data, u64 val)

{

	u64 old_val = kmemtrace_enabled;



	*((int *) data) = !!val;



	if (old_val == val)

		return 0;

	if (val)

		kmemtrace_start_probes();

	else

		kmemtrace_stop_probes();



	return 0;

}



DEFINE_SIMPLE_ATTRIBUTE(kmemtrace_enabled_fops,

			kmemtrace_enabled_get,

			kmemtrace_enabled_set, "%llu\n");



static void kmemtrace_cleanup(void)

{

	if (kmemtrace_enabled_dentry)

		debugfs_remove(kmemtrace_enabled_dentry);



	kmemtrace_stop_probes();



	if (kmemtrace_abi_version_dentry)

		debugfs_remove(kmemtrace_abi_version_dentry);

	if (kmemtrace_overruns_dentry)

		debugfs_remove(kmemtrace_overruns_dentry);



	relay_close(kmemtrace_chan);

	kmemtrace_chan = NULL;



	if (kmemtrace_dir)

		debugfs_remove(kmemtrace_dir);

}



static int __init kmemtrace_setup_late(void)

{

	if (!kmemtrace_chan)

		goto failed;



	kmemtrace_dir = debugfs_create_dir("kmemtrace", NULL);

	if (!kmemtrace_dir)

		goto cleanup;



	kmemtrace_abi_version_dentry =

		debugfs_create_u32("abi_version", S_IRUSR,

				   kmemtrace_dir, &kmemtrace_abi_version);

	kmemtrace_overruns_dentry =

		debugfs_create_u32("total_overruns", S_IRUSR,

				   kmemtrace_dir, &kmemtrace_buf_overruns);

	if (!kmemtrace_overruns_dentry || !kmemtrace_abi_version_dentry)

		goto cleanup;



	kmemtrace_enabled_dentry =

		debugfs_create_file("enabled", S_IRUSR | S_IWUSR,

				    kmemtrace_dir, &kmemtrace_enabled,

				    &kmemtrace_enabled_fops);

	if (!kmemtrace_enabled_dentry)

		goto cleanup;



	if (relay_late_setup_files(kmemtrace_chan, "cpu", kmemtrace_dir))

		goto cleanup;



	printk(KERN_INFO "kmemtrace: fully up.\n");



	return 0;



cleanup:

	kmemtrace_cleanup();

failed:

	return 1;

}

late_initcall(kmemtrace_setup_late);



static int __init kmemtrace_set_boot_enabled(char *str)

{

	if (!str)

		return -EINVAL;



	if (!strcmp(str, "yes"))

		kmemtrace_enabled = 1;

	else if (!strcmp(str, "no"))

		kmemtrace_enabled = 0;

	else

		return -EINVAL;



	return 0;

}

early_param("kmemtrace.enable", kmemtrace_set_boot_enabled);



static int __init kmemtrace_set_subbufs(char *str)

{

	get_option(&str, &kmemtrace_n_subbufs);

	return 0;

}

early_param("kmemtrace.subbufs", kmemtrace_set_subbufs);



void kmemtrace_init(void)

{

	if (!kmemtrace_n_subbufs)

		kmemtrace_n_subbufs = KMEMTRACE_DEF_N_SUBBUFS;



	kmemtrace_chan = relay_open(NULL, NULL, KMEMTRACE_SUBBUF_SIZE,

				    kmemtrace_n_subbufs, &relay_callbacks,

				    NULL);

	if (!kmemtrace_chan) {

		printk(KERN_ERR "kmemtrace: could not open relay channel.\n");

		return;

	}



	if (!kmemtrace_enabled) {

		printk(KERN_INFO "kmemtrace: disabled. Pass "

			"kemtrace.enable=yes as kernel parameter for "

			"boot-time tracing.\n");

		return;

	}

	if (kmemtrace_start_probes()) {

		printk(KERN_ERR "kmemtrace: could not register marker probes!\n");

		kmemtrace_cleanup();

		return;

	}



	printk(KERN_INFO "kmemtrace: enabled.\n");

}