mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-12-06 03:36:39 +07:00
0d3f54257d
There is currently no way to evaluate the effective affinity mask of a given interrupt. Many irq chips allow only a single target CPU or a subset of CPUs in the affinity mask. Updating the mask at the time of setting the affinity to the subset would be counterproductive because information for cpu hotplug about assigned interrupt affinities gets lost. On CPU hotplug it's also pointless to force migrate an interrupt, which is not targeted at the CPU effectively. But currently the information is not available. Provide a seperate mask to be updated by the irq_chip->irq_set_affinity() implementations. Implement the read only proc files so the user can see the effective mask as well w/o trying to deduce it from /proc/interrupts. Signed-off-by: Thomas Gleixner <tglx@linutronix.de> Cc: Jens Axboe <axboe@kernel.dk> Cc: Marc Zyngier <marc.zyngier@arm.com> Cc: Michael Ellerman <mpe@ellerman.id.au> Cc: Keith Busch <keith.busch@intel.com> Cc: Peter Zijlstra <peterz@infradead.org> Cc: Christoph Hellwig <hch@lst.de> Link: http://lkml.kernel.org/r/20170619235446.247834245@linutronix.de
590 lines
14 KiB
C
590 lines
14 KiB
C
/*
|
|
* linux/kernel/irq/proc.c
|
|
*
|
|
* Copyright (C) 1992, 1998-2004 Linus Torvalds, Ingo Molnar
|
|
*
|
|
* This file contains the /proc/irq/ handling code.
|
|
*/
|
|
|
|
#include <linux/irq.h>
|
|
#include <linux/gfp.h>
|
|
#include <linux/proc_fs.h>
|
|
#include <linux/seq_file.h>
|
|
#include <linux/interrupt.h>
|
|
#include <linux/kernel_stat.h>
|
|
#include <linux/mutex.h>
|
|
|
|
#include "internals.h"
|
|
|
|
/*
|
|
* Access rules:
|
|
*
|
|
* procfs protects read/write of /proc/irq/N/ files against a
|
|
* concurrent free of the interrupt descriptor. remove_proc_entry()
|
|
* immediately prevents new read/writes to happen and waits for
|
|
* already running read/write functions to complete.
|
|
*
|
|
* We remove the proc entries first and then delete the interrupt
|
|
* descriptor from the radix tree and free it. So it is guaranteed
|
|
* that irq_to_desc(N) is valid as long as the read/writes are
|
|
* permitted by procfs.
|
|
*
|
|
* The read from /proc/interrupts is a different problem because there
|
|
* is no protection. So the lookup and the access to irqdesc
|
|
* information must be protected by sparse_irq_lock.
|
|
*/
|
|
static struct proc_dir_entry *root_irq_dir;
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
enum {
|
|
AFFINITY,
|
|
AFFINITY_LIST,
|
|
EFFECTIVE,
|
|
EFFECTIVE_LIST,
|
|
};
|
|
|
|
static int show_irq_affinity(int type, struct seq_file *m)
|
|
{
|
|
struct irq_desc *desc = irq_to_desc((long)m->private);
|
|
const struct cpumask *mask;
|
|
|
|
switch (type) {
|
|
case AFFINITY:
|
|
case AFFINITY_LIST:
|
|
mask = desc->irq_common_data.affinity;
|
|
#ifdef CONFIG_GENERIC_PENDING_IRQ
|
|
if (irqd_is_setaffinity_pending(&desc->irq_data))
|
|
mask = desc->pending_mask;
|
|
#endif
|
|
break;
|
|
case EFFECTIVE:
|
|
case EFFECTIVE_LIST:
|
|
#ifdef CONFIG_GENERIC_IRQ_EFFECTIVE_AFF_MASK
|
|
mask = desc->irq_common_data.effective_affinity;
|
|
break;
|
|
#else
|
|
return -EINVAL;
|
|
#endif
|
|
};
|
|
|
|
switch (type) {
|
|
case AFFINITY_LIST:
|
|
case EFFECTIVE_LIST:
|
|
seq_printf(m, "%*pbl\n", cpumask_pr_args(mask));
|
|
break;
|
|
case AFFINITY:
|
|
case EFFECTIVE:
|
|
seq_printf(m, "%*pb\n", cpumask_pr_args(mask));
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int irq_affinity_hint_proc_show(struct seq_file *m, void *v)
|
|
{
|
|
struct irq_desc *desc = irq_to_desc((long)m->private);
|
|
unsigned long flags;
|
|
cpumask_var_t mask;
|
|
|
|
if (!zalloc_cpumask_var(&mask, GFP_KERNEL))
|
|
return -ENOMEM;
|
|
|
|
raw_spin_lock_irqsave(&desc->lock, flags);
|
|
if (desc->affinity_hint)
|
|
cpumask_copy(mask, desc->affinity_hint);
|
|
raw_spin_unlock_irqrestore(&desc->lock, flags);
|
|
|
|
seq_printf(m, "%*pb\n", cpumask_pr_args(mask));
|
|
free_cpumask_var(mask);
|
|
|
|
return 0;
|
|
}
|
|
|
|
#ifndef is_affinity_mask_valid
|
|
#define is_affinity_mask_valid(val) 1
|
|
#endif
|
|
|
|
int no_irq_affinity;
|
|
static int irq_affinity_proc_show(struct seq_file *m, void *v)
|
|
{
|
|
return show_irq_affinity(AFFINITY, m);
|
|
}
|
|
|
|
static int irq_affinity_list_proc_show(struct seq_file *m, void *v)
|
|
{
|
|
return show_irq_affinity(AFFINITY_LIST, m);
|
|
}
|
|
|
|
|
|
static ssize_t write_irq_affinity(int type, struct file *file,
|
|
const char __user *buffer, size_t count, loff_t *pos)
|
|
{
|
|
unsigned int irq = (int)(long)PDE_DATA(file_inode(file));
|
|
cpumask_var_t new_value;
|
|
int err;
|
|
|
|
if (!irq_can_set_affinity_usr(irq) || no_irq_affinity)
|
|
return -EIO;
|
|
|
|
if (!alloc_cpumask_var(&new_value, GFP_KERNEL))
|
|
return -ENOMEM;
|
|
|
|
if (type)
|
|
err = cpumask_parselist_user(buffer, count, new_value);
|
|
else
|
|
err = cpumask_parse_user(buffer, count, new_value);
|
|
if (err)
|
|
goto free_cpumask;
|
|
|
|
if (!is_affinity_mask_valid(new_value)) {
|
|
err = -EINVAL;
|
|
goto free_cpumask;
|
|
}
|
|
|
|
/*
|
|
* Do not allow disabling IRQs completely - it's a too easy
|
|
* way to make the system unusable accidentally :-) At least
|
|
* one online CPU still has to be targeted.
|
|
*/
|
|
if (!cpumask_intersects(new_value, cpu_online_mask)) {
|
|
/*
|
|
* Special case for empty set - allow the architecture code
|
|
* to set default SMP affinity.
|
|
*/
|
|
err = irq_select_affinity_usr(irq) ? -EINVAL : count;
|
|
} else {
|
|
irq_set_affinity(irq, new_value);
|
|
err = count;
|
|
}
|
|
|
|
free_cpumask:
|
|
free_cpumask_var(new_value);
|
|
return err;
|
|
}
|
|
|
|
static ssize_t irq_affinity_proc_write(struct file *file,
|
|
const char __user *buffer, size_t count, loff_t *pos)
|
|
{
|
|
return write_irq_affinity(0, file, buffer, count, pos);
|
|
}
|
|
|
|
static ssize_t irq_affinity_list_proc_write(struct file *file,
|
|
const char __user *buffer, size_t count, loff_t *pos)
|
|
{
|
|
return write_irq_affinity(1, file, buffer, count, pos);
|
|
}
|
|
|
|
static int irq_affinity_proc_open(struct inode *inode, struct file *file)
|
|
{
|
|
return single_open(file, irq_affinity_proc_show, PDE_DATA(inode));
|
|
}
|
|
|
|
static int irq_affinity_list_proc_open(struct inode *inode, struct file *file)
|
|
{
|
|
return single_open(file, irq_affinity_list_proc_show, PDE_DATA(inode));
|
|
}
|
|
|
|
static int irq_affinity_hint_proc_open(struct inode *inode, struct file *file)
|
|
{
|
|
return single_open(file, irq_affinity_hint_proc_show, PDE_DATA(inode));
|
|
}
|
|
|
|
static const struct file_operations irq_affinity_proc_fops = {
|
|
.open = irq_affinity_proc_open,
|
|
.read = seq_read,
|
|
.llseek = seq_lseek,
|
|
.release = single_release,
|
|
.write = irq_affinity_proc_write,
|
|
};
|
|
|
|
static const struct file_operations irq_affinity_hint_proc_fops = {
|
|
.open = irq_affinity_hint_proc_open,
|
|
.read = seq_read,
|
|
.llseek = seq_lseek,
|
|
.release = single_release,
|
|
};
|
|
|
|
static const struct file_operations irq_affinity_list_proc_fops = {
|
|
.open = irq_affinity_list_proc_open,
|
|
.read = seq_read,
|
|
.llseek = seq_lseek,
|
|
.release = single_release,
|
|
.write = irq_affinity_list_proc_write,
|
|
};
|
|
|
|
#ifdef CONFIG_GENERIC_IRQ_EFFECTIVE_AFF_MASK
|
|
static int irq_effective_aff_proc_show(struct seq_file *m, void *v)
|
|
{
|
|
return show_irq_affinity(EFFECTIVE, m);
|
|
}
|
|
|
|
static int irq_effective_aff_list_proc_show(struct seq_file *m, void *v)
|
|
{
|
|
return show_irq_affinity(EFFECTIVE_LIST, m);
|
|
}
|
|
|
|
static int irq_effective_aff_proc_open(struct inode *inode, struct file *file)
|
|
{
|
|
return single_open(file, irq_effective_aff_proc_show, PDE_DATA(inode));
|
|
}
|
|
|
|
static int irq_effective_aff_list_proc_open(struct inode *inode,
|
|
struct file *file)
|
|
{
|
|
return single_open(file, irq_effective_aff_list_proc_show,
|
|
PDE_DATA(inode));
|
|
}
|
|
|
|
static const struct file_operations irq_effective_aff_proc_fops = {
|
|
.open = irq_effective_aff_proc_open,
|
|
.read = seq_read,
|
|
.llseek = seq_lseek,
|
|
.release = single_release,
|
|
};
|
|
|
|
static const struct file_operations irq_effective_aff_list_proc_fops = {
|
|
.open = irq_effective_aff_list_proc_open,
|
|
.read = seq_read,
|
|
.llseek = seq_lseek,
|
|
.release = single_release,
|
|
};
|
|
#endif
|
|
|
|
static int default_affinity_show(struct seq_file *m, void *v)
|
|
{
|
|
seq_printf(m, "%*pb\n", cpumask_pr_args(irq_default_affinity));
|
|
return 0;
|
|
}
|
|
|
|
static ssize_t default_affinity_write(struct file *file,
|
|
const char __user *buffer, size_t count, loff_t *ppos)
|
|
{
|
|
cpumask_var_t new_value;
|
|
int err;
|
|
|
|
if (!alloc_cpumask_var(&new_value, GFP_KERNEL))
|
|
return -ENOMEM;
|
|
|
|
err = cpumask_parse_user(buffer, count, new_value);
|
|
if (err)
|
|
goto out;
|
|
|
|
if (!is_affinity_mask_valid(new_value)) {
|
|
err = -EINVAL;
|
|
goto out;
|
|
}
|
|
|
|
/*
|
|
* Do not allow disabling IRQs completely - it's a too easy
|
|
* way to make the system unusable accidentally :-) At least
|
|
* one online CPU still has to be targeted.
|
|
*/
|
|
if (!cpumask_intersects(new_value, cpu_online_mask)) {
|
|
err = -EINVAL;
|
|
goto out;
|
|
}
|
|
|
|
cpumask_copy(irq_default_affinity, new_value);
|
|
err = count;
|
|
|
|
out:
|
|
free_cpumask_var(new_value);
|
|
return err;
|
|
}
|
|
|
|
static int default_affinity_open(struct inode *inode, struct file *file)
|
|
{
|
|
return single_open(file, default_affinity_show, PDE_DATA(inode));
|
|
}
|
|
|
|
static const struct file_operations default_affinity_proc_fops = {
|
|
.open = default_affinity_open,
|
|
.read = seq_read,
|
|
.llseek = seq_lseek,
|
|
.release = single_release,
|
|
.write = default_affinity_write,
|
|
};
|
|
|
|
static int irq_node_proc_show(struct seq_file *m, void *v)
|
|
{
|
|
struct irq_desc *desc = irq_to_desc((long) m->private);
|
|
|
|
seq_printf(m, "%d\n", irq_desc_get_node(desc));
|
|
return 0;
|
|
}
|
|
|
|
static int irq_node_proc_open(struct inode *inode, struct file *file)
|
|
{
|
|
return single_open(file, irq_node_proc_show, PDE_DATA(inode));
|
|
}
|
|
|
|
static const struct file_operations irq_node_proc_fops = {
|
|
.open = irq_node_proc_open,
|
|
.read = seq_read,
|
|
.llseek = seq_lseek,
|
|
.release = single_release,
|
|
};
|
|
#endif
|
|
|
|
static int irq_spurious_proc_show(struct seq_file *m, void *v)
|
|
{
|
|
struct irq_desc *desc = irq_to_desc((long) m->private);
|
|
|
|
seq_printf(m, "count %u\n" "unhandled %u\n" "last_unhandled %u ms\n",
|
|
desc->irq_count, desc->irqs_unhandled,
|
|
jiffies_to_msecs(desc->last_unhandled));
|
|
return 0;
|
|
}
|
|
|
|
static int irq_spurious_proc_open(struct inode *inode, struct file *file)
|
|
{
|
|
return single_open(file, irq_spurious_proc_show, PDE_DATA(inode));
|
|
}
|
|
|
|
static const struct file_operations irq_spurious_proc_fops = {
|
|
.open = irq_spurious_proc_open,
|
|
.read = seq_read,
|
|
.llseek = seq_lseek,
|
|
.release = single_release,
|
|
};
|
|
|
|
#define MAX_NAMELEN 128
|
|
|
|
static int name_unique(unsigned int irq, struct irqaction *new_action)
|
|
{
|
|
struct irq_desc *desc = irq_to_desc(irq);
|
|
struct irqaction *action;
|
|
unsigned long flags;
|
|
int ret = 1;
|
|
|
|
raw_spin_lock_irqsave(&desc->lock, flags);
|
|
for_each_action_of_desc(desc, action) {
|
|
if ((action != new_action) && action->name &&
|
|
!strcmp(new_action->name, action->name)) {
|
|
ret = 0;
|
|
break;
|
|
}
|
|
}
|
|
raw_spin_unlock_irqrestore(&desc->lock, flags);
|
|
return ret;
|
|
}
|
|
|
|
void register_handler_proc(unsigned int irq, struct irqaction *action)
|
|
{
|
|
char name [MAX_NAMELEN];
|
|
struct irq_desc *desc = irq_to_desc(irq);
|
|
|
|
if (!desc->dir || action->dir || !action->name ||
|
|
!name_unique(irq, action))
|
|
return;
|
|
|
|
snprintf(name, MAX_NAMELEN, "%s", action->name);
|
|
|
|
/* create /proc/irq/1234/handler/ */
|
|
action->dir = proc_mkdir(name, desc->dir);
|
|
}
|
|
|
|
#undef MAX_NAMELEN
|
|
|
|
#define MAX_NAMELEN 10
|
|
|
|
void register_irq_proc(unsigned int irq, struct irq_desc *desc)
|
|
{
|
|
static DEFINE_MUTEX(register_lock);
|
|
void __maybe_unused *irqp = (void *)(unsigned long) irq;
|
|
char name [MAX_NAMELEN];
|
|
|
|
if (!root_irq_dir || (desc->irq_data.chip == &no_irq_chip))
|
|
return;
|
|
|
|
/*
|
|
* irq directories are registered only when a handler is
|
|
* added, not when the descriptor is created, so multiple
|
|
* tasks might try to register at the same time.
|
|
*/
|
|
mutex_lock(®ister_lock);
|
|
|
|
if (desc->dir)
|
|
goto out_unlock;
|
|
|
|
sprintf(name, "%d", irq);
|
|
|
|
/* create /proc/irq/1234 */
|
|
desc->dir = proc_mkdir(name, root_irq_dir);
|
|
if (!desc->dir)
|
|
goto out_unlock;
|
|
|
|
#ifdef CONFIG_SMP
|
|
/* create /proc/irq/<irq>/smp_affinity */
|
|
proc_create_data("smp_affinity", 0644, desc->dir,
|
|
&irq_affinity_proc_fops, irqp);
|
|
|
|
/* create /proc/irq/<irq>/affinity_hint */
|
|
proc_create_data("affinity_hint", 0444, desc->dir,
|
|
&irq_affinity_hint_proc_fops, irqp);
|
|
|
|
/* create /proc/irq/<irq>/smp_affinity_list */
|
|
proc_create_data("smp_affinity_list", 0644, desc->dir,
|
|
&irq_affinity_list_proc_fops, irqp);
|
|
|
|
proc_create_data("node", 0444, desc->dir,
|
|
&irq_node_proc_fops, irqp);
|
|
# ifdef CONFIG_GENERIC_IRQ_EFFECTIVE_AFF_MASK
|
|
proc_create_data("effective_affinity", 0444, desc->dir,
|
|
&irq_effective_aff_proc_fops, irqp);
|
|
proc_create_data("effective_affinity_list", 0444, desc->dir,
|
|
&irq_effective_aff_list_proc_fops, irqp);
|
|
# endif
|
|
#endif
|
|
proc_create_data("spurious", 0444, desc->dir,
|
|
&irq_spurious_proc_fops, (void *)(long)irq);
|
|
|
|
out_unlock:
|
|
mutex_unlock(®ister_lock);
|
|
}
|
|
|
|
void unregister_irq_proc(unsigned int irq, struct irq_desc *desc)
|
|
{
|
|
char name [MAX_NAMELEN];
|
|
|
|
if (!root_irq_dir || !desc->dir)
|
|
return;
|
|
#ifdef CONFIG_SMP
|
|
remove_proc_entry("smp_affinity", desc->dir);
|
|
remove_proc_entry("affinity_hint", desc->dir);
|
|
remove_proc_entry("smp_affinity_list", desc->dir);
|
|
remove_proc_entry("node", desc->dir);
|
|
# ifdef CONFIG_GENERIC_IRQ_EFFECTIVE_AFF_MASK
|
|
remove_proc_entry("effective_affinity", desc->dir);
|
|
remove_proc_entry("effective_affinity_list", desc->dir);
|
|
# endif
|
|
#endif
|
|
remove_proc_entry("spurious", desc->dir);
|
|
|
|
sprintf(name, "%u", irq);
|
|
remove_proc_entry(name, root_irq_dir);
|
|
}
|
|
|
|
#undef MAX_NAMELEN
|
|
|
|
void unregister_handler_proc(unsigned int irq, struct irqaction *action)
|
|
{
|
|
proc_remove(action->dir);
|
|
}
|
|
|
|
static void register_default_affinity_proc(void)
|
|
{
|
|
#ifdef CONFIG_SMP
|
|
proc_create("irq/default_smp_affinity", 0644, NULL,
|
|
&default_affinity_proc_fops);
|
|
#endif
|
|
}
|
|
|
|
void init_irq_proc(void)
|
|
{
|
|
unsigned int irq;
|
|
struct irq_desc *desc;
|
|
|
|
/* create /proc/irq */
|
|
root_irq_dir = proc_mkdir("irq", NULL);
|
|
if (!root_irq_dir)
|
|
return;
|
|
|
|
register_default_affinity_proc();
|
|
|
|
/*
|
|
* Create entries for all existing IRQs.
|
|
*/
|
|
for_each_irq_desc(irq, desc)
|
|
register_irq_proc(irq, desc);
|
|
}
|
|
|
|
#ifdef CONFIG_GENERIC_IRQ_SHOW
|
|
|
|
int __weak arch_show_interrupts(struct seq_file *p, int prec)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
#ifndef ACTUAL_NR_IRQS
|
|
# define ACTUAL_NR_IRQS nr_irqs
|
|
#endif
|
|
|
|
int show_interrupts(struct seq_file *p, void *v)
|
|
{
|
|
static int prec;
|
|
|
|
unsigned long flags, any_count = 0;
|
|
int i = *(loff_t *) v, j;
|
|
struct irqaction *action;
|
|
struct irq_desc *desc;
|
|
|
|
if (i > ACTUAL_NR_IRQS)
|
|
return 0;
|
|
|
|
if (i == ACTUAL_NR_IRQS)
|
|
return arch_show_interrupts(p, prec);
|
|
|
|
/* print header and calculate the width of the first column */
|
|
if (i == 0) {
|
|
for (prec = 3, j = 1000; prec < 10 && j <= nr_irqs; ++prec)
|
|
j *= 10;
|
|
|
|
seq_printf(p, "%*s", prec + 8, "");
|
|
for_each_online_cpu(j)
|
|
seq_printf(p, "CPU%-8d", j);
|
|
seq_putc(p, '\n');
|
|
}
|
|
|
|
irq_lock_sparse();
|
|
desc = irq_to_desc(i);
|
|
if (!desc)
|
|
goto outsparse;
|
|
|
|
raw_spin_lock_irqsave(&desc->lock, flags);
|
|
for_each_online_cpu(j)
|
|
any_count |= kstat_irqs_cpu(i, j);
|
|
action = desc->action;
|
|
if ((!action || irq_desc_is_chained(desc)) && !any_count)
|
|
goto out;
|
|
|
|
seq_printf(p, "%*d: ", prec, i);
|
|
for_each_online_cpu(j)
|
|
seq_printf(p, "%10u ", kstat_irqs_cpu(i, j));
|
|
|
|
if (desc->irq_data.chip) {
|
|
if (desc->irq_data.chip->irq_print_chip)
|
|
desc->irq_data.chip->irq_print_chip(&desc->irq_data, p);
|
|
else if (desc->irq_data.chip->name)
|
|
seq_printf(p, " %8s", desc->irq_data.chip->name);
|
|
else
|
|
seq_printf(p, " %8s", "-");
|
|
} else {
|
|
seq_printf(p, " %8s", "None");
|
|
}
|
|
if (desc->irq_data.domain)
|
|
seq_printf(p, " %*d", prec, (int) desc->irq_data.hwirq);
|
|
else
|
|
seq_printf(p, " %*s", prec, "");
|
|
#ifdef CONFIG_GENERIC_IRQ_SHOW_LEVEL
|
|
seq_printf(p, " %-8s", irqd_is_level_type(&desc->irq_data) ? "Level" : "Edge");
|
|
#endif
|
|
if (desc->name)
|
|
seq_printf(p, "-%-8s", desc->name);
|
|
|
|
if (action) {
|
|
seq_printf(p, " %s", action->name);
|
|
while ((action = action->next) != NULL)
|
|
seq_printf(p, ", %s", action->name);
|
|
}
|
|
|
|
seq_putc(p, '\n');
|
|
out:
|
|
raw_spin_unlock_irqrestore(&desc->lock, flags);
|
|
outsparse:
|
|
irq_unlock_sparse();
|
|
return 0;
|
|
}
|
|
#endif
|