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