projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
IPMI: Style fixes in the system interface code
[linux-2.6-block.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:
783e6bcd 672 case WDIOC_SETPRETIMEOUT:
1da177e4
LT		 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:
783e6bcd 680 case WDIOC_GETPRETIMEOUT:
1da177e4
LT		 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
719static 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
750static 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
800static int ipmi_open(struct inode *ino, struct file *filep)
801{
e8b33617
CM		 802 switch (iminor(ino)) {
803 case WATCHDOG_MINOR:
804 if (test_and_set_bit(0, &ipmi_wdog_open))
1da177e4
LT		 805 return -EBUSY;
806
e8b33617
CM		 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);
1da177e4 811
e8b33617
CM		 812 default:
813 return (-ENODEV);
1da177e4
LT		 814 }
815}
816
817static 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
831static 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
840static int ipmi_close(struct inode *ino, struct file *filep)
841{
8a3628d5 842 if (iminor(ino) == WATCHDOG_MINOR) {
1da177e4
LT		 843 if (expect_close == 42) {
844 ipmi_watchdog_state = WDOG_TIMEOUT_NONE;
845 ipmi_set_timeout(IPMI_SET_TIMEOUT_NO_HB);
1da177e4 846 } else {
8a3628d5
CM		 847 printk(KERN_CRIT PFX
848 "Unexpected close, not stopping watchdog!\n");
1da177e4
LT		 849 ipmi_heartbeat();
850 }
ec26d79f 851 clear_bit(0, &ipmi_wdog_open);
1da177e4
LT		 852 }
853
854 ipmi_fasync (-1, filep, 0);
855 expect_close = 0;
856
857 return 0;
858}
859
62322d25 860static const struct file_operations ipmi_wdog_fops = {
1da177e4
LT		 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
871static struct miscdevice ipmi_wdog_miscdev = {
872 .minor = WATCHDOG_MINOR,
873 .name = "watchdog",
874 .fops = &ipmi_wdog_fops
875};
876
1da177e4
LT		 877static 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
889static void ipmi_wdog_pretimeout_handler(void *handler_data)
890{
891 if (preaction_val != WDOG_PRETIMEOUT_NONE) {
b385676b
CM		 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) {
1da177e4
LT		 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
911static 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
917static void ipmi_register_watchdog(int ipmi_intf)
918{
919 int rv = -EBUSY;
920
1da177e4
LT		 921 if (watchdog_user)
922 goto out;
923
b2c03941
CM		 924 if ((ifnum_to_use >= 0) && (ifnum_to_use != ipmi_intf))
925 goto out;
926
927 watchdog_ifnum = ipmi_intf;
928
1da177e4
LT		 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
612b5a8d
CM		 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
1da177e4 985 out:
1da177e4
LT		 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");
612b5a8d
CM		 992 } else {
993 /* Stop the timer now. */
994 ipmi_watchdog_state = WDOG_TIMEOUT_NONE;
995 ipmi_set_timeout(IPMI_SET_TIMEOUT_NO_HB);
1da177e4
LT		 996 }
997}
998
b2c03941
CM		 999static void ipmi_unregister_watchdog(int ipmi_intf)
1000{
1001 int rv;
1002
b2c03941
CM		 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:
f8fbcd3b 1027 return;
b2c03941
CM		 1028}
1029
612b5a8d 1030#ifdef HAVE_DIE_NMI
1da177e4 1031static int
612b5a8d 1032ipmi_nmi(struct notifier_block *self, unsigned long val, void *data)
1da177e4 1033{
612b5a8d
CM		 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
8f05ee9a
CM		 1055 /* If we are not expecting a timeout, ignore it. */
1056 if (ipmi_watchdog_state == WDOG_TIMEOUT_NONE)
612b5a8d
CM		 1057 return NOTIFY_OK;
1058
1059 if (preaction_val != WDOG_PRETIMEOUT_NMI)
1060 return NOTIFY_OK;
8f05ee9a 1061
1da177e4
LT		 1062 /* If no one else handled the NMI, we assume it was the IPMI
1063 watchdog. */
612b5a8d 1064 if (preop_val == WDOG_PREOP_PANIC) {
8f05ee9a
CM		 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;
b385676b
CM		 1069 if (atomic_inc_and_test(&preop_panic_excl))
1070 panic(PFX "pre-timeout");
8f05ee9a 1071 }
1da177e4 1072
612b5a8d 1073 return NOTIFY_STOP;
1da177e4
LT		 1074}
1075
612b5a8d
CM		 1076static struct notifier_block ipmi_nmi_handler = {
1077 .notifier_call = ipmi_nmi
1da177e4
LT		 1078};
1079#endif
1080
1081static 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
fcfa4724 1091 if (code == SYS_POWER_OFF || code == SYS_HALT) {
1da177e4
LT		 1092 /* Disable the WDT if we are shutting down. */
1093 ipmi_watchdog_state = WDOG_TIMEOUT_NONE;
1094 panic_halt_ipmi_set_timeout();
96febe9f 1095 } else if (ipmi_watchdog_state != WDOG_TIMEOUT_NONE) {
1da177e4 1096 /* Set a long timer to let the reboot happens, but
96febe9f
CM		 1097 reboot if it hangs, but only if the watchdog
1098 timer was already running. */
1da177e4
LT		 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
1108static struct notifier_block wdog_reboot_notifier = {
1109 .notifier_call = wdog_reboot_handler,
1110 .next = NULL,
1111 .priority = 0
1112};
1113
1114static int wdog_panic_handler(struct notifier_block *this,
1115 unsigned long event,
1116 void *unused)
1117{
1118 static int panic_event_handled = 0;
1119
96febe9f
CM		 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. */
1da177e4
LT		 1127 panic_event_handled = 1;
1128
1129 timeout = 255;
1130 pretimeout = 0;
1da177e4
LT		 1131 panic_halt_ipmi_set_timeout();
1132 }
1133
1134 return NOTIFY_OK;
1135}
1136
1137static 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
50c812b2 1144static void ipmi_new_smi(int if_num, struct device *device)
1da177e4
LT		 1145{
1146 ipmi_register_watchdog(if_num);
1147}
1148
1149static void ipmi_smi_gone(int if_num)
1150{
b2c03941 1151 ipmi_unregister_watchdog(if_num);
1da177e4
LT		 1152}
1153
1154static 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
cc4673ee 1161static int action_op(const char *inval, char *outval)
1da177e4 1162{
cc4673ee
CM		 1163 if (outval)
1164 strcpy(outval, action);
1165
1166 if (!inval)
1167 return 0;
1da177e4 1168
cc4673ee 1169 if (strcmp(inval, "reset") == 0)
1da177e4 1170 action_val = WDOG_TIMEOUT_RESET;
cc4673ee 1171 else if (strcmp(inval, "none") == 0)
1da177e4 1172 action_val = WDOG_TIMEOUT_NONE;
cc4673ee 1173 else if (strcmp(inval, "power_cycle") == 0)
1da177e4 1174 action_val = WDOG_TIMEOUT_POWER_CYCLE;
cc4673ee 1175 else if (strcmp(inval, "power_off") == 0)
1da177e4 1176 action_val = WDOG_TIMEOUT_POWER_DOWN;
cc4673ee
CM		 1177 else
1178 return -EINVAL;
1179 strcpy(action, inval);
1180 return 0;
1181}
1182
1183static int preaction_op(const char *inval, char *outval)
1184{
1185 if (outval)
1186 strcpy(outval, preaction);
1da177e4 1187
cc4673ee
CM		 1188 if (!inval)
1189 return 0;
1190
1191 if (strcmp(inval, "pre_none") == 0)
1da177e4 1192 preaction_val = WDOG_PRETIMEOUT_NONE;
cc4673ee 1193 else if (strcmp(inval, "pre_smi") == 0)
1da177e4 1194 preaction_val = WDOG_PRETIMEOUT_SMI;
612b5a8d 1195#ifdef HAVE_DIE_NMI
cc4673ee 1196 else if (strcmp(inval, "pre_nmi") == 0)
1da177e4
LT		 1197 preaction_val = WDOG_PRETIMEOUT_NMI;
1198#endif
cc4673ee 1199 else if (strcmp(inval, "pre_int") == 0)
1da177e4 1200 preaction_val = WDOG_PRETIMEOUT_MSG_INT;
cc4673ee
CM		 1201 else
1202 return -EINVAL;
1203 strcpy(preaction, inval);
1204 return 0;
1205}
1206
1207static int preop_op(const char *inval, char *outval)
1208{
1209 if (outval)
1210 strcpy(outval, preop);
1da177e4 1211
cc4673ee
CM		 1212 if (!inval)
1213 return 0;
1214
1215 if (strcmp(inval, "preop_none") == 0)
1da177e4 1216 preop_val = WDOG_PREOP_NONE;
cc4673ee 1217 else if (strcmp(inval, "preop_panic") == 0)
1da177e4 1218 preop_val = WDOG_PREOP_PANIC;
cc4673ee 1219 else if (strcmp(inval, "preop_give_data") == 0)
1da177e4 1220 preop_val = WDOG_PREOP_GIVE_DATA;
cc4673ee
CM		 1221 else
1222 return -EINVAL;
1223 strcpy(preop, inval);
1224 return 0;
1225}
1da177e4 1226
cc4673ee
CM		 1227static void check_parms(void)
1228{
612b5a8d 1229#ifdef HAVE_DIE_NMI
cc4673ee
CM		 1230 int do_nmi = 0;
1231 int rv;
1232
1da177e4 1233 if (preaction_val == WDOG_PRETIMEOUT_NMI) {
cc4673ee 1234 do_nmi = 1;
1da177e4
LT		 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");
cc4673ee
CM		 1239 preop_op("preop_none", NULL);
1240 do_nmi = 0;
1da177e4 1241 }
cc4673ee
CM		 1242 }
1243 if (do_nmi && !nmi_handler_registered) {
612b5a8d 1244 rv = register_die_notifier(&ipmi_nmi_handler);
1da177e4 1245 if (rv) {
cc4673ee
CM		 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) {
612b5a8d 1252 unregister_die_notifier(&ipmi_nmi_handler);
cc4673ee 1253 nmi_handler_registered = 0;
1da177e4
LT		 1254 }
1255#endif
cc4673ee
CM		 1256}
1257
1258static 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();
1da177e4 1281
b2c03941
CM		 1282 register_reboot_notifier(&wdog_reboot_notifier);
1283 atomic_notifier_chain_register(&panic_notifier_list,
1284 &wdog_panic_notifier);
1285
1da177e4
LT		 1286 rv = ipmi_smi_watcher_register(&smi_watcher);
1287 if (rv) {
612b5a8d
CM		 1288#ifdef HAVE_DIE_NMI
1289 if (nmi_handler_registered)
1290 unregister_die_notifier(&ipmi_nmi_handler);
1da177e4 1291#endif
b2c03941
CM		 1292 atomic_notifier_chain_unregister(&panic_notifier_list,
1293 &wdog_panic_notifier);
1294 unregister_reboot_notifier(&wdog_reboot_notifier);
1da177e4
LT		 1295 printk(KERN_WARNING PFX "can't register smi watcher\n");
1296 return rv;
1297 }
1298
1fdd75bd
CM		 1299 printk(KERN_INFO PFX "driver initialized\n");
1300
1da177e4
LT		 1301 return 0;
1302}
1303
b2c03941 1304static void __exit ipmi_wdog_exit(void)
1da177e4 1305{
b2c03941
CM		 1306 ipmi_smi_watcher_unregister(&smi_watcher);
1307 ipmi_unregister_watchdog(watchdog_ifnum);
1da177e4 1308
612b5a8d 1309#ifdef HAVE_DIE_NMI
cc4673ee 1310 if (nmi_handler_registered)
612b5a8d 1311 unregister_die_notifier(&ipmi_nmi_handler);
1da177e4
LT		 1312#endif
1313
e041c683 1314 atomic_notifier_chain_unregister(&panic_notifier_list,
b2c03941 1315 &wdog_panic_notifier);
1da177e4 1316 unregister_reboot_notifier(&wdog_reboot_notifier);
1da177e4
LT		 1317}
1318module_exit(ipmi_wdog_exit);
1319module_init(ipmi_wdog_init);
1320MODULE_LICENSE("GPL");
1fdd75bd
CM		 1321MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>");
1322MODULE_DESCRIPTION("watchdog timer based upon the IPMI interface.");
Linux 6.x block layer and io_uring tree(s)