The following IPMI commands are added or modified to support getting
fake LAN channel configurations from the `ipmi_bmc_sim` device:
* Get Channel Access;
* Get Channel Info Command;
* Get LAN Configuration Parameters.
The fake LAN channel configurations can be specified from QEMU
commandline options for device `ipmi_bmc_sim`. Inside the guest OS, the
configurations can be retrieved from the device using some IPMI tools,
e.g., `ipmitool lan print`.
Note, there is not a real LAN channel. The fake LAN channel is suitable
for testing purposes.
Signed-off-by: Yunpeng Yang <yunpeng.yang@nutanix.com>
---
hw/ipmi/ipmi_bmc_sim.c | 297 ++++++++++++++++++++++++++++++++++--
include/hw/ipmi/ipmi.h | 1 +
qemu-options.hx | 26 ++++
tests/qtest/ipmi-kcs-test.c | 60 ++++++++
4 files changed, 374 insertions(+), 10 deletions(-)
diff --git a/hw/ipmi/ipmi_bmc_sim.c b/hw/ipmi/ipmi_bmc_sim.c
index 04e1dcd0e7..2ead46ee55 100644
--- a/hw/ipmi/ipmi_bmc_sim.c
+++ b/hw/ipmi/ipmi_bmc_sim.c
@@ -27,11 +27,13 @@
#include "qemu/timer.h"
#include "hw/ipmi/ipmi.h"
#include "qemu/error-report.h"
+#include "qapi/error.h"
#include "qemu/module.h"
#include "hw/loader.h"
#include "hw/qdev-properties.h"
#include "hw/qdev-properties-system.h"
#include "migration/vmstate.h"
+#include "net/net.h"
#define IPMI_NETFN_CHASSIS 0x00
@@ -70,6 +72,7 @@
#define IPMI_CMD_GET_MSG 0x33
#define IPMI_CMD_SEND_MSG 0x34
#define IPMI_CMD_READ_EVT_MSG_BUF 0x35
+#define IPMI_CMD_GET_CHANNEL_ACCESS 0x41
#define IPMI_CMD_GET_CHANNEL_INFO 0x42
#define IPMI_NETFN_STORAGE 0x0a
@@ -101,6 +104,10 @@
#define IPMI_CMD_GET_SEL_TIME 0x48
#define IPMI_CMD_SET_SEL_TIME 0x49
+#define IPMI_NETFN_TRANSPORT 0x0c
+
+#define IPMI_CMD_GET_LAN_CONFIG 0x02
+
/* Same as a timespec struct. */
struct ipmi_time {
@@ -170,6 +177,23 @@ typedef struct IPMISensor {
#define MAX_SENSORS 20
#define IPMI_WATCHDOG_SENSOR 0
+#define NBYTES_IP 4
+#define NBYTES_MAC 6
+
+typedef struct IPMILan {
+ uint8_t channel;
+ uint8_t ipaddr[NBYTES_IP];
+ uint8_t ipsrc;
+ MACAddr macaddr;
+ uint8_t netmask[NBYTES_IP];
+ uint8_t defgw_ipaddr[NBYTES_IP];
+ MACAddr defgw_macaddr;
+
+ char *arg_ipaddr;
+ char *arg_netmask;
+ char *arg_defgw_ipaddr;
+} IPMILan;
+
#define MAX_NETFNS 64
typedef struct IPMIRcvBufEntry {
@@ -215,6 +239,7 @@ struct IPMIBmcSim {
IPMIFru fru;
IPMISensor sensors[MAX_SENSORS];
char *sdr_filename;
+ IPMILan lan;
/* Odd netfns are for responses, so we only need the even ones. */
const IPMINetfn *netfns[MAX_NETFNS / 2];
@@ -265,6 +290,36 @@ struct IPMIBmcSim {
#define IPMI_BMC_WATCHDOG_ACTION_POWER_DOWN 2
#define IPMI_BMC_WATCHDOG_ACTION_POWER_CYCLE 3
+#define IPMI_CHANNEL_IMPLEMENTATION_MIN 0x1
+#define IPMI_CHANNEL_IMPLEMENTATION_MAX 0xb
+#define IPMI_CHANNEL_IS_IMPLEMENTATION_SPECIFIC(c) \
+ (IPMI_CHANNEL_IMPLEMENTATION_MIN <= (c) && \
+ (c) <= IPMI_CHANNEL_IMPLEMENTATION_MAX)
+
+#define IPMI_BMC_CHANNEL_IS_LAN(ibs, c) \
+ ((ibs)->lan.channel != 0 && (ibs)->lan.channel == (c))
+
+#define IPMI_BMC_LAN_CFG_CC_PARAM_NOT_SUPPORTED 0x80
+
+#define IPMI_BMC_LAN_CFG_PARAM_SET_IN_PROGRESS 0x00
+#define IPMI_BMC_LAN_CFG_PARAM_AUTH_TYPE_SUPPORT 0x01
+#define IPMI_BMC_LAN_CFG_PARAM_AUTH_TYPE_ENABLES 0x02
+#define IPMI_BMC_LAN_CFG_PARAM_IP_ADDR 0x03
+#define IPMI_BMC_LAN_CFG_PARAM_IP_ADDR_SOURCE 0x04
+#define IPMI_BMC_LAN_CFG_PARAM_MAC_ADDR 0x05
+#define IPMI_BMC_LAN_CFG_PARAM_SUBNET_MASK 0x06
+#define IPMI_BMC_LAN_CFG_PARAM_IPV4_HDR_PARAMS 0x07
+#define IPMI_BMC_LAN_CFG_PARAM_DEFAULT_GW_IP_ADDR 0x0c
+#define IPMI_BMC_LAN_CFG_PARAM_DEFAULT_GW_MAC_ADDR 0x0d
+#define IPMI_BMC_LAN_CFG_PARAM_BACKUP_GW_ADDR 0x0e
+#define IPMI_BMC_LAN_CFG_PARAM_BACKUP_GW_MAC_ADDR 0x0f
+#define IPMI_BMC_LAN_CFG_PARAM_COMMUNITY_STRING 0x10
+#define IPMI_BMC_LAN_CFG_PARAM_NUM_DESTINATIONS 0x11
+
+#define IPMI_BMC_LAN_CFG_PARAMETER_REVISION 0x11
+
+#define IPMI_BMC_LAN_CFG_IS_VALID_IP_SOURCE(v) (0x0 <= (v) && (v) <= 0x4)
+
#define RSP_BUFFER_INITIALIZER { }
static inline void rsp_buffer_pushmore(RspBuffer *rsp, uint8_t *bytes,
@@ -1231,6 +1286,25 @@ static void get_watchdog_timer(IPMIBmcSim *ibs,
}
}
+static void get_channel_access(IPMIBmcSim *ibs,
+ uint8_t *cmd, unsigned int cmd_len,
+ RspBuffer *rsp)
+{
+ uint8_t channel = cmd[2] & 0xf;
+
+ if (channel == IPMI_CHANNEL_IPMB || channel == IPMI_CHANNEL_SYSTEM ||
+ IPMI_BMC_CHANNEL_IS_LAN(ibs, channel)) {
+ /* alerting disabled */
+ /* per message authentication disabled */
+ /* user level authentication disabled */
+ /* channel always available */
+ rsp_buffer_push(rsp, 0x20 | 0x10 | 0x08 | 0x02);
+ rsp_buffer_push(rsp, 0x04); /* privilege limit: ADMINISTRATOR */
+ } else {
+ rsp_buffer_set_error(rsp, IPMI_CC_INVALID_DATA_FIELD);
+ }
+}
+
static void get_channel_info(IPMIBmcSim *ibs,
uint8_t *cmd, unsigned int cmd_len,
RspBuffer *rsp)
@@ -1240,29 +1314,29 @@ static void get_channel_info(IPMIBmcSim *ibs,
IPMIFwInfo info = {};
uint8_t ch = cmd[2] & 0x0f;
- /* Only define channel 0h (IPMB) and Fh (system interface) */
-
if (ch == 0x0e) { /* "This channel" */
ch = IPMI_CHANNEL_SYSTEM;
}
rsp_buffer_push(rsp, ch);
- if (ch != IPMI_CHANNEL_IPMB && ch != IPMI_CHANNEL_SYSTEM) {
- /* Not a supported channel */
- rsp_buffer_set_error(rsp, IPMI_CC_INVALID_DATA_FIELD);
- return;
- }
-
if (k->get_fwinfo) {
k->get_fwinfo(s, &info);
}
+ /* Only define channel 0h (IPMB), LAN, and Fh (system interface) */
if (ch == IPMI_CHANNEL_IPMB) {
rsp_buffer_push(rsp, IPMI_CHANNEL_MEDIUM_IPMB);
rsp_buffer_push(rsp, IPMI_CHANNEL_PROTOCOL_IPMB);
- } else { /* IPMI_CHANNEL_SYSTEM */
+ } else if (IPMI_BMC_CHANNEL_IS_LAN(ibs, ch)) {
+ rsp_buffer_push(rsp, IPMI_CHANNEL_MEDIUM_802_3_LAN);
+ rsp_buffer_push(rsp, IPMI_CHANNEL_PROTOCOL_IPMB);
+ } else if (ch == IPMI_CHANNEL_SYSTEM) {
rsp_buffer_push(rsp, IPMI_CHANNEL_MEDIUM_SYSTEM);
rsp_buffer_push(rsp, info.ipmi_channel_protocol);
+ } else {
+ /* Not a supported channel */
+ rsp_buffer_set_error(rsp, IPMI_CC_INVALID_DATA_FIELD);
+ return;
}
rsp_buffer_push(rsp, 0x00); /* Session-less */
@@ -2045,6 +2119,140 @@ static void set_sensor_reading(IPMIBmcSim *ibs,
}
}
+static inline bool is_valid_netmask(const uint8_t *netmask)
+{
+ uint32_t mask = netmask[3];
+ uint32_t inverted;
+
+ mask |= (uint32_t) netmask[2] << 8;
+ mask |= (uint32_t) netmask[1] << 16;
+ mask |= (uint32_t) netmask[0] << 24;
+ inverted = ~mask;
+ return mask != 0 && (inverted & (inverted + 1)) == 0;
+}
+
+/*
+ * Request data (from cmd[2] to cmd[5] inclusive):
+ * bytes meaning
+ * 1 [bit 7] revision only flag, [bits 3:0] channel number
+ * 2 parameter selector
+ * 3 set selector
+ * 4 block selector
+ */
+static void get_lan_config(IPMIBmcSim *ibs,
+ uint8_t *cmd, unsigned int cmd_len,
+ RspBuffer *rsp)
+{
+ uint8_t channel;
+
+ if (ibs->lan.channel == 0) {
+ /* LAN channel disabled. Fail as if this command were not defined. */
+ rsp_buffer_set_error(rsp, IPMI_CC_INVALID_CMD);
+ return;
+ }
+ if (cmd_len < 6) {
+ rsp_buffer_set_error(rsp, IPMI_CC_REQUEST_DATA_LENGTH_INVALID);
+ return;
+ }
+ channel = cmd[2] & 0xf;
+
+ rsp_buffer_push(rsp, IPMI_BMC_LAN_CFG_PARAMETER_REVISION);
+ if (cmd[2] & 0x80) {
+ /* The requester only requests parameter revision, not the parameter */
+ return;
+ }
+ if (!IPMI_BMC_CHANNEL_IS_LAN(ibs, channel)) {
+ rsp_buffer_set_error(rsp, IPMI_CC_INVALID_DATA_FIELD);
+ return;
+ }
+
+ switch (cmd[3]) {
+ case IPMI_BMC_LAN_CFG_PARAM_SET_IN_PROGRESS:
+ rsp_buffer_push(rsp, 0x0); /* set complete */
+ break;
+
+ case IPMI_BMC_LAN_CFG_PARAM_AUTH_TYPE_SUPPORT:
+ rsp_buffer_push(rsp, 0x01); /* Authentication type "none" supported */
+ break;
+
+ case IPMI_BMC_LAN_CFG_PARAM_AUTH_TYPE_ENABLES:
+ /* Only authentication type "none" enabled */
+ rsp_buffer_push(rsp, 0x01); /* for privilege level "Callback" */
+ rsp_buffer_push(rsp, 0x01); /* for privilege level "User" */
+ rsp_buffer_push(rsp, 0x01); /* for privilege level "Operator" */
+ rsp_buffer_push(rsp, 0x01); /* for privilege level "Administrator" */
+ rsp_buffer_push(rsp, 0x01); /* for privilege level "OEM" */
+ break;
+
+ case IPMI_BMC_LAN_CFG_PARAM_IP_ADDR:
+ rsp_buffer_pushmore(rsp, ibs->lan.ipaddr, NBYTES_IP);
+ break;
+
+ case IPMI_BMC_LAN_CFG_PARAM_IP_ADDR_SOURCE:
+ rsp_buffer_push(rsp, ibs->lan.ipsrc);
+ break;
+
+ case IPMI_BMC_LAN_CFG_PARAM_MAC_ADDR:
+ rsp_buffer_pushmore(rsp, ibs->lan.macaddr.a, NBYTES_MAC);
+ break;
+
+ case IPMI_BMC_LAN_CFG_PARAM_SUBNET_MASK:
+ rsp_buffer_pushmore(rsp, ibs->lan.netmask, NBYTES_IP);
+ break;
+
+ case IPMI_BMC_LAN_CFG_PARAM_IPV4_HDR_PARAMS:
+ /* TTL 0x40 */
+ rsp_buffer_push(rsp, 0x40);
+ /* don't fragment */
+ rsp_buffer_push(rsp, 0x40);
+ /* precedence 0x0, minimize delay */
+ rsp_buffer_push(rsp, 0x10);
+ break;
+
+ case IPMI_BMC_LAN_CFG_PARAM_DEFAULT_GW_IP_ADDR:
+ rsp_buffer_pushmore(rsp, ibs->lan.defgw_ipaddr, NBYTES_IP);
+ break;
+
+ case IPMI_BMC_LAN_CFG_PARAM_DEFAULT_GW_MAC_ADDR:
+ rsp_buffer_pushmore(rsp, ibs->lan.defgw_macaddr.a, NBYTES_MAC);
+ break;
+
+ case IPMI_BMC_LAN_CFG_PARAM_BACKUP_GW_ADDR:
+ /* 0.0.0.0 */
+ rsp_buffer_push(rsp, 0x00);
+ rsp_buffer_push(rsp, 0x00);
+ rsp_buffer_push(rsp, 0x00);
+ rsp_buffer_push(rsp, 0x00);
+ break;
+
+ case IPMI_BMC_LAN_CFG_PARAM_BACKUP_GW_MAC_ADDR:
+ /* 00:00:00:00:00:00 */
+ rsp_buffer_push(rsp, 0x00);
+ rsp_buffer_push(rsp, 0x00);
+ rsp_buffer_push(rsp, 0x00);
+ rsp_buffer_push(rsp, 0x00);
+ rsp_buffer_push(rsp, 0x00);
+ rsp_buffer_push(rsp, 0x00);
+ break;
+
+ case IPMI_BMC_LAN_CFG_PARAM_COMMUNITY_STRING:
+ {
+ static uint8_t community_str[18] = "public";
+
+ rsp_buffer_pushmore(rsp, community_str, sizeof(community_str));
+ }
+ break;
+
+ case IPMI_BMC_LAN_CFG_PARAM_NUM_DESTINATIONS:
+ rsp_buffer_push(rsp, 0x00); /* LAN Alerting not supported */
+ break;
+
+ default:
+ rsp_buffer_set_error(rsp, IPMI_BMC_LAN_CFG_CC_PARAM_NOT_SUPPORTED);
+ return;
+ };
+}
+
static const IPMICmdHandler chassis_cmds[] = {
[IPMI_CMD_GET_CHASSIS_CAPABILITIES] = { chassis_capabilities },
[IPMI_CMD_GET_CHASSIS_STATUS] = { chassis_status },
@@ -2089,6 +2297,7 @@ static const IPMICmdHandler app_cmds[] = {
[IPMI_CMD_RESET_WATCHDOG_TIMER] = { reset_watchdog_timer },
[IPMI_CMD_SET_WATCHDOG_TIMER] = { set_watchdog_timer, 8 },
[IPMI_CMD_GET_WATCHDOG_TIMER] = { get_watchdog_timer },
+ [IPMI_CMD_GET_CHANNEL_ACCESS] = { get_channel_access, 4 },
[IPMI_CMD_GET_CHANNEL_INFO] = { get_channel_info, 3 },
};
static const IPMINetfn app_netfn = {
@@ -2119,12 +2328,22 @@ static const IPMINetfn storage_netfn = {
.cmd_handlers = storage_cmds
};
+static const IPMICmdHandler transport_cmds[] = {
+ [IPMI_CMD_GET_LAN_CONFIG] = { get_lan_config },
+};
+static const IPMINetfn transport_netfn = {
+ .cmd_nums = ARRAY_SIZE(transport_cmds),
+ .cmd_handlers = transport_cmds
+};
+
+
static void register_cmds(IPMIBmcSim *s)
{
ipmi_sim_register_netfn(s, IPMI_NETFN_CHASSIS, &chassis_netfn);
ipmi_sim_register_netfn(s, IPMI_NETFN_SENSOR_EVENT, &sensor_event_netfn);
ipmi_sim_register_netfn(s, IPMI_NETFN_APP, &app_netfn);
ipmi_sim_register_netfn(s, IPMI_NETFN_STORAGE, &storage_netfn);
+ ipmi_sim_register_netfn(s, IPMI_NETFN_TRANSPORT, &transport_netfn);
}
static uint8_t init_sdrs[] = {
@@ -2176,7 +2395,7 @@ static void ipmi_sdr_init(IPMIBmcSim *ibs)
static const VMStateDescription vmstate_ipmi_sim = {
.name = TYPE_IPMI_BMC_SIMULATOR,
- .version_id = 1,
+ .version_id = 2,
.minimum_version_id = 1,
.fields = (const VMStateField[]) {
VMSTATE_UINT8(bmc_global_enables, IPMIBmcSim),
@@ -2198,6 +2417,13 @@ static const VMStateDescription vmstate_ipmi_sim = {
VMSTATE_UINT16(sensors[IPMI_WATCHDOG_SENSOR].deassert_states,
IPMIBmcSim),
VMSTATE_UINT16(sensors[IPMI_WATCHDOG_SENSOR].assert_enable, IPMIBmcSim),
+ VMSTATE_UINT8_V(lan.channel, IPMIBmcSim, 2),
+ VMSTATE_UINT8_ARRAY_V(lan.ipaddr, IPMIBmcSim, NBYTES_IP, 2),
+ VMSTATE_UINT8_V(lan.ipsrc, IPMIBmcSim, 2),
+ VMSTATE_UINT8_ARRAY_V(lan.macaddr.a, IPMIBmcSim, NBYTES_MAC, 2),
+ VMSTATE_UINT8_ARRAY_V(lan.netmask, IPMIBmcSim, NBYTES_IP, 2),
+ VMSTATE_UINT8_ARRAY_V(lan.defgw_ipaddr, IPMIBmcSim, NBYTES_IP, 2),
+ VMSTATE_UINT8_ARRAY_V(lan.defgw_macaddr.a, IPMIBmcSim, NBYTES_MAC, 2),
VMSTATE_END_OF_LIST()
}
};
@@ -2232,6 +2458,47 @@ out:
fru->nentries = size / fru->areasize;
}
+static void ipmi_lan_init(IPMILan *lan, Error **errp)
+{
+ struct in_addr ip;
+
+ /*
+ * `lan->channel` can be either 0 (meaning LAN channel disabled) or
+ * a valid IPMI implementation-specific channel.
+ */
+ if (lan->channel != 0 &&
+ !IPMI_CHANNEL_IS_IMPLEMENTATION_SPECIFIC(lan->channel)) {
+ error_setg(errp, "invalid LAN channel %d", lan->channel);
+ return;
+ }
+ if (lan->arg_ipaddr) {
+ if (inet_pton(AF_INET, lan->arg_ipaddr, &ip) != 1) {
+ error_setg(errp, "invalid ip address '%s'", lan->arg_ipaddr);
+ return;
+ }
+ memcpy(lan->ipaddr, &ip.s_addr, NBYTES_IP);
+ }
+ if (!IPMI_BMC_LAN_CFG_IS_VALID_IP_SOURCE(lan->ipsrc)) {
+ error_setg(errp, "invalid ip source %d", lan->ipsrc);
+ return;
+ }
+ if (lan->arg_netmask) {
+ if (inet_pton(AF_INET, lan->arg_netmask, &ip) != 1 ||
+ !is_valid_netmask((const uint8_t *) &ip.s_addr)) {
+ error_setg(errp, "invalid subnet mask '%s'", lan->arg_netmask);
+ return;
+ }
+ memcpy(lan->netmask, &ip.s_addr, NBYTES_IP);
+ }
+ if (lan->arg_defgw_ipaddr) {
+ if (inet_pton(AF_INET, lan->arg_defgw_ipaddr, &ip) != 1) {
+ error_setg(errp, "invalid ip address '%s'", lan->arg_defgw_ipaddr);
+ return;
+ }
+ memcpy(lan->defgw_ipaddr, &ip.s_addr, NBYTES_IP);
+ }
+}
+
static void ipmi_sim_realize(DeviceState *dev, Error **errp)
{
IPMIBmc *b = IPMI_BMC(dev);
@@ -2259,6 +2526,9 @@ static void ipmi_sim_realize(DeviceState *dev, Error **errp)
ibs->acpi_power_state[1] = 0;
ipmi_init_sensors_from_sdrs(ibs);
+
+ ipmi_lan_init(&ibs->lan, errp);
+
register_cmds(ibs);
ibs->timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, ipmi_timeout, ibs);
@@ -2276,6 +2546,13 @@ static const Property ipmi_sim_properties[] = {
DEFINE_PROP_UINT32("mfg_id", IPMIBmcSim, mfg_id, 0),
DEFINE_PROP_UINT16("product_id", IPMIBmcSim, product_id, 0),
DEFINE_PROP_UUID_NODEFAULT("guid", IPMIBmcSim, uuid),
+ DEFINE_PROP_UINT8("lan.channel", IPMIBmcSim, lan.channel, 0),
+ DEFINE_PROP_STRING("lan.ipaddr", IPMIBmcSim, lan.arg_ipaddr),
+ DEFINE_PROP_UINT8("lan.ipsrc", IPMIBmcSim, lan.ipsrc, 0),
+ DEFINE_PROP_MACADDR("lan.macaddr", IPMIBmcSim, lan.macaddr),
+ DEFINE_PROP_STRING("lan.netmask", IPMIBmcSim, lan.arg_netmask),
+ DEFINE_PROP_STRING("lan.defgw_ipaddr", IPMIBmcSim, lan.arg_defgw_ipaddr),
+ DEFINE_PROP_MACADDR("lan.defgw_macaddr", IPMIBmcSim, lan.defgw_macaddr),
};
static void ipmi_sim_class_init(ObjectClass *oc, const void *data)
diff --git a/include/hw/ipmi/ipmi.h b/include/hw/ipmi/ipmi.h
index cd581aa134..3435d84178 100644
--- a/include/hw/ipmi/ipmi.h
+++ b/include/hw/ipmi/ipmi.h
@@ -45,6 +45,7 @@ enum ipmi_op {
#define IPMI_CHANNEL_IPMB 0x00
#define IPMI_CHANNEL_SYSTEM 0x0f
#define IPMI_CHANNEL_MEDIUM_IPMB 0x01
+#define IPMI_CHANNEL_MEDIUM_802_3_LAN 0x04
#define IPMI_CHANNEL_MEDIUM_SYSTEM 0x0c
#define IPMI_CHANNEL_PROTOCOL_IPMB 0x01
#define IPMI_CHANNEL_PROTOCOL_KCS 0x05
diff --git a/qemu-options.hx b/qemu-options.hx
index 0223ceffeb..100226d84b 100644
--- a/qemu-options.hx
+++ b/qemu-options.hx
@@ -1142,6 +1142,32 @@ SRST
is set, get "Get GUID" command to the BMC will return it.
Otherwise "Get GUID" will return an error.
+ ``lan.channel=val``
+ channel number of the fake LAN channel. It can be 0 or any
+ integer from 0x1 to 0xb inclusive. If set to 0, the LAN channel
+ is disabled, otherwise the LAN channel is enabled at the
+ specified channel number. The default is 0.
+
+ ``lan.ipaddr=addr``
+ the ipv4 address of the BMC LAN channel.
+
+ ``lan.ipsrc=val``
+ the ipv4 address source of the BMC LAN channel. It can be 0
+ (unspecified source), 1 (static address), 2 (DHCP), 3 (BIOS or
+ system software), or 4 (other source). The default is 0.
+
+ ``lan.macaddr=mac``
+ the mac address of the BMC LAN channel.
+
+ ``lan.netmask=mask``
+ the ipv4 subnet mask for the BMC LAN channel.
+
+ ``lan.defgw_ipaddr=addr``
+ the default gateway ipv4 address for the BMC LAN channel.
+
+ ``lan.defgw_macaddr=mac``
+ the default gateway mac address for the BMC LAN channel.
+
``-device ipmi-bmc-extern,id=id,chardev=id[,slave_addr=val]``
Add a connection to an external IPMI BMC simulator. Instead of
locally emulating the BMC like the above item, instead connect to an
diff --git a/tests/qtest/ipmi-kcs-test.c b/tests/qtest/ipmi-kcs-test.c
index 3186c6ad64..d0a207477e 100644
--- a/tests/qtest/ipmi-kcs-test.c
+++ b/tests/qtest/ipmi-kcs-test.c
@@ -262,6 +262,62 @@ static void test_enable_irq(void)
kcs_ints_enabled = 1;
}
+
+static uint8_t get_channel_access_cmd[] = { 0x18, 0x41, 0x01, 0x40 };
+static uint8_t get_channel_access_rsp[] = { 0x1c, 0x41, 0x00, 0x3a, 0x04 };
+
+/*
+ * Get channel access
+ */
+static void test_kcs_channel_access(void)
+{
+ uint8_t rsp[20];
+ unsigned int rsplen = sizeof(rsp);
+
+ kcs_cmd(get_channel_access_cmd, sizeof(get_channel_access_cmd),
+ rsp, &rsplen);
+ g_assert(rsplen == sizeof(get_channel_access_rsp));
+ g_assert(memcmp(get_channel_access_rsp, rsp, rsplen) == 0);
+}
+
+
+static uint8_t get_channel_info_cmd[] = { 0x18, 0x42, 0x01 };
+static uint8_t get_channel_info_rsp[] = { 0x1c, 0x42, 0x00, 0x01, 0x04, 0x01,
+ 0x00, 0xf2, 0x1b, 0x00, 0x00, 0x00 };
+
+/*
+ * Get channel info
+ */
+static void test_kcs_channel_info(void)
+{
+ uint8_t rsp[20];
+ unsigned int rsplen = sizeof(rsp);
+
+ kcs_cmd(get_channel_info_cmd, sizeof(get_channel_info_cmd), rsp, &rsplen);
+ g_assert(rsplen == sizeof(get_channel_info_rsp));
+ g_assert(memcmp(get_channel_info_rsp, rsp, rsplen) == 0);
+}
+
+
+/* get ip address (specified in cmdline): 10.0.0.2 */
+static uint8_t get_ipaddr_cmd[] = { 0x30, 0x02, 0x01, 0x03, 0x00, 0x00 };
+static uint8_t get_ipaddr_rsp[] = { 0x34, 0x02, 0x00, 0x11,
+ 0x0a, 0x00, 0x00, 0x02 };
+
+/*
+ * Get LAN configurations
+ */
+static void test_kcs_lan_get(void)
+{
+ uint8_t rsp[20];
+ unsigned int rsplen = sizeof(rsp);
+
+ kcs_cmd(get_ipaddr_cmd, sizeof(get_ipaddr_cmd), rsp, &rsplen);
+ g_assert(rsplen == sizeof(get_ipaddr_rsp));
+ g_assert(memcmp(get_ipaddr_rsp, rsp, rsplen) == 0);
+}
+
+
int main(int argc, char **argv)
{
char *cmdline;
@@ -271,6 +327,7 @@ int main(int argc, char **argv)
g_test_init(&argc, &argv, NULL);
cmdline = g_strdup_printf("-device ipmi-bmc-sim,id=bmc0"
+ ",lan.channel=1,lan.ipaddr=10.0.0.2"
" -device isa-ipmi-kcs,bmc=bmc0");
qtest_start(cmdline);
g_free(cmdline);
@@ -280,6 +337,9 @@ int main(int argc, char **argv)
qtest_add_func("/ipmi/local/kcs_enable_irq", test_enable_irq);
qtest_add_func("/ipmi/local/kcs_base_irq", test_kcs_base);
qtest_add_func("/ipmi/local/kcs_abort_irq", test_kcs_abort);
+ qtest_add_func("/ipmi/local/kcs_channel_access", test_kcs_channel_access);
+ qtest_add_func("/ipmi/local/kcs_channel_info", test_kcs_channel_info);
+ qtest_add_func("/ipmi/local/kcs_lan_get", test_kcs_lan_get);
ret = g_test_run();
qtest_quit(global_qtest);
--
2.43.7
© 2016 - 2025 Red Hat, Inc.