Branch data     Line data    Source code

       1                 :            : // SPDX-License-Identifier: GPL-2.0
       2                 :            : /*
       3                 :            :  *      Copyright (C) 1992, 1998 Linus Torvalds, Ingo Molnar
       4                 :            :  *
       5                 :            :  * This file contains the lowest level x86_64-specific interrupt
       6                 :            :  * entry and irq statistics code. All the remaining irq logic is
       7                 :            :  * done by the generic kernel/irq/ code and in the
       8                 :            :  * x86_64-specific irq controller code. (e.g. i8259.c and
       9                 :            :  * io_apic.c.)
      10                 :            :  */
      11                 :            : 
      12                 :            : #include <linux/kernel_stat.h>
      13                 :            : #include <linux/interrupt.h>
      14                 :            : #include <linux/irq.h>
      15                 :            : #include <linux/seq_file.h>
      16                 :            : #include <linux/delay.h>
      17                 :            : #include <linux/ftrace.h>
      18                 :            : #include <linux/uaccess.h>
      19                 :            : #include <linux/smp.h>
      20                 :            : #include <linux/sched/task_stack.h>
      21                 :            : 
      22                 :            : #include <asm/cpu_entry_area.h>
      23                 :            : #include <asm/io_apic.h>
      24                 :            : #include <asm/apic.h>
      25                 :            : 
      26                 :            : DEFINE_PER_CPU_PAGE_ALIGNED(struct irq_stack, irq_stack_backing_store) __visible;
      27                 :            : DECLARE_INIT_PER_CPU(irq_stack_backing_store);
      28                 :            : 
      29                 :            : #ifdef CONFIG_VMAP_STACK
      30                 :            : /*
      31                 :            :  * VMAP the backing store with guard pages
      32                 :            :  */
      33                 :            : static int map_irq_stack(unsigned int cpu)
      34                 :            : {
      35                 :            :         char *stack = (char *)per_cpu_ptr(&irq_stack_backing_store, cpu);
      36                 :            :         struct page *pages[IRQ_STACK_SIZE / PAGE_SIZE];
      37                 :            :         void *va;
      38                 :            :         int i;
      39                 :            : 
      40                 :            :         for (i = 0; i < IRQ_STACK_SIZE / PAGE_SIZE; i++) {
      41                 :            :                 phys_addr_t pa = per_cpu_ptr_to_phys(stack + (i << PAGE_SHIFT));
      42                 :            : 
      43                 :            :                 pages[i] = pfn_to_page(pa >> PAGE_SHIFT);
      44                 :            :         }
      45                 :            : 
      46                 :            :         va = vmap(pages, IRQ_STACK_SIZE / PAGE_SIZE, GFP_KERNEL, PAGE_KERNEL);
      47                 :            :         if (!va)
      48                 :            :                 return -ENOMEM;
      49                 :            : 
      50                 :            :         per_cpu(hardirq_stack_ptr, cpu) = va + IRQ_STACK_SIZE;
      51                 :            :         return 0;
      52                 :            : }
      53                 :            : #else
      54                 :            : /*
      55                 :            :  * If VMAP stacks are disabled due to KASAN, just use the per cpu
      56                 :            :  * backing store without guard pages.
      57                 :            :  */
      58                 :         13 : static int map_irq_stack(unsigned int cpu)
      59                 :            : {
      60                 :         13 :         void *va = per_cpu_ptr(&irq_stack_backing_store, cpu);
      61                 :            : 
      62                 :         13 :         per_cpu(hardirq_stack_ptr, cpu) = va + IRQ_STACK_SIZE;
      63                 :         13 :         return 0;
      64                 :            : }
      65                 :            : #endif
      66                 :            : 
      67                 :         13 : int irq_init_percpu_irqstack(unsigned int cpu)
      68                 :            : {
      69         [ +  - ]:         13 :         if (per_cpu(hardirq_stack_ptr, cpu))
      70                 :            :                 return 0;
      71                 :         13 :         return map_irq_stack(cpu);
      72                 :            : }