[deliverable/linux.git] / arch / s390 / oprofile / init.c

/**
 * arch/s390/oprofile/init.c
 *
 * S390 Version
 *   Copyright (C) 2003 IBM Deutschland Entwicklung GmbH, IBM Corporation
 *   Author(s): Thomas Spatzier (tspat@de.ibm.com)
 *   Author(s): Mahesh Salgaonkar (mahesh@linux.vnet.ibm.com)
 *   Author(s): Heinz Graalfs (graalfs@linux.vnet.ibm.com)
 *
 * @remark Copyright 2002-2011 OProfile authors
 */

#include <linux/oprofile.h>
#include <linux/init.h>
#include <linux/errno.h>
#include <linux/oprofile.h>
#include <linux/errno.h>
#include <linux/fs.h>

#include "../../../drivers/oprofile/oprof.h"

extern void s390_backtrace(struct pt_regs * const regs, unsigned int depth);

#ifdef CONFIG_64BIT

#include "hwsampler.h"

#define DEFAULT_INTERVAL	4096

#define DEFAULT_SDBT_BLOCKS	1
#define DEFAULT_SDB_BLOCKS	511

static unsigned long oprofile_hw_interval = DEFAULT_INTERVAL;
static unsigned long oprofile_min_interval;
static unsigned long oprofile_max_interval;

static unsigned long oprofile_sdbt_blocks = DEFAULT_SDBT_BLOCKS;
static unsigned long oprofile_sdb_blocks = DEFAULT_SDB_BLOCKS;

static int hwsampler_file;
static int hwsampler_running;	/* start_mutex must be held to change */

static struct oprofile_operations timer_ops;

static int oprofile_hwsampler_start(void)
{
	int retval;

	hwsampler_running = hwsampler_file;

	if (!hwsampler_running)
		return timer_ops.start();

	retval = hwsampler_allocate(oprofile_sdbt_blocks, oprofile_sdb_blocks);
	if (retval)
		return retval;

	retval = hwsampler_start_all(oprofile_hw_interval);
	if (retval)
		hwsampler_deallocate();

	return retval;
}

static void oprofile_hwsampler_stop(void)
{
	if (!hwsampler_running) {
		timer_ops.stop();
		return;
	}

	hwsampler_stop_all();
	hwsampler_deallocate();
	return;
}

static ssize_t hwsampler_read(struct file *file, char __user *buf,
		size_t count, loff_t *offset)
{
	return oprofilefs_ulong_to_user(hwsampler_file, buf, count, offset);
}

static ssize_t hwsampler_write(struct file *file, char const __user *buf,
		size_t count, loff_t *offset)
{
	unsigned long val;
	int retval;

	if (*offset)
		return -EINVAL;

	retval = oprofilefs_ulong_from_user(&val, buf, count);
	if (retval)
		return retval;

	if (oprofile_started)
		/*
		 * save to do without locking as we set
		 * hwsampler_running in start() when start_mutex is
		 * held
		 */
		return -EBUSY;

	hwsampler_file = val;

	return count;
}

static const struct file_operations hwsampler_fops = {
	.read		= hwsampler_read,
	.write		= hwsampler_write,
};

static int oprofile_create_hwsampling_files(struct super_block *sb,
						struct dentry *root)
{
	struct dentry *hw_dir;

	/* reinitialize default values */
	hwsampler_file = 1;

	hw_dir = oprofilefs_mkdir(sb, root, "hwsampling");
	if (!hw_dir)
		return -EINVAL;

	oprofilefs_create_file(sb, hw_dir, "hwsampler", &hwsampler_fops);
	oprofilefs_create_ulong(sb, hw_dir, "hw_interval",
				&oprofile_hw_interval);
	oprofilefs_create_ro_ulong(sb, hw_dir, "hw_min_interval",
				&oprofile_min_interval);
	oprofilefs_create_ro_ulong(sb, hw_dir, "hw_max_interval",
				&oprofile_max_interval);
	oprofilefs_create_ulong(sb, hw_dir, "hw_sdbt_blocks",
				&oprofile_sdbt_blocks);

	return 0;
}

static int oprofile_hwsampler_init(struct oprofile_operations *ops)
{
	if (hwsampler_setup())
		return -ENODEV;

	/*
	 * create hwsampler files only if hwsampler_setup() succeeds.
	 */
	oprofile_min_interval = hwsampler_query_min_interval();
	if (oprofile_min_interval == 0)
		return -ENODEV;
	oprofile_max_interval = hwsampler_query_max_interval();
	if (oprofile_max_interval == 0)
		return -ENODEV;

	if (oprofile_timer_init(ops))
		return -ENODEV;

	printk(KERN_INFO "oprofile: using hardware sampling\n");

	memcpy(&timer_ops, ops, sizeof(timer_ops));

	ops->start = oprofile_hwsampler_start;
	ops->stop = oprofile_hwsampler_stop;
	ops->create_files = oprofile_create_hwsampling_files;

	return 0;
}

static void oprofile_hwsampler_exit(void)
{
	oprofile_timer_exit();
	hwsampler_shutdown();
}

#endif /* CONFIG_64BIT */

int __init oprofile_arch_init(struct oprofile_operations *ops)
{
	ops->backtrace = s390_backtrace;

#ifdef CONFIG_64BIT
	return oprofile_hwsampler_init(ops);
#else
	return -ENODEV;
#endif
}

void oprofile_arch_exit(void)
{
#ifdef CONFIG_64BIT
	oprofile_hwsampler_exit();
#endif
}
Commit	Line	Data
1da177e4 LT	1	/**
	2	* arch/s390/oprofile/init.c
	3	*
	4	* S390 Version
	5	* Copyright (C) 2003 IBM Deutschland Entwicklung GmbH, IBM Corporation
	6	* Author(s): Thomas Spatzier (tspat@de.ibm.com)
c814d160 HG	7	* Author(s): Mahesh Salgaonkar (mahesh@linux.vnet.ibm.com)
c814d160 HG	8	* Author(s): Heinz Graalfs (graalfs@linux.vnet.ibm.com)
1da177e4	9	*
c814d160	10	* @remark Copyright 2002-2011 OProfile authors
1da177e4 LT	11	*/
	12
	13	#include <linux/oprofile.h>
	14	#include <linux/init.h>
	15	#include <linux/errno.h>
c814d160 HG	16	#include <linux/oprofile.h>
	17	#include <linux/errno.h>
	18	#include <linux/fs.h>
	19
	20	#include "../../../drivers/oprofile/oprof.h"
984e8486 HC	21
	22	extern void s390_backtrace(struct pt_regs * const regs, unsigned int depth);
	23
	24	#ifdef CONFIG_64BIT
	25
c814d160 HG	26	#include "hwsampler.h"
	27
	28	#define DEFAULT_INTERVAL 4096
	29
	30	#define DEFAULT_SDBT_BLOCKS 1
	31	#define DEFAULT_SDB_BLOCKS 511
	32
	33	static unsigned long oprofile_hw_interval = DEFAULT_INTERVAL;
	34	static unsigned long oprofile_min_interval;
	35	static unsigned long oprofile_max_interval;
	36
	37	static unsigned long oprofile_sdbt_blocks = DEFAULT_SDBT_BLOCKS;
	38	static unsigned long oprofile_sdb_blocks = DEFAULT_SDB_BLOCKS;
1da177e4	39
c814d160 HG	40	static int hwsampler_file;
	41	static int hwsampler_running; /* start_mutex must be held to change */
	42
	43	static struct oprofile_operations timer_ops;
d0f4c16f	44
c814d160 HG	45	static int oprofile_hwsampler_start(void)
	46	{
	47	int retval;
	48
	49	hwsampler_running = hwsampler_file;
	50
	51	if (!hwsampler_running)
	52	return timer_ops.start();
	53
	54	retval = hwsampler_allocate(oprofile_sdbt_blocks, oprofile_sdb_blocks);
	55	if (retval)
	56	return retval;
	57
	58	retval = hwsampler_start_all(oprofile_hw_interval);
	59	if (retval)
	60	hwsampler_deallocate();
	61
	62	return retval;
	63	}
	64
	65	static void oprofile_hwsampler_stop(void)
	66	{
	67	if (!hwsampler_running) {
	68	timer_ops.stop();
	69	return;
	70	}
	71
	72	hwsampler_stop_all();
	73	hwsampler_deallocate();
	74	return;
	75	}
	76
	77	static ssize_t hwsampler_read(struct file file, char __user buf,
	78	size_t count, loff_t *offset)
	79	{
	80	return oprofilefs_ulong_to_user(hwsampler_file, buf, count, offset);
	81	}
	82
	83	static ssize_t hwsampler_write(struct file file, char const __user buf,
	84	size_t count, loff_t *offset)
	85	{
	86	unsigned long val;
	87	int retval;
	88
	89	if (*offset)
	90	return -EINVAL;
	91
	92	retval = oprofilefs_ulong_from_user(&val, buf, count);
	93	if (retval)
	94	return retval;
	95
	96	if (oprofile_started)
	97	/*
	98	* save to do without locking as we set
	99	* hwsampler_running in start() when start_mutex is
	100	* held
	101	*/
	102	return -EBUSY;
	103
	104	hwsampler_file = val;
	105
	106	return count;
	107	}
	108
109	static const struct file_operations hwsampler_fops = {
110	.read = hwsampler_read,
111	.write = hwsampler_write,
112	};
113
114	static int oprofile_create_hwsampling_files(struct super_block *sb,
115	struct dentry *root)
116	{
117	struct dentry *hw_dir;
118
119	/* reinitialize default values */
120	hwsampler_file = 1;
121
122	hw_dir = oprofilefs_mkdir(sb, root, "hwsampling");
123	if (!hw_dir)
124	return -EINVAL;
125
126	oprofilefs_create_file(sb, hw_dir, "hwsampler", &hwsampler_fops);
127	oprofilefs_create_ulong(sb, hw_dir, "hw_interval",
128	&oprofile_hw_interval);
129	oprofilefs_create_ro_ulong(sb, hw_dir, "hw_min_interval",
130	&oprofile_min_interval);
131	oprofilefs_create_ro_ulong(sb, hw_dir, "hw_max_interval",
132	&oprofile_max_interval);
133	oprofilefs_create_ulong(sb, hw_dir, "hw_sdbt_blocks",
134	&oprofile_sdbt_blocks);
135
136	return 0;
137	}
138
ec6b426c	139	static int oprofile_hwsampler_init(struct oprofile_operations *ops)
c814d160 HG	140	{
	141	if (hwsampler_setup())
	142	return -ENODEV;
	143
	144	/*
	145	* create hwsampler files only if hwsampler_setup() succeeds.
	146	*/
	147	oprofile_min_interval = hwsampler_query_min_interval();
3d8dcb3c	148	if (oprofile_min_interval == 0)
c814d160	149	return -ENODEV;
c814d160	150	oprofile_max_interval = hwsampler_query_max_interval();
3d8dcb3c	151	if (oprofile_max_interval == 0)
c814d160	152	return -ENODEV;
c814d160 HG	153
	154	if (oprofile_timer_init(ops))
	155	return -ENODEV;
	156
	157	printk(KERN_INFO "oprofile: using hardware sampling\n");
	158
	159	memcpy(&timer_ops, ops, sizeof(timer_ops));
	160
	161	ops->start = oprofile_hwsampler_start;
	162	ops->stop = oprofile_hwsampler_stop;
	163	ops->create_files = oprofile_create_hwsampling_files;
	164
	165	return 0;
	166	}
	167
ec6b426c	168	static void oprofile_hwsampler_exit(void)
c814d160 HG	169	{
	170	oprofile_timer_exit();
	171	hwsampler_shutdown();
	172	}
	173
984e8486 HC	174	#endif /* CONFIG_64BIT */
984e8486 HC	175
ec6b426c	176	int __init oprofile_arch_init(struct oprofile_operations *ops)
1da177e4	177	{
d0f4c16f	178	ops->backtrace = s390_backtrace;
997dbb49	179
984e8486	180	#ifdef CONFIG_64BIT
997dbb49	181	return oprofile_hwsampler_init(ops);
984e8486 HC	182	#else
	183	return -ENODEV;
	184	#endif
1da177e4 LT	185	}
	186
	187	void oprofile_arch_exit(void)
	188	{
984e8486	189	#ifdef CONFIG_64BIT
997dbb49	190	oprofile_hwsampler_exit();
984e8486	191	#endif
1da177e4	192	}