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