2 * Linux Magic System Request Key Hacks
4 * (c) 1997 Martin Mares <mj@atrey.karlin.mff.cuni.cz>
5 * based on ideas by Pavel Machek <pavel@atrey.karlin.mff.cuni.cz>
7 * (c) 2000 Crutcher Dunnavant <crutcher+kernel@datastacks.com>
8 * overhauled to use key registration
9 * based upon discusions in irc://irc.openprojects.net/#kernelnewbies
11 * Copyright (c) 2010 Dmitry Torokhov
12 * Input handler conversion
15 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
17 #include <linux/sched.h>
18 #include <linux/sched/rt.h>
19 #include <linux/interrupt.h>
22 #include <linux/mount.h>
23 #include <linux/kdev_t.h>
24 #include <linux/major.h>
25 #include <linux/reboot.h>
26 #include <linux/sysrq.h>
27 #include <linux/kbd_kern.h>
28 #include <linux/proc_fs.h>
29 #include <linux/nmi.h>
30 #include <linux/quotaops.h>
31 #include <linux/perf_event.h>
32 #include <linux/kernel.h>
33 #include <linux/module.h>
34 #include <linux/suspend.h>
35 #include <linux/writeback.h>
36 #include <linux/swap.h>
37 #include <linux/spinlock.h>
38 #include <linux/vt_kern.h>
39 #include <linux/workqueue.h>
40 #include <linux/hrtimer.h>
41 #include <linux/oom.h>
42 #include <linux/slab.h>
43 #include <linux/input.h>
44 #include <linux/uaccess.h>
45 #include <linux/moduleparam.h>
46 #include <linux/jiffies.h>
48 #include <asm/ptrace.h>
49 #include <asm/irq_regs.h>
51 /* Whether we react on sysrq keys or just ignore them */
52 static int __read_mostly sysrq_enabled
= SYSRQ_DEFAULT_ENABLE
;
53 static bool __read_mostly sysrq_always_enabled
;
55 unsigned short platform_sysrq_reset_seq
[] __weak
= { KEY_RESERVED
};
56 int sysrq_reset_downtime_ms __weak
;
58 static bool sysrq_on(void)
60 return sysrq_enabled
|| sysrq_always_enabled
;
64 * A value of 1 means 'all', other nonzero values are an op mask:
66 static bool sysrq_on_mask(int mask
)
68 return sysrq_always_enabled
||
70 (sysrq_enabled
& mask
);
73 static int __init
sysrq_always_enabled_setup(char *str
)
75 sysrq_always_enabled
= true;
76 pr_info("sysrq always enabled.\n");
81 __setup("sysrq_always_enabled", sysrq_always_enabled_setup
);
84 static void sysrq_handle_loglevel(int key
)
90 printk("Loglevel set to %d\n", i
);
93 static struct sysrq_key_op sysrq_loglevel_op
= {
94 .handler
= sysrq_handle_loglevel
,
95 .help_msg
= "loglevel(0-9)",
96 .action_msg
= "Changing Loglevel",
97 .enable_mask
= SYSRQ_ENABLE_LOG
,
101 static void sysrq_handle_SAK(int key
)
103 struct work_struct
*SAK_work
= &vc_cons
[fg_console
].SAK_work
;
104 schedule_work(SAK_work
);
106 static struct sysrq_key_op sysrq_SAK_op
= {
107 .handler
= sysrq_handle_SAK
,
108 .help_msg
= "sak(k)",
110 .enable_mask
= SYSRQ_ENABLE_KEYBOARD
,
113 #define sysrq_SAK_op (*(struct sysrq_key_op *)NULL)
117 static void sysrq_handle_unraw(int key
)
119 vt_reset_unicode(fg_console
);
122 static struct sysrq_key_op sysrq_unraw_op
= {
123 .handler
= sysrq_handle_unraw
,
124 .help_msg
= "unraw(r)",
125 .action_msg
= "Keyboard mode set to system default",
126 .enable_mask
= SYSRQ_ENABLE_KEYBOARD
,
129 #define sysrq_unraw_op (*(struct sysrq_key_op *)NULL)
130 #endif /* CONFIG_VT */
132 static void sysrq_handle_crash(int key
)
136 panic_on_oops
= 1; /* force panic */
140 static struct sysrq_key_op sysrq_crash_op
= {
141 .handler
= sysrq_handle_crash
,
142 .help_msg
= "crash(c)",
143 .action_msg
= "Trigger a crash",
144 .enable_mask
= SYSRQ_ENABLE_DUMP
,
147 static void sysrq_handle_reboot(int key
)
153 static struct sysrq_key_op sysrq_reboot_op
= {
154 .handler
= sysrq_handle_reboot
,
155 .help_msg
= "reboot(b)",
156 .action_msg
= "Resetting",
157 .enable_mask
= SYSRQ_ENABLE_BOOT
,
160 static void sysrq_handle_sync(int key
)
164 static struct sysrq_key_op sysrq_sync_op
= {
165 .handler
= sysrq_handle_sync
,
166 .help_msg
= "sync(s)",
167 .action_msg
= "Emergency Sync",
168 .enable_mask
= SYSRQ_ENABLE_SYNC
,
171 static void sysrq_handle_show_timers(int key
)
173 sysrq_timer_list_show();
176 static struct sysrq_key_op sysrq_show_timers_op
= {
177 .handler
= sysrq_handle_show_timers
,
178 .help_msg
= "show-all-timers(q)",
179 .action_msg
= "Show clockevent devices & pending hrtimers (no others)",
182 static void sysrq_handle_mountro(int key
)
186 static struct sysrq_key_op sysrq_mountro_op
= {
187 .handler
= sysrq_handle_mountro
,
188 .help_msg
= "unmount(u)",
189 .action_msg
= "Emergency Remount R/O",
190 .enable_mask
= SYSRQ_ENABLE_REMOUNT
,
193 #ifdef CONFIG_LOCKDEP
194 static void sysrq_handle_showlocks(int key
)
196 debug_show_all_locks();
199 static struct sysrq_key_op sysrq_showlocks_op
= {
200 .handler
= sysrq_handle_showlocks
,
201 .help_msg
= "show-all-locks(d)",
202 .action_msg
= "Show Locks Held",
205 #define sysrq_showlocks_op (*(struct sysrq_key_op *)NULL)
209 static DEFINE_SPINLOCK(show_lock
);
211 static void showacpu(void *dummy
)
215 /* Idle CPUs have no interesting backtrace. */
216 if (idle_cpu(smp_processor_id()))
219 spin_lock_irqsave(&show_lock
, flags
);
220 printk(KERN_INFO
"CPU%d:\n", smp_processor_id());
221 show_stack(NULL
, NULL
);
222 spin_unlock_irqrestore(&show_lock
, flags
);
225 static void sysrq_showregs_othercpus(struct work_struct
*dummy
)
227 smp_call_function(showacpu
, NULL
, 0);
230 static DECLARE_WORK(sysrq_showallcpus
, sysrq_showregs_othercpus
);
232 static void sysrq_handle_showallcpus(int key
)
235 * Fall back to the workqueue based printing if the
236 * backtrace printing did not succeed or the
237 * architecture has no support for it:
239 if (!trigger_all_cpu_backtrace()) {
240 struct pt_regs
*regs
= get_irq_regs();
243 printk(KERN_INFO
"CPU%d:\n", smp_processor_id());
246 schedule_work(&sysrq_showallcpus
);
250 static struct sysrq_key_op sysrq_showallcpus_op
= {
251 .handler
= sysrq_handle_showallcpus
,
252 .help_msg
= "show-backtrace-all-active-cpus(l)",
253 .action_msg
= "Show backtrace of all active CPUs",
254 .enable_mask
= SYSRQ_ENABLE_DUMP
,
258 static void sysrq_handle_showregs(int key
)
260 struct pt_regs
*regs
= get_irq_regs();
263 perf_event_print_debug();
265 static struct sysrq_key_op sysrq_showregs_op
= {
266 .handler
= sysrq_handle_showregs
,
267 .help_msg
= "show-registers(p)",
268 .action_msg
= "Show Regs",
269 .enable_mask
= SYSRQ_ENABLE_DUMP
,
272 static void sysrq_handle_showstate(int key
)
276 static struct sysrq_key_op sysrq_showstate_op
= {
277 .handler
= sysrq_handle_showstate
,
278 .help_msg
= "show-task-states(t)",
279 .action_msg
= "Show State",
280 .enable_mask
= SYSRQ_ENABLE_DUMP
,
283 static void sysrq_handle_showstate_blocked(int key
)
285 show_state_filter(TASK_UNINTERRUPTIBLE
);
287 static struct sysrq_key_op sysrq_showstate_blocked_op
= {
288 .handler
= sysrq_handle_showstate_blocked
,
289 .help_msg
= "show-blocked-tasks(w)",
290 .action_msg
= "Show Blocked State",
291 .enable_mask
= SYSRQ_ENABLE_DUMP
,
294 #ifdef CONFIG_TRACING
295 #include <linux/ftrace.h>
297 static void sysrq_ftrace_dump(int key
)
299 ftrace_dump(DUMP_ALL
);
301 static struct sysrq_key_op sysrq_ftrace_dump_op
= {
302 .handler
= sysrq_ftrace_dump
,
303 .help_msg
= "dump-ftrace-buffer(z)",
304 .action_msg
= "Dump ftrace buffer",
305 .enable_mask
= SYSRQ_ENABLE_DUMP
,
308 #define sysrq_ftrace_dump_op (*(struct sysrq_key_op *)NULL)
311 static void sysrq_handle_showmem(int key
)
315 static struct sysrq_key_op sysrq_showmem_op
= {
316 .handler
= sysrq_handle_showmem
,
317 .help_msg
= "show-memory-usage(m)",
318 .action_msg
= "Show Memory",
319 .enable_mask
= SYSRQ_ENABLE_DUMP
,
323 * Signal sysrq helper function. Sends a signal to all user processes.
325 static void send_sig_all(int sig
)
327 struct task_struct
*p
;
329 read_lock(&tasklist_lock
);
330 for_each_process(p
) {
331 if (p
->flags
& PF_KTHREAD
)
333 if (is_global_init(p
))
336 do_send_sig_info(sig
, SEND_SIG_FORCED
, p
, true);
338 read_unlock(&tasklist_lock
);
341 static void sysrq_handle_term(int key
)
343 send_sig_all(SIGTERM
);
344 console_loglevel
= 8;
346 static struct sysrq_key_op sysrq_term_op
= {
347 .handler
= sysrq_handle_term
,
348 .help_msg
= "terminate-all-tasks(e)",
349 .action_msg
= "Terminate All Tasks",
350 .enable_mask
= SYSRQ_ENABLE_SIGNAL
,
353 static void moom_callback(struct work_struct
*ignored
)
355 out_of_memory(node_zonelist(first_online_node
, GFP_KERNEL
), GFP_KERNEL
,
359 static DECLARE_WORK(moom_work
, moom_callback
);
361 static void sysrq_handle_moom(int key
)
363 schedule_work(&moom_work
);
365 static struct sysrq_key_op sysrq_moom_op
= {
366 .handler
= sysrq_handle_moom
,
367 .help_msg
= "memory-full-oom-kill(f)",
368 .action_msg
= "Manual OOM execution",
369 .enable_mask
= SYSRQ_ENABLE_SIGNAL
,
373 static void sysrq_handle_thaw(int key
)
375 emergency_thaw_all();
377 static struct sysrq_key_op sysrq_thaw_op
= {
378 .handler
= sysrq_handle_thaw
,
379 .help_msg
= "thaw-filesystems(j)",
380 .action_msg
= "Emergency Thaw of all frozen filesystems",
381 .enable_mask
= SYSRQ_ENABLE_SIGNAL
,
385 static void sysrq_handle_kill(int key
)
387 send_sig_all(SIGKILL
);
388 console_loglevel
= 8;
390 static struct sysrq_key_op sysrq_kill_op
= {
391 .handler
= sysrq_handle_kill
,
392 .help_msg
= "kill-all-tasks(i)",
393 .action_msg
= "Kill All Tasks",
394 .enable_mask
= SYSRQ_ENABLE_SIGNAL
,
397 static void sysrq_handle_unrt(int key
)
399 normalize_rt_tasks();
401 static struct sysrq_key_op sysrq_unrt_op
= {
402 .handler
= sysrq_handle_unrt
,
403 .help_msg
= "nice-all-RT-tasks(n)",
404 .action_msg
= "Nice All RT Tasks",
405 .enable_mask
= SYSRQ_ENABLE_RTNICE
,
408 /* Key Operations table and lock */
409 static DEFINE_SPINLOCK(sysrq_key_table_lock
);
411 static struct sysrq_key_op
*sysrq_key_table
[36] = {
412 &sysrq_loglevel_op
, /* 0 */
413 &sysrq_loglevel_op
, /* 1 */
414 &sysrq_loglevel_op
, /* 2 */
415 &sysrq_loglevel_op
, /* 3 */
416 &sysrq_loglevel_op
, /* 4 */
417 &sysrq_loglevel_op
, /* 5 */
418 &sysrq_loglevel_op
, /* 6 */
419 &sysrq_loglevel_op
, /* 7 */
420 &sysrq_loglevel_op
, /* 8 */
421 &sysrq_loglevel_op
, /* 9 */
424 * a: Don't use for system provided sysrqs, it is handled specially on
425 * sparc and will never arrive.
428 &sysrq_reboot_op
, /* b */
429 &sysrq_crash_op
, /* c & ibm_emac driver debug */
430 &sysrq_showlocks_op
, /* d */
431 &sysrq_term_op
, /* e */
432 &sysrq_moom_op
, /* f */
433 /* g: May be registered for the kernel debugger */
435 NULL
, /* h - reserved for help */
436 &sysrq_kill_op
, /* i */
438 &sysrq_thaw_op
, /* j */
442 &sysrq_SAK_op
, /* k */
444 &sysrq_showallcpus_op
, /* l */
448 &sysrq_showmem_op
, /* m */
449 &sysrq_unrt_op
, /* n */
450 /* o: This will often be registered as 'Off' at init time */
452 &sysrq_showregs_op
, /* p */
453 &sysrq_show_timers_op
, /* q */
454 &sysrq_unraw_op
, /* r */
455 &sysrq_sync_op
, /* s */
456 &sysrq_showstate_op
, /* t */
457 &sysrq_mountro_op
, /* u */
458 /* v: May be registered for frame buffer console restore */
460 &sysrq_showstate_blocked_op
, /* w */
461 /* x: May be registered on ppc/powerpc for xmon */
462 /* x: May be registered on sparc64 for global PMU dump */
464 /* y: May be registered on sparc64 for global register dump */
466 &sysrq_ftrace_dump_op
, /* z */
469 /* key2index calculation, -1 on invalid index */
470 static int sysrq_key_table_key2index(int key
)
474 if ((key
>= '0') && (key
<= '9'))
476 else if ((key
>= 'a') && (key
<= 'z'))
477 retval
= key
+ 10 - 'a';
484 * get and put functions for the table, exposed to modules.
486 struct sysrq_key_op
*__sysrq_get_key_op(int key
)
488 struct sysrq_key_op
*op_p
= NULL
;
491 i
= sysrq_key_table_key2index(key
);
493 op_p
= sysrq_key_table
[i
];
498 static void __sysrq_put_key_op(int key
, struct sysrq_key_op
*op_p
)
500 int i
= sysrq_key_table_key2index(key
);
503 sysrq_key_table
[i
] = op_p
;
506 void __handle_sysrq(int key
, bool check_mask
)
508 struct sysrq_key_op
*op_p
;
513 spin_lock_irqsave(&sysrq_key_table_lock
, flags
);
515 * Raise the apparent loglevel to maximum so that the sysrq header
516 * is shown to provide the user with positive feedback. We do not
517 * simply emit this at KERN_EMERG as that would change message
518 * routing in the consumers of /proc/kmsg.
520 orig_log_level
= console_loglevel
;
521 console_loglevel
= 7;
522 printk(KERN_INFO
"SysRq : ");
524 op_p
= __sysrq_get_key_op(key
);
527 * Should we check for enabled operations (/proc/sysrq-trigger
528 * should not) and is the invoked operation enabled?
530 if (!check_mask
|| sysrq_on_mask(op_p
->enable_mask
)) {
531 printk("%s\n", op_p
->action_msg
);
532 console_loglevel
= orig_log_level
;
535 printk("This sysrq operation is disabled.\n");
539 /* Only print the help msg once per handler */
540 for (i
= 0; i
< ARRAY_SIZE(sysrq_key_table
); i
++) {
541 if (sysrq_key_table
[i
]) {
544 for (j
= 0; sysrq_key_table
[i
] !=
545 sysrq_key_table
[j
]; j
++)
549 printk("%s ", sysrq_key_table
[i
]->help_msg
);
553 console_loglevel
= orig_log_level
;
555 spin_unlock_irqrestore(&sysrq_key_table_lock
, flags
);
558 void handle_sysrq(int key
)
561 __handle_sysrq(key
, true);
563 EXPORT_SYMBOL(handle_sysrq
);
567 /* Simple translation table for the SysRq keys */
568 static const unsigned char sysrq_xlate
[KEY_CNT
] =
569 "\000\0331234567890-=\177\t" /* 0x00 - 0x0f */
570 "qwertyuiop[]\r\000as" /* 0x10 - 0x1f */
571 "dfghjkl;'`\000\\zxcv" /* 0x20 - 0x2f */
572 "bnm,./\000*\000 \000\201\202\203\204\205" /* 0x30 - 0x3f */
573 "\206\207\210\211\212\000\000789-456+1" /* 0x40 - 0x4f */
574 "230\177\000\000\213\214\000\000\000\000\000\000\000\000\000\000" /* 0x50 - 0x5f */
575 "\r\000/"; /* 0x60 - 0x6f */
578 struct input_handle handle
;
579 struct work_struct reinject_work
;
580 unsigned long key_down
[BITS_TO_LONGS(KEY_CNT
)];
582 unsigned int alt_use
;
587 /* reset sequence handling */
589 unsigned long reset_keybit
[BITS_TO_LONGS(KEY_CNT
)];
592 int reset_seq_version
;
593 struct timer_list keyreset_timer
;
596 #define SYSRQ_KEY_RESET_MAX 20 /* Should be plenty */
597 static unsigned short sysrq_reset_seq
[SYSRQ_KEY_RESET_MAX
];
598 static unsigned int sysrq_reset_seq_len
;
599 static unsigned int sysrq_reset_seq_version
= 1;
601 static void sysrq_parse_reset_sequence(struct sysrq_state
*state
)
606 state
->reset_seq_cnt
= 0;
608 for (i
= 0; i
< sysrq_reset_seq_len
; i
++) {
609 key
= sysrq_reset_seq
[i
];
611 if (key
== KEY_RESERVED
|| key
> KEY_MAX
)
614 __set_bit(key
, state
->reset_keybit
);
615 state
->reset_seq_len
++;
617 if (test_bit(key
, state
->key_down
))
618 state
->reset_seq_cnt
++;
621 /* Disable reset until old keys are not released */
622 state
->reset_canceled
= state
->reset_seq_cnt
!= 0;
624 state
->reset_seq_version
= sysrq_reset_seq_version
;
627 static void sysrq_do_reset(unsigned long dummy
)
629 __handle_sysrq(sysrq_xlate
[KEY_B
], false);
632 static void sysrq_handle_reset_request(struct sysrq_state
*state
)
634 if (sysrq_reset_downtime_ms
)
635 mod_timer(&state
->keyreset_timer
,
636 jiffies
+ msecs_to_jiffies(sysrq_reset_downtime_ms
));
641 static void sysrq_detect_reset_sequence(struct sysrq_state
*state
,
642 unsigned int code
, int value
)
644 if (!test_bit(code
, state
->reset_keybit
)) {
646 * Pressing any key _not_ in reset sequence cancels
647 * the reset sequence. Also cancelling the timer in
648 * case additional keys were pressed after a reset
649 * has been requested.
651 if (value
&& state
->reset_seq_cnt
) {
652 state
->reset_canceled
= true;
653 del_timer(&state
->keyreset_timer
);
655 } else if (value
== 0) {
657 * Key release - all keys in the reset sequence need
658 * to be pressed and held for the reset timeout
661 del_timer(&state
->keyreset_timer
);
663 if (--state
->reset_seq_cnt
== 0)
664 state
->reset_canceled
= false;
665 } else if (value
== 1) {
666 /* key press, not autorepeat */
667 if (++state
->reset_seq_cnt
== state
->reset_seq_len
&&
668 !state
->reset_canceled
) {
669 sysrq_handle_reset_request(state
);
674 static void sysrq_reinject_alt_sysrq(struct work_struct
*work
)
676 struct sysrq_state
*sysrq
=
677 container_of(work
, struct sysrq_state
, reinject_work
);
678 struct input_handle
*handle
= &sysrq
->handle
;
679 unsigned int alt_code
= sysrq
->alt_use
;
681 if (sysrq
->need_reinject
) {
682 /* we do not want the assignment to be reordered */
683 sysrq
->reinjecting
= true;
686 /* Simulate press and release of Alt + SysRq */
687 input_inject_event(handle
, EV_KEY
, alt_code
, 1);
688 input_inject_event(handle
, EV_KEY
, KEY_SYSRQ
, 1);
689 input_inject_event(handle
, EV_SYN
, SYN_REPORT
, 1);
691 input_inject_event(handle
, EV_KEY
, KEY_SYSRQ
, 0);
692 input_inject_event(handle
, EV_KEY
, alt_code
, 0);
693 input_inject_event(handle
, EV_SYN
, SYN_REPORT
, 1);
696 sysrq
->reinjecting
= false;
700 static bool sysrq_handle_keypress(struct sysrq_state
*sysrq
,
701 unsigned int code
, int value
)
703 bool was_active
= sysrq
->active
;
711 /* One of ALTs is being released */
712 if (sysrq
->active
&& code
== sysrq
->alt_use
)
713 sysrq
->active
= false;
715 sysrq
->alt
= KEY_RESERVED
;
717 } else if (value
!= 2) {
719 sysrq
->need_reinject
= false;
724 if (value
== 1 && sysrq
->alt
!= KEY_RESERVED
) {
725 sysrq
->active
= true;
726 sysrq
->alt_use
= sysrq
->alt
;
728 * If nothing else will be pressed we'll need
729 * to re-inject Alt-SysRq keysroke.
731 sysrq
->need_reinject
= true;
735 * Pretend that sysrq was never pressed at all. This
736 * is needed to properly handle KGDB which will try
737 * to release all keys after exiting debugger. If we
738 * do not clear key bit it KGDB will end up sending
739 * release events for Alt and SysRq, potentially
740 * triggering print screen function.
743 clear_bit(KEY_SYSRQ
, sysrq
->handle
.dev
->key
);
748 if (sysrq
->active
&& value
&& value
!= 2) {
749 sysrq
->need_reinject
= false;
750 __handle_sysrq(sysrq_xlate
[code
], true);
755 suppress
= sysrq
->active
;
757 if (!sysrq
->active
) {
760 * See if reset sequence has changed since the last time.
762 if (sysrq
->reset_seq_version
!= sysrq_reset_seq_version
)
763 sysrq_parse_reset_sequence(sysrq
);
766 * If we are not suppressing key presses keep track of
767 * keyboard state so we can release keys that have been
768 * pressed before entering SysRq mode.
771 set_bit(code
, sysrq
->key_down
);
773 clear_bit(code
, sysrq
->key_down
);
776 schedule_work(&sysrq
->reinject_work
);
778 /* Check for reset sequence */
779 sysrq_detect_reset_sequence(sysrq
, code
, value
);
781 } else if (value
== 0 && test_and_clear_bit(code
, sysrq
->key_down
)) {
783 * Pass on release events for keys that was pressed before
784 * entering SysRq mode.
792 static bool sysrq_filter(struct input_handle
*handle
,
793 unsigned int type
, unsigned int code
, int value
)
795 struct sysrq_state
*sysrq
= handle
->private;
799 * Do not filter anything if we are in the process of re-injecting
800 * Alt+SysRq combination.
802 if (sysrq
->reinjecting
)
812 suppress
= sysrq_handle_keypress(sysrq
, code
, value
);
816 suppress
= sysrq
->active
;
823 static int sysrq_connect(struct input_handler
*handler
,
824 struct input_dev
*dev
,
825 const struct input_device_id
*id
)
827 struct sysrq_state
*sysrq
;
830 sysrq
= kzalloc(sizeof(struct sysrq_state
), GFP_KERNEL
);
834 INIT_WORK(&sysrq
->reinject_work
, sysrq_reinject_alt_sysrq
);
836 sysrq
->handle
.dev
= dev
;
837 sysrq
->handle
.handler
= handler
;
838 sysrq
->handle
.name
= "sysrq";
839 sysrq
->handle
.private = sysrq
;
840 setup_timer(&sysrq
->keyreset_timer
, sysrq_do_reset
, 0);
842 error
= input_register_handle(&sysrq
->handle
);
844 pr_err("Failed to register input sysrq handler, error %d\n",
849 error
= input_open_device(&sysrq
->handle
);
851 pr_err("Failed to open input device, error %d\n", error
);
858 input_unregister_handle(&sysrq
->handle
);
864 static void sysrq_disconnect(struct input_handle
*handle
)
866 struct sysrq_state
*sysrq
= handle
->private;
868 input_close_device(handle
);
869 cancel_work_sync(&sysrq
->reinject_work
);
870 del_timer_sync(&sysrq
->keyreset_timer
);
871 input_unregister_handle(handle
);
876 * We are matching on KEY_LEFTALT instead of KEY_SYSRQ because not all
877 * keyboards have SysRq key predefined and so user may add it to keymap
878 * later, but we expect all such keyboards to have left alt.
880 static const struct input_device_id sysrq_ids
[] = {
882 .flags
= INPUT_DEVICE_ID_MATCH_EVBIT
|
883 INPUT_DEVICE_ID_MATCH_KEYBIT
,
884 .evbit
= { [BIT_WORD(EV_KEY
)] = BIT_MASK(EV_KEY
) },
885 .keybit
= { [BIT_WORD(KEY_LEFTALT
)] = BIT_MASK(KEY_LEFTALT
) },
890 static struct input_handler sysrq_handler
= {
891 .filter
= sysrq_filter
,
892 .connect
= sysrq_connect
,
893 .disconnect
= sysrq_disconnect
,
895 .id_table
= sysrq_ids
,
898 static bool sysrq_handler_registered
;
900 static inline void sysrq_register_handler(void)
906 for (i
= 0; i
< ARRAY_SIZE(sysrq_reset_seq
); i
++) {
907 key
= platform_sysrq_reset_seq
[i
];
908 if (key
== KEY_RESERVED
|| key
> KEY_MAX
)
911 sysrq_reset_seq
[sysrq_reset_seq_len
++] = key
;
914 error
= input_register_handler(&sysrq_handler
);
916 pr_err("Failed to register input handler, error %d", error
);
918 sysrq_handler_registered
= true;
921 static inline void sysrq_unregister_handler(void)
923 if (sysrq_handler_registered
) {
924 input_unregister_handler(&sysrq_handler
);
925 sysrq_handler_registered
= false;
929 static int sysrq_reset_seq_param_set(const char *buffer
,
930 const struct kernel_param
*kp
)
935 error
= strict_strtoul(buffer
, 0, &val
);
942 *((unsigned short *)kp
->arg
) = val
;
943 sysrq_reset_seq_version
++;
948 static struct kernel_param_ops param_ops_sysrq_reset_seq
= {
949 .get
= param_get_ushort
,
950 .set
= sysrq_reset_seq_param_set
,
953 #define param_check_sysrq_reset_seq(name, p) \
954 __param_check(name, p, unsigned short)
956 module_param_array_named(reset_seq
, sysrq_reset_seq
, sysrq_reset_seq
,
957 &sysrq_reset_seq_len
, 0644);
959 module_param_named(sysrq_downtime_ms
, sysrq_reset_downtime_ms
, int, 0644);
963 static inline void sysrq_register_handler(void)
967 static inline void sysrq_unregister_handler(void)
971 #endif /* CONFIG_INPUT */
973 int sysrq_toggle_support(int enable_mask
)
975 bool was_enabled
= sysrq_on();
977 sysrq_enabled
= enable_mask
;
979 if (was_enabled
!= sysrq_on()) {
981 sysrq_register_handler();
983 sysrq_unregister_handler();
989 static int __sysrq_swap_key_ops(int key
, struct sysrq_key_op
*insert_op_p
,
990 struct sysrq_key_op
*remove_op_p
)
995 spin_lock_irqsave(&sysrq_key_table_lock
, flags
);
996 if (__sysrq_get_key_op(key
) == remove_op_p
) {
997 __sysrq_put_key_op(key
, insert_op_p
);
1002 spin_unlock_irqrestore(&sysrq_key_table_lock
, flags
);
1006 int register_sysrq_key(int key
, struct sysrq_key_op
*op_p
)
1008 return __sysrq_swap_key_ops(key
, op_p
, NULL
);
1010 EXPORT_SYMBOL(register_sysrq_key
);
1012 int unregister_sysrq_key(int key
, struct sysrq_key_op
*op_p
)
1014 return __sysrq_swap_key_ops(key
, NULL
, op_p
);
1016 EXPORT_SYMBOL(unregister_sysrq_key
);
1018 #ifdef CONFIG_PROC_FS
1020 * writing 'C' to /proc/sysrq-trigger is like sysrq-C
1022 static ssize_t
write_sysrq_trigger(struct file
*file
, const char __user
*buf
,
1023 size_t count
, loff_t
*ppos
)
1028 if (get_user(c
, buf
))
1030 __handle_sysrq(c
, false);
1036 static const struct file_operations proc_sysrq_trigger_operations
= {
1037 .write
= write_sysrq_trigger
,
1038 .llseek
= noop_llseek
,
1041 static void sysrq_init_procfs(void)
1043 if (!proc_create("sysrq-trigger", S_IWUSR
, NULL
,
1044 &proc_sysrq_trigger_operations
))
1045 pr_err("Failed to register proc interface\n");
1050 static inline void sysrq_init_procfs(void)
1054 #endif /* CONFIG_PROC_FS */
1056 static int __init
sysrq_init(void)
1058 sysrq_init_procfs();
1061 sysrq_register_handler();
1065 module_init(sysrq_init
);