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