projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/roland...
[deliverable/linux.git] / drivers / char / ipmi / ipmi_watchdog.c
CommitLineData
1da177e4
LT		 1/*
2 * ipmi_watchdog.c
3 *
4 * A watchdog timer based upon the IPMI interface.
5 *
6 * Author: MontaVista Software, Inc.
7 * Corey Minyard <minyard@mvista.com>
8 * source@mvista.com
9 *
10 * Copyright 2002 MontaVista Software Inc.
11 *
12 * This program is free software; you can redistribute it and/or modify it
13 * under the terms of the GNU General Public License as published by the
14 * Free Software Foundation; either version 2 of the License, or (at your
15 * option) any later version.
16 *
17 *
18 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
19 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
20 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
23 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
24 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
25 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
26 * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
27 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 *
29 * You should have received a copy of the GNU General Public License along
30 * with this program; if not, write to the Free Software Foundation, Inc.,
31 * 675 Mass Ave, Cambridge, MA 02139, USA.
32 */
33
1da177e4
LT		 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>
d6dfd131 41#include <linux/completion.h>
1eeb66a1 42#include <linux/kdebug.h>
1da177e4
LT		 43#include <linux/rwsem.h>
44#include <linux/errno.h>
45#include <asm/uaccess.h>
46#include <linux/notifier.h>
47#include <linux/nmi.h>
48#include <linux/reboot.h>
49#include <linux/wait.h>
50#include <linux/poll.h>
cc4673ee
CM		 51#include <linux/string.h>
52#include <linux/ctype.h>
612b5a8d 53#include <linux/delay.h>
b385676b 54#include <asm/atomic.h>
f64da958 55
612b5a8d
CM		 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
1da177e4
LT		 66#endif
67
68#define PFX "IPMI Watchdog: "
69
1da177e4
LT		 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
4bfdf378 146static int nowayout = WATCHDOG_NOWAYOUT;
1da177e4 147
0c8204b3 148static ipmi_user_t watchdog_user;
b2c03941 149static int watchdog_ifnum;
1da177e4
LT		 150
151/* Default the timeout to 10 seconds. */
152static int timeout = 10;
153
154/* The pre-timeout is disabled by default. */
0c8204b3 155static int pretimeout;
1da177e4
LT		 156
157/* Default action is to reset the board on a timeout. */
158static unsigned char action_val = WDOG_TIMEOUT_RESET;
159
160static char action[16] = "reset";
161
162static unsigned char preaction_val = WDOG_PRETIMEOUT_NONE;
163
164static char preaction[16] = "pre_none";
165
166static unsigned char preop_val = WDOG_PREOP_NONE;
167
168static char preop[16] = "preop_none";
169static DEFINE_SPINLOCK(ipmi_read_lock);
0c8204b3 170static char data_to_read;
1da177e4 171static DECLARE_WAIT_QUEUE_HEAD(read_q);
0c8204b3
RD		 172static struct fasync_struct *fasync_q;
173static char pretimeout_since_last_heartbeat;
1da177e4
LT		 174static char expect_close;
175
b2c03941
CM		 176static int ifnum_to_use = -1;
177
cc4673ee
CM		 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
183static int ipmi_set_timeout(int do_heartbeat);
b2c03941
CM		 184static void ipmi_register_watchdog(int ipmi_intf);
185static void ipmi_unregister_watchdog(int ipmi_intf);
cc4673ee 186
1da177e4
LT		 187/* If true, the driver will start running as soon as it is configured
188 and ready. */
0c8204b3 189static int start_now;
1da177e4 190
cc4673ee
CM		 191static 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
cc4673ee
CM		 203 *((int *)kp->arg) = l;
204 if (watchdog_user)
205 rv = ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY);
cc4673ee
CM		 206
207 return rv;
208}
209
210static int get_param_int(char *buffer, struct kernel_param *kp)
211{
212 return sprintf(buffer, "%i", *((int *)kp->arg));
213}
214
215typedef int (*action_fn)(const char *intval, char *outval);
216
217static int action_op(const char *inval, char *outval);
218static int preaction_op(const char *inval, char *outval);
219static int preop_op(const char *inval, char *outval);
220static void check_parms(void);
221
222static int set_param_str(const char *val, struct kernel_param *kp)
223{
224 action_fn fn = (action_fn) kp->arg;
225 int rv = 0;
43cdff92
SD		 226 char valcp[16];
227 char *s;
66f969d0 228
43cdff92
SD		 229 strncpy(valcp, val, 16);
230 valcp[15] = '\0';
66f969d0 231
43cdff92 232 s = strstrip(valcp);
cc4673ee 233
66f969d0 234 rv = fn(s, NULL);
cc4673ee 235 if (rv)
f8fbcd3b 236 goto out;
cc4673ee
CM		 237
238 check_parms();
239 if (watchdog_user)
240 rv = ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY);
241
f8fbcd3b 242 out:
cc4673ee
CM		 243 return rv;
244}
245
246static 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
b2c03941
CM		 257
258static 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
271module_param_call(ifnum_to_use, set_param_wdog_ifnum, get_param_int,
272 &ifnum_to_use, 0644);
273MODULE_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
cc4673ee 277module_param_call(timeout, set_param_int, get_param_int, &timeout, 0644);
1da177e4 278MODULE_PARM_DESC(timeout, "Timeout value in seconds.");
cc4673ee
CM		 279
280module_param_call(pretimeout, set_param_int, get_param_int, &pretimeout, 0644);
1da177e4 281MODULE_PARM_DESC(pretimeout, "Pretimeout value in seconds.");
cc4673ee
CM		 282
283module_param_call(action, set_param_str, get_param_str, action_op, 0644);
1da177e4
LT		 284MODULE_PARM_DESC(action, "Timeout action. One of: "
285 "reset, none, power_cycle, power_off.");
cc4673ee
CM		 286
287module_param_call(preaction, set_param_str, get_param_str, preaction_op, 0644);
1da177e4
LT		 288MODULE_PARM_DESC(preaction, "Pretimeout action. One of: "
289 "pre_none, pre_smi, pre_nmi, pre_int.");
cc4673ee
CM		 290
291module_param_call(preop, set_param_str, get_param_str, preop_op, 0644);
1da177e4
LT		 292MODULE_PARM_DESC(preop, "Pretimeout driver operation. One of: "
293 "preop_none, preop_panic, preop_give_data.");
cc4673ee 294
b2c03941 295module_param(start_now, int, 0444);
1da177e4
LT		 296MODULE_PARM_DESC(start_now, "Set to 1 to start the watchdog as"
297 "soon as the driver is loaded.");
cc4673ee
CM		 298
299module_param(nowayout, int, 0644);
b2c03941
CM		 300MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started "
301 "(default=CONFIG_WATCHDOG_NOWAYOUT)");
1da177e4
LT		 302
303/* Default state of the timer. */
304static unsigned char ipmi_watchdog_state = WDOG_TIMEOUT_NONE;
305
306/* If shutting down via IPMI, we ignore the heartbeat. */
0c8204b3 307static int ipmi_ignore_heartbeat;
1da177e4
LT		 308
309/* Is someone using the watchdog? Only one user is allowed. */
0c8204b3 310static unsigned long ipmi_wdog_open;
1da177e4
LT		 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. */
0c8204b3 316static int ipmi_start_timer_on_heartbeat;
1da177e4
LT		 317
318/* IPMI version of the BMC. */
319static unsigned char ipmi_version_major;
320static unsigned char ipmi_version_minor;
321
b385676b
CM		 322/* If a pretimeout occurs, this is used to allow only one panic to happen. */
323static atomic_t preop_panic_excl = ATOMIC_INIT(-1);
1da177e4 324
612b5a8d
CM		 325#ifdef HAVE_DIE_NMI
326static int testing_nmi;
327static int nmi_handler_registered;
328#endif
329
1da177e4 330static int ipmi_heartbeat(void);
1da177e4 331
d6dfd131 332/* We use a mutex to make sure that only one thing can send a set
1da177e4 333 timeout at one time, because we only have one copy of the data.
d6dfd131 334 The mutex is claimed when the set_timeout is sent and freed
1da177e4
LT		 335 when both messages are free. */
336static atomic_t set_timeout_tofree = ATOMIC_INIT(0);
d6dfd131
CM		 337static DEFINE_MUTEX(set_timeout_lock);
338static DECLARE_COMPLETION(set_timeout_wait);
1da177e4
LT		 339static void set_timeout_free_smi(struct ipmi_smi_msg *msg)
340{
341 if (atomic_dec_and_test(&set_timeout_tofree))
d6dfd131 342 complete(&set_timeout_wait);
1da177e4
LT		 343}
344static void set_timeout_free_recv(struct ipmi_recv_msg *msg)
345{
346 if (atomic_dec_and_test(&set_timeout_tofree))
d6dfd131 347 complete(&set_timeout_wait);
1da177e4
LT		 348}
349static struct ipmi_smi_msg set_timeout_smi_msg =
350{
351 .done = set_timeout_free_smi
352};
353static struct ipmi_recv_msg set_timeout_recv_msg =
354{
355 .done = set_timeout_free_recv
356};
357
358static 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
612b5a8d
CM		 369 /* These can be cleared as we are setting the timeout. */
370 pretimeout_since_last_heartbeat = 0;
371
1da177e4
LT		 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);
8f05ee9a 388 if ((pretimeout > 0) && (ipmi_watchdog_state != WDOG_TIMEOUT_NONE)) {
1da177e4
LT		 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
1da177e4
LT		 425static 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. */
d6dfd131 432 mutex_lock(&set_timeout_lock);
1da177e4
LT		 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) {
d6dfd131
CM		 440 mutex_unlock(&set_timeout_lock);
441 goto out;
442 }
443
444 wait_for_completion(&set_timeout_wait);
445
612b5a8d
CM		 446 mutex_unlock(&set_timeout_lock);
447
d6dfd131
CM		 448 if ((do_heartbeat == IPMI_SET_TIMEOUT_FORCE_HB)
449 || ((send_heartbeat_now)
450 && (do_heartbeat == IPMI_SET_TIMEOUT_HB_IF_NECESSARY)))
d6dfd131 451 rv = ipmi_heartbeat();
1da177e4 452
d6dfd131 453out:
1da177e4
LT		 454 return rv;
455}
456
fcfa4724
CM		 457static atomic_t panic_done_count = ATOMIC_INIT(0);
458
459static void panic_smi_free(struct ipmi_smi_msg *msg)
1da177e4 460{
fcfa4724 461 atomic_dec(&panic_done_count);
1da177e4 462}
fcfa4724
CM		 463static void panic_recv_free(struct ipmi_recv_msg *msg)
464{
465 atomic_dec(&panic_done_count);
466}
467
468static struct ipmi_smi_msg panic_halt_heartbeat_smi_msg =
469{
470 .done = panic_smi_free
471};
472static struct ipmi_recv_msg panic_halt_heartbeat_recv_msg =
1da177e4 473{
fcfa4724
CM		 474 .done = panic_recv_free
475};
476
477static 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);
1da177e4 506}
fcfa4724 507
1da177e4
LT		 508static struct ipmi_smi_msg panic_halt_smi_msg =
509{
fcfa4724 510 .done = panic_smi_free
1da177e4
LT		 511};
512static struct ipmi_recv_msg panic_halt_recv_msg =
513{
fcfa4724 514 .done = panic_recv_free
1da177e4
LT		 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. */
521static void panic_halt_ipmi_set_timeout(void)
522{
523 int send_heartbeat_now;
524 int rv;
525
fcfa4724
CM		 526 /* Wait for the messages to be free. */
527 while (atomic_read(&panic_done_count) != 0)
528 ipmi_poll_interface(watchdog_user);
1da177e4
LT		 529 rv = i_ipmi_set_timeout(&panic_halt_smi_msg,
530 &panic_halt_recv_msg,
531 &send_heartbeat_now);
532 if (!rv) {
fcfa4724 533 atomic_add(2, &panic_done_count);
1da177e4
LT		 534 if (send_heartbeat_now)
535 panic_halt_ipmi_heartbeat();
fcfa4724
CM		 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);
1da177e4
LT		 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. */
547static atomic_t heartbeat_tofree = ATOMIC_INIT(0);
d6dfd131
CM		 548static DEFINE_MUTEX(heartbeat_lock);
549static DECLARE_COMPLETION(heartbeat_wait);
1da177e4
LT		 550static void heartbeat_free_smi(struct ipmi_smi_msg *msg)
551{
552 if (atomic_dec_and_test(&heartbeat_tofree))
d6dfd131 553 complete(&heartbeat_wait);
1da177e4
LT		 554}
555static void heartbeat_free_recv(struct ipmi_recv_msg *msg)
556{
557 if (atomic_dec_and_test(&heartbeat_tofree))
d6dfd131 558 complete(&heartbeat_wait);
1da177e4
LT		 559}
560static struct ipmi_smi_msg heartbeat_smi_msg =
561{
562 .done = heartbeat_free_smi
563};
564static struct ipmi_recv_msg heartbeat_recv_msg =
565{
566 .done = heartbeat_free_recv
567};
568
1da177e4
LT		 569static int ipmi_heartbeat(void)
570{
571 struct kernel_ipmi_msg msg;
572 int rv;
573 struct ipmi_system_interface_addr addr;
574
612b5a8d 575 if (ipmi_ignore_heartbeat)
1da177e4 576 return 0;
1da177e4
LT		 577
578 if (ipmi_start_timer_on_heartbeat) {
faa8b6c3 579 ipmi_start_timer_on_heartbeat = 0;
1da177e4
LT		 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. */
1da177e4
LT		 587 return ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY);
588 }
589
d6dfd131 590 mutex_lock(&heartbeat_lock);
1da177e4
LT		 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) {
d6dfd131 597 mutex_unlock(&heartbeat_lock);
1da177e4
LT		 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) {
d6dfd131 618 mutex_unlock(&heartbeat_lock);
1da177e4
LT		 619 printk(KERN_WARNING PFX "heartbeat failure: %d\n",
620 rv);
621 return rv;
622 }
623
624 /* Wait for the heartbeat to be sent. */
d6dfd131 625 wait_for_completion(&heartbeat_wait);
1da177e4
LT		 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
d6dfd131 634 mutex_unlock(&heartbeat_lock);
1da177e4
LT		 635
636 return rv;
637}
638
8a3628d5 639static struct watchdog_info ident =
1da177e4
LT		 640{
641 .options = 0, /* WDIOF_SETTIMEOUT, */
642 .firmware_version = 1,
643 .identity = "IPMI"
644};
645
646static 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 i = copy_from_user(&val, argp, sizeof(int));
673 if (i)
674 return -EFAULT;
675 pretimeout = val;
676 return ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY);
677
678 case WDIOC_GET_PRETIMEOUT:
679 i = copy_to_user(argp, &pretimeout, sizeof(pretimeout));
680 if (i)
681 return -EFAULT;
682 return 0;
683
684 case WDIOC_KEEPALIVE:
685 return ipmi_heartbeat();
686
687 case WDIOC_SETOPTIONS:
688 i = copy_from_user(&val, argp, sizeof(int));
689 if (i)
690 return -EFAULT;
691 if (val & WDIOS_DISABLECARD)
692 {
693 ipmi_watchdog_state = WDOG_TIMEOUT_NONE;
694 ipmi_set_timeout(IPMI_SET_TIMEOUT_NO_HB);
695 ipmi_start_timer_on_heartbeat = 0;
696 }
697
698 if (val & WDIOS_ENABLECARD)
699 {
700 ipmi_watchdog_state = action_val;
701 ipmi_set_timeout(IPMI_SET_TIMEOUT_FORCE_HB);
702 }
703 return 0;
704
705 case WDIOC_GETSTATUS:
706 val = 0;
707 i = copy_to_user(argp, &val, sizeof(val));
708 if (i)
709 return -EFAULT;
710 return 0;
711
712 default:
713 return -ENOIOCTLCMD;
714 }
715}
716
717static ssize_t ipmi_write(struct file *file,
718 const char __user *buf,
719 size_t len,
720 loff_t *ppos)
721{
722 int rv;
723
724 if (len) {
725 if (!nowayout) {
726 size_t i;
727
728 /* In case it was set long ago */
729 expect_close = 0;
730
731 for (i = 0; i != len; i++) {
732 char c;
733
734 if (get_user(c, buf + i))
735 return -EFAULT;
736 if (c == 'V')
737 expect_close = 42;
738 }
739 }
740 rv = ipmi_heartbeat();
741 if (rv)
742 return rv;
743 return 1;
744 }
745 return 0;
746}
747
748static ssize_t ipmi_read(struct file *file,
749 char __user *buf,
750 size_t count,
751 loff_t *ppos)
752{
753 int rv = 0;
754 wait_queue_t wait;
755
756 if (count <= 0)
757 return 0;
758
759 /* Reading returns if the pretimeout has gone off, and it only does
760 it once per pretimeout. */
761 spin_lock(&ipmi_read_lock);
762 if (!data_to_read) {
763 if (file->f_flags & O_NONBLOCK) {
764 rv = -EAGAIN;
765 goto out;
766 }
767
768 init_waitqueue_entry(&wait, current);
769 add_wait_queue(&read_q, &wait);
770 while (!data_to_read) {
771 set_current_state(TASK_INTERRUPTIBLE);
772 spin_unlock(&ipmi_read_lock);
773 schedule();
774 spin_lock(&ipmi_read_lock);
775 }
776 remove_wait_queue(&read_q, &wait);
777
778 if (signal_pending(current)) {
779 rv = -ERESTARTSYS;
780 goto out;
781 }
782 }
783 data_to_read = 0;
784
785 out:
786 spin_unlock(&ipmi_read_lock);
787
788 if (rv == 0) {
789 if (copy_to_user(buf, &data_to_read, 1))
790 rv = -EFAULT;
791 else
792 rv = 1;
793 }
794
795 return rv;
796}
797
798static int ipmi_open(struct inode *ino, struct file *filep)
799{
e8b33617
CM		 800 switch (iminor(ino)) {
801 case WATCHDOG_MINOR:
802 if (test_and_set_bit(0, &ipmi_wdog_open))
1da177e4
LT		 803 return -EBUSY;
804
e8b33617
CM		 805 /* Don't start the timer now, let it start on the
806 first heartbeat. */
807 ipmi_start_timer_on_heartbeat = 1;
808 return nonseekable_open(ino, filep);
1da177e4 809
e8b33617
CM		 810 default:
811 return (-ENODEV);
1da177e4
LT		 812 }
813}
814
815static unsigned int ipmi_poll(struct file *file, poll_table *wait)
816{
817 unsigned int mask = 0;
818
819 poll_wait(file, &read_q, wait);
820
821 spin_lock(&ipmi_read_lock);
822 if (data_to_read)
823 mask |= (POLLIN | POLLRDNORM);
824 spin_unlock(&ipmi_read_lock);
825
826 return mask;
827}
828
829static int ipmi_fasync(int fd, struct file *file, int on)
830{
831 int result;
832
833 result = fasync_helper(fd, file, on, &fasync_q);
834
835 return (result);
836}
837
838static int ipmi_close(struct inode *ino, struct file *filep)
839{
8a3628d5 840 if (iminor(ino) == WATCHDOG_MINOR) {
1da177e4
LT		 841 if (expect_close == 42) {
842 ipmi_watchdog_state = WDOG_TIMEOUT_NONE;
843 ipmi_set_timeout(IPMI_SET_TIMEOUT_NO_HB);
1da177e4 844 } else {
8a3628d5
CM		 845 printk(KERN_CRIT PFX
846 "Unexpected close, not stopping watchdog!\n");
1da177e4
LT		 847 ipmi_heartbeat();
848 }
ec26d79f 849 clear_bit(0, &ipmi_wdog_open);
1da177e4
LT		 850 }
851
852 ipmi_fasync (-1, filep, 0);
853 expect_close = 0;
854
855 return 0;
856}
857
62322d25 858static const struct file_operations ipmi_wdog_fops = {
1da177e4
LT		 859 .owner = THIS_MODULE,
860 .read = ipmi_read,
861 .poll = ipmi_poll,
862 .write = ipmi_write,
863 .ioctl = ipmi_ioctl,
864 .open = ipmi_open,
865 .release = ipmi_close,
866 .fasync = ipmi_fasync,
867};
868
869static struct miscdevice ipmi_wdog_miscdev = {
870 .minor = WATCHDOG_MINOR,
871 .name = "watchdog",
872 .fops = &ipmi_wdog_fops
873};
874
1da177e4
LT		 875static void ipmi_wdog_msg_handler(struct ipmi_recv_msg *msg,
876 void *handler_data)
877{
878 if (msg->msg.data[0] != 0) {
879 printk(KERN_ERR PFX "response: Error %x on cmd %x\n",
880 msg->msg.data[0],
881 msg->msg.cmd);
882 }
883
884 ipmi_free_recv_msg(msg);
885}
886
887static void ipmi_wdog_pretimeout_handler(void *handler_data)
888{
889 if (preaction_val != WDOG_PRETIMEOUT_NONE) {
b385676b
CM		 890 if (preop_val == WDOG_PREOP_PANIC) {
891 if (atomic_inc_and_test(&preop_panic_excl))
892 panic("Watchdog pre-timeout");
893 } else if (preop_val == WDOG_PREOP_GIVE_DATA) {
1da177e4
LT		 894 spin_lock(&ipmi_read_lock);
895 data_to_read = 1;
896 wake_up_interruptible(&read_q);
897 kill_fasync(&fasync_q, SIGIO, POLL_IN);
898
899 spin_unlock(&ipmi_read_lock);
900 }
901 }
902
903 /* On some machines, the heartbeat will give
904 an error and not work unless we re-enable
905 the timer. So do so. */
906 pretimeout_since_last_heartbeat = 1;
907}
908
909static struct ipmi_user_hndl ipmi_hndlrs =
910{
911 .ipmi_recv_hndl = ipmi_wdog_msg_handler,
912 .ipmi_watchdog_pretimeout = ipmi_wdog_pretimeout_handler
913};
914
915static void ipmi_register_watchdog(int ipmi_intf)
916{
917 int rv = -EBUSY;
918
1da177e4
LT		 919 if (watchdog_user)
920 goto out;
921
b2c03941
CM		 922 if ((ifnum_to_use >= 0) && (ifnum_to_use != ipmi_intf))
923 goto out;
924
925 watchdog_ifnum = ipmi_intf;
926
1da177e4
LT		 927 rv = ipmi_create_user(ipmi_intf, &ipmi_hndlrs, NULL, &watchdog_user);
928 if (rv < 0) {
929 printk(KERN_CRIT PFX "Unable to register with ipmi\n");
930 goto out;
931 }
932
933 ipmi_get_version(watchdog_user,
934 &ipmi_version_major,
935 &ipmi_version_minor);
936
937 rv = misc_register(&ipmi_wdog_miscdev);
938 if (rv < 0) {
939 ipmi_destroy_user(watchdog_user);
940 watchdog_user = NULL;
941 printk(KERN_CRIT PFX "Unable to register misc device\n");
942 }
943
612b5a8d
CM		 944#ifdef HAVE_DIE_NMI
945 if (nmi_handler_registered) {
946 int old_pretimeout = pretimeout;
947 int old_timeout = timeout;
948 int old_preop_val = preop_val;
949
950 /* Set the pretimeout to go off in a second and give
951 ourselves plenty of time to stop the timer. */
952 ipmi_watchdog_state = WDOG_TIMEOUT_RESET;
953 preop_val = WDOG_PREOP_NONE; /* Make sure nothing happens */
954 pretimeout = 99;
955 timeout = 100;
956
957 testing_nmi = 1;
958
959 rv = ipmi_set_timeout(IPMI_SET_TIMEOUT_FORCE_HB);
960 if (rv) {
961 printk(KERN_WARNING PFX "Error starting timer to"
962 " test NMI: 0x%x. The NMI pretimeout will"
963 " likely not work\n", rv);
964 rv = 0;
965 goto out_restore;
966 }
967
968 msleep(1500);
969
970 if (testing_nmi != 2) {
971 printk(KERN_WARNING PFX "IPMI NMI didn't seem to"
972 " occur. The NMI pretimeout will"
973 " likely not work\n");
974 }
975 out_restore:
976 testing_nmi = 0;
977 preop_val = old_preop_val;
978 pretimeout = old_pretimeout;
979 timeout = old_timeout;
980 }
981#endif
982
1da177e4 983 out:
1da177e4
LT		 984 if ((start_now) && (rv == 0)) {
985 /* Run from startup, so start the timer now. */
986 start_now = 0; /* Disable this function after first startup. */
987 ipmi_watchdog_state = action_val;
988 ipmi_set_timeout(IPMI_SET_TIMEOUT_FORCE_HB);
989 printk(KERN_INFO PFX "Starting now!\n");
612b5a8d
CM		 990 } else {
991 /* Stop the timer now. */
992 ipmi_watchdog_state = WDOG_TIMEOUT_NONE;
993 ipmi_set_timeout(IPMI_SET_TIMEOUT_NO_HB);
1da177e4
LT		 994 }
995}
996
b2c03941
CM		 997static void ipmi_unregister_watchdog(int ipmi_intf)
998{
999 int rv;
1000
b2c03941
CM		 1001 if (!watchdog_user)
1002 goto out;
1003
1004 if (watchdog_ifnum != ipmi_intf)
1005 goto out;
1006
1007 /* Make sure no one can call us any more. */
1008 misc_deregister(&ipmi_wdog_miscdev);
1009
1010 /* Wait to make sure the message makes it out. The lower layer has
1011 pointers to our buffers, we want to make sure they are done before
1012 we release our memory. */
1013 while (atomic_read(&set_timeout_tofree))
1014 schedule_timeout_uninterruptible(1);
1015
1016 /* Disconnect from IPMI. */
1017 rv = ipmi_destroy_user(watchdog_user);
1018 if (rv) {
1019 printk(KERN_WARNING PFX "error unlinking from IPMI: %d\n",
1020 rv);
1021 }
1022 watchdog_user = NULL;
1023
1024 out:
f8fbcd3b 1025 return;
b2c03941
CM		 1026}
1027
612b5a8d 1028#ifdef HAVE_DIE_NMI
1da177e4 1029static int
612b5a8d 1030ipmi_nmi(struct notifier_block *self, unsigned long val, void *data)
1da177e4 1031{
612b5a8d
CM		 1032 struct die_args *args = data;
1033
1034 if (val != DIE_NMI)
1035 return NOTIFY_OK;
1036
1037 /* Hack, if it's a memory or I/O error, ignore it. */
1038 if (args->err & 0xc0)
1039 return NOTIFY_OK;
1040
1041 /*
1042 * If we get here, it's an NMI that's not a memory or I/O
1043 * error. We can't truly tell if it's from IPMI or not
1044 * without sending a message, and sending a message is almost
1045 * impossible because of locking.
1046 */
1047
1048 if (testing_nmi) {
1049 testing_nmi = 2;
1050 return NOTIFY_STOP;
1051 }
1052
8f05ee9a
CM		 1053 /* If we are not expecting a timeout, ignore it. */
1054 if (ipmi_watchdog_state == WDOG_TIMEOUT_NONE)
612b5a8d
CM		 1055 return NOTIFY_OK;
1056
1057 if (preaction_val != WDOG_PRETIMEOUT_NMI)
1058 return NOTIFY_OK;
8f05ee9a 1059
1da177e4
LT		 1060 /* If no one else handled the NMI, we assume it was the IPMI
1061 watchdog. */
612b5a8d 1062 if (preop_val == WDOG_PREOP_PANIC) {
8f05ee9a
CM		 1063 /* On some machines, the heartbeat will give
1064 an error and not work unless we re-enable
1065 the timer. So do so. */
1066 pretimeout_since_last_heartbeat = 1;
b385676b
CM		 1067 if (atomic_inc_and_test(&preop_panic_excl))
1068 panic(PFX "pre-timeout");
8f05ee9a 1069 }
1da177e4 1070
612b5a8d 1071 return NOTIFY_STOP;
1da177e4
LT		 1072}
1073
612b5a8d
CM		 1074static struct notifier_block ipmi_nmi_handler = {
1075 .notifier_call = ipmi_nmi
1da177e4
LT		 1076};
1077#endif
1078
1079static int wdog_reboot_handler(struct notifier_block *this,
1080 unsigned long code,
1081 void *unused)
1082{
1083 static int reboot_event_handled = 0;
1084
1085 if ((watchdog_user) && (!reboot_event_handled)) {
1086 /* Make sure we only do this once. */
1087 reboot_event_handled = 1;
1088
fcfa4724 1089 if (code == SYS_POWER_OFF || code == SYS_HALT) {
1da177e4
LT		 1090 /* Disable the WDT if we are shutting down. */
1091 ipmi_watchdog_state = WDOG_TIMEOUT_NONE;
1092 panic_halt_ipmi_set_timeout();
96febe9f 1093 } else if (ipmi_watchdog_state != WDOG_TIMEOUT_NONE) {
1da177e4 1094 /* Set a long timer to let the reboot happens, but
96febe9f
CM		 1095 reboot if it hangs, but only if the watchdog
1096 timer was already running. */
1da177e4
LT		 1097 timeout = 120;
1098 pretimeout = 0;
1099 ipmi_watchdog_state = WDOG_TIMEOUT_RESET;
1100 panic_halt_ipmi_set_timeout();
1101 }
1102 }
1103 return NOTIFY_OK;
1104}
1105
1106static struct notifier_block wdog_reboot_notifier = {
1107 .notifier_call = wdog_reboot_handler,
1108 .next = NULL,
1109 .priority = 0
1110};
1111
1112static int wdog_panic_handler(struct notifier_block *this,
1113 unsigned long event,
1114 void *unused)
1115{
1116 static int panic_event_handled = 0;
1117
96febe9f
CM		 1118 /* On a panic, if we have a panic timeout, make sure to extend
1119 the watchdog timer to a reasonable value to complete the
1120 panic, if the watchdog timer is running. Plus the
1121 pretimeout is meaningless at panic time. */
1122 if (watchdog_user && !panic_event_handled &&
1123 ipmi_watchdog_state != WDOG_TIMEOUT_NONE) {
1124 /* Make sure we do this only once. */
1da177e4
LT		 1125 panic_event_handled = 1;
1126
1127 timeout = 255;
1128 pretimeout = 0;
1da177e4
LT		 1129 panic_halt_ipmi_set_timeout();
1130 }
1131
1132 return NOTIFY_OK;
1133}
1134
1135static struct notifier_block wdog_panic_notifier = {
1136 .notifier_call = wdog_panic_handler,
1137 .next = NULL,
1138 .priority = 150 /* priority: INT_MAX >= x >= 0 */
1139};
1140
1141
50c812b2 1142static void ipmi_new_smi(int if_num, struct device *device)
1da177e4
LT		 1143{
1144 ipmi_register_watchdog(if_num);
1145}
1146
1147static void ipmi_smi_gone(int if_num)
1148{
b2c03941 1149 ipmi_unregister_watchdog(if_num);
1da177e4
LT		 1150}
1151
1152static struct ipmi_smi_watcher smi_watcher =
1153{
1154 .owner = THIS_MODULE,
1155 .new_smi = ipmi_new_smi,
1156 .smi_gone = ipmi_smi_gone
1157};
1158
cc4673ee 1159static int action_op(const char *inval, char *outval)
1da177e4 1160{
cc4673ee
CM		 1161 if (outval)
1162 strcpy(outval, action);
1163
1164 if (!inval)
1165 return 0;
1da177e4 1166
cc4673ee 1167 if (strcmp(inval, "reset") == 0)
1da177e4 1168 action_val = WDOG_TIMEOUT_RESET;
cc4673ee 1169 else if (strcmp(inval, "none") == 0)
1da177e4 1170 action_val = WDOG_TIMEOUT_NONE;
cc4673ee 1171 else if (strcmp(inval, "power_cycle") == 0)
1da177e4 1172 action_val = WDOG_TIMEOUT_POWER_CYCLE;
cc4673ee 1173 else if (strcmp(inval, "power_off") == 0)
1da177e4 1174 action_val = WDOG_TIMEOUT_POWER_DOWN;
cc4673ee
CM		 1175 else
1176 return -EINVAL;
1177 strcpy(action, inval);
1178 return 0;
1179}
1180
1181static int preaction_op(const char *inval, char *outval)
1182{
1183 if (outval)
1184 strcpy(outval, preaction);
1da177e4 1185
cc4673ee
CM		 1186 if (!inval)
1187 return 0;
1188
1189 if (strcmp(inval, "pre_none") == 0)
1da177e4 1190 preaction_val = WDOG_PRETIMEOUT_NONE;
cc4673ee 1191 else if (strcmp(inval, "pre_smi") == 0)
1da177e4 1192 preaction_val = WDOG_PRETIMEOUT_SMI;
612b5a8d 1193#ifdef HAVE_DIE_NMI
cc4673ee 1194 else if (strcmp(inval, "pre_nmi") == 0)
1da177e4
LT		 1195 preaction_val = WDOG_PRETIMEOUT_NMI;
1196#endif
cc4673ee 1197 else if (strcmp(inval, "pre_int") == 0)
1da177e4 1198 preaction_val = WDOG_PRETIMEOUT_MSG_INT;
cc4673ee
CM		 1199 else
1200 return -EINVAL;
1201 strcpy(preaction, inval);
1202 return 0;
1203}
1204
1205static int preop_op(const char *inval, char *outval)
1206{
1207 if (outval)
1208 strcpy(outval, preop);
1da177e4 1209
cc4673ee
CM		 1210 if (!inval)
1211 return 0;
1212
1213 if (strcmp(inval, "preop_none") == 0)
1da177e4 1214 preop_val = WDOG_PREOP_NONE;
cc4673ee 1215 else if (strcmp(inval, "preop_panic") == 0)
1da177e4 1216 preop_val = WDOG_PREOP_PANIC;
cc4673ee 1217 else if (strcmp(inval, "preop_give_data") == 0)
1da177e4 1218 preop_val = WDOG_PREOP_GIVE_DATA;
cc4673ee
CM		 1219 else
1220 return -EINVAL;
1221 strcpy(preop, inval);
1222 return 0;
1223}
1da177e4 1224
cc4673ee
CM		 1225static void check_parms(void)
1226{
612b5a8d 1227#ifdef HAVE_DIE_NMI
cc4673ee
CM		 1228 int do_nmi = 0;
1229 int rv;
1230
1da177e4 1231 if (preaction_val == WDOG_PRETIMEOUT_NMI) {
cc4673ee 1232 do_nmi = 1;
1da177e4
LT		 1233 if (preop_val == WDOG_PREOP_GIVE_DATA) {
1234 printk(KERN_WARNING PFX "Pretimeout op is to give data"
1235 " but NMI pretimeout is enabled, setting"
1236 " pretimeout op to none\n");
cc4673ee
CM		 1237 preop_op("preop_none", NULL);
1238 do_nmi = 0;
1da177e4 1239 }
cc4673ee
CM		 1240 }
1241 if (do_nmi && !nmi_handler_registered) {
612b5a8d 1242 rv = register_die_notifier(&ipmi_nmi_handler);
1da177e4 1243 if (rv) {
cc4673ee
CM		 1244 printk(KERN_WARNING PFX
1245 "Can't register nmi handler\n");
1246 return;
1247 } else
1248 nmi_handler_registered = 1;
1249 } else if (!do_nmi && nmi_handler_registered) {
612b5a8d 1250 unregister_die_notifier(&ipmi_nmi_handler);
cc4673ee 1251 nmi_handler_registered = 0;
1da177e4
LT		 1252 }
1253#endif
cc4673ee
CM		 1254}
1255
1256static int __init ipmi_wdog_init(void)
1257{
1258 int rv;
1259
1260 if (action_op(action, NULL)) {
1261 action_op("reset", NULL);
1262 printk(KERN_INFO PFX "Unknown action '%s', defaulting to"
1263 " reset\n", action);
1264 }
1265
1266 if (preaction_op(preaction, NULL)) {
1267 preaction_op("pre_none", NULL);
1268 printk(KERN_INFO PFX "Unknown preaction '%s', defaulting to"
1269 " none\n", preaction);
1270 }
1271
1272 if (preop_op(preop, NULL)) {
1273 preop_op("preop_none", NULL);
1274 printk(KERN_INFO PFX "Unknown preop '%s', defaulting to"
1275 " none\n", preop);
1276 }
1277
1278 check_parms();
1da177e4 1279
b2c03941
CM		 1280 register_reboot_notifier(&wdog_reboot_notifier);
1281 atomic_notifier_chain_register(&panic_notifier_list,
1282 &wdog_panic_notifier);
1283
1da177e4
LT		 1284 rv = ipmi_smi_watcher_register(&smi_watcher);
1285 if (rv) {
612b5a8d
CM		 1286#ifdef HAVE_DIE_NMI
1287 if (nmi_handler_registered)
1288 unregister_die_notifier(&ipmi_nmi_handler);
1da177e4 1289#endif
b2c03941
CM		 1290 atomic_notifier_chain_unregister(&panic_notifier_list,
1291 &wdog_panic_notifier);
1292 unregister_reboot_notifier(&wdog_reboot_notifier);
1da177e4
LT		 1293 printk(KERN_WARNING PFX "can't register smi watcher\n");
1294 return rv;
1295 }
1296
1fdd75bd
CM		 1297 printk(KERN_INFO PFX "driver initialized\n");
1298
1da177e4
LT		 1299 return 0;
1300}
1301
b2c03941 1302static void __exit ipmi_wdog_exit(void)
1da177e4 1303{
b2c03941
CM		 1304 ipmi_smi_watcher_unregister(&smi_watcher);
1305 ipmi_unregister_watchdog(watchdog_ifnum);
1da177e4 1306
612b5a8d 1307#ifdef HAVE_DIE_NMI
cc4673ee 1308 if (nmi_handler_registered)
612b5a8d 1309 unregister_die_notifier(&ipmi_nmi_handler);
1da177e4
LT		 1310#endif
1311
e041c683 1312 atomic_notifier_chain_unregister(&panic_notifier_list,
b2c03941 1313 &wdog_panic_notifier);
1da177e4 1314 unregister_reboot_notifier(&wdog_reboot_notifier);
1da177e4
LT		 1315}
1316module_exit(ipmi_wdog_exit);
1317module_init(ipmi_wdog_init);
1318MODULE_LICENSE("GPL");
1fdd75bd
CM		 1319MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>");
1320MODULE_DESCRIPTION("watchdog timer based upon the IPMI interface.");
Linux kernel - Deliverables
This page took 0.596106 seconds and 5 git commands to generate.