4 * A watchdog timer based upon the IPMI interface.
6 * Author: MontaVista Software, Inc.
7 * Corey Minyard <minyard@mvista.com>
10 * Copyright 2002 MontaVista Software Inc.
12 * This program is free software; you can redistribute it and/or modify it
13 * under the terms of the GNU General Public License as published by the
14 * Free Software Foundation; either version 2 of the License, or (at your
15 * option) any later version.
18 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
19 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
20 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
23 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
24 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
25 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
26 * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
27 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 * You should have received a copy of the GNU General Public License along
30 * with this program; if not, write to the Free Software Foundation, Inc.,
31 * 675 Mass Ave, Cambridge, MA 02139, USA.
34 #include <linux/config.h>
35 #include <linux/module.h>
36 #include <linux/moduleparam.h>
37 #include <linux/ipmi.h>
38 #include <linux/ipmi_smi.h>
39 #include <linux/watchdog.h>
40 #include <linux/miscdevice.h>
41 #include <linux/init.h>
42 #include <linux/rwsem.h>
43 #include <linux/errno.h>
44 #include <asm/uaccess.h>
45 #include <linux/notifier.h>
46 #include <linux/nmi.h>
47 #include <linux/reboot.h>
48 #include <linux/wait.h>
49 #include <linux/poll.h>
50 #ifdef CONFIG_X86_LOCAL_APIC
54 #define IPMI_WATCHDOG_VERSION "v32"
57 * The IPMI command/response information for the watchdog timer.
60 /* values for byte 1 of the set command, byte 2 of the get response. */
61 #define WDOG_DONT_LOG (1 << 7)
62 #define WDOG_DONT_STOP_ON_SET (1 << 6)
63 #define WDOG_SET_TIMER_USE(byte, use) \
64 byte = ((byte) & 0xf8) | ((use) & 0x7)
65 #define WDOG_GET_TIMER_USE(byte) ((byte) & 0x7)
66 #define WDOG_TIMER_USE_BIOS_FRB2 1
67 #define WDOG_TIMER_USE_BIOS_POST 2
68 #define WDOG_TIMER_USE_OS_LOAD 3
69 #define WDOG_TIMER_USE_SMS_OS 4
70 #define WDOG_TIMER_USE_OEM 5
72 /* values for byte 2 of the set command, byte 3 of the get response. */
73 #define WDOG_SET_PRETIMEOUT_ACT(byte, use) \
74 byte = ((byte) & 0x8f) | (((use) & 0x7) << 4)
75 #define WDOG_GET_PRETIMEOUT_ACT(byte) (((byte) >> 4) & 0x7)
76 #define WDOG_PRETIMEOUT_NONE 0
77 #define WDOG_PRETIMEOUT_SMI 1
78 #define WDOG_PRETIMEOUT_NMI 2
79 #define WDOG_PRETIMEOUT_MSG_INT 3
81 /* Operations that can be performed on a pretimout. */
82 #define WDOG_PREOP_NONE 0
83 #define WDOG_PREOP_PANIC 1
84 #define WDOG_PREOP_GIVE_DATA 2 /* Cause data to be available to
85 read. Doesn't work in NMI
88 /* Actions to perform on a full timeout. */
89 #define WDOG_SET_TIMEOUT_ACT(byte, use) \
90 byte = ((byte) & 0xf8) | ((use) & 0x7)
91 #define WDOG_GET_TIMEOUT_ACT(byte) ((byte) & 0x7)
92 #define WDOG_TIMEOUT_NONE 0
93 #define WDOG_TIMEOUT_RESET 1
94 #define WDOG_TIMEOUT_POWER_DOWN 2
95 #define WDOG_TIMEOUT_POWER_CYCLE 3
97 /* Byte 3 of the get command, byte 4 of the get response is the
98 pre-timeout in seconds. */
100 /* Bits for setting byte 4 of the set command, byte 5 of the get response. */
101 #define WDOG_EXPIRE_CLEAR_BIOS_FRB2 (1 << 1)
102 #define WDOG_EXPIRE_CLEAR_BIOS_POST (1 << 2)
103 #define WDOG_EXPIRE_CLEAR_OS_LOAD (1 << 3)
104 #define WDOG_EXPIRE_CLEAR_SMS_OS (1 << 4)
105 #define WDOG_EXPIRE_CLEAR_OEM (1 << 5)
107 /* Setting/getting the watchdog timer value. This is for bytes 5 and
108 6 (the timeout time) of the set command, and bytes 6 and 7 (the
109 timeout time) and 8 and 9 (the current countdown value) of the
110 response. The timeout value is given in seconds (in the command it
111 is 100ms intervals). */
112 #define WDOG_SET_TIMEOUT(byte1, byte2, val) \
113 (byte1) = (((val) * 10) & 0xff), (byte2) = (((val) * 10) >> 8)
114 #define WDOG_GET_TIMEOUT(byte1, byte2) \
115 (((byte1) | ((byte2) << 8)) / 10)
117 #define IPMI_WDOG_RESET_TIMER 0x22
118 #define IPMI_WDOG_SET_TIMER 0x24
119 #define IPMI_WDOG_GET_TIMER 0x25
121 /* These are here until the real ones get into the watchdog.h interface. */
122 #ifndef WDIOC_GETTIMEOUT
123 #define WDIOC_GETTIMEOUT _IOW(WATCHDOG_IOCTL_BASE, 20, int)
125 #ifndef WDIOC_SET_PRETIMEOUT
126 #define WDIOC_SET_PRETIMEOUT _IOW(WATCHDOG_IOCTL_BASE, 21, int)
128 #ifndef WDIOC_GET_PRETIMEOUT
129 #define WDIOC_GET_PRETIMEOUT _IOW(WATCHDOG_IOCTL_BASE, 22, int)
132 static ipmi_user_t watchdog_user = NULL;
134 /* Default the timeout to 10 seconds. */
135 static int timeout = 10;
137 /* The pre-timeout is disabled by default. */
138 static int pretimeout = 0;
140 /* Default action is to reset the board on a timeout. */
141 static unsigned char action_val = WDOG_TIMEOUT_RESET;
143 static char action[16] = "reset";
145 static unsigned char preaction_val = WDOG_PRETIMEOUT_NONE;
147 static char preaction[16] = "pre_none";
149 static unsigned char preop_val = WDOG_PREOP_NONE;
151 static char preop[16] = "preop_none";
152 static spinlock_t ipmi_read_lock = SPIN_LOCK_UNLOCKED;
153 static char data_to_read = 0;
154 static DECLARE_WAIT_QUEUE_HEAD(read_q);
155 static struct fasync_struct *fasync_q = NULL;
156 static char pretimeout_since_last_heartbeat = 0;
158 /* If true, the driver will start running as soon as it is configured
160 static int start_now = 0;
162 module_param(timeout, int, 0);
163 MODULE_PARM_DESC(timeout, "Timeout value in seconds.");
164 module_param(pretimeout, int, 0);
165 MODULE_PARM_DESC(pretimeout, "Pretimeout value in seconds.");
166 module_param_string(action, action, sizeof(action), 0);
167 MODULE_PARM_DESC(action, "Timeout action. One of: "
168 "reset, none, power_cycle, power_off.");
169 module_param_string(preaction, preaction, sizeof(preaction), 0);
170 MODULE_PARM_DESC(preaction, "Pretimeout action. One of: "
171 "pre_none, pre_smi, pre_nmi, pre_int.");
172 module_param_string(preop, preop, sizeof(preop), 0);
173 MODULE_PARM_DESC(preop, "Pretimeout driver operation. One of: "
174 "preop_none, preop_panic, preop_give_data.");
175 module_param(start_now, int, 0);
176 MODULE_PARM_DESC(start_now, "Set to 1 to start the watchdog as"
177 "soon as the driver is loaded.");
179 /* Default state of the timer. */
180 static unsigned char ipmi_watchdog_state = WDOG_TIMEOUT_NONE;
182 /* If shutting down via IPMI, we ignore the heartbeat. */
183 static int ipmi_ignore_heartbeat = 0;
185 /* Is someone using the watchdog? Only one user is allowed. */
186 static int ipmi_wdog_open = 0;
188 /* If set to 1, the heartbeat command will set the state to reset and
189 start the timer. The timer doesn't normally run when the driver is
190 first opened until the heartbeat is set the first time, this
191 variable is used to accomplish this. */
192 static int ipmi_start_timer_on_heartbeat = 0;
194 /* IPMI version of the BMC. */
195 static unsigned char ipmi_version_major;
196 static unsigned char ipmi_version_minor;
199 static int ipmi_heartbeat(void);
200 static void panic_halt_ipmi_heartbeat(void);
203 /* We use a semaphore to make sure that only one thing can send a set
204 timeout at one time, because we only have one copy of the data.
205 The semaphore is claimed when the set_timeout is sent and freed
206 when both messages are free. */
207 static atomic_t set_timeout_tofree = ATOMIC_INIT(0);
208 static DECLARE_MUTEX(set_timeout_lock);
209 static void set_timeout_free_smi(struct ipmi_smi_msg *msg)
211 if (atomic_dec_and_test(&set_timeout_tofree))
212 up(&set_timeout_lock);
214 static void set_timeout_free_recv(struct ipmi_recv_msg *msg)
216 if (atomic_dec_and_test(&set_timeout_tofree))
217 up(&set_timeout_lock);
219 static struct ipmi_smi_msg set_timeout_smi_msg =
221 .done = set_timeout_free_smi
223 static struct ipmi_recv_msg set_timeout_recv_msg =
225 .done = set_timeout_free_recv
228 static int i_ipmi_set_timeout(struct ipmi_smi_msg *smi_msg,
229 struct ipmi_recv_msg *recv_msg,
230 int *send_heartbeat_now)
233 unsigned char data[6];
235 struct ipmi_system_interface_addr addr;
240 WDOG_SET_TIMER_USE(data[0], WDOG_TIMER_USE_SMS_OS);
242 if ((ipmi_version_major > 1)
243 || ((ipmi_version_major == 1) && (ipmi_version_minor >= 5)))
245 /* This is an IPMI 1.5-only feature. */
246 data[0] |= WDOG_DONT_STOP_ON_SET;
247 } else if (ipmi_watchdog_state != WDOG_TIMEOUT_NONE) {
248 /* In ipmi 1.0, setting the timer stops the watchdog, we
249 need to start it back up again. */
254 WDOG_SET_TIMEOUT_ACT(data[1], ipmi_watchdog_state);
255 if (pretimeout > 0) {
256 WDOG_SET_PRETIMEOUT_ACT(data[1], preaction_val);
257 data[2] = pretimeout;
259 WDOG_SET_PRETIMEOUT_ACT(data[1], WDOG_PRETIMEOUT_NONE);
260 data[2] = 0; /* No pretimeout. */
263 WDOG_SET_TIMEOUT(data[4], data[5], timeout);
265 addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
266 addr.channel = IPMI_BMC_CHANNEL;
270 msg.cmd = IPMI_WDOG_SET_TIMER;
272 msg.data_len = sizeof(data);
273 rv = ipmi_request_supply_msgs(watchdog_user,
274 (struct ipmi_addr *) &addr,
282 printk(KERN_WARNING "IPMI Watchdog, set timeout error: %d\n",
286 if (send_heartbeat_now)
287 *send_heartbeat_now = hbnow;
292 /* Parameters to ipmi_set_timeout */
293 #define IPMI_SET_TIMEOUT_NO_HB 0
294 #define IPMI_SET_TIMEOUT_HB_IF_NECESSARY 1
295 #define IPMI_SET_TIMEOUT_FORCE_HB 2
297 static int ipmi_set_timeout(int do_heartbeat)
299 int send_heartbeat_now;
303 /* We can only send one of these at a time. */
304 down(&set_timeout_lock);
306 atomic_set(&set_timeout_tofree, 2);
308 rv = i_ipmi_set_timeout(&set_timeout_smi_msg,
309 &set_timeout_recv_msg,
310 &send_heartbeat_now);
312 up(&set_timeout_lock);
314 if ((do_heartbeat == IPMI_SET_TIMEOUT_FORCE_HB)
315 || ((send_heartbeat_now)
316 && (do_heartbeat == IPMI_SET_TIMEOUT_HB_IF_NECESSARY)))
318 rv = ipmi_heartbeat();
325 static void dummy_smi_free(struct ipmi_smi_msg *msg)
328 static void dummy_recv_free(struct ipmi_recv_msg *msg)
331 static struct ipmi_smi_msg panic_halt_smi_msg =
333 .done = dummy_smi_free
335 static struct ipmi_recv_msg panic_halt_recv_msg =
337 .done = dummy_recv_free
340 /* Special call, doesn't claim any locks. This is only to be called
341 at panic or halt time, in run-to-completion mode, when the caller
342 is the only CPU and the only thing that will be going is these IPMI
344 static void panic_halt_ipmi_set_timeout(void)
346 int send_heartbeat_now;
349 rv = i_ipmi_set_timeout(&panic_halt_smi_msg,
350 &panic_halt_recv_msg,
351 &send_heartbeat_now);
353 if (send_heartbeat_now)
354 panic_halt_ipmi_heartbeat();
358 /* Do a delayed shutdown, with the delay in milliseconds. If power_off is
359 false, do a reset. If power_off is true, do a power down. This is
360 primarily for the IMB code's shutdown. */
361 void ipmi_delayed_shutdown(long delay, int power_off)
363 ipmi_ignore_heartbeat = 1;
365 ipmi_watchdog_state = WDOG_TIMEOUT_POWER_DOWN;
367 ipmi_watchdog_state = WDOG_TIMEOUT_RESET;
369 ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY);
372 /* We use a semaphore to make sure that only one thing can send a
373 heartbeat at one time, because we only have one copy of the data.
374 The semaphore is claimed when the set_timeout is sent and freed
375 when both messages are free. */
376 static atomic_t heartbeat_tofree = ATOMIC_INIT(0);
377 static DECLARE_MUTEX(heartbeat_lock);
378 static DECLARE_MUTEX_LOCKED(heartbeat_wait_lock);
379 static void heartbeat_free_smi(struct ipmi_smi_msg *msg)
381 if (atomic_dec_and_test(&heartbeat_tofree))
382 up(&heartbeat_wait_lock);
384 static void heartbeat_free_recv(struct ipmi_recv_msg *msg)
386 if (atomic_dec_and_test(&heartbeat_tofree))
387 up(&heartbeat_wait_lock);
389 static struct ipmi_smi_msg heartbeat_smi_msg =
391 .done = heartbeat_free_smi
393 static struct ipmi_recv_msg heartbeat_recv_msg =
395 .done = heartbeat_free_recv
398 static struct ipmi_smi_msg panic_halt_heartbeat_smi_msg =
400 .done = dummy_smi_free
402 static struct ipmi_recv_msg panic_halt_heartbeat_recv_msg =
404 .done = dummy_recv_free
407 static int ipmi_heartbeat(void)
411 struct ipmi_system_interface_addr addr;
413 if (ipmi_ignore_heartbeat) {
417 if (ipmi_start_timer_on_heartbeat) {
418 ipmi_start_timer_on_heartbeat = 0;
419 ipmi_watchdog_state = action_val;
420 return ipmi_set_timeout(IPMI_SET_TIMEOUT_FORCE_HB);
421 } else if (pretimeout_since_last_heartbeat) {
422 /* A pretimeout occurred, make sure we set the timeout.
423 We don't want to set the action, though, we want to
424 leave that alone (thus it can't be combined with the
426 pretimeout_since_last_heartbeat = 0;
427 return ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY);
430 down(&heartbeat_lock);
432 atomic_set(&heartbeat_tofree, 2);
434 /* Don't reset the timer if we have the timer turned off, that
435 re-enables the watchdog. */
436 if (ipmi_watchdog_state == WDOG_TIMEOUT_NONE) {
441 addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
442 addr.channel = IPMI_BMC_CHANNEL;
446 msg.cmd = IPMI_WDOG_RESET_TIMER;
449 rv = ipmi_request_supply_msgs(watchdog_user,
450 (struct ipmi_addr *) &addr,
459 printk(KERN_WARNING "IPMI Watchdog, heartbeat failure: %d\n",
464 /* Wait for the heartbeat to be sent. */
465 down(&heartbeat_wait_lock);
467 if (heartbeat_recv_msg.msg.data[0] != 0) {
468 /* Got an error in the heartbeat response. It was already
469 reported in ipmi_wdog_msg_handler, but we should return
479 static void panic_halt_ipmi_heartbeat(void)
482 struct ipmi_system_interface_addr addr;
485 /* Don't reset the timer if we have the timer turned off, that
486 re-enables the watchdog. */
487 if (ipmi_watchdog_state == WDOG_TIMEOUT_NONE)
490 addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
491 addr.channel = IPMI_BMC_CHANNEL;
495 msg.cmd = IPMI_WDOG_RESET_TIMER;
498 ipmi_request_supply_msgs(watchdog_user,
499 (struct ipmi_addr *) &addr,
503 &panic_halt_heartbeat_smi_msg,
504 &panic_halt_heartbeat_recv_msg,
508 static struct watchdog_info ident=
510 0, /* WDIOF_SETTIMEOUT, */
515 static int ipmi_ioctl(struct inode *inode, struct file *file,
516 unsigned int cmd, unsigned long arg)
518 void __user *argp = (void __user *)arg;
523 case WDIOC_GETSUPPORT:
524 i = copy_to_user(argp, &ident, sizeof(ident));
525 return i ? -EFAULT : 0;
527 case WDIOC_SETTIMEOUT:
528 i = copy_from_user(&val, argp, sizeof(int));
532 return ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY);
534 case WDIOC_GETTIMEOUT:
535 i = copy_to_user(argp, &timeout, sizeof(timeout));
540 case WDIOC_SET_PRETIMEOUT:
541 i = copy_from_user(&val, argp, sizeof(int));
545 return ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY);
547 case WDIOC_GET_PRETIMEOUT:
548 i = copy_to_user(argp, &pretimeout, sizeof(pretimeout));
553 case WDIOC_KEEPALIVE:
554 return ipmi_heartbeat();
556 case WDIOC_SETOPTIONS:
557 i = copy_from_user(&val, argp, sizeof(int));
560 if (val & WDIOS_DISABLECARD)
562 ipmi_watchdog_state = WDOG_TIMEOUT_NONE;
563 ipmi_set_timeout(IPMI_SET_TIMEOUT_NO_HB);
564 ipmi_start_timer_on_heartbeat = 0;
567 if (val & WDIOS_ENABLECARD)
569 ipmi_watchdog_state = action_val;
570 ipmi_set_timeout(IPMI_SET_TIMEOUT_FORCE_HB);
574 case WDIOC_GETSTATUS:
576 i = copy_to_user(argp, &val, sizeof(val));
586 static ssize_t ipmi_write(struct file *file,
587 const char __user *buf,
593 /* Can't seek (pwrite) on this device */
594 if (ppos != &file->f_pos)
598 rv = ipmi_heartbeat();
606 static ssize_t ipmi_read(struct file *file,
614 /* Can't seek (pread) on this device */
615 if (ppos != &file->f_pos)
621 /* Reading returns if the pretimeout has gone off, and it only does
622 it once per pretimeout. */
623 spin_lock(&ipmi_read_lock);
625 if (file->f_flags & O_NONBLOCK) {
630 init_waitqueue_entry(&wait, current);
631 add_wait_queue(&read_q, &wait);
632 while (!data_to_read) {
633 set_current_state(TASK_INTERRUPTIBLE);
634 spin_unlock(&ipmi_read_lock);
636 spin_lock(&ipmi_read_lock);
638 remove_wait_queue(&read_q, &wait);
640 if (signal_pending(current)) {
648 spin_unlock(&ipmi_read_lock);
651 if (copy_to_user(buf, &data_to_read, 1))
660 static int ipmi_open(struct inode *ino, struct file *filep)
670 /* Don't start the timer now, let it start on the
672 ipmi_start_timer_on_heartbeat = 1;
680 static unsigned int ipmi_poll(struct file *file, poll_table *wait)
682 unsigned int mask = 0;
684 poll_wait(file, &read_q, wait);
686 spin_lock(&ipmi_read_lock);
688 mask |= (POLLIN | POLLRDNORM);
689 spin_unlock(&ipmi_read_lock);
694 static int ipmi_fasync(int fd, struct file *file, int on)
698 result = fasync_helper(fd, file, on, &fasync_q);
703 static int ipmi_close(struct inode *ino, struct file *filep)
705 if (iminor(ino)==WATCHDOG_MINOR)
707 #ifndef CONFIG_WATCHDOG_NOWAYOUT
708 ipmi_watchdog_state = WDOG_TIMEOUT_NONE;
709 ipmi_set_timeout(IPMI_SET_TIMEOUT_NO_HB);
714 ipmi_fasync (-1, filep, 0);
719 static struct file_operations ipmi_wdog_fops = {
720 .owner = THIS_MODULE,
726 .release = ipmi_close,
727 .fasync = ipmi_fasync,
730 static struct miscdevice ipmi_wdog_miscdev = {
736 static DECLARE_RWSEM(register_sem);
738 static void ipmi_wdog_msg_handler(struct ipmi_recv_msg *msg,
741 if (msg->msg.data[0] != 0) {
742 printk(KERN_ERR "IPMI Watchdog response: Error %x on cmd %x\n",
747 ipmi_free_recv_msg(msg);
750 static void ipmi_wdog_pretimeout_handler(void *handler_data)
752 if (preaction_val != WDOG_PRETIMEOUT_NONE) {
753 if (preop_val == WDOG_PREOP_PANIC)
754 panic("Watchdog pre-timeout");
755 else if (preop_val == WDOG_PREOP_GIVE_DATA) {
756 spin_lock(&ipmi_read_lock);
758 wake_up_interruptible(&read_q);
759 kill_fasync(&fasync_q, SIGIO, POLL_IN);
761 spin_unlock(&ipmi_read_lock);
765 /* On some machines, the heartbeat will give
766 an error and not work unless we re-enable
767 the timer. So do so. */
768 pretimeout_since_last_heartbeat = 1;
771 static struct ipmi_user_hndl ipmi_hndlrs =
773 .ipmi_recv_hndl = ipmi_wdog_msg_handler,
774 .ipmi_watchdog_pretimeout = ipmi_wdog_pretimeout_handler
777 static void ipmi_register_watchdog(int ipmi_intf)
781 down_write(®ister_sem);
785 rv = ipmi_create_user(ipmi_intf, &ipmi_hndlrs, NULL, &watchdog_user);
787 printk("IPMI watchdog: Unable to register with ipmi\n");
791 ipmi_get_version(watchdog_user,
793 &ipmi_version_minor);
795 rv = misc_register(&ipmi_wdog_miscdev);
797 ipmi_destroy_user(watchdog_user);
798 watchdog_user = NULL;
799 printk("IPMI watchdog: Unable to register misc device\n");
803 up_write(®ister_sem);
805 if ((start_now) && (rv == 0)) {
806 /* Run from startup, so start the timer now. */
807 start_now = 0; /* Disable this function after first startup. */
808 ipmi_watchdog_state = action_val;
809 ipmi_set_timeout(IPMI_SET_TIMEOUT_FORCE_HB);
810 printk("Starting IPMI Watchdog now!\n");
814 #ifdef HAVE_NMI_HANDLER
816 ipmi_nmi(void *dev_id, struct pt_regs *regs, int cpu, int handled)
818 /* If no one else handled the NMI, we assume it was the IPMI
820 if ((!handled) && (preop_val == WDOG_PREOP_PANIC))
821 panic("IPMI watchdog pre-timeout");
823 /* On some machines, the heartbeat will give
824 an error and not work unless we re-enable
825 the timer. So do so. */
826 pretimeout_since_last_heartbeat = 1;
831 static struct nmi_handler ipmi_nmi_handler =
833 .link = LIST_HEAD_INIT(ipmi_nmi_handler.link),
834 .dev_name = "ipmi_watchdog",
837 .priority = 0, /* Call us last. */
841 static int wdog_reboot_handler(struct notifier_block *this,
845 static int reboot_event_handled = 0;
847 if ((watchdog_user) && (!reboot_event_handled)) {
848 /* Make sure we only do this once. */
849 reboot_event_handled = 1;
851 if (code == SYS_DOWN || code == SYS_HALT) {
852 /* Disable the WDT if we are shutting down. */
853 ipmi_watchdog_state = WDOG_TIMEOUT_NONE;
854 panic_halt_ipmi_set_timeout();
856 /* Set a long timer to let the reboot happens, but
857 reboot if it hangs. */
860 ipmi_watchdog_state = WDOG_TIMEOUT_RESET;
861 panic_halt_ipmi_set_timeout();
867 static struct notifier_block wdog_reboot_notifier = {
873 extern int panic_timeout; /* Why isn't this defined anywhere? */
875 static int wdog_panic_handler(struct notifier_block *this,
879 static int panic_event_handled = 0;
881 /* On a panic, if we have a panic timeout, make sure that the thing
882 reboots, even if it hangs during that panic. */
883 if (watchdog_user && !panic_event_handled) {
884 /* Make sure the panic doesn't hang, and make sure we
885 do this only once. */
886 panic_event_handled = 1;
890 ipmi_watchdog_state = WDOG_TIMEOUT_RESET;
891 panic_halt_ipmi_set_timeout();
897 static struct notifier_block wdog_panic_notifier = {
900 150 /* priority: INT_MAX >= x >= 0 */
904 static void ipmi_new_smi(int if_num)
906 ipmi_register_watchdog(if_num);
909 static void ipmi_smi_gone(int if_num)
911 /* This can never be called, because once the watchdog is
912 registered, the interface can't go away until the watchdog
916 static struct ipmi_smi_watcher smi_watcher =
918 .owner = THIS_MODULE,
919 .new_smi = ipmi_new_smi,
920 .smi_gone = ipmi_smi_gone
923 static int __init ipmi_wdog_init(void)
927 printk(KERN_INFO "IPMI watchdog driver version "
928 IPMI_WATCHDOG_VERSION "\n");
930 if (strcmp(action, "reset") == 0) {
931 action_val = WDOG_TIMEOUT_RESET;
932 } else if (strcmp(action, "none") == 0) {
933 action_val = WDOG_TIMEOUT_NONE;
934 } else if (strcmp(action, "power_cycle") == 0) {
935 action_val = WDOG_TIMEOUT_POWER_CYCLE;
936 } else if (strcmp(action, "power_off") == 0) {
937 action_val = WDOG_TIMEOUT_POWER_DOWN;
939 action_val = WDOG_TIMEOUT_RESET;
940 printk("ipmi_watchdog: Unknown action '%s', defaulting to"
944 if (strcmp(preaction, "pre_none") == 0) {
945 preaction_val = WDOG_PRETIMEOUT_NONE;
946 } else if (strcmp(preaction, "pre_smi") == 0) {
947 preaction_val = WDOG_PRETIMEOUT_SMI;
948 #ifdef HAVE_NMI_HANDLER
949 } else if (strcmp(preaction, "pre_nmi") == 0) {
950 preaction_val = WDOG_PRETIMEOUT_NMI;
952 } else if (strcmp(preaction, "pre_int") == 0) {
953 preaction_val = WDOG_PRETIMEOUT_MSG_INT;
955 preaction_val = WDOG_PRETIMEOUT_NONE;
956 printk("ipmi_watchdog: Unknown preaction '%s', defaulting to"
957 " none\n", preaction);
960 if (strcmp(preop, "preop_none") == 0) {
961 preop_val = WDOG_PREOP_NONE;
962 } else if (strcmp(preop, "preop_panic") == 0) {
963 preop_val = WDOG_PREOP_PANIC;
964 } else if (strcmp(preop, "preop_give_data") == 0) {
965 preop_val = WDOG_PREOP_GIVE_DATA;
967 preop_val = WDOG_PREOP_NONE;
968 printk("ipmi_watchdog: Unknown preop '%s', defaulting to"
972 #ifdef HAVE_NMI_HANDLER
973 if (preaction_val == WDOG_PRETIMEOUT_NMI) {
974 if (preop_val == WDOG_PREOP_GIVE_DATA) {
976 "ipmi_watchdog: Pretimeout op is to give data"
977 " but NMI pretimeout is enabled, setting"
978 " pretimeout op to none\n");
979 preop_val = WDOG_PREOP_NONE;
981 #ifdef CONFIG_X86_LOCAL_APIC
982 if (nmi_watchdog == NMI_IO_APIC) {
984 "ipmi_watchdog: nmi_watchdog is set to IO APIC"
985 " mode (value is %d), that is incompatible"
986 " with using NMI in the IPMI watchdog."
987 " Disabling IPMI nmi pretimeout.\n",
989 preaction_val = WDOG_PRETIMEOUT_NONE;
992 rv = request_nmi(&ipmi_nmi_handler);
995 "ipmi_watchdog: Can't register nmi handler\n");
998 #ifdef CONFIG_X86_LOCAL_APIC
1004 rv = ipmi_smi_watcher_register(&smi_watcher);
1006 #ifdef HAVE_NMI_HANDLER
1007 if (preaction_val == WDOG_PRETIMEOUT_NMI)
1008 release_nmi(&ipmi_nmi_handler);
1011 "ipmi_watchdog: can't register smi watcher\n");
1015 register_reboot_notifier(&wdog_reboot_notifier);
1016 notifier_chain_register(&panic_notifier_list, &wdog_panic_notifier);
1021 static __exit void ipmi_unregister_watchdog(void)
1025 down_write(®ister_sem);
1027 #ifdef HAVE_NMI_HANDLER
1028 if (preaction_val == WDOG_PRETIMEOUT_NMI)
1029 release_nmi(&ipmi_nmi_handler);
1032 notifier_chain_unregister(&panic_notifier_list, &wdog_panic_notifier);
1033 unregister_reboot_notifier(&wdog_reboot_notifier);
1035 if (! watchdog_user)
1038 /* Make sure no one can call us any more. */
1039 misc_deregister(&ipmi_wdog_miscdev);
1041 /* Disable the timer. */
1042 ipmi_watchdog_state = WDOG_TIMEOUT_NONE;
1043 ipmi_set_timeout(IPMI_SET_TIMEOUT_NO_HB);
1045 /* Wait to make sure the message makes it out. The lower layer has
1046 pointers to our buffers, we want to make sure they are done before
1047 we release our memory. */
1048 while (atomic_read(&set_timeout_tofree)) {
1049 set_current_state(TASK_UNINTERRUPTIBLE);
1050 schedule_timeout(1);
1053 /* Disconnect from IPMI. */
1054 rv = ipmi_destroy_user(watchdog_user);
1057 "IPMI Watchdog, error unlinking from IPMI: %d\n",
1060 watchdog_user = NULL;
1063 up_write(®ister_sem);
1066 static void __exit ipmi_wdog_exit(void)
1068 ipmi_smi_watcher_unregister(&smi_watcher);
1069 ipmi_unregister_watchdog();
1071 module_exit(ipmi_wdog_exit);
1073 EXPORT_SYMBOL(ipmi_delayed_shutdown);
1075 module_init(ipmi_wdog_init);
1076 MODULE_LICENSE("GPL");