| /* | |
| * 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(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(dir, "enabled", &hwsampler_fops); | |
| oprofilefs_create_file(dir, "event", &zero_fops); | |
| oprofilefs_create_file(dir, "count", &hw_interval_fops); | |
| oprofilefs_create_file(dir, "unit_mask", &zero_fops); | |
| oprofilefs_create_file(dir, "kernel", &kernel_fops); | |
| oprofilefs_create_file(dir, "user", &user_fops); | |
| oprofilefs_create_ulong(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(dir, "hwsampler", | |
| &hwsampler_fops); | |
| oprofilefs_create_file(dir, "hw_interval", | |
| &hw_interval_fops); | |
| oprofilefs_create_ro_ulong(dir, "hw_min_interval", | |
| &oprofile_min_interval); | |
| oprofilefs_create_ro_ulong(dir, "hw_max_interval", | |
| &oprofile_max_interval); | |
| oprofilefs_create_ulong(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 | |
| } |