nmi.c 7.0 KB

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