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