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