From 40091f0c13718ed380ca86520a106d1d32c72209 Mon Sep 17 00:00:00 2001 From: CentOS Sources Date: Wed, 3 Nov 2021 17:50:02 -0400 Subject: [PATCH] import hyperv-daemons-0-0.37.20190303git.el9 --- .gitignore | 0 .hyperv-daemons.metadata | 0 .../0002-Do-not-set-NM_CONTROLLED-no.patch | 24 + ...nd-scripts-to-kernel-version-5.7-rc1.patch | 345 ++++ ...5-Add-vmbus_testing-tool-build-files.patch | 401 ++++ ...nge-http-to-https-in-hv_kvp_daemon.c.patch | 56 + SOURCES/COPYING | 356 ++++ SOURCES/hv_fcopy_daemon.c | 239 +++ SOURCES/hv_get_dhcp_info.sh | 29 + SOURCES/hv_get_dns_info.sh | 13 + SOURCES/hv_kvp_daemon.c | 1632 +++++++++++++++++ SOURCES/hv_set_ifconfig.sh | 65 + SOURCES/hv_vss_daemon.c | 328 ++++ SOURCES/hypervfcopy.rules | 1 + SOURCES/hypervfcopyd.service | 7 + SOURCES/hypervkvp.rules | 1 + SOURCES/hypervkvpd.service | 9 + SOURCES/hypervvss.rules | 1 + SOURCES/hypervvssd.service | 7 + SOURCES/lsvmbus | 112 ++ SPECS/hyperv-daemons.spec | 398 ++++ 21 files changed, 4024 insertions(+) create mode 100644 .gitignore create mode 100644 .hyperv-daemons.metadata create mode 100644 SOURCES/0002-Do-not-set-NM_CONTROLLED-no.patch create mode 100644 SOURCES/0004-Update-C-files-and-scripts-to-kernel-version-5.7-rc1.patch create mode 100644 SOURCES/0005-Add-vmbus_testing-tool-build-files.patch create mode 100644 SOURCES/0006-tools-hv-change-http-to-https-in-hv_kvp_daemon.c.patch create mode 100644 SOURCES/COPYING create mode 100644 SOURCES/hv_fcopy_daemon.c create mode 100644 SOURCES/hv_get_dhcp_info.sh create mode 100644 SOURCES/hv_get_dns_info.sh create mode 100644 SOURCES/hv_kvp_daemon.c create mode 100644 SOURCES/hv_set_ifconfig.sh create mode 100644 SOURCES/hv_vss_daemon.c create mode 100644 SOURCES/hypervfcopy.rules create mode 100644 SOURCES/hypervfcopyd.service create mode 100644 SOURCES/hypervkvp.rules create mode 100644 SOURCES/hypervkvpd.service create mode 100644 SOURCES/hypervvss.rules create mode 100644 SOURCES/hypervvssd.service create mode 100644 SOURCES/lsvmbus create mode 100644 SPECS/hyperv-daemons.spec diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..e69de29 diff --git a/.hyperv-daemons.metadata b/.hyperv-daemons.metadata new file mode 100644 index 0000000..e69de29 diff --git a/SOURCES/0002-Do-not-set-NM_CONTROLLED-no.patch b/SOURCES/0002-Do-not-set-NM_CONTROLLED-no.patch new file mode 100644 index 0000000..563c9f1 --- /dev/null +++ b/SOURCES/0002-Do-not-set-NM_CONTROLLED-no.patch @@ -0,0 +1,24 @@ +From 88be69d62a01b9ac233de7f68118c948623c6f0a Mon Sep 17 00:00:00 2001 +From: Miroslav Rezanina +Date: Thu, 14 Nov 2019 09:45:44 +0100 +Subject: Do not set NM_CONTROLLED=no + +--- + hv_set_ifconfig.sh | 1 - + 1 file changed, 1 deletion(-) + +diff --git a/hv_set_ifconfig.sh b/hv_set_ifconfig.sh +index 7ed9f85..18b27cc 100644 +--- a/hv_set_ifconfig.sh ++++ b/hv_set_ifconfig.sh +@@ -51,7 +51,6 @@ + + + echo "IPV6INIT=yes" >> $1 +-echo "NM_CONTROLLED=no" >> $1 + echo "PEERDNS=yes" >> $1 + echo "ONBOOT=yes" >> $1 + +-- +2.27.0 + diff --git a/SOURCES/0004-Update-C-files-and-scripts-to-kernel-version-5.7-rc1.patch b/SOURCES/0004-Update-C-files-and-scripts-to-kernel-version-5.7-rc1.patch new file mode 100644 index 0000000..f706a1f --- /dev/null +++ b/SOURCES/0004-Update-C-files-and-scripts-to-kernel-version-5.7-rc1.patch @@ -0,0 +1,345 @@ +From f20c2a3298ceae7536c06bd08a5c571ebfa8cce4 Mon Sep 17 00:00:00 2001 +From: Miroslav Rezanina +Date: Thu, 6 May 2021 12:50:43 +0200 +Subject: Update C files and scripts to kernel version 5.7-rc1 + +(cherry-picked from RHEL 8.4.0 commit b0a20fac0e74b0b3eecc20ffe74006e7877da352) +Signed-off-by: Miroslav Rezanina +--- + hv_fcopy_daemon.c | 37 +++++++++++++++++++++++++++++++----- + hv_get_dhcp_info.sh | 2 +- + hv_kvp_daemon.c | 35 ++++++++++++++++++++-------------- + hv_set_ifconfig.sh | 2 +- + hv_vss_daemon.c | 46 ++++++++++++++++++++++++++++++++++----------- + 5 files changed, 90 insertions(+), 32 deletions(-) + +diff --git a/hv_fcopy_daemon.c b/hv_fcopy_daemon.c +index aea2d91..16d629b 100644 +--- a/hv_fcopy_daemon.c ++++ b/hv_fcopy_daemon.c +@@ -80,6 +80,8 @@ static int hv_start_fcopy(struct hv_start_fcopy *smsg) + + error = 0; + done: ++ if (error) ++ target_fname[0] = '\0'; + return error; + } + +@@ -108,15 +110,29 @@ static int hv_copy_data(struct hv_do_fcopy *cpmsg) + return ret; + } + ++/* ++ * Reset target_fname to "" in the two below functions for hibernation: if ++ * the fcopy operation is aborted by hibernation, the daemon should remove the ++ * partially-copied file; to achieve this, the hv_utils driver always fakes a ++ * CANCEL_FCOPY message upon suspend, and later when the VM resumes back, ++ * the daemon calls hv_copy_cancel() to remove the file; if a file is copied ++ * successfully before suspend, hv_copy_finished() must reset target_fname to ++ * avoid that the file can be incorrectly removed upon resume, since the faked ++ * CANCEL_FCOPY message is spurious in this case. ++ */ + static int hv_copy_finished(void) + { + close(target_fd); ++ target_fname[0] = '\0'; + return 0; + } + static int hv_copy_cancel(void) + { + close(target_fd); +- unlink(target_fname); ++ if (strlen(target_fname) > 0) { ++ unlink(target_fname); ++ target_fname[0] = '\0'; ++ } + return 0; + + } +@@ -131,7 +147,7 @@ void print_usage(char *argv[]) + + int main(int argc, char *argv[]) + { +- int fcopy_fd; ++ int fcopy_fd = -1; + int error; + int daemonize = 1, long_index = 0, opt; + int version = FCOPY_CURRENT_VERSION; +@@ -141,7 +157,7 @@ int main(int argc, char *argv[]) + struct hv_do_fcopy copy; + __u32 kernel_modver; + } buffer = { }; +- int in_handshake = 1; ++ int in_handshake; + + static struct option long_options[] = { + {"help", no_argument, 0, 'h' }, +@@ -170,6 +186,12 @@ int main(int argc, char *argv[]) + openlog("HV_FCOPY", 0, LOG_USER); + syslog(LOG_INFO, "starting; pid is:%d", getpid()); + ++reopen_fcopy_fd: ++ if (fcopy_fd != -1) ++ close(fcopy_fd); ++ /* Remove any possible partially-copied file on error */ ++ hv_copy_cancel(); ++ in_handshake = 1; + fcopy_fd = open("/dev/vmbus/hv_fcopy", O_RDWR); + + if (fcopy_fd < 0) { +@@ -196,7 +218,7 @@ int main(int argc, char *argv[]) + len = pread(fcopy_fd, &buffer, sizeof(buffer), 0); + if (len < 0) { + syslog(LOG_ERR, "pread failed: %s", strerror(errno)); +- exit(EXIT_FAILURE); ++ goto reopen_fcopy_fd; + } + + if (in_handshake) { +@@ -231,9 +253,14 @@ int main(int argc, char *argv[]) + + } + ++ /* ++ * pwrite() may return an error due to the faked CANCEL_FCOPY ++ * message upon hibernation. Ignore the error by resetting the ++ * dev file, i.e. closing and re-opening it. ++ */ + if (pwrite(fcopy_fd, &error, sizeof(int), 0) != sizeof(int)) { + syslog(LOG_ERR, "pwrite failed: %s", strerror(errno)); +- exit(EXIT_FAILURE); ++ goto reopen_fcopy_fd; + } + } + } +diff --git a/hv_get_dhcp_info.sh b/hv_get_dhcp_info.sh +index c38686c..2f2a3c7 100644 +--- a/hv_get_dhcp_info.sh ++++ b/hv_get_dhcp_info.sh +@@ -13,7 +13,7 @@ + # the script prints the string "Disabled" to stdout. + # + # Each Distro is expected to implement this script in a distro specific +-# fashion. For instance on Distros that ship with Network Manager enabled, ++# fashion. For instance, on Distros that ship with Network Manager enabled, + # this script can be based on the Network Manager APIs for retrieving DHCP + # information. + +diff --git a/hv_kvp_daemon.c b/hv_kvp_daemon.c +index e9ef4ca..0e5f14a 100644 +--- a/hv_kvp_daemon.c ++++ b/hv_kvp_daemon.c +@@ -76,7 +76,7 @@ enum { + DNS + }; + +-static int in_hand_shake = 1; ++static int in_hand_shake; + + static char *os_name = ""; + static char *os_major = ""; +@@ -1360,7 +1360,7 @@ void print_usage(char *argv[]) + + int main(int argc, char *argv[]) + { +- int kvp_fd, len; ++ int kvp_fd = -1, len; + int error; + struct pollfd pfd; + char *p; +@@ -1400,14 +1400,6 @@ int main(int argc, char *argv[]) + openlog("KVP", 0, LOG_USER); + syslog(LOG_INFO, "KVP starting; pid is:%d", getpid()); + +- kvp_fd = open("/dev/vmbus/hv_kvp", O_RDWR | O_CLOEXEC); +- +- if (kvp_fd < 0) { +- syslog(LOG_ERR, "open /dev/vmbus/hv_kvp failed; error: %d %s", +- errno, strerror(errno)); +- exit(EXIT_FAILURE); +- } +- + /* + * Retrieve OS release information. + */ +@@ -1423,6 +1415,18 @@ int main(int argc, char *argv[]) + exit(EXIT_FAILURE); + } + ++reopen_kvp_fd: ++ if (kvp_fd != -1) ++ close(kvp_fd); ++ in_hand_shake = 1; ++ kvp_fd = open("/dev/vmbus/hv_kvp", O_RDWR | O_CLOEXEC); ++ ++ if (kvp_fd < 0) { ++ syslog(LOG_ERR, "open /dev/vmbus/hv_kvp failed; error: %d %s", ++ errno, strerror(errno)); ++ exit(EXIT_FAILURE); ++ } ++ + /* + * Register ourselves with the kernel. + */ +@@ -1457,8 +1461,7 @@ int main(int argc, char *argv[]) + syslog(LOG_ERR, "read failed; error:%d %s", + errno, strerror(errno)); + +- close(kvp_fd); +- return EXIT_FAILURE; ++ goto reopen_kvp_fd; + } + + /* +@@ -1617,13 +1620,17 @@ int main(int argc, char *argv[]) + break; + } + +- /* Send the value back to the kernel. */ ++ /* ++ * Send the value back to the kernel. Note: the write() may ++ * return an error due to hibernation; we can ignore the error ++ * by resetting the dev file, i.e. closing and re-opening it. ++ */ + kvp_done: + len = write(kvp_fd, hv_msg, sizeof(struct hv_kvp_msg)); + if (len != sizeof(struct hv_kvp_msg)) { + syslog(LOG_ERR, "write failed; error: %d %s", errno, + strerror(errno)); +- exit(EXIT_FAILURE); ++ goto reopen_kvp_fd; + } + } + +diff --git a/hv_set_ifconfig.sh b/hv_set_ifconfig.sh +index 18b27cc..3dd064c 100644 +--- a/hv_set_ifconfig.sh ++++ b/hv_set_ifconfig.sh +@@ -12,7 +12,7 @@ + # be used to configure the interface. + # + # Each Distro is expected to implement this script in a distro specific +-# fashion. For instance on Distros that ship with Network Manager enabled, ++# fashion. For instance, on Distros that ship with Network Manager enabled, + # this script can be based on the Network Manager APIs for configuring the + # interface. + # +diff --git a/hv_vss_daemon.c b/hv_vss_daemon.c +index 92902a8..29a1e48 100644 +--- a/hv_vss_daemon.c ++++ b/hv_vss_daemon.c +@@ -28,6 +28,8 @@ + #include + #include + ++static bool fs_frozen; ++ + /* Don't use syslog() in the function since that can cause write to disk */ + static int vss_do_freeze(char *dir, unsigned int cmd) + { +@@ -155,16 +157,22 @@ static int vss_operate(int operation) + continue; + } + error |= vss_do_freeze(ent->mnt_dir, cmd); +- if (error && operation == VSS_OP_FREEZE) +- goto err; ++ if (operation == VSS_OP_FREEZE) { ++ if (error) ++ goto err; ++ fs_frozen = true; ++ } + } + + endmntent(mounts); + + if (root_seen) { + error |= vss_do_freeze("/", cmd); +- if (error && operation == VSS_OP_FREEZE) +- goto err; ++ if (operation == VSS_OP_FREEZE) { ++ if (error) ++ goto err; ++ fs_frozen = true; ++ } + } + + goto out; +@@ -175,6 +183,7 @@ err: + endmntent(mounts); + } + vss_operate(VSS_OP_THAW); ++ fs_frozen = false; + /* Call syslog after we thaw all filesystems */ + if (ent) + syslog(LOG_ERR, "FREEZE of %s failed; error:%d %s", +@@ -196,13 +205,13 @@ void print_usage(char *argv[]) + + int main(int argc, char *argv[]) + { +- int vss_fd, len; ++ int vss_fd = -1, len; + int error; + struct pollfd pfd; + int op; + struct hv_vss_msg vss_msg[1]; + int daemonize = 1, long_index = 0, opt; +- int in_handshake = 1; ++ int in_handshake; + __u32 kernel_modver; + + static struct option long_options[] = { +@@ -232,6 +241,18 @@ int main(int argc, char *argv[]) + openlog("Hyper-V VSS", 0, LOG_USER); + syslog(LOG_INFO, "VSS starting; pid is:%d", getpid()); + ++reopen_vss_fd: ++ if (vss_fd != -1) ++ close(vss_fd); ++ if (fs_frozen) { ++ if (vss_operate(VSS_OP_THAW) || fs_frozen) { ++ syslog(LOG_ERR, "failed to thaw file system: err=%d", ++ errno); ++ exit(EXIT_FAILURE); ++ } ++ } ++ ++ in_handshake = 1; + vss_fd = open("/dev/vmbus/hv_vss", O_RDWR); + if (vss_fd < 0) { + syslog(LOG_ERR, "open /dev/vmbus/hv_vss failed; error: %d %s", +@@ -247,8 +268,7 @@ int main(int argc, char *argv[]) + if (len < 0) { + syslog(LOG_ERR, "registration to kernel failed; error: %d %s", + errno, strerror(errno)); +- close(vss_fd); +- exit(EXIT_FAILURE); ++ goto reopen_vss_fd; + } + + pfd.fd = vss_fd; +@@ -312,14 +332,18 @@ int main(int argc, char *argv[]) + default: + syslog(LOG_ERR, "Illegal op:%d\n", op); + } ++ ++ /* ++ * The write() may return an error due to the faked VSS_OP_THAW ++ * message upon hibernation. Ignore the error by resetting the ++ * dev file, i.e. closing and re-opening it. ++ */ + vss_msg->error = error; + len = write(vss_fd, vss_msg, sizeof(struct hv_vss_msg)); + if (len != sizeof(struct hv_vss_msg)) { + syslog(LOG_ERR, "write failed; error: %d %s", errno, + strerror(errno)); +- +- if (op == VSS_OP_FREEZE) +- vss_operate(VSS_OP_THAW); ++ goto reopen_vss_fd; + } + } + +-- +2.27.0 + diff --git a/SOURCES/0005-Add-vmbus_testing-tool-build-files.patch b/SOURCES/0005-Add-vmbus_testing-tool-build-files.patch new file mode 100644 index 0000000..92f2717 --- /dev/null +++ b/SOURCES/0005-Add-vmbus_testing-tool-build-files.patch @@ -0,0 +1,401 @@ +From a13aa83d1b5bb4b6ce4396aef3457b48695b7c41 Mon Sep 17 00:00:00 2001 +From: Miroslav Rezanina +Date: Thu, 6 May 2021 12:53:31 +0200 +Subject: Add vmbus_testing tool build files + +Add the vmbus_testing tool to redhat build dirs + +(cherry-pick from rhel 8.4.0 commit d8ca5e0) +Signed-off-by: Mohammed Gamal +Signed-off-by: Miroslav Rezanina +--- + .distro/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/ ++# /sys/kernel/debug/hyperv/UUID/ ++# ++# author: Branden Bonaby ++ ++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() +-- +2.27.0 + diff --git a/SOURCES/0006-tools-hv-change-http-to-https-in-hv_kvp_daemon.c.patch b/SOURCES/0006-tools-hv-change-http-to-https-in-hv_kvp_daemon.c.patch new file mode 100644 index 0000000..a6c7947 --- /dev/null +++ b/SOURCES/0006-tools-hv-change-http-to-https-in-hv_kvp_daemon.c.patch @@ -0,0 +1,56 @@ +From 6ed9946f9a4f1a01846add2279e8d0640c1c2f1c Mon Sep 17 00:00:00 2001 +From: Miroslav Rezanina +Date: Thu, 6 May 2021 12:53:58 +0200 +Subject: tools: hv: change http to https in hv_kvp_daemon.c + +The patch has no functional change. Only changes the URL pointed to +in one of the comments + +commit fa52a4b2d0ab416508538bb47a95167d4c94caac +Author: Alexander A. Klimov +Date: Sun Jul 5 23:44:57 2020 +0200 + + tools: hv: change http to https in hv_kvp_daemon.c + + Rationale: + Reduces attack surface on kernel devs opening the links for MITM + as HTTPS traffic is much harder to manipulate. + + Deterministic algorithm: + For each file: + If not .svg: + For each line: + If doesn't contain `\bxmlns\b`: + For each link, `\bhttp://[^# \t\r\n]*(?:\w|/)`: + If both the HTTP and HTTPS versions + return 200 OK and serve the same content: + Replace HTTP with HTTPS. + + Signed-off-by: Alexander A. Klimov + Link: https://lore.kernel.org/r/20200705214457.28433-1-grandmaster@al2klimov.de + [ wei: change subject line to be more specific ] + Signed-off-by: Wei Liu + +Signed-off-by: Mohammed Gamal +(cherry-picked from rhel 8.4.0 commit e956573) +Signed-off-by: Miroslav Rezanina +--- + hv_kvp_daemon.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/hv_kvp_daemon.c b/hv_kvp_daemon.c +index 0e5f14a..c06c94d 100644 +--- a/hv_kvp_daemon.c ++++ b/hv_kvp_daemon.c +@@ -437,7 +437,7 @@ void kvp_get_os_info(void) + + /* + * Parse the /etc/os-release file if present: +- * http://www.freedesktop.org/software/systemd/man/os-release.html ++ * https://www.freedesktop.org/software/systemd/man/os-release.html + */ + file = fopen("/etc/os-release", "r"); + if (file != NULL) { +-- +2.27.0 + diff --git a/SOURCES/COPYING b/SOURCES/COPYING new file mode 100644 index 0000000..ca442d3 --- /dev/null +++ b/SOURCES/COPYING @@ -0,0 +1,356 @@ + + NOTE! This copyright does *not* cover user programs that use kernel + services by normal system calls - this is merely considered normal use + of the kernel, and does *not* fall under the heading of "derived work". + Also note that the GPL below is copyrighted by the Free Software + Foundation, but the instance of code that it refers to (the Linux + kernel) is copyrighted by me and others who actually wrote it. + + Also note that the only valid version of the GPL as far as the kernel + is concerned is _this_ particular version of the license (ie v2, not + v2.2 or v3.x or whatever), unless explicitly otherwise stated. + + Linus Torvalds + +---------------------------------------- + + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 1991 Free Software Foundation, Inc. + 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +License is intended to guarantee your freedom to share and change free +software--to make sure the software is free for all its users. This +General Public License applies to most of the Free Software +Foundation's software and to any other program whose authors commit to +using it. (Some other Free Software Foundation software is covered by +the GNU Library General Public License instead.) You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +this service if you wish), that you receive source code or can get it +if you want it, that you can change the software or use pieces of it +in new free programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if you +distribute copies of the software, or if you modify it. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must give the recipients all the rights that +you have. You must make sure that they, too, receive or can get the +source code. And you must show them these terms so they know their +rights. + + We protect your rights with two steps: (1) copyright the software, and +(2) offer you this license which gives you legal permission to copy, +distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain +that everyone understands that there is no warranty for this free +software. If the software is modified by someone else and passed on, we +want its recipients to know that what they have is not the original, so +that any problems introduced by others will not reflect on the original +authors' reputations. + + Finally, any free program is threatened constantly by software +patents. We wish to avoid the danger that redistributors of a free +program will individually obtain patent licenses, in effect making the +program proprietary. To prevent this, we have made it clear that any +patent must be licensed for everyone's free use or not licensed at all. + + The precise terms and conditions for copying, distribution and +modification follow. + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License applies to any program or other work which contains +a notice placed by the copyright holder saying it may be distributed +under the terms of this General Public License. The "Program", below, +refers to any such program or work, and a "work based on the Program" +means either the Program or any derivative work under copyright law: +that is to say, a work containing the Program or a portion of it, +either verbatim or with modifications and/or translated into another +language. (Hereinafter, translation is included without limitation in +the term "modification".) Each licensee is addressed as "you". + +Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running the Program is not restricted, and the output from the Program +is covered only if its contents constitute a work based on the +Program (independent of having been made by running the Program). +Whether that is true depends on what the Program does. + + 1. You may copy and distribute verbatim copies of the Program's +source code as you receive it, in any medium, provided that you +conspicuously and appropriately publish on each copy an appropriate +copyright notice and disclaimer of warranty; keep intact all the +notices that refer to this License and to the absence of any warranty; +and give any other recipients of the Program a copy of this License +along with the Program. + +You may charge a fee for the physical act of transferring a copy, and +you may at your option offer warranty protection in exchange for a fee. + + 2. You may modify your copy or copies of the Program or any portion +of it, thus forming a work based on the Program, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) You must cause the modified files to carry prominent notices + stating that you changed the files and the date of any change. + + b) You must cause any work that you distribute or publish, that in + whole or in part contains or is derived from the Program or any + part thereof, to be licensed as a whole at no charge to all third + parties under the terms of this License. + + c) If the modified program normally reads commands interactively + when run, you must cause it, when started running for such + interactive use in the most ordinary way, to print or display an + announcement including an appropriate copyright notice and a + notice that there is no warranty (or else, saying that you provide + a warranty) and that users may redistribute the program under + these conditions, and telling the user how to view a copy of this + License. (Exception: if the Program itself is interactive but + does not normally print such an announcement, your work based on + the Program is not required to print an announcement.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Program, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Program, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Program. + +In addition, mere aggregation of another work not based on the Program +with the Program (or with a work based on the Program) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may copy and distribute the Program (or a work based on it, +under Section 2) in object code or executable form under the terms of +Sections 1 and 2 above provided that you also do one of the following: + + a) Accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of Sections + 1 and 2 above on a medium customarily used for software interchange; or, + + b) Accompany it with a written offer, valid for at least three + years, to give any third party, for a charge no more than your + cost of physically performing source distribution, a complete + machine-readable copy of the corresponding source code, to be + distributed under the terms of Sections 1 and 2 above on a medium + customarily used for software interchange; or, + + c) Accompany it with the information you received as to the offer + to distribute corresponding source code. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form with such + an offer, in accord with Subsection b above.) + +The source code for a work means the preferred form of the work for +making modifications to it. For an executable work, complete source +code means all the source code for all modules it contains, plus any +associated interface definition files, plus the scripts used to +control compilation and installation of the executable. However, as a +special exception, the source code distributed need not include +anything that is normally distributed (in either source or binary +form) with the major components (compiler, kernel, and so on) of the +operating system on which the executable runs, unless that component +itself accompanies the executable. + +If distribution of executable or object code is made by offering +access to copy from a designated place, then offering equivalent +access to copy the source code from the same place counts as +distribution of the source code, even though third parties are not +compelled to copy the source along with the object code. + + 4. You may not copy, modify, sublicense, or distribute the Program +except as expressly provided under this License. Any attempt +otherwise to copy, modify, sublicense or distribute the Program is +void, and will automatically terminate your rights under this License. +However, parties who have received copies, or rights, from you under +this License will not have their licenses terminated so long as such +parties remain in full compliance. + + 5. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Program or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Program (or any work based on the +Program), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Program or works based on it. + + 6. Each time you redistribute the Program (or any work based on the +Program), the recipient automatically receives a license from the +original licensor to copy, distribute or modify the Program subject to +these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties to +this License. + + 7. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Program at all. For example, if a patent +license would not permit royalty-free redistribution of the Program by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Program. + +If any portion of this section is held invalid or unenforceable under +any particular circumstance, the balance of the section is intended to +apply and the section as a whole is intended to apply in other +circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system, which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 8. If the distribution and/or use of the Program is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Program under this License +may add an explicit geographical distribution limitation excluding +those countries, so that distribution is permitted only in or among +countries not thus excluded. In such case, this License incorporates +the limitation as if written in the body of this License. + + 9. The Free Software Foundation may publish revised and/or new versions +of the General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + +Each version is given a distinguishing version number. If the Program +specifies a version number of this License which applies to it and "any +later version", you have the option of following the terms and conditions +either of that version or of any later version published by the Free +Software Foundation. If the Program does not specify a version number of +this License, you may choose any version ever published by the Free Software +Foundation. + + 10. If you wish to incorporate parts of the Program into other free +programs whose distribution conditions are different, write to the author +to ask for permission. For software which is copyrighted by the Free +Software Foundation, write to the Free Software Foundation; we sometimes +make exceptions for this. Our decision will be guided by the two goals +of preserving the free status of all derivatives of our free software and +of promoting the sharing and reuse of software generally. + + NO WARRANTY + + 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY +FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN +OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES +PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED +OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS +TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE +PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, +REPAIR OR CORRECTION. + + 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR +REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, +INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING +OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED +TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY +YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER +PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + + +Also add information on how to contact you by electronic and paper mail. + +If the program is interactive, make it output a short notice like this +when it starts in an interactive mode: + + Gnomovision version 69, Copyright (C) year name of author + Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, the commands you use may +be called something other than `show w' and `show c'; they could even be +mouse-clicks or menu items--whatever suits your program. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the program, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the program + `Gnomovision' (which makes passes at compilers) written by James Hacker. + + , 1 April 1989 + Ty Coon, President of Vice + +This General Public License does not permit incorporating your program into +proprietary programs. If your program is a subroutine library, you may +consider it more useful to permit linking proprietary applications with the +library. If this is what you want to do, use the GNU Library General +Public License instead of this License. diff --git a/SOURCES/hv_fcopy_daemon.c b/SOURCES/hv_fcopy_daemon.c new file mode 100644 index 0000000..aea2d91 --- /dev/null +++ b/SOURCES/hv_fcopy_daemon.c @@ -0,0 +1,239 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * An implementation of host to guest copy functionality for Linux. + * + * Copyright (C) 2014, Microsoft, Inc. + * + * Author : K. Y. Srinivasan + */ + + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static int target_fd; +static char target_fname[PATH_MAX]; +static unsigned long long filesize; + +static int hv_start_fcopy(struct hv_start_fcopy *smsg) +{ + int error = HV_E_FAIL; + char *q, *p; + + filesize = 0; + p = (char *)smsg->path_name; + snprintf(target_fname, sizeof(target_fname), "%s/%s", + (char *)smsg->path_name, (char *)smsg->file_name); + + syslog(LOG_INFO, "Target file name: %s", target_fname); + /* + * Check to see if the path is already in place; if not, + * create if required. + */ + while ((q = strchr(p, '/')) != NULL) { + if (q == p) { + p++; + continue; + } + *q = '\0'; + if (access((char *)smsg->path_name, F_OK)) { + if (smsg->copy_flags & CREATE_PATH) { + if (mkdir((char *)smsg->path_name, 0755)) { + syslog(LOG_ERR, "Failed to create %s", + (char *)smsg->path_name); + goto done; + } + } else { + syslog(LOG_ERR, "Invalid path: %s", + (char *)smsg->path_name); + goto done; + } + } + p = q + 1; + *q = '/'; + } + + if (!access(target_fname, F_OK)) { + syslog(LOG_INFO, "File: %s exists", target_fname); + if (!(smsg->copy_flags & OVER_WRITE)) { + error = HV_ERROR_ALREADY_EXISTS; + goto done; + } + } + + target_fd = open(target_fname, + O_RDWR | O_CREAT | O_TRUNC | O_CLOEXEC, 0744); + if (target_fd == -1) { + syslog(LOG_INFO, "Open Failed: %s", strerror(errno)); + goto done; + } + + error = 0; +done: + return error; +} + +static int hv_copy_data(struct hv_do_fcopy *cpmsg) +{ + ssize_t bytes_written; + int ret = 0; + + bytes_written = pwrite(target_fd, cpmsg->data, cpmsg->size, + cpmsg->offset); + + filesize += cpmsg->size; + if (bytes_written != cpmsg->size) { + switch (errno) { + case ENOSPC: + ret = HV_ERROR_DISK_FULL; + break; + default: + ret = HV_E_FAIL; + break; + } + syslog(LOG_ERR, "pwrite failed to write %llu bytes: %ld (%s)", + filesize, (long)bytes_written, strerror(errno)); + } + + return ret; +} + +static int hv_copy_finished(void) +{ + close(target_fd); + return 0; +} +static int hv_copy_cancel(void) +{ + close(target_fd); + unlink(target_fname); + return 0; + +} + +void print_usage(char *argv[]) +{ + fprintf(stderr, "Usage: %s [options]\n" + "Options are:\n" + " -n, --no-daemon stay in foreground, don't daemonize\n" + " -h, --help print this help\n", argv[0]); +} + +int main(int argc, char *argv[]) +{ + int fcopy_fd; + int error; + int daemonize = 1, long_index = 0, opt; + int version = FCOPY_CURRENT_VERSION; + union { + struct hv_fcopy_hdr hdr; + struct hv_start_fcopy start; + struct hv_do_fcopy copy; + __u32 kernel_modver; + } buffer = { }; + int in_handshake = 1; + + static struct option long_options[] = { + {"help", no_argument, 0, 'h' }, + {"no-daemon", no_argument, 0, 'n' }, + {0, 0, 0, 0 } + }; + + while ((opt = getopt_long(argc, argv, "hn", long_options, + &long_index)) != -1) { + switch (opt) { + case 'n': + daemonize = 0; + break; + case 'h': + default: + print_usage(argv); + exit(EXIT_FAILURE); + } + } + + if (daemonize && daemon(1, 0)) { + syslog(LOG_ERR, "daemon() failed; error: %s", strerror(errno)); + exit(EXIT_FAILURE); + } + + openlog("HV_FCOPY", 0, LOG_USER); + syslog(LOG_INFO, "starting; pid is:%d", getpid()); + + fcopy_fd = open("/dev/vmbus/hv_fcopy", O_RDWR); + + if (fcopy_fd < 0) { + syslog(LOG_ERR, "open /dev/vmbus/hv_fcopy failed; error: %d %s", + errno, strerror(errno)); + exit(EXIT_FAILURE); + } + + /* + * Register with the kernel. + */ + if ((write(fcopy_fd, &version, sizeof(int))) != sizeof(int)) { + syslog(LOG_ERR, "Registration failed: %s", strerror(errno)); + exit(EXIT_FAILURE); + } + + while (1) { + /* + * In this loop we process fcopy messages after the + * handshake is complete. + */ + ssize_t len; + + len = pread(fcopy_fd, &buffer, sizeof(buffer), 0); + if (len < 0) { + syslog(LOG_ERR, "pread failed: %s", strerror(errno)); + exit(EXIT_FAILURE); + } + + if (in_handshake) { + if (len != sizeof(buffer.kernel_modver)) { + syslog(LOG_ERR, "invalid version negotiation"); + exit(EXIT_FAILURE); + } + in_handshake = 0; + syslog(LOG_INFO, "kernel module version: %u", + buffer.kernel_modver); + continue; + } + + switch (buffer.hdr.operation) { + case START_FILE_COPY: + error = hv_start_fcopy(&buffer.start); + break; + case WRITE_TO_FILE: + error = hv_copy_data(&buffer.copy); + break; + case COMPLETE_FCOPY: + error = hv_copy_finished(); + break; + case CANCEL_FCOPY: + error = hv_copy_cancel(); + break; + + default: + error = HV_E_FAIL; + syslog(LOG_ERR, "Unknown operation: %d", + buffer.hdr.operation); + + } + + if (pwrite(fcopy_fd, &error, sizeof(int), 0) != sizeof(int)) { + syslog(LOG_ERR, "pwrite failed: %s", strerror(errno)); + exit(EXIT_FAILURE); + } + } +} diff --git a/SOURCES/hv_get_dhcp_info.sh b/SOURCES/hv_get_dhcp_info.sh new file mode 100644 index 0000000..c38686c --- /dev/null +++ b/SOURCES/hv_get_dhcp_info.sh @@ -0,0 +1,29 @@ +#!/bin/bash +# SPDX-License-Identifier: GPL-2.0 + +# This example script retrieves the DHCP state of a given interface. +# In the interest of keeping the KVP daemon code free of distro specific +# information; the kvp daemon code invokes this external script to gather +# DHCP setting for the specific interface. +# +# Input: Name of the interface +# +# Output: The script prints the string "Enabled" to stdout to indicate +# that DHCP is enabled on the interface. If DHCP is not enabled, +# the script prints the string "Disabled" to stdout. +# +# Each Distro is expected to implement this script in a distro specific +# fashion. For instance on Distros that ship with Network Manager enabled, +# this script can be based on the Network Manager APIs for retrieving DHCP +# information. + +if_file="/etc/sysconfig/network-scripts/ifcfg-"$1 + +dhcp=$(grep "dhcp" $if_file 2>/dev/null) + +if [ "$dhcp" != "" ]; +then +echo "Enabled" +else +echo "Disabled" +fi diff --git a/SOURCES/hv_get_dns_info.sh b/SOURCES/hv_get_dns_info.sh new file mode 100644 index 0000000..058c17b --- /dev/null +++ b/SOURCES/hv_get_dns_info.sh @@ -0,0 +1,13 @@ +#!/bin/bash + +# This example script parses /etc/resolv.conf to retrive DNS information. +# In the interest of keeping the KVP daemon code free of distro specific +# information; the kvp daemon code invokes this external script to gather +# DNS information. +# This script is expected to print the nameserver values to stdout. +# Each Distro is expected to implement this script in a distro specific +# fashion. For instance on Distros that ship with Network Manager enabled, +# this script can be based on the Network Manager APIs for retrieving DNS +# entries. + +cat /etc/resolv.conf 2>/dev/null | awk '/^nameserver/ { print $2 }' diff --git a/SOURCES/hv_kvp_daemon.c b/SOURCES/hv_kvp_daemon.c new file mode 100644 index 0000000..e9ef4ca --- /dev/null +++ b/SOURCES/hv_kvp_daemon.c @@ -0,0 +1,1632 @@ +/* + * An implementation of key value pair (KVP) functionality for Linux. + * + * + * Copyright (C) 2010, Novell, Inc. + * Author : K. Y. Srinivasan + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 as published + * by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or + * NON INFRINGEMENT. See the GNU General Public License for more + * details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + */ + + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/* + * KVP protocol: The user mode component first registers with the + * the kernel component. Subsequently, the kernel component requests, data + * for the specified keys. In response to this message the user mode component + * fills in the value corresponding to the specified key. We overload the + * sequence field in the cn_msg header to define our KVP message types. + * + * We use this infrastructure for also supporting queries from user mode + * application for state that may be maintained in the KVP kernel component. + * + */ + + +enum key_index { + FullyQualifiedDomainName = 0, + IntegrationServicesVersion, /*This key is serviced in the kernel*/ + NetworkAddressIPv4, + NetworkAddressIPv6, + OSBuildNumber, + OSName, + OSMajorVersion, + OSMinorVersion, + OSVersion, + ProcessorArchitecture +}; + + +enum { + IPADDR = 0, + NETMASK, + GATEWAY, + DNS +}; + +static int in_hand_shake = 1; + +static char *os_name = ""; +static char *os_major = ""; +static char *os_minor = ""; +static char *processor_arch; +static char *os_build; +static char *os_version; +static char *lic_version = "Unknown version"; +static char full_domain_name[HV_KVP_EXCHANGE_MAX_VALUE_SIZE]; +static struct utsname uts_buf; + +/* + * The location of the interface configuration file. + */ + +#define KVP_CONFIG_LOC "/var/lib/hyperv" + +#ifndef KVP_SCRIPTS_PATH +#define KVP_SCRIPTS_PATH "/usr/libexec/hypervkvpd/" +#endif + +#define KVP_NET_DIR "/sys/class/net/" + +#define MAX_FILE_NAME 100 +#define ENTRIES_PER_BLOCK 50 + +struct kvp_record { + char key[HV_KVP_EXCHANGE_MAX_KEY_SIZE]; + char value[HV_KVP_EXCHANGE_MAX_VALUE_SIZE]; +}; + +struct kvp_file_state { + int fd; + int num_blocks; + struct kvp_record *records; + int num_records; + char fname[MAX_FILE_NAME]; +}; + +static struct kvp_file_state kvp_file_info[KVP_POOL_COUNT]; + +static void kvp_acquire_lock(int pool) +{ + struct flock fl = {F_WRLCK, SEEK_SET, 0, 0, 0}; + fl.l_pid = getpid(); + + if (fcntl(kvp_file_info[pool].fd, F_SETLKW, &fl) == -1) { + syslog(LOG_ERR, "Failed to acquire the lock pool: %d; error: %d %s", pool, + errno, strerror(errno)); + exit(EXIT_FAILURE); + } +} + +static void kvp_release_lock(int pool) +{ + struct flock fl = {F_UNLCK, SEEK_SET, 0, 0, 0}; + fl.l_pid = getpid(); + + if (fcntl(kvp_file_info[pool].fd, F_SETLK, &fl) == -1) { + syslog(LOG_ERR, "Failed to release the lock pool: %d; error: %d %s", pool, + errno, strerror(errno)); + exit(EXIT_FAILURE); + } +} + +static void kvp_update_file(int pool) +{ + FILE *filep; + + /* + * We are going to write our in-memory registry out to + * disk; acquire the lock first. + */ + kvp_acquire_lock(pool); + + filep = fopen(kvp_file_info[pool].fname, "we"); + if (!filep) { + syslog(LOG_ERR, "Failed to open file, pool: %d; error: %d %s", pool, + errno, strerror(errno)); + kvp_release_lock(pool); + exit(EXIT_FAILURE); + } + + fwrite(kvp_file_info[pool].records, sizeof(struct kvp_record), + kvp_file_info[pool].num_records, filep); + + if (ferror(filep) || fclose(filep)) { + kvp_release_lock(pool); + syslog(LOG_ERR, "Failed to write file, pool: %d", pool); + exit(EXIT_FAILURE); + } + + kvp_release_lock(pool); +} + +static void kvp_update_mem_state(int pool) +{ + FILE *filep; + size_t records_read = 0; + struct kvp_record *record = kvp_file_info[pool].records; + struct kvp_record *readp; + int num_blocks = kvp_file_info[pool].num_blocks; + int alloc_unit = sizeof(struct kvp_record) * ENTRIES_PER_BLOCK; + + kvp_acquire_lock(pool); + + filep = fopen(kvp_file_info[pool].fname, "re"); + if (!filep) { + syslog(LOG_ERR, "Failed to open file, pool: %d; error: %d %s", pool, + errno, strerror(errno)); + kvp_release_lock(pool); + exit(EXIT_FAILURE); + } + for (;;) { + readp = &record[records_read]; + records_read += fread(readp, sizeof(struct kvp_record), + ENTRIES_PER_BLOCK * num_blocks - records_read, + filep); + + if (ferror(filep)) { + syslog(LOG_ERR, + "Failed to read file, pool: %d; error: %d %s", + pool, errno, strerror(errno)); + kvp_release_lock(pool); + exit(EXIT_FAILURE); + } + + if (!feof(filep)) { + /* + * We have more data to read. + */ + num_blocks++; + record = realloc(record, alloc_unit * num_blocks); + + if (record == NULL) { + syslog(LOG_ERR, "malloc failed"); + kvp_release_lock(pool); + exit(EXIT_FAILURE); + } + continue; + } + break; + } + + kvp_file_info[pool].num_blocks = num_blocks; + kvp_file_info[pool].records = record; + kvp_file_info[pool].num_records = records_read; + + fclose(filep); + kvp_release_lock(pool); +} + +static int kvp_file_init(void) +{ + int fd; + char *fname; + int i; + int alloc_unit = sizeof(struct kvp_record) * ENTRIES_PER_BLOCK; + + if (access(KVP_CONFIG_LOC, F_OK)) { + if (mkdir(KVP_CONFIG_LOC, 0755 /* rwxr-xr-x */)) { + syslog(LOG_ERR, "Failed to create '%s'; error: %d %s", KVP_CONFIG_LOC, + errno, strerror(errno)); + exit(EXIT_FAILURE); + } + } + + for (i = 0; i < KVP_POOL_COUNT; i++) { + fname = kvp_file_info[i].fname; + sprintf(fname, "%s/.kvp_pool_%d", KVP_CONFIG_LOC, i); + fd = open(fname, O_RDWR | O_CREAT | O_CLOEXEC, 0644 /* rw-r--r-- */); + + if (fd == -1) + return 1; + + kvp_file_info[i].fd = fd; + kvp_file_info[i].num_blocks = 1; + kvp_file_info[i].records = malloc(alloc_unit); + if (kvp_file_info[i].records == NULL) + return 1; + kvp_file_info[i].num_records = 0; + kvp_update_mem_state(i); + } + + return 0; +} + +static int kvp_key_delete(int pool, const __u8 *key, int key_size) +{ + int i; + int j, k; + int num_records; + struct kvp_record *record; + + /* + * First update the in-memory state. + */ + kvp_update_mem_state(pool); + + num_records = kvp_file_info[pool].num_records; + record = kvp_file_info[pool].records; + + for (i = 0; i < num_records; i++) { + if (memcmp(key, record[i].key, key_size)) + continue; + /* + * Found a match; just move the remaining + * entries up. + */ + if (i == (num_records - 1)) { + kvp_file_info[pool].num_records--; + kvp_update_file(pool); + return 0; + } + + j = i; + k = j + 1; + for (; k < num_records; k++) { + strcpy(record[j].key, record[k].key); + strcpy(record[j].value, record[k].value); + j++; + } + + kvp_file_info[pool].num_records--; + kvp_update_file(pool); + return 0; + } + return 1; +} + +static int kvp_key_add_or_modify(int pool, const __u8 *key, int key_size, + const __u8 *value, int value_size) +{ + int i; + int num_records; + struct kvp_record *record; + int num_blocks; + + if ((key_size > HV_KVP_EXCHANGE_MAX_KEY_SIZE) || + (value_size > HV_KVP_EXCHANGE_MAX_VALUE_SIZE)) + return 1; + + /* + * First update the in-memory state. + */ + kvp_update_mem_state(pool); + + num_records = kvp_file_info[pool].num_records; + record = kvp_file_info[pool].records; + num_blocks = kvp_file_info[pool].num_blocks; + + for (i = 0; i < num_records; i++) { + if (memcmp(key, record[i].key, key_size)) + continue; + /* + * Found a match; just update the value - + * this is the modify case. + */ + memcpy(record[i].value, value, value_size); + kvp_update_file(pool); + return 0; + } + + /* + * Need to add a new entry; + */ + if (num_records == (ENTRIES_PER_BLOCK * num_blocks)) { + /* Need to allocate a larger array for reg entries. */ + record = realloc(record, sizeof(struct kvp_record) * + ENTRIES_PER_BLOCK * (num_blocks + 1)); + + if (record == NULL) + return 1; + kvp_file_info[pool].num_blocks++; + + } + memcpy(record[i].value, value, value_size); + memcpy(record[i].key, key, key_size); + kvp_file_info[pool].records = record; + kvp_file_info[pool].num_records++; + kvp_update_file(pool); + return 0; +} + +static int kvp_get_value(int pool, const __u8 *key, int key_size, __u8 *value, + int value_size) +{ + int i; + int num_records; + struct kvp_record *record; + + if ((key_size > HV_KVP_EXCHANGE_MAX_KEY_SIZE) || + (value_size > HV_KVP_EXCHANGE_MAX_VALUE_SIZE)) + return 1; + + /* + * First update the in-memory state. + */ + kvp_update_mem_state(pool); + + num_records = kvp_file_info[pool].num_records; + record = kvp_file_info[pool].records; + + for (i = 0; i < num_records; i++) { + if (memcmp(key, record[i].key, key_size)) + continue; + /* + * Found a match; just copy the value out. + */ + memcpy(value, record[i].value, value_size); + return 0; + } + + return 1; +} + +static int kvp_pool_enumerate(int pool, int index, __u8 *key, int key_size, + __u8 *value, int value_size) +{ + struct kvp_record *record; + + /* + * First update our in-memory database. + */ + kvp_update_mem_state(pool); + record = kvp_file_info[pool].records; + + if (index >= kvp_file_info[pool].num_records) { + return 1; + } + + memcpy(key, record[index].key, key_size); + memcpy(value, record[index].value, value_size); + return 0; +} + + +void kvp_get_os_info(void) +{ + FILE *file; + char *p, buf[512]; + + uname(&uts_buf); + os_version = uts_buf.release; + os_build = strdup(uts_buf.release); + + os_name = uts_buf.sysname; + processor_arch = uts_buf.machine; + + /* + * The current windows host (win7) expects the build + * string to be of the form: x.y.z + * Strip additional information we may have. + */ + p = strchr(os_version, '-'); + if (p) + *p = '\0'; + + /* + * Parse the /etc/os-release file if present: + * http://www.freedesktop.org/software/systemd/man/os-release.html + */ + file = fopen("/etc/os-release", "r"); + if (file != NULL) { + while (fgets(buf, sizeof(buf), file)) { + char *value, *q; + + /* Ignore comments */ + if (buf[0] == '#') + continue; + + /* Split into name=value */ + p = strchr(buf, '='); + if (!p) + continue; + *p++ = 0; + + /* Remove quotes and newline; un-escape */ + value = p; + q = p; + while (*p) { + if (*p == '\\') { + ++p; + if (!*p) + break; + *q++ = *p++; + } else if (*p == '\'' || *p == '"' || + *p == '\n') { + ++p; + } else { + *q++ = *p++; + } + } + *q = 0; + + if (!strcmp(buf, "NAME")) { + p = strdup(value); + if (!p) + break; + os_name = p; + } else if (!strcmp(buf, "VERSION_ID")) { + p = strdup(value); + if (!p) + break; + os_major = p; + } + } + fclose(file); + return; + } + + /* Fallback for older RH/SUSE releases */ + file = fopen("/etc/SuSE-release", "r"); + if (file != NULL) + goto kvp_osinfo_found; + file = fopen("/etc/redhat-release", "r"); + if (file != NULL) + goto kvp_osinfo_found; + + /* + * We don't have information about the os. + */ + return; + +kvp_osinfo_found: + /* up to three lines */ + p = fgets(buf, sizeof(buf), file); + if (p) { + p = strchr(buf, '\n'); + if (p) + *p = '\0'; + p = strdup(buf); + if (!p) + goto done; + os_name = p; + + /* second line */ + p = fgets(buf, sizeof(buf), file); + if (p) { + p = strchr(buf, '\n'); + if (p) + *p = '\0'; + p = strdup(buf); + if (!p) + goto done; + os_major = p; + + /* third line */ + p = fgets(buf, sizeof(buf), file); + if (p) { + p = strchr(buf, '\n'); + if (p) + *p = '\0'; + p = strdup(buf); + if (p) + os_minor = p; + } + } + } + +done: + fclose(file); + return; +} + + + +/* + * Retrieve an interface name corresponding to the specified guid. + * If there is a match, the function returns a pointer + * to the interface name and if not, a NULL is returned. + * If a match is found, the caller is responsible for + * freeing the memory. + */ + +static char *kvp_get_if_name(char *guid) +{ + DIR *dir; + struct dirent *entry; + FILE *file; + char *p, *x; + char *if_name = NULL; + char buf[256]; + char dev_id[PATH_MAX]; + + dir = opendir(KVP_NET_DIR); + if (dir == NULL) + return NULL; + + while ((entry = readdir(dir)) != NULL) { + /* + * Set the state for the next pass. + */ + snprintf(dev_id, sizeof(dev_id), "%s%s/device/device_id", + KVP_NET_DIR, entry->d_name); + + file = fopen(dev_id, "r"); + if (file == NULL) + continue; + + p = fgets(buf, sizeof(buf), file); + if (p) { + x = strchr(p, '\n'); + if (x) + *x = '\0'; + + if (!strcmp(p, guid)) { + /* + * Found the guid match; return the interface + * name. The caller will free the memory. + */ + if_name = strdup(entry->d_name); + fclose(file); + break; + } + } + fclose(file); + } + + closedir(dir); + return if_name; +} + +/* + * Retrieve the MAC address given the interface name. + */ + +static char *kvp_if_name_to_mac(char *if_name) +{ + FILE *file; + char *p, *x; + char buf[256]; + char addr_file[PATH_MAX]; + unsigned int i; + char *mac_addr = NULL; + + snprintf(addr_file, sizeof(addr_file), "%s%s%s", KVP_NET_DIR, + if_name, "/address"); + + file = fopen(addr_file, "r"); + if (file == NULL) + return NULL; + + p = fgets(buf, sizeof(buf), file); + if (p) { + x = strchr(p, '\n'); + if (x) + *x = '\0'; + for (i = 0; i < strlen(p); i++) + p[i] = toupper(p[i]); + mac_addr = strdup(p); + } + + fclose(file); + return mac_addr; +} + +static void kvp_process_ipconfig_file(char *cmd, + char *config_buf, unsigned int len, + int element_size, int offset) +{ + char buf[256]; + char *p; + char *x; + FILE *file; + + /* + * First execute the command. + */ + file = popen(cmd, "r"); + if (file == NULL) + return; + + if (offset == 0) + memset(config_buf, 0, len); + while ((p = fgets(buf, sizeof(buf), file)) != NULL) { + if (len < strlen(config_buf) + element_size + 1) + break; + + x = strchr(p, '\n'); + if (x) + *x = '\0'; + + strcat(config_buf, p); + strcat(config_buf, ";"); + } + pclose(file); +} + +static void kvp_get_ipconfig_info(char *if_name, + struct hv_kvp_ipaddr_value *buffer) +{ + char cmd[512]; + char dhcp_info[128]; + char *p; + FILE *file; + + /* + * Get the address of default gateway (ipv4). + */ + sprintf(cmd, "%s %s", "ip route show dev", if_name); + strcat(cmd, " | awk '/default/ {print $3 }'"); + + /* + * Execute the command to gather gateway info. + */ + kvp_process_ipconfig_file(cmd, (char *)buffer->gate_way, + (MAX_GATEWAY_SIZE * 2), INET_ADDRSTRLEN, 0); + + /* + * Get the address of default gateway (ipv6). + */ + sprintf(cmd, "%s %s", "ip -f inet6 route show dev", if_name); + strcat(cmd, " | awk '/default/ {print $3 }'"); + + /* + * Execute the command to gather gateway info (ipv6). + */ + kvp_process_ipconfig_file(cmd, (char *)buffer->gate_way, + (MAX_GATEWAY_SIZE * 2), INET6_ADDRSTRLEN, 1); + + + /* + * Gather the DNS state. + * Since there is no standard way to get this information + * across various distributions of interest; we just invoke + * an external script that needs to be ported across distros + * of interest. + * + * Following is the expected format of the information from the script: + * + * ipaddr1 (nameserver1) + * ipaddr2 (nameserver2) + * . + * . + */ + + sprintf(cmd, KVP_SCRIPTS_PATH "%s", "hv_get_dns_info"); + + /* + * Execute the command to gather DNS info. + */ + kvp_process_ipconfig_file(cmd, (char *)buffer->dns_addr, + (MAX_IP_ADDR_SIZE * 2), INET_ADDRSTRLEN, 0); + + /* + * Gather the DHCP state. + * We will gather this state by invoking an external script. + * The parameter to the script is the interface name. + * Here is the expected output: + * + * Enabled: DHCP enabled. + */ + + sprintf(cmd, KVP_SCRIPTS_PATH "%s %s", "hv_get_dhcp_info", if_name); + + file = popen(cmd, "r"); + if (file == NULL) + return; + + p = fgets(dhcp_info, sizeof(dhcp_info), file); + if (p == NULL) { + pclose(file); + return; + } + + if (!strncmp(p, "Enabled", 7)) + buffer->dhcp_enabled = 1; + else + buffer->dhcp_enabled = 0; + + pclose(file); +} + + +static unsigned int hweight32(unsigned int *w) +{ + unsigned int res = *w - ((*w >> 1) & 0x55555555); + res = (res & 0x33333333) + ((res >> 2) & 0x33333333); + res = (res + (res >> 4)) & 0x0F0F0F0F; + res = res + (res >> 8); + return (res + (res >> 16)) & 0x000000FF; +} + +static int kvp_process_ip_address(void *addrp, + int family, char *buffer, + int length, int *offset) +{ + struct sockaddr_in *addr; + struct sockaddr_in6 *addr6; + int addr_length; + char tmp[50]; + const char *str; + + if (family == AF_INET) { + addr = (struct sockaddr_in *)addrp; + str = inet_ntop(family, &addr->sin_addr, tmp, 50); + addr_length = INET_ADDRSTRLEN; + } else { + addr6 = (struct sockaddr_in6 *)addrp; + str = inet_ntop(family, &addr6->sin6_addr.s6_addr, tmp, 50); + addr_length = INET6_ADDRSTRLEN; + } + + if ((length - *offset) < addr_length + 2) + return HV_E_FAIL; + if (str == NULL) { + strcpy(buffer, "inet_ntop failed\n"); + return HV_E_FAIL; + } + if (*offset == 0) + strcpy(buffer, tmp); + else { + strcat(buffer, ";"); + strcat(buffer, tmp); + } + + *offset += strlen(str) + 1; + + return 0; +} + +static int +kvp_get_ip_info(int family, char *if_name, int op, + void *out_buffer, unsigned int length) +{ + struct ifaddrs *ifap; + struct ifaddrs *curp; + int offset = 0; + int sn_offset = 0; + int error = 0; + char *buffer; + struct hv_kvp_ipaddr_value *ip_buffer = NULL; + char cidr_mask[5]; /* /xyz */ + int weight; + int i; + unsigned int *w; + char *sn_str; + struct sockaddr_in6 *addr6; + + if (op == KVP_OP_ENUMERATE) { + buffer = out_buffer; + } else { + ip_buffer = out_buffer; + buffer = (char *)ip_buffer->ip_addr; + ip_buffer->addr_family = 0; + } + /* + * On entry into this function, the buffer is capable of holding the + * maximum key value. + */ + + if (getifaddrs(&ifap)) { + strcpy(buffer, "getifaddrs failed\n"); + return HV_E_FAIL; + } + + curp = ifap; + while (curp != NULL) { + if (curp->ifa_addr == NULL) { + curp = curp->ifa_next; + continue; + } + + if ((if_name != NULL) && + (strncmp(curp->ifa_name, if_name, strlen(if_name)))) { + /* + * We want info about a specific interface; + * just continue. + */ + curp = curp->ifa_next; + continue; + } + + /* + * We only support two address families: AF_INET and AF_INET6. + * If a family value of 0 is specified, we collect both + * supported address families; if not we gather info on + * the specified address family. + */ + if ((((family != 0) && + (curp->ifa_addr->sa_family != family))) || + (curp->ifa_flags & IFF_LOOPBACK)) { + curp = curp->ifa_next; + continue; + } + if ((curp->ifa_addr->sa_family != AF_INET) && + (curp->ifa_addr->sa_family != AF_INET6)) { + curp = curp->ifa_next; + continue; + } + + if (op == KVP_OP_GET_IP_INFO) { + /* + * Gather info other than the IP address. + * IP address info will be gathered later. + */ + if (curp->ifa_addr->sa_family == AF_INET) { + ip_buffer->addr_family |= ADDR_FAMILY_IPV4; + /* + * Get subnet info. + */ + error = kvp_process_ip_address( + curp->ifa_netmask, + AF_INET, + (char *) + ip_buffer->sub_net, + length, + &sn_offset); + if (error) + goto gather_ipaddr; + } else { + ip_buffer->addr_family |= ADDR_FAMILY_IPV6; + + /* + * Get subnet info in CIDR format. + */ + weight = 0; + sn_str = (char *)ip_buffer->sub_net; + addr6 = (struct sockaddr_in6 *) + curp->ifa_netmask; + w = addr6->sin6_addr.s6_addr32; + + for (i = 0; i < 4; i++) + weight += hweight32(&w[i]); + + sprintf(cidr_mask, "/%d", weight); + if (length < sn_offset + strlen(cidr_mask) + 1) + goto gather_ipaddr; + + if (sn_offset == 0) + strcpy(sn_str, cidr_mask); + else { + strcat((char *)ip_buffer->sub_net, ";"); + strcat(sn_str, cidr_mask); + } + sn_offset += strlen(sn_str) + 1; + } + + /* + * Collect other ip related configuration info. + */ + + kvp_get_ipconfig_info(if_name, ip_buffer); + } + +gather_ipaddr: + error = kvp_process_ip_address(curp->ifa_addr, + curp->ifa_addr->sa_family, + buffer, + length, &offset); + if (error) + goto getaddr_done; + + curp = curp->ifa_next; + } + +getaddr_done: + freeifaddrs(ifap); + return error; +} + +/* + * Retrieve the IP given the MAC address. + */ +static int kvp_mac_to_ip(struct hv_kvp_ipaddr_value *kvp_ip_val) +{ + char *mac = (char *)kvp_ip_val->adapter_id; + DIR *dir; + struct dirent *entry; + FILE *file; + char *p, *x; + char *if_name = NULL; + char buf[256]; + char dev_id[PATH_MAX]; + unsigned int i; + int error = HV_E_FAIL; + + dir = opendir(KVP_NET_DIR); + if (dir == NULL) + return HV_E_FAIL; + + while ((entry = readdir(dir)) != NULL) { + /* + * Set the state for the next pass. + */ + snprintf(dev_id, sizeof(dev_id), "%s%s/address", KVP_NET_DIR, + entry->d_name); + + file = fopen(dev_id, "r"); + if (file == NULL) + continue; + + p = fgets(buf, sizeof(buf), file); + fclose(file); + if (!p) + continue; + + x = strchr(p, '\n'); + if (x) + *x = '\0'; + + for (i = 0; i < strlen(p); i++) + p[i] = toupper(p[i]); + + if (strcmp(p, mac)) + continue; + + /* + * Found the MAC match. + * A NIC (e.g. VF) matching the MAC, but without IP, is skipped. + */ + if_name = entry->d_name; + if (!if_name) + continue; + + error = kvp_get_ip_info(0, if_name, KVP_OP_GET_IP_INFO, + kvp_ip_val, MAX_IP_ADDR_SIZE * 2); + + if (!error && strlen((char *)kvp_ip_val->ip_addr)) + break; + } + + closedir(dir); + return error; +} + +static int expand_ipv6(char *addr, int type) +{ + int ret; + struct in6_addr v6_addr; + + ret = inet_pton(AF_INET6, addr, &v6_addr); + + if (ret != 1) { + if (type == NETMASK) + return 1; + return 0; + } + + sprintf(addr, "%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:" + "%02x%02x:%02x%02x:%02x%02x", + (int)v6_addr.s6_addr[0], (int)v6_addr.s6_addr[1], + (int)v6_addr.s6_addr[2], (int)v6_addr.s6_addr[3], + (int)v6_addr.s6_addr[4], (int)v6_addr.s6_addr[5], + (int)v6_addr.s6_addr[6], (int)v6_addr.s6_addr[7], + (int)v6_addr.s6_addr[8], (int)v6_addr.s6_addr[9], + (int)v6_addr.s6_addr[10], (int)v6_addr.s6_addr[11], + (int)v6_addr.s6_addr[12], (int)v6_addr.s6_addr[13], + (int)v6_addr.s6_addr[14], (int)v6_addr.s6_addr[15]); + + return 1; + +} + +static int is_ipv4(char *addr) +{ + int ret; + struct in_addr ipv4_addr; + + ret = inet_pton(AF_INET, addr, &ipv4_addr); + + if (ret == 1) + return 1; + return 0; +} + +static int parse_ip_val_buffer(char *in_buf, int *offset, + char *out_buf, int out_len) +{ + char *x; + char *start; + + /* + * in_buf has sequence of characters that are separated by + * the character ';'. The last sequence does not have the + * terminating ";" character. + */ + start = in_buf + *offset; + + x = strchr(start, ';'); + if (x) + *x = 0; + else + x = start + strlen(start); + + if (strlen(start) != 0) { + int i = 0; + /* + * Get rid of leading spaces. + */ + while (start[i] == ' ') + i++; + + if ((x - start) <= out_len) { + strcpy(out_buf, (start + i)); + *offset += (x - start) + 1; + return 1; + } + } + return 0; +} + +static int kvp_write_file(FILE *f, char *s1, char *s2, char *s3) +{ + int ret; + + ret = fprintf(f, "%s%s%s%s\n", s1, s2, "=", s3); + + if (ret < 0) + return HV_E_FAIL; + + return 0; +} + + +static int process_ip_string(FILE *f, char *ip_string, int type) +{ + int error = 0; + char addr[INET6_ADDRSTRLEN]; + int i = 0; + int j = 0; + char str[256]; + char sub_str[13]; + int offset = 0; + + memset(addr, 0, sizeof(addr)); + + while (parse_ip_val_buffer(ip_string, &offset, addr, + (MAX_IP_ADDR_SIZE * 2))) { + + sub_str[0] = 0; + if (is_ipv4(addr)) { + switch (type) { + case IPADDR: + snprintf(str, sizeof(str), "%s", "IPADDR"); + break; + case NETMASK: + snprintf(str, sizeof(str), "%s", "NETMASK"); + break; + case GATEWAY: + snprintf(str, sizeof(str), "%s", "GATEWAY"); + break; + case DNS: + snprintf(str, sizeof(str), "%s", "DNS"); + break; + } + + if (type == DNS) { + snprintf(sub_str, sizeof(sub_str), "%d", ++i); + } else if (type == GATEWAY && i == 0) { + ++i; + } else { + snprintf(sub_str, sizeof(sub_str), "%d", i++); + } + + + } else if (expand_ipv6(addr, type)) { + switch (type) { + case IPADDR: + snprintf(str, sizeof(str), "%s", "IPV6ADDR"); + break; + case NETMASK: + snprintf(str, sizeof(str), "%s", "IPV6NETMASK"); + break; + case GATEWAY: + snprintf(str, sizeof(str), "%s", + "IPV6_DEFAULTGW"); + break; + case DNS: + snprintf(str, sizeof(str), "%s", "DNS"); + break; + } + + if (type == DNS) { + snprintf(sub_str, sizeof(sub_str), "%d", ++i); + } else if (j == 0) { + ++j; + } else { + snprintf(sub_str, sizeof(sub_str), "_%d", j++); + } + } else { + return HV_INVALIDARG; + } + + error = kvp_write_file(f, str, sub_str, addr); + if (error) + return error; + memset(addr, 0, sizeof(addr)); + } + + return 0; +} + +static int kvp_set_ip_info(char *if_name, struct hv_kvp_ipaddr_value *new_val) +{ + int error = 0; + char if_file[PATH_MAX]; + FILE *file; + char cmd[PATH_MAX]; + char *mac_addr; + int str_len; + + /* + * Set the configuration for the specified interface with + * the information provided. Since there is no standard + * way to configure an interface, we will have an external + * script that does the job of configuring the interface and + * flushing the configuration. + * + * The parameters passed to this external script are: + * 1. A configuration file that has the specified configuration. + * + * We will embed the name of the interface in the configuration + * file: ifcfg-ethx (where ethx is the interface name). + * + * The information provided here may be more than what is needed + * in a given distro to configure the interface and so are free + * ignore information that may not be relevant. + * + * Here is the format of the ip configuration file: + * + * HWADDR=macaddr + * DEVICE=interface name + * BOOTPROTO= (where is "dhcp" if DHCP is configured + * or "none" if no boot-time protocol should be used) + * + * IPADDR0=ipaddr1 + * IPADDR1=ipaddr2 + * IPADDRx=ipaddry (where y = x + 1) + * + * NETMASK0=netmask1 + * NETMASKx=netmasky (where y = x + 1) + * + * GATEWAY=ipaddr1 + * GATEWAYx=ipaddry (where y = x + 1) + * + * DNSx=ipaddrx (where first DNS address is tagged as DNS1 etc) + * + * IPV6 addresses will be tagged as IPV6ADDR, IPV6 gateway will be + * tagged as IPV6_DEFAULTGW and IPV6 NETMASK will be tagged as + * IPV6NETMASK. + * + * The host can specify multiple ipv4 and ipv6 addresses to be + * configured for the interface. Furthermore, the configuration + * needs to be persistent. A subsequent GET call on the interface + * is expected to return the configuration that is set via the SET + * call. + */ + + snprintf(if_file, sizeof(if_file), "%s%s%s", KVP_CONFIG_LOC, + "/ifcfg-", if_name); + + file = fopen(if_file, "w"); + + if (file == NULL) { + syslog(LOG_ERR, "Failed to open config file; error: %d %s", + errno, strerror(errno)); + return HV_E_FAIL; + } + + /* + * First write out the MAC address. + */ + + mac_addr = kvp_if_name_to_mac(if_name); + if (mac_addr == NULL) { + error = HV_E_FAIL; + goto setval_error; + } + + error = kvp_write_file(file, "HWADDR", "", mac_addr); + free(mac_addr); + if (error) + goto setval_error; + + error = kvp_write_file(file, "DEVICE", "", if_name); + if (error) + goto setval_error; + + /* + * The dhcp_enabled flag is only for IPv4. In the case the host only + * injects an IPv6 address, the flag is true, but we still need to + * proceed to parse and pass the IPv6 information to the + * disto-specific script hv_set_ifconfig. + */ + if (new_val->dhcp_enabled) { + error = kvp_write_file(file, "BOOTPROTO", "", "dhcp"); + if (error) + goto setval_error; + + } else { + error = kvp_write_file(file, "BOOTPROTO", "", "none"); + if (error) + goto setval_error; + } + + /* + * Write the configuration for ipaddress, netmask, gateway and + * name servers. + */ + + error = process_ip_string(file, (char *)new_val->ip_addr, IPADDR); + if (error) + goto setval_error; + + error = process_ip_string(file, (char *)new_val->sub_net, NETMASK); + if (error) + goto setval_error; + + error = process_ip_string(file, (char *)new_val->gate_way, GATEWAY); + if (error) + goto setval_error; + + error = process_ip_string(file, (char *)new_val->dns_addr, DNS); + if (error) + goto setval_error; + + fclose(file); + + /* + * Now that we have populated the configuration file, + * invoke the external script to do its magic. + */ + + str_len = snprintf(cmd, sizeof(cmd), KVP_SCRIPTS_PATH "%s %s", + "hv_set_ifconfig", if_file); + /* + * This is a little overcautious, but it's necessary to suppress some + * false warnings from gcc 8.0.1. + */ + if (str_len <= 0 || (unsigned int)str_len >= sizeof(cmd)) { + syslog(LOG_ERR, "Cmd '%s' (len=%d) may be too long", + cmd, str_len); + return HV_E_FAIL; + } + + if (system(cmd)) { + syslog(LOG_ERR, "Failed to execute cmd '%s'; error: %d %s", + cmd, errno, strerror(errno)); + return HV_E_FAIL; + } + return 0; + +setval_error: + syslog(LOG_ERR, "Failed to write config file"); + fclose(file); + return error; +} + + +static void +kvp_get_domain_name(char *buffer, int length) +{ + struct addrinfo hints, *info ; + int error = 0; + + gethostname(buffer, length); + memset(&hints, 0, sizeof(hints)); + hints.ai_family = AF_INET; /*Get only ipv4 addrinfo. */ + hints.ai_socktype = SOCK_STREAM; + hints.ai_flags = AI_CANONNAME; + + error = getaddrinfo(buffer, NULL, &hints, &info); + if (error != 0) { + snprintf(buffer, length, "getaddrinfo failed: 0x%x %s", + error, gai_strerror(error)); + return; + } + snprintf(buffer, length, "%s", info->ai_canonname); + freeaddrinfo(info); +} + +void print_usage(char *argv[]) +{ + fprintf(stderr, "Usage: %s [options]\n" + "Options are:\n" + " -n, --no-daemon stay in foreground, don't daemonize\n" + " -h, --help print this help\n", argv[0]); +} + +int main(int argc, char *argv[]) +{ + int kvp_fd, len; + int error; + struct pollfd pfd; + char *p; + struct hv_kvp_msg hv_msg[1]; + char *key_value; + char *key_name; + int op; + int pool; + char *if_name; + struct hv_kvp_ipaddr_value *kvp_ip_val; + int daemonize = 1, long_index = 0, opt; + + static struct option long_options[] = { + {"help", no_argument, 0, 'h' }, + {"no-daemon", no_argument, 0, 'n' }, + {0, 0, 0, 0 } + }; + + while ((opt = getopt_long(argc, argv, "hn", long_options, + &long_index)) != -1) { + switch (opt) { + case 'n': + daemonize = 0; + break; + case 'h': + print_usage(argv); + exit(0); + default: + print_usage(argv); + exit(EXIT_FAILURE); + } + } + + if (daemonize && daemon(1, 0)) + return 1; + + openlog("KVP", 0, LOG_USER); + syslog(LOG_INFO, "KVP starting; pid is:%d", getpid()); + + kvp_fd = open("/dev/vmbus/hv_kvp", O_RDWR | O_CLOEXEC); + + if (kvp_fd < 0) { + syslog(LOG_ERR, "open /dev/vmbus/hv_kvp failed; error: %d %s", + errno, strerror(errno)); + exit(EXIT_FAILURE); + } + + /* + * Retrieve OS release information. + */ + kvp_get_os_info(); + /* + * Cache Fully Qualified Domain Name because getaddrinfo takes an + * unpredictable amount of time to finish. + */ + kvp_get_domain_name(full_domain_name, sizeof(full_domain_name)); + + if (kvp_file_init()) { + syslog(LOG_ERR, "Failed to initialize the pools"); + exit(EXIT_FAILURE); + } + + /* + * Register ourselves with the kernel. + */ + hv_msg->kvp_hdr.operation = KVP_OP_REGISTER1; + len = write(kvp_fd, hv_msg, sizeof(struct hv_kvp_msg)); + if (len != sizeof(struct hv_kvp_msg)) { + syslog(LOG_ERR, "registration to kernel failed; error: %d %s", + errno, strerror(errno)); + close(kvp_fd); + exit(EXIT_FAILURE); + } + + pfd.fd = kvp_fd; + + while (1) { + pfd.events = POLLIN; + pfd.revents = 0; + + if (poll(&pfd, 1, -1) < 0) { + syslog(LOG_ERR, "poll failed; error: %d %s", errno, strerror(errno)); + if (errno == EINVAL) { + close(kvp_fd); + exit(EXIT_FAILURE); + } + else + continue; + } + + len = read(kvp_fd, hv_msg, sizeof(struct hv_kvp_msg)); + + if (len != sizeof(struct hv_kvp_msg)) { + syslog(LOG_ERR, "read failed; error:%d %s", + errno, strerror(errno)); + + close(kvp_fd); + return EXIT_FAILURE; + } + + /* + * We will use the KVP header information to pass back + * the error from this daemon. So, first copy the state + * and set the error code to success. + */ + op = hv_msg->kvp_hdr.operation; + pool = hv_msg->kvp_hdr.pool; + hv_msg->error = HV_S_OK; + + if ((in_hand_shake) && (op == KVP_OP_REGISTER1)) { + /* + * Driver is registering with us; stash away the version + * information. + */ + in_hand_shake = 0; + p = (char *)hv_msg->body.kvp_register.version; + lic_version = malloc(strlen(p) + 1); + if (lic_version) { + strcpy(lic_version, p); + syslog(LOG_INFO, "KVP LIC Version: %s", + lic_version); + } else { + syslog(LOG_ERR, "malloc failed"); + } + continue; + } + + switch (op) { + case KVP_OP_GET_IP_INFO: + kvp_ip_val = &hv_msg->body.kvp_ip_val; + + error = kvp_mac_to_ip(kvp_ip_val); + + if (error) + hv_msg->error = error; + + break; + + case KVP_OP_SET_IP_INFO: + kvp_ip_val = &hv_msg->body.kvp_ip_val; + if_name = kvp_get_if_name( + (char *)kvp_ip_val->adapter_id); + if (if_name == NULL) { + /* + * We could not map the guid to an + * interface name; return error. + */ + hv_msg->error = HV_GUID_NOTFOUND; + break; + } + error = kvp_set_ip_info(if_name, kvp_ip_val); + if (error) + hv_msg->error = error; + + free(if_name); + break; + + case KVP_OP_SET: + if (kvp_key_add_or_modify(pool, + hv_msg->body.kvp_set.data.key, + hv_msg->body.kvp_set.data.key_size, + hv_msg->body.kvp_set.data.value, + hv_msg->body.kvp_set.data.value_size)) + hv_msg->error = HV_S_CONT; + break; + + case KVP_OP_GET: + if (kvp_get_value(pool, + hv_msg->body.kvp_set.data.key, + hv_msg->body.kvp_set.data.key_size, + hv_msg->body.kvp_set.data.value, + hv_msg->body.kvp_set.data.value_size)) + hv_msg->error = HV_S_CONT; + break; + + case KVP_OP_DELETE: + if (kvp_key_delete(pool, + hv_msg->body.kvp_delete.key, + hv_msg->body.kvp_delete.key_size)) + hv_msg->error = HV_S_CONT; + break; + + default: + break; + } + + if (op != KVP_OP_ENUMERATE) + goto kvp_done; + + /* + * If the pool is KVP_POOL_AUTO, dynamically generate + * both the key and the value; if not read from the + * appropriate pool. + */ + if (pool != KVP_POOL_AUTO) { + if (kvp_pool_enumerate(pool, + hv_msg->body.kvp_enum_data.index, + hv_msg->body.kvp_enum_data.data.key, + HV_KVP_EXCHANGE_MAX_KEY_SIZE, + hv_msg->body.kvp_enum_data.data.value, + HV_KVP_EXCHANGE_MAX_VALUE_SIZE)) + hv_msg->error = HV_S_CONT; + goto kvp_done; + } + + key_name = (char *)hv_msg->body.kvp_enum_data.data.key; + key_value = (char *)hv_msg->body.kvp_enum_data.data.value; + + switch (hv_msg->body.kvp_enum_data.index) { + case FullyQualifiedDomainName: + strcpy(key_value, full_domain_name); + strcpy(key_name, "FullyQualifiedDomainName"); + break; + case IntegrationServicesVersion: + strcpy(key_name, "IntegrationServicesVersion"); + strcpy(key_value, lic_version); + break; + case NetworkAddressIPv4: + kvp_get_ip_info(AF_INET, NULL, KVP_OP_ENUMERATE, + key_value, HV_KVP_EXCHANGE_MAX_VALUE_SIZE); + strcpy(key_name, "NetworkAddressIPv4"); + break; + case NetworkAddressIPv6: + kvp_get_ip_info(AF_INET6, NULL, KVP_OP_ENUMERATE, + key_value, HV_KVP_EXCHANGE_MAX_VALUE_SIZE); + strcpy(key_name, "NetworkAddressIPv6"); + break; + case OSBuildNumber: + strcpy(key_value, os_build); + strcpy(key_name, "OSBuildNumber"); + break; + case OSName: + strcpy(key_value, os_name); + strcpy(key_name, "OSName"); + break; + case OSMajorVersion: + strcpy(key_value, os_major); + strcpy(key_name, "OSMajorVersion"); + break; + case OSMinorVersion: + strcpy(key_value, os_minor); + strcpy(key_name, "OSMinorVersion"); + break; + case OSVersion: + strcpy(key_value, os_version); + strcpy(key_name, "OSVersion"); + break; + case ProcessorArchitecture: + strcpy(key_value, processor_arch); + strcpy(key_name, "ProcessorArchitecture"); + break; + default: + hv_msg->error = HV_S_CONT; + break; + } + + /* Send the value back to the kernel. */ +kvp_done: + len = write(kvp_fd, hv_msg, sizeof(struct hv_kvp_msg)); + if (len != sizeof(struct hv_kvp_msg)) { + syslog(LOG_ERR, "write failed; error: %d %s", errno, + strerror(errno)); + exit(EXIT_FAILURE); + } + } + + close(kvp_fd); + exit(0); +} diff --git a/SOURCES/hv_set_ifconfig.sh b/SOURCES/hv_set_ifconfig.sh new file mode 100644 index 0000000..7ed9f85 --- /dev/null +++ b/SOURCES/hv_set_ifconfig.sh @@ -0,0 +1,65 @@ +#!/bin/bash +# SPDX-License-Identifier: GPL-2.0 + +# This example script activates an interface based on the specified +# configuration. +# +# In the interest of keeping the KVP daemon code free of distro specific +# information; the kvp daemon code invokes this external script to configure +# the interface. +# +# The only argument to this script is the configuration file that is to +# be used to configure the interface. +# +# Each Distro is expected to implement this script in a distro specific +# fashion. For instance on Distros that ship with Network Manager enabled, +# this script can be based on the Network Manager APIs for configuring the +# interface. +# +# This example script is based on a RHEL environment. +# +# Here is the format of the ip configuration file: +# +# HWADDR=macaddr +# DEVICE=interface name +# BOOTPROTO= (where is "dhcp" if DHCP is configured +# or "none" if no boot-time protocol should be used) +# +# IPADDR0=ipaddr1 +# IPADDR1=ipaddr2 +# IPADDRx=ipaddry (where y = x + 1) +# +# NETMASK0=netmask1 +# NETMASKx=netmasky (where y = x + 1) +# +# GATEWAY=ipaddr1 +# GATEWAYx=ipaddry (where y = x + 1) +# +# DNSx=ipaddrx (where first DNS address is tagged as DNS1 etc) +# +# IPV6 addresses will be tagged as IPV6ADDR, IPV6 gateway will be +# tagged as IPV6_DEFAULTGW and IPV6 NETMASK will be tagged as +# IPV6NETMASK. +# +# The host can specify multiple ipv4 and ipv6 addresses to be +# configured for the interface. Furthermore, the configuration +# needs to be persistent. A subsequent GET call on the interface +# is expected to return the configuration that is set via the SET +# call. +# + + + +echo "IPV6INIT=yes" >> $1 +echo "NM_CONTROLLED=no" >> $1 +echo "PEERDNS=yes" >> $1 +echo "ONBOOT=yes" >> $1 + + +cp $1 /etc/sysconfig/network-scripts/ + + +interface=$(echo $1 | awk -F - '{ print $2 }') + +/sbin/ifdown $interface 2>/dev/null +/sbin/ifup $interface 2>/dev/null diff --git a/SOURCES/hv_vss_daemon.c b/SOURCES/hv_vss_daemon.c new file mode 100644 index 0000000..92902a8 --- /dev/null +++ b/SOURCES/hv_vss_daemon.c @@ -0,0 +1,328 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * An implementation of the host initiated guest snapshot for Hyper-V. + * + * Copyright (C) 2013, Microsoft, Inc. + * Author : K. Y. Srinivasan + */ + + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/* Don't use syslog() in the function since that can cause write to disk */ +static int vss_do_freeze(char *dir, unsigned int cmd) +{ + int ret, fd = open(dir, O_RDONLY); + + if (fd < 0) + return 1; + + ret = ioctl(fd, cmd, 0); + + /* + * If a partition is mounted more than once, only the first + * FREEZE/THAW can succeed and the later ones will get + * EBUSY/EINVAL respectively: there could be 2 cases: + * 1) a user may mount the same partition to different directories + * by mistake or on purpose; + * 2) The subvolume of btrfs appears to have the same partition + * mounted more than once. + */ + if (ret) { + if ((cmd == FIFREEZE && errno == EBUSY) || + (cmd == FITHAW && errno == EINVAL)) { + close(fd); + return 0; + } + } + + close(fd); + return !!ret; +} + +static bool is_dev_loop(const char *blkname) +{ + char *buffer; + DIR *dir; + struct dirent *entry; + bool ret = false; + + buffer = malloc(PATH_MAX); + if (!buffer) { + syslog(LOG_ERR, "Can't allocate memory!"); + exit(1); + } + + snprintf(buffer, PATH_MAX, "%s/loop", blkname); + if (!access(buffer, R_OK | X_OK)) { + ret = true; + goto free_buffer; + } else if (errno != ENOENT) { + syslog(LOG_ERR, "Can't access: %s; error:%d %s!", + buffer, errno, strerror(errno)); + } + + snprintf(buffer, PATH_MAX, "%s/slaves", blkname); + dir = opendir(buffer); + if (!dir) { + if (errno != ENOENT) + syslog(LOG_ERR, "Can't opendir: %s; error:%d %s!", + buffer, errno, strerror(errno)); + goto free_buffer; + } + + while ((entry = readdir(dir)) != NULL) { + if (strcmp(entry->d_name, ".") == 0 || + strcmp(entry->d_name, "..") == 0) + continue; + + snprintf(buffer, PATH_MAX, "%s/slaves/%s", blkname, + entry->d_name); + if (is_dev_loop(buffer)) { + ret = true; + break; + } + } + closedir(dir); +free_buffer: + free(buffer); + return ret; +} + +static int vss_operate(int operation) +{ + char match[] = "/dev/"; + FILE *mounts; + struct mntent *ent; + struct stat sb; + char errdir[1024] = {0}; + char blkdir[23]; /* /sys/dev/block/XXX:XXX */ + unsigned int cmd; + int error = 0, root_seen = 0, save_errno = 0; + + switch (operation) { + case VSS_OP_FREEZE: + cmd = FIFREEZE; + break; + case VSS_OP_THAW: + cmd = FITHAW; + break; + default: + return -1; + } + + mounts = setmntent("/proc/mounts", "r"); + if (mounts == NULL) + return -1; + + while ((ent = getmntent(mounts))) { + if (strncmp(ent->mnt_fsname, match, strlen(match))) + continue; + if (stat(ent->mnt_fsname, &sb)) { + syslog(LOG_ERR, "Can't stat: %s; error:%d %s!", + ent->mnt_fsname, errno, strerror(errno)); + } else { + sprintf(blkdir, "/sys/dev/block/%d:%d", + major(sb.st_rdev), minor(sb.st_rdev)); + if (is_dev_loop(blkdir)) + continue; + } + if (hasmntopt(ent, MNTOPT_RO) != NULL) + continue; + if (strcmp(ent->mnt_type, "vfat") == 0) + continue; + if (strcmp(ent->mnt_dir, "/") == 0) { + root_seen = 1; + continue; + } + error |= vss_do_freeze(ent->mnt_dir, cmd); + if (error && operation == VSS_OP_FREEZE) + goto err; + } + + endmntent(mounts); + + if (root_seen) { + error |= vss_do_freeze("/", cmd); + if (error && operation == VSS_OP_FREEZE) + goto err; + } + + goto out; +err: + save_errno = errno; + if (ent) { + strncpy(errdir, ent->mnt_dir, sizeof(errdir)-1); + endmntent(mounts); + } + vss_operate(VSS_OP_THAW); + /* Call syslog after we thaw all filesystems */ + if (ent) + syslog(LOG_ERR, "FREEZE of %s failed; error:%d %s", + errdir, save_errno, strerror(save_errno)); + else + syslog(LOG_ERR, "FREEZE of / failed; error:%d %s", save_errno, + strerror(save_errno)); +out: + return error; +} + +void print_usage(char *argv[]) +{ + fprintf(stderr, "Usage: %s [options]\n" + "Options are:\n" + " -n, --no-daemon stay in foreground, don't daemonize\n" + " -h, --help print this help\n", argv[0]); +} + +int main(int argc, char *argv[]) +{ + int vss_fd, len; + int error; + struct pollfd pfd; + int op; + struct hv_vss_msg vss_msg[1]; + int daemonize = 1, long_index = 0, opt; + int in_handshake = 1; + __u32 kernel_modver; + + static struct option long_options[] = { + {"help", no_argument, 0, 'h' }, + {"no-daemon", no_argument, 0, 'n' }, + {0, 0, 0, 0 } + }; + + while ((opt = getopt_long(argc, argv, "hn", long_options, + &long_index)) != -1) { + switch (opt) { + case 'n': + daemonize = 0; + break; + case 'h': + print_usage(argv); + exit(0); + default: + print_usage(argv); + exit(EXIT_FAILURE); + } + } + + if (daemonize && daemon(1, 0)) + return 1; + + openlog("Hyper-V VSS", 0, LOG_USER); + syslog(LOG_INFO, "VSS starting; pid is:%d", getpid()); + + vss_fd = open("/dev/vmbus/hv_vss", O_RDWR); + if (vss_fd < 0) { + syslog(LOG_ERR, "open /dev/vmbus/hv_vss failed; error: %d %s", + errno, strerror(errno)); + exit(EXIT_FAILURE); + } + /* + * Register ourselves with the kernel. + */ + vss_msg->vss_hdr.operation = VSS_OP_REGISTER1; + + len = write(vss_fd, vss_msg, sizeof(struct hv_vss_msg)); + if (len < 0) { + syslog(LOG_ERR, "registration to kernel failed; error: %d %s", + errno, strerror(errno)); + close(vss_fd); + exit(EXIT_FAILURE); + } + + pfd.fd = vss_fd; + + while (1) { + pfd.events = POLLIN; + pfd.revents = 0; + + if (poll(&pfd, 1, -1) < 0) { + syslog(LOG_ERR, "poll failed; error:%d %s", errno, strerror(errno)); + if (errno == EINVAL) { + close(vss_fd); + exit(EXIT_FAILURE); + } + else + continue; + } + + len = read(vss_fd, vss_msg, sizeof(struct hv_vss_msg)); + + if (in_handshake) { + if (len != sizeof(kernel_modver)) { + syslog(LOG_ERR, "invalid version negotiation"); + exit(EXIT_FAILURE); + } + kernel_modver = *(__u32 *)vss_msg; + in_handshake = 0; + syslog(LOG_INFO, "VSS: kernel module version: %d", + kernel_modver); + continue; + } + + if (len != sizeof(struct hv_vss_msg)) { + syslog(LOG_ERR, "read failed; error:%d %s", + errno, strerror(errno)); + close(vss_fd); + return EXIT_FAILURE; + } + + op = vss_msg->vss_hdr.operation; + error = HV_S_OK; + + switch (op) { + case VSS_OP_FREEZE: + case VSS_OP_THAW: + error = vss_operate(op); + syslog(LOG_INFO, "VSS: op=%s: %s\n", + op == VSS_OP_FREEZE ? "FREEZE" : "THAW", + error ? "failed" : "succeeded"); + + if (error) { + error = HV_E_FAIL; + syslog(LOG_ERR, "op=%d failed!", op); + syslog(LOG_ERR, "report it with these files:"); + syslog(LOG_ERR, "/etc/fstab and /proc/mounts"); + } + break; + case VSS_OP_HOT_BACKUP: + syslog(LOG_INFO, "VSS: op=CHECK HOT BACKUP\n"); + break; + default: + syslog(LOG_ERR, "Illegal op:%d\n", op); + } + vss_msg->error = error; + len = write(vss_fd, vss_msg, sizeof(struct hv_vss_msg)); + if (len != sizeof(struct hv_vss_msg)) { + syslog(LOG_ERR, "write failed; error: %d %s", errno, + strerror(errno)); + + if (op == VSS_OP_FREEZE) + vss_operate(VSS_OP_THAW); + } + } + + close(vss_fd); + exit(0); +} diff --git a/SOURCES/hypervfcopy.rules b/SOURCES/hypervfcopy.rules new file mode 100644 index 0000000..f70b879 --- /dev/null +++ b/SOURCES/hypervfcopy.rules @@ -0,0 +1 @@ +SUBSYSTEM=="misc", KERNEL=="vmbus/hv_fcopy", TAG+="systemd", ENV{SYSTEMD_WANTS}+="hypervfcopyd.service" diff --git a/SOURCES/hypervfcopyd.service b/SOURCES/hypervfcopyd.service new file mode 100644 index 0000000..dd14a97 --- /dev/null +++ b/SOURCES/hypervfcopyd.service @@ -0,0 +1,7 @@ +[Unit] +Description=Hyper-V FCOPY daemon +BindsTo=sys-devices-virtual-misc-vmbus\x21hv_fcopy.device +IgnoreOnIsolate=1 + +[Service] +ExecStart=/usr/sbin/hypervfcopyd -n diff --git a/SOURCES/hypervkvp.rules b/SOURCES/hypervkvp.rules new file mode 100644 index 0000000..2cf867f --- /dev/null +++ b/SOURCES/hypervkvp.rules @@ -0,0 +1 @@ +SUBSYSTEM=="misc", KERNEL=="vmbus/hv_kvp", TAG+="systemd", ENV{SYSTEMD_WANTS}+="hypervkvpd.service" diff --git a/SOURCES/hypervkvpd.service b/SOURCES/hypervkvpd.service new file mode 100644 index 0000000..36ee11c --- /dev/null +++ b/SOURCES/hypervkvpd.service @@ -0,0 +1,9 @@ +[Unit] +Description=Hyper-V KVP daemon +BindsTo=sys-devices-virtual-misc-vmbus\x21hv_kvp.device +After=network.target +IgnoreOnIsolate=1 + +[Service] +Type=simple +ExecStart=/usr/sbin/hypervkvpd -n diff --git a/SOURCES/hypervvss.rules b/SOURCES/hypervvss.rules new file mode 100644 index 0000000..a8a8eb0 --- /dev/null +++ b/SOURCES/hypervvss.rules @@ -0,0 +1 @@ +SUBSYSTEM=="misc", KERNEL=="vmbus/hv_vss", TAG+="systemd", ENV{SYSTEMD_WANTS}+="hypervvssd.service" diff --git a/SOURCES/hypervvssd.service b/SOURCES/hypervvssd.service new file mode 100644 index 0000000..1e5ff43 --- /dev/null +++ b/SOURCES/hypervvssd.service @@ -0,0 +1,7 @@ +[Unit] +Description=Hyper-V VSS daemon +BindsTo=sys-devices-virtual-misc-vmbus\x21hv_vss.device +IgnoreOnIsolate=1 + +[Service] +ExecStart=/usr/sbin/hypervvssd -n diff --git a/SOURCES/lsvmbus b/SOURCES/lsvmbus new file mode 100644 index 0000000..099f2c4 --- /dev/null +++ b/SOURCES/lsvmbus @@ -0,0 +1,112 @@ +#!/usr/bin/env python +# SPDX-License-Identifier: GPL-2.0 + +import os +from optparse import OptionParser + +help_msg = "print verbose messages. Try -vv, -vvv for more verbose messages" +parser = OptionParser() +parser.add_option( + "-v", "--verbose", dest="verbose", help=help_msg, action="count") + +(options, args) = parser.parse_args() + +verbose = 0 +if options.verbose is not None: + verbose = options.verbose + +vmbus_sys_path = '/sys/bus/vmbus/devices' +if not os.path.isdir(vmbus_sys_path): + print("%s doesn't exist: exiting..." % vmbus_sys_path) + exit(-1) + +vmbus_dev_dict = { + '{0e0b6031-5213-4934-818b-38d90ced39db}': '[Operating system shutdown]', + '{9527e630-d0ae-497b-adce-e80ab0175caf}': '[Time Synchronization]', + '{57164f39-9115-4e78-ab55-382f3bd5422d}': '[Heartbeat]', + '{a9a0f4e7-5a45-4d96-b827-8a841e8c03e6}': '[Data Exchange]', + '{35fa2e29-ea23-4236-96ae-3a6ebacba440}': '[Backup (volume checkpoint)]', + '{34d14be3-dee4-41c8-9ae7-6b174977c192}': '[Guest services]', + '{525074dc-8985-46e2-8057-a307dc18a502}': '[Dynamic Memory]', + '{cfa8b69e-5b4a-4cc0-b98b-8ba1a1f3f95a}': 'Synthetic mouse', + '{f912ad6d-2b17-48ea-bd65-f927a61c7684}': 'Synthetic keyboard', + '{da0a7802-e377-4aac-8e77-0558eb1073f8}': 'Synthetic framebuffer adapter', + '{f8615163-df3e-46c5-913f-f2d2f965ed0e}': 'Synthetic network adapter', + '{32412632-86cb-44a2-9b5c-50d1417354f5}': 'Synthetic IDE Controller', + '{ba6163d9-04a1-4d29-b605-72e2ffb1dc7f}': 'Synthetic SCSI Controller', + '{2f9bcc4a-0069-4af3-b76b-6fd0be528cda}': 'Synthetic fiber channel adapter', + '{8c2eaf3d-32a7-4b09-ab99-bd1f1c86b501}': 'Synthetic RDMA adapter', + '{44c4f61d-4444-4400-9d52-802e27ede19f}': 'PCI Express pass-through', + '{276aacf4-ac15-426c-98dd-7521ad3f01fe}': '[Reserved system device]', + '{f8e65716-3cb3-4a06-9a60-1889c5cccab5}': '[Reserved system device]', + '{3375baf4-9e15-4b30-b765-67acb10d607b}': '[Reserved system device]', +} + + +def get_vmbus_dev_attr(dev_name, attr): + try: + f = open('%s/%s/%s' % (vmbus_sys_path, dev_name, attr), 'r') + lines = f.readlines() + f.close() + except IOError: + lines = [] + + return lines + + +class VMBus_Dev: + pass + + +vmbus_dev_list = [] + +for f in os.listdir(vmbus_sys_path): + vmbus_id = get_vmbus_dev_attr(f, 'id')[0].strip() + class_id = get_vmbus_dev_attr(f, 'class_id')[0].strip() + device_id = get_vmbus_dev_attr(f, 'device_id')[0].strip() + dev_desc = vmbus_dev_dict.get(class_id, 'Unknown') + + chn_vp_mapping = get_vmbus_dev_attr(f, 'channel_vp_mapping') + chn_vp_mapping = [c.strip() for c in chn_vp_mapping] + chn_vp_mapping = sorted( + chn_vp_mapping, key=lambda c: int(c.split(':')[0])) + + chn_vp_mapping = [ + '\tRel_ID=%s, target_cpu=%s' % + (c.split(':')[0], c.split(':')[1]) for c in chn_vp_mapping + ] + d = VMBus_Dev() + d.sysfs_path = '%s/%s' % (vmbus_sys_path, f) + d.vmbus_id = vmbus_id + d.class_id = class_id + d.device_id = device_id + d.dev_desc = dev_desc + d.chn_vp_mapping = '\n'.join(chn_vp_mapping) + if d.chn_vp_mapping: + d.chn_vp_mapping += '\n' + + vmbus_dev_list.append(d) + + +vmbus_dev_list = sorted(vmbus_dev_list, key=lambda d: int(d.vmbus_id)) + +format0 = '%2s: %s' +format1 = '%2s: Class_ID = %s - %s\n%s' +format2 = '%2s: Class_ID = %s - %s\n\tDevice_ID = %s\n\tSysfs path: %s\n%s' + +for d in vmbus_dev_list: + if verbose == 0: + print(('VMBUS ID ' + format0) % (d.vmbus_id, d.dev_desc)) + elif verbose == 1: + print( + ('VMBUS ID ' + format1) % + (d.vmbus_id, d.class_id, d.dev_desc, d.chn_vp_mapping) + ) + else: + print( + ('VMBUS ID ' + format2) % + ( + d.vmbus_id, d.class_id, d.dev_desc, + d.device_id, d.sysfs_path, d.chn_vp_mapping + ) + ) diff --git a/SPECS/hyperv-daemons.spec b/SPECS/hyperv-daemons.spec new file mode 100644 index 0000000..279b477 --- /dev/null +++ b/SPECS/hyperv-daemons.spec @@ -0,0 +1,398 @@ +# Hyper-V KVP daemon binary name +%global hv_kvp_daemon hypervkvpd +# Hyper-V VSS daemon binary name +%global hv_vss_daemon hypervvssd +# Hyper-V FCOPY daemon binary name +%global hv_fcopy_daemon hypervfcopyd +# snapshot version +%global snapver .20190303git +# use hardened build +%global _hardened_build 1 +# udev rules prefix +%global udev_prefix 70 + +Name: hyperv-daemons +Version: 0 +Release: 0.37%{?snapver}%{?dist} +Summary: Hyper-V daemons suite + +License: GPLv2 +URL: http://www.kernel.org + +# Source files obtained from kernel upstream 4.17-rc1 (60cc43fc888428bb2f18f08997432d426a243338) +# git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git +Source0: COPYING + +# HYPERV KVP DAEMON +Source1: hv_kvp_daemon.c +Source2: hv_get_dhcp_info.sh +Source3: hv_get_dns_info.sh +Source4: hv_set_ifconfig.sh +Source5: hypervkvpd.service +Source6: hypervkvp.rules + +# HYPERV VSS DAEMON +Source100: hv_vss_daemon.c +Source101: hypervvssd.service +Source102: hypervvss.rules + +# HYPERV FCOPY DAEMON +Source200: hv_fcopy_daemon.c +Source201: hypervfcopyd.service +Source202: hypervfcopy.rules + +# HYPERV TOOLS +Source301: lsvmbus + +Patch0002: 0002-Do-not-set-NM_CONTROLLED-no.patch +Patch0004: 0004-Update-C-files-and-scripts-to-kernel-version-5.7-rc1.patch +Patch0005: 0005-Add-vmbus_testing-tool-build-files.patch +Patch0006: 0006-tools-hv-change-http-to-https-in-hv_kvp_daemon.c.patch +# Hyper-V is available only on x86 architectures +# The base empty (a.k.a. virtual) package can not be noarch +# due to http://www.rpm.org/ticket/78 +ExclusiveArch: i686 x86_64 + +Requires: hypervkvpd = %{version}-%{release} +Requires: hypervvssd = %{version}-%{release} +Requires: hypervfcopyd = %{version}-%{release} +BuildRequires: gcc + + +%description +Suite of daemons that are needed when Linux guest +is running on Windows Host with Hyper-V. + + +%package -n hypervkvpd +Summary: Hyper-V key value pair (KVP) daemon +Requires: %{name}-license = %{version}-%{release} +BuildRequires: systemd, kernel-headers +Requires(post): systemd +Requires(preun): systemd +Requires(postun): systemd + +%description -n hypervkvpd +Hypervkvpd is an implementation of Hyper-V key value pair (KVP) +functionality for Linux. The daemon first registers with the +kernel driver. After this is done it collects information +requested by Windows Host about the Linux Guest. It also supports +IP injection functionality on the Guest. + + +%package -n hypervvssd +Summary: Hyper-V VSS daemon +Requires: %{name}-license = %{version}-%{release} +BuildRequires: systemd, kernel-headers +Requires(post): systemd +Requires(preun): systemd +Requires(postun): systemd + +%description -n hypervvssd +Hypervvssd is an implementation of Hyper-V VSS functionality +for Linux. The daemon is used for host initiated guest snapshot +on Hyper-V hypervisor. The daemon first registers with the +kernel driver. After this is done it waits for instructions +from Windows Host if to "freeze" or "thaw" the filesystem +on the Linux Guest. + + +%package -n hypervfcopyd +Summary: Hyper-V FCOPY daemon +Requires: %{name}-license = %{version}-%{release} +BuildRequires: systemd, kernel-headers +Requires(post): systemd +Requires(preun): systemd +Requires(postun): systemd + +%description -n hypervfcopyd +Hypervfcopyd is an implementation of file copy service functionality +for Linux Guest running on Hyper-V. The daemon enables host to copy +a file (over VMBUS) into the Linux Guest. The daemon first registers +with the kernel driver. After this is done it waits for instructions +from Windows Host. + + +%package license +Summary: License of the Hyper-V daemons suite +BuildArch: noarch + +%description license +Contains license of the Hyper-V daemons suite. + +%package -n hyperv-tools +Summary: Tools for Hyper-V guests +BuildArch: noarch + +%description -n hyperv-tools +Contains tools and scripts useful for Hyper-V guests. + +%prep +%setup -Tc +cp -pvL %{SOURCE0} COPYING + +cp -pvL %{SOURCE1} hv_kvp_daemon.c +cp -pvL %{SOURCE2} hv_get_dhcp_info.sh +cp -pvL %{SOURCE3} hv_get_dns_info.sh +cp -pvL %{SOURCE4} hv_set_ifconfig.sh +cp -pvL %{SOURCE5} hypervkvpd.service +cp -pvL %{SOURCE6} hypervkvp.rules +cp -pvL %{SOURCE100} hv_vss_daemon.c +cp -pvL %{SOURCE101} hypervvssd.service +cp -pvL %{SOURCE102} hypervvss.rules +cp -pvL %{SOURCE200} hv_fcopy_daemon.c +cp -pvL %{SOURCE201} hypervfcopyd.service +cp -pvL %{SOURCE202} hypervfcopy.rules + +cp -pvL %{SOURCE301} lsvmbus + +%patch0002 -p1 +%patch0004 -p1 +%patch0005 -p1 +%patch0006 -p1 + +%build +# HYPERV KVP DAEMON +%{__cc} $RPM_OPT_FLAGS -c hv_kvp_daemon.c +%{__cc} $RPM_LD_FLAGS hv_kvp_daemon.o -o %{hv_kvp_daemon} + +# HYPERV VSS DAEMON +%{__cc} $RPM_OPT_FLAGS -c hv_vss_daemon.c +%{__cc} $RPM_LD_FLAGS hv_vss_daemon.o -o %{hv_vss_daemon} + +# HYPERV FCOPY DAEMON +%{__cc} $RPM_OPT_FLAGS -c hv_fcopy_daemon.c +%{__cc} $RPM_LD_FLAGS hv_fcopy_daemon.o -o %{hv_fcopy_daemon} + +%install +rm -rf %{buildroot} + +mkdir -p %{buildroot}%{_sbindir} +install -p -m 0755 %{hv_kvp_daemon} %{buildroot}%{_sbindir} +install -p -m 0755 %{hv_vss_daemon} %{buildroot}%{_sbindir} +install -p -m 0755 %{hv_fcopy_daemon} %{buildroot}%{_sbindir} +# Systemd unit file +mkdir -p %{buildroot}%{_unitdir} +install -p -m 0644 hypervkvpd.service %{buildroot}%{_unitdir} +install -p -m 0644 hypervvssd.service %{buildroot}%{_unitdir} +install -p -m 0644 hypervfcopyd.service %{buildroot}%{_unitdir} +# Udev rules +mkdir -p %{buildroot}%{_udevrulesdir} +install -p -m 0644 hypervkvp.rules %{buildroot}%{_udevrulesdir}/%{udev_prefix}-hypervkvp.rules +install -p -m 0644 hypervvss.rules %{buildroot}%{_udevrulesdir}/%{udev_prefix}-hypervvss.rules +install -p -m 0644 hypervfcopy.rules %{buildroot}%{_udevrulesdir}/%{udev_prefix}-hypervfcopy.rules +# Shell scripts for the KVP daemon +mkdir -p %{buildroot}%{_libexecdir}/%{hv_kvp_daemon} +install -p -m 0755 hv_get_dhcp_info.sh %{buildroot}%{_libexecdir}/%{hv_kvp_daemon}/hv_get_dhcp_info +install -p -m 0755 hv_get_dns_info.sh %{buildroot}%{_libexecdir}/%{hv_kvp_daemon}/hv_get_dns_info +install -p -m 0755 hv_set_ifconfig.sh %{buildroot}%{_libexecdir}/%{hv_kvp_daemon}/hv_set_ifconfig +# Directory for pool files +mkdir -p %{buildroot}%{_sharedstatedir}/hyperv + +# Tools +install -p -m 0755 lsvmbus %{buildroot}%{_sbindir}/ +sed -i 's,#!/usr/bin/env python,#!%{__python3},' %{buildroot}%{_sbindir}/lsvmbus +install -p -m 0755 vmbus_testing %{buildroot}%{_sbindir}/ + +%post -n hypervkvpd +if [ $1 -gt 1 ] ; then + # Upgrade + systemctl --no-reload disable hypervkvpd.service >/dev/null 2>&1 || : +fi + +%preun -n hypervkvpd +%systemd_preun hypervkvpd.service + +%postun -n hypervkvpd +# hypervkvpd daemon does NOT support restarting (driver, neither) +%systemd_postun hypervkvpd.service +# If removing the package, delete %%{_sharedstatedir}/hyperv directory +if [ "$1" -eq "0" ] ; then + rm -rf %{_sharedstatedir}/hyperv || : +fi + + +%post -n hypervvssd +if [ $1 -gt 1 ] ; then + # Upgrade + systemctl --no-reload disable hypervvssd.service >/dev/null 2>&1 || : +fi + +%postun -n hypervvssd +%systemd_postun hypervvssd.service + +%preun -n hypervvssd +%systemd_preun hypervvssd.service + + +%post -n hypervfcopyd +if [ $1 -gt 1 ] ; then + # Upgrade + systemctl --no-reload disable hypervfcopyd.service >/dev/null 2>&1 || : +fi + +%postun -n hypervfcopyd +%systemd_postun hypervfcopyd.service + +%preun -n hypervfcopyd +%systemd_preun hypervfcopyd.service + + +%files +# the base package does not contain any files. + +%files -n hypervkvpd +%{_sbindir}/%{hv_kvp_daemon} +%{_unitdir}/hypervkvpd.service +%{_udevrulesdir}/%{udev_prefix}-hypervkvp.rules +%dir %{_libexecdir}/%{hv_kvp_daemon} +%{_libexecdir}/%{hv_kvp_daemon}/* +%dir %{_sharedstatedir}/hyperv + +%files -n hypervvssd +%{_sbindir}/%{hv_vss_daemon} +%{_unitdir}/hypervvssd.service +%{_udevrulesdir}/%{udev_prefix}-hypervvss.rules + +%files -n hypervfcopyd +%{_sbindir}/%{hv_fcopy_daemon} +%{_unitdir}/hypervfcopyd.service +%{_udevrulesdir}/%{udev_prefix}-hypervfcopy.rules + +%files license +%doc COPYING + +%files -n hyperv-tools +%{_sbindir}/lsvmbus +%{_sbindir}/vmbus_testing + +%changelog +* Mon Aug 09 2021 Mohan Boddu - 0-0.37.20190303git +- Rebuilt for IMA sigs, glibc 2.34, aarch64 flags + Related: rhbz#1991688 + +* Mon May 10 2021 Miroslav Rezanina - 0-0.36.20190303git +- Synchronize RHEL 8 changes [rhbz#1957651] +- Resolves: rhbz#1957651 + ([Hyper-V][RHEL-9] Update build to rhel format and syncup RHEL 8 content for hyperv-daemons.) + +* Fri Apr 16 2021 Mohan Boddu - 0-0.35.20190303git +- Rebuilt for RHEL 9 BETA on Apr 15th 2021. Related: rhbz#1947937 + +* Tue Jan 26 2021 Fedora Release Engineering - 0-0.34.20190303git +- Rebuilt for https://fedoraproject.org/wiki/Fedora_34_Mass_Rebuild + +* Tue Jul 28 2020 Fedora Release Engineering - 0-0.33.20190303git +- Rebuilt for https://fedoraproject.org/wiki/Fedora_33_Mass_Rebuild + +* Wed Jan 29 2020 Fedora Release Engineering - 0-0.32.20190303git +- Rebuilt for https://fedoraproject.org/wiki/Fedora_32_Mass_Rebuild + +* Wed Jan 15 2020 Tom Stellard - 0-0.31.20190303git +- Use __cc macro instead of hard-coding gcc + +* Fri Nov 08 2019 Vitaly Kuznetsov - 0-0.30.20190303git +- Rebase to 5.4-rc6 +- Add IgnoreOnIsolate to systemd units + +* Thu Jul 25 2019 Fedora Release Engineering - 0-0.29.20190303git +- Rebuilt for https://fedoraproject.org/wiki/Fedora_31_Mass_Rebuild + +* Fri Mar 15 2019 Vitaly Kuznetsov - 0-0.28.20190303git +- Rebase to 5.0 + +* Fri Feb 01 2019 Fedora Release Engineering - 0-0.27.20180415git +- Rebuilt for https://fedoraproject.org/wiki/Fedora_30_Mass_Rebuild + +* Fri Jul 13 2018 Fedora Release Engineering - 0-0.26.20180415git +- Rebuilt for https://fedoraproject.org/wiki/Fedora_29_Mass_Rebuild + +* Mon Jun 11 2018 Vitaly Kuznetsov - 0-0.25.20180415git +- Switch lsvmbus to Python3 + +* Thu Apr 26 2018 Tomas Hozza - 0-0.24.20180415git +- Added gcc as an explicit BuildRequires + +* Thu Apr 19 2018 Vitaly Kuznetsov - 0-0.23.20180415git +- Rebase to 4.17-rc1 + +* Wed Feb 07 2018 Fedora Release Engineering - 0-0.22.20170105git +- Rebuilt for https://fedoraproject.org/wiki/Fedora_28_Mass_Rebuild + +* Mon Dec 11 2017 Vitaly Kuznetsov - 0-0.21.20170105git +- Rebase to 4.15-rc2, drop fedora patches as changes are upstream +- Start kvpd after network.target + +* Wed Aug 02 2017 Fedora Release Engineering - 0-0.20.20170105git +- Rebuilt for https://fedoraproject.org/wiki/Fedora_27_Binutils_Mass_Rebuild + +* Wed Jul 26 2017 Fedora Release Engineering - 0-0.19.20170105git +- Rebuilt for https://fedoraproject.org/wiki/Fedora_27_Mass_Rebuild + +* Fri Feb 10 2017 Fedora Release Engineering - 0-0.18.20170105git +- Rebuilt for https://fedoraproject.org/wiki/Fedora_26_Mass_Rebuild + +* Wed Jan 11 2017 Vitaly Kuznetsov - 0-0.17.20160728git +- Use '-gt' instead of '>' to do the right comparison (#1412033) + +* Thu Jan 05 2017 Vitaly Kuznetsov - 0-0.16.20160728git +- Rebase to 4.9 +- hyperv-tools subpackage added + +* Thu Jul 28 2016 Vitaly Kuznetsov - 0-0.15.20160728git +- Rebase to 4.8-rc0 (20160728 git snapshot) +- Disable services and remove ConditionVirtualization, multi-user.target + dependencies switching to udev-only activation (#1331577) + +* Thu Feb 04 2016 Fedora Release Engineering - 0-0.14.20150702git +- Rebuilt for https://fedoraproject.org/wiki/Fedora_24_Mass_Rebuild + +* Wed Nov 18 2015 Vitaly Kuznetsov - 0-0.13.20150702git +- Add udev rules to properly restart services (#1195029) +- Spec cleanup + +* Thu Jul 02 2015 Vitaly Kuznetsov - 0-0.12.20150702git +- Rebase to 4.2-rc0 (20150702 git snapshot) +- Switch to new chardev-based communication layer (#1195029) + +* Wed Jun 17 2015 Fedora Release Engineering - 0-0.11.20150108git +- Rebuilt for https://fedoraproject.org/wiki/Fedora_23_Mass_Rebuild + +* Thu Jan 08 2015 Vitaly Kuznetsov - 0-0.10.20150108git +- Rebase to 3.19-rc3 (20150108 git snapshot) +- Drop 'nodaemon' patches, use newly introduced '-n' option + +* Sat Aug 16 2014 Fedora Release Engineering - 0-0.9.20140714git +- Rebuilt for https://fedoraproject.org/wiki/Fedora_21_22_Mass_Rebuild + +* Mon Jul 14 2014 Tomas Hozza - 0-0.8.20140714git +- Update the File copy daemon to the latest git snapshot +- Fix hyperfcopyd.service to check for /dev/vmbus/hv_fcopy + +* Wed Jun 11 2014 Tomas Hozza - 0-0.7.20140611git +- Fix FTBFS (#1106781) +- Use kernel-headers instead of kernel-devel for building +- package new Hyper-V fcopy daemon as hypervfcopyd sub-package + +* Sat Jun 07 2014 Fedora Release Engineering - 0-0.6.20140219git +- Rebuilt for https://fedoraproject.org/wiki/Fedora_21_Mass_Rebuild + +* Wed Feb 19 2014 Tomas Hozza - 0-0.5.20140219git +- rebase to the latest git snapshot next-20140219 + - KVP, VSS: removed inclusion of linux/types.h + - VSS: Ignore VFAT mounts during freeze operation + +* Fri Jan 10 2014 Tomas Hozza - 0-0.4.20131022git +- provide 'hyperv-daemons' package for convenient installation of all daemons + +* Tue Oct 22 2013 Tomas Hozza - 0-0.3.20131022git +- rebase to the latest git snapshot next-20130927 (obtained 2013-10-22) + - KVP, VSS: daemon use single buffer for send/recv + - KVP: FQDN is obtained on start and cached + +* Fri Sep 20 2013 Tomas Hozza - 0-0.2.20130826git +- Use 'hypervkvpd' directory in libexec for KVP daemon scripts (#1010268) +- daemons are now WantedBy multi-user.target instead of basic.target (#1010260) + +* Mon Aug 26 2013 Tomas Hozza - 0-0.1.20130826git +- Initial package