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/ctype.h>
23 #include <linux/interrupt.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>
53 #include <linux/rcupdate.h>
55 #include <asm/ptrace.h>
56 #include <asm/irq_regs.h>
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
;
62 static bool sysrq_on(void)
64 return sysrq_enabled
|| sysrq_always_enabled
;
68 * sysrq_mask - Getter for sysrq_enabled mask.
70 * Return: 1 if sysrq is always enabled, enabled sysrq_key_op mask otherwise.
74 if (sysrq_always_enabled
)
78 EXPORT_SYMBOL_GPL(sysrq_mask
);
81 * A value of 1 means 'all', other nonzero values are an op mask:
83 static bool sysrq_on_mask(int mask
)
85 return sysrq_always_enabled
||
87 (sysrq_enabled
& mask
);
90 static int __init
sysrq_always_enabled_setup(char *str
)
92 sysrq_always_enabled
= true;
93 pr_info("sysrq always enabled.\n");
98 __setup("sysrq_always_enabled", sysrq_always_enabled_setup
);
101 static void sysrq_handle_loglevel(int key
)
106 console_loglevel
= CONSOLE_LOGLEVEL_DEFAULT
;
107 pr_info("Loglevel set to %d\n", i
);
108 console_loglevel
= i
;
110 static const struct sysrq_key_op sysrq_loglevel_op
= {
111 .handler
= sysrq_handle_loglevel
,
112 .help_msg
= "loglevel(0-9)",
113 .action_msg
= "Changing Loglevel",
114 .enable_mask
= SYSRQ_ENABLE_LOG
,
118 static void sysrq_handle_SAK(int key
)
120 struct work_struct
*SAK_work
= &vc_cons
[fg_console
].SAK_work
;
122 schedule_work(SAK_work
);
124 static const struct sysrq_key_op sysrq_SAK_op
= {
125 .handler
= sysrq_handle_SAK
,
126 .help_msg
= "sak(k)",
128 .enable_mask
= SYSRQ_ENABLE_KEYBOARD
,
131 #define sysrq_SAK_op (*(const struct sysrq_key_op *)NULL)
135 static void sysrq_handle_unraw(int key
)
137 vt_reset_unicode(fg_console
);
140 static const struct sysrq_key_op sysrq_unraw_op
= {
141 .handler
= sysrq_handle_unraw
,
142 .help_msg
= "unraw(r)",
143 .action_msg
= "Keyboard mode set to system default",
144 .enable_mask
= SYSRQ_ENABLE_KEYBOARD
,
147 #define sysrq_unraw_op (*(const struct sysrq_key_op *)NULL)
148 #endif /* CONFIG_VT */
150 static void sysrq_handle_crash(int key
)
152 /* release the RCU read lock before crashing */
155 panic("sysrq triggered crash\n");
157 static const struct sysrq_key_op sysrq_crash_op
= {
158 .handler
= sysrq_handle_crash
,
159 .help_msg
= "crash(c)",
160 .action_msg
= "Trigger a crash",
161 .enable_mask
= SYSRQ_ENABLE_DUMP
,
164 static void sysrq_handle_reboot(int key
)
170 static const struct sysrq_key_op sysrq_reboot_op
= {
171 .handler
= sysrq_handle_reboot
,
172 .help_msg
= "reboot(b)",
173 .action_msg
= "Resetting",
174 .enable_mask
= SYSRQ_ENABLE_BOOT
,
177 const struct sysrq_key_op
*__sysrq_reboot_op
= &sysrq_reboot_op
;
179 static void sysrq_handle_sync(int key
)
183 static const struct sysrq_key_op sysrq_sync_op
= {
184 .handler
= sysrq_handle_sync
,
185 .help_msg
= "sync(s)",
186 .action_msg
= "Emergency Sync",
187 .enable_mask
= SYSRQ_ENABLE_SYNC
,
190 static void sysrq_handle_show_timers(int key
)
192 sysrq_timer_list_show();
195 static const struct sysrq_key_op sysrq_show_timers_op
= {
196 .handler
= sysrq_handle_show_timers
,
197 .help_msg
= "show-all-timers(q)",
198 .action_msg
= "Show clockevent devices & pending hrtimers (no others)",
201 static void sysrq_handle_mountro(int key
)
205 static const struct sysrq_key_op sysrq_mountro_op
= {
206 .handler
= sysrq_handle_mountro
,
207 .help_msg
= "unmount(u)",
208 .action_msg
= "Emergency Remount R/O",
209 .enable_mask
= SYSRQ_ENABLE_REMOUNT
,
212 #ifdef CONFIG_LOCKDEP
213 static void sysrq_handle_showlocks(int key
)
215 debug_show_all_locks();
218 static const struct sysrq_key_op sysrq_showlocks_op
= {
219 .handler
= sysrq_handle_showlocks
,
220 .help_msg
= "show-all-locks(d)",
221 .action_msg
= "Show Locks Held",
224 #define sysrq_showlocks_op (*(const struct sysrq_key_op *)NULL)
228 static DEFINE_RAW_SPINLOCK(show_lock
);
230 static void showacpu(void *dummy
)
234 /* Idle CPUs have no interesting backtrace. */
235 if (idle_cpu(smp_processor_id()))
238 raw_spin_lock_irqsave(&show_lock
, flags
);
239 pr_info("CPU%d:\n", smp_processor_id());
240 show_stack(NULL
, NULL
, KERN_INFO
);
241 raw_spin_unlock_irqrestore(&show_lock
, flags
);
244 static void sysrq_showregs_othercpus(struct work_struct
*dummy
)
246 smp_call_function(showacpu
, NULL
, 0);
249 static DECLARE_WORK(sysrq_showallcpus
, sysrq_showregs_othercpus
);
251 static void sysrq_handle_showallcpus(int key
)
254 * Fall back to the workqueue based printing if the
255 * backtrace printing did not succeed or the
256 * architecture has no support for it:
258 if (!trigger_all_cpu_backtrace()) {
259 struct pt_regs
*regs
= NULL
;
262 regs
= get_irq_regs();
264 pr_info("CPU%d:\n", smp_processor_id());
267 schedule_work(&sysrq_showallcpus
);
271 static const struct sysrq_key_op sysrq_showallcpus_op
= {
272 .handler
= sysrq_handle_showallcpus
,
273 .help_msg
= "show-backtrace-all-active-cpus(l)",
274 .action_msg
= "Show backtrace of all active CPUs",
275 .enable_mask
= SYSRQ_ENABLE_DUMP
,
279 static void sysrq_handle_showregs(int key
)
281 struct pt_regs
*regs
= NULL
;
284 regs
= get_irq_regs();
287 perf_event_print_debug();
289 static const struct sysrq_key_op sysrq_showregs_op
= {
290 .handler
= sysrq_handle_showregs
,
291 .help_msg
= "show-registers(p)",
292 .action_msg
= "Show Regs",
293 .enable_mask
= SYSRQ_ENABLE_DUMP
,
296 static void sysrq_handle_showstate(int key
)
299 show_workqueue_state();
301 static const struct sysrq_key_op sysrq_showstate_op
= {
302 .handler
= sysrq_handle_showstate
,
303 .help_msg
= "show-task-states(t)",
304 .action_msg
= "Show State",
305 .enable_mask
= SYSRQ_ENABLE_DUMP
,
308 static void sysrq_handle_showstate_blocked(int key
)
310 show_state_filter(TASK_UNINTERRUPTIBLE
);
312 static const struct sysrq_key_op sysrq_showstate_blocked_op
= {
313 .handler
= sysrq_handle_showstate_blocked
,
314 .help_msg
= "show-blocked-tasks(w)",
315 .action_msg
= "Show Blocked State",
316 .enable_mask
= SYSRQ_ENABLE_DUMP
,
319 #ifdef CONFIG_TRACING
320 #include <linux/ftrace.h>
322 static void sysrq_ftrace_dump(int key
)
324 ftrace_dump(DUMP_ALL
);
326 static const struct sysrq_key_op sysrq_ftrace_dump_op
= {
327 .handler
= sysrq_ftrace_dump
,
328 .help_msg
= "dump-ftrace-buffer(z)",
329 .action_msg
= "Dump ftrace buffer",
330 .enable_mask
= SYSRQ_ENABLE_DUMP
,
333 #define sysrq_ftrace_dump_op (*(const struct sysrq_key_op *)NULL)
336 static void sysrq_handle_showmem(int key
)
340 static const struct sysrq_key_op sysrq_showmem_op
= {
341 .handler
= sysrq_handle_showmem
,
342 .help_msg
= "show-memory-usage(m)",
343 .action_msg
= "Show Memory",
344 .enable_mask
= SYSRQ_ENABLE_DUMP
,
348 * Signal sysrq helper function. Sends a signal to all user processes.
350 static void send_sig_all(int sig
)
352 struct task_struct
*p
;
354 read_lock(&tasklist_lock
);
355 for_each_process(p
) {
356 if (p
->flags
& PF_KTHREAD
)
358 if (is_global_init(p
))
361 do_send_sig_info(sig
, SEND_SIG_PRIV
, p
, PIDTYPE_MAX
);
363 read_unlock(&tasklist_lock
);
366 static void sysrq_handle_term(int key
)
368 send_sig_all(SIGTERM
);
369 console_loglevel
= CONSOLE_LOGLEVEL_DEBUG
;
371 static const struct sysrq_key_op sysrq_term_op
= {
372 .handler
= sysrq_handle_term
,
373 .help_msg
= "terminate-all-tasks(e)",
374 .action_msg
= "Terminate All Tasks",
375 .enable_mask
= SYSRQ_ENABLE_SIGNAL
,
378 static void moom_callback(struct work_struct
*ignored
)
380 const gfp_t gfp_mask
= GFP_KERNEL
;
381 struct oom_control oc
= {
382 .zonelist
= node_zonelist(first_memory_node
, gfp_mask
),
385 .gfp_mask
= gfp_mask
,
389 mutex_lock(&oom_lock
);
390 if (!out_of_memory(&oc
))
391 pr_info("OOM request ignored. No task eligible\n");
392 mutex_unlock(&oom_lock
);
395 static DECLARE_WORK(moom_work
, moom_callback
);
397 static void sysrq_handle_moom(int key
)
399 schedule_work(&moom_work
);
401 static const struct sysrq_key_op sysrq_moom_op
= {
402 .handler
= sysrq_handle_moom
,
403 .help_msg
= "memory-full-oom-kill(f)",
404 .action_msg
= "Manual OOM execution",
405 .enable_mask
= SYSRQ_ENABLE_SIGNAL
,
408 static void sysrq_handle_thaw(int key
)
410 emergency_thaw_all();
412 static const struct sysrq_key_op sysrq_thaw_op
= {
413 .handler
= sysrq_handle_thaw
,
414 .help_msg
= "thaw-filesystems(j)",
415 .action_msg
= "Emergency Thaw of all frozen filesystems",
416 .enable_mask
= SYSRQ_ENABLE_SIGNAL
,
419 static void sysrq_handle_kill(int key
)
421 send_sig_all(SIGKILL
);
422 console_loglevel
= CONSOLE_LOGLEVEL_DEBUG
;
424 static const struct sysrq_key_op sysrq_kill_op
= {
425 .handler
= sysrq_handle_kill
,
426 .help_msg
= "kill-all-tasks(i)",
427 .action_msg
= "Kill All Tasks",
428 .enable_mask
= SYSRQ_ENABLE_SIGNAL
,
431 static void sysrq_handle_unrt(int key
)
433 normalize_rt_tasks();
435 static const struct sysrq_key_op sysrq_unrt_op
= {
436 .handler
= sysrq_handle_unrt
,
437 .help_msg
= "nice-all-RT-tasks(n)",
438 .action_msg
= "Nice All RT Tasks",
439 .enable_mask
= SYSRQ_ENABLE_RTNICE
,
442 /* Key Operations table and lock */
443 static DEFINE_SPINLOCK(sysrq_key_table_lock
);
445 static const struct sysrq_key_op
*sysrq_key_table
[62] = {
446 &sysrq_loglevel_op
, /* 0 */
447 &sysrq_loglevel_op
, /* 1 */
448 &sysrq_loglevel_op
, /* 2 */
449 &sysrq_loglevel_op
, /* 3 */
450 &sysrq_loglevel_op
, /* 4 */
451 &sysrq_loglevel_op
, /* 5 */
452 &sysrq_loglevel_op
, /* 6 */
453 &sysrq_loglevel_op
, /* 7 */
454 &sysrq_loglevel_op
, /* 8 */
455 &sysrq_loglevel_op
, /* 9 */
458 * a: Don't use for system provided sysrqs, it is handled specially on
459 * sparc and will never arrive.
462 &sysrq_reboot_op
, /* b */
463 &sysrq_crash_op
, /* c */
464 &sysrq_showlocks_op
, /* d */
465 &sysrq_term_op
, /* e */
466 &sysrq_moom_op
, /* f */
467 /* g: May be registered for the kernel debugger */
469 NULL
, /* h - reserved for help */
470 &sysrq_kill_op
, /* i */
472 &sysrq_thaw_op
, /* j */
476 &sysrq_SAK_op
, /* k */
478 &sysrq_showallcpus_op
, /* l */
482 &sysrq_showmem_op
, /* m */
483 &sysrq_unrt_op
, /* n */
484 /* o: This will often be registered as 'Off' at init time */
486 &sysrq_showregs_op
, /* p */
487 &sysrq_show_timers_op
, /* q */
488 &sysrq_unraw_op
, /* r */
489 &sysrq_sync_op
, /* s */
490 &sysrq_showstate_op
, /* t */
491 &sysrq_mountro_op
, /* u */
492 /* v: May be registered for frame buffer console restore */
494 &sysrq_showstate_blocked_op
, /* w */
495 /* x: May be registered on mips for TLB dump */
496 /* x: May be registered on ppc/powerpc for xmon */
497 /* x: May be registered on sparc64 for global PMU dump */
499 /* y: May be registered on sparc64 for global register dump */
501 &sysrq_ftrace_dump_op
, /* z */
530 /* key2index calculation, -1 on invalid index */
531 static int sysrq_key_table_key2index(int key
)
535 if ((key
>= '0') && (key
<= '9'))
537 else if ((key
>= 'a') && (key
<= 'z'))
538 retval
= key
+ 10 - 'a';
539 else if ((key
>= 'A') && (key
<= 'Z'))
540 retval
= key
+ 36 - 'A';
547 * get and put functions for the table, exposed to modules.
549 static const struct sysrq_key_op
*__sysrq_get_key_op(int key
)
551 const struct sysrq_key_op
*op_p
= NULL
;
554 i
= sysrq_key_table_key2index(key
);
556 op_p
= sysrq_key_table
[i
];
561 static void __sysrq_put_key_op(int key
, const struct sysrq_key_op
*op_p
)
563 int i
= sysrq_key_table_key2index(key
);
566 sysrq_key_table
[i
] = op_p
;
569 void __handle_sysrq(int key
, bool check_mask
)
571 const struct sysrq_key_op
*op_p
;
573 int orig_suppress_printk
;
576 orig_suppress_printk
= suppress_printk
;
582 * Raise the apparent loglevel to maximum so that the sysrq header
583 * is shown to provide the user with positive feedback. We do not
584 * simply emit this at KERN_EMERG as that would change message
585 * routing in the consumers of /proc/kmsg.
587 orig_log_level
= console_loglevel
;
588 console_loglevel
= CONSOLE_LOGLEVEL_DEFAULT
;
590 op_p
= __sysrq_get_key_op(key
);
593 * Should we check for enabled operations (/proc/sysrq-trigger
594 * should not) and is the invoked operation enabled?
596 if (!check_mask
|| sysrq_on_mask(op_p
->enable_mask
)) {
597 pr_info("%s\n", op_p
->action_msg
);
598 console_loglevel
= orig_log_level
;
601 pr_info("This sysrq operation is disabled.\n");
602 console_loglevel
= orig_log_level
;
606 /* Only print the help msg once per handler */
607 for (i
= 0; i
< ARRAY_SIZE(sysrq_key_table
); i
++) {
608 if (sysrq_key_table
[i
]) {
611 for (j
= 0; sysrq_key_table
[i
] !=
612 sysrq_key_table
[j
]; j
++)
616 pr_cont("%s ", sysrq_key_table
[i
]->help_msg
);
620 console_loglevel
= orig_log_level
;
625 suppress_printk
= orig_suppress_printk
;
628 void handle_sysrq(int key
)
631 __handle_sysrq(key
, true);
633 EXPORT_SYMBOL(handle_sysrq
);
636 static int sysrq_reset_downtime_ms
;
638 /* Simple translation table for the SysRq keys */
639 static const unsigned char sysrq_xlate
[KEY_CNT
] =
640 "\000\0331234567890-=\177\t" /* 0x00 - 0x0f */
641 "qwertyuiop[]\r\000as" /* 0x10 - 0x1f */
642 "dfghjkl;'`\000\\zxcv" /* 0x20 - 0x2f */
643 "bnm,./\000*\000 \000\201\202\203\204\205" /* 0x30 - 0x3f */
644 "\206\207\210\211\212\000\000789-456+1" /* 0x40 - 0x4f */
645 "230\177\000\000\213\214\000\000\000\000\000\000\000\000\000\000" /* 0x50 - 0x5f */
646 "\r\000/"; /* 0x60 - 0x6f */
649 struct input_handle handle
;
650 struct work_struct reinject_work
;
651 unsigned long key_down
[BITS_TO_LONGS(KEY_CNT
)];
653 unsigned int alt_use
;
655 unsigned int shift_use
;
660 /* reset sequence handling */
662 bool reset_requested
;
663 unsigned long reset_keybit
[BITS_TO_LONGS(KEY_CNT
)];
666 int reset_seq_version
;
667 struct timer_list keyreset_timer
;
670 #define SYSRQ_KEY_RESET_MAX 20 /* Should be plenty */
671 static unsigned short sysrq_reset_seq
[SYSRQ_KEY_RESET_MAX
];
672 static unsigned int sysrq_reset_seq_len
;
673 static unsigned int sysrq_reset_seq_version
= 1;
675 static void sysrq_parse_reset_sequence(struct sysrq_state
*state
)
680 state
->reset_seq_cnt
= 0;
682 for (i
= 0; i
< sysrq_reset_seq_len
; i
++) {
683 key
= sysrq_reset_seq
[i
];
685 if (key
== KEY_RESERVED
|| key
> KEY_MAX
)
688 __set_bit(key
, state
->reset_keybit
);
689 state
->reset_seq_len
++;
691 if (test_bit(key
, state
->key_down
))
692 state
->reset_seq_cnt
++;
695 /* Disable reset until old keys are not released */
696 state
->reset_canceled
= state
->reset_seq_cnt
!= 0;
698 state
->reset_seq_version
= sysrq_reset_seq_version
;
701 static void sysrq_do_reset(struct timer_list
*t
)
703 struct sysrq_state
*state
= from_timer(state
, t
, keyreset_timer
);
705 state
->reset_requested
= true;
710 static void sysrq_handle_reset_request(struct sysrq_state
*state
)
712 if (state
->reset_requested
)
713 __handle_sysrq(sysrq_xlate
[KEY_B
], false);
715 if (sysrq_reset_downtime_ms
)
716 mod_timer(&state
->keyreset_timer
,
717 jiffies
+ msecs_to_jiffies(sysrq_reset_downtime_ms
));
719 sysrq_do_reset(&state
->keyreset_timer
);
722 static void sysrq_detect_reset_sequence(struct sysrq_state
*state
,
723 unsigned int code
, int value
)
725 if (!test_bit(code
, state
->reset_keybit
)) {
727 * Pressing any key _not_ in reset sequence cancels
728 * the reset sequence. Also cancelling the timer in
729 * case additional keys were pressed after a reset
730 * has been requested.
732 if (value
&& state
->reset_seq_cnt
) {
733 state
->reset_canceled
= true;
734 del_timer(&state
->keyreset_timer
);
736 } else if (value
== 0) {
738 * Key release - all keys in the reset sequence need
739 * to be pressed and held for the reset timeout
742 del_timer(&state
->keyreset_timer
);
744 if (--state
->reset_seq_cnt
== 0)
745 state
->reset_canceled
= false;
746 } else if (value
== 1) {
747 /* key press, not autorepeat */
748 if (++state
->reset_seq_cnt
== state
->reset_seq_len
&&
749 !state
->reset_canceled
) {
750 sysrq_handle_reset_request(state
);
756 static void sysrq_of_get_keyreset_config(void)
759 struct device_node
*np
;
760 struct property
*prop
;
763 np
= of_find_node_by_path("/chosen/linux,sysrq-reset-seq");
765 pr_debug("No sysrq node found");
769 /* Reset in case a __weak definition was present */
770 sysrq_reset_seq_len
= 0;
772 of_property_for_each_u32(np
, "keyset", prop
, p
, key
) {
773 if (key
== KEY_RESERVED
|| key
> KEY_MAX
||
774 sysrq_reset_seq_len
== SYSRQ_KEY_RESET_MAX
)
777 sysrq_reset_seq
[sysrq_reset_seq_len
++] = (unsigned short)key
;
780 /* Get reset timeout if any. */
781 of_property_read_u32(np
, "timeout-ms", &sysrq_reset_downtime_ms
);
786 static void sysrq_of_get_keyreset_config(void)
791 static void sysrq_reinject_alt_sysrq(struct work_struct
*work
)
793 struct sysrq_state
*sysrq
=
794 container_of(work
, struct sysrq_state
, reinject_work
);
795 struct input_handle
*handle
= &sysrq
->handle
;
796 unsigned int alt_code
= sysrq
->alt_use
;
798 if (sysrq
->need_reinject
) {
799 /* we do not want the assignment to be reordered */
800 sysrq
->reinjecting
= true;
803 /* Simulate press and release of Alt + SysRq */
804 input_inject_event(handle
, EV_KEY
, alt_code
, 1);
805 input_inject_event(handle
, EV_KEY
, KEY_SYSRQ
, 1);
806 input_inject_event(handle
, EV_SYN
, SYN_REPORT
, 1);
808 input_inject_event(handle
, EV_KEY
, KEY_SYSRQ
, 0);
809 input_inject_event(handle
, EV_KEY
, alt_code
, 0);
810 input_inject_event(handle
, EV_SYN
, SYN_REPORT
, 1);
813 sysrq
->reinjecting
= false;
817 static bool sysrq_handle_keypress(struct sysrq_state
*sysrq
,
818 unsigned int code
, int value
)
820 bool was_active
= sysrq
->active
;
828 /* One of ALTs is being released */
829 if (sysrq
->active
&& code
== sysrq
->alt_use
)
830 sysrq
->active
= false;
832 sysrq
->alt
= KEY_RESERVED
;
834 } else if (value
!= 2) {
836 sysrq
->need_reinject
= false;
843 sysrq
->shift
= KEY_RESERVED
;
849 if (value
== 1 && sysrq
->alt
!= KEY_RESERVED
) {
850 sysrq
->active
= true;
851 sysrq
->alt_use
= sysrq
->alt
;
852 /* either RESERVED (for released) or actual code */
853 sysrq
->shift_use
= sysrq
->shift
;
855 * If nothing else will be pressed we'll need
856 * to re-inject Alt-SysRq keysroke.
858 sysrq
->need_reinject
= true;
862 * Pretend that sysrq was never pressed at all. This
863 * is needed to properly handle KGDB which will try
864 * to release all keys after exiting debugger. If we
865 * do not clear key bit it KGDB will end up sending
866 * release events for Alt and SysRq, potentially
867 * triggering print screen function.
870 clear_bit(KEY_SYSRQ
, sysrq
->handle
.dev
->key
);
875 if (sysrq
->active
&& value
&& value
!= 2) {
876 unsigned char c
= sysrq_xlate
[code
];
878 sysrq
->need_reinject
= false;
879 if (sysrq
->shift_use
!= KEY_RESERVED
)
881 __handle_sysrq(c
, true);
886 suppress
= sysrq
->active
;
888 if (!sysrq
->active
) {
891 * See if reset sequence has changed since the last time.
893 if (sysrq
->reset_seq_version
!= sysrq_reset_seq_version
)
894 sysrq_parse_reset_sequence(sysrq
);
897 * If we are not suppressing key presses keep track of
898 * keyboard state so we can release keys that have been
899 * pressed before entering SysRq mode.
902 set_bit(code
, sysrq
->key_down
);
904 clear_bit(code
, sysrq
->key_down
);
907 schedule_work(&sysrq
->reinject_work
);
909 /* Check for reset sequence */
910 sysrq_detect_reset_sequence(sysrq
, code
, value
);
912 } else if (value
== 0 && test_and_clear_bit(code
, sysrq
->key_down
)) {
914 * Pass on release events for keys that was pressed before
915 * entering SysRq mode.
923 static bool sysrq_filter(struct input_handle
*handle
,
924 unsigned int type
, unsigned int code
, int value
)
926 struct sysrq_state
*sysrq
= handle
->private;
930 * Do not filter anything if we are in the process of re-injecting
931 * Alt+SysRq combination.
933 if (sysrq
->reinjecting
)
943 suppress
= sysrq_handle_keypress(sysrq
, code
, value
);
947 suppress
= sysrq
->active
;
954 static int sysrq_connect(struct input_handler
*handler
,
955 struct input_dev
*dev
,
956 const struct input_device_id
*id
)
958 struct sysrq_state
*sysrq
;
961 sysrq
= kzalloc(sizeof(struct sysrq_state
), GFP_KERNEL
);
965 INIT_WORK(&sysrq
->reinject_work
, sysrq_reinject_alt_sysrq
);
967 sysrq
->handle
.dev
= dev
;
968 sysrq
->handle
.handler
= handler
;
969 sysrq
->handle
.name
= "sysrq";
970 sysrq
->handle
.private = sysrq
;
971 timer_setup(&sysrq
->keyreset_timer
, sysrq_do_reset
, 0);
973 error
= input_register_handle(&sysrq
->handle
);
975 pr_err("Failed to register input sysrq handler, error %d\n",
980 error
= input_open_device(&sysrq
->handle
);
982 pr_err("Failed to open input device, error %d\n", error
);
989 input_unregister_handle(&sysrq
->handle
);
995 static void sysrq_disconnect(struct input_handle
*handle
)
997 struct sysrq_state
*sysrq
= handle
->private;
999 input_close_device(handle
);
1000 cancel_work_sync(&sysrq
->reinject_work
);
1001 del_timer_sync(&sysrq
->keyreset_timer
);
1002 input_unregister_handle(handle
);
1007 * We are matching on KEY_LEFTALT instead of KEY_SYSRQ because not all
1008 * keyboards have SysRq key predefined and so user may add it to keymap
1009 * later, but we expect all such keyboards to have left alt.
1011 static const struct input_device_id sysrq_ids
[] = {
1013 .flags
= INPUT_DEVICE_ID_MATCH_EVBIT
|
1014 INPUT_DEVICE_ID_MATCH_KEYBIT
,
1015 .evbit
= { [BIT_WORD(EV_KEY
)] = BIT_MASK(EV_KEY
) },
1016 .keybit
= { [BIT_WORD(KEY_LEFTALT
)] = BIT_MASK(KEY_LEFTALT
) },
1021 static struct input_handler sysrq_handler
= {
1022 .filter
= sysrq_filter
,
1023 .connect
= sysrq_connect
,
1024 .disconnect
= sysrq_disconnect
,
1026 .id_table
= sysrq_ids
,
1029 static inline void sysrq_register_handler(void)
1033 sysrq_of_get_keyreset_config();
1035 error
= input_register_handler(&sysrq_handler
);
1037 pr_err("Failed to register input handler, error %d", error
);
1040 static inline void sysrq_unregister_handler(void)
1042 input_unregister_handler(&sysrq_handler
);
1045 static int sysrq_reset_seq_param_set(const char *buffer
,
1046 const struct kernel_param
*kp
)
1051 error
= kstrtoul(buffer
, 0, &val
);
1058 *((unsigned short *)kp
->arg
) = val
;
1059 sysrq_reset_seq_version
++;
1064 static const struct kernel_param_ops param_ops_sysrq_reset_seq
= {
1065 .get
= param_get_ushort
,
1066 .set
= sysrq_reset_seq_param_set
,
1069 #define param_check_sysrq_reset_seq(name, p) \
1070 __param_check(name, p, unsigned short)
1073 * not really modular, but the easiest way to keep compat with existing
1074 * bootargs behaviour is to continue using module_param here.
1076 module_param_array_named(reset_seq
, sysrq_reset_seq
, sysrq_reset_seq
,
1077 &sysrq_reset_seq_len
, 0644);
1079 module_param_named(sysrq_downtime_ms
, sysrq_reset_downtime_ms
, int, 0644);
1083 static inline void sysrq_register_handler(void)
1087 static inline void sysrq_unregister_handler(void)
1091 #endif /* CONFIG_INPUT */
1093 int sysrq_toggle_support(int enable_mask
)
1095 bool was_enabled
= sysrq_on();
1097 sysrq_enabled
= enable_mask
;
1099 if (was_enabled
!= sysrq_on()) {
1101 sysrq_register_handler();
1103 sysrq_unregister_handler();
1108 EXPORT_SYMBOL_GPL(sysrq_toggle_support
);
1110 static int __sysrq_swap_key_ops(int key
, const struct sysrq_key_op
*insert_op_p
,
1111 const struct sysrq_key_op
*remove_op_p
)
1115 spin_lock(&sysrq_key_table_lock
);
1116 if (__sysrq_get_key_op(key
) == remove_op_p
) {
1117 __sysrq_put_key_op(key
, insert_op_p
);
1122 spin_unlock(&sysrq_key_table_lock
);
1125 * A concurrent __handle_sysrq either got the old op or the new op.
1126 * Wait for it to go away before returning, so the code for an old
1127 * op is not freed (eg. on module unload) while it is in use.
1134 int register_sysrq_key(int key
, const struct sysrq_key_op
*op_p
)
1136 return __sysrq_swap_key_ops(key
, op_p
, NULL
);
1138 EXPORT_SYMBOL(register_sysrq_key
);
1140 int unregister_sysrq_key(int key
, const struct sysrq_key_op
*op_p
)
1142 return __sysrq_swap_key_ops(key
, NULL
, op_p
);
1144 EXPORT_SYMBOL(unregister_sysrq_key
);
1146 #ifdef CONFIG_PROC_FS
1148 * writing 'C' to /proc/sysrq-trigger is like sysrq-C
1150 static ssize_t
write_sysrq_trigger(struct file
*file
, const char __user
*buf
,
1151 size_t count
, loff_t
*ppos
)
1156 if (get_user(c
, buf
))
1158 __handle_sysrq(c
, false);
1164 static const struct proc_ops sysrq_trigger_proc_ops
= {
1165 .proc_write
= write_sysrq_trigger
,
1166 .proc_lseek
= noop_llseek
,
1169 static void sysrq_init_procfs(void)
1171 if (!proc_create("sysrq-trigger", S_IWUSR
, NULL
,
1172 &sysrq_trigger_proc_ops
))
1173 pr_err("Failed to register proc interface\n");
1178 static inline void sysrq_init_procfs(void)
1182 #endif /* CONFIG_PROC_FS */
1184 static int __init
sysrq_init(void)
1186 sysrq_init_procfs();
1189 sysrq_register_handler();
1193 device_initcall(sysrq_init
);