nmi.c 7.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /* Pseudo NMI support on sparc64 systems.
  3. *
  4. * Copyright (C) 2009 David S. Miller <davem@davemloft.net>
  5. *
  6. * The NMI watchdog support and infrastructure is based almost
  7. * entirely upon the x86 NMI support code.
  8. */
  9. #include <linux/kernel.h>
  10. #include <linux/param.h>
  11. #include <linux/init.h>
  12. #include <linux/percpu.h>
  13. #include <linux/nmi.h>
  14. #include <linux/export.h>
  15. #include <linux/kprobes.h>
  16. #include <linux/kernel_stat.h>
  17. #include <linux/reboot.h>
  18. #include <linux/slab.h>
  19. #include <linux/kdebug.h>
  20. #include <linux/delay.h>
  21. #include <linux/smp.h>
  22. #include <asm/perf_event.h>
  23. #include <asm/ptrace.h>
  24. #include <asm/pcr.h>
  25. #include "kstack.h"
  26. /* We don't have a real NMI on sparc64, but we can fake one
  27. * up using profiling counter overflow interrupts and interrupt
  28. * levels.
  29. *
  30. * The profile overflow interrupts at level 15, so we use
  31. * level 14 as our IRQ off level.
  32. */
  33. static int panic_on_timeout;
  34. /* nmi_active:
  35. * >0: the NMI watchdog is active, but can be disabled
  36. * <0: the NMI watchdog has not been set up, and cannot be enabled
  37. * 0: the NMI watchdog is disabled, but can be enabled
  38. */
  39. atomic_t nmi_active = ATOMIC_INIT(0); /* oprofile uses this */
  40. EXPORT_SYMBOL(nmi_active);
  41. static int nmi_init_done;
  42. static unsigned int nmi_hz = HZ;
  43. static DEFINE_PER_CPU(short, wd_enabled);
  44. static int endflag __initdata;
  45. static DEFINE_PER_CPU(unsigned int, last_irq_sum);
  46. static DEFINE_PER_CPU(long, alert_counter);
  47. static DEFINE_PER_CPU(int, nmi_touch);
  48. void arch_touch_nmi_watchdog(void)
  49. {
  50. if (atomic_read(&nmi_active)) {
  51. int cpu;
  52. for_each_present_cpu(cpu) {
  53. if (per_cpu(nmi_touch, cpu) != 1)
  54. per_cpu(nmi_touch, cpu) = 1;
  55. }
  56. }
  57. }
  58. EXPORT_SYMBOL(arch_touch_nmi_watchdog);
  59. static void die_nmi(const char *str, struct pt_regs *regs, int do_panic)
  60. {
  61. int this_cpu = smp_processor_id();
  62. if (notify_die(DIE_NMIWATCHDOG, str, regs, 0,
  63. pt_regs_trap_type(regs), SIGINT) == NOTIFY_STOP)
  64. return;
  65. if (do_panic || panic_on_oops)
  66. panic("Watchdog detected hard LOCKUP on cpu %d", this_cpu);
  67. else
  68. WARN(1, "Watchdog detected hard LOCKUP on cpu %d", this_cpu);
  69. }
  70. notrace __kprobes void perfctr_irq(int irq, struct pt_regs *regs)
  71. {
  72. unsigned int sum, touched = 0;
  73. void *orig_sp;
  74. clear_softint(1 << irq);
  75. local_cpu_data().__nmi_count++;
  76. nmi_enter();
  77. orig_sp = set_hardirq_stack();
  78. if (notify_die(DIE_NMI, "nmi", regs, 0,
  79. pt_regs_trap_type(regs), SIGINT) == NOTIFY_STOP)
  80. touched = 1;
  81. else
  82. pcr_ops->write_pcr(0, pcr_ops->pcr_nmi_disable);
  83. sum = local_cpu_data().irq0_irqs;
  84. if (__this_cpu_read(nmi_touch)) {
  85. __this_cpu_write(nmi_touch, 0);
  86. touched = 1;
  87. }
  88. if (!touched && __this_cpu_read(last_irq_sum) == sum) {
  89. __this_cpu_inc(alert_counter);
  90. if (__this_cpu_read(alert_counter) == 30 * nmi_hz)
  91. die_nmi("BUG: NMI Watchdog detected LOCKUP",
  92. regs, panic_on_timeout);
  93. } else {
  94. __this_cpu_write(last_irq_sum, sum);
  95. __this_cpu_write(alert_counter, 0);
  96. }
  97. if (__this_cpu_read(wd_enabled)) {
  98. pcr_ops->write_pic(0, pcr_ops->nmi_picl_value(nmi_hz));
  99. pcr_ops->write_pcr(0, pcr_ops->pcr_nmi_enable);
  100. }
  101. restore_hardirq_stack(orig_sp);
  102. nmi_exit();
  103. }
  104. static inline unsigned int get_nmi_count(int cpu)
  105. {
  106. return cpu_data(cpu).__nmi_count;
  107. }
  108. static __init void nmi_cpu_busy(void *data)
  109. {
  110. while (endflag == 0)
  111. mb();
  112. }
  113. static void report_broken_nmi(int cpu, int *prev_nmi_count)
  114. {
  115. printk(KERN_CONT "\n");
  116. printk(KERN_WARNING
  117. "WARNING: CPU#%d: NMI appears to be stuck (%d->%d)!\n",
  118. cpu, prev_nmi_count[cpu], get_nmi_count(cpu));
  119. printk(KERN_WARNING
  120. "Please report this to bugzilla.kernel.org,\n");
  121. printk(KERN_WARNING
  122. "and attach the output of the 'dmesg' command.\n");
  123. per_cpu(wd_enabled, cpu) = 0;
  124. atomic_dec(&nmi_active);
  125. }
  126. void stop_nmi_watchdog(void *unused)
  127. {
  128. if (!__this_cpu_read(wd_enabled))
  129. return;
  130. pcr_ops->write_pcr(0, pcr_ops->pcr_nmi_disable);
  131. __this_cpu_write(wd_enabled, 0);
  132. atomic_dec(&nmi_active);
  133. }
  134. static int __init check_nmi_watchdog(void)
  135. {
  136. unsigned int *prev_nmi_count;
  137. int cpu, err;
  138. if (!atomic_read(&nmi_active))
  139. return 0;
  140. prev_nmi_count = kmalloc_array(nr_cpu_ids, sizeof(unsigned int),
  141. GFP_KERNEL);
  142. if (!prev_nmi_count) {
  143. err = -ENOMEM;
  144. goto error;
  145. }
  146. printk(KERN_INFO "Testing NMI watchdog ... ");
  147. smp_call_function(nmi_cpu_busy, (void *)&endflag, 0);
  148. for_each_possible_cpu(cpu)
  149. prev_nmi_count[cpu] = get_nmi_count(cpu);
  150. local_irq_enable();
  151. mdelay((20 * 1000) / nmi_hz); /* wait 20 ticks */
  152. for_each_online_cpu(cpu) {
  153. if (!per_cpu(wd_enabled, cpu))
  154. continue;
  155. if (get_nmi_count(cpu) - prev_nmi_count[cpu] <= 5)
  156. report_broken_nmi(cpu, prev_nmi_count);
  157. }
  158. endflag = 1;
  159. if (!atomic_read(&nmi_active)) {
  160. kfree(prev_nmi_count);
  161. atomic_set(&nmi_active, -1);
  162. err = -ENODEV;
  163. goto error;
  164. }
  165. printk("OK.\n");
  166. nmi_hz = 1;
  167. kfree(prev_nmi_count);
  168. return 0;
  169. error:
  170. on_each_cpu(stop_nmi_watchdog, NULL, 1);
  171. return err;
  172. }
  173. void start_nmi_watchdog(void *unused)
  174. {
  175. if (__this_cpu_read(wd_enabled))
  176. return;
  177. __this_cpu_write(wd_enabled, 1);
  178. atomic_inc(&nmi_active);
  179. pcr_ops->write_pcr(0, pcr_ops->pcr_nmi_disable);
  180. pcr_ops->write_pic(0, pcr_ops->nmi_picl_value(nmi_hz));
  181. pcr_ops->write_pcr(0, pcr_ops->pcr_nmi_enable);
  182. }
  183. static void nmi_adjust_hz_one(void *unused)
  184. {
  185. if (!__this_cpu_read(wd_enabled))
  186. return;
  187. pcr_ops->write_pcr(0, pcr_ops->pcr_nmi_disable);
  188. pcr_ops->write_pic(0, pcr_ops->nmi_picl_value(nmi_hz));
  189. pcr_ops->write_pcr(0, pcr_ops->pcr_nmi_enable);
  190. }
  191. void nmi_adjust_hz(unsigned int new_hz)
  192. {
  193. nmi_hz = new_hz;
  194. on_each_cpu(nmi_adjust_hz_one, NULL, 1);
  195. }
  196. EXPORT_SYMBOL_GPL(nmi_adjust_hz);
  197. static int nmi_shutdown(struct notifier_block *nb, unsigned long cmd, void *p)
  198. {
  199. on_each_cpu(stop_nmi_watchdog, NULL, 1);
  200. return 0;
  201. }
  202. static struct notifier_block nmi_reboot_notifier = {
  203. .notifier_call = nmi_shutdown,
  204. };
  205. int __init nmi_init(void)
  206. {
  207. int err;
  208. on_each_cpu(start_nmi_watchdog, NULL, 1);
  209. err = check_nmi_watchdog();
  210. if (!err) {
  211. err = register_reboot_notifier(&nmi_reboot_notifier);
  212. if (err) {
  213. on_each_cpu(stop_nmi_watchdog, NULL, 1);
  214. atomic_set(&nmi_active, -1);
  215. }
  216. }
  217. nmi_init_done = 1;
  218. return err;
  219. }
  220. static int __init setup_nmi_watchdog(char *str)
  221. {
  222. if (!strncmp(str, "panic", 5))
  223. panic_on_timeout = 1;
  224. return 0;
  225. }
  226. __setup("nmi_watchdog=", setup_nmi_watchdog);
  227. /*
  228. * sparc specific NMI watchdog enable function.
  229. * Enables watchdog if it is not enabled already.
  230. */
  231. int watchdog_nmi_enable(unsigned int cpu)
  232. {
  233. if (atomic_read(&nmi_active) == -1) {
  234. pr_warn("NMI watchdog cannot be enabled or disabled\n");
  235. return -1;
  236. }
  237. /*
  238. * watchdog thread could start even before nmi_init is called.
  239. * Just Return in that case. Let nmi_init finish the init
  240. * process first.
  241. */
  242. if (!nmi_init_done)
  243. return 0;
  244. smp_call_function_single(cpu, start_nmi_watchdog, NULL, 1);
  245. return 0;
  246. }
  247. /*
  248. * sparc specific NMI watchdog disable function.
  249. * Disables watchdog if it is not disabled already.
  250. */
  251. void watchdog_nmi_disable(unsigned int cpu)
  252. {
  253. if (atomic_read(&nmi_active) == -1)
  254. pr_warn_once("NMI watchdog cannot be enabled or disabled\n");
  255. else
  256. smp_call_function_single(cpu, stop_nmi_watchdog, NULL, 1);
  257. }