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/module.h>
35 #include <linux/moduleparam.h>
36 #include <linux/ipmi.h>
37 #include <linux/ipmi_smi.h>
38 #include <linux/mutex.h>
39 #include <linux/watchdog.h>
40 #include <linux/miscdevice.h>
41 #include <linux/init.h>
42 #include <linux/completion.h>
43 #include <linux/kdebug.h>
44 #include <linux/rwsem.h>
45 #include <linux/errno.h>
46 #include <asm/uaccess.h>
47 #include <linux/notifier.h>
48 #include <linux/nmi.h>
49 #include <linux/reboot.h>
50 #include <linux/wait.h>
51 #include <linux/poll.h>
52 #include <linux/string.h>
53 #include <linux/ctype.h>
54 #include <linux/delay.h>
55 #include <linux/atomic.h>
59 * This is ugly, but I've determined that x86 is the only architecture
60 * that can reasonably support the IPMI NMI watchdog timeout at this
61 * time. If another architecture adds this capability somehow, it
62 * will have to be a somewhat different mechanism and I have no idea
63 * how it will work. So in the unlikely event that another
64 * architecture supports this, we can figure out a good generic
65 * mechanism for it at that time.
67 #include <asm/kdebug.h>
72 #define PFX "IPMI Watchdog: "
75 * The IPMI command/response information for the watchdog timer.
78 /* values for byte 1 of the set command, byte 2 of the get response. */
79 #define WDOG_DONT_LOG (1 << 7)
80 #define WDOG_DONT_STOP_ON_SET (1 << 6)
81 #define WDOG_SET_TIMER_USE(byte, use) \
82 byte = ((byte) & 0xf8) | ((use) & 0x7)
83 #define WDOG_GET_TIMER_USE(byte) ((byte) & 0x7)
84 #define WDOG_TIMER_USE_BIOS_FRB2 1
85 #define WDOG_TIMER_USE_BIOS_POST 2
86 #define WDOG_TIMER_USE_OS_LOAD 3
87 #define WDOG_TIMER_USE_SMS_OS 4
88 #define WDOG_TIMER_USE_OEM 5
90 /* values for byte 2 of the set command, byte 3 of the get response. */
91 #define WDOG_SET_PRETIMEOUT_ACT(byte, use) \
92 byte = ((byte) & 0x8f) | (((use) & 0x7) << 4)
93 #define WDOG_GET_PRETIMEOUT_ACT(byte) (((byte) >> 4) & 0x7)
94 #define WDOG_PRETIMEOUT_NONE 0
95 #define WDOG_PRETIMEOUT_SMI 1
96 #define WDOG_PRETIMEOUT_NMI 2
97 #define WDOG_PRETIMEOUT_MSG_INT 3
99 /* Operations that can be performed on a pretimout. */
100 #define WDOG_PREOP_NONE 0
101 #define WDOG_PREOP_PANIC 1
102 /* Cause data to be available to read. Doesn't work in NMI mode. */
103 #define WDOG_PREOP_GIVE_DATA 2
105 /* Actions to perform on a full timeout. */
106 #define WDOG_SET_TIMEOUT_ACT(byte, use) \
107 byte = ((byte) & 0xf8) | ((use) & 0x7)
108 #define WDOG_GET_TIMEOUT_ACT(byte) ((byte) & 0x7)
109 #define WDOG_TIMEOUT_NONE 0
110 #define WDOG_TIMEOUT_RESET 1
111 #define WDOG_TIMEOUT_POWER_DOWN 2
112 #define WDOG_TIMEOUT_POWER_CYCLE 3
115 * Byte 3 of the get command, byte 4 of the get response is the
116 * pre-timeout in seconds.
119 /* Bits for setting byte 4 of the set command, byte 5 of the get response. */
120 #define WDOG_EXPIRE_CLEAR_BIOS_FRB2 (1 << 1)
121 #define WDOG_EXPIRE_CLEAR_BIOS_POST (1 << 2)
122 #define WDOG_EXPIRE_CLEAR_OS_LOAD (1 << 3)
123 #define WDOG_EXPIRE_CLEAR_SMS_OS (1 << 4)
124 #define WDOG_EXPIRE_CLEAR_OEM (1 << 5)
127 * Setting/getting the watchdog timer value. This is for bytes 5 and
128 * 6 (the timeout time) of the set command, and bytes 6 and 7 (the
129 * timeout time) and 8 and 9 (the current countdown value) of the
130 * response. The timeout value is given in seconds (in the command it
131 * is 100ms intervals).
133 #define WDOG_SET_TIMEOUT(byte1, byte2, val) \
134 (byte1) = (((val) * 10) & 0xff), (byte2) = (((val) * 10) >> 8)
135 #define WDOG_GET_TIMEOUT(byte1, byte2) \
136 (((byte1) | ((byte2) << 8)) / 10)
138 #define IPMI_WDOG_RESET_TIMER 0x22
139 #define IPMI_WDOG_SET_TIMER 0x24
140 #define IPMI_WDOG_GET_TIMER 0x25
142 #define IPMI_WDOG_TIMER_NOT_INIT_RESP 0x80
144 /* These are here until the real ones get into the watchdog.h interface. */
145 #ifndef WDIOC_GETTIMEOUT
146 #define WDIOC_GETTIMEOUT _IOW(WATCHDOG_IOCTL_BASE, 20, int)
148 #ifndef WDIOC_SET_PRETIMEOUT
149 #define WDIOC_SET_PRETIMEOUT _IOW(WATCHDOG_IOCTL_BASE, 21, int)
151 #ifndef WDIOC_GET_PRETIMEOUT
152 #define WDIOC_GET_PRETIMEOUT _IOW(WATCHDOG_IOCTL_BASE, 22, int)
155 static DEFINE_MUTEX(ipmi_watchdog_mutex
);
156 static bool nowayout
= WATCHDOG_NOWAYOUT
;
158 static ipmi_user_t watchdog_user
;
159 static int watchdog_ifnum
;
161 /* Default the timeout to 10 seconds. */
162 static int timeout
= 10;
164 /* The pre-timeout is disabled by default. */
165 static int pretimeout
;
167 /* Default action is to reset the board on a timeout. */
168 static unsigned char action_val
= WDOG_TIMEOUT_RESET
;
170 static char action
[16] = "reset";
172 static unsigned char preaction_val
= WDOG_PRETIMEOUT_NONE
;
174 static char preaction
[16] = "pre_none";
176 static unsigned char preop_val
= WDOG_PREOP_NONE
;
178 static char preop
[16] = "preop_none";
179 static DEFINE_SPINLOCK(ipmi_read_lock
);
180 static char data_to_read
;
181 static DECLARE_WAIT_QUEUE_HEAD(read_q
);
182 static struct fasync_struct
*fasync_q
;
183 static char pretimeout_since_last_heartbeat
;
184 static char expect_close
;
186 static int ifnum_to_use
= -1;
188 /* Parameters to ipmi_set_timeout */
189 #define IPMI_SET_TIMEOUT_NO_HB 0
190 #define IPMI_SET_TIMEOUT_HB_IF_NECESSARY 1
191 #define IPMI_SET_TIMEOUT_FORCE_HB 2
193 static int ipmi_set_timeout(int do_heartbeat
);
194 static void ipmi_register_watchdog(int ipmi_intf
);
195 static void ipmi_unregister_watchdog(int ipmi_intf
);
198 * If true, the driver will start running as soon as it is configured
201 static int start_now
;
203 static int set_param_timeout(const char *val
, const struct kernel_param
*kp
)
211 l
= simple_strtoul(val
, &endp
, 0);
215 *((int *)kp
->arg
) = l
;
217 rv
= ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY
);
222 static struct kernel_param_ops param_ops_timeout
= {
223 .set
= set_param_timeout
,
224 .get
= param_get_int
,
226 #define param_check_timeout param_check_int
228 typedef int (*action_fn
)(const char *intval
, char *outval
);
230 static int action_op(const char *inval
, char *outval
);
231 static int preaction_op(const char *inval
, char *outval
);
232 static int preop_op(const char *inval
, char *outval
);
233 static void check_parms(void);
235 static int set_param_str(const char *val
, const struct kernel_param
*kp
)
237 action_fn fn
= (action_fn
) kp
->arg
;
242 strncpy(valcp
, val
, 16);
253 rv
= ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY
);
259 static int get_param_str(char *buffer
, const struct kernel_param
*kp
)
261 action_fn fn
= (action_fn
) kp
->arg
;
264 rv
= fn(NULL
, buffer
);
267 return strlen(buffer
);
271 static int set_param_wdog_ifnum(const char *val
, const struct kernel_param
*kp
)
273 int rv
= param_set_int(val
, kp
);
276 if ((ifnum_to_use
< 0) || (ifnum_to_use
== watchdog_ifnum
))
279 ipmi_unregister_watchdog(watchdog_ifnum
);
280 ipmi_register_watchdog(ifnum_to_use
);
284 static struct kernel_param_ops param_ops_wdog_ifnum
= {
285 .set
= set_param_wdog_ifnum
,
286 .get
= param_get_int
,
289 #define param_check_wdog_ifnum param_check_int
291 static struct kernel_param_ops param_ops_str
= {
292 .set
= set_param_str
,
293 .get
= get_param_str
,
296 module_param(ifnum_to_use
, wdog_ifnum
, 0644);
297 MODULE_PARM_DESC(ifnum_to_use
, "The interface number to use for the watchdog "
298 "timer. Setting to -1 defaults to the first registered "
301 module_param(timeout
, timeout
, 0644);
302 MODULE_PARM_DESC(timeout
, "Timeout value in seconds.");
304 module_param(pretimeout
, timeout
, 0644);
305 MODULE_PARM_DESC(pretimeout
, "Pretimeout value in seconds.");
307 module_param_cb(action
, ¶m_ops_str
, action_op
, 0644);
308 MODULE_PARM_DESC(action
, "Timeout action. One of: "
309 "reset, none, power_cycle, power_off.");
311 module_param_cb(preaction
, ¶m_ops_str
, preaction_op
, 0644);
312 MODULE_PARM_DESC(preaction
, "Pretimeout action. One of: "
313 "pre_none, pre_smi, pre_nmi, pre_int.");
315 module_param_cb(preop
, ¶m_ops_str
, preop_op
, 0644);
316 MODULE_PARM_DESC(preop
, "Pretimeout driver operation. One of: "
317 "preop_none, preop_panic, preop_give_data.");
319 module_param(start_now
, int, 0444);
320 MODULE_PARM_DESC(start_now
, "Set to 1 to start the watchdog as"
321 "soon as the driver is loaded.");
323 module_param(nowayout
, bool, 0644);
324 MODULE_PARM_DESC(nowayout
, "Watchdog cannot be stopped once started "
325 "(default=CONFIG_WATCHDOG_NOWAYOUT)");
327 /* Default state of the timer. */
328 static unsigned char ipmi_watchdog_state
= WDOG_TIMEOUT_NONE
;
330 /* If shutting down via IPMI, we ignore the heartbeat. */
331 static int ipmi_ignore_heartbeat
;
333 /* Is someone using the watchdog? Only one user is allowed. */
334 static unsigned long ipmi_wdog_open
;
337 * If set to 1, the heartbeat command will set the state to reset and
338 * start the timer. The timer doesn't normally run when the driver is
339 * first opened until the heartbeat is set the first time, this
340 * variable is used to accomplish this.
342 static int ipmi_start_timer_on_heartbeat
;
344 /* IPMI version of the BMC. */
345 static unsigned char ipmi_version_major
;
346 static unsigned char ipmi_version_minor
;
348 /* If a pretimeout occurs, this is used to allow only one panic to happen. */
349 static atomic_t preop_panic_excl
= ATOMIC_INIT(-1);
352 static int testing_nmi
;
353 static int nmi_handler_registered
;
356 static int ipmi_heartbeat(void);
359 * We use a mutex to make sure that only one thing can send a set
360 * timeout at one time, because we only have one copy of the data.
361 * The mutex is claimed when the set_timeout is sent and freed
362 * when both messages are free.
364 static atomic_t set_timeout_tofree
= ATOMIC_INIT(0);
365 static DEFINE_MUTEX(set_timeout_lock
);
366 static DECLARE_COMPLETION(set_timeout_wait
);
367 static void set_timeout_free_smi(struct ipmi_smi_msg
*msg
)
369 if (atomic_dec_and_test(&set_timeout_tofree
))
370 complete(&set_timeout_wait
);
372 static void set_timeout_free_recv(struct ipmi_recv_msg
*msg
)
374 if (atomic_dec_and_test(&set_timeout_tofree
))
375 complete(&set_timeout_wait
);
377 static struct ipmi_smi_msg set_timeout_smi_msg
= {
378 .done
= set_timeout_free_smi
380 static struct ipmi_recv_msg set_timeout_recv_msg
= {
381 .done
= set_timeout_free_recv
384 static int i_ipmi_set_timeout(struct ipmi_smi_msg
*smi_msg
,
385 struct ipmi_recv_msg
*recv_msg
,
386 int *send_heartbeat_now
)
388 struct kernel_ipmi_msg msg
;
389 unsigned char data
[6];
391 struct ipmi_system_interface_addr addr
;
395 /* These can be cleared as we are setting the timeout. */
396 pretimeout_since_last_heartbeat
= 0;
399 WDOG_SET_TIMER_USE(data
[0], WDOG_TIMER_USE_SMS_OS
);
401 if ((ipmi_version_major
> 1)
402 || ((ipmi_version_major
== 1) && (ipmi_version_minor
>= 5))) {
403 /* This is an IPMI 1.5-only feature. */
404 data
[0] |= WDOG_DONT_STOP_ON_SET
;
405 } else if (ipmi_watchdog_state
!= WDOG_TIMEOUT_NONE
) {
407 * In ipmi 1.0, setting the timer stops the watchdog, we
408 * need to start it back up again.
414 WDOG_SET_TIMEOUT_ACT(data
[1], ipmi_watchdog_state
);
415 if ((pretimeout
> 0) && (ipmi_watchdog_state
!= WDOG_TIMEOUT_NONE
)) {
416 WDOG_SET_PRETIMEOUT_ACT(data
[1], preaction_val
);
417 data
[2] = pretimeout
;
419 WDOG_SET_PRETIMEOUT_ACT(data
[1], WDOG_PRETIMEOUT_NONE
);
420 data
[2] = 0; /* No pretimeout. */
423 WDOG_SET_TIMEOUT(data
[4], data
[5], timeout
);
425 addr
.addr_type
= IPMI_SYSTEM_INTERFACE_ADDR_TYPE
;
426 addr
.channel
= IPMI_BMC_CHANNEL
;
430 msg
.cmd
= IPMI_WDOG_SET_TIMER
;
432 msg
.data_len
= sizeof(data
);
433 rv
= ipmi_request_supply_msgs(watchdog_user
,
434 (struct ipmi_addr
*) &addr
,
442 printk(KERN_WARNING PFX
"set timeout error: %d\n",
446 if (send_heartbeat_now
)
447 *send_heartbeat_now
= hbnow
;
452 static int ipmi_set_timeout(int do_heartbeat
)
454 int send_heartbeat_now
;
458 /* We can only send one of these at a time. */
459 mutex_lock(&set_timeout_lock
);
461 atomic_set(&set_timeout_tofree
, 2);
463 rv
= i_ipmi_set_timeout(&set_timeout_smi_msg
,
464 &set_timeout_recv_msg
,
465 &send_heartbeat_now
);
467 mutex_unlock(&set_timeout_lock
);
471 wait_for_completion(&set_timeout_wait
);
473 mutex_unlock(&set_timeout_lock
);
475 if ((do_heartbeat
== IPMI_SET_TIMEOUT_FORCE_HB
)
476 || ((send_heartbeat_now
)
477 && (do_heartbeat
== IPMI_SET_TIMEOUT_HB_IF_NECESSARY
)))
478 rv
= ipmi_heartbeat();
484 static atomic_t panic_done_count
= ATOMIC_INIT(0);
486 static void panic_smi_free(struct ipmi_smi_msg
*msg
)
488 atomic_dec(&panic_done_count
);
490 static void panic_recv_free(struct ipmi_recv_msg
*msg
)
492 atomic_dec(&panic_done_count
);
495 static struct ipmi_smi_msg panic_halt_heartbeat_smi_msg
= {
496 .done
= panic_smi_free
498 static struct ipmi_recv_msg panic_halt_heartbeat_recv_msg
= {
499 .done
= panic_recv_free
502 static void panic_halt_ipmi_heartbeat(void)
504 struct kernel_ipmi_msg msg
;
505 struct ipmi_system_interface_addr addr
;
509 * Don't reset the timer if we have the timer turned off, that
510 * re-enables the watchdog.
512 if (ipmi_watchdog_state
== WDOG_TIMEOUT_NONE
)
515 addr
.addr_type
= IPMI_SYSTEM_INTERFACE_ADDR_TYPE
;
516 addr
.channel
= IPMI_BMC_CHANNEL
;
520 msg
.cmd
= IPMI_WDOG_RESET_TIMER
;
523 atomic_add(2, &panic_done_count
);
524 rv
= ipmi_request_supply_msgs(watchdog_user
,
525 (struct ipmi_addr
*) &addr
,
529 &panic_halt_heartbeat_smi_msg
,
530 &panic_halt_heartbeat_recv_msg
,
533 atomic_sub(2, &panic_done_count
);
536 static struct ipmi_smi_msg panic_halt_smi_msg
= {
537 .done
= panic_smi_free
539 static struct ipmi_recv_msg panic_halt_recv_msg
= {
540 .done
= panic_recv_free
544 * Special call, doesn't claim any locks. This is only to be called
545 * at panic or halt time, in run-to-completion mode, when the caller
546 * is the only CPU and the only thing that will be going is these IPMI
549 static void panic_halt_ipmi_set_timeout(void)
551 int send_heartbeat_now
;
554 /* Wait for the messages to be free. */
555 while (atomic_read(&panic_done_count
) != 0)
556 ipmi_poll_interface(watchdog_user
);
557 atomic_add(2, &panic_done_count
);
558 rv
= i_ipmi_set_timeout(&panic_halt_smi_msg
,
559 &panic_halt_recv_msg
,
560 &send_heartbeat_now
);
562 atomic_sub(2, &panic_done_count
);
563 printk(KERN_WARNING PFX
564 "Unable to extend the watchdog timeout.");
566 if (send_heartbeat_now
)
567 panic_halt_ipmi_heartbeat();
569 while (atomic_read(&panic_done_count
) != 0)
570 ipmi_poll_interface(watchdog_user
);
574 * We use a mutex to make sure that only one thing can send a
575 * heartbeat at one time, because we only have one copy of the data.
576 * The semaphore is claimed when the set_timeout is sent and freed
577 * when both messages are free.
579 static atomic_t heartbeat_tofree
= ATOMIC_INIT(0);
580 static DEFINE_MUTEX(heartbeat_lock
);
581 static DECLARE_COMPLETION(heartbeat_wait
);
582 static void heartbeat_free_smi(struct ipmi_smi_msg
*msg
)
584 if (atomic_dec_and_test(&heartbeat_tofree
))
585 complete(&heartbeat_wait
);
587 static void heartbeat_free_recv(struct ipmi_recv_msg
*msg
)
589 if (atomic_dec_and_test(&heartbeat_tofree
))
590 complete(&heartbeat_wait
);
592 static struct ipmi_smi_msg heartbeat_smi_msg
= {
593 .done
= heartbeat_free_smi
595 static struct ipmi_recv_msg heartbeat_recv_msg
= {
596 .done
= heartbeat_free_recv
599 static int ipmi_heartbeat(void)
601 struct kernel_ipmi_msg msg
;
603 struct ipmi_system_interface_addr addr
;
604 int timeout_retries
= 0;
606 if (ipmi_ignore_heartbeat
)
609 if (ipmi_start_timer_on_heartbeat
) {
610 ipmi_start_timer_on_heartbeat
= 0;
611 ipmi_watchdog_state
= action_val
;
612 return ipmi_set_timeout(IPMI_SET_TIMEOUT_FORCE_HB
);
613 } else if (pretimeout_since_last_heartbeat
) {
615 * A pretimeout occurred, make sure we set the timeout.
616 * We don't want to set the action, though, we want to
617 * leave that alone (thus it can't be combined with the
620 return ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY
);
623 mutex_lock(&heartbeat_lock
);
626 atomic_set(&heartbeat_tofree
, 2);
629 * Don't reset the timer if we have the timer turned off, that
630 * re-enables the watchdog.
632 if (ipmi_watchdog_state
== WDOG_TIMEOUT_NONE
) {
633 mutex_unlock(&heartbeat_lock
);
637 addr
.addr_type
= IPMI_SYSTEM_INTERFACE_ADDR_TYPE
;
638 addr
.channel
= IPMI_BMC_CHANNEL
;
642 msg
.cmd
= IPMI_WDOG_RESET_TIMER
;
645 rv
= ipmi_request_supply_msgs(watchdog_user
,
646 (struct ipmi_addr
*) &addr
,
654 mutex_unlock(&heartbeat_lock
);
655 printk(KERN_WARNING PFX
"heartbeat failure: %d\n",
660 /* Wait for the heartbeat to be sent. */
661 wait_for_completion(&heartbeat_wait
);
663 if (heartbeat_recv_msg
.msg
.data
[0] == IPMI_WDOG_TIMER_NOT_INIT_RESP
) {
665 if (timeout_retries
> 3) {
666 printk(KERN_ERR PFX
": Unable to restore the IPMI"
667 " watchdog's settings, giving up.\n");
673 * The timer was not initialized, that means the BMC was
674 * probably reset and lost the watchdog information. Attempt
675 * to restore the timer's info. Note that we still hold
676 * the heartbeat lock, to keep a heartbeat from happening
677 * in this process, so must say no heartbeat to avoid a
678 * deadlock on this mutex.
680 rv
= ipmi_set_timeout(IPMI_SET_TIMEOUT_NO_HB
);
682 printk(KERN_ERR PFX
": Unable to send the command to"
683 " set the watchdog's settings, giving up.\n");
687 /* We might need a new heartbeat, so do it now */
689 } else if (heartbeat_recv_msg
.msg
.data
[0] != 0) {
691 * Got an error in the heartbeat response. It was already
692 * reported in ipmi_wdog_msg_handler, but we should return
699 mutex_unlock(&heartbeat_lock
);
704 static struct watchdog_info ident
= {
705 .options
= 0, /* WDIOF_SETTIMEOUT, */
706 .firmware_version
= 1,
710 static int ipmi_ioctl(struct file
*file
,
711 unsigned int cmd
, unsigned long arg
)
713 void __user
*argp
= (void __user
*)arg
;
718 case WDIOC_GETSUPPORT
:
719 i
= copy_to_user(argp
, &ident
, sizeof(ident
));
720 return i
? -EFAULT
: 0;
722 case WDIOC_SETTIMEOUT
:
723 i
= copy_from_user(&val
, argp
, sizeof(int));
727 return ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY
);
729 case WDIOC_GETTIMEOUT
:
730 i
= copy_to_user(argp
, &timeout
, sizeof(timeout
));
735 case WDIOC_SET_PRETIMEOUT
:
736 case WDIOC_SETPRETIMEOUT
:
737 i
= copy_from_user(&val
, argp
, sizeof(int));
741 return ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY
);
743 case WDIOC_GET_PRETIMEOUT
:
744 case WDIOC_GETPRETIMEOUT
:
745 i
= copy_to_user(argp
, &pretimeout
, sizeof(pretimeout
));
750 case WDIOC_KEEPALIVE
:
751 return ipmi_heartbeat();
753 case WDIOC_SETOPTIONS
:
754 i
= copy_from_user(&val
, argp
, sizeof(int));
757 if (val
& WDIOS_DISABLECARD
) {
758 ipmi_watchdog_state
= WDOG_TIMEOUT_NONE
;
759 ipmi_set_timeout(IPMI_SET_TIMEOUT_NO_HB
);
760 ipmi_start_timer_on_heartbeat
= 0;
763 if (val
& WDIOS_ENABLECARD
) {
764 ipmi_watchdog_state
= action_val
;
765 ipmi_set_timeout(IPMI_SET_TIMEOUT_FORCE_HB
);
769 case WDIOC_GETSTATUS
:
771 i
= copy_to_user(argp
, &val
, sizeof(val
));
781 static long ipmi_unlocked_ioctl(struct file
*file
,
787 mutex_lock(&ipmi_watchdog_mutex
);
788 ret
= ipmi_ioctl(file
, cmd
, arg
);
789 mutex_unlock(&ipmi_watchdog_mutex
);
794 static ssize_t
ipmi_write(struct file
*file
,
795 const char __user
*buf
,
805 /* In case it was set long ago */
808 for (i
= 0; i
!= len
; i
++) {
811 if (get_user(c
, buf
+ i
))
817 rv
= ipmi_heartbeat();
824 static ssize_t
ipmi_read(struct file
*file
,
836 * Reading returns if the pretimeout has gone off, and it only does
837 * it once per pretimeout.
839 spin_lock(&ipmi_read_lock
);
841 if (file
->f_flags
& O_NONBLOCK
) {
846 init_waitqueue_entry(&wait
, current
);
847 add_wait_queue(&read_q
, &wait
);
848 while (!data_to_read
) {
849 set_current_state(TASK_INTERRUPTIBLE
);
850 spin_unlock(&ipmi_read_lock
);
852 spin_lock(&ipmi_read_lock
);
854 remove_wait_queue(&read_q
, &wait
);
856 if (signal_pending(current
)) {
864 spin_unlock(&ipmi_read_lock
);
867 if (copy_to_user(buf
, &data_to_read
, 1))
876 static int ipmi_open(struct inode
*ino
, struct file
*filep
)
878 switch (iminor(ino
)) {
880 if (test_and_set_bit(0, &ipmi_wdog_open
))
885 * Don't start the timer now, let it start on the
888 ipmi_start_timer_on_heartbeat
= 1;
889 return nonseekable_open(ino
, filep
);
896 static unsigned int ipmi_poll(struct file
*file
, poll_table
*wait
)
898 unsigned int mask
= 0;
900 poll_wait(file
, &read_q
, wait
);
902 spin_lock(&ipmi_read_lock
);
904 mask
|= (POLLIN
| POLLRDNORM
);
905 spin_unlock(&ipmi_read_lock
);
910 static int ipmi_fasync(int fd
, struct file
*file
, int on
)
914 result
= fasync_helper(fd
, file
, on
, &fasync_q
);
919 static int ipmi_close(struct inode
*ino
, struct file
*filep
)
921 if (iminor(ino
) == WATCHDOG_MINOR
) {
922 if (expect_close
== 42) {
923 ipmi_watchdog_state
= WDOG_TIMEOUT_NONE
;
924 ipmi_set_timeout(IPMI_SET_TIMEOUT_NO_HB
);
927 "Unexpected close, not stopping watchdog!\n");
930 clear_bit(0, &ipmi_wdog_open
);
938 static const struct file_operations ipmi_wdog_fops
= {
939 .owner
= THIS_MODULE
,
943 .unlocked_ioctl
= ipmi_unlocked_ioctl
,
945 .release
= ipmi_close
,
946 .fasync
= ipmi_fasync
,
950 static struct miscdevice ipmi_wdog_miscdev
= {
951 .minor
= WATCHDOG_MINOR
,
953 .fops
= &ipmi_wdog_fops
956 static void ipmi_wdog_msg_handler(struct ipmi_recv_msg
*msg
,
959 if (msg
->msg
.cmd
== IPMI_WDOG_RESET_TIMER
&&
960 msg
->msg
.data
[0] == IPMI_WDOG_TIMER_NOT_INIT_RESP
)
961 printk(KERN_INFO PFX
"response: The IPMI controller appears"
962 " to have been reset, will attempt to reinitialize"
963 " the watchdog timer\n");
964 else if (msg
->msg
.data
[0] != 0)
965 printk(KERN_ERR PFX
"response: Error %x on cmd %x\n",
969 ipmi_free_recv_msg(msg
);
972 static void ipmi_wdog_pretimeout_handler(void *handler_data
)
974 if (preaction_val
!= WDOG_PRETIMEOUT_NONE
) {
975 if (preop_val
== WDOG_PREOP_PANIC
) {
976 if (atomic_inc_and_test(&preop_panic_excl
))
977 panic("Watchdog pre-timeout");
978 } else if (preop_val
== WDOG_PREOP_GIVE_DATA
) {
979 spin_lock(&ipmi_read_lock
);
981 wake_up_interruptible(&read_q
);
982 kill_fasync(&fasync_q
, SIGIO
, POLL_IN
);
984 spin_unlock(&ipmi_read_lock
);
989 * On some machines, the heartbeat will give an error and not
990 * work unless we re-enable the timer. So do so.
992 pretimeout_since_last_heartbeat
= 1;
995 static struct ipmi_user_hndl ipmi_hndlrs
= {
996 .ipmi_recv_hndl
= ipmi_wdog_msg_handler
,
997 .ipmi_watchdog_pretimeout
= ipmi_wdog_pretimeout_handler
1000 static void ipmi_register_watchdog(int ipmi_intf
)
1007 if ((ifnum_to_use
>= 0) && (ifnum_to_use
!= ipmi_intf
))
1010 watchdog_ifnum
= ipmi_intf
;
1012 rv
= ipmi_create_user(ipmi_intf
, &ipmi_hndlrs
, NULL
, &watchdog_user
);
1014 printk(KERN_CRIT PFX
"Unable to register with ipmi\n");
1018 ipmi_get_version(watchdog_user
,
1019 &ipmi_version_major
,
1020 &ipmi_version_minor
);
1022 rv
= misc_register(&ipmi_wdog_miscdev
);
1024 ipmi_destroy_user(watchdog_user
);
1025 watchdog_user
= NULL
;
1026 printk(KERN_CRIT PFX
"Unable to register misc device\n");
1030 if (nmi_handler_registered
) {
1031 int old_pretimeout
= pretimeout
;
1032 int old_timeout
= timeout
;
1033 int old_preop_val
= preop_val
;
1036 * Set the pretimeout to go off in a second and give
1037 * ourselves plenty of time to stop the timer.
1039 ipmi_watchdog_state
= WDOG_TIMEOUT_RESET
;
1040 preop_val
= WDOG_PREOP_NONE
; /* Make sure nothing happens */
1046 rv
= ipmi_set_timeout(IPMI_SET_TIMEOUT_FORCE_HB
);
1048 printk(KERN_WARNING PFX
"Error starting timer to"
1049 " test NMI: 0x%x. The NMI pretimeout will"
1050 " likely not work\n", rv
);
1057 if (testing_nmi
!= 2) {
1058 printk(KERN_WARNING PFX
"IPMI NMI didn't seem to"
1059 " occur. The NMI pretimeout will"
1060 " likely not work\n");
1064 preop_val
= old_preop_val
;
1065 pretimeout
= old_pretimeout
;
1066 timeout
= old_timeout
;
1071 if ((start_now
) && (rv
== 0)) {
1072 /* Run from startup, so start the timer now. */
1073 start_now
= 0; /* Disable this function after first startup. */
1074 ipmi_watchdog_state
= action_val
;
1075 ipmi_set_timeout(IPMI_SET_TIMEOUT_FORCE_HB
);
1076 printk(KERN_INFO PFX
"Starting now!\n");
1078 /* Stop the timer now. */
1079 ipmi_watchdog_state
= WDOG_TIMEOUT_NONE
;
1080 ipmi_set_timeout(IPMI_SET_TIMEOUT_NO_HB
);
1084 static void ipmi_unregister_watchdog(int ipmi_intf
)
1091 if (watchdog_ifnum
!= ipmi_intf
)
1094 /* Make sure no one can call us any more. */
1095 misc_deregister(&ipmi_wdog_miscdev
);
1098 * Wait to make sure the message makes it out. The lower layer has
1099 * pointers to our buffers, we want to make sure they are done before
1100 * we release our memory.
1102 while (atomic_read(&set_timeout_tofree
))
1103 schedule_timeout_uninterruptible(1);
1105 /* Disconnect from IPMI. */
1106 rv
= ipmi_destroy_user(watchdog_user
);
1108 printk(KERN_WARNING PFX
"error unlinking from IPMI: %d\n",
1111 watchdog_user
= NULL
;
1119 ipmi_nmi(unsigned int val
, struct pt_regs
*regs
)
1122 * If we get here, it's an NMI that's not a memory or I/O
1123 * error. We can't truly tell if it's from IPMI or not
1124 * without sending a message, and sending a message is almost
1125 * impossible because of locking.
1133 /* If we are not expecting a timeout, ignore it. */
1134 if (ipmi_watchdog_state
== WDOG_TIMEOUT_NONE
)
1137 if (preaction_val
!= WDOG_PRETIMEOUT_NMI
)
1141 * If no one else handled the NMI, we assume it was the IPMI
1144 if (preop_val
== WDOG_PREOP_PANIC
) {
1145 /* On some machines, the heartbeat will give
1146 an error and not work unless we re-enable
1147 the timer. So do so. */
1148 pretimeout_since_last_heartbeat
= 1;
1149 if (atomic_inc_and_test(&preop_panic_excl
))
1150 panic(PFX
"pre-timeout");
1157 static int wdog_reboot_handler(struct notifier_block
*this,
1161 static int reboot_event_handled
;
1163 if ((watchdog_user
) && (!reboot_event_handled
)) {
1164 /* Make sure we only do this once. */
1165 reboot_event_handled
= 1;
1167 if (code
== SYS_POWER_OFF
|| code
== SYS_HALT
) {
1168 /* Disable the WDT if we are shutting down. */
1169 ipmi_watchdog_state
= WDOG_TIMEOUT_NONE
;
1170 ipmi_set_timeout(IPMI_SET_TIMEOUT_NO_HB
);
1171 } else if (ipmi_watchdog_state
!= WDOG_TIMEOUT_NONE
) {
1172 /* Set a long timer to let the reboot happens, but
1173 reboot if it hangs, but only if the watchdog
1174 timer was already running. */
1177 ipmi_watchdog_state
= WDOG_TIMEOUT_RESET
;
1178 ipmi_set_timeout(IPMI_SET_TIMEOUT_NO_HB
);
1184 static struct notifier_block wdog_reboot_notifier
= {
1185 .notifier_call
= wdog_reboot_handler
,
1190 static int wdog_panic_handler(struct notifier_block
*this,
1191 unsigned long event
,
1194 static int panic_event_handled
;
1196 /* On a panic, if we have a panic timeout, make sure to extend
1197 the watchdog timer to a reasonable value to complete the
1198 panic, if the watchdog timer is running. Plus the
1199 pretimeout is meaningless at panic time. */
1200 if (watchdog_user
&& !panic_event_handled
&&
1201 ipmi_watchdog_state
!= WDOG_TIMEOUT_NONE
) {
1202 /* Make sure we do this only once. */
1203 panic_event_handled
= 1;
1207 panic_halt_ipmi_set_timeout();
1213 static struct notifier_block wdog_panic_notifier
= {
1214 .notifier_call
= wdog_panic_handler
,
1216 .priority
= 150 /* priority: INT_MAX >= x >= 0 */
1220 static void ipmi_new_smi(int if_num
, struct device
*device
)
1222 ipmi_register_watchdog(if_num
);
1225 static void ipmi_smi_gone(int if_num
)
1227 ipmi_unregister_watchdog(if_num
);
1230 static struct ipmi_smi_watcher smi_watcher
= {
1231 .owner
= THIS_MODULE
,
1232 .new_smi
= ipmi_new_smi
,
1233 .smi_gone
= ipmi_smi_gone
1236 static int action_op(const char *inval
, char *outval
)
1239 strcpy(outval
, action
);
1244 if (strcmp(inval
, "reset") == 0)
1245 action_val
= WDOG_TIMEOUT_RESET
;
1246 else if (strcmp(inval
, "none") == 0)
1247 action_val
= WDOG_TIMEOUT_NONE
;
1248 else if (strcmp(inval
, "power_cycle") == 0)
1249 action_val
= WDOG_TIMEOUT_POWER_CYCLE
;
1250 else if (strcmp(inval
, "power_off") == 0)
1251 action_val
= WDOG_TIMEOUT_POWER_DOWN
;
1254 strcpy(action
, inval
);
1258 static int preaction_op(const char *inval
, char *outval
)
1261 strcpy(outval
, preaction
);
1266 if (strcmp(inval
, "pre_none") == 0)
1267 preaction_val
= WDOG_PRETIMEOUT_NONE
;
1268 else if (strcmp(inval
, "pre_smi") == 0)
1269 preaction_val
= WDOG_PRETIMEOUT_SMI
;
1271 else if (strcmp(inval
, "pre_nmi") == 0)
1272 preaction_val
= WDOG_PRETIMEOUT_NMI
;
1274 else if (strcmp(inval
, "pre_int") == 0)
1275 preaction_val
= WDOG_PRETIMEOUT_MSG_INT
;
1278 strcpy(preaction
, inval
);
1282 static int preop_op(const char *inval
, char *outval
)
1285 strcpy(outval
, preop
);
1290 if (strcmp(inval
, "preop_none") == 0)
1291 preop_val
= WDOG_PREOP_NONE
;
1292 else if (strcmp(inval
, "preop_panic") == 0)
1293 preop_val
= WDOG_PREOP_PANIC
;
1294 else if (strcmp(inval
, "preop_give_data") == 0)
1295 preop_val
= WDOG_PREOP_GIVE_DATA
;
1298 strcpy(preop
, inval
);
1302 static void check_parms(void)
1308 if (preaction_val
== WDOG_PRETIMEOUT_NMI
) {
1310 if (preop_val
== WDOG_PREOP_GIVE_DATA
) {
1311 printk(KERN_WARNING PFX
"Pretimeout op is to give data"
1312 " but NMI pretimeout is enabled, setting"
1313 " pretimeout op to none\n");
1314 preop_op("preop_none", NULL
);
1318 if (do_nmi
&& !nmi_handler_registered
) {
1319 rv
= register_nmi_handler(NMI_UNKNOWN
, ipmi_nmi
, 0,
1322 printk(KERN_WARNING PFX
1323 "Can't register nmi handler\n");
1326 nmi_handler_registered
= 1;
1327 } else if (!do_nmi
&& nmi_handler_registered
) {
1328 unregister_nmi_handler(NMI_UNKNOWN
, "ipmi");
1329 nmi_handler_registered
= 0;
1334 static int __init
ipmi_wdog_init(void)
1338 if (action_op(action
, NULL
)) {
1339 action_op("reset", NULL
);
1340 printk(KERN_INFO PFX
"Unknown action '%s', defaulting to"
1341 " reset\n", action
);
1344 if (preaction_op(preaction
, NULL
)) {
1345 preaction_op("pre_none", NULL
);
1346 printk(KERN_INFO PFX
"Unknown preaction '%s', defaulting to"
1347 " none\n", preaction
);
1350 if (preop_op(preop
, NULL
)) {
1351 preop_op("preop_none", NULL
);
1352 printk(KERN_INFO PFX
"Unknown preop '%s', defaulting to"
1358 register_reboot_notifier(&wdog_reboot_notifier
);
1359 atomic_notifier_chain_register(&panic_notifier_list
,
1360 &wdog_panic_notifier
);
1362 rv
= ipmi_smi_watcher_register(&smi_watcher
);
1365 if (nmi_handler_registered
)
1366 unregister_nmi_handler(NMI_UNKNOWN
, "ipmi");
1368 atomic_notifier_chain_unregister(&panic_notifier_list
,
1369 &wdog_panic_notifier
);
1370 unregister_reboot_notifier(&wdog_reboot_notifier
);
1371 printk(KERN_WARNING PFX
"can't register smi watcher\n");
1375 printk(KERN_INFO PFX
"driver initialized\n");
1380 static void __exit
ipmi_wdog_exit(void)
1382 ipmi_smi_watcher_unregister(&smi_watcher
);
1383 ipmi_unregister_watchdog(watchdog_ifnum
);
1386 if (nmi_handler_registered
)
1387 unregister_nmi_handler(NMI_UNKNOWN
, "ipmi");
1390 atomic_notifier_chain_unregister(&panic_notifier_list
,
1391 &wdog_panic_notifier
);
1392 unregister_reboot_notifier(&wdog_reboot_notifier
);
1394 module_exit(ipmi_wdog_exit
);
1395 module_init(ipmi_wdog_init
);
1396 MODULE_LICENSE("GPL");
1397 MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>");
1398 MODULE_DESCRIPTION("watchdog timer based upon the IPMI interface.");