Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
ipmi_watchdog.c
Go to the documentation of this file.
1 /*
2  * ipmi_watchdog.c
3  *
4  * A watchdog timer based upon the IPMI interface.
5  *
6  * Author: MontaVista Software, Inc.
7  * Corey Minyard <[email protected]>
9  *
10  * Copyright 2002 MontaVista Software Inc.
11  *
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.
16  *
17  *
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.
28  *
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.
32  */
33 
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>
56 
57 #ifdef CONFIG_X86
58 /*
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.
66  */
67 #include <asm/kdebug.h>
68 #include <asm/nmi.h>
69 #define HAVE_DIE_NMI
70 #endif
71 
72 #define PFX "IPMI Watchdog: "
73 
74 /*
75  * The IPMI command/response information for the watchdog timer.
76  */
77 
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
89 
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
98 
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
104 
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
113 
114 /*
115  * Byte 3 of the get command, byte 4 of the get response is the
116  * pre-timeout in seconds.
117  */
118 
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)
125 
126 /*
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).
132  */
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)
137 
138 #define IPMI_WDOG_RESET_TIMER 0x22
139 #define IPMI_WDOG_SET_TIMER 0x24
140 #define IPMI_WDOG_GET_TIMER 0x25
141 
142 #define IPMI_WDOG_TIMER_NOT_INIT_RESP 0x80
143 
144 static DEFINE_MUTEX(ipmi_watchdog_mutex);
145 static bool nowayout = WATCHDOG_NOWAYOUT;
146 
147 static ipmi_user_t watchdog_user;
148 static int watchdog_ifnum;
149 
150 /* Default the timeout to 10 seconds. */
151 static int timeout = 10;
152 
153 /* The pre-timeout is disabled by default. */
154 static int pretimeout;
155 
156 /* Default action is to reset the board on a timeout. */
157 static unsigned char action_val = WDOG_TIMEOUT_RESET;
158 
159 static char action[16] = "reset";
160 
161 static unsigned char preaction_val = WDOG_PRETIMEOUT_NONE;
162 
163 static char preaction[16] = "pre_none";
164 
165 static unsigned char preop_val = WDOG_PREOP_NONE;
166 
167 static char preop[16] = "preop_none";
168 static DEFINE_SPINLOCK(ipmi_read_lock);
169 static char data_to_read;
170 static DECLARE_WAIT_QUEUE_HEAD(read_q);
171 static struct fasync_struct *fasync_q;
172 static char pretimeout_since_last_heartbeat;
173 static char expect_close;
174 
175 static int ifnum_to_use = -1;
176 
177 /* Parameters to ipmi_set_timeout */
178 #define IPMI_SET_TIMEOUT_NO_HB 0
179 #define IPMI_SET_TIMEOUT_HB_IF_NECESSARY 1
180 #define IPMI_SET_TIMEOUT_FORCE_HB 2
181 
182 static int ipmi_set_timeout(int do_heartbeat);
183 static void ipmi_register_watchdog(int ipmi_intf);
184 static void ipmi_unregister_watchdog(int ipmi_intf);
185 
186 /*
187  * If true, the driver will start running as soon as it is configured
188  * and ready.
189  */
190 static int start_now;
191 
192 static int set_param_timeout(const char *val, const struct kernel_param *kp)
193 {
194  char *endp;
195  int l;
196  int rv = 0;
197 
198  if (!val)
199  return -EINVAL;
200  l = simple_strtoul(val, &endp, 0);
201  if (endp == val)
202  return -EINVAL;
203 
204  *((int *)kp->arg) = l;
205  if (watchdog_user)
206  rv = ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY);
207 
208  return rv;
209 }
210 
211 static struct kernel_param_ops param_ops_timeout = {
212  .set = set_param_timeout,
213  .get = param_get_int,
214 };
215 #define param_check_timeout param_check_int
216 
217 typedef int (*action_fn)(const char *intval, char *outval);
218 
219 static int action_op(const char *inval, char *outval);
220 static int preaction_op(const char *inval, char *outval);
221 static int preop_op(const char *inval, char *outval);
222 static void check_parms(void);
223 
224 static int set_param_str(const char *val, const struct kernel_param *kp)
225 {
226  action_fn fn = (action_fn) kp->arg;
227  int rv = 0;
228  char valcp[16];
229  char *s;
230 
231  strncpy(valcp, val, 16);
232  valcp[15] = '\0';
233 
234  s = strstrip(valcp);
235 
236  rv = fn(s, NULL);
237  if (rv)
238  goto out;
239 
240  check_parms();
241  if (watchdog_user)
242  rv = ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY);
243 
244  out:
245  return rv;
246 }
247 
248 static int get_param_str(char *buffer, const struct kernel_param *kp)
249 {
250  action_fn fn = (action_fn) kp->arg;
251  int rv;
252 
253  rv = fn(NULL, buffer);
254  if (rv)
255  return rv;
256  return strlen(buffer);
257 }
258 
259 
260 static int set_param_wdog_ifnum(const char *val, const struct kernel_param *kp)
261 {
262  int rv = param_set_int(val, kp);
263  if (rv)
264  return rv;
265  if ((ifnum_to_use < 0) || (ifnum_to_use == watchdog_ifnum))
266  return 0;
267 
268  ipmi_unregister_watchdog(watchdog_ifnum);
269  ipmi_register_watchdog(ifnum_to_use);
270  return 0;
271 }
272 
273 static struct kernel_param_ops param_ops_wdog_ifnum = {
274  .set = set_param_wdog_ifnum,
275  .get = param_get_int,
276 };
277 
278 #define param_check_wdog_ifnum param_check_int
279 
280 static struct kernel_param_ops param_ops_str = {
281  .set = set_param_str,
282  .get = get_param_str,
283 };
284 
285 module_param(ifnum_to_use, wdog_ifnum, 0644);
286 MODULE_PARM_DESC(ifnum_to_use, "The interface number to use for the watchdog "
287  "timer. Setting to -1 defaults to the first registered "
288  "interface");
289 
290 module_param(timeout, timeout, 0644);
291 MODULE_PARM_DESC(timeout, "Timeout value in seconds.");
292 
293 module_param(pretimeout, timeout, 0644);
294 MODULE_PARM_DESC(pretimeout, "Pretimeout value in seconds.");
295 
296 module_param_cb(action, &param_ops_str, action_op, 0644);
297 MODULE_PARM_DESC(action, "Timeout action. One of: "
298  "reset, none, power_cycle, power_off.");
299 
300 module_param_cb(preaction, &param_ops_str, preaction_op, 0644);
301 MODULE_PARM_DESC(preaction, "Pretimeout action. One of: "
302  "pre_none, pre_smi, pre_nmi, pre_int.");
303 
304 module_param_cb(preop, &param_ops_str, preop_op, 0644);
305 MODULE_PARM_DESC(preop, "Pretimeout driver operation. One of: "
306  "preop_none, preop_panic, preop_give_data.");
307 
308 module_param(start_now, int, 0444);
309 MODULE_PARM_DESC(start_now, "Set to 1 to start the watchdog as"
310  "soon as the driver is loaded.");
311 
312 module_param(nowayout, bool, 0644);
313 MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started "
314  "(default=CONFIG_WATCHDOG_NOWAYOUT)");
315 
316 /* Default state of the timer. */
317 static unsigned char ipmi_watchdog_state = WDOG_TIMEOUT_NONE;
318 
319 /* If shutting down via IPMI, we ignore the heartbeat. */
320 static int ipmi_ignore_heartbeat;
321 
322 /* Is someone using the watchdog? Only one user is allowed. */
323 static unsigned long ipmi_wdog_open;
324 
325 /*
326  * If set to 1, the heartbeat command will set the state to reset and
327  * start the timer. The timer doesn't normally run when the driver is
328  * first opened until the heartbeat is set the first time, this
329  * variable is used to accomplish this.
330  */
331 static int ipmi_start_timer_on_heartbeat;
332 
333 /* IPMI version of the BMC. */
334 static unsigned char ipmi_version_major;
335 static unsigned char ipmi_version_minor;
336 
337 /* If a pretimeout occurs, this is used to allow only one panic to happen. */
338 static atomic_t preop_panic_excl = ATOMIC_INIT(-1);
339 
340 #ifdef HAVE_DIE_NMI
341 static int testing_nmi;
342 static int nmi_handler_registered;
343 #endif
344 
345 static int ipmi_heartbeat(void);
346 
347 /*
348  * We use a mutex to make sure that only one thing can send a set
349  * timeout at one time, because we only have one copy of the data.
350  * The mutex is claimed when the set_timeout is sent and freed
351  * when both messages are free.
352  */
353 static atomic_t set_timeout_tofree = ATOMIC_INIT(0);
354 static DEFINE_MUTEX(set_timeout_lock);
355 static DECLARE_COMPLETION(set_timeout_wait);
356 static void set_timeout_free_smi(struct ipmi_smi_msg *msg)
357 {
358  if (atomic_dec_and_test(&set_timeout_tofree))
359  complete(&set_timeout_wait);
360 }
361 static void set_timeout_free_recv(struct ipmi_recv_msg *msg)
362 {
363  if (atomic_dec_and_test(&set_timeout_tofree))
364  complete(&set_timeout_wait);
365 }
366 static struct ipmi_smi_msg set_timeout_smi_msg = {
367  .done = set_timeout_free_smi
368 };
369 static struct ipmi_recv_msg set_timeout_recv_msg = {
370  .done = set_timeout_free_recv
371 };
372 
373 static int i_ipmi_set_timeout(struct ipmi_smi_msg *smi_msg,
374  struct ipmi_recv_msg *recv_msg,
375  int *send_heartbeat_now)
376 {
377  struct kernel_ipmi_msg msg;
378  unsigned char data[6];
379  int rv;
381  int hbnow = 0;
382 
383 
384  /* These can be cleared as we are setting the timeout. */
385  pretimeout_since_last_heartbeat = 0;
386 
387  data[0] = 0;
389 
390  if ((ipmi_version_major > 1)
391  || ((ipmi_version_major == 1) && (ipmi_version_minor >= 5))) {
392  /* This is an IPMI 1.5-only feature. */
393  data[0] |= WDOG_DONT_STOP_ON_SET;
394  } else if (ipmi_watchdog_state != WDOG_TIMEOUT_NONE) {
395  /*
396  * In ipmi 1.0, setting the timer stops the watchdog, we
397  * need to start it back up again.
398  */
399  hbnow = 1;
400  }
401 
402  data[1] = 0;
403  WDOG_SET_TIMEOUT_ACT(data[1], ipmi_watchdog_state);
404  if ((pretimeout > 0) && (ipmi_watchdog_state != WDOG_TIMEOUT_NONE)) {
405  WDOG_SET_PRETIMEOUT_ACT(data[1], preaction_val);
406  data[2] = pretimeout;
407  } else {
409  data[2] = 0; /* No pretimeout. */
410  }
411  data[3] = 0;
412  WDOG_SET_TIMEOUT(data[4], data[5], timeout);
413 
415  addr.channel = IPMI_BMC_CHANNEL;
416  addr.lun = 0;
417 
418  msg.netfn = 0x06;
419  msg.cmd = IPMI_WDOG_SET_TIMER;
420  msg.data = data;
421  msg.data_len = sizeof(data);
422  rv = ipmi_request_supply_msgs(watchdog_user,
423  (struct ipmi_addr *) &addr,
424  0,
425  &msg,
426  NULL,
427  smi_msg,
428  recv_msg,
429  1);
430  if (rv) {
431  printk(KERN_WARNING PFX "set timeout error: %d\n",
432  rv);
433  }
434 
435  if (send_heartbeat_now)
436  *send_heartbeat_now = hbnow;
437 
438  return rv;
439 }
440 
441 static int ipmi_set_timeout(int do_heartbeat)
442 {
443  int send_heartbeat_now;
444  int rv;
445 
446 
447  /* We can only send one of these at a time. */
448  mutex_lock(&set_timeout_lock);
449 
450  atomic_set(&set_timeout_tofree, 2);
451 
452  rv = i_ipmi_set_timeout(&set_timeout_smi_msg,
453  &set_timeout_recv_msg,
454  &send_heartbeat_now);
455  if (rv) {
456  mutex_unlock(&set_timeout_lock);
457  goto out;
458  }
459 
460  wait_for_completion(&set_timeout_wait);
461 
462  mutex_unlock(&set_timeout_lock);
463 
464  if ((do_heartbeat == IPMI_SET_TIMEOUT_FORCE_HB)
465  || ((send_heartbeat_now)
466  && (do_heartbeat == IPMI_SET_TIMEOUT_HB_IF_NECESSARY)))
467  rv = ipmi_heartbeat();
468 
469 out:
470  return rv;
471 }
472 
473 static atomic_t panic_done_count = ATOMIC_INIT(0);
474 
475 static void panic_smi_free(struct ipmi_smi_msg *msg)
476 {
477  atomic_dec(&panic_done_count);
478 }
479 static void panic_recv_free(struct ipmi_recv_msg *msg)
480 {
481  atomic_dec(&panic_done_count);
482 }
483 
484 static struct ipmi_smi_msg panic_halt_heartbeat_smi_msg = {
485  .done = panic_smi_free
486 };
487 static struct ipmi_recv_msg panic_halt_heartbeat_recv_msg = {
488  .done = panic_recv_free
489 };
490 
491 static void panic_halt_ipmi_heartbeat(void)
492 {
493  struct kernel_ipmi_msg msg;
495  int rv;
496 
497  /*
498  * Don't reset the timer if we have the timer turned off, that
499  * re-enables the watchdog.
500  */
501  if (ipmi_watchdog_state == WDOG_TIMEOUT_NONE)
502  return;
503 
505  addr.channel = IPMI_BMC_CHANNEL;
506  addr.lun = 0;
507 
508  msg.netfn = 0x06;
509  msg.cmd = IPMI_WDOG_RESET_TIMER;
510  msg.data = NULL;
511  msg.data_len = 0;
512  atomic_add(2, &panic_done_count);
513  rv = ipmi_request_supply_msgs(watchdog_user,
514  (struct ipmi_addr *) &addr,
515  0,
516  &msg,
517  NULL,
518  &panic_halt_heartbeat_smi_msg,
519  &panic_halt_heartbeat_recv_msg,
520  1);
521  if (rv)
522  atomic_sub(2, &panic_done_count);
523 }
524 
525 static struct ipmi_smi_msg panic_halt_smi_msg = {
526  .done = panic_smi_free
527 };
528 static struct ipmi_recv_msg panic_halt_recv_msg = {
529  .done = panic_recv_free
530 };
531 
532 /*
533  * Special call, doesn't claim any locks. This is only to be called
534  * at panic or halt time, in run-to-completion mode, when the caller
535  * is the only CPU and the only thing that will be going is these IPMI
536  * calls.
537  */
538 static void panic_halt_ipmi_set_timeout(void)
539 {
540  int send_heartbeat_now;
541  int rv;
542 
543  /* Wait for the messages to be free. */
544  while (atomic_read(&panic_done_count) != 0)
545  ipmi_poll_interface(watchdog_user);
546  atomic_add(2, &panic_done_count);
547  rv = i_ipmi_set_timeout(&panic_halt_smi_msg,
548  &panic_halt_recv_msg,
549  &send_heartbeat_now);
550  if (rv) {
551  atomic_sub(2, &panic_done_count);
553  "Unable to extend the watchdog timeout.");
554  } else {
555  if (send_heartbeat_now)
556  panic_halt_ipmi_heartbeat();
557  }
558  while (atomic_read(&panic_done_count) != 0)
559  ipmi_poll_interface(watchdog_user);
560 }
561 
562 /*
563  * We use a mutex to make sure that only one thing can send a
564  * heartbeat at one time, because we only have one copy of the data.
565  * The semaphore is claimed when the set_timeout is sent and freed
566  * when both messages are free.
567  */
568 static atomic_t heartbeat_tofree = ATOMIC_INIT(0);
569 static DEFINE_MUTEX(heartbeat_lock);
570 static DECLARE_COMPLETION(heartbeat_wait);
571 static void heartbeat_free_smi(struct ipmi_smi_msg *msg)
572 {
573  if (atomic_dec_and_test(&heartbeat_tofree))
574  complete(&heartbeat_wait);
575 }
576 static void heartbeat_free_recv(struct ipmi_recv_msg *msg)
577 {
578  if (atomic_dec_and_test(&heartbeat_tofree))
579  complete(&heartbeat_wait);
580 }
581 static struct ipmi_smi_msg heartbeat_smi_msg = {
582  .done = heartbeat_free_smi
583 };
584 static struct ipmi_recv_msg heartbeat_recv_msg = {
585  .done = heartbeat_free_recv
586 };
587 
588 static int ipmi_heartbeat(void)
589 {
590  struct kernel_ipmi_msg msg;
591  int rv;
593  int timeout_retries = 0;
594 
595  if (ipmi_ignore_heartbeat)
596  return 0;
597 
598  if (ipmi_start_timer_on_heartbeat) {
599  ipmi_start_timer_on_heartbeat = 0;
600  ipmi_watchdog_state = action_val;
601  return ipmi_set_timeout(IPMI_SET_TIMEOUT_FORCE_HB);
602  } else if (pretimeout_since_last_heartbeat) {
603  /*
604  * A pretimeout occurred, make sure we set the timeout.
605  * We don't want to set the action, though, we want to
606  * leave that alone (thus it can't be combined with the
607  * above operation.
608  */
609  return ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY);
610  }
611 
612  mutex_lock(&heartbeat_lock);
613 
614 restart:
615  atomic_set(&heartbeat_tofree, 2);
616 
617  /*
618  * Don't reset the timer if we have the timer turned off, that
619  * re-enables the watchdog.
620  */
621  if (ipmi_watchdog_state == WDOG_TIMEOUT_NONE) {
622  mutex_unlock(&heartbeat_lock);
623  return 0;
624  }
625 
627  addr.channel = IPMI_BMC_CHANNEL;
628  addr.lun = 0;
629 
630  msg.netfn = 0x06;
631  msg.cmd = IPMI_WDOG_RESET_TIMER;
632  msg.data = NULL;
633  msg.data_len = 0;
634  rv = ipmi_request_supply_msgs(watchdog_user,
635  (struct ipmi_addr *) &addr,
636  0,
637  &msg,
638  NULL,
639  &heartbeat_smi_msg,
640  &heartbeat_recv_msg,
641  1);
642  if (rv) {
643  mutex_unlock(&heartbeat_lock);
644  printk(KERN_WARNING PFX "heartbeat failure: %d\n",
645  rv);
646  return rv;
647  }
648 
649  /* Wait for the heartbeat to be sent. */
650  wait_for_completion(&heartbeat_wait);
651 
652  if (heartbeat_recv_msg.msg.data[0] == IPMI_WDOG_TIMER_NOT_INIT_RESP) {
653  timeout_retries++;
654  if (timeout_retries > 3) {
655  printk(KERN_ERR PFX ": Unable to restore the IPMI"
656  " watchdog's settings, giving up.\n");
657  rv = -EIO;
658  goto out_unlock;
659  }
660 
661  /*
662  * The timer was not initialized, that means the BMC was
663  * probably reset and lost the watchdog information. Attempt
664  * to restore the timer's info. Note that we still hold
665  * the heartbeat lock, to keep a heartbeat from happening
666  * in this process, so must say no heartbeat to avoid a
667  * deadlock on this mutex.
668  */
669  rv = ipmi_set_timeout(IPMI_SET_TIMEOUT_NO_HB);
670  if (rv) {
671  printk(KERN_ERR PFX ": Unable to send the command to"
672  " set the watchdog's settings, giving up.\n");
673  goto out_unlock;
674  }
675 
676  /* We might need a new heartbeat, so do it now */
677  goto restart;
678  } else if (heartbeat_recv_msg.msg.data[0] != 0) {
679  /*
680  * Got an error in the heartbeat response. It was already
681  * reported in ipmi_wdog_msg_handler, but we should return
682  * an error here.
683  */
684  rv = -EINVAL;
685  }
686 
687 out_unlock:
688  mutex_unlock(&heartbeat_lock);
689 
690  return rv;
691 }
692 
693 static struct watchdog_info ident = {
694  .options = 0, /* WDIOF_SETTIMEOUT, */
695  .firmware_version = 1,
696  .identity = "IPMI"
697 };
698 
699 static int ipmi_ioctl(struct file *file,
700  unsigned int cmd, unsigned long arg)
701 {
702  void __user *argp = (void __user *)arg;
703  int i;
704  int val;
705 
706  switch (cmd) {
707  case WDIOC_GETSUPPORT:
708  i = copy_to_user(argp, &ident, sizeof(ident));
709  return i ? -EFAULT : 0;
710 
711  case WDIOC_SETTIMEOUT:
712  i = copy_from_user(&val, argp, sizeof(int));
713  if (i)
714  return -EFAULT;
715  timeout = val;
716  return ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY);
717 
718  case WDIOC_GETTIMEOUT:
719  i = copy_to_user(argp, &timeout, sizeof(timeout));
720  if (i)
721  return -EFAULT;
722  return 0;
723 
724  case WDIOC_SETPRETIMEOUT:
725  i = copy_from_user(&val, argp, sizeof(int));
726  if (i)
727  return -EFAULT;
728  pretimeout = val;
729  return ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY);
730 
731  case WDIOC_GETPRETIMEOUT:
732  i = copy_to_user(argp, &pretimeout, sizeof(pretimeout));
733  if (i)
734  return -EFAULT;
735  return 0;
736 
737  case WDIOC_KEEPALIVE:
738  return ipmi_heartbeat();
739 
740  case WDIOC_SETOPTIONS:
741  i = copy_from_user(&val, argp, sizeof(int));
742  if (i)
743  return -EFAULT;
744  if (val & WDIOS_DISABLECARD) {
745  ipmi_watchdog_state = WDOG_TIMEOUT_NONE;
746  ipmi_set_timeout(IPMI_SET_TIMEOUT_NO_HB);
747  ipmi_start_timer_on_heartbeat = 0;
748  }
749 
750  if (val & WDIOS_ENABLECARD) {
751  ipmi_watchdog_state = action_val;
752  ipmi_set_timeout(IPMI_SET_TIMEOUT_FORCE_HB);
753  }
754  return 0;
755 
756  case WDIOC_GETSTATUS:
757  val = 0;
758  i = copy_to_user(argp, &val, sizeof(val));
759  if (i)
760  return -EFAULT;
761  return 0;
762 
763  default:
764  return -ENOIOCTLCMD;
765  }
766 }
767 
768 static long ipmi_unlocked_ioctl(struct file *file,
769  unsigned int cmd,
770  unsigned long arg)
771 {
772  int ret;
773 
774  mutex_lock(&ipmi_watchdog_mutex);
775  ret = ipmi_ioctl(file, cmd, arg);
776  mutex_unlock(&ipmi_watchdog_mutex);
777 
778  return ret;
779 }
780 
781 static ssize_t ipmi_write(struct file *file,
782  const char __user *buf,
783  size_t len,
784  loff_t *ppos)
785 {
786  int rv;
787 
788  if (len) {
789  if (!nowayout) {
790  size_t i;
791 
792  /* In case it was set long ago */
793  expect_close = 0;
794 
795  for (i = 0; i != len; i++) {
796  char c;
797 
798  if (get_user(c, buf + i))
799  return -EFAULT;
800  if (c == 'V')
801  expect_close = 42;
802  }
803  }
804  rv = ipmi_heartbeat();
805  if (rv)
806  return rv;
807  }
808  return len;
809 }
810 
811 static ssize_t ipmi_read(struct file *file,
812  char __user *buf,
813  size_t count,
814  loff_t *ppos)
815 {
816  int rv = 0;
818 
819  if (count <= 0)
820  return 0;
821 
822  /*
823  * Reading returns if the pretimeout has gone off, and it only does
824  * it once per pretimeout.
825  */
826  spin_lock(&ipmi_read_lock);
827  if (!data_to_read) {
828  if (file->f_flags & O_NONBLOCK) {
829  rv = -EAGAIN;
830  goto out;
831  }
832 
833  init_waitqueue_entry(&wait, current);
834  add_wait_queue(&read_q, &wait);
835  while (!data_to_read) {
837  spin_unlock(&ipmi_read_lock);
838  schedule();
839  spin_lock(&ipmi_read_lock);
840  }
841  remove_wait_queue(&read_q, &wait);
842 
843  if (signal_pending(current)) {
844  rv = -ERESTARTSYS;
845  goto out;
846  }
847  }
848  data_to_read = 0;
849 
850  out:
851  spin_unlock(&ipmi_read_lock);
852 
853  if (rv == 0) {
854  if (copy_to_user(buf, &data_to_read, 1))
855  rv = -EFAULT;
856  else
857  rv = 1;
858  }
859 
860  return rv;
861 }
862 
863 static int ipmi_open(struct inode *ino, struct file *filep)
864 {
865  switch (iminor(ino)) {
866  case WATCHDOG_MINOR:
867  if (test_and_set_bit(0, &ipmi_wdog_open))
868  return -EBUSY;
869 
870 
871  /*
872  * Don't start the timer now, let it start on the
873  * first heartbeat.
874  */
875  ipmi_start_timer_on_heartbeat = 1;
876  return nonseekable_open(ino, filep);
877 
878  default:
879  return (-ENODEV);
880  }
881 }
882 
883 static unsigned int ipmi_poll(struct file *file, poll_table *wait)
884 {
885  unsigned int mask = 0;
886 
887  poll_wait(file, &read_q, wait);
888 
889  spin_lock(&ipmi_read_lock);
890  if (data_to_read)
891  mask |= (POLLIN | POLLRDNORM);
892  spin_unlock(&ipmi_read_lock);
893 
894  return mask;
895 }
896 
897 static int ipmi_fasync(int fd, struct file *file, int on)
898 {
899  int result;
900 
901  result = fasync_helper(fd, file, on, &fasync_q);
902 
903  return (result);
904 }
905 
906 static int ipmi_close(struct inode *ino, struct file *filep)
907 {
908  if (iminor(ino) == WATCHDOG_MINOR) {
909  if (expect_close == 42) {
910  ipmi_watchdog_state = WDOG_TIMEOUT_NONE;
911  ipmi_set_timeout(IPMI_SET_TIMEOUT_NO_HB);
912  } else {
914  "Unexpected close, not stopping watchdog!\n");
915  ipmi_heartbeat();
916  }
917  clear_bit(0, &ipmi_wdog_open);
918  }
919 
920  expect_close = 0;
921 
922  return 0;
923 }
924 
925 static const struct file_operations ipmi_wdog_fops = {
926  .owner = THIS_MODULE,
927  .read = ipmi_read,
928  .poll = ipmi_poll,
929  .write = ipmi_write,
930  .unlocked_ioctl = ipmi_unlocked_ioctl,
931  .open = ipmi_open,
932  .release = ipmi_close,
933  .fasync = ipmi_fasync,
934  .llseek = no_llseek,
935 };
936 
937 static struct miscdevice ipmi_wdog_miscdev = {
938  .minor = WATCHDOG_MINOR,
939  .name = "watchdog",
940  .fops = &ipmi_wdog_fops
941 };
942 
943 static void ipmi_wdog_msg_handler(struct ipmi_recv_msg *msg,
944  void *handler_data)
945 {
946  if (msg->msg.cmd == IPMI_WDOG_RESET_TIMER &&
947  msg->msg.data[0] == IPMI_WDOG_TIMER_NOT_INIT_RESP)
948  printk(KERN_INFO PFX "response: The IPMI controller appears"
949  " to have been reset, will attempt to reinitialize"
950  " the watchdog timer\n");
951  else if (msg->msg.data[0] != 0)
952  printk(KERN_ERR PFX "response: Error %x on cmd %x\n",
953  msg->msg.data[0],
954  msg->msg.cmd);
955 
956  ipmi_free_recv_msg(msg);
957 }
958 
959 static void ipmi_wdog_pretimeout_handler(void *handler_data)
960 {
961  if (preaction_val != WDOG_PRETIMEOUT_NONE) {
962  if (preop_val == WDOG_PREOP_PANIC) {
963  if (atomic_inc_and_test(&preop_panic_excl))
964  panic("Watchdog pre-timeout");
965  } else if (preop_val == WDOG_PREOP_GIVE_DATA) {
966  spin_lock(&ipmi_read_lock);
967  data_to_read = 1;
968  wake_up_interruptible(&read_q);
969  kill_fasync(&fasync_q, SIGIO, POLL_IN);
970 
971  spin_unlock(&ipmi_read_lock);
972  }
973  }
974 
975  /*
976  * On some machines, the heartbeat will give an error and not
977  * work unless we re-enable the timer. So do so.
978  */
979  pretimeout_since_last_heartbeat = 1;
980 }
981 
982 static struct ipmi_user_hndl ipmi_hndlrs = {
983  .ipmi_recv_hndl = ipmi_wdog_msg_handler,
984  .ipmi_watchdog_pretimeout = ipmi_wdog_pretimeout_handler
985 };
986 
987 static void ipmi_register_watchdog(int ipmi_intf)
988 {
989  int rv = -EBUSY;
990 
991  if (watchdog_user)
992  goto out;
993 
994  if ((ifnum_to_use >= 0) && (ifnum_to_use != ipmi_intf))
995  goto out;
996 
997  watchdog_ifnum = ipmi_intf;
998 
999  rv = ipmi_create_user(ipmi_intf, &ipmi_hndlrs, NULL, &watchdog_user);
1000  if (rv < 0) {
1001  printk(KERN_CRIT PFX "Unable to register with ipmi\n");
1002  goto out;
1003  }
1004 
1005  ipmi_get_version(watchdog_user,
1006  &ipmi_version_major,
1007  &ipmi_version_minor);
1008 
1009  rv = misc_register(&ipmi_wdog_miscdev);
1010  if (rv < 0) {
1011  ipmi_destroy_user(watchdog_user);
1012  watchdog_user = NULL;
1013  printk(KERN_CRIT PFX "Unable to register misc device\n");
1014  }
1015 
1016 #ifdef HAVE_DIE_NMI
1017  if (nmi_handler_registered) {
1018  int old_pretimeout = pretimeout;
1019  int old_timeout = timeout;
1020  int old_preop_val = preop_val;
1021 
1022  /*
1023  * Set the pretimeout to go off in a second and give
1024  * ourselves plenty of time to stop the timer.
1025  */
1026  ipmi_watchdog_state = WDOG_TIMEOUT_RESET;
1027  preop_val = WDOG_PREOP_NONE; /* Make sure nothing happens */
1028  pretimeout = 99;
1029  timeout = 100;
1030 
1031  testing_nmi = 1;
1032 
1033  rv = ipmi_set_timeout(IPMI_SET_TIMEOUT_FORCE_HB);
1034  if (rv) {
1035  printk(KERN_WARNING PFX "Error starting timer to"
1036  " test NMI: 0x%x. The NMI pretimeout will"
1037  " likely not work\n", rv);
1038  rv = 0;
1039  goto out_restore;
1040  }
1041 
1042  msleep(1500);
1043 
1044  if (testing_nmi != 2) {
1045  printk(KERN_WARNING PFX "IPMI NMI didn't seem to"
1046  " occur. The NMI pretimeout will"
1047  " likely not work\n");
1048  }
1049  out_restore:
1050  testing_nmi = 0;
1051  preop_val = old_preop_val;
1052  pretimeout = old_pretimeout;
1053  timeout = old_timeout;
1054  }
1055 #endif
1056 
1057  out:
1058  if ((start_now) && (rv == 0)) {
1059  /* Run from startup, so start the timer now. */
1060  start_now = 0; /* Disable this function after first startup. */
1061  ipmi_watchdog_state = action_val;
1062  ipmi_set_timeout(IPMI_SET_TIMEOUT_FORCE_HB);
1063  printk(KERN_INFO PFX "Starting now!\n");
1064  } else {
1065  /* Stop the timer now. */
1066  ipmi_watchdog_state = WDOG_TIMEOUT_NONE;
1067  ipmi_set_timeout(IPMI_SET_TIMEOUT_NO_HB);
1068  }
1069 }
1070 
1071 static void ipmi_unregister_watchdog(int ipmi_intf)
1072 {
1073  int rv;
1074 
1075  if (!watchdog_user)
1076  goto out;
1077 
1078  if (watchdog_ifnum != ipmi_intf)
1079  goto out;
1080 
1081  /* Make sure no one can call us any more. */
1082  misc_deregister(&ipmi_wdog_miscdev);
1083 
1084  /*
1085  * Wait to make sure the message makes it out. The lower layer has
1086  * pointers to our buffers, we want to make sure they are done before
1087  * we release our memory.
1088  */
1089  while (atomic_read(&set_timeout_tofree))
1091 
1092  /* Disconnect from IPMI. */
1093  rv = ipmi_destroy_user(watchdog_user);
1094  if (rv) {
1095  printk(KERN_WARNING PFX "error unlinking from IPMI: %d\n",
1096  rv);
1097  }
1098  watchdog_user = NULL;
1099 
1100  out:
1101  return;
1102 }
1103 
1104 #ifdef HAVE_DIE_NMI
1105 static int
1106 ipmi_nmi(unsigned int val, struct pt_regs *regs)
1107 {
1108  /*
1109  * If we get here, it's an NMI that's not a memory or I/O
1110  * error. We can't truly tell if it's from IPMI or not
1111  * without sending a message, and sending a message is almost
1112  * impossible because of locking.
1113  */
1114 
1115  if (testing_nmi) {
1116  testing_nmi = 2;
1117  return NMI_HANDLED;
1118  }
1119 
1120  /* If we are not expecting a timeout, ignore it. */
1121  if (ipmi_watchdog_state == WDOG_TIMEOUT_NONE)
1122  return NMI_DONE;
1123 
1124  if (preaction_val != WDOG_PRETIMEOUT_NMI)
1125  return NMI_DONE;
1126 
1127  /*
1128  * If no one else handled the NMI, we assume it was the IPMI
1129  * watchdog.
1130  */
1131  if (preop_val == WDOG_PREOP_PANIC) {
1132  /* On some machines, the heartbeat will give
1133  an error and not work unless we re-enable
1134  the timer. So do so. */
1135  pretimeout_since_last_heartbeat = 1;
1136  if (atomic_inc_and_test(&preop_panic_excl))
1137  panic(PFX "pre-timeout");
1138  }
1139 
1140  return NMI_HANDLED;
1141 }
1142 #endif
1143 
1144 static int wdog_reboot_handler(struct notifier_block *this,
1145  unsigned long code,
1146  void *unused)
1147 {
1148  static int reboot_event_handled;
1149 
1150  if ((watchdog_user) && (!reboot_event_handled)) {
1151  /* Make sure we only do this once. */
1152  reboot_event_handled = 1;
1153 
1154  if (code == SYS_POWER_OFF || code == SYS_HALT) {
1155  /* Disable the WDT if we are shutting down. */
1156  ipmi_watchdog_state = WDOG_TIMEOUT_NONE;
1157  ipmi_set_timeout(IPMI_SET_TIMEOUT_NO_HB);
1158  } else if (ipmi_watchdog_state != WDOG_TIMEOUT_NONE) {
1159  /* Set a long timer to let the reboot happens, but
1160  reboot if it hangs, but only if the watchdog
1161  timer was already running. */
1162  timeout = 120;
1163  pretimeout = 0;
1164  ipmi_watchdog_state = WDOG_TIMEOUT_RESET;
1165  ipmi_set_timeout(IPMI_SET_TIMEOUT_NO_HB);
1166  }
1167  }
1168  return NOTIFY_OK;
1169 }
1170 
1171 static struct notifier_block wdog_reboot_notifier = {
1172  .notifier_call = wdog_reboot_handler,
1173  .next = NULL,
1174  .priority = 0
1175 };
1176 
1177 static int wdog_panic_handler(struct notifier_block *this,
1178  unsigned long event,
1179  void *unused)
1180 {
1181  static int panic_event_handled;
1182 
1183  /* On a panic, if we have a panic timeout, make sure to extend
1184  the watchdog timer to a reasonable value to complete the
1185  panic, if the watchdog timer is running. Plus the
1186  pretimeout is meaningless at panic time. */
1187  if (watchdog_user && !panic_event_handled &&
1188  ipmi_watchdog_state != WDOG_TIMEOUT_NONE) {
1189  /* Make sure we do this only once. */
1190  panic_event_handled = 1;
1191 
1192  timeout = 255;
1193  pretimeout = 0;
1194  panic_halt_ipmi_set_timeout();
1195  }
1196 
1197  return NOTIFY_OK;
1198 }
1199 
1200 static struct notifier_block wdog_panic_notifier = {
1201  .notifier_call = wdog_panic_handler,
1202  .next = NULL,
1203  .priority = 150 /* priority: INT_MAX >= x >= 0 */
1204 };
1205 
1206 
1207 static void ipmi_new_smi(int if_num, struct device *device)
1208 {
1209  ipmi_register_watchdog(if_num);
1210 }
1211 
1212 static void ipmi_smi_gone(int if_num)
1213 {
1214  ipmi_unregister_watchdog(if_num);
1215 }
1216 
1217 static struct ipmi_smi_watcher smi_watcher = {
1218  .owner = THIS_MODULE,
1219  .new_smi = ipmi_new_smi,
1220  .smi_gone = ipmi_smi_gone
1221 };
1222 
1223 static int action_op(const char *inval, char *outval)
1224 {
1225  if (outval)
1226  strcpy(outval, action);
1227 
1228  if (!inval)
1229  return 0;
1230 
1231  if (strcmp(inval, "reset") == 0)
1232  action_val = WDOG_TIMEOUT_RESET;
1233  else if (strcmp(inval, "none") == 0)
1234  action_val = WDOG_TIMEOUT_NONE;
1235  else if (strcmp(inval, "power_cycle") == 0)
1236  action_val = WDOG_TIMEOUT_POWER_CYCLE;
1237  else if (strcmp(inval, "power_off") == 0)
1238  action_val = WDOG_TIMEOUT_POWER_DOWN;
1239  else
1240  return -EINVAL;
1241  strcpy(action, inval);
1242  return 0;
1243 }
1244 
1245 static int preaction_op(const char *inval, char *outval)
1246 {
1247  if (outval)
1248  strcpy(outval, preaction);
1249 
1250  if (!inval)
1251  return 0;
1252 
1253  if (strcmp(inval, "pre_none") == 0)
1254  preaction_val = WDOG_PRETIMEOUT_NONE;
1255  else if (strcmp(inval, "pre_smi") == 0)
1256  preaction_val = WDOG_PRETIMEOUT_SMI;
1257 #ifdef HAVE_DIE_NMI
1258  else if (strcmp(inval, "pre_nmi") == 0)
1259  preaction_val = WDOG_PRETIMEOUT_NMI;
1260 #endif
1261  else if (strcmp(inval, "pre_int") == 0)
1262  preaction_val = WDOG_PRETIMEOUT_MSG_INT;
1263  else
1264  return -EINVAL;
1265  strcpy(preaction, inval);
1266  return 0;
1267 }
1268 
1269 static int preop_op(const char *inval, char *outval)
1270 {
1271  if (outval)
1272  strcpy(outval, preop);
1273 
1274  if (!inval)
1275  return 0;
1276 
1277  if (strcmp(inval, "preop_none") == 0)
1278  preop_val = WDOG_PREOP_NONE;
1279  else if (strcmp(inval, "preop_panic") == 0)
1280  preop_val = WDOG_PREOP_PANIC;
1281  else if (strcmp(inval, "preop_give_data") == 0)
1282  preop_val = WDOG_PREOP_GIVE_DATA;
1283  else
1284  return -EINVAL;
1285  strcpy(preop, inval);
1286  return 0;
1287 }
1288 
1289 static void check_parms(void)
1290 {
1291 #ifdef HAVE_DIE_NMI
1292  int do_nmi = 0;
1293  int rv;
1294 
1295  if (preaction_val == WDOG_PRETIMEOUT_NMI) {
1296  do_nmi = 1;
1297  if (preop_val == WDOG_PREOP_GIVE_DATA) {
1298  printk(KERN_WARNING PFX "Pretimeout op is to give data"
1299  " but NMI pretimeout is enabled, setting"
1300  " pretimeout op to none\n");
1301  preop_op("preop_none", NULL);
1302  do_nmi = 0;
1303  }
1304  }
1305  if (do_nmi && !nmi_handler_registered) {
1306  rv = register_nmi_handler(NMI_UNKNOWN, ipmi_nmi, 0,
1307  "ipmi");
1308  if (rv) {
1310  "Can't register nmi handler\n");
1311  return;
1312  } else
1313  nmi_handler_registered = 1;
1314  } else if (!do_nmi && nmi_handler_registered) {
1316  nmi_handler_registered = 0;
1317  }
1318 #endif
1319 }
1320 
1321 static int __init ipmi_wdog_init(void)
1322 {
1323  int rv;
1324 
1325  if (action_op(action, NULL)) {
1326  action_op("reset", NULL);
1327  printk(KERN_INFO PFX "Unknown action '%s', defaulting to"
1328  " reset\n", action);
1329  }
1330 
1331  if (preaction_op(preaction, NULL)) {
1332  preaction_op("pre_none", NULL);
1333  printk(KERN_INFO PFX "Unknown preaction '%s', defaulting to"
1334  " none\n", preaction);
1335  }
1336 
1337  if (preop_op(preop, NULL)) {
1338  preop_op("preop_none", NULL);
1339  printk(KERN_INFO PFX "Unknown preop '%s', defaulting to"
1340  " none\n", preop);
1341  }
1342 
1343  check_parms();
1344 
1345  register_reboot_notifier(&wdog_reboot_notifier);
1346  atomic_notifier_chain_register(&panic_notifier_list,
1347  &wdog_panic_notifier);
1348 
1349  rv = ipmi_smi_watcher_register(&smi_watcher);
1350  if (rv) {
1351 #ifdef HAVE_DIE_NMI
1352  if (nmi_handler_registered)
1354 #endif
1355  atomic_notifier_chain_unregister(&panic_notifier_list,
1356  &wdog_panic_notifier);
1357  unregister_reboot_notifier(&wdog_reboot_notifier);
1358  printk(KERN_WARNING PFX "can't register smi watcher\n");
1359  return rv;
1360  }
1361 
1362  printk(KERN_INFO PFX "driver initialized\n");
1363 
1364  return 0;
1365 }
1366 
1367 static void __exit ipmi_wdog_exit(void)
1368 {
1369  ipmi_smi_watcher_unregister(&smi_watcher);
1370  ipmi_unregister_watchdog(watchdog_ifnum);
1371 
1372 #ifdef HAVE_DIE_NMI
1373  if (nmi_handler_registered)
1375 #endif
1376 
1377  atomic_notifier_chain_unregister(&panic_notifier_list,
1378  &wdog_panic_notifier);
1379  unregister_reboot_notifier(&wdog_reboot_notifier);
1380 }
1381 module_exit(ipmi_wdog_exit);
1382 module_init(ipmi_wdog_init);
1383 MODULE_LICENSE("GPL");
1384 MODULE_AUTHOR("Corey Minyard <[email protected]>");
1385 MODULE_DESCRIPTION("watchdog timer based upon the IPMI interface.");