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