LCOV - code coverage report
Current view: top level - drivers/tty - sysrq.c (source / functions) Hit Total Coverage
Test: Real Lines: 83 299 27.8 %
Date: 2020-10-17 15:46:16 Functions: 0 44 0.0 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

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

Generated by: LCOV version 1.14