drivers/char/sysrq.c

   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/interrupt.h>
  19 #include <linux/mm.h>
  20 #include <linux/fs.h>
  21 #include <linux/tty.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/buffer_head.h>          /* for fsync_bdev() */
  37 #include <linux/swap.h>
  38 #include <linux/spinlock.h>
  39 #include <linux/vt_kern.h>
  40 #include <linux/workqueue.h>
  41 #include <linux/hrtimer.h>
  42 #include <linux/oom.h>
  43 #include <linux/slab.h>
  44 #include <linux/input.h>
  45
  46 #include <asm/ptrace.h>
  47 #include <asm/irq_regs.h>
  48
  49 /* Whether we react on sysrq keys or just ignore them */
  50 static int __read_mostly sysrq_enabled = 1;
  51 static bool __read_mostly sysrq_always_enabled;
  52
  53 static bool sysrq_on(void)
  54 {
  55         return sysrq_enabled || sysrq_always_enabled;
  56 }
  57
  58 /*
  59  * A value of 1 means 'all', other nonzero values are an op mask:
  60  */
  61 static bool sysrq_on_mask(int mask)
  62 {
  63         return sysrq_always_enabled ||
  64                sysrq_enabled == 1 ||
  65                (sysrq_enabled & mask);
  66 }
  67
  68 static int __init sysrq_always_enabled_setup(char *str)
  69 {
  70         sysrq_always_enabled = true;
  71         pr_info("sysrq always enabled.\n");
  72
  73         return 1;
  74 }
  75
  76 __setup("sysrq_always_enabled", sysrq_always_enabled_setup);
  77
  78
  79 static void sysrq_handle_loglevel(int key, struct tty_struct *tty)
  80 {
  81         int i;
  82
  83         i = key - '0';
  84         console_loglevel = 7;
  85         printk("Loglevel set to %d\n", i);
  86         console_loglevel = i;
  87 }
  88 static struct sysrq_key_op sysrq_loglevel_op = {
  89         .handler        = sysrq_handle_loglevel,
  90         .help_msg       = "loglevel(0-9)",
  91         .action_msg     = "Changing Loglevel",
  92         .enable_mask    = SYSRQ_ENABLE_LOG,
  93 };
  94
  95 #ifdef CONFIG_VT
  96 static void sysrq_handle_SAK(int key, struct tty_struct *tty)
  97 {
  98         struct work_struct *SAK_work = &vc_cons[fg_console].SAK_work;
  99         schedule_work(SAK_work);
 100 }
 101 static struct sysrq_key_op sysrq_SAK_op = {
 102         .handler        = sysrq_handle_SAK,
 103         .help_msg       = "saK",
 104         .action_msg     = "SAK",
 105         .enable_mask    = SYSRQ_ENABLE_KEYBOARD,
 106 };
 107 #else
 108 #define sysrq_SAK_op (*(struct sysrq_key_op *)NULL)
 109 #endif
 110
 111 #ifdef CONFIG_VT
 112 static void sysrq_handle_unraw(int key, struct tty_struct *tty)
 113 {
 114         struct kbd_struct *kbd = &kbd_table[fg_console];
 115
 116         if (kbd)
 117                 kbd->kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE;
 118 }
 119 static struct sysrq_key_op sysrq_unraw_op = {
 120         .handler        = sysrq_handle_unraw,
 121         .help_msg       = "unRaw",
 122         .action_msg     = "Keyboard mode set to system default",
 123         .enable_mask    = SYSRQ_ENABLE_KEYBOARD,
 124 };
 125 #else
 126 #define sysrq_unraw_op (*(struct sysrq_key_op *)NULL)
 127 #endif /* CONFIG_VT */
 128
 129 static void sysrq_handle_crash(int key, struct tty_struct *tty)
 130 {
 131         char *killer = NULL;
 132
 133         panic_on_oops = 1;      /* force panic */
 134         wmb();
 135         *killer = 1;
 136 }
 137 static struct sysrq_key_op sysrq_crash_op = {
 138         .handler        = sysrq_handle_crash,
 139         .help_msg       = "Crash",
 140         .action_msg     = "Trigger a crash",
 141         .enable_mask    = SYSRQ_ENABLE_DUMP,
 142 };
 143
 144 static void sysrq_handle_reboot(int key, struct tty_struct *tty)
 145 {
 146         lockdep_off();
 147         local_irq_enable();
 148         emergency_restart();
 149 }
 150 static struct sysrq_key_op sysrq_reboot_op = {
 151         .handler        = sysrq_handle_reboot,
 152         .help_msg       = "reBoot",
 153         .action_msg     = "Resetting",
 154         .enable_mask    = SYSRQ_ENABLE_BOOT,
 155 };
 156
 157 static void sysrq_handle_sync(int key, struct tty_struct *tty)
 158 {
 159         emergency_sync();
 160 }
 161 static struct sysrq_key_op sysrq_sync_op = {
 162         .handler        = sysrq_handle_sync,
 163         .help_msg       = "Sync",
 164         .action_msg     = "Emergency Sync",
 165         .enable_mask    = SYSRQ_ENABLE_SYNC,
 166 };
 167
 168 static void sysrq_handle_show_timers(int key, struct tty_struct *tty)
 169 {
 170         sysrq_timer_list_show();
 171 }
 172
 173 static struct sysrq_key_op sysrq_show_timers_op = {
 174         .handler        = sysrq_handle_show_timers,
 175         .help_msg       = "show-all-timers(Q)",
 176         .action_msg     = "Show clockevent devices & pending hrtimers (no others)",
 177 };
 178
 179 static void sysrq_handle_mountro(int key, struct tty_struct *tty)
 180 {
 181         emergency_remount();
 182 }
 183 static struct sysrq_key_op sysrq_mountro_op = {
 184         .handler        = sysrq_handle_mountro,
 185         .help_msg       = "Unmount",
 186         .action_msg     = "Emergency Remount R/O",
 187         .enable_mask    = SYSRQ_ENABLE_REMOUNT,
 188 };
 189
 190 #ifdef CONFIG_LOCKDEP
 191 static void sysrq_handle_showlocks(int key, struct tty_struct *tty)
 192 {
 193         debug_show_all_locks();
 194 }
 195
 196 static struct sysrq_key_op sysrq_showlocks_op = {
 197         .handler        = sysrq_handle_showlocks,
 198         .help_msg       = "show-all-locks(D)",
 199         .action_msg     = "Show Locks Held",
 200 };
 201 #else
 202 #define sysrq_showlocks_op (*(struct sysrq_key_op *)NULL)
 203 #endif
 204
 205 #ifdef CONFIG_SMP
 206 static DEFINE_SPINLOCK(show_lock);
 207
 208 static void showacpu(void *dummy)
 209 {
 210         unsigned long flags;
 211
 212         /* Idle CPUs have no interesting backtrace. */
 213         if (idle_cpu(smp_processor_id()))
 214                 return;
 215
 216         spin_lock_irqsave(&show_lock, flags);
 217         printk(KERN_INFO "CPU%d:\n", smp_processor_id());
 218         show_stack(NULL, NULL);
 219         spin_unlock_irqrestore(&show_lock, flags);
 220 }
 221
 222 static void sysrq_showregs_othercpus(struct work_struct *dummy)
 223 {
 224         smp_call_function(showacpu, NULL, 0);
 225 }
 226
 227 static DECLARE_WORK(sysrq_showallcpus, sysrq_showregs_othercpus);
 228
 229 static void sysrq_handle_showallcpus(int key, struct tty_struct *tty)
 230 {
 231         /*
 232          * Fall back to the workqueue based printing if the
 233          * backtrace printing did not succeed or the
 234          * architecture has no support for it:
 235          */
 236         if (!trigger_all_cpu_backtrace()) {
 237                 struct pt_regs *regs = get_irq_regs();
 238
 239                 if (regs) {
 240                         printk(KERN_INFO "CPU%d:\n", smp_processor_id());
 241                         show_regs(regs);
 242                 }
 243                 schedule_work(&sysrq_showallcpus);
 244         }
 245 }
 246
 247 static struct sysrq_key_op sysrq_showallcpus_op = {
 248         .handler        = sysrq_handle_showallcpus,
 249         .help_msg       = "show-backtrace-all-active-cpus(L)",
 250         .action_msg     = "Show backtrace of all active CPUs",
 251         .enable_mask    = SYSRQ_ENABLE_DUMP,
 252 };
 253 #endif
 254
 255 static void sysrq_handle_showregs(int key, struct tty_struct *tty)
 256 {
 257         struct pt_regs *regs = get_irq_regs();
 258         if (regs)
 259                 show_regs(regs);
 260         perf_event_print_debug();
 261 }
 262 static struct sysrq_key_op sysrq_showregs_op = {
 263         .handler        = sysrq_handle_showregs,
 264         .help_msg       = "show-registers(P)",
 265         .action_msg     = "Show Regs",
 266         .enable_mask    = SYSRQ_ENABLE_DUMP,
 267 };
 268
 269 static void sysrq_handle_showstate(int key, struct tty_struct *tty)
 270 {
 271         show_state();
 272 }
 273 static struct sysrq_key_op sysrq_showstate_op = {
 274         .handler        = sysrq_handle_showstate,
 275         .help_msg       = "show-task-states(T)",
 276         .action_msg     = "Show State",
 277         .enable_mask    = SYSRQ_ENABLE_DUMP,
 278 };
 279
 280 static void sysrq_handle_showstate_blocked(int key, struct tty_struct *tty)
 281 {
 282         show_state_filter(TASK_UNINTERRUPTIBLE);
 283 }
 284 static struct sysrq_key_op sysrq_showstate_blocked_op = {
 285         .handler        = sysrq_handle_showstate_blocked,
 286         .help_msg       = "show-blocked-tasks(W)",
 287         .action_msg     = "Show Blocked State",
 288         .enable_mask    = SYSRQ_ENABLE_DUMP,
 289 };
 290
 291 #ifdef CONFIG_TRACING
 292 #include <linux/ftrace.h>
 293
 294 static void sysrq_ftrace_dump(int key, struct tty_struct *tty)
 295 {
 296         ftrace_dump(DUMP_ALL);
 297 }
 298 static struct sysrq_key_op sysrq_ftrace_dump_op = {
 299         .handler        = sysrq_ftrace_dump,
 300         .help_msg       = "dump-ftrace-buffer(Z)",
 301         .action_msg     = "Dump ftrace buffer",
 302         .enable_mask    = SYSRQ_ENABLE_DUMP,
 303 };
 304 #else
 305 #define sysrq_ftrace_dump_op (*(struct sysrq_key_op *)NULL)
 306 #endif
 307
 308 static void sysrq_handle_showmem(int key, struct tty_struct *tty)
 309 {
 310         show_mem();
 311 }
 312 static struct sysrq_key_op sysrq_showmem_op = {
 313         .handler        = sysrq_handle_showmem,
 314         .help_msg       = "show-memory-usage(M)",
 315         .action_msg     = "Show Memory",
 316         .enable_mask    = SYSRQ_ENABLE_DUMP,
 317 };
 318
 319 /*
 320  * Signal sysrq helper function.  Sends a signal to all user processes.
 321  */
 322 static void send_sig_all(int sig)
 323 {
 324         struct task_struct *p;
 325
 326         for_each_process(p) {
 327                 if (p->mm && !is_global_init(p))
 328                         /* Not swapper, init nor kernel thread */
 329                         force_sig(sig, p);
 330         }
 331 }
 332
 333 static void sysrq_handle_term(int key, struct tty_struct *tty)
 334 {
 335         send_sig_all(SIGTERM);
 336         console_loglevel = 8;
 337 }
 338 static struct sysrq_key_op sysrq_term_op = {
 339         .handler        = sysrq_handle_term,
 340         .help_msg       = "terminate-all-tasks(E)",
 341         .action_msg     = "Terminate All Tasks",
 342         .enable_mask    = SYSRQ_ENABLE_SIGNAL,
 343 };
 344
 345 static void moom_callback(struct work_struct *ignored)
 346 {
 347         out_of_memory(node_zonelist(0, GFP_KERNEL), GFP_KERNEL, 0, NULL);
 348 }
 349
 350 static DECLARE_WORK(moom_work, moom_callback);
 351
 352 static void sysrq_handle_moom(int key, struct tty_struct *tty)
 353 {
 354         schedule_work(&moom_work);
 355 }
 356 static struct sysrq_key_op sysrq_moom_op = {
 357         .handler        = sysrq_handle_moom,
 358         .help_msg       = "memory-full-oom-kill(F)",
 359         .action_msg     = "Manual OOM execution",
 360         .enable_mask    = SYSRQ_ENABLE_SIGNAL,
 361 };
 362
 363 #ifdef CONFIG_BLOCK
 364 static void sysrq_handle_thaw(int key, struct tty_struct *tty)
 365 {
 366         emergency_thaw_all();
 367 }
 368 static struct sysrq_key_op sysrq_thaw_op = {
 369         .handler        = sysrq_handle_thaw,
 370         .help_msg       = "thaw-filesystems(J)",
 371         .action_msg     = "Emergency Thaw of all frozen filesystems",
 372         .enable_mask    = SYSRQ_ENABLE_SIGNAL,
 373 };
 374 #endif
 375
 376 static void sysrq_handle_kill(int key, struct tty_struct *tty)
 377 {
 378         send_sig_all(SIGKILL);
 379         console_loglevel = 8;
 380 }
 381 static struct sysrq_key_op sysrq_kill_op = {
 382         .handler        = sysrq_handle_kill,
 383         .help_msg       = "kill-all-tasks(I)",
 384         .action_msg     = "Kill All Tasks",
 385         .enable_mask    = SYSRQ_ENABLE_SIGNAL,
 386 };
 387
 388 static void sysrq_handle_unrt(int key, struct tty_struct *tty)
 389 {
 390         normalize_rt_tasks();
 391 }
 392 static struct sysrq_key_op sysrq_unrt_op = {
 393         .handler        = sysrq_handle_unrt,
 394         .help_msg       = "nice-all-RT-tasks(N)",
 395         .action_msg     = "Nice All RT Tasks",
 396         .enable_mask    = SYSRQ_ENABLE_RTNICE,
 397 };
 398
 399 /* Key Operations table and lock */
 400 static DEFINE_SPINLOCK(sysrq_key_table_lock);
 401
 402 static struct sysrq_key_op *sysrq_key_table[36] = {
 403         &sysrq_loglevel_op,             /* 0 */
 404         &sysrq_loglevel_op,             /* 1 */
 405         &sysrq_loglevel_op,             /* 2 */
 406         &sysrq_loglevel_op,             /* 3 */
 407         &sysrq_loglevel_op,             /* 4 */
 408         &sysrq_loglevel_op,             /* 5 */
 409         &sysrq_loglevel_op,             /* 6 */
 410         &sysrq_loglevel_op,             /* 7 */
 411         &sysrq_loglevel_op,             /* 8 */
 412         &sysrq_loglevel_op,             /* 9 */
 413
 414         /*
 415          * a: Don't use for system provided sysrqs, it is handled specially on
 416          * sparc and will never arrive.
 417          */
 418         NULL,                           /* a */
 419         &sysrq_reboot_op,               /* b */
 420         &sysrq_crash_op,                /* c & ibm_emac driver debug */
 421         &sysrq_showlocks_op,            /* d */
 422         &sysrq_term_op,                 /* e */
 423         &sysrq_moom_op,                 /* f */
 424         /* g: May be registered for the kernel debugger */
 425         NULL,                           /* g */
 426         NULL,                           /* h - reserved for help */
 427         &sysrq_kill_op,                 /* i */
 428 #ifdef CONFIG_BLOCK
 429         &sysrq_thaw_op,                 /* j */
 430 #else
 431         NULL,                           /* j */
 432 #endif
 433         &sysrq_SAK_op,                  /* k */
 434 #ifdef CONFIG_SMP
 435         &sysrq_showallcpus_op,          /* l */
 436 #else
 437         NULL,                           /* l */
 438 #endif
 439         &sysrq_showmem_op,              /* m */
 440         &sysrq_unrt_op,                 /* n */
 441         /* o: This will often be registered as 'Off' at init time */
 442         NULL,                           /* o */
 443         &sysrq_showregs_op,             /* p */
 444         &sysrq_show_timers_op,          /* q */
 445         &sysrq_unraw_op,                /* r */
 446         &sysrq_sync_op,                 /* s */
 447         &sysrq_showstate_op,            /* t */
 448         &sysrq_mountro_op,              /* u */
 449         /* v: May be registered for frame buffer console restore */
 450         NULL,                           /* v */
 451         &sysrq_showstate_blocked_op,    /* w */
 452         /* x: May be registered on ppc/powerpc for xmon */
 453         NULL,                           /* x */
 454         /* y: May be registered on sparc64 for global register dump */
 455         NULL,                           /* y */
 456         &sysrq_ftrace_dump_op,          /* z */
 457 };
 458
 459 /* key2index calculation, -1 on invalid index */
 460 static int sysrq_key_table_key2index(int key)
 461 {
 462         int retval;
 463
 464         if ((key >= '0') && (key <= '9'))
 465                 retval = key - '0';
 466         else if ((key >= 'a') && (key <= 'z'))
 467                 retval = key + 10 - 'a';
 468         else
 469                 retval = -1;
 470         return retval;
 471 }
 472
 473 /*
 474  * get and put functions for the table, exposed to modules.
 475  */
 476 struct sysrq_key_op *__sysrq_get_key_op(int key)
 477 {
 478         struct sysrq_key_op *op_p = NULL;
 479         int i;
 480
 481         i = sysrq_key_table_key2index(key);
 482         if (i != -1)
 483                 op_p = sysrq_key_table[i];
 484
 485         return op_p;
 486 }
 487
 488 static void __sysrq_put_key_op(int key, struct sysrq_key_op *op_p)
 489 {
 490         int i = sysrq_key_table_key2index(key);
 491
 492         if (i != -1)
 493                 sysrq_key_table[i] = op_p;
 494 }
 495
 496 void __handle_sysrq(int key, struct tty_struct *tty, int check_mask)
 497 {
 498         struct sysrq_key_op *op_p;
 499         int orig_log_level;
 500         int i;
 501         unsigned long flags;
 502
 503         spin_lock_irqsave(&sysrq_key_table_lock, flags);
 504         /*
 505          * Raise the apparent loglevel to maximum so that the sysrq header
 506          * is shown to provide the user with positive feedback.  We do not
 507          * simply emit this at KERN_EMERG as that would change message
 508          * routing in the consumers of /proc/kmsg.
 509          */
 510         orig_log_level = console_loglevel;
 511         console_loglevel = 7;
 512         printk(KERN_INFO "SysRq : ");
 513
 514         op_p = __sysrq_get_key_op(key);
 515         if (op_p) {
 516                 /*
 517                  * Should we check for enabled operations (/proc/sysrq-trigger
 518                  * should not) and is the invoked operation enabled?
 519                  */
 520                 if (!check_mask || sysrq_on_mask(op_p->enable_mask)) {
 521                         printk("%s\n", op_p->action_msg);
 522                         console_loglevel = orig_log_level;
 523                         op_p->handler(key, tty);
 524                 } else {
 525                         printk("This sysrq operation is disabled.\n");
 526                 }
 527         } else {
 528                 printk("HELP : ");
 529                 /* Only print the help msg once per handler */
 530                 for (i = 0; i < ARRAY_SIZE(sysrq_key_table); i++) {
 531                         if (sysrq_key_table[i]) {
 532                                 int j;
 533
 534                                 for (j = 0; sysrq_key_table[i] !=
 535                                                 sysrq_key_table[j]; j++)
 536                                         ;
 537                                 if (j != i)
 538                                         continue;
 539                                 printk("%s ", sysrq_key_table[i]->help_msg);
 540                         }
 541                 }
 542                 printk("\n");
 543                 console_loglevel = orig_log_level;
 544         }
 545         spin_unlock_irqrestore(&sysrq_key_table_lock, flags);
 546 }
 547
 548 void handle_sysrq(int key, struct tty_struct *tty)
 549 {
 550         if (sysrq_on())
 551                 __handle_sysrq(key, tty, 1);
 552 }
 553 EXPORT_SYMBOL(handle_sysrq);
 554
 555 #ifdef CONFIG_INPUT
 556
 557 /* Simple translation table for the SysRq keys */
 558 static const unsigned char sysrq_xlate[KEY_MAX + 1] =
 559         "\000\0331234567890-=\177\t"                    /* 0x00 - 0x0f */
 560         "qwertyuiop[]\r\000as"                          /* 0x10 - 0x1f */
 561         "dfghjkl;'`\000\\zxcv"                          /* 0x20 - 0x2f */
 562         "bnm,./\000*\000 \000\201\202\203\204\205"      /* 0x30 - 0x3f */
 563         "\206\207\210\211\212\000\000789-456+1"         /* 0x40 - 0x4f */
 564         "230\177\000\000\213\214\000\000\000\000\000\000\000\000\000\000" /* 0x50 - 0x5f */
 565         "\r\000/";                                      /* 0x60 - 0x6f */
 566
 567 static bool sysrq_down;
 568 static int sysrq_alt_use;
 569 static int sysrq_alt;
 570
 571 static bool sysrq_filter(struct input_handle *handle, unsigned int type,
 572                          unsigned int code, int value)
 573 {
 574         if (type != EV_KEY)
 575                 goto out;
 576
 577         switch (code) {
 578
 579         case KEY_LEFTALT:
 580         case KEY_RIGHTALT:
 581                 if (value)
 582                         sysrq_alt = code;
 583                 else {
 584                         if (sysrq_down && code == sysrq_alt_use)
 585                                 sysrq_down = false;
 586
 587                         sysrq_alt = 0;
 588                 }
 589                 break;
 590
 591         case KEY_SYSRQ:
 592                 if (value == 1 && sysrq_alt) {
 593                         sysrq_down = true;
 594                         sysrq_alt_use = sysrq_alt;
 595                 }
 596                 break;
 597
 598         default:
 599                 if (sysrq_down && value && value != 2)
 600                         __handle_sysrq(sysrq_xlate[code], NULL, 1);
 601                 break;
 602         }
 603
 604 out:
 605         return sysrq_down;
 606 }
 607
 608 static int sysrq_connect(struct input_handler *handler,
 609                          struct input_dev *dev,
 610                          const struct input_device_id *id)
 611 {
 612         struct input_handle *handle;
 613         int error;
 614
 615         sysrq_down = false;
 616         sysrq_alt = 0;
 617
 618         handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);
 619         if (!handle)
 620                 return -ENOMEM;
 621
 622         handle->dev = dev;
 623         handle->handler = handler;
 624         handle->name = "sysrq";
 625
 626         error = input_register_handle(handle);
 627         if (error) {
 628                 pr_err("Failed to register input sysrq handler, error %d\n",
 629                         error);
 630                 goto err_free;
 631         }
 632
 633         error = input_open_device(handle);
 634         if (error) {
 635                 pr_err("Failed to open input device, error %d\n", error);
 636                 goto err_unregister;
 637         }
 638
 639         return 0;
 640
 641  err_unregister:
 642         input_unregister_handle(handle);
 643  err_free:
 644         kfree(handle);
 645         return error;
 646 }
 647
 648 static void sysrq_disconnect(struct input_handle *handle)
 649 {
 650         input_close_device(handle);
 651         input_unregister_handle(handle);
 652         kfree(handle);
 653 }
 654
 655 /*
 656  * We are matching on KEY_LEFTALT insteard of KEY_SYSRQ because not all
 657  * keyboards have SysRq ikey predefined and so user may add it to keymap
 658  * later, but we expect all such keyboards to have left alt.
 659  */
 660 static const struct input_device_id sysrq_ids[] = {
 661         {
 662                 .flags = INPUT_DEVICE_ID_MATCH_EVBIT |
 663                                 INPUT_DEVICE_ID_MATCH_KEYBIT,
 664                 .evbit = { BIT_MASK(EV_KEY) },
 665                 .keybit = { BIT_MASK(KEY_LEFTALT) },
 666         },
 667         { },
 668 };
 669
 670 static struct input_handler sysrq_handler = {
 671         .filter         = sysrq_filter,
 672         .connect        = sysrq_connect,
 673         .disconnect     = sysrq_disconnect,
 674         .name           = "sysrq",
 675         .id_table       = sysrq_ids,
 676 };
 677
 678 static bool sysrq_handler_registered;
 679
 680 static inline void sysrq_register_handler(void)
 681 {
 682         int error;
 683
 684         error = input_register_handler(&sysrq_handler);
 685         if (error)
 686                 pr_err("Failed to register input handler, error %d", error);
 687         else
 688                 sysrq_handler_registered = true;
 689 }
 690
 691 static inline void sysrq_unregister_handler(void)
 692 {
 693         if (sysrq_handler_registered) {
 694                 input_unregister_handler(&sysrq_handler);
 695                 sysrq_handler_registered = false;
 696         }
 697 }
 698
 699 #else
 700
 701 static inline void sysrq_register_handler(void)
 702 {
 703 }
 704
 705 static inline void sysrq_unregister_handler(void)
 706 {
 707 }
 708
 709 #endif /* CONFIG_INPUT */
 710
 711 int sysrq_toggle_support(int enable_mask)
 712 {
 713         bool was_enabled = sysrq_on();
 714
 715         sysrq_enabled = enable_mask;
 716
 717         if (was_enabled != sysrq_on()) {
 718                 if (sysrq_on())
 719                         sysrq_register_handler();
 720                 else
 721                         sysrq_unregister_handler();
 722         }
 723
 724         return 0;
 725 }
 726
 727 static int __sysrq_swap_key_ops(int key, struct sysrq_key_op *insert_op_p,
 728                                 struct sysrq_key_op *remove_op_p)
 729 {
 730         int retval;
 731         unsigned long flags;
 732
 733         spin_lock_irqsave(&sysrq_key_table_lock, flags);
 734         if (__sysrq_get_key_op(key) == remove_op_p) {
 735                 __sysrq_put_key_op(key, insert_op_p);
 736                 retval = 0;
 737         } else {
 738                 retval = -1;
 739         }
 740         spin_unlock_irqrestore(&sysrq_key_table_lock, flags);
 741         return retval;
 742 }
 743
 744 int register_sysrq_key(int key, struct sysrq_key_op *op_p)
 745 {
 746         return __sysrq_swap_key_ops(key, op_p, NULL);
 747 }
 748 EXPORT_SYMBOL(register_sysrq_key);
 749
 750 int unregister_sysrq_key(int key, struct sysrq_key_op *op_p)
 751 {
 752         return __sysrq_swap_key_ops(key, NULL, op_p);
 753 }
 754 EXPORT_SYMBOL(unregister_sysrq_key);
 755
 756 #ifdef CONFIG_PROC_FS
 757 /*
 758  * writing 'C' to /proc/sysrq-trigger is like sysrq-C
 759  */
 760 static ssize_t write_sysrq_trigger(struct file *file, const char __user *buf,
 761                                    size_t count, loff_t *ppos)
 762 {
 763         if (count) {
 764                 char c;
 765
 766                 if (get_user(c, buf))
 767                         return -EFAULT;
 768                 __handle_sysrq(c, NULL, 0);
 769         }
 770
 771         return count;
 772 }
 773
 774 static const struct file_operations proc_sysrq_trigger_operations = {
 775         .write          = write_sysrq_trigger,
 776 };
 777
 778 static void sysrq_init_procfs(void)
 779 {
 780         if (!proc_create("sysrq-trigger", S_IWUSR, NULL,
 781                          &proc_sysrq_trigger_operations))
 782                 pr_err("Failed to register proc interface\n");
 783 }
 784
 785 #else
 786
 787 static inline void sysrq_init_procfs(void)
 788 {
 789 }
 790
 791 #endif /* CONFIG_PROC_FS */
 792
 793 static int __init sysrq_init(void)
 794 {
 795         sysrq_init_procfs();
 796
 797         if (sysrq_on())
 798                 sysrq_register_handler();
 799
 800         return 0;
 801 }
 802 module_init(sysrq_init);