git.oblomov.eu Git - linux-2.6/blob - drivers/char/ipmi/ipmi_watchdog.c

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