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

/*
 * S390 Version
 *   Copyright IBM Corp. 2002, 2011
 *   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)
 *   Author(s): Andreas Krebbel (krebbel@linux.vnet.ibm.com)
 *
 * @remark Copyright 2002-2011 OProfile authors
 */

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

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

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

#ifdef CONFIG_64BIT

#include "hwsampler.h"
#include "op_counter.h"

#define DEFAULT_INTERVAL	4127518

#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_enabled;
static int hwsampler_running;	/* start_mutex must be held to change */
static int hwsampler_available;

static struct oprofile_operations timer_ops;

struct op_counter_config counter_config;

enum __force_cpu_type {
	reserved = 0,		/* do not force */
	timer,
};
static int force_cpu_type;

static int set_cpu_type(const char *str, struct kernel_param *kp)
{
	if (!strcmp(str, "timer")) {
		force_cpu_type = timer;
		printk(KERN_INFO "oprofile: forcing timer to be returned "
		                 "as cpu type\n");
	} else {
		force_cpu_type = 0;
	}

	return 0;
}
module_param_call(cpu_type, set_cpu_type, NULL, NULL, 0);
MODULE_PARM_DESC(cpu_type, "Force legacy basic mode sampling"
		           "(report cpu_type \"timer\"");

static int oprofile_hwsampler_start(void)
{
	int retval;

	hwsampler_running = hwsampler_enabled;

	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;
}

/*
 * File ops used for:
 * /dev/oprofile/0/enabled
 * /dev/oprofile/hwsampling/hwsampler  (cpu_type = timer)
 */

static ssize_t hwsampler_read(struct file *file, char __user *buf,
		size_t count, loff_t *offset)
{
	return oprofilefs_ulong_to_user(hwsampler_enabled, 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 <= 0)
		return retval;

	if (val != 0 && val != 1)
		return -EINVAL;

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

	hwsampler_enabled = val;

	return count;
}

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

/*
 * File ops used for:
 * /dev/oprofile/0/count
 * /dev/oprofile/hwsampling/hw_interval  (cpu_type = timer)
 *
 * Make sure that the value is within the hardware range.
 */

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

static ssize_t hw_interval_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 <= 0)
		return retval;
	if (val < oprofile_min_interval)
		oprofile_hw_interval = oprofile_min_interval;
	else if (val > oprofile_max_interval)
		oprofile_hw_interval = oprofile_max_interval;
	else
		oprofile_hw_interval = val;

	return count;
}

static const struct file_operations hw_interval_fops = {
	.read		= hw_interval_read,
	.write		= hw_interval_write,
};

/*
 * File ops used for:
 * /dev/oprofile/0/event
 * Only a single event with number 0 is supported with this counter.
 *
 * /dev/oprofile/0/unit_mask
 * This is a dummy file needed by the user space tools.
 * No value other than 0 is accepted or returned.
 */

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

static ssize_t hwsampler_zero_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 <= 0)
		return retval;
	if (val != 0)
		return -EINVAL;
	return count;
}

static const struct file_operations zero_fops = {
	.read		= hwsampler_zero_read,
	.write		= hwsampler_zero_write,
};

/* /dev/oprofile/0/kernel file ops.  */

static ssize_t hwsampler_kernel_read(struct file *file, char __user *buf,
				     size_t count, loff_t *offset)
{
	return oprofilefs_ulong_to_user(counter_config.kernel,
					buf, count, offset);
}

static ssize_t hwsampler_kernel_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 <= 0)
		return retval;

	if (val != 0 && val != 1)
		return -EINVAL;

	counter_config.kernel = val;

	return count;
}

static const struct file_operations kernel_fops = {
	.read		= hwsampler_kernel_read,
	.write		= hwsampler_kernel_write,
};

/* /dev/oprofile/0/user file ops. */

static ssize_t hwsampler_user_read(struct file *file, char __user *buf,
				   size_t count, loff_t *offset)
{
	return oprofilefs_ulong_to_user(counter_config.user,
					buf, count, offset);
}

static ssize_t hwsampler_user_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 <= 0)
		return retval;

	if (val != 0 && val != 1)
		return -EINVAL;

	counter_config.user = val;

	return count;
}

static const struct file_operations user_fops = {
	.read		= hwsampler_user_read,
	.write		= hwsampler_user_write,
};


/*
 * File ops used for: /dev/oprofile/timer/enabled
 * The value always has to be the inverted value of hwsampler_enabled. So
 * no separate variable is created. That way we do not need locking.
 */

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

static ssize_t timer_enabled_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 <= 0)
		return retval;

	if (val != 0 && val != 1)
		return -EINVAL;

	/* Timer cannot be disabled without having hardware sampling.  */
	if (val == 0 && !hwsampler_available)
		return -EINVAL;

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

	hwsampler_enabled = !val;

	return count;
}

static const struct file_operations timer_enabled_fops = {
	.read		= timer_enabled_read,
	.write		= timer_enabled_write,
};


static int oprofile_create_hwsampling_files(struct dentry *root)
{
	struct dentry *dir;

	dir = oprofilefs_mkdir(root, "timer");
	if (!dir)
		return -EINVAL;

	oprofilefs_create_file(root->d_sb, dir, "enabled", &timer_enabled_fops);

	if (!hwsampler_available)
		return 0;

	/* reinitialize default values */
	hwsampler_enabled = 1;
	counter_config.kernel = 1;
	counter_config.user = 1;

	if (!force_cpu_type) {
		/*
		 * Create the counter file system.  A single virtual
		 * counter is created which can be used to
		 * enable/disable hardware sampling dynamically from
		 * user space.  The user space will configure a single
		 * counter with a single event.  The value of 'event'
		 * and 'unit_mask' are not evaluated by the kernel code
		 * and can only be set to 0.
		 */

		dir = oprofilefs_mkdir(root, "0");
		if (!dir)
			return -EINVAL;

		oprofilefs_create_file(root->d_sb, dir, "enabled", &hwsampler_fops);
		oprofilefs_create_file(root->d_sb, dir, "event", &zero_fops);
		oprofilefs_create_file(root->d_sb, dir, "count", &hw_interval_fops);
		oprofilefs_create_file(root->d_sb, dir, "unit_mask", &zero_fops);
		oprofilefs_create_file(root->d_sb, dir, "kernel", &kernel_fops);
		oprofilefs_create_file(root->d_sb, dir, "user", &user_fops);
		oprofilefs_create_ulong(root->d_sb, dir, "hw_sdbt_blocks",
					&oprofile_sdbt_blocks);

	} else {
		/*
		 * Hardware sampling can be used but the cpu_type is
		 * forced to timer in order to deal with legacy user
		 * space tools.  The /dev/oprofile/hwsampling fs is
		 * provided in that case.
		 */
		dir = oprofilefs_mkdir(root, "hwsampling");
		if (!dir)
			return -EINVAL;

		oprofilefs_create_file(root->d_sb, dir, "hwsampler",
				       &hwsampler_fops);
		oprofilefs_create_file(root->d_sb, dir, "hw_interval",
				       &hw_interval_fops);
		oprofilefs_create_ro_ulong(root->d_sb, dir, "hw_min_interval",
					   &oprofile_min_interval);
		oprofilefs_create_ro_ulong(root->d_sb, dir, "hw_max_interval",
					   &oprofile_max_interval);
		oprofilefs_create_ulong(root->d_sb, dir, "hw_sdbt_blocks",
					&oprofile_sdbt_blocks);
	}
	return 0;
}

static int oprofile_hwsampler_init(struct oprofile_operations *ops)
{
	/*
	 * Initialize the timer mode infrastructure as well in order
	 * to be able to switch back dynamically.  oprofile_timer_init
	 * is not supposed to fail.
	 */
	if (oprofile_timer_init(ops))
		BUG();

	memcpy(&timer_ops, ops, sizeof(timer_ops));
	ops->create_files = oprofile_create_hwsampling_files;

	/*
	 * If the user space tools do not support newer cpu types,
	 * the force_cpu_type module parameter
	 * can be used to always return \"timer\" as cpu type.
	 */
	if (force_cpu_type != timer) {
		struct cpuid id;

		get_cpu_id (&id);

		switch (id.machine) {
		case 0x2097: case 0x2098: ops->cpu_type = "s390/z10"; break;
		case 0x2817: case 0x2818: ops->cpu_type = "s390/z196"; break;
		case 0x2827: case 0x2828: ops->cpu_type = "s390/zEC12"; break;
		default: return -ENODEV;
		}
	}

	if (hwsampler_setup())
		return -ENODEV;

	/*
	 * Query the range for the sampling interval from the
	 * hardware.
	 */
	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;

	/* The initial value should be sane */
	if (oprofile_hw_interval < oprofile_min_interval)
		oprofile_hw_interval = oprofile_min_interval;
	if (oprofile_hw_interval > oprofile_max_interval)
		oprofile_hw_interval = oprofile_max_interval;

	printk(KERN_INFO "oprofile: System z hardware sampling "
	       "facility found.\n");

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

	return 0;
}

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

#endif /* CONFIG_64BIT */

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

#ifdef CONFIG_64BIT

	/*
	 * -ENODEV is not reported to the caller.  The module itself
         * will use the timer mode sampling as fallback and this is
         * always available.
	 */
	hwsampler_available = oprofile_hwsampler_init(ops) == 0;

	return 0;
#else
	return -ENODEV;
#endif
}

void oprofile_arch_exit(void)
{
#ifdef CONFIG_64BIT
	oprofile_hwsampler_exit();
#endif
}
Commit	Line	Data
a53c8fab	1	/*
1da177e4	2	* S390 Version
a53c8fab	3	* Copyright IBM Corp. 2002, 2011
1da177e4	4	* Author(s): Thomas Spatzier (tspat@de.ibm.com)
c814d160 HG	5	* Author(s): Mahesh Salgaonkar (mahesh@linux.vnet.ibm.com)
c814d160 HG	6	* Author(s): Heinz Graalfs (graalfs@linux.vnet.ibm.com)
dd3c4670	7	* Author(s): Andreas Krebbel (krebbel@linux.vnet.ibm.com)
1da177e4	8	*
c814d160	9	* @remark Copyright 2002-2011 OProfile authors
1da177e4 LT	10	*/
	11
	12	#include <linux/oprofile.h>
	13	#include <linux/init.h>
	14	#include <linux/errno.h>
c814d160	15	#include <linux/fs.h>
dd3c4670 AK	16	#include <linux/module.h>
dd3c4670 AK	17	#include <asm/processor.h>
c814d160 HG	18
c814d160 HG	19	#include "../../../drivers/oprofile/oprof.h"
984e8486 HC	20
	21	extern void s390_backtrace(struct pt_regs * const regs, unsigned int depth);
	22
	23	#ifdef CONFIG_64BIT
	24
c814d160	25	#include "hwsampler.h"
dd3c4670	26	#include "op_counter.h"
c814d160	27
68158234	28	#define DEFAULT_INTERVAL 4127518
c814d160 HG	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
dd3c4670	40	static int hwsampler_enabled;
c814d160	41	static int hwsampler_running; /* start_mutex must be held to change */
dd3c4670	42	static int hwsampler_available;
c814d160 HG	43
c814d160 HG	44	static struct oprofile_operations timer_ops;
d0f4c16f	45
dd3c4670 AK	46	struct op_counter_config counter_config;
	47
	48	enum __force_cpu_type {
	49	reserved = 0, /* do not force */
	50	timer,
	51	};
	52	static int force_cpu_type;
	53
	54	static int set_cpu_type(const char str, struct kernel_param kp)
	55	{
	56	if (!strcmp(str, "timer")) {
	57	force_cpu_type = timer;
	58	printk(KERN_INFO "oprofile: forcing timer to be returned "
	59	"as cpu type\n");
	60	} else {
	61	force_cpu_type = 0;
	62	}
	63
	64	return 0;
	65	}
	66	module_param_call(cpu_type, set_cpu_type, NULL, NULL, 0);
	67	MODULE_PARM_DESC(cpu_type, "Force legacy basic mode sampling"
	68	"(report cpu_type \"timer\"");
	69
c814d160 HG	70	static int oprofile_hwsampler_start(void)
	71	{
	72	int retval;
	73
dd3c4670	74	hwsampler_running = hwsampler_enabled;
c814d160 HG	75
	76	if (!hwsampler_running)
	77	return timer_ops.start();
	78
	79	retval = hwsampler_allocate(oprofile_sdbt_blocks, oprofile_sdb_blocks);
	80	if (retval)
	81	return retval;
	82
	83	retval = hwsampler_start_all(oprofile_hw_interval);
	84	if (retval)
	85	hwsampler_deallocate();
	86
	87	return retval;
	88	}
	89
	90	static void oprofile_hwsampler_stop(void)
	91	{
	92	if (!hwsampler_running) {
	93	timer_ops.stop();
	94	return;
	95	}
	96
	97	hwsampler_stop_all();
	98	hwsampler_deallocate();
	99	return;
	100	}
	101
dd3c4670 AK	102	/*
	103	* File ops used for:
	104	* /dev/oprofile/0/enabled
	105	* /dev/oprofile/hwsampling/hwsampler (cpu_type = timer)
	106	*/
	107
c814d160 HG	108	static ssize_t hwsampler_read(struct file file, char __user buf,
	109	size_t count, loff_t *offset)
	110	{
dd3c4670	111	return oprofilefs_ulong_to_user(hwsampler_enabled, buf, count, offset);
c814d160 HG	112	}
	113
	114	static ssize_t hwsampler_write(struct file file, char const __user buf,
	115	size_t count, loff_t *offset)
	116	{
	117	unsigned long val;
	118	int retval;
	119
	120	if (*offset)
	121	return -EINVAL;
	122
	123	retval = oprofilefs_ulong_from_user(&val, buf, count);
913050b9	124	if (retval <= 0)
c814d160 HG	125	return retval;
c814d160 HG	126
dd3c4670 AK	127	if (val != 0 && val != 1)
	128	return -EINVAL;
	129
c814d160 HG	130	if (oprofile_started)
	131	/*
	132	* save to do without locking as we set
	133	* hwsampler_running in start() when start_mutex is
	134	* held
	135	*/
	136	return -EBUSY;
	137
dd3c4670	138	hwsampler_enabled = val;
c814d160 HG	139
	140	return count;
	141	}
	142
	143	static const struct file_operations hwsampler_fops = {
	144	.read = hwsampler_read,
	145	.write = hwsampler_write,
	146	};
	147
dd3c4670 AK	148	/*
	149	* File ops used for:
	150	* /dev/oprofile/0/count
	151	* /dev/oprofile/hwsampling/hw_interval (cpu_type = timer)
	152	*
	153	* Make sure that the value is within the hardware range.
	154	*/
	155
	156	static ssize_t hw_interval_read(struct file file, char __user buf,
	157	size_t count, loff_t *offset)
	158	{
	159	return oprofilefs_ulong_to_user(oprofile_hw_interval, buf,
	160	count, offset);
	161	}
	162
	163	static ssize_t hw_interval_write(struct file file, char const __user buf,
	164	size_t count, loff_t *offset)
	165	{
	166	unsigned long val;
	167	int retval;
	168
	169	if (*offset)
	170	return -EINVAL;
	171	retval = oprofilefs_ulong_from_user(&val, buf, count);
81ff3478	172	if (retval <= 0)
dd3c4670 AK	173	return retval;
	174	if (val < oprofile_min_interval)
	175	oprofile_hw_interval = oprofile_min_interval;
	176	else if (val > oprofile_max_interval)
	177	oprofile_hw_interval = oprofile_max_interval;
	178	else
	179	oprofile_hw_interval = val;
	180
	181	return count;
	182	}
	183
	184	static const struct file_operations hw_interval_fops = {
	185	.read = hw_interval_read,
	186	.write = hw_interval_write,
	187	};
	188
	189	/*
	190	* File ops used for:
	191	* /dev/oprofile/0/event
	192	* Only a single event with number 0 is supported with this counter.
	193	*
	194	* /dev/oprofile/0/unit_mask
	195	* This is a dummy file needed by the user space tools.
	196	* No value other than 0 is accepted or returned.
	197	*/
	198
	199	static ssize_t hwsampler_zero_read(struct file file, char __user buf,
	200	size_t count, loff_t *offset)
	201	{
	202	return oprofilefs_ulong_to_user(0, buf, count, offset);
	203	}
	204
	205	static ssize_t hwsampler_zero_write(struct file file, char const __user buf,
	206	size_t count, loff_t *offset)
	207	{
	208	unsigned long val;
	209	int retval;
	210
	211	if (*offset)
	212	return -EINVAL;
	213
	214	retval = oprofilefs_ulong_from_user(&val, buf, count);
81ff3478	215	if (retval <= 0)
dd3c4670 AK	216	return retval;
	217	if (val != 0)
	218	return -EINVAL;
	219	return count;
	220	}
	221
	222	static const struct file_operations zero_fops = {
	223	.read = hwsampler_zero_read,
	224	.write = hwsampler_zero_write,
	225	};
	226
	227	/* /dev/oprofile/0/kernel file ops. */
	228
	229	static ssize_t hwsampler_kernel_read(struct file file, char __user buf,
	230	size_t count, loff_t *offset)
	231	{
	232	return oprofilefs_ulong_to_user(counter_config.kernel,
	233	buf, count, offset);
	234	}
	235
	236	static ssize_t hwsampler_kernel_write(struct file file, char const __user buf,
	237	size_t count, loff_t *offset)
	238	{
	239	unsigned long val;
	240	int retval;
	241
	242	if (*offset)
	243	return -EINVAL;
	244
	245	retval = oprofilefs_ulong_from_user(&val, buf, count);
81ff3478	246	if (retval <= 0)
dd3c4670 AK	247	return retval;
	248
	249	if (val != 0 && val != 1)
	250	return -EINVAL;
	251
	252	counter_config.kernel = val;
	253
	254	return count;
	255	}
	256
	257	static const struct file_operations kernel_fops = {
	258	.read = hwsampler_kernel_read,
	259	.write = hwsampler_kernel_write,
	260	};
	261
	262	/* /dev/oprofile/0/user file ops. */
	263
	264	static ssize_t hwsampler_user_read(struct file file, char __user buf,
	265	size_t count, loff_t *offset)
	266	{
	267	return oprofilefs_ulong_to_user(counter_config.user,
	268	buf, count, offset);
	269	}
	270
	271	static ssize_t hwsampler_user_write(struct file file, char const __user buf,
	272	size_t count, loff_t *offset)
	273	{
	274	unsigned long val;
	275	int retval;
	276
	277	if (*offset)
	278	return -EINVAL;
	279
	280	retval = oprofilefs_ulong_from_user(&val, buf, count);
81ff3478	281	if (retval <= 0)
dd3c4670 AK	282	return retval;
	283
	284	if (val != 0 && val != 1)
	285	return -EINVAL;
	286
	287	counter_config.user = val;
	288
	289	return count;
	290	}
	291
	292	static const struct file_operations user_fops = {
	293	.read = hwsampler_user_read,
	294	.write = hwsampler_user_write,
	295	};
	296
	297
	298	/*
	299	* File ops used for: /dev/oprofile/timer/enabled
	300	* The value always has to be the inverted value of hwsampler_enabled. So
	301	* no separate variable is created. That way we do not need locking.
	302	*/
	303
	304	static ssize_t timer_enabled_read(struct file file, char __user buf,
	305	size_t count, loff_t *offset)
	306	{
	307	return oprofilefs_ulong_to_user(!hwsampler_enabled, buf, count, offset);
	308	}
	309
	310	static ssize_t timer_enabled_write(struct file file, char const __user buf,
	311	size_t count, loff_t *offset)
	312	{
	313	unsigned long val;
	314	int retval;
	315
	316	if (*offset)
	317	return -EINVAL;
	318
	319	retval = oprofilefs_ulong_from_user(&val, buf, count);
81ff3478	320	if (retval <= 0)
dd3c4670 AK	321	return retval;
	322
	323	if (val != 0 && val != 1)
	324	return -EINVAL;
	325
	326	/* Timer cannot be disabled without having hardware sampling. */
	327	if (val == 0 && !hwsampler_available)
	328	return -EINVAL;
	329
	330	if (oprofile_started)
	331	/*
	332	* save to do without locking as we set
	333	* hwsampler_running in start() when start_mutex is
	334	* held
	335	*/
	336	return -EBUSY;
	337
	338	hwsampler_enabled = !val;
	339
	340	return count;
	341	}
	342
	343	static const struct file_operations timer_enabled_fops = {
	344	.read = timer_enabled_read,
	345	.write = timer_enabled_write,
	346	};
	347
	348
ef7bca14	349	static int oprofile_create_hwsampling_files(struct dentry *root)
c814d160	350	{
dd3c4670 AK	351	struct dentry *dir;
dd3c4670 AK	352
ecde2823	353	dir = oprofilefs_mkdir(root, "timer");
dd3c4670 AK	354	if (!dir)
	355	return -EINVAL;
	356
ef7bca14	357	oprofilefs_create_file(root->d_sb, dir, "enabled", &timer_enabled_fops);
dd3c4670 AK	358
	359	if (!hwsampler_available)
	360	return 0;
c814d160 HG	361
c814d160 HG	362	/* reinitialize default values */
dd3c4670 AK	363	hwsampler_enabled = 1;
	364	counter_config.kernel = 1;
	365	counter_config.user = 1;
c814d160	366
dd3c4670 AK	367	if (!force_cpu_type) {
	368	/*
	369	* Create the counter file system. A single virtual
	370	* counter is created which can be used to
	371	* enable/disable hardware sampling dynamically from
	372	* user space. The user space will configure a single
	373	* counter with a single event. The value of 'event'
	374	* and 'unit_mask' are not evaluated by the kernel code
	375	* and can only be set to 0.
	376	*/
	377
ecde2823	378	dir = oprofilefs_mkdir(root, "0");
dd3c4670 AK	379	if (!dir)
dd3c4670 AK	380	return -EINVAL;
c814d160	381
ef7bca14 AV	382	oprofilefs_create_file(root->d_sb, dir, "enabled", &hwsampler_fops);
	383	oprofilefs_create_file(root->d_sb, dir, "event", &zero_fops);
	384	oprofilefs_create_file(root->d_sb, dir, "count", &hw_interval_fops);
	385	oprofilefs_create_file(root->d_sb, dir, "unit_mask", &zero_fops);
	386	oprofilefs_create_file(root->d_sb, dir, "kernel", &kernel_fops);
	387	oprofilefs_create_file(root->d_sb, dir, "user", &user_fops);
	388	oprofilefs_create_ulong(root->d_sb, dir, "hw_sdbt_blocks",
dd3c4670	389	&oprofile_sdbt_blocks);
c814d160	390
dd3c4670 AK	391	} else {
	392	/*
	393	* Hardware sampling can be used but the cpu_type is
	394	* forced to timer in order to deal with legacy user
	395	* space tools. The /dev/oprofile/hwsampling fs is
	396	* provided in that case.
	397	*/
ecde2823	398	dir = oprofilefs_mkdir(root, "hwsampling");
dd3c4670 AK	399	if (!dir)
	400	return -EINVAL;
	401
ef7bca14	402	oprofilefs_create_file(root->d_sb, dir, "hwsampler",
dd3c4670	403	&hwsampler_fops);
ef7bca14	404	oprofilefs_create_file(root->d_sb, dir, "hw_interval",
dd3c4670	405	&hw_interval_fops);
ef7bca14	406	oprofilefs_create_ro_ulong(root->d_sb, dir, "hw_min_interval",
dd3c4670	407	&oprofile_min_interval);
ef7bca14	408	oprofilefs_create_ro_ulong(root->d_sb, dir, "hw_max_interval",
dd3c4670	409	&oprofile_max_interval);
ef7bca14	410	oprofilefs_create_ulong(root->d_sb, dir, "hw_sdbt_blocks",
dd3c4670 AK	411	&oprofile_sdbt_blocks);
dd3c4670 AK	412	}
c814d160 HG	413	return 0;
	414	}
	415
ec6b426c	416	static int oprofile_hwsampler_init(struct oprofile_operations *ops)
c814d160	417	{
dd3c4670 AK	418	/*
	419	* Initialize the timer mode infrastructure as well in order
	420	* to be able to switch back dynamically. oprofile_timer_init
	421	* is not supposed to fail.
	422	*/
	423	if (oprofile_timer_init(ops))
	424	BUG();
	425
	426	memcpy(&timer_ops, ops, sizeof(timer_ops));
	427	ops->create_files = oprofile_create_hwsampling_files;
	428
	429	/*
	430	* If the user space tools do not support newer cpu types,
	431	* the force_cpu_type module parameter
	432	* can be used to always return \"timer\" as cpu type.
	433	*/
	434	if (force_cpu_type != timer) {
	435	struct cpuid id;
	436
	437	get_cpu_id (&id);
	438
	439	switch (id.machine) {
	440	case 0x2097: case 0x2098: ops->cpu_type = "s390/z10"; break;
	441	case 0x2817: case 0x2818: ops->cpu_type = "s390/z196"; break;
59471227	442	case 0x2827: case 0x2828: ops->cpu_type = "s390/zEC12"; break;
dd3c4670 AK	443	default: return -ENODEV;
	444	}
	445	}
	446
c814d160 HG	447	if (hwsampler_setup())
	448	return -ENODEV;
	449
	450	/*
dd3c4670 AK	451	* Query the range for the sampling interval from the
dd3c4670 AK	452	* hardware.
c814d160 HG	453	*/
c814d160 HG	454	oprofile_min_interval = hwsampler_query_min_interval();
3d8dcb3c	455	if (oprofile_min_interval == 0)
c814d160	456	return -ENODEV;
c814d160	457	oprofile_max_interval = hwsampler_query_max_interval();
3d8dcb3c	458	if (oprofile_max_interval == 0)
c814d160	459	return -ENODEV;
c814d160	460
b530ce7a CB	461	/* The initial value should be sane */
	462	if (oprofile_hw_interval < oprofile_min_interval)
	463	oprofile_hw_interval = oprofile_min_interval;
	464	if (oprofile_hw_interval > oprofile_max_interval)
	465	oprofile_hw_interval = oprofile_max_interval;
	466
dd3c4670 AK	467	printk(KERN_INFO "oprofile: System z hardware sampling "
dd3c4670 AK	468	"facility found.\n");
c814d160 HG	469
	470	ops->start = oprofile_hwsampler_start;
	471	ops->stop = oprofile_hwsampler_stop;
c814d160 HG	472
	473	return 0;
	474	}
	475
ec6b426c	476	static void oprofile_hwsampler_exit(void)
c814d160	477	{
c814d160 HG	478	hwsampler_shutdown();
	479	}
	480
984e8486 HC	481	#endif /* CONFIG_64BIT */
984e8486 HC	482
ec6b426c	483	int __init oprofile_arch_init(struct oprofile_operations *ops)
1da177e4	484	{
d0f4c16f	485	ops->backtrace = s390_backtrace;
997dbb49	486
984e8486	487	#ifdef CONFIG_64BIT
dd3c4670 AK	488
	489	/*
	490	* -ENODEV is not reported to the caller. The module itself
	491	* will use the timer mode sampling as fallback and this is
	492	* always available.
	493	*/
	494	hwsampler_available = oprofile_hwsampler_init(ops) == 0;
	495
	496	return 0;
984e8486 HC	497	#else
	498	return -ENODEV;
	499	#endif
1da177e4 LT	500	}
	501
	502	void oprofile_arch_exit(void)
	503	{
984e8486	504	#ifdef CONFIG_64BIT
997dbb49	505	oprofile_hwsampler_exit();
984e8486	506	#endif
1da177e4	507	}