Skip to contentSkip to conversation

Input: implement sysrq as an input handler

RFC In review Dmitry Torokhov 4 participants 13 messages Mar 17, 2010 – Apr 16, 2010

Subsystems (4)
lore
Share & tools
lore
#0 lore raw

RFC 1/1 Input: implement sysrq as an input handler

Instead of keeping SysRq support inside of legacy keyboard driver split it out into a separate input handler (filter). This stops most SysRq input events from leaking into evdev clients (some events, such as first SysRq scancode - not keycode - event, are still leaked into both legacy keyboard and evdev).

---

 drivers/char/keyboard.c |   40 +-------
 drivers/char/sysrq.c    |  222 +++++++++++++++++++++++++++++++++++++++++------
 include/linux/sysrq.h   |   23 +----
 kernel/sysctl.c         |   23 +++++
 4 files changed, 224 insertions(+), 84 deletions(-)
drivers/char/keyboard.c +3 -37
index ada25bb..50f6c01 100644
@@ -38,7 +38,6 @@
 #include <linux/kbd_kern.h>
 #include <linux/kbd_diacr.h>
 #include <linux/vt_kern.h>
-#include <linux/sysrq.h>
 #include <linux/input.h>
 #include <linux/reboot.h>
 #include <linux/notifier.h>
@@ -82,8 +81,7 @@ void compute_shiftstate(void);
 typedef void (k_handler_fn)(struct vc_data *vc, unsigned char value,
 			    char up_flag);
 static k_handler_fn K_HANDLERS;
-k_handler_fn *k_handler[16] = { K_HANDLERS };
-EXPORT_SYMBOL_GPL(k_handler);
+static k_handler_fn *k_handler[16] = { K_HANDLERS };
 
 #define FN_HANDLERS\
 	fn_null,	fn_enter,	fn_show_ptregs,	fn_show_mem,\
@@ -147,22 +145,6 @@ static struct ledptr {
 	unsigned char valid:1;
 } ledptrs[3];
 
-/* Simple translation table for the SysRq keys */
-
-#ifdef CONFIG_MAGIC_SYSRQ
-unsigned char kbd_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 int sysrq_down;
-static int sysrq_alt_use;
-#endif
-static int sysrq_alt;
-
 /*
  * Notifier list for console keyboard events
  */
@@ -1108,7 +1090,8 @@ static int emulate_raw(struct vc_data *vc, unsigned int keycode,
 			 * pressing PrtSc/SysRq alone, but simply 0x54
 			 * when pressing Alt+PrtSc/SysRq.
 			 */
-			if (sysrq_alt) {
+			if (test_bit(KEY_LEFTALT, key_down) ||
+			    test_bit(KEY_RIGHTALT, key_down)) {
 				put_queue(vc, 0x54 | up_flag);
 			} else {
 				put_queue(vc, 0xe0);
@@ -1176,8 +1159,6 @@ static void kbd_keycode(unsigned int keycode, int down, int hw_raw)
 
 	kbd = kbd_table + vc->vc_num;
 
-	if (keycode == KEY_LEFTALT || keycode == KEY_RIGHTALT)
-		sysrq_alt = down ? keycode : 0;
 #ifdef CONFIG_SPARC
 	if (keycode == KEY_STOP)
 		sparc_l1_a_state = down;
@@ -1190,21 +1171,6 @@ static void kbd_keycode(unsigned int keycode, int down, int hw_raw)
 			if (keycode < BTN_MISC && printk_ratelimit())
 				printk(KERN_WARNING "keyboard.c: can't emulate rawmode for keycode %d\n", keycode);
 
-#ifdef CONFIG_MAGIC_SYSRQ	       /* Handle the SysRq Hack */
-	if (keycode == KEY_SYSRQ && (sysrq_down || (down == 1 && sysrq_alt))) {
-		if (!sysrq_down) {
-			sysrq_down = down;
-			sysrq_alt_use = sysrq_alt;
-		}
-		return;
-	}
-	if (sysrq_down && !down && keycode == sysrq_alt_use)
-		sysrq_down = 0;
-	if (sysrq_down && down && !rep) {
-		handle_sysrq(kbd_sysrq_xlate[keycode], tty);
-		return;
-	}
-#endif
 #ifdef CONFIG_SPARC
 	if (keycode == KEY_A && sparc_l1_a_state) {
 		sparc_l1_a_state = 0;
drivers/char/sysrq.c +193 -29

324 lines not on this page · raw message

include/linux/sysrq.h +6 -17
index 99adcdc..5f2bdef 100644
@@ -39,41 +39,30 @@ struct sysrq_key_op {
 
 #ifdef CONFIG_MAGIC_SYSRQ
 
-extern int sysrq_on(void);
-
-/*
- * Do not use this one directly:
- */
-extern int __sysrq_enabled;
-
 /* Generic SysRq interface -- you may call it from any device driver, supplying
  * ASCII code of the key, pointer to registers and kbd/tty structs (if they
  * are available -- else NULL's).
  */
 
 void handle_sysrq(int key, struct tty_struct *tty);
-void __handle_sysrq(int key, struct tty_struct *tty, int check_mask);
 int register_sysrq_key(int key, struct sysrq_key_op *op);
 int unregister_sysrq_key(int key, struct sysrq_key_op *op);
 struct sysrq_key_op *__sysrq_get_key_op(int key);
 
+int sysrq_toggle_support(int enable_mask);
+
 #else
 
-static inline int sysrq_on(void)
-{
-	return 0;
-}
-static inline int __reterr(void)
+static inline int register_sysrq_key(int key, struct sysrq_key_op *op)
 {
 	return -EINVAL;
 }
-static inline void handle_sysrq(int key, struct tty_struct *tty)
+
+static inline int unregister_sysrq_key(int key, struct sysrq_key_op *op)
 {
+	return -EINVAL;
 }
 
-#define register_sysrq_key(ig,nore) __reterr()
-#define unregister_sysrq_key(ig,nore) __reterr()
-
 #endif
 
 #endif /* _LINUX_SYSRQ_H */
kernel/sysctl.c +22 -1
index 8686b0f..ce724a0 100644
@@ -163,6 +163,27 @@ static int proc_taint(struct ctl_table *table, int write,
 			       void __user *buffer, size_t *lenp, loff_t *ppos);
 #endif
 
+#ifdef CONFIG_MAGIC_SYSRQ
+static int __sysrq_enabled; /* Note: sysrq code ises it's own private copy */
+
+static int sysrq_sysctl_handler(ctl_table *table, int write,
+				void __user *buffer, size_t *lenp,
+				loff_t *ppos)
+{
+	int error;
+
+	error = proc_dointvec(table, write, buffer, lenp, ppos);
+	if (error)
+		return error;
+
+	if (write)
+		sysrq_toggle_support(__sysrq_enabled);
+
+	return 0;
+}
+
+#endif
+
 static struct ctl_table root_table[];
 static struct ctl_table_root sysctl_table_root;
 static struct ctl_table_header root_table_header = {
@@ -567,7 +588,7 @@ static struct ctl_table kern_table[] = {
 		.data		= &__sysrq_enabled,
 		.maxlen		= sizeof (int),
 		.mode		= 0644,
-		.proc_handler	= proc_dointvec,
+		.proc_handler	= sysrq_sysctl_handler,
 	},
 #endif
 #ifdef CONFIG_PROC_SYSCTL
Signature · 1 line
Dmitry
#1 lore raw

Any chance of the user being able to avoid the SysRQ events getting to the handle, e.g. by opening the input device in exclusive mode or something like that?

Signature · 4 lines
  "One disk to rule them all, One disk to find them. One disk to bring
  them all and in the darkness grind them. In the Land of Redmond
  where the shadows lie." -- The Silicon Valley Tarot
  Henrique Holschuh
#2 lore raw
Quoted 4 lines · Henrique de Moraes Holschuh

Any chance of the user being able to avoid the SysRQ events getting to the handle, e.g. by opening the input device in exclusive mode or something like that?

Yes, it is a possible to suppress SysRq by grabbing an input device. This possibility exisst with the current implementation too though - after all legacy keyboard driver implemented as an input handler as well.

... or am I answering a question different from the one you asked? ;)

Signature · 1 line
Dmitry
#3 lore raw
Quoted 11 lines · Dmitry Torokhov
Quoted 3 lines · Henrique de Moraes Holschuh

Any chance of the user being able to avoid the SysRQ events getting to the handle, e.g. by opening the input device in exclusive mode or something like that?

Yes, it is a possible to suppress SysRq by grabbing an input device. This possibility exisst with the current implementation too though - after all legacy keyboard driver implemented as an input handler as well.

... or am I answering a question different from the one you asked? ;)

No, that's exactly what I wanted to know.

What about SAK? That thing *has* to be untrappable.

Even for the SysRQ debug events, I'd feel better if we could have a class of system input handlers that cannot be suppressed to use for these things.

Signature · 4 lines
  "One disk to rule them all, One disk to find them. One disk to bring
  them all and in the darkness grind them. In the Land of Redmond
  where the shadows lie." -- The Silicon Valley Tarot
  Henrique Holschuh
#4 lore raw
Quoted 11 lines · Henrique de Moraes Holschuh
Quoted 10 lines · Dmitry Torokhov
Quoted 3 lines · Henrique de Moraes Holschuh

Any chance of the user being able to avoid the SysRQ events getting to the handle, e.g. by opening the input device in exclusive mode or something like that?

Yes, it is a possible to suppress SysRq by grabbing an input device. This possibility exisst with the current implementation too though - after all legacy keyboard driver implemented as an input handler as well.

Quoted 6 lines
Quoted 1 line

... or am I answering a question different from the one you asked? ;)

No, that's exactly what I wanted to know.

What about SAK? That thing *has* to be untrappable.

On what level untrapable? And what exactly is SAK? There is not a special key, at least not in general case, it is an action assigned to a key comboi. Root can "trap" legacy keyboard SAK with loadkeys; it can also disable sysrq, unload modules and do other nasty things. But ordinary users can not trap it.

Quoted 2 lines

Even for the SysRQ debug events, I'd feel better if we could have a class of system input handlers that cannot be suppressed to use for these things.

That would require moving "these things", including their state machines, into input core otherwise it would not know what events can be trappable and which should be passed through. Or we should get rid of EVIOCGRAB.

Given the fact that event devices are accessible only to root I think that current behavior is acceptable.

Signature · 1 line
Dmitry
#5 lore raw
Quoted 16 lines · Dmitry Torokhov
Quoted 15 lines · Henrique de Moraes Holschuh
Quoted 11 lines · Dmitry Torokhov
Quoted 3 lines · Henrique de Moraes Holschuh

Any chance of the user being able to avoid the SysRQ events getting to the handle, e.g. by opening the input device in exclusive mode or something like that?

Yes, it is a possible to suppress SysRq by grabbing an input device. This possibility exisst with the current implementation too though - after all legacy keyboard driver implemented as an input handler as well.

... or am I answering a question different from the one you asked? ;)

No, that's exactly what I wanted to know.

Quoted 7 lines
Quoted 1 line

What about SAK? That thing *has* to be untrappable.

On what level untrapable? And what exactly is SAK? There is not a special key, at least not in general case, it is an action assigned to a key comboi. Root can "trap" legacy keyboard SAK with loadkeys; it can also disable sysrq, unload modules and do other nasty things. But ordinary users can not trap it.

root isn't really a problem from a security PoV (well, maybe it is if the operation isn't constrained by capabilities). SAK can't protect you from root.

_Normal_ userspace behaviour running a root process is a problem if it blocks these handles, though, both for SAK and regular SysRQ. I have lost count of how many times SysRQ+SUB delivered me from filesystem corruption and very annoying problems, both at home and at work.

We are sort of trusting userspace to not break the one way out from severly hung systems while doing its normal day-to-day operations (as opposed to deliberately disabling SysRQ or remapping SAK, etc).

Quoted 7 lines
Quoted 2 lines

Even for the SysRQ debug events, I'd feel better if we could have a class of system input handlers that cannot be suppressed to use for these things.

That would require moving "these things", including their state machines, into input core otherwise it would not know what events can be trappable and which should be passed through. Or we should get rid of EVIOCGRAB.

Maybe we can add a flags field to input devices and input handlers, to be able to have the core behave differently when needed, without moving everything into the input core? Would that work, or would it need too much churn in the core?

Quoted 2 lines

Given the fact that event devices are accessible only to root I think that current behavior is acceptable.

I don't trust the class of programs that would want to open input devices as root in exclusive mode. Desktop fluff might decide to use EVIOCGRAB or open input devices in exclusive mode for some reason, and break SysRQ. I'd like to preserve the hability of userspace to EVIOCGRAB if it feels there's a need to, while preserving the kernel's hability to NEVER ignore SysRQ and SAK while enabled.

Signature · 4 lines
  "One disk to rule them all, One disk to find them. One disk to bring
  them all and in the darkness grind them. In the Land of Redmond
  where the shadows lie." -- The Silicon Valley Tarot
  Henrique Holschuh
#6 lore raw
Quoted 46 lines · Henrique de Moraes Holschuh
Quoted 16 lines · Dmitry Torokhov
Quoted 15 lines · Henrique de Moraes Holschuh
Quoted 11 lines · Dmitry Torokhov
Quoted 3 lines · Henrique de Moraes Holschuh

Any chance of the user being able to avoid the SysRQ events getting to the handle, e.g. by opening the input device in exclusive mode or something like that?

Yes, it is a possible to suppress SysRq by grabbing an input device. This possibility exisst with the current implementation too though - after all legacy keyboard driver implemented as an input handler as well.

... or am I answering a question different from the one you asked? ;)

No, that's exactly what I wanted to know.

Quoted 7 lines
Quoted 1 line

What about SAK? That thing *has* to be untrappable.

On what level untrapable? And what exactly is SAK? There is not a special key, at least not in general case, it is an action assigned to a key comboi. Root can "trap" legacy keyboard SAK with loadkeys; it can also disable sysrq, unload modules and do other nasty things. But ordinary users can not trap it.

root isn't really a problem from a security PoV (well, maybe it is if the operation isn't constrained by capabilities). SAK can't protect you from root.

_Normal_ userspace behaviour running a root process is a problem if it blocks these handles, though, both for SAK and regular SysRQ. I have lost count of how many times SysRQ+SUB delivered me from filesystem corruption and very annoying problems, both at home and at work.

We are sort of trusting userspace to not break the one way out from severly hung systems while doing its normal day-to-day operations (as opposed to deliberately disabling SysRQ or remapping SAK, etc).

Quoted 7 lines
Quoted 2 lines

Even for the SysRQ debug events, I'd feel better if we could have a class of system input handlers that cannot be suppressed to use for these things.

That would require moving "these things", including their state machines, into input core otherwise it would not know what events can be trappable and which should be passed through. Or we should get rid of EVIOCGRAB.

Quoted 4 lines

Maybe we can add a flags field to input devices and input handlers, to be able to have the core behave differently when needed, without moving everything into the input core? Would that work, or would it need too much churn in the core?

The problem is that device does not know what SysRq and especially SAK are. User can reassign key codes and key symbols easily.

Quoted 10 lines
Quoted 3 lines

Given the fact that event devices are accessible only to root I think that current behavior is acceptable.

I don't trust the class of programs that would want to open input devices as root in exclusive mode. Desktop fluff might decide to use EVIOCGRAB or open input devices in exclusive mode for some reason, and break SysRQ. I'd like to preserve the hability of userspace to EVIOCGRAB if it feels there's a need to, while preserving the kernel's hability to NEVER ignore SysRQ and SAK while enabled.

I am afraid that you chose wrong verb then. You can not _preserve_ what you do not have - legacy keyboard driver is still an input handler, and thus can still interfere with SysRq by grabbing input devices.

I don't think we had any issues like this since 2.5 so I would not worry about userspace too much. If anything we just need to review what stuff we run as root (we do that anyway, right?).

Signature · 1 line
Dmitry
#7 lore raw

Hi!

Quoted 4 lines
Quoted 4 lines

root isn't really a problem from a security PoV (well, maybe it is if the operation isn't constrained by capabilities). SAK can't protect you from root.

Quoted 8 lines
Quoted 8 lines

_Normal_ userspace behaviour running a root process is a problem if it blocks these handles, though, both for SAK and regular SysRQ. I have lost count of how many times SysRQ+SUB delivered me from filesystem corruption and very annoying problems, both at home and at work.

We are sort of trusting userspace to not break the one way out from severly hung systems while doing its normal day-to-day operations (as opposed to deliberately disabling SysRQ or remapping SAK, etc).

If userspace disables sysrq during normal operation, that makes it useless.

If normal user could do that, that's a security problem.

Quoted 5 lines
Quoted 5 lines
Quoted 4 lines

That would require moving "these things", including their state machines, into input core otherwise it would not know what events can be trappable and which should be passed through. Or we should get rid of EVIOCGRAB.

Quoted 7 lines
Quoted 4 lines

Maybe we can add a flags field to input devices and input handlers, to be able to have the core behave differently when needed, without moving everything into the input core? Would that work, or would it need too much churn in the core?

The problem is that device does not know what SysRq and especially SAK are. User can reassign key codes and key symbols easily.

That was not case in original implementation; it had hardcoded keymap.

Quoted 3 lines

I don't think we had any issues like this since 2.5 so I would not worry about userspace too much. If anything we just need to review what stuff we run as root (we do that anyway, right?).

Hehe. If X can break sysrq, that's both X and sysrq problem.
Pavel

Signature · 2 lines
(english) http://www.livejournal.com/~pavelmachek
(cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html
#8 lore raw

Hi Pavel,

Quoted 11 lines · Pavel Machek

Hi!

Quoted 9 lines
Quoted 9 lines

root isn't really a problem from a security PoV (well, maybe it is if the operation isn't constrained by capabilities). SAK can't protect you from root.

_Normal_ userspace behaviour running a root process is a problem if it blocks these handles, though, both for SAK and regular SysRQ. I have lost count of how many times SysRQ+SUB delivered me from filesystem corruption and very annoying problems, both at home and at work.

Quoted 9 lines
Quoted 3 lines
Quoted 3 lines

We are sort of trusting userspace to not break the one way out from severly hung systems while doing its normal day-to-day operations (as opposed to deliberately disabling SysRQ or remapping SAK, etc).

If userspace disables sysrq during normal operation, that makes it useless.

If normal user could do that, that's a security problem.

Yes, and...? This patch does not change the way one enables, disables, intercepts, etc. SysRq and SAK compared to how it was handled when SysRq was part of keyboard _input handler_. The only thisng this patch does is moving the code into a _separate_ input handler.

Quoted 10 lines
Quoted 10 lines
Quoted 9 lines
Quoted 4 lines

That would require moving "these things", including their state machines, into input core otherwise it would not know what events can be trappable and which should be passed through. Or we should get rid of EVIOCGRAB.

Maybe we can add a flags field to input devices and input handlers, to be able to have the core behave differently when needed, without moving everything into the input core? Would that work, or would it need too much churn in the core?

Quoted 4 lines
Quoted 2 lines

The problem is that device does not know what SysRq and especially SAK are. User can reassign key codes and key symbols easily.

That was not case in original implementation; it had hardcoded keymap.

The earth was also flat back then and the only keyboard was AT one. SAK was always part of keymap so could be reassinged at any time.

Quoted 6 lines
Quoted 4 lines

I don't think we had any issues like this since 2.5 so I would not worry about userspace too much. If anything we just need to review what stuff we run as root (we do that anyway, right?).

Hehe. If X can break sysrq, that's both X and sysrq problem.

Root can disable Sysrq... News at 11.

Signature · 1 line
Dmitry
#9 lore raw

Hi!

Quoted 10 lines
Quoted 5 lines

If userspace disables sysrq during normal operation, that makes it useless.

If normal user could do that, that's a security problem.

Yes, and...? This patch does not change the way one enables, disables, intercepts, etc. SysRq and SAK compared to how it was handled when SysRq was part of keyboard _input handler_. The only thisng this patch does is moving the code into a _separate_ input handler.

Yep, that was just a note.

Quoted 7 lines
Quoted 4 lines
Quoted 2 lines

The problem is that device does not know what SysRq and especially SAK are. User can reassign key codes and key symbols easily.

That was not case in original implementation; it had hardcoded keymap.

The earth was also flat back then and the only keyboard was AT one. SAK was always part of keymap so could be reassinged at any time.

Well, there are two SAKs.

One SAK -- in keymap, is remappable and always was.

Second, sysrq-saK -- is (was?) hardcoded and not affected by keymap. Please don't change that.

Quoted 7 lines
Quoted 5 lines
Quoted 3 lines

I don't think we had any issues like this since 2.5 so I would not worry about userspace too much. If anything we just need to review what stuff we run as root (we do that anyway, right?).

Hehe. If X can break sysrq, that's both X and sysrq problem.

Root can disable Sysrq... News at 11.

Root *does* disable sysrq is indeed news ... and problem.
Pavel

Signature · 2 lines
(english) http://www.livejournal.com/~pavelmachek
(cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html
#10 lore raw
Quoted 23 lines · Pavel Machek

Hi!

Quoted 10 lines
Quoted 5 lines

If userspace disables sysrq during normal operation, that makes it useless.

If normal user could do that, that's a security problem.

Yes, and...? This patch does not change the way one enables, disables, intercepts, etc. SysRq and SAK compared to how it was handled when SysRq was part of keyboard _input handler_. The only thisng this patch does is moving the code into a _separate_ input handler.

Yep, that was just a note.

Quoted 7 lines
Quoted 4 lines
Quoted 2 lines

The problem is that device does not know what SysRq and especially SAK are. User can reassign key codes and key symbols easily.

That was not case in original implementation; it had hardcoded keymap.

The earth was also flat back then and the only keyboard was AT one. SAK was always part of keymap so could be reassinged at any time.

Quoted 6 lines

Well, there are two SAKs.

One SAK -- in keymap, is remappable and always was.

Second, sysrq-saK -- is (was?) hardcoded and not affected by keymap. Please don't change that.

Can I change Alt? Just saying... ;)

Anyway, yes, it was hardcodced in 2.4. It also was only working on AT keyboards, and now we support much wider range.

Signature · 1 line
Dmitry
#11 lore raw
In reply to Dmitry Torokhov
Quoted 16 lines · Dmitry Torokhov

Instead of keeping SysRq support inside of legacy keyboard driver split it out into a separate input handler (filter). This stops most SysRq input events from leaking into evdev clients (some events, such as first SysRq scancode - not keycode - event, are still leaked into both legacy keyboard and evdev).

---

 drivers/char/keyboard.c |   40 +-------
 drivers/char/sysrq.c    |  222 +++++++++++++++++++++++++++++++++++++++++------
 include/linux/sysrq.h   |   23 +----
 kernel/sysctl.c         |   23 +++++
 4 files changed, 224 insertions(+), 84 deletions(-)

drivers/char/sysrq.c void handle_sysrq(int key, struct tty_struct *tty) · line 562

Quoted 9 lines
drivers/char/sysrq.c +9 -0
+/* 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 */

We are running out of these precious sysrq keys. Do you have any ideas of how to have a larger xlate table?

Signature · 1 line
~Randy
#12 lore raw
Quoted 17 lines · Randy Dunlap
Quoted 14 lines · Dmitry Torokhov

Instead of keeping SysRq support inside of legacy keyboard driver split it out into a separate input handler (filter). This stops most SysRq input events from leaking into evdev clients (some events, such as first SysRq scancode - not keycode - event, are still leaked into both legacy keyboard and evdev).

---

 drivers/char/keyboard.c |   40 +-------
 drivers/char/sysrq.c    |  222 +++++++++++++++++++++++++++++++++++++++++------
 include/linux/sysrq.h   |   23 +----
 kernel/sysctl.c         |   23 +++++
 4 files changed, 224 insertions(+), 84 deletions(-)
Quoted 13 lines

drivers/char/sysrq.c void handle_sysrq(int key, struct tty_struct *tty) · line 562

Quoted 9 lines
drivers/char/sysrq.c +9 -0
+/* 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 */

We are running out of these precious sysrq keys. Do you have any ideas of how to have a larger xlate table?

When we run out we could add shift modifiers I guess.

Signature · 1 line
Dmitry