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