1 /* -*- linux-c -*-
2 *
3 * $Id: sysrq.c,v 1.15 1998/08/23 14:56:41 mj Exp $
4 *
5 * Linux Magic System Request Key Hacks
6 *
7 * (c) 1997 Martin Mares <mj@atrey.karlin.mff.cuni.cz>
8 * based on ideas by Pavel Machek <pavel@atrey.karlin.mff.cuni.cz>
9 *
10 * (c) 2000 Crutcher Dunnavant <crutcher+kernel@datastacks.com>
11 * overhauled to use key registration
12 * based upon discusions in irc://irc.openprojects.net/#kernelnewbies
13 */
14
15 #include <linux/sched.h>
16 #include <linux/interrupt.h>
17 #include <linux/mm.h>
18 #include <linux/fs.h>
19 #include <linux/tty.h>
20 #include <linux/mount.h>
21 #include <linux/kdev_t.h>
22 #include <linux/major.h>
23 #include <linux/reboot.h>
24 #include <linux/sysrq.h>
25 #include <linux/kbd_kern.h>
26 #include <linux/quotaops.h>
27 #include <linux/kernel.h>
28 #include <linux/module.h>
29 #include <linux/suspend.h>
30 #include <linux/writeback.h>
31 #include <linux/buffer_head.h> /* for fsync_bdev() */
32 #include <linux/swap.h>
33 #include <linux/spinlock.h>
34 #include <linux/vt_kern.h>
35 #include <linux/workqueue.h>
36 #include <linux/kexec.h>
37 #include <linux/irq.h>
38 #include <linux/hrtimer.h>
39 #include <linux/oom.h>
40
41 #include <asm/ptrace.h>
42 #include <asm/irq_regs.h>
43
44 /* Whether we react on sysrq keys or just ignore them */
45 int __read_mostly __sysrq_enabled = 1;
46
47 static int __read_mostly sysrq_always_enabled;
48
49 int sysrq_on(void)
50 {
51 return __sysrq_enabled || sysrq_always_enabled;
52 }
53
54 /*
55 * A value of 1 means 'all', other nonzero values are an op mask:
56 */
57 static inline int sysrq_on_mask(int mask)
58 {
59 return sysrq_always_enabled || __sysrq_enabled == 1 ||
60 (__sysrq_enabled & mask);
61 }
62
63 static int __init sysrq_always_enabled_setup(char *str)
64 {
65 sysrq_always_enabled = 1;
66 printk(KERN_INFO "debug: sysrq always enabled.\n");
67
68 return 1;
69 }
70
71 __setup("sysrq_always_enabled", sysrq_always_enabled_setup);
72
73
74 static void sysrq_handle_loglevel(int key, struct tty_struct *tty)
75 {
76 int i;
77 i = key - '';
78 console_loglevel = 7;
79 printk("Loglevel set to %d\n", i);
80 console_loglevel = i;
81 }
82 static struct sysrq_key_op sysrq_loglevel_op = {
83 .handler = sysrq_handle_loglevel,
84 .help_msg = "loglevel0-8",
85 .action_msg = "Changing Loglevel",
86 .enable_mask = SYSRQ_ENABLE_LOG,
87 };
88
89 #ifdef CONFIG_VT
90 static void sysrq_handle_SAK(int key, struct tty_struct *tty)
91 {
92 struct work_struct *SAK_work = &vc_cons[fg_console].SAK_work;
93 schedule_work(SAK_work);
94 }
95 static struct sysrq_key_op sysrq_SAK_op = {
96 .handler = sysrq_handle_SAK,
97 .help_msg = "saK",
98 .action_msg = "SAK",
99 .enable_mask = SYSRQ_ENABLE_KEYBOARD,
100 };
101 #else
102 #define sysrq_SAK_op (*(struct sysrq_key_op *)0)
103 #endif
104
105 #ifdef CONFIG_VT
106 static void sysrq_handle_unraw(int key, struct tty_struct *tty)
107 {
108 struct kbd_struct *kbd = &kbd_table[fg_console];
109
110 if (kbd)
111 kbd->kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE;
112 }
113 static struct sysrq_key_op sysrq_unraw_op = {
114 .handler = sysrq_handle_unraw,
115 .help_msg = "unRaw",
116 .action_msg = "Keyboard mode set to system default",
117 .enable_mask = SYSRQ_ENABLE_KEYBOARD,
118 };
119 #else
120 #define sysrq_unraw_op (*(struct sysrq_key_op *)0)
121 #endif /* CONFIG_VT */
122
123 #ifdef CONFIG_KEXEC
124 static void sysrq_handle_crashdump(int key, struct tty_struct *tty)
125 {
126 crash_kexec(get_irq_regs());
127 }
128 static struct sysrq_key_op sysrq_crashdump_op = {
129 .handler = sysrq_handle_crashdump,
130 .help_msg = "Crashdump",
131 .action_msg = "Trigger a crashdump",
132 .enable_mask = SYSRQ_ENABLE_DUMP,
133 };
134 #else
135 #define sysrq_crashdump_op (*(struct sysrq_key_op *)0)
136 #endif
137
138 static void sysrq_handle_reboot(int key, struct tty_struct *tty)
139 {
140 lockdep_off();
141 local_irq_enable();
142 emergency_restart();
143 }
144 static struct sysrq_key_op sysrq_reboot_op = {
145 .handler = sysrq_handle_reboot,
146 .help_msg = "reBoot",
147 .action_msg = "Resetting",
148 .enable_mask = SYSRQ_ENABLE_BOOT,
149 };
150
151 static void sysrq_handle_sync(int key, struct tty_struct *tty)
152 {
153 emergency_sync();
154 }
155 static struct sysrq_key_op sysrq_sync_op = {
156 .handler = sysrq_handle_sync,
157 .help_msg = "Sync",
158 .action_msg = "Emergency Sync",
159 .enable_mask = SYSRQ_ENABLE_SYNC,
160 };
161
162 static void sysrq_handle_show_timers(int key, struct tty_struct *tty)
163 {
164 sysrq_timer_list_show();
165 }
166
167 static struct sysrq_key_op sysrq_show_timers_op = {
168 .handler = sysrq_handle_show_timers,
169 .help_msg = "show-all-timers(Q)",
170 .action_msg = "Show Pending Timers",
171 };
172
173 static void sysrq_handle_mountro(int key, struct tty_struct *tty)
174 {
175 emergency_remount();
176 }
177 static struct sysrq_key_op sysrq_mountro_op = {
178 .handler = sysrq_handle_mountro,
179 .help_msg = "Unmount",
180 .action_msg = "Emergency Remount R/O",
181 .enable_mask = SYSRQ_ENABLE_REMOUNT,
182 };
183
184 #ifdef CONFIG_LOCKDEP
185 static void sysrq_handle_showlocks(int key, struct tty_struct *tty)
186 {
187 debug_show_all_locks();
188 }
189
190 static struct sysrq_key_op sysrq_showlocks_op = {
191 .handler = sysrq_handle_showlocks,
192 .help_msg = "show-all-locks(D)",
193 .action_msg = "Show Locks Held",
194 };
195 #else
196 #define sysrq_showlocks_op (*(struct sysrq_key_op *)0)
197 #endif
198
199 static void sysrq_handle_showregs(int key, struct tty_struct *tty)
200 {
201 struct pt_regs *regs = get_irq_regs();
202 if (regs)
203 show_regs(regs);
204 }
205 static struct sysrq_key_op sysrq_showregs_op = {
206 .handler = sysrq_handle_showregs,
207 .help_msg = "showPc",
208 .action_msg = "Show Regs",
209 .enable_mask = SYSRQ_ENABLE_DUMP,
210 };
211
212 #if defined(__i386__) || defined(__x86_64__)
213
214 static void sysrq_handle_showallregs(int key, struct tty_struct *tty)
215 {
216 nmi_show_all_regs();
217 }
218
219 static struct sysrq_key_op sysrq_showallregs_op = {
220 .handler = sysrq_handle_showallregs,
221 .help_msg = "showalLcpupc",
222 .action_msg = "Show Regs On All CPUs",
223 };
224 #else
225 #define sysrq_showallregs_op (*(struct sysrq_key_op *)0)
226 #endif
227
228 static void sysrq_handle_showstate(int key, struct tty_struct *tty)
229 {
230 show_state();
231 }
232 static struct sysrq_key_op sysrq_showstate_op = {
233 .handler = sysrq_handle_showstate,
234 .help_msg = "showTasks",
235 .action_msg = "Show State",
236 .enable_mask = SYSRQ_ENABLE_DUMP,
237 };
238
239 static void sysrq_handle_showstate_blocked(int key, struct tty_struct *tty)
240 {
241 show_state_filter(TASK_UNINTERRUPTIBLE);
242 }
243 static struct sysrq_key_op sysrq_showstate_blocked_op = {
244 .handler = sysrq_handle_showstate_blocked,
245 .help_msg = "shoW-blocked-tasks",
246 .action_msg = "Show Blocked State",
247 .enable_mask = SYSRQ_ENABLE_DUMP,
248 };
249
250
251 static void sysrq_handle_showmem(int key, struct tty_struct *tty)
252 {
253 show_mem();
254 }
255 static struct sysrq_key_op sysrq_showmem_op = {
256 .handler = sysrq_handle_showmem,
257 .help_msg = "showMem",
258 .action_msg = "Show Memory",
259 .enable_mask = SYSRQ_ENABLE_DUMP,
260 };
261
262 /*
263 * Signal sysrq helper function. Sends a signal to all user processes.
264 */
265 static void send_sig_all(int sig)
266 {
267 struct task_struct *p;
268
269 for_each_process(p) {
270 if (p->mm && !is_global_init(p))
271 /* Not swapper, init nor kernel thread */
272 force_sig(sig, p);
273 }
274 }
275
276 static void sysrq_handle_term(int key, struct tty_struct *tty)
277 {
278 send_sig_all(SIGTERM);
279 console_loglevel = 8;
280 }
281 static struct sysrq_key_op sysrq_term_op = {
282 .handler = sysrq_handle_term,
283 .help_msg = "tErm",
284 .action_msg = "Terminate All Tasks",
285 .enable_mask = SYSRQ_ENABLE_SIGNAL,
286 };
287
288 static void moom_callback(struct work_struct *ignored)
289 {
290 out_of_memory(&NODE_DATA(0)->node_zonelists[ZONE_NORMAL],
291 GFP_KERNEL, 0);
292 }
293
294 static DECLARE_WORK(moom_work, moom_callback);
295
296 static void sysrq_handle_moom(int key, struct tty_struct *tty)
297 {
298 schedule_work(&moom_work);
299 }
300 static struct sysrq_key_op sysrq_moom_op = {
301 .handler = sysrq_handle_moom,
302 .help_msg = "Full",
303 .action_msg = "Manual OOM execution",
304 };
305
306 static void sysrq_handle_kill(int key, struct tty_struct *tty)
307 {
308 send_sig_all(SIGKILL);
309 console_loglevel = 8;
310 }
311 static struct sysrq_key_op sysrq_kill_op = {
312 .handler = sysrq_handle_kill,
313 .help_msg = "kIll",
314 .action_msg = "Kill All Tasks",
315 .enable_mask = SYSRQ_ENABLE_SIGNAL,
316 };
317
318 static void sysrq_handle_unrt(int key, struct tty_struct *tty)
319 {
320 normalize_rt_tasks();
321 }
322 static struct sysrq_key_op sysrq_unrt_op = {
323 .handler = sysrq_handle_unrt,
324 .help_msg = "Nice",
325 .action_msg = "Nice All RT Tasks",
326 .enable_mask = SYSRQ_ENABLE_RTNICE,
327 };
328
329 /* Key Operations table and lock */
330 static DEFINE_SPINLOCK(sysrq_key_table_lock);
331
332 static struct sysrq_key_op *sysrq_key_table[36] = {
333 &sysrq_loglevel_op, /* 0 */
334 &sysrq_loglevel_op, /* 1 */
335 &sysrq_loglevel_op, /* 2 */
336 &sysrq_loglevel_op, /* 3 */
337 &sysrq_loglevel_op, /* 4 */
338 &sysrq_loglevel_op, /* 5 */
339 &sysrq_loglevel_op, /* 6 */
340 &sysrq_loglevel_op, /* 7 */
341 &sysrq_loglevel_op, /* 8 */
342 &sysrq_loglevel_op, /* 9 */
343
344 /*
345 * a: Don't use for system provided sysrqs, it is handled specially on
346 * sparc and will never arrive.
347 */
348 NULL, /* a */
349 &sysrq_reboot_op, /* b */
350 &sysrq_crashdump_op, /* c & ibm_emac driver debug */
351 &sysrq_showlocks_op, /* d */
352 &sysrq_term_op, /* e */
353 &sysrq_moom_op, /* f */
354 /* g: May be registered by ppc for kgdb */
355 NULL, /* g */
356 NULL, /* h */
357 &sysrq_kill_op, /* i */
358 NULL, /* j */
359 &sysrq_SAK_op, /* k */
360 &sysrq_showallregs_op, /* l */
361 &sysrq_showmem_op, /* m */
362 &sysrq_unrt_op, /* n */
363 /* o: This will often be registered as 'Off' at init time */
364 NULL, /* o */
365 &sysrq_showregs_op, /* p */
366 &sysrq_show_timers_op, /* q */
367 &sysrq_unraw_op, /* r */
368 &sysrq_sync_op, /* s */
369 &sysrq_showstate_op, /* t */
370 &sysrq_mountro_op, /* u */
371 /* v: May be registered at init time by SMP VOYAGER */
372 NULL, /* v */
373 &sysrq_showstate_blocked_op, /* w */
374 /* x: May be registered on ppc/powerpc for xmon */
375 NULL, /* x */
376 NULL, /* y */
377 NULL /* z */
378 };
379
380 /* key2index calculation, -1 on invalid index */
381 static int sysrq_key_table_key2index(int key)
382 {
383 int retval;
384
385 if ((key >= '') && (key <= '9'))
386 retval = key - '';
387 else if ((key >= 'a') && (key <= 'z'))
388 retval = key + 10 - 'a';
389 else
390 retval = -1;
391 return retval;
392 }
393
394 /*
395 * get and put functions for the table, exposed to modules.
396 */
397 struct sysrq_key_op *__sysrq_get_key_op(int key)
398 {
399 struct sysrq_key_op *op_p = NULL;
400 int i;
401
402 i = sysrq_key_table_key2index(key);
403 if (i != -1)
404 op_p = sysrq_key_table[i];
405 return op_p;
406 }
407
408 static void __sysrq_put_key_op(int key, struct sysrq_key_op *op_p)
409 {
410 int i = sysrq_key_table_key2index(key);
411
412 if (i != -1)
413 sysrq_key_table[i] = op_p;
414 }
415
416 /*
417 * This is the non-locking version of handle_sysrq. It must/can only be called
418 * by sysrq key handlers, as they are inside of the lock
419 */
420 void __handle_sysrq(int key, struct tty_struct *tty, int check_mask)
421 {
422 struct sysrq_key_op *op_p;
423 int orig_log_level;
424 int i;
425 unsigned long flags;
426
427 spin_lock_irqsave(&sysrq_key_table_lock, flags);
428 orig_log_level = console_loglevel;
429 console_loglevel = 7;
430 printk(KERN_INFO "SysRq : ");
431
432 op_p = __sysrq_get_key_op(key);
433 if (op_p) {
434 /*
435 * Should we check for enabled operations (/proc/sysrq-trigger
436 * should not) and is the invoked operation enabled?
437 */
438 if (!check_mask || sysrq_on_mask(op_p->enable_mask)) {
439 printk("%s\n", op_p->action_msg);
440 console_loglevel = orig_log_level;
441 op_p->handler(key, tty);
442 } else {
443 printk("This sysrq operation is disabled.\n");
444 }
445 } else {
446 printk("HELP : ");
447 /* Only print the help msg once per handler */
448 for (i = 0; i < ARRAY_SIZE(sysrq_key_table); i++) {
449 if (sysrq_key_table[i]) {
450 int j;
451
452 for (j = 0; sysrq_key_table[i] !=
453 sysrq_key_table[j]; j++)
454 ;
455 if (j != i)
456 continue;
457 printk("%s ", sysrq_key_table[i]->help_msg);
458 }
459 }
460 printk("\n");
461 console_loglevel = orig_log_level;
462 }
463 spin_unlock_irqrestore(&sysrq_key_table_lock, flags);
464 }
465
466 /*
467 * This function is called by the keyboard handler when SysRq is pressed
468 * and any other keycode arrives.
469 */
470 void handle_sysrq(int key, struct tty_struct *tty)
471 {
472 if (sysrq_on())
473 __handle_sysrq(key, tty, 1);
474 }
475 EXPORT_SYMBOL(handle_sysrq);
476
477 static int __sysrq_swap_key_ops(int key, struct sysrq_key_op *insert_op_p,
478 struct sysrq_key_op *remove_op_p)
479 {
480
481 int retval;
482 unsigned long flags;
483
484 spin_lock_irqsave(&sysrq_key_table_lock, flags);
485 if (__sysrq_get_key_op(key) == remove_op_p) {
486 __sysrq_put_key_op(key, insert_op_p);
487 retval = 0;
488 } else {
489 retval = -1;
490 }
491 spin_unlock_irqrestore(&sysrq_key_table_lock, flags);
492 return retval;
493 }
494
495 int register_sysrq_key(int key, struct sysrq_key_op *op_p)
496 {
497 return __sysrq_swap_key_ops(key, op_p, NULL);
498 }
499 EXPORT_SYMBOL(register_sysrq_key);
500
501 int unregister_sysrq_key(int key, struct sysrq_key_op *op_p)
502 {
503 return __sysrq_swap_key_ops(key, NULL, op_p);
504 }
505 EXPORT_SYMBOL(unregister_sysrq_key);
506
|
This page was automatically generated by the
LXR engine.
|