1 /* 2 * ipmi_watchdog.c 3 * 4 * A watchdog timer based upon the IPMI interface. 5 * 6 * Author: MontaVista Software, Inc. 7 * Corey Minyard <minyard@mvista.com> 8 * source@mvista.com 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 /* 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) 147 #endif 148 #ifndef WDIOC_SET_PRETIMEOUT 149 #define WDIOC_SET_PRETIMEOUT _IOW(WATCHDOG_IOCTL_BASE, 21, int) 150 #endif 151 #ifndef WDIOC_GET_PRETIMEOUT 152 #define WDIOC_GET_PRETIMEOUT _IOW(WATCHDOG_IOCTL_BASE, 22, int) 153 #endif 154 155 static DEFINE_MUTEX(ipmi_watchdog_mutex); 156 static bool nowayout = WATCHDOG_NOWAYOUT; 157 158 static ipmi_user_t watchdog_user; 159 static int watchdog_ifnum; 160 161 /* Default the timeout to 10 seconds. */ 162 static int timeout = 10; 163 164 /* The pre-timeout is disabled by default. */ 165 static int pretimeout; 166 167 /* Default action is to reset the board on a timeout. */ 168 static unsigned char action_val = WDOG_TIMEOUT_RESET; 169 170 static char action[16] = "reset"; 171 172 static unsigned char preaction_val = WDOG_PRETIMEOUT_NONE; 173 174 static char preaction[16] = "pre_none"; 175 176 static unsigned char preop_val = WDOG_PREOP_NONE; 177 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; 185 186 static int ifnum_to_use = -1; 187 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 192 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); 196 197 /* 198 * If true, the driver will start running as soon as it is configured 199 * and ready. 200 */ 201 static int start_now; 202 203 static int set_param_timeout(const char *val, const struct kernel_param *kp) 204 { 205 char *endp; 206 int l; 207 int rv = 0; 208 209 if (!val) 210 return -EINVAL; 211 l = simple_strtoul(val, &endp, 0); 212 if (endp == val) 213 return -EINVAL; 214 215 *((int *)kp->arg) = l; 216 if (watchdog_user) 217 rv = ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY); 218 219 return rv; 220 } 221 222 static struct kernel_param_ops param_ops_timeout = { 223 .set = set_param_timeout, 224 .get = param_get_int, 225 }; 226 #define param_check_timeout param_check_int 227 228 typedef int (*action_fn)(const char *intval, char *outval); 229 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); 234 235 static int set_param_str(const char *val, const struct kernel_param *kp) 236 { 237 action_fn fn = (action_fn) kp->arg; 238 int rv = 0; 239 char valcp[16]; 240 char *s; 241 242 strncpy(valcp, val, 16); 243 valcp[15] = '\0'; 244 245 s = strstrip(valcp); 246 247 rv = fn(s, NULL); 248 if (rv) 249 goto out; 250 251 check_parms(); 252 if (watchdog_user) 253 rv = ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY); 254 255 out: 256 return rv; 257 } 258 259 static int get_param_str(char *buffer, const struct kernel_param *kp) 260 { 261 action_fn fn = (action_fn) kp->arg; 262 int rv; 263 264 rv = fn(NULL, buffer); 265 if (rv) 266 return rv; 267 return strlen(buffer); 268 } 269 270 271 static int set_param_wdog_ifnum(const char *val, const struct kernel_param *kp) 272 { 273 int rv = param_set_int(val, kp); 274 if (rv) 275 return rv; 276 if ((ifnum_to_use < 0) || (ifnum_to_use == watchdog_ifnum)) 277 return 0; 278 279 ipmi_unregister_watchdog(watchdog_ifnum); 280 ipmi_register_watchdog(ifnum_to_use); 281 return 0; 282 } 283 284 static struct kernel_param_ops param_ops_wdog_ifnum = { 285 .set = set_param_wdog_ifnum, 286 .get = param_get_int, 287 }; 288 289 #define param_check_wdog_ifnum param_check_int 290 291 static struct kernel_param_ops param_ops_str = { 292 .set = set_param_str, 293 .get = get_param_str, 294 }; 295 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 " 299 "interface"); 300 301 module_param(timeout, timeout, 0644); 302 MODULE_PARM_DESC(timeout, "Timeout value in seconds."); 303 304 module_param(pretimeout, timeout, 0644); 305 MODULE_PARM_DESC(pretimeout, "Pretimeout value in seconds."); 306 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."); 310 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."); 314 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."); 318 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."); 322 323 module_param(nowayout, bool, 0644); 324 MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started " 325 "(default=CONFIG_WATCHDOG_NOWAYOUT)"); 326 327 /* Default state of the timer. */ 328 static unsigned char ipmi_watchdog_state = WDOG_TIMEOUT_NONE; 329 330 /* If shutting down via IPMI, we ignore the heartbeat. */ 331 static int ipmi_ignore_heartbeat; 332 333 /* Is someone using the watchdog? Only one user is allowed. */ 334 static unsigned long ipmi_wdog_open; 335 336 /* 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. 341 */ 342 static int ipmi_start_timer_on_heartbeat; 343 344 /* IPMI version of the BMC. */ 345 static unsigned char ipmi_version_major; 346 static unsigned char ipmi_version_minor; 347 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); 350 351 #ifdef HAVE_DIE_NMI 352 static int testing_nmi; 353 static int nmi_handler_registered; 354 #endif 355 356 static int ipmi_heartbeat(void); 357 358 /* 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. 363 */ 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) 368 { 369 if (atomic_dec_and_test(&set_timeout_tofree)) 370 complete(&set_timeout_wait); 371 } 372 static void set_timeout_free_recv(struct ipmi_recv_msg *msg) 373 { 374 if (atomic_dec_and_test(&set_timeout_tofree)) 375 complete(&set_timeout_wait); 376 } 377 static struct ipmi_smi_msg set_timeout_smi_msg = { 378 .done = set_timeout_free_smi 379 }; 380 static struct ipmi_recv_msg set_timeout_recv_msg = { 381 .done = set_timeout_free_recv 382 }; 383 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) 387 { 388 struct kernel_ipmi_msg msg; 389 unsigned char data[6]; 390 int rv; 391 struct ipmi_system_interface_addr addr; 392 int hbnow = 0; 393 394 395 /* These can be cleared as we are setting the timeout. */ 396 pretimeout_since_last_heartbeat = 0; 397 398 data[0] = 0; 399 WDOG_SET_TIMER_USE(data[0], WDOG_TIMER_USE_SMS_OS); 400 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) { 406 /* 407 * In ipmi 1.0, setting the timer stops the watchdog, we 408 * need to start it back up again. 409 */ 410 hbnow = 1; 411 } 412 413 data[1] = 0; 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; 418 } else { 419 WDOG_SET_PRETIMEOUT_ACT(data[1], WDOG_PRETIMEOUT_NONE); 420 data[2] = 0; /* No pretimeout. */ 421 } 422 data[3] = 0; 423 WDOG_SET_TIMEOUT(data[4], data[5], timeout); 424 425 addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE; 426 addr.channel = IPMI_BMC_CHANNEL; 427 addr.lun = 0; 428 429 msg.netfn = 0x06; 430 msg.cmd = IPMI_WDOG_SET_TIMER; 431 msg.data = data; 432 msg.data_len = sizeof(data); 433 rv = ipmi_request_supply_msgs(watchdog_user, 434 (struct ipmi_addr *) &addr, 435 0, 436 &msg, 437 NULL, 438 smi_msg, 439 recv_msg, 440 1); 441 if (rv) { 442 printk(KERN_WARNING PFX "set timeout error: %d\n", 443 rv); 444 } 445 446 if (send_heartbeat_now) 447 *send_heartbeat_now = hbnow; 448 449 return rv; 450 } 451 452 static int ipmi_set_timeout(int do_heartbeat) 453 { 454 int send_heartbeat_now; 455 int rv; 456 457 458 /* We can only send one of these at a time. */ 459 mutex_lock(&set_timeout_lock); 460 461 atomic_set(&set_timeout_tofree, 2); 462 463 rv = i_ipmi_set_timeout(&set_timeout_smi_msg, 464 &set_timeout_recv_msg, 465 &send_heartbeat_now); 466 if (rv) { 467 mutex_unlock(&set_timeout_lock); 468 goto out; 469 } 470 471 wait_for_completion(&set_timeout_wait); 472 473 mutex_unlock(&set_timeout_lock); 474 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(); 479 480 out: 481 return rv; 482 } 483 484 static atomic_t panic_done_count = ATOMIC_INIT(0); 485 486 static void panic_smi_free(struct ipmi_smi_msg *msg) 487 { 488 atomic_dec(&panic_done_count); 489 } 490 static void panic_recv_free(struct ipmi_recv_msg *msg) 491 { 492 atomic_dec(&panic_done_count); 493 } 494 495 static struct ipmi_smi_msg panic_halt_heartbeat_smi_msg = { 496 .done = panic_smi_free 497 }; 498 static struct ipmi_recv_msg panic_halt_heartbeat_recv_msg = { 499 .done = panic_recv_free 500 }; 501 502 static void panic_halt_ipmi_heartbeat(void) 503 { 504 struct kernel_ipmi_msg msg; 505 struct ipmi_system_interface_addr addr; 506 int rv; 507 508 /* 509 * Don't reset the timer if we have the timer turned off, that 510 * re-enables the watchdog. 511 */ 512 if (ipmi_watchdog_state == WDOG_TIMEOUT_NONE) 513 return; 514 515 addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE; 516 addr.channel = IPMI_BMC_CHANNEL; 517 addr.lun = 0; 518 519 msg.netfn = 0x06; 520 msg.cmd = IPMI_WDOG_RESET_TIMER; 521 msg.data = NULL; 522 msg.data_len = 0; 523 atomic_add(2, &panic_done_count); 524 rv = ipmi_request_supply_msgs(watchdog_user, 525 (struct ipmi_addr *) &addr, 526 0, 527 &msg, 528 NULL, 529 &panic_halt_heartbeat_smi_msg, 530 &panic_halt_heartbeat_recv_msg, 531 1); 532 if (rv) 533 atomic_sub(2, &panic_done_count); 534 } 535 536 static struct ipmi_smi_msg panic_halt_smi_msg = { 537 .done = panic_smi_free 538 }; 539 static struct ipmi_recv_msg panic_halt_recv_msg = { 540 .done = panic_recv_free 541 }; 542 543 /* 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 547 * calls. 548 */ 549 static void panic_halt_ipmi_set_timeout(void) 550 { 551 int send_heartbeat_now; 552 int rv; 553 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); 561 if (rv) { 562 atomic_sub(2, &panic_done_count); 563 printk(KERN_WARNING PFX 564 "Unable to extend the watchdog timeout."); 565 } else { 566 if (send_heartbeat_now) 567 panic_halt_ipmi_heartbeat(); 568 } 569 while (atomic_read(&panic_done_count) != 0) 570 ipmi_poll_interface(watchdog_user); 571 } 572 573 /* 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. 578 */ 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) 583 { 584 if (atomic_dec_and_test(&heartbeat_tofree)) 585 complete(&heartbeat_wait); 586 } 587 static void heartbeat_free_recv(struct ipmi_recv_msg *msg) 588 { 589 if (atomic_dec_and_test(&heartbeat_tofree)) 590 complete(&heartbeat_wait); 591 } 592 static struct ipmi_smi_msg heartbeat_smi_msg = { 593 .done = heartbeat_free_smi 594 }; 595 static struct ipmi_recv_msg heartbeat_recv_msg = { 596 .done = heartbeat_free_recv 597 }; 598 599 static int ipmi_heartbeat(void) 600 { 601 struct kernel_ipmi_msg msg; 602 int rv; 603 struct ipmi_system_interface_addr addr; 604 int timeout_retries = 0; 605 606 if (ipmi_ignore_heartbeat) 607 return 0; 608 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) { 614 /* 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 618 * above operation. 619 */ 620 return ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY); 621 } 622 623 mutex_lock(&heartbeat_lock); 624 625 restart: 626 atomic_set(&heartbeat_tofree, 2); 627 628 /* 629 * Don't reset the timer if we have the timer turned off, that 630 * re-enables the watchdog. 631 */ 632 if (ipmi_watchdog_state == WDOG_TIMEOUT_NONE) { 633 mutex_unlock(&heartbeat_lock); 634 return 0; 635 } 636 637 addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE; 638 addr.channel = IPMI_BMC_CHANNEL; 639 addr.lun = 0; 640 641 msg.netfn = 0x06; 642 msg.cmd = IPMI_WDOG_RESET_TIMER; 643 msg.data = NULL; 644 msg.data_len = 0; 645 rv = ipmi_request_supply_msgs(watchdog_user, 646 (struct ipmi_addr *) &addr, 647 0, 648 &msg, 649 NULL, 650 &heartbeat_smi_msg, 651 &heartbeat_recv_msg, 652 1); 653 if (rv) { 654 mutex_unlock(&heartbeat_lock); 655 printk(KERN_WARNING PFX "heartbeat failure: %d\n", 656 rv); 657 return rv; 658 } 659 660 /* Wait for the heartbeat to be sent. */ 661 wait_for_completion(&heartbeat_wait); 662 663 if (heartbeat_recv_msg.msg.data[0] == IPMI_WDOG_TIMER_NOT_INIT_RESP) { 664 timeout_retries++; 665 if (timeout_retries > 3) { 666 printk(KERN_ERR PFX ": Unable to restore the IPMI" 667 " watchdog's settings, giving up.\n"); 668 rv = -EIO; 669 goto out_unlock; 670 } 671 672 /* 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. 679 */ 680 rv = ipmi_set_timeout(IPMI_SET_TIMEOUT_NO_HB); 681 if (rv) { 682 printk(KERN_ERR PFX ": Unable to send the command to" 683 " set the watchdog's settings, giving up.\n"); 684 goto out_unlock; 685 } 686 687 /* We might need a new heartbeat, so do it now */ 688 goto restart; 689 } else if (heartbeat_recv_msg.msg.data[0] != 0) { 690 /* 691 * Got an error in the heartbeat response. It was already 692 * reported in ipmi_wdog_msg_handler, but we should return 693 * an error here. 694 */ 695 rv = -EINVAL; 696 } 697 698 out_unlock: 699 mutex_unlock(&heartbeat_lock); 700 701 return rv; 702 } 703 704 static struct watchdog_info ident = { 705 .options = 0, /* WDIOF_SETTIMEOUT, */ 706 .firmware_version = 1, 707 .identity = "IPMI" 708 }; 709 710 static int ipmi_ioctl(struct file *file, 711 unsigned int cmd, unsigned long arg) 712 { 713 void __user *argp = (void __user *)arg; 714 int i; 715 int val; 716 717 switch (cmd) { 718 case WDIOC_GETSUPPORT: 719 i = copy_to_user(argp, &ident, sizeof(ident)); 720 return i ? -EFAULT : 0; 721 722 case WDIOC_SETTIMEOUT: 723 i = copy_from_user(&val, argp, sizeof(int)); 724 if (i) 725 return -EFAULT; 726 timeout = val; 727 return ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY); 728 729 case WDIOC_GETTIMEOUT: 730 i = copy_to_user(argp, &timeout, sizeof(timeout)); 731 if (i) 732 return -EFAULT; 733 return 0; 734 735 case WDIOC_SET_PRETIMEOUT: 736 case WDIOC_SETPRETIMEOUT: 737 i = copy_from_user(&val, argp, sizeof(int)); 738 if (i) 739 return -EFAULT; 740 pretimeout = val; 741 return ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY); 742 743 case WDIOC_GET_PRETIMEOUT: 744 case WDIOC_GETPRETIMEOUT: 745 i = copy_to_user(argp, &pretimeout, sizeof(pretimeout)); 746 if (i) 747 return -EFAULT; 748 return 0; 749 750 case WDIOC_KEEPALIVE: 751 return ipmi_heartbeat(); 752 753 case WDIOC_SETOPTIONS: 754 i = copy_from_user(&val, argp, sizeof(int)); 755 if (i) 756 return -EFAULT; 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; 761 } 762 763 if (val & WDIOS_ENABLECARD) { 764 ipmi_watchdog_state = action_val; 765 ipmi_set_timeout(IPMI_SET_TIMEOUT_FORCE_HB); 766 } 767 return 0; 768 769 case WDIOC_GETSTATUS: 770 val = 0; 771 i = copy_to_user(argp, &val, sizeof(val)); 772 if (i) 773 return -EFAULT; 774 return 0; 775 776 default: 777 return -ENOIOCTLCMD; 778 } 779 } 780 781 static long ipmi_unlocked_ioctl(struct file *file, 782 unsigned int cmd, 783 unsigned long arg) 784 { 785 int ret; 786 787 mutex_lock(&ipmi_watchdog_mutex); 788 ret = ipmi_ioctl(file, cmd, arg); 789 mutex_unlock(&ipmi_watchdog_mutex); 790 791 return ret; 792 } 793 794 static ssize_t ipmi_write(struct file *file, 795 const char __user *buf, 796 size_t len, 797 loff_t *ppos) 798 { 799 int rv; 800 801 if (len) { 802 if (!nowayout) { 803 size_t i; 804 805 /* In case it was set long ago */ 806 expect_close = 0; 807 808 for (i = 0; i != len; i++) { 809 char c; 810 811 if (get_user(c, buf + i)) 812 return -EFAULT; 813 if (c == 'V') 814 expect_close = 42; 815 } 816 } 817 rv = ipmi_heartbeat(); 818 if (rv) 819 return rv; 820 } 821 return len; 822 } 823 824 static ssize_t ipmi_read(struct file *file, 825 char __user *buf, 826 size_t count, 827 loff_t *ppos) 828 { 829 int rv = 0; 830 wait_queue_t wait; 831 832 if (count <= 0) 833 return 0; 834 835 /* 836 * Reading returns if the pretimeout has gone off, and it only does 837 * it once per pretimeout. 838 */ 839 spin_lock(&ipmi_read_lock); 840 if (!data_to_read) { 841 if (file->f_flags & O_NONBLOCK) { 842 rv = -EAGAIN; 843 goto out; 844 } 845 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); 851 schedule(); 852 spin_lock(&ipmi_read_lock); 853 } 854 remove_wait_queue(&read_q, &wait); 855 856 if (signal_pending(current)) { 857 rv = -ERESTARTSYS; 858 goto out; 859 } 860 } 861 data_to_read = 0; 862 863 out: 864 spin_unlock(&ipmi_read_lock); 865 866 if (rv == 0) { 867 if (copy_to_user(buf, &data_to_read, 1)) 868 rv = -EFAULT; 869 else 870 rv = 1; 871 } 872 873 return rv; 874 } 875 876 static int ipmi_open(struct inode *ino, struct file *filep) 877 { 878 switch (iminor(ino)) { 879 case WATCHDOG_MINOR: 880 if (test_and_set_bit(0, &ipmi_wdog_open)) 881 return -EBUSY; 882 883 884 /* 885 * Don't start the timer now, let it start on the 886 * first heartbeat. 887 */ 888 ipmi_start_timer_on_heartbeat = 1; 889 return nonseekable_open(ino, filep); 890 891 default: 892 return (-ENODEV); 893 } 894 } 895 896 static unsigned int ipmi_poll(struct file *file, poll_table *wait) 897 { 898 unsigned int mask = 0; 899 900 poll_wait(file, &read_q, wait); 901 902 spin_lock(&ipmi_read_lock); 903 if (data_to_read) 904 mask |= (POLLIN | POLLRDNORM); 905 spin_unlock(&ipmi_read_lock); 906 907 return mask; 908 } 909 910 static int ipmi_fasync(int fd, struct file *file, int on) 911 { 912 int result; 913 914 result = fasync_helper(fd, file, on, &fasync_q); 915 916 return (result); 917 } 918 919 static int ipmi_close(struct inode *ino, struct file *filep) 920 { 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); 925 } else { 926 printk(KERN_CRIT PFX 927 "Unexpected close, not stopping watchdog!\n"); 928 ipmi_heartbeat(); 929 } 930 clear_bit(0, &ipmi_wdog_open); 931 } 932 933 expect_close = 0; 934 935 return 0; 936 } 937 938 static const struct file_operations ipmi_wdog_fops = { 939 .owner = THIS_MODULE, 940 .read = ipmi_read, 941 .poll = ipmi_poll, 942 .write = ipmi_write, 943 .unlocked_ioctl = ipmi_unlocked_ioctl, 944 .open = ipmi_open, 945 .release = ipmi_close, 946 .fasync = ipmi_fasync, 947 .llseek = no_llseek, 948 }; 949 950 static struct miscdevice ipmi_wdog_miscdev = { 951 .minor = WATCHDOG_MINOR, 952 .name = "watchdog", 953 .fops = &ipmi_wdog_fops 954 }; 955 956 static void ipmi_wdog_msg_handler(struct ipmi_recv_msg *msg, 957 void *handler_data) 958 { 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", 966 msg->msg.data[0], 967 msg->msg.cmd); 968 969 ipmi_free_recv_msg(msg); 970 } 971 972 static void ipmi_wdog_pretimeout_handler(void *handler_data) 973 { 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); 980 data_to_read = 1; 981 wake_up_interruptible(&read_q); 982 kill_fasync(&fasync_q, SIGIO, POLL_IN); 983 984 spin_unlock(&ipmi_read_lock); 985 } 986 } 987 988 /* 989 * On some machines, the heartbeat will give an error and not 990 * work unless we re-enable the timer. So do so. 991 */ 992 pretimeout_since_last_heartbeat = 1; 993 } 994 995 static struct ipmi_user_hndl ipmi_hndlrs = { 996 .ipmi_recv_hndl = ipmi_wdog_msg_handler, 997 .ipmi_watchdog_pretimeout = ipmi_wdog_pretimeout_handler 998 }; 999 1000 static void ipmi_register_watchdog(int ipmi_intf) 1001 { 1002 int rv = -EBUSY; 1003 1004 if (watchdog_user) 1005 goto out; 1006 1007 if ((ifnum_to_use >= 0) && (ifnum_to_use != ipmi_intf)) 1008 goto out; 1009 1010 watchdog_ifnum = ipmi_intf; 1011 1012 rv = ipmi_create_user(ipmi_intf, &ipmi_hndlrs, NULL, &watchdog_user); 1013 if (rv < 0) { 1014 printk(KERN_CRIT PFX "Unable to register with ipmi\n"); 1015 goto out; 1016 } 1017 1018 ipmi_get_version(watchdog_user, 1019 &ipmi_version_major, 1020 &ipmi_version_minor); 1021 1022 rv = misc_register(&ipmi_wdog_miscdev); 1023 if (rv < 0) { 1024 ipmi_destroy_user(watchdog_user); 1025 watchdog_user = NULL; 1026 printk(KERN_CRIT PFX "Unable to register misc device\n"); 1027 } 1028 1029 #ifdef HAVE_DIE_NMI 1030 if (nmi_handler_registered) { 1031 int old_pretimeout = pretimeout; 1032 int old_timeout = timeout; 1033 int old_preop_val = preop_val; 1034 1035 /* 1036 * Set the pretimeout to go off in a second and give 1037 * ourselves plenty of time to stop the timer. 1038 */ 1039 ipmi_watchdog_state = WDOG_TIMEOUT_RESET; 1040 preop_val = WDOG_PREOP_NONE; /* Make sure nothing happens */ 1041 pretimeout = 99; 1042 timeout = 100; 1043 1044 testing_nmi = 1; 1045 1046 rv = ipmi_set_timeout(IPMI_SET_TIMEOUT_FORCE_HB); 1047 if (rv) { 1048 printk(KERN_WARNING PFX "Error starting timer to" 1049 " test NMI: 0x%x. The NMI pretimeout will" 1050 " likely not work\n", rv); 1051 rv = 0; 1052 goto out_restore; 1053 } 1054 1055 msleep(1500); 1056 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"); 1061 } 1062 out_restore: 1063 testing_nmi = 0; 1064 preop_val = old_preop_val; 1065 pretimeout = old_pretimeout; 1066 timeout = old_timeout; 1067 } 1068 #endif 1069 1070 out: 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"); 1077 } else { 1078 /* Stop the timer now. */ 1079 ipmi_watchdog_state = WDOG_TIMEOUT_NONE; 1080 ipmi_set_timeout(IPMI_SET_TIMEOUT_NO_HB); 1081 } 1082 } 1083 1084 static void ipmi_unregister_watchdog(int ipmi_intf) 1085 { 1086 int rv; 1087 1088 if (!watchdog_user) 1089 goto out; 1090 1091 if (watchdog_ifnum != ipmi_intf) 1092 goto out; 1093 1094 /* Make sure no one can call us any more. */ 1095 misc_deregister(&ipmi_wdog_miscdev); 1096 1097 /* 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. 1101 */ 1102 while (atomic_read(&set_timeout_tofree)) 1103 schedule_timeout_uninterruptible(1); 1104 1105 /* Disconnect from IPMI. */ 1106 rv = ipmi_destroy_user(watchdog_user); 1107 if (rv) { 1108 printk(KERN_WARNING PFX "error unlinking from IPMI: %d\n", 1109 rv); 1110 } 1111 watchdog_user = NULL; 1112 1113 out: 1114 return; 1115 } 1116 1117 #ifdef HAVE_DIE_NMI 1118 static int 1119 ipmi_nmi(unsigned int val, struct pt_regs *regs) 1120 { 1121 /* 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. 1126 */ 1127 1128 if (testing_nmi) { 1129 testing_nmi = 2; 1130 return NMI_HANDLED; 1131 } 1132 1133 /* If we are not expecting a timeout, ignore it. */ 1134 if (ipmi_watchdog_state == WDOG_TIMEOUT_NONE) 1135 return NMI_DONE; 1136 1137 if (preaction_val != WDOG_PRETIMEOUT_NMI) 1138 return NMI_DONE; 1139 1140 /* 1141 * If no one else handled the NMI, we assume it was the IPMI 1142 * watchdog. 1143 */ 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"); 1151 } 1152 1153 return NMI_HANDLED; 1154 } 1155 #endif 1156 1157 static int wdog_reboot_handler(struct notifier_block *this, 1158 unsigned long code, 1159 void *unused) 1160 { 1161 static int reboot_event_handled; 1162 1163 if ((watchdog_user) && (!reboot_event_handled)) { 1164 /* Make sure we only do this once. */ 1165 reboot_event_handled = 1; 1166 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. */ 1175 timeout = 120; 1176 pretimeout = 0; 1177 ipmi_watchdog_state = WDOG_TIMEOUT_RESET; 1178 ipmi_set_timeout(IPMI_SET_TIMEOUT_NO_HB); 1179 } 1180 } 1181 return NOTIFY_OK; 1182 } 1183 1184 static struct notifier_block wdog_reboot_notifier = { 1185 .notifier_call = wdog_reboot_handler, 1186 .next = NULL, 1187 .priority = 0 1188 }; 1189 1190 static int wdog_panic_handler(struct notifier_block *this, 1191 unsigned long event, 1192 void *unused) 1193 { 1194 static int panic_event_handled; 1195 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; 1204 1205 timeout = 255; 1206 pretimeout = 0; 1207 panic_halt_ipmi_set_timeout(); 1208 } 1209 1210 return NOTIFY_OK; 1211 } 1212 1213 static struct notifier_block wdog_panic_notifier = { 1214 .notifier_call = wdog_panic_handler, 1215 .next = NULL, 1216 .priority = 150 /* priority: INT_MAX >= x >= 0 */ 1217 }; 1218 1219 1220 static void ipmi_new_smi(int if_num, struct device *device) 1221 { 1222 ipmi_register_watchdog(if_num); 1223 } 1224 1225 static void ipmi_smi_gone(int if_num) 1226 { 1227 ipmi_unregister_watchdog(if_num); 1228 } 1229 1230 static struct ipmi_smi_watcher smi_watcher = { 1231 .owner = THIS_MODULE, 1232 .new_smi = ipmi_new_smi, 1233 .smi_gone = ipmi_smi_gone 1234 }; 1235 1236 static int action_op(const char *inval, char *outval) 1237 { 1238 if (outval) 1239 strcpy(outval, action); 1240 1241 if (!inval) 1242 return 0; 1243 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; 1252 else 1253 return -EINVAL; 1254 strcpy(action, inval); 1255 return 0; 1256 } 1257 1258 static int preaction_op(const char *inval, char *outval) 1259 { 1260 if (outval) 1261 strcpy(outval, preaction); 1262 1263 if (!inval) 1264 return 0; 1265 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; 1270 #ifdef HAVE_DIE_NMI 1271 else if (strcmp(inval, "pre_nmi") == 0) 1272 preaction_val = WDOG_PRETIMEOUT_NMI; 1273 #endif 1274 else if (strcmp(inval, "pre_int") == 0) 1275 preaction_val = WDOG_PRETIMEOUT_MSG_INT; 1276 else 1277 return -EINVAL; 1278 strcpy(preaction, inval); 1279 return 0; 1280 } 1281 1282 static int preop_op(const char *inval, char *outval) 1283 { 1284 if (outval) 1285 strcpy(outval, preop); 1286 1287 if (!inval) 1288 return 0; 1289 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; 1296 else 1297 return -EINVAL; 1298 strcpy(preop, inval); 1299 return 0; 1300 } 1301 1302 static void check_parms(void) 1303 { 1304 #ifdef HAVE_DIE_NMI 1305 int do_nmi = 0; 1306 int rv; 1307 1308 if (preaction_val == WDOG_PRETIMEOUT_NMI) { 1309 do_nmi = 1; 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); 1315 do_nmi = 0; 1316 } 1317 } 1318 if (do_nmi && !nmi_handler_registered) { 1319 rv = register_nmi_handler(NMI_UNKNOWN, ipmi_nmi, 0, 1320 "ipmi"); 1321 if (rv) { 1322 printk(KERN_WARNING PFX 1323 "Can't register nmi handler\n"); 1324 return; 1325 } else 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; 1330 } 1331 #endif 1332 } 1333 1334 static int __init ipmi_wdog_init(void) 1335 { 1336 int rv; 1337 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); 1342 } 1343 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); 1348 } 1349 1350 if (preop_op(preop, NULL)) { 1351 preop_op("preop_none", NULL); 1352 printk(KERN_INFO PFX "Unknown preop '%s', defaulting to" 1353 " none\n", preop); 1354 } 1355 1356 check_parms(); 1357 1358 register_reboot_notifier(&wdog_reboot_notifier); 1359 atomic_notifier_chain_register(&panic_notifier_list, 1360 &wdog_panic_notifier); 1361 1362 rv = ipmi_smi_watcher_register(&smi_watcher); 1363 if (rv) { 1364 #ifdef HAVE_DIE_NMI 1365 if (nmi_handler_registered) 1366 unregister_nmi_handler(NMI_UNKNOWN, "ipmi"); 1367 #endif 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"); 1372 return rv; 1373 } 1374 1375 printk(KERN_INFO PFX "driver initialized\n"); 1376 1377 return 0; 1378 } 1379 1380 static void __exit ipmi_wdog_exit(void) 1381 { 1382 ipmi_smi_watcher_unregister(&smi_watcher); 1383 ipmi_unregister_watchdog(watchdog_ifnum); 1384 1385 #ifdef HAVE_DIE_NMI 1386 if (nmi_handler_registered) 1387 unregister_nmi_handler(NMI_UNKNOWN, "ipmi"); 1388 #endif 1389 1390 atomic_notifier_chain_unregister(&panic_notifier_list, 1391 &wdog_panic_notifier); 1392 unregister_reboot_notifier(&wdog_reboot_notifier); 1393 } 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."); 1399