ia64/linux-2.6.18-xen.hg

view drivers/char/ipmi/ipmi_watchdog.c @ 893:f994bfe9b93b

linux/blktap2: reduce TLB flush scope

c/s 885 added very coarse TLB flushing. Since these flushes always
follow single page updates, single page flushes (when available) are
sufficient.

Signed-off-by: Jan Beulich <jbeulich@novell.com>
author Keir Fraser <keir.fraser@citrix.com>
date Thu Jun 04 10:32:57 2009 +0100 (2009-06-04)
parents 831230e53067
children
line source
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 */
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
57 #define PFX "IPMI Watchdog: "
59 /*
60 * The IPMI command/response information for the watchdog timer.
61 */
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
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
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. */
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
100 /* Byte 3 of the get command, byte 4 of the get response is the
101 pre-timeout in seconds. */
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)
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)
120 #define IPMI_WDOG_RESET_TIMER 0x22
121 #define IPMI_WDOG_SET_TIMER 0x24
122 #define IPMI_WDOG_GET_TIMER 0x25
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
135 static int nowayout = WATCHDOG_NOWAYOUT;
137 static ipmi_user_t watchdog_user = NULL;
139 /* Default the timeout to 10 seconds. */
140 static int timeout = 10;
142 /* The pre-timeout is disabled by default. */
143 static int pretimeout = 0;
145 /* Default action is to reset the board on a timeout. */
146 static unsigned char action_val = WDOG_TIMEOUT_RESET;
148 static char action[16] = "reset";
150 static unsigned char preaction_val = WDOG_PRETIMEOUT_NONE;
152 static char preaction[16] = "pre_none";
154 static unsigned char preop_val = WDOG_PREOP_NONE;
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;
164 static DECLARE_RWSEM(register_sem);
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
171 static int ipmi_set_timeout(int do_heartbeat);
173 /* If true, the driver will start running as soon as it is configured
174 and ready. */
175 static int start_now = 0;
177 static int set_param_int(const char *val, struct kernel_param *kp)
178 {
179 char *endp;
180 int l;
181 int rv = 0;
183 if (!val)
184 return -EINVAL;
185 l = simple_strtoul(val, &endp, 0);
186 if (endp == val)
187 return -EINVAL;
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);
195 return rv;
196 }
198 static int get_param_int(char *buffer, struct kernel_param *kp)
199 {
200 return sprintf(buffer, "%i", *((int *)kp->arg));
201 }
203 typedef int (*action_fn)(const char *intval, char *outval);
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);
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;
216 dup = kstrdup(val, GFP_KERNEL);
217 if (!dup)
218 return -ENOMEM;
220 s = strstrip(dup);
222 down_read(&register_sem);
223 rv = fn(s, NULL);
224 if (rv)
225 goto out_unlock;
227 check_parms();
228 if (watchdog_user)
229 rv = ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY);
231 out_unlock:
232 up_read(&register_sem);
233 kfree(dup);
234 return rv;
235 }
237 static int get_param_str(char *buffer, struct kernel_param *kp)
238 {
239 action_fn fn = (action_fn) kp->arg;
240 int rv;
242 rv = fn(NULL, buffer);
243 if (rv)
244 return rv;
245 return strlen(buffer);
246 }
248 module_param_call(timeout, set_param_int, get_param_int, &timeout, 0644);
249 MODULE_PARM_DESC(timeout, "Timeout value in seconds.");
251 module_param_call(pretimeout, set_param_int, get_param_int, &pretimeout, 0644);
252 MODULE_PARM_DESC(pretimeout, "Pretimeout value in seconds.");
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.");
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.");
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.");
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.");
270 module_param(nowayout, int, 0644);
271 MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=CONFIG_WATCHDOG_NOWAYOUT)");
273 /* Default state of the timer. */
274 static unsigned char ipmi_watchdog_state = WDOG_TIMEOUT_NONE;
276 /* If shutting down via IPMI, we ignore the heartbeat. */
277 static int ipmi_ignore_heartbeat = 0;
279 /* Is someone using the watchdog? Only one user is allowed. */
280 static unsigned long ipmi_wdog_open = 0;
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;
288 /* IPMI version of the BMC. */
289 static unsigned char ipmi_version_major;
290 static unsigned char ipmi_version_minor;
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);
295 static int ipmi_heartbeat(void);
296 static void panic_halt_ipmi_heartbeat(void);
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 };
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;
336 data[0] = 0;
337 WDOG_SET_TIMER_USE(data[0], WDOG_TIMER_USE_SMS_OS);
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 }
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);
362 addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
363 addr.channel = IPMI_BMC_CHANNEL;
364 addr.lun = 0;
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 }
383 if (send_heartbeat_now)
384 *send_heartbeat_now = hbnow;
386 return rv;
387 }
389 static int ipmi_set_timeout(int do_heartbeat)
390 {
391 int send_heartbeat_now;
392 int rv;
395 /* We can only send one of these at a time. */
396 mutex_lock(&set_timeout_lock);
398 atomic_set(&set_timeout_tofree, 2);
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 }
408 wait_for_completion(&set_timeout_wait);
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);
418 out:
419 return rv;
420 }
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 };
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;
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 }
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 };
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 };
490 static int ipmi_heartbeat(void)
491 {
492 struct kernel_ipmi_msg msg;
493 int rv;
494 struct ipmi_system_interface_addr addr;
496 if (ipmi_ignore_heartbeat) {
497 return 0;
498 }
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 }
513 mutex_lock(&heartbeat_lock);
515 atomic_set(&heartbeat_tofree, 2);
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 }
524 addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
525 addr.channel = IPMI_BMC_CHANNEL;
526 addr.lun = 0;
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 }
547 /* Wait for the heartbeat to be sent. */
548 wait_for_completion(&heartbeat_wait);
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 }
557 mutex_unlock(&heartbeat_lock);
559 return rv;
560 }
562 static void panic_halt_ipmi_heartbeat(void)
563 {
564 struct kernel_ipmi_msg msg;
565 struct ipmi_system_interface_addr addr;
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;
573 addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
574 addr.channel = IPMI_BMC_CHANNEL;
575 addr.lun = 0;
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 }
591 static struct watchdog_info ident =
592 {
593 .options = 0, /* WDIOF_SETTIMEOUT, */
594 .firmware_version = 1,
595 .identity = "IPMI"
596 };
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;
605 switch(cmd) {
606 case WDIOC_GETSUPPORT:
607 i = copy_to_user(argp, &ident, sizeof(ident));
608 return i ? -EFAULT : 0;
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);
617 case WDIOC_GETTIMEOUT:
618 i = copy_to_user(argp, &timeout, sizeof(timeout));
619 if (i)
620 return -EFAULT;
621 return 0;
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);
630 case WDIOC_GET_PRETIMEOUT:
631 i = copy_to_user(argp, &pretimeout, sizeof(pretimeout));
632 if (i)
633 return -EFAULT;
634 return 0;
636 case WDIOC_KEEPALIVE:
637 return ipmi_heartbeat();
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 }
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;
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;
664 default:
665 return -ENOIOCTLCMD;
666 }
667 }
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;
676 if (len) {
677 if (!nowayout) {
678 size_t i;
680 /* In case it was set long ago */
681 expect_close = 0;
683 for (i = 0; i != len; i++) {
684 char c;
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 }
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;
708 if (count <= 0)
709 return 0;
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 }
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);
730 if (signal_pending(current)) {
731 rv = -ERESTARTSYS;
732 goto out;
733 }
734 }
735 data_to_read = 0;
737 out:
738 spin_unlock(&ipmi_read_lock);
740 if (rv == 0) {
741 if (copy_to_user(buf, &data_to_read, 1))
742 rv = -EFAULT;
743 else
744 rv = 1;
745 }
747 return rv;
748 }
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;
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);
762 default:
763 return (-ENODEV);
764 }
765 }
767 static unsigned int ipmi_poll(struct file *file, poll_table *wait)
768 {
769 unsigned int mask = 0;
771 poll_wait(file, &read_q, wait);
773 spin_lock(&ipmi_read_lock);
774 if (data_to_read)
775 mask |= (POLLIN | POLLRDNORM);
776 spin_unlock(&ipmi_read_lock);
778 return mask;
779 }
781 static int ipmi_fasync(int fd, struct file *file, int on)
782 {
783 int result;
785 result = fasync_helper(fd, file, on, &fasync_q);
787 return (result);
788 }
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 }
804 ipmi_fasync (-1, filep, 0);
805 expect_close = 0;
807 return 0;
808 }
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 };
821 static struct miscdevice ipmi_wdog_miscdev = {
822 .minor = WATCHDOG_MINOR,
823 .name = "watchdog",
824 .fops = &ipmi_wdog_fops
825 };
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 }
836 ipmi_free_recv_msg(msg);
837 }
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);
851 spin_unlock(&ipmi_read_lock);
852 }
853 }
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 }
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 };
867 static void ipmi_register_watchdog(int ipmi_intf)
868 {
869 int rv = -EBUSY;
871 down_write(&register_sem);
872 if (watchdog_user)
873 goto out;
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 }
881 ipmi_get_version(watchdog_user,
882 &ipmi_version_major,
883 &ipmi_version_minor);
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 }
892 out:
893 up_write(&register_sem);
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 }
904 #ifdef HAVE_NMI_HANDLER
905 static int
906 ipmi_nmi(void *dev_id, struct pt_regs *regs, 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;
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 }
923 return NOTIFY_DONE;
924 }
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
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;
943 if ((watchdog_user) && (!reboot_event_handled)) {
944 /* Make sure we only do this once. */
945 reboot_event_handled = 1;
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 }
964 static struct notifier_block wdog_reboot_notifier = {
965 .notifier_call = wdog_reboot_handler,
966 .next = NULL,
967 .priority = 0
968 };
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;
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;
985 timeout = 255;
986 pretimeout = 0;
987 panic_halt_ipmi_set_timeout();
988 }
990 return NOTIFY_OK;
991 }
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 };
1000 static void ipmi_new_smi(int if_num, struct device *device)
1002 ipmi_register_watchdog(if_num);
1005 static void ipmi_smi_gone(int if_num)
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. */
1012 static struct ipmi_smi_watcher smi_watcher =
1014 .owner = THIS_MODULE,
1015 .new_smi = ipmi_new_smi,
1016 .smi_gone = ipmi_smi_gone
1017 };
1019 static int action_op(const char *inval, char *outval)
1021 if (outval)
1022 strcpy(outval, action);
1024 if (!inval)
1025 return 0;
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;
1041 static int preaction_op(const char *inval, char *outval)
1043 if (outval)
1044 strcpy(outval, preaction);
1046 if (!inval)
1047 return 0;
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;
1065 static int preop_op(const char *inval, char *outval)
1067 if (outval)
1068 strcpy(outval, preop);
1070 if (!inval)
1071 return 0;
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;
1085 static void check_parms(void)
1087 #ifdef HAVE_NMI_HANDLER
1088 int do_nmi = 0;
1089 int rv;
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;
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;
1110 #endif
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;
1124 #endif
1127 static int __init ipmi_wdog_init(void)
1129 int rv;
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);
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);
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);
1149 check_parms();
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;
1161 register_reboot_notifier(&wdog_reboot_notifier);
1162 atomic_notifier_chain_register(&panic_notifier_list,
1163 &wdog_panic_notifier);
1165 printk(KERN_INFO PFX "driver initialized\n");
1167 return 0;
1170 static __exit void ipmi_unregister_watchdog(void)
1172 int rv;
1174 down_write(&register_sem);
1176 #ifdef HAVE_NMI_HANDLER
1177 if (nmi_handler_registered)
1178 release_nmi(&ipmi_nmi_handler);
1179 #endif
1181 atomic_notifier_chain_unregister(&panic_notifier_list,
1182 &wdog_panic_notifier);
1183 unregister_reboot_notifier(&wdog_reboot_notifier);
1185 if (! watchdog_user)
1186 goto out;
1188 /* Make sure no one can call us any more. */
1189 misc_deregister(&ipmi_wdog_miscdev);
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);
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);
1203 watchdog_user = NULL;
1205 out:
1206 up_write(&register_sem);
1209 static void __exit ipmi_wdog_exit(void)
1211 ipmi_smi_watcher_unregister(&smi_watcher);
1212 ipmi_unregister_watchdog();
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.");