You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
363 lines
9.1 KiB
363 lines
9.1 KiB
/*
|
|
* Copyright © 2016-2017 Intel Corporation
|
|
*
|
|
* 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.
|
|
*/
|
|
|
|
/*
|
|
* This program is intended for testing of validate GVT-g virtual machine
|
|
* creation of allow for testing of KVMGT / XenGT (the tool should be root
|
|
* privilege only).
|
|
*
|
|
* TODO:
|
|
* Enable more GVT-g related test cases.
|
|
*/
|
|
#include "config.h"
|
|
|
|
#include "igt.h"
|
|
#include <errno.h>
|
|
#include <getopt.h>
|
|
#include <math.h>
|
|
#include <stdint.h>
|
|
#include <stdbool.h>
|
|
#include <strings.h>
|
|
#include <unistd.h>
|
|
#include <termios.h>
|
|
#include <sys/poll.h>
|
|
#include <sys/time.h>
|
|
#include <sys/ioctl.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <signal.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <time.h>
|
|
#include <unistd.h>
|
|
#include <pwd.h>
|
|
#include <limits.h>
|
|
#include <dirent.h>
|
|
|
|
#define RANDOM(x) (rand() % x)
|
|
|
|
|
|
static char uuid[40];
|
|
static char guest_ip[32];
|
|
|
|
static char mac_addr[20] = {0};
|
|
static char qemu_path[PATH_MAX] = {0};
|
|
static char hda_path[PATH_MAX] = {0};
|
|
static char bios_path[PATH_MAX] = {0};
|
|
|
|
static int super_system(const char *cmd, char *retmsg, int msg_len)
|
|
{
|
|
FILE *fp;
|
|
int res = -1;
|
|
if (cmd == NULL || retmsg == NULL || msg_len < 0) {
|
|
igt_info("Error: %s system parameter invalid!\n", __func__);
|
|
return 1;
|
|
}
|
|
fp = popen(cmd, "r");
|
|
if (fp == NULL) {
|
|
perror("popen");
|
|
igt_info("Error: %s popen error: %s\n", __func__, strerror(errno));
|
|
return 2;
|
|
} else {
|
|
memset(retmsg, 0, msg_len);
|
|
while (fgets(retmsg, msg_len, fp)) {
|
|
;
|
|
}
|
|
res = pclose(fp);
|
|
if (res == -1) {
|
|
igt_info("Error:%s close popen file pointer fp error!\n", __func__);
|
|
return 3;
|
|
}
|
|
retmsg[strlen(retmsg) - 1] = '\0';
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
static int check_gvtg_support(void)
|
|
{
|
|
DIR *mdevdir = opendir("/sys/bus/pci/devices/0000:00:02.0/"
|
|
"mdev_supported_types");
|
|
|
|
if (mdevdir == NULL) {
|
|
return 1;
|
|
}
|
|
closedir(mdevdir);
|
|
return 0;
|
|
}
|
|
|
|
static int check_tools(void)
|
|
{
|
|
if (system("which uuidgen > /dev/null") != 0) {
|
|
return 1;
|
|
} else if (system("which arp-scan > /dev/null") != 0) {
|
|
return 2;
|
|
} else if (system("which /etc/qemu-ifup > /dev/null") != 0) {
|
|
return 3;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static void create_guest(void)
|
|
{
|
|
unsigned int max_size_cmd = 4 * PATH_MAX;
|
|
char *command;
|
|
|
|
command = malloc(max_size_cmd);
|
|
if (!command)
|
|
return;
|
|
|
|
sprintf(command, "qemu-img create -b %s -f qcow2 %s.qcow2",
|
|
hda_path, hda_path);
|
|
igt_assert_eq(system(command), 0);
|
|
|
|
sprintf(command, "echo \"%s\" > /sys/bus/pci/devices/0000:00:02.0/"
|
|
"mdev_supported_types/$(ls /sys/bus/pci/devices/0000:00:02.0/"
|
|
"mdev_supported_types |awk {'print $1'}|tail -1)/create", uuid);
|
|
igt_assert_eq(system(command), 0);
|
|
|
|
sprintf(command, "%s -m 2048 -smp 2 -M pc -name gvtg_guest"
|
|
" -hda %s.qcow2 -bios %s -enable-kvm --net nic,macaddr=%s -net"
|
|
" tap,script=/etc/qemu-ifup -vga cirrus -k en-us"
|
|
" -serial stdio -vnc :1 -machine kernel_irqchip=on -global"
|
|
" PIIX4_PM.disable_s3=1 -global PIIX4_PM.disable_s4=1 -cpu host"
|
|
" -usb -usbdevice tablet -device vfio-pci,sysfsdev="
|
|
"/sys/bus/pci/devices/0000:00:02.0/%s &",
|
|
qemu_path, hda_path, bios_path, mac_addr, uuid);
|
|
igt_assert_eq(system(command), 0);
|
|
|
|
free(command);
|
|
}
|
|
|
|
static void destroy_all_guest(void)
|
|
{
|
|
int ret = system("pkill qemu");
|
|
|
|
igt_assert(ret >= 0 && WIFEXITED(ret));
|
|
igt_assert(WEXITSTATUS(ret) == 0 || WEXITSTATUS(ret) == 1);
|
|
}
|
|
|
|
static void remove_vgpu(void)
|
|
{
|
|
char cmd[128] = {0};
|
|
sprintf(cmd, "echo 1 > /sys/bus/pci/devices/0000:00:02.0/%s/remove", uuid);
|
|
igt_assert_eq(system(cmd), 0);
|
|
}
|
|
|
|
static void gen_mac_addr(void)
|
|
{
|
|
srand(getpid());
|
|
sprintf(mac_addr, "52:54:00:%02X:%02X:%02X", RANDOM(256), RANDOM(256),
|
|
RANDOM(256));
|
|
}
|
|
|
|
static void gen_uuid(void)
|
|
{
|
|
igt_assert_eq(super_system("uuidgen", uuid, sizeof(uuid)), 0);
|
|
}
|
|
|
|
static char *fetch_ip_by_mac(char *mac)
|
|
{
|
|
char cmd[1024] = {0};
|
|
sprintf(cmd, "arp-scan -l -I $(ip addr show|grep inet|grep global|"
|
|
"awk '{print $NF;}')|grep -i %s|awk '{print $1}'", mac);
|
|
igt_assert_eq(super_system(cmd, guest_ip, sizeof(guest_ip)), 0);
|
|
return guest_ip;
|
|
}
|
|
|
|
static int check_guest_ip(void)
|
|
{
|
|
int timeout = 0;
|
|
while (timeout <= 12) {
|
|
igt_info("Trying to connect guest, attempt %d.\n", timeout);
|
|
if (timeout == 12) {
|
|
igt_info("Cannot connect to guest.\n");
|
|
return 1;
|
|
break;
|
|
}
|
|
|
|
fetch_ip_by_mac(mac_addr);
|
|
|
|
if (guest_ip[0] != '\0') {
|
|
igt_info("Fetched guest ip address: %s.\n", guest_ip);
|
|
break;
|
|
}
|
|
timeout++;
|
|
sleep(5);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static void clear_dmesg(void)
|
|
{
|
|
igt_assert_eq(system("dmesg -c > /dev/null"), 0);
|
|
}
|
|
|
|
static int check_dmesg(void)
|
|
{
|
|
char errorlog[PATH_MAX] = {0};
|
|
|
|
igt_assert_eq(super_system("dmesg|grep -E \"GPU HANG|gfx reset|BUG\"",
|
|
errorlog, sizeof(errorlog)), 0);
|
|
|
|
if (errorlog[0] == '\0') {
|
|
return 0;
|
|
} else {
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
static void print_help(void)
|
|
{
|
|
igt_info("\n[options]\n"
|
|
"-h, --help display usage\n"
|
|
"-q, --qemu the qemu path\n"
|
|
"-a, --hda the hda raw image / qcow path\n"
|
|
"-b, --bios the seabios path\n\n"
|
|
"[example]\n"
|
|
" ./intel_gvtg_test -q /usr/bin/qemu-system-x86_64 -a "
|
|
"/home/img/ubuntu-16.04.img -b /usr/bin/bios.bin\n"
|
|
);
|
|
}
|
|
|
|
static void arg_mismatch(const char *arg)
|
|
{
|
|
igt_info("argument mismatch: %s\n", arg);
|
|
}
|
|
|
|
int main(int argc, char *argv[])
|
|
{
|
|
int opt = -1;
|
|
const char *optstring = "hq:a:b:";
|
|
static struct option long_options[] = {
|
|
{"help", 0, NULL, 'h'},
|
|
{"qemu", 1, NULL, 'q'},
|
|
{"hda", 1, NULL, 'a'},
|
|
{"bios", 1, NULL, 'b'},
|
|
{0, 0, 0, 0}
|
|
};
|
|
|
|
int ret = 0;
|
|
int flag_cnt = 0;
|
|
int h_flag = 0;
|
|
int q_flag = 0;
|
|
int a_flag = 0;
|
|
int b_flag = 0;
|
|
int tools_status = 0;
|
|
|
|
igt_skip_on_f(check_gvtg_support() == 1,
|
|
"GVT-g technology is not supported in your system.\n");
|
|
|
|
tools_status = check_tools();
|
|
igt_skip_on_f(tools_status == 1, "Please install the \"uuid-runtime\" tool.\n");
|
|
igt_skip_on_f(tools_status == 2, "Please install the \"arp-scan\" tool.\n");
|
|
igt_skip_on_f(tools_status == 3, "Please prepare the \"qemu-ifup\" script.\n");
|
|
|
|
if (argc == 1) {
|
|
print_help();
|
|
return 0;
|
|
}
|
|
|
|
while ((opt = getopt_long(argc, argv, optstring, long_options, NULL))
|
|
!= -1) {
|
|
switch (opt) {
|
|
case 'h':
|
|
h_flag = 1;
|
|
break;
|
|
case 'q':
|
|
strcpy(qemu_path, optarg);
|
|
q_flag = 1;
|
|
break;
|
|
case 'a':
|
|
strcpy(hda_path, optarg);
|
|
a_flag = 1;
|
|
break;
|
|
case 'b':
|
|
strcpy(bios_path, optarg);
|
|
b_flag = 1;
|
|
break;
|
|
case ':':
|
|
ret = -1;
|
|
break;
|
|
case '?':
|
|
ret = -1;
|
|
break;
|
|
}
|
|
|
|
if (ret) {
|
|
break;
|
|
}
|
|
};
|
|
|
|
if (ret != 0) {
|
|
return ret;
|
|
}
|
|
|
|
flag_cnt = h_flag + q_flag + a_flag + b_flag;
|
|
|
|
if (flag_cnt == 1) {
|
|
if (h_flag == 1) {
|
|
print_help();
|
|
return 0;
|
|
} else {
|
|
arg_mismatch(argv[1]);
|
|
return -1;
|
|
}
|
|
} else if (flag_cnt == 3) {
|
|
if (q_flag == 1 && a_flag == 1 && b_flag == 1) {
|
|
igt_info("\nqemu_path: %s\nhda_path: %s\nbios_path: %s\n",
|
|
qemu_path, hda_path, bios_path);
|
|
} else {
|
|
arg_mismatch("-h");
|
|
return -1;
|
|
}
|
|
} else {
|
|
arg_mismatch(argv[1]);
|
|
return -1;
|
|
}
|
|
|
|
destroy_all_guest();
|
|
clear_dmesg();
|
|
|
|
gen_mac_addr();
|
|
gen_uuid();
|
|
create_guest();
|
|
|
|
if (check_guest_ip()) {
|
|
ret = 1;
|
|
}
|
|
|
|
destroy_all_guest();
|
|
sleep(5);
|
|
remove_vgpu();
|
|
|
|
if (check_dmesg() > 0) {
|
|
ret = 1;
|
|
}
|
|
|
|
igt_assert_eq(ret, 0);
|
|
igt_exit();
|
|
|
|
}
|
|
|