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/rwsem.h> 43 #include <linux/errno.h> 44 #include <asm/uaccess.h> 45 #include <linux/notifier.h> 46 #include <linux/nmi.h> 47 #include <linux/reboot.h> 48 #include <linux/wait.h> 49 #include <linux/poll.h> 50 #include <linux/string.h> 51 #include <linux/ctype.h> 52 #include <asm/atomic.h> 53 #ifdef CONFIG_X86_LOCAL_APIC 54 #include <asm/apic.h> 55 #endif 56 57 #define PFX "IPMI Watchdog: " 58 59 /* 60 * The IPMI command/response information for the watchdog timer. 61 */ 62 63 /* values for byte 1 of the set command, byte 2 of the get response. */ 64 #define WDOG_DONT_LOG (1 << 7) 65 #define WDOG_DONT_STOP_ON_SET (1 << 6) 66 #define WDOG_SET_TIMER_USE(byte, use) \ 67 byte = ((byte) & 0xf8) | ((use) & 0x7) 68 #define WDOG_GET_TIMER_USE(byte) ((byte) & 0x7) 69 #define WDOG_TIMER_USE_BIOS_FRB2 1 70 #define WDOG_TIMER_USE_BIOS_POST 2 71 #define WDOG_TIMER_USE_OS_LOAD 3 72 #define WDOG_TIMER_USE_SMS_OS 4 73 #define WDOG_TIMER_USE_OEM 5 74 75 /* values for byte 2 of the set command, byte 3 of the get response. */ 76 #define WDOG_SET_PRETIMEOUT_ACT(byte, use) \ 77 byte = ((byte) & 0x8f) | (((use) & 0x7) << 4) 78 #define WDOG_GET_PRETIMEOUT_ACT(byte) (((byte) >> 4) & 0x7) 79 #define WDOG_PRETIMEOUT_NONE 0 80 #define WDOG_PRETIMEOUT_SMI 1 81 #define WDOG_PRETIMEOUT_NMI 2 82 #define WDOG_PRETIMEOUT_MSG_INT 3 83 84 /* Operations that can be performed on a pretimout. */ 85 #define WDOG_PREOP_NONE 0 86 #define WDOG_PREOP_PANIC 1 87 #define WDOG_PREOP_GIVE_DATA 2 /* Cause data to be available to 88 read. Doesn't work in NMI 89 mode. */ 90 91 /* Actions to perform on a full timeout. */ 92 #define WDOG_SET_TIMEOUT_ACT(byte, use) \ 93 byte = ((byte) & 0xf8) | ((use) & 0x7) 94 #define WDOG_GET_TIMEOUT_ACT(byte) ((byte) & 0x7) 95 #define WDOG_TIMEOUT_NONE 0 96 #define WDOG_TIMEOUT_RESET 1 97 #define WDOG_TIMEOUT_POWER_DOWN 2 98 #define WDOG_TIMEOUT_POWER_CYCLE 3 99 100 /* Byte 3 of the get command, byte 4 of the get response is the 101 pre-timeout in seconds. */ 102 103 /* Bits for setting byte 4 of the set command, byte 5 of the get response. */ 104 #define WDOG_EXPIRE_CLEAR_BIOS_FRB2 (1 << 1) 105 #define WDOG_EXPIRE_CLEAR_BIOS_POST (1 << 2) 106 #define WDOG_EXPIRE_CLEAR_OS_LOAD (1 << 3) 107 #define WDOG_EXPIRE_CLEAR_SMS_OS (1 << 4) 108 #define WDOG_EXPIRE_CLEAR_OEM (1 << 5) 109 110 /* Setting/getting the watchdog timer value. This is for bytes 5 and 111 6 (the timeout time) of the set command, and bytes 6 and 7 (the 112 timeout time) and 8 and 9 (the current countdown value) of the 113 response. The timeout value is given in seconds (in the command it 114 is 100ms intervals). */ 115 #define WDOG_SET_TIMEOUT(byte1, byte2, val) \ 116 (byte1) = (((val) * 10) & 0xff), (byte2) = (((val) * 10) >> 8) 117 #define WDOG_GET_TIMEOUT(byte1, byte2) \ 118 (((byte1) | ((byte2) << 8)) / 10) 119 120 #define IPMI_WDOG_RESET_TIMER 0x22 121 #define IPMI_WDOG_SET_TIMER 0x24 122 #define IPMI_WDOG_GET_TIMER 0x25 123 124 /* These are here until the real ones get into the watchdog.h interface. */ 125 #ifndef WDIOC_GETTIMEOUT 126 #define WDIOC_GETTIMEOUT _IOW(WATCHDOG_IOCTL_BASE, 20, int) 127 #endif 128 #ifndef WDIOC_SET_PRETIMEOUT 129 #define WDIOC_SET_PRETIMEOUT _IOW(WATCHDOG_IOCTL_BASE, 21, int) 130 #endif 131 #ifndef WDIOC_GET_PRETIMEOUT 132 #define WDIOC_GET_PRETIMEOUT _IOW(WATCHDOG_IOCTL_BASE, 22, int) 133 #endif 134 135 static int nowayout = WATCHDOG_NOWAYOUT; 136 137 static ipmi_user_t watchdog_user = NULL; 138 139 /* Default the timeout to 10 seconds. */ 140 static int timeout = 10; 141 142 /* The pre-timeout is disabled by default. */ 143 static int pretimeout = 0; 144 145 /* Default action is to reset the board on a timeout. */ 146 static unsigned char action_val = WDOG_TIMEOUT_RESET; 147 148 static char action[16] = "reset"; 149 150 static unsigned char preaction_val = WDOG_PRETIMEOUT_NONE; 151 152 static char preaction[16] = "pre_none"; 153 154 static unsigned char preop_val = WDOG_PREOP_NONE; 155 156 static char preop[16] = "preop_none"; 157 static DEFINE_SPINLOCK(ipmi_read_lock); 158 static char data_to_read = 0; 159 static DECLARE_WAIT_QUEUE_HEAD(read_q); 160 static struct fasync_struct *fasync_q = NULL; 161 static char pretimeout_since_last_heartbeat = 0; 162 static char expect_close; 163 164 static DECLARE_RWSEM(register_sem); 165 166 /* Parameters to ipmi_set_timeout */ 167 #define IPMI_SET_TIMEOUT_NO_HB 0 168 #define IPMI_SET_TIMEOUT_HB_IF_NECESSARY 1 169 #define IPMI_SET_TIMEOUT_FORCE_HB 2 170 171 static int ipmi_set_timeout(int do_heartbeat); 172 173 /* If true, the driver will start running as soon as it is configured 174 and ready. */ 175 static int start_now = 0; 176 177 static int set_param_int(const char *val, struct kernel_param *kp) 178 { 179 char *endp; 180 int l; 181 int rv = 0; 182 183 if (!val) 184 return -EINVAL; 185 l = simple_strtoul(val, &endp, 0); 186 if (endp == val) 187 return -EINVAL; 188 189 down_read(®ister_sem); 190 *((int *)kp->arg) = l; 191 if (watchdog_user) 192 rv = ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY); 193 up_read(®ister_sem); 194 195 return rv; 196 } 197 198 static int get_param_int(char *buffer, struct kernel_param *kp) 199 { 200 return sprintf(buffer, "%i", *((int *)kp->arg)); 201 } 202 203 typedef int (*action_fn)(const char *intval, char *outval); 204 205 static int action_op(const char *inval, char *outval); 206 static int preaction_op(const char *inval, char *outval); 207 static int preop_op(const char *inval, char *outval); 208 static void check_parms(void); 209 210 static int set_param_str(const char *val, struct kernel_param *kp) 211 { 212 action_fn fn = (action_fn) kp->arg; 213 int rv = 0; 214 const char *end; 215 char valcp[16]; 216 int len; 217 218 /* Truncate leading and trailing spaces. */ 219 while (isspace(*val)) 220 val++; 221 end = val + strlen(val) - 1; 222 while ((end >= val) && isspace(*end)) 223 end--; 224 len = end - val + 1; 225 if (len > sizeof(valcp) - 1) 226 return -EINVAL; 227 memcpy(valcp, val, len); 228 valcp[len] = '\0'; 229 230 down_read(®ister_sem); 231 rv = fn(valcp, NULL); 232 if (rv) 233 goto out_unlock; 234 235 check_parms(); 236 if (watchdog_user) 237 rv = ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY); 238 239 out_unlock: 240 up_read(®ister_sem); 241 return rv; 242 } 243 244 static int get_param_str(char *buffer, struct kernel_param *kp) 245 { 246 action_fn fn = (action_fn) kp->arg; 247 int rv; 248 249 rv = fn(NULL, buffer); 250 if (rv) 251 return rv; 252 return strlen(buffer); 253 } 254 255 module_param_call(timeout, set_param_int, get_param_int, &timeout, 0644); 256 MODULE_PARM_DESC(timeout, "Timeout value in seconds."); 257 258 module_param_call(pretimeout, set_param_int, get_param_int, &pretimeout, 0644); 259 MODULE_PARM_DESC(pretimeout, "Pretimeout value in seconds."); 260 261 module_param_call(action, set_param_str, get_param_str, action_op, 0644); 262 MODULE_PARM_DESC(action, "Timeout action. One of: " 263 "reset, none, power_cycle, power_off."); 264 265 module_param_call(preaction, set_param_str, get_param_str, preaction_op, 0644); 266 MODULE_PARM_DESC(preaction, "Pretimeout action. One of: " 267 "pre_none, pre_smi, pre_nmi, pre_int."); 268 269 module_param_call(preop, set_param_str, get_param_str, preop_op, 0644); 270 MODULE_PARM_DESC(preop, "Pretimeout driver operation. One of: " 271 "preop_none, preop_panic, preop_give_data."); 272 273 module_param(start_now, int, 0); 274 MODULE_PARM_DESC(start_now, "Set to 1 to start the watchdog as" 275 "soon as the driver is loaded."); 276 277 module_param(nowayout, int, 0644); 278 MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=CONFIG_WATCHDOG_NOWAYOUT)"); 279 280 /* Default state of the timer. */ 281 static unsigned char ipmi_watchdog_state = WDOG_TIMEOUT_NONE; 282 283 /* If shutting down via IPMI, we ignore the heartbeat. */ 284 static int ipmi_ignore_heartbeat = 0; 285 286 /* Is someone using the watchdog? Only one user is allowed. */ 287 static unsigned long ipmi_wdog_open = 0; 288 289 /* If set to 1, the heartbeat command will set the state to reset and 290 start the timer. The timer doesn't normally run when the driver is 291 first opened until the heartbeat is set the first time, this 292 variable is used to accomplish this. */ 293 static int ipmi_start_timer_on_heartbeat = 0; 294 295 /* IPMI version of the BMC. */ 296 static unsigned char ipmi_version_major; 297 static unsigned char ipmi_version_minor; 298 299 /* If a pretimeout occurs, this is used to allow only one panic to happen. */ 300 static atomic_t preop_panic_excl = ATOMIC_INIT(-1); 301 302 static int ipmi_heartbeat(void); 303 static void panic_halt_ipmi_heartbeat(void); 304 305 306 /* We use a semaphore to make sure that only one thing can send a set 307 timeout at one time, because we only have one copy of the data. 308 The semaphore is claimed when the set_timeout is sent and freed 309 when both messages are free. */ 310 static atomic_t set_timeout_tofree = ATOMIC_INIT(0); 311 static DECLARE_MUTEX(set_timeout_lock); 312 static void set_timeout_free_smi(struct ipmi_smi_msg *msg) 313 { 314 if (atomic_dec_and_test(&set_timeout_tofree)) 315 up(&set_timeout_lock); 316 } 317 static void set_timeout_free_recv(struct ipmi_recv_msg *msg) 318 { 319 if (atomic_dec_and_test(&set_timeout_tofree)) 320 up(&set_timeout_lock); 321 } 322 static struct ipmi_smi_msg set_timeout_smi_msg = 323 { 324 .done = set_timeout_free_smi 325 }; 326 static struct ipmi_recv_msg set_timeout_recv_msg = 327 { 328 .done = set_timeout_free_recv 329 }; 330 331 static int i_ipmi_set_timeout(struct ipmi_smi_msg *smi_msg, 332 struct ipmi_recv_msg *recv_msg, 333 int *send_heartbeat_now) 334 { 335 struct kernel_ipmi_msg msg; 336 unsigned char data[6]; 337 int rv; 338 struct ipmi_system_interface_addr addr; 339 int hbnow = 0; 340 341 342 data[0] = 0; 343 WDOG_SET_TIMER_USE(data[0], WDOG_TIMER_USE_SMS_OS); 344 345 if ((ipmi_version_major > 1) 346 || ((ipmi_version_major == 1) && (ipmi_version_minor >= 5))) 347 { 348 /* This is an IPMI 1.5-only feature. */ 349 data[0] |= WDOG_DONT_STOP_ON_SET; 350 } else if (ipmi_watchdog_state != WDOG_TIMEOUT_NONE) { 351 /* In ipmi 1.0, setting the timer stops the watchdog, we 352 need to start it back up again. */ 353 hbnow = 1; 354 } 355 356 data[1] = 0; 357 WDOG_SET_TIMEOUT_ACT(data[1], ipmi_watchdog_state); 358 if ((pretimeout > 0) && (ipmi_watchdog_state != WDOG_TIMEOUT_NONE)) { 359 WDOG_SET_PRETIMEOUT_ACT(data[1], preaction_val); 360 data[2] = pretimeout; 361 } else { 362 WDOG_SET_PRETIMEOUT_ACT(data[1], WDOG_PRETIMEOUT_NONE); 363 data[2] = 0; /* No pretimeout. */ 364 } 365 data[3] = 0; 366 WDOG_SET_TIMEOUT(data[4], data[5], timeout); 367 368 addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE; 369 addr.channel = IPMI_BMC_CHANNEL; 370 addr.lun = 0; 371 372 msg.netfn = 0x06; 373 msg.cmd = IPMI_WDOG_SET_TIMER; 374 msg.data = data; 375 msg.data_len = sizeof(data); 376 rv = ipmi_request_supply_msgs(watchdog_user, 377 (struct ipmi_addr *) &addr, 378 0, 379 &msg, 380 NULL, 381 smi_msg, 382 recv_msg, 383 1); 384 if (rv) { 385 printk(KERN_WARNING PFX "set timeout error: %d\n", 386 rv); 387 } 388 389 if (send_heartbeat_now) 390 *send_heartbeat_now = hbnow; 391 392 return rv; 393 } 394 395 static int ipmi_set_timeout(int do_heartbeat) 396 { 397 int send_heartbeat_now; 398 int rv; 399 400 401 /* We can only send one of these at a time. */ 402 down(&set_timeout_lock); 403 404 atomic_set(&set_timeout_tofree, 2); 405 406 rv = i_ipmi_set_timeout(&set_timeout_smi_msg, 407 &set_timeout_recv_msg, 408 &send_heartbeat_now); 409 if (rv) { 410 up(&set_timeout_lock); 411 } else { 412 if ((do_heartbeat == IPMI_SET_TIMEOUT_FORCE_HB) 413 || ((send_heartbeat_now) 414 && (do_heartbeat == IPMI_SET_TIMEOUT_HB_IF_NECESSARY))) 415 { 416 rv = ipmi_heartbeat(); 417 } 418 } 419 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 DECLARE_MUTEX(heartbeat_lock); 462 static DECLARE_MUTEX_LOCKED(heartbeat_wait_lock); 463 static void heartbeat_free_smi(struct ipmi_smi_msg *msg) 464 { 465 if (atomic_dec_and_test(&heartbeat_tofree)) 466 up(&heartbeat_wait_lock); 467 } 468 static void heartbeat_free_recv(struct ipmi_recv_msg *msg) 469 { 470 if (atomic_dec_and_test(&heartbeat_tofree)) 471 up(&heartbeat_wait_lock); 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 down(&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 up(&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 up(&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 down(&heartbeat_wait_lock); 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 up(&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 { 795 if (expect_close == 42) { 796 ipmi_watchdog_state = WDOG_TIMEOUT_NONE; 797 ipmi_set_timeout(IPMI_SET_TIMEOUT_NO_HB); 798 } else { 799 printk(KERN_CRIT PFX "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 { 953 /* Set a long timer to let the reboot happens, but 954 reboot if it hangs. */ 955 timeout = 120; 956 pretimeout = 0; 957 ipmi_watchdog_state = WDOG_TIMEOUT_RESET; 958 panic_halt_ipmi_set_timeout(); 959 } 960 } 961 return NOTIFY_OK; 962 } 963 964 static struct notifier_block wdog_reboot_notifier = { 965 .notifier_call = wdog_reboot_handler, 966 .next = NULL, 967 .priority = 0 968 }; 969 970 static int wdog_panic_handler(struct notifier_block *this, 971 unsigned long event, 972 void *unused) 973 { 974 static int panic_event_handled = 0; 975 976 /* On a panic, if we have a panic timeout, make sure that the thing 977 reboots, even if it hangs during that panic. */ 978 if (watchdog_user && !panic_event_handled) { 979 /* Make sure the panic doesn't hang, and make sure we 980 do this only once. */ 981 panic_event_handled = 1; 982 983 timeout = 255; 984 pretimeout = 0; 985 ipmi_watchdog_state = WDOG_TIMEOUT_RESET; 986 panic_halt_ipmi_set_timeout(); 987 } 988 989 return NOTIFY_OK; 990 } 991 992 static struct notifier_block wdog_panic_notifier = { 993 .notifier_call = wdog_panic_handler, 994 .next = NULL, 995 .priority = 150 /* priority: INT_MAX >= x >= 0 */ 996 }; 997 998 999 static void ipmi_new_smi(int if_num) 1000 { 1001 ipmi_register_watchdog(if_num); 1002 } 1003 1004 static void ipmi_smi_gone(int if_num) 1005 { 1006 /* This can never be called, because once the watchdog is 1007 registered, the interface can't go away until the watchdog 1008 is unregistered. */ 1009 } 1010 1011 static struct ipmi_smi_watcher smi_watcher = 1012 { 1013 .owner = THIS_MODULE, 1014 .new_smi = ipmi_new_smi, 1015 .smi_gone = ipmi_smi_gone 1016 }; 1017 1018 static int action_op(const char *inval, char *outval) 1019 { 1020 if (outval) 1021 strcpy(outval, action); 1022 1023 if (!inval) 1024 return 0; 1025 1026 if (strcmp(inval, "reset") == 0) 1027 action_val = WDOG_TIMEOUT_RESET; 1028 else if (strcmp(inval, "none") == 0) 1029 action_val = WDOG_TIMEOUT_NONE; 1030 else if (strcmp(inval, "power_cycle") == 0) 1031 action_val = WDOG_TIMEOUT_POWER_CYCLE; 1032 else if (strcmp(inval, "power_off") == 0) 1033 action_val = WDOG_TIMEOUT_POWER_DOWN; 1034 else 1035 return -EINVAL; 1036 strcpy(action, inval); 1037 return 0; 1038 } 1039 1040 static int preaction_op(const char *inval, char *outval) 1041 { 1042 if (outval) 1043 strcpy(outval, preaction); 1044 1045 if (!inval) 1046 return 0; 1047 1048 if (strcmp(inval, "pre_none") == 0) 1049 preaction_val = WDOG_PRETIMEOUT_NONE; 1050 else if (strcmp(inval, "pre_smi") == 0) 1051 preaction_val = WDOG_PRETIMEOUT_SMI; 1052 #ifdef HAVE_NMI_HANDLER 1053 else if (strcmp(inval, "pre_nmi") == 0) 1054 preaction_val = WDOG_PRETIMEOUT_NMI; 1055 #endif 1056 else if (strcmp(inval, "pre_int") == 0) 1057 preaction_val = WDOG_PRETIMEOUT_MSG_INT; 1058 else 1059 return -EINVAL; 1060 strcpy(preaction, inval); 1061 return 0; 1062 } 1063 1064 static int preop_op(const char *inval, char *outval) 1065 { 1066 if (outval) 1067 strcpy(outval, preop); 1068 1069 if (!inval) 1070 return 0; 1071 1072 if (strcmp(inval, "preop_none") == 0) 1073 preop_val = WDOG_PREOP_NONE; 1074 else if (strcmp(inval, "preop_panic") == 0) 1075 preop_val = WDOG_PREOP_PANIC; 1076 else if (strcmp(inval, "preop_give_data") == 0) 1077 preop_val = WDOG_PREOP_GIVE_DATA; 1078 else 1079 return -EINVAL; 1080 strcpy(preop, inval); 1081 return 0; 1082 } 1083 1084 static void check_parms(void) 1085 { 1086 #ifdef HAVE_NMI_HANDLER 1087 int do_nmi = 0; 1088 int rv; 1089 1090 if (preaction_val == WDOG_PRETIMEOUT_NMI) { 1091 do_nmi = 1; 1092 if (preop_val == WDOG_PREOP_GIVE_DATA) { 1093 printk(KERN_WARNING PFX "Pretimeout op is to give data" 1094 " but NMI pretimeout is enabled, setting" 1095 " pretimeout op to none\n"); 1096 preop_op("preop_none", NULL); 1097 do_nmi = 0; 1098 } 1099 #ifdef CONFIG_X86_LOCAL_APIC 1100 if (nmi_watchdog == NMI_IO_APIC) { 1101 printk(KERN_WARNING PFX "nmi_watchdog is set to IO APIC" 1102 " mode (value is %d), that is incompatible" 1103 " with using NMI in the IPMI watchdog." 1104 " Disabling IPMI nmi pretimeout.\n", 1105 nmi_watchdog); 1106 preaction_val = WDOG_PRETIMEOUT_NONE; 1107 do_nmi = 0; 1108 } 1109 #endif 1110 } 1111 if (do_nmi && !nmi_handler_registered) { 1112 rv = request_nmi(&ipmi_nmi_handler); 1113 if (rv) { 1114 printk(KERN_WARNING PFX 1115 "Can't register nmi handler\n"); 1116 return; 1117 } else 1118 nmi_handler_registered = 1; 1119 } else if (!do_nmi && nmi_handler_registered) { 1120 release_nmi(&ipmi_nmi_handler); 1121 nmi_handler_registered = 0; 1122 } 1123 #endif 1124 } 1125 1126 static int __init ipmi_wdog_init(void) 1127 { 1128 int rv; 1129 1130 if (action_op(action, NULL)) { 1131 action_op("reset", NULL); 1132 printk(KERN_INFO PFX "Unknown action '%s', defaulting to" 1133 " reset\n", action); 1134 } 1135 1136 if (preaction_op(preaction, NULL)) { 1137 preaction_op("pre_none", NULL); 1138 printk(KERN_INFO PFX "Unknown preaction '%s', defaulting to" 1139 " none\n", preaction); 1140 } 1141 1142 if (preop_op(preop, NULL)) { 1143 preop_op("preop_none", NULL); 1144 printk(KERN_INFO PFX "Unknown preop '%s', defaulting to" 1145 " none\n", preop); 1146 } 1147 1148 check_parms(); 1149 1150 rv = ipmi_smi_watcher_register(&smi_watcher); 1151 if (rv) { 1152 #ifdef HAVE_NMI_HANDLER 1153 if (preaction_val == WDOG_PRETIMEOUT_NMI) 1154 release_nmi(&ipmi_nmi_handler); 1155 #endif 1156 printk(KERN_WARNING PFX "can't register smi watcher\n"); 1157 return rv; 1158 } 1159 1160 register_reboot_notifier(&wdog_reboot_notifier); 1161 notifier_chain_register(&panic_notifier_list, &wdog_panic_notifier); 1162 1163 printk(KERN_INFO PFX "driver initialized\n"); 1164 1165 return 0; 1166 } 1167 1168 static __exit void ipmi_unregister_watchdog(void) 1169 { 1170 int rv; 1171 1172 down_write(®ister_sem); 1173 1174 #ifdef HAVE_NMI_HANDLER 1175 if (nmi_handler_registered) 1176 release_nmi(&ipmi_nmi_handler); 1177 #endif 1178 1179 notifier_chain_unregister(&panic_notifier_list, &wdog_panic_notifier); 1180 unregister_reboot_notifier(&wdog_reboot_notifier); 1181 1182 if (! watchdog_user) 1183 goto out; 1184 1185 /* Make sure no one can call us any more. */ 1186 misc_deregister(&ipmi_wdog_miscdev); 1187 1188 /* Wait to make sure the message makes it out. The lower layer has 1189 pointers to our buffers, we want to make sure they are done before 1190 we release our memory. */ 1191 while (atomic_read(&set_timeout_tofree)) 1192 schedule_timeout_uninterruptible(1); 1193 1194 /* Disconnect from IPMI. */ 1195 rv = ipmi_destroy_user(watchdog_user); 1196 if (rv) { 1197 printk(KERN_WARNING PFX "error unlinking from IPMI: %d\n", 1198 rv); 1199 } 1200 watchdog_user = NULL; 1201 1202 out: 1203 up_write(®ister_sem); 1204 } 1205 1206 static void __exit ipmi_wdog_exit(void) 1207 { 1208 ipmi_smi_watcher_unregister(&smi_watcher); 1209 ipmi_unregister_watchdog(); 1210 } 1211 module_exit(ipmi_wdog_exit); 1212 module_init(ipmi_wdog_init); 1213 MODULE_LICENSE("GPL"); 1214 MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>"); 1215 MODULE_DESCRIPTION("watchdog timer based upon the IPMI interface."); 1216