* [PATCH v4] drivers/tty: Folding Android's keyreset driver in sysRQ
@ 2012-11-11 20:24 mathieu.poirier
2012-11-19 7:25 ` Dmitry Torokhov
0 siblings, 1 reply; 11+ messages in thread
From: mathieu.poirier @ 2012-11-11 20:24 UTC (permalink / raw)
To: linux-kernel
Cc: Mathieu J. Poirier, arve, kernel-team, dmitry.torokhov,
john.stultz, alan
From: "Mathieu J. Poirier" <mathieu.poirier@linaro.org>
This patch adds keyreset functionality to the sysrq driver. It
allows certain button/key combinations to be used in order to
trigger device resets.
The first time the key-combo is detected a work function that syncs
the filesystems is scheduled and the kernel rebooted. If all the keys
are released and then pressed again, it calls panic. Reboot on panic
should be set for this to work.
Redefining the '__weak sysrq_keyreset_get_params' function is required
to trigger the feature. Alternatively keys can be passed to the
driver via the "/sys/module/sysrq" interface.
This functionality comes from the keyreset driver submitted by
Arve Hjønnevåg in the Android kernel.
Cc: arve@android.com
Cc: kernel-team@android.com
Cc: dmitry.torokhov@gmail.com
Cc: john.stultz@linaro.org
Cc: alan@lxorguk.ukuu.org.uk
Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
---
drivers/tty/sysrq.c | 303 +++++++++++++++++++++++++++++++++++++++++++++++++
include/linux/sysrq.h | 2 +
2 files changed, 305 insertions(+), 0 deletions(-)
diff --git a/drivers/tty/sysrq.c b/drivers/tty/sysrq.c
index 05728894..da4f538 100644
--- a/drivers/tty/sysrq.c
+++ b/drivers/tty/sysrq.c
@@ -41,14 +41,29 @@
#include <linux/slab.h>
#include <linux/input.h>
#include <linux/uaccess.h>
+#include <linux/syscalls.h>
+#include <linux/atomic.h>
+#include <linux/moduleparam.h>
+#include <linux/mutex.h>
#include <asm/ptrace.h>
#include <asm/irq_regs.h>
+#define KEY_RESET_MAX 20 /* how many is enough ? */
+int keyreset_param[KEY_RESET_MAX];
+struct mutex sysrq_mutex;
+static struct sysrq_state *sysrq_handle;
+
/* Whether we react on sysrq keys or just ignore them */
static int __read_mostly sysrq_enabled = SYSRQ_DEFAULT_ENABLE;
static bool __read_mostly sysrq_always_enabled;
+static struct input_handler sysrq_handler;
+
+/* Keep track of what has been called */
+static atomic_t restart_requested;
+
+
static bool sysrq_on(void)
{
return sysrq_enabled || sysrq_always_enabled;
@@ -570,6 +585,15 @@ struct sysrq_state {
struct input_handle handle;
struct work_struct reinject_work;
unsigned long key_down[BITS_TO_LONGS(KEY_CNT)];
+ unsigned long keybit[BITS_TO_LONGS(KEY_CNT)];
+ unsigned long upbit[BITS_TO_LONGS(KEY_CNT)];
+ unsigned long key[BITS_TO_LONGS(KEY_CNT)];
+ int (*reset_fn)(void);
+ int key_down_target;
+ int key_down_ctn;
+ int key_up_ctn;
+ int keyreset_data;
+ int restart_disabled;
unsigned int alt;
unsigned int alt_use;
bool active;
@@ -603,6 +627,80 @@ static void sysrq_reinject_alt_sysrq(struct work_struct *work)
}
}
+static void deferred_restart(struct work_struct *dummy)
+{
+ atomic_inc(&restart_requested);
+ sys_sync();
+ atomic_inc(&restart_requested);
+ kernel_restart(NULL);
+}
+static DECLARE_WORK(restart_work, deferred_restart);
+
+static int do_keyreset_event(struct sysrq_state *state,
+ unsigned int code, int value)
+{
+ int ret;
+ int processed = 0;
+
+ mutex_lock(&sysrq_mutex);
+
+ /* Is the code of interest to us */
+ if (!test_bit(code, state->keybit)) {
+ mutex_unlock(&sysrq_mutex);
+ return processed;
+ }
+
+ /* No need to take care of key up events */
+ if (!test_bit(code, state->key) == !value) {
+ mutex_unlock(&sysrq_mutex);
+ return processed;
+ }
+
+ /* Record new entry */
+ __change_bit(code, state->key);
+
+ processed = 1;
+
+ if (test_bit(code, state->upbit)) {
+ if (value) {
+ state->restart_disabled = 1;
+ state->key_up_ctn++;
+ } else
+ state->key_up_ctn--;
+ } else {
+ if (value)
+ state->key_down_ctn++;
+ else
+ state->key_down_ctn--;
+ }
+
+ if (state->key_down_ctn == 0 && state->key_up_ctn == 0)
+ state->restart_disabled = 0;
+
+ if (value && !state->restart_disabled &&
+ state->key_down_ctn == state->key_down_target) {
+ state->restart_disabled = 1;
+ if (atomic_read(&restart_requested))
+ panic("keyboard reset failed, %d - panic\n",
+ atomic_read(&restart_requested));
+ if (state->reset_fn) {
+ ret = state->reset_fn();
+ atomic_set(&restart_requested, ret);
+ } else {
+ pr_info("keyboard reset\n");
+ schedule_work(&restart_work);
+ atomic_inc(&restart_requested);
+ }
+ }
+
+ mutex_unlock(&sysrq_mutex);
+
+ /* no need to suppress keyreset characters */
+ state->active = false;
+
+ return processed;
+}
+
static bool sysrq_filter(struct input_handle *handle,
unsigned int type, unsigned int code, int value)
{
@@ -669,6 +767,11 @@ static bool sysrq_filter(struct input_handle *handle,
if (sysrq->active && value && value != 2) {
sysrq->need_reinject = false;
__handle_sysrq(sysrq_xlate[code], true);
+ } else if (sysrq->keyreset_data) {
+ if (do_keyreset_event(sysrq, code, value)) {
+ suppress = sysrq->active;
+ goto end;
+ }
}
break;
}
@@ -704,26 +807,105 @@ static bool sysrq_filter(struct input_handle *handle,
break;
}
+ /*
+ * suppress == true - suppress passing to other subsystems.
+ * suppress == false - passing to other subsystems.
+ */
+end:
return suppress;
}
+static void parse_user_data(struct sysrq_state *sysrq,
+ int *keys_down, int *keys_up)
+{
+ int key, *keyp;
+
+ if (keys_down) {
+ sysrq->key_down_target = 0;
+ memset(sysrq->keybit, 0, BITS_TO_LONGS(KEY_CNT));
+
+ keyp = keys_down;
+ while ((key = *keyp++)) {
+ if (key >= KEY_MAX)
+ continue;
+ sysrq->key_down_target++;
+ __set_bit(key, sysrq->keybit);
+ }
+ sysrq->keyreset_data = 1;
+ }
+
+ if (keys_up) {
+ memset(sysrq->upbit, 0, BITS_TO_LONGS(KEY_CNT));
+ keyp = keys_up;
+ while ((key = *keyp++)) {
+ if (key >= KEY_MAX)
+ continue;
+ __set_bit(key, sysrq->keybit);
+ __set_bit(key, sysrq->upbit);
+ }
+ }
+
+ /* something changed, reset state machine */
+ sysrq->key_down_ctn = 0;
+ sysrq->key_up_ctn = 0;
+ sysrq->restart_disabled = 0;
+ memset(sysrq->key, 0, BITS_TO_LONGS(KEY_CNT));
+
+}
+
+/*
+ * Example of how to instantiate keyreset parameters:
+ *
+ * int acme_reset_fn(void)
+ * {
+ * printk(KERN_ALERT "ACME SYSTEM GOING DOWN!\n");
+ * return 0;
+ * }
+ *
+ * int acme_keys_down[] = {KEY_1, KEY_2, KEY_9, 0};
+ * int acme_keys_up[] = {KEY_0, 0};
+ *
+ * void sysrq_keyreset_get_params(int (**reset_fn)(void),
+ int **keys_down, int **keys_up)
+ * {
+ * *reset_fn = &acme_reset_fn;
+ * *keys_down = (int*) &acme_keys_down;
+ * *keys_up = (int*) &acme_keys_up;
+ * }
+ */
+void __weak sysrq_keyreset_get_params(int (**reset_fn)(void),
+ int **keys_down, int **keys_up)
+{
+ *reset_fn = NULL;
+ *keys_down = *keys_up = NULL;
+}
+
static int sysrq_connect(struct input_handler *handler,
struct input_dev *dev,
const struct input_device_id *id)
{
struct sysrq_state *sysrq;
+ int *keys_up, *keys_down;
+ int (*reset_fn)(void);
int error;
sysrq = kzalloc(sizeof(struct sysrq_state), GFP_KERNEL);
if (!sysrq)
return -ENOMEM;
+ /* Get key up, down and reset function */
+ sysrq_keyreset_get_params(&reset_fn, &keys_down, &keys_up);
+ parse_user_data(sysrq, keys_down, keys_up);
+ if (reset_fn)
+ sysrq->reset_fn = reset_fn;
+
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;
+ sysrq_handle = sysrq;
error = input_register_handle(&sysrq->handle);
if (error) {
@@ -744,6 +926,7 @@ static int sysrq_connect(struct input_handler *handler,
input_unregister_handle(&sysrq->handle);
err_free:
kfree(sysrq);
+ sysrq_handle = NULL;
return error;
}
@@ -754,6 +937,7 @@ static void sysrq_disconnect(struct input_handle *handle)
input_close_device(handle);
cancel_work_sync(&sysrq->reinject_work);
input_unregister_handle(handle);
+ sysrq_handle = NULL;
kfree(sysrq);
}
@@ -786,6 +970,8 @@ static inline void sysrq_register_handler(void)
{
int error;
+ mutex_init(&sysrq_mutex);
+
error = input_register_handler(&sysrq_handler);
if (error)
pr_err("Failed to register input handler, error %d", error);
@@ -905,4 +1091,121 @@ static int __init sysrq_init(void)
return 0;
}
+
+static int key_array_set(const char *val,
+ const struct kernel_param *kp, int is_key_down)
+{
+ int num, len, ret;
+ char save;
+ int max = kp->arr->max;
+
+ ret = 0;
+ num = 0;
+
+ mutex_lock(&sysrq_mutex);
+ /*
+ * Highly tailored on the original code found
+ * in kernel/params.c
+ *
+ * We expect a comma-separated list of values, which should conform to
+ * values found in linux/input.h. The list should also be zero
+ * terminated as with the platform data. ex:
+ * $ echo 2,3,4 > /sys/module/sysrq/parameters/key_[down, up]
+ */
+ do {
+ if (num == max) {
+ pr_err("%s: can only take %i arguments\n",
+ kp->name, max);
+ mutex_unlock(&sysrq_mutex);
+ return -EINVAL;
+ }
+ len = strcspn(val, ",");
+
+ /* null-terminate and parse */
+ save = val[len];
+ ((char *)val)[len] = '\0';
+
+ ret = kstrtoint(val, 10, &keyreset_param[num]);
+ if (ret)
+ goto error;
+ val += len + 1;
+ num++;
+ } while (save == ',');
+
+ if (keyreset_param[num] != 0)
+ keyreset_param[num] = 0;
+
+ if (is_key_down)
+ parse_user_data(sysrq_handle, keyreset_param, NULL);
+ else
+ parse_user_data(sysrq_handle, NULL, keyreset_param);
+
+ mutex_unlock(&sysrq_mutex);
+error:
+ return ret;
+}
+
+static int print_bits(char *buffer, unsigned long *keybit)
+{
+ int i, off, ret;
+
+ off = 0;
+ i = 0;
+
+ mutex_lock(&sysrq_mutex);
+ while (i < KEY_CNT) {
+ if (test_bit(i, keybit) && i != KEY_SYSRQ) {
+ if (off)
+ buffer[off++] = ',';
+
+ ret = sprintf(buffer + off, "%d", i);
+ off += ret;
+ }
+ i++;
+ }
+
+ buffer[off] = '\0';
+ mutex_unlock(&sysrq_mutex);
+ return off;
+
+}
+
+static int key_down_array_set(const char *val, const struct kernel_param *kp)
+{
+ return key_array_set(val, kp, 1);
+}
+
+static int key_down_array_get(char *buffer, const struct kernel_param *kp)
+{
+ return print_bits(buffer, sysrq_handle->keybit);
+}
+
+static int key_up_array_set(const char *val, const struct kernel_param *kp)
+{
+ return key_array_set(val, kp, 0);
+}
+
+static int key_up_array_get(char *buffer, const struct kernel_param *kp)
+{
+ return print_bits(buffer, sysrq_handle->upbit);
+}
+
+struct kernel_param_ops key_down_array_ops = {
+ .set = key_down_array_set,
+ .get = key_down_array_get,
+};
+
+struct kernel_param_ops key_up_array_ops = {
+ .set = key_up_array_set,
+ .get = key_up_array_get,
+};
+
+static struct kparam_array __param_keyreset = {
+ .max = KEY_RESET_MAX,
+ .elemsize = sizeof(int),
+ .elem = keyreset_param,
+};
+
+module_param_cb(key_down, &key_down_array_ops, &__param_keyreset, 0644);
+module_param_cb(key_up, &key_up_array_ops, &__param_keyreset, 0644);
module_init(sysrq_init);
diff --git a/include/linux/sysrq.h b/include/linux/sysrq.h
index 7faf933..e292f0f 100644
--- a/include/linux/sysrq.h
+++ b/include/linux/sysrq.h
@@ -17,6 +17,8 @@
#include <linux/errno.h>
#include <linux/types.h>
+#define SYSRQ_KRESET_NAME "keyreset"
+
/* Enable/disable SYSRQ support by default (0==no, 1==yes). */
#define SYSRQ_DEFAULT_ENABLE 1
--
1.7.5.4
^ permalink raw reply related [flat|nested] 11+ messages in thread* Re: [PATCH v4] drivers/tty: Folding Android's keyreset driver in sysRQ
2012-11-11 20:24 [PATCH v4] drivers/tty: Folding Android's keyreset driver in sysRQ mathieu.poirier
@ 2012-11-19 7:25 ` Dmitry Torokhov
[not found] ` <CAPM=9tw8mefcYTqELXFbZWZ44a--SNcPnRMAvMSGTiODzRpDhg@mail.gmail.com>
0 siblings, 1 reply; 11+ messages in thread
From: Dmitry Torokhov @ 2012-11-19 7:25 UTC (permalink / raw)
To: mathieu.poirier; +Cc: linux-kernel, arve, kernel-team, john.stultz, alan
Hi Mathieu,
On Sun, Nov 11, 2012 at 01:24:48PM -0700, mathieu.poirier@linaro.org wrote:
> From: "Mathieu J. Poirier" <mathieu.poirier@linaro.org>
>
> This patch adds keyreset functionality to the sysrq driver. It
> allows certain button/key combinations to be used in order to
> trigger device resets.
>
> The first time the key-combo is detected a work function that syncs
> the filesystems is scheduled and the kernel rebooted. If all the keys
> are released and then pressed again, it calls panic. Reboot on panic
> should be set for this to work.
>
> Redefining the '__weak sysrq_keyreset_get_params' function is required
> to trigger the feature. Alternatively keys can be passed to the
> driver via the "/sys/module/sysrq" interface.
>
> This functionality comes from the keyreset driver submitted by
> Arve Hjønnevåg in the Android kernel.
Thank you for making the changes. This still looks pretty complicated,
how about if we trim it a bit, like in the patch below.
Thanks.
--
Dmitry
Input: sysrq - allow specifying alternate reset sequence
From: Mathieu J. Poirier <mathieu.poirier@linaro.org>
This patch adds keyreset functionality to the sysrq driver. It allows
certain button/key combinations to be used in order to trigger emergency
reboots.
Redefining the '__weak platform_sysrq_reset_seq' variable is required
to trigger the feature. Alternatively keys can be passed to the driver
via a module parameter.
This functionality comes from the keyreset driver submitted by
Arve Hjønnevåg in the Android kernel.
Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
Signed-off-by: Dmitry Torokhov <dmitry.torokhov@gmail.com>
---
drivers/tty/sysrq.c | 114 +++++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 114 insertions(+)
diff --git a/drivers/tty/sysrq.c b/drivers/tty/sysrq.c
index 16ee6ce..9dddaf7 100644
--- a/drivers/tty/sysrq.c
+++ b/drivers/tty/sysrq.c
@@ -41,6 +41,7 @@
#include <linux/slab.h>
#include <linux/input.h>
#include <linux/uaccess.h>
+#include <linux/moduleparam.h>
#include <asm/ptrace.h>
#include <asm/irq_regs.h>
@@ -576,8 +577,73 @@ struct sysrq_state {
bool active;
bool need_reinject;
bool reinjecting;
+
+ /* 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;
};
+#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++;
+ }
+}
+
+static bool sysrq_detect_reset_sequence(struct sysrq_state *state,
+ unsigned int code, int value)
+{
+ if (state->reset_seq_version != sysrq_reset_seq_version) {
+ sysrq_parse_reset_sequence(state);
+ /* Disable reset until old keys are not released */
+ state->reset_canceled = state->reset_seq_cnt != 0;
+ state->reset_seq_version = sysrq_reset_seq_version;
+ }
+
+ 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;
+}
+
static void sysrq_reinject_alt_sysrq(struct work_struct *work)
{
struct sysrq_state *sysrq =
@@ -690,6 +756,11 @@ static bool sysrq_filter(struct input_handle *handle,
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);
+ }
+
} else if (value == 0 &&
test_and_clear_bit(code, sysrq->key_down)) {
/*
@@ -785,7 +856,20 @@ static bool sysrq_handler_registered;
static inline void sysrq_register_handler(void)
{
+ extern unsigned short platform_sysrq_reset_seq[] __weak;
+ unsigned short key;
int error;
+ 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;
+ }
+ }
error = input_register_handler(&sysrq_handler);
if (error)
@@ -802,6 +886,36 @@ static inline void sysrq_unregister_handler(void)
}
}
+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);
+
#else
static inline void sysrq_register_handler(void)
^ permalink raw reply related [flat|nested] 11+ messages in thread
end of thread, other threads:[~2013-02-27 18:49 UTC | newest]
Thread overview: 11+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2012-11-11 20:24 [PATCH v4] drivers/tty: Folding Android's keyreset driver in sysRQ mathieu.poirier
2012-11-19 7:25 ` Dmitry Torokhov
[not found] ` <CAPM=9tw8mefcYTqELXFbZWZ44a--SNcPnRMAvMSGTiODzRpDhg@mail.gmail.com>
2013-02-27 8:26 ` Dave Airlie
2013-02-27 11:06 ` Dave Airlie
2013-02-27 11:10 ` Dave Airlie
2013-02-27 11:40 ` Dave Airlie
2013-02-27 16:57 ` Linus Torvalds
2013-02-27 17:58 ` Mathieu Poirier
2013-02-27 18:09 ` Linus Torvalds
2013-02-27 18:26 ` David Howells
2013-02-27 18:49 ` Dmitry Torokhov
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.
