]> bbs.cooldavid.org Git - net-next-2.6.git/blame - drivers/char/ipmi/ipmi_watchdog.c
git://bbs.cooldavid.org / net-next-2.6.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[PATCH] IPMI: watchdog handle panic properly
[net-next-2.6.git] / drivers / char / ipmi / ipmi_watchdog.c
CommitLineData
1da177e4
LT		 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>
d6dfd131 42#include <linux/completion.h>
1da177e4
LT		 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>
cc4673ee
CM		 51#include <linux/string.h>
52#include <linux/ctype.h>
b385676b 53#include <asm/atomic.h>
1da177e4
LT		 54#ifdef CONFIG_X86_LOCAL_APIC
55#include <asm/apic.h>
56#endif
57
58#define PFX "IPMI Watchdog: "
59
1da177e4
LT		 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
4bfdf378 136static int nowayout = WATCHDOG_NOWAYOUT;
1da177e4
LT		 137
138static ipmi_user_t watchdog_user = NULL;
139
140/* Default the timeout to 10 seconds. */
141static int timeout = 10;
142
143/* The pre-timeout is disabled by default. */
144static int pretimeout = 0;
145
146/* Default action is to reset the board on a timeout. */
147static unsigned char action_val = WDOG_TIMEOUT_RESET;
148
149static char action[16] = "reset";
150
151static unsigned char preaction_val = WDOG_PRETIMEOUT_NONE;
152
153static char preaction[16] = "pre_none";
154
155static unsigned char preop_val = WDOG_PREOP_NONE;
156
157static char preop[16] = "preop_none";
158static DEFINE_SPINLOCK(ipmi_read_lock);
159static char data_to_read = 0;
160static DECLARE_WAIT_QUEUE_HEAD(read_q);
161static struct fasync_struct *fasync_q = NULL;
162static char pretimeout_since_last_heartbeat = 0;
163static char expect_close;
164
cc4673ee
CM		 165static 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
172static int ipmi_set_timeout(int do_heartbeat);
173
1da177e4
LT		 174/* If true, the driver will start running as soon as it is configured
175 and ready. */
176static int start_now = 0;
177
cc4673ee
CM		 178static 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
199static int get_param_int(char *buffer, struct kernel_param *kp)
200{
201 return sprintf(buffer, "%i", *((int *)kp->arg));
202}
203
204typedef int (*action_fn)(const char *intval, char *outval);
205
206static int action_op(const char *inval, char *outval);
207static int preaction_op(const char *inval, char *outval);
208static int preop_op(const char *inval, char *outval);
209static void check_parms(void);
210
211static int set_param_str(const char *val, struct kernel_param *kp)
212{
213 action_fn fn = (action_fn) kp->arg;
214 int rv = 0;
66f969d0
PE		 215 char *dup, *s;
216
217 dup = kstrdup(val, GFP_KERNEL);
218 if (!dup)
219 return -ENOMEM;
220
221 s = strstrip(dup);
cc4673ee
CM		 222
223 down_read(&register_sem);
66f969d0 224 rv = fn(s, NULL);
cc4673ee
CM		 225 if (rv)
226 goto out_unlock;
227
228 check_parms();
229 if (watchdog_user)
230 rv = ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY);
231
232 out_unlock:
233 up_read(&register_sem);
66f969d0 234 kfree(dup);
cc4673ee
CM		 235 return rv;
236}
237
238static int get_param_str(char *buffer, struct kernel_param *kp)
239{
240 action_fn fn = (action_fn) kp->arg;
241 int rv;
242
243 rv = fn(NULL, buffer);
244 if (rv)
245 return rv;
246 return strlen(buffer);
247}
248
249module_param_call(timeout, set_param_int, get_param_int, &timeout, 0644);
1da177e4 250MODULE_PARM_DESC(timeout, "Timeout value in seconds.");
cc4673ee
CM		 251
252module_param_call(pretimeout, set_param_int, get_param_int, &pretimeout, 0644);
1da177e4 253MODULE_PARM_DESC(pretimeout, "Pretimeout value in seconds.");
cc4673ee
CM		 254
255module_param_call(action, set_param_str, get_param_str, action_op, 0644);
1da177e4
LT		 256MODULE_PARM_DESC(action, "Timeout action. One of: "
257 "reset, none, power_cycle, power_off.");
cc4673ee
CM		 258
259module_param_call(preaction, set_param_str, get_param_str, preaction_op, 0644);
1da177e4
LT		 260MODULE_PARM_DESC(preaction, "Pretimeout action. One of: "
261 "pre_none, pre_smi, pre_nmi, pre_int.");
cc4673ee
CM		 262
263module_param_call(preop, set_param_str, get_param_str, preop_op, 0644);
1da177e4
LT		 264MODULE_PARM_DESC(preop, "Pretimeout driver operation. One of: "
265 "preop_none, preop_panic, preop_give_data.");
cc4673ee 266
1da177e4
LT		 267module_param(start_now, int, 0);
268MODULE_PARM_DESC(start_now, "Set to 1 to start the watchdog as"
269 "soon as the driver is loaded.");
cc4673ee
CM		 270
271module_param(nowayout, int, 0644);
1da177e4
LT		 272MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=CONFIG_WATCHDOG_NOWAYOUT)");
273
274/* Default state of the timer. */
275static unsigned char ipmi_watchdog_state = WDOG_TIMEOUT_NONE;
276
277/* If shutting down via IPMI, we ignore the heartbeat. */
278static int ipmi_ignore_heartbeat = 0;
279
280/* Is someone using the watchdog? Only one user is allowed. */
281static unsigned long ipmi_wdog_open = 0;
282
283/* If set to 1, the heartbeat command will set the state to reset and
284 start the timer. The timer doesn't normally run when the driver is
285 first opened until the heartbeat is set the first time, this
286 variable is used to accomplish this. */
287static int ipmi_start_timer_on_heartbeat = 0;
288
289/* IPMI version of the BMC. */
290static unsigned char ipmi_version_major;
291static unsigned char ipmi_version_minor;
292
b385676b
CM		 293/* If a pretimeout occurs, this is used to allow only one panic to happen. */
294static atomic_t preop_panic_excl = ATOMIC_INIT(-1);
1da177e4
LT		 295
296static int ipmi_heartbeat(void);
297static void panic_halt_ipmi_heartbeat(void);
298
299
d6dfd131 300/* We use a mutex to make sure that only one thing can send a set
1da177e4 301 timeout at one time, because we only have one copy of the data.
d6dfd131 302 The mutex is claimed when the set_timeout is sent and freed
1da177e4
LT		 303 when both messages are free. */
304static atomic_t set_timeout_tofree = ATOMIC_INIT(0);
d6dfd131
CM		 305static DEFINE_MUTEX(set_timeout_lock);
306static DECLARE_COMPLETION(set_timeout_wait);
1da177e4
LT		 307static void set_timeout_free_smi(struct ipmi_smi_msg *msg)
308{
309 if (atomic_dec_and_test(&set_timeout_tofree))
d6dfd131 310 complete(&set_timeout_wait);
1da177e4
LT		 311}
312static void set_timeout_free_recv(struct ipmi_recv_msg *msg)
313{
314 if (atomic_dec_and_test(&set_timeout_tofree))
d6dfd131 315 complete(&set_timeout_wait);
1da177e4
LT		 316}
317static struct ipmi_smi_msg set_timeout_smi_msg =
318{
319 .done = set_timeout_free_smi
320};
321static struct ipmi_recv_msg set_timeout_recv_msg =
322{
323 .done = set_timeout_free_recv
324};
325
326static int i_ipmi_set_timeout(struct ipmi_smi_msg *smi_msg,
327 struct ipmi_recv_msg *recv_msg,
328 int *send_heartbeat_now)
329{
330 struct kernel_ipmi_msg msg;
331 unsigned char data[6];
332 int rv;
333 struct ipmi_system_interface_addr addr;
334 int hbnow = 0;
335
336
337 data[0] = 0;
338 WDOG_SET_TIMER_USE(data[0], WDOG_TIMER_USE_SMS_OS);
339
340 if ((ipmi_version_major > 1)
341 || ((ipmi_version_major == 1) && (ipmi_version_minor >= 5)))
342 {
343 /* This is an IPMI 1.5-only feature. */
344 data[0] |= WDOG_DONT_STOP_ON_SET;
345 } else if (ipmi_watchdog_state != WDOG_TIMEOUT_NONE) {
346 /* In ipmi 1.0, setting the timer stops the watchdog, we
347 need to start it back up again. */
348 hbnow = 1;
349 }
350
351 data[1] = 0;
352 WDOG_SET_TIMEOUT_ACT(data[1], ipmi_watchdog_state);
8f05ee9a 353 if ((pretimeout > 0) && (ipmi_watchdog_state != WDOG_TIMEOUT_NONE)) {
1da177e4
LT		 354 WDOG_SET_PRETIMEOUT_ACT(data[1], preaction_val);
355 data[2] = pretimeout;
356 } else {
357 WDOG_SET_PRETIMEOUT_ACT(data[1], WDOG_PRETIMEOUT_NONE);
358 data[2] = 0; /* No pretimeout. */
359 }
360 data[3] = 0;
361 WDOG_SET_TIMEOUT(data[4], data[5], timeout);
362
363 addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
364 addr.channel = IPMI_BMC_CHANNEL;
365 addr.lun = 0;
366
367 msg.netfn = 0x06;
368 msg.cmd = IPMI_WDOG_SET_TIMER;
369 msg.data = data;
370 msg.data_len = sizeof(data);
371 rv = ipmi_request_supply_msgs(watchdog_user,
372 (struct ipmi_addr *) &addr,
373 0,
374 &msg,
375 NULL,
376 smi_msg,
377 recv_msg,
378 1);
379 if (rv) {
380 printk(KERN_WARNING PFX "set timeout error: %d\n",
381 rv);
382 }
383
384 if (send_heartbeat_now)
385 *send_heartbeat_now = hbnow;
386
387 return rv;
388}
389
1da177e4
LT		 390static int ipmi_set_timeout(int do_heartbeat)
391{
392 int send_heartbeat_now;
393 int rv;
394
395
396 /* We can only send one of these at a time. */
d6dfd131 397 mutex_lock(&set_timeout_lock);
1da177e4
LT		 398
399 atomic_set(&set_timeout_tofree, 2);
400
401 rv = i_ipmi_set_timeout(&set_timeout_smi_msg,
402 &set_timeout_recv_msg,
403 &send_heartbeat_now);
404 if (rv) {
d6dfd131
CM		 405 mutex_unlock(&set_timeout_lock);
406 goto out;
407 }
408
409 wait_for_completion(&set_timeout_wait);
410
411 if ((do_heartbeat == IPMI_SET_TIMEOUT_FORCE_HB)
412 || ((send_heartbeat_now)
413 && (do_heartbeat == IPMI_SET_TIMEOUT_HB_IF_NECESSARY)))
414 {
415 rv = ipmi_heartbeat();
1da177e4 416 }
d6dfd131 417 mutex_unlock(&set_timeout_lock);
1da177e4 418
d6dfd131 419out:
1da177e4
LT		 420 return rv;
421}
422
423static void dummy_smi_free(struct ipmi_smi_msg *msg)
424{
425}
426static void dummy_recv_free(struct ipmi_recv_msg *msg)
427{
428}
429static struct ipmi_smi_msg panic_halt_smi_msg =
430{
431 .done = dummy_smi_free
432};
433static 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. */
442static 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. */
460static atomic_t heartbeat_tofree = ATOMIC_INIT(0);
d6dfd131
CM		 461static DEFINE_MUTEX(heartbeat_lock);
462static DECLARE_COMPLETION(heartbeat_wait);
1da177e4
LT		 463static void heartbeat_free_smi(struct ipmi_smi_msg *msg)
464{
465 if (atomic_dec_and_test(&heartbeat_tofree))
d6dfd131 466 complete(&heartbeat_wait);
1da177e4
LT		 467}
468static void heartbeat_free_recv(struct ipmi_recv_msg *msg)
469{
470 if (atomic_dec_and_test(&heartbeat_tofree))
d6dfd131 471 complete(&heartbeat_wait);
1da177e4
LT		 472}
473static struct ipmi_smi_msg heartbeat_smi_msg =
474{
475 .done = heartbeat_free_smi
476};
477static struct ipmi_recv_msg heartbeat_recv_msg =
478{
479 .done = heartbeat_free_recv
480};
481
482static struct ipmi_smi_msg panic_halt_heartbeat_smi_msg =
483{
484 .done = dummy_smi_free
485};
486static struct ipmi_recv_msg panic_halt_heartbeat_recv_msg =
487{
488 .done = dummy_recv_free
489};
490
491static 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
d6dfd131 514 mutex_lock(&heartbeat_lock);
1da177e4
LT		 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) {
d6dfd131 521 mutex_unlock(&heartbeat_lock);
1da177e4
LT		 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) {
d6dfd131 542 mutex_unlock(&heartbeat_lock);
1da177e4
LT		 543 printk(KERN_WARNING PFX "heartbeat failure: %d\n",
544 rv);
545 return rv;
546 }
547
548 /* Wait for the heartbeat to be sent. */
d6dfd131 549 wait_for_completion(&heartbeat_wait);
1da177e4
LT		 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
d6dfd131 558 mutex_unlock(&heartbeat_lock);
1da177e4
LT		 559
560 return rv;
561}
562
563static 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
8a3628d5 592static struct watchdog_info ident =
1da177e4
LT		 593{
594 .options = 0, /* WDIOF_SETTIMEOUT, */
595 .firmware_version = 1,
596 .identity = "IPMI"
597};
598
599static 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
670static 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
701static 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
751static int ipmi_open(struct inode *ino, struct file *filep)
752{
e8b33617
CM		 753 switch (iminor(ino)) {
754 case WATCHDOG_MINOR:
755 if (test_and_set_bit(0, &ipmi_wdog_open))
1da177e4
LT		 756 return -EBUSY;
757
e8b33617
CM		 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);
1da177e4 762
e8b33617
CM		 763 default:
764 return (-ENODEV);
1da177e4
LT		 765 }
766}
767
768static 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
782static 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
791static int ipmi_close(struct inode *ino, struct file *filep)
792{
8a3628d5 793 if (iminor(ino) == WATCHDOG_MINOR) {
1da177e4
LT		 794 if (expect_close == 42) {
795 ipmi_watchdog_state = WDOG_TIMEOUT_NONE;
796 ipmi_set_timeout(IPMI_SET_TIMEOUT_NO_HB);
1da177e4 797 } else {
8a3628d5
CM		 798 printk(KERN_CRIT PFX
799 "Unexpected close, not stopping watchdog!\n");
1da177e4
LT		 800 ipmi_heartbeat();
801 }
ec26d79f 802 clear_bit(0, &ipmi_wdog_open);
1da177e4
LT		 803 }
804
805 ipmi_fasync (-1, filep, 0);
806 expect_close = 0;
807
808 return 0;
809}
810
811static 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
822static struct miscdevice ipmi_wdog_miscdev = {
823 .minor = WATCHDOG_MINOR,
824 .name = "watchdog",
825 .fops = &ipmi_wdog_fops
826};
827
1da177e4
LT		 828static 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
840static void ipmi_wdog_pretimeout_handler(void *handler_data)
841{
842 if (preaction_val != WDOG_PRETIMEOUT_NONE) {
b385676b
CM		 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) {
1da177e4
LT		 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
862static 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
868static 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
906static int
907ipmi_nmi(void *dev_id, struct pt_regs *regs, int cpu, int handled)
908{
8f05ee9a
CM		 909 /* If we are not expecting a timeout, ignore it. */
910 if (ipmi_watchdog_state == WDOG_TIMEOUT_NONE)
911 return NOTIFY_DONE;
912
1da177e4
LT		 913 /* If no one else handled the NMI, we assume it was the IPMI
914 watchdog. */
8f05ee9a
CM		 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;
b385676b
CM		 920 if (atomic_inc_and_test(&preop_panic_excl))
921 panic(PFX "pre-timeout");
8f05ee9a 922 }
1da177e4
LT		 923
924 return NOTIFY_DONE;
925}
926
927static 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};
cc4673ee 935int nmi_handler_registered;
1da177e4
LT		 936#endif
937
938static 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();
96febe9f 952 } else if (ipmi_watchdog_state != WDOG_TIMEOUT_NONE) {
1da177e4 953 /* Set a long timer to let the reboot happens, but
96febe9f
CM		 954 reboot if it hangs, but only if the watchdog
955 timer was already running. */
1da177e4
LT		 956 timeout = 120;
957 pretimeout = 0;
958 ipmi_watchdog_state = WDOG_TIMEOUT_RESET;
959 panic_halt_ipmi_set_timeout();
960 }
961 }
962 return NOTIFY_OK;
963}
964
965static struct notifier_block wdog_reboot_notifier = {
966 .notifier_call = wdog_reboot_handler,
967 .next = NULL,
968 .priority = 0
969};
970
971static int wdog_panic_handler(struct notifier_block *this,
972 unsigned long event,
973 void *unused)
974{
975 static int panic_event_handled = 0;
976
96febe9f
CM		 977 /* On a panic, if we have a panic timeout, make sure to extend
978 the watchdog timer to a reasonable value to complete the
979 panic, if the watchdog timer is running. Plus the
980 pretimeout is meaningless at panic time. */
981 if (watchdog_user && !panic_event_handled &&
982 ipmi_watchdog_state != WDOG_TIMEOUT_NONE) {
983 /* Make sure we do this only once. */
1da177e4
LT		 984 panic_event_handled = 1;
985
986 timeout = 255;
987 pretimeout = 0;
1da177e4
LT		 988 panic_halt_ipmi_set_timeout();
989 }
990
991 return NOTIFY_OK;
992}
993
994static struct notifier_block wdog_panic_notifier = {
995 .notifier_call = wdog_panic_handler,
996 .next = NULL,
997 .priority = 150 /* priority: INT_MAX >= x >= 0 */
998};
999
1000
50c812b2 1001static void ipmi_new_smi(int if_num, struct device *device)
1da177e4
LT		 1002{
1003 ipmi_register_watchdog(if_num);
1004}
1005
1006static void ipmi_smi_gone(int if_num)
1007{
1008 /* This can never be called, because once the watchdog is
1009 registered, the interface can't go away until the watchdog
1010 is unregistered. */
1011}
1012
1013static struct ipmi_smi_watcher smi_watcher =
1014{
1015 .owner = THIS_MODULE,
1016 .new_smi = ipmi_new_smi,
1017 .smi_gone = ipmi_smi_gone
1018};
1019
cc4673ee 1020static int action_op(const char *inval, char *outval)
1da177e4 1021{
cc4673ee
CM		 1022 if (outval)
1023 strcpy(outval, action);
1024
1025 if (!inval)
1026 return 0;
1da177e4 1027
cc4673ee 1028 if (strcmp(inval, "reset") == 0)
1da177e4 1029 action_val = WDOG_TIMEOUT_RESET;
cc4673ee 1030 else if (strcmp(inval, "none") == 0)
1da177e4 1031 action_val = WDOG_TIMEOUT_NONE;
cc4673ee 1032 else if (strcmp(inval, "power_cycle") == 0)
1da177e4 1033 action_val = WDOG_TIMEOUT_POWER_CYCLE;
cc4673ee 1034 else if (strcmp(inval, "power_off") == 0)
1da177e4 1035 action_val = WDOG_TIMEOUT_POWER_DOWN;
cc4673ee
CM		 1036 else
1037 return -EINVAL;
1038 strcpy(action, inval);
1039 return 0;
1040}
1041
1042static int preaction_op(const char *inval, char *outval)
1043{
1044 if (outval)
1045 strcpy(outval, preaction);
1da177e4 1046
cc4673ee
CM		 1047 if (!inval)
1048 return 0;
1049
1050 if (strcmp(inval, "pre_none") == 0)
1da177e4 1051 preaction_val = WDOG_PRETIMEOUT_NONE;
cc4673ee 1052 else if (strcmp(inval, "pre_smi") == 0)
1da177e4
LT		 1053 preaction_val = WDOG_PRETIMEOUT_SMI;
1054#ifdef HAVE_NMI_HANDLER
cc4673ee 1055 else if (strcmp(inval, "pre_nmi") == 0)
1da177e4
LT		 1056 preaction_val = WDOG_PRETIMEOUT_NMI;
1057#endif
cc4673ee 1058 else if (strcmp(inval, "pre_int") == 0)
1da177e4 1059 preaction_val = WDOG_PRETIMEOUT_MSG_INT;
cc4673ee
CM		 1060 else
1061 return -EINVAL;
1062 strcpy(preaction, inval);
1063 return 0;
1064}
1065
1066static int preop_op(const char *inval, char *outval)
1067{
1068 if (outval)
1069 strcpy(outval, preop);
1da177e4 1070
cc4673ee
CM		 1071 if (!inval)
1072 return 0;
1073
1074 if (strcmp(inval, "preop_none") == 0)
1da177e4 1075 preop_val = WDOG_PREOP_NONE;
cc4673ee 1076 else if (strcmp(inval, "preop_panic") == 0)
1da177e4 1077 preop_val = WDOG_PREOP_PANIC;
cc4673ee 1078 else if (strcmp(inval, "preop_give_data") == 0)
1da177e4 1079 preop_val = WDOG_PREOP_GIVE_DATA;
cc4673ee
CM		 1080 else
1081 return -EINVAL;
1082 strcpy(preop, inval);
1083 return 0;
1084}
1da177e4 1085
cc4673ee
CM		 1086static void check_parms(void)
1087{
1da177e4 1088#ifdef HAVE_NMI_HANDLER
cc4673ee
CM		 1089 int do_nmi = 0;
1090 int rv;
1091
1da177e4 1092 if (preaction_val == WDOG_PRETIMEOUT_NMI) {
cc4673ee 1093 do_nmi = 1;
1da177e4
LT		 1094 if (preop_val == WDOG_PREOP_GIVE_DATA) {
1095 printk(KERN_WARNING PFX "Pretimeout op is to give data"
1096 " but NMI pretimeout is enabled, setting"
1097 " pretimeout op to none\n");
cc4673ee
CM		 1098 preop_op("preop_none", NULL);
1099 do_nmi = 0;
1da177e4
LT		 1100 }
1101#ifdef CONFIG_X86_LOCAL_APIC
1102 if (nmi_watchdog == NMI_IO_APIC) {
1103 printk(KERN_WARNING PFX "nmi_watchdog is set to IO APIC"
1104 " mode (value is %d), that is incompatible"
1105 " with using NMI in the IPMI watchdog."
1106 " Disabling IPMI nmi pretimeout.\n",
1107 nmi_watchdog);
1108 preaction_val = WDOG_PRETIMEOUT_NONE;
cc4673ee
CM		 1109 do_nmi = 0;
1110 }
1da177e4 1111#endif
cc4673ee
CM		 1112 }
1113 if (do_nmi && !nmi_handler_registered) {
1da177e4
LT		 1114 rv = request_nmi(&ipmi_nmi_handler);
1115 if (rv) {
cc4673ee
CM		 1116 printk(KERN_WARNING PFX
1117 "Can't register nmi handler\n");
1118 return;
1119 } else
1120 nmi_handler_registered = 1;
1121 } else if (!do_nmi && nmi_handler_registered) {
1122 release_nmi(&ipmi_nmi_handler);
1123 nmi_handler_registered = 0;
1da177e4
LT		 1124 }
1125#endif
cc4673ee
CM		 1126}
1127
1128static int __init ipmi_wdog_init(void)
1129{
1130 int rv;
1131
1132 if (action_op(action, NULL)) {
1133 action_op("reset", NULL);
1134 printk(KERN_INFO PFX "Unknown action '%s', defaulting to"
1135 " reset\n", action);
1136 }
1137
1138 if (preaction_op(preaction, NULL)) {
1139 preaction_op("pre_none", NULL);
1140 printk(KERN_INFO PFX "Unknown preaction '%s', defaulting to"
1141 " none\n", preaction);
1142 }
1143
1144 if (preop_op(preop, NULL)) {
1145 preop_op("preop_none", NULL);
1146 printk(KERN_INFO PFX "Unknown preop '%s', defaulting to"
1147 " none\n", preop);
1148 }
1149
1150 check_parms();
1da177e4
LT		 1151
1152 rv = ipmi_smi_watcher_register(&smi_watcher);
1153 if (rv) {
1154#ifdef HAVE_NMI_HANDLER
1155 if (preaction_val == WDOG_PRETIMEOUT_NMI)
1156 release_nmi(&ipmi_nmi_handler);
1157#endif
1158 printk(KERN_WARNING PFX "can't register smi watcher\n");
1159 return rv;
1160 }
1161
1162 register_reboot_notifier(&wdog_reboot_notifier);
e041c683
AS		 1163 atomic_notifier_chain_register(&panic_notifier_list,
1164 &wdog_panic_notifier);
1da177e4 1165
1fdd75bd
CM		 1166 printk(KERN_INFO PFX "driver initialized\n");
1167
1da177e4
LT		 1168 return 0;
1169}
1170
1171static __exit void ipmi_unregister_watchdog(void)
1172{
1173 int rv;
1174
1175 down_write(&register_sem);
1176
1177#ifdef HAVE_NMI_HANDLER
cc4673ee 1178 if (nmi_handler_registered)
1da177e4
LT		 1179 release_nmi(&ipmi_nmi_handler);
1180#endif
1181
e041c683
AS		 1182 atomic_notifier_chain_unregister(&panic_notifier_list,
1183 &wdog_panic_notifier);
1da177e4
LT		 1184 unregister_reboot_notifier(&wdog_reboot_notifier);
1185
1186 if (! watchdog_user)
1187 goto out;
1188
1189 /* Make sure no one can call us any more. */
1190 misc_deregister(&ipmi_wdog_miscdev);
1191
1192 /* Wait to make sure the message makes it out. The lower layer has
1193 pointers to our buffers, we want to make sure they are done before
1194 we release our memory. */
da4cd8df
NA		 1195 while (atomic_read(&set_timeout_tofree))
1196 schedule_timeout_uninterruptible(1);
1da177e4
LT		 1197
1198 /* Disconnect from IPMI. */
1199 rv = ipmi_destroy_user(watchdog_user);
1200 if (rv) {
1201 printk(KERN_WARNING PFX "error unlinking from IPMI: %d\n",
1202 rv);
1203 }
1204 watchdog_user = NULL;
1205
1206 out:
1207 up_write(&register_sem);
1208}
1209
1210static void __exit ipmi_wdog_exit(void)
1211{
1212 ipmi_smi_watcher_unregister(&smi_watcher);
1213 ipmi_unregister_watchdog();
1214}
1215module_exit(ipmi_wdog_exit);
1216module_init(ipmi_wdog_init);
1217MODULE_LICENSE("GPL");
1fdd75bd
CM		 1218MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>");
1219MODULE_DESCRIPTION("watchdog timer based upon the IPMI interface.");
Clone of davem's net-next-2.6 tree