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>
47 #include <linux/syscalls.h>
49 #include <asm/ptrace.h>
50 #include <asm/irq_regs.h>
52 /* Whether we react on sysrq keys or just ignore them */
53 static int __read_mostly sysrq_enabled
= SYSRQ_DEFAULT_ENABLE
;
54 static bool __read_mostly sysrq_always_enabled
;
56 unsigned short platform_sysrq_reset_seq
[] __weak
= { KEY_RESERVED
};
57 int sysrq_reset_downtime_ms __weak
;
59 static bool sysrq_on(void)
61 return sysrq_enabled
|| sysrq_always_enabled
;
65 * A value of 1 means 'all', other nonzero values are an op mask:
67 static bool sysrq_on_mask(int mask
)
69 return sysrq_always_enabled
||
71 (sysrq_enabled
& mask
);
74 static int __init
sysrq_always_enabled_setup(char *str
)
76 sysrq_always_enabled
= true;
77 pr_info("sysrq always enabled.\n");
82 __setup("sysrq_always_enabled", sysrq_always_enabled_setup
);
85 static void sysrq_handle_loglevel(int key
)
91 printk("Loglevel set to %d\n", i
);
94 static struct sysrq_key_op sysrq_loglevel_op
= {
95 .handler
= sysrq_handle_loglevel
,
96 .help_msg
= "loglevel(0-9)",
97 .action_msg
= "Changing Loglevel",
98 .enable_mask
= SYSRQ_ENABLE_LOG
,
102 static void sysrq_handle_SAK(int key
)
104 struct work_struct
*SAK_work
= &vc_cons
[fg_console
].SAK_work
;
105 schedule_work(SAK_work
);
107 static struct sysrq_key_op sysrq_SAK_op
= {
108 .handler
= sysrq_handle_SAK
,
109 .help_msg
= "sak(k)",
111 .enable_mask
= SYSRQ_ENABLE_KEYBOARD
,
114 #define sysrq_SAK_op (*(struct sysrq_key_op *)NULL)
118 static void sysrq_handle_unraw(int key
)
120 vt_reset_unicode(fg_console
);
123 static struct sysrq_key_op sysrq_unraw_op
= {
124 .handler
= sysrq_handle_unraw
,
125 .help_msg
= "unraw(r)",
126 .action_msg
= "Keyboard mode set to system default",
127 .enable_mask
= SYSRQ_ENABLE_KEYBOARD
,
130 #define sysrq_unraw_op (*(struct sysrq_key_op *)NULL)
131 #endif /* CONFIG_VT */
133 static void sysrq_handle_crash(int key
)
137 panic_on_oops
= 1; /* force panic */
141 static struct sysrq_key_op sysrq_crash_op
= {
142 .handler
= sysrq_handle_crash
,
143 .help_msg
= "crash(c)",
144 .action_msg
= "Trigger a crash",
145 .enable_mask
= SYSRQ_ENABLE_DUMP
,
148 static void sysrq_handle_reboot(int key
)
154 static struct sysrq_key_op sysrq_reboot_op
= {
155 .handler
= sysrq_handle_reboot
,
156 .help_msg
= "reboot(b)",
157 .action_msg
= "Resetting",
158 .enable_mask
= SYSRQ_ENABLE_BOOT
,
161 static void sysrq_handle_sync(int key
)
165 static struct sysrq_key_op sysrq_sync_op
= {
166 .handler
= sysrq_handle_sync
,
167 .help_msg
= "sync(s)",
168 .action_msg
= "Emergency Sync",
169 .enable_mask
= SYSRQ_ENABLE_SYNC
,
172 static void sysrq_handle_show_timers(int key
)
174 sysrq_timer_list_show();
177 static struct sysrq_key_op sysrq_show_timers_op
= {
178 .handler
= sysrq_handle_show_timers
,
179 .help_msg
= "show-all-timers(q)",
180 .action_msg
= "Show clockevent devices & pending hrtimers (no others)",
183 static void sysrq_handle_mountro(int key
)
187 static struct sysrq_key_op sysrq_mountro_op
= {
188 .handler
= sysrq_handle_mountro
,
189 .help_msg
= "unmount(u)",
190 .action_msg
= "Emergency Remount R/O",
191 .enable_mask
= SYSRQ_ENABLE_REMOUNT
,
194 #ifdef CONFIG_LOCKDEP
195 static void sysrq_handle_showlocks(int key
)
197 debug_show_all_locks();
200 static struct sysrq_key_op sysrq_showlocks_op
= {
201 .handler
= sysrq_handle_showlocks
,
202 .help_msg
= "show-all-locks(d)",
203 .action_msg
= "Show Locks Held",
206 #define sysrq_showlocks_op (*(struct sysrq_key_op *)NULL)
210 static DEFINE_SPINLOCK(show_lock
);
212 static void showacpu(void *dummy
)
216 /* Idle CPUs have no interesting backtrace. */
217 if (idle_cpu(smp_processor_id()))
220 spin_lock_irqsave(&show_lock
, flags
);
221 printk(KERN_INFO
"CPU%d:\n", smp_processor_id());
222 show_stack(NULL
, NULL
);
223 spin_unlock_irqrestore(&show_lock
, flags
);
226 static void sysrq_showregs_othercpus(struct work_struct
*dummy
)
228 smp_call_function(showacpu
, NULL
, 0);
231 static DECLARE_WORK(sysrq_showallcpus
, sysrq_showregs_othercpus
);
233 static void sysrq_handle_showallcpus(int key
)
236 * Fall back to the workqueue based printing if the
237 * backtrace printing did not succeed or the
238 * architecture has no support for it:
240 if (!trigger_all_cpu_backtrace()) {
241 struct pt_regs
*regs
= get_irq_regs();
244 printk(KERN_INFO
"CPU%d:\n", smp_processor_id());
247 schedule_work(&sysrq_showallcpus
);
251 static struct sysrq_key_op sysrq_showallcpus_op
= {
252 .handler
= sysrq_handle_showallcpus
,
253 .help_msg
= "show-backtrace-all-active-cpus(l)",
254 .action_msg
= "Show backtrace of all active CPUs",
255 .enable_mask
= SYSRQ_ENABLE_DUMP
,
259 static void sysrq_handle_showregs(int key
)
261 struct pt_regs
*regs
= get_irq_regs();
264 perf_event_print_debug();
266 static struct sysrq_key_op sysrq_showregs_op
= {
267 .handler
= sysrq_handle_showregs
,
268 .help_msg
= "show-registers(p)",
269 .action_msg
= "Show Regs",
270 .enable_mask
= SYSRQ_ENABLE_DUMP
,
273 static void sysrq_handle_showstate(int key
)
277 static struct sysrq_key_op sysrq_showstate_op
= {
278 .handler
= sysrq_handle_showstate
,
279 .help_msg
= "show-task-states(t)",
280 .action_msg
= "Show State",
281 .enable_mask
= SYSRQ_ENABLE_DUMP
,
284 static void sysrq_handle_showstate_blocked(int key
)
286 show_state_filter(TASK_UNINTERRUPTIBLE
);
288 static struct sysrq_key_op sysrq_showstate_blocked_op
= {
289 .handler
= sysrq_handle_showstate_blocked
,
290 .help_msg
= "show-blocked-tasks(w)",
291 .action_msg
= "Show Blocked State",
292 .enable_mask
= SYSRQ_ENABLE_DUMP
,
295 #ifdef CONFIG_TRACING
296 #include <linux/ftrace.h>
298 static void sysrq_ftrace_dump(int key
)
300 ftrace_dump(DUMP_ALL
);
302 static struct sysrq_key_op sysrq_ftrace_dump_op
= {
303 .handler
= sysrq_ftrace_dump
,
304 .help_msg
= "dump-ftrace-buffer(z)",
305 .action_msg
= "Dump ftrace buffer",
306 .enable_mask
= SYSRQ_ENABLE_DUMP
,
309 #define sysrq_ftrace_dump_op (*(struct sysrq_key_op *)NULL)
312 static void sysrq_handle_showmem(int key
)
316 static struct sysrq_key_op sysrq_showmem_op
= {
317 .handler
= sysrq_handle_showmem
,
318 .help_msg
= "show-memory-usage(m)",
319 .action_msg
= "Show Memory",
320 .enable_mask
= SYSRQ_ENABLE_DUMP
,
324 * Signal sysrq helper function. Sends a signal to all user processes.
326 static void send_sig_all(int sig
)
328 struct task_struct
*p
;
330 read_lock(&tasklist_lock
);
331 for_each_process(p
) {
332 if (p
->flags
& PF_KTHREAD
)
334 if (is_global_init(p
))
337 do_send_sig_info(sig
, SEND_SIG_FORCED
, p
, true);
339 read_unlock(&tasklist_lock
);
342 static void sysrq_handle_term(int key
)
344 send_sig_all(SIGTERM
);
345 console_loglevel
= 8;
347 static struct sysrq_key_op sysrq_term_op
= {
348 .handler
= sysrq_handle_term
,
349 .help_msg
= "terminate-all-tasks(e)",
350 .action_msg
= "Terminate All Tasks",
351 .enable_mask
= SYSRQ_ENABLE_SIGNAL
,
354 static void moom_callback(struct work_struct
*ignored
)
356 out_of_memory(node_zonelist(first_online_node
, GFP_KERNEL
), GFP_KERNEL
,
360 static DECLARE_WORK(moom_work
, moom_callback
);
362 static void sysrq_handle_moom(int key
)
364 schedule_work(&moom_work
);
366 static struct sysrq_key_op sysrq_moom_op
= {
367 .handler
= sysrq_handle_moom
,
368 .help_msg
= "memory-full-oom-kill(f)",
369 .action_msg
= "Manual OOM execution",
370 .enable_mask
= SYSRQ_ENABLE_SIGNAL
,
374 static void sysrq_handle_thaw(int key
)
376 emergency_thaw_all();
378 static struct sysrq_key_op sysrq_thaw_op
= {
379 .handler
= sysrq_handle_thaw
,
380 .help_msg
= "thaw-filesystems(j)",
381 .action_msg
= "Emergency Thaw of all frozen filesystems",
382 .enable_mask
= SYSRQ_ENABLE_SIGNAL
,
386 static void sysrq_handle_kill(int key
)
388 send_sig_all(SIGKILL
);
389 console_loglevel
= 8;
391 static struct sysrq_key_op sysrq_kill_op
= {
392 .handler
= sysrq_handle_kill
,
393 .help_msg
= "kill-all-tasks(i)",
394 .action_msg
= "Kill All Tasks",
395 .enable_mask
= SYSRQ_ENABLE_SIGNAL
,
398 static void sysrq_handle_unrt(int key
)
400 normalize_rt_tasks();
402 static struct sysrq_key_op sysrq_unrt_op
= {
403 .handler
= sysrq_handle_unrt
,
404 .help_msg
= "nice-all-RT-tasks(n)",
405 .action_msg
= "Nice All RT Tasks",
406 .enable_mask
= SYSRQ_ENABLE_RTNICE
,
409 /* Key Operations table and lock */
410 static DEFINE_SPINLOCK(sysrq_key_table_lock
);
412 static struct sysrq_key_op
*sysrq_key_table
[36] = {
413 &sysrq_loglevel_op
, /* 0 */
414 &sysrq_loglevel_op
, /* 1 */
415 &sysrq_loglevel_op
, /* 2 */
416 &sysrq_loglevel_op
, /* 3 */
417 &sysrq_loglevel_op
, /* 4 */
418 &sysrq_loglevel_op
, /* 5 */
419 &sysrq_loglevel_op
, /* 6 */
420 &sysrq_loglevel_op
, /* 7 */
421 &sysrq_loglevel_op
, /* 8 */
422 &sysrq_loglevel_op
, /* 9 */
425 * a: Don't use for system provided sysrqs, it is handled specially on
426 * sparc and will never arrive.
429 &sysrq_reboot_op
, /* b */
430 &sysrq_crash_op
, /* c & ibm_emac driver debug */
431 &sysrq_showlocks_op
, /* d */
432 &sysrq_term_op
, /* e */
433 &sysrq_moom_op
, /* f */
434 /* g: May be registered for the kernel debugger */
436 NULL
, /* h - reserved for help */
437 &sysrq_kill_op
, /* i */
439 &sysrq_thaw_op
, /* j */
443 &sysrq_SAK_op
, /* k */
445 &sysrq_showallcpus_op
, /* l */
449 &sysrq_showmem_op
, /* m */
450 &sysrq_unrt_op
, /* n */
451 /* o: This will often be registered as 'Off' at init time */
453 &sysrq_showregs_op
, /* p */
454 &sysrq_show_timers_op
, /* q */
455 &sysrq_unraw_op
, /* r */
456 &sysrq_sync_op
, /* s */
457 &sysrq_showstate_op
, /* t */
458 &sysrq_mountro_op
, /* u */
459 /* v: May be registered for frame buffer console restore */
461 &sysrq_showstate_blocked_op
, /* w */
462 /* x: May be registered on ppc/powerpc for xmon */
463 /* x: May be registered on sparc64 for global PMU dump */
465 /* y: May be registered on sparc64 for global register dump */
467 &sysrq_ftrace_dump_op
, /* z */
470 /* key2index calculation, -1 on invalid index */
471 static int sysrq_key_table_key2index(int key
)
475 if ((key
>= '0') && (key
<= '9'))
477 else if ((key
>= 'a') && (key
<= 'z'))
478 retval
= key
+ 10 - 'a';
485 * get and put functions for the table, exposed to modules.
487 struct sysrq_key_op
*__sysrq_get_key_op(int key
)
489 struct sysrq_key_op
*op_p
= NULL
;
492 i
= sysrq_key_table_key2index(key
);
494 op_p
= sysrq_key_table
[i
];
499 static void __sysrq_put_key_op(int key
, struct sysrq_key_op
*op_p
)
501 int i
= sysrq_key_table_key2index(key
);
504 sysrq_key_table
[i
] = op_p
;
507 void __handle_sysrq(int key
, bool check_mask
)
509 struct sysrq_key_op
*op_p
;
514 spin_lock_irqsave(&sysrq_key_table_lock
, flags
);
516 * Raise the apparent loglevel to maximum so that the sysrq header
517 * is shown to provide the user with positive feedback. We do not
518 * simply emit this at KERN_EMERG as that would change message
519 * routing in the consumers of /proc/kmsg.
521 orig_log_level
= console_loglevel
;
522 console_loglevel
= 7;
523 printk(KERN_INFO
"SysRq : ");
525 op_p
= __sysrq_get_key_op(key
);
528 * Should we check for enabled operations (/proc/sysrq-trigger
529 * should not) and is the invoked operation enabled?
531 if (!check_mask
|| sysrq_on_mask(op_p
->enable_mask
)) {
532 printk("%s\n", op_p
->action_msg
);
533 console_loglevel
= orig_log_level
;
536 printk("This sysrq operation is disabled.\n");
540 /* Only print the help msg once per handler */
541 for (i
= 0; i
< ARRAY_SIZE(sysrq_key_table
); i
++) {
542 if (sysrq_key_table
[i
]) {
545 for (j
= 0; sysrq_key_table
[i
] !=
546 sysrq_key_table
[j
]; j
++)
550 printk("%s ", sysrq_key_table
[i
]->help_msg
);
554 console_loglevel
= orig_log_level
;
556 spin_unlock_irqrestore(&sysrq_key_table_lock
, flags
);
559 void handle_sysrq(int key
)
562 __handle_sysrq(key
, true);
564 EXPORT_SYMBOL(handle_sysrq
);
568 /* Simple translation table for the SysRq keys */
569 static const unsigned char sysrq_xlate
[KEY_CNT
] =
570 "\000\0331234567890-=\177\t" /* 0x00 - 0x0f */
571 "qwertyuiop[]\r\000as" /* 0x10 - 0x1f */
572 "dfghjkl;'`\000\\zxcv" /* 0x20 - 0x2f */
573 "bnm,./\000*\000 \000\201\202\203\204\205" /* 0x30 - 0x3f */
574 "\206\207\210\211\212\000\000789-456+1" /* 0x40 - 0x4f */
575 "230\177\000\000\213\214\000\000\000\000\000\000\000\000\000\000" /* 0x50 - 0x5f */
576 "\r\000/"; /* 0x60 - 0x6f */
579 struct input_handle handle
;
580 struct work_struct reinject_work
;
581 unsigned long key_down
[BITS_TO_LONGS(KEY_CNT
)];
583 unsigned int alt_use
;
588 /* reset sequence handling */
590 bool reset_requested
;
591 unsigned long reset_keybit
[BITS_TO_LONGS(KEY_CNT
)];
594 int reset_seq_version
;
595 struct timer_list keyreset_timer
;
598 #define SYSRQ_KEY_RESET_MAX 20 /* Should be plenty */
599 static unsigned short sysrq_reset_seq
[SYSRQ_KEY_RESET_MAX
];
600 static unsigned int sysrq_reset_seq_len
;
601 static unsigned int sysrq_reset_seq_version
= 1;
603 static void sysrq_parse_reset_sequence(struct sysrq_state
*state
)
608 state
->reset_seq_cnt
= 0;
610 for (i
= 0; i
< sysrq_reset_seq_len
; i
++) {
611 key
= sysrq_reset_seq
[i
];
613 if (key
== KEY_RESERVED
|| key
> KEY_MAX
)
616 __set_bit(key
, state
->reset_keybit
);
617 state
->reset_seq_len
++;
619 if (test_bit(key
, state
->key_down
))
620 state
->reset_seq_cnt
++;
623 /* Disable reset until old keys are not released */
624 state
->reset_canceled
= state
->reset_seq_cnt
!= 0;
626 state
->reset_seq_version
= sysrq_reset_seq_version
;
629 static void sysrq_do_reset(unsigned long _state
)
631 struct sysrq_state
*state
= (struct sysrq_state
*) _state
;
633 state
->reset_requested
= true;
636 kernel_restart(NULL
);
639 static void sysrq_handle_reset_request(struct sysrq_state
*state
)
641 if (state
->reset_requested
)
642 __handle_sysrq(sysrq_xlate
[KEY_B
], false);
644 if (sysrq_reset_downtime_ms
)
645 mod_timer(&state
->keyreset_timer
,
646 jiffies
+ msecs_to_jiffies(sysrq_reset_downtime_ms
));
648 sysrq_do_reset((unsigned long)state
);
651 static void sysrq_detect_reset_sequence(struct sysrq_state
*state
,
652 unsigned int code
, int value
)
654 if (!test_bit(code
, state
->reset_keybit
)) {
656 * Pressing any key _not_ in reset sequence cancels
657 * the reset sequence. Also cancelling the timer in
658 * case additional keys were pressed after a reset
659 * has been requested.
661 if (value
&& state
->reset_seq_cnt
) {
662 state
->reset_canceled
= true;
663 del_timer(&state
->keyreset_timer
);
665 } else if (value
== 0) {
667 * Key release - all keys in the reset sequence need
668 * to be pressed and held for the reset timeout
671 del_timer(&state
->keyreset_timer
);
673 if (--state
->reset_seq_cnt
== 0)
674 state
->reset_canceled
= false;
675 } else if (value
== 1) {
676 /* key press, not autorepeat */
677 if (++state
->reset_seq_cnt
== state
->reset_seq_len
&&
678 !state
->reset_canceled
) {
679 sysrq_handle_reset_request(state
);
684 static void sysrq_reinject_alt_sysrq(struct work_struct
*work
)
686 struct sysrq_state
*sysrq
=
687 container_of(work
, struct sysrq_state
, reinject_work
);
688 struct input_handle
*handle
= &sysrq
->handle
;
689 unsigned int alt_code
= sysrq
->alt_use
;
691 if (sysrq
->need_reinject
) {
692 /* we do not want the assignment to be reordered */
693 sysrq
->reinjecting
= true;
696 /* Simulate press and release of Alt + SysRq */
697 input_inject_event(handle
, EV_KEY
, alt_code
, 1);
698 input_inject_event(handle
, EV_KEY
, KEY_SYSRQ
, 1);
699 input_inject_event(handle
, EV_SYN
, SYN_REPORT
, 1);
701 input_inject_event(handle
, EV_KEY
, KEY_SYSRQ
, 0);
702 input_inject_event(handle
, EV_KEY
, alt_code
, 0);
703 input_inject_event(handle
, EV_SYN
, SYN_REPORT
, 1);
706 sysrq
->reinjecting
= false;
710 static bool sysrq_handle_keypress(struct sysrq_state
*sysrq
,
711 unsigned int code
, int value
)
713 bool was_active
= sysrq
->active
;
721 /* One of ALTs is being released */
722 if (sysrq
->active
&& code
== sysrq
->alt_use
)
723 sysrq
->active
= false;
725 sysrq
->alt
= KEY_RESERVED
;
727 } else if (value
!= 2) {
729 sysrq
->need_reinject
= false;
734 if (value
== 1 && sysrq
->alt
!= KEY_RESERVED
) {
735 sysrq
->active
= true;
736 sysrq
->alt_use
= sysrq
->alt
;
738 * If nothing else will be pressed we'll need
739 * to re-inject Alt-SysRq keysroke.
741 sysrq
->need_reinject
= true;
745 * Pretend that sysrq was never pressed at all. This
746 * is needed to properly handle KGDB which will try
747 * to release all keys after exiting debugger. If we
748 * do not clear key bit it KGDB will end up sending
749 * release events for Alt and SysRq, potentially
750 * triggering print screen function.
753 clear_bit(KEY_SYSRQ
, sysrq
->handle
.dev
->key
);
758 if (sysrq
->active
&& value
&& value
!= 2) {
759 sysrq
->need_reinject
= false;
760 __handle_sysrq(sysrq_xlate
[code
], true);
765 suppress
= sysrq
->active
;
767 if (!sysrq
->active
) {
770 * See if reset sequence has changed since the last time.
772 if (sysrq
->reset_seq_version
!= sysrq_reset_seq_version
)
773 sysrq_parse_reset_sequence(sysrq
);
776 * If we are not suppressing key presses keep track of
777 * keyboard state so we can release keys that have been
778 * pressed before entering SysRq mode.
781 set_bit(code
, sysrq
->key_down
);
783 clear_bit(code
, sysrq
->key_down
);
786 schedule_work(&sysrq
->reinject_work
);
788 /* Check for reset sequence */
789 sysrq_detect_reset_sequence(sysrq
, code
, value
);
791 } else if (value
== 0 && test_and_clear_bit(code
, sysrq
->key_down
)) {
793 * Pass on release events for keys that was pressed before
794 * entering SysRq mode.
802 static bool sysrq_filter(struct input_handle
*handle
,
803 unsigned int type
, unsigned int code
, int value
)
805 struct sysrq_state
*sysrq
= handle
->private;
809 * Do not filter anything if we are in the process of re-injecting
810 * Alt+SysRq combination.
812 if (sysrq
->reinjecting
)
822 suppress
= sysrq_handle_keypress(sysrq
, code
, value
);
826 suppress
= sysrq
->active
;
833 static int sysrq_connect(struct input_handler
*handler
,
834 struct input_dev
*dev
,
835 const struct input_device_id
*id
)
837 struct sysrq_state
*sysrq
;
840 sysrq
= kzalloc(sizeof(struct sysrq_state
), GFP_KERNEL
);
844 INIT_WORK(&sysrq
->reinject_work
, sysrq_reinject_alt_sysrq
);
846 sysrq
->handle
.dev
= dev
;
847 sysrq
->handle
.handler
= handler
;
848 sysrq
->handle
.name
= "sysrq";
849 sysrq
->handle
.private = sysrq
;
850 setup_timer(&sysrq
->keyreset_timer
,
851 sysrq_do_reset
, (unsigned long)sysrq
);
853 error
= input_register_handle(&sysrq
->handle
);
855 pr_err("Failed to register input sysrq handler, error %d\n",
860 error
= input_open_device(&sysrq
->handle
);
862 pr_err("Failed to open input device, error %d\n", error
);
869 input_unregister_handle(&sysrq
->handle
);
875 static void sysrq_disconnect(struct input_handle
*handle
)
877 struct sysrq_state
*sysrq
= handle
->private;
879 input_close_device(handle
);
880 cancel_work_sync(&sysrq
->reinject_work
);
881 del_timer_sync(&sysrq
->keyreset_timer
);
882 input_unregister_handle(handle
);
887 * We are matching on KEY_LEFTALT instead of KEY_SYSRQ because not all
888 * keyboards have SysRq key predefined and so user may add it to keymap
889 * later, but we expect all such keyboards to have left alt.
891 static const struct input_device_id sysrq_ids
[] = {
893 .flags
= INPUT_DEVICE_ID_MATCH_EVBIT
|
894 INPUT_DEVICE_ID_MATCH_KEYBIT
,
895 .evbit
= { BIT_MASK(EV_KEY
) },
896 .keybit
= { BIT_MASK(KEY_LEFTALT
) },
901 static struct input_handler sysrq_handler
= {
902 .filter
= sysrq_filter
,
903 .connect
= sysrq_connect
,
904 .disconnect
= sysrq_disconnect
,
906 .id_table
= sysrq_ids
,
909 static bool sysrq_handler_registered
;
911 static inline void sysrq_register_handler(void)
917 for (i
= 0; i
< ARRAY_SIZE(sysrq_reset_seq
); i
++) {
918 key
= platform_sysrq_reset_seq
[i
];
919 if (key
== KEY_RESERVED
|| key
> KEY_MAX
)
922 sysrq_reset_seq
[sysrq_reset_seq_len
++] = key
;
925 error
= input_register_handler(&sysrq_handler
);
927 pr_err("Failed to register input handler, error %d", error
);
929 sysrq_handler_registered
= true;
932 static inline void sysrq_unregister_handler(void)
934 if (sysrq_handler_registered
) {
935 input_unregister_handler(&sysrq_handler
);
936 sysrq_handler_registered
= false;
940 static int sysrq_reset_seq_param_set(const char *buffer
,
941 const struct kernel_param
*kp
)
946 error
= kstrtoul(buffer
, 0, &val
);
953 *((unsigned short *)kp
->arg
) = val
;
954 sysrq_reset_seq_version
++;
959 static struct kernel_param_ops param_ops_sysrq_reset_seq
= {
960 .get
= param_get_ushort
,
961 .set
= sysrq_reset_seq_param_set
,
964 #define param_check_sysrq_reset_seq(name, p) \
965 __param_check(name, p, unsigned short)
967 module_param_array_named(reset_seq
, sysrq_reset_seq
, sysrq_reset_seq
,
968 &sysrq_reset_seq_len
, 0644);
970 module_param_named(sysrq_downtime_ms
, sysrq_reset_downtime_ms
, int, 0644);
974 static inline void sysrq_register_handler(void)
978 static inline void sysrq_unregister_handler(void)
982 #endif /* CONFIG_INPUT */
984 int sysrq_toggle_support(int enable_mask
)
986 bool was_enabled
= sysrq_on();
988 sysrq_enabled
= enable_mask
;
990 if (was_enabled
!= sysrq_on()) {
992 sysrq_register_handler();
994 sysrq_unregister_handler();
1000 static int __sysrq_swap_key_ops(int key
, struct sysrq_key_op
*insert_op_p
,
1001 struct sysrq_key_op
*remove_op_p
)
1004 unsigned long flags
;
1006 spin_lock_irqsave(&sysrq_key_table_lock
, flags
);
1007 if (__sysrq_get_key_op(key
) == remove_op_p
) {
1008 __sysrq_put_key_op(key
, insert_op_p
);
1013 spin_unlock_irqrestore(&sysrq_key_table_lock
, flags
);
1017 int register_sysrq_key(int key
, struct sysrq_key_op
*op_p
)
1019 return __sysrq_swap_key_ops(key
, op_p
, NULL
);
1021 EXPORT_SYMBOL(register_sysrq_key
);
1023 int unregister_sysrq_key(int key
, struct sysrq_key_op
*op_p
)
1025 return __sysrq_swap_key_ops(key
, NULL
, op_p
);
1027 EXPORT_SYMBOL(unregister_sysrq_key
);
1029 #ifdef CONFIG_PROC_FS
1031 * writing 'C' to /proc/sysrq-trigger is like sysrq-C
1033 static ssize_t
write_sysrq_trigger(struct file
*file
, const char __user
*buf
,
1034 size_t count
, loff_t
*ppos
)
1039 if (get_user(c
, buf
))
1041 __handle_sysrq(c
, false);
1047 static const struct file_operations proc_sysrq_trigger_operations
= {
1048 .write
= write_sysrq_trigger
,
1049 .llseek
= noop_llseek
,
1052 static void sysrq_init_procfs(void)
1054 if (!proc_create("sysrq-trigger", S_IWUSR
, NULL
,
1055 &proc_sysrq_trigger_operations
))
1056 pr_err("Failed to register proc interface\n");
1061 static inline void sysrq_init_procfs(void)
1065 #endif /* CONFIG_PROC_FS */
1067 static int __init
sysrq_init(void)
1069 sysrq_init_procfs();
1072 sysrq_register_handler();
1076 module_init(sysrq_init
);