sysrq.c 26 KB

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