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