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