Commit d62c8dee authored by Naveen N. Rao's avatar Naveen N. Rao Committed by Michael Ellerman
Browse files

powerpc/pseries: Provide vcpu dispatch statistics 



For Shared Processor LPARs, the POWER Hypervisor maintains a
relatively static mapping of the LPAR processors (vcpus) to physical
processor chips (representing the "home" node) and tries to always
dispatch vcpus on their associated physical processor chip. However,
under certain scenarios, vcpus may be dispatched on a different
processor chip (away from its home node). The actual physical
processor number on which a certain vcpu is dispatched is available to
the guest in the 'processor_id' field of each DTL entry.

The guest can discover the home node of each vcpu through the
H_HOME_NODE_ASSOCIATIVITY(flags=1) hcall. The guest can also discover
the associativity of physical processors, as represented in the DTL
entry, through the H_HOME_NODE_ASSOCIATIVITY(flags=2) hcall.

These can then be compared to determine if the vcpu was dispatched on
its home node or not. If the vcpu was not dispatched on the home node,
it is possible to determine if the vcpu was dispatched in a different
chip, socket or drawer.

Introduce a procfs file /proc/powerpc/vcpudispatch_stats that can be
used to obtain these statistics. Writing '1' to this file enables
collecting the statistics, while writing '0' disables the statistics.
The statistics themselves are available by reading the procfs file. By
default, the DTLB log for each vcpu is processed 50 times a second so
as not to miss any entries. This processing frequency can be changed
through /proc/powerpc/vcpudispatch_stats_freq.

Signed-off-by: default avatarNaveen N. Rao <naveen.n.rao@linux.vnet.ibm.com>
Signed-off-by: default avatarMichael Ellerman <mpe@ellerman.id.au>
parent 5a1ea477

arch/powerpc/include/asm/topology.h

+6 −0
Original line number Diff line number Diff line
@@ -35,6 +35,7 @@ static inline int pcibus_to_node(struct pci_bus *bus) 
				 cpu_all_mask :				\

				 cpumask_of_node(pcibus_to_node(bus)))



extern int cpu_distance(__be32 *cpu1_assoc, __be32 *cpu2_assoc);

extern int __node_distance(int, int);

#define node_distance(a, b) __node_distance(a, b)
@@ -84,6 +85,11 @@ static inline int numa_update_cpu_topology(bool cpus_locked) 


static inline void update_numa_cpu_lookup_table(unsigned int cpu, int node) {}



static inline int cpu_distance(__be32 *cpu1_assoc, __be32 *cpu2_assoc)

{

	return 0;

}



#endif /* CONFIG_NUMA */



#if defined(CONFIG_NUMA) && defined(CONFIG_PPC_SPLPAR)

arch/powerpc/mm/numa.c

+16 −0
Original line number Diff line number Diff line
@@ -167,6 +167,22 @@ static void unmap_cpu_from_node(unsigned long cpu) 
}

#endif /* CONFIG_HOTPLUG_CPU || CONFIG_PPC_SPLPAR */



int cpu_distance(__be32 *cpu1_assoc, __be32 *cpu2_assoc)

{

	int dist = 0;



	int i, index;



	for (i = 0; i < distance_ref_points_depth; i++) {

		index = be32_to_cpu(distance_ref_points[i]);

		if (cpu1_assoc[index] == cpu2_assoc[index])

			break;

		dist++;

	}



	return dist;

}



/* must hold reference to node during call */

static const __be32 *of_get_associativity(struct device_node *dev)

{

arch/powerpc/platforms/pseries/lpar.c

+523 −2
Original line number Diff line number Diff line
@@ -30,6 +30,10 @@ 
#include <linux/jump_label.h>

#include <linux/delay.h>

#include <linux/stop_machine.h>

#include <linux/spinlock.h>

#include <linux/cpuhotplug.h>

#include <linux/workqueue.h>

#include <linux/proc_fs.h>

#include <asm/processor.h>

#include <asm/mmu.h>

#include <asm/page.h>
@@ -65,6 +69,12 @@ EXPORT_SYMBOL(plpar_hcall); 
EXPORT_SYMBOL(plpar_hcall9);

EXPORT_SYMBOL(plpar_hcall_norets);



#ifdef CONFIG_VIRT_CPU_ACCOUNTING_NATIVE

static u8 dtl_mask = DTL_LOG_PREEMPT;

#else

static u8 dtl_mask;

#endif



void alloc_dtl_buffers(void)

{

	int cpu;
@@ -73,11 +83,15 @@ void alloc_dtl_buffers(void) 


	for_each_possible_cpu(cpu) {

		pp = paca_ptrs[cpu];

		if (pp->dispatch_log)

			continue;

		dtl = kmem_cache_alloc(dtl_cache, GFP_KERNEL);

		if (!dtl) {

			pr_warn("Failed to allocate dispatch trace log for cpu %d\n",

				cpu);

#ifdef CONFIG_VIRT_CPU_ACCOUNTING_NATIVE

			pr_warn("Stolen time statistics will be unreliable\n");

#endif

			break;

		}
@@ -97,7 +111,7 @@ void register_dtl_buffer(int cpu) 


	pp = paca_ptrs[cpu];

	dtl = pp->dispatch_log;

	if (dtl) {

	if (dtl && dtl_mask) {

		pp->dtl_ridx = 0;

		pp->dtl_curr = dtl;

		lppaca_of(cpu).dtl_idx = 0;
@@ -109,12 +123,519 @@ void register_dtl_buffer(int cpu) 
			pr_err("WARNING: DTL registration of cpu %d (hw %d) failed with %ld\n",

			       cpu, hwcpu, ret);



		lppaca_of(cpu).dtl_enable_mask = DTL_LOG_PREEMPT;

		lppaca_of(cpu).dtl_enable_mask = dtl_mask;

	}

}



#ifdef CONFIG_PPC_SPLPAR

struct dtl_worker {

	struct delayed_work work;

	int cpu;

};



struct vcpu_dispatch_data {

	int last_disp_cpu;



	int total_disp;



	int same_cpu_disp;

	int same_chip_disp;

	int diff_chip_disp;

	int far_chip_disp;



	int numa_home_disp;

	int numa_remote_disp;

	int numa_far_disp;

};



/*

 * This represents the number of cpus in the hypervisor. Since there is no

 * architected way to discover the number of processors in the host, we

 * provision for dealing with NR_CPUS. This is currently 2048 by default, and

 * is sufficient for our purposes. This will need to be tweaked if

 * CONFIG_NR_CPUS is changed.

 */

#define NR_CPUS_H	NR_CPUS



DEFINE_RWLOCK(dtl_access_lock);

static DEFINE_PER_CPU(struct vcpu_dispatch_data, vcpu_disp_data);

static DEFINE_PER_CPU(u64, dtl_entry_ridx);

static DEFINE_PER_CPU(struct dtl_worker, dtl_workers);

static enum cpuhp_state dtl_worker_state;

static DEFINE_MUTEX(dtl_enable_mutex);

static int vcpudispatch_stats_on __read_mostly;

static int vcpudispatch_stats_freq = 50;

static __be32 *vcpu_associativity, *pcpu_associativity;





static void free_dtl_buffers(void)

{

#ifndef CONFIG_VIRT_CPU_ACCOUNTING_NATIVE

	int cpu;

	struct paca_struct *pp;



	for_each_possible_cpu(cpu) {

		pp = paca_ptrs[cpu];

		if (!pp->dispatch_log)

			continue;

		kmem_cache_free(dtl_cache, pp->dispatch_log);

		pp->dtl_ridx = 0;

		pp->dispatch_log = 0;

		pp->dispatch_log_end = 0;

		pp->dtl_curr = 0;

	}

#endif

}



static int init_cpu_associativity(void)

{

	vcpu_associativity = kcalloc(num_possible_cpus() / threads_per_core,

			VPHN_ASSOC_BUFSIZE * sizeof(__be32), GFP_KERNEL);

	pcpu_associativity = kcalloc(NR_CPUS_H / threads_per_core,

			VPHN_ASSOC_BUFSIZE * sizeof(__be32), GFP_KERNEL);



	if (!vcpu_associativity || !pcpu_associativity) {

		pr_err("error allocating memory for associativity information\n");

		return -ENOMEM;

	}



	return 0;

}



static void destroy_cpu_associativity(void)

{

	kfree(vcpu_associativity);

	kfree(pcpu_associativity);

	vcpu_associativity = pcpu_associativity = 0;

}



static __be32 *__get_cpu_associativity(int cpu, __be32 *cpu_assoc, int flag)

{

	__be32 *assoc;

	int rc = 0;



	assoc = &cpu_assoc[(int)(cpu / threads_per_core) * VPHN_ASSOC_BUFSIZE];

	if (!assoc[0]) {

		rc = hcall_vphn(cpu, flag, &assoc[0]);

		if (rc)

			return NULL;

	}



	return assoc;

}



static __be32 *get_pcpu_associativity(int cpu)

{

	return __get_cpu_associativity(cpu, pcpu_associativity, VPHN_FLAG_PCPU);

}



static __be32 *get_vcpu_associativity(int cpu)

{

	return __get_cpu_associativity(cpu, vcpu_associativity, VPHN_FLAG_VCPU);

}



static int cpu_relative_dispatch_distance(int last_disp_cpu, int cur_disp_cpu)

{

	__be32 *last_disp_cpu_assoc, *cur_disp_cpu_assoc;



	if (last_disp_cpu >= NR_CPUS_H || cur_disp_cpu >= NR_CPUS_H)

		return -EINVAL;



	last_disp_cpu_assoc = get_pcpu_associativity(last_disp_cpu);

	cur_disp_cpu_assoc = get_pcpu_associativity(cur_disp_cpu);



	if (!last_disp_cpu_assoc || !cur_disp_cpu_assoc)

		return -EIO;



	return cpu_distance(last_disp_cpu_assoc, cur_disp_cpu_assoc);

}



static int cpu_home_node_dispatch_distance(int disp_cpu)

{

	__be32 *disp_cpu_assoc, *vcpu_assoc;

	int vcpu_id = smp_processor_id();



	if (disp_cpu >= NR_CPUS_H) {

		pr_debug_ratelimited("vcpu dispatch cpu %d > %d\n",

						disp_cpu, NR_CPUS_H);

		return -EINVAL;

	}



	disp_cpu_assoc = get_pcpu_associativity(disp_cpu);

	vcpu_assoc = get_vcpu_associativity(vcpu_id);



	if (!disp_cpu_assoc || !vcpu_assoc)

		return -EIO;



	return cpu_distance(disp_cpu_assoc, vcpu_assoc);

}



static void update_vcpu_disp_stat(int disp_cpu)

{

	struct vcpu_dispatch_data *disp;

	int distance;



	disp = this_cpu_ptr(&vcpu_disp_data);

	if (disp->last_disp_cpu == -1) {

		disp->last_disp_cpu = disp_cpu;

		return;

	}



	disp->total_disp++;



	if (disp->last_disp_cpu == disp_cpu ||

		(cpu_first_thread_sibling(disp->last_disp_cpu) ==

					cpu_first_thread_sibling(disp_cpu)))

		disp->same_cpu_disp++;

	else {

		distance = cpu_relative_dispatch_distance(disp->last_disp_cpu,

								disp_cpu);

		if (distance < 0)

			pr_debug_ratelimited("vcpudispatch_stats: cpu %d: error determining associativity\n",

					smp_processor_id());

		else {

			switch (distance) {

			case 0:

				disp->same_chip_disp++;

				break;

			case 1:

				disp->diff_chip_disp++;

				break;

			case 2:

				disp->far_chip_disp++;

				break;

			default:

				pr_debug_ratelimited("vcpudispatch_stats: cpu %d (%d -> %d): unexpected relative dispatch distance %d\n",

						 smp_processor_id(),

						 disp->last_disp_cpu,

						 disp_cpu,

						 distance);

			}

		}

	}



	distance = cpu_home_node_dispatch_distance(disp_cpu);

	if (distance < 0)

		pr_debug_ratelimited("vcpudispatch_stats: cpu %d: error determining associativity\n",

				smp_processor_id());

	else {

		switch (distance) {

		case 0:

			disp->numa_home_disp++;

			break;

		case 1:

			disp->numa_remote_disp++;

			break;

		case 2:

			disp->numa_far_disp++;

			break;

		default:

			pr_debug_ratelimited("vcpudispatch_stats: cpu %d on %d: unexpected numa dispatch distance %d\n",

						 smp_processor_id(),

						 disp_cpu,

						 distance);

		}

	}



	disp->last_disp_cpu = disp_cpu;

}



static void process_dtl_buffer(struct work_struct *work)

{

	struct dtl_entry dtle;

	u64 i = __this_cpu_read(dtl_entry_ridx);

	struct dtl_entry *dtl = local_paca->dispatch_log + (i % N_DISPATCH_LOG);

	struct dtl_entry *dtl_end = local_paca->dispatch_log_end;

	struct lppaca *vpa = local_paca->lppaca_ptr;

	struct dtl_worker *d = container_of(work, struct dtl_worker, work.work);



	if (!local_paca->dispatch_log)

		return;



	/* if we have been migrated away, we cancel ourself */

	if (d->cpu != smp_processor_id()) {

		pr_debug("vcpudispatch_stats: cpu %d worker migrated -- canceling worker\n",

						smp_processor_id());

		return;

	}



	if (i == be64_to_cpu(vpa->dtl_idx))

		goto out;



	while (i < be64_to_cpu(vpa->dtl_idx)) {

		dtle = *dtl;

		barrier();

		if (i + N_DISPATCH_LOG < be64_to_cpu(vpa->dtl_idx)) {

			/* buffer has overflowed */

			pr_debug_ratelimited("vcpudispatch_stats: cpu %d lost %lld DTL samples\n",

				d->cpu,

				be64_to_cpu(vpa->dtl_idx) - N_DISPATCH_LOG - i);

			i = be64_to_cpu(vpa->dtl_idx) - N_DISPATCH_LOG;

			dtl = local_paca->dispatch_log + (i % N_DISPATCH_LOG);

			continue;

		}

		update_vcpu_disp_stat(be16_to_cpu(dtle.processor_id));

		++i;

		++dtl;

		if (dtl == dtl_end)

			dtl = local_paca->dispatch_log;

	}



	__this_cpu_write(dtl_entry_ridx, i);



out:

	schedule_delayed_work_on(d->cpu, to_delayed_work(work),

					HZ / vcpudispatch_stats_freq);

}



static int dtl_worker_online(unsigned int cpu)

{

	struct dtl_worker *d = &per_cpu(dtl_workers, cpu);



	memset(d, 0, sizeof(*d));

	INIT_DELAYED_WORK(&d->work, process_dtl_buffer);

	d->cpu = cpu;



#ifndef CONFIG_VIRT_CPU_ACCOUNTING_NATIVE

	per_cpu(dtl_entry_ridx, cpu) = 0;

	register_dtl_buffer(cpu);

#else

	per_cpu(dtl_entry_ridx, cpu) = be64_to_cpu(lppaca_of(cpu).dtl_idx);

#endif



	schedule_delayed_work_on(cpu, &d->work, HZ / vcpudispatch_stats_freq);

	return 0;

}



static int dtl_worker_offline(unsigned int cpu)

{

	struct dtl_worker *d = &per_cpu(dtl_workers, cpu);



	cancel_delayed_work_sync(&d->work);



#ifndef CONFIG_VIRT_CPU_ACCOUNTING_NATIVE

	unregister_dtl(get_hard_smp_processor_id(cpu));

#endif



	return 0;

}



static void set_global_dtl_mask(u8 mask)

{

	int cpu;



	dtl_mask = mask;

	for_each_present_cpu(cpu)

		lppaca_of(cpu).dtl_enable_mask = dtl_mask;

}



static void reset_global_dtl_mask(void)

{

	int cpu;



#ifdef CONFIG_VIRT_CPU_ACCOUNTING_NATIVE

	dtl_mask = DTL_LOG_PREEMPT;

#else

	dtl_mask = 0;

#endif

	for_each_present_cpu(cpu)

		lppaca_of(cpu).dtl_enable_mask = dtl_mask;

}



static int dtl_worker_enable(void)

{

	int rc = 0, state;



	if (!write_trylock(&dtl_access_lock)) {

		rc = -EBUSY;

		goto out;

	}



	set_global_dtl_mask(DTL_LOG_ALL);



	/* Setup dtl buffers and register those */

	alloc_dtl_buffers();



	state = cpuhp_setup_state(CPUHP_AP_ONLINE_DYN, "powerpc/dtl:online",

					dtl_worker_online, dtl_worker_offline);

	if (state < 0) {

		pr_err("vcpudispatch_stats: unable to setup workqueue for DTL processing\n");

		free_dtl_buffers();

		reset_global_dtl_mask();

		write_unlock(&dtl_access_lock);

		rc = -EINVAL;

		goto out;

	}

	dtl_worker_state = state;



out:

	return rc;

}



static void dtl_worker_disable(void)

{

	cpuhp_remove_state(dtl_worker_state);

	free_dtl_buffers();

	reset_global_dtl_mask();

	write_unlock(&dtl_access_lock);

}



static ssize_t vcpudispatch_stats_write(struct file *file, const char __user *p,

		size_t count, loff_t *ppos)

{

	struct vcpu_dispatch_data *disp;

	int rc, cmd, cpu;

	char buf[16];



	if (count > 15)

		return -EINVAL;



	if (copy_from_user(buf, p, count))

		return -EFAULT;



	buf[count] = 0;

	rc = kstrtoint(buf, 0, &cmd);

	if (rc || cmd < 0 || cmd > 1) {

		pr_err("vcpudispatch_stats: please use 0 to disable or 1 to enable dispatch statistics\n");

		return rc ? rc : -EINVAL;

	}



	mutex_lock(&dtl_enable_mutex);



	if ((cmd == 0 && !vcpudispatch_stats_on) ||

			(cmd == 1 && vcpudispatch_stats_on))

		goto out;



	if (cmd) {

		rc = init_cpu_associativity();

		if (rc)

			goto out;



		for_each_possible_cpu(cpu) {

			disp = per_cpu_ptr(&vcpu_disp_data, cpu);

			memset(disp, 0, sizeof(*disp));

			disp->last_disp_cpu = -1;

		}



		rc = dtl_worker_enable();

		if (rc) {

			destroy_cpu_associativity();

			goto out;

		}

	} else {

		dtl_worker_disable();

		destroy_cpu_associativity();

	}



	vcpudispatch_stats_on = cmd;



out:

	mutex_unlock(&dtl_enable_mutex);

	if (rc)

		return rc;

	return count;

}



static int vcpudispatch_stats_display(struct seq_file *p, void *v)

{

	int cpu;

	struct vcpu_dispatch_data *disp;



	if (!vcpudispatch_stats_on) {

		seq_puts(p, "off\n");

		return 0;

	}



	for_each_online_cpu(cpu) {

		disp = per_cpu_ptr(&vcpu_disp_data, cpu);

		seq_printf(p, "cpu%d", cpu);

		seq_put_decimal_ull(p, " ", disp->total_disp);

		seq_put_decimal_ull(p, " ", disp->same_cpu_disp);

		seq_put_decimal_ull(p, " ", disp->same_chip_disp);

		seq_put_decimal_ull(p, " ", disp->diff_chip_disp);

		seq_put_decimal_ull(p, " ", disp->far_chip_disp);

		seq_put_decimal_ull(p, " ", disp->numa_home_disp);

		seq_put_decimal_ull(p, " ", disp->numa_remote_disp);

		seq_put_decimal_ull(p, " ", disp->numa_far_disp);

		seq_puts(p, "\n");

	}



	return 0;

}



static int vcpudispatch_stats_open(struct inode *inode, struct file *file)

{

	return single_open(file, vcpudispatch_stats_display, NULL);

}



static const struct file_operations vcpudispatch_stats_proc_ops = {

	.open		= vcpudispatch_stats_open,

	.read		= seq_read,

	.write		= vcpudispatch_stats_write,

	.llseek		= seq_lseek,

	.release	= single_release,

};



static ssize_t vcpudispatch_stats_freq_write(struct file *file,

		const char __user *p, size_t count, loff_t *ppos)

{

	int rc, freq;

	char buf[16];



	if (count > 15)

		return -EINVAL;



	if (copy_from_user(buf, p, count))

		return -EFAULT;



	buf[count] = 0;

	rc = kstrtoint(buf, 0, &freq);

	if (rc || freq < 1 || freq > HZ) {

		pr_err("vcpudispatch_stats_freq: please specify a frequency between 1 and %d\n",

				HZ);

		return rc ? rc : -EINVAL;

	}



	vcpudispatch_stats_freq = freq;



	return count;

}



static int vcpudispatch_stats_freq_display(struct seq_file *p, void *v)

{

	seq_printf(p, "%d\n", vcpudispatch_stats_freq);

	return 0;

}



static int vcpudispatch_stats_freq_open(struct inode *inode, struct file *file)

{

	return single_open(file, vcpudispatch_stats_freq_display, NULL);

}



static const struct file_operations vcpudispatch_stats_freq_proc_ops = {

	.open		= vcpudispatch_stats_freq_open,

	.read		= seq_read,

	.write		= vcpudispatch_stats_freq_write,

	.llseek		= seq_lseek,

	.release	= single_release,

};



static int __init vcpudispatch_stats_procfs_init(void)

{

	if (!lppaca_shared_proc(get_lppaca()))

		return 0;



	if (!proc_create("powerpc/vcpudispatch_stats", 0600, NULL,

					&vcpudispatch_stats_proc_ops))

		pr_err("vcpudispatch_stats: error creating procfs file\n");

	else if (!proc_create("powerpc/vcpudispatch_stats_freq", 0600, NULL,

					&vcpudispatch_stats_freq_proc_ops))

		pr_err("vcpudispatch_stats_freq: error creating procfs file\n");



	return 0;

}



machine_device_initcall(pseries, vcpudispatch_stats_procfs_init);

#endif /* CONFIG_PPC_SPLPAR */



void vpa_init(int cpu)

CRA Git | Maintained and supported by SUSTech CRA and CCSE