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