Version:  2.6.34 2.6.35 2.6.36 2.6.37 2.6.38 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14

Linux/drivers/tty/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/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 - '';
 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 >= '') && (key <= '9'))
477                 retval = key - '';
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 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us