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