mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-28 20:02:17 +00:00
![Thomas Gleixner](/assets/img/avatar_default.png)
Qian Cai reported that the WARN_ON() in the x86/msi affinity setting code, which catches cases where the affinity setting is not done on the CPU which is the current target of the interrupt, triggers during CPU hotplug stress testing. It turns out that the warning which was added with the commit addressing the MSI affinity race unearthed yet another long standing bug. If user space writes a bogus affinity mask, i.e. it contains no online CPUs, then it calls irq_select_affinity_usr(). This was introduced for ALPHA ineee45269b0
("[PATCH] Alpha: convert to generic irq framework (generic part)") and subsequently made available for all architectures in1840475676
("genirq: Expose default irq affinity mask (take 3)") which introduced the circumvention of the affinity setting restrictions for interrupt which cannot be moved in process context. The whole exercise is bogus in various aspects: 1) If the interrupt is already started up then there is absolutely no point to honour a bogus interrupt affinity setting from user space. The interrupt is already assigned to an online CPU and it does not make any sense to reassign it to some other randomly chosen online CPU. 2) If the interupt is not yet started up then there is no point either. A subsequent startup of the interrupt will invoke irq_setup_affinity() anyway which will chose a valid target CPU. So the only correct solution is to just return -EINVAL in case user space wrote an affinity mask which does not contain any online CPUs, except for ALPHA which has it's own magic sauce for this. Fixes:1840475676
("genirq: Expose default irq affinity mask (take 3)") Reported-by: Qian Cai <cai@lca.pw> Signed-off-by: Thomas Gleixner <tglx@linutronix.de> Tested-by: Qian Cai <cai@lca.pw> Link: https://lkml.kernel.org/r/878sl8xdbm.fsf@nanos.tec.linutronix.de
537 lines
13 KiB
C
537 lines
13 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* 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 = irq_data_get_effective_affinity_mask(&desc->irq_data);
|
|
break;
|
|
#endif
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
#ifndef CONFIG_AUTO_IRQ_AFFINITY
|
|
static inline int irq_select_affinity_usr(unsigned int irq)
|
|
{
|
|
/*
|
|
* If the interrupt is started up already then this fails. The
|
|
* interrupt is assigned to an online CPU already. There is no
|
|
* point to move it around randomly. Tell user space that the
|
|
* selected mask is bogus.
|
|
*
|
|
* If not then any change to the affinity is pointless because the
|
|
* startup code invokes irq_setup_affinity() which will select
|
|
* a online CPU anyway.
|
|
*/
|
|
return -EINVAL;
|
|
}
|
|
#else
|
|
/* ALPHA magic affinity auto selector. Keep it for historical reasons. */
|
|
static inline int irq_select_affinity_usr(unsigned int irq)
|
|
{
|
|
return irq_select_affinity(irq);
|
|
}
|
|
#endif
|
|
|
|
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;
|
|
|
|
/*
|
|
* 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 {
|
|
err = irq_set_affinity(irq, new_value);
|
|
if (!err)
|
|
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 const struct proc_ops irq_affinity_proc_ops = {
|
|
.proc_open = irq_affinity_proc_open,
|
|
.proc_read = seq_read,
|
|
.proc_lseek = seq_lseek,
|
|
.proc_release = single_release,
|
|
.proc_write = irq_affinity_proc_write,
|
|
};
|
|
|
|
static const struct proc_ops irq_affinity_list_proc_ops = {
|
|
.proc_open = irq_affinity_list_proc_open,
|
|
.proc_read = seq_read,
|
|
.proc_lseek = seq_lseek,
|
|
.proc_release = single_release,
|
|
.proc_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);
|
|
}
|
|
#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;
|
|
|
|
/*
|
|
* 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 proc_ops default_affinity_proc_ops = {
|
|
.proc_open = default_affinity_open,
|
|
.proc_read = seq_read,
|
|
.proc_lseek = seq_lseek,
|
|
.proc_release = single_release,
|
|
.proc_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;
|
|
}
|
|
#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;
|
|
}
|
|
|
|
#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_ops, irqp);
|
|
|
|
/* create /proc/irq/<irq>/affinity_hint */
|
|
proc_create_single_data("affinity_hint", 0444, desc->dir,
|
|
irq_affinity_hint_proc_show, irqp);
|
|
|
|
/* create /proc/irq/<irq>/smp_affinity_list */
|
|
proc_create_data("smp_affinity_list", 0644, desc->dir,
|
|
&irq_affinity_list_proc_ops, irqp);
|
|
|
|
proc_create_single_data("node", 0444, desc->dir, irq_node_proc_show,
|
|
irqp);
|
|
# ifdef CONFIG_GENERIC_IRQ_EFFECTIVE_AFF_MASK
|
|
proc_create_single_data("effective_affinity", 0444, desc->dir,
|
|
irq_effective_aff_proc_show, irqp);
|
|
proc_create_single_data("effective_affinity_list", 0444, desc->dir,
|
|
irq_effective_aff_list_proc_show, irqp);
|
|
# endif
|
|
#endif
|
|
proc_create_single_data("spurious", 0444, desc->dir,
|
|
irq_spurious_proc_show, (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_ops);
|
|
#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');
|
|
}
|
|
|
|
rcu_read_lock();
|
|
desc = irq_to_desc(i);
|
|
if (!desc)
|
|
goto outsparse;
|
|
|
|
if (desc->kstat_irqs)
|
|
for_each_online_cpu(j)
|
|
any_count |= *per_cpu_ptr(desc->kstat_irqs, j);
|
|
|
|
if ((!desc->action || irq_desc_is_chained(desc)) && !any_count)
|
|
goto outsparse;
|
|
|
|
seq_printf(p, "%*d: ", prec, i);
|
|
for_each_online_cpu(j)
|
|
seq_printf(p, "%10u ", desc->kstat_irqs ?
|
|
*per_cpu_ptr(desc->kstat_irqs, j) : 0);
|
|
|
|
raw_spin_lock_irqsave(&desc->lock, flags);
|
|
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);
|
|
|
|
action = desc->action;
|
|
if (action) {
|
|
seq_printf(p, " %s", action->name);
|
|
while ((action = action->next) != NULL)
|
|
seq_printf(p, ", %s", action->name);
|
|
}
|
|
|
|
seq_putc(p, '\n');
|
|
raw_spin_unlock_irqrestore(&desc->lock, flags);
|
|
outsparse:
|
|
rcu_read_unlock();
|
|
return 0;
|
|
}
|
|
#endif
|