sysrq.c 18.5 KB
Newer Older
1
/*
Linus Torvalds's avatar
Linus Torvalds committed
2 3 4 5 6 7 8 9
 *	Linux Magic System Request Key Hacks
 *
 *	(c) 1997 Martin Mares <mj@atrey.karlin.mff.cuni.cz>
 *	based on ideas by Pavel Machek <pavel@atrey.karlin.mff.cuni.cz>
 *
 *	(c) 2000 Crutcher Dunnavant <crutcher+kernel@datastacks.com>
 *	overhauled to use key registration
 *	based upon discusions in irc://irc.openprojects.net/#kernelnewbies
10 11 12
 *
 *	Copyright (c) 2010 Dmitry Torokhov
 *	Input handler conversion
Linus Torvalds's avatar
Linus Torvalds committed
13 14
 */

15 16
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

Linus Torvalds's avatar
Linus Torvalds committed
17 18 19 20 21 22 23 24 25 26 27
#include <linux/sched.h>
#include <linux/interrupt.h>
#include <linux/mm.h>
#include <linux/fs.h>
#include <linux/tty.h>
#include <linux/mount.h>
#include <linux/kdev_t.h>
#include <linux/major.h>
#include <linux/reboot.h>
#include <linux/sysrq.h>
#include <linux/kbd_kern.h>
28
#include <linux/proc_fs.h>
29
#include <linux/nmi.h>
Linus Torvalds's avatar
Linus Torvalds committed
30
#include <linux/quotaops.h>
31
#include <linux/perf_event.h>
Linus Torvalds's avatar
Linus Torvalds committed
32 33 34 35 36 37 38 39 40
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/suspend.h>
#include <linux/writeback.h>
#include <linux/buffer_head.h>		/* for fsync_bdev() */
#include <linux/swap.h>
#include <linux/spinlock.h>
#include <linux/vt_kern.h>
#include <linux/workqueue.h>
41
#include <linux/hrtimer.h>
42
#include <linux/oom.h>
43
#include <linux/slab.h>
44
#include <linux/input.h>
Linus Torvalds's avatar
Linus Torvalds committed
45 46

#include <asm/ptrace.h>
47
#include <asm/irq_regs.h>
Linus Torvalds's avatar
Linus Torvalds committed
48 49

/* Whether we react on sysrq keys or just ignore them */
50 51
static int __read_mostly sysrq_enabled = 1;
static bool __read_mostly sysrq_always_enabled;
52

53
static bool sysrq_on(void)
54
{
55
	return sysrq_enabled || sysrq_always_enabled;
56 57 58 59 60
}

/*
 * A value of 1 means 'all', other nonzero values are an op mask:
 */
61
static bool sysrq_on_mask(int mask)
62
{
63 64 65
	return sysrq_always_enabled ||
	       sysrq_enabled == 1 ||
	       (sysrq_enabled & mask);
66 67 68 69
}

static int __init sysrq_always_enabled_setup(char *str)
{
70 71
	sysrq_always_enabled = true;
	pr_info("sysrq always enabled.\n");
72 73 74 75 76 77

	return 1;
}

__setup("sysrq_always_enabled", sysrq_always_enabled_setup);

Linus Torvalds's avatar
Linus Torvalds committed
78

79
static void sysrq_handle_loglevel(int key, struct tty_struct *tty)
Linus Torvalds's avatar
Linus Torvalds committed
80 81
{
	int i;
82

Linus Torvalds's avatar
Linus Torvalds committed
83 84 85 86
	i = key - '0';
	console_loglevel = 7;
	printk("Loglevel set to %d\n", i);
	console_loglevel = i;
Andrew Morton's avatar
Andrew Morton committed
87
}
Linus Torvalds's avatar
Linus Torvalds committed
88 89
static struct sysrq_key_op sysrq_loglevel_op = {
	.handler	= sysrq_handle_loglevel,
90
	.help_msg	= "loglevel(0-9)",
Linus Torvalds's avatar
Linus Torvalds committed
91 92 93 94 95
	.action_msg	= "Changing Loglevel",
	.enable_mask	= SYSRQ_ENABLE_LOG,
};

#ifdef CONFIG_VT
96
static void sysrq_handle_SAK(int key, struct tty_struct *tty)
Linus Torvalds's avatar
Linus Torvalds committed
97
{
98 99
	struct work_struct *SAK_work = &vc_cons[fg_console].SAK_work;
	schedule_work(SAK_work);
Linus Torvalds's avatar
Linus Torvalds committed
100 101 102 103 104 105 106
}
static struct sysrq_key_op sysrq_SAK_op = {
	.handler	= sysrq_handle_SAK,
	.help_msg	= "saK",
	.action_msg	= "SAK",
	.enable_mask	= SYSRQ_ENABLE_KEYBOARD,
};
Andrew Morton's avatar
Andrew Morton committed
107
#else
108
#define sysrq_SAK_op (*(struct sysrq_key_op *)NULL)
Linus Torvalds's avatar
Linus Torvalds committed
109 110 111
#endif

#ifdef CONFIG_VT
112
static void sysrq_handle_unraw(int key, struct tty_struct *tty)
Linus Torvalds's avatar
Linus Torvalds committed
113 114 115 116
{
	struct kbd_struct *kbd = &kbd_table[fg_console];

	if (kbd)
Bill Nottingham's avatar
Bill Nottingham committed
117
		kbd->kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE;
Linus Torvalds's avatar
Linus Torvalds committed
118 119 120 121
}
static struct sysrq_key_op sysrq_unraw_op = {
	.handler	= sysrq_handle_unraw,
	.help_msg	= "unRaw",
Bill Nottingham's avatar
Bill Nottingham committed
122
	.action_msg	= "Keyboard mode set to system default",
Linus Torvalds's avatar
Linus Torvalds committed
123 124
	.enable_mask	= SYSRQ_ENABLE_KEYBOARD,
};
Andrew Morton's avatar
Andrew Morton committed
125
#else
126
#define sysrq_unraw_op (*(struct sysrq_key_op *)NULL)
Linus Torvalds's avatar
Linus Torvalds committed
127 128
#endif /* CONFIG_VT */

129
static void sysrq_handle_crash(int key, struct tty_struct *tty)
130
{
131
	char *killer = NULL;
132 133 134

	panic_on_oops = 1;	/* force panic */
	wmb();
135
	*killer = 1;
136
}
137
static struct sysrq_key_op sysrq_crash_op = {
138 139 140
	.handler	= sysrq_handle_crash,
	.help_msg	= "Crash",
	.action_msg	= "Trigger a crash",
141 142 143
	.enable_mask	= SYSRQ_ENABLE_DUMP,
};

144
static void sysrq_handle_reboot(int key, struct tty_struct *tty)
Linus Torvalds's avatar
Linus Torvalds committed
145
{
146
	lockdep_off();
Linus Torvalds's avatar
Linus Torvalds committed
147
	local_irq_enable();
148
	emergency_restart();
Linus Torvalds's avatar
Linus Torvalds committed
149 150 151 152 153 154 155 156
}
static struct sysrq_key_op sysrq_reboot_op = {
	.handler	= sysrq_handle_reboot,
	.help_msg	= "reBoot",
	.action_msg	= "Resetting",
	.enable_mask	= SYSRQ_ENABLE_BOOT,
};

157
static void sysrq_handle_sync(int key, struct tty_struct *tty)
Linus Torvalds's avatar
Linus Torvalds committed
158 159 160 161 162 163 164 165 166 167
{
	emergency_sync();
}
static struct sysrq_key_op sysrq_sync_op = {
	.handler	= sysrq_handle_sync,
	.help_msg	= "Sync",
	.action_msg	= "Emergency Sync",
	.enable_mask	= SYSRQ_ENABLE_SYNC,
};

168 169 170 171 172 173 174 175
static void sysrq_handle_show_timers(int key, struct tty_struct *tty)
{
	sysrq_timer_list_show();
}

static struct sysrq_key_op sysrq_show_timers_op = {
	.handler	= sysrq_handle_show_timers,
	.help_msg	= "show-all-timers(Q)",
176
	.action_msg	= "Show clockevent devices & pending hrtimers (no others)",
177 178
};

179
static void sysrq_handle_mountro(int key, struct tty_struct *tty)
Linus Torvalds's avatar
Linus Torvalds committed
180 181 182 183 184 185 186 187 188 189
{
	emergency_remount();
}
static struct sysrq_key_op sysrq_mountro_op = {
	.handler	= sysrq_handle_mountro,
	.help_msg	= "Unmount",
	.action_msg	= "Emergency Remount R/O",
	.enable_mask	= SYSRQ_ENABLE_REMOUNT,
};

190
#ifdef CONFIG_LOCKDEP
191
static void sysrq_handle_showlocks(int key, struct tty_struct *tty)
192
{
193
	debug_show_all_locks();
194
}
195

196 197 198 199 200
static struct sysrq_key_op sysrq_showlocks_op = {
	.handler	= sysrq_handle_showlocks,
	.help_msg	= "show-all-locks(D)",
	.action_msg	= "Show Locks Held",
};
Andrew Morton's avatar
Andrew Morton committed
201
#else
202
#define sysrq_showlocks_op (*(struct sysrq_key_op *)NULL)
203
#endif
Linus Torvalds's avatar
Linus Torvalds committed
204

205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223
#ifdef CONFIG_SMP
static DEFINE_SPINLOCK(show_lock);

static void showacpu(void *dummy)
{
	unsigned long flags;

	/* Idle CPUs have no interesting backtrace. */
	if (idle_cpu(smp_processor_id()))
		return;

	spin_lock_irqsave(&show_lock, flags);
	printk(KERN_INFO "CPU%d:\n", smp_processor_id());
	show_stack(NULL, NULL);
	spin_unlock_irqrestore(&show_lock, flags);
}

static void sysrq_showregs_othercpus(struct work_struct *dummy)
{
224
	smp_call_function(showacpu, NULL, 0);
225 226 227 228 229 230
}

static DECLARE_WORK(sysrq_showallcpus, sysrq_showregs_othercpus);

static void sysrq_handle_showallcpus(int key, struct tty_struct *tty)
{
231 232 233 234 235 236 237 238 239 240 241 242 243 244
	/*
	 * Fall back to the workqueue based printing if the
	 * backtrace printing did not succeed or the
	 * architecture has no support for it:
	 */
	if (!trigger_all_cpu_backtrace()) {
		struct pt_regs *regs = get_irq_regs();

		if (regs) {
			printk(KERN_INFO "CPU%d:\n", smp_processor_id());
			show_regs(regs);
		}
		schedule_work(&sysrq_showallcpus);
	}
245 246 247 248
}

static struct sysrq_key_op sysrq_showallcpus_op = {
	.handler	= sysrq_handle_showallcpus,
249
	.help_msg	= "show-backtrace-all-active-cpus(L)",
250 251 252 253 254
	.action_msg	= "Show backtrace of all active CPUs",
	.enable_mask	= SYSRQ_ENABLE_DUMP,
};
#endif

255
static void sysrq_handle_showregs(int key, struct tty_struct *tty)
Linus Torvalds's avatar
Linus Torvalds committed
256
{
257 258 259
	struct pt_regs *regs = get_irq_regs();
	if (regs)
		show_regs(regs);
260
	perf_event_print_debug();
Linus Torvalds's avatar
Linus Torvalds committed
261 262 263
}
static struct sysrq_key_op sysrq_showregs_op = {
	.handler	= sysrq_handle_showregs,
264
	.help_msg	= "show-registers(P)",
Linus Torvalds's avatar
Linus Torvalds committed
265 266 267 268
	.action_msg	= "Show Regs",
	.enable_mask	= SYSRQ_ENABLE_DUMP,
};

269
static void sysrq_handle_showstate(int key, struct tty_struct *tty)
Linus Torvalds's avatar
Linus Torvalds committed
270 271 272 273 274
{
	show_state();
}
static struct sysrq_key_op sysrq_showstate_op = {
	.handler	= sysrq_handle_showstate,
275
	.help_msg	= "show-task-states(T)",
Linus Torvalds's avatar
Linus Torvalds committed
276 277 278 279
	.action_msg	= "Show State",
	.enable_mask	= SYSRQ_ENABLE_DUMP,
};

280 281 282 283 284 285
static void sysrq_handle_showstate_blocked(int key, struct tty_struct *tty)
{
	show_state_filter(TASK_UNINTERRUPTIBLE);
}
static struct sysrq_key_op sysrq_showstate_blocked_op = {
	.handler	= sysrq_handle_showstate_blocked,
286
	.help_msg	= "show-blocked-tasks(W)",
287 288 289 290
	.action_msg	= "Show Blocked State",
	.enable_mask	= SYSRQ_ENABLE_DUMP,
};

291 292 293 294 295 296 297 298 299
#ifdef CONFIG_TRACING
#include <linux/ftrace.h>

static void sysrq_ftrace_dump(int key, struct tty_struct *tty)
{
	ftrace_dump();
}
static struct sysrq_key_op sysrq_ftrace_dump_op = {
	.handler	= sysrq_ftrace_dump,
300
	.help_msg	= "dump-ftrace-buffer(Z)",
301 302 303 304
	.action_msg	= "Dump ftrace buffer",
	.enable_mask	= SYSRQ_ENABLE_DUMP,
};
#else
305
#define sysrq_ftrace_dump_op (*(struct sysrq_key_op *)NULL)
306
#endif
307

308
static void sysrq_handle_showmem(int key, struct tty_struct *tty)
Linus Torvalds's avatar
Linus Torvalds committed
309 310 311 312 313
{
	show_mem();
}
static struct sysrq_key_op sysrq_showmem_op = {
	.handler	= sysrq_handle_showmem,
314
	.help_msg	= "show-memory-usage(M)",
Linus Torvalds's avatar
Linus Torvalds committed
315 316 317 318
	.action_msg	= "Show Memory",
	.enable_mask	= SYSRQ_ENABLE_DUMP,
};

Andrew Morton's avatar
Andrew Morton committed
319 320 321
/*
 * Signal sysrq helper function.  Sends a signal to all user processes.
 */
Linus Torvalds's avatar
Linus Torvalds committed
322 323 324 325 326
static void send_sig_all(int sig)
{
	struct task_struct *p;

	for_each_process(p) {
327
		if (p->mm && !is_global_init(p))
Linus Torvalds's avatar
Linus Torvalds committed
328 329 330 331 332
			/* Not swapper, init nor kernel thread */
			force_sig(sig, p);
	}
}

333
static void sysrq_handle_term(int key, struct tty_struct *tty)
Linus Torvalds's avatar
Linus Torvalds committed
334 335 336 337 338 339
{
	send_sig_all(SIGTERM);
	console_loglevel = 8;
}
static struct sysrq_key_op sysrq_term_op = {
	.handler	= sysrq_handle_term,
340
	.help_msg	= "terminate-all-tasks(E)",
Linus Torvalds's avatar
Linus Torvalds committed
341 342 343 344
	.action_msg	= "Terminate All Tasks",
	.enable_mask	= SYSRQ_ENABLE_SIGNAL,
};

345
static void moom_callback(struct work_struct *ignored)
Linus Torvalds's avatar
Linus Torvalds committed
346
{
347
	out_of_memory(node_zonelist(0, GFP_KERNEL), GFP_KERNEL, 0, NULL);
Linus Torvalds's avatar
Linus Torvalds committed
348 349
}

350
static DECLARE_WORK(moom_work, moom_callback);
Linus Torvalds's avatar
Linus Torvalds committed
351

352
static void sysrq_handle_moom(int key, struct tty_struct *tty)
Linus Torvalds's avatar
Linus Torvalds committed
353 354 355 356 357
{
	schedule_work(&moom_work);
}
static struct sysrq_key_op sysrq_moom_op = {
	.handler	= sysrq_handle_moom,
358
	.help_msg	= "memory-full-oom-kill(F)",
Linus Torvalds's avatar
Linus Torvalds committed
359
	.action_msg	= "Manual OOM execution",
360
	.enable_mask	= SYSRQ_ENABLE_SIGNAL,
Linus Torvalds's avatar
Linus Torvalds committed
361 362
};

363 364 365 366 367 368 369 370 371 372 373 374 375
#ifdef CONFIG_BLOCK
static void sysrq_handle_thaw(int key, struct tty_struct *tty)
{
	emergency_thaw_all();
}
static struct sysrq_key_op sysrq_thaw_op = {
	.handler	= sysrq_handle_thaw,
	.help_msg	= "thaw-filesystems(J)",
	.action_msg	= "Emergency Thaw of all frozen filesystems",
	.enable_mask	= SYSRQ_ENABLE_SIGNAL,
};
#endif

376
static void sysrq_handle_kill(int key, struct tty_struct *tty)
Linus Torvalds's avatar
Linus Torvalds committed
377 378 379 380 381 382
{
	send_sig_all(SIGKILL);
	console_loglevel = 8;
}
static struct sysrq_key_op sysrq_kill_op = {
	.handler	= sysrq_handle_kill,
383
	.help_msg	= "kill-all-tasks(I)",
Linus Torvalds's avatar
Linus Torvalds committed
384 385 386 387
	.action_msg	= "Kill All Tasks",
	.enable_mask	= SYSRQ_ENABLE_SIGNAL,
};

388
static void sysrq_handle_unrt(int key, struct tty_struct *tty)
Linus Torvalds's avatar
Linus Torvalds committed
389 390 391 392 393
{
	normalize_rt_tasks();
}
static struct sysrq_key_op sysrq_unrt_op = {
	.handler	= sysrq_handle_unrt,
394
	.help_msg	= "nice-all-RT-tasks(N)",
Linus Torvalds's avatar
Linus Torvalds committed
395 396 397 398 399 400
	.action_msg	= "Nice All RT Tasks",
	.enable_mask	= SYSRQ_ENABLE_RTNICE,
};

/* Key Operations table and lock */
static DEFINE_SPINLOCK(sysrq_key_table_lock);
Andrew Morton's avatar
Andrew Morton committed
401 402 403 404 405 406 407 408 409 410 411 412 413 414

static struct sysrq_key_op *sysrq_key_table[36] = {
	&sysrq_loglevel_op,		/* 0 */
	&sysrq_loglevel_op,		/* 1 */
	&sysrq_loglevel_op,		/* 2 */
	&sysrq_loglevel_op,		/* 3 */
	&sysrq_loglevel_op,		/* 4 */
	&sysrq_loglevel_op,		/* 5 */
	&sysrq_loglevel_op,		/* 6 */
	&sysrq_loglevel_op,		/* 7 */
	&sysrq_loglevel_op,		/* 8 */
	&sysrq_loglevel_op,		/* 9 */

	/*
415 416
	 * a: Don't use for system provided sysrqs, it is handled specially on
	 * sparc and will never arrive.
Andrew Morton's avatar
Andrew Morton committed
417 418 419
	 */
	NULL,				/* a */
	&sysrq_reboot_op,		/* b */
420
	&sysrq_crash_op,		/* c & ibm_emac driver debug */
Andrew Morton's avatar
Andrew Morton committed
421 422 423
	&sysrq_showlocks_op,		/* d */
	&sysrq_term_op,			/* e */
	&sysrq_moom_op,			/* f */
424
	/* g: May be registered for the kernel debugger */
Andrew Morton's avatar
Andrew Morton committed
425
	NULL,				/* g */
426
	NULL,				/* h - reserved for help */
Andrew Morton's avatar
Andrew Morton committed
427
	&sysrq_kill_op,			/* i */
428 429 430
#ifdef CONFIG_BLOCK
	&sysrq_thaw_op,			/* j */
#else
Andrew Morton's avatar
Andrew Morton committed
431
	NULL,				/* j */
432
#endif
Andrew Morton's avatar
Andrew Morton committed
433
	&sysrq_SAK_op,			/* k */
434 435 436
#ifdef CONFIG_SMP
	&sysrq_showallcpus_op,		/* l */
#else
Andrew Morton's avatar
Andrew Morton committed
437
	NULL,				/* l */
438
#endif
Andrew Morton's avatar
Andrew Morton committed
439 440
	&sysrq_showmem_op,		/* m */
	&sysrq_unrt_op,			/* n */
441
	/* o: This will often be registered as 'Off' at init time */
Andrew Morton's avatar
Andrew Morton committed
442 443
	NULL,				/* o */
	&sysrq_showregs_op,		/* p */
444
	&sysrq_show_timers_op,		/* q */
445
	&sysrq_unraw_op,		/* r */
Andrew Morton's avatar
Andrew Morton committed
446 447 448
	&sysrq_sync_op,			/* s */
	&sysrq_showstate_op,		/* t */
	&sysrq_mountro_op,		/* u */
449
	/* v: May be registered for frame buffer console restore */
Andrew Morton's avatar
Andrew Morton committed
450
	NULL,				/* v */
451 452 453
	&sysrq_showstate_blocked_op,	/* w */
	/* x: May be registered on ppc/powerpc for xmon */
	NULL,				/* x */
454
	/* y: May be registered on sparc64 for global register dump */
Andrew Morton's avatar
Andrew Morton committed
455
	NULL,				/* y */
456
	&sysrq_ftrace_dump_op,		/* z */
Linus Torvalds's avatar
Linus Torvalds committed
457 458 459
};

/* key2index calculation, -1 on invalid index */
Andrew Morton's avatar
Andrew Morton committed
460 461
static int sysrq_key_table_key2index(int key)
{
Linus Torvalds's avatar
Linus Torvalds committed
462
	int retval;
Andrew Morton's avatar
Andrew Morton committed
463 464

	if ((key >= '0') && (key <= '9'))
Linus Torvalds's avatar
Linus Torvalds committed
465
		retval = key - '0';
Andrew Morton's avatar
Andrew Morton committed
466
	else if ((key >= 'a') && (key <= 'z'))
Linus Torvalds's avatar
Linus Torvalds committed
467
		retval = key + 10 - 'a';
Andrew Morton's avatar
Andrew Morton committed
468
	else
Linus Torvalds's avatar
Linus Torvalds committed
469 470 471 472 473 474 475
		retval = -1;
	return retval;
}

/*
 * get and put functions for the table, exposed to modules.
 */
Andrew Morton's avatar
Andrew Morton committed
476 477 478
struct sysrq_key_op *__sysrq_get_key_op(int key)
{
        struct sysrq_key_op *op_p = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
479
        int i;
Andrew Morton's avatar
Andrew Morton committed
480

Linus Torvalds's avatar
Linus Torvalds committed
481
	i = sysrq_key_table_key2index(key);
Andrew Morton's avatar
Andrew Morton committed
482 483
	if (i != -1)
	        op_p = sysrq_key_table[i];
484

Linus Torvalds's avatar
Linus Torvalds committed
485 486 487
        return op_p;
}

Andrew Morton's avatar
Andrew Morton committed
488 489 490
static void __sysrq_put_key_op(int key, struct sysrq_key_op *op_p)
{
        int i = sysrq_key_table_key2index(key);
Linus Torvalds's avatar
Linus Torvalds committed
491 492 493 494 495

        if (i != -1)
                sysrq_key_table[i] = op_p;
}

496
static void __handle_sysrq(int key, struct tty_struct *tty, int check_mask)
Linus Torvalds's avatar
Linus Torvalds committed
497 498 499
{
	struct sysrq_key_op *op_p;
	int orig_log_level;
Andrew Morton's avatar
Andrew Morton committed
500
	int i;
Linus Torvalds's avatar
Linus Torvalds committed
501 502 503
	unsigned long flags;

	spin_lock_irqsave(&sysrq_key_table_lock, flags);
504 505 506 507 508 509
	/*
	 * Raise the apparent loglevel to maximum so that the sysrq header
	 * is shown to provide the user with positive feedback.  We do not
	 * simply emit this at KERN_EMERG as that would change message
	 * routing in the consumers of /proc/kmsg.
	 */
Linus Torvalds's avatar
Linus Torvalds committed
510 511 512 513 514 515
	orig_log_level = console_loglevel;
	console_loglevel = 7;
	printk(KERN_INFO "SysRq : ");

        op_p = __sysrq_get_key_op(key);
        if (op_p) {
Andrew Morton's avatar
Andrew Morton committed
516 517 518 519
		/*
		 * Should we check for enabled operations (/proc/sysrq-trigger
		 * should not) and is the invoked operation enabled?
		 */
520
		if (!check_mask || sysrq_on_mask(op_p->enable_mask)) {
Andrew Morton's avatar
Andrew Morton committed
521
			printk("%s\n", op_p->action_msg);
Linus Torvalds's avatar
Linus Torvalds committed
522
			console_loglevel = orig_log_level;
523
			op_p->handler(key, tty);
Andrew Morton's avatar
Andrew Morton committed
524
		} else {
Linus Torvalds's avatar
Linus Torvalds committed
525
			printk("This sysrq operation is disabled.\n");
Andrew Morton's avatar
Andrew Morton committed
526
		}
Linus Torvalds's avatar
Linus Torvalds committed
527 528 529
	} else {
		printk("HELP : ");
		/* Only print the help msg once per handler */
Andrew Morton's avatar
Andrew Morton committed
530 531 532 533 534 535 536 537 538 539 540
		for (i = 0; i < ARRAY_SIZE(sysrq_key_table); i++) {
			if (sysrq_key_table[i]) {
				int j;

				for (j = 0; sysrq_key_table[i] !=
						sysrq_key_table[j]; j++)
					;
				if (j != i)
					continue;
				printk("%s ", sysrq_key_table[i]->help_msg);
			}
Linus Torvalds's avatar
Linus Torvalds committed
541
		}
Andrew Morton's avatar
Andrew Morton committed
542
		printk("\n");
Linus Torvalds's avatar
Linus Torvalds committed
543 544 545 546 547
		console_loglevel = orig_log_level;
	}
	spin_unlock_irqrestore(&sysrq_key_table_lock, flags);
}

548
void handle_sysrq(int key, struct tty_struct *tty)
Linus Torvalds's avatar
Linus Torvalds committed
549
{
550 551
	if (sysrq_on())
		__handle_sysrq(key, tty, 1);
Linus Torvalds's avatar
Linus Torvalds committed
552
}
Andrew Morton's avatar
Andrew Morton committed
553
EXPORT_SYMBOL(handle_sysrq);
Linus Torvalds's avatar
Linus Torvalds committed
554

555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722
#ifdef CONFIG_INPUT

/* Simple translation table for the SysRq keys */
static const unsigned char sysrq_xlate[KEY_MAX + 1] =
        "\000\0331234567890-=\177\t"                    /* 0x00 - 0x0f */
        "qwertyuiop[]\r\000as"                          /* 0x10 - 0x1f */
        "dfghjkl;'`\000\\zxcv"                          /* 0x20 - 0x2f */
        "bnm,./\000*\000 \000\201\202\203\204\205"      /* 0x30 - 0x3f */
        "\206\207\210\211\212\000\000789-456+1"         /* 0x40 - 0x4f */
        "230\177\000\000\213\214\000\000\000\000\000\000\000\000\000\000" /* 0x50 - 0x5f */
        "\r\000/";                                      /* 0x60 - 0x6f */

static bool sysrq_down;
static int sysrq_alt_use;
static int sysrq_alt;

static bool sysrq_filter(struct input_handle *handle, unsigned int type,
		         unsigned int code, int value)
{
	if (type != EV_KEY)
		goto out;

	switch (code) {

	case KEY_LEFTALT:
	case KEY_RIGHTALT:
		if (value)
			sysrq_alt = code;
		else if (sysrq_down && code == sysrq_alt_use)
			sysrq_down = false;
		break;

	case KEY_SYSRQ:
		if (value == 1 && sysrq_alt) {
			sysrq_down = true;
			sysrq_alt_use = sysrq_alt;
		}
		break;

	default:
		if (sysrq_down && value && value != 2)
			__handle_sysrq(sysrq_xlate[code], NULL, 1);
		break;
	}

out:
	return sysrq_down;
}

static int sysrq_connect(struct input_handler *handler,
			 struct input_dev *dev,
			 const struct input_device_id *id)
{
	struct input_handle *handle;
	int error;

	sysrq_down = false;
	sysrq_alt = 0;

	handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);
	if (!handle)
		return -ENOMEM;

	handle->dev = dev;
	handle->handler = handler;
	handle->name = "sysrq";

	error = input_register_handle(handle);
	if (error) {
		pr_err("Failed to register input sysrq handler, error %d\n",
			error);
		goto err_free;
	}

	error = input_open_device(handle);
	if (error) {
		pr_err("Failed to open input device, error %d\n", error);
		goto err_unregister;
	}

	return 0;

 err_unregister:
	input_unregister_handle(handle);
 err_free:
	kfree(handle);
	return error;
}

static void sysrq_disconnect(struct input_handle *handle)
{
	input_close_device(handle);
	input_unregister_handle(handle);
	kfree(handle);
}

/*
 * We are matching on KEY_LEFTALT insteard of KEY_SYSRQ because not all
 * keyboards have SysRq ikey predefined and so user may add it to keymap
 * later, but we expect all such keyboards to have left alt.
 */
static const struct input_device_id sysrq_ids[] = {
	{
		.flags = INPUT_DEVICE_ID_MATCH_EVBIT |
				INPUT_DEVICE_ID_MATCH_KEYBIT,
		.evbit = { BIT_MASK(EV_KEY) },
		.keybit = { BIT_MASK(KEY_LEFTALT) },
	},
	{ },
};

static struct input_handler sysrq_handler = {
	.filter		= sysrq_filter,
	.connect	= sysrq_connect,
	.disconnect	= sysrq_disconnect,
	.name		= "sysrq",
	.id_table	= sysrq_ids,
};

static bool sysrq_handler_registered;

static inline void sysrq_register_handler(void)
{
	int error;

	error = input_register_handler(&sysrq_handler);
	if (error)
		pr_err("Failed to register input handler, error %d", error);
	else
		sysrq_handler_registered = true;
}

static inline void sysrq_unregister_handler(void)
{
	if (sysrq_handler_registered) {
		input_unregister_handler(&sysrq_handler);
		sysrq_handler_registered = false;
	}
}

#else

static inline void sysrq_register_handler(void)
{
}

static inline void sysrq_unregister_handler(void)
{
}

#endif /* CONFIG_INPUT */

int sysrq_toggle_support(int enable_mask)
{
	bool was_enabled = sysrq_on();

	sysrq_enabled = enable_mask;

	if (was_enabled != sysrq_on()) {
		if (sysrq_on())
			sysrq_register_handler();
		else
			sysrq_unregister_handler();
	}

	return 0;
}

723
static int __sysrq_swap_key_ops(int key, struct sysrq_key_op *insert_op_p,
Andrew Morton's avatar
Andrew Morton committed
724 725
                                struct sysrq_key_op *remove_op_p)
{
Linus Torvalds's avatar
Linus Torvalds committed
726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743
	int retval;
	unsigned long flags;

	spin_lock_irqsave(&sysrq_key_table_lock, flags);
	if (__sysrq_get_key_op(key) == remove_op_p) {
		__sysrq_put_key_op(key, insert_op_p);
		retval = 0;
	} else {
		retval = -1;
	}
	spin_unlock_irqrestore(&sysrq_key_table_lock, flags);
	return retval;
}

int register_sysrq_key(int key, struct sysrq_key_op *op_p)
{
	return __sysrq_swap_key_ops(key, op_p, NULL);
}
Andrew Morton's avatar
Andrew Morton committed
744
EXPORT_SYMBOL(register_sysrq_key);
Linus Torvalds's avatar
Linus Torvalds committed
745 746 747 748 749 750

int unregister_sysrq_key(int key, struct sysrq_key_op *op_p)
{
	return __sysrq_swap_key_ops(key, NULL, op_p);
}
EXPORT_SYMBOL(unregister_sysrq_key);
751 752 753 754 755 756 757 758 759 760 761 762 763 764 765

#ifdef CONFIG_PROC_FS
/*
 * writing 'C' to /proc/sysrq-trigger is like sysrq-C
 */
static ssize_t write_sysrq_trigger(struct file *file, const char __user *buf,
				   size_t count, loff_t *ppos)
{
	if (count) {
		char c;

		if (get_user(c, buf))
			return -EFAULT;
		__handle_sysrq(c, NULL, 0);
	}
766

767 768 769 770 771 772 773
	return count;
}

static const struct file_operations proc_sysrq_trigger_operations = {
	.write		= write_sysrq_trigger,
};

774 775 776 777 778 779 780 781 782 783 784 785 786 787 788
static void sysrq_init_procfs(void)
{
	if (!proc_create("sysrq-trigger", S_IWUSR, NULL,
			 &proc_sysrq_trigger_operations))
		pr_err("Failed to register proc interface\n");
}

#else

static inline void sysrq_init_procfs(void)
{
}

#endif /* CONFIG_PROC_FS */

789 790
static int __init sysrq_init(void)
{
791 792 793 794 795
	sysrq_init_procfs();

	if (sysrq_on())
		sysrq_register_handler();

796 797 798
	return 0;
}
module_init(sysrq_init);