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

Archive Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9



interactive