Release 4.7 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/perf_event.h>
#include <linux/init.h>
#include <linux/errno.h>
#include <linux/fs.h>
#include <linux/module.h>
#include <asm/processor.h>
#include <asm/perf_event.h>

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

#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;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
andreas krebbel
andreas krebbel
49
100.00%
1
100.00%
Total
49
100.00%
1
100.00%

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;

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

Contributors
Person
Tokens
Prop
Commits
CommitProp
hendrik brueckner
hendrik brueckner
44
100.00%
1
100.00%
Total
44
100.00%
1
100.00%



static int oprofile_hwsampler_start(void)
{
	int retval;

	hwsampler_running = hwsampler_enabled;

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

	retval = perf_reserve_sampling();
	if (retval)
		return retval;

	retval = __oprofile_hwsampler_start();
	if (retval)
		perf_release_sampling();

	return retval;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
heinz graalfs
heinz graalfs
47
88.68%
1
33.33%
hendrik brueckner
hendrik brueckner
5
9.43%
1
33.33%
andreas krebbel
andreas krebbel
1
1.89%
1
33.33%
Total
53
100.00%
3
100.00%



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

	hwsampler_stop_all();
	hwsampler_deallocate();
	perf_release_sampling();
	return;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
heinz graalfs
heinz graalfs
28
90.32%
1
50.00%
hendrik brueckner
hendrik brueckner
3
9.68%
1
50.00%
Total
31
100.00%
2
100.00%

/*
 * 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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
heinz graalfs
heinz graalfs
34
97.14%
1
50.00%
andreas krebbel
andreas krebbel
1
2.86%
1
50.00%
Total
35
100.00%
2
100.00%



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

Contributors
Person
Tokens
Prop
Commits
CommitProp
heinz graalfs
heinz graalfs
74
81.32%
1
33.33%
andreas krebbel
andreas krebbel
15
16.48%
1
33.33%
robert richter
robert richter
2
2.20%
1
33.33%
Total
91
100.00%
3
100.00%


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

Contributors
Person
Tokens
Prop
Commits
CommitProp
andreas krebbel
andreas krebbel
18
51.43%
1
50.00%
heinz graalfs
heinz graalfs
17
48.57%
1
50.00%
Total
35
100.00%
2
100.00%



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

Contributors
Person
Tokens
Prop
Commits
CommitProp
andreas krebbel
andreas krebbel
69
76.67%
1
25.00%
heinz graalfs
heinz graalfs
18
20.00%
1
25.00%
robert richter
robert richter
3
3.33%
2
50.00%
Total
90
100.00%
4
100.00%


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

Contributors
Person
Tokens
Prop
Commits
CommitProp
andreas krebbel
andreas krebbel
35
100.00%
1
100.00%
Total
35
100.00%
1
100.00%



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

Contributors
Person
Tokens
Prop
Commits
CommitProp
andreas krebbel
andreas krebbel
72
97.30%
1
50.00%
robert richter
robert richter
2
2.70%
1
50.00%
Total
74
100.00%
2
100.00%


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

Contributors
Person
Tokens
Prop
Commits
CommitProp
andreas krebbel
andreas krebbel
37
100.00%
1
100.00%
Total
37
100.00%
1
100.00%



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

Contributors
Person
Tokens
Prop
Commits
CommitProp
andreas krebbel
andreas krebbel
82
97.62%
1
50.00%
robert richter
robert richter
2
2.38%
1
50.00%
Total
84
100.00%
2
100.00%


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

Contributors
Person
Tokens
Prop
Commits
CommitProp
andreas krebbel
andreas krebbel
37
100.00%
1
100.00%
Total
37
100.00%
1
100.00%



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

Contributors
Person
Tokens
Prop
Commits
CommitProp
andreas krebbel
andreas krebbel
82
97.62%
1
50.00%
robert richter
robert richter
2
2.38%
1
50.00%
Total
84
100.00%
2
100.00%


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

Contributors
Person
Tokens
Prop
Commits
CommitProp
andreas krebbel
andreas krebbel
36
100.00%
1
100.00%
Total
36
100.00%
1
100.00%



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

Contributors
Person
Tokens
Prop
Commits
CommitProp
andreas krebbel
andreas krebbel
104
98.11%
1
50.00%
robert richter
robert richter
2
1.89%
1
50.00%
Total
106
100.00%
2
100.00%


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

Contributors
Person
Tokens
Prop
Commits
CommitProp
andreas krebbel
andreas krebbel
237
98.75%
1
50.00%
al viro
al viro
3
1.25%
1
50.00%
Total
240
100.00%
2
100.00%



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;
		case 0x2964: case 0x2965: ops->cpu_type = "s390/z13"; 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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
andreas krebbel
andreas krebbel
140
67.31%
2
28.57%
heinz graalfs
heinz graalfs
30
14.42%
1
14.29%
christian borntraeger
christian borntraeger
21
10.10%
1
14.29%
heiko carstens
heiko carstens
16
7.69%
2
28.57%
martin schwidefsky
martin schwidefsky
1
0.48%
1
14.29%
Total
208
100.00%
7
100.00%



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

Contributors
Person
Tokens
Prop
Commits
CommitProp
heinz graalfs
heinz graalfs
10
90.91%
1
50.00%
robert richter
robert richter
1
9.09%
1
50.00%
Total
11
100.00%
2
100.00%



static int __s390_backtrace(void *data, unsigned long address)
{
	unsigned int *depth = data;

	if (*depth == 0)
		return 1;
	(*depth)--;
	oprofile_add_trace(address);
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
heiko carstens
heiko carstens
45
100.00%
1
100.00%
Total
45
100.00%
1
100.00%



static void s390_backtrace(struct pt_regs *regs, unsigned int depth)
{
	if (user_mode(regs))
		return;
	dump_trace(__s390_backtrace, &depth, NULL, regs->gprs[15]);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
heiko carstens
heiko carstens
40
100.00%
1
100.00%
Total
40
100.00%
1
100.00%



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

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

Contributors
Person
Tokens
Prop
Commits
CommitProp
andreas krebbel
andreas krebbel
14
46.67%
2
40.00%
andrew morton
andrew morton
8
26.67%
1
20.00%
heinz graalfs
heinz graalfs
4
13.33%
1
20.00%
akinobu mita
akinobu mita
4
13.33%
1
20.00%
Total
30
100.00%
5
100.00%



void oprofile_arch_exit(void)
{
	oprofile_hwsampler_exit();
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
andrew morton
andrew morton
5
50.00%
1
50.00%
heinz graalfs
heinz graalfs
5
50.00%
1
50.00%
Total
10
100.00%
2
100.00%

Overall Contributors
Person
Tokens
Prop
Commits
CommitProp
andreas krebbel
andreas krebbel
1179
67.22%
3
15.00%
heinz graalfs
heinz graalfs
349
19.90%
2
10.00%
heiko carstens
heiko carstens
102
5.82%
4
20.00%
hendrik brueckner
hendrik brueckner
55
3.14%
1
5.00%
andrew morton
andrew morton
22
1.25%
1
5.00%
christian borntraeger
christian borntraeger
22
1.25%
2
10.00%
robert richter
robert richter
14
0.80%
3
15.00%
akinobu mita
akinobu mita
4
0.23%
1
5.00%
al viro
al viro
3
0.17%
1
5.00%
sebastian ott
sebastian ott
3
0.17%
1
5.00%
martin schwidefsky
martin schwidefsky
1
0.06%
1
5.00%
Total
1754
100.00%
20
100.00%
  
Directory: arch/s390/oprofile

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.