sysrq.c 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489
  1. /* -*- linux-c -*-
  2. *
  3. * $Id: sysrq.c,v 1.1.1.1 2007/06/12 07:27:10 eyryu Exp $
  4. *
  5. * Linux Magic System Request Key Hacks
  6. *
  7. * (c) 1997 Martin Mares <mj@atrey.karlin.mff.cuni.cz>
  8. * based on ideas by Pavel Machek <pavel@atrey.karlin.mff.cuni.cz>
  9. *
  10. * (c) 2000 Crutcher Dunnavant <crutcher+kernel@datastacks.com>
  11. * overhauled to use key registration
  12. * based upon discusions in irc://irc.openprojects.net/#kernelnewbies
  13. */
  14. #include <linux/sched.h>
  15. #include <linux/interrupt.h>
  16. #include <linux/mm.h>
  17. #include <linux/fs.h>
  18. #include <linux/tty.h>
  19. #include <linux/mount.h>
  20. #include <linux/kdev_t.h>
  21. #include <linux/major.h>
  22. #include <linux/reboot.h>
  23. #include <linux/sysrq.h>
  24. #include <linux/kbd_kern.h>
  25. #include <linux/quotaops.h>
  26. #include <linux/smp_lock.h>
  27. #include <linux/kernel.h>
  28. #include <linux/module.h>
  29. #include <linux/suspend.h>
  30. #include <linux/writeback.h>
  31. #include <linux/buffer_head.h> /* for fsync_bdev() */
  32. #include <linux/swap.h>
  33. #include <linux/spinlock.h>
  34. #include <linux/vt_kern.h>
  35. #include <linux/workqueue.h>
  36. #include <linux/kexec.h>
  37. #include <linux/irq.h>
  38. #include <linux/hrtimer.h>
  39. #include <asm/ptrace.h>
  40. #include <asm/irq_regs.h>
  41. /* Whether we react on sysrq keys or just ignore them */
  42. int __read_mostly __sysrq_enabled = 1;
  43. static int __read_mostly sysrq_always_enabled;
  44. int sysrq_on(void)
  45. {
  46. return __sysrq_enabled || sysrq_always_enabled;
  47. }
  48. /*
  49. * A value of 1 means 'all', other nonzero values are an op mask:
  50. */
  51. static inline int sysrq_on_mask(int mask)
  52. {
  53. return sysrq_always_enabled || __sysrq_enabled == 1 ||
  54. (__sysrq_enabled & mask);
  55. }
  56. static int __init sysrq_always_enabled_setup(char *str)
  57. {
  58. sysrq_always_enabled = 1;
  59. printk(KERN_INFO "debug: sysrq always enabled.\n");
  60. return 1;
  61. }
  62. __setup("sysrq_always_enabled", sysrq_always_enabled_setup);
  63. static void sysrq_handle_loglevel(int key, struct tty_struct *tty)
  64. {
  65. int i;
  66. i = key - '0';
  67. console_loglevel = 7;
  68. printk("Loglevel set to %d\n", i);
  69. console_loglevel = i;
  70. }
  71. static struct sysrq_key_op sysrq_loglevel_op = {
  72. .handler = sysrq_handle_loglevel,
  73. .help_msg = "loglevel0-8",
  74. .action_msg = "Changing Loglevel",
  75. .enable_mask = SYSRQ_ENABLE_LOG,
  76. };
  77. #ifdef CONFIG_VT
  78. static void sysrq_handle_SAK(int key, struct tty_struct *tty)
  79. {
  80. struct work_struct *SAK_work = &vc_cons[fg_console].SAK_work;
  81. schedule_work(SAK_work);
  82. }
  83. static struct sysrq_key_op sysrq_SAK_op = {
  84. .handler = sysrq_handle_SAK,
  85. .help_msg = "saK",
  86. .action_msg = "SAK",
  87. .enable_mask = SYSRQ_ENABLE_KEYBOARD,
  88. };
  89. #else
  90. #define sysrq_SAK_op (*(struct sysrq_key_op *)0)
  91. #endif
  92. #ifdef CONFIG_VT
  93. static void sysrq_handle_unraw(int key, struct tty_struct *tty)
  94. {
  95. struct kbd_struct *kbd = &kbd_table[fg_console];
  96. if (kbd)
  97. kbd->kbdmode = VC_XLATE;
  98. }
  99. static struct sysrq_key_op sysrq_unraw_op = {
  100. .handler = sysrq_handle_unraw,
  101. .help_msg = "unRaw",
  102. .action_msg = "Keyboard mode set to XLATE",
  103. .enable_mask = SYSRQ_ENABLE_KEYBOARD,
  104. };
  105. #else
  106. #define sysrq_unraw_op (*(struct sysrq_key_op *)0)
  107. #endif /* CONFIG_VT */
  108. #ifdef CONFIG_KEXEC
  109. static void sysrq_handle_crashdump(int key, struct tty_struct *tty)
  110. {
  111. crash_kexec(get_irq_regs());
  112. }
  113. static struct sysrq_key_op sysrq_crashdump_op = {
  114. .handler = sysrq_handle_crashdump,
  115. .help_msg = "Crashdump",
  116. .action_msg = "Trigger a crashdump",
  117. .enable_mask = SYSRQ_ENABLE_DUMP,
  118. };
  119. #else
  120. #define sysrq_crashdump_op (*(struct sysrq_key_op *)0)
  121. #endif
  122. static void sysrq_handle_reboot(int key, struct tty_struct *tty)
  123. {
  124. lockdep_off();
  125. local_irq_enable();
  126. emergency_restart();
  127. }
  128. static struct sysrq_key_op sysrq_reboot_op = {
  129. .handler = sysrq_handle_reboot,
  130. .help_msg = "reBoot",
  131. .action_msg = "Resetting",
  132. .enable_mask = SYSRQ_ENABLE_BOOT,
  133. };
  134. static void sysrq_handle_sync(int key, struct tty_struct *tty)
  135. {
  136. emergency_sync();
  137. }
  138. static struct sysrq_key_op sysrq_sync_op = {
  139. .handler = sysrq_handle_sync,
  140. .help_msg = "Sync",
  141. .action_msg = "Emergency Sync",
  142. .enable_mask = SYSRQ_ENABLE_SYNC,
  143. };
  144. static void sysrq_handle_show_timers(int key, struct tty_struct *tty)
  145. {
  146. sysrq_timer_list_show();
  147. }
  148. static struct sysrq_key_op sysrq_show_timers_op = {
  149. .handler = sysrq_handle_show_timers,
  150. .help_msg = "show-all-timers(Q)",
  151. .action_msg = "Show Pending Timers",
  152. };
  153. static void sysrq_handle_mountro(int key, struct tty_struct *tty)
  154. {
  155. emergency_remount();
  156. }
  157. static struct sysrq_key_op sysrq_mountro_op = {
  158. .handler = sysrq_handle_mountro,
  159. .help_msg = "Unmount",
  160. .action_msg = "Emergency Remount R/O",
  161. .enable_mask = SYSRQ_ENABLE_REMOUNT,
  162. };
  163. #ifdef CONFIG_LOCKDEP
  164. static void sysrq_handle_showlocks(int key, struct tty_struct *tty)
  165. {
  166. debug_show_all_locks();
  167. }
  168. static struct sysrq_key_op sysrq_showlocks_op = {
  169. .handler = sysrq_handle_showlocks,
  170. .help_msg = "show-all-locks(D)",
  171. .action_msg = "Show Locks Held",
  172. };
  173. #else
  174. #define sysrq_showlocks_op (*(struct sysrq_key_op *)0)
  175. #endif
  176. static void sysrq_handle_showregs(int key, struct tty_struct *tty)
  177. {
  178. struct pt_regs *regs = get_irq_regs();
  179. if (regs)
  180. show_regs(regs);
  181. }
  182. static struct sysrq_key_op sysrq_showregs_op = {
  183. .handler = sysrq_handle_showregs,
  184. .help_msg = "showPc",
  185. .action_msg = "Show Regs",
  186. .enable_mask = SYSRQ_ENABLE_DUMP,
  187. };
  188. static void sysrq_handle_showstate(int key, struct tty_struct *tty)
  189. {
  190. show_state();
  191. }
  192. static struct sysrq_key_op sysrq_showstate_op = {
  193. .handler = sysrq_handle_showstate,
  194. .help_msg = "showTasks",
  195. .action_msg = "Show State",
  196. .enable_mask = SYSRQ_ENABLE_DUMP,
  197. };
  198. static void sysrq_handle_showstate_blocked(int key, struct tty_struct *tty)
  199. {
  200. show_state_filter(TASK_UNINTERRUPTIBLE);
  201. }
  202. static struct sysrq_key_op sysrq_showstate_blocked_op = {
  203. .handler = sysrq_handle_showstate_blocked,
  204. .help_msg = "shoW-blocked-tasks",
  205. .action_msg = "Show Blocked State",
  206. .enable_mask = SYSRQ_ENABLE_DUMP,
  207. };
  208. static void sysrq_handle_showmem(int key, struct tty_struct *tty)
  209. {
  210. show_mem();
  211. }
  212. static struct sysrq_key_op sysrq_showmem_op = {
  213. .handler = sysrq_handle_showmem,
  214. .help_msg = "showMem",
  215. .action_msg = "Show Memory",
  216. .enable_mask = SYSRQ_ENABLE_DUMP,
  217. };
  218. /*
  219. * Signal sysrq helper function. Sends a signal to all user processes.
  220. */
  221. static void send_sig_all(int sig)
  222. {
  223. struct task_struct *p;
  224. for_each_process(p) {
  225. if (p->mm && !is_init(p))
  226. /* Not swapper, init nor kernel thread */
  227. force_sig(sig, p);
  228. }
  229. }
  230. static void sysrq_handle_term(int key, struct tty_struct *tty)
  231. {
  232. send_sig_all(SIGTERM);
  233. console_loglevel = 8;
  234. }
  235. static struct sysrq_key_op sysrq_term_op = {
  236. .handler = sysrq_handle_term,
  237. .help_msg = "tErm",
  238. .action_msg = "Terminate All Tasks",
  239. .enable_mask = SYSRQ_ENABLE_SIGNAL,
  240. };
  241. static void moom_callback(struct work_struct *ignored)
  242. {
  243. out_of_memory(&NODE_DATA(0)->node_zonelists[ZONE_NORMAL],
  244. GFP_KERNEL, 0);
  245. }
  246. static DECLARE_WORK(moom_work, moom_callback);
  247. static void sysrq_handle_moom(int key, struct tty_struct *tty)
  248. {
  249. schedule_work(&moom_work);
  250. }
  251. static struct sysrq_key_op sysrq_moom_op = {
  252. .handler = sysrq_handle_moom,
  253. .help_msg = "Full",
  254. .action_msg = "Manual OOM execution",
  255. };
  256. static void sysrq_handle_kill(int key, struct tty_struct *tty)
  257. {
  258. send_sig_all(SIGKILL);
  259. console_loglevel = 8;
  260. }
  261. static struct sysrq_key_op sysrq_kill_op = {
  262. .handler = sysrq_handle_kill,
  263. .help_msg = "kIll",
  264. .action_msg = "Kill All Tasks",
  265. .enable_mask = SYSRQ_ENABLE_SIGNAL,
  266. };
  267. static void sysrq_handle_unrt(int key, struct tty_struct *tty)
  268. {
  269. normalize_rt_tasks();
  270. }
  271. static struct sysrq_key_op sysrq_unrt_op = {
  272. .handler = sysrq_handle_unrt,
  273. .help_msg = "Nice",
  274. .action_msg = "Nice All RT Tasks",
  275. .enable_mask = SYSRQ_ENABLE_RTNICE,
  276. };
  277. /* Key Operations table and lock */
  278. static DEFINE_SPINLOCK(sysrq_key_table_lock);
  279. static struct sysrq_key_op *sysrq_key_table[36] = {
  280. &sysrq_loglevel_op, /* 0 */
  281. &sysrq_loglevel_op, /* 1 */
  282. &sysrq_loglevel_op, /* 2 */
  283. &sysrq_loglevel_op, /* 3 */
  284. &sysrq_loglevel_op, /* 4 */
  285. &sysrq_loglevel_op, /* 5 */
  286. &sysrq_loglevel_op, /* 6 */
  287. &sysrq_loglevel_op, /* 7 */
  288. &sysrq_loglevel_op, /* 8 */
  289. &sysrq_loglevel_op, /* 9 */
  290. /*
  291. * a: Don't use for system provided sysrqs, it is handled specially on
  292. * sparc and will never arrive.
  293. */
  294. NULL, /* a */
  295. &sysrq_reboot_op, /* b */
  296. &sysrq_crashdump_op, /* c & ibm_emac driver debug */
  297. &sysrq_showlocks_op, /* d */
  298. &sysrq_term_op, /* e */
  299. &sysrq_moom_op, /* f */
  300. /* g: May be registered by ppc for kgdb */
  301. NULL, /* g */
  302. NULL, /* h */
  303. &sysrq_kill_op, /* i */
  304. NULL, /* j */
  305. &sysrq_SAK_op, /* k */
  306. NULL, /* l */
  307. &sysrq_showmem_op, /* m */
  308. &sysrq_unrt_op, /* n */
  309. /* o: This will often be registered as 'Off' at init time */
  310. NULL, /* o */
  311. &sysrq_showregs_op, /* p */
  312. &sysrq_show_timers_op, /* q */
  313. &sysrq_unraw_op, /* r */
  314. &sysrq_sync_op, /* s */
  315. &sysrq_showstate_op, /* t */
  316. &sysrq_mountro_op, /* u */
  317. /* v: May be registered at init time by SMP VOYAGER */
  318. NULL, /* v */
  319. &sysrq_showstate_blocked_op, /* w */
  320. /* x: May be registered on ppc/powerpc for xmon */
  321. NULL, /* x */
  322. NULL, /* y */
  323. NULL /* z */
  324. };
  325. /* key2index calculation, -1 on invalid index */
  326. static int sysrq_key_table_key2index(int key)
  327. {
  328. int retval;
  329. if ((key >= '0') && (key <= '9'))
  330. retval = key - '0';
  331. else if ((key >= 'a') && (key <= 'z'))
  332. retval = key + 10 - 'a';
  333. else
  334. retval = -1;
  335. return retval;
  336. }
  337. /*
  338. * get and put functions for the table, exposed to modules.
  339. */
  340. struct sysrq_key_op *__sysrq_get_key_op(int key)
  341. {
  342. struct sysrq_key_op *op_p = NULL;
  343. int i;
  344. i = sysrq_key_table_key2index(key);
  345. if (i != -1)
  346. op_p = sysrq_key_table[i];
  347. return op_p;
  348. }
  349. static void __sysrq_put_key_op(int key, struct sysrq_key_op *op_p)
  350. {
  351. int i = sysrq_key_table_key2index(key);
  352. if (i != -1)
  353. sysrq_key_table[i] = op_p;
  354. }
  355. /*
  356. * This is the non-locking version of handle_sysrq. It must/can only be called
  357. * by sysrq key handlers, as they are inside of the lock
  358. */
  359. void __handle_sysrq(int key, struct tty_struct *tty, int check_mask)
  360. {
  361. struct sysrq_key_op *op_p;
  362. int orig_log_level;
  363. int i;
  364. unsigned long flags;
  365. spin_lock_irqsave(&sysrq_key_table_lock, flags);
  366. orig_log_level = console_loglevel;
  367. console_loglevel = 7;
  368. printk(KERN_INFO "SysRq : ");
  369. op_p = __sysrq_get_key_op(key);
  370. if (op_p) {
  371. /*
  372. * Should we check for enabled operations (/proc/sysrq-trigger
  373. * should not) and is the invoked operation enabled?
  374. */
  375. if (!check_mask || sysrq_on_mask(op_p->enable_mask)) {
  376. printk("%s\n", op_p->action_msg);
  377. console_loglevel = orig_log_level;
  378. op_p->handler(key, tty);
  379. } else {
  380. printk("This sysrq operation is disabled.\n");
  381. }
  382. } else {
  383. printk("HELP : ");
  384. /* Only print the help msg once per handler */
  385. for (i = 0; i < ARRAY_SIZE(sysrq_key_table); i++) {
  386. if (sysrq_key_table[i]) {
  387. int j;
  388. for (j = 0; sysrq_key_table[i] !=
  389. sysrq_key_table[j]; j++)
  390. ;
  391. if (j != i)
  392. continue;
  393. printk("%s ", sysrq_key_table[i]->help_msg);
  394. }
  395. }
  396. printk("\n");
  397. console_loglevel = orig_log_level;
  398. }
  399. spin_unlock_irqrestore(&sysrq_key_table_lock, flags);
  400. }
  401. /*
  402. * This function is called by the keyboard handler when SysRq is pressed
  403. * and any other keycode arrives.
  404. */
  405. void handle_sysrq(int key, struct tty_struct *tty)
  406. {
  407. if (sysrq_on())
  408. __handle_sysrq(key, tty, 1);
  409. }
  410. EXPORT_SYMBOL(handle_sysrq);
  411. static int __sysrq_swap_key_ops(int key, struct sysrq_key_op *insert_op_p,
  412. struct sysrq_key_op *remove_op_p)
  413. {
  414. int retval;
  415. unsigned long flags;
  416. spin_lock_irqsave(&sysrq_key_table_lock, flags);
  417. if (__sysrq_get_key_op(key) == remove_op_p) {
  418. __sysrq_put_key_op(key, insert_op_p);
  419. retval = 0;
  420. } else {
  421. retval = -1;
  422. }
  423. spin_unlock_irqrestore(&sysrq_key_table_lock, flags);
  424. return retval;
  425. }
  426. int register_sysrq_key(int key, struct sysrq_key_op *op_p)
  427. {
  428. return __sysrq_swap_key_ops(key, op_p, NULL);
  429. }
  430. EXPORT_SYMBOL(register_sysrq_key);
  431. int unregister_sysrq_key(int key, struct sysrq_key_op *op_p)
  432. {
  433. return __sysrq_swap_key_ops(key, NULL, op_p);
  434. }
  435. EXPORT_SYMBOL(unregister_sysrq_key);