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