blob: 37d74d7ee09a7a84e4e09529f06ebc92233e748d [file]
/*
* PXE test cases.
*
* Copyright (c) 2016, 2017 Red Hat Inc.
*
* Authors:
* Michael S. Tsirkin <mst@redhat.com>,
* Victor Kaplansky <victork@redhat.com>
* Thomas Huth <thuth@redhat.com>
*
* This work is licensed under the terms of the GNU GPL, version 2 or later.
* See the COPYING file in the top-level directory.
*/
#include "qemu/osdep.h"
#include <glib/gstdio.h>
#include "libqtest.h"
#include "boot-sector.h"
#include "ppc-util.h"
#define NETNAME "net0"
static char disk[] = "tests/pxe-test-disk-XXXXXX";
typedef struct testdef {
const char *machine; /* Machine type */
const char *model; /* NIC device model */
const char *extra; /* Any additional parameters */
bool (*boot_dev_support)(void); /* optional: boot device support check */
} testdef_t;
static testdef_t x86_tests[] = {
{ "pc", "e1000" },
{ "pc", "virtio-net-pci" },
{ "q35", "e1000e" },
{ "q35", "virtio-net-pci", },
{ NULL },
};
static testdef_t x86_tests_slow[] = {
{ "pc", "ne2k_pci", },
{ "pc", "i82550", },
{ "pc", "rtl8139" },
{ "pc", "vmxnet3" },
{ NULL },
};
static testdef_t ppc64_tests[] = {
{ "pseries", "spapr-vlan",
"-machine vsmt=8," PSERIES_DEFAULT_CAPABILITIES },
{ "pseries", "virtio-net-pci",
"-machine vsmt=8," PSERIES_DEFAULT_CAPABILITIES },
{ NULL },
};
static testdef_t ppc64_tests_slow[] = {
{ "pseries", "e1000",
"-machine vsmt=8," PSERIES_DEFAULT_CAPABILITIES },
{ NULL },
};
static const char *s390_bios_load(gsize *len)
{
static char *cached_contents;
static gsize cached_len;
const char *qemu_bin;
g_autofree char *cmd = NULL;
char dir[PATH_MAX];
char *found = NULL;
char *path = NULL;
FILE *fp;
if (cached_contents) {
g_test_message("Using cached bios contents");
goto out;
}
/* search the qemu binary's data directories for s390-ccw.img */
qemu_bin = qtest_qemu_binary(NULL);
cmd = g_strdup_printf("%s -L help", qemu_bin);
fp = popen(cmd, "r");
if (!fp) {
g_error("Failed to run '%s'", cmd);
}
while (fgets(dir, sizeof(dir), fp) && !found) {
dir[strcspn(dir, "\n")] = '\0';
path = g_build_filename(dir, "s390-ccw.img", NULL);
if (g_file_get_contents(path, &cached_contents, &cached_len, NULL)) {
found = path;
} else {
g_free(path);
}
}
pclose(fp);
if (!found) {
g_error("s390-ccw.img not found");
}
g_test_message("Loaded %s", found);
g_free(found);
out:
*len = cached_len;
return cached_contents;
}
static bool s390_bios_has_string(const char *needle)
{
const char *contents;
gsize len;
size_t needle_len = strlen(needle);
bool found = false;
contents = s390_bios_load(&len);
if (needle_len <= len) {
for (gsize i = 0; i <= len - needle_len; i++) {
if (memcmp(contents + i, needle, needle_len) == 0) {
found = true;
break;
}
}
}
g_test_message("\"%s\" %s in bios", needle, found ? "found" : "not found");
return found;
}
static bool s390_bios_has_net_ccw(void)
{
/*
* Assume that netboot support always includes virtio-net-ccw support.
* Check only that netboot code exists, rather than probing virtio-net-ccw
* support directly.
*/
return s390_bios_has_string("Network boot starting...");
}
static bool s390_bios_has_net_pci(void)
{
/*
* Check for a string unique to virtio-net-pci boot support in the bios
* to determine if the binary was built with support for this device.
*/
return s390_bios_has_string("Setup failed for virtio-net-pci");
}
static testdef_t s390x_tests[] = {
{ "s390-ccw-virtio", "virtio-net-ccw",
.boot_dev_support = s390_bios_has_net_ccw },
{ "s390-ccw-virtio", "virtio-net-pci",
.boot_dev_support = s390_bios_has_net_pci },
{ NULL },
};
static void test_pxe_one(const testdef_t *test, bool ipv6)
{
QTestState *qts;
char *args;
const char *extra = test->extra;
if (!extra) {
extra = "";
}
args = g_strdup_printf(
"-accel kvm -accel tcg -machine %s -nodefaults -boot order=n "
"-netdev user,id=" NETNAME ",tftp=./,bootfile=%s,ipv4=%s,ipv6=%s "
"-device %s,bootindex=1,netdev=" NETNAME " %s",
test->machine, disk, ipv6 ? "off" : "on", ipv6 ? "on" : "off",
test->model, extra);
qts = qtest_init(args);
boot_sector_test(qts);
qtest_quit(qts);
g_free(args);
}
static void test_pxe_ipv4(gconstpointer data)
{
const testdef_t *test = data;
if (test->boot_dev_support && !test->boot_dev_support()) {
g_test_skip("The bios does not support booting this device");
return;
}
test_pxe_one(test, false);
}
static void test_pxe_ipv6(gconstpointer data)
{
const testdef_t *test = data;
if (test->boot_dev_support && !test->boot_dev_support()) {
g_test_skip("The bios does not support booting this device");
return;
}
test_pxe_one(test, true);
}
static void test_batch(const testdef_t *tests, bool ipv6)
{
int i;
for (i = 0; tests[i].machine; i++) {
const testdef_t *test = &tests[i];
char *testname;
if (!qtest_has_machine(test->machine)) {
continue;
}
if (!qtest_has_device(test->model)) {
continue;
}
testname = g_strdup_printf("pxe/ipv4/%s/%s",
test->machine, test->model);
qtest_add_data_func(testname, test, test_pxe_ipv4);
g_free(testname);
if (ipv6) {
testname = g_strdup_printf("pxe/ipv6/%s/%s",
test->machine, test->model);
qtest_add_data_func(testname, test, test_pxe_ipv6);
g_free(testname);
}
}
}
int main(int argc, char *argv[])
{
int ret;
const char *arch = qtest_get_arch();
g_test_init(&argc, &argv, NULL);
if (!qtest_has_accel("tcg") && !qtest_has_accel("kvm")) {
g_test_skip("No KVM or TCG accelerator available");
return 0;
}
ret = boot_sector_init(disk);
if(ret)
return ret;
if (strcmp(arch, "i386") == 0 || strcmp(arch, "x86_64") == 0) {
test_batch(x86_tests, false);
if (g_test_slow()) {
test_batch(x86_tests_slow, false);
}
} else if (strcmp(arch, "ppc64") == 0) {
test_batch(ppc64_tests, g_test_slow());
if (g_test_slow()) {
test_batch(ppc64_tests_slow, true);
}
} else if (g_str_equal(arch, "s390x")) {
test_batch(s390x_tests, g_test_slow());
}
ret = g_test_run();
boot_sector_cleanup(disk);
return ret;
}