1 // SPDX-License-Identifier: GPL-2.0
3 * Linux Magic System Request Key Hacks
5 * (c) 1997 Martin Mares <mj@atrey.karlin.mff.cuni.cz>
6 * based on ideas by Pavel Machek <pavel@atrey.karlin.mff.cuni.cz>
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
12 * Copyright (c) 2010 Dmitry Torokhov
13 * Input handler conversion
16 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
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/interrupt.h>
25 #include <linux/mount.h>
26 #include <linux/kdev_t.h>
27 #include <linux/major.h>
28 #include <linux/reboot.h>
29 #include <linux/sysrq.h>
30 #include <linux/kbd_kern.h>
31 #include <linux/proc_fs.h>
32 #include <linux/nmi.h>
33 #include <linux/quotaops.h>
34 #include <linux/perf_event.h>
35 #include <linux/kernel.h>
36 #include <linux/module.h>
37 #include <linux/suspend.h>
38 #include <linux/writeback.h>
39 #include <linux/swap.h>
40 #include <linux/spinlock.h>
41 #include <linux/vt_kern.h>
42 #include <linux/workqueue.h>
43 #include <linux/hrtimer.h>
44 #include <linux/oom.h>
45 #include <linux/slab.h>
46 #include <linux/input.h>
47 #include <linux/uaccess.h>
48 #include <linux/moduleparam.h>
49 #include <linux/jiffies.h>
50 #include <linux/syscalls.h>
52 #include <linux/rcupdate.h>
54 #include <asm/ptrace.h>
55 #include <asm/irq_regs.h>
57 /* Whether we react on sysrq keys or just ignore them */
58 static int __read_mostly sysrq_enabled
= CONFIG_MAGIC_SYSRQ_DEFAULT_ENABLE
;
59 static bool __read_mostly sysrq_always_enabled
;
61 static bool sysrq_on(void)
63 return sysrq_enabled
|| sysrq_always_enabled
;
67 * A value of 1 means 'all', other nonzero values are an op mask:
69 static bool sysrq_on_mask(int mask
)
71 return sysrq_always_enabled
||
73 (sysrq_enabled
& mask
);
76 static int __init
sysrq_always_enabled_setup(char *str
)
78 sysrq_always_enabled
= true;
79 pr_info("sysrq always enabled.\n");
84 __setup("sysrq_always_enabled", sysrq_always_enabled_setup
);
87 static void sysrq_handle_loglevel(int key
)
92 console_loglevel
= CONSOLE_LOGLEVEL_DEFAULT
;
93 pr_info("Loglevel set to %d\n", i
);
96 static struct sysrq_key_op sysrq_loglevel_op
= {
97 .handler
= sysrq_handle_loglevel
,
98 .help_msg
= "loglevel(0-9)",
99 .action_msg
= "Changing Loglevel",
100 .enable_mask
= SYSRQ_ENABLE_LOG
,
104 static void sysrq_handle_SAK(int key
)
106 struct work_struct
*SAK_work
= &vc_cons
[fg_console
].SAK_work
;
107 schedule_work(SAK_work
);
109 static struct sysrq_key_op sysrq_SAK_op
= {
110 .handler
= sysrq_handle_SAK
,
111 .help_msg
= "sak(k)",
113 .enable_mask
= SYSRQ_ENABLE_KEYBOARD
,
116 #define sysrq_SAK_op (*(struct sysrq_key_op *)NULL)
120 static void sysrq_handle_unraw(int key
)
122 vt_reset_unicode(fg_console
);
125 static struct sysrq_key_op sysrq_unraw_op
= {
126 .handler
= sysrq_handle_unraw
,
127 .help_msg
= "unraw(r)",
128 .action_msg
= "Keyboard mode set to system default",
129 .enable_mask
= SYSRQ_ENABLE_KEYBOARD
,
132 #define sysrq_unraw_op (*(struct sysrq_key_op *)NULL)
133 #endif /* CONFIG_VT */
135 static void sysrq_handle_crash(int key
)
139 /* we need to release the RCU read lock here,
140 * otherwise we get an annoying
141 * 'BUG: sleeping function called from invalid context'
142 * complaint from the kernel before the panic.
145 panic_on_oops
= 1; /* force panic */
149 static struct sysrq_key_op sysrq_crash_op
= {
150 .handler
= sysrq_handle_crash
,
151 .help_msg
= "crash(c)",
152 .action_msg
= "Trigger a crash",
153 .enable_mask
= SYSRQ_ENABLE_DUMP
,
156 static void sysrq_handle_reboot(int key
)
162 static struct sysrq_key_op sysrq_reboot_op
= {
163 .handler
= sysrq_handle_reboot
,
164 .help_msg
= "reboot(b)",
165 .action_msg
= "Resetting",
166 .enable_mask
= SYSRQ_ENABLE_BOOT
,
169 static void sysrq_handle_sync(int key
)
173 static struct sysrq_key_op sysrq_sync_op
= {
174 .handler
= sysrq_handle_sync
,
175 .help_msg
= "sync(s)",
176 .action_msg
= "Emergency Sync",
177 .enable_mask
= SYSRQ_ENABLE_SYNC
,
180 static void sysrq_handle_show_timers(int key
)
182 sysrq_timer_list_show();
185 static struct sysrq_key_op sysrq_show_timers_op
= {
186 .handler
= sysrq_handle_show_timers
,
187 .help_msg
= "show-all-timers(q)",
188 .action_msg
= "Show clockevent devices & pending hrtimers (no others)",
191 static void sysrq_handle_mountro(int key
)
195 static struct sysrq_key_op sysrq_mountro_op
= {
196 .handler
= sysrq_handle_mountro
,
197 .help_msg
= "unmount(u)",
198 .action_msg
= "Emergency Remount R/O",
199 .enable_mask
= SYSRQ_ENABLE_REMOUNT
,
202 #ifdef CONFIG_LOCKDEP
203 static void sysrq_handle_showlocks(int key
)
205 debug_show_all_locks();
208 static struct sysrq_key_op sysrq_showlocks_op
= {
209 .handler
= sysrq_handle_showlocks
,
210 .help_msg
= "show-all-locks(d)",
211 .action_msg
= "Show Locks Held",
214 #define sysrq_showlocks_op (*(struct sysrq_key_op *)NULL)
218 static DEFINE_SPINLOCK(show_lock
);
220 static void showacpu(void *dummy
)
224 /* Idle CPUs have no interesting backtrace. */
225 if (idle_cpu(smp_processor_id()))
228 spin_lock_irqsave(&show_lock
, flags
);
229 pr_info("CPU%d:\n", smp_processor_id());
230 show_stack(NULL
, NULL
);
231 spin_unlock_irqrestore(&show_lock
, flags
);
234 static void sysrq_showregs_othercpus(struct work_struct
*dummy
)
236 smp_call_function(showacpu
, NULL
, 0);
239 static DECLARE_WORK(sysrq_showallcpus
, sysrq_showregs_othercpus
);
241 static void sysrq_handle_showallcpus(int key
)
244 * Fall back to the workqueue based printing if the
245 * backtrace printing did not succeed or the
246 * architecture has no support for it:
248 if (!trigger_all_cpu_backtrace()) {
249 struct pt_regs
*regs
= NULL
;
252 regs
= get_irq_regs();
254 pr_info("CPU%d:\n", smp_processor_id());
257 schedule_work(&sysrq_showallcpus
);
261 static struct sysrq_key_op sysrq_showallcpus_op
= {
262 .handler
= sysrq_handle_showallcpus
,
263 .help_msg
= "show-backtrace-all-active-cpus(l)",
264 .action_msg
= "Show backtrace of all active CPUs",
265 .enable_mask
= SYSRQ_ENABLE_DUMP
,
269 static void sysrq_handle_showregs(int key
)
271 struct pt_regs
*regs
= NULL
;
274 regs
= get_irq_regs();
277 perf_event_print_debug();
279 static struct sysrq_key_op sysrq_showregs_op
= {
280 .handler
= sysrq_handle_showregs
,
281 .help_msg
= "show-registers(p)",
282 .action_msg
= "Show Regs",
283 .enable_mask
= SYSRQ_ENABLE_DUMP
,
286 static void sysrq_handle_showstate(int key
)
289 show_workqueue_state();
291 static struct sysrq_key_op sysrq_showstate_op
= {
292 .handler
= sysrq_handle_showstate
,
293 .help_msg
= "show-task-states(t)",
294 .action_msg
= "Show State",
295 .enable_mask
= SYSRQ_ENABLE_DUMP
,
298 static void sysrq_handle_showstate_blocked(int key
)
300 show_state_filter(TASK_UNINTERRUPTIBLE
);
302 static struct sysrq_key_op sysrq_showstate_blocked_op
= {
303 .handler
= sysrq_handle_showstate_blocked
,
304 .help_msg
= "show-blocked-tasks(w)",
305 .action_msg
= "Show Blocked State",
306 .enable_mask
= SYSRQ_ENABLE_DUMP
,
309 #ifdef CONFIG_TRACING
310 #include <linux/ftrace.h>
312 static void sysrq_ftrace_dump(int key
)
314 ftrace_dump(DUMP_ALL
);
316 static struct sysrq_key_op sysrq_ftrace_dump_op
= {
317 .handler
= sysrq_ftrace_dump
,
318 .help_msg
= "dump-ftrace-buffer(z)",
319 .action_msg
= "Dump ftrace buffer",
320 .enable_mask
= SYSRQ_ENABLE_DUMP
,
323 #define sysrq_ftrace_dump_op (*(struct sysrq_key_op *)NULL)
326 static void sysrq_handle_showmem(int key
)
330 static struct sysrq_key_op sysrq_showmem_op
= {
331 .handler
= sysrq_handle_showmem
,
332 .help_msg
= "show-memory-usage(m)",
333 .action_msg
= "Show Memory",
334 .enable_mask
= SYSRQ_ENABLE_DUMP
,
338 * Signal sysrq helper function. Sends a signal to all user processes.
340 static void send_sig_all(int sig
)
342 struct task_struct
*p
;
344 read_lock(&tasklist_lock
);
345 for_each_process(p
) {
346 if (p
->flags
& PF_KTHREAD
)
348 if (is_global_init(p
))
351 do_send_sig_info(sig
, SEND_SIG_FORCED
, p
, true);
353 read_unlock(&tasklist_lock
);
356 static void sysrq_handle_term(int key
)
358 send_sig_all(SIGTERM
);
359 console_loglevel
= CONSOLE_LOGLEVEL_DEBUG
;
361 static struct sysrq_key_op sysrq_term_op
= {
362 .handler
= sysrq_handle_term
,
363 .help_msg
= "terminate-all-tasks(e)",
364 .action_msg
= "Terminate All Tasks",
365 .enable_mask
= SYSRQ_ENABLE_SIGNAL
,
368 static void moom_callback(struct work_struct
*ignored
)
370 const gfp_t gfp_mask
= GFP_KERNEL
;
371 struct oom_control oc
= {
372 .zonelist
= node_zonelist(first_memory_node
, gfp_mask
),
375 .gfp_mask
= gfp_mask
,
379 mutex_lock(&oom_lock
);
380 if (!out_of_memory(&oc
))
381 pr_info("OOM request ignored. No task eligible\n");
382 mutex_unlock(&oom_lock
);
385 static DECLARE_WORK(moom_work
, moom_callback
);
387 static void sysrq_handle_moom(int key
)
389 schedule_work(&moom_work
);
391 static struct sysrq_key_op sysrq_moom_op
= {
392 .handler
= sysrq_handle_moom
,
393 .help_msg
= "memory-full-oom-kill(f)",
394 .action_msg
= "Manual OOM execution",
395 .enable_mask
= SYSRQ_ENABLE_SIGNAL
,
399 static void sysrq_handle_thaw(int key
)
401 emergency_thaw_all();
403 static struct sysrq_key_op sysrq_thaw_op
= {
404 .handler
= sysrq_handle_thaw
,
405 .help_msg
= "thaw-filesystems(j)",
406 .action_msg
= "Emergency Thaw of all frozen filesystems",
407 .enable_mask
= SYSRQ_ENABLE_SIGNAL
,
411 static void sysrq_handle_kill(int key
)
413 send_sig_all(SIGKILL
);
414 console_loglevel
= CONSOLE_LOGLEVEL_DEBUG
;
416 static struct sysrq_key_op sysrq_kill_op
= {
417 .handler
= sysrq_handle_kill
,
418 .help_msg
= "kill-all-tasks(i)",
419 .action_msg
= "Kill All Tasks",
420 .enable_mask
= SYSRQ_ENABLE_SIGNAL
,
423 static void sysrq_handle_unrt(int key
)
425 normalize_rt_tasks();
427 static struct sysrq_key_op sysrq_unrt_op
= {
428 .handler
= sysrq_handle_unrt
,
429 .help_msg
= "nice-all-RT-tasks(n)",
430 .action_msg
= "Nice All RT Tasks",
431 .enable_mask
= SYSRQ_ENABLE_RTNICE
,
434 /* Key Operations table and lock */
435 static DEFINE_SPINLOCK(sysrq_key_table_lock
);
437 static struct sysrq_key_op
*sysrq_key_table
[36] = {
438 &sysrq_loglevel_op
, /* 0 */
439 &sysrq_loglevel_op
, /* 1 */
440 &sysrq_loglevel_op
, /* 2 */
441 &sysrq_loglevel_op
, /* 3 */
442 &sysrq_loglevel_op
, /* 4 */
443 &sysrq_loglevel_op
, /* 5 */
444 &sysrq_loglevel_op
, /* 6 */
445 &sysrq_loglevel_op
, /* 7 */
446 &sysrq_loglevel_op
, /* 8 */
447 &sysrq_loglevel_op
, /* 9 */
450 * a: Don't use for system provided sysrqs, it is handled specially on
451 * sparc and will never arrive.
454 &sysrq_reboot_op
, /* b */
455 &sysrq_crash_op
, /* c */
456 &sysrq_showlocks_op
, /* d */
457 &sysrq_term_op
, /* e */
458 &sysrq_moom_op
, /* f */
459 /* g: May be registered for the kernel debugger */
461 NULL
, /* h - reserved for help */
462 &sysrq_kill_op
, /* i */
464 &sysrq_thaw_op
, /* j */
468 &sysrq_SAK_op
, /* k */
470 &sysrq_showallcpus_op
, /* l */
474 &sysrq_showmem_op
, /* m */
475 &sysrq_unrt_op
, /* n */
476 /* o: This will often be registered as 'Off' at init time */
478 &sysrq_showregs_op
, /* p */
479 &sysrq_show_timers_op
, /* q */
480 &sysrq_unraw_op
, /* r */
481 &sysrq_sync_op
, /* s */
482 &sysrq_showstate_op
, /* t */
483 &sysrq_mountro_op
, /* u */
484 /* v: May be registered for frame buffer console restore */
486 &sysrq_showstate_blocked_op
, /* w */
487 /* x: May be registered on mips for TLB dump */
488 /* x: May be registered on ppc/powerpc for xmon */
489 /* x: May be registered on sparc64 for global PMU dump */
490 /* x: May be registered on x86_64 for disabling secure boot */
492 /* y: May be registered on sparc64 for global register dump */
494 &sysrq_ftrace_dump_op
, /* z */
497 /* key2index calculation, -1 on invalid index */
498 static int sysrq_key_table_key2index(int key
)
502 if ((key
>= '0') && (key
<= '9'))
504 else if ((key
>= 'a') && (key
<= 'z'))
505 retval
= key
+ 10 - 'a';
512 * get and put functions for the table, exposed to modules.
514 struct sysrq_key_op
*__sysrq_get_key_op(int key
)
516 struct sysrq_key_op
*op_p
= NULL
;
519 i
= sysrq_key_table_key2index(key
);
521 op_p
= sysrq_key_table
[i
];
526 static void __sysrq_put_key_op(int key
, struct sysrq_key_op
*op_p
)
528 int i
= sysrq_key_table_key2index(key
);
531 sysrq_key_table
[i
] = op_p
;
534 void __handle_sysrq(int key
, unsigned int from
)
536 struct sysrq_key_op
*op_p
;
543 * Raise the apparent loglevel to maximum so that the sysrq header
544 * is shown to provide the user with positive feedback. We do not
545 * simply emit this at KERN_EMERG as that would change message
546 * routing in the consumers of /proc/kmsg.
548 orig_log_level
= console_loglevel
;
549 console_loglevel
= CONSOLE_LOGLEVEL_DEFAULT
;
552 op_p
= __sysrq_get_key_op(key
);
554 /* Ban synthetic events from some sysrq functionality */
555 if ((from
== SYSRQ_FROM_PROC
|| from
== SYSRQ_FROM_SYNTHETIC
) &&
556 op_p
->enable_mask
& SYSRQ_DISABLE_USERSPACE
)
557 printk("This sysrq operation is disabled from userspace.\n");
559 * Should we check for enabled operations (/proc/sysrq-trigger
560 * should not) and is the invoked operation enabled?
562 if (from
== SYSRQ_FROM_KERNEL
|| sysrq_on_mask(op_p
->enable_mask
)) {
563 pr_cont("%s\n", op_p
->action_msg
);
564 console_loglevel
= orig_log_level
;
567 pr_cont("This sysrq operation is disabled.\n");
571 /* Only print the help msg once per handler */
572 for (i
= 0; i
< ARRAY_SIZE(sysrq_key_table
); i
++) {
573 if (sysrq_key_table
[i
]) {
576 for (j
= 0; sysrq_key_table
[i
] !=
577 sysrq_key_table
[j
]; j
++)
581 pr_cont("%s ", sysrq_key_table
[i
]->help_msg
);
585 console_loglevel
= orig_log_level
;
591 void handle_sysrq(int key
)
594 __handle_sysrq(key
, SYSRQ_FROM_KERNEL
);
596 EXPORT_SYMBOL(handle_sysrq
);
599 static int sysrq_reset_downtime_ms
;
601 /* Simple translation table for the SysRq keys */
602 static const unsigned char sysrq_xlate
[KEY_CNT
] =
603 "\000\0331234567890-=\177\t" /* 0x00 - 0x0f */
604 "qwertyuiop[]\r\000as" /* 0x10 - 0x1f */
605 "dfghjkl;'`\000\\zxcv" /* 0x20 - 0x2f */
606 "bnm,./\000*\000 \000\201\202\203\204\205" /* 0x30 - 0x3f */
607 "\206\207\210\211\212\000\000789-456+1" /* 0x40 - 0x4f */
608 "230\177\000\000\213\214\000\000\000\000\000\000\000\000\000\000" /* 0x50 - 0x5f */
609 "\r\000/"; /* 0x60 - 0x6f */
612 struct input_handle handle
;
613 struct work_struct reinject_work
;
614 unsigned long key_down
[BITS_TO_LONGS(KEY_CNT
)];
616 unsigned int alt_use
;
621 /* reset sequence handling */
623 bool reset_requested
;
624 unsigned long reset_keybit
[BITS_TO_LONGS(KEY_CNT
)];
627 int reset_seq_version
;
628 struct timer_list keyreset_timer
;
631 #define SYSRQ_KEY_RESET_MAX 20 /* Should be plenty */
632 static unsigned short sysrq_reset_seq
[SYSRQ_KEY_RESET_MAX
];
633 static unsigned int sysrq_reset_seq_len
;
634 static unsigned int sysrq_reset_seq_version
= 1;
636 static void sysrq_parse_reset_sequence(struct sysrq_state
*state
)
641 state
->reset_seq_cnt
= 0;
643 for (i
= 0; i
< sysrq_reset_seq_len
; i
++) {
644 key
= sysrq_reset_seq
[i
];
646 if (key
== KEY_RESERVED
|| key
> KEY_MAX
)
649 __set_bit(key
, state
->reset_keybit
);
650 state
->reset_seq_len
++;
652 if (test_bit(key
, state
->key_down
))
653 state
->reset_seq_cnt
++;
656 /* Disable reset until old keys are not released */
657 state
->reset_canceled
= state
->reset_seq_cnt
!= 0;
659 state
->reset_seq_version
= sysrq_reset_seq_version
;
662 static void sysrq_do_reset(struct timer_list
*t
)
664 struct sysrq_state
*state
= from_timer(state
, t
, keyreset_timer
);
666 state
->reset_requested
= true;
669 kernel_restart(NULL
);
672 static void sysrq_handle_reset_request(struct sysrq_state
*state
)
674 if (state
->reset_requested
)
675 __handle_sysrq(sysrq_xlate
[KEY_B
], SYSRQ_FROM_KERNEL
);
677 if (sysrq_reset_downtime_ms
)
678 mod_timer(&state
->keyreset_timer
,
679 jiffies
+ msecs_to_jiffies(sysrq_reset_downtime_ms
));
681 sysrq_do_reset(&state
->keyreset_timer
);
684 static void sysrq_detect_reset_sequence(struct sysrq_state
*state
,
685 unsigned int code
, int value
)
687 if (!test_bit(code
, state
->reset_keybit
)) {
689 * Pressing any key _not_ in reset sequence cancels
690 * the reset sequence. Also cancelling the timer in
691 * case additional keys were pressed after a reset
692 * has been requested.
694 if (value
&& state
->reset_seq_cnt
) {
695 state
->reset_canceled
= true;
696 del_timer(&state
->keyreset_timer
);
698 } else if (value
== 0) {
700 * Key release - all keys in the reset sequence need
701 * to be pressed and held for the reset timeout
704 del_timer(&state
->keyreset_timer
);
706 if (--state
->reset_seq_cnt
== 0)
707 state
->reset_canceled
= false;
708 } else if (value
== 1) {
709 /* key press, not autorepeat */
710 if (++state
->reset_seq_cnt
== state
->reset_seq_len
&&
711 !state
->reset_canceled
) {
712 sysrq_handle_reset_request(state
);
718 static void sysrq_of_get_keyreset_config(void)
721 struct device_node
*np
;
722 struct property
*prop
;
725 np
= of_find_node_by_path("/chosen/linux,sysrq-reset-seq");
727 pr_debug("No sysrq node found");
731 /* Reset in case a __weak definition was present */
732 sysrq_reset_seq_len
= 0;
734 of_property_for_each_u32(np
, "keyset", prop
, p
, key
) {
735 if (key
== KEY_RESERVED
|| key
> KEY_MAX
||
736 sysrq_reset_seq_len
== SYSRQ_KEY_RESET_MAX
)
739 sysrq_reset_seq
[sysrq_reset_seq_len
++] = (unsigned short)key
;
742 /* Get reset timeout if any. */
743 of_property_read_u32(np
, "timeout-ms", &sysrq_reset_downtime_ms
);
746 static void sysrq_of_get_keyreset_config(void)
751 static void sysrq_reinject_alt_sysrq(struct work_struct
*work
)
753 struct sysrq_state
*sysrq
=
754 container_of(work
, struct sysrq_state
, reinject_work
);
755 struct input_handle
*handle
= &sysrq
->handle
;
756 unsigned int alt_code
= sysrq
->alt_use
;
758 if (sysrq
->need_reinject
) {
759 /* we do not want the assignment to be reordered */
760 sysrq
->reinjecting
= true;
763 /* Simulate press and release of Alt + SysRq */
764 input_inject_event(handle
, EV_KEY
, alt_code
, 1);
765 input_inject_event(handle
, EV_KEY
, KEY_SYSRQ
, 1);
766 input_inject_event(handle
, EV_SYN
, SYN_REPORT
, 1);
768 input_inject_event(handle
, EV_KEY
, KEY_SYSRQ
, 0);
769 input_inject_event(handle
, EV_KEY
, alt_code
, 0);
770 input_inject_event(handle
, EV_SYN
, SYN_REPORT
, 1);
773 sysrq
->reinjecting
= false;
777 static bool sysrq_handle_keypress(struct sysrq_state
*sysrq
,
778 unsigned int code
, int value
)
780 bool was_active
= sysrq
->active
;
788 /* One of ALTs is being released */
789 if (sysrq
->active
&& code
== sysrq
->alt_use
)
790 sysrq
->active
= false;
792 sysrq
->alt
= KEY_RESERVED
;
794 } else if (value
!= 2) {
796 sysrq
->need_reinject
= false;
801 if (value
== 1 && sysrq
->alt
!= KEY_RESERVED
) {
802 sysrq
->active
= true;
803 sysrq
->alt_use
= sysrq
->alt
;
805 * If nothing else will be pressed we'll need
806 * to re-inject Alt-SysRq keysroke.
808 sysrq
->need_reinject
= true;
812 * Pretend that sysrq was never pressed at all. This
813 * is needed to properly handle KGDB which will try
814 * to release all keys after exiting debugger. If we
815 * do not clear key bit it KGDB will end up sending
816 * release events for Alt and SysRq, potentially
817 * triggering print screen function.
820 clear_bit(KEY_SYSRQ
, sysrq
->handle
.dev
->key
);
825 if (sysrq
->active
&& value
&& value
!= 2) {
826 int from
= sysrq
->handle
.dev
->flags
& INPUTDEV_FLAGS_SYNTHETIC
?
827 SYSRQ_FROM_SYNTHETIC
: 0;
828 sysrq
->need_reinject
= false;
829 __handle_sysrq(sysrq_xlate
[code
], from
);
834 suppress
= sysrq
->active
;
836 if (!sysrq
->active
) {
839 * See if reset sequence has changed since the last time.
841 if (sysrq
->reset_seq_version
!= sysrq_reset_seq_version
)
842 sysrq_parse_reset_sequence(sysrq
);
845 * If we are not suppressing key presses keep track of
846 * keyboard state so we can release keys that have been
847 * pressed before entering SysRq mode.
850 set_bit(code
, sysrq
->key_down
);
852 clear_bit(code
, sysrq
->key_down
);
855 schedule_work(&sysrq
->reinject_work
);
857 /* Check for reset sequence */
858 sysrq_detect_reset_sequence(sysrq
, code
, value
);
860 } else if (value
== 0 && test_and_clear_bit(code
, sysrq
->key_down
)) {
862 * Pass on release events for keys that was pressed before
863 * entering SysRq mode.
871 static bool sysrq_filter(struct input_handle
*handle
,
872 unsigned int type
, unsigned int code
, int value
)
874 struct sysrq_state
*sysrq
= handle
->private;
878 * Do not filter anything if we are in the process of re-injecting
879 * Alt+SysRq combination.
881 if (sysrq
->reinjecting
)
891 suppress
= sysrq_handle_keypress(sysrq
, code
, value
);
895 suppress
= sysrq
->active
;
902 static int sysrq_connect(struct input_handler
*handler
,
903 struct input_dev
*dev
,
904 const struct input_device_id
*id
)
906 struct sysrq_state
*sysrq
;
909 sysrq
= kzalloc(sizeof(struct sysrq_state
), GFP_KERNEL
);
913 INIT_WORK(&sysrq
->reinject_work
, sysrq_reinject_alt_sysrq
);
915 sysrq
->handle
.dev
= dev
;
916 sysrq
->handle
.handler
= handler
;
917 sysrq
->handle
.name
= "sysrq";
918 sysrq
->handle
.private = sysrq
;
919 timer_setup(&sysrq
->keyreset_timer
, sysrq_do_reset
, 0);
921 error
= input_register_handle(&sysrq
->handle
);
923 pr_err("Failed to register input sysrq handler, error %d\n",
928 error
= input_open_device(&sysrq
->handle
);
930 pr_err("Failed to open input device, error %d\n", error
);
937 input_unregister_handle(&sysrq
->handle
);
943 static void sysrq_disconnect(struct input_handle
*handle
)
945 struct sysrq_state
*sysrq
= handle
->private;
947 input_close_device(handle
);
948 cancel_work_sync(&sysrq
->reinject_work
);
949 del_timer_sync(&sysrq
->keyreset_timer
);
950 input_unregister_handle(handle
);
955 * We are matching on KEY_LEFTALT instead of KEY_SYSRQ because not all
956 * keyboards have SysRq key predefined and so user may add it to keymap
957 * later, but we expect all such keyboards to have left alt.
959 static const struct input_device_id sysrq_ids
[] = {
961 .flags
= INPUT_DEVICE_ID_MATCH_EVBIT
|
962 INPUT_DEVICE_ID_MATCH_KEYBIT
,
963 .evbit
= { [BIT_WORD(EV_KEY
)] = BIT_MASK(EV_KEY
) },
964 .keybit
= { [BIT_WORD(KEY_LEFTALT
)] = BIT_MASK(KEY_LEFTALT
) },
969 static struct input_handler sysrq_handler
= {
970 .filter
= sysrq_filter
,
971 .connect
= sysrq_connect
,
972 .disconnect
= sysrq_disconnect
,
974 .id_table
= sysrq_ids
,
977 static bool sysrq_handler_registered
;
979 static inline void sysrq_register_handler(void)
983 sysrq_of_get_keyreset_config();
985 error
= input_register_handler(&sysrq_handler
);
987 pr_err("Failed to register input handler, error %d", error
);
989 sysrq_handler_registered
= true;
992 static inline void sysrq_unregister_handler(void)
994 if (sysrq_handler_registered
) {
995 input_unregister_handler(&sysrq_handler
);
996 sysrq_handler_registered
= false;
1000 static int sysrq_reset_seq_param_set(const char *buffer
,
1001 const struct kernel_param
*kp
)
1006 error
= kstrtoul(buffer
, 0, &val
);
1013 *((unsigned short *)kp
->arg
) = val
;
1014 sysrq_reset_seq_version
++;
1019 static const struct kernel_param_ops param_ops_sysrq_reset_seq
= {
1020 .get
= param_get_ushort
,
1021 .set
= sysrq_reset_seq_param_set
,
1024 #define param_check_sysrq_reset_seq(name, p) \
1025 __param_check(name, p, unsigned short)
1028 * not really modular, but the easiest way to keep compat with existing
1029 * bootargs behaviour is to continue using module_param here.
1031 module_param_array_named(reset_seq
, sysrq_reset_seq
, sysrq_reset_seq
,
1032 &sysrq_reset_seq_len
, 0644);
1034 module_param_named(sysrq_downtime_ms
, sysrq_reset_downtime_ms
, int, 0644);
1038 static inline void sysrq_register_handler(void)
1042 static inline void sysrq_unregister_handler(void)
1046 #endif /* CONFIG_INPUT */
1048 int sysrq_toggle_support(int enable_mask
)
1050 bool was_enabled
= sysrq_on();
1052 sysrq_enabled
= enable_mask
;
1054 if (was_enabled
!= sysrq_on()) {
1056 sysrq_register_handler();
1058 sysrq_unregister_handler();
1064 static int __sysrq_swap_key_ops(int key
, struct sysrq_key_op
*insert_op_p
,
1065 struct sysrq_key_op
*remove_op_p
)
1069 spin_lock(&sysrq_key_table_lock
);
1070 if (__sysrq_get_key_op(key
) == remove_op_p
) {
1071 __sysrq_put_key_op(key
, insert_op_p
);
1076 spin_unlock(&sysrq_key_table_lock
);
1079 * A concurrent __handle_sysrq either got the old op or the new op.
1080 * Wait for it to go away before returning, so the code for an old
1081 * op is not freed (eg. on module unload) while it is in use.
1088 int register_sysrq_key(int key
, struct sysrq_key_op
*op_p
)
1090 return __sysrq_swap_key_ops(key
, op_p
, NULL
);
1092 EXPORT_SYMBOL(register_sysrq_key
);
1094 int unregister_sysrq_key(int key
, struct sysrq_key_op
*op_p
)
1096 return __sysrq_swap_key_ops(key
, NULL
, op_p
);
1098 EXPORT_SYMBOL(unregister_sysrq_key
);
1100 #ifdef CONFIG_PROC_FS
1102 * writing 'C' to /proc/sysrq-trigger is like sysrq-C
1104 static ssize_t
write_sysrq_trigger(struct file
*file
, const char __user
*buf
,
1105 size_t count
, loff_t
*ppos
)
1110 if (get_user(c
, buf
))
1112 __handle_sysrq(c
, SYSRQ_FROM_PROC
);
1118 static const struct file_operations proc_sysrq_trigger_operations
= {
1119 .write
= write_sysrq_trigger
,
1120 .llseek
= noop_llseek
,
1123 static void sysrq_init_procfs(void)
1125 if (!proc_create("sysrq-trigger", S_IWUSR
, NULL
,
1126 &proc_sysrq_trigger_operations
))
1127 pr_err("Failed to register proc interface\n");
1132 static inline void sysrq_init_procfs(void)
1136 #endif /* CONFIG_PROC_FS */
1138 static int __init
sysrq_init(void)
1140 sysrq_init_procfs();
1143 sysrq_register_handler();
1147 device_initcall(sysrq_init
);