1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
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/mutex.h>
39#include <linux/watchdog.h>
40#include <linux/miscdevice.h>
41#include <linux/init.h>
42#include <linux/completion.h>
43#include <linux/kdebug.h>
44#include <linux/rwsem.h>
45#include <linux/errno.h>
46#include <asm/uaccess.h>
47#include <linux/notifier.h>
48#include <linux/nmi.h>
49#include <linux/reboot.h>
50#include <linux/wait.h>
51#include <linux/poll.h>
52#include <linux/string.h>
53#include <linux/ctype.h>
54#include <linux/delay.h>
55#include <linux/atomic.h>
56
57#ifdef CONFIG_X86
58
59
60
61
62
63
64
65
66
67#include <asm/kdebug.h>
68#include <asm/nmi.h>
69#define HAVE_DIE_NMI
70#endif
71
72#define PFX "IPMI Watchdog: "
73
74
75
76
77
78
79#define WDOG_DONT_LOG (1 << 7)
80#define WDOG_DONT_STOP_ON_SET (1 << 6)
81#define WDOG_SET_TIMER_USE(byte, use) \
82 byte = ((byte) & 0xf8) | ((use) & 0x7)
83#define WDOG_GET_TIMER_USE(byte) ((byte) & 0x7)
84#define WDOG_TIMER_USE_BIOS_FRB2 1
85#define WDOG_TIMER_USE_BIOS_POST 2
86#define WDOG_TIMER_USE_OS_LOAD 3
87#define WDOG_TIMER_USE_SMS_OS 4
88#define WDOG_TIMER_USE_OEM 5
89
90
91#define WDOG_SET_PRETIMEOUT_ACT(byte, use) \
92 byte = ((byte) & 0x8f) | (((use) & 0x7) << 4)
93#define WDOG_GET_PRETIMEOUT_ACT(byte) (((byte) >> 4) & 0x7)
94#define WDOG_PRETIMEOUT_NONE 0
95#define WDOG_PRETIMEOUT_SMI 1
96#define WDOG_PRETIMEOUT_NMI 2
97#define WDOG_PRETIMEOUT_MSG_INT 3
98
99
100#define WDOG_PREOP_NONE 0
101#define WDOG_PREOP_PANIC 1
102
103#define WDOG_PREOP_GIVE_DATA 2
104
105
106#define WDOG_SET_TIMEOUT_ACT(byte, use) \
107 byte = ((byte) & 0xf8) | ((use) & 0x7)
108#define WDOG_GET_TIMEOUT_ACT(byte) ((byte) & 0x7)
109#define WDOG_TIMEOUT_NONE 0
110#define WDOG_TIMEOUT_RESET 1
111#define WDOG_TIMEOUT_POWER_DOWN 2
112#define WDOG_TIMEOUT_POWER_CYCLE 3
113
114
115
116
117
118
119
120#define WDOG_EXPIRE_CLEAR_BIOS_FRB2 (1 << 1)
121#define WDOG_EXPIRE_CLEAR_BIOS_POST (1 << 2)
122#define WDOG_EXPIRE_CLEAR_OS_LOAD (1 << 3)
123#define WDOG_EXPIRE_CLEAR_SMS_OS (1 << 4)
124#define WDOG_EXPIRE_CLEAR_OEM (1 << 5)
125
126
127
128
129
130
131
132
133#define WDOG_SET_TIMEOUT(byte1, byte2, val) \
134 (byte1) = (((val) * 10) & 0xff), (byte2) = (((val) * 10) >> 8)
135#define WDOG_GET_TIMEOUT(byte1, byte2) \
136 (((byte1) | ((byte2) << 8)) / 10)
137
138#define IPMI_WDOG_RESET_TIMER 0x22
139#define IPMI_WDOG_SET_TIMER 0x24
140#define IPMI_WDOG_GET_TIMER 0x25
141
142#define IPMI_WDOG_TIMER_NOT_INIT_RESP 0x80
143
144static DEFINE_MUTEX(ipmi_watchdog_mutex);
145static bool nowayout = WATCHDOG_NOWAYOUT;
146
147static ipmi_user_t watchdog_user;
148static int watchdog_ifnum;
149
150
151static int timeout = 10;
152
153
154static int pretimeout;
155
156
157static int panic_wdt_timeout = 255;
158
159
160static unsigned char action_val = WDOG_TIMEOUT_RESET;
161
162static char action[16] = "reset";
163
164static unsigned char preaction_val = WDOG_PRETIMEOUT_NONE;
165
166static char preaction[16] = "pre_none";
167
168static unsigned char preop_val = WDOG_PREOP_NONE;
169
170static char preop[16] = "preop_none";
171static DEFINE_SPINLOCK(ipmi_read_lock);
172static char data_to_read;
173static DECLARE_WAIT_QUEUE_HEAD(read_q);
174static struct fasync_struct *fasync_q;
175static char pretimeout_since_last_heartbeat;
176static char expect_close;
177
178static int ifnum_to_use = -1;
179
180
181#define IPMI_SET_TIMEOUT_NO_HB 0
182#define IPMI_SET_TIMEOUT_HB_IF_NECESSARY 1
183#define IPMI_SET_TIMEOUT_FORCE_HB 2
184
185static int ipmi_set_timeout(int do_heartbeat);
186static void ipmi_register_watchdog(int ipmi_intf);
187static void ipmi_unregister_watchdog(int ipmi_intf);
188
189
190
191
192
193static int start_now;
194
195static int set_param_timeout(const char *val, const struct kernel_param *kp)
196{
197 char *endp;
198 int l;
199 int rv = 0;
200
201 if (!val)
202 return -EINVAL;
203 l = simple_strtoul(val, &endp, 0);
204 if (endp == val)
205 return -EINVAL;
206
207 *((int *)kp->arg) = l;
208 if (watchdog_user)
209 rv = ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY);
210
211 return rv;
212}
213
214static const struct kernel_param_ops param_ops_timeout = {
215 .set = set_param_timeout,
216 .get = param_get_int,
217};
218#define param_check_timeout param_check_int
219
220typedef int (*action_fn)(const char *intval, char *outval);
221
222static int action_op(const char *inval, char *outval);
223static int preaction_op(const char *inval, char *outval);
224static int preop_op(const char *inval, char *outval);
225static void check_parms(void);
226
227static int set_param_str(const char *val, const struct kernel_param *kp)
228{
229 action_fn fn = (action_fn) kp->arg;
230 int rv = 0;
231 char valcp[16];
232 char *s;
233
234 strncpy(valcp, val, 16);
235 valcp[15] = '\0';
236
237 s = strstrip(valcp);
238
239 rv = fn(s, NULL);
240 if (rv)
241 goto out;
242
243 check_parms();
244 if (watchdog_user)
245 rv = ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY);
246
247 out:
248 return rv;
249}
250
251static int get_param_str(char *buffer, const struct kernel_param *kp)
252{
253 action_fn fn = (action_fn) kp->arg;
254 int rv;
255
256 rv = fn(NULL, buffer);
257 if (rv)
258 return rv;
259 return strlen(buffer);
260}
261
262
263static int set_param_wdog_ifnum(const char *val, const struct kernel_param *kp)
264{
265 int rv = param_set_int(val, kp);
266 if (rv)
267 return rv;
268 if ((ifnum_to_use < 0) || (ifnum_to_use == watchdog_ifnum))
269 return 0;
270
271 ipmi_unregister_watchdog(watchdog_ifnum);
272 ipmi_register_watchdog(ifnum_to_use);
273 return 0;
274}
275
276static const struct kernel_param_ops param_ops_wdog_ifnum = {
277 .set = set_param_wdog_ifnum,
278 .get = param_get_int,
279};
280
281#define param_check_wdog_ifnum param_check_int
282
283static const struct kernel_param_ops param_ops_str = {
284 .set = set_param_str,
285 .get = get_param_str,
286};
287
288module_param(ifnum_to_use, wdog_ifnum, 0644);
289MODULE_PARM_DESC(ifnum_to_use, "The interface number to use for the watchdog "
290 "timer. Setting to -1 defaults to the first registered "
291 "interface");
292
293module_param(timeout, timeout, 0644);
294MODULE_PARM_DESC(timeout, "Timeout value in seconds.");
295
296module_param(pretimeout, timeout, 0644);
297MODULE_PARM_DESC(pretimeout, "Pretimeout value in seconds.");
298
299module_param(panic_wdt_timeout, timeout, 0644);
300MODULE_PARM_DESC(timeout, "Timeout value on kernel panic in seconds.");
301
302module_param_cb(action, ¶m_ops_str, action_op, 0644);
303MODULE_PARM_DESC(action, "Timeout action. One of: "
304 "reset, none, power_cycle, power_off.");
305
306module_param_cb(preaction, ¶m_ops_str, preaction_op, 0644);
307MODULE_PARM_DESC(preaction, "Pretimeout action. One of: "
308 "pre_none, pre_smi, pre_nmi, pre_int.");
309
310module_param_cb(preop, ¶m_ops_str, preop_op, 0644);
311MODULE_PARM_DESC(preop, "Pretimeout driver operation. One of: "
312 "preop_none, preop_panic, preop_give_data.");
313
314module_param(start_now, int, 0444);
315MODULE_PARM_DESC(start_now, "Set to 1 to start the watchdog as"
316 "soon as the driver is loaded.");
317
318module_param(nowayout, bool, 0644);
319MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started "
320 "(default=CONFIG_WATCHDOG_NOWAYOUT)");
321
322
323static unsigned char ipmi_watchdog_state = WDOG_TIMEOUT_NONE;
324
325
326static int ipmi_ignore_heartbeat;
327
328
329static unsigned long ipmi_wdog_open;
330
331
332
333
334
335
336
337static int ipmi_start_timer_on_heartbeat;
338
339
340static unsigned char ipmi_version_major;
341static unsigned char ipmi_version_minor;
342
343
344static atomic_t preop_panic_excl = ATOMIC_INIT(-1);
345
346#ifdef HAVE_DIE_NMI
347static int testing_nmi;
348static int nmi_handler_registered;
349#endif
350
351static int ipmi_heartbeat(void);
352
353
354
355
356
357
358
359static atomic_t set_timeout_tofree = ATOMIC_INIT(0);
360static DEFINE_MUTEX(set_timeout_lock);
361static DECLARE_COMPLETION(set_timeout_wait);
362static void set_timeout_free_smi(struct ipmi_smi_msg *msg)
363{
364 if (atomic_dec_and_test(&set_timeout_tofree))
365 complete(&set_timeout_wait);
366}
367static void set_timeout_free_recv(struct ipmi_recv_msg *msg)
368{
369 if (atomic_dec_and_test(&set_timeout_tofree))
370 complete(&set_timeout_wait);
371}
372static struct ipmi_smi_msg set_timeout_smi_msg = {
373 .done = set_timeout_free_smi
374};
375static struct ipmi_recv_msg set_timeout_recv_msg = {
376 .done = set_timeout_free_recv
377};
378
379static int i_ipmi_set_timeout(struct ipmi_smi_msg *smi_msg,
380 struct ipmi_recv_msg *recv_msg,
381 int *send_heartbeat_now)
382{
383 struct kernel_ipmi_msg msg;
384 unsigned char data[6];
385 int rv;
386 struct ipmi_system_interface_addr addr;
387 int hbnow = 0;
388
389
390
391 pretimeout_since_last_heartbeat = 0;
392
393 data[0] = 0;
394 WDOG_SET_TIMER_USE(data[0], WDOG_TIMER_USE_SMS_OS);
395
396 if ((ipmi_version_major > 1)
397 || ((ipmi_version_major == 1) && (ipmi_version_minor >= 5))) {
398
399 data[0] |= WDOG_DONT_STOP_ON_SET;
400 } else if (ipmi_watchdog_state != WDOG_TIMEOUT_NONE) {
401
402
403
404
405 hbnow = 1;
406 }
407
408 data[1] = 0;
409 WDOG_SET_TIMEOUT_ACT(data[1], ipmi_watchdog_state);
410 if ((pretimeout > 0) && (ipmi_watchdog_state != WDOG_TIMEOUT_NONE)) {
411 WDOG_SET_PRETIMEOUT_ACT(data[1], preaction_val);
412 data[2] = pretimeout;
413 } else {
414 WDOG_SET_PRETIMEOUT_ACT(data[1], WDOG_PRETIMEOUT_NONE);
415 data[2] = 0;
416 }
417 data[3] = 0;
418 WDOG_SET_TIMEOUT(data[4], data[5], timeout);
419
420 addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
421 addr.channel = IPMI_BMC_CHANNEL;
422 addr.lun = 0;
423
424 msg.netfn = 0x06;
425 msg.cmd = IPMI_WDOG_SET_TIMER;
426 msg.data = data;
427 msg.data_len = sizeof(data);
428 rv = ipmi_request_supply_msgs(watchdog_user,
429 (struct ipmi_addr *) &addr,
430 0,
431 &msg,
432 NULL,
433 smi_msg,
434 recv_msg,
435 1);
436 if (rv) {
437 printk(KERN_WARNING PFX "set timeout error: %d\n",
438 rv);
439 }
440
441 if (send_heartbeat_now)
442 *send_heartbeat_now = hbnow;
443
444 return rv;
445}
446
447static int ipmi_set_timeout(int do_heartbeat)
448{
449 int send_heartbeat_now;
450 int rv;
451
452
453
454 mutex_lock(&set_timeout_lock);
455
456 atomic_set(&set_timeout_tofree, 2);
457
458 rv = i_ipmi_set_timeout(&set_timeout_smi_msg,
459 &set_timeout_recv_msg,
460 &send_heartbeat_now);
461 if (rv) {
462 mutex_unlock(&set_timeout_lock);
463 goto out;
464 }
465
466 wait_for_completion(&set_timeout_wait);
467
468 mutex_unlock(&set_timeout_lock);
469
470 if ((do_heartbeat == IPMI_SET_TIMEOUT_FORCE_HB)
471 || ((send_heartbeat_now)
472 && (do_heartbeat == IPMI_SET_TIMEOUT_HB_IF_NECESSARY)))
473 rv = ipmi_heartbeat();
474
475out:
476 return rv;
477}
478
479static atomic_t panic_done_count = ATOMIC_INIT(0);
480
481static void panic_smi_free(struct ipmi_smi_msg *msg)
482{
483 atomic_dec(&panic_done_count);
484}
485static void panic_recv_free(struct ipmi_recv_msg *msg)
486{
487 atomic_dec(&panic_done_count);
488}
489
490static struct ipmi_smi_msg panic_halt_heartbeat_smi_msg = {
491 .done = panic_smi_free
492};
493static struct ipmi_recv_msg panic_halt_heartbeat_recv_msg = {
494 .done = panic_recv_free
495};
496
497static void panic_halt_ipmi_heartbeat(void)
498{
499 struct kernel_ipmi_msg msg;
500 struct ipmi_system_interface_addr addr;
501 int rv;
502
503
504
505
506
507 if (ipmi_watchdog_state == WDOG_TIMEOUT_NONE)
508 return;
509
510 addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
511 addr.channel = IPMI_BMC_CHANNEL;
512 addr.lun = 0;
513
514 msg.netfn = 0x06;
515 msg.cmd = IPMI_WDOG_RESET_TIMER;
516 msg.data = NULL;
517 msg.data_len = 0;
518 atomic_add(2, &panic_done_count);
519 rv = ipmi_request_supply_msgs(watchdog_user,
520 (struct ipmi_addr *) &addr,
521 0,
522 &msg,
523 NULL,
524 &panic_halt_heartbeat_smi_msg,
525 &panic_halt_heartbeat_recv_msg,
526 1);
527 if (rv)
528 atomic_sub(2, &panic_done_count);
529}
530
531static struct ipmi_smi_msg panic_halt_smi_msg = {
532 .done = panic_smi_free
533};
534static struct ipmi_recv_msg panic_halt_recv_msg = {
535 .done = panic_recv_free
536};
537
538
539
540
541
542
543
544static void panic_halt_ipmi_set_timeout(void)
545{
546 int send_heartbeat_now;
547 int rv;
548
549
550 while (atomic_read(&panic_done_count) != 0)
551 ipmi_poll_interface(watchdog_user);
552 atomic_add(2, &panic_done_count);
553 rv = i_ipmi_set_timeout(&panic_halt_smi_msg,
554 &panic_halt_recv_msg,
555 &send_heartbeat_now);
556 if (rv) {
557 atomic_sub(2, &panic_done_count);
558 printk(KERN_WARNING PFX
559 "Unable to extend the watchdog timeout.");
560 } else {
561 if (send_heartbeat_now)
562 panic_halt_ipmi_heartbeat();
563 }
564 while (atomic_read(&panic_done_count) != 0)
565 ipmi_poll_interface(watchdog_user);
566}
567
568
569
570
571
572
573
574static atomic_t heartbeat_tofree = ATOMIC_INIT(0);
575static DEFINE_MUTEX(heartbeat_lock);
576static DECLARE_COMPLETION(heartbeat_wait);
577static void heartbeat_free_smi(struct ipmi_smi_msg *msg)
578{
579 if (atomic_dec_and_test(&heartbeat_tofree))
580 complete(&heartbeat_wait);
581}
582static void heartbeat_free_recv(struct ipmi_recv_msg *msg)
583{
584 if (atomic_dec_and_test(&heartbeat_tofree))
585 complete(&heartbeat_wait);
586}
587static struct ipmi_smi_msg heartbeat_smi_msg = {
588 .done = heartbeat_free_smi
589};
590static struct ipmi_recv_msg heartbeat_recv_msg = {
591 .done = heartbeat_free_recv
592};
593
594static int ipmi_heartbeat(void)
595{
596 struct kernel_ipmi_msg msg;
597 int rv;
598 struct ipmi_system_interface_addr addr;
599 int timeout_retries = 0;
600
601 if (ipmi_ignore_heartbeat)
602 return 0;
603
604 if (ipmi_start_timer_on_heartbeat) {
605 ipmi_start_timer_on_heartbeat = 0;
606 ipmi_watchdog_state = action_val;
607 return ipmi_set_timeout(IPMI_SET_TIMEOUT_FORCE_HB);
608 } else if (pretimeout_since_last_heartbeat) {
609
610
611
612
613
614
615 return ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY);
616 }
617
618 mutex_lock(&heartbeat_lock);
619
620restart:
621 atomic_set(&heartbeat_tofree, 2);
622
623
624
625
626
627 if (ipmi_watchdog_state == WDOG_TIMEOUT_NONE) {
628 mutex_unlock(&heartbeat_lock);
629 return 0;
630 }
631
632 addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
633 addr.channel = IPMI_BMC_CHANNEL;
634 addr.lun = 0;
635
636 msg.netfn = 0x06;
637 msg.cmd = IPMI_WDOG_RESET_TIMER;
638 msg.data = NULL;
639 msg.data_len = 0;
640 rv = ipmi_request_supply_msgs(watchdog_user,
641 (struct ipmi_addr *) &addr,
642 0,
643 &msg,
644 NULL,
645 &heartbeat_smi_msg,
646 &heartbeat_recv_msg,
647 1);
648 if (rv) {
649 mutex_unlock(&heartbeat_lock);
650 printk(KERN_WARNING PFX "heartbeat failure: %d\n",
651 rv);
652 return rv;
653 }
654
655
656 wait_for_completion(&heartbeat_wait);
657
658 if (heartbeat_recv_msg.msg.data[0] == IPMI_WDOG_TIMER_NOT_INIT_RESP) {
659 timeout_retries++;
660 if (timeout_retries > 3) {
661 printk(KERN_ERR PFX ": Unable to restore the IPMI"
662 " watchdog's settings, giving up.\n");
663 rv = -EIO;
664 goto out_unlock;
665 }
666
667
668
669
670
671
672
673
674
675 rv = ipmi_set_timeout(IPMI_SET_TIMEOUT_NO_HB);
676 if (rv) {
677 printk(KERN_ERR PFX ": Unable to send the command to"
678 " set the watchdog's settings, giving up.\n");
679 goto out_unlock;
680 }
681
682
683 goto restart;
684 } else if (heartbeat_recv_msg.msg.data[0] != 0) {
685
686
687
688
689
690 rv = -EINVAL;
691 }
692
693out_unlock:
694 mutex_unlock(&heartbeat_lock);
695
696 return rv;
697}
698
699static struct watchdog_info ident = {
700 .options = 0,
701 .firmware_version = 1,
702 .identity = "IPMI"
703};
704
705static int ipmi_ioctl(struct file *file,
706 unsigned int cmd, unsigned long arg)
707{
708 void __user *argp = (void __user *)arg;
709 int i;
710 int val;
711
712 switch (cmd) {
713 case WDIOC_GETSUPPORT:
714 i = copy_to_user(argp, &ident, sizeof(ident));
715 return i ? -EFAULT : 0;
716
717 case WDIOC_SETTIMEOUT:
718 i = copy_from_user(&val, argp, sizeof(int));
719 if (i)
720 return -EFAULT;
721 timeout = val;
722 return ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY);
723
724 case WDIOC_GETTIMEOUT:
725 i = copy_to_user(argp, &timeout, sizeof(timeout));
726 if (i)
727 return -EFAULT;
728 return 0;
729
730 case WDIOC_SETPRETIMEOUT:
731 i = copy_from_user(&val, argp, sizeof(int));
732 if (i)
733 return -EFAULT;
734 pretimeout = val;
735 return ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY);
736
737 case WDIOC_GETPRETIMEOUT:
738 i = copy_to_user(argp, &pretimeout, sizeof(pretimeout));
739 if (i)
740 return -EFAULT;
741 return 0;
742
743 case WDIOC_KEEPALIVE:
744 return ipmi_heartbeat();
745
746 case WDIOC_SETOPTIONS:
747 i = copy_from_user(&val, argp, sizeof(int));
748 if (i)
749 return -EFAULT;
750 if (val & WDIOS_DISABLECARD) {
751 ipmi_watchdog_state = WDOG_TIMEOUT_NONE;
752 ipmi_set_timeout(IPMI_SET_TIMEOUT_NO_HB);
753 ipmi_start_timer_on_heartbeat = 0;
754 }
755
756 if (val & WDIOS_ENABLECARD) {
757 ipmi_watchdog_state = action_val;
758 ipmi_set_timeout(IPMI_SET_TIMEOUT_FORCE_HB);
759 }
760 return 0;
761
762 case WDIOC_GETSTATUS:
763 val = 0;
764 i = copy_to_user(argp, &val, sizeof(val));
765 if (i)
766 return -EFAULT;
767 return 0;
768
769 default:
770 return -ENOIOCTLCMD;
771 }
772}
773
774static long ipmi_unlocked_ioctl(struct file *file,
775 unsigned int cmd,
776 unsigned long arg)
777{
778 int ret;
779
780 mutex_lock(&ipmi_watchdog_mutex);
781 ret = ipmi_ioctl(file, cmd, arg);
782 mutex_unlock(&ipmi_watchdog_mutex);
783
784 return ret;
785}
786
787static ssize_t ipmi_write(struct file *file,
788 const char __user *buf,
789 size_t len,
790 loff_t *ppos)
791{
792 int rv;
793
794 if (len) {
795 if (!nowayout) {
796 size_t i;
797
798
799 expect_close = 0;
800
801 for (i = 0; i != len; i++) {
802 char c;
803
804 if (get_user(c, buf + i))
805 return -EFAULT;
806 if (c == 'V')
807 expect_close = 42;
808 }
809 }
810 rv = ipmi_heartbeat();
811 if (rv)
812 return rv;
813 }
814 return len;
815}
816
817static ssize_t ipmi_read(struct file *file,
818 char __user *buf,
819 size_t count,
820 loff_t *ppos)
821{
822 int rv = 0;
823 wait_queue_t wait;
824
825 if (count <= 0)
826 return 0;
827
828
829
830
831
832 spin_lock(&ipmi_read_lock);
833 if (!data_to_read) {
834 if (file->f_flags & O_NONBLOCK) {
835 rv = -EAGAIN;
836 goto out;
837 }
838
839 init_waitqueue_entry(&wait, current);
840 add_wait_queue(&read_q, &wait);
841 while (!data_to_read) {
842 set_current_state(TASK_INTERRUPTIBLE);
843 spin_unlock(&ipmi_read_lock);
844 schedule();
845 spin_lock(&ipmi_read_lock);
846 }
847 remove_wait_queue(&read_q, &wait);
848
849 if (signal_pending(current)) {
850 rv = -ERESTARTSYS;
851 goto out;
852 }
853 }
854 data_to_read = 0;
855
856 out:
857 spin_unlock(&ipmi_read_lock);
858
859 if (rv == 0) {
860 if (copy_to_user(buf, &data_to_read, 1))
861 rv = -EFAULT;
862 else
863 rv = 1;
864 }
865
866 return rv;
867}
868
869static int ipmi_open(struct inode *ino, struct file *filep)
870{
871 switch (iminor(ino)) {
872 case WATCHDOG_MINOR:
873 if (test_and_set_bit(0, &ipmi_wdog_open))
874 return -EBUSY;
875
876
877
878
879
880
881 ipmi_start_timer_on_heartbeat = 1;
882 return nonseekable_open(ino, filep);
883
884 default:
885 return (-ENODEV);
886 }
887}
888
889static unsigned int ipmi_poll(struct file *file, poll_table *wait)
890{
891 unsigned int mask = 0;
892
893 poll_wait(file, &read_q, wait);
894
895 spin_lock(&ipmi_read_lock);
896 if (data_to_read)
897 mask |= (POLLIN | POLLRDNORM);
898 spin_unlock(&ipmi_read_lock);
899
900 return mask;
901}
902
903static int ipmi_fasync(int fd, struct file *file, int on)
904{
905 int result;
906
907 result = fasync_helper(fd, file, on, &fasync_q);
908
909 return (result);
910}
911
912static int ipmi_close(struct inode *ino, struct file *filep)
913{
914 if (iminor(ino) == WATCHDOG_MINOR) {
915 if (expect_close == 42) {
916 ipmi_watchdog_state = WDOG_TIMEOUT_NONE;
917 ipmi_set_timeout(IPMI_SET_TIMEOUT_NO_HB);
918 } else {
919 printk(KERN_CRIT PFX
920 "Unexpected close, not stopping watchdog!\n");
921 ipmi_heartbeat();
922 }
923 clear_bit(0, &ipmi_wdog_open);
924 }
925
926 expect_close = 0;
927
928 return 0;
929}
930
931static const struct file_operations ipmi_wdog_fops = {
932 .owner = THIS_MODULE,
933 .read = ipmi_read,
934 .poll = ipmi_poll,
935 .write = ipmi_write,
936 .unlocked_ioctl = ipmi_unlocked_ioctl,
937 .open = ipmi_open,
938 .release = ipmi_close,
939 .fasync = ipmi_fasync,
940 .llseek = no_llseek,
941};
942
943static struct miscdevice ipmi_wdog_miscdev = {
944 .minor = WATCHDOG_MINOR,
945 .name = "watchdog",
946 .fops = &ipmi_wdog_fops
947};
948
949static void ipmi_wdog_msg_handler(struct ipmi_recv_msg *msg,
950 void *handler_data)
951{
952 if (msg->msg.cmd == IPMI_WDOG_RESET_TIMER &&
953 msg->msg.data[0] == IPMI_WDOG_TIMER_NOT_INIT_RESP)
954 printk(KERN_INFO PFX "response: The IPMI controller appears"
955 " to have been reset, will attempt to reinitialize"
956 " the watchdog timer\n");
957 else if (msg->msg.data[0] != 0)
958 printk(KERN_ERR PFX "response: Error %x on cmd %x\n",
959 msg->msg.data[0],
960 msg->msg.cmd);
961
962 ipmi_free_recv_msg(msg);
963}
964
965static void ipmi_wdog_pretimeout_handler(void *handler_data)
966{
967 if (preaction_val != WDOG_PRETIMEOUT_NONE) {
968 if (preop_val == WDOG_PREOP_PANIC) {
969 if (atomic_inc_and_test(&preop_panic_excl))
970 panic("Watchdog pre-timeout");
971 } else if (preop_val == WDOG_PREOP_GIVE_DATA) {
972 spin_lock(&ipmi_read_lock);
973 data_to_read = 1;
974 wake_up_interruptible(&read_q);
975 kill_fasync(&fasync_q, SIGIO, POLL_IN);
976
977 spin_unlock(&ipmi_read_lock);
978 }
979 }
980
981
982
983
984
985 pretimeout_since_last_heartbeat = 1;
986}
987
988static struct ipmi_user_hndl ipmi_hndlrs = {
989 .ipmi_recv_hndl = ipmi_wdog_msg_handler,
990 .ipmi_watchdog_pretimeout = ipmi_wdog_pretimeout_handler
991};
992
993static void ipmi_register_watchdog(int ipmi_intf)
994{
995 int rv = -EBUSY;
996
997 if (watchdog_user)
998 goto out;
999
1000 if ((ifnum_to_use >= 0) && (ifnum_to_use != ipmi_intf))
1001 goto out;
1002
1003 watchdog_ifnum = ipmi_intf;
1004
1005 rv = ipmi_create_user(ipmi_intf, &ipmi_hndlrs, NULL, &watchdog_user);
1006 if (rv < 0) {
1007 printk(KERN_CRIT PFX "Unable to register with ipmi\n");
1008 goto out;
1009 }
1010
1011 ipmi_get_version(watchdog_user,
1012 &ipmi_version_major,
1013 &ipmi_version_minor);
1014
1015 rv = misc_register(&ipmi_wdog_miscdev);
1016 if (rv < 0) {
1017 ipmi_destroy_user(watchdog_user);
1018 watchdog_user = NULL;
1019 printk(KERN_CRIT PFX "Unable to register misc device\n");
1020 }
1021
1022#ifdef HAVE_DIE_NMI
1023 if (nmi_handler_registered) {
1024 int old_pretimeout = pretimeout;
1025 int old_timeout = timeout;
1026 int old_preop_val = preop_val;
1027
1028
1029
1030
1031
1032 ipmi_watchdog_state = WDOG_TIMEOUT_RESET;
1033 preop_val = WDOG_PREOP_NONE;
1034 pretimeout = 99;
1035 timeout = 100;
1036
1037 testing_nmi = 1;
1038
1039 rv = ipmi_set_timeout(IPMI_SET_TIMEOUT_FORCE_HB);
1040 if (rv) {
1041 printk(KERN_WARNING PFX "Error starting timer to"
1042 " test NMI: 0x%x. The NMI pretimeout will"
1043 " likely not work\n", rv);
1044 rv = 0;
1045 goto out_restore;
1046 }
1047
1048 msleep(1500);
1049
1050 if (testing_nmi != 2) {
1051 printk(KERN_WARNING PFX "IPMI NMI didn't seem to"
1052 " occur. The NMI pretimeout will"
1053 " likely not work\n");
1054 }
1055 out_restore:
1056 testing_nmi = 0;
1057 preop_val = old_preop_val;
1058 pretimeout = old_pretimeout;
1059 timeout = old_timeout;
1060 }
1061#endif
1062
1063 out:
1064 if ((start_now) && (rv == 0)) {
1065
1066 start_now = 0;
1067 ipmi_watchdog_state = action_val;
1068 ipmi_set_timeout(IPMI_SET_TIMEOUT_FORCE_HB);
1069 printk(KERN_INFO PFX "Starting now!\n");
1070 } else {
1071
1072 ipmi_watchdog_state = WDOG_TIMEOUT_NONE;
1073 ipmi_set_timeout(IPMI_SET_TIMEOUT_NO_HB);
1074 }
1075}
1076
1077static void ipmi_unregister_watchdog(int ipmi_intf)
1078{
1079 int rv;
1080
1081 if (!watchdog_user)
1082 goto out;
1083
1084 if (watchdog_ifnum != ipmi_intf)
1085 goto out;
1086
1087
1088 misc_deregister(&ipmi_wdog_miscdev);
1089
1090
1091
1092
1093
1094
1095 while (atomic_read(&set_timeout_tofree))
1096 schedule_timeout_uninterruptible(1);
1097
1098
1099 rv = ipmi_destroy_user(watchdog_user);
1100 if (rv) {
1101 printk(KERN_WARNING PFX "error unlinking from IPMI: %d\n",
1102 rv);
1103 }
1104 watchdog_user = NULL;
1105
1106 out:
1107 return;
1108}
1109
1110#ifdef HAVE_DIE_NMI
1111static int
1112ipmi_nmi(unsigned int val, struct pt_regs *regs)
1113{
1114
1115
1116
1117
1118
1119
1120
1121 if (testing_nmi) {
1122 testing_nmi = 2;
1123 return NMI_HANDLED;
1124 }
1125
1126
1127 if (ipmi_watchdog_state == WDOG_TIMEOUT_NONE)
1128 return NMI_DONE;
1129
1130 if (preaction_val != WDOG_PRETIMEOUT_NMI)
1131 return NMI_DONE;
1132
1133
1134
1135
1136
1137 if (preop_val == WDOG_PREOP_PANIC) {
1138
1139
1140
1141 pretimeout_since_last_heartbeat = 1;
1142 if (atomic_inc_and_test(&preop_panic_excl))
1143 nmi_panic(regs, PFX "pre-timeout");
1144 }
1145
1146 return NMI_HANDLED;
1147}
1148#endif
1149
1150static int wdog_reboot_handler(struct notifier_block *this,
1151 unsigned long code,
1152 void *unused)
1153{
1154 static int reboot_event_handled;
1155
1156 if ((watchdog_user) && (!reboot_event_handled)) {
1157
1158 reboot_event_handled = 1;
1159
1160 if (code == SYS_POWER_OFF || code == SYS_HALT) {
1161
1162 ipmi_watchdog_state = WDOG_TIMEOUT_NONE;
1163 ipmi_set_timeout(IPMI_SET_TIMEOUT_NO_HB);
1164 } else if (ipmi_watchdog_state != WDOG_TIMEOUT_NONE) {
1165
1166
1167
1168 timeout = 120;
1169 pretimeout = 0;
1170 ipmi_watchdog_state = WDOG_TIMEOUT_RESET;
1171 ipmi_set_timeout(IPMI_SET_TIMEOUT_NO_HB);
1172 }
1173 }
1174 return NOTIFY_OK;
1175}
1176
1177static struct notifier_block wdog_reboot_notifier = {
1178 .notifier_call = wdog_reboot_handler,
1179 .next = NULL,
1180 .priority = 0
1181};
1182
1183static int wdog_panic_handler(struct notifier_block *this,
1184 unsigned long event,
1185 void *unused)
1186{
1187 static int panic_event_handled;
1188
1189
1190
1191
1192
1193 if (watchdog_user && !panic_event_handled &&
1194 ipmi_watchdog_state != WDOG_TIMEOUT_NONE) {
1195
1196 panic_event_handled = 1;
1197
1198 timeout = panic_wdt_timeout;
1199 pretimeout = 0;
1200 panic_halt_ipmi_set_timeout();
1201 }
1202
1203 return NOTIFY_OK;
1204}
1205
1206static struct notifier_block wdog_panic_notifier = {
1207 .notifier_call = wdog_panic_handler,
1208 .next = NULL,
1209 .priority = 150
1210};
1211
1212
1213static void ipmi_new_smi(int if_num, struct device *device)
1214{
1215 ipmi_register_watchdog(if_num);
1216}
1217
1218static void ipmi_smi_gone(int if_num)
1219{
1220 ipmi_unregister_watchdog(if_num);
1221}
1222
1223static struct ipmi_smi_watcher smi_watcher = {
1224 .owner = THIS_MODULE,
1225 .new_smi = ipmi_new_smi,
1226 .smi_gone = ipmi_smi_gone
1227};
1228
1229static int action_op(const char *inval, char *outval)
1230{
1231 if (outval)
1232 strcpy(outval, action);
1233
1234 if (!inval)
1235 return 0;
1236
1237 if (strcmp(inval, "reset") == 0)
1238 action_val = WDOG_TIMEOUT_RESET;
1239 else if (strcmp(inval, "none") == 0)
1240 action_val = WDOG_TIMEOUT_NONE;
1241 else if (strcmp(inval, "power_cycle") == 0)
1242 action_val = WDOG_TIMEOUT_POWER_CYCLE;
1243 else if (strcmp(inval, "power_off") == 0)
1244 action_val = WDOG_TIMEOUT_POWER_DOWN;
1245 else
1246 return -EINVAL;
1247 strcpy(action, inval);
1248 return 0;
1249}
1250
1251static int preaction_op(const char *inval, char *outval)
1252{
1253 if (outval)
1254 strcpy(outval, preaction);
1255
1256 if (!inval)
1257 return 0;
1258
1259 if (strcmp(inval, "pre_none") == 0)
1260 preaction_val = WDOG_PRETIMEOUT_NONE;
1261 else if (strcmp(inval, "pre_smi") == 0)
1262 preaction_val = WDOG_PRETIMEOUT_SMI;
1263#ifdef HAVE_DIE_NMI
1264 else if (strcmp(inval, "pre_nmi") == 0)
1265 preaction_val = WDOG_PRETIMEOUT_NMI;
1266#endif
1267 else if (strcmp(inval, "pre_int") == 0)
1268 preaction_val = WDOG_PRETIMEOUT_MSG_INT;
1269 else
1270 return -EINVAL;
1271 strcpy(preaction, inval);
1272 return 0;
1273}
1274
1275static int preop_op(const char *inval, char *outval)
1276{
1277 if (outval)
1278 strcpy(outval, preop);
1279
1280 if (!inval)
1281 return 0;
1282
1283 if (strcmp(inval, "preop_none") == 0)
1284 preop_val = WDOG_PREOP_NONE;
1285 else if (strcmp(inval, "preop_panic") == 0)
1286 preop_val = WDOG_PREOP_PANIC;
1287 else if (strcmp(inval, "preop_give_data") == 0)
1288 preop_val = WDOG_PREOP_GIVE_DATA;
1289 else
1290 return -EINVAL;
1291 strcpy(preop, inval);
1292 return 0;
1293}
1294
1295static void check_parms(void)
1296{
1297#ifdef HAVE_DIE_NMI
1298 int do_nmi = 0;
1299 int rv;
1300
1301 if (preaction_val == WDOG_PRETIMEOUT_NMI) {
1302 do_nmi = 1;
1303 if (preop_val == WDOG_PREOP_GIVE_DATA) {
1304 printk(KERN_WARNING PFX "Pretimeout op is to give data"
1305 " but NMI pretimeout is enabled, setting"
1306 " pretimeout op to none\n");
1307 preop_op("preop_none", NULL);
1308 do_nmi = 0;
1309 }
1310 }
1311 if (do_nmi && !nmi_handler_registered) {
1312 rv = register_nmi_handler(NMI_UNKNOWN, ipmi_nmi, 0,
1313 "ipmi");
1314 if (rv) {
1315 printk(KERN_WARNING PFX
1316 "Can't register nmi handler\n");
1317 return;
1318 } else
1319 nmi_handler_registered = 1;
1320 } else if (!do_nmi && nmi_handler_registered) {
1321 unregister_nmi_handler(NMI_UNKNOWN, "ipmi");
1322 nmi_handler_registered = 0;
1323 }
1324#endif
1325}
1326
1327static int __init ipmi_wdog_init(void)
1328{
1329 int rv;
1330
1331 if (action_op(action, NULL)) {
1332 action_op("reset", NULL);
1333 printk(KERN_INFO PFX "Unknown action '%s', defaulting to"
1334 " reset\n", action);
1335 }
1336
1337 if (preaction_op(preaction, NULL)) {
1338 preaction_op("pre_none", NULL);
1339 printk(KERN_INFO PFX "Unknown preaction '%s', defaulting to"
1340 " none\n", preaction);
1341 }
1342
1343 if (preop_op(preop, NULL)) {
1344 preop_op("preop_none", NULL);
1345 printk(KERN_INFO PFX "Unknown preop '%s', defaulting to"
1346 " none\n", preop);
1347 }
1348
1349 check_parms();
1350
1351 register_reboot_notifier(&wdog_reboot_notifier);
1352 atomic_notifier_chain_register(&panic_notifier_list,
1353 &wdog_panic_notifier);
1354
1355 rv = ipmi_smi_watcher_register(&smi_watcher);
1356 if (rv) {
1357#ifdef HAVE_DIE_NMI
1358 if (nmi_handler_registered)
1359 unregister_nmi_handler(NMI_UNKNOWN, "ipmi");
1360#endif
1361 atomic_notifier_chain_unregister(&panic_notifier_list,
1362 &wdog_panic_notifier);
1363 unregister_reboot_notifier(&wdog_reboot_notifier);
1364 printk(KERN_WARNING PFX "can't register smi watcher\n");
1365 return rv;
1366 }
1367
1368 printk(KERN_INFO PFX "driver initialized\n");
1369
1370 return 0;
1371}
1372
1373static void __exit ipmi_wdog_exit(void)
1374{
1375 ipmi_smi_watcher_unregister(&smi_watcher);
1376 ipmi_unregister_watchdog(watchdog_ifnum);
1377
1378#ifdef HAVE_DIE_NMI
1379 if (nmi_handler_registered)
1380 unregister_nmi_handler(NMI_UNKNOWN, "ipmi");
1381#endif
1382
1383 atomic_notifier_chain_unregister(&panic_notifier_list,
1384 &wdog_panic_notifier);
1385 unregister_reboot_notifier(&wdog_reboot_notifier);
1386}
1387module_exit(ipmi_wdog_exit);
1388module_init(ipmi_wdog_init);
1389MODULE_LICENSE("GPL");
1390MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>");
1391MODULE_DESCRIPTION("watchdog timer based upon the IPMI interface.");
1392