xemu-project/xemu
1
0
Fork 0
mirror of https://github.com/xemu-project/xemu.git synced 2024-12-28 15:24:13 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
38033052f6
xemu/tests/ipmi-bt-test.c
Corey Minyard 77cd44b9ec tests:ipmi: Fix IPMI BT tests 
The IPMI BT tests had a race condition, if it receive an IPMI command
to enable interrupt, it would write the message to enable interrupts
after it wrote the command response.  So the test code could
receive the command response and issue the next command before the
device handled the interrupt enable command, and thus no interrupt.

So send the message to enable interrupt before the command response.

Also add some sleeps to give qemu time to handle responses, there was
no delay before, and it could result in an invalid timeout.

And re-enable the tests, as hopefully they are fixed now.

Note that I was unable to reproduce this even with the instructions
Peter gave me, but hopefully this fixes the issue.

Cc: Peter Maydell <peter.maydell@linaro.org>
Signed-off-by: Corey Minyard <cminyard@mvista.com>
2019-09-20 14:08:10 -05:00

426 lines
12 KiB
C
Raw Blame History

/*
* IPMI BT test cases, using the external interface for checking
*
* Copyright (c) 2012 Corey Minyard <cminyard@mvista.com>
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include "qemu/osdep.h"
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <netinet/tcp.h>
#include "libqtest-single.h"
#include "qemu-common.h"
#define IPMI_IRQ 5
#define IPMI_BT_BASE 0xe4
#define IPMI_BT_CTLREG_CLR_WR_PTR 0
#define IPMI_BT_CTLREG_CLR_RD_PTR 1
#define IPMI_BT_CTLREG_H2B_ATN 2
#define IPMI_BT_CTLREG_B2H_ATN 3
#define IPMI_BT_CTLREG_SMS_ATN 4
#define IPMI_BT_CTLREG_H_BUSY 6
#define IPMI_BT_CTLREG_B_BUSY 7
#define IPMI_BT_CTLREG_GET(b) ((bt_get_ctrlreg() >> (b)) & 1)
#define IPMI_BT_CTLREG_GET_H2B_ATN() IPMI_BT_CTLREG_GET(IPMI_BT_CTLREG_H2B_ATN)
#define IPMI_BT_CTLREG_GET_B2H_ATN() IPMI_BT_CTLREG_GET(IPMI_BT_CTLREG_B2H_ATN)
#define IPMI_BT_CTLREG_GET_SMS_ATN() IPMI_BT_CTLREG_GET(IPMI_BT_CTLREG_SMS_ATN)
#define IPMI_BT_CTLREG_GET_H_BUSY() IPMI_BT_CTLREG_GET(IPMI_BT_CTLREG_H_BUSY)
#define IPMI_BT_CTLREG_GET_B_BUSY() IPMI_BT_CTLREG_GET(IPMI_BT_CTLREG_B_BUSY)
#define IPMI_BT_CTLREG_SET(b) bt_write_ctrlreg(1 << (b))
#define IPMI_BT_CTLREG_SET_CLR_WR_PTR() IPMI_BT_CTLREG_SET( \
IPMI_BT_CTLREG_CLR_WR_PTR)
#define IPMI_BT_CTLREG_SET_CLR_RD_PTR() IPMI_BT_CTLREG_SET( \
IPMI_BT_CTLREG_CLR_RD_PTR)
#define IPMI_BT_CTLREG_SET_H2B_ATN() IPMI_BT_CTLREG_SET(IPMI_BT_CTLREG_H2B_ATN)
#define IPMI_BT_CTLREG_SET_B2H_ATN() IPMI_BT_CTLREG_SET(IPMI_BT_CTLREG_B2H_ATN)
#define IPMI_BT_CTLREG_SET_SMS_ATN() IPMI_BT_CTLREG_SET(IPMI_BT_CTLREG_SMS_ATN)
#define IPMI_BT_CTLREG_SET_H_BUSY() IPMI_BT_CTLREG_SET(IPMI_BT_CTLREG_H_BUSY)
static int bt_ints_enabled;
static uint8_t bt_get_ctrlreg(void)
{
return inb(IPMI_BT_BASE);
}
static void bt_write_ctrlreg(uint8_t val)
{
outb(IPMI_BT_BASE, val);
}
static uint8_t bt_get_buf(void)
{
return inb(IPMI_BT_BASE + 1);
}
static void bt_write_buf(uint8_t val)
{
outb(IPMI_BT_BASE + 1, val);
}
static uint8_t bt_get_irqreg(void)
{
return inb(IPMI_BT_BASE + 2);
}
static void bt_write_irqreg(uint8_t val)
{
outb(IPMI_BT_BASE + 2, val);
}
static void bt_wait_b_busy(void)
{
unsigned int count = 1000;
while (IPMI_BT_CTLREG_GET_B_BUSY() != 0) {
g_assert(--count != 0);
usleep(100);
}
}
static void bt_wait_b2h_atn(void)
{
unsigned int count = 1000;
while (IPMI_BT_CTLREG_GET_B2H_ATN() == 0) {
g_assert(--count != 0);
usleep(100);
}
}
static int emu_lfd;
static int emu_fd;
static in_port_t emu_port;
static uint8_t inbuf[100];
static unsigned int inbuf_len;
static unsigned int inbuf_pos;
static int last_was_aa;
static void read_emu_data(void)
{
fd_set readfds;
int rv;
struct timeval tv;
FD_ZERO(&readfds);
FD_SET(emu_fd, &readfds);
tv.tv_sec = 10;
tv.tv_usec = 0;
rv = select(emu_fd + 1, &readfds, NULL, NULL, &tv);
if (rv == -1) {
perror("select");
}
g_assert(rv == 1);
rv = read(emu_fd, inbuf, sizeof(inbuf));
if (rv == -1) {
perror("read");
}
g_assert(rv > 0);
inbuf_len = rv;
inbuf_pos = 0;
}
static void write_emu_msg(uint8_t *msg, unsigned int len)
{
int rv;
#ifdef DEBUG_TEST
{
unsigned int i;
printf("sending:");
for (i = 0; i < len; i++) {
printf(" %2.2x", msg[i]);
}
printf("\n");
}
#endif
rv = write(emu_fd, msg, len);
g_assert(rv == len);
}
static void get_emu_msg(uint8_t *msg, unsigned int *len)
{
unsigned int outpos = 0;
for (;;) {
while (inbuf_pos < inbuf_len) {
uint8_t ch = inbuf[inbuf_pos++];
g_assert(outpos < *len);
if (last_was_aa) {
assert(ch & 0x10);
msg[outpos++] = ch & ~0x10;
last_was_aa = 0;
} else if (ch == 0xaa) {
last_was_aa = 1;
} else {
msg[outpos++] = ch;
if ((ch == 0xa0) || (ch == 0xa1)) {
/* Message complete */
*len = outpos;
goto done;
}
}
}
read_emu_data();
}
done:
#ifdef DEBUG_TEST
{
unsigned int i;
printf("Msg:");
for (i = 0; i < outpos; i++) {
printf(" %2.2x", msg[i]);
}
printf("\n");
}
#endif
return;
}
static uint8_t
ipmb_checksum(const unsigned char *data, int size, unsigned char start)
{
unsigned char csum = start;
for (; size > 0; size--, data++) {
csum += *data;
}
return csum;
}
static uint8_t get_dev_id_cmd[] = { 0x18, 0x01 };
static uint8_t get_dev_id_rsp[] = { 0x1c, 0x01, 0x00, 0x20, 0x00, 0x00, 0x00,
0x02, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00 };
static uint8_t set_bmc_globals_cmd[] = { 0x18, 0x2e, 0x0f };
static uint8_t set_bmc_globals_rsp[] = { 0x1c, 0x2e, 0x00 };
static uint8_t enable_irq_cmd[] = { 0x05, 0xa1 };
static void emu_msg_handler(void)
{
uint8_t msg[100];
unsigned int msg_len = sizeof(msg);
get_emu_msg(msg, &msg_len);
g_assert(msg_len >= 5);
g_assert(msg[msg_len - 1] == 0xa0);
msg_len--;
g_assert(ipmb_checksum(msg, msg_len, 0) == 0);
msg_len--;
if ((msg[1] == get_dev_id_cmd[0]) && (msg[2] == get_dev_id_cmd[1])) {
memcpy(msg + 1, get_dev_id_rsp, sizeof(get_dev_id_rsp));
msg_len = sizeof(get_dev_id_rsp) + 1;
msg[msg_len] = -ipmb_checksum(msg, msg_len, 0);
msg_len++;
msg[msg_len++] = 0xa0;
write_emu_msg(msg, msg_len);
} else if ((msg[1] == set_bmc_globals_cmd[0]) &&
(msg[2] == set_bmc_globals_cmd[1])) {
write_emu_msg(enable_irq_cmd, sizeof(enable_irq_cmd));
memcpy(msg + 1, set_bmc_globals_rsp, sizeof(set_bmc_globals_rsp));
msg_len = sizeof(set_bmc_globals_rsp) + 1;
msg[msg_len] = -ipmb_checksum(msg, msg_len, 0);
msg_len++;
msg[msg_len++] = 0xa0;
write_emu_msg(msg, msg_len);
} else {
g_assert(0);
}
}
static void bt_cmd(uint8_t *cmd, unsigned int cmd_len,
uint8_t *rsp, unsigned int *rsp_len)
{
unsigned int i, len, j = 0;
uint8_t seq = 5;
/* Should be idle */
g_assert(bt_get_ctrlreg() == 0);
bt_wait_b_busy();
IPMI_BT_CTLREG_SET_CLR_WR_PTR();
bt_write_buf(cmd_len + 1);
bt_write_buf(cmd[0]);
bt_write_buf(seq);
for (i = 1; i < cmd_len; i++) {
bt_write_buf(cmd[i]);
}
IPMI_BT_CTLREG_SET_H2B_ATN();
emu_msg_handler(); /* We should get a message on the socket here. */
bt_wait_b2h_atn();
if (bt_ints_enabled) {
g_assert((bt_get_irqreg() & 0x02) == 0x02);
g_assert(get_irq(IPMI_IRQ));
bt_write_irqreg(0x03);
} else {
g_assert(!get_irq(IPMI_IRQ));
}
IPMI_BT_CTLREG_SET_H_BUSY();
IPMI_BT_CTLREG_SET_B2H_ATN();
IPMI_BT_CTLREG_SET_CLR_RD_PTR();
len = bt_get_buf();
g_assert(len >= 4);
rsp[0] = bt_get_buf();
assert(bt_get_buf() == seq);
len--;
for (j = 1; j < len; j++) {
rsp[j] = bt_get_buf();
}
IPMI_BT_CTLREG_SET_H_BUSY();
*rsp_len = j;
}
/*
* We should get a connect request and a short message with capabilities.
*/
static void test_connect(void)
{
fd_set readfds;
int rv;
int val;
struct timeval tv;
uint8_t msg[100];
unsigned int msglen;
static uint8_t exp1[] = { 0xff, 0x01, 0xa1 }; /* A protocol version */
static uint8_t exp2[] = { 0x08, 0x3f, 0xa1 }; /* A capabilities cmd */
FD_ZERO(&readfds);
FD_SET(emu_lfd, &readfds);
tv.tv_sec = 10;
tv.tv_usec = 0;
rv = select(emu_lfd + 1, &readfds, NULL, NULL, &tv);
g_assert(rv == 1);
emu_fd = accept(emu_lfd, NULL, 0);
if (emu_fd < 0) {
perror("accept");
}
g_assert(emu_fd >= 0);
val = 1;
rv = setsockopt(emu_fd, IPPROTO_TCP, TCP_NODELAY, &val, sizeof(val));
g_assert(rv != -1);
/* Report our version */
write_emu_msg(exp1, sizeof(exp1));
/* Validate that we get the info we expect. */
msglen = sizeof(msg);
get_emu_msg(msg, &msglen);
g_assert(msglen == sizeof(exp1));
g_assert(memcmp(msg, exp1, msglen) == 0);
msglen = sizeof(msg);
get_emu_msg(msg, &msglen);
g_assert(msglen == sizeof(exp2));
g_assert(memcmp(msg, exp2, msglen) == 0);
}
/*
* Send a get_device_id to do a basic test.
*/
static void test_bt_base(void)
{
uint8_t rsp[20];
unsigned int rsplen = sizeof(rsp);
bt_cmd(get_dev_id_cmd, sizeof(get_dev_id_cmd), rsp, &rsplen);
g_assert(rsplen == sizeof(get_dev_id_rsp));
g_assert(memcmp(get_dev_id_rsp, rsp, rsplen) == 0);
}
/*
* Enable IRQs for the interface.
*/
static void test_enable_irq(void)
{
uint8_t rsp[20];
unsigned int rsplen = sizeof(rsp);
bt_cmd(set_bmc_globals_cmd, sizeof(set_bmc_globals_cmd), rsp, &rsplen);
g_assert(rsplen == sizeof(set_bmc_globals_rsp));
g_assert(memcmp(set_bmc_globals_rsp, rsp, rsplen) == 0);
bt_write_irqreg(0x01);
bt_ints_enabled = 1;
}
/*
* Create a local TCP socket with any port, then save off the port we got.
*/
static void open_socket(void)
{
struct sockaddr_in myaddr;
socklen_t addrlen;
myaddr.sin_family = AF_INET;
myaddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
myaddr.sin_port = 0;
emu_lfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (emu_lfd == -1) {
perror("socket");
exit(1);
}
if (bind(emu_lfd, (struct sockaddr *) &myaddr, sizeof(myaddr)) == -1) {
perror("bind");
exit(1);
}
addrlen = sizeof(myaddr);
if (getsockname(emu_lfd, (struct sockaddr *) &myaddr , &addrlen) == -1) {
perror("getsockname");
exit(1);
}
emu_port = ntohs(myaddr.sin_port);
assert(listen(emu_lfd, 1) != -1);
}
int main(int argc, char **argv)
{
int ret;
open_socket();
/* Run the tests */
g_test_init(&argc, &argv, NULL);
global_qtest = qtest_initf(
" -chardev socket,id=ipmi0,host=localhost,port=%d,reconnect=10"
" -device ipmi-bmc-extern,chardev=ipmi0,id=bmc0"
" -device isa-ipmi-bt,bmc=bmc0", emu_port);
qtest_irq_intercept_in(global_qtest, "ioapic");
qtest_add_func("/ipmi/extern/connect", test_connect);
qtest_add_func("/ipmi/extern/bt_base", test_bt_base);
qtest_add_func("/ipmi/extern/bt_enable_irq", test_enable_irq);
qtest_add_func("/ipmi/extern/bt_base_irq", test_bt_base);
ret = g_test_run();
qtest_quit(global_qtest);
return ret;
}
Reference in New Issue View Git Blame Copy Permalink