415 lines
18 KiB
Diff
415 lines
18 KiB
Diff
|
From d8ca5e0a429b8f7395e136e713980db6a7ac8dc2 Mon Sep 17 00:00:00 2001
|
||
|
|
From: Mohammed Gamal <mgamal@redhat.com>
|
||
|
|
Date: Wed, 15 Apr 2020 12:00:30 +0200
|
||
|
|
Subject: [PATCH 2/2] Add vmbus_testing tool build files
|
||
|
|
|
||
|
|
RH-Author: Mohammed Gamal <mgamal@redhat.com>
|
||
|
|
Message-id: <20200414183955.194006-3-mgamal@redhat.com>
|
||
|
|
Patchwork-id: 94690
|
||
|
|
O-Subject: [RHEL8.3 virt hyperv-daemons PATCH v5 2/2] Add vmbus_testing tool build files
|
||
|
|
Bugzilla: 1816750
|
||
|
|
RH-Acked-by: Vitaly Kuznetsov <vkuznets@redhat.com>
|
||
|
|
RH-Acked-by: Cathy Avery <cavery@redhat.com>
|
||
|
|
|
||
|
|
Add the vmbus_testing tool to redhat build dirs
|
||
|
|
|
||
|
|
Signed-off-by: Mohammed Gamal <mgamal@redhat.com>
|
||
|
|
---
|
||
|
|
redhat/hyperv-daemons.spec.template | 2 +
|
||
|
|
vmbus_testing | 376 ++++++++++++++++++++++++++++
|
||
|
|
2 files changed, 378 insertions(+)
|
||
|
|
create mode 100755 vmbus_testing
|
||
|
|
|
||
|
|
Signed-off-by: Miroslav Rezanina <mrezanin@redhat.com>
|
||
|
|
---
|
||
|
|
redhat/hyperv-daemons.spec.template | 2 +
|
||
|
|
vmbus_testing | 376 ++++++++++++++++++++++++++++++++++++
|
||
|
|
2 files changed, 378 insertions(+)
|
||
|
|
create mode 100755 vmbus_testing
|
||
|
|
|
||
|
|
diff --git a/vmbus_testing b/vmbus_testing
|
||
|
|
new file mode 100755
|
||
|
|
index 0000000..e721290
|
||
|
|
--- /dev/null
|
||
|
|
+++ b/vmbus_testing
|
||
|
|
@@ -0,0 +1,376 @@
|
||
|
|
+#!/usr/bin/env python3
|
||
|
|
+# SPDX-License-Identifier: GPL-2.0
|
||
|
|
+#
|
||
|
|
+# Program to allow users to fuzz test Hyper-V drivers
|
||
|
|
+# by interfacing with Hyper-V debugfs attributes.
|
||
|
|
+# Current test methods available:
|
||
|
|
+# 1. delay testing
|
||
|
|
+#
|
||
|
|
+# Current file/directory structure of hyper-V debugfs:
|
||
|
|
+# /sys/kernel/debug/hyperv/UUID
|
||
|
|
+# /sys/kernel/debug/hyperv/UUID/<test-state filename>
|
||
|
|
+# /sys/kernel/debug/hyperv/UUID/<test-method sub-directory>
|
||
|
|
+#
|
||
|
|
+# author: Branden Bonaby <brandonbonaby94@gmail.com>
|
||
|
|
+
|
||
|
|
+import os
|
||
|
|
+import cmd
|
||
|
|
+import argparse
|
||
|
|
+import glob
|
||
|
|
+from argparse import RawDescriptionHelpFormatter
|
||
|
|
+from argparse import RawTextHelpFormatter
|
||
|
|
+from enum import Enum
|
||
|
|
+
|
||
|
|
+# Do not change unless, you change the debugfs attributes
|
||
|
|
+# in /drivers/hv/debugfs.c. All fuzz testing
|
||
|
|
+# attributes will start with "fuzz_test".
|
||
|
|
+
|
||
|
|
+# debugfs path for hyperv must exist before proceeding
|
||
|
|
+debugfs_hyperv_path = "/sys/kernel/debug/hyperv"
|
||
|
|
+if not os.path.isdir(debugfs_hyperv_path):
|
||
|
|
+ print("{} doesn't exist/check permissions".format(debugfs_hyperv_path))
|
||
|
|
+ exit(-1)
|
||
|
|
+
|
||
|
|
+class dev_state(Enum):
|
||
|
|
+ off = 0
|
||
|
|
+ on = 1
|
||
|
|
+
|
||
|
|
+# File names, that correspond to the files created in
|
||
|
|
+# /drivers/hv/debugfs.c
|
||
|
|
+class f_names(Enum):
|
||
|
|
+ state_f = "fuzz_test_state"
|
||
|
|
+ buff_f = "fuzz_test_buffer_interrupt_delay"
|
||
|
|
+ mess_f = "fuzz_test_message_delay"
|
||
|
|
+
|
||
|
|
+# Both single_actions and all_actions are used
|
||
|
|
+# for error checking and to allow for some subparser
|
||
|
|
+# names to be abbreviated. Do not abbreviate the
|
||
|
|
+# test method names, as it will become less intuitive
|
||
|
|
+# as to what the user can do. If you do decide to
|
||
|
|
+# abbreviate the test method name, make sure the main
|
||
|
|
+# function reflects this change.
|
||
|
|
+
|
||
|
|
+all_actions = [
|
||
|
|
+ "disable_all",
|
||
|
|
+ "D",
|
||
|
|
+ "enable_all",
|
||
|
|
+ "view_all",
|
||
|
|
+ "V"
|
||
|
|
+]
|
||
|
|
+
|
||
|
|
+single_actions = [
|
||
|
|
+ "disable_single",
|
||
|
|
+ "d",
|
||
|
|
+ "enable_single",
|
||
|
|
+ "view_single",
|
||
|
|
+ "v"
|
||
|
|
+]
|
||
|
|
+
|
||
|
|
+def main():
|
||
|
|
+
|
||
|
|
+ file_map = recursive_file_lookup(debugfs_hyperv_path, dict())
|
||
|
|
+ args = parse_args()
|
||
|
|
+ if (not args.action):
|
||
|
|
+ print ("Error, no options selected...exiting")
|
||
|
|
+ exit(-1)
|
||
|
|
+ arg_set = { k for (k,v) in vars(args).items() if v and k != "action" }
|
||
|
|
+ arg_set.add(args.action)
|
||
|
|
+ path = args.path if "path" in arg_set else None
|
||
|
|
+ if (path and path[-1] == "/"):
|
||
|
|
+ path = path[:-1]
|
||
|
|
+ validate_args_path(path, arg_set, file_map)
|
||
|
|
+ if (path and "enable_single" in arg_set):
|
||
|
|
+ state_path = locate_state(path, file_map)
|
||
|
|
+ set_test_state(state_path, dev_state.on.value, args.quiet)
|
||
|
|
+
|
||
|
|
+ # Use subparsers as the key for different actions
|
||
|
|
+ if ("delay" in arg_set):
|
||
|
|
+ validate_delay_values(args.delay_time)
|
||
|
|
+ if (args.enable_all):
|
||
|
|
+ set_delay_all_devices(file_map, args.delay_time,
|
||
|
|
+ args.quiet)
|
||
|
|
+ else:
|
||
|
|
+ set_delay_values(path, file_map, args.delay_time,
|
||
|
|
+ args.quiet)
|
||
|
|
+ elif ("disable_all" in arg_set or "D" in arg_set):
|
||
|
|
+ disable_all_testing(file_map)
|
||
|
|
+ elif ("disable_single" in arg_set or "d" in arg_set):
|
||
|
|
+ disable_testing_single_device(path, file_map)
|
||
|
|
+ elif ("view_all" in arg_set or "V" in arg_set):
|
||
|
|
+ get_all_devices_test_status(file_map)
|
||
|
|
+ elif ("view_single" in arg_set or "v" in arg_set):
|
||
|
|
+ get_device_test_values(path, file_map)
|
||
|
|
+
|
||
|
|
+# Get the state location
|
||
|
|
+def locate_state(device, file_map):
|
||
|
|
+ return file_map[device][f_names.state_f.value]
|
||
|
|
+
|
||
|
|
+# Validate delay values to make sure they are acceptable to
|
||
|
|
+# enable delays on a device
|
||
|
|
+def validate_delay_values(delay):
|
||
|
|
+
|
||
|
|
+ if (delay[0] == -1 and delay[1] == -1):
|
||
|
|
+ print("\nError, At least 1 value must be greater than 0")
|
||
|
|
+ exit(-1)
|
||
|
|
+ for i in delay:
|
||
|
|
+ if (i < -1 or i == 0 or i > 1000):
|
||
|
|
+ print("\nError, Values must be equal to -1 "
|
||
|
|
+ "or be > 0 and <= 1000")
|
||
|
|
+ exit(-1)
|
||
|
|
+
|
||
|
|
+# Validate argument path
|
||
|
|
+def validate_args_path(path, arg_set, file_map):
|
||
|
|
+
|
||
|
|
+ if (not path and any(element in arg_set for element in single_actions)):
|
||
|
|
+ print("Error, path (-p) REQUIRED for the specified option. "
|
||
|
|
+ "Use (-h) to check usage.")
|
||
|
|
+ exit(-1)
|
||
|
|
+ elif (path and any(item in arg_set for item in all_actions)):
|
||
|
|
+ print("Error, path (-p) NOT REQUIRED for the specified option. "
|
||
|
|
+ "Use (-h) to check usage." )
|
||
|
|
+ exit(-1)
|
||
|
|
+ elif (path not in file_map and any(item in arg_set
|
||
|
|
+ for item in single_actions)):
|
||
|
|
+ print("Error, path '{}' not a valid vmbus device".format(path))
|
||
|
|
+ exit(-1)
|
||
|
|
+
|
||
|
|
+# display Testing status of single device
|
||
|
|
+def get_device_test_values(path, file_map):
|
||
|
|
+
|
||
|
|
+ for name in file_map[path]:
|
||
|
|
+ file_location = file_map[path][name]
|
||
|
|
+ print( name + " = " + str(read_test_files(file_location)))
|
||
|
|
+
|
||
|
|
+# Create a map of the vmbus devices and their associated files
|
||
|
|
+# [key=device, value = [key = filename, value = file path]]
|
||
|
|
+def recursive_file_lookup(path, file_map):
|
||
|
|
+
|
||
|
|
+ for f_path in glob.iglob(path + '**/*'):
|
||
|
|
+ if (os.path.isfile(f_path)):
|
||
|
|
+ if (f_path.rsplit("/",2)[0] == debugfs_hyperv_path):
|
||
|
|
+ directory = f_path.rsplit("/",1)[0]
|
||
|
|
+ else:
|
||
|
|
+ directory = f_path.rsplit("/",2)[0]
|
||
|
|
+ f_name = f_path.split("/")[-1]
|
||
|
|
+ if (file_map.get(directory)):
|
||
|
|
+ file_map[directory].update({f_name:f_path})
|
||
|
|
+ else:
|
||
|
|
+ file_map[directory] = {f_name:f_path}
|
||
|
|
+ elif (os.path.isdir(f_path)):
|
||
|
|
+ recursive_file_lookup(f_path,file_map)
|
||
|
|
+ return file_map
|
||
|
|
+
|
||
|
|
+# display Testing state of devices
|
||
|
|
+def get_all_devices_test_status(file_map):
|
||
|
|
+
|
||
|
|
+ for device in file_map:
|
||
|
|
+ if (get_test_state(locate_state(device, file_map)) is 1):
|
||
|
|
+ print("Testing = ON for: {}"
|
||
|
|
+ .format(device.split("/")[5]))
|
||
|
|
+ else:
|
||
|
|
+ print("Testing = OFF for: {}"
|
||
|
|
+ .format(device.split("/")[5]))
|
||
|
|
+
|
||
|
|
+# read the vmbus device files, path must be absolute path before calling
|
||
|
|
+def read_test_files(path):
|
||
|
|
+ try:
|
||
|
|
+ with open(path,"r") as f:
|
||
|
|
+ file_value = f.readline().strip()
|
||
|
|
+ return int(file_value)
|
||
|
|
+
|
||
|
|
+ except IOError as e:
|
||
|
|
+ errno, strerror = e.args
|
||
|
|
+ print("I/O error({0}): {1} on file {2}"
|
||
|
|
+ .format(errno, strerror, path))
|
||
|
|
+ exit(-1)
|
||
|
|
+ except ValueError:
|
||
|
|
+ print ("Element to int conversion error in: \n{}".format(path))
|
||
|
|
+ exit(-1)
|
||
|
|
+
|
||
|
|
+# writing to vmbus device files, path must be absolute path before calling
|
||
|
|
+def write_test_files(path, value):
|
||
|
|
+
|
||
|
|
+ try:
|
||
|
|
+ with open(path,"w") as f:
|
||
|
|
+ f.write("{}".format(value))
|
||
|
|
+ except IOError as e:
|
||
|
|
+ errno, strerror = e.args
|
||
|
|
+ print("I/O error({0}): {1} on file {2}"
|
||
|
|
+ .format(errno, strerror, path))
|
||
|
|
+ exit(-1)
|
||
|
|
+
|
||
|
|
+# set testing state of device
|
||
|
|
+def set_test_state(state_path, state_value, quiet):
|
||
|
|
+
|
||
|
|
+ write_test_files(state_path, state_value)
|
||
|
|
+ if (get_test_state(state_path) is 1):
|
||
|
|
+ if (not quiet):
|
||
|
|
+ print("Testing = ON for device: {}"
|
||
|
|
+ .format(state_path.split("/")[5]))
|
||
|
|
+ else:
|
||
|
|
+ if (not quiet):
|
||
|
|
+ print("Testing = OFF for device: {}"
|
||
|
|
+ .format(state_path.split("/")[5]))
|
||
|
|
+
|
||
|
|
+# get testing state of device
|
||
|
|
+def get_test_state(state_path):
|
||
|
|
+ #state == 1 - test = ON
|
||
|
|
+ #state == 0 - test = OFF
|
||
|
|
+ return read_test_files(state_path)
|
||
|
|
+
|
||
|
|
+# write 1 - 1000 microseconds, into a single device using the
|
||
|
|
+# fuzz_test_buffer_interrupt_delay and fuzz_test_message_delay
|
||
|
|
+# debugfs attributes
|
||
|
|
+def set_delay_values(device, file_map, delay_length, quiet):
|
||
|
|
+
|
||
|
|
+ try:
|
||
|
|
+ interrupt = file_map[device][f_names.buff_f.value]
|
||
|
|
+ message = file_map[device][f_names.mess_f.value]
|
||
|
|
+
|
||
|
|
+ # delay[0]- buffer interrupt delay, delay[1]- message delay
|
||
|
|
+ if (delay_length[0] >= 0 and delay_length[0] <= 1000):
|
||
|
|
+ write_test_files(interrupt, delay_length[0])
|
||
|
|
+ if (delay_length[1] >= 0 and delay_length[1] <= 1000):
|
||
|
|
+ write_test_files(message, delay_length[1])
|
||
|
|
+ if (not quiet):
|
||
|
|
+ print("Buffer delay testing = {} for: {}"
|
||
|
|
+ .format(read_test_files(interrupt),
|
||
|
|
+ interrupt.split("/")[5]))
|
||
|
|
+ print("Message delay testing = {} for: {}"
|
||
|
|
+ .format(read_test_files(message),
|
||
|
|
+ message.split("/")[5]))
|
||
|
|
+ except IOError as e:
|
||
|
|
+ errno, strerror = e.args
|
||
|
|
+ print("I/O error({0}): {1} on files {2}{3}"
|
||
|
|
+ .format(errno, strerror, interrupt, message))
|
||
|
|
+ exit(-1)
|
||
|
|
+
|
||
|
|
+# enabling delay testing on all devices
|
||
|
|
+def set_delay_all_devices(file_map, delay, quiet):
|
||
|
|
+
|
||
|
|
+ for device in (file_map):
|
||
|
|
+ set_test_state(locate_state(device, file_map),
|
||
|
|
+ dev_state.on.value,
|
||
|
|
+ quiet)
|
||
|
|
+ set_delay_values(device, file_map, delay, quiet)
|
||
|
|
+
|
||
|
|
+# disable all testing on a SINGLE device.
|
||
|
|
+def disable_testing_single_device(device, file_map):
|
||
|
|
+
|
||
|
|
+ for name in file_map[device]:
|
||
|
|
+ file_location = file_map[device][name]
|
||
|
|
+ write_test_files(file_location, dev_state.off.value)
|
||
|
|
+ print("ALL testing now OFF for {}".format(device.split("/")[-1]))
|
||
|
|
+
|
||
|
|
+# disable all testing on ALL devices
|
||
|
|
+def disable_all_testing(file_map):
|
||
|
|
+
|
||
|
|
+ for device in file_map:
|
||
|
|
+ disable_testing_single_device(device, file_map)
|
||
|
|
+
|
||
|
|
+def parse_args():
|
||
|
|
+ parser = argparse.ArgumentParser(prog = "vmbus_testing",usage ="\n"
|
||
|
|
+ "%(prog)s [delay] [-h] [-e|-E] -t [-p]\n"
|
||
|
|
+ "%(prog)s [view_all | V] [-h]\n"
|
||
|
|
+ "%(prog)s [disable_all | D] [-h]\n"
|
||
|
|
+ "%(prog)s [disable_single | d] [-h|-p]\n"
|
||
|
|
+ "%(prog)s [view_single | v] [-h|-p]\n"
|
||
|
|
+ "%(prog)s --version\n",
|
||
|
|
+ description = "\nUse lsvmbus to get vmbus device type "
|
||
|
|
+ "information.\n" "\nThe debugfs root path is "
|
||
|
|
+ "/sys/kernel/debug/hyperv",
|
||
|
|
+ formatter_class = RawDescriptionHelpFormatter)
|
||
|
|
+ subparsers = parser.add_subparsers(dest = "action")
|
||
|
|
+ parser.add_argument("--version", action = "version",
|
||
|
|
+ version = '%(prog)s 0.1.0')
|
||
|
|
+ parser.add_argument("-q","--quiet", action = "store_true",
|
||
|
|
+ help = "silence none important test messages."
|
||
|
|
+ " This will only work when enabling testing"
|
||
|
|
+ " on a device.")
|
||
|
|
+ # Use the path parser to hold the --path attribute so it can
|
||
|
|
+ # be shared between subparsers. Also do the same for the state
|
||
|
|
+ # parser, as all testing methods will use --enable_all and
|
||
|
|
+ # enable_single.
|
||
|
|
+ path_parser = argparse.ArgumentParser(add_help=False)
|
||
|
|
+ path_parser.add_argument("-p","--path", metavar = "",
|
||
|
|
+ help = "Debugfs path to a vmbus device. The path "
|
||
|
|
+ "must be the absolute path to the device.")
|
||
|
|
+ state_parser = argparse.ArgumentParser(add_help=False)
|
||
|
|
+ state_group = state_parser.add_mutually_exclusive_group(required = True)
|
||
|
|
+ state_group.add_argument("-E", "--enable_all", action = "store_const",
|
||
|
|
+ const = "enable_all",
|
||
|
|
+ help = "Enable the specified test type "
|
||
|
|
+ "on ALL vmbus devices.")
|
||
|
|
+ state_group.add_argument("-e", "--enable_single",
|
||
|
|
+ action = "store_const",
|
||
|
|
+ const = "enable_single",
|
||
|
|
+ help = "Enable the specified test type on a "
|
||
|
|
+ "SINGLE vmbus device.")
|
||
|
|
+ parser_delay = subparsers.add_parser("delay",
|
||
|
|
+ parents = [state_parser, path_parser],
|
||
|
|
+ help = "Delay the ring buffer interrupt or the "
|
||
|
|
+ "ring buffer message reads in microseconds.",
|
||
|
|
+ prog = "vmbus_testing",
|
||
|
|
+ usage = "%(prog)s [-h]\n"
|
||
|
|
+ "%(prog)s -E -t [value] [value]\n"
|
||
|
|
+ "%(prog)s -e -t [value] [value] -p",
|
||
|
|
+ description = "Delay the ring buffer interrupt for "
|
||
|
|
+ "vmbus devices, or delay the ring buffer message "
|
||
|
|
+ "reads for vmbus devices (both in microseconds). This "
|
||
|
|
+ "is only on the host to guest channel.")
|
||
|
|
+ parser_delay.add_argument("-t", "--delay_time", metavar = "", nargs = 2,
|
||
|
|
+ type = check_range, default =[0,0], required = (True),
|
||
|
|
+ help = "Set [buffer] & [message] delay time. "
|
||
|
|
+ "Value constraints: -1 == value "
|
||
|
|
+ "or 0 < value <= 1000.\n"
|
||
|
|
+ "Use -1 to keep the previous value for that delay "
|
||
|
|
+ "type, or a value > 0 <= 1000 to change the delay "
|
||
|
|
+ "time.")
|
||
|
|
+ parser_dis_all = subparsers.add_parser("disable_all",
|
||
|
|
+ aliases = ['D'], prog = "vmbus_testing",
|
||
|
|
+ usage = "%(prog)s [disable_all | D] -h\n"
|
||
|
|
+ "%(prog)s [disable_all | D]\n",
|
||
|
|
+ help = "Disable ALL testing on ALL vmbus devices.",
|
||
|
|
+ description = "Disable ALL testing on ALL vmbus "
|
||
|
|
+ "devices.")
|
||
|
|
+ parser_dis_single = subparsers.add_parser("disable_single",
|
||
|
|
+ aliases = ['d'],
|
||
|
|
+ parents = [path_parser], prog = "vmbus_testing",
|
||
|
|
+ usage = "%(prog)s [disable_single | d] -h\n"
|
||
|
|
+ "%(prog)s [disable_single | d] -p\n",
|
||
|
|
+ help = "Disable ALL testing on a SINGLE vmbus device.",
|
||
|
|
+ description = "Disable ALL testing on a SINGLE vmbus "
|
||
|
|
+ "device.")
|
||
|
|
+ parser_view_all = subparsers.add_parser("view_all", aliases = ['V'],
|
||
|
|
+ help = "View the test state for ALL vmbus devices.",
|
||
|
|
+ prog = "vmbus_testing",
|
||
|
|
+ usage = "%(prog)s [view_all | V] -h\n"
|
||
|
|
+ "%(prog)s [view_all | V]\n",
|
||
|
|
+ description = "This shows the test state for ALL the "
|
||
|
|
+ "vmbus devices.")
|
||
|
|
+ parser_view_single = subparsers.add_parser("view_single",
|
||
|
|
+ aliases = ['v'],parents = [path_parser],
|
||
|
|
+ help = "View the test values for a SINGLE vmbus "
|
||
|
|
+ "device.",
|
||
|
|
+ description = "This shows the test values for a SINGLE "
|
||
|
|
+ "vmbus device.", prog = "vmbus_testing",
|
||
|
|
+ usage = "%(prog)s [view_single | v] -h\n"
|
||
|
|
+ "%(prog)s [view_single | v] -p")
|
||
|
|
+
|
||
|
|
+ return parser.parse_args()
|
||
|
|
+
|
||
|
|
+# value checking for range checking input in parser
|
||
|
|
+def check_range(arg1):
|
||
|
|
+
|
||
|
|
+ try:
|
||
|
|
+ val = int(arg1)
|
||
|
|
+ except ValueError as err:
|
||
|
|
+ raise argparse.ArgumentTypeError(str(err))
|
||
|
|
+ if val < -1 or val > 1000:
|
||
|
|
+ message = ("\n\nvalue must be -1 or 0 < value <= 1000. "
|
||
|
|
+ "Value program received: {}\n").format(val)
|
||
|
|
+ raise argparse.ArgumentTypeError(message)
|
||
|
|
+ return val
|
||
|
|
+
|
||
|
|
+if __name__ == "__main__":
|
||
|
|
+ main()
|
||
|
|
--
|
||
|
|
1.8.3.1
|
||
|
|
|