irq.c 6.4 KB
Newer Older
1 2 3 4 5 6 7
/*
 * Common interrupt code for 32 and 64 bit
 */
#include <linux/cpu.h>
#include <linux/interrupt.h>
#include <linux/kernel_stat.h>
#include <linux/seq_file.h>
8
#include <linux/smp.h>
J
Jeremy Fitzhardinge 已提交
9
#include <linux/ftrace.h>
10

I
Ingo Molnar 已提交
11
#include <asm/apic.h>
12
#include <asm/io_apic.h>
13
#include <asm/irq.h>
J
Jeremy Fitzhardinge 已提交
14
#include <asm/idle.h>
15
#include <asm/mce.h>
16 17 18

atomic_t irq_err_count;

19 20 21
/* Function pointer for generic interrupt vector handling */
void (*generic_interrupt_extension)(void) = NULL;

T
Thomas Gleixner 已提交
22 23 24 25 26 27
/*
 * 'what should we do if we get a hw irq event on an illegal vector'.
 * each architecture has to answer this themselves.
 */
void ack_bad_irq(unsigned int irq)
{
C
Cyrill Gorcunov 已提交
28 29
	if (printk_ratelimit())
		pr_err("unexpected IRQ trap at vector %02x\n", irq);
T
Thomas Gleixner 已提交
30 31 32 33 34 35 36 37 38 39

	/*
	 * Currently unexpected vectors happen only on SMP and APIC.
	 * We _must_ ack these because every local APIC has only N
	 * irq slots per priority level, and a 'hanging, unacked' IRQ
	 * holds up an irq slot - in excessive cases (when multiple
	 * unexpected vectors occur) that might lock up the APIC
	 * completely.
	 * But only ack when the APIC is enabled -AK
	 */
40
	ack_APIC_irq();
T
Thomas Gleixner 已提交
41 42
}

43
#define irq_stats(x)		(&per_cpu(irq_stat, x))
44 45 46
/*
 * /proc/interrupts printing:
 */
47
static int show_other_interrupts(struct seq_file *p, int prec)
48 49 50
{
	int j;

51
	seq_printf(p, "%*s: ", prec, "NMI");
52 53 54 55
	for_each_online_cpu(j)
		seq_printf(p, "%10u ", irq_stats(j)->__nmi_count);
	seq_printf(p, "  Non-maskable interrupts\n");
#ifdef CONFIG_X86_LOCAL_APIC
56
	seq_printf(p, "%*s: ", prec, "LOC");
57 58 59
	for_each_online_cpu(j)
		seq_printf(p, "%10u ", irq_stats(j)->apic_timer_irqs);
	seq_printf(p, "  Local timer interrupts\n");
60 61 62 63 64

	seq_printf(p, "%*s: ", prec, "SPU");
	for_each_online_cpu(j)
		seq_printf(p, "%10u ", irq_stats(j)->irq_spurious_count);
	seq_printf(p, "  Spurious interrupts\n");
65
#endif
66
	if (generic_interrupt_extension) {
67
		seq_printf(p, "%*s: ", prec, "PLT");
68 69 70 71
		for_each_online_cpu(j)
			seq_printf(p, "%10u ", irq_stats(j)->generic_irqs);
		seq_printf(p, "  Platform interrupts\n");
	}
72
#ifdef CONFIG_SMP
73
	seq_printf(p, "%*s: ", prec, "RES");
74 75 76
	for_each_online_cpu(j)
		seq_printf(p, "%10u ", irq_stats(j)->irq_resched_count);
	seq_printf(p, "  Rescheduling interrupts\n");
77
	seq_printf(p, "%*s: ", prec, "CAL");
78 79 80
	for_each_online_cpu(j)
		seq_printf(p, "%10u ", irq_stats(j)->irq_call_count);
	seq_printf(p, "  Function call interrupts\n");
81
	seq_printf(p, "%*s: ", prec, "TLB");
82 83 84 85 86
	for_each_online_cpu(j)
		seq_printf(p, "%10u ", irq_stats(j)->irq_tlb_count);
	seq_printf(p, "  TLB shootdowns\n");
#endif
#ifdef CONFIG_X86_MCE
87
	seq_printf(p, "%*s: ", prec, "TRM");
88 89 90
	for_each_online_cpu(j)
		seq_printf(p, "%10u ", irq_stats(j)->irq_thermal_count);
	seq_printf(p, "  Thermal event interrupts\n");
91
# ifdef CONFIG_X86_MCE_THRESHOLD
92
	seq_printf(p, "%*s: ", prec, "THR");
93 94 95 96
	for_each_online_cpu(j)
		seq_printf(p, "%10u ", irq_stats(j)->irq_threshold_count);
	seq_printf(p, "  Threshold APIC interrupts\n");
# endif
97 98 99 100 101 102
#endif
#if defined(CONFIG_X86_MCE) && defined(CONFIG_X86_64)
	seq_printf(p, "%*s: ", prec, "MCE");
	for_each_online_cpu(j)
		seq_printf(p, "%10u ", per_cpu(mce_exception_count, j));
	seq_printf(p, "  Machine check exceptions\n");
103 104 105 106
	seq_printf(p, "%*s: ", prec, "MCP");
	for_each_online_cpu(j)
		seq_printf(p, "%10u ", per_cpu(mce_poll_count, j));
	seq_printf(p, "  Machine check polls\n");
107
#endif
108
	seq_printf(p, "%*s: %10u\n", prec, "ERR", atomic_read(&irq_err_count));
109
#if defined(CONFIG_X86_IO_APIC)
110
	seq_printf(p, "%*s: %10u\n", prec, "MIS", atomic_read(&irq_mis_count));
111 112 113 114 115 116 117
#endif
	return 0;
}

int show_interrupts(struct seq_file *p, void *v)
{
	unsigned long flags, any_count = 0;
118
	int i = *(loff_t *) v, j, prec;
119 120 121 122 123 124
	struct irqaction *action;
	struct irq_desc *desc;

	if (i > nr_irqs)
		return 0;

125 126 127
	for (prec = 3, j = 1000; prec < 10 && j <= nr_irqs; ++prec)
		j *= 10;

128
	if (i == nr_irqs)
129
		return show_other_interrupts(p, prec);
130 131 132

	/* print header */
	if (i == 0) {
133
		seq_printf(p, "%*s", prec + 8, "");
134
		for_each_online_cpu(j)
135
			seq_printf(p, "CPU%-8d", j);
136 137 138 139
		seq_putc(p, '\n');
	}

	desc = irq_to_desc(i);
140 141 142
	if (!desc)
		return 0;

143 144 145 146 147 148 149
	spin_lock_irqsave(&desc->lock, flags);
	for_each_online_cpu(j)
		any_count |= kstat_irqs_cpu(i, j);
	action = desc->action;
	if (!action && !any_count)
		goto out;

150
	seq_printf(p, "%*d: ", prec, i);
151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174
	for_each_online_cpu(j)
		seq_printf(p, "%10u ", kstat_irqs_cpu(i, j));
	seq_printf(p, " %8s", desc->chip->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:
	spin_unlock_irqrestore(&desc->lock, flags);
	return 0;
}

/*
 * /proc/stat helpers
 */
u64 arch_irq_stat_cpu(unsigned int cpu)
{
	u64 sum = irq_stats(cpu)->__nmi_count;

175 176 177
#if defined(CONFIG_X86_MCE) && defined(CONFIG_X86_64)
	sum += per_cpu(mce_exception_count, cpu);
#endif
178 179
#ifdef CONFIG_X86_LOCAL_APIC
	sum += irq_stats(cpu)->apic_timer_irqs;
180
	sum += irq_stats(cpu)->irq_spurious_count;
181
#endif
182 183
	if (generic_interrupt_extension)
		sum += irq_stats(cpu)->generic_irqs;
184 185 186 187 188 189 190
#ifdef CONFIG_SMP
	sum += irq_stats(cpu)->irq_resched_count;
	sum += irq_stats(cpu)->irq_call_count;
	sum += irq_stats(cpu)->irq_tlb_count;
#endif
#ifdef CONFIG_X86_MCE
	sum += irq_stats(cpu)->irq_thermal_count;
191
# ifdef CONFIG_X86_MCE_THRESHOLD
192
	sum += irq_stats(cpu)->irq_threshold_count;
C
Cyrill Gorcunov 已提交
193
# endif
194 195 196 197 198 199 200 201 202 203 204 205 206
#endif
	return sum;
}

u64 arch_irq_stat(void)
{
	u64 sum = atomic_read(&irq_err_count);

#ifdef CONFIG_X86_IO_APIC
	sum += atomic_read(&irq_mis_count);
#endif
	return sum;
}
207

J
Jeremy Fitzhardinge 已提交
208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227

/*
 * do_IRQ handles all normal device IRQ's (the special
 * SMP cross-CPU interrupts have their own specific
 * handlers).
 */
unsigned int __irq_entry do_IRQ(struct pt_regs *regs)
{
	struct pt_regs *old_regs = set_irq_regs(regs);

	/* high bit used in ret_from_ code  */
	unsigned vector = ~regs->orig_ax;
	unsigned irq;

	exit_idle();
	irq_enter();

	irq = __get_cpu_var(vector_irq)[vector];

	if (!handle_irq(irq, regs)) {
228
		ack_APIC_irq();
J
Jeremy Fitzhardinge 已提交
229 230

		if (printk_ratelimit())
C
Cyrill Gorcunov 已提交
231 232
			pr_emerg("%s: %d.%d No irq handler for vector (irq %d)\n",
				__func__, smp_processor_id(), vector, irq);
J
Jeremy Fitzhardinge 已提交
233 234 235 236 237 238 239 240
	}

	irq_exit();

	set_irq_regs(old_regs);
	return 1;
}

241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263
/*
 * Handler for GENERIC_INTERRUPT_VECTOR.
 */
void smp_generic_interrupt(struct pt_regs *regs)
{
	struct pt_regs *old_regs = set_irq_regs(regs);

	ack_APIC_irq();

	exit_idle();

	irq_enter();

	inc_irq_stat(generic_irqs);

	if (generic_interrupt_extension)
		generic_interrupt_extension();

	irq_exit();

	set_irq_regs(old_regs);
}

264
EXPORT_SYMBOL_GPL(vector_used_by_percpu_irq);