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