sysrq.c 23.7 KB
Newer Older
1
/*
L
Linus Torvalds 已提交
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
L
Linus Torvalds 已提交
13 14
 */

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

L
Linus Torvalds 已提交
17 18 19 20 21 22 23 24 25 26
#include <linux/sched.h>
#include <linux/interrupt.h>
#include <linux/mm.h>
#include <linux/fs.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>
27
#include <linux/proc_fs.h>
28
#include <linux/nmi.h>
L
Linus Torvalds 已提交
29
#include <linux/quotaops.h>
30
#include <linux/perf_event.h>
L
Linus Torvalds 已提交
31 32 33 34 35 36 37 38
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/suspend.h>
#include <linux/writeback.h>
#include <linux/swap.h>
#include <linux/spinlock.h>
#include <linux/vt_kern.h>
#include <linux/workqueue.h>
39
#include <linux/hrtimer.h>
40
#include <linux/oom.h>
41
#include <linux/slab.h>
42
#include <linux/input.h>
A
Al Viro 已提交
43
#include <linux/uaccess.h>
44
#include <linux/moduleparam.h>
L
Linus Torvalds 已提交
45 46

#include <asm/ptrace.h>
47
#include <asm/irq_regs.h>
L
Linus Torvalds 已提交
48 49

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

53
static bool sysrq_on(void)
54
{
55
	return sysrq_enabled || sysrq_always_enabled;
56 57 58 59 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);

L
Linus Torvalds 已提交
78

79
static void sysrq_handle_loglevel(int key)
L
Linus Torvalds 已提交
80 81
{
	int i;
82

L
Linus Torvalds 已提交
83 84 85 86
	i = key - '0';
	console_loglevel = 7;
	printk("Loglevel set to %d\n", i);
	console_loglevel = i;
A
Andrew Morton 已提交
87
}
L
Linus Torvalds 已提交
88 89
static struct sysrq_key_op sysrq_loglevel_op = {
	.handler	= sysrq_handle_loglevel,
90
	.help_msg	= "loglevel(0-9)",
L
Linus Torvalds 已提交
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)
L
Linus Torvalds 已提交
97
{
98 99
	struct work_struct *SAK_work = &vc_cons[fg_console].SAK_work;
	schedule_work(SAK_work);
L
Linus Torvalds 已提交
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,
};
A
Andrew Morton 已提交
107
#else
108
#define sysrq_SAK_op (*(struct sysrq_key_op *)NULL)
L
Linus Torvalds 已提交
109 110 111
#endif

#ifdef CONFIG_VT
112
static void sysrq_handle_unraw(int key)
L
Linus Torvalds 已提交
113
{
A
Alan Cox 已提交
114
	vt_reset_unicode(fg_console);
L
Linus Torvalds 已提交
115
}
A
Alan Cox 已提交
116

L
Linus Torvalds 已提交
117 118 119
static struct sysrq_key_op sysrq_unraw_op = {
	.handler	= sysrq_handle_unraw,
	.help_msg	= "unRaw",
B
Bill Nottingham 已提交
120
	.action_msg	= "Keyboard mode set to system default",
L
Linus Torvalds 已提交
121 122
	.enable_mask	= SYSRQ_ENABLE_KEYBOARD,
};
A
Andrew Morton 已提交
123
#else
124
#define sysrq_unraw_op (*(struct sysrq_key_op *)NULL)
L
Linus Torvalds 已提交
125 126
#endif /* CONFIG_VT */

127
static void sysrq_handle_crash(int key)
128
{
129
	char *killer = NULL;
130 131 132

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

142
static void sysrq_handle_reboot(int key)
L
Linus Torvalds 已提交
143
{
144
	lockdep_off();
L
Linus Torvalds 已提交
145
	local_irq_enable();
146
	emergency_restart();
L
Linus Torvalds 已提交
147 148 149 150 151 152 153 154
}
static struct sysrq_key_op sysrq_reboot_op = {
	.handler	= sysrq_handle_reboot,
	.help_msg	= "reBoot",
	.action_msg	= "Resetting",
	.enable_mask	= SYSRQ_ENABLE_BOOT,
};

155
static void sysrq_handle_sync(int key)
L
Linus Torvalds 已提交
156 157 158 159 160 161 162 163 164 165
{
	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,
};

166
static void sysrq_handle_show_timers(int key)
167 168 169 170 171 172 173
{
	sysrq_timer_list_show();
}

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

177
static void sysrq_handle_mountro(int key)
L
Linus Torvalds 已提交
178 179 180 181 182 183 184 185 186 187
{
	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,
};

188
#ifdef CONFIG_LOCKDEP
189
static void sysrq_handle_showlocks(int key)
190
{
191
	debug_show_all_locks();
192
}
193

194 195 196 197 198
static struct sysrq_key_op sysrq_showlocks_op = {
	.handler	= sysrq_handle_showlocks,
	.help_msg	= "show-all-locks(D)",
	.action_msg	= "Show Locks Held",
};
A
Andrew Morton 已提交
199
#else
200
#define sysrq_showlocks_op (*(struct sysrq_key_op *)NULL)
201
#endif
L
Linus Torvalds 已提交
202

203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221
#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)
{
222
	smp_call_function(showacpu, NULL, 0);
223 224 225 226
}

static DECLARE_WORK(sysrq_showallcpus, sysrq_showregs_othercpus);

227
static void sysrq_handle_showallcpus(int key)
228
{
229 230 231 232 233 234 235 236 237 238 239 240 241 242
	/*
	 * 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);
	}
243 244 245 246
}

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

253
static void sysrq_handle_showregs(int key)
L
Linus Torvalds 已提交
254
{
255 256 257
	struct pt_regs *regs = get_irq_regs();
	if (regs)
		show_regs(regs);
258
	perf_event_print_debug();
L
Linus Torvalds 已提交
259 260 261
}
static struct sysrq_key_op sysrq_showregs_op = {
	.handler	= sysrq_handle_showregs,
262
	.help_msg	= "show-registers(P)",
L
Linus Torvalds 已提交
263 264 265 266
	.action_msg	= "Show Regs",
	.enable_mask	= SYSRQ_ENABLE_DUMP,
};

267
static void sysrq_handle_showstate(int key)
L
Linus Torvalds 已提交
268 269 270 271 272
{
	show_state();
}
static struct sysrq_key_op sysrq_showstate_op = {
	.handler	= sysrq_handle_showstate,
273
	.help_msg	= "show-task-states(T)",
L
Linus Torvalds 已提交
274 275 276 277
	.action_msg	= "Show State",
	.enable_mask	= SYSRQ_ENABLE_DUMP,
};

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

289 290 291
#ifdef CONFIG_TRACING
#include <linux/ftrace.h>

292
static void sysrq_ftrace_dump(int key)
293
{
294
	ftrace_dump(DUMP_ALL);
295 296 297
}
static struct sysrq_key_op sysrq_ftrace_dump_op = {
	.handler	= sysrq_ftrace_dump,
298
	.help_msg	= "dump-ftrace-buffer(Z)",
299 300 301 302
	.action_msg	= "Dump ftrace buffer",
	.enable_mask	= SYSRQ_ENABLE_DUMP,
};
#else
303
#define sysrq_ftrace_dump_op (*(struct sysrq_key_op *)NULL)
304
#endif
305

306
static void sysrq_handle_showmem(int key)
L
Linus Torvalds 已提交
307
{
308
	show_mem(0);
L
Linus Torvalds 已提交
309 310 311
}
static struct sysrq_key_op sysrq_showmem_op = {
	.handler	= sysrq_handle_showmem,
312
	.help_msg	= "show-memory-usage(M)",
L
Linus Torvalds 已提交
313 314 315 316
	.action_msg	= "Show Memory",
	.enable_mask	= SYSRQ_ENABLE_DUMP,
};

A
Andrew Morton 已提交
317 318 319
/*
 * Signal sysrq helper function.  Sends a signal to all user processes.
 */
L
Linus Torvalds 已提交
320 321 322 323
static void send_sig_all(int sig)
{
	struct task_struct *p;

324
	read_lock(&tasklist_lock);
L
Linus Torvalds 已提交
325
	for_each_process(p) {
326 327 328 329 330
		if (p->flags & PF_KTHREAD)
			continue;
		if (is_global_init(p))
			continue;

331
		do_send_sig_info(sig, SEND_SIG_FORCED, p, true);
L
Linus Torvalds 已提交
332
	}
333
	read_unlock(&tasklist_lock);
L
Linus Torvalds 已提交
334 335
}

336
static void sysrq_handle_term(int key)
L
Linus Torvalds 已提交
337 338 339 340 341 342
{
	send_sig_all(SIGTERM);
	console_loglevel = 8;
}
static struct sysrq_key_op sysrq_term_op = {
	.handler	= sysrq_handle_term,
343
	.help_msg	= "terminate-all-tasks(E)",
L
Linus Torvalds 已提交
344 345 346 347
	.action_msg	= "Terminate All Tasks",
	.enable_mask	= SYSRQ_ENABLE_SIGNAL,
};

348
static void moom_callback(struct work_struct *ignored)
L
Linus Torvalds 已提交
349
{
350
	out_of_memory(node_zonelist(0, GFP_KERNEL), GFP_KERNEL, 0, NULL, true);
L
Linus Torvalds 已提交
351 352
}

353
static DECLARE_WORK(moom_work, moom_callback);
L
Linus Torvalds 已提交
354

355
static void sysrq_handle_moom(int key)
L
Linus Torvalds 已提交
356 357 358 359 360
{
	schedule_work(&moom_work);
}
static struct sysrq_key_op sysrq_moom_op = {
	.handler	= sysrq_handle_moom,
361
	.help_msg	= "memory-full-oom-kill(F)",
L
Linus Torvalds 已提交
362
	.action_msg	= "Manual OOM execution",
363
	.enable_mask	= SYSRQ_ENABLE_SIGNAL,
L
Linus Torvalds 已提交
364 365
};

366
#ifdef CONFIG_BLOCK
367
static void sysrq_handle_thaw(int key)
368 369 370 371 372 373 374 375 376 377 378
{
	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

379
static void sysrq_handle_kill(int key)
L
Linus Torvalds 已提交
380 381 382 383 384 385
{
	send_sig_all(SIGKILL);
	console_loglevel = 8;
}
static struct sysrq_key_op sysrq_kill_op = {
	.handler	= sysrq_handle_kill,
386
	.help_msg	= "kill-all-tasks(I)",
L
Linus Torvalds 已提交
387 388 389 390
	.action_msg	= "Kill All Tasks",
	.enable_mask	= SYSRQ_ENABLE_SIGNAL,
};

391
static void sysrq_handle_unrt(int key)
L
Linus Torvalds 已提交
392 393 394 395 396
{
	normalize_rt_tasks();
}
static struct sysrq_key_op sysrq_unrt_op = {
	.handler	= sysrq_handle_unrt,
397
	.help_msg	= "nice-all-RT-tasks(N)",
L
Linus Torvalds 已提交
398 399 400 401 402 403
	.action_msg	= "Nice All RT Tasks",
	.enable_mask	= SYSRQ_ENABLE_RTNICE,
};

/* Key Operations table and lock */
static DEFINE_SPINLOCK(sysrq_key_table_lock);
A
Andrew Morton 已提交
404 405 406 407 408 409 410 411 412 413 414 415 416 417

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 */

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

/* key2index calculation, -1 on invalid index */
A
Andrew Morton 已提交
464 465
static int sysrq_key_table_key2index(int key)
{
L
Linus Torvalds 已提交
466
	int retval;
A
Andrew Morton 已提交
467 468

	if ((key >= '0') && (key <= '9'))
L
Linus Torvalds 已提交
469
		retval = key - '0';
A
Andrew Morton 已提交
470
	else if ((key >= 'a') && (key <= 'z'))
L
Linus Torvalds 已提交
471
		retval = key + 10 - 'a';
A
Andrew Morton 已提交
472
	else
L
Linus Torvalds 已提交
473 474 475 476 477 478 479
		retval = -1;
	return retval;
}

/*
 * get and put functions for the table, exposed to modules.
 */
A
Andrew Morton 已提交
480 481 482
struct sysrq_key_op *__sysrq_get_key_op(int key)
{
        struct sysrq_key_op *op_p = NULL;
L
Linus Torvalds 已提交
483
        int i;
A
Andrew Morton 已提交
484

L
Linus Torvalds 已提交
485
	i = sysrq_key_table_key2index(key);
A
Andrew Morton 已提交
486 487
	if (i != -1)
	        op_p = sysrq_key_table[i];
488

L
Linus Torvalds 已提交
489 490 491
        return op_p;
}

A
Andrew Morton 已提交
492 493 494
static void __sysrq_put_key_op(int key, struct sysrq_key_op *op_p)
{
        int i = sysrq_key_table_key2index(key);
L
Linus Torvalds 已提交
495 496 497 498 499

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

500
void __handle_sysrq(int key, bool check_mask)
L
Linus Torvalds 已提交
501 502 503
{
	struct sysrq_key_op *op_p;
	int orig_log_level;
A
Andrew Morton 已提交
504
	int i;
L
Linus Torvalds 已提交
505 506 507
	unsigned long flags;

	spin_lock_irqsave(&sysrq_key_table_lock, flags);
508 509 510 511 512 513
	/*
	 * 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.
	 */
L
Linus Torvalds 已提交
514 515 516 517 518 519
	orig_log_level = console_loglevel;
	console_loglevel = 7;
	printk(KERN_INFO "SysRq : ");

        op_p = __sysrq_get_key_op(key);
        if (op_p) {
A
Andrew Morton 已提交
520 521 522 523
		/*
		 * Should we check for enabled operations (/proc/sysrq-trigger
		 * should not) and is the invoked operation enabled?
		 */
524
		if (!check_mask || sysrq_on_mask(op_p->enable_mask)) {
A
Andrew Morton 已提交
525
			printk("%s\n", op_p->action_msg);
L
Linus Torvalds 已提交
526
			console_loglevel = orig_log_level;
527
			op_p->handler(key);
A
Andrew Morton 已提交
528
		} else {
L
Linus Torvalds 已提交
529
			printk("This sysrq operation is disabled.\n");
A
Andrew Morton 已提交
530
		}
L
Linus Torvalds 已提交
531 532 533
	} else {
		printk("HELP : ");
		/* Only print the help msg once per handler */
A
Andrew Morton 已提交
534 535 536 537 538 539 540 541 542 543 544
		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);
			}
L
Linus Torvalds 已提交
545
		}
A
Andrew Morton 已提交
546
		printk("\n");
L
Linus Torvalds 已提交
547 548 549 550 551
		console_loglevel = orig_log_level;
	}
	spin_unlock_irqrestore(&sysrq_key_table_lock, flags);
}

552
void handle_sysrq(int key)
L
Linus Torvalds 已提交
553
{
554
	if (sysrq_on())
555
		__handle_sysrq(key, true);
L
Linus Torvalds 已提交
556
}
A
Andrew Morton 已提交
557
EXPORT_SYMBOL(handle_sysrq);
L
Linus Torvalds 已提交
558

559 560 561
#ifdef CONFIG_INPUT

/* Simple translation table for the SysRq keys */
562
static const unsigned char sysrq_xlate[KEY_CNT] =
563 564 565 566 567 568 569 570
        "\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 */

571 572 573 574 575 576 577 578
struct sysrq_state {
	struct input_handle handle;
	struct work_struct reinject_work;
	unsigned long key_down[BITS_TO_LONGS(KEY_CNT)];
	unsigned int alt;
	unsigned int alt_use;
	bool active;
	bool need_reinject;
579
	bool reinjecting;
580 581 582 583 584 585 586

	/* reset sequence handling */
	bool reset_canceled;
	unsigned long reset_keybit[BITS_TO_LONGS(KEY_CNT)];
	int reset_seq_len;
	int reset_seq_cnt;
	int reset_seq_version;
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
#define SYSRQ_KEY_RESET_MAX	20 /* Should be plenty */
static unsigned short sysrq_reset_seq[SYSRQ_KEY_RESET_MAX];
static unsigned int sysrq_reset_seq_len;
static unsigned int sysrq_reset_seq_version = 1;

static void sysrq_parse_reset_sequence(struct sysrq_state *state)
{
	int i;
	unsigned short key;

	state->reset_seq_cnt = 0;

	for (i = 0; i < sysrq_reset_seq_len; i++) {
		key = sysrq_reset_seq[i];

		if (key == KEY_RESERVED || key > KEY_MAX)
			break;

		__set_bit(key, state->reset_keybit);
		state->reset_seq_len++;

		if (test_bit(key, state->key_down))
			state->reset_seq_cnt++;
	}

	/* Disable reset until old keys are not released */
	state->reset_canceled = state->reset_seq_cnt != 0;

	state->reset_seq_version = sysrq_reset_seq_version;
}

static bool sysrq_detect_reset_sequence(struct sysrq_state *state,
					unsigned int code, int value)
{
	if (!test_bit(code, state->reset_keybit)) {
		/*
		 * Pressing any key _not_ in reset sequence cancels
		 * the reset sequence.
		 */
		if (value && state->reset_seq_cnt)
			state->reset_canceled = true;
	} else if (value == 0) {
		/* key release */
		if (--state->reset_seq_cnt == 0)
			state->reset_canceled = false;
	} else if (value == 1) {
		/* key press, not autorepeat */
		if (++state->reset_seq_cnt == state->reset_seq_len &&
		    !state->reset_canceled) {
			return true;
		}
	}

	return false;
}

645 646 647 648 649 650 651 652
static void sysrq_reinject_alt_sysrq(struct work_struct *work)
{
	struct sysrq_state *sysrq =
			container_of(work, struct sysrq_state, reinject_work);
	struct input_handle *handle = &sysrq->handle;
	unsigned int alt_code = sysrq->alt_use;

	if (sysrq->need_reinject) {
653 654 655 656
		/* we do not want the assignment to be reordered */
		sysrq->reinjecting = true;
		mb();

657 658 659 660 661 662 663 664
		/* Simulate press and release of Alt + SysRq */
		input_inject_event(handle, EV_KEY, alt_code, 1);
		input_inject_event(handle, EV_KEY, KEY_SYSRQ, 1);
		input_inject_event(handle, EV_SYN, SYN_REPORT, 1);

		input_inject_event(handle, EV_KEY, KEY_SYSRQ, 0);
		input_inject_event(handle, EV_KEY, alt_code, 0);
		input_inject_event(handle, EV_SYN, SYN_REPORT, 1);
665 666 667

		mb();
		sysrq->reinjecting = false;
668 669
	}
}
670

671 672
static bool sysrq_handle_keypress(struct sysrq_state *sysrq,
				  unsigned int code, int value)
673
{
674
	bool was_active = sysrq->active;
675 676
	bool suppress;

677
	switch (code) {
678

679 680 681 682 683 684
	case KEY_LEFTALT:
	case KEY_RIGHTALT:
		if (!value) {
			/* One of ALTs is being released */
			if (sysrq->active && code == sysrq->alt_use)
				sysrq->active = false;
685

686 687 688 689 690 691
			sysrq->alt = KEY_RESERVED;

		} else if (value != 2) {
			sysrq->alt = code;
			sysrq->need_reinject = false;
		}
692
		break;
693

694 695 696 697 698 699 700 701 702 703
	case KEY_SYSRQ:
		if (value == 1 && sysrq->alt != KEY_RESERVED) {
			sysrq->active = true;
			sysrq->alt_use = sysrq->alt;
			/*
			 * If nothing else will be pressed we'll need
			 * to re-inject Alt-SysRq keysroke.
			 */
			sysrq->need_reinject = true;
		}
704

705 706 707 708 709 710 711 712 713 714
		/*
		 * Pretend that sysrq was never pressed at all. This
		 * is needed to properly handle KGDB which will try
		 * to release all keys after exiting debugger. If we
		 * do not clear key bit it KGDB will end up sending
		 * release events for Alt and SysRq, potentially
		 * triggering print screen function.
		 */
		if (sysrq->active)
			clear_bit(KEY_SYSRQ, sysrq->handle.dev->key);
715

716
		break;
717

718 719 720 721 722 723 724
	default:
		if (sysrq->active && value && value != 2) {
			sysrq->need_reinject = false;
			__handle_sysrq(sysrq_xlate[code], true);
		}
		break;
	}
725

726
	suppress = sysrq->active;
727

728
	if (!sysrq->active) {
729

730 731 732 733 734
		/*
		 * See if reset sequence has changed since the last time.
		 */
		if (sysrq->reset_seq_version != sysrq_reset_seq_version)
			sysrq_parse_reset_sequence(sysrq);
735

736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751
		/*
		 * If we are not suppressing key presses keep track of
		 * keyboard state so we can release keys that have been
		 * pressed before entering SysRq mode.
		 */
		if (value)
			set_bit(code, sysrq->key_down);
		else
			clear_bit(code, sysrq->key_down);

		if (was_active)
			schedule_work(&sysrq->reinject_work);

		if (sysrq_detect_reset_sequence(sysrq, code, value)) {
			/* Force emergency reboot */
			__handle_sysrq(sysrq_xlate[KEY_B], false);
752
		}
753

754 755 756 757 758 759 760
	} else if (value == 0 && test_and_clear_bit(code, sysrq->key_down)) {
		/*
		 * Pass on release events for keys that was pressed before
		 * entering SysRq mode.
		 */
		suppress = false;
	}
761

762 763
	return suppress;
}
764

765 766 767 768 769
static bool sysrq_filter(struct input_handle *handle,
			 unsigned int type, unsigned int code, int value)
{
	struct sysrq_state *sysrq = handle->private;
	bool suppress;
770

771 772 773 774 775 776 777 778 779 780 781 782 783 784 785
	/*
	 * Do not filter anything if we are in the process of re-injecting
	 * Alt+SysRq combination.
	 */
	if (sysrq->reinjecting)
		return false;

	switch (type) {

	case EV_SYN:
		suppress = false;
		break;

	case EV_KEY:
		suppress = sysrq_handle_keypress(sysrq, code, value);
786 787 788
		break;

	default:
789
		suppress = sysrq->active;
790 791 792
		break;
	}

793
	return suppress;
794 795 796 797 798 799
}

static int sysrq_connect(struct input_handler *handler,
			 struct input_dev *dev,
			 const struct input_device_id *id)
{
800
	struct sysrq_state *sysrq;
801 802
	int error;

803 804
	sysrq = kzalloc(sizeof(struct sysrq_state), GFP_KERNEL);
	if (!sysrq)
805 806
		return -ENOMEM;

807 808 809 810 811 812
	INIT_WORK(&sysrq->reinject_work, sysrq_reinject_alt_sysrq);

	sysrq->handle.dev = dev;
	sysrq->handle.handler = handler;
	sysrq->handle.name = "sysrq";
	sysrq->handle.private = sysrq;
813

814
	error = input_register_handle(&sysrq->handle);
815 816 817 818 819 820
	if (error) {
		pr_err("Failed to register input sysrq handler, error %d\n",
			error);
		goto err_free;
	}

821
	error = input_open_device(&sysrq->handle);
822 823 824 825 826 827 828 829
	if (error) {
		pr_err("Failed to open input device, error %d\n", error);
		goto err_unregister;
	}

	return 0;

 err_unregister:
830
	input_unregister_handle(&sysrq->handle);
831
 err_free:
832
	kfree(sysrq);
833 834 835 836 837
	return error;
}

static void sysrq_disconnect(struct input_handle *handle)
{
838 839
	struct sysrq_state *sysrq = handle->private;

840
	input_close_device(handle);
841
	cancel_work_sync(&sysrq->reinject_work);
842
	input_unregister_handle(handle);
843
	kfree(sysrq);
844 845 846
}

/*
847 848
 * We are matching on KEY_LEFTALT instead of KEY_SYSRQ because not all
 * keyboards have SysRq key predefined and so user may add it to keymap
849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872
 * 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)
{
873 874
	extern unsigned short platform_sysrq_reset_seq[] __weak;
	unsigned short key;
875
	int error;
876 877 878 879 880 881 882 883 884 885 886
	int i;

	if (platform_sysrq_reset_seq) {
		for (i = 0; i < ARRAY_SIZE(sysrq_reset_seq); i++) {
			key = platform_sysrq_reset_seq[i];
			if (key == KEY_RESERVED || key > KEY_MAX)
				break;

			sysrq_reset_seq[sysrq_reset_seq_len++] = key;
		}
	}
887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902

	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;
	}
}

903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932
static int sysrq_reset_seq_param_set(const char *buffer,
				     const struct kernel_param *kp)
{
	unsigned long val;
	int error;

	error = strict_strtoul(buffer, 0, &val);
	if (error < 0)
		return error;

	if (val > KEY_MAX)
		return -EINVAL;

	*((unsigned short *)kp->arg) = val;
	sysrq_reset_seq_version++;

	return 0;
}

static struct kernel_param_ops param_ops_sysrq_reset_seq = {
	.get	= param_get_ushort,
	.set	= sysrq_reset_seq_param_set,
};

#define param_check_sysrq_reset_seq(name, p)	\
	__param_check(name, p, unsigned short)

module_param_array_named(reset_seq, sysrq_reset_seq, sysrq_reset_seq,
			 &sysrq_reset_seq_len, 0644);

933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960
#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;
}

961
static int __sysrq_swap_key_ops(int key, struct sysrq_key_op *insert_op_p,
A
Andrew Morton 已提交
962 963
                                struct sysrq_key_op *remove_op_p)
{
L
Linus Torvalds 已提交
964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981
	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);
}
A
Andrew Morton 已提交
982
EXPORT_SYMBOL(register_sysrq_key);
L
Linus Torvalds 已提交
983 984 985 986 987 988

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);
989 990 991 992 993 994 995 996 997 998 999 1000 1001

#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;
1002
		__handle_sysrq(c, false);
1003
	}
1004

1005 1006 1007 1008 1009
	return count;
}

static const struct file_operations proc_sysrq_trigger_operations = {
	.write		= write_sysrq_trigger,
1010
	.llseek		= noop_llseek,
1011 1012
};

1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027
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 */

1028 1029
static int __init sysrq_init(void)
{
1030 1031 1032 1033 1034
	sysrq_init_procfs();

	if (sysrq_on())
		sysrq_register_handler();

1035 1036 1037
	return 0;
}
module_init(sysrq_init);
新手
引导
客服 返回
顶部