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