Subversion Repositories or1k

/* -*- linux-c -*-

 *

 *      $Id: sysrq.c,v 1.1.1.1 2004-04-15 01:59:18 phoenix Exp $

 *

 *      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

 */

#include <linux/config.h>

#include <linux/sched.h>

#include <linux/interrupt.h>

#include <linux/mm.h>

#include <linux/fs.h>

#include <linux/tty.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>

#include <linux/quotaops.h>

#include <linux/smp_lock.h>

#include <linux/module.h>

#include <linux/spinlock.h>

#include <asm/ptrace.h>

extern void reset_vc(unsigned int);

extern struct list_head super_blocks;

/* Whether we react on sysrq keys or just ignore them */

int sysrq_enabled = 1;

/* Machine specific power off function */

void (*sysrq_power_off)(void);

/* Loglevel sysrq handler */

static void sysrq_handle_loglevel(int key, struct pt_regs *pt_regs,

                struct kbd_struct *kbd, struct tty_struct *tty) {

        int i;

        i = key - '0';

        console_loglevel = 7;

        printk("Loglevel set to %d\n", i);

        console_loglevel = i;

}

static struct sysrq_key_op sysrq_loglevel_op = {

        handler:        sysrq_handle_loglevel,

        help_msg:       "loglevel0-8",

        action_msg:     "Changing Loglevel",

};

/* SAK sysrq handler */

#ifdef CONFIG_VT

static void sysrq_handle_SAK(int key, struct pt_regs *pt_regs,

                struct kbd_struct *kbd, struct tty_struct *tty) {

        if (tty)

                do_SAK(tty);

        reset_vc(fg_console);

}

static struct sysrq_key_op sysrq_SAK_op = {

        handler:        sysrq_handle_SAK,

        help_msg:       "saK",

        action_msg:     "SAK",

};

#endif

/* unraw sysrq handler */

static void sysrq_handle_unraw(int key, struct pt_regs *pt_regs,

                struct kbd_struct *kbd, struct tty_struct *tty) {

        if (kbd)

                kbd->kbdmode = VC_XLATE;

}

static struct sysrq_key_op sysrq_unraw_op = {

        handler:        sysrq_handle_unraw,

        help_msg:       "unRaw",

        action_msg:     "Keyboard mode set to XLATE",

};

/* reboot sysrq handler */

static void sysrq_handle_reboot(int key, struct pt_regs *pt_regs,

                struct kbd_struct *kbd, struct tty_struct *tty) {

        machine_restart(NULL);

}

static struct sysrq_key_op sysrq_reboot_op = {

        handler:        sysrq_handle_reboot,

        help_msg:       "reBoot",

        action_msg:     "Resetting",

};

/* SYNC SYSRQ HANDLERS BLOCK */

/* do_emergency_sync helper function */

/* Guesses if the device is a local hard drive */

static int is_local_disk(kdev_t dev) {

        unsigned int major;

        major = MAJOR(dev);

        switch (major) {

        case IDE0_MAJOR:

        case IDE1_MAJOR:

        case IDE2_MAJOR:

        case IDE3_MAJOR:

        case IDE4_MAJOR:

        case IDE5_MAJOR:

        case IDE6_MAJOR:

        case IDE7_MAJOR:

        case IDE8_MAJOR:

        case IDE9_MAJOR:

        case SCSI_DISK0_MAJOR:

        case SCSI_DISK1_MAJOR:

        case SCSI_DISK2_MAJOR:

        case SCSI_DISK3_MAJOR:

        case SCSI_DISK4_MAJOR:

        case SCSI_DISK5_MAJOR:

        case SCSI_DISK6_MAJOR:

        case SCSI_DISK7_MAJOR:

        case XT_DISK_MAJOR:

                return 1;

        default:

                return 0;

        }

}

/* do_emergency_sync helper function */

static void go_sync(struct super_block *sb, int remount_flag)

{

        int orig_loglevel;

        orig_loglevel = console_loglevel;

        console_loglevel = 7;

        printk(KERN_INFO "%sing device %s ... ",

               remount_flag ? "Remount" : "Sync",

               kdevname(sb->s_dev));

        if (remount_flag) { /* Remount R/O */

                int ret, flags;

                struct list_head *p;

                if (sb->s_flags & MS_RDONLY) {

                        printk("R/O\n");

                        return;

                }

                file_list_lock();

                for (p = sb->s_files.next; p != &sb->s_files; p = p->next) {

                        struct file *file = list_entry(p, struct file, f_list);

                        if (file->f_dentry && file_count(file)

                                && S_ISREG(file->f_dentry->d_inode->i_mode))

                                file->f_mode &= ~2;

                }

                file_list_unlock();

                DQUOT_OFF(sb);

                fsync_dev(sb->s_dev);

                flags = MS_RDONLY;

                if (sb->s_op && sb->s_op->remount_fs) {

                        ret = sb->s_op->remount_fs(sb, &flags, NULL);

                        if (ret)

                                printk("error %d\n", ret);

                        else {

                                sb->s_flags = (sb->s_flags & ~MS_RMT_MASK) | (flags & MS_RMT_MASK);

                                printk("OK\n");

                        }

                } else

                        printk("nothing to do\n");

        } else { /* Sync only */

                fsync_dev(sb->s_dev);

                printk("OK\n");

        }

        console_loglevel = orig_loglevel;

}

/*

 * Emergency Sync or Unmount. We cannot do it directly, so we set a special

 * flag and wake up the bdflush kernel thread which immediately calls this function.

 * We process all mounted hard drives first to recover from crashed experimental

 * block devices and malfunctional network filesystems.

 */

volatile int emergency_sync_scheduled;

void do_emergency_sync(void) {

        struct super_block *sb;

        int remount_flag;

        int orig_loglevel;

        lock_kernel();

        remount_flag = (emergency_sync_scheduled == EMERG_REMOUNT);

        emergency_sync_scheduled = 0;

        for (sb = sb_entry(super_blocks.next);

             sb != sb_entry(&super_blocks);

             sb = sb_entry(sb->s_list.next))

                if (is_local_disk(sb->s_dev))

                        go_sync(sb, remount_flag);

        for (sb = sb_entry(super_blocks.next);

             sb != sb_entry(&super_blocks);

             sb = sb_entry(sb->s_list.next))

                if (!is_local_disk(sb->s_dev) && MAJOR(sb->s_dev))

                        go_sync(sb, remount_flag);

        unlock_kernel();

        orig_loglevel = console_loglevel;

        console_loglevel = 7;

        printk(KERN_INFO "Done.\n");

        console_loglevel = orig_loglevel;

}

static void sysrq_handle_sync(int key, struct pt_regs *pt_regs,

                struct kbd_struct *kbd, struct tty_struct *tty) {

        emergency_sync_scheduled = EMERG_SYNC;

        wakeup_bdflush();

}

static struct sysrq_key_op sysrq_sync_op = {

        handler:        sysrq_handle_sync,

        help_msg:       "Sync",

        action_msg:     "Emergency Sync",

};

static void sysrq_handle_mountro(int key, struct pt_regs *pt_regs,

                struct kbd_struct *kbd, struct tty_struct *tty) {

        emergency_sync_scheduled = EMERG_REMOUNT;

        wakeup_bdflush();

}

static struct sysrq_key_op sysrq_mountro_op = {

        handler:        sysrq_handle_mountro,

        help_msg:       "Unmount",

        action_msg:     "Emergency Remount R/O",

};

/* END SYNC SYSRQ HANDLERS BLOCK */

/* SHOW SYSRQ HANDLERS BLOCK */

static void sysrq_handle_showregs(int key, struct pt_regs *pt_regs,

                struct kbd_struct *kbd, struct tty_struct *tty) {

        if (pt_regs)

                show_regs(pt_regs);

}

static struct sysrq_key_op sysrq_showregs_op = {

        handler:        sysrq_handle_showregs,

        help_msg:       "showPc",

        action_msg:     "Show Regs",

};

static void sysrq_handle_showstate(int key, struct pt_regs *pt_regs,

                struct kbd_struct *kbd, struct tty_struct *tty) {

        show_state();

}

static struct sysrq_key_op sysrq_showstate_op = {

        handler:        sysrq_handle_showstate,

        help_msg:       "showTasks",

        action_msg:     "Show State",

};

static void sysrq_handle_showmem(int key, struct pt_regs *pt_regs,

                struct kbd_struct *kbd, struct tty_struct *tty) {

        show_mem();

}

static struct sysrq_key_op sysrq_showmem_op = {

        handler:        sysrq_handle_showmem,

        help_msg:       "showMem",

        action_msg:     "Show Memory",

};

/* SHOW SYSRQ HANDLERS BLOCK */

/* SIGNAL SYSRQ HANDLERS BLOCK */

/* signal sysrq helper function

 * Sends a signal to all user processes */

static void send_sig_all(int sig)

{

        struct task_struct *p;

        for_each_task(p) {

                if (p->mm && p->pid != 1)

                        /* Not swapper, init nor kernel thread */

                        force_sig(sig, p);

        }

}

static void sysrq_handle_term(int key, struct pt_regs *pt_regs,

                struct kbd_struct *kbd, struct tty_struct *tty) {

        send_sig_all(SIGTERM);

        console_loglevel = 8;

}

static struct sysrq_key_op sysrq_term_op = {

        handler:        sysrq_handle_term,

        help_msg:       "tErm",

        action_msg:     "Terminate All Tasks",

};

static void sysrq_handle_kill(int key, struct pt_regs *pt_regs,

                struct kbd_struct *kbd, struct tty_struct *tty) {

        send_sig_all(SIGKILL);

        console_loglevel = 8;

}

static struct sysrq_key_op sysrq_kill_op = {

        handler:        sysrq_handle_kill,

        help_msg:       "kIll",

        action_msg:     "Kill All Tasks",

};

/* END SIGNAL SYSRQ HANDLERS BLOCK */

/* Key Operations table and lock */

static spinlock_t sysrq_key_table_lock = SPIN_LOCK_UNLOCKED;

#define SYSRQ_KEY_TABLE_LENGTH 36

static struct sysrq_key_op *sysrq_key_table[SYSRQ_KEY_TABLE_LENGTH] = {

/* 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 */ &sysrq_loglevel_op,

/* a */ NULL, /* Don't use for system provided sysrqs,

                 it is handled specially on the spark

                 and will never arive */

/* b */ &sysrq_reboot_op,

/* c */ NULL,

/* d */ NULL,

/* e */ &sysrq_term_op,

/* f */ NULL,

/* g */ NULL,

/* h */ NULL,

/* i */ &sysrq_kill_op,

/* j */ NULL,

#ifdef CONFIG_VT

/* k */ &sysrq_SAK_op,

#else

/* k */ NULL,

#endif

/* l */ NULL,

/* m */ &sysrq_showmem_op,

/* n */ NULL,

/* o */ NULL, /* This will often be registered

                 as 'Off' at init time */

/* p */ &sysrq_showregs_op,

/* q */ NULL,

/* r */ &sysrq_unraw_op,

/* s */ &sysrq_sync_op,

/* t */ &sysrq_showstate_op,

/* u */ &sysrq_mountro_op,

/* v */ NULL,

/* w */ NULL,

/* x */ NULL,

/* w */ NULL,

/* z */ NULL

};

/* key2index calculation, -1 on invalid index */

static __inline__ int sysrq_key_table_key2index(int key) {

        int retval;

        if ((key >= '0') && (key <= '9')) {

                retval = key - '0';

        } else if ((key >= 'a') && (key <= 'z')) {

                retval = key + 10 - 'a';

        } else {

                retval = -1;

        }

        return retval;

}

/*

 * table lock and unlocking functions, exposed to modules

 */

void __sysrq_lock_table (void) { spin_lock(&sysrq_key_table_lock); }

void __sysrq_unlock_table (void) { spin_unlock(&sysrq_key_table_lock); }

/*

 * get and put functions for the table, exposed to modules.

 */

struct sysrq_key_op *__sysrq_get_key_op (int key) {

        struct sysrq_key_op *op_p;

        int i;

        i = sysrq_key_table_key2index(key);

        op_p = (i == -1) ? NULL : sysrq_key_table[i];

        return op_p;

}

void __sysrq_put_key_op (int key, struct sysrq_key_op *op_p) {

        int i;

        i = sysrq_key_table_key2index(key);

        if (i != -1)

                sysrq_key_table[i] = op_p;

}

/*

 * This function is called by the keyboard handler when SysRq is pressed

 * and any other keycode arrives.

 */

void handle_sysrq(int key, struct pt_regs *pt_regs,

                  struct kbd_struct *kbd, struct tty_struct *tty) {

        if (!sysrq_enabled)

                return;

        __sysrq_lock_table();

        __handle_sysrq_nolock(key, pt_regs, kbd, tty);

        __sysrq_unlock_table();

}

/*

 * This is the non-locking version of handle_sysrq

 * It must/can only be called by sysrq key handlers,

 * as they are inside of the lock

 */

void __handle_sysrq_nolock(int key, struct pt_regs *pt_regs,

                  struct kbd_struct *kbd, struct tty_struct *tty) {

        struct sysrq_key_op *op_p;

        int orig_log_level;

        int i, j;

        if (!sysrq_enabled)

                return;

        orig_log_level = console_loglevel;

        console_loglevel = 7;

        printk(KERN_INFO "SysRq : ");

        op_p = __sysrq_get_key_op(key);

        if (op_p) {

                printk ("%s\n", op_p->action_msg);

                console_loglevel = orig_log_level;

                op_p->handler(key, pt_regs, kbd, tty);

        } else {

                printk("HELP : ");

                /* Only print the help msg once per handler */

                for (i=0; i<SYSRQ_KEY_TABLE_LENGTH; i++)

                if (sysrq_key_table[i]) {

                        for (j=0; sysrq_key_table[i] != sysrq_key_table[j]; j++);

                        if (j == i)

                                printk ("%s ", sysrq_key_table[i]->help_msg);

                }

                printk ("\n");

                console_loglevel = orig_log_level;

        }

}

EXPORT_SYMBOL(handle_sysrq);

EXPORT_SYMBOL(__handle_sysrq_nolock);

EXPORT_SYMBOL(__sysrq_lock_table);

EXPORT_SYMBOL(__sysrq_unlock_table);

EXPORT_SYMBOL(__sysrq_get_key_op);

EXPORT_SYMBOL(__sysrq_put_key_op);