1 /*
2 * ipmi_watchdog.c
3 *
4 * A watchdog timer based upon the IPMI interface.
5 *
6 * Author: MontaVista Software, Inc.
7 * Corey Minyard <minyard@mvista.com>
8 * source@mvista.com
9 *
10 * Copyright 2002 MontaVista Software Inc.
11 *
12 * This program is free software; you can redistribute it and/or modify it
13 * under the terms of the GNU General Public License as published by the
14 * Free Software Foundation; either version 2 of the License, or (at your
15 * option) any later version.
16 *
17 *
18 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
19 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
20 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
23 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
24 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
25 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
26 * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
27 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 *
29 * You should have received a copy of the GNU General Public License along
30 * with this program; if not, write to the Free Software Foundation, Inc.,
31 * 675 Mass Ave, Cambridge, MA 02139, USA.
32 */
33
34 #include <linux/module.h>
35 #include <linux/moduleparam.h>
36 #include <linux/ipmi.h>
37 #include <linux/ipmi_smi.h>
38 #include <linux/watchdog.h>
39 #include <linux/miscdevice.h>
40 #include <linux/init.h>
41 #include <linux/completion.h>
42 #include <linux/kdebug.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 <linux/delay.h>
54 #include <asm/atomic.h>
55
56 #ifdef CONFIG_X86
57 /* This is ugly, but I've determined that x86 is the only architecture
58 that can reasonably support the IPMI NMI watchdog timeout at this
59 time. If another architecture adds this capability somehow, it
60 will have to be a somewhat different mechanism and I have no idea
61 how it will work. So in the unlikely event that another
62 architecture supports this, we can figure out a good generic
63 mechanism for it at that time. */
64 #include <asm/kdebug.h>
65 #define HAVE_DIE_NMI
66 #endif
67
68 #define PFX "IPMI Watchdog: "
69
70 /*
71 * The IPMI command/response information for the watchdog timer.
72 */
73
74 /* values for byte 1 of the set command, byte 2 of the get response. */
75 #define WDOG_DONT_LOG (1 << 7)
76 #define WDOG_DONT_STOP_ON_SET (1 << 6)
77 #define WDOG_SET_TIMER_USE(byte, use) \
78 byte = ((byte) & 0xf8) | ((use) & 0x7)
79 #define WDOG_GET_TIMER_USE(byte) ((byte) & 0x7)
80 #define WDOG_TIMER_USE_BIOS_FRB2 1
81 #define WDOG_TIMER_USE_BIOS_POST 2
82 #define WDOG_TIMER_USE_OS_LOAD 3
83 #define WDOG_TIMER_USE_SMS_OS 4
84 #define WDOG_TIMER_USE_OEM 5
85
86 /* values for byte 2 of the set command, byte 3 of the get response. */
87 #define WDOG_SET_PRETIMEOUT_ACT(byte, use) \
88 byte = ((byte) & 0x8f) | (((use) & 0x7) << 4)
89 #define WDOG_GET_PRETIMEOUT_ACT(byte) (((byte) >> 4) & 0x7)
90 #define WDOG_PRETIMEOUT_NONE 0
91 #define WDOG_PRETIMEOUT_SMI 1
92 #define WDOG_PRETIMEOUT_NMI 2
93 #define WDOG_PRETIMEOUT_MSG_INT 3
94
95 /* Operations that can be performed on a pretimout. */
96 #define WDOG_PREOP_NONE 0
97 #define WDOG_PREOP_PANIC 1
98 #define WDOG_PREOP_GIVE_DATA 2 /* Cause data to be available to
99 read. Doesn't work in NMI
100 mode. */
101
102 /* Actions to perform on a full timeout. */
103 #define WDOG_SET_TIMEOUT_ACT(byte, use) \
104 byte = ((byte) & 0xf8) | ((use) & 0x7)
105 #define WDOG_GET_TIMEOUT_ACT(byte) ((byte) & 0x7)
106 #define WDOG_TIMEOUT_NONE 0
107 #define WDOG_TIMEOUT_RESET 1
108 #define WDOG_TIMEOUT_POWER_DOWN 2
109 #define WDOG_TIMEOUT_POWER_CYCLE 3
110
111 /* Byte 3 of the get command, byte 4 of the get response is the
112 pre-timeout in seconds. */
113
114 /* Bits for setting byte 4 of the set command, byte 5 of the get response. */
115 #define WDOG_EXPIRE_CLEAR_BIOS_FRB2 (1 << 1)
116 #define WDOG_EXPIRE_CLEAR_BIOS_POST (1 << 2)
117 #define WDOG_EXPIRE_CLEAR_OS_LOAD (1 << 3)
118 #define WDOG_EXPIRE_CLEAR_SMS_OS (1 << 4)
119 #define WDOG_EXPIRE_CLEAR_OEM (1 << 5)
120
121 /* Setting/getting the watchdog timer value. This is for bytes 5 and
122 6 (the timeout time) of the set command, and bytes 6 and 7 (the
123 timeout time) and 8 and 9 (the current countdown value) of the
124 response. The timeout value is given in seconds (in the command it
125 is 100ms intervals). */
126 #define WDOG_SET_TIMEOUT(byte1, byte2, val) \
127 (byte1) = (((val) * 10) & 0xff), (byte2) = (((val) * 10) >> 8)
128 #define WDOG_GET_TIMEOUT(byte1, byte2) \
129 (((byte1) | ((byte2) << 8)) / 10)
130
131 #define IPMI_WDOG_RESET_TIMER 0x22
132 #define IPMI_WDOG_SET_TIMER 0x24
133 #define IPMI_WDOG_GET_TIMER 0x25
134
135 /* These are here until the real ones get into the watchdog.h interface. */
136 #ifndef WDIOC_GETTIMEOUT
137 #define WDIOC_GETTIMEOUT _IOW(WATCHDOG_IOCTL_BASE, 20, int)
138 #endif
139 #ifndef WDIOC_SET_PRETIMEOUT
140 #define WDIOC_SET_PRETIMEOUT _IOW(WATCHDOG_IOCTL_BASE, 21, int)
141 #endif
142 #ifndef WDIOC_GET_PRETIMEOUT
143 #define WDIOC_GET_PRETIMEOUT _IOW(WATCHDOG_IOCTL_BASE, 22, int)
144 #endif
145
146 static int nowayout = WATCHDOG_NOWAYOUT;
147
148 static ipmi_user_t watchdog_user;
149 static int watchdog_ifnum;
150
151 /* Default the timeout to 10 seconds. */
152 static int timeout = 10;
153
154 /* The pre-timeout is disabled by default. */
155 static int pretimeout;
156
157 /* Default action is to reset the board on a timeout. */
158 static unsigned char action_val = WDOG_TIMEOUT_RESET;
159
160 static char action[16] = "reset";
161
162 static unsigned char preaction_val = WDOG_PRETIMEOUT_NONE;
163
164 static char preaction[16] = "pre_none";
165
166 static unsigned char preop_val = WDOG_PREOP_NONE;
167
168 static char preop[16] = "preop_none";
169 static DEFINE_SPINLOCK(ipmi_read_lock);
170 static char data_to_read;
171 static DECLARE_WAIT_QUEUE_HEAD(read_q);
172 static struct fasync_struct *fasync_q;
173 static char pretimeout_since_last_heartbeat;
174 static char expect_close;
175
176 static int ifnum_to_use = -1;
177
178 /* Parameters to ipmi_set_timeout */
179 #define IPMI_SET_TIMEOUT_NO_HB 0
180 #define IPMI_SET_TIMEOUT_HB_IF_NECESSARY 1
181 #define IPMI_SET_TIMEOUT_FORCE_HB 2
182
183 static int ipmi_set_timeout(int do_heartbeat);
184 static void ipmi_register_watchdog(int ipmi_intf);
185 static void ipmi_unregister_watchdog(int ipmi_intf);
186
187 /* If true, the driver will start running as soon as it is configured
188 and ready. */
189 static int start_now;
190
191 static int set_param_int(const char *val, struct kernel_param *kp)
192 {
193 char *endp;
194 int l;
195 int rv = 0;
196
197 if (!val)
198 return -EINVAL;
199 l = simple_strtoul(val, &endp, 0);
200 if (endp == val)
201 return -EINVAL;
202
203 *((int *)kp->arg) = l;
204 if (watchdog_user)
205 rv = ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY);
206
207 return rv;
208 }
209
210 static int get_param_int(char *buffer, struct kernel_param *kp)
211 {
212 return sprintf(buffer, "%i", *((int *)kp->arg));
213 }
214
215 typedef int (*action_fn)(const char *intval, char *outval);
216
217 static int action_op(const char *inval, char *outval);
218 static int preaction_op(const char *inval, char *outval);
219 static int preop_op(const char *inval, char *outval);
220 static void check_parms(void);
221
222 static int set_param_str(const char *val, struct kernel_param *kp)
223 {
224 action_fn fn = (action_fn) kp->arg;
225 int rv = 0;
226 char valcp[16];
227 char *s;
228
229 strncpy(valcp, val, 16);
230 valcp[15] = '\0';
231
232 s = strstrip(valcp);
233
234 rv = fn(s, NULL);
235 if (rv)
236 goto out;
237
238 check_parms();
239 if (watchdog_user)
240 rv = ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY);
241
242 out:
243 return rv;
244 }
245
246 static int get_param_str(char *buffer, struct kernel_param *kp)
247 {
248 action_fn fn = (action_fn) kp->arg;
249 int rv;
250
251 rv = fn(NULL, buffer);
252 if (rv)
253 return rv;
254 return strlen(buffer);
255 }
256
257
258 static int set_param_wdog_ifnum(const char *val, struct kernel_param *kp)
259 {
260 int rv = param_set_int(val, kp);
261 if (rv)
262 return rv;
263 if ((ifnum_to_use < 0) || (ifnum_to_use == watchdog_ifnum))
264 return 0;
265
266 ipmi_unregister_watchdog(watchdog_ifnum);
267 ipmi_register_watchdog(ifnum_to_use);
268 return 0;
269 }
270
271 module_param_call(ifnum_to_use, set_param_wdog_ifnum, get_param_int,
272 &ifnum_to_use, 0644);
273 MODULE_PARM_DESC(ifnum_to_use, "The interface number to use for the watchdog "
274 "timer. Setting to -1 defaults to the first registered "
275 "interface");
276
277 module_param_call(timeout, set_param_int, get_param_int, &timeout, 0644);
278 MODULE_PARM_DESC(timeout, "Timeout value in seconds.");
279
280 module_param_call(pretimeout, set_param_int, get_param_int, &pretimeout, 0644);
281 MODULE_PARM_DESC(pretimeout, "Pretimeout value in seconds.");
282
283 module_param_call(action, set_param_str, get_param_str, action_op, 0644);
284 MODULE_PARM_DESC(action, "Timeout action. One of: "
285 "reset, none, power_cycle, power_off.");
286
287 module_param_call(preaction, set_param_str, get_param_str, preaction_op, 0644);
288 MODULE_PARM_DESC(preaction, "Pretimeout action. One of: "
289 "pre_none, pre_smi, pre_nmi, pre_int.");
290
291 module_param_call(preop, set_param_str, get_param_str, preop_op, 0644);
292 MODULE_PARM_DESC(preop, "Pretimeout driver operation. One of: "
293 "preop_none, preop_panic, preop_give_data.");
294
295 module_param(start_now, int, 0444);
296 MODULE_PARM_DESC(start_now, "Set to 1 to start the watchdog as"
297 "soon as the driver is loaded.");
298
299 module_param(nowayout, int, 0644);
300 MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started "
301 "(default=CONFIG_WATCHDOG_NOWAYOUT)");
302
303 /* Default state of the timer. */
304 static unsigned char ipmi_watchdog_state = WDOG_TIMEOUT_NONE;
305
306 /* If shutting down via IPMI, we ignore the heartbeat. */
307 static int ipmi_ignore_heartbeat;
308
309 /* Is someone using the watchdog? Only one user is allowed. */
310 static unsigned long ipmi_wdog_open;
311
312 /* If set to 1, the heartbeat command will set the state to reset and
313 start the timer. The timer doesn't normally run when the driver is
314 first opened until the heartbeat is set the first time, this
315 variable is used to accomplish this. */
316 static int ipmi_start_timer_on_heartbeat;
317
318 /* IPMI version of the BMC. */
319 static unsigned char ipmi_version_major;
320 static unsigned char ipmi_version_minor;
321
322 /* If a pretimeout occurs, this is used to allow only one panic to happen. */
323 static atomic_t preop_panic_excl = ATOMIC_INIT(-1);
324
325 #ifdef HAVE_DIE_NMI
326 static int testing_nmi;
327 static int nmi_handler_registered;
328 #endif
329
330 static int ipmi_heartbeat(void);
331
332 /* We use a mutex to make sure that only one thing can send a set
333 timeout at one time, because we only have one copy of the data.
334 The mutex is claimed when the set_timeout is sent and freed
335 when both messages are free. */
336 static atomic_t set_timeout_tofree = ATOMIC_INIT(0);
337 static DEFINE_MUTEX(set_timeout_lock);
338 static DECLARE_COMPLETION(set_timeout_wait);
339 static void set_timeout_free_smi(struct ipmi_smi_msg *msg)
340 {
341 if (atomic_dec_and_test(&set_timeout_tofree))
342 complete(&set_timeout_wait);
343 }
344 static void set_timeout_free_recv(struct ipmi_recv_msg *msg)
345 {
346 if (atomic_dec_and_test(&set_timeout_tofree))
347 complete(&set_timeout_wait);
348 }
349 static struct ipmi_smi_msg set_timeout_smi_msg =
350 {
351 .done = set_timeout_free_smi
352 };
353 static struct ipmi_recv_msg set_timeout_recv_msg =
354 {
355 .done = set_timeout_free_recv
356 };
357
358 static int i_ipmi_set_timeout(struct ipmi_smi_msg *smi_msg,
359 struct ipmi_recv_msg *recv_msg,
360 int *send_heartbeat_now)
361 {
362 struct kernel_ipmi_msg msg;
363 unsigned char data[6];
364 int rv;
365 struct ipmi_system_interface_addr addr;
366 int hbnow = 0;
367
368
369 /* These can be cleared as we are setting the timeout. */
370 pretimeout_since_last_heartbeat = 0;
371
372 data[0] = 0;
373 WDOG_SET_TIMER_USE(data[0], WDOG_TIMER_USE_SMS_OS);
374
375 if ((ipmi_version_major > 1)
376 || ((ipmi_version_major == 1) && (ipmi_version_minor >= 5)))
377 {
378 /* This is an IPMI 1.5-only feature. */
379 data[0] |= WDOG_DONT_STOP_ON_SET;
380 } else if (ipmi_watchdog_state != WDOG_TIMEOUT_NONE) {
381 /* In ipmi 1.0, setting the timer stops the watchdog, we
382 need to start it back up again. */
383 hbnow = 1;
384 }
385
386 data[1] = 0;
387 WDOG_SET_TIMEOUT_ACT(data[1], ipmi_watchdog_state);
388 if ((pretimeout > 0) && (ipmi_watchdog_state != WDOG_TIMEOUT_NONE)) {
389 WDOG_SET_PRETIMEOUT_ACT(data[1], preaction_val);
390 data[2] = pretimeout;
391 } else {
392 WDOG_SET_PRETIMEOUT_ACT(data[1], WDOG_PRETIMEOUT_NONE);
393 data[2] = 0; /* No pretimeout. */
394 }
395 data[3] = 0;
396 WDOG_SET_TIMEOUT(data[4], data[5], timeout);
397
398 addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
399 addr.channel = IPMI_BMC_CHANNEL;
400 addr.lun = 0;
401
402 msg.netfn = 0x06;
403 msg.cmd = IPMI_WDOG_SET_TIMER;
404 msg.data = data;
405 msg.data_len = sizeof(data);
406 rv = ipmi_request_supply_msgs(watchdog_user,
407 (struct ipmi_addr *) &addr,
408 0,
409 &msg,
410 NULL,
411 smi_msg,
412 recv_msg,
413 1);
414 if (rv) {
415 printk(KERN_WARNING PFX "set timeout error: %d\n",
416 rv);
417 }
418
419 if (send_heartbeat_now)
420 *send_heartbeat_now = hbnow;
421
422 return rv;
423 }
424
425 static int ipmi_set_timeout(int do_heartbeat)
426 {
427 int send_heartbeat_now;
428 int rv;
429
430
431 /* We can only send one of these at a time. */
432 mutex_lock(&set_timeout_lock);
433
434 atomic_set(&set_timeout_tofree, 2);
435
436 rv = i_ipmi_set_timeout(&set_timeout_smi_msg,
437 &set_timeout_recv_msg,
438 &send_heartbeat_now);
439 if (rv) {
440 mutex_unlock(&set_timeout_lock);
441 goto out;
442 }
443
444 wait_for_completion(&set_timeout_wait);
445
446 mutex_unlock(&set_timeout_lock);
447
448 if ((do_heartbeat == IPMI_SET_TIMEOUT_FORCE_HB)
449 || ((send_heartbeat_now)
450 && (do_heartbeat == IPMI_SET_TIMEOUT_HB_IF_NECESSARY)))
451 rv = ipmi_heartbeat();
452
453 out:
454 return rv;
455 }
456
457 static atomic_t panic_done_count = ATOMIC_INIT(0);
458
459 static void panic_smi_free(struct ipmi_smi_msg *msg)
460 {
461 atomic_dec(&panic_done_count);
462 }
463 static void panic_recv_free(struct ipmi_recv_msg *msg)
464 {
465 atomic_dec(&panic_done_count);
466 }
467
468 static struct ipmi_smi_msg panic_halt_heartbeat_smi_msg =
469 {
470 .done = panic_smi_free
471 };
472 static struct ipmi_recv_msg panic_halt_heartbeat_recv_msg =
473 {
474 .done = panic_recv_free
475 };
476
477 static void panic_halt_ipmi_heartbeat(void)
478 {
479 struct kernel_ipmi_msg msg;
480 struct ipmi_system_interface_addr addr;
481 int rv;
482
483 /* Don't reset the timer if we have the timer turned off, that
484 re-enables the watchdog. */
485 if (ipmi_watchdog_state == WDOG_TIMEOUT_NONE)
486 return;
487
488 addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
489 addr.channel = IPMI_BMC_CHANNEL;
490 addr.lun = 0;
491
492 msg.netfn = 0x06;
493 msg.cmd = IPMI_WDOG_RESET_TIMER;
494 msg.data = NULL;
495 msg.data_len = 0;
496 rv = ipmi_request_supply_msgs(watchdog_user,
497 (struct ipmi_addr *) &addr,
498 0,
499 &msg,
500 NULL,
501 &panic_halt_heartbeat_smi_msg,
502 &panic_halt_heartbeat_recv_msg,
503 1);
504 if (!rv)
505 atomic_add(2, &panic_done_count);
506 }
507
508 static struct ipmi_smi_msg panic_halt_smi_msg =
509 {
510 .done = panic_smi_free
511 };
512 static struct ipmi_recv_msg panic_halt_recv_msg =
513 {
514 .done = panic_recv_free
515 };
516
517 /* Special call, doesn't claim any locks. This is only to be called
518 at panic or halt time, in run-to-completion mode, when the caller
519 is the only CPU and the only thing that will be going is these IPMI
520 calls. */
521 static void panic_halt_ipmi_set_timeout(void)
522 {
523 int send_heartbeat_now;
524 int rv;
525
526 /* Wait for the messages to be free. */
527 while (atomic_read(&panic_done_count) != 0)
528 ipmi_poll_interface(watchdog_user);
529 rv = i_ipmi_set_timeout(&panic_halt_smi_msg,
530 &panic_halt_recv_msg,
531 &send_heartbeat_now);
532 if (!rv) {
533 atomic_add(2, &panic_done_count);
534 if (send_heartbeat_now)
535 panic_halt_ipmi_heartbeat();
536 } else
537 printk(KERN_WARNING PFX
538 "Unable to extend the watchdog timeout.");
539 while (atomic_read(&panic_done_count) != 0)
540 ipmi_poll_interface(watchdog_user);
541 }
542
543 /* We use a semaphore to make sure that only one thing can send a
544 heartbeat at one time, because we only have one copy of the data.
545 The semaphore is claimed when the set_timeout is sent and freed
546 when both messages are free. */
547 static atomic_t heartbeat_tofree = ATOMIC_INIT(0);
548 static DEFINE_MUTEX(heartbeat_lock);
549 static DECLARE_COMPLETION(heartbeat_wait);
550 static void heartbeat_free_smi(struct ipmi_smi_msg *msg)
551 {
552 if (atomic_dec_and_test(&heartbeat_tofree))
553 complete(&heartbeat_wait);
554 }
555 static void heartbeat_free_recv(struct ipmi_recv_msg *msg)
556 {
557 if (atomic_dec_and_test(&heartbeat_tofree))
558 complete(&heartbeat_wait);
559 }
560 static struct ipmi_smi_msg heartbeat_smi_msg =
561 {
562 .done = heartbeat_free_smi
563 };
564 static struct ipmi_recv_msg heartbeat_recv_msg =
565 {
566 .done = heartbeat_free_recv
567 };
568
569 static int ipmi_heartbeat(void)
570 {
571 struct kernel_ipmi_msg msg;
572 int rv;
573 struct ipmi_system_interface_addr addr;
574
575 if (ipmi_ignore_heartbeat)
576 return 0;
577
578 if (ipmi_start_timer_on_heartbeat) {
579 ipmi_start_timer_on_heartbeat = 0;
580 ipmi_watchdog_state = action_val;
581 return ipmi_set_timeout(IPMI_SET_TIMEOUT_FORCE_HB);
582 } else if (pretimeout_since_last_heartbeat) {
583 /* A pretimeout occurred, make sure we set the timeout.
584 We don't want to set the action, though, we want to
585 leave that alone (thus it can't be combined with the
586 above operation. */
587 return ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY);
588 }
589
590 mutex_lock(&heartbeat_lock);
591
592 atomic_set(&heartbeat_tofree, 2);
593
594 /* Don't reset the timer if we have the timer turned off, that
595 re-enables the watchdog. */
596 if (ipmi_watchdog_state == WDOG_TIMEOUT_NONE) {
597 mutex_unlock(&heartbeat_lock);
598 return 0;
599 }
600
601 addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
602 addr.channel = IPMI_BMC_CHANNEL;
603 addr.lun = 0;
604
605 msg.netfn = 0x06;
606 msg.cmd = IPMI_WDOG_RESET_TIMER;
607 msg.data = NULL;
608 msg.data_len = 0;
609 rv = ipmi_request_supply_msgs(watchdog_user,
610 (struct ipmi_addr *) &addr,
611 0,
612 &msg,
613 NULL,
614 &heartbeat_smi_msg,
615 &heartbeat_recv_msg,
616 1);
617 if (rv) {
618 mutex_unlock(&heartbeat_lock);
619 printk(KERN_WARNING PFX "heartbeat failure: %d\n",
620 rv);
621 return rv;
622 }
623
624 /* Wait for the heartbeat to be sent. */
625 wait_for_completion(&heartbeat_wait);
626
627 if (heartbeat_recv_msg.msg.data[0] != 0) {
628 /* Got an error in the heartbeat response. It was already
629 reported in ipmi_wdog_msg_handler, but we should return
630 an error here. */
631 rv = -EINVAL;
632 }
633
634 mutex_unlock(&heartbeat_lock);
635
636 return rv;
637 }
638
639 static struct watchdog_info ident =
640 {
641 .options = 0, /* WDIOF_SETTIMEOUT, */
642 .firmware_version = 1,
643 .identity = "IPMI"
644 };
645
646 static int ipmi_ioctl(struct inode *inode, struct file *file,
647 unsigned int cmd, unsigned long arg)
648 {
649 void __user *argp = (void __user *)arg;
650 int i;
651 int val;
652
653 switch(cmd) {
654 case WDIOC_GETSUPPORT:
655 i = copy_to_user(argp, &ident, sizeof(ident));
656 return i ? -EFAULT : 0;
657
658 case WDIOC_SETTIMEOUT:
659 i = copy_from_user(&val, argp, sizeof(int));
660 if (i)
661 return -EFAULT;
662 timeout = val;
663 return ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY);
664
665 case WDIOC_GETTIMEOUT:
666 i = copy_to_user(argp, &timeout, sizeof(timeout));
667 if (i)
668 return -EFAULT;
669 return 0;
670
671 case WDIOC_SET_PRETIMEOUT:
672 case WDIOC_SETPRETIMEOUT:
673 i = copy_from_user(&val, argp, sizeof(int));
674 if (i)
675 return -EFAULT;
676 pretimeout = val;
677 return ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY);
678
679 case WDIOC_GET_PRETIMEOUT:
680 case WDIOC_GETPRETIMEOUT:
681 i = copy_to_user(argp, &pretimeout, sizeof(pretimeout));
682 if (i)
683 return -EFAULT;
684 return 0;
685
686 case WDIOC_KEEPALIVE:
687 return ipmi_heartbeat();
688
689 case WDIOC_SETOPTIONS:
690 i = copy_from_user(&val, argp, sizeof(int));
691 if (i)
692 return -EFAULT;
693 if (val & WDIOS_DISABLECARD)
694 {
695 ipmi_watchdog_state = WDOG_TIMEOUT_NONE;
696 ipmi_set_timeout(IPMI_SET_TIMEOUT_NO_HB);
697 ipmi_start_timer_on_heartbeat = 0;
698 }
699
700 if (val & WDIOS_ENABLECARD)
701 {
702 ipmi_watchdog_state = action_val;
703 ipmi_set_timeout(IPMI_SET_TIMEOUT_FORCE_HB);
704 }
705 return 0;
706
707 case WDIOC_GETSTATUS:
708 val = 0;
709 i = copy_to_user(argp, &val, sizeof(val));
710 if (i)
711 return -EFAULT;
712 return 0;
713
714 default:
715 return -ENOIOCTLCMD;
716 }
717 }
718
719 static ssize_t ipmi_write(struct file *file,
720 const char __user *buf,
721 size_t len,
722 loff_t *ppos)
723 {
724 int rv;
725
726 if (len) {
727 if (!nowayout) {
728 size_t i;
729
730 /* In case it was set long ago */
731 expect_close = 0;
732
733 for (i = 0; i != len; i++) {
734 char c;
735
736 if (get_user(c, buf + i))
737 return -EFAULT;
738 if (c == 'V')
739 expect_close = 42;
740 }
741 }
742 rv = ipmi_heartbeat();
743 if (rv)
744 return rv;
745 return 1;
746 }
747 return 0;
748 }
749
750 static ssize_t ipmi_read(struct file *file,
751 char __user *buf,
752 size_t count,
753 loff_t *ppos)
754 {
755 int rv = 0;
756 wait_queue_t wait;
757
758 if (count <= 0)
759 return 0;
760
761 /* Reading returns if the pretimeout has gone off, and it only does
762 it once per pretimeout. */
763 spin_lock(&ipmi_read_lock);
764 if (!data_to_read) {
765 if (file->f_flags & O_NONBLOCK) {
766 rv = -EAGAIN;
767 goto out;
768 }
769
770 init_waitqueue_entry(&wait, current);
771 add_wait_queue(&read_q, &wait);
772 while (!data_to_read) {
773 set_current_state(TASK_INTERRUPTIBLE);
774 spin_unlock(&ipmi_read_lock);
775 schedule();
776 spin_lock(&ipmi_read_lock);
777 }
778 remove_wait_queue(&read_q, &wait);
779
780 if (signal_pending(current)) {
781 rv = -ERESTARTSYS;
782 goto out;
783 }
784 }
785 data_to_read = 0;
786
787 out:
788 spin_unlock(&ipmi_read_lock);
789
790 if (rv == 0) {
791 if (copy_to_user(buf, &data_to_read, 1))
792 rv = -EFAULT;
793 else
794 rv = 1;
795 }
796
797 return rv;
798 }
799
800 static int ipmi_open(struct inode *ino, struct file *filep)
801 {
802 switch (iminor(ino)) {
803 case WATCHDOG_MINOR:
804 if (test_and_set_bit(0, &ipmi_wdog_open))
805 return -EBUSY;
806
807 /* Don't start the timer now, let it start on the
808 first heartbeat. */
809 ipmi_start_timer_on_heartbeat = 1;
810 return nonseekable_open(ino, filep);
811
812 default:
813 return (-ENODEV);
814 }
815 }
816
817 static unsigned int ipmi_poll(struct file *file, poll_table *wait)
818 {
819 unsigned int mask = 0;
820
821 poll_wait(file, &read_q, wait);
822
823 spin_lock(&ipmi_read_lock);
824 if (data_to_read)
825 mask |= (POLLIN | POLLRDNORM);
826 spin_unlock(&ipmi_read_lock);
827
828 return mask;
829 }
830
831 static int ipmi_fasync(int fd, struct file *file, int on)
832 {
833 int result;
834
835 result = fasync_helper(fd, file, on, &fasync_q);
836
837 return (result);
838 }
839
840 static int ipmi_close(struct inode *ino, struct file *filep)
841 {
842 if (iminor(ino) == WATCHDOG_MINOR) {
843 if (expect_close == 42) {
844 ipmi_watchdog_state = WDOG_TIMEOUT_NONE;
845 ipmi_set_timeout(IPMI_SET_TIMEOUT_NO_HB);
846 } else {
847 printk(KERN_CRIT PFX
848 "Unexpected close, not stopping watchdog!\n");
849 ipmi_heartbeat();
850 }
851 clear_bit(0, &ipmi_wdog_open);
852 }
853
854 ipmi_fasync (-1, filep, 0);
855 expect_close = 0;
856
857 return 0;
858 }
859
860 static const struct file_operations ipmi_wdog_fops = {
861 .owner = THIS_MODULE,
862 .read = ipmi_read,
863 .poll = ipmi_poll,
864 .write = ipmi_write,
865 .ioctl = ipmi_ioctl,
866 .open = ipmi_open,
867 .release = ipmi_close,
868 .fasync = ipmi_fasync,
869 };
870
871 static struct miscdevice ipmi_wdog_miscdev = {
872 .minor = WATCHDOG_MINOR,
873 .name = "watchdog",
874 .fops = &ipmi_wdog_fops
875 };
876
877 static void ipmi_wdog_msg_handler(struct ipmi_recv_msg *msg,
878 void *handler_data)
879 {
880 if (msg->msg.data[0] != 0) {
881 printk(KERN_ERR PFX "response: Error %x on cmd %x\n",
882 msg->msg.data[0],
883 msg->msg.cmd);
884 }
885
886 ipmi_free_recv_msg(msg);
887 }
888
889 static void ipmi_wdog_pretimeout_handler(void *handler_data)
890 {
891 if (preaction_val != WDOG_PRETIMEOUT_NONE) {
892 if (preop_val == WDOG_PREOP_PANIC) {
893 if (atomic_inc_and_test(&preop_panic_excl))
894 panic("Watchdog pre-timeout");
895 } else if (preop_val == WDOG_PREOP_GIVE_DATA) {
896 spin_lock(&ipmi_read_lock);
897 data_to_read = 1;
898 wake_up_interruptible(&read_q);
899 kill_fasync(&fasync_q, SIGIO, POLL_IN);
900
901 spin_unlock(&ipmi_read_lock);
902 }
903 }
904
905 /* On some machines, the heartbeat will give
906 an error and not work unless we re-enable
907 the timer. So do so. */
908 pretimeout_since_last_heartbeat = 1;
909 }
910
911 static struct ipmi_user_hndl ipmi_hndlrs =
912 {
913 .ipmi_recv_hndl = ipmi_wdog_msg_handler,
914 .ipmi_watchdog_pretimeout = ipmi_wdog_pretimeout_handler
915 };
916
917 static void ipmi_register_watchdog(int ipmi_intf)
918 {
919 int rv = -EBUSY;
920
921 if (watchdog_user)
922 goto out;
923
924 if ((ifnum_to_use >= 0) && (ifnum_to_use != ipmi_intf))
925 goto out;
926
927 watchdog_ifnum = ipmi_intf;
928
929 rv = ipmi_create_user(ipmi_intf, &ipmi_hndlrs, NULL, &watchdog_user);
930 if (rv < 0) {
931 printk(KERN_CRIT PFX "Unable to register with ipmi\n");
932 goto out;
933 }
934
935 ipmi_get_version(watchdog_user,
936 &ipmi_version_major,
937 &ipmi_version_minor);
938
939 rv = misc_register(&ipmi_wdog_miscdev);
940 if (rv < 0) {
941 ipmi_destroy_user(watchdog_user);
942 watchdog_user = NULL;
943 printk(KERN_CRIT PFX "Unable to register misc device\n");
944 }
945
946 #ifdef HAVE_DIE_NMI
947 if (nmi_handler_registered) {
948 int old_pretimeout = pretimeout;
949 int old_timeout = timeout;
950 int old_preop_val = preop_val;
951
952 /* Set the pretimeout to go off in a second and give
953 ourselves plenty of time to stop the timer. */
954 ipmi_watchdog_state = WDOG_TIMEOUT_RESET;
955 preop_val = WDOG_PREOP_NONE; /* Make sure nothing happens */
956 pretimeout = 99;
957 timeout = 100;
958
959 testing_nmi = 1;
960
961 rv = ipmi_set_timeout(IPMI_SET_TIMEOUT_FORCE_HB);
962 if (rv) {
963 printk(KERN_WARNING PFX "Error starting timer to"
964 " test NMI: 0x%x. The NMI pretimeout will"
965 " likely not work\n", rv);
966 rv = 0;
967 goto out_restore;
968 }
969
970 msleep(1500);
971
972 if (testing_nmi != 2) {
973 printk(KERN_WARNING PFX "IPMI NMI didn't seem to"
974 " occur. The NMI pretimeout will"
975 " likely not work\n");
976 }
977 out_restore:
978 testing_nmi = 0;
979 preop_val = old_preop_val;
980 pretimeout = old_pretimeout;
981 timeout = old_timeout;
982 }
983 #endif
984
985 out:
986 if ((start_now) && (rv == 0)) {
987 /* Run from startup, so start the timer now. */
988 start_now = 0; /* Disable this function after first startup. */
989 ipmi_watchdog_state = action_val;
990 ipmi_set_timeout(IPMI_SET_TIMEOUT_FORCE_HB);
991 printk(KERN_INFO PFX "Starting now!\n");
992 } else {
993 /* Stop the timer now. */
994 ipmi_watchdog_state = WDOG_TIMEOUT_NONE;
995 ipmi_set_timeout(IPMI_SET_TIMEOUT_NO_HB);
996 }
997 }
998
999 static void ipmi_unregister_watchdog(int ipmi_intf)
1000 {
1001 int rv;
1002
1003 if (!watchdog_user)
1004 goto out;
1005
1006 if (watchdog_ifnum != ipmi_intf)
1007 goto out;
1008
1009 /* Make sure no one can call us any more. */
1010 misc_deregister(&ipmi_wdog_miscdev);
1011
1012 /* Wait to make sure the message makes it out. The lower layer has
1013 pointers to our buffers, we want to make sure they are done before
1014 we release our memory. */
1015 while (atomic_read(&set_timeout_tofree))
1016 schedule_timeout_uninterruptible(1);
1017
1018 /* Disconnect from IPMI. */
1019 rv = ipmi_destroy_user(watchdog_user);
1020 if (rv) {
1021 printk(KERN_WARNING PFX "error unlinking from IPMI: %d\n",
1022 rv);
1023 }
1024 watchdog_user = NULL;
1025
1026 out:
1027 return;
1028 }
1029
1030 #ifdef HAVE_DIE_NMI
1031 static int
1032 ipmi_nmi(struct notifier_block *self, unsigned long val, void *data)
1033 {
1034 struct die_args *args = data;
1035
1036 if (val != DIE_NMI)
1037 return NOTIFY_OK;
1038
1039 /* Hack, if it's a memory or I/O error, ignore it. */
1040 if (args->err & 0xc0)
1041 return NOTIFY_OK;
1042
1043 /*
1044 * If we get here, it's an NMI that's not a memory or I/O
1045 * error. We can't truly tell if it's from IPMI or not
1046 * without sending a message, and sending a message is almost
1047 * impossible because of locking.
1048 */
1049
1050 if (testing_nmi) {
1051 testing_nmi = 2;
1052 return NOTIFY_STOP;
1053 }
1054
1055 /* If we are not expecting a timeout, ignore it. */
1056 if (ipmi_watchdog_state == WDOG_TIMEOUT_NONE)
1057 return NOTIFY_OK;
1058
1059 if (preaction_val != WDOG_PRETIMEOUT_NMI)
1060 return NOTIFY_OK;
1061
1062 /* If no one else handled the NMI, we assume it was the IPMI
1063 watchdog. */
1064 if (preop_val == WDOG_PREOP_PANIC) {
1065 /* On some machines, the heartbeat will give
1066 an error and not work unless we re-enable
1067 the timer. So do so. */
1068 pretimeout_since_last_heartbeat = 1;
1069 if (atomic_inc_and_test(&preop_panic_excl))
1070 panic(PFX "pre-timeout");
1071 }
1072
1073 return NOTIFY_STOP;
1074 }
1075
1076 static struct notifier_block ipmi_nmi_handler = {
1077 .notifier_call = ipmi_nmi
1078 };
1079 #endif
1080
1081 static int wdog_reboot_handler(struct notifier_block *this,
1082 unsigned long code,
1083 void *unused)
1084 {
1085 static int reboot_event_handled = 0;
1086
1087 if ((watchdog_user) && (!reboot_event_handled)) {
1088 /* Make sure we only do this once. */
1089 reboot_event_handled = 1;
1090
1091 if (code == SYS_POWER_OFF || code == SYS_HALT) {
1092 /* Disable the WDT if we are shutting down. */
1093 ipmi_watchdog_state = WDOG_TIMEOUT_NONE;
1094 panic_halt_ipmi_set_timeout();
1095 } else if (ipmi_watchdog_state != WDOG_TIMEOUT_NONE) {
1096 /* Set a long timer to let the reboot happens, but
1097 reboot if it hangs, but only if the watchdog
1098 timer was already running. */
1099 timeout = 120;
1100 pretimeout = 0;
1101 ipmi_watchdog_state = WDOG_TIMEOUT_RESET;
1102 panic_halt_ipmi_set_timeout();
1103 }
1104 }
1105 return NOTIFY_OK;
1106 }
1107
1108 static struct notifier_block wdog_reboot_notifier = {
1109 .notifier_call = wdog_reboot_handler,
1110 .next = NULL,
1111 .priority = 0
1112 };
1113
1114 static int wdog_panic_handler(struct notifier_block *this,
1115 unsigned long event,
1116 void *unused)
1117 {
1118 static int panic_event_handled = 0;
1119
1120 /* On a panic, if we have a panic timeout, make sure to extend
1121 the watchdog timer to a reasonable value to complete the
1122 panic, if the watchdog timer is running. Plus the
1123 pretimeout is meaningless at panic time. */
1124 if (watchdog_user && !panic_event_handled &&
1125 ipmi_watchdog_state != WDOG_TIMEOUT_NONE) {
1126 /* Make sure we do this only once. */
1127 panic_event_handled = 1;
1128
1129 timeout = 255;
1130 pretimeout = 0;
1131 panic_halt_ipmi_set_timeout();
1132 }
1133
1134 return NOTIFY_OK;
1135 }
1136
1137 static struct notifier_block wdog_panic_notifier = {
1138 .notifier_call = wdog_panic_handler,
1139 .next = NULL,
1140 .priority = 150 /* priority: INT_MAX >= x >= 0 */
1141 };
1142
1143
1144 static void ipmi_new_smi(int if_num, struct device *device)
1145 {
1146 ipmi_register_watchdog(if_num);
1147 }
1148
1149 static void ipmi_smi_gone(int if_num)
1150 {
1151 ipmi_unregister_watchdog(if_num);
1152 }
1153
1154 static struct ipmi_smi_watcher smi_watcher =
1155 {
1156 .owner = THIS_MODULE,
1157 .new_smi = ipmi_new_smi,
1158 .smi_gone = ipmi_smi_gone
1159 };
1160
1161 static int action_op(const char *inval, char *outval)
1162 {
1163 if (outval)
1164 strcpy(outval, action);
1165
1166 if (!inval)
1167 return 0;
1168
1169 if (strcmp(inval, "reset") == 0)
1170 action_val = WDOG_TIMEOUT_RESET;
1171 else if (strcmp(inval, "none") == 0)
1172 action_val = WDOG_TIMEOUT_NONE;
1173 else if (strcmp(inval, "power_cycle") == 0)
1174 action_val = WDOG_TIMEOUT_POWER_CYCLE;
1175 else if (strcmp(inval, "power_off") == 0)
1176 action_val = WDOG_TIMEOUT_POWER_DOWN;
1177 else
1178 return -EINVAL;
1179 strcpy(action, inval);
1180 return 0;
1181 }
1182
1183 static int preaction_op(const char *inval, char *outval)
1184 {
1185 if (outval)
1186 strcpy(outval, preaction);
1187
1188 if (!inval)
1189 return 0;
1190
1191 if (strcmp(inval, "pre_none") == 0)
1192 preaction_val = WDOG_PRETIMEOUT_NONE;
1193 else if (strcmp(inval, "pre_smi") == 0)
1194 preaction_val = WDOG_PRETIMEOUT_SMI;
1195 #ifdef HAVE_DIE_NMI
1196 else if (strcmp(inval, "pre_nmi") == 0)
1197 preaction_val = WDOG_PRETIMEOUT_NMI;
1198 #endif
1199 else if (strcmp(inval, "pre_int") == 0)
1200 preaction_val = WDOG_PRETIMEOUT_MSG_INT;
1201 else
1202 return -EINVAL;
1203 strcpy(preaction, inval);
1204 return 0;
1205 }
1206
1207 static int preop_op(const char *inval, char *outval)
1208 {
1209 if (outval)
1210 strcpy(outval, preop);
1211
1212 if (!inval)
1213 return 0;
1214
1215 if (strcmp(inval, "preop_none") == 0)
1216 preop_val = WDOG_PREOP_NONE;
1217 else if (strcmp(inval, "preop_panic") == 0)
1218 preop_val = WDOG_PREOP_PANIC;
1219 else if (strcmp(inval, "preop_give_data") == 0)
1220 preop_val = WDOG_PREOP_GIVE_DATA;
1221 else
1222 return -EINVAL;
1223 strcpy(preop, inval);
1224 return 0;
1225 }
1226
1227 static void check_parms(void)
1228 {
1229 #ifdef HAVE_DIE_NMI
1230 int do_nmi = 0;
1231 int rv;
1232
1233 if (preaction_val == WDOG_PRETIMEOUT_NMI) {
1234 do_nmi = 1;
1235 if (preop_val == WDOG_PREOP_GIVE_DATA) {
1236 printk(KERN_WARNING PFX "Pretimeout op is to give data"
1237 " but NMI pretimeout is enabled, setting"
1238 " pretimeout op to none\n");
1239 preop_op("preop_none", NULL);
1240 do_nmi = 0;
1241 }
1242 }
1243 if (do_nmi && !nmi_handler_registered) {
1244 rv = register_die_notifier(&ipmi_nmi_handler);
1245 if (rv) {
1246 printk(KERN_WARNING PFX
1247 "Can't register nmi handler\n");
1248 return;
1249 } else
1250 nmi_handler_registered = 1;
1251 } else if (!do_nmi && nmi_handler_registered) {
1252 unregister_die_notifier(&ipmi_nmi_handler);
1253 nmi_handler_registered = 0;
1254 }
1255 #endif
1256 }
1257
1258 static int __init ipmi_wdog_init(void)
1259 {
1260 int rv;
1261
1262 if (action_op(action, NULL)) {
1263 action_op("reset", NULL);
1264 printk(KERN_INFO PFX "Unknown action '%s', defaulting to"
1265 " reset\n", action);
1266 }
1267
1268 if (preaction_op(preaction, NULL)) {
1269 preaction_op("pre_none", NULL);
1270 printk(KERN_INFO PFX "Unknown preaction '%s', defaulting to"
1271 " none\n", preaction);
1272 }
1273
1274 if (preop_op(preop, NULL)) {
1275 preop_op("preop_none", NULL);
1276 printk(KERN_INFO PFX "Unknown preop '%s', defaulting to"
1277 " none\n", preop);
1278 }
1279
1280 check_parms();
1281
1282 register_reboot_notifier(&wdog_reboot_notifier);
1283 atomic_notifier_chain_register(&panic_notifier_list,
1284 &wdog_panic_notifier);
1285
1286 rv = ipmi_smi_watcher_register(&smi_watcher);
1287 if (rv) {
1288 #ifdef HAVE_DIE_NMI
1289 if (nmi_handler_registered)
1290 unregister_die_notifier(&ipmi_nmi_handler);
1291 #endif
1292 atomic_notifier_chain_unregister(&panic_notifier_list,
1293 &wdog_panic_notifier);
1294 unregister_reboot_notifier(&wdog_reboot_notifier);
1295 printk(KERN_WARNING PFX "can't register smi watcher\n");
1296 return rv;
1297 }
1298
1299 printk(KERN_INFO PFX "driver initialized\n");
1300
1301 return 0;
1302 }
1303
1304 static void __exit ipmi_wdog_exit(void)
1305 {
1306 ipmi_smi_watcher_unregister(&smi_watcher);
1307 ipmi_unregister_watchdog(watchdog_ifnum);
1308
1309 #ifdef HAVE_DIE_NMI
1310 if (nmi_handler_registered)
1311 unregister_die_notifier(&ipmi_nmi_handler);
1312 #endif
1313
1314 atomic_notifier_chain_unregister(&panic_notifier_list,
1315 &wdog_panic_notifier);
1316 unregister_reboot_notifier(&wdog_reboot_notifier);
1317 }
1318 module_exit(ipmi_wdog_exit);
1319 module_init(ipmi_wdog_init);
1320 MODULE_LICENSE("GPL");
1321 MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>");
1322 MODULE_DESCRIPTION("watchdog timer based upon the IPMI interface.");
1323
|
This page was automatically generated by the
LXR engine.
|