oprofile, s390: Add event interface to the System z hardware sampling module

With this patch the OProfile Basic Mode Sampling support for System z is enhanced with a counter file system. That way hardware sampling can be configured using the user space tools with only little modifications. With the patch by default new cpu_types (s390/z10, s390/z196) are returned in order to indicate that we are running a CPU which provides the hardware sampling facility. Existing user space tools will complain about an unknown cpu type. In order to be compatible with existing user space tools the `cpu_type' module parameter has been added. Setting the parameter to `timer' will force the module to return `timer' as cpu_type. The module will still try to use hardware sampling if available and the hwsampling virtual filesystem will be also be available for configuration. So this has a different effect than using the generic oprofile module parameter `timer=1'. If the basic mode sampling is enabled on the machine and the cpu_type=timer parameter is not used the kernel module will provide the following virtual filesystem: /dev/oprofile/0/enabled /dev/oprofile/0/event /dev/oprofile/0/count /dev/oprofile/0/unit_mask /dev/oprofile/0/kernel /dev/oprofile/0/user In the counter file system only the values of 'enabled', 'count', 'kernel', and 'user' are evaluated by the kernel module. Everything else must contain fixed values. The 'event' value only supports a single event - HWSAMPLING with value 0. The 'count' value specifies the hardware sampling rate as it is passed to the CPU measurement facility. The 'kernel' and 'user' flags can now be used to filter for samples when using hardware sampling. Additionally also the following file will be created: /dev/oprofile/timer/enabled This will always be the inverted value of /dev/oprofile/0/enabled. 0 is not accepted without hardware sampling. Signed-off-by: Andreas Krebbel <krebbel@linux.vnet.ibm.com> Signed-off-by: Robert Richter <robert.richter@amd.com>

oprofile, s390: Add event interface to the System z hardware sampling module
With this patch the OProfile Basic Mode Sampling support for System z is enhanced with a counter file system. That way hardware sampling can be configured using the user space tools with only little modifications. With the patch by default new cpu_types (s390/z10, s390/z196) are returned in order to indicate that we are running a CPU which provides the hardware sampling facility. Existing user space tools will complain about an unknown cpu type. In order to be compatible with existing user space tools the `cpu_type' module parameter has been added. Setting the parameter to `timer' will force the module to return `timer' as cpu_type. The module will still try to use hardware sampling if available and the hwsampling virtual filesystem will be also be available for configuration. So this has a different effect than using the generic oprofile module parameter `timer=1'. If the basic mode sampling is enabled on the machine and the cpu_type=timer parameter is not used the kernel module will provide the following virtual filesystem: /dev/oprofile/0/enabled /dev/oprofile/0/event /dev/oprofile/0/count /dev/oprofile/0/unit_mask /dev/oprofile/0/kernel /dev/oprofile/0/user In the counter file system only the values of 'enabled', 'count', 'kernel', and 'user' are evaluated by the kernel module. Everything else must contain fixed values. The 'event' value only supports a single event - HWSAMPLING with value 0. The 'count' value specifies the hardware sampling rate as it is passed to the CPU measurement facility. The 'kernel' and 'user' flags can now be used to filter for samples when using hardware sampling. Additionally also the following file will be created: /dev/oprofile/timer/enabled This will always be the inverted value of /dev/oprofile/0/enabled. 0 is not accepted without hardware sampling. Signed-off-by: Andreas Krebbel <krebbel@linux.vnet.ibm.com> Signed-off-by: Robert Richter <robert.richter@amd.com>
Andreas Krebbel · Robert Richter
1 parent f8c852031a
Showing 4 changed files with 374 additions and 30 deletions Side-by-side Diff
Documentation/kernel-parameters.txt
arch/s390/oprofile/hwsampler.c
arch/s390/oprofile/init.c
arch/s390/oprofile/op_counter.h
@@ -1851,6 +1851,8 @@
 			timer: [X86] Force use of architectural NMI
 				timer mode (see also oprofile.timer
 				for generic hr timer mode)
+				[s390] Force legacy basic mode sampling
+                                (report cpu_type "timer")
  
 	oops=panic	Always panic on oopses. Default is to just kill the
 			process, but there is a small probability of
@@ -22,6 +22,7 @@
 #include <asm/irq.h>
  
 #include "hwsampler.h"
+#include "op_counter.h"
  
 #define MAX_NUM_SDB 511
 #define MIN_NUM_SDB 1
@@ -896,6 +897,8 @@
 		if (sample_data_ptr->P == 1) {
 			/* userspace sample */
 			unsigned int pid = sample_data_ptr->prim_asn;
+			if (!counter_config.user)
+				goto skip_sample;
 			rcu_read_lock();
 			tsk = pid_task(find_vpid(pid), PIDTYPE_PID);
 			if (tsk)
@@ -903,6 +906,8 @@
 			rcu_read_unlock();
 		} else {
 			/* kernelspace sample */
+			if (!counter_config.kernel)
+				goto skip_sample;
 			regs = task_pt_regs(current);
 		}
  
@@ -910,7 +915,7 @@
 		oprofile_add_ext_hw_sample(sample_data_ptr->ia, regs, 0,
 				!sample_data_ptr->P, tsk);
 		mutex_unlock(&hws_sem);
-
+	skip_sample:
 		sample_data_ptr++;
 	}
 }
@@ -2,10 +2,11 @@
  * arch/s390/oprofile/init.c
  *
  * S390 Version
- *   Copyright (C) 2003 IBM Deutschland Entwicklung GmbH, IBM Corporation
+ *   Copyright (C) 2002-2011 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)
+ *   Author(s): Andreas Krebbel (krebbel@linux.vnet.ibm.com)
  *
  * @remark Copyright 2002-2011 OProfile authors
  */
@@ -14,6 +15,8 @@
 #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"
  
@@ -22,6 +25,7 @@
 #ifdef CONFIG_64BIT
  
 #include "hwsampler.h"
+#include "op_counter.h"
  
 #define DEFAULT_INTERVAL	4127518
  
  
  
  
@@ -35,16 +39,41 @@
 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_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_file;
+	hwsampler_running = hwsampler_enabled;
  
 	if (!hwsampler_running)
 		return timer_ops.start();
  
@@ -72,10 +101,16 @@
 	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_file, buf, count, offset);
+	return oprofilefs_ulong_to_user(hwsampler_enabled, buf, count, offset);
 }
  
 static ssize_t hwsampler_write(struct file *file, char const __user *buf,
@@ -91,6 +126,9 @@
 	if (retval)
 		return retval;
  
+	if (val != 0 && val != 1)
+		return -EINVAL;
+
 	if (oprofile_started)
 		/*
 		 * save to do without locking as we set
@@ -99,7 +137,7 @@
 		 */
 		return -EBUSY;
  
-	hwsampler_file = val;
+	hwsampler_enabled = val;
  
 	return count;
 }
  
  
  
  
  
  
  
  
  
@@ -109,38 +147,311 @@
 	.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)
+		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)
+		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)
+		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)
+		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)
+		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 super_block *sb,
-						struct dentry *root)
+					    struct dentry *root)
 {
-	struct dentry *hw_dir;
+	struct dentry *dir;
  
+	dir = oprofilefs_mkdir(sb, root, "timer");
+	if (!dir)
+		return -EINVAL;
+
+	oprofilefs_create_file(sb, dir, "enabled", &timer_enabled_fops);
+
+	if (!hwsampler_available)
+		return 0;
+
 	/* reinitialize default values */
-	hwsampler_file = 1;
+	hwsampler_enabled = 1;
+	counter_config.kernel = 1;
+	counter_config.user = 1;
  
-	hw_dir = oprofilefs_mkdir(sb, root, "hwsampling");
-	if (!hw_dir)
-		return -EINVAL;
+	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.
+		 */
  
-	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);
+		dir = oprofilefs_mkdir(sb, root, "0");
+		if (!dir)
+			return -EINVAL;
  
+		oprofilefs_create_file(sb, dir, "enabled", &hwsampler_fops);
+		oprofilefs_create_file(sb, dir, "event", &zero_fops);
+		oprofilefs_create_file(sb, dir, "count", &hw_interval_fops);
+		oprofilefs_create_file(sb, dir, "unit_mask", &zero_fops);
+		oprofilefs_create_file(sb, dir, "kernel", &kernel_fops);
+		oprofilefs_create_file(sb, dir, "user", &user_fops);
+		oprofilefs_create_ulong(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(sb, root, "hwsampling");
+		if (!dir)
+			return -EINVAL;
+
+		oprofilefs_create_file(sb, dir, "hwsampler",
+				       &hwsampler_fops);
+		oprofilefs_create_file(sb, dir, "hw_interval",
+				       &hw_interval_fops);
+		oprofilefs_create_ro_ulong(sb, dir, "hw_min_interval",
+					   &oprofile_min_interval);
+		oprofilefs_create_ro_ulong(sb, dir, "hw_max_interval",
+					   &oprofile_max_interval);
+		oprofilefs_create_ulong(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;
+		default: return -ENODEV;
+		}
+	}
+
 	if (hwsampler_setup())
 		return -ENODEV;
  
 	/*
-	 * create hwsampler files only if hwsampler_setup() succeeds.
+	 * Query the range for the sampling interval from the
+	 * hardware.
 	 */
 	oprofile_min_interval = hwsampler_query_min_interval();
 	if (oprofile_min_interval == 0)
  
  
@@ -155,16 +466,11 @@
 	if (oprofile_hw_interval > oprofile_max_interval)
 		oprofile_hw_interval = oprofile_max_interval;
  
-	if (oprofile_timer_init(ops))
-		return -ENODEV;
+	printk(KERN_INFO "oprofile: System z hardware sampling "
+	       "facility found.\n");
  
-	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;
 }
@@ -181,7 +487,15 @@
 	ops->backtrace = s390_backtrace;
  
 #ifdef CONFIG_64BIT
-	return oprofile_hwsampler_init(ops);
+
+	/*
+	 * -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
+/**
+ * arch/s390/oprofile/op_counter.h
+ *
+ *   Copyright (C) 2011 IBM Deutschland Entwicklung GmbH, IBM Corporation
+ *   Author(s): Andreas Krebbel (krebbel@linux.vnet.ibm.com)
+ *
+ * @remark Copyright 2011 OProfile authors
+ */
+
+#ifndef OP_COUNTER_H
+#define OP_COUNTER_H
+
+struct op_counter_config {
+	/* `enabled' maps to the hwsampler_file variable.  */
+	/* `count' maps to the oprofile_hw_interval variable.  */
+	/* `event' and `unit_mask' are unused. */
+	unsigned long kernel;
+	unsigned long user;
+};
+
+extern struct op_counter_config counter_config;
+
+#endif /* OP_COUNTER_H */
...	...	@@ -1851,6 +1851,8 @@
1851	1851	timer: [X86] Force use of architectural NMI
1852	1852	timer mode (see also oprofile.timer
1853	1853	for generic hr timer mode)
	1854	+ [s390] Force legacy basic mode sampling
	1855	+ (report cpu_type "timer")
1854	1856
1855	1857	oops=panic Always panic on oopses. Default is to just kill the
1856	1858	process, but there is a small probability of
...	...	@@ -22,6 +22,7 @@
22	22	#include <asm/irq.h>
23	23
24	24	#include "hwsampler.h"
	25	+#include "op_counter.h"
25	26
26	27	#define MAX_NUM_SDB 511
27	28	#define MIN_NUM_SDB 1
...	...	@@ -896,6 +897,8 @@
896	897	if (sample_data_ptr->P == 1) {
897	898	/* userspace sample */
898	899	unsigned int pid = sample_data_ptr->prim_asn;
	900	+ if (!counter_config.user)
	901	+ goto skip_sample;
899	902	rcu_read_lock();
900	903	tsk = pid_task(find_vpid(pid), PIDTYPE_PID);
901	904	if (tsk)
...	...	@@ -903,6 +906,8 @@
903	906	rcu_read_unlock();
904	907	} else {
905	908	/* kernelspace sample */
	909	+ if (!counter_config.kernel)
	910	+ goto skip_sample;
906	911	regs = task_pt_regs(current);
907	912	}
908	913
...	...	@@ -910,7 +915,7 @@
910	915	oprofile_add_ext_hw_sample(sample_data_ptr->ia, regs, 0,
911	916	!sample_data_ptr->P, tsk);
912	917	mutex_unlock(&hws_sem);
913		-
	918	+ skip_sample:
914	919	sample_data_ptr++;
915	920	}
916	921	}
...	...	@@ -2,10 +2,11 @@
2	2	* arch/s390/oprofile/init.c
3	3	*
4	4	* S390 Version
5		- * Copyright (C) 2003 IBM Deutschland Entwicklung GmbH, IBM Corporation
	5	+ * Copyright (C) 2002-2011 IBM Deutschland Entwicklung GmbH, IBM Corporation
6	6	* Author(s): Thomas Spatzier (tspat@de.ibm.com)
7	7	* Author(s): Mahesh Salgaonkar (mahesh@linux.vnet.ibm.com)
8	8	* Author(s): Heinz Graalfs (graalfs@linux.vnet.ibm.com)
	9	+ * Author(s): Andreas Krebbel (krebbel@linux.vnet.ibm.com)
9	10	*
10	11	* @remark Copyright 2002-2011 OProfile authors
11	12	*/
...	...	@@ -14,6 +15,8 @@
14	15	#include <linux/init.h>
15	16	#include <linux/errno.h>
16	17	#include <linux/fs.h>
	18	+#include <linux/module.h>
	19	+#include <asm/processor.h>
17	20
18	21	#include "../../../drivers/oprofile/oprof.h"
19	22
...	...	@@ -22,6 +25,7 @@
22	25	#ifdef CONFIG_64BIT
23	26
24	27	#include "hwsampler.h"
	28	+#include "op_counter.h"
25	29
26	30	#define DEFAULT_INTERVAL 4127518
27	31
28	32
29	33
30	34
...	...	@@ -35,16 +39,41 @@
35	39	static unsigned long oprofile_sdbt_blocks = DEFAULT_SDBT_BLOCKS;
36	40	static unsigned long oprofile_sdb_blocks = DEFAULT_SDB_BLOCKS;
37	41
38		-static int hwsampler_file;
	42	+static int hwsampler_enabled;
39	43	static int hwsampler_running; /* start_mutex must be held to change */
	44	+static int hwsampler_available;
40	45
41	46	static struct oprofile_operations timer_ops;
42	47
	48	+struct op_counter_config counter_config;
	49	+
	50	+enum __force_cpu_type {
	51	+ reserved = 0, /* do not force */
	52	+ timer,
	53	+};
	54	+static int force_cpu_type;
	55	+
	56	+static int set_cpu_type(const char str, struct kernel_param kp)
	57	+{
	58	+ if (!strcmp(str, "timer")) {
	59	+ force_cpu_type = timer;
	60	+ printk(KERN_INFO "oprofile: forcing timer to be returned "
	61	+ "as cpu type\n");
	62	+ } else {
	63	+ force_cpu_type = 0;
	64	+ }
	65	+
	66	+ return 0;
	67	+}
	68	+module_param_call(cpu_type, set_cpu_type, NULL, NULL, 0);
	69	+MODULE_PARM_DESC(cpu_type, "Force legacy basic mode sampling"
	70	+ "(report cpu_type \"timer\"");
	71	+
43	72	static int oprofile_hwsampler_start(void)
44	73	{
45	74	int retval;
46	75
47		- hwsampler_running = hwsampler_file;
	76	+ hwsampler_running = hwsampler_enabled;
48	77
49	78	if (!hwsampler_running)
50	79	return timer_ops.start();
51	80
...	...	@@ -72,10 +101,16 @@
72	101	return;
73	102	}
74	103
	104	+/*
	105	+ * File ops used for:
	106	+ * /dev/oprofile/0/enabled
	107	+ * /dev/oprofile/hwsampling/hwsampler (cpu_type = timer)
	108	+ */
	109	+
75	110	static ssize_t hwsampler_read(struct file file, char __user buf,
76	111	size_t count, loff_t *offset)
77	112	{
78		- return oprofilefs_ulong_to_user(hwsampler_file, buf, count, offset);
	113	+ return oprofilefs_ulong_to_user(hwsampler_enabled, buf, count, offset);
79	114	}
80	115
81	116	static ssize_t hwsampler_write(struct file file, char const __user buf,
...	...	@@ -91,6 +126,9 @@
91	126	if (retval)
92	127	return retval;
93	128
	129	+ if (val != 0 && val != 1)
	130	+ return -EINVAL;
	131	+
94	132	if (oprofile_started)
95	133	/*
96	134	* save to do without locking as we set
...	...	@@ -99,7 +137,7 @@
99	137	*/
100	138	return -EBUSY;
101	139
102		- hwsampler_file = val;
	140	+ hwsampler_enabled = val;
103	141
104	142	return count;
105	143	}
106	144
107	145
108	146
109	147
110	148
111	149
112	150
113	151
114	152
...	...	@@ -109,38 +147,311 @@
109	147	.write = hwsampler_write,
110	148	};
111	149
	150	+/*
	151	+ * File ops used for:
	152	+ * /dev/oprofile/0/count
	153	+ * /dev/oprofile/hwsampling/hw_interval (cpu_type = timer)
	154	+ *
	155	+ * Make sure that the value is within the hardware range.
	156	+ */
	157	+
	158	+static ssize_t hw_interval_read(struct file file, char __user buf,
	159	+ size_t count, loff_t *offset)
	160	+{
	161	+ return oprofilefs_ulong_to_user(oprofile_hw_interval, buf,
	162	+ count, offset);
	163	+}
	164	+
	165	+static ssize_t hw_interval_write(struct file file, char const __user buf,
	166	+ size_t count, loff_t *offset)
	167	+{
	168	+ unsigned long val;
	169	+ int retval;
	170	+
	171	+ if (*offset)
	172	+ return -EINVAL;
	173	+ retval = oprofilefs_ulong_from_user(&val, buf, count);
	174	+ if (retval)
	175	+ return retval;
	176	+ if (val < oprofile_min_interval)
	177	+ oprofile_hw_interval = oprofile_min_interval;
	178	+ else if (val > oprofile_max_interval)
	179	+ oprofile_hw_interval = oprofile_max_interval;
	180	+ else
	181	+ oprofile_hw_interval = val;
	182	+
	183	+ return count;
	184	+}
	185	+
	186	+static const struct file_operations hw_interval_fops = {
	187	+ .read = hw_interval_read,
	188	+ .write = hw_interval_write,
	189	+};
	190	+
	191	+/*
	192	+ * File ops used for:
	193	+ * /dev/oprofile/0/event
	194	+ * Only a single event with number 0 is supported with this counter.
	195	+ *
	196	+ * /dev/oprofile/0/unit_mask
	197	+ * This is a dummy file needed by the user space tools.
	198	+ * No value other than 0 is accepted or returned.
	199	+ */
	200	+
	201	+static ssize_t hwsampler_zero_read(struct file file, char __user buf,
	202	+ size_t count, loff_t *offset)
	203	+{
	204	+ return oprofilefs_ulong_to_user(0, buf, count, offset);
	205	+}
	206	+
	207	+static ssize_t hwsampler_zero_write(struct file file, char const __user buf,
	208	+ size_t count, loff_t *offset)
	209	+{
	210	+ unsigned long val;
	211	+ int retval;
	212	+
	213	+ if (*offset)
	214	+ return -EINVAL;
	215	+
	216	+ retval = oprofilefs_ulong_from_user(&val, buf, count);
	217	+ if (retval)
	218	+ return retval;
	219	+ if (val != 0)
	220	+ return -EINVAL;
	221	+ return count;
	222	+}
	223	+
	224	+static const struct file_operations zero_fops = {
	225	+ .read = hwsampler_zero_read,
	226	+ .write = hwsampler_zero_write,
	227	+};
	228	+
	229	+/* /dev/oprofile/0/kernel file ops. */
	230	+
	231	+static ssize_t hwsampler_kernel_read(struct file file, char __user buf,
	232	+ size_t count, loff_t *offset)
	233	+{
	234	+ return oprofilefs_ulong_to_user(counter_config.kernel,
	235	+ buf, count, offset);
	236	+}
	237	+
	238	+static ssize_t hwsampler_kernel_write(struct file file, char const __user buf,
	239	+ size_t count, loff_t *offset)
	240	+{
	241	+ unsigned long val;
	242	+ int retval;
	243	+
	244	+ if (*offset)
	245	+ return -EINVAL;
	246	+
	247	+ retval = oprofilefs_ulong_from_user(&val, buf, count);
	248	+ if (retval)
	249	+ return retval;
	250	+
	251	+ if (val != 0 && val != 1)
	252	+ return -EINVAL;
	253	+
	254	+ counter_config.kernel = val;
	255	+
	256	+ return count;
	257	+}
	258	+
	259	+static const struct file_operations kernel_fops = {
	260	+ .read = hwsampler_kernel_read,
	261	+ .write = hwsampler_kernel_write,
	262	+};
	263	+
	264	+/* /dev/oprofile/0/user file ops. */
	265	+
	266	+static ssize_t hwsampler_user_read(struct file file, char __user buf,
	267	+ size_t count, loff_t *offset)
	268	+{
	269	+ return oprofilefs_ulong_to_user(counter_config.user,
	270	+ buf, count, offset);
	271	+}
	272	+
	273	+static ssize_t hwsampler_user_write(struct file file, char const __user buf,
	274	+ size_t count, loff_t *offset)
	275	+{
	276	+ unsigned long val;
	277	+ int retval;
	278	+
	279	+ if (*offset)
	280	+ return -EINVAL;
	281	+
	282	+ retval = oprofilefs_ulong_from_user(&val, buf, count);
	283	+ if (retval)
	284	+ return retval;
	285	+
	286	+ if (val != 0 && val != 1)
	287	+ return -EINVAL;
	288	+
	289	+ counter_config.user = val;
	290	+
	291	+ return count;
	292	+}
	293	+
	294	+static const struct file_operations user_fops = {
	295	+ .read = hwsampler_user_read,
	296	+ .write = hwsampler_user_write,
	297	+};
	298	+
	299	+
	300	+/*
	301	+ * File ops used for: /dev/oprofile/timer/enabled
	302	+ * The value always has to be the inverted value of hwsampler_enabled. So
	303	+ * no separate variable is created. That way we do not need locking.
	304	+ */
	305	+
	306	+static ssize_t timer_enabled_read(struct file file, char __user buf,
	307	+ size_t count, loff_t *offset)
	308	+{
	309	+ return oprofilefs_ulong_to_user(!hwsampler_enabled, buf, count, offset);
	310	+}
	311	+
	312	+static ssize_t timer_enabled_write(struct file file, char const __user buf,
	313	+ size_t count, loff_t *offset)
	314	+{
	315	+ unsigned long val;
	316	+ int retval;
	317	+
	318	+ if (*offset)
	319	+ return -EINVAL;
	320	+
	321	+ retval = oprofilefs_ulong_from_user(&val, buf, count);
	322	+ if (retval)
	323	+ return retval;
	324	+
	325	+ if (val != 0 && val != 1)
	326	+ return -EINVAL;
	327	+
	328	+ /* Timer cannot be disabled without having hardware sampling. */
	329	+ if (val == 0 && !hwsampler_available)
	330	+ return -EINVAL;
	331	+
	332	+ if (oprofile_started)
	333	+ /*
	334	+ * save to do without locking as we set
	335	+ * hwsampler_running in start() when start_mutex is
	336	+ * held
	337	+ */
	338	+ return -EBUSY;
	339	+
	340	+ hwsampler_enabled = !val;
	341	+
	342	+ return count;
	343	+}
	344	+
	345	+static const struct file_operations timer_enabled_fops = {
	346	+ .read = timer_enabled_read,
	347	+ .write = timer_enabled_write,
	348	+};
	349	+
	350	+
112	351	static int oprofile_create_hwsampling_files(struct super_block *sb,
113		- struct dentry *root)
	352	+ struct dentry *root)
114	353	{
115		- struct dentry *hw_dir;
	354	+ struct dentry *dir;
116	355
	356	+ dir = oprofilefs_mkdir(sb, root, "timer");
	357	+ if (!dir)
	358	+ return -EINVAL;
	359	+
	360	+ oprofilefs_create_file(sb, dir, "enabled", &timer_enabled_fops);
	361	+
	362	+ if (!hwsampler_available)
	363	+ return 0;
	364	+
117	365	/* reinitialize default values */
118		- hwsampler_file = 1;
	366	+ hwsampler_enabled = 1;
	367	+ counter_config.kernel = 1;
	368	+ counter_config.user = 1;
119	369
120		- hw_dir = oprofilefs_mkdir(sb, root, "hwsampling");
121		- if (!hw_dir)
122		- return -EINVAL;
	370	+ if (!force_cpu_type) {
	371	+ /*
	372	+ * Create the counter file system. A single virtual
	373	+ * counter is created which can be used to
	374	+ * enable/disable hardware sampling dynamically from
	375	+ * user space. The user space will configure a single
	376	+ * counter with a single event. The value of 'event'
	377	+ * and 'unit_mask' are not evaluated by the kernel code
	378	+ * and can only be set to 0.
	379	+ */
123	380
124		- oprofilefs_create_file(sb, hw_dir, "hwsampler", &hwsampler_fops);
125		- oprofilefs_create_ulong(sb, hw_dir, "hw_interval",
126		- &oprofile_hw_interval);
127		- oprofilefs_create_ro_ulong(sb, hw_dir, "hw_min_interval",
128		- &oprofile_min_interval);
129		- oprofilefs_create_ro_ulong(sb, hw_dir, "hw_max_interval",
130		- &oprofile_max_interval);
131		- oprofilefs_create_ulong(sb, hw_dir, "hw_sdbt_blocks",
132		- &oprofile_sdbt_blocks);
	381	+ dir = oprofilefs_mkdir(sb, root, "0");
	382	+ if (!dir)
	383	+ return -EINVAL;
133	384
	385	+ oprofilefs_create_file(sb, dir, "enabled", &hwsampler_fops);
	386	+ oprofilefs_create_file(sb, dir, "event", &zero_fops);
	387	+ oprofilefs_create_file(sb, dir, "count", &hw_interval_fops);
	388	+ oprofilefs_create_file(sb, dir, "unit_mask", &zero_fops);
	389	+ oprofilefs_create_file(sb, dir, "kernel", &kernel_fops);
	390	+ oprofilefs_create_file(sb, dir, "user", &user_fops);
	391	+ oprofilefs_create_ulong(sb, dir, "hw_sdbt_blocks",
	392	+ &oprofile_sdbt_blocks);
	393	+
	394	+ } else {
	395	+ /*
	396	+ * Hardware sampling can be used but the cpu_type is
	397	+ * forced to timer in order to deal with legacy user
	398	+ * space tools. The /dev/oprofile/hwsampling fs is
	399	+ * provided in that case.
	400	+ */
	401	+ dir = oprofilefs_mkdir(sb, root, "hwsampling");
	402	+ if (!dir)
	403	+ return -EINVAL;
	404	+
	405	+ oprofilefs_create_file(sb, dir, "hwsampler",
	406	+ &hwsampler_fops);
	407	+ oprofilefs_create_file(sb, dir, "hw_interval",
	408	+ &hw_interval_fops);
	409	+ oprofilefs_create_ro_ulong(sb, dir, "hw_min_interval",
	410	+ &oprofile_min_interval);
	411	+ oprofilefs_create_ro_ulong(sb, dir, "hw_max_interval",
	412	+ &oprofile_max_interval);
	413	+ oprofilefs_create_ulong(sb, dir, "hw_sdbt_blocks",
	414	+ &oprofile_sdbt_blocks);
	415	+ }
134	416	return 0;
135	417	}
136	418
137	419	static int oprofile_hwsampler_init(struct oprofile_operations *ops)
138	420	{
	421	+ /*
	422	+ * Initialize the timer mode infrastructure as well in order
	423	+ * to be able to switch back dynamically. oprofile_timer_init
	424	+ * is not supposed to fail.
	425	+ */
	426	+ if (oprofile_timer_init(ops))
	427	+ BUG();
	428	+
	429	+ memcpy(&timer_ops, ops, sizeof(timer_ops));
	430	+ ops->create_files = oprofile_create_hwsampling_files;
	431	+
	432	+ /*
	433	+ * If the user space tools do not support newer cpu types,
	434	+ * the force_cpu_type module parameter
	435	+ * can be used to always return \"timer\" as cpu type.
	436	+ */
	437	+ if (force_cpu_type != timer) {
	438	+ struct cpuid id;
	439	+
	440	+ get_cpu_id (&id);
	441	+
	442	+ switch (id.machine) {
	443	+ case 0x2097: case 0x2098: ops->cpu_type = "s390/z10"; break;
	444	+ case 0x2817: case 0x2818: ops->cpu_type = "s390/z196"; break;
	445	+ default: return -ENODEV;
	446	+ }
	447	+ }
	448	+
139	449	if (hwsampler_setup())
140	450	return -ENODEV;
141	451
142	452	/*
143		- * create hwsampler files only if hwsampler_setup() succeeds.
	453	+ * Query the range for the sampling interval from the
	454	+ * hardware.
144	455	*/
145	456	oprofile_min_interval = hwsampler_query_min_interval();
146	457	if (oprofile_min_interval == 0)
147	458
148	459
...	...	@@ -155,16 +466,11 @@
155	466	if (oprofile_hw_interval > oprofile_max_interval)
156	467	oprofile_hw_interval = oprofile_max_interval;
157	468
158		- if (oprofile_timer_init(ops))
159		- return -ENODEV;
	469	+ printk(KERN_INFO "oprofile: System z hardware sampling "
	470	+ "facility found.\n");
160	471
161		- printk(KERN_INFO "oprofile: using hardware sampling\n");
162		-
163		- memcpy(&timer_ops, ops, sizeof(timer_ops));
164		-
165	472	ops->start = oprofile_hwsampler_start;
166	473	ops->stop = oprofile_hwsampler_stop;
167		- ops->create_files = oprofile_create_hwsampling_files;
168	474
169	475	return 0;
170	476	}
...	...	@@ -181,7 +487,15 @@
181	487	ops->backtrace = s390_backtrace;
182	488
183	489	#ifdef CONFIG_64BIT
184		- return oprofile_hwsampler_init(ops);
	490	+
	491	+ /*
	492	+ * -ENODEV is not reported to the caller. The module itself
	493	+ * will use the timer mode sampling as fallback and this is
	494	+ * always available.
	495	+ */
	496	+ hwsampler_available = oprofile_hwsampler_init(ops) == 0;
	497	+
	498	+ return 0;
185	499	#else
186	500	return -ENODEV;
187	501	#endif
	1	+/**
	2	+ * arch/s390/oprofile/op_counter.h
	3	+ *
	4	+ * Copyright (C) 2011 IBM Deutschland Entwicklung GmbH, IBM Corporation
	5	+ * Author(s): Andreas Krebbel (krebbel@linux.vnet.ibm.com)
	6	+ *
	7	+ * @remark Copyright 2011 OProfile authors
	8	+ */
	9	+
	10	+#ifndef OP_COUNTER_H
	11	+#define OP_COUNTER_H
	12	+
	13	+struct op_counter_config {
	14	+ /* `enabled' maps to the hwsampler_file variable. */
	15	+ /* `count' maps to the oprofile_hw_interval variable. */
	16	+ /* `event' and `unit_mask' are unused. */
	17	+ unsigned long kernel;
	18	+ unsigned long user;
	19	+};
	20	+
	21	+extern struct op_counter_config counter_config;
	22	+
	23	+#endif /* OP_COUNTER_H */