arch/s390/kernel/wti.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Support for warning track interruption
   4  *
   5  * Copyright IBM Corp. 2023
   6  */
   7
   8 #include <linux/cpu.h>
   9 #include <linux/debugfs.h>
  10 #include <linux/kallsyms.h>
  11 #include <linux/smpboot.h>
  12 #include <linux/irq.h>
  13 #include <uapi/linux/sched/types.h>
  14 #include <asm/debug.h>
  15 #include <asm/diag.h>
  16 #include <asm/sclp.h>
  17
  18 #define WTI_DBF_LEN 64
  19
  20 struct wti_debug {
  21         unsigned long   missed;
  22         unsigned long   addr;
  23         pid_t           pid;
  24 };
  25
  26 struct wti_state {
  27         /* debug data for s390dbf */
  28         struct wti_debug        dbg;
  29         /*
  30          * Represents the real-time thread responsible to
  31          * acknowledge the warning-track interrupt and trigger
  32          * preliminary and postliminary precautions.
  33          */
  34         struct task_struct      *thread;
  35         /*
  36          * If pending is true, the real-time thread must be scheduled.
  37          * If not, a wake up of that thread will remain a noop.
  38          */
  39         bool                    pending;
  40 };
  41
  42 static DEFINE_PER_CPU(struct wti_state, wti_state);
  43
  44 static debug_info_t *wti_dbg;
  45
  46 /*
  47  * During a warning-track grace period, interrupts are disabled
  48  * to prevent delays of the warning-track acknowledgment.
  49  *
  50  * Once the CPU is physically dispatched again, interrupts are
  51  * re-enabled.
  52  */
  53
  54 static void wti_irq_disable(void)
  55 {
  56         unsigned long flags;
  57         struct ctlreg cr6;
  58
  59         local_irq_save(flags);
  60         local_ctl_store(6, &cr6);
  61         /* disable all I/O interrupts */
  62         cr6.val &= ~0xff000000UL;
  63         local_ctl_load(6, &cr6);
  64         local_irq_restore(flags);
  65 }
  66
  67 static void wti_irq_enable(void)
  68 {
  69         unsigned long flags;
  70         struct ctlreg cr6;
  71
  72         local_irq_save(flags);
  73         local_ctl_store(6, &cr6);
  74         /* enable all I/O interrupts */
  75         cr6.val |= 0xff000000UL;
  76         local_ctl_load(6, &cr6);
  77         local_irq_restore(flags);
  78 }
  79
  80 static void store_debug_data(struct wti_state *st)
  81 {
  82         struct pt_regs *regs = get_irq_regs();
  83
  84         st->dbg.pid = current->pid;
  85         st->dbg.addr = 0;
  86         if (!user_mode(regs))
  87                 st->dbg.addr = regs->psw.addr;
  88 }
  89
  90 static void wti_interrupt(struct ext_code ext_code,
  91                           unsigned int param32, unsigned long param64)
  92 {
  93         struct wti_state *st = this_cpu_ptr(&wti_state);
  94
  95         inc_irq_stat(IRQEXT_WTI);
  96         wti_irq_disable();
  97         store_debug_data(st);
  98         st->pending = true;
  99         wake_up_process(st->thread);
 100 }
 101
 102 static int wti_pending(unsigned int cpu)
 103 {
 104         struct wti_state *st = per_cpu_ptr(&wti_state, cpu);
 105
 106         return st->pending;
 107 }
 108
 109 static void wti_dbf_grace_period(struct wti_state *st)
 110 {
 111         struct wti_debug *wdi = &st->dbg;
 112         char buf[WTI_DBF_LEN];
 113
 114         if (wdi->addr)
 115                 snprintf(buf, sizeof(buf), "%d %pS", wdi->pid, (void *)wdi->addr);
 116         else
 117                 snprintf(buf, sizeof(buf), "%d <user>", wdi->pid);
 118         debug_text_event(wti_dbg, 2, buf);
 119         wdi->missed++;
 120 }
 121
 122 static int wti_show(struct seq_file *seq, void *v)
 123 {
 124         struct wti_state *st;
 125         int cpu;
 126
 127         cpus_read_lock();
 128         seq_puts(seq, "       ");
 129         for_each_online_cpu(cpu)
 130                 seq_printf(seq, "CPU%-8d", cpu);
 131         seq_putc(seq, '\n');
 132         for_each_online_cpu(cpu) {
 133                 st = per_cpu_ptr(&wti_state, cpu);
 134                 seq_printf(seq, " %10lu", st->dbg.missed);
 135         }
 136         seq_putc(seq, '\n');
 137         cpus_read_unlock();
 138         return 0;
 139 }
 140 DEFINE_SHOW_ATTRIBUTE(wti);
 141
 142 static void wti_thread_fn(unsigned int cpu)
 143 {
 144         struct wti_state *st = per_cpu_ptr(&wti_state, cpu);
 145
 146         st->pending = false;
 147         /*
 148          * Yield CPU voluntarily to the hypervisor. Control
 149          * resumes when hypervisor decides to dispatch CPU
 150          * to this LPAR again.
 151          */
 152         if (diag49c(DIAG49C_SUBC_ACK))
 153                 wti_dbf_grace_period(st);
 154         wti_irq_enable();
 155 }
 156
 157 static struct smp_hotplug_thread wti_threads = {
 158         .store                  = &wti_state.thread,
 159         .thread_should_run      = wti_pending,
 160         .thread_fn              = wti_thread_fn,
 161         .thread_comm            = "cpuwti/%u",
 162         .selfparking            = false,
 163 };
 164
 165 static int __init wti_init(void)
 166 {
 167         struct sched_param wti_sched_param = { .sched_priority = MAX_RT_PRIO - 1 };
 168         struct dentry *wti_dir;
 169         struct wti_state *st;
 170         int cpu, rc;
 171
 172         rc = -EOPNOTSUPP;
 173         if (!sclp.has_wti)
 174                 goto out;
 175         rc = smpboot_register_percpu_thread(&wti_threads);
 176         if (WARN_ON(rc))
 177                 goto out;
 178         for_each_online_cpu(cpu) {
 179                 st = per_cpu_ptr(&wti_state, cpu);
 180                 sched_setscheduler(st->thread, SCHED_FIFO, &wti_sched_param);
 181         }
 182         rc = register_external_irq(EXT_IRQ_WARNING_TRACK, wti_interrupt);
 183         if (rc) {
 184                 pr_warn("Couldn't request external interrupt 0x1007\n");
 185                 goto out_thread;
 186         }
 187         irq_subclass_register(IRQ_SUBCLASS_WARNING_TRACK);
 188         rc = diag49c(DIAG49C_SUBC_REG);
 189         if (rc) {
 190                 pr_warn("Failed to register warning track interrupt through DIAG 49C\n");
 191                 rc = -EOPNOTSUPP;
 192                 goto out_subclass;
 193         }
 194         wti_dir = debugfs_create_dir("wti", arch_debugfs_dir);
 195         debugfs_create_file("stat", 0400, wti_dir, NULL, &wti_fops);
 196         wti_dbg = debug_register("wti", 1, 1, WTI_DBF_LEN);
 197         if (!wti_dbg) {
 198                 rc = -ENOMEM;
 199                 goto out_debug_register;
 200         }
 201         rc = debug_register_view(wti_dbg, &debug_hex_ascii_view);
 202         if (rc)
 203                 goto out_debug_register;
 204         goto out;
 205 out_debug_register:
 206         debug_unregister(wti_dbg);
 207 out_subclass:
 208         irq_subclass_unregister(IRQ_SUBCLASS_WARNING_TRACK);
 209         unregister_external_irq(EXT_IRQ_WARNING_TRACK, wti_interrupt);
 210 out_thread:
 211         smpboot_unregister_percpu_thread(&wti_threads);
 212 out:
 213         return rc;
 214 }
 215 late_initcall(wti_init);