Input: implement sysrq as an input handler
Subsystems (4)
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
@@ -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
@@ -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
@@ -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
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
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
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
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
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
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
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
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
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
_inputhandler_. 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
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
_inputhandler_. 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
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).
Signed-off-by Dmitry Torokhov <[email protected]>---
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
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).
Signed-off-by Dmitry Torokhov <[email protected]>---
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