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 #include <linux/string.h>
51 #include <linux/ctype.h>
52 #ifdef CONFIG_X86_LOCAL_APIC
56 #define PFX "IPMI Watchdog: "
59 * The IPMI command/response information for the watchdog timer.
62 /* values for byte 1 of the set command, byte 2 of the get response. */
63 #define WDOG_DONT_LOG (1 << 7)
64 #define WDOG_DONT_STOP_ON_SET (1 << 6)
65 #define WDOG_SET_TIMER_USE(byte, use) \
66 byte = ((byte) & 0xf8) | ((use) & 0x7)
67 #define WDOG_GET_TIMER_USE(byte) ((byte) & 0x7)
68 #define WDOG_TIMER_USE_BIOS_FRB2 1
69 #define WDOG_TIMER_USE_BIOS_POST 2
70 #define WDOG_TIMER_USE_OS_LOAD 3
71 #define WDOG_TIMER_USE_SMS_OS 4
72 #define WDOG_TIMER_USE_OEM 5
74 /* values for byte 2 of the set command, byte 3 of the get response. */
75 #define WDOG_SET_PRETIMEOUT_ACT(byte, use) \
76 byte = ((byte) & 0x8f) | (((use) & 0x7) << 4)
77 #define WDOG_GET_PRETIMEOUT_ACT(byte) (((byte) >> 4) & 0x7)
78 #define WDOG_PRETIMEOUT_NONE 0
79 #define WDOG_PRETIMEOUT_SMI 1
80 #define WDOG_PRETIMEOUT_NMI 2
81 #define WDOG_PRETIMEOUT_MSG_INT 3
83 /* Operations that can be performed on a pretimout. */
84 #define WDOG_PREOP_NONE 0
85 #define WDOG_PREOP_PANIC 1
86 #define WDOG_PREOP_GIVE_DATA 2 /* Cause data to be available to
87 read. Doesn't work in NMI
90 /* Actions to perform on a full timeout. */
91 #define WDOG_SET_TIMEOUT_ACT(byte, use) \
92 byte = ((byte) & 0xf8) | ((use) & 0x7)
93 #define WDOG_GET_TIMEOUT_ACT(byte) ((byte) & 0x7)
94 #define WDOG_TIMEOUT_NONE 0
95 #define WDOG_TIMEOUT_RESET 1
96 #define WDOG_TIMEOUT_POWER_DOWN 2
97 #define WDOG_TIMEOUT_POWER_CYCLE 3
99 /* Byte 3 of the get command, byte 4 of the get response is the
100 pre-timeout in seconds. */
102 /* Bits for setting byte 4 of the set command, byte 5 of the get response. */
103 #define WDOG_EXPIRE_CLEAR_BIOS_FRB2 (1 << 1)
104 #define WDOG_EXPIRE_CLEAR_BIOS_POST (1 << 2)
105 #define WDOG_EXPIRE_CLEAR_OS_LOAD (1 << 3)
106 #define WDOG_EXPIRE_CLEAR_SMS_OS (1 << 4)
107 #define WDOG_EXPIRE_CLEAR_OEM (1 << 5)
109 /* Setting/getting the watchdog timer value. This is for bytes 5 and
110 6 (the timeout time) of the set command, and bytes 6 and 7 (the
111 timeout time) and 8 and 9 (the current countdown value) of the
112 response. The timeout value is given in seconds (in the command it
113 is 100ms intervals). */
114 #define WDOG_SET_TIMEOUT(byte1, byte2, val) \
115 (byte1) = (((val) * 10) & 0xff), (byte2) = (((val) * 10) >> 8)
116 #define WDOG_GET_TIMEOUT(byte1, byte2) \
117 (((byte1) | ((byte2) << 8)) / 10)
119 #define IPMI_WDOG_RESET_TIMER 0x22
120 #define IPMI_WDOG_SET_TIMER 0x24
121 #define IPMI_WDOG_GET_TIMER 0x25
123 /* These are here until the real ones get into the watchdog.h interface. */
124 #ifndef WDIOC_GETTIMEOUT
125 #define WDIOC_GETTIMEOUT _IOW(WATCHDOG_IOCTL_BASE, 20, int)
127 #ifndef WDIOC_SET_PRETIMEOUT
128 #define WDIOC_SET_PRETIMEOUT _IOW(WATCHDOG_IOCTL_BASE, 21, int)
130 #ifndef WDIOC_GET_PRETIMEOUT
131 #define WDIOC_GET_PRETIMEOUT _IOW(WATCHDOG_IOCTL_BASE, 22, int)
134 static int nowayout
= WATCHDOG_NOWAYOUT
;
136 static ipmi_user_t watchdog_user
= NULL
;
138 /* Default the timeout to 10 seconds. */
139 static int timeout
= 10;
141 /* The pre-timeout is disabled by default. */
142 static int pretimeout
= 0;
144 /* Default action is to reset the board on a timeout. */
145 static unsigned char action_val
= WDOG_TIMEOUT_RESET
;
147 static char action
[16] = "reset";
149 static unsigned char preaction_val
= WDOG_PRETIMEOUT_NONE
;
151 static char preaction
[16] = "pre_none";
153 static unsigned char preop_val
= WDOG_PREOP_NONE
;
155 static char preop
[16] = "preop_none";
156 static DEFINE_SPINLOCK(ipmi_read_lock
);
157 static char data_to_read
= 0;
158 static DECLARE_WAIT_QUEUE_HEAD(read_q
);
159 static struct fasync_struct
*fasync_q
= NULL
;
160 static char pretimeout_since_last_heartbeat
= 0;
161 static char expect_close
;
163 static DECLARE_RWSEM(register_sem
);
165 /* Parameters to ipmi_set_timeout */
166 #define IPMI_SET_TIMEOUT_NO_HB 0
167 #define IPMI_SET_TIMEOUT_HB_IF_NECESSARY 1
168 #define IPMI_SET_TIMEOUT_FORCE_HB 2
170 static int ipmi_set_timeout(int do_heartbeat
);
172 /* If true, the driver will start running as soon as it is configured
174 static int start_now
= 0;
176 static int set_param_int(const char *val
, struct kernel_param
*kp
)
184 l
= simple_strtoul(val
, &endp
, 0);
188 down_read(®ister_sem
);
189 *((int *)kp
->arg
) = l
;
191 rv
= ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY
);
192 up_read(®ister_sem
);
197 static int get_param_int(char *buffer
, struct kernel_param
*kp
)
199 return sprintf(buffer
, "%i", *((int *)kp
->arg
));
202 typedef int (*action_fn
)(const char *intval
, char *outval
);
204 static int action_op(const char *inval
, char *outval
);
205 static int preaction_op(const char *inval
, char *outval
);
206 static int preop_op(const char *inval
, char *outval
);
207 static void check_parms(void);
209 static int set_param_str(const char *val
, struct kernel_param
*kp
)
211 action_fn fn
= (action_fn
) kp
->arg
;
217 /* Truncate leading and trailing spaces. */
218 while (isspace(*val
))
220 end
= val
+ strlen(val
) - 1;
221 while ((end
>= val
) && isspace(*end
))
224 if (len
> sizeof(valcp
) - 1)
226 memcpy(valcp
, val
, len
);
229 down_read(®ister_sem
);
230 rv
= fn(valcp
, NULL
);
236 rv
= ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY
);
239 up_read(®ister_sem
);
243 static int get_param_str(char *buffer
, struct kernel_param
*kp
)
245 action_fn fn
= (action_fn
) kp
->arg
;
248 rv
= fn(NULL
, buffer
);
251 return strlen(buffer
);
254 module_param_call(timeout
, set_param_int
, get_param_int
, &timeout
, 0644);
255 MODULE_PARM_DESC(timeout
, "Timeout value in seconds.");
257 module_param_call(pretimeout
, set_param_int
, get_param_int
, &pretimeout
, 0644);
258 MODULE_PARM_DESC(pretimeout
, "Pretimeout value in seconds.");
260 module_param_call(action
, set_param_str
, get_param_str
, action_op
, 0644);
261 MODULE_PARM_DESC(action
, "Timeout action. One of: "
262 "reset, none, power_cycle, power_off.");
264 module_param_call(preaction
, set_param_str
, get_param_str
, preaction_op
, 0644);
265 MODULE_PARM_DESC(preaction
, "Pretimeout action. One of: "
266 "pre_none, pre_smi, pre_nmi, pre_int.");
268 module_param_call(preop
, set_param_str
, get_param_str
, preop_op
, 0644);
269 MODULE_PARM_DESC(preop
, "Pretimeout driver operation. One of: "
270 "preop_none, preop_panic, preop_give_data.");
272 module_param(start_now
, int, 0);
273 MODULE_PARM_DESC(start_now
, "Set to 1 to start the watchdog as"
274 "soon as the driver is loaded.");
276 module_param(nowayout
, int, 0644);
277 MODULE_PARM_DESC(nowayout
, "Watchdog cannot be stopped once started (default=CONFIG_WATCHDOG_NOWAYOUT)");
279 /* Default state of the timer. */
280 static unsigned char ipmi_watchdog_state
= WDOG_TIMEOUT_NONE
;
282 /* If shutting down via IPMI, we ignore the heartbeat. */
283 static int ipmi_ignore_heartbeat
= 0;
285 /* Is someone using the watchdog? Only one user is allowed. */
286 static unsigned long ipmi_wdog_open
= 0;
288 /* If set to 1, the heartbeat command will set the state to reset and
289 start the timer. The timer doesn't normally run when the driver is
290 first opened until the heartbeat is set the first time, this
291 variable is used to accomplish this. */
292 static int ipmi_start_timer_on_heartbeat
= 0;
294 /* IPMI version of the BMC. */
295 static unsigned char ipmi_version_major
;
296 static unsigned char ipmi_version_minor
;
299 static int ipmi_heartbeat(void);
300 static void panic_halt_ipmi_heartbeat(void);
303 /* We use a semaphore to make sure that only one thing can send a set
304 timeout at one time, because we only have one copy of the data.
305 The semaphore is claimed when the set_timeout is sent and freed
306 when both messages are free. */
307 static atomic_t set_timeout_tofree
= ATOMIC_INIT(0);
308 static DECLARE_MUTEX(set_timeout_lock
);
309 static void set_timeout_free_smi(struct ipmi_smi_msg
*msg
)
311 if (atomic_dec_and_test(&set_timeout_tofree
))
312 up(&set_timeout_lock
);
314 static void set_timeout_free_recv(struct ipmi_recv_msg
*msg
)
316 if (atomic_dec_and_test(&set_timeout_tofree
))
317 up(&set_timeout_lock
);
319 static struct ipmi_smi_msg set_timeout_smi_msg
=
321 .done
= set_timeout_free_smi
323 static struct ipmi_recv_msg set_timeout_recv_msg
=
325 .done
= set_timeout_free_recv
328 static int i_ipmi_set_timeout(struct ipmi_smi_msg
*smi_msg
,
329 struct ipmi_recv_msg
*recv_msg
,
330 int *send_heartbeat_now
)
332 struct kernel_ipmi_msg msg
;
333 unsigned char data
[6];
335 struct ipmi_system_interface_addr addr
;
340 WDOG_SET_TIMER_USE(data
[0], WDOG_TIMER_USE_SMS_OS
);
342 if ((ipmi_version_major
> 1)
343 || ((ipmi_version_major
== 1) && (ipmi_version_minor
>= 5)))
345 /* This is an IPMI 1.5-only feature. */
346 data
[0] |= WDOG_DONT_STOP_ON_SET
;
347 } else if (ipmi_watchdog_state
!= WDOG_TIMEOUT_NONE
) {
348 /* In ipmi 1.0, setting the timer stops the watchdog, we
349 need to start it back up again. */
354 WDOG_SET_TIMEOUT_ACT(data
[1], ipmi_watchdog_state
);
355 if ((pretimeout
> 0) && (ipmi_watchdog_state
!= WDOG_TIMEOUT_NONE
)) {
356 WDOG_SET_PRETIMEOUT_ACT(data
[1], preaction_val
);
357 data
[2] = pretimeout
;
359 WDOG_SET_PRETIMEOUT_ACT(data
[1], WDOG_PRETIMEOUT_NONE
);
360 data
[2] = 0; /* No pretimeout. */
363 WDOG_SET_TIMEOUT(data
[4], data
[5], timeout
);
365 addr
.addr_type
= IPMI_SYSTEM_INTERFACE_ADDR_TYPE
;
366 addr
.channel
= IPMI_BMC_CHANNEL
;
370 msg
.cmd
= IPMI_WDOG_SET_TIMER
;
372 msg
.data_len
= sizeof(data
);
373 rv
= ipmi_request_supply_msgs(watchdog_user
,
374 (struct ipmi_addr
*) &addr
,
382 printk(KERN_WARNING PFX
"set timeout error: %d\n",
386 if (send_heartbeat_now
)
387 *send_heartbeat_now
= hbnow
;
392 static int ipmi_set_timeout(int do_heartbeat
)
394 int send_heartbeat_now
;
398 /* We can only send one of these at a time. */
399 down(&set_timeout_lock
);
401 atomic_set(&set_timeout_tofree
, 2);
403 rv
= i_ipmi_set_timeout(&set_timeout_smi_msg
,
404 &set_timeout_recv_msg
,
405 &send_heartbeat_now
);
407 up(&set_timeout_lock
);
409 if ((do_heartbeat
== IPMI_SET_TIMEOUT_FORCE_HB
)
410 || ((send_heartbeat_now
)
411 && (do_heartbeat
== IPMI_SET_TIMEOUT_HB_IF_NECESSARY
)))
413 rv
= ipmi_heartbeat();
420 static void dummy_smi_free(struct ipmi_smi_msg
*msg
)
423 static void dummy_recv_free(struct ipmi_recv_msg
*msg
)
426 static struct ipmi_smi_msg panic_halt_smi_msg
=
428 .done
= dummy_smi_free
430 static struct ipmi_recv_msg panic_halt_recv_msg
=
432 .done
= dummy_recv_free
435 /* Special call, doesn't claim any locks. This is only to be called
436 at panic or halt time, in run-to-completion mode, when the caller
437 is the only CPU and the only thing that will be going is these IPMI
439 static void panic_halt_ipmi_set_timeout(void)
441 int send_heartbeat_now
;
444 rv
= i_ipmi_set_timeout(&panic_halt_smi_msg
,
445 &panic_halt_recv_msg
,
446 &send_heartbeat_now
);
448 if (send_heartbeat_now
)
449 panic_halt_ipmi_heartbeat();
453 /* We use a semaphore to make sure that only one thing can send a
454 heartbeat at one time, because we only have one copy of the data.
455 The semaphore is claimed when the set_timeout is sent and freed
456 when both messages are free. */
457 static atomic_t heartbeat_tofree
= ATOMIC_INIT(0);
458 static DECLARE_MUTEX(heartbeat_lock
);
459 static DECLARE_MUTEX_LOCKED(heartbeat_wait_lock
);
460 static void heartbeat_free_smi(struct ipmi_smi_msg
*msg
)
462 if (atomic_dec_and_test(&heartbeat_tofree
))
463 up(&heartbeat_wait_lock
);
465 static void heartbeat_free_recv(struct ipmi_recv_msg
*msg
)
467 if (atomic_dec_and_test(&heartbeat_tofree
))
468 up(&heartbeat_wait_lock
);
470 static struct ipmi_smi_msg heartbeat_smi_msg
=
472 .done
= heartbeat_free_smi
474 static struct ipmi_recv_msg heartbeat_recv_msg
=
476 .done
= heartbeat_free_recv
479 static struct ipmi_smi_msg panic_halt_heartbeat_smi_msg
=
481 .done
= dummy_smi_free
483 static struct ipmi_recv_msg panic_halt_heartbeat_recv_msg
=
485 .done
= dummy_recv_free
488 static int ipmi_heartbeat(void)
490 struct kernel_ipmi_msg msg
;
492 struct ipmi_system_interface_addr addr
;
494 if (ipmi_ignore_heartbeat
) {
498 if (ipmi_start_timer_on_heartbeat
) {
499 ipmi_start_timer_on_heartbeat
= 0;
500 ipmi_watchdog_state
= action_val
;
501 return ipmi_set_timeout(IPMI_SET_TIMEOUT_FORCE_HB
);
502 } else if (pretimeout_since_last_heartbeat
) {
503 /* A pretimeout occurred, make sure we set the timeout.
504 We don't want to set the action, though, we want to
505 leave that alone (thus it can't be combined with the
507 pretimeout_since_last_heartbeat
= 0;
508 return ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY
);
511 down(&heartbeat_lock
);
513 atomic_set(&heartbeat_tofree
, 2);
515 /* Don't reset the timer if we have the timer turned off, that
516 re-enables the watchdog. */
517 if (ipmi_watchdog_state
== WDOG_TIMEOUT_NONE
) {
522 addr
.addr_type
= IPMI_SYSTEM_INTERFACE_ADDR_TYPE
;
523 addr
.channel
= IPMI_BMC_CHANNEL
;
527 msg
.cmd
= IPMI_WDOG_RESET_TIMER
;
530 rv
= ipmi_request_supply_msgs(watchdog_user
,
531 (struct ipmi_addr
*) &addr
,
540 printk(KERN_WARNING PFX
"heartbeat failure: %d\n",
545 /* Wait for the heartbeat to be sent. */
546 down(&heartbeat_wait_lock
);
548 if (heartbeat_recv_msg
.msg
.data
[0] != 0) {
549 /* Got an error in the heartbeat response. It was already
550 reported in ipmi_wdog_msg_handler, but we should return
560 static void panic_halt_ipmi_heartbeat(void)
562 struct kernel_ipmi_msg msg
;
563 struct ipmi_system_interface_addr addr
;
566 /* Don't reset the timer if we have the timer turned off, that
567 re-enables the watchdog. */
568 if (ipmi_watchdog_state
== WDOG_TIMEOUT_NONE
)
571 addr
.addr_type
= IPMI_SYSTEM_INTERFACE_ADDR_TYPE
;
572 addr
.channel
= IPMI_BMC_CHANNEL
;
576 msg
.cmd
= IPMI_WDOG_RESET_TIMER
;
579 ipmi_request_supply_msgs(watchdog_user
,
580 (struct ipmi_addr
*) &addr
,
584 &panic_halt_heartbeat_smi_msg
,
585 &panic_halt_heartbeat_recv_msg
,
589 static struct watchdog_info ident
=
591 .options
= 0, /* WDIOF_SETTIMEOUT, */
592 .firmware_version
= 1,
596 static int ipmi_ioctl(struct inode
*inode
, struct file
*file
,
597 unsigned int cmd
, unsigned long arg
)
599 void __user
*argp
= (void __user
*)arg
;
604 case WDIOC_GETSUPPORT
:
605 i
= copy_to_user(argp
, &ident
, sizeof(ident
));
606 return i
? -EFAULT
: 0;
608 case WDIOC_SETTIMEOUT
:
609 i
= copy_from_user(&val
, argp
, sizeof(int));
613 return ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY
);
615 case WDIOC_GETTIMEOUT
:
616 i
= copy_to_user(argp
, &timeout
, sizeof(timeout
));
621 case WDIOC_SET_PRETIMEOUT
:
622 i
= copy_from_user(&val
, argp
, sizeof(int));
626 return ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY
);
628 case WDIOC_GET_PRETIMEOUT
:
629 i
= copy_to_user(argp
, &pretimeout
, sizeof(pretimeout
));
634 case WDIOC_KEEPALIVE
:
635 return ipmi_heartbeat();
637 case WDIOC_SETOPTIONS
:
638 i
= copy_from_user(&val
, argp
, sizeof(int));
641 if (val
& WDIOS_DISABLECARD
)
643 ipmi_watchdog_state
= WDOG_TIMEOUT_NONE
;
644 ipmi_set_timeout(IPMI_SET_TIMEOUT_NO_HB
);
645 ipmi_start_timer_on_heartbeat
= 0;
648 if (val
& WDIOS_ENABLECARD
)
650 ipmi_watchdog_state
= action_val
;
651 ipmi_set_timeout(IPMI_SET_TIMEOUT_FORCE_HB
);
655 case WDIOC_GETSTATUS
:
657 i
= copy_to_user(argp
, &val
, sizeof(val
));
667 static ssize_t
ipmi_write(struct file
*file
,
668 const char __user
*buf
,
678 /* In case it was set long ago */
681 for (i
= 0; i
!= len
; i
++) {
684 if (get_user(c
, buf
+ i
))
690 rv
= ipmi_heartbeat();
698 static ssize_t
ipmi_read(struct file
*file
,
709 /* Reading returns if the pretimeout has gone off, and it only does
710 it once per pretimeout. */
711 spin_lock(&ipmi_read_lock
);
713 if (file
->f_flags
& O_NONBLOCK
) {
718 init_waitqueue_entry(&wait
, current
);
719 add_wait_queue(&read_q
, &wait
);
720 while (!data_to_read
) {
721 set_current_state(TASK_INTERRUPTIBLE
);
722 spin_unlock(&ipmi_read_lock
);
724 spin_lock(&ipmi_read_lock
);
726 remove_wait_queue(&read_q
, &wait
);
728 if (signal_pending(current
)) {
736 spin_unlock(&ipmi_read_lock
);
739 if (copy_to_user(buf
, &data_to_read
, 1))
748 static int ipmi_open(struct inode
*ino
, struct file
*filep
)
750 switch (iminor(ino
)) {
752 if (test_and_set_bit(0, &ipmi_wdog_open
))
755 /* Don't start the timer now, let it start on the
757 ipmi_start_timer_on_heartbeat
= 1;
758 return nonseekable_open(ino
, filep
);
765 static unsigned int ipmi_poll(struct file
*file
, poll_table
*wait
)
767 unsigned int mask
= 0;
769 poll_wait(file
, &read_q
, wait
);
771 spin_lock(&ipmi_read_lock
);
773 mask
|= (POLLIN
| POLLRDNORM
);
774 spin_unlock(&ipmi_read_lock
);
779 static int ipmi_fasync(int fd
, struct file
*file
, int on
)
783 result
= fasync_helper(fd
, file
, on
, &fasync_q
);
788 static int ipmi_close(struct inode
*ino
, struct file
*filep
)
790 if (iminor(ino
)==WATCHDOG_MINOR
)
792 if (expect_close
== 42) {
793 ipmi_watchdog_state
= WDOG_TIMEOUT_NONE
;
794 ipmi_set_timeout(IPMI_SET_TIMEOUT_NO_HB
);
796 printk(KERN_CRIT PFX
"Unexpected close, not stopping watchdog!\n");
799 clear_bit(0, &ipmi_wdog_open
);
802 ipmi_fasync (-1, filep
, 0);
808 static struct file_operations ipmi_wdog_fops
= {
809 .owner
= THIS_MODULE
,
815 .release
= ipmi_close
,
816 .fasync
= ipmi_fasync
,
819 static struct miscdevice ipmi_wdog_miscdev
= {
820 .minor
= WATCHDOG_MINOR
,
822 .fops
= &ipmi_wdog_fops
825 static void ipmi_wdog_msg_handler(struct ipmi_recv_msg
*msg
,
828 if (msg
->msg
.data
[0] != 0) {
829 printk(KERN_ERR PFX
"response: Error %x on cmd %x\n",
834 ipmi_free_recv_msg(msg
);
837 static void ipmi_wdog_pretimeout_handler(void *handler_data
)
839 if (preaction_val
!= WDOG_PRETIMEOUT_NONE
) {
840 if (preop_val
== WDOG_PREOP_PANIC
)
841 panic("Watchdog pre-timeout");
842 else if (preop_val
== WDOG_PREOP_GIVE_DATA
) {
843 spin_lock(&ipmi_read_lock
);
845 wake_up_interruptible(&read_q
);
846 kill_fasync(&fasync_q
, SIGIO
, POLL_IN
);
848 spin_unlock(&ipmi_read_lock
);
852 /* On some machines, the heartbeat will give
853 an error and not work unless we re-enable
854 the timer. So do so. */
855 pretimeout_since_last_heartbeat
= 1;
858 static struct ipmi_user_hndl ipmi_hndlrs
=
860 .ipmi_recv_hndl
= ipmi_wdog_msg_handler
,
861 .ipmi_watchdog_pretimeout
= ipmi_wdog_pretimeout_handler
864 static void ipmi_register_watchdog(int ipmi_intf
)
868 down_write(®ister_sem
);
872 rv
= ipmi_create_user(ipmi_intf
, &ipmi_hndlrs
, NULL
, &watchdog_user
);
874 printk(KERN_CRIT PFX
"Unable to register with ipmi\n");
878 ipmi_get_version(watchdog_user
,
880 &ipmi_version_minor
);
882 rv
= misc_register(&ipmi_wdog_miscdev
);
884 ipmi_destroy_user(watchdog_user
);
885 watchdog_user
= NULL
;
886 printk(KERN_CRIT PFX
"Unable to register misc device\n");
890 up_write(®ister_sem
);
892 if ((start_now
) && (rv
== 0)) {
893 /* Run from startup, so start the timer now. */
894 start_now
= 0; /* Disable this function after first startup. */
895 ipmi_watchdog_state
= action_val
;
896 ipmi_set_timeout(IPMI_SET_TIMEOUT_FORCE_HB
);
897 printk(KERN_INFO PFX
"Starting now!\n");
901 #ifdef HAVE_NMI_HANDLER
903 ipmi_nmi(void *dev_id
, struct pt_regs
*regs
, int cpu
, int handled
)
905 /* If we are not expecting a timeout, ignore it. */
906 if (ipmi_watchdog_state
== WDOG_TIMEOUT_NONE
)
909 /* If no one else handled the NMI, we assume it was the IPMI
911 if ((!handled
) && (preop_val
== WDOG_PREOP_PANIC
)) {
912 /* On some machines, the heartbeat will give
913 an error and not work unless we re-enable
914 the timer. So do so. */
915 pretimeout_since_last_heartbeat
= 1;
916 panic(PFX
"pre-timeout");
922 static struct nmi_handler ipmi_nmi_handler
=
924 .link
= LIST_HEAD_INIT(ipmi_nmi_handler
.link
),
925 .dev_name
= "ipmi_watchdog",
928 .priority
= 0, /* Call us last. */
930 int nmi_handler_registered
;
933 static int wdog_reboot_handler(struct notifier_block
*this,
937 static int reboot_event_handled
= 0;
939 if ((watchdog_user
) && (!reboot_event_handled
)) {
940 /* Make sure we only do this once. */
941 reboot_event_handled
= 1;
943 if (code
== SYS_DOWN
|| code
== SYS_HALT
) {
944 /* Disable the WDT if we are shutting down. */
945 ipmi_watchdog_state
= WDOG_TIMEOUT_NONE
;
946 panic_halt_ipmi_set_timeout();
948 /* Set a long timer to let the reboot happens, but
949 reboot if it hangs. */
952 ipmi_watchdog_state
= WDOG_TIMEOUT_RESET
;
953 panic_halt_ipmi_set_timeout();
959 static struct notifier_block wdog_reboot_notifier
= {
960 .notifier_call
= wdog_reboot_handler
,
965 static int wdog_panic_handler(struct notifier_block
*this,
969 static int panic_event_handled
= 0;
971 /* On a panic, if we have a panic timeout, make sure that the thing
972 reboots, even if it hangs during that panic. */
973 if (watchdog_user
&& !panic_event_handled
) {
974 /* Make sure the panic doesn't hang, and make sure we
975 do this only once. */
976 panic_event_handled
= 1;
980 ipmi_watchdog_state
= WDOG_TIMEOUT_RESET
;
981 panic_halt_ipmi_set_timeout();
987 static struct notifier_block wdog_panic_notifier
= {
988 .notifier_call
= wdog_panic_handler
,
990 .priority
= 150 /* priority: INT_MAX >= x >= 0 */
994 static void ipmi_new_smi(int if_num
)
996 ipmi_register_watchdog(if_num
);
999 static void ipmi_smi_gone(int if_num
)
1001 /* This can never be called, because once the watchdog is
1002 registered, the interface can't go away until the watchdog
1006 static struct ipmi_smi_watcher smi_watcher
=
1008 .owner
= THIS_MODULE
,
1009 .new_smi
= ipmi_new_smi
,
1010 .smi_gone
= ipmi_smi_gone
1013 static int action_op(const char *inval
, char *outval
)
1016 strcpy(outval
, action
);
1021 if (strcmp(inval
, "reset") == 0)
1022 action_val
= WDOG_TIMEOUT_RESET
;
1023 else if (strcmp(inval
, "none") == 0)
1024 action_val
= WDOG_TIMEOUT_NONE
;
1025 else if (strcmp(inval
, "power_cycle") == 0)
1026 action_val
= WDOG_TIMEOUT_POWER_CYCLE
;
1027 else if (strcmp(inval
, "power_off") == 0)
1028 action_val
= WDOG_TIMEOUT_POWER_DOWN
;
1031 strcpy(action
, inval
);
1035 static int preaction_op(const char *inval
, char *outval
)
1038 strcpy(outval
, preaction
);
1043 if (strcmp(inval
, "pre_none") == 0)
1044 preaction_val
= WDOG_PRETIMEOUT_NONE
;
1045 else if (strcmp(inval
, "pre_smi") == 0)
1046 preaction_val
= WDOG_PRETIMEOUT_SMI
;
1047 #ifdef HAVE_NMI_HANDLER
1048 else if (strcmp(inval
, "pre_nmi") == 0)
1049 preaction_val
= WDOG_PRETIMEOUT_NMI
;
1051 else if (strcmp(inval
, "pre_int") == 0)
1052 preaction_val
= WDOG_PRETIMEOUT_MSG_INT
;
1055 strcpy(preaction
, inval
);
1059 static int preop_op(const char *inval
, char *outval
)
1062 strcpy(outval
, preop
);
1067 if (strcmp(inval
, "preop_none") == 0)
1068 preop_val
= WDOG_PREOP_NONE
;
1069 else if (strcmp(inval
, "preop_panic") == 0)
1070 preop_val
= WDOG_PREOP_PANIC
;
1071 else if (strcmp(inval
, "preop_give_data") == 0)
1072 preop_val
= WDOG_PREOP_GIVE_DATA
;
1075 strcpy(preop
, inval
);
1079 static void check_parms(void)
1081 #ifdef HAVE_NMI_HANDLER
1085 if (preaction_val
== WDOG_PRETIMEOUT_NMI
) {
1087 if (preop_val
== WDOG_PREOP_GIVE_DATA
) {
1088 printk(KERN_WARNING PFX
"Pretimeout op is to give data"
1089 " but NMI pretimeout is enabled, setting"
1090 " pretimeout op to none\n");
1091 preop_op("preop_none", NULL
);
1094 #ifdef CONFIG_X86_LOCAL_APIC
1095 if (nmi_watchdog
== NMI_IO_APIC
) {
1096 printk(KERN_WARNING PFX
"nmi_watchdog is set to IO APIC"
1097 " mode (value is %d), that is incompatible"
1098 " with using NMI in the IPMI watchdog."
1099 " Disabling IPMI nmi pretimeout.\n",
1101 preaction_val
= WDOG_PRETIMEOUT_NONE
;
1106 if (do_nmi
&& !nmi_handler_registered
) {
1107 rv
= request_nmi(&ipmi_nmi_handler
);
1109 printk(KERN_WARNING PFX
1110 "Can't register nmi handler\n");
1113 nmi_handler_registered
= 1;
1114 } else if (!do_nmi
&& nmi_handler_registered
) {
1115 release_nmi(&ipmi_nmi_handler
);
1116 nmi_handler_registered
= 0;
1121 static int __init
ipmi_wdog_init(void)
1125 if (action_op(action
, NULL
)) {
1126 action_op("reset", NULL
);
1127 printk(KERN_INFO PFX
"Unknown action '%s', defaulting to"
1128 " reset\n", action
);
1131 if (preaction_op(preaction
, NULL
)) {
1132 preaction_op("pre_none", NULL
);
1133 printk(KERN_INFO PFX
"Unknown preaction '%s', defaulting to"
1134 " none\n", preaction
);
1137 if (preop_op(preop
, NULL
)) {
1138 preop_op("preop_none", NULL
);
1139 printk(KERN_INFO PFX
"Unknown preop '%s', defaulting to"
1145 rv
= ipmi_smi_watcher_register(&smi_watcher
);
1147 #ifdef HAVE_NMI_HANDLER
1148 if (preaction_val
== WDOG_PRETIMEOUT_NMI
)
1149 release_nmi(&ipmi_nmi_handler
);
1151 printk(KERN_WARNING PFX
"can't register smi watcher\n");
1155 register_reboot_notifier(&wdog_reboot_notifier
);
1156 notifier_chain_register(&panic_notifier_list
, &wdog_panic_notifier
);
1158 printk(KERN_INFO PFX
"driver initialized\n");
1163 static __exit
void ipmi_unregister_watchdog(void)
1167 down_write(®ister_sem
);
1169 #ifdef HAVE_NMI_HANDLER
1170 if (nmi_handler_registered
)
1171 release_nmi(&ipmi_nmi_handler
);
1174 notifier_chain_unregister(&panic_notifier_list
, &wdog_panic_notifier
);
1175 unregister_reboot_notifier(&wdog_reboot_notifier
);
1177 if (! watchdog_user
)
1180 /* Make sure no one can call us any more. */
1181 misc_deregister(&ipmi_wdog_miscdev
);
1183 /* Wait to make sure the message makes it out. The lower layer has
1184 pointers to our buffers, we want to make sure they are done before
1185 we release our memory. */
1186 while (atomic_read(&set_timeout_tofree
))
1187 schedule_timeout_uninterruptible(1);
1189 /* Disconnect from IPMI. */
1190 rv
= ipmi_destroy_user(watchdog_user
);
1192 printk(KERN_WARNING PFX
"error unlinking from IPMI: %d\n",
1195 watchdog_user
= NULL
;
1198 up_write(®ister_sem
);
1201 static void __exit
ipmi_wdog_exit(void)
1203 ipmi_smi_watcher_unregister(&smi_watcher
);
1204 ipmi_unregister_watchdog();
1206 module_exit(ipmi_wdog_exit
);
1207 module_init(ipmi_wdog_init
);
1208 MODULE_LICENSE("GPL");
1209 MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>");
1210 MODULE_DESCRIPTION("watchdog timer based upon the IPMI interface.");