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/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
 139 /* Default the timeout to 10 seconds. */
 140 static int timeout = 10;
 141
 142 /* The pre-timeout is disabled by default. */
 143 static int pretimeout = 0;
 144
 145 /* Default action is to reset the board on a timeout. */
 146 static unsigned char action_val = WDOG_TIMEOUT_RESET;
 147
 148 static char action[16] = "reset";
 149
 150 static unsigned char preaction_val = WDOG_PRETIMEOUT_NONE;
 151
 152 static char preaction[16] = "pre_none";
 153
 154 static unsigned char preop_val = WDOG_PREOP_NONE;
 155
 156 static char preop[16] = "preop_none";
 157 static DEFINE_SPINLOCK(ipmi_read_lock);
 158 static char data_to_read = 0;
 159 static DECLARE_WAIT_QUEUE_HEAD(read_q);
 160 static struct fasync_struct *fasync_q = NULL;
 161 static char pretimeout_since_last_heartbeat = 0;
 162 static char expect_close;
 163
 164 static DECLARE_RWSEM(register_sem);
 165
 166 /* Parameters to ipmi_set_timeout */
 167 #define IPMI_SET_TIMEOUT_NO_HB                  0
 168 #define IPMI_SET_TIMEOUT_HB_IF_NECESSARY        1
 169 #define IPMI_SET_TIMEOUT_FORCE_HB               2
 170
 171 static int ipmi_set_timeout(int do_heartbeat);
 172
 173 /* If true, the driver will start running as soon as it is configured
 174    and ready. */
 175 static int start_now = 0;
 176
 177 static int set_param_int(const char *val, struct kernel_param *kp)
 178 {
 179         char *endp;
 180         int  l;
 181         int  rv = 0;
 182
 183         if (!val)
 184                 return -EINVAL;
 185         l = simple_strtoul(val, &endp, 0);
 186         if (endp == val)
 187                 return -EINVAL;
 188
 189         down_read(&register_sem);
 190         *((int *)kp->arg) = l;
 191         if (watchdog_user)
 192                 rv = ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY);
 193         up_read(&register_sem);
 194
 195         return rv;
 196 }
 197
 198 static int get_param_int(char *buffer, struct kernel_param *kp)
 199 {
 200         return sprintf(buffer, "%i", *((int *)kp->arg));
 201 }
 202
 203 typedef int (*action_fn)(const char *intval, char *outval);
 204
 205 static int action_op(const char *inval, char *outval);
 206 static int preaction_op(const char *inval, char *outval);
 207 static int preop_op(const char *inval, char *outval);
 208 static void check_parms(void);
 209
 210 static int set_param_str(const char *val, struct kernel_param *kp)
 211 {
 212         action_fn  fn = (action_fn) kp->arg;
 213         int        rv = 0;
 214         const char *end;
 215         char       valcp[16];
 216         int        len;
 217
 218         /* Truncate leading and trailing spaces. */
 219         while (isspace(*val))
 220                 val++;
 221         end = val + strlen(val) - 1;
 222         while ((end >= val) && isspace(*end))
 223                 end--;
 224         len = end - val + 1;
 225         if (len > sizeof(valcp) - 1)
 226                 return -EINVAL;
 227         memcpy(valcp, val, len);
 228         valcp[len] = '\0';
 229
 230         down_read(&register_sem);
 231         rv = fn(valcp, NULL);
 232         if (rv)
 233                 goto out_unlock;
 234
 235         check_parms();
 236         if (watchdog_user)
 237                 rv = ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY);
 238
 239  out_unlock:
 240         up_read(&register_sem);
 241         return rv;
 242 }
 243
 244 static int get_param_str(char *buffer, struct kernel_param *kp)
 245 {
 246         action_fn fn = (action_fn) kp->arg;
 247         int       rv;
 248
 249         rv = fn(NULL, buffer);
 250         if (rv)
 251                 return rv;
 252         return strlen(buffer);
 253 }
 254
 255 module_param_call(timeout, set_param_int, get_param_int, &timeout, 0644);
 256 MODULE_PARM_DESC(timeout, "Timeout value in seconds.");
 257
 258 module_param_call(pretimeout, set_param_int, get_param_int, &pretimeout, 0644);
 259 MODULE_PARM_DESC(pretimeout, "Pretimeout value in seconds.");
 260
 261 module_param_call(action, set_param_str, get_param_str, action_op, 0644);
 262 MODULE_PARM_DESC(action, "Timeout action. One of: "
 263                  "reset, none, power_cycle, power_off.");
 264
 265 module_param_call(preaction, set_param_str, get_param_str, preaction_op, 0644);
 266 MODULE_PARM_DESC(preaction, "Pretimeout action.  One of: "
 267                  "pre_none, pre_smi, pre_nmi, pre_int.");
 268
 269 module_param_call(preop, set_param_str, get_param_str, preop_op, 0644);
 270 MODULE_PARM_DESC(preop, "Pretimeout driver operation.  One of: "
 271                  "preop_none, preop_panic, preop_give_data.");
 272
 273 module_param(start_now, int, 0);
 274 MODULE_PARM_DESC(start_now, "Set to 1 to start the watchdog as"
 275                  "soon as the driver is loaded.");
 276
 277 module_param(nowayout, int, 0644);
 278 MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=CONFIG_WATCHDOG_NOWAYOUT)");
 279
 280 /* Default state of the timer. */
 281 static unsigned char ipmi_watchdog_state = WDOG_TIMEOUT_NONE;
 282
 283 /* If shutting down via IPMI, we ignore the heartbeat. */
 284 static int ipmi_ignore_heartbeat = 0;
 285
 286 /* Is someone using the watchdog?  Only one user is allowed. */
 287 static unsigned long ipmi_wdog_open = 0;
 288
 289 /* If set to 1, the heartbeat command will set the state to reset and
 290    start the timer.  The timer doesn't normally run when the driver is
 291    first opened until the heartbeat is set the first time, this
 292    variable is used to accomplish this. */
 293 static int ipmi_start_timer_on_heartbeat = 0;
 294
 295 /* IPMI version of the BMC. */
 296 static unsigned char ipmi_version_major;
 297 static unsigned char ipmi_version_minor;
 298
 299 /* If a pretimeout occurs, this is used to allow only one panic to happen. */
 300 static atomic_t preop_panic_excl = ATOMIC_INIT(-1);
 301
 302 static int ipmi_heartbeat(void);
 303 static void panic_halt_ipmi_heartbeat(void);
 304
 305
 306 /* We use a semaphore to make sure that only one thing can send a set
 307    timeout at one time, because we only have one copy of the data.
 308    The semaphore is claimed when the set_timeout is sent and freed
 309    when both messages are free. */
 310 static atomic_t set_timeout_tofree = ATOMIC_INIT(0);
 311 static DECLARE_MUTEX(set_timeout_lock);
 312 static void set_timeout_free_smi(struct ipmi_smi_msg *msg)
 313 {
 314     if (atomic_dec_and_test(&set_timeout_tofree))
 315             up(&set_timeout_lock);
 316 }
 317 static void set_timeout_free_recv(struct ipmi_recv_msg *msg)
 318 {
 319     if (atomic_dec_and_test(&set_timeout_tofree))
 320             up(&set_timeout_lock);
 321 }
 322 static struct ipmi_smi_msg set_timeout_smi_msg =
 323 {
 324         .done = set_timeout_free_smi
 325 };
 326 static struct ipmi_recv_msg set_timeout_recv_msg =
 327 {
 328         .done = set_timeout_free_recv
 329 };
 330
 331 static int i_ipmi_set_timeout(struct ipmi_smi_msg  *smi_msg,
 332                               struct ipmi_recv_msg *recv_msg,
 333                               int                  *send_heartbeat_now)
 334 {
 335         struct kernel_ipmi_msg            msg;
 336         unsigned char                     data[6];
 337         int                               rv;
 338         struct ipmi_system_interface_addr addr;
 339         int                               hbnow = 0;
 340
 341
 342         data[0] = 0;
 343         WDOG_SET_TIMER_USE(data[0], WDOG_TIMER_USE_SMS_OS);
 344
 345         if ((ipmi_version_major > 1)
 346             || ((ipmi_version_major == 1) && (ipmi_version_minor >= 5)))
 347         {
 348                 /* This is an IPMI 1.5-only feature. */
 349                 data[0] |= WDOG_DONT_STOP_ON_SET;
 350         } else if (ipmi_watchdog_state != WDOG_TIMEOUT_NONE) {
 351                 /* In ipmi 1.0, setting the timer stops the watchdog, we
 352                    need to start it back up again. */
 353                 hbnow = 1;
 354         }
 355
 356         data[1] = 0;
 357         WDOG_SET_TIMEOUT_ACT(data[1], ipmi_watchdog_state);
 358         if ((pretimeout > 0) && (ipmi_watchdog_state != WDOG_TIMEOUT_NONE)) {
 359             WDOG_SET_PRETIMEOUT_ACT(data[1], preaction_val);
 360             data[2] = pretimeout;
 361         } else {
 362             WDOG_SET_PRETIMEOUT_ACT(data[1], WDOG_PRETIMEOUT_NONE);
 363             data[2] = 0; /* No pretimeout. */
 364         }
 365         data[3] = 0;
 366         WDOG_SET_TIMEOUT(data[4], data[5], timeout);
 367
 368         addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
 369         addr.channel = IPMI_BMC_CHANNEL;
 370         addr.lun = 0;
 371
 372         msg.netfn = 0x06;
 373         msg.cmd = IPMI_WDOG_SET_TIMER;
 374         msg.data = data;
 375         msg.data_len = sizeof(data);
 376         rv = ipmi_request_supply_msgs(watchdog_user,
 377                                       (struct ipmi_addr *) &addr,
 378                                       0,
 379                                       &msg,
 380                                       NULL,
 381                                       smi_msg,
 382                                       recv_msg,
 383                                       1);
 384         if (rv) {
 385                 printk(KERN_WARNING PFX "set timeout error: %d\n",
 386                        rv);
 387         }
 388
 389         if (send_heartbeat_now)
 390             *send_heartbeat_now = hbnow;
 391
 392         return rv;
 393 }
 394
 395 static int ipmi_set_timeout(int do_heartbeat)
 396 {
 397         int send_heartbeat_now;
 398         int rv;
 399
 400
 401         /* We can only send one of these at a time. */
 402         down(&set_timeout_lock);
 403
 404         atomic_set(&set_timeout_tofree, 2);
 405
 406         rv = i_ipmi_set_timeout(&set_timeout_smi_msg,
 407                                 &set_timeout_recv_msg,
 408                                 &send_heartbeat_now);
 409         if (rv) {
 410                 up(&set_timeout_lock);
 411         } else {
 412                 if ((do_heartbeat == IPMI_SET_TIMEOUT_FORCE_HB)
 413                     || ((send_heartbeat_now)
 414                         && (do_heartbeat == IPMI_SET_TIMEOUT_HB_IF_NECESSARY)))
 415                 {
 416                         rv = ipmi_heartbeat();
 417                 }
 418         }
 419
 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 DECLARE_MUTEX(heartbeat_lock);
 462 static DECLARE_MUTEX_LOCKED(heartbeat_wait_lock);
 463 static void heartbeat_free_smi(struct ipmi_smi_msg *msg)
 464 {
 465     if (atomic_dec_and_test(&heartbeat_tofree))
 466             up(&heartbeat_wait_lock);
 467 }
 468 static void heartbeat_free_recv(struct ipmi_recv_msg *msg)
 469 {
 470     if (atomic_dec_and_test(&heartbeat_tofree))
 471             up(&heartbeat_wait_lock);
 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         down(&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                 up(&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                 up(&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         down(&heartbeat_wait_lock);
 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         up(&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         {
 795                 if (expect_close == 42) {
 796                         ipmi_watchdog_state = WDOG_TIMEOUT_NONE;
 797                         ipmi_set_timeout(IPMI_SET_TIMEOUT_NO_HB);
 798                 } else {
 799                         printk(KERN_CRIT PFX "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 {
 953                         /* Set a long timer to let the reboot happens, but
 954                            reboot if it hangs. */
 955                         timeout = 120;
 956                         pretimeout = 0;
 957                         ipmi_watchdog_state = WDOG_TIMEOUT_RESET;
 958                         panic_halt_ipmi_set_timeout();
 959                 }
 960         }
 961         return NOTIFY_OK;
 962 }
 963
 964 static struct notifier_block wdog_reboot_notifier = {
 965         .notifier_call  = wdog_reboot_handler,
 966         .next           = NULL,
 967         .priority       = 0
 968 };
 969
 970 static int wdog_panic_handler(struct notifier_block *this,
 971                               unsigned long         event,
 972                               void                  *unused)
 973 {
 974         static int panic_event_handled = 0;
 975
 976         /* On a panic, if we have a panic timeout, make sure that the thing
 977            reboots, even if it hangs during that panic. */
 978         if (watchdog_user && !panic_event_handled) {
 979                 /* Make sure the panic doesn't hang, and make sure we
 980                    do this only once. */
 981                 panic_event_handled = 1;
 982
 983                 timeout = 255;
 984                 pretimeout = 0;
 985                 ipmi_watchdog_state = WDOG_TIMEOUT_RESET;
 986                 panic_halt_ipmi_set_timeout();
 987         }
 988
 989         return NOTIFY_OK;
 990 }
 991
 992 static struct notifier_block wdog_panic_notifier = {
 993         .notifier_call  = wdog_panic_handler,
 994         .next           = NULL,
 995         .priority       = 150   /* priority: INT_MAX >= x >= 0 */
 996 };
 997
 998
 999 static void ipmi_new_smi(int if_num, struct device *device)
1000 {
1001         ipmi_register_watchdog(if_num);
1002 }
1003
1004 static void ipmi_smi_gone(int if_num)
1005 {
1006         /* This can never be called, because once the watchdog is
1007            registered, the interface can't go away until the watchdog
1008            is unregistered. */
1009 }
1010
1011 static struct ipmi_smi_watcher smi_watcher =
1012 {
1013         .owner    = THIS_MODULE,
1014         .new_smi  = ipmi_new_smi,
1015         .smi_gone = ipmi_smi_gone
1016 };
1017
1018 static int action_op(const char *inval, char *outval)
1019 {
1020         if (outval)
1021                 strcpy(outval, action);
1022
1023         if (!inval)
1024                 return 0;
1025
1026         if (strcmp(inval, "reset") == 0)
1027                 action_val = WDOG_TIMEOUT_RESET;
1028         else if (strcmp(inval, "none") == 0)
1029                 action_val = WDOG_TIMEOUT_NONE;
1030         else if (strcmp(inval, "power_cycle") == 0)
1031                 action_val = WDOG_TIMEOUT_POWER_CYCLE;
1032         else if (strcmp(inval, "power_off") == 0)
1033                 action_val = WDOG_TIMEOUT_POWER_DOWN;
1034         else
1035                 return -EINVAL;
1036         strcpy(action, inval);
1037         return 0;
1038 }
1039
1040 static int preaction_op(const char *inval, char *outval)
1041 {
1042         if (outval)
1043                 strcpy(outval, preaction);
1044
1045         if (!inval)
1046                 return 0;
1047
1048         if (strcmp(inval, "pre_none") == 0)
1049                 preaction_val = WDOG_PRETIMEOUT_NONE;
1050         else if (strcmp(inval, "pre_smi") == 0)
1051                 preaction_val = WDOG_PRETIMEOUT_SMI;
1052 #ifdef HAVE_NMI_HANDLER
1053         else if (strcmp(inval, "pre_nmi") == 0)
1054                 preaction_val = WDOG_PRETIMEOUT_NMI;
1055 #endif
1056         else if (strcmp(inval, "pre_int") == 0)
1057                 preaction_val = WDOG_PRETIMEOUT_MSG_INT;
1058         else
1059                 return -EINVAL;
1060         strcpy(preaction, inval);
1061         return 0;
1062 }
1063
1064 static int preop_op(const char *inval, char *outval)
1065 {
1066         if (outval)
1067                 strcpy(outval, preop);
1068
1069         if (!inval)
1070                 return 0;
1071
1072         if (strcmp(inval, "preop_none") == 0)
1073                 preop_val = WDOG_PREOP_NONE;
1074         else if (strcmp(inval, "preop_panic") == 0)
1075                 preop_val = WDOG_PREOP_PANIC;
1076         else if (strcmp(inval, "preop_give_data") == 0)
1077                 preop_val = WDOG_PREOP_GIVE_DATA;
1078         else
1079                 return -EINVAL;
1080         strcpy(preop, inval);
1081         return 0;
1082 }
1083
1084 static void check_parms(void)
1085 {
1086 #ifdef HAVE_NMI_HANDLER
1087         int do_nmi = 0;
1088         int rv;
1089
1090         if (preaction_val == WDOG_PRETIMEOUT_NMI) {
1091                 do_nmi = 1;
1092                 if (preop_val == WDOG_PREOP_GIVE_DATA) {
1093                         printk(KERN_WARNING PFX "Pretimeout op is to give data"
1094                                " but NMI pretimeout is enabled, setting"
1095                                " pretimeout op to none\n");
1096                         preop_op("preop_none", NULL);
1097                         do_nmi = 0;
1098                 }
1099 #ifdef CONFIG_X86_LOCAL_APIC
1100                 if (nmi_watchdog == NMI_IO_APIC) {
1101                         printk(KERN_WARNING PFX "nmi_watchdog is set to IO APIC"
1102                                " mode (value is %d), that is incompatible"
1103                                " with using NMI in the IPMI watchdog."
1104                                " Disabling IPMI nmi pretimeout.\n",
1105                                nmi_watchdog);
1106                         preaction_val = WDOG_PRETIMEOUT_NONE;
1107                         do_nmi = 0;
1108                 }
1109 #endif
1110         }
1111         if (do_nmi && !nmi_handler_registered) {
1112                 rv = request_nmi(&ipmi_nmi_handler);
1113                 if (rv) {
1114                         printk(KERN_WARNING PFX
1115                                "Can't register nmi handler\n");
1116                         return;
1117                 } else
1118                         nmi_handler_registered = 1;
1119         } else if (!do_nmi && nmi_handler_registered) {
1120                 release_nmi(&ipmi_nmi_handler);
1121                 nmi_handler_registered = 0;
1122         }
1123 #endif
1124 }
1125
1126 static int __init ipmi_wdog_init(void)
1127 {
1128         int rv;
1129
1130         if (action_op(action, NULL)) {
1131                 action_op("reset", NULL);
1132                 printk(KERN_INFO PFX "Unknown action '%s', defaulting to"
1133                        " reset\n", action);
1134         }
1135
1136         if (preaction_op(preaction, NULL)) {
1137                 preaction_op("pre_none", NULL);
1138                 printk(KERN_INFO PFX "Unknown preaction '%s', defaulting to"
1139                        " none\n", preaction);
1140         }
1141
1142         if (preop_op(preop, NULL)) {
1143                 preop_op("preop_none", NULL);
1144                 printk(KERN_INFO PFX "Unknown preop '%s', defaulting to"
1145                        " none\n", preop);
1146         }
1147
1148         check_parms();
1149
1150         rv = ipmi_smi_watcher_register(&smi_watcher);
1151         if (rv) {
1152 #ifdef HAVE_NMI_HANDLER
1153                 if (preaction_val == WDOG_PRETIMEOUT_NMI)
1154                         release_nmi(&ipmi_nmi_handler);
1155 #endif
1156                 printk(KERN_WARNING PFX "can't register smi watcher\n");
1157                 return rv;
1158         }
1159
1160         register_reboot_notifier(&wdog_reboot_notifier);
1161         atomic_notifier_chain_register(&panic_notifier_list,
1162                         &wdog_panic_notifier);
1163
1164         printk(KERN_INFO PFX "driver initialized\n");
1165
1166         return 0;
1167 }
1168
1169 static __exit void ipmi_unregister_watchdog(void)
1170 {
1171         int rv;
1172
1173         down_write(&register_sem);
1174
1175 #ifdef HAVE_NMI_HANDLER
1176         if (nmi_handler_registered)
1177                 release_nmi(&ipmi_nmi_handler);
1178 #endif
1179
1180         atomic_notifier_chain_unregister(&panic_notifier_list,
1181                         &wdog_panic_notifier);
1182         unregister_reboot_notifier(&wdog_reboot_notifier);
1183
1184         if (! watchdog_user)
1185                 goto out;
1186
1187         /* Make sure no one can call us any more. */
1188         misc_deregister(&ipmi_wdog_miscdev);
1189
1190         /* Wait to make sure the message makes it out.  The lower layer has
1191            pointers to our buffers, we want to make sure they are done before
1192            we release our memory. */
1193         while (atomic_read(&set_timeout_tofree))
1194                 schedule_timeout_uninterruptible(1);
1195
1196         /* Disconnect from IPMI. */
1197         rv = ipmi_destroy_user(watchdog_user);
1198         if (rv) {
1199                 printk(KERN_WARNING PFX "error unlinking from IPMI: %d\n",
1200                        rv);
1201         }
1202         watchdog_user = NULL;
1203
1204  out:
1205         up_write(&register_sem);
1206 }
1207
1208 static void __exit ipmi_wdog_exit(void)
1209 {
1210         ipmi_smi_watcher_unregister(&smi_watcher);
1211         ipmi_unregister_watchdog();
1212 }
1213 module_exit(ipmi_wdog_exit);
1214 module_init(ipmi_wdog_init);
1215 MODULE_LICENSE("GPL");
1216 MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>");
1217 MODULE_DESCRIPTION("watchdog timer based upon the IPMI interface.");