| /* |
| * 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(); |
| |
| } |
| |