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