sysrq.c 28 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * Linux Magic System Request Key Hacks
  4. *
  5. * (c) 1997 Martin Mares <mj@atrey.karlin.mff.cuni.cz>
  6. * based on ideas by Pavel Machek <pavel@atrey.karlin.mff.cuni.cz>
  7. *
  8. * (c) 2000 Crutcher Dunnavant <crutcher+kernel@datastacks.com>
  9. * overhauled to use key registration
  10. * based upon discusions in irc://irc.openprojects.net/#kernelnewbies
  11. *
  12. * Copyright (c) 2010 Dmitry Torokhov
  13. * Input handler conversion
  14. */
  15. #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  16. #include <linux/sched/signal.h>
  17. #include <linux/sched/rt.h>
  18. #include <linux/sched/debug.h>
  19. #include <linux/sched/task.h>
  20. #include <linux/ctype.h>
  21. #include <linux/interrupt.h>
  22. #include <linux/mm.h>
  23. #include <linux/fs.h>
  24. #include <linux/mount.h>
  25. #include <linux/kdev_t.h>
  26. #include <linux/major.h>
  27. #include <linux/reboot.h>
  28. #include <linux/sysrq.h>
  29. #include <linux/kbd_kern.h>
  30. #include <linux/proc_fs.h>
  31. #include <linux/nmi.h>
  32. #include <linux/quotaops.h>
  33. #include <linux/perf_event.h>
  34. #include <linux/kernel.h>
  35. #include <linux/module.h>
  36. #include <linux/suspend.h>
  37. #include <linux/writeback.h>
  38. #include <linux/swap.h>
  39. #include <linux/spinlock.h>
  40. #include <linux/vt_kern.h>
  41. #include <linux/workqueue.h>
  42. #include <linux/hrtimer.h>
  43. #include <linux/oom.h>
  44. #include <linux/slab.h>
  45. #include <linux/input.h>
  46. #include <linux/uaccess.h>
  47. #include <linux/moduleparam.h>
  48. #include <linux/jiffies.h>
  49. #include <linux/syscalls.h>
  50. #include <linux/of.h>
  51. #include <linux/rcupdate.h>
  52. #include <asm/ptrace.h>
  53. #include <asm/irq_regs.h>
  54. /* Whether we react on sysrq keys or just ignore them */
  55. static int __read_mostly sysrq_enabled = CONFIG_MAGIC_SYSRQ_DEFAULT_ENABLE;
  56. static bool __read_mostly sysrq_always_enabled;
  57. static bool sysrq_on(void)
  58. {
  59. return sysrq_enabled || sysrq_always_enabled;
  60. }
  61. /**
  62. * sysrq_mask - Getter for sysrq_enabled mask.
  63. *
  64. * Return: 1 if sysrq is always enabled, enabled sysrq_key_op mask otherwise.
  65. */
  66. int sysrq_mask(void)
  67. {
  68. if (sysrq_always_enabled)
  69. return 1;
  70. return sysrq_enabled;
  71. }
  72. EXPORT_SYMBOL_GPL(sysrq_mask);
  73. /*
  74. * A value of 1 means 'all', other nonzero values are an op mask:
  75. */
  76. static bool sysrq_on_mask(int mask)
  77. {
  78. return sysrq_always_enabled ||
  79. sysrq_enabled == 1 ||
  80. (sysrq_enabled & mask);
  81. }
  82. static int __init sysrq_always_enabled_setup(char *str)
  83. {
  84. sysrq_always_enabled = true;
  85. pr_info("sysrq always enabled.\n");
  86. return 1;
  87. }
  88. __setup("sysrq_always_enabled", sysrq_always_enabled_setup);
  89. static void sysrq_handle_loglevel(int key)
  90. {
  91. int i;
  92. i = key - '0';
  93. console_loglevel = CONSOLE_LOGLEVEL_DEFAULT;
  94. pr_info("Loglevel set to %d\n", i);
  95. console_loglevel = i;
  96. }
  97. static const struct sysrq_key_op sysrq_loglevel_op = {
  98. .handler = sysrq_handle_loglevel,
  99. .help_msg = "loglevel(0-9)",
  100. .action_msg = "Changing Loglevel",
  101. .enable_mask = SYSRQ_ENABLE_LOG,
  102. };
  103. #ifdef CONFIG_VT
  104. static void sysrq_handle_SAK(int key)
  105. {
  106. struct work_struct *SAK_work = &vc_cons[fg_console].SAK_work;
  107. schedule_work(SAK_work);
  108. }
  109. static const struct sysrq_key_op sysrq_SAK_op = {
  110. .handler = sysrq_handle_SAK,
  111. .help_msg = "sak(k)",
  112. .action_msg = "SAK",
  113. .enable_mask = SYSRQ_ENABLE_KEYBOARD,
  114. };
  115. #else
  116. #define sysrq_SAK_op (*(const struct sysrq_key_op *)NULL)
  117. #endif
  118. #ifdef CONFIG_VT
  119. static void sysrq_handle_unraw(int key)
  120. {
  121. vt_reset_unicode(fg_console);
  122. }
  123. static const struct sysrq_key_op sysrq_unraw_op = {
  124. .handler = sysrq_handle_unraw,
  125. .help_msg = "unraw(r)",
  126. .action_msg = "Keyboard mode set to system default",
  127. .enable_mask = SYSRQ_ENABLE_KEYBOARD,
  128. };
  129. #else
  130. #define sysrq_unraw_op (*(const struct sysrq_key_op *)NULL)
  131. #endif /* CONFIG_VT */
  132. static void sysrq_handle_crash(int key)
  133. {
  134. /* release the RCU read lock before crashing */
  135. rcu_read_unlock();
  136. panic("sysrq triggered crash\n");
  137. }
  138. static const struct sysrq_key_op sysrq_crash_op = {
  139. .handler = sysrq_handle_crash,
  140. .help_msg = "crash(c)",
  141. .action_msg = "Trigger a crash",
  142. .enable_mask = SYSRQ_ENABLE_DUMP,
  143. };
  144. static void sysrq_handle_reboot(int key)
  145. {
  146. lockdep_off();
  147. local_irq_enable();
  148. emergency_restart();
  149. }
  150. static const struct sysrq_key_op sysrq_reboot_op = {
  151. .handler = sysrq_handle_reboot,
  152. .help_msg = "reboot(b)",
  153. .action_msg = "Resetting",
  154. .enable_mask = SYSRQ_ENABLE_BOOT,
  155. };
  156. const struct sysrq_key_op *__sysrq_reboot_op = &sysrq_reboot_op;
  157. static void sysrq_handle_sync(int key)
  158. {
  159. emergency_sync();
  160. }
  161. static const struct sysrq_key_op sysrq_sync_op = {
  162. .handler = sysrq_handle_sync,
  163. .help_msg = "sync(s)",
  164. .action_msg = "Emergency Sync",
  165. .enable_mask = SYSRQ_ENABLE_SYNC,
  166. };
  167. static void sysrq_handle_show_timers(int key)
  168. {
  169. sysrq_timer_list_show();
  170. }
  171. static const struct sysrq_key_op sysrq_show_timers_op = {
  172. .handler = sysrq_handle_show_timers,
  173. .help_msg = "show-all-timers(q)",
  174. .action_msg = "Show clockevent devices & pending hrtimers (no others)",
  175. };
  176. static void sysrq_handle_mountro(int key)
  177. {
  178. emergency_remount();
  179. }
  180. static const struct sysrq_key_op sysrq_mountro_op = {
  181. .handler = sysrq_handle_mountro,
  182. .help_msg = "unmount(u)",
  183. .action_msg = "Emergency Remount R/O",
  184. .enable_mask = SYSRQ_ENABLE_REMOUNT,
  185. };
  186. #ifdef CONFIG_LOCKDEP
  187. static void sysrq_handle_showlocks(int key)
  188. {
  189. debug_show_all_locks();
  190. }
  191. static const struct sysrq_key_op sysrq_showlocks_op = {
  192. .handler = sysrq_handle_showlocks,
  193. .help_msg = "show-all-locks(d)",
  194. .action_msg = "Show Locks Held",
  195. };
  196. #else
  197. #define sysrq_showlocks_op (*(const struct sysrq_key_op *)NULL)
  198. #endif
  199. #ifdef CONFIG_SMP
  200. static DEFINE_RAW_SPINLOCK(show_lock);
  201. static void showacpu(void *dummy)
  202. {
  203. unsigned long flags;
  204. /* Idle CPUs have no interesting backtrace. */
  205. if (idle_cpu(smp_processor_id()))
  206. return;
  207. raw_spin_lock_irqsave(&show_lock, flags);
  208. pr_info("CPU%d:\n", smp_processor_id());
  209. show_stack(NULL, NULL, KERN_INFO);
  210. raw_spin_unlock_irqrestore(&show_lock, flags);
  211. }
  212. static void sysrq_showregs_othercpus(struct work_struct *dummy)
  213. {
  214. smp_call_function(showacpu, NULL, 0);
  215. }
  216. static DECLARE_WORK(sysrq_showallcpus, sysrq_showregs_othercpus);
  217. static void sysrq_handle_showallcpus(int key)
  218. {
  219. /*
  220. * Fall back to the workqueue based printing if the
  221. * backtrace printing did not succeed or the
  222. * architecture has no support for it:
  223. */
  224. if (!trigger_all_cpu_backtrace()) {
  225. struct pt_regs *regs = NULL;
  226. if (in_irq())
  227. regs = get_irq_regs();
  228. if (regs) {
  229. pr_info("CPU%d:\n", smp_processor_id());
  230. show_regs(regs);
  231. }
  232. schedule_work(&sysrq_showallcpus);
  233. }
  234. }
  235. static const struct sysrq_key_op sysrq_showallcpus_op = {
  236. .handler = sysrq_handle_showallcpus,
  237. .help_msg = "show-backtrace-all-active-cpus(l)",
  238. .action_msg = "Show backtrace of all active CPUs",
  239. .enable_mask = SYSRQ_ENABLE_DUMP,
  240. };
  241. #endif
  242. static void sysrq_handle_showregs(int key)
  243. {
  244. struct pt_regs *regs = NULL;
  245. if (in_irq())
  246. regs = get_irq_regs();
  247. if (regs)
  248. show_regs(regs);
  249. perf_event_print_debug();
  250. }
  251. static const struct sysrq_key_op sysrq_showregs_op = {
  252. .handler = sysrq_handle_showregs,
  253. .help_msg = "show-registers(p)",
  254. .action_msg = "Show Regs",
  255. .enable_mask = SYSRQ_ENABLE_DUMP,
  256. };
  257. static void sysrq_handle_showstate(int key)
  258. {
  259. show_state();
  260. show_workqueue_state();
  261. }
  262. static const struct sysrq_key_op sysrq_showstate_op = {
  263. .handler = sysrq_handle_showstate,
  264. .help_msg = "show-task-states(t)",
  265. .action_msg = "Show State",
  266. .enable_mask = SYSRQ_ENABLE_DUMP,
  267. };
  268. static void sysrq_handle_showstate_blocked(int key)
  269. {
  270. show_state_filter(TASK_UNINTERRUPTIBLE);
  271. }
  272. static const struct sysrq_key_op sysrq_showstate_blocked_op = {
  273. .handler = sysrq_handle_showstate_blocked,
  274. .help_msg = "show-blocked-tasks(w)",
  275. .action_msg = "Show Blocked State",
  276. .enable_mask = SYSRQ_ENABLE_DUMP,
  277. };
  278. #ifdef CONFIG_TRACING
  279. #include <linux/ftrace.h>
  280. static void sysrq_ftrace_dump(int key)
  281. {
  282. ftrace_dump(DUMP_ALL);
  283. }
  284. static const struct sysrq_key_op sysrq_ftrace_dump_op = {
  285. .handler = sysrq_ftrace_dump,
  286. .help_msg = "dump-ftrace-buffer(z)",
  287. .action_msg = "Dump ftrace buffer",
  288. .enable_mask = SYSRQ_ENABLE_DUMP,
  289. };
  290. #else
  291. #define sysrq_ftrace_dump_op (*(const struct sysrq_key_op *)NULL)
  292. #endif
  293. static void sysrq_handle_showmem(int key)
  294. {
  295. show_mem(0, NULL);
  296. }
  297. static const struct sysrq_key_op sysrq_showmem_op = {
  298. .handler = sysrq_handle_showmem,
  299. .help_msg = "show-memory-usage(m)",
  300. .action_msg = "Show Memory",
  301. .enable_mask = SYSRQ_ENABLE_DUMP,
  302. };
  303. /*
  304. * Signal sysrq helper function. Sends a signal to all user processes.
  305. */
  306. static void send_sig_all(int sig)
  307. {
  308. struct task_struct *p;
  309. read_lock(&tasklist_lock);
  310. for_each_process(p) {
  311. if (p->flags & PF_KTHREAD)
  312. continue;
  313. if (is_global_init(p))
  314. continue;
  315. do_send_sig_info(sig, SEND_SIG_PRIV, p, PIDTYPE_MAX);
  316. }
  317. read_unlock(&tasklist_lock);
  318. }
  319. static void sysrq_handle_term(int key)
  320. {
  321. send_sig_all(SIGTERM);
  322. console_loglevel = CONSOLE_LOGLEVEL_DEBUG;
  323. }
  324. static const struct sysrq_key_op sysrq_term_op = {
  325. .handler = sysrq_handle_term,
  326. .help_msg = "terminate-all-tasks(e)",
  327. .action_msg = "Terminate All Tasks",
  328. .enable_mask = SYSRQ_ENABLE_SIGNAL,
  329. };
  330. static void moom_callback(struct work_struct *ignored)
  331. {
  332. const gfp_t gfp_mask = GFP_KERNEL;
  333. struct oom_control oc = {
  334. .zonelist = node_zonelist(first_memory_node, gfp_mask),
  335. .nodemask = NULL,
  336. .memcg = NULL,
  337. .gfp_mask = gfp_mask,
  338. .order = -1,
  339. };
  340. mutex_lock(&oom_lock);
  341. if (!out_of_memory(&oc))
  342. pr_info("OOM request ignored. No task eligible\n");
  343. mutex_unlock(&oom_lock);
  344. }
  345. static DECLARE_WORK(moom_work, moom_callback);
  346. static void sysrq_handle_moom(int key)
  347. {
  348. schedule_work(&moom_work);
  349. }
  350. static const struct sysrq_key_op sysrq_moom_op = {
  351. .handler = sysrq_handle_moom,
  352. .help_msg = "memory-full-oom-kill(f)",
  353. .action_msg = "Manual OOM execution",
  354. .enable_mask = SYSRQ_ENABLE_SIGNAL,
  355. };
  356. static void sysrq_handle_thaw(int key)
  357. {
  358. emergency_thaw_all();
  359. }
  360. static const struct sysrq_key_op sysrq_thaw_op = {
  361. .handler = sysrq_handle_thaw,
  362. .help_msg = "thaw-filesystems(j)",
  363. .action_msg = "Emergency Thaw of all frozen filesystems",
  364. .enable_mask = SYSRQ_ENABLE_SIGNAL,
  365. };
  366. static void sysrq_handle_kill(int key)
  367. {
  368. send_sig_all(SIGKILL);
  369. console_loglevel = CONSOLE_LOGLEVEL_DEBUG;
  370. }
  371. static const struct sysrq_key_op sysrq_kill_op = {
  372. .handler = sysrq_handle_kill,
  373. .help_msg = "kill-all-tasks(i)",
  374. .action_msg = "Kill All Tasks",
  375. .enable_mask = SYSRQ_ENABLE_SIGNAL,
  376. };
  377. static void sysrq_handle_unrt(int key)
  378. {
  379. normalize_rt_tasks();
  380. }
  381. static const struct sysrq_key_op sysrq_unrt_op = {
  382. .handler = sysrq_handle_unrt,
  383. .help_msg = "nice-all-RT-tasks(n)",
  384. .action_msg = "Nice All RT Tasks",
  385. .enable_mask = SYSRQ_ENABLE_RTNICE,
  386. };
  387. /* Key Operations table and lock */
  388. static DEFINE_SPINLOCK(sysrq_key_table_lock);
  389. static const struct sysrq_key_op *sysrq_key_table[62] = {
  390. &sysrq_loglevel_op, /* 0 */
  391. &sysrq_loglevel_op, /* 1 */
  392. &sysrq_loglevel_op, /* 2 */
  393. &sysrq_loglevel_op, /* 3 */
  394. &sysrq_loglevel_op, /* 4 */
  395. &sysrq_loglevel_op, /* 5 */
  396. &sysrq_loglevel_op, /* 6 */
  397. &sysrq_loglevel_op, /* 7 */
  398. &sysrq_loglevel_op, /* 8 */
  399. &sysrq_loglevel_op, /* 9 */
  400. /*
  401. * a: Don't use for system provided sysrqs, it is handled specially on
  402. * sparc and will never arrive.
  403. */
  404. NULL, /* a */
  405. &sysrq_reboot_op, /* b */
  406. &sysrq_crash_op, /* c */
  407. &sysrq_showlocks_op, /* d */
  408. &sysrq_term_op, /* e */
  409. &sysrq_moom_op, /* f */
  410. /* g: May be registered for the kernel debugger */
  411. NULL, /* g */
  412. NULL, /* h - reserved for help */
  413. &sysrq_kill_op, /* i */
  414. #ifdef CONFIG_BLOCK
  415. &sysrq_thaw_op, /* j */
  416. #else
  417. NULL, /* j */
  418. #endif
  419. &sysrq_SAK_op, /* k */
  420. #ifdef CONFIG_SMP
  421. &sysrq_showallcpus_op, /* l */
  422. #else
  423. NULL, /* l */
  424. #endif
  425. &sysrq_showmem_op, /* m */
  426. &sysrq_unrt_op, /* n */
  427. /* o: This will often be registered as 'Off' at init time */
  428. NULL, /* o */
  429. &sysrq_showregs_op, /* p */
  430. &sysrq_show_timers_op, /* q */
  431. &sysrq_unraw_op, /* r */
  432. &sysrq_sync_op, /* s */
  433. &sysrq_showstate_op, /* t */
  434. &sysrq_mountro_op, /* u */
  435. /* v: May be registered for frame buffer console restore */
  436. NULL, /* v */
  437. &sysrq_showstate_blocked_op, /* w */
  438. /* x: May be registered on mips for TLB dump */
  439. /* x: May be registered on ppc/powerpc for xmon */
  440. /* x: May be registered on sparc64 for global PMU dump */
  441. NULL, /* x */
  442. /* y: May be registered on sparc64 for global register dump */
  443. NULL, /* y */
  444. &sysrq_ftrace_dump_op, /* z */
  445. NULL, /* A */
  446. NULL, /* B */
  447. NULL, /* C */
  448. NULL, /* D */
  449. NULL, /* E */
  450. NULL, /* F */
  451. NULL, /* G */
  452. NULL, /* H */
  453. NULL, /* I */
  454. NULL, /* J */
  455. NULL, /* K */
  456. NULL, /* L */
  457. NULL, /* M */
  458. NULL, /* N */
  459. NULL, /* O */
  460. NULL, /* P */
  461. NULL, /* Q */
  462. NULL, /* R */
  463. NULL, /* S */
  464. NULL, /* T */
  465. NULL, /* U */
  466. NULL, /* V */
  467. NULL, /* W */
  468. NULL, /* X */
  469. NULL, /* Y */
  470. NULL, /* Z */
  471. };
  472. /* key2index calculation, -1 on invalid index */
  473. static int sysrq_key_table_key2index(int key)
  474. {
  475. int retval;
  476. if ((key >= '0') && (key <= '9'))
  477. retval = key - '0';
  478. else if ((key >= 'a') && (key <= 'z'))
  479. retval = key + 10 - 'a';
  480. else if ((key >= 'A') && (key <= 'Z'))
  481. retval = key + 36 - 'A';
  482. else
  483. retval = -1;
  484. return retval;
  485. }
  486. /*
  487. * get and put functions for the table, exposed to modules.
  488. */
  489. static const struct sysrq_key_op *__sysrq_get_key_op(int key)
  490. {
  491. const struct sysrq_key_op *op_p = NULL;
  492. int i;
  493. i = sysrq_key_table_key2index(key);
  494. if (i != -1)
  495. op_p = sysrq_key_table[i];
  496. return op_p;
  497. }
  498. static void __sysrq_put_key_op(int key, const struct sysrq_key_op *op_p)
  499. {
  500. int i = sysrq_key_table_key2index(key);
  501. if (i != -1)
  502. sysrq_key_table[i] = op_p;
  503. }
  504. void __handle_sysrq(int key, bool check_mask)
  505. {
  506. const struct sysrq_key_op *op_p;
  507. int orig_log_level;
  508. int orig_suppress_printk;
  509. int i;
  510. orig_suppress_printk = suppress_printk;
  511. suppress_printk = 0;
  512. rcu_sysrq_start();
  513. rcu_read_lock();
  514. /*
  515. * Raise the apparent loglevel to maximum so that the sysrq header
  516. * is shown to provide the user with positive feedback. We do not
  517. * simply emit this at KERN_EMERG as that would change message
  518. * routing in the consumers of /proc/kmsg.
  519. */
  520. orig_log_level = console_loglevel;
  521. console_loglevel = CONSOLE_LOGLEVEL_DEFAULT;
  522. op_p = __sysrq_get_key_op(key);
  523. if (op_p) {
  524. /*
  525. * Should we check for enabled operations (/proc/sysrq-trigger
  526. * should not) and is the invoked operation enabled?
  527. */
  528. if (!check_mask || sysrq_on_mask(op_p->enable_mask)) {
  529. pr_info("%s\n", op_p->action_msg);
  530. console_loglevel = orig_log_level;
  531. op_p->handler(key);
  532. } else {
  533. pr_info("This sysrq operation is disabled.\n");
  534. console_loglevel = orig_log_level;
  535. }
  536. } else {
  537. pr_info("HELP : ");
  538. /* Only print the help msg once per handler */
  539. for (i = 0; i < ARRAY_SIZE(sysrq_key_table); i++) {
  540. if (sysrq_key_table[i]) {
  541. int j;
  542. for (j = 0; sysrq_key_table[i] !=
  543. sysrq_key_table[j]; j++)
  544. ;
  545. if (j != i)
  546. continue;
  547. pr_cont("%s ", sysrq_key_table[i]->help_msg);
  548. }
  549. }
  550. pr_cont("\n");
  551. console_loglevel = orig_log_level;
  552. }
  553. rcu_read_unlock();
  554. rcu_sysrq_end();
  555. suppress_printk = orig_suppress_printk;
  556. }
  557. void handle_sysrq(int key)
  558. {
  559. if (sysrq_on())
  560. __handle_sysrq(key, true);
  561. }
  562. EXPORT_SYMBOL(handle_sysrq);
  563. #ifdef CONFIG_INPUT
  564. static int sysrq_reset_downtime_ms;
  565. /* Simple translation table for the SysRq keys */
  566. static const unsigned char sysrq_xlate[KEY_CNT] =
  567. "\000\0331234567890-=\177\t" /* 0x00 - 0x0f */
  568. "qwertyuiop[]\r\000as" /* 0x10 - 0x1f */
  569. "dfghjkl;'`\000\\zxcv" /* 0x20 - 0x2f */
  570. "bnm,./\000*\000 \000\201\202\203\204\205" /* 0x30 - 0x3f */
  571. "\206\207\210\211\212\000\000789-456+1" /* 0x40 - 0x4f */
  572. "230\177\000\000\213\214\000\000\000\000\000\000\000\000\000\000" /* 0x50 - 0x5f */
  573. "\r\000/"; /* 0x60 - 0x6f */
  574. struct sysrq_state {
  575. struct input_handle handle;
  576. struct work_struct reinject_work;
  577. unsigned long key_down[BITS_TO_LONGS(KEY_CNT)];
  578. unsigned int alt;
  579. unsigned int alt_use;
  580. unsigned int shift;
  581. unsigned int shift_use;
  582. bool active;
  583. bool need_reinject;
  584. bool reinjecting;
  585. /* reset sequence handling */
  586. bool reset_canceled;
  587. bool reset_requested;
  588. unsigned long reset_keybit[BITS_TO_LONGS(KEY_CNT)];
  589. int reset_seq_len;
  590. int reset_seq_cnt;
  591. int reset_seq_version;
  592. struct timer_list keyreset_timer;
  593. };
  594. #define SYSRQ_KEY_RESET_MAX 20 /* Should be plenty */
  595. static unsigned short sysrq_reset_seq[SYSRQ_KEY_RESET_MAX];
  596. static unsigned int sysrq_reset_seq_len;
  597. static unsigned int sysrq_reset_seq_version = 1;
  598. static void sysrq_parse_reset_sequence(struct sysrq_state *state)
  599. {
  600. int i;
  601. unsigned short key;
  602. state->reset_seq_cnt = 0;
  603. for (i = 0; i < sysrq_reset_seq_len; i++) {
  604. key = sysrq_reset_seq[i];
  605. if (key == KEY_RESERVED || key > KEY_MAX)
  606. break;
  607. __set_bit(key, state->reset_keybit);
  608. state->reset_seq_len++;
  609. if (test_bit(key, state->key_down))
  610. state->reset_seq_cnt++;
  611. }
  612. /* Disable reset until old keys are not released */
  613. state->reset_canceled = state->reset_seq_cnt != 0;
  614. state->reset_seq_version = sysrq_reset_seq_version;
  615. }
  616. static void sysrq_do_reset(struct timer_list *t)
  617. {
  618. struct sysrq_state *state = from_timer(state, t, keyreset_timer);
  619. state->reset_requested = true;
  620. orderly_reboot();
  621. }
  622. static void sysrq_handle_reset_request(struct sysrq_state *state)
  623. {
  624. if (state->reset_requested)
  625. __handle_sysrq(sysrq_xlate[KEY_B], false);
  626. if (sysrq_reset_downtime_ms)
  627. mod_timer(&state->keyreset_timer,
  628. jiffies + msecs_to_jiffies(sysrq_reset_downtime_ms));
  629. else
  630. sysrq_do_reset(&state->keyreset_timer);
  631. }
  632. static void sysrq_detect_reset_sequence(struct sysrq_state *state,
  633. unsigned int code, int value)
  634. {
  635. if (!test_bit(code, state->reset_keybit)) {
  636. /*
  637. * Pressing any key _not_ in reset sequence cancels
  638. * the reset sequence. Also cancelling the timer in
  639. * case additional keys were pressed after a reset
  640. * has been requested.
  641. */
  642. if (value && state->reset_seq_cnt) {
  643. state->reset_canceled = true;
  644. del_timer(&state->keyreset_timer);
  645. }
  646. } else if (value == 0) {
  647. /*
  648. * Key release - all keys in the reset sequence need
  649. * to be pressed and held for the reset timeout
  650. * to hold.
  651. */
  652. del_timer(&state->keyreset_timer);
  653. if (--state->reset_seq_cnt == 0)
  654. state->reset_canceled = false;
  655. } else if (value == 1) {
  656. /* key press, not autorepeat */
  657. if (++state->reset_seq_cnt == state->reset_seq_len &&
  658. !state->reset_canceled) {
  659. sysrq_handle_reset_request(state);
  660. }
  661. }
  662. }
  663. #ifdef CONFIG_OF
  664. static void sysrq_of_get_keyreset_config(void)
  665. {
  666. u32 key;
  667. struct device_node *np;
  668. struct property *prop;
  669. const __be32 *p;
  670. np = of_find_node_by_path("/chosen/linux,sysrq-reset-seq");
  671. if (!np) {
  672. pr_debug("No sysrq node found");
  673. return;
  674. }
  675. /* Reset in case a __weak definition was present */
  676. sysrq_reset_seq_len = 0;
  677. of_property_for_each_u32(np, "keyset", prop, p, key) {
  678. if (key == KEY_RESERVED || key > KEY_MAX ||
  679. sysrq_reset_seq_len == SYSRQ_KEY_RESET_MAX)
  680. break;
  681. sysrq_reset_seq[sysrq_reset_seq_len++] = (unsigned short)key;
  682. }
  683. /* Get reset timeout if any. */
  684. of_property_read_u32(np, "timeout-ms", &sysrq_reset_downtime_ms);
  685. of_node_put(np);
  686. }
  687. #else
  688. static void sysrq_of_get_keyreset_config(void)
  689. {
  690. }
  691. #endif
  692. static void sysrq_reinject_alt_sysrq(struct work_struct *work)
  693. {
  694. struct sysrq_state *sysrq =
  695. container_of(work, struct sysrq_state, reinject_work);
  696. struct input_handle *handle = &sysrq->handle;
  697. unsigned int alt_code = sysrq->alt_use;
  698. if (sysrq->need_reinject) {
  699. /* we do not want the assignment to be reordered */
  700. sysrq->reinjecting = true;
  701. mb();
  702. /* Simulate press and release of Alt + SysRq */
  703. input_inject_event(handle, EV_KEY, alt_code, 1);
  704. input_inject_event(handle, EV_KEY, KEY_SYSRQ, 1);
  705. input_inject_event(handle, EV_SYN, SYN_REPORT, 1);
  706. input_inject_event(handle, EV_KEY, KEY_SYSRQ, 0);
  707. input_inject_event(handle, EV_KEY, alt_code, 0);
  708. input_inject_event(handle, EV_SYN, SYN_REPORT, 1);
  709. mb();
  710. sysrq->reinjecting = false;
  711. }
  712. }
  713. static bool sysrq_handle_keypress(struct sysrq_state *sysrq,
  714. unsigned int code, int value)
  715. {
  716. bool was_active = sysrq->active;
  717. bool suppress;
  718. switch (code) {
  719. case KEY_LEFTALT:
  720. case KEY_RIGHTALT:
  721. if (!value) {
  722. /* One of ALTs is being released */
  723. if (sysrq->active && code == sysrq->alt_use)
  724. sysrq->active = false;
  725. sysrq->alt = KEY_RESERVED;
  726. } else if (value != 2) {
  727. sysrq->alt = code;
  728. sysrq->need_reinject = false;
  729. }
  730. break;
  731. case KEY_LEFTSHIFT:
  732. case KEY_RIGHTSHIFT:
  733. if (!value)
  734. sysrq->shift = KEY_RESERVED;
  735. else if (value != 2)
  736. sysrq->shift = code;
  737. break;
  738. case KEY_SYSRQ:
  739. if (value == 1 && sysrq->alt != KEY_RESERVED) {
  740. sysrq->active = true;
  741. sysrq->alt_use = sysrq->alt;
  742. /* either RESERVED (for released) or actual code */
  743. sysrq->shift_use = sysrq->shift;
  744. /*
  745. * If nothing else will be pressed we'll need
  746. * to re-inject Alt-SysRq keysroke.
  747. */
  748. sysrq->need_reinject = true;
  749. }
  750. /*
  751. * Pretend that sysrq was never pressed at all. This
  752. * is needed to properly handle KGDB which will try
  753. * to release all keys after exiting debugger. If we
  754. * do not clear key bit it KGDB will end up sending
  755. * release events for Alt and SysRq, potentially
  756. * triggering print screen function.
  757. */
  758. if (sysrq->active)
  759. clear_bit(KEY_SYSRQ, sysrq->handle.dev->key);
  760. break;
  761. default:
  762. if (sysrq->active && value && value != 2) {
  763. unsigned char c = sysrq_xlate[code];
  764. sysrq->need_reinject = false;
  765. if (sysrq->shift_use != KEY_RESERVED)
  766. c = toupper(c);
  767. __handle_sysrq(c, true);
  768. }
  769. break;
  770. }
  771. suppress = sysrq->active;
  772. if (!sysrq->active) {
  773. /*
  774. * See if reset sequence has changed since the last time.
  775. */
  776. if (sysrq->reset_seq_version != sysrq_reset_seq_version)
  777. sysrq_parse_reset_sequence(sysrq);
  778. /*
  779. * If we are not suppressing key presses keep track of
  780. * keyboard state so we can release keys that have been
  781. * pressed before entering SysRq mode.
  782. */
  783. if (value)
  784. set_bit(code, sysrq->key_down);
  785. else
  786. clear_bit(code, sysrq->key_down);
  787. if (was_active)
  788. schedule_work(&sysrq->reinject_work);
  789. /* Check for reset sequence */
  790. sysrq_detect_reset_sequence(sysrq, code, value);
  791. } else if (value == 0 && test_and_clear_bit(code, sysrq->key_down)) {
  792. /*
  793. * Pass on release events for keys that was pressed before
  794. * entering SysRq mode.
  795. */
  796. suppress = false;
  797. }
  798. return suppress;
  799. }
  800. static bool sysrq_filter(struct input_handle *handle,
  801. unsigned int type, unsigned int code, int value)
  802. {
  803. struct sysrq_state *sysrq = handle->private;
  804. bool suppress;
  805. /*
  806. * Do not filter anything if we are in the process of re-injecting
  807. * Alt+SysRq combination.
  808. */
  809. if (sysrq->reinjecting)
  810. return false;
  811. switch (type) {
  812. case EV_SYN:
  813. suppress = false;
  814. break;
  815. case EV_KEY:
  816. suppress = sysrq_handle_keypress(sysrq, code, value);
  817. break;
  818. default:
  819. suppress = sysrq->active;
  820. break;
  821. }
  822. return suppress;
  823. }
  824. static int sysrq_connect(struct input_handler *handler,
  825. struct input_dev *dev,
  826. const struct input_device_id *id)
  827. {
  828. struct sysrq_state *sysrq;
  829. int error;
  830. sysrq = kzalloc(sizeof(struct sysrq_state), GFP_KERNEL);
  831. if (!sysrq)
  832. return -ENOMEM;
  833. INIT_WORK(&sysrq->reinject_work, sysrq_reinject_alt_sysrq);
  834. sysrq->handle.dev = dev;
  835. sysrq->handle.handler = handler;
  836. sysrq->handle.name = "sysrq";
  837. sysrq->handle.private = sysrq;
  838. timer_setup(&sysrq->keyreset_timer, sysrq_do_reset, 0);
  839. error = input_register_handle(&sysrq->handle);
  840. if (error) {
  841. pr_err("Failed to register input sysrq handler, error %d\n",
  842. error);
  843. goto err_free;
  844. }
  845. error = input_open_device(&sysrq->handle);
  846. if (error) {
  847. pr_err("Failed to open input device, error %d\n", error);
  848. goto err_unregister;
  849. }
  850. return 0;
  851. err_unregister:
  852. input_unregister_handle(&sysrq->handle);
  853. err_free:
  854. kfree(sysrq);
  855. return error;
  856. }
  857. static void sysrq_disconnect(struct input_handle *handle)
  858. {
  859. struct sysrq_state *sysrq = handle->private;
  860. input_close_device(handle);
  861. cancel_work_sync(&sysrq->reinject_work);
  862. del_timer_sync(&sysrq->keyreset_timer);
  863. input_unregister_handle(handle);
  864. kfree(sysrq);
  865. }
  866. /*
  867. * We are matching on KEY_LEFTALT instead of KEY_SYSRQ because not all
  868. * keyboards have SysRq key predefined and so user may add it to keymap
  869. * later, but we expect all such keyboards to have left alt.
  870. */
  871. static const struct input_device_id sysrq_ids[] = {
  872. {
  873. .flags = INPUT_DEVICE_ID_MATCH_EVBIT |
  874. INPUT_DEVICE_ID_MATCH_KEYBIT,
  875. .evbit = { [BIT_WORD(EV_KEY)] = BIT_MASK(EV_KEY) },
  876. .keybit = { [BIT_WORD(KEY_LEFTALT)] = BIT_MASK(KEY_LEFTALT) },
  877. },
  878. { },
  879. };
  880. static struct input_handler sysrq_handler = {
  881. .filter = sysrq_filter,
  882. .connect = sysrq_connect,
  883. .disconnect = sysrq_disconnect,
  884. .name = "sysrq",
  885. .id_table = sysrq_ids,
  886. };
  887. static inline void sysrq_register_handler(void)
  888. {
  889. int error;
  890. sysrq_of_get_keyreset_config();
  891. error = input_register_handler(&sysrq_handler);
  892. if (error)
  893. pr_err("Failed to register input handler, error %d", error);
  894. }
  895. static inline void sysrq_unregister_handler(void)
  896. {
  897. input_unregister_handler(&sysrq_handler);
  898. }
  899. static int sysrq_reset_seq_param_set(const char *buffer,
  900. const struct kernel_param *kp)
  901. {
  902. unsigned long val;
  903. int error;
  904. error = kstrtoul(buffer, 0, &val);
  905. if (error < 0)
  906. return error;
  907. if (val > KEY_MAX)
  908. return -EINVAL;
  909. *((unsigned short *)kp->arg) = val;
  910. sysrq_reset_seq_version++;
  911. return 0;
  912. }
  913. static const struct kernel_param_ops param_ops_sysrq_reset_seq = {
  914. .get = param_get_ushort,
  915. .set = sysrq_reset_seq_param_set,
  916. };
  917. #define param_check_sysrq_reset_seq(name, p) \
  918. __param_check(name, p, unsigned short)
  919. /*
  920. * not really modular, but the easiest way to keep compat with existing
  921. * bootargs behaviour is to continue using module_param here.
  922. */
  923. module_param_array_named(reset_seq, sysrq_reset_seq, sysrq_reset_seq,
  924. &sysrq_reset_seq_len, 0644);
  925. module_param_named(sysrq_downtime_ms, sysrq_reset_downtime_ms, int, 0644);
  926. #else
  927. static inline void sysrq_register_handler(void)
  928. {
  929. }
  930. static inline void sysrq_unregister_handler(void)
  931. {
  932. }
  933. #endif /* CONFIG_INPUT */
  934. int sysrq_toggle_support(int enable_mask)
  935. {
  936. bool was_enabled = sysrq_on();
  937. sysrq_enabled = enable_mask;
  938. if (was_enabled != sysrq_on()) {
  939. if (sysrq_on())
  940. sysrq_register_handler();
  941. else
  942. sysrq_unregister_handler();
  943. }
  944. return 0;
  945. }
  946. EXPORT_SYMBOL_GPL(sysrq_toggle_support);
  947. static int __sysrq_swap_key_ops(int key, const struct sysrq_key_op *insert_op_p,
  948. const struct sysrq_key_op *remove_op_p)
  949. {
  950. int retval;
  951. spin_lock(&sysrq_key_table_lock);
  952. if (__sysrq_get_key_op(key) == remove_op_p) {
  953. __sysrq_put_key_op(key, insert_op_p);
  954. retval = 0;
  955. } else {
  956. retval = -1;
  957. }
  958. spin_unlock(&sysrq_key_table_lock);
  959. /*
  960. * A concurrent __handle_sysrq either got the old op or the new op.
  961. * Wait for it to go away before returning, so the code for an old
  962. * op is not freed (eg. on module unload) while it is in use.
  963. */
  964. synchronize_rcu();
  965. return retval;
  966. }
  967. int register_sysrq_key(int key, const struct sysrq_key_op *op_p)
  968. {
  969. return __sysrq_swap_key_ops(key, op_p, NULL);
  970. }
  971. EXPORT_SYMBOL(register_sysrq_key);
  972. int unregister_sysrq_key(int key, const struct sysrq_key_op *op_p)
  973. {
  974. return __sysrq_swap_key_ops(key, NULL, op_p);
  975. }
  976. EXPORT_SYMBOL(unregister_sysrq_key);
  977. #ifdef CONFIG_PROC_FS
  978. /*
  979. * writing 'C' to /proc/sysrq-trigger is like sysrq-C
  980. */
  981. static ssize_t write_sysrq_trigger(struct file *file, const char __user *buf,
  982. size_t count, loff_t *ppos)
  983. {
  984. if (count) {
  985. char c;
  986. if (get_user(c, buf))
  987. return -EFAULT;
  988. __handle_sysrq(c, false);
  989. }
  990. return count;
  991. }
  992. static const struct proc_ops sysrq_trigger_proc_ops = {
  993. .proc_write = write_sysrq_trigger,
  994. .proc_lseek = noop_llseek,
  995. };
  996. static void sysrq_init_procfs(void)
  997. {
  998. if (!proc_create("sysrq-trigger", S_IWUSR, NULL,
  999. &sysrq_trigger_proc_ops))
  1000. pr_err("Failed to register proc interface\n");
  1001. }
  1002. #else
  1003. static inline void sysrq_init_procfs(void)
  1004. {
  1005. }
  1006. #endif /* CONFIG_PROC_FS */
  1007. static int __init sysrq_init(void)
  1008. {
  1009. sysrq_init_procfs();
  1010. if (sysrq_on())
  1011. sysrq_register_handler();
  1012. return 0;
  1013. }
  1014. device_initcall(sysrq_init);