From 6d57f8254b094ac7bc1c75ea5a0ec9fb64cc5035 Mon Sep 17 00:00:00 2001 From: Chenli Wei Date: Wed, 2 Nov 2022 19:47:08 +0800 Subject: [PATCH] misc: rename common.py to avoid private library conflict The offline tool use a utility libary and use "common" to named it, this name conflict with some customer's local library, so we rename it to a better and clear name. Tracked-On: #6690 Signed-off-by: Chenli Wei --- misc/config_tools/acpi_gen/acpi_const.py | 4 +- misc/config_tools/acpi_gen/asl_gen.py | 37 +++--- misc/config_tools/acpi_gen/bin_gen.py | 31 ++--- .../board_config/acpi_platform_h.py | 8 +- misc/config_tools/board_config/board_c.py | 63 +++++----- .../board_config/board_cfg_gen.py | 32 ++--- .../config_tools/board_config/board_info_h.py | 20 ++-- .../board_config/pci_devices_h.py | 1 - misc/config_tools/board_config/vbar_base_h.py | 82 ++++++------- .../config_tools/hv_config/board_defconfig.py | 12 +- misc/config_tools/hv_config/hv_item.py | 56 ++++----- .../{common.py => acrn_config_utilities.py} | 2 +- misc/config_tools/library/board_cfg_lib.py | 66 +++++------ misc/config_tools/library/hv_cfg_lib.py | 20 ++-- misc/config_tools/library/launch_cfg_lib.py | 46 ++++---- misc/config_tools/library/rdt.py | 21 ++-- misc/config_tools/library/scenario_cfg_lib.py | 82 ++++++------- .../scenario_config/scenario_cfg_gen.py | 52 ++++----- .../scenario_config/scenario_item.py | 60 +++++----- .../service_vm_config/serial_config.py | 15 +-- misc/config_tools/static_allocators/bdf.py | 35 +++--- .../static_allocators/board_capability.py | 13 ++- misc/config_tools/static_allocators/clos.py | 37 +++--- .../static_allocators/cpu_affinity.py | 23 ++-- .../static_allocators/cpu_freq.py | 69 +++++------ misc/config_tools/static_allocators/gpa.py | 109 +++++++++--------- .../static_allocators/guest_flags.py | 11 +- misc/config_tools/static_allocators/hv_ram.py | 15 +-- misc/config_tools/static_allocators/intx.py | 59 +++++----- .../config_tools/static_allocators/lib/lib.py | 19 +-- misc/config_tools/static_allocators/main.py | 10 +- .../static_allocators/memory_allocator.py | 37 +++--- misc/config_tools/static_allocators/pio.py | 2 +- .../static_allocators/s5_vuart.py | 37 +++--- 34 files changed, 601 insertions(+), 585 deletions(-) rename misc/config_tools/library/{common.py => acrn_config_utilities.py} (99%) diff --git a/misc/config_tools/acpi_gen/acpi_const.py b/misc/config_tools/acpi_gen/acpi_const.py index f7e7171a6..f118cf05b 100644 --- a/misc/config_tools/acpi_gen/acpi_const.py +++ b/misc/config_tools/acpi_gen/acpi_const.py @@ -8,9 +8,9 @@ import os, sys sys.path.append(os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', 'library')) -import common +import acrn_config_utilities -VM_CONFIGS_PATH = os.path.join(common.SOURCE_ROOT_DIR, 'misc', 'config_tools') +VM_CONFIGS_PATH = os.path.join(acrn_config_utilities.SOURCE_ROOT_DIR, 'misc', 'config_tools') TEMPLATE_ACPI_PATH = os.path.join(VM_CONFIGS_PATH, 'acpi_template', 'template') ACPI_TABLE_LIST = [('rsdp.asl', 'rsdp.aml'), ('xsdt.asl', 'xsdt.aml'), ('facp.asl', 'facp.aml'), diff --git a/misc/config_tools/acpi_gen/asl_gen.py b/misc/config_tools/acpi_gen/asl_gen.py index 4693f0680..a61c896ef 100644 --- a/misc/config_tools/acpi_gen/asl_gen.py +++ b/misc/config_tools/acpi_gen/asl_gen.py @@ -7,9 +7,10 @@ import sys, os, re, argparse, shutil, ctypes from acpi_const import * -import board_cfg_lib, common +import board_cfg_lib, acrn_config_utilities import collections import lxml.etree +from acrn_config_utilities import get_node sys.path.append(os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', 'board_inspector')) from acpiparser._utils import TableHeader @@ -575,7 +576,7 @@ def collect_dependent_devices(board_etree, device_node): result.add(device) for node in device.findall("dependency"): if node.get("type") in types_in_scope: - peer_device = common.get_node(f"//device[acpi_object='{node.text}']", board_etree) + peer_device = get_node(f"//device[acpi_object='{node.text}']", board_etree) if peer_device is not None: queue.append(peer_device) @@ -669,8 +670,8 @@ def gen_dsdt(board_etree, scenario_etree, allocation_etree, vm_id, dest_path): bus_number = int(m.group(1), 16) bdf = f"{bus_number:02x}:{device_number:02x}.{function_number}" address = hex((device_number << 16) | (function_number)) - device_node = common.get_node(f"//bus[@address='{hex(bus_number)}']/device[@address='{address}']", board_etree) - alloc_node = common.get_node(f"/acrn-config/vm[@id='{vm_id}']/device[@name='PTDEV_{bdf}']", allocation_etree) + device_node = get_node(f"//bus[@address='{hex(bus_number)}']/device[@address='{address}']", board_etree) + alloc_node = get_node(f"/acrn-config/vm[@id='{vm_id}']/device[@name='PTDEV_{bdf}']", allocation_etree) if device_node is not None and alloc_node is not None: assert int(alloc_node.find("bus").text, 16) == 0, "Virtual PCI devices must be on bus 0." vdev = int(alloc_node.find("dev").text, 16) @@ -686,8 +687,8 @@ def gen_dsdt(board_etree, scenario_etree, allocation_etree, vm_id, dest_path): objects.add_device_object(tree) # The _PRT remapping package, if necessary - intr_pin_node = common.get_node("resource[@type='interrupt_pin']", device_node) - virq_node = common.get_node("pt_intx", alloc_node) + intr_pin_node = get_node("resource[@type='interrupt_pin']", device_node) + virq_node = get_node("pt_intx", alloc_node) if intr_pin_node is not None and virq_node is not None: pin_id = interrupt_pin_ids[intr_pin_node.get("pin")] vaddr = (vdev << 16) | 0xffff @@ -724,12 +725,12 @@ def gen_dsdt(board_etree, scenario_etree, allocation_etree, vm_id, dest_path): # as the guest physical address of the passed through TPM2. Thus, it works for now to reuse the host TPM2 device # object without updating the addresses of operation regions or resource descriptors. It is, however, necessary to # introduce a pass to translate such address to arbitrary guest physical ones in the future. - has_tpm2 = common.get_node(f"//vm[@id='{vm_id}']//TPM2/text()", scenario_etree) + has_tpm2 = get_node(f"//vm[@id='{vm_id}']//TPM2/text()", scenario_etree) if has_tpm2 == "y": # TPM2 devices should have "MSFT0101" as hardware id or compatible ID - template = common.get_node("//device[@id='MSFT0101']/aml_template", board_etree) + template = get_node("//device[@id='MSFT0101']/aml_template", board_etree) if template is None: - template = common.get_node("//device[compatible_id='MSFT0101']/aml_template", board_etree) + template = get_node("//device[compatible_id='MSFT0101']/aml_template", board_etree) if template is not None: tree = parse_tree("DefDevice", bytes.fromhex(template.text)) objects.add_device_object(tree) @@ -768,9 +769,9 @@ def gen_dsdt(board_etree, scenario_etree, allocation_etree, vm_id, dest_path): def gen_rtct(board_etree, scenario_etree, allocation_etree, vm_id, dest_path): def cpu_id_to_lapic_id(cpu_id): - return common.get_node(f"//thread[cpu_id = '{cpu_id}']/apic_id/text()", board_etree) + return get_node(f"//thread[cpu_id = '{cpu_id}']/apic_id/text()", board_etree) - vm_node = common.get_node(f"//vm[@id='{vm_id}']", scenario_etree) + vm_node = get_node(f"//vm[@id='{vm_id}']", scenario_etree) if vm_node is None: return False @@ -810,7 +811,7 @@ def gen_rtct(board_etree, scenario_etree, allocation_etree, vm_id, dest_path): # Look for the cache blocks that are visible to this VM and have software SRAM in it. Those software SRAM will be # exposed to the VM in RTCT. for cache in board_etree.xpath(f"//caches/cache[count(processors/processor[contains('{vcpus}', .)]) and capability[@id = 'Software SRAM']]"): - ssram_cap = common.get_node("capability[@id = 'Software SRAM']", cache) + ssram_cap = get_node("capability[@id = 'Software SRAM']", cache) ssram_entry = create_object( rtct.RTCTSubtableSoftwareSRAM_v2, @@ -851,7 +852,7 @@ def main(args): err_dic = {} - (err_dic, params) = common.get_param(args) + (err_dic, params) = acrn_config_utilities.get_param(args) if err_dic: return err_dic @@ -872,7 +873,7 @@ def main(args): if out is None or out == '': DEST_ACPI_PATH = os.path.join(VM_CONFIGS_PATH, 'scenarios', scenario_name) else: - DEST_ACPI_PATH = os.path.join(common.SOURCE_ROOT_DIR, out, 'scenarios', scenario_name) + DEST_ACPI_PATH = os.path.join(acrn_config_utilities.SOURCE_ROOT_DIR, out, 'scenarios', scenario_name) if os.path.isdir(DEST_ACPI_PATH): for config in os.listdir(DEST_ACPI_PATH): @@ -914,10 +915,10 @@ def main(args): except: PASSTHROUGH_RTCT = False - kern_args = common.get_leaf_tag_map(scenario, "os_config", "bootargs") - kern_type = common.get_leaf_tag_map(scenario, "os_config", "kern_type") + kern_args = acrn_config_utilities.get_leaf_tag_map(scenario, "os_config", "bootargs") + kern_type = acrn_config_utilities.get_leaf_tag_map(scenario, "os_config", "kern_type") for vm_id, passthru_devices in dict_passthru_devices.items(): - bootargs_node= common.get_node(f"//vm[@id='{vm_id}']/os_config/bootargs", scenario_etree) + bootargs_node= get_node(f"//vm[@id='{vm_id}']/os_config/bootargs", scenario_etree) if bootargs_node is not None and kern_args[int(vm_id)].find('reboot=acpi') == -1 and kern_type[int(vm_id)] in ['KERNEL_BZIMAGE']: emsg = "you need to specify 'reboot=acpi' in scenario file's bootargs for VM{}".format(vm_id) print(emsg) @@ -940,7 +941,7 @@ def main(args): apic_ids = [] for id in dict_pcpu_list[vm_id]: - apic_id = common.get_node(f"//processors//thread[cpu_id='{id}']/apic_id/text()", board_etree) + apic_id = get_node(f"//processors//thread[cpu_id='{id}']/apic_id/text()", board_etree) if apic_id is None: emsg = 'some or all of the processors//thread/cpu_id tags are missing in board xml file for cpu {}, please run board_inspector.py to regenerate the board xml file!'.format(id) print(emsg) diff --git a/misc/config_tools/acpi_gen/bin_gen.py b/misc/config_tools/acpi_gen/bin_gen.py index 8d8cec462..037b8b19c 100644 --- a/misc/config_tools/acpi_gen/bin_gen.py +++ b/misc/config_tools/acpi_gen/bin_gen.py @@ -14,7 +14,8 @@ from acpi_const import * import acpiparser.tpm2 import inspectorlib.cdata import acpiparser.rtct -import common +import acrn_config_utilities +from acrn_config_utilities import get_node def move_rtct_ssram_and_bin_entries(rtct, new_base_addr, new_area_max_size): ''' @@ -75,11 +76,11 @@ def asl_to_aml(dest_vm_acpi_path, dest_vm_acpi_bin_path, scenario_etree, allocat rtct = acpiparser.rtct.RTCT(os.path.join(dest_vm_acpi_path, acpi_table[0])) outfile = os.path.join(dest_vm_acpi_bin_path, acpi_table[1]) # move the guest ssram area to the area next to ACPI region - pre_rt_vms = common.get_node("//vm[load_order ='PRE_LAUNCHED_VM' and vm_type ='RTVM']", scenario_etree) + pre_rt_vms = get_node("//vm[load_order ='PRE_LAUNCHED_VM' and vm_type ='RTVM']", scenario_etree) vm_id = pre_rt_vms.get("id") - allocation_vm_node = common.get_node(f"/acrn-config/vm[@id = '{vm_id}']", allocation_etree) - ssram_start_gpa = common.get_node("./ssram/start_gpa/text()", allocation_vm_node) - ssram_max_size = common.get_node("./ssram/max_size/text()", allocation_vm_node) + allocation_vm_node = get_node(f"/acrn-config/vm[@id = '{vm_id}']", allocation_etree) + ssram_start_gpa = get_node("./ssram/start_gpa/text()", allocation_vm_node) + ssram_max_size = get_node("./ssram/max_size/text()", allocation_vm_node) move_rtct_ssram_and_bin_entries(rtct, int(ssram_start_gpa, 16), int(ssram_max_size, 16)) fp = open(outfile, mode='wb') fp.write(rtct) @@ -105,11 +106,11 @@ def asl_to_aml(dest_vm_acpi_path, dest_vm_acpi_bin_path, scenario_etree, allocat return rmsg def tpm2_acpi_gen(acpi_bin, board_etree, scenario_etree, allocation_etree): - tpm2_enabled = common.get_node("//vm[@id = '0']/mmio_resources/TPM2/text()", scenario_etree) + tpm2_enabled = get_node("//vm[@id = '0']/mmio_resources/TPM2/text()", scenario_etree) if tpm2_enabled is not None and tpm2_enabled == 'y': - tpm2_node = common.get_node("//device[@id = 'MSFT0101' or compatible_id = 'MSFT0101']", board_etree) + tpm2_node = get_node("//device[@id = 'MSFT0101' or compatible_id = 'MSFT0101']", board_etree) if tpm2_node is not None: - _data_len = 0x4c if common.get_node("//capability[@id = 'log_area']", board_etree) is not None else 0x40 + _data_len = 0x4c if get_node("//capability[@id = 'log_area']", board_etree) is not None else 0x40 _data = bytearray(_data_len) ctype_data = acpiparser.tpm2.TPM2(_data) ctype_data.header.signature = "TPM2".encode() @@ -121,13 +122,13 @@ def tpm2_acpi_gen(acpi_bin, board_etree, scenario_etree, allocation_etree): ctype_data.header.creatorid = "INTL".encode() ctype_data.header.creatorrevision = 0x20190703 ctype_data.address_of_control_area = 0xFED40040 - ctype_data.start_method = int(common.get_node("//capability[@id = 'start_method']/value/text()", tpm2_node), 16) + ctype_data.start_method = int(get_node("//capability[@id = 'start_method']/value/text()", tpm2_node), 16) start_method_parameters = tpm2_node.xpath("//parameter/text()") for i in range(len(start_method_parameters)): ctype_data.start_method_specific_parameters[i] = int(start_method_parameters[i], 16) - if common.get_node("//capability[@id = 'log_area']", board_etree) is not None: - ctype_data.log_area_minimum_length = int(common.get_node("//log_area_minimum_length/text()", allocation_etree), 16) - ctype_data.log_area_start_address = int(common.get_node("//log_area_start_address/text()", allocation_etree), 16) + if get_node("//capability[@id = 'log_area']", board_etree) is not None: + ctype_data.log_area_minimum_length = int(get_node("//log_area_minimum_length/text()", allocation_etree), 16) + ctype_data.log_area_start_address = int(get_node("//log_area_start_address/text()", allocation_etree), 16) ctype_data.header.checksum = (~(sum(inspectorlib.cdata.to_bytes(ctype_data))) + 1) & 0xFF acpi_bin.seek(ACPI_TPM2_ADDR_OFFSET) acpi_bin.write(inspectorlib.cdata.to_bytes(ctype_data)) @@ -253,14 +254,14 @@ def main(args): board_etree = lxml.etree.parse(args.board) scenario_etree = lxml.etree.parse(args.scenario) - scenario_name = common.get_node("//@scenario", scenario_etree) + scenario_name = get_node("//@scenario", scenario_etree) if args.asl is None: DEST_ACPI_PATH = os.path.join(VM_CONFIGS_PATH, 'scenarios', scenario_name) else: - DEST_ACPI_PATH = os.path.join(common.SOURCE_ROOT_DIR, args.asl, 'scenarios', scenario_name) + DEST_ACPI_PATH = os.path.join(acrn_config_utilities.SOURCE_ROOT_DIR, args.asl, 'scenarios', scenario_name) if args.out is None: - hypervisor_out = os.path.join(common.SOURCE_ROOT_DIR, 'build', 'hypervisor') + hypervisor_out = os.path.join(acrn_config_utilities.SOURCE_ROOT_DIR, 'build', 'hypervisor') else: hypervisor_out = args.out DEST_ACPI_BIN_PATH = os.path.join(hypervisor_out, 'acpi') diff --git a/misc/config_tools/board_config/acpi_platform_h.py b/misc/config_tools/board_config/acpi_platform_h.py index ae395c759..25562ecde 100644 --- a/misc/config_tools/board_config/acpi_platform_h.py +++ b/misc/config_tools/board_config/acpi_platform_h.py @@ -4,7 +4,7 @@ # import board_cfg_lib -import common +import acrn_config_utilities PLATFORM_HEADER = r"""/* DO NOT MODIFY THIS FILE UNLESS YOU KNOW WHAT YOU ARE DOING! */ @@ -89,7 +89,7 @@ def multi_info_parser(config, default_platform, msg_s, msg_e): write_direct = ['PM1A_EVT_ACCESS_SIZE', 'PM1A_EVT_ADDRESS', 'PM1A_CNT_ADDRESS'] pm_ac_sz = OverridAccessSize() - multi_lines = board_cfg_lib.get_info(common.BOARD_INFO_FILE, msg_s, msg_e) + multi_lines = board_cfg_lib.get_info(acrn_config_utilities.BOARD_INFO_FILE, msg_s, msg_e) msg_name = msg_s.split('_')[0].strip('<') @@ -138,7 +138,7 @@ def write_direct_info_parser(config, msg_s, msg_e): :param msg_s: it is a pattern of key stings what start to match from board information :param msg_e: it is a pattern of key stings what end to match from board information """ - vector_lines = board_cfg_lib.get_info(common.BOARD_INFO_FILE, msg_s, msg_e) + vector_lines = board_cfg_lib.get_info(acrn_config_utilities.BOARD_INFO_FILE, msg_s, msg_e) msg_name = msg_s.split('_')[0].strip('<') # Set defaults if not present in target xml file @@ -193,7 +193,7 @@ def drhd_info_parser(config): prev_num = 0 drhd_lines = board_cfg_lib.get_info( - common.BOARD_INFO_FILE, "", "") + acrn_config_utilities.BOARD_INFO_FILE, "", "") # write DRHD print("/* DRHD of DMAR */", file=config) diff --git a/misc/config_tools/board_config/board_c.py b/misc/config_tools/board_config/board_c.py index 35c4e5ebc..c0cfe631f 100644 --- a/misc/config_tools/board_config/board_c.py +++ b/misc/config_tools/board_config/board_c.py @@ -6,9 +6,10 @@ import sys import enum import board_cfg_lib -import common +import acrn_config_utilities import lxml.etree import os +from acrn_config_utilities import get_node class RDT(enum.Enum): L2 = 0 @@ -33,7 +34,7 @@ MSR_IA32_L3_MASK_END = 0x00000D0F def gen_dmar_structure(config): """Generate dmar structure information""" - dmar_info_lines = board_cfg_lib.get_info(common.BOARD_INFO_FILE, "", "") + dmar_info_lines = board_cfg_lib.get_info(acrn_config_utilities.BOARD_INFO_FILE, "", "") drhd_cnt = 0 drhd_dev_scope_cnt = [] dev_scope_type = [] @@ -124,7 +125,7 @@ def populate_mba_delay_mask(rdt_res, mba_delay_list, config): idx += 1 def get_rdt_enabled(): - scenario_etree = lxml.etree.parse(common.SCENARIO_INFO_FILE) + scenario_etree = lxml.etree.parse(acrn_config_utilities.SCENARIO_INFO_FILE) enable = scenario_etree.xpath(f"//RDT_ENABLED/text()") if enable[0] == "y": return "true" @@ -132,7 +133,7 @@ def get_rdt_enabled(): return "false" def get_cdp_enabled(): - scenario_etree = lxml.etree.parse(common.SCENARIO_INFO_FILE) + scenario_etree = lxml.etree.parse(acrn_config_utilities.SCENARIO_INFO_FILE) enable = scenario_etree.xpath(f"//CDP_ENABLED/text()") if enable[0] == "y": return "true" @@ -153,13 +154,13 @@ def gen_rdt_str(cache, config): err_dic = {} cat_mask_list = {} - board_etree = lxml.etree.parse(common.BOARD_INFO_FILE) - mask_length = common.get_node(f"./capability[@id='CAT']/capacity_mask_length/text()", cache) - clos_number = common.get_node(f"./capability[@id='CAT']/clos_number/text()", cache) + board_etree = lxml.etree.parse(acrn_config_utilities.BOARD_INFO_FILE) + mask_length = get_node(f"./capability[@id='CAT']/capacity_mask_length/text()", cache) + clos_number = get_node(f"./capability[@id='CAT']/clos_number/text()", cache) bitmask = (1 << int(mask_length)) - 1 - cache_level = common.get_node(f"./@level", cache) - cache_id = common.get_node(f"./@id", cache) + cache_level = get_node(f"./@level", cache) + cache_id = get_node(f"./@id", cache) processor_list = board_etree.xpath(f"//cache[@level = '{cache_level}' and @id = '{cache_id}']/processors/processor/text()") capability_list = board_etree.xpath(f"//cache[@level = '{cache_level}' and @id = '{cache_id}']/capability/@id") @@ -192,7 +193,7 @@ def gen_rdt_str(cache, config): print("\t\t\t.is_cdp_enabled = {0},".format(cdp_enable), file=config) print("\t\t},", file=config) elif capability_id == "MBA": - max_throttling_value = common.get_node(f"./capability/max_throttling_value/text()", cache) + max_throttling_value = get_node(f"./capability/max_throttling_value/text()", cache) rdt_res = "mba" clos_config_array = "platform_mba_clos_array" print("\t{", file=config) @@ -207,7 +208,7 @@ def gen_rdt_str(cache, config): cpu_mask = 0 for processor in processor_list: - core_id = common.get_node(f"//thread[apic_id = '{processor}']/cpu_id/text()", board_etree) + core_id = get_node(f"//thread[apic_id = '{processor}']/cpu_id/text()", board_etree) if core_id is None: continue else: @@ -218,7 +219,7 @@ def gen_rdt_str(cache, config): return err_dic; def get_mask_list(cache_level, cache_id): - allocation_dir = os.path.split(common.SCENARIO_INFO_FILE)[0] + "/configs/allocation.xml" + allocation_dir = os.path.split(acrn_config_utilities.SCENARIO_INFO_FILE)[0] + "/configs/allocation.xml" allocation_etree = lxml.etree.parse(allocation_dir) if cache_level == "3": clos_list = allocation_etree.xpath(f"//clos_mask[@id = 'l3']/clos/text()") @@ -235,9 +236,9 @@ def gen_clos_array(cache_list, config): print("struct rdt_info res_infos[RDT_INFO_NUMBER];", file=config) else: for idx, cache in enumerate(cache_list): - cache_level = common.get_node(f"./@level", cache) - cache_id = common.get_node(f"./@id", cache) - clos_number = common.get_node(f"./capability/clos_number/text()", cache) + cache_level = get_node(f"./@level", cache) + cache_id = get_node(f"./@id", cache) + clos_number = get_node(f"./capability/clos_number/text()", cache) if cache_level == "2": cat_mask_list = get_mask_list(cache_level, cache_id) @@ -264,7 +265,7 @@ def gen_clos_array(cache_list, config): print("};\n", file=config) res_present[RDT.MBA.value] = 1 else: - err_dic['board config: generate board.c failed'] = "The input of {} was corrupted!".format(common.BOARD_INFO_FILE) + err_dic['board config: generate board.c failed'] = "The input of {} was corrupted!".format(acrn_config_utilities.BOARD_INFO_FILE) return err_dic if res_present[RDT.L2.value] == 0: @@ -284,9 +285,9 @@ def gen_rdt_res(config): err_dic = {} res_present = [0, 0, 0] - scenario_etree = lxml.etree.parse(common.SCENARIO_INFO_FILE) - allocation_etree = lxml.etree.parse(common.SCENARIO_INFO_FILE) - board_etree = lxml.etree.parse(common.BOARD_INFO_FILE) + scenario_etree = lxml.etree.parse(acrn_config_utilities.SCENARIO_INFO_FILE) + allocation_etree = lxml.etree.parse(acrn_config_utilities.SCENARIO_INFO_FILE) + board_etree = lxml.etree.parse(acrn_config_utilities.BOARD_INFO_FILE) cache_list = board_etree.xpath(f"//cache[capability/@id = 'CAT' or capability/@id = 'MBA']") gen_clos_array(cache_list, config) @@ -385,9 +386,9 @@ def gen_px_cx(config): :param config: it is a file pointer of board information for writing to """ cpu_brand_lines = board_cfg_lib.get_info( - common.BOARD_INFO_FILE, "", "") - cx_lines = board_cfg_lib.get_info(common.BOARD_INFO_FILE, "", "") - px_lines = board_cfg_lib.get_info(common.BOARD_INFO_FILE, "", "") + acrn_config_utilities.BOARD_INFO_FILE, "", "") + cx_lines = board_cfg_lib.get_info(acrn_config_utilities.BOARD_INFO_FILE, "", "") + px_lines = board_cfg_lib.get_info(acrn_config_utilities.BOARD_INFO_FILE, "", "") gen_single_data(cx_lines, 'c', config) gen_single_data(px_lines, 'p', config) @@ -409,7 +410,7 @@ def gen_px_cx(config): def gen_pci_hide(config): """Generate hide pci information for this platform""" - scenario_etree = lxml.etree.parse(common.SCENARIO_INFO_FILE) + scenario_etree = lxml.etree.parse(acrn_config_utilities.SCENARIO_INFO_FILE) hidden_pdev_list = [x.replace('.', ':') for x in scenario_etree.xpath(f"//HIDDEN_PDEV/text()")] if board_cfg_lib.BOARD_NAME in list(board_cfg_lib.KNOWN_HIDDEN_PDEVS_BOARD_DB.keys()) and board_cfg_lib.KNOWN_HIDDEN_PDEVS_BOARD_DB[board_cfg_lib.BOARD_NAME] != 0: @@ -456,21 +457,21 @@ def gen_known_caps_pci_devs(config): print("};", file=config) def gen_cpufreq_limits(config): - allocation_dir = os.path.split(common.SCENARIO_INFO_FILE)[0] + "/configs/allocation.xml" + allocation_dir = os.path.split(acrn_config_utilities.SCENARIO_INFO_FILE)[0] + "/configs/allocation.xml" allocation_etree = lxml.etree.parse(allocation_dir) cpu_list = board_cfg_lib.get_processor_info() max_cpu_num = len(cpu_list) print("\nstruct acrn_cpufreq_limits cpufreq_limits[MAX_PCPU_NUM] = {", file=config) for cpu_id in range(max_cpu_num): - limit_node = common.get_node(f"//cpufreq/CPU[@id='{cpu_id}']/limits", allocation_etree) + limit_node = get_node(f"//cpufreq/CPU[@id='{cpu_id}']/limits", allocation_etree) if limit_node != None: - limit_guaranteed_lvl = common.get_node("./limit_guaranteed_lvl/text()", limit_node) - limit_highest_lvl = common.get_node("./limit_highest_lvl/text()", limit_node) - limit_lowest_lvl = common.get_node("./limit_lowest_lvl/text()", limit_node) - limit_nominal_pstate = common.get_node("./limit_nominal_pstate/text()", limit_node) - limit_highest_pstate = common.get_node("./limit_highest_pstate/text()", limit_node) - limit_lowest_pstate = common.get_node("./limit_lowest_pstate/text()", limit_node) + limit_guaranteed_lvl = get_node("./limit_guaranteed_lvl/text()", limit_node) + limit_highest_lvl = get_node("./limit_highest_lvl/text()", limit_node) + limit_lowest_lvl = get_node("./limit_lowest_lvl/text()", limit_node) + limit_nominal_pstate = get_node("./limit_nominal_pstate/text()", limit_node) + limit_highest_pstate = get_node("./limit_highest_pstate/text()", limit_node) + limit_lowest_pstate = get_node("./limit_lowest_pstate/text()", limit_node) print("\t{", file=config) print(f"\t\t.guaranteed_hwp_lvl = {limit_guaranteed_lvl},", file=config) diff --git a/misc/config_tools/board_config/board_cfg_gen.py b/misc/config_tools/board_config/board_cfg_gen.py index 5d9c7e6a3..e0aea8410 100755 --- a/misc/config_tools/board_config/board_cfg_gen.py +++ b/misc/config_tools/board_config/board_cfg_gen.py @@ -12,9 +12,9 @@ import board_c import board_info_h import pci_devices_h import acpi_platform_h -import common +import acrn_config_utilities -ACRN_PATH = common.SOURCE_ROOT_DIR +ACRN_PATH = acrn_config_utilities.SOURCE_ROOT_DIR ACRN_CONFIG_DEF = ACRN_PATH + "misc/config_tools/data/" ACRN_DEFAULT_ACPI = ACRN_PATH + "hypervisor/include/arch/x86/asm/default_acpi_info.h" @@ -29,32 +29,32 @@ def main(args): """ err_dic = {} - (err_dic, params) = common.get_param(args) + (err_dic, params) = acrn_config_utilities.get_param(args) if err_dic: return err_dic # check env - err_dic = common.prepare() + err_dic = acrn_config_utilities.prepare() if err_dic: return err_dic - common.BOARD_INFO_FILE = params['--board'] - common.SCENARIO_INFO_FILE = params['--scenario'] - common.get_vm_num(params['--scenario']) - common.get_load_order() + acrn_config_utilities.BOARD_INFO_FILE = params['--board'] + acrn_config_utilities.SCENARIO_INFO_FILE = params['--scenario'] + acrn_config_utilities.get_vm_num(params['--scenario']) + acrn_config_utilities.get_load_order() - if common.VM_COUNT > common.MAX_VM_NUM: + if acrn_config_utilities.VM_COUNT > acrn_config_utilities.MAX_VM_NUM: err_dic['vm count'] = "The number of VMs in the scenario XML file should be no greater than " \ - "hv.CAPACITIES.MAX_VM_NUM. Its current value is {}.".format(common.MAX_VM_NUM) + "hv.CAPACITIES.MAX_VM_NUM. Its current value is {}.".format(acrn_config_utilities.MAX_VM_NUM) return err_dic # check if this is the scenario config which matched board info # get board name - (err_dic, board) = common.get_board_name() + (err_dic, board) = acrn_config_utilities.get_board_name() if err_dic: return err_dic - (err_dic, scenario) = common.get_scenario_name() + (err_dic, scenario) = acrn_config_utilities.get_scenario_name() if err_dic: return err_dic board_cfg_lib.BOARD_NAME = board @@ -70,8 +70,8 @@ def main(args): board_fix_dir = os.path.join(output, "boards/") scen_board_dir = os.path.join(output, "scenarios/" + scenario + "/") - common.mkdir(board_fix_dir) - common.mkdir(scen_board_dir) + acrn_config_utilities.mkdir(board_fix_dir) + acrn_config_utilities.mkdir(scen_board_dir) config_pci = board_fix_dir + GEN_FILE[0] config_board = board_fix_dir + GEN_FILE[1] @@ -110,7 +110,7 @@ def ui_entry_api(board_info, scenario_info, out=''): arg_list = ['board_cfg_gen.py', '--board', board_info, '--scenario', scenario_info, '--out', out] - err_dic = common.prepare() + err_dic = acrn_config_utilities.prepare() if err_dic: return err_dic @@ -125,5 +125,5 @@ if __name__ == '__main__': err_dic = main(ARGS) if err_dic: for err_k, err_v in err_dic.items(): - common.print_red("{}: {}".format(err_k, err_v), err=True) + acrn_config_utilities.print_red("{}: {}".format(err_k, err_v), err=True) sys.exit(1 if err_dic else 0) diff --git a/misc/config_tools/board_config/board_info_h.py b/misc/config_tools/board_config/board_info_h.py index fc95ea6dc..a11f1eb63 100644 --- a/misc/config_tools/board_config/board_info_h.py +++ b/misc/config_tools/board_config/board_info_h.py @@ -3,7 +3,7 @@ # SPDX-License-Identifier: BSD-3-Clause # -import common +import acrn_config_utilities import board_cfg_lib import scenario_cfg_lib @@ -31,7 +31,7 @@ def find_hi_mmio_window(config): mmio_max = 0 is_hi_mmio = False - iomem_lines = board_cfg_lib.get_info(common.BOARD_INFO_FILE, "", "") + iomem_lines = board_cfg_lib.get_info(acrn_config_utilities.BOARD_INFO_FILE, "", "") for line in iomem_lines: if "PCI Bus" not in line: @@ -39,12 +39,12 @@ def find_hi_mmio_window(config): line_start_addr = int(line.split('-')[0], 16) line_end_addr = int(line.split('-')[1].split()[0], 16) - if line_start_addr < common.SIZE_4G and line_end_addr < common.SIZE_4G: + if line_start_addr < acrn_config_utilities.SIZE_4G and line_end_addr < acrn_config_utilities.SIZE_4G: continue - elif line_start_addr < common.SIZE_4G and line_end_addr >= common.SIZE_4G: + elif line_start_addr < acrn_config_utilities.SIZE_4G and line_end_addr >= acrn_config_utilities.SIZE_4G: i_cnt += 1 is_hi_mmio = True - mmio_min = common.SIZE_4G + mmio_min = acrn_config_utilities.SIZE_4G mmio_max = line_end_addr continue @@ -59,8 +59,8 @@ def find_hi_mmio_window(config): print("", file=config) if is_hi_mmio: - print("#define HI_MMIO_START\t\t\t0x%xUL" % common.round_down(mmio_min, common.SIZE_G), file=config) - print("#define HI_MMIO_END\t\t\t0x%xUL" % common.round_up(mmio_max, common.SIZE_G), file=config) + print("#define HI_MMIO_START\t\t\t0x%xUL" % acrn_config_utilities.round_down(mmio_min, acrn_config_utilities.SIZE_G), file=config) + print("#define HI_MMIO_END\t\t\t0x%xUL" % acrn_config_utilities.round_up(mmio_max, acrn_config_utilities.SIZE_G), file=config) else: print("#define HI_MMIO_START\t\t\t~0UL", file=config) print("#define HI_MMIO_END\t\t\t0UL", file=config) @@ -91,8 +91,8 @@ def generate_file(config): # generate HI_MMIO_START/HI_MMIO_END find_hi_mmio_window(config) - p2sb = common.get_leaf_tag_map_bool(common.SCENARIO_INFO_FILE, "mmio_resources", "p2sb") - if (common.LOAD_ORDER.get(0) == "PRE_LAUNCHED_VM" + p2sb = acrn_config_utilities.get_leaf_tag_map_bool(acrn_config_utilities.SCENARIO_INFO_FILE, "mmio_resources", "p2sb") + if (acrn_config_utilities.LOAD_ORDER.get(0) == "PRE_LAUNCHED_VM" and board_cfg_lib.is_p2sb_passthru_possible() and p2sb.get(0, False)): print("", file=config) @@ -100,7 +100,7 @@ def generate_file(config): hpa = board_cfg_lib.find_p2sb_bar_addr() print("#define P2SB_BAR_ADDR\t\t\t0x{:X}UL".format(hpa), file=config) - gpa = common.hpa2gpa(0, hpa, 0x1000000) + gpa = acrn_config_utilities.hpa2gpa(0, hpa, 0x1000000) print("#define P2SB_BAR_ADDR_GPA\t\t0x{:X}UL".format(gpa), file=config) print("#define P2SB_BAR_SIZE\t\t\t0x1000000UL", file=config) diff --git a/misc/config_tools/board_config/pci_devices_h.py b/misc/config_tools/board_config/pci_devices_h.py index 97457ac01..e40f05e9f 100644 --- a/misc/config_tools/board_config/pci_devices_h.py +++ b/misc/config_tools/board_config/pci_devices_h.py @@ -5,7 +5,6 @@ import collections import board_cfg_lib -import common PCI_HEADER = r""" #ifndef PCI_DEVICES_H_ diff --git a/misc/config_tools/board_config/vbar_base_h.py b/misc/config_tools/board_config/vbar_base_h.py index 074c44b6d..e562ea328 100644 --- a/misc/config_tools/board_config/vbar_base_h.py +++ b/misc/config_tools/board_config/vbar_base_h.py @@ -6,7 +6,7 @@ import re from collections import namedtuple -import common +import acrn_config_utilities import board_cfg_lib import scenario_cfg_lib @@ -17,20 +17,20 @@ VBAR_INFO_DEFINE="""#ifndef VBAR_BASE_H_ VBAR_INFO_ENDIF="""#endif /* VBAR_BASE_H_ */""" # Constants for ivshmem -BAR0_SHEMEM_SIZE = 4*common.SIZE_K -BAR1_SHEMEM_SIZE = 4*common.SIZE_K -BAR0_SHEMEM_ALIGNMENT = 4*common.SIZE_K -BAR1_SHEMEM_ALIGNMENT = 4*common.SIZE_K -BAR2_SHEMEM_ALIGNMENT = 2*common.SIZE_M +BAR0_SHEMEM_SIZE = 4*acrn_config_utilities.SIZE_K +BAR1_SHEMEM_SIZE = 4*acrn_config_utilities.SIZE_K +BAR0_SHEMEM_ALIGNMENT = 4*acrn_config_utilities.SIZE_K +BAR1_SHEMEM_ALIGNMENT = 4*acrn_config_utilities.SIZE_K +BAR2_SHEMEM_ALIGNMENT = 2*acrn_config_utilities.SIZE_M # Constants for pci vuart -PCI_VUART_VBAR0_SIZE = 4*common.SIZE_K -PCI_VUART_VBAR1_SIZE = 4*common.SIZE_K -PCI_VUART_VBAR0_ALIGNMENT = 4*common.SIZE_K -PCI_VUART_VBAR1_ALIGNMENT = 4*common.SIZE_K +PCI_VUART_VBAR0_SIZE = 4*acrn_config_utilities.SIZE_K +PCI_VUART_VBAR1_SIZE = 4*acrn_config_utilities.SIZE_K +PCI_VUART_VBAR0_ALIGNMENT = 4*acrn_config_utilities.SIZE_K +PCI_VUART_VBAR1_ALIGNMENT = 4*acrn_config_utilities.SIZE_K # Constants for vmsix bar -VMSIX_VBAR_SIZE = 4*common.SIZE_K +VMSIX_VBAR_SIZE = 4*acrn_config_utilities.SIZE_K VMSIX_VBAR_ALIGNMENT = VMSIX_VBAR_SIZE @@ -98,13 +98,13 @@ def write_vbar(i_cnt, bdf, pci_bar_dic, bar_attr, \ if board_cfg_lib.is_matched_board(('ehl-crb-b')): for vm_i in pci_devs_per_vm: if bdf in pci_devs_per_vm[vm_i]: - if scenario_cfg_lib.VM_DB[common.VM_TYPES[vm_i]]['load_type'] == "PRE_LAUNCHED_VM": + if scenario_cfg_lib.VM_DB[acrn_config_utilities.VM_TYPES[vm_i]]['load_type'] == "PRE_LAUNCHED_VM": is_vmsix = True bar_len += 1 # For pre-launched VM, the windows range is form 2G to 4G - free = get_free_mmio([MmioWindow(start=common.SIZE_2G, end=common.SIZE_4G-1)], \ + free = get_free_mmio([MmioWindow(start=acrn_config_utilities.SIZE_2G, end=acrn_config_utilities.SIZE_4G-1)], \ mmiolist_per_vm[vm_i], VMSIX_VBAR_ALIGNMENT + VMSIX_VBAR_SIZE) - free_vbar_start_addr = common.round_up(free.start, VMSIX_VBAR_ALIGNMENT) + free_vbar_start_addr = acrn_config_utilities.round_up(free.start, VMSIX_VBAR_ALIGNMENT) free_vbar_end_addr = free_vbar_start_addr + VMSIX_VBAR_SIZE - 1 free = MmioWindow(free_vbar_start_addr, free_vbar_end_addr) mmiolist_per_vm[vm_i].append(free) @@ -137,7 +137,7 @@ def write_vbar(i_cnt, bdf, pci_bar_dic, bar_attr, \ def find_next_bar(bar_val, bar_list): - pci_lines = board_cfg_lib.get_info(common.BOARD_INFO_FILE, "", "") + pci_lines = board_cfg_lib.get_info(acrn_config_utilities.BOARD_INFO_FILE, "", "") idx = bar_list[-1] for line in pci_lines: if bar_val.split('x')[1] in line: @@ -154,12 +154,12 @@ def find_next_bar(bar_val, bar_list): def write_vuart_vbar(mmiolist_per_vm, sos_mmio_range, config): # get legacy vuart information - vuart0_setting = common.get_vuart_info_id(common.SCENARIO_INFO_FILE, 0) - vuart1_setting = common.get_vuart_info_id(common.SCENARIO_INFO_FILE, 1) + vuart0_setting = acrn_config_utilities.get_vuart_info_id(acrn_config_utilities.SCENARIO_INFO_FILE, 0) + vuart1_setting = acrn_config_utilities.get_vuart_info_id(acrn_config_utilities.SCENARIO_INFO_FILE, 1) # get pci vuart information - vuarts = common.get_vuart_info(common.SCENARIO_INFO_FILE) + vuarts = acrn_config_utilities.get_vuart_info(acrn_config_utilities.SCENARIO_INFO_FILE) for vm_id in vuarts.keys(): - vm_type = common.VM_TYPES[vm_id] + vm_type = acrn_config_utilities.VM_TYPES[vm_id] if scenario_cfg_lib.VM_DB[vm_type]['load_type'] == "POST_LAUNCHED_VM": continue for vuart_id in vuarts[vm_id].keys(): @@ -179,29 +179,29 @@ def write_vuart_vbar(mmiolist_per_vm, sos_mmio_range, config): if scenario_cfg_lib.VM_DB[vm_type]['load_type'] == "SERVICE_VM": free_bar0 = get_free_mmio(sos_mmio_range, mmiolist_per_vm[vm_id], \ PCI_VUART_VBAR0_SIZE + PCI_VUART_VBAR0_ALIGNMENT) - free_bar0_start_addr = common.round_up(free_bar0.start, PCI_VUART_VBAR0_ALIGNMENT) + free_bar0_start_addr = acrn_config_utilities.round_up(free_bar0.start, PCI_VUART_VBAR0_ALIGNMENT) free_bar0_end_addr = free_bar0_start_addr + PCI_VUART_VBAR0_SIZE - 1 free_bar0 = MmioWindow(free_bar0_start_addr, free_bar0_end_addr) mmiolist_per_vm[vm_id].append(free_bar0) mmiolist_per_vm[vm_id].sort() free_bar1 = get_free_mmio(sos_mmio_range, mmiolist_per_vm[vm_id], \ PCI_VUART_VBAR1_SIZE + PCI_VUART_VBAR1_ALIGNMENT) - free_bar1_start_addr = common.round_up(free_bar1.start, PCI_VUART_VBAR1_ALIGNMENT) + free_bar1_start_addr = acrn_config_utilities.round_up(free_bar1.start, PCI_VUART_VBAR1_ALIGNMENT) free_bar1_end_addr = free_bar1_start_addr + PCI_VUART_VBAR1_SIZE - 1 free_bar1 = MmioWindow(free_bar1_start_addr, free_bar1_end_addr) mmiolist_per_vm[vm_id].append(free_bar1) mmiolist_per_vm[vm_id].sort() elif scenario_cfg_lib.VM_DB[vm_type]['load_type'] == "PRE_LAUNCHED_VM": - free_bar0 = get_free_mmio([MmioWindow(start=common.SIZE_2G, end=common.SIZE_4G-1)], \ + free_bar0 = get_free_mmio([MmioWindow(start=acrn_config_utilities.SIZE_2G, end=acrn_config_utilities.SIZE_4G-1)], \ mmiolist_per_vm[vm_id], PCI_VUART_VBAR0_SIZE + PCI_VUART_VBAR0_ALIGNMENT) - free_bar0_start_addr = common.round_up(free_bar0.start, PCI_VUART_VBAR0_ALIGNMENT) + free_bar0_start_addr = acrn_config_utilities.round_up(free_bar0.start, PCI_VUART_VBAR0_ALIGNMENT) free_bar0_end_addr = free_bar0_start_addr + PCI_VUART_VBAR0_SIZE - 1 free_bar0 = MmioWindow(free_bar0_start_addr, free_bar0_end_addr) mmiolist_per_vm[vm_id].append(free_bar0) mmiolist_per_vm[vm_id].sort() - free_bar1 = get_free_mmio([MmioWindow(start=common.SIZE_2G, end=common.SIZE_4G-1)], \ + free_bar1 = get_free_mmio([MmioWindow(start=acrn_config_utilities.SIZE_2G, end=acrn_config_utilities.SIZE_4G-1)], \ mmiolist_per_vm[vm_id], PCI_VUART_VBAR1_SIZE + PCI_VUART_VBAR1_ALIGNMENT) - free_bar1_start_addr = common.round_up(free_bar1.start, PCI_VUART_VBAR1_ALIGNMENT) + free_bar1_start_addr = acrn_config_utilities.round_up(free_bar1.start, PCI_VUART_VBAR1_ALIGNMENT) free_bar1_end_addr = free_bar1_start_addr + PCI_VUART_VBAR1_SIZE - 1 free_bar1 = MmioWindow(free_bar1_start_addr, free_bar1_end_addr) mmiolist_per_vm[vm_id].append(free_bar1) @@ -213,8 +213,8 @@ def write_vuart_vbar(mmiolist_per_vm, sos_mmio_range, config): def write_ivshmem_vbar(mmiolist_per_vm, sos_mmio_range, config): - for vm_id,vm_type in common.VM_TYPES.items(): - ivshmem_region = common.get_hv_item_tag(common.SCENARIO_INFO_FILE, + for vm_id,vm_type in acrn_config_utilities.VM_TYPES.items(): + ivshmem_region = acrn_config_utilities.get_hv_item_tag(acrn_config_utilities.SCENARIO_INFO_FILE, "FEATURES", "IVSHMEM", "IVSHMEM_REGION") shmem_regions = scenario_cfg_lib.get_shmem_regions(ivshmem_region) if vm_id not in shmem_regions: @@ -235,21 +235,21 @@ def write_ivshmem_vbar(mmiolist_per_vm, sos_mmio_range, config): if scenario_cfg_lib.VM_DB[vm_type]['load_type'] == "SERVICE_VM": # vbar[0] for shared memory is 4k free_bar0 = get_free_mmio(sos_mmio_range, mmiolist_per_vm[vm_id], BAR0_SHEMEM_ALIGNMENT + BAR0_SHEMEM_SIZE) - free_bar0_start_addr = common.round_up(free_bar0.start, BAR0_SHEMEM_ALIGNMENT) + free_bar0_start_addr = acrn_config_utilities.round_up(free_bar0.start, BAR0_SHEMEM_ALIGNMENT) free_bar0_end_addr = free_bar0_start_addr + BAR0_SHEMEM_SIZE - 1 free_bar0 = MmioWindow(free_bar0_start_addr, free_bar0_end_addr) mmiolist_per_vm[vm_id].append(free_bar0) mmiolist_per_vm[vm_id].sort() # vbar[1] for shared memory is 4K free_bar1 = get_free_mmio(sos_mmio_range, mmiolist_per_vm[vm_id], BAR1_SHEMEM_ALIGNMENT + BAR1_SHEMEM_SIZE) - free_bar1_start_addr = common.round_up(free_bar1.start, BAR1_SHEMEM_ALIGNMENT) + free_bar1_start_addr = acrn_config_utilities.round_up(free_bar1.start, BAR1_SHEMEM_ALIGNMENT) free_bar1_end_addr = free_bar1_start_addr + BAR1_SHEMEM_SIZE - 1 free_bar1 = MmioWindow(free_bar1_start_addr, free_bar1_end_addr) mmiolist_per_vm[vm_id].append(free_bar1) mmiolist_per_vm[vm_id].sort() # vbar[2] for shared memory is specified size in MB free_bar2 = get_free_mmio(sos_mmio_range, mmiolist_per_vm[vm_id], BAR2_SHEMEM_ALIGNMENT + int_size) - free_bar2_start_addr = common.round_up(free_bar2.start, BAR2_SHEMEM_ALIGNMENT) + 0xC + free_bar2_start_addr = acrn_config_utilities.round_up(free_bar2.start, BAR2_SHEMEM_ALIGNMENT) + 0xC free_bar2_end_addr = free_bar2_start_addr + int_size - 1 free_bar2 = MmioWindow(free_bar2_start_addr, free_bar2_end_addr) mmiolist_per_vm[vm_id].append(free_bar2) @@ -261,24 +261,24 @@ def write_ivshmem_vbar(mmiolist_per_vm, sos_mmio_range, config): print("", file=config) idx += 1 elif scenario_cfg_lib.VM_DB[vm_type]['load_type'] == "PRE_LAUNCHED_VM": - mmioRange = [MmioWindow(start=common.SIZE_2G, end=common.SIZE_4G-1)] + mmioRange = [MmioWindow(start=acrn_config_utilities.SIZE_2G, end=acrn_config_utilities.SIZE_4G-1)] # vbar[0] for shared memory is 4k free_bar0 = get_free_mmio(mmioRange, mmiolist_per_vm[vm_id], BAR0_SHEMEM_ALIGNMENT + BAR0_SHEMEM_SIZE) - free_bar0_start_addr = common.round_up(free_bar0.start, BAR0_SHEMEM_ALIGNMENT) + free_bar0_start_addr = acrn_config_utilities.round_up(free_bar0.start, BAR0_SHEMEM_ALIGNMENT) free_bar0_end_addr = free_bar0_start_addr + BAR0_SHEMEM_SIZE - 1 free_bar0 = MmioWindow(free_bar0_start_addr, free_bar0_end_addr) mmiolist_per_vm[vm_id].append(free_bar0) mmiolist_per_vm[vm_id].sort() # vbar[1] for shared memory is 4K free_bar1 = get_free_mmio(mmioRange, mmiolist_per_vm[vm_id], BAR1_SHEMEM_ALIGNMENT + BAR1_SHEMEM_SIZE) - free_bar1_start_addr = common.round_up(free_bar1.start, BAR1_SHEMEM_ALIGNMENT) + free_bar1_start_addr = acrn_config_utilities.round_up(free_bar1.start, BAR1_SHEMEM_ALIGNMENT) free_bar1_end_addr = free_bar1_start_addr + BAR1_SHEMEM_SIZE - 1 free_bar1 = MmioWindow(free_bar1_start_addr, free_bar1_end_addr) mmiolist_per_vm[vm_id].append(free_bar1) mmiolist_per_vm[vm_id].sort() # vbar[2] for shared memory is specified size in MB free_bar2 = get_free_mmio(mmioRange, mmiolist_per_vm[vm_id], BAR2_SHEMEM_ALIGNMENT + int_size) - free_bar2_start_addr = common.round_up(free_bar2.start, BAR2_SHEMEM_ALIGNMENT) + 0xC + free_bar2_start_addr = acrn_config_utilities.round_up(free_bar2.start, BAR2_SHEMEM_ALIGNMENT) + 0xC free_bar2_end_addr = free_bar2_start_addr + int_size - 1 free_bar2 = MmioWindow(free_bar2_start_addr, free_bar2_end_addr) mmiolist_per_vm[vm_id].append(free_bar2) @@ -302,7 +302,7 @@ def is_mmio_window_used(devinfo, keywords): def get_mmio_windows_with_key(keywords): keyword_mmiolist = [] exclusive_mmiolist = [] - iomem_lines = board_cfg_lib.get_info(common.BOARD_INFO_FILE, "", "") + iomem_lines = board_cfg_lib.get_info(acrn_config_utilities.BOARD_INFO_FILE, "", "") for line in iomem_lines: mmio_range = line.split(':')[0] @@ -373,7 +373,7 @@ def generate_file(config): # list of all vmsix supported device list in bdf format bdf_list = board_cfg_lib.get_known_caps_pci_devs().get('VMSIX', []) # list of all PRE_LAUNCHED_VMs' vmsix supported passthrough devices in bdf format - pci_items = common.get_leaf_tag_map(common.SCENARIO_INFO_FILE, "pci_devs", "pci_dev") + pci_items = acrn_config_utilities.get_leaf_tag_map(acrn_config_utilities.SCENARIO_INFO_FILE, "pci_devs", "pci_dev") pci_devs = scenario_cfg_lib.get_pt_pci_devs(pci_items) pci_devs_per_vm = get_devs_per_vm_with_key(pci_devs, bdf_list) # list Service VM vmsix supported devices without other PRE_LAUNCHED_VMs' in bdf format @@ -383,12 +383,12 @@ def generate_file(config): ] for vm_i in pci_devs_per_vm: - vm_type = common.VM_TYPES[vm_i] + vm_type = acrn_config_utilities.VM_TYPES[vm_i] if scenario_cfg_lib.VM_DB[vm_type]['load_type'] == "SERVICE_VM": pci_devs_per_vm[vm_i] = sos_bdf_list mmiolist_per_vm = {} - for vm_i,vm_type in common.VM_TYPES.items(): + for vm_i,vm_type in acrn_config_utilities.VM_TYPES.items(): if vm_i not in mmiolist_per_vm.keys(): mmiolist_per_vm[vm_i] = [] if scenario_cfg_lib.VM_DB[vm_type]['load_type'] == "SERVICE_VM": @@ -414,10 +414,10 @@ def generate_file(config): # start to generate board_info.h print("{0}".format(board_cfg_lib.HEADER_LICENSE), file=config) print(VBAR_INFO_DEFINE, file=config) - common.get_vm_types() + acrn_config_utilities.get_vm_types() pre_vm = False sos_vm = False - for vm_type in common.VM_TYPES.values(): + for vm_type in acrn_config_utilities.VM_TYPES.values(): if scenario_cfg_lib.VM_DB[vm_type]['load_type'] == "PRE_LAUNCHED_VM": pre_vm = True if scenario_cfg_lib.VM_DB[vm_type]['load_type'] == "SERVICE_VM": @@ -427,7 +427,7 @@ def generate_file(config): print(VBAR_INFO_ENDIF, file=config) return - ivshmem_enabled = common.get_hv_item_tag(common.SCENARIO_INFO_FILE, "FEATURES", "IVSHMEM", "IVSHMEM_ENABLED") + ivshmem_enabled = acrn_config_utilities.get_hv_item_tag(acrn_config_utilities.SCENARIO_INFO_FILE, "FEATURES", "IVSHMEM", "IVSHMEM_ENABLED") if ivshmem_enabled == 'y': write_ivshmem_vbar(mmiolist_per_vm, matching_mmios, config) diff --git a/misc/config_tools/hv_config/board_defconfig.py b/misc/config_tools/hv_config/board_defconfig.py index 31da5bf85..b8769043d 100644 --- a/misc/config_tools/hv_config/board_defconfig.py +++ b/misc/config_tools/hv_config/board_defconfig.py @@ -7,13 +7,13 @@ import sys import subprocess # nosec import board_cfg_lib, scenario_cfg_lib import hv_cfg_lib -import common +import acrn_config_utilities DESC = """# Board defconfig generated by acrn-config tool """ -MEM_ALIGN = 2 * common.SIZE_M +MEM_ALIGN = 2 * acrn_config_utilities.SIZE_M def get_serial_type(): @@ -23,7 +23,7 @@ def get_serial_type(): pci_mmio = False # Get ttySx information from board config file - ttys_lines = board_cfg_lib.get_info(common.BOARD_INFO_FILE, "", "") + ttys_lines = board_cfg_lib.get_info(acrn_config_utilities.BOARD_INFO_FILE, "", "") # Get ttySx from scenario config file which selected by user (err_dic, ttyn) = board_cfg_lib.parser_hv_console() @@ -110,7 +110,7 @@ def get_capacities(hv_info, config): print("CONFIG_MAX_PT_IRQ_ENTRIES={}".format(hv_info.cap.max_pt_irq_entries), file=config) max_msix_table_num = 0 if not hv_info.cap.max_msix_table_num: - native_max_msix_line = board_cfg_lib.get_info(common.BOARD_INFO_FILE, "", "") + native_max_msix_line = board_cfg_lib.get_info(acrn_config_utilities.BOARD_INFO_FILE, "", "") max_msix_table_num = native_max_msix_line[0].strip() else: max_msix_table_num = hv_info.cap.max_msix_table_num @@ -132,8 +132,8 @@ def generate_file(hv_info, config): err_dic = {} # add config scenario name - (err_dic, scenario_name) = common.get_scenario_name() - (err_dic, board_name) = common.get_board_name() + (err_dic, scenario_name) = acrn_config_utilities.get_scenario_name() + (err_dic, board_name) = acrn_config_utilities.get_board_name() print("{}".format(DESC), file=config) if hv_info.log.release == 'y': diff --git a/misc/config_tools/hv_config/hv_item.py b/misc/config_tools/hv_config/hv_item.py index 9b45a9f0f..842cc1a41 100644 --- a/misc/config_tools/hv_config/hv_item.py +++ b/misc/config_tools/hv_config/hv_item.py @@ -3,7 +3,7 @@ # SPDX-License-Identifier: BSD-3-Clause # -import common +import acrn_config_utilities import hv_cfg_lib class LogLevel: @@ -15,9 +15,9 @@ class LogLevel: self.console = 0 def get_info(self): - self.npk = common.get_hv_item_tag(self.hv_file, "DEBUG_OPTIONS", "NPK_LOGLEVEL") - self.mem = common.get_hv_item_tag(self.hv_file, "DEBUG_OPTIONS", "MEM_LOGLEVEL") - self.console = common.get_hv_item_tag(self.hv_file, "DEBUG_OPTIONS", "CONSOLE_LOGLEVEL") + self.npk = acrn_config_utilities.get_hv_item_tag(self.hv_file, "DEBUG_OPTIONS", "NPK_LOGLEVEL") + self.mem = acrn_config_utilities.get_hv_item_tag(self.hv_file, "DEBUG_OPTIONS", "MEM_LOGLEVEL") + self.console = acrn_config_utilities.get_hv_item_tag(self.hv_file, "DEBUG_OPTIONS", "CONSOLE_LOGLEVEL") def check_item(self): hv_cfg_lib.hv_range_check(self.npk, "DEBUG_OPTIONS", "NPK_LOGLEVEL", hv_cfg_lib.RANGE_DB['LOG_LEVEL']) @@ -33,7 +33,7 @@ class LogOpt: self.level = LogLevel(self.hv_file) def get_info(self): - self.release = common.get_hv_item_tag(self.hv_file, "DEBUG_OPTIONS", "RELEASE") + self.release = acrn_config_utilities.get_hv_item_tag(self.hv_file, "DEBUG_OPTIONS", "RELEASE") self.level.get_info() def check_item(self): @@ -53,12 +53,12 @@ class CapHv: self.max_msix_table_num = 0 def get_info(self): - self.max_emu_mmio_regions = common.get_hv_item_tag(self.hv_file, "CAPACITIES", "MAX_EMULATED_MMIO") - self.max_pt_irq_entries = common.get_hv_item_tag(self.hv_file, "CAPACITIES", "MAX_PT_IRQ_ENTRIES") - self.max_ioapic_num = common.get_hv_item_tag(self.hv_file, "CAPACITIES", "MAX_IOAPIC_NUM") - self.max_ioapic_lines = common.get_hv_item_tag(self.hv_file, "CAPACITIES", "MAX_IOAPIC_LINES") - self.max_pci_dev_num = common.get_hv_item_tag(self.hv_file, "CAPACITIES", "MAX_PCI_DEV_NUM") - self.max_msix_table_num = common.get_hv_item_tag(self.hv_file, "CAPACITIES", "MAX_MSIX_TABLE_NUM") + self.max_emu_mmio_regions = acrn_config_utilities.get_hv_item_tag(self.hv_file, "CAPACITIES", "MAX_EMULATED_MMIO") + self.max_pt_irq_entries = acrn_config_utilities.get_hv_item_tag(self.hv_file, "CAPACITIES", "MAX_PT_IRQ_ENTRIES") + self.max_ioapic_num = acrn_config_utilities.get_hv_item_tag(self.hv_file, "CAPACITIES", "MAX_IOAPIC_NUM") + self.max_ioapic_lines = acrn_config_utilities.get_hv_item_tag(self.hv_file, "CAPACITIES", "MAX_IOAPIC_LINES") + self.max_pci_dev_num = acrn_config_utilities.get_hv_item_tag(self.hv_file, "CAPACITIES", "MAX_PCI_DEV_NUM") + self.max_msix_table_num = acrn_config_utilities.get_hv_item_tag(self.hv_file, "CAPACITIES", "MAX_MSIX_TABLE_NUM") def check_item(self): hv_cfg_lib.hv_range_check(self.max_emu_mmio_regions, "CAPACITIES", "MAX_EMULATED_MMIO", hv_cfg_lib.RANGE_DB['EMULATED_MMIO_REGIONS']) @@ -86,19 +86,19 @@ class Features: self.ssram_enabled = '' def get_info(self): - self.multiboot2 = common.get_hv_item_tag(self.hv_file, "FEATURES", "MULTIBOOT2_ENABLED") - self.rdt_enabled = common.get_hv_item_tag(self.hv_file, "FEATURES", "RDT", "RDT_ENABLED") - self.cdp_enabled = common.get_hv_item_tag(self.hv_file, "FEATURES", "RDT", "CDP_ENABLED") - self.cat_max_mask = common.get_hv_item_tag(self.hv_file, "FEATURES", "RDT", "CLOS_MASK") - self.mba_delay = common.get_hv_item_tag(self.hv_file, "FEATURES", "RDT", "MBA_DELAY") - self.scheduler = common.get_hv_item_tag(self.hv_file, "FEATURES", "SCHEDULER") - self.reloc = common.get_hv_item_tag(self.hv_file, "FEATURES", "RELOC_ENABLED") - self.hyperv_enabled = common.get_hv_item_tag(self.hv_file, "FEATURES", "HYPERV_ENABLED") - self.acpi_parse_enabled = common.get_hv_item_tag(self.hv_file, "FEATURES", "ACPI_PARSE_ENABLED") - self.l1d_flush_vmentry_enabled = common.get_hv_item_tag(self.hv_file, "FEATURES", "L1D_VMENTRY_ENABLED") - self.mce_on_psc_workaround_disabled = common.get_hv_item_tag(self.hv_file, "FEATURES", "MCE_ON_PSC_DISABLED") - self.iommu_enforce_snp = common.get_hv_item_tag(self.hv_file, "FEATURES", "IOMMU_ENFORCE_SNP") - self.ssram_enabled = common.get_hv_item_tag(self.hv_file, "FEATURES", "SSRAM", "SSRAM_ENABLED") + self.multiboot2 = acrn_config_utilities.get_hv_item_tag(self.hv_file, "FEATURES", "MULTIBOOT2_ENABLED") + self.rdt_enabled = acrn_config_utilities.get_hv_item_tag(self.hv_file, "FEATURES", "RDT", "RDT_ENABLED") + self.cdp_enabled = acrn_config_utilities.get_hv_item_tag(self.hv_file, "FEATURES", "RDT", "CDP_ENABLED") + self.cat_max_mask = acrn_config_utilities.get_hv_item_tag(self.hv_file, "FEATURES", "RDT", "CLOS_MASK") + self.mba_delay = acrn_config_utilities.get_hv_item_tag(self.hv_file, "FEATURES", "RDT", "MBA_DELAY") + self.scheduler = acrn_config_utilities.get_hv_item_tag(self.hv_file, "FEATURES", "SCHEDULER") + self.reloc = acrn_config_utilities.get_hv_item_tag(self.hv_file, "FEATURES", "RELOC_ENABLED") + self.hyperv_enabled = acrn_config_utilities.get_hv_item_tag(self.hv_file, "FEATURES", "HYPERV_ENABLED") + self.acpi_parse_enabled = acrn_config_utilities.get_hv_item_tag(self.hv_file, "FEATURES", "ACPI_PARSE_ENABLED") + self.l1d_flush_vmentry_enabled = acrn_config_utilities.get_hv_item_tag(self.hv_file, "FEATURES", "L1D_VMENTRY_ENABLED") + self.mce_on_psc_workaround_disabled = acrn_config_utilities.get_hv_item_tag(self.hv_file, "FEATURES", "MCE_ON_PSC_DISABLED") + self.iommu_enforce_snp = acrn_config_utilities.get_hv_item_tag(self.hv_file, "FEATURES", "IOMMU_ENFORCE_SNP") + self.ssram_enabled = acrn_config_utilities.get_hv_item_tag(self.hv_file, "FEATURES", "SSRAM", "SSRAM_ENABLED") def check_item(self): hv_cfg_lib.ny_support_check(self.multiboot2, "FEATURES", "MULTIBOOT2_ENABLED") @@ -129,10 +129,10 @@ class Memory: self.ivshmem_region = [] def get_info(self): - self.stack_size = common.get_hv_item_tag(self.hv_file, "MEMORY", "STACK_SIZE") - self.hv_ram_start = common.get_hv_item_tag(self.hv_file, "MEMORY", "HV_RAM_START") - self.ivshmem_enable = common.get_hv_item_tag(self.hv_file, "FEATURES", "IVSHMEM", "IVSHMEM_ENABLED") - self.ivshmem_region = common.get_hv_item_tag(self.hv_file, "FEATURES", "IVSHMEM", "IVSHMEM_REGION") + self.stack_size = acrn_config_utilities.get_hv_item_tag(self.hv_file, "MEMORY", "STACK_SIZE") + self.hv_ram_start = acrn_config_utilities.get_hv_item_tag(self.hv_file, "MEMORY", "HV_RAM_START") + self.ivshmem_enable = acrn_config_utilities.get_hv_item_tag(self.hv_file, "FEATURES", "IVSHMEM", "IVSHMEM_ENABLED") + self.ivshmem_region = acrn_config_utilities.get_hv_item_tag(self.hv_file, "FEATURES", "IVSHMEM", "IVSHMEM_REGION") def check_item(self): hv_cfg_lib.hv_size_check(self.stack_size, "MEMORY", "STACK_SIZE") diff --git a/misc/config_tools/library/common.py b/misc/config_tools/library/acrn_config_utilities.py similarity index 99% rename from misc/config_tools/library/common.py rename to misc/config_tools/library/acrn_config_utilities.py index db414e56c..f8c11b3cf 100644 --- a/misc/config_tools/library/common.py +++ b/misc/config_tools/library/acrn_config_utilities.py @@ -183,7 +183,7 @@ def get_xml_attrib(config_file, attrib): if 'board=' in line or 'scenario=' in line: if attrib not in line: - err_dic['common error'] = "The {} attribute is not in xml file".format(attrib) + err_dic['acrn_config_utilities error'] = "The {} attribute is not in xml file".format(attrib) return (err_dic, value) attrib_list = line.split() diff --git a/misc/config_tools/library/board_cfg_lib.py b/misc/config_tools/library/board_cfg_lib.py index cbe8a1247..a663d0f72 100644 --- a/misc/config_tools/library/board_cfg_lib.py +++ b/misc/config_tools/library/board_cfg_lib.py @@ -5,7 +5,7 @@ import re import sys -import common +import acrn_config_utilities import collections BOARD_NAME = '' @@ -23,7 +23,7 @@ VALID_LEGACY_IRQ = [] ERR_LIST = {} USED_RAM_RANGE = {} -HEADER_LICENSE = common.open_license() + "\n" +HEADER_LICENSE = acrn_config_utilities.open_license() + "\n" # The data base contains hide pci device KNOWN_HIDDEN_PDEVS_BOARD_DB = { @@ -84,8 +84,8 @@ def handle_bios_info(config): Handle bios information :param config: it is a file pointer of bios information for writing to """ - bios_lines = get_info(common.BOARD_INFO_FILE, "", "") - board_lines = get_info(common.BOARD_INFO_FILE, "", "") + bios_lines = get_info(acrn_config_utilities.BOARD_INFO_FILE, "", "") + board_lines = get_info(acrn_config_utilities.BOARD_INFO_FILE, "", "") print("/*", file=config) if not bios_lines or not board_lines: @@ -216,7 +216,7 @@ def parser_hv_console(): """ ttys_n = '' err_dic = {} - ttys = common.get_hv_item_tag(common.SCENARIO_INFO_FILE, "DEBUG_OPTIONS", "SERIAL_CONSOLE") + ttys = acrn_config_utilities.get_hv_item_tag(acrn_config_utilities.SCENARIO_INFO_FILE, "DEBUG_OPTIONS", "SERIAL_CONSOLE") if not ttys or ttys == None: return (err_dic, ttys_n) @@ -237,7 +237,7 @@ def get_processor_info(): """ processor_list = [] tmp_list = [] - processor_info = get_info(common.BOARD_INFO_FILE, "", "") + processor_info = get_info(acrn_config_utilities.BOARD_INFO_FILE, "", "") if not processor_info: key = "CPU PROCESSOR_INFO error:" @@ -285,7 +285,7 @@ def get_total_mem(): """ scale_to_mb = 1 total_mem_mb = scale_to_mb - mem_lines = get_info(common.BOARD_INFO_FILE, "", "") + mem_lines = get_info(acrn_config_utilities.BOARD_INFO_FILE, "", "") for mem_line in mem_lines: mem_info_list = mem_line.split() @@ -354,7 +354,7 @@ def get_p_state_count(): Get cpu p-state count :return: p-state count """ - px_info = get_info(common.BOARD_INFO_FILE, "", "") + px_info = get_info(acrn_config_utilities.BOARD_INFO_FILE, "", "") if px_info != None: for line in px_info: if re.search("{.*}", line) == None: @@ -368,7 +368,7 @@ def get_p_state_index_from_ratio(ratio): :return: p-state index; If no px_info found in board file, return 0; """ closest_index = 0 - px_info = get_info(common.BOARD_INFO_FILE, "", "") + px_info = get_info(acrn_config_utilities.BOARD_INFO_FILE, "", "") if px_info != None: for line in px_info: if re.search("{.*}", line) == None: @@ -434,11 +434,11 @@ def get_size(line): # get size string from format, Region n: Memory at x ... [size=NK] size_str = line.split()[-1].strip(']').split('=')[1] if 'G' in size_str: - size = int(size_str.strip('G')) * common.SIZE_G + size = int(size_str.strip('G')) * acrn_config_utilities.SIZE_G elif 'M' in size_str: - size = int(size_str.strip('M')) * common.SIZE_M + size = int(size_str.strip('M')) * acrn_config_utilities.SIZE_M elif 'K' in size_str: - size = int(size_str.strip('K')) * common.SIZE_K + size = int(size_str.strip('K')) * acrn_config_utilities.SIZE_K else: size = int(size_str) @@ -449,7 +449,7 @@ def remap_bar_addr_to_high(bar_addr, line): """Generate vbar address""" global HI_MMIO_OFFSET size = get_size(line) - cur_addr = common.round_up(bar_addr, size) + cur_addr = acrn_config_utilities.round_up(bar_addr, size) HI_MMIO_OFFSET = cur_addr + size return cur_addr @@ -463,7 +463,7 @@ def parser_pci(): bar_addr = bar_num = '0' cal_sub_pci_name = [] - pci_lines = get_info(common.BOARD_INFO_FILE, "", "") + pci_lines = get_info(acrn_config_utilities.BOARD_INFO_FILE, "", "") for line in pci_lines: tmp_bar_mem = Bar_Mem() @@ -479,7 +479,7 @@ def parser_pci(): continue bar_num = line.split()[1].strip(':') - if bar_addr >= common.SIZE_4G or bar_addr < common.SIZE_2G: + if bar_addr >= acrn_config_utilities.SIZE_4G or bar_addr < acrn_config_utilities.SIZE_2G: if not tmp_bar_attr.remappable: continue @@ -521,7 +521,7 @@ def parser_pci(): def parse_mem(): - raw_shmem_regions = common.get_hv_item_tag(common.SCENARIO_INFO_FILE, "FEATURES", "IVSHMEM", "IVSHMEM_REGION") + raw_shmem_regions = acrn_config_utilities.get_hv_item_tag(acrn_config_utilities.SCENARIO_INFO_FILE, "FEATURES", "IVSHMEM", "IVSHMEM_REGION") global USED_RAM_RANGE for shm_name, shm_bar_dic in PCI_DEV_BAR_DESC.shm_bar_dic.items(): @@ -547,15 +547,15 @@ def parse_mem(): hv_start_offset = 0x80000000 ret_start_addr = find_avl_memory(ram_range, str(0x200100), hv_start_offset) bar_mem_0 = Bar_Mem() - bar_mem_0.addr = hex(common.round_up(int(ret_start_addr, 16), 0x200000)) + bar_mem_0.addr = hex(acrn_config_utilities.round_up(int(ret_start_addr, 16), 0x200000)) USED_RAM_RANGE[int(bar_mem_0.addr, 16)] = 0x100 tmp_bar_dict[0] = bar_mem_0 ram_range = get_ram_range() hv_start_offset2 = 0x100000000 ret_start_addr2 = find_avl_memory(ram_range, str(int_size + 0x200000), hv_start_offset2) bar_mem_2 = Bar_Mem() - bar_mem_2.addr = hex(common.round_up(int(ret_start_addr2, 16), 0x200000) + 0xC) - USED_RAM_RANGE[common.round_up(int(ret_start_addr2, 16), 0x20000)] = int_size + bar_mem_2.addr = hex(acrn_config_utilities.round_up(int(ret_start_addr2, 16), 0x200000) + 0xC) + USED_RAM_RANGE[acrn_config_utilities.round_up(int(ret_start_addr2, 16), 0x20000)] = int_size tmp_bar_dict[2] = bar_mem_2 PCI_DEV_BAR_DESC.shm_bar_dic[str(idx)+'_'+name] = tmp_bar_dict idx += 1 @@ -565,7 +565,7 @@ def is_rdt_supported(): """ Returns True if platform supports RDT else False """ - (rdt_resources, rdt_res_clos_max, _) = clos_info_parser(common.BOARD_INFO_FILE) + (rdt_resources, rdt_res_clos_max, _) = clos_info_parser(acrn_config_utilities.BOARD_INFO_FILE) if len(rdt_resources) == 0 or len(rdt_res_clos_max) == 0: return False else: @@ -576,7 +576,7 @@ def is_rdt_enabled(): """ Returns True if RDT enabled else False """ - rdt_enabled = common.get_hv_item_tag(common.SCENARIO_INFO_FILE, "FEATURES", "RDT", "RDT_ENABLED") + rdt_enabled = acrn_config_utilities.get_hv_item_tag(acrn_config_utilities.SCENARIO_INFO_FILE, "FEATURES", "RDT", "RDT_ENABLED") if is_rdt_supported() and rdt_enabled == 'y': return True return False @@ -587,7 +587,7 @@ def is_cdp_enabled(): Returns True if platform supports RDT/CDP else False """ rdt_enabled = is_rdt_enabled() - cdp_enabled = common.get_hv_item_tag(common.SCENARIO_INFO_FILE, "FEATURES", "RDT", "CDP_ENABLED") + cdp_enabled = acrn_config_utilities.get_hv_item_tag(acrn_config_utilities.SCENARIO_INFO_FILE, "FEATURES", "RDT", "CDP_ENABLED") if rdt_enabled and cdp_enabled == 'y': return True @@ -605,7 +605,7 @@ def get_rdt_select_opt(): def get_common_clos_max(): common_clos_max = 0 - (res_info, rdt_res_clos_max, clos_max_mask_list) = clos_info_parser(common.BOARD_INFO_FILE) + (res_info, rdt_res_clos_max, clos_max_mask_list) = clos_info_parser(acrn_config_utilities.BOARD_INFO_FILE) if is_rdt_enabled() and not is_cdp_enabled(): common_clos_max = min(rdt_res_clos_max) @@ -628,7 +628,7 @@ def get_sub_pci_name(i_cnt, bar_attr): tmp_sub_name = "_".join(bar_attr.name.split()).upper() else: if '-' in bar_attr.name: - tmp_sub_name = common.undline_name(bar_attr.name) + "_" + str(i_cnt) + tmp_sub_name = acrn_config_utilities.undline_name(bar_attr.name) + "_" + str(i_cnt) else: tmp_sub_name = "_".join(bar_attr.name.split()).upper() + "_" + str(i_cnt) @@ -636,7 +636,7 @@ def get_sub_pci_name(i_cnt, bar_attr): def get_known_caps_pci_devs(): known_caps_pci_devs = {} - vpid_lines = get_info(common.BOARD_INFO_FILE, "", "") + vpid_lines = get_info(acrn_config_utilities.BOARD_INFO_FILE, "", "") for dev,known_dev in KNOWN_CAPS_PCI_DEVS_DB.items(): if dev not in known_caps_pci_devs: known_caps_pci_devs[dev] = [] @@ -653,8 +653,8 @@ def get_known_caps_pci_devs(): def is_tpm_passthru(): tpm_passthru = False - (_, board) = common.get_board_name() - tpm2_passthru_enabled = common.get_leaf_tag_map(common.SCENARIO_INFO_FILE, "mmio_resources", "TPM2") + (_, board) = acrn_config_utilities.get_board_name() + tpm2_passthru_enabled = acrn_config_utilities.get_leaf_tag_map(acrn_config_utilities.SCENARIO_INFO_FILE, "mmio_resources", "TPM2") if board in TPM_PASSTHRU_BOARD and tpm2_passthru_enabled and 'y' in tpm2_passthru_enabled.values(): tpm_passthru = True @@ -692,7 +692,7 @@ def get_ram_range(): ram_range = {} io_mem_lines = get_info( - common.BOARD_INFO_FILE, "", "") + acrn_config_utilities.BOARD_INFO_FILE, "", "") for line in io_mem_lines: if 'System RAM' not in line: @@ -732,7 +732,7 @@ def get_ram_range(): def is_p2sb_passthru_possible(): p2sb_passthru = False - (_, board) = common.get_board_name() + (_, board) = acrn_config_utilities.get_board_name() if board in P2SB_PASSTHRU_BOARD: p2sb_passthru = True @@ -741,22 +741,22 @@ def is_p2sb_passthru_possible(): def is_matched_board(boardlist): - (_, board) = common.get_board_name() + (_, board) = acrn_config_utilities.get_board_name() return board in boardlist def find_p2sb_bar_addr(): if not is_matched_board(('ehl-crb-b')): - common.print_red('find_p2sb_bar_addr() can only be called for board ehl-crb-b', err=True) + acrn_config_utilities.print_red('find_p2sb_bar_addr() can only be called for board ehl-crb-b', err=True) sys.exit(1) - iomem_lines = get_info(common.BOARD_INFO_FILE, "", "") + iomem_lines = get_info(acrn_config_utilities.BOARD_INFO_FILE, "", "") for line in iomem_lines: if 'INTC1020:' in line: start_addr = int(line.split('-')[0], 16) & 0xFF000000 return start_addr - common.print_red('p2sb device is not found in board file %s!\n' % common.BOARD_INFO_FILE, err=True) + acrn_config_utilities.print_red('p2sb device is not found in board file %s!\n' % acrn_config_utilities.BOARD_INFO_FILE, err=True) sys.exit(1) diff --git a/misc/config_tools/library/hv_cfg_lib.py b/misc/config_tools/library/hv_cfg_lib.py index 6aae81c30..2b7c07b55 100644 --- a/misc/config_tools/library/hv_cfg_lib.py +++ b/misc/config_tools/library/hv_cfg_lib.py @@ -5,7 +5,7 @@ import os import sys -import common +import acrn_config_utilities import getopt import board_cfg_lib @@ -56,7 +56,7 @@ def is_numeric_check(str_value, prime_item, item): def range_check(str_value, prime_item, item, range_val): - value = common.num2int(str_value) + value = acrn_config_utilities.num2int(str_value) if value < range_val['min'] or value > range_val['max']: key = 'hv,{},{}'.format(prime_item, item) ERR_LIST[key] = "{} should be in range[{},{}]".format(item, range_val['min'], range_val['max']) @@ -102,7 +102,7 @@ def hv_ram_start_check(hv_ram_start, prime_item, item): def ir_entries_check(str_num, cap, cap_ir_entries): hv_size_check(str_num, cap, cap_ir_entries) - val = common.num2int(str_num) + val = acrn_config_utilities.num2int(str_num) if val % 2 != 0: key = 'hv,{},{}'.format(cap, cap_ir_entries) ERR_LIST[key] = "{} should be a value of 2^n".format(cap_ir_entries) @@ -173,7 +173,7 @@ def is_contiguous_bit_set(value): def cat_max_mask_check(cat_mask_list, feature, cat_str, max_mask_str): - (res_info, rdt_res_clos_max, clos_max_mask_list) = board_cfg_lib.clos_info_parser(common.BOARD_INFO_FILE) + (res_info, rdt_res_clos_max, clos_max_mask_list) = board_cfg_lib.clos_info_parser(acrn_config_utilities.BOARD_INFO_FILE) if not board_cfg_lib.is_rdt_enabled() or ("L2" not in res_info and "L3" not in res_info): return @@ -189,11 +189,11 @@ def cat_max_mask_check(cat_mask_list, feature, cat_str, max_mask_str): return clos_max_mask_str = clos_max_mask_list[0].strip('"').strip("'") - clos_max_mask = common.num2int(clos_max_mask_str) + clos_max_mask = acrn_config_utilities.num2int(clos_max_mask_str) for val_str in cat_mask_list: if empty_check(val_str, feature, cat_str, max_mask_str): return - value = common.num2int(val_str) + value = acrn_config_utilities.num2int(val_str) if value < 0 or value > clos_max_mask: key = 'hv,{},{},{}'.format(feature, cat_str, max_mask_str) ERR_LIST[key] = "{} should be in range[0,{}]".format(max_mask_str, clos_max_mask_str) @@ -207,7 +207,7 @@ def cat_max_mask_check(cat_mask_list, feature, cat_str, max_mask_str): def mba_delay_check(mba_delay_list, feature, mba_str, max_mask_str): - (res_info, rdt_res_clos_max, clos_max_mask_list) = board_cfg_lib.clos_info_parser(common.BOARD_INFO_FILE) + (res_info, rdt_res_clos_max, clos_max_mask_list) = board_cfg_lib.clos_info_parser(acrn_config_utilities.BOARD_INFO_FILE) if not board_cfg_lib.is_rdt_enabled() or "MBA" not in res_info: return @@ -220,11 +220,11 @@ def mba_delay_check(mba_delay_list, feature, mba_str, max_mask_str): mba_idx = res_info.index("MBA") mba_delay_str = clos_max_mask_list[mba_idx].strip('"').strip("'") - mba_delay = common.num2int(mba_delay_str) + mba_delay = acrn_config_utilities.num2int(mba_delay_str) for val_str in mba_delay_list: if empty_check(val_str, feature, mba_str, max_mask_str): return - value = common.num2int(val_str) + value = acrn_config_utilities.num2int(val_str) if value > mba_delay: key = 'hv,{},{},{}'.format(feature, mba_str, max_mask_str) ERR_LIST[key] = "{} should be in range[0,{}]".format(max_mask_str, mba_delay_str) @@ -232,7 +232,7 @@ def mba_delay_check(mba_delay_list, feature, mba_str, max_mask_str): def max_msix_table_num_check(max_msix_table_num, cap_str, max_msi_num_str): - native_max_msix_line = board_cfg_lib.get_info(common.BOARD_INFO_FILE, "", "") + native_max_msix_line = board_cfg_lib.get_info(acrn_config_utilities.BOARD_INFO_FILE, "", "") if not native_max_msix_line and not max_msix_table_num: empty_check(max_msix_table_num, cap_str, max_msi_num_str) return diff --git a/misc/config_tools/library/launch_cfg_lib.py b/misc/config_tools/library/launch_cfg_lib.py index 90f520216..e396b5eb5 100644 --- a/misc/config_tools/library/launch_cfg_lib.py +++ b/misc/config_tools/library/launch_cfg_lib.py @@ -7,7 +7,7 @@ import os import getopt import re -import common +import acrn_config_utilities import board_cfg_lib import scenario_cfg_lib import lxml @@ -81,7 +81,7 @@ def get_param(args): if arg_str not in args: usage(args[0]) - err_dic['common error: wrong parameter'] = "wrong usage" + err_dic['acrn_config_utilities error: wrong parameter'] = "wrong usage" return (err_dic, board_info_file, scenario_info_file, launch_info_file, int(vm_th), output_folder) args_list = args[1:] @@ -131,7 +131,7 @@ def launch_vm_cnt(config_file): post_vm_count = 0 # get post vm number - root = common.get_config_root(config_file) + root = acrn_config_utilities.get_config_root(config_file) for item in root: if item.tag == "user_vm": post_vm_count += 1 @@ -147,7 +147,7 @@ def get_post_num_list(): post_vm_list = [] # get post vm number - root = common.get_config_root(common.LAUNCH_INFO_FILE) + root = acrn_config_utilities.get_config_root(acrn_config_utilities.LAUNCH_INFO_FILE) for item in root: if item.tag == "user_vm": post_vm_list.append(int(item.attrib['id'])) @@ -163,7 +163,7 @@ def post_vm_cnt(config_file): """ post_launch_cnt = 0 - for load_order in common.LOAD_ORDER.values(): + for load_order in acrn_config_utilities.LOAD_ORDER.values(): if load_order == "POST_LAUNCHED_VM": post_launch_cnt += 1 @@ -175,15 +175,15 @@ def get_post_vm_cnt(): Get board name from launch.xml at fist line :param scenario_file: it is a file what contains scenario information for script to read from """ - launch_vm_count = launch_vm_cnt(common.LAUNCH_INFO_FILE) - post_vm_count = post_vm_cnt(common.SCENARIO_INFO_FILE) + launch_vm_count = launch_vm_cnt(acrn_config_utilities.LAUNCH_INFO_FILE) + post_vm_count = post_vm_cnt(acrn_config_utilities.SCENARIO_INFO_FILE) return (launch_vm_count, post_vm_count) def get_sos_vmid(): sos_id = '' - for vm_i,load_order in common.LOAD_ORDER.items(): + for vm_i,load_order in acrn_config_utilities.LOAD_ORDER.items(): if load_order == "SERVICE_VM": sos_id = vm_i break @@ -193,7 +193,7 @@ def get_sos_vmid(): def get_bdf_from_tag(config_file, branch_tag, tag_str): bdf_list = {} - bdf_list = common.get_leaf_tag_map(config_file, branch_tag, tag_str) + bdf_list = acrn_config_utilities.get_leaf_tag_map(config_file, branch_tag, tag_str) # split b:d:f from pci description for idx, bdf_v in bdf_list.items(): @@ -223,13 +223,13 @@ def get_user_vm_type(): """ Get User VM name from launch.xml at fist line """ - user_vm_types = common.get_leaf_tag_map(common.LAUNCH_INFO_FILE, "user_vm_type") + user_vm_types = acrn_config_utilities.get_leaf_tag_map(acrn_config_utilities.LAUNCH_INFO_FILE, "user_vm_type") return user_vm_types def get_user_vm_names(): - user_vm_names = common.get_leaf_tag_map(common.LAUNCH_INFO_FILE, "vm_name") + user_vm_names = acrn_config_utilities.get_leaf_tag_map(acrn_config_utilities.LAUNCH_INFO_FILE, "vm_name") return user_vm_names @@ -410,7 +410,7 @@ def get_pt_dev(): def get_vuart1_from_scenario(vmid): """Get the vmid's vuart1 base""" - vuart1 = common.get_vuart_info_id(common.SCENARIO_INFO_FILE, 1) + vuart1 = acrn_config_utilities.get_vuart_info_id(acrn_config_utilities.SCENARIO_INFO_FILE, 1) return vuart1[vmid]['base'] @@ -431,7 +431,7 @@ def pt_devs_check_audio(audio_map, audio_codec_map): def check_block_mount(virtio_blk_dic): - (blk_dev_list, num) = board_cfg_lib.get_rootfs(common.BOARD_INFO_FILE) + (blk_dev_list, num) = board_cfg_lib.get_rootfs(acrn_config_utilities.BOARD_INFO_FILE) for vmid in list(virtio_blk_dic.keys()): mount_flags = [] for blk in virtio_blk_dic[vmid]: @@ -494,7 +494,7 @@ def bdf_duplicate_check(bdf_dic): def get_gpu_bdf(): - pci_lines = board_cfg_lib.get_info(common.BOARD_INFO_FILE, "", "") + pci_lines = board_cfg_lib.get_info(acrn_config_utilities.BOARD_INFO_FILE, "", "") for line in pci_lines: if "VGA compatible controller" in line: @@ -506,7 +506,7 @@ def get_gpu_bdf(): def get_vpid_by_bdf(bdf): vpid = '' - vpid_lines = board_cfg_lib.get_info(common.BOARD_INFO_FILE, "", "") + vpid_lines = board_cfg_lib.get_info(acrn_config_utilities.BOARD_INFO_FILE, "", "") for vpid_line in vpid_lines: if bdf in vpid_line: @@ -572,9 +572,9 @@ def is_linux_like(user_vm_type): def set_shm_regions(launch_item_values, scenario_info): try: - raw_shmem_regions = common.get_hv_item_tag(scenario_info, "FEATURES", "IVSHMEM", "IVSHMEM_REGION") - load_orders = common.get_leaf_tag_map(scenario_info, "load_order") - shm_enabled = common.get_hv_item_tag(scenario_info, "FEATURES", "IVSHMEM", "IVSHMEM_ENABLED") + raw_shmem_regions = acrn_config_utilities.get_hv_item_tag(scenario_info, "FEATURES", "IVSHMEM", "IVSHMEM_REGION") + load_orders = acrn_config_utilities.get_leaf_tag_map(scenario_info, "load_order") + shm_enabled = acrn_config_utilities.get_hv_item_tag(scenario_info, "FEATURES", "IVSHMEM", "IVSHMEM_ENABLED") except: return @@ -604,12 +604,12 @@ def set_shm_regions(launch_item_values, scenario_info): def set_pci_vuarts(launch_item_values, scenario_info): try: launch_item_values['user_vm,console_vuart'] = DM_VUART0 - load_orders = common.get_leaf_tag_map(scenario_info, 'load_order') + load_orders = acrn_config_utilities.get_leaf_tag_map(scenario_info, 'load_order') sos_vm_id = 0 for vm_id,load_order in load_orders.items(): if load_order in ['SERVICE_VM']: sos_vm_id = vm_id - for vm in list(common.get_config_root(scenario_info)): + for vm in list(acrn_config_utilities.get_config_root(scenario_info)): if vm.tag == 'vm' and load_orders[int(vm.attrib['id'])] == 'POST_LAUNCHED_VM': user_vmid = int(vm.attrib['id']) - sos_vm_id pci_vuart_key = 'user_vm:id={},communication_vuarts,communication_vuart'.format(user_vmid) @@ -639,7 +639,7 @@ def check_shm_regions(launch_shm_regions, scenario_info): def check_console_vuart(launch_console_vuart, vuart0, scenario_info): - vuarts = common.get_vuart_info(scenario_info) + vuarts = acrn_config_utilities.get_vuart_info(scenario_info) for user_vmid, console_vuart_enable in launch_console_vuart.items(): key = 'user_vm:id={},console_vuart'.format(user_vmid) @@ -654,8 +654,8 @@ def check_console_vuart(launch_console_vuart, vuart0, scenario_info): def check_communication_vuart(launch_communication_vuarts, scenario_info): - vuarts = common.get_vuart_info(scenario_info) - vuart1_setting = common.get_vuart_info_id(common.SCENARIO_INFO_FILE, 1) + vuarts = acrn_config_utilities.get_vuart_info(scenario_info) + vuart1_setting = acrn_config_utilities.get_vuart_info_id(acrn_config_utilities.SCENARIO_INFO_FILE, 1) for user_vmid, vuart_list in launch_communication_vuarts.items(): vuart_key = 'user_vm:id={},communication_vuarts,communication_vuart'.format(user_vmid) diff --git a/misc/config_tools/library/rdt.py b/misc/config_tools/library/rdt.py index 8a4e12d98..09926c540 100644 --- a/misc/config_tools/library/rdt.py +++ b/misc/config_tools/library/rdt.py @@ -7,10 +7,11 @@ import sys, os sys.path.append(os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', 'library')) -import common +import acrn_config_utilities import re from collections import defaultdict from collections import namedtuple +from acrn_config_utilities import get_node policy_owner = namedtuple("policy_owner", ["vm_name", "vcpu", "cache_type"]) @@ -74,9 +75,9 @@ class RdtPolicy: l2_mask = None l3_mask = None for policy in policy_list: - cache_level = common.get_node("../CACHE_LEVEL/text()", policy) - cache_id = common.get_node("../CACHE_ID/text()", policy) - clos_mask = common.get_node("./CLOS_MASK/text()", policy) + cache_level = get_node("../CACHE_LEVEL/text()", policy) + cache_id = get_node("../CACHE_ID/text()", policy) + clos_mask = get_node("./CLOS_MASK/text()", policy) if cache_level == "2": l2_mask = clos_mask cache2_id = cache_id @@ -137,19 +138,19 @@ def gen_policy_owner_list(scenario_etree): policy_owner_list = [] vm_list = scenario_etree.xpath("//POLICY/VM") for vm in vm_list: - vm_name = common.get_node("./text()", vm) - vcpu = common.get_node("../VCPU/text()", vm) - cache_type = common.get_node("../TYPE/text()", vm) + vm_name = get_node("./text()", vm) + vcpu = get_node("../VCPU/text()", vm) + cache_type = get_node("../TYPE/text()", vm) policy_owner_list.append(policy_owner(vm_name, int(vcpu), cache_type)) return policy_owner_list def vm_vcat_enable(scenario_etree, vm_name): - vcat_enable = common.get_node(f"//VCAT_ENABLED/text()", scenario_etree) - virtual_cat_support = common.get_node(f"//vm[name = '{vm_name}']/virtual_cat_support/text()", scenario_etree) + vcat_enable = get_node(f"//VCAT_ENABLED/text()", scenario_etree) + virtual_cat_support = get_node(f"//vm[name = '{vm_name}']/virtual_cat_support/text()", scenario_etree) return (vcat_enable == "y") and (virtual_cat_support == "y") def cdp_enable(scenario_etree): - cdp_enable = common.get_node(f"//CDP_ENABLED/text()", scenario_etree) + cdp_enable = get_node(f"//CDP_ENABLED/text()", scenario_etree) return cdp_enable == "y" def convert_cdp_to_normal(cdp_policy_list): diff --git a/misc/config_tools/library/scenario_cfg_lib.py b/misc/config_tools/library/scenario_cfg_lib.py index 34f34fd0a..efecd0265 100644 --- a/misc/config_tools/library/scenario_cfg_lib.py +++ b/misc/config_tools/library/scenario_cfg_lib.py @@ -4,11 +4,11 @@ # import math -import common +import acrn_config_utilities import board_cfg_lib import launch_cfg_lib -HEADER_LICENSE = common.open_license() +HEADER_LICENSE = acrn_config_utilities.open_license() SERVICE_VM_UART1_VALID_NUM = "" NATIVE_TTYS_DIC = {} @@ -130,8 +130,8 @@ def get_pci_vuart_num(vuarts): vuarts_num = {} # get legacy vuart information - vuart0_setting = common.get_vuart_info_id(common.SCENARIO_INFO_FILE, 0) - vuart1_setting = common.get_vuart_info_id(common.SCENARIO_INFO_FILE, 1) + vuart0_setting = acrn_config_utilities.get_vuart_info_id(acrn_config_utilities.SCENARIO_INFO_FILE, 0) + vuart1_setting = acrn_config_utilities.get_vuart_info_id(acrn_config_utilities.SCENARIO_INFO_FILE, 1) for vm_i,vuart_list in vuarts.items(): vuarts_num[vm_i] = 0 for vuart_id in vuart_list: @@ -139,7 +139,7 @@ def get_pci_vuart_num(vuarts): vuarts_num[vm_i] += 1 for vm_i in vuart0_setting: - load_order = common.LOAD_ORDER[vm_i] + load_order = acrn_config_utilities.LOAD_ORDER[vm_i] # Skip post-launched vm's pci base vuart0 if "POST_LAUNCHED_VM" == load_order and 0 in vuarts[vm_i].keys() \ and vuarts[vm_i][0]['base'] != "INVALID_PCI_BASE": @@ -160,23 +160,23 @@ def get_pci_vuart_num(vuarts): def get_pci_dev_num_per_vm(): pci_dev_num_per_vm = {} - pci_items = common.get_leaf_tag_map(common.SCENARIO_INFO_FILE, "pci_devs", "pci_dev") + pci_items = acrn_config_utilities.get_leaf_tag_map(acrn_config_utilities.SCENARIO_INFO_FILE, "pci_devs", "pci_dev") pci_devs = get_pt_pci_devs(pci_items) pt_pci_num = get_pt_pci_num(pci_devs) - ivshmem_region = common.get_hv_item_tag(common.SCENARIO_INFO_FILE, + ivshmem_region = acrn_config_utilities.get_hv_item_tag(acrn_config_utilities.SCENARIO_INFO_FILE, "FEATURES", "IVSHMEM", "IVSHMEM_REGION") - shmem_enabled = common.get_hv_item_tag(common.SCENARIO_INFO_FILE, + shmem_enabled = acrn_config_utilities.get_hv_item_tag(acrn_config_utilities.SCENARIO_INFO_FILE, "FEATURES", "IVSHMEM", "IVSHMEM_ENABLED") shmem_regions = get_shmem_regions(ivshmem_region) shmem_num = get_shmem_num(shmem_regions) - vuarts = common.get_vuart_info(common.SCENARIO_INFO_FILE) + vuarts = acrn_config_utilities.get_vuart_info(acrn_config_utilities.SCENARIO_INFO_FILE) vuarts_num = get_pci_vuart_num(vuarts) - for vm_i,load_order in common.LOAD_ORDER.items(): + for vm_i,load_order in acrn_config_utilities.LOAD_ORDER.items(): if "POST_LAUNCHED_VM" == load_order: shmem_num_i = 0 vuart_num = vuarts_num[vm_i] @@ -273,7 +273,7 @@ def guest_flag_check(guest_flags, branch_tag, leaf_tag): for vm_i, flags in guest_flags.items(): for guest_flag in flags: - if guest_flag and guest_flag not in common.GUEST_FLAG: + if guest_flag and guest_flag not in acrn_config_utilities.GUEST_FLAG: key = "vm:id={},{},{}".format(vm_i, branch_tag, leaf_tag) ERR_LIST[key] = "Unknow guest flag" @@ -288,16 +288,16 @@ def vm_cpu_affinity_check(scenario_file, launch_file, cpu_affinity): use_cpus = [] cpu_sharing_enabled = True - cpu_sharing = common.get_hv_item_tag(common.SCENARIO_INFO_FILE, "FEATURES", "SCHEDULER") + cpu_sharing = acrn_config_utilities.get_hv_item_tag(acrn_config_utilities.SCENARIO_INFO_FILE, "FEATURES", "SCHEDULER") if cpu_sharing == "SCHED_NOOP": cpu_sharing_enabled = False # validate cpu_affinity config with scenario file sos_vmid = launch_cfg_lib.get_sos_vmid() - scenario_cpu_aff = common.get_leaf_tag_map(scenario_file, "cpu_affinity", "pcpu_id") - scenario_vm_names = {v: k for k, v in common.get_leaf_tag_map(scenario_file, 'name').items()} + scenario_cpu_aff = acrn_config_utilities.get_leaf_tag_map(scenario_file, "cpu_affinity", "pcpu_id") + scenario_vm_names = {v: k for k, v in acrn_config_utilities.get_leaf_tag_map(scenario_file, 'name').items()} if launch_file: - launch_vm_names = common.get_leaf_tag_map(launch_file, 'vm_name') + launch_vm_names = acrn_config_utilities.get_leaf_tag_map(launch_file, 'vm_name') for vm_id, cpu_ids in cpu_affinity.items(): launch_vm_name = launch_vm_names[vm_id - sos_vmid] if launch_vm_name not in scenario_vm_names: @@ -325,10 +325,10 @@ def vm_cpu_affinity_check(scenario_file, launch_file, cpu_affinity): else: use_cpus.append(cpu) - sos_vm_cpus = [] + service_vm_cpus = [] pre_launch_cpus = [] post_launch_cpus = [] - for vm_i, load_order in common.LOAD_ORDER.items(): + for vm_i, load_order in acrn_config_utilities.LOAD_ORDER.items(): if vm_i not in cpu_affinity.keys(): continue elif VM_DB[load_order]['load_type'] == "PRE_LAUNCHED_VM": @@ -339,7 +339,7 @@ def vm_cpu_affinity_check(scenario_file, launch_file, cpu_affinity): post_launch_cpus.extend(cpus) elif VM_DB[load_order]['load_type'] == "SERVICE_VM": cpus = [x for x in cpu_affinity[vm_i] if not None] - sos_vm_cpus.extend(cpus) + service_vm_cpus.extend(cpus) # duplicate cpus assign the same VM check cpus_vm_i = cpu_affinity[vm_i] @@ -350,7 +350,7 @@ def vm_cpu_affinity_check(scenario_file, launch_file, cpu_affinity): return err_dic if pre_launch_cpus: - if "SERVICE_VM" in common.LOAD_ORDER and not sos_vm_cpus: + if "SERVICE_VM" in acrn_config_utilities.LOAD_ORDER and not service_vm_cpus: key = "Service VM cpu_affinity" err_dic[key] = "Should assign CPU id for Service VM" @@ -507,7 +507,7 @@ def pci_devs_check(pci_bdf_devs, branch_tag, tag_str): :param item: vm pci_devs item in xml :return: None """ - (bdf_desc_map, bdf_vpid_map) = board_cfg_lib.get_pci_info(common.BOARD_INFO_FILE) + (bdf_desc_map, bdf_vpid_map) = board_cfg_lib.get_pci_info(acrn_config_utilities.BOARD_INFO_FILE) for id_key, pci_bdf_devs_list in pci_bdf_devs.items(): for pci_bdf_dev in pci_bdf_devs_list: if pci_bdf_dev and pci_bdf_dev not in bdf_desc_map.keys(): @@ -523,7 +523,7 @@ def get_vuart1_vmid(vm_vuart1): """ vm_id_dic = {} new_vm_id_dic = {} - for i in list(common.LOAD_ORDER.keys()): + for i in list(acrn_config_utilities.LOAD_ORDER.keys()): for key in vm_vuart1[i].keys(): if key == "target_vm_id": vm_id_dic[i] = vm_vuart1[i][key] @@ -547,13 +547,13 @@ def cpus_assignment(cpus_per_vm, index): :return: cpu assignment string """ vm_cpu_bmp = {} - if "SERVICE_VM" == common.LOAD_ORDER[index]: + if "SERVICE_VM" == acrn_config_utilities.LOAD_ORDER[index]: if index not in cpus_per_vm or cpus_per_vm[index] == [None]: sos_extend_all_cpus = board_cfg_lib.get_processor_info() pre_all_cpus = [] for vmid, cpu_list in cpus_per_vm.items(): - if vmid in common.LOAD_ORDER: - load_order = common.LOAD_ORDER[vmid] + if vmid in acrn_config_utilities.LOAD_ORDER: + load_order = acrn_config_utilities.LOAD_ORDER[vmid] load_type = '' if load_order in VM_DB: load_type = VM_DB[load_order]['load_type'] @@ -605,7 +605,7 @@ def clos_assignment(clos_per_vm, index): def avl_vuart_ui_select(scenario_info): tmp_vuart = {} - for vm_i,load_order in common.LOAD_ORDER.items(): + for vm_i,load_order in acrn_config_utilities.LOAD_ORDER.items(): if "SERVICE_VM" == VM_DB[load_order]['load_type']: key = "vm={},legacy_vuart=0,base".format(vm_i) @@ -624,7 +624,7 @@ def avl_vuart_ui_select(scenario_info): def get_first_post_vm(): i = 0 - for vm_i,load_order in common.LOAD_ORDER.items(): + for vm_i,load_order in acrn_config_utilities.LOAD_ORDER.items(): if "POST_LAUNCHED_VM" == VM_DB[load_order]['load_type']: i = vm_i break @@ -635,13 +635,13 @@ def get_first_post_vm(): def avl_pci_devs(): pci_dev_list = [] - (bdf_desc_map, bdf_vpid_map) = board_cfg_lib.get_pci_info(common.BOARD_INFO_FILE) - pci_dev_list = common.get_avl_dev_info(bdf_desc_map, PT_SUB_PCI['ethernet']) - tmp_pci_list = common.get_avl_dev_info(bdf_desc_map, PT_SUB_PCI['sata']) + (bdf_desc_map, bdf_vpid_map) = board_cfg_lib.get_pci_info(acrn_config_utilities.BOARD_INFO_FILE) + pci_dev_list = acrn_config_utilities.get_avl_dev_info(bdf_desc_map, PT_SUB_PCI['ethernet']) + tmp_pci_list = acrn_config_utilities.get_avl_dev_info(bdf_desc_map, PT_SUB_PCI['sata']) pci_dev_list.extend(tmp_pci_list) - tmp_pci_list = common.get_avl_dev_info(bdf_desc_map, PT_SUB_PCI['nvme']) + tmp_pci_list = acrn_config_utilities.get_avl_dev_info(bdf_desc_map, PT_SUB_PCI['nvme']) pci_dev_list.extend(tmp_pci_list) - tmp_pci_list = common.get_avl_dev_info(bdf_desc_map, PT_SUB_PCI['usb']) + tmp_pci_list = acrn_config_utilities.get_avl_dev_info(bdf_desc_map, PT_SUB_PCI['usb']) pci_dev_list.extend(tmp_pci_list) pci_dev_list.insert(0, '') @@ -678,7 +678,7 @@ def check_vuart(v0_vuart, v1_vuart): target_id_keys = list(vm_target_id_dic.keys()) i = 0 for vm_i,t_vm_id in vm_target_id_dic.items(): - if t_vm_id.isnumeric() and int(t_vm_id) not in common.LOAD_ORDER.keys(): + if t_vm_id.isnumeric() and int(t_vm_id) not in acrn_config_utilities.LOAD_ORDER.keys(): key = "vm:id={},legacy_vuart:id=1,target_vm_id".format(vm_i) ERR_LIST[key] = "target_vm_id which specified does not exist" @@ -760,8 +760,8 @@ def check_vuart_id_count(vm_pci_vuarts, legacy_vuart0, legacy_vuart1): if legacy_vuart_base1 != INVALID_COM_BASE: vuart_cnt += 1 - if vuart_cnt > common.MAX_VUART_NUM: - raise XmlError("enables more than {} vuarts, total number: {}".format(common.MAX_VUART_NUM, vuart_cnt)) + if vuart_cnt > acrn_config_utilities.MAX_VUART_NUM: + raise XmlError("enables more than {} vuarts, total number: {}".format(acrn_config_utilities.MAX_VUART_NUM, vuart_cnt)) def check_against_coexistence(vm_pci_vuarts, vm_legacy_vuart, legacy_vuart_idx): @@ -808,10 +808,10 @@ def get_target_vm_id(vuart, vm_id): "target_vm_id should be present and numeric: {!r}".format( target_vm_id_str)) - if target_vm_id not in common.LOAD_ORDER: + if target_vm_id not in acrn_config_utilities.LOAD_ORDER: raise XmlError( 'invalid target_vm_id: target_vm_id={!r}, vm_ids={}'.format( - target_vm_id, common.LOAD_ORDER.keys())) + target_vm_id, acrn_config_utilities.LOAD_ORDER.keys())) if target_vm_id == vm_id: raise XmlError( @@ -950,7 +950,7 @@ def is_target_vm_available(target_vm_id, vm_visited, legacy_vuart1_visited): raise TypeError('legacy_vuart1_visited should be a dict: {}, {!r}' \ .format(type(legacy_vuart1_visited), legacy_vuart1_visited)) - if target_vm_id not in common.LOAD_ORDER: + if target_vm_id not in acrn_config_utilities.LOAD_ORDER: raise TargetError("target vm {} is not present".format(target_vm_id)) if target_vm_id in vm_visited: pass @@ -1151,7 +1151,7 @@ def check_p2sb(enable_p2sb): ERR_LIST[key] = "Can only specify p2sb passthru for VM0" return - if p2sb and not VM_DB[common.LOAD_ORDER[0]]['load_type'] == "PRE_LAUNCHED_VM": + if p2sb and not VM_DB[acrn_config_utilities.LOAD_ORDER[0]]['load_type'] == "PRE_LAUNCHED_VM": ERR_LIST["vm:id=0,p2sb"] = "p2sb passthru can only be enabled for Pre-launched VM" return @@ -1176,7 +1176,7 @@ def check_pt_intx(phys_gsi, virt_gsi): ERR_LIST["pt_intx"] = "only board ehl-crb-b/generic_board is supported" return - if not VM_DB[common.LOAD_ORDER[0]]['load_type'] == "PRE_LAUNCHED_VM": + if not VM_DB[acrn_config_utilities.LOAD_ORDER[0]]['load_type'] == "PRE_LAUNCHED_VM": ERR_LIST["pt_intx"] = "pt_intx can only be specified for pre-launched VM" return @@ -1213,7 +1213,7 @@ def get_valid_ttys_for_sos_vuart(ttys_n): """ vuart0_valid = [] vuart1_valid = ['ttyS0', 'ttyS1', 'ttyS2', 'ttyS3'] - ttys_lines = board_cfg_lib.get_info(common.BOARD_INFO_FILE, "", "") + ttys_lines = board_cfg_lib.get_info(acrn_config_utilities.BOARD_INFO_FILE, "", "") if ttys_lines: vuart0_valid.clear() for tty_line in ttys_lines: @@ -1231,7 +1231,7 @@ def get_valid_ttys_for_sos_vuart(ttys_n): vuart1_valid.remove(tty) if not vuart1_valid: - common.print_yel("ttyS are fully used. ttyS0 is used for hv_console, ttyS1 is used for vuart1!", warn=True) + acrn_config_utilities.print_yel("ttyS are fully used. ttyS0 is used for hv_console, ttyS1 is used for vuart1!", warn=True) vuart1_valid = ['ttyS0', 'ttyS1', 'ttyS2', 'ttyS3'] if ttys_n in vuart1_valid: vuart1_valid.remove(ttys_n) diff --git a/misc/config_tools/scenario_config/scenario_cfg_gen.py b/misc/config_tools/scenario_config/scenario_cfg_gen.py index 188cc1e6c..ff47fb288 100755 --- a/misc/config_tools/scenario_config/scenario_cfg_gen.py +++ b/misc/config_tools/scenario_config/scenario_cfg_gen.py @@ -13,7 +13,7 @@ sys.path.append(os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', ' from scenario_item import HwInfo, VmInfo import board_cfg_lib import scenario_cfg_lib -import common +import acrn_config_utilities import hv_cfg_lib import board_defconfig from hv_item import HvInfo @@ -24,7 +24,7 @@ try: except ImportError: pass -ACRN_PATH = common.SOURCE_ROOT_DIR +ACRN_PATH = acrn_config_utilities.SOURCE_ROOT_DIR ACRN_CONFIG_DEF = ACRN_PATH + 'misc/config_tools/data/' GEN_FILE = ["vm_configurations.h", "vm_configurations.c", "pci_dev.c", ".config", "ivshmem_cfg.h", "pt_intx.c"] @@ -42,13 +42,13 @@ def get_scenario_item_values(board_info, scenario_info): hv_info = HvInfo(scenario_info) # get vm count - common.BOARD_INFO_FILE = board_info - common.SCENARIO_INFO_FILE = scenario_info - common.get_vm_num(scenario_info) - common.get_load_order() + acrn_config_utilities.BOARD_INFO_FILE = board_info + acrn_config_utilities.SCENARIO_INFO_FILE = scenario_info + acrn_config_utilities.get_vm_num(scenario_info) + acrn_config_utilities.get_load_order() # per scenario - guest_flags = copy.deepcopy(common.GUEST_FLAG) + guest_flags = copy.deepcopy(acrn_config_utilities.GUEST_FLAG) guest_flags.remove('0UL') scenario_item_values['vm,vm_type'] = scenario_cfg_lib.LOAD_VM_TYPE scenario_item_values["vm,cpu_affinity"] = hw_info.get_processor_val() @@ -100,7 +100,7 @@ def validate_scenario_schema(scenario_info): XMLSchema does not process XInclude. Use lxml to expand the schema which is feed to XMLSchema as a string. """ - xsd_doc = etree.parse(common.SCENARIO_SCHEMA_FILE) + xsd_doc = etree.parse(acrn_config_utilities.SCENARIO_SCHEMA_FILE) xsd_doc.xinclude() my_schema = xmlschema.XMLSchema11(etree.tostring(xsd_doc, encoding="unicode")) @@ -124,7 +124,7 @@ def validate_scenario_schema(scenario_info): scenario_cfg_lib.ERR_LIST[key] = element + reason def apply_data_checks(board_info, scenario_info): - xsd_doc = etree.parse(common.DATACHECK_SCHEMA_FILE) + xsd_doc = etree.parse(acrn_config_utilities.DATACHECK_SCHEMA_FILE) xsd_doc.xinclude() datachecks_schema = xmlschema.XMLSchema11(etree.tostring(xsd_doc, encoding="unicode")) @@ -160,8 +160,8 @@ def validate_scenario_setting(board_info, scenario_info): :param scenario_info: scenario file :return: return a dictionary that contains errors """ - common.BOARD_INFO_FILE = board_info - common.SCENARIO_INFO_FILE = scenario_info + acrn_config_utilities.BOARD_INFO_FILE = board_info + acrn_config_utilities.SCENARIO_INFO_FILE = scenario_info hv_info = HvInfo(scenario_info) hv_info.get_info() @@ -187,31 +187,31 @@ def main(args): """ err_dic = {} - (err_dic, params) = common.get_param(args) + (err_dic, params) = acrn_config_utilities.get_param(args) if err_dic: return err_dic # check env - err_dic = common.prepare() + err_dic = acrn_config_utilities.prepare() if err_dic: return err_dic - common.BOARD_INFO_FILE = params['--board'] - common.SCENARIO_INFO_FILE = params['--scenario'] - common.get_vm_num(params['--scenario']) - common.get_load_order() + acrn_config_utilities.BOARD_INFO_FILE = params['--board'] + acrn_config_utilities.SCENARIO_INFO_FILE = params['--scenario'] + acrn_config_utilities.get_vm_num(params['--scenario']) + acrn_config_utilities.get_load_order() # get board name - (err_dic, board_name) = common.get_board_name() + (err_dic, board_name) = acrn_config_utilities.get_board_name() # get scenario name - (err_dic, scenario) = common.get_scenario_name() + (err_dic, scenario) = acrn_config_utilities.get_scenario_name() if err_dic: return err_dic - if common.VM_COUNT > common.MAX_VM_NUM: + if acrn_config_utilities.VM_COUNT > acrn_config_utilities.MAX_VM_NUM: err_dic['vm count'] = "Number of VMs in scenario xml file should be no greater than hv/CAPACITIES/MAX_VM_NUM ! " \ - "Now this value is {}.".format(common.MAX_VM_NUM) + "Now this value is {}.".format(acrn_config_utilities.MAX_VM_NUM) return err_dic if params['--out']: @@ -223,8 +223,8 @@ def main(args): scen_output = ACRN_CONFIG_DEF + "/" + scenario + "/" scen_board = scen_output + "/" - common.mkdir(scen_board) - common.mkdir(scen_output) + acrn_config_utilities.mkdir(scen_board) + acrn_config_utilities.mkdir(scen_output) vm_config_h = scen_output + GEN_FILE[0] vm_config_c = scen_output + GEN_FILE[1] @@ -237,7 +237,7 @@ def main(args): get_scenario_item_values(params['--board'], params['--scenario']) (err_dic, scenario_items) = validate_scenario_setting(params['--board'], params['--scenario']) if err_dic: - common.print_red("Scenario xml file validation failed:", err=True) + acrn_config_utilities.print_red("Scenario xml file validation failed:", err=True) return err_dic # generate board defconfig @@ -262,7 +262,7 @@ def ui_entry_api(board_info, scenario_info, out=''): arg_list = ['scenario_cfg_gen.py', '--board', board_info, '--scenario', scenario_info, '--out', out] - err_dic = common.prepare() + err_dic = acrn_config_utilities.prepare() if err_dic: return err_dic @@ -277,5 +277,5 @@ if __name__ == '__main__': err_dic = main(ARGS) if err_dic: for err_k, err_v in err_dic.items(): - common.print_red("{}: {}".format(err_k, err_v), err=True) + acrn_config_utilities.print_red("{}: {}".format(err_k, err_v), err=True) sys.exit(1 if err_dic else 0) diff --git a/misc/config_tools/scenario_config/scenario_item.py b/misc/config_tools/scenario_config/scenario_item.py index 812368f23..cdaf554be 100644 --- a/misc/config_tools/scenario_config/scenario_item.py +++ b/misc/config_tools/scenario_config/scenario_item.py @@ -3,7 +3,7 @@ # SPDX-License-Identifier: BSD-3-Clause # -import common +import acrn_config_utilities import board_cfg_lib import scenario_cfg_lib @@ -30,7 +30,7 @@ class HwInfo: Get root devices from board info :return: root devices list """ - (self.root_dev_val, num) = common.get_rootfs(self.board_info) + (self.root_dev_val, num) = acrn_config_utilities.get_rootfs(self.board_info) return self.root_dev_val def get_ttys_val(self): @@ -86,18 +86,18 @@ class CfgOsKern: Get all items which belong to this class :return: None """ - self.kern_name = common.get_leaf_tag_map(self.scenario_info, "os_config", "name") - self.kern_type = common.get_leaf_tag_map( + self.kern_name = acrn_config_utilities.get_leaf_tag_map(self.scenario_info, "os_config", "name") + self.kern_type = acrn_config_utilities.get_leaf_tag_map( self.scenario_info, "os_config", "kern_type") - self.kern_mod = common.get_leaf_tag_map( + self.kern_mod = acrn_config_utilities.get_leaf_tag_map( self.scenario_info, "os_config", "kern_mod") - self.kern_args = common.get_leaf_tag_map( + self.kern_args = acrn_config_utilities.get_leaf_tag_map( self.scenario_info, "os_config", "bootargs") - self.kern_load_addr = common.get_leaf_tag_map( + self.kern_load_addr = acrn_config_utilities.get_leaf_tag_map( self.scenario_info, "os_config", "kern_load_addr") - self.kern_entry_addr = common.get_leaf_tag_map( + self.kern_entry_addr = acrn_config_utilities.get_leaf_tag_map( self.scenario_info, "os_config", "kern_entry_addr") - self.ramdisk_mod = common.get_leaf_tag_map( + self.ramdisk_mod = acrn_config_utilities.get_leaf_tag_map( self.scenario_info, "os_config", "ramdisk_mod") def check_item(self): @@ -130,9 +130,9 @@ class VuartInfo: Get all items which belong to this class :return: None """ - self.v0_vuart = common.get_vuart_info_id(self.scenario_info, 0) - self.v1_vuart = common.get_vuart_info_id(self.scenario_info, 1) - self.pci_vuarts = common.get_vuart_info(self.scenario_info) + self.v0_vuart = acrn_config_utilities.get_vuart_info_id(self.scenario_info, 0) + self.v1_vuart = acrn_config_utilities.get_vuart_info_id(self.scenario_info, 1) + self.pci_vuarts = acrn_config_utilities.get_vuart_info(self.scenario_info) def check_item(self): """ @@ -157,13 +157,13 @@ class MemInfo: Get all items which belong to this class :return: None """ - self.mem_start_hpa = common.get_leaf_tag_map( + self.mem_start_hpa = acrn_config_utilities.get_leaf_tag_map( self.scenario_info, "memory", "start_hpa") - self.mem_size = common.get_leaf_tag_map( + self.mem_size = acrn_config_utilities.get_leaf_tag_map( self.scenario_info, "memory", "size") - self.mem_start_hpa2 = common.get_leaf_tag_map( + self.mem_start_hpa2 = acrn_config_utilities.get_leaf_tag_map( self.scenario_info, "memory", "start_hpa2") - self.mem_size_hpa2 = common.get_leaf_tag_map( + self.mem_size_hpa2 = acrn_config_utilities.get_leaf_tag_map( self.scenario_info, "memory", "size_hpa2") def check_item(self): @@ -197,7 +197,7 @@ class CfgPci: Get pci devices items :return: None """ - pci_items = common.get_leaf_tag_map(self.scenario_info, "pci_devs", "pci_dev") + pci_items = acrn_config_utilities.get_leaf_tag_map(self.scenario_info, "pci_devs", "pci_dev") self.pci_devs = scenario_cfg_lib.get_pt_pci_devs(pci_items) @@ -224,8 +224,8 @@ class EpcSection: self.scenario_info = scenario_info def get_info(self): - self.base = common.get_leaf_tag_map(self.scenario_info, "epc_section", "base") - self.size = common.get_leaf_tag_map(self.scenario_info, "epc_section", "size") + self.base = acrn_config_utilities.get_leaf_tag_map(self.scenario_info, "epc_section", "base") + self.size = acrn_config_utilities.get_leaf_tag_map(self.scenario_info, "epc_section", "size") class ShareMem: @@ -245,7 +245,7 @@ class ShareMem: :return: """ self.raw_shmem_regions = ivshmem_regions - self.shmem_enabled = common.get_hv_item_tag(self.scenario_info, "FEATURES", "IVSHMEM", "IVSHMEM_ENABLED") + self.shmem_enabled = acrn_config_utilities.get_hv_item_tag(self.scenario_info, "FEATURES", "IVSHMEM", "IVSHMEM_ENABLED") self.shmem_regions = scenario_cfg_lib.get_shmem_regions(ivshmem_regions) self.shmem_num = scenario_cfg_lib.get_shmem_num(self.shmem_regions) @@ -255,7 +255,7 @@ class ShareMem: :return: ''' if self.shmem_enabled == 'y': - vm_type_info = common.get_leaf_tag_map(self.scenario_info, "vm_type") + vm_type_info = acrn_config_utilities.get_leaf_tag_map(self.scenario_info, "vm_type") scenario_cfg_lib.share_mem_check(self.shmem_regions, self.raw_shmem_regions, vm_type_info, "FEATURES", "IVSHMEM", "IVSHMEM_REGION") @@ -285,8 +285,8 @@ class MmioResourcesInfo: Get all items which belong to this class :return: None """ - self.p2sb = common.get_leaf_tag_map_bool(self.scenario_info, "mmio_resources", "p2sb") - self.tpm2 = common.get_leaf_tag_map_bool(self.scenario_info, "mmio_resources", "TPM2") + self.p2sb = acrn_config_utilities.get_leaf_tag_map_bool(self.scenario_info, "mmio_resources", "p2sb") + self.tpm2 = acrn_config_utilities.get_leaf_tag_map_bool(self.scenario_info, "mmio_resources", "TPM2") def check_item(self): """ @@ -309,7 +309,7 @@ class PtIntxInfo: Get all items which belong to this class :return: None """ - self.phys_gsi, self.virt_gsi = common.get_pt_intx_table(self.scenario_info) + self.phys_gsi, self.virt_gsi = acrn_config_utilities.get_pt_intx_table(self.scenario_info) def check_item(self): """ @@ -331,7 +331,7 @@ class VmInfo: def __init__(self, board_file, scenario_file): self.board_info = board_file self.scenario_info = scenario_file - common.get_vm_num(self.scenario_info) + acrn_config_utilities.get_vm_num(self.scenario_info) self.epc_section = EpcSection(self.scenario_info) self.mem_info = MemInfo(self.scenario_info) @@ -349,13 +349,13 @@ class VmInfo: Get all items which belong to this class :return: None """ - self.name = common.get_leaf_tag_map(self.scenario_info, "name") - self.load_vm= common.get_leaf_tag_map(self.scenario_info, "vm_type") - self.guest_flags = common.get_leaf_tag_map( + self.name = acrn_config_utilities.get_leaf_tag_map(self.scenario_info, "name") + self.load_vm= acrn_config_utilities.get_leaf_tag_map(self.scenario_info, "vm_type") + self.guest_flags = acrn_config_utilities.get_leaf_tag_map( self.scenario_info, "guest_flags", "guest_flag") - self.cpus_per_vm = common.get_leaf_tag_map( + self.cpus_per_vm = acrn_config_utilities.get_leaf_tag_map( self.scenario_info, "cpu_affinity", "pcpu_id") - self.clos_per_vm = common.get_leaf_tag_map( + self.clos_per_vm = acrn_config_utilities.get_leaf_tag_map( self.scenario_info, "clos", "vcpu_clos") self.epc_section.get_info() diff --git a/misc/config_tools/service_vm_config/serial_config.py b/misc/config_tools/service_vm_config/serial_config.py index 3a45eb6b7..cb902f10c 100644 --- a/misc/config_tools/service_vm_config/serial_config.py +++ b/misc/config_tools/service_vm_config/serial_config.py @@ -9,7 +9,8 @@ sys.path.append(os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', ' import argparse import lxml.etree -import common +import acrn_config_utilities +from acrn_config_utilities import get_node #vuart devices name is configured to start from /dev/ttyS8 START_VUART_DEV_NAME_NO = 8 @@ -19,19 +20,19 @@ UART_IRQ_BAUD = " irq 0 uart 16550A baud_base 115200" def find_non_standard_uart(vm, scenario_etree, allocation_etree): uart_list = [] - vmname = common.get_node("./name/text()", vm) + vmname = get_node("./name/text()", vm) connection_list0 = scenario_etree.xpath(f"//vuart_connection[endpoint/vm_name = '{vmname}']") connection_list1 = allocation_etree.xpath(f"//vuart_connection[endpoint/vm_name = '{vmname}']") for connection in (connection_list0 + connection_list1): - type = common.get_node(f"./type/text()", connection) + type = get_node(f"./type/text()", connection) if (type != "legacy") : continue - port = common.get_node(f".//endpoint[vm_name = '{vmname}']/io_port/text()", connection) + port = get_node(f".//endpoint[vm_name = '{vmname}']/io_port/text()", connection) if port not in stadard_uart_port: - target_vm_name = common.get_node(f".//endpoint[vm_name != '{vmname}']/vm_name/text()", connection) - target_vm_id = common.get_node(f"//vm[name = '{target_vm_name}']/@id", scenario_etree) + target_vm_name = get_node(f".//endpoint[vm_name != '{vmname}']/vm_name/text()", connection) + target_vm_id = get_node(f"//vm[name = '{target_vm_name}']/@id", scenario_etree) uart_list.append({"io_port" : port, "target_vm_id" : target_vm_id}) return uart_list @@ -47,7 +48,7 @@ def main(args): vm_list = scenario_etree.xpath("//vm[load_order = 'SERVICE_VM']") for vm in vm_list: vuart_list = find_non_standard_uart(vm, scenario_etree, allocation_etree) - vmname = common.get_node("./name/text()", vm) + vmname = get_node("./name/text()", vm) if len(vuart_list) != 0: with open(args.out, "w+") as config_f: for uart_start_num, vuart in enumerate(vuart_list, start=START_VUART_DEV_NAME_NO): diff --git a/misc/config_tools/static_allocators/bdf.py b/misc/config_tools/static_allocators/bdf.py index 4e7dc9b6b..d110bb12c 100644 --- a/misc/config_tools/static_allocators/bdf.py +++ b/misc/config_tools/static_allocators/bdf.py @@ -7,7 +7,8 @@ import sys, os, re sys.path.append(os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', 'library')) -import common, lib.error, lib.lib +import acrn_config_utilities, lib.error, lib.lib +from acrn_config_utilities import get_node # Constants for device name prefix IVSHMEM = "IVSHMEM" @@ -78,7 +79,7 @@ def get_devs_bdf_native(board_etree): dev_list = [] for node in nodes: address = node.get('address') - bus = int(common.get_node("../@address", node), 16) + bus = int(get_node("../@address", node), 16) dev = int(address, 16) >> 16 func = int(address, 16) & 0xffff @@ -108,18 +109,18 @@ def create_device_node(allocation_etree, vm_id, devdict): for dev in devdict: dev_name = dev bdf = devdict.get(dev) - vm_node = common.get_node(f"/acrn-config/vm[@id = '{vm_id}']", allocation_etree) + vm_node = get_node(f"/acrn-config/vm[@id = '{vm_id}']", allocation_etree) if vm_node is None: - vm_node = common.append_node("/acrn-config/vm", None, allocation_etree, id = vm_id) - dev_node = common.get_node(f"./device[@name = '{dev_name}']", vm_node) + vm_node = acrn_config_utilities.append_node("/acrn-config/vm", None, allocation_etree, id = vm_id) + dev_node = get_node(f"./device[@name = '{dev_name}']", vm_node) if dev_node is None: - dev_node = common.append_node("./device", None, vm_node, name = dev_name) - if common.get_node(f"./bus", dev_node) is None: - common.append_node(f"./bus", f"{bdf.bus:#04x}", dev_node) - if common.get_node(f"./dev", dev_node) is None: - common.append_node(f"./dev", f"{bdf.dev:#04x}", dev_node) - if common.get_node(f"./func", dev_node) is None: - common.append_node(f"./func", f"{bdf.func:#04x}", dev_node) + dev_node = acrn_config_utilities.append_node("./device", None, vm_node, name = dev_name) + if get_node(f"./bus", dev_node) is None: + acrn_config_utilities.append_node(f"./bus", f"{bdf.bus:#04x}", dev_node) + if get_node(f"./dev", dev_node) is None: + acrn_config_utilities.append_node(f"./dev", f"{bdf.dev:#04x}", dev_node) + if get_node(f"./func", dev_node) is None: + acrn_config_utilities.append_node(f"./func", f"{bdf.func:#04x}", dev_node) def create_igd_sbdf(board_etree, allocation_etree): """ @@ -127,14 +128,14 @@ def create_igd_sbdf(board_etree, allocation_etree): doesn't exist. """ bus = "0x0" - device_node = common.get_node(f"//bus[@type='pci' and @address='{bus}']/device[@address='0x20000' and vendor='0x8086' and class='0x030000']", board_etree) + device_node = get_node(f"//bus[@type='pci' and @address='{bus}']/device[@address='0x20000' and vendor='0x8086' and class='0x030000']", board_etree) if device_node is None: - common.append_node("/acrn-config/hv/MISC_CFG/IGD_SBDF", '0xFFFF', allocation_etree) + acrn_config_utilities.append_node("/acrn-config/hv/MISC_CFG/IGD_SBDF", '0xFFFF', allocation_etree) else: address = device_node.get('address') dev = int(address, 16) >> 16 func = int(address, 16) & 0xffff - common.append_node("/acrn-config/hv/MISC_CFG/IGD_SBDF", f"{(int(bus, 16) << 8) | (dev << 3) | func:#06x}", allocation_etree) + acrn_config_utilities.append_node("/acrn-config/hv/MISC_CFG/IGD_SBDF", f"{(int(bus, 16) << 8) | (dev << 3) | func:#06x}", allocation_etree) def fn(board_etree, scenario_etree, allocation_etree): create_igd_sbdf(board_etree, allocation_etree) @@ -143,7 +144,7 @@ def fn(board_etree, scenario_etree, allocation_etree): vm_id = vm_node.get('id') devdict = {} used = [] - load_order = common.get_node("./load_order/text()", vm_node) + load_order = get_node("./load_order/text()", vm_node) if load_order is not None and lib.lib.is_post_launched_vm(load_order): continue @@ -151,7 +152,7 @@ def fn(board_etree, scenario_etree, allocation_etree): native_used = get_devs_bdf_native(board_etree) passthrough_used = get_devs_bdf_passthrough(scenario_etree) used = [bdf for bdf in native_used if bdf not in passthrough_used] - if common.get_node("//@board", scenario_etree) == "tgl-rvp": + if get_node("//@board", scenario_etree) == "tgl-rvp": used.append(lib.lib.BusDevFunc(bus = 0, dev = 1, func = 0)) insert_vuart_to_dev_dict(vm_node, devdict, used) diff --git a/misc/config_tools/static_allocators/board_capability.py b/misc/config_tools/static_allocators/board_capability.py index e03528a5e..6776a0378 100644 --- a/misc/config_tools/static_allocators/board_capability.py +++ b/misc/config_tools/static_allocators/board_capability.py @@ -5,31 +5,32 @@ # SPDX-License-Identifier: BSD-3-Clause # import logging -import common +import acrn_config_utilities +from acrn_config_utilities import get_node def powerof2_roundup(value): return 0 if value == 0 else (1 << (value - 1).bit_length()) # Make sure all PT IRQs work w/ interrupt remapping or post interrupt def create_max_ir_entries(scenario_etree, allocation_etree): - pt_irq_entries = common.get_node(f"//MAX_PT_IRQ_ENTRIES/text()", scenario_etree) + pt_irq_entries = get_node(f"//MAX_PT_IRQ_ENTRIES/text()", scenario_etree) if (pt_irq_entries is not None) and (int(pt_irq_entries) > 256): ir_entries = powerof2_roundup(int(pt_irq_entries)) else: ir_entries = 256 - common.append_node("/acrn-config/hv/MAX_IR_ENTRIES", ir_entries, allocation_etree) + acrn_config_utilities.append_node("/acrn-config/hv/MAX_IR_ENTRIES", ir_entries, allocation_etree) def fn(board_etree, scenario_etree, allocation_etree): pci_bus_nums = board_etree.xpath("//bus[@type='pci']/@address") calc_pci_bus_nums = (max(map(lambda x: int(x, 16), pci_bus_nums)) + 1) - user_def_pci_bus_nums = common.get_node(f"//MAX_PCI_BUS_NUM/text()", scenario_etree) + user_def_pci_bus_nums = get_node(f"//MAX_PCI_BUS_NUM/text()", scenario_etree) if user_def_pci_bus_nums == '0': - common.append_node("/acrn-config/platform/MAX_PCI_BUS_NUM", hex(calc_pci_bus_nums), allocation_etree) + acrn_config_utilities.append_node("/acrn-config/platform/MAX_PCI_BUS_NUM", hex(calc_pci_bus_nums), allocation_etree) else: if calc_pci_bus_nums > int(user_def_pci_bus_nums): logging.error(f"MAX_PCI_BUS_NUM should be greater than {calc_pci_bus_nums}") sys.exit(1) else: - common.append_node("/acrn-config/platform/MAX_PCI_BUS_NUM", hex(int(user_def_pci_bus_nums)), allocation_etree) + acrn_config_utilities.append_node("/acrn-config/platform/MAX_PCI_BUS_NUM", hex(int(user_def_pci_bus_nums)), allocation_etree) create_max_ir_entries(scenario_etree, allocation_etree) diff --git a/misc/config_tools/static_allocators/clos.py b/misc/config_tools/static_allocators/clos.py index 83dc88fec..0e1f007b3 100644 --- a/misc/config_tools/static_allocators/clos.py +++ b/misc/config_tools/static_allocators/clos.py @@ -7,21 +7,22 @@ import sys, os sys.path.append(os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', 'library')) -import common +import acrn_config_utilities import rdt import re from collections import defaultdict from itertools import combinations from collections import namedtuple +from acrn_config_utilities import get_node def create_clos_node(scenario_etree, vm_id, index_list): - allocation_vm_node = common.get_node(f"/acrn-config/vm[@id = '{vm_id}']", scenario_etree) + allocation_vm_node = get_node(f"/acrn-config/vm[@id = '{vm_id}']", scenario_etree) if allocation_vm_node is None: - allocation_vm_node = common.append_node("/acrn-config/vm", None, scenario_etree, id = vm_id) - if common.get_node("./clos", allocation_vm_node) is None: - clos_node = common.append_node("./clos", None, allocation_vm_node) + allocation_vm_node = acrn_config_utilities.append_node("/acrn-config/vm", None, scenario_etree, id = vm_id) + if get_node("./clos", allocation_vm_node) is None: + clos_node = acrn_config_utilities.append_node("./clos", None, allocation_vm_node) for index in index_list: - common.append_node(f"./vcpu_clos", str(index), clos_node) + acrn_config_utilities.append_node(f"./vcpu_clos", str(index), clos_node) def get_clos_id(rdt_list, policy_owner): for index,rdt in enumerate(rdt_list): @@ -32,7 +33,7 @@ def get_clos_id(rdt_list, policy_owner): def alloc_clos_index(board_etree, scenario_etree, allocation_etree, mask_list): vm_node_list = scenario_etree.xpath("//vm") for vm_node in vm_node_list: - vm_name = common.get_node("./name/text()", vm_node) + vm_name = get_node("./name/text()", vm_node) vcpu_list = scenario_etree.xpath(f"//POLICY[VM = '{vm_name}']/VCPU/text()") index_list = [] for vcpu in sorted([int(x) for x in set(vcpu_list)]): @@ -41,16 +42,16 @@ def alloc_clos_index(board_etree, scenario_etree, allocation_etree, mask_list): else: index = get_clos_id(mask_list, rdt.policy_owner(vm_name, vcpu, "Unified")) index_list.append(index) - create_clos_node(allocation_etree, common.get_node("./@id", vm_node), index_list) + create_clos_node(allocation_etree, get_node("./@id", vm_node), index_list) def create_mask_list_node(board_etree, scenario_etree, allocation_etree, rdt_policy_list): - allocation_hv_node = common.get_node(f"//hv", allocation_etree) + allocation_hv_node = get_node(f"//hv", allocation_etree) if allocation_hv_node is None: - allocation_hv_node = common.append_node(f"/acrn-config/hv", None, allocation_etree) + allocation_hv_node = acrn_config_utilities.append_node(f"/acrn-config/hv", None, allocation_etree) - if common.get_node("./clos_mask[@id = l3]", allocation_hv_node) is None: - clos_mask = common.append_node("./clos_mask", None, allocation_hv_node, id="l3") - length = common.get_node(f"//cache[@level='3']/capability/capacity_mask_length/text()", board_etree) + if get_node("./clos_mask[@id = l3]", allocation_hv_node) is None: + clos_mask = acrn_config_utilities.append_node("./clos_mask", None, allocation_hv_node, id="l3") + length = get_node(f"//cache[@level='3']/capability/capacity_mask_length/text()", board_etree) if length is not None: default_l3_value = hex((1 << int(length)) - 1) else: @@ -60,22 +61,22 @@ def create_mask_list_node(board_etree, scenario_etree, allocation_etree, rdt_pol value = str(rdt_policy_list[i].l3policy.get_clos_mask()) else: value = default_l3_value - common.append_node(f"./clos", value, clos_mask) + acrn_config_utilities.append_node(f"./clos", value, clos_mask) for index,cache2 in enumerate(rdt.L2Policy.cache2_id_list): - length = common.get_node(f"//cache[@level='2' and @id = '{cache2}']/capability/capacity_mask_length/text()", board_etree) + length = get_node(f"//cache[@level='2' and @id = '{cache2}']/capability/capacity_mask_length/text()", board_etree) if length is not None: default_l2_value = hex((1 << int(length)) - 1) else: default_l2_value = "0xffff" - if common.get_node("./clos_mask[@id = '{cache2}']", allocation_hv_node) is None: - clos_mask = common.append_node("./clos_mask", None, allocation_hv_node, id=cache2) + if get_node("./clos_mask[@id = '{cache2}']", allocation_hv_node) is None: + clos_mask = acrn_config_utilities.append_node("./clos_mask", None, allocation_hv_node, id=cache2) for i in range(0, len(rdt_policy_list)): if rdt_policy_list[i].l2policy.get_clos_mask(index) is not None: value = str(rdt_policy_list[i].l2policy.get_clos_mask(index)) else: value = default_l2_value - common.append_node(f"./clos", value, clos_mask) + acrn_config_utilities.append_node(f"./clos", value, clos_mask) def fn(board_etree, scenario_etree, allocation_etree): policy_list = rdt.get_policy_list(scenario_etree) diff --git a/misc/config_tools/static_allocators/cpu_affinity.py b/misc/config_tools/static_allocators/cpu_affinity.py index 82df71a33..25686dd56 100644 --- a/misc/config_tools/static_allocators/cpu_affinity.py +++ b/misc/config_tools/static_allocators/cpu_affinity.py @@ -7,13 +7,14 @@ import sys, os sys.path.append(os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', 'library')) -import common, board_cfg_lib +import acrn_config_utilities, board_cfg_lib +from acrn_config_utilities import get_node def sos_cpu_affinity(etree): - if common.get_node("//vm[load_order = 'SERVICE_VM']", etree) is None: + if get_node("//vm[load_order = 'SERVICE_VM']", etree) is None: return None - if common.get_node("//vm[load_order = 'SERVICE_VM' and count(cpu_affinity//pcpu_id)]", etree) is not None: + if get_node("//vm[load_order = 'SERVICE_VM' and count(cpu_affinity//pcpu_id)]", etree) is not None: return None sos_extend_all_cpus = board_cfg_lib.get_processor_info() @@ -25,12 +26,12 @@ def sos_cpu_affinity(etree): def fn(board_etree, scenario_etree, allocation_etree): cpus_for_sos = sos_cpu_affinity(scenario_etree) if cpus_for_sos: - if common.get_node("//vm[load_order = 'SERVICE_VM']", scenario_etree) is not None: - vm_id = common.get_node("//vm[load_order = 'SERVICE_VM']/@id", scenario_etree) - allocation_sos_vm_node = common.get_node(f"/acrn-config/vm[@id='{vm_id}']", allocation_etree) - if allocation_sos_vm_node is None: - allocation_sos_vm_node = common.append_node("/acrn-config/vm", None, allocation_etree, id = vm_id) - if common.get_node("./load_order", allocation_sos_vm_node) is None: - common.append_node("./load_order", "SERVICE_VM", allocation_sos_vm_node) + if get_node("//vm[load_order = 'SERVICE_VM']", scenario_etree) is not None: + vm_id = get_node("//vm[load_order = 'SERVICE_VM']/@id", scenario_etree) + allocation_service_vm_node = get_node(f"/acrn-config/vm[@id='{vm_id}']", allocation_etree) + if allocation_service_vm_node is None: + allocation_service_vm_node = acrn_config_utilities.append_node("/acrn-config/vm", None, allocation_etree, id = vm_id) + if get_node("./load_order", allocation_service_vm_node) is None: + acrn_config_utilities.append_node("./load_order", "SERVICE_VM", allocation_service_vm_node) for pcpu_id in sorted([int(x) for x in cpus_for_sos]): - common.append_node("./cpu_affinity/pcpu_id", str(pcpu_id), allocation_sos_vm_node) + acrn_config_utilities.append_node("./cpu_affinity/pcpu_id", str(pcpu_id), allocation_service_vm_node) diff --git a/misc/config_tools/static_allocators/cpu_freq.py b/misc/config_tools/static_allocators/cpu_freq.py index 0ad101a86..f3f8c94fe 100644 --- a/misc/config_tools/static_allocators/cpu_freq.py +++ b/misc/config_tools/static_allocators/cpu_freq.py @@ -5,7 +5,8 @@ # SPDX-License-Identifier: BSD-3-Clause # -import common, board_cfg_lib +import acrn_config_utilities, board_cfg_lib +from acrn_config_utilities import get_node # CPU frequency dependency # Some CPU cores may share the same clock domain/group with others, which makes them always run at @@ -26,19 +27,19 @@ def get_dependency(board_etree): cpus = board_etree.xpath("//processors//thread") dep_ret = [] for cpu in cpus: - cpu_id = common.get_node("./cpu_id/text()", cpu) + cpu_id = get_node("./cpu_id/text()", cpu) psd_cpus = [cpu_id] - psd_cpus_list = common.get_node("./freqdomain_cpus/text()", cpu) + psd_cpus_list = get_node("./freqdomain_cpus/text()", cpu) if psd_cpus_list != None: psd_cpus = psd_cpus_list.split(' ') - apic_id = int(common.get_node("./apic_id/text()", cpu)[2:], base=16) + apic_id = int(get_node("./apic_id/text()", cpu)[2:], base=16) is_hybrid = (len(board_etree.xpath("//processors//capability[@id='hybrid']")) != 0) - core_type = common.get_node("./core_type/text()", cpu) + core_type = get_node("./core_type/text()", cpu) for other_cpu in cpus: - other_cpu_id = common.get_node("./cpu_id/text()", other_cpu) + other_cpu_id = get_node("./cpu_id/text()", other_cpu) if cpu_id != other_cpu_id: - other_apic_id = int(common.get_node("./apic_id/text()", other_cpu)[2:], base=16) - other_core_type = common.get_node("./core_type/text()", other_cpu) + other_apic_id = int(get_node("./apic_id/text()", other_cpu)[2:], base=16) + other_core_type = get_node("./core_type/text()", other_cpu) # threads at same core if (apic_id & ~1) == (other_apic_id & ~1): psd_cpus.append(other_cpu_id) @@ -92,11 +93,11 @@ def alloc_limits(board_etree, scenario_etree, allocation_etree): cpus = board_etree.xpath("//processors//thread") for cpu in cpus: - cpu_id = common.get_node("./cpu_id/text()", cpu) + cpu_id = get_node("./cpu_id/text()", cpu) if cpu_has_hwp: - guaranteed_performance_lvl = common.get_node("./guaranteed_performance_lvl/text()", cpu) - highest_performance_lvl = common.get_node("./highest_performance_lvl/text()", cpu) - lowest_performance_lvl = common.get_node("./lowest_performance_lvl/text()", cpu) + guaranteed_performance_lvl = get_node("./guaranteed_performance_lvl/text()", cpu) + highest_performance_lvl = get_node("./highest_performance_lvl/text()", cpu) + lowest_performance_lvl = get_node("./lowest_performance_lvl/text()", cpu) if cpu_id in rtvm_cpus: # for CPUs in RTVM, fix to base performance limit_lowest_lvl = guaranteed_performance_lvl @@ -115,11 +116,11 @@ def alloc_limits(board_etree, scenario_etree, allocation_etree): limit_highest_lvl = 0xff limit_guaranteed_lvl = 0xff - cpu_node = common.append_node(f"//hv/cpufreq/CPU", None, allocation_etree, id = cpu_id) - limit_node = common.append_node("./limits", None, cpu_node) - common.append_node("./limit_guaranteed_lvl", limit_guaranteed_lvl, limit_node) - common.append_node("./limit_highest_lvl", limit_highest_lvl, limit_node) - common.append_node("./limit_lowest_lvl", limit_lowest_lvl, limit_node) + cpu_node = acrn_config_utilities.append_node(f"//hv/cpufreq/CPU", None, allocation_etree, id = cpu_id) + limit_node = acrn_config_utilities.append_node("./limits", None, cpu_node) + acrn_config_utilities.append_node("./limit_guaranteed_lvl", limit_guaranteed_lvl, limit_node) + acrn_config_utilities.append_node("./limit_highest_lvl", limit_highest_lvl, limit_node) + acrn_config_utilities.append_node("./limit_lowest_lvl", limit_lowest_lvl, limit_node) limit_highest_pstate = 0 limit_nominal_pstate = 0 @@ -152,39 +153,39 @@ def alloc_limits(board_etree, scenario_etree, allocation_etree): limit_nominal_pstate = 0 limit_lowest_pstate = p_count -1 - common.append_node("./limit_nominal_pstate", str(limit_nominal_pstate), limit_node) - common.append_node("./limit_highest_pstate", str(limit_highest_pstate), limit_node) - common.append_node("./limit_lowest_pstate", str(limit_lowest_pstate), limit_node) + acrn_config_utilities.append_node("./limit_nominal_pstate", str(limit_nominal_pstate), limit_node) + acrn_config_utilities.append_node("./limit_highest_pstate", str(limit_highest_pstate), limit_node) + acrn_config_utilities.append_node("./limit_lowest_pstate", str(limit_lowest_pstate), limit_node) # Let CPUs in the same frequency dependency group have the same limits. So that RTVM's frequency can be fixed dep_info = get_dependency(board_etree) for alloc_cpu in allocation_etree.xpath("//cpufreq/CPU"): dependency_cpus = dep_info[int(alloc_cpu.attrib['id'])] - if common.get_node("./limits", alloc_cpu) != None: - highest_lvl = int(common.get_node(".//limit_highest_lvl/text()", alloc_cpu)) - lowest_lvl = int(common.get_node(".//limit_lowest_lvl/text()", alloc_cpu)) - highest_pstate = int(common.get_node(".//limit_highest_pstate/text()", alloc_cpu)) - lowest_pstate = int(common.get_node(".//limit_lowest_pstate/text()", alloc_cpu)) + if get_node("./limits", alloc_cpu) != None: + highest_lvl = int(get_node(".//limit_highest_lvl/text()", alloc_cpu)) + lowest_lvl = int(get_node(".//limit_lowest_lvl/text()", alloc_cpu)) + highest_pstate = int(get_node(".//limit_highest_pstate/text()", alloc_cpu)) + lowest_pstate = int(get_node(".//limit_lowest_pstate/text()", alloc_cpu)) for dep_cpu_id in dependency_cpus: - dep_highest_lvl = int(common.get_node(f"//cpufreq/CPU[@id={dep_cpu_id}]//limit_highest_lvl/text()", allocation_etree)) - dep_lowest_lvl = int(common.get_node(f"//cpufreq/CPU[@id={dep_cpu_id}]//limit_lowest_lvl/text()", allocation_etree)) + dep_highest_lvl = int(get_node(f"//cpufreq/CPU[@id={dep_cpu_id}]//limit_highest_lvl/text()", allocation_etree)) + dep_lowest_lvl = int(get_node(f"//cpufreq/CPU[@id={dep_cpu_id}]//limit_lowest_lvl/text()", allocation_etree)) if highest_lvl > dep_highest_lvl: highest_lvl = dep_highest_lvl if lowest_lvl < dep_lowest_lvl: lowest_lvl = dep_lowest_lvl - dep_highest_pstate = int(common.get_node(f"//cpufreq/CPU[@id={dep_cpu_id}]//limit_highest_pstate/text()", allocation_etree)) - dep_lowest_pstate = int(common.get_node(f"//cpufreq/CPU[@id={dep_cpu_id}]//limit_lowest_pstate/text()", allocation_etree)) + dep_highest_pstate = int(get_node(f"//cpufreq/CPU[@id={dep_cpu_id}]//limit_highest_pstate/text()", allocation_etree)) + dep_lowest_pstate = int(get_node(f"//cpufreq/CPU[@id={dep_cpu_id}]//limit_lowest_pstate/text()", allocation_etree)) if highest_pstate < dep_highest_pstate: highest_pstate = dep_highest_pstate if lowest_pstate > dep_lowest_pstate: lowest_pstate = dep_lowest_pstate - common.update_text("./limits/limit_highest_lvl", str(highest_lvl), alloc_cpu, True) - common.update_text("./limits/limit_lowest_lvl", str(lowest_lvl), alloc_cpu, True) - common.update_text("./limits/limit_highest_pstate", str(highest_pstate), alloc_cpu, True) - common.update_text("./limits/limit_lowest_pstate", str(lowest_pstate), alloc_cpu, True) + acrn_config_utilities.update_text("./limits/limit_highest_lvl", str(highest_lvl), alloc_cpu, True) + acrn_config_utilities.update_text("./limits/limit_lowest_lvl", str(lowest_lvl), alloc_cpu, True) + acrn_config_utilities.update_text("./limits/limit_highest_pstate", str(highest_pstate), alloc_cpu, True) + acrn_config_utilities.update_text("./limits/limit_lowest_pstate", str(lowest_pstate), alloc_cpu, True) def fn(board_etree, scenario_etree, allocation_etree): - common.append_node("/acrn-config/hv/cpufreq", None, allocation_etree) + acrn_config_utilities.append_node("/acrn-config/hv/cpufreq", None, allocation_etree) alloc_limits(board_etree, scenario_etree, allocation_etree) diff --git a/misc/config_tools/static_allocators/gpa.py b/misc/config_tools/static_allocators/gpa.py index 2bd212514..c546568af 100644 --- a/misc/config_tools/static_allocators/gpa.py +++ b/misc/config_tools/static_allocators/gpa.py @@ -7,8 +7,9 @@ import sys, os, re sys.path.append(os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', 'library')) -import common, lib.error, lib.lib, math +import acrn_config_utilities, lib.error, lib.lib, math from collections import namedtuple +from acrn_config_utilities import get_node # VMSIX devices list TSN_DEVS = [("0x8086", "0x4b30"), ("0x8086", "0x4b31"), ("0x8086", "0x4b32"), ("0x8086", "0x4ba0"), @@ -58,7 +59,7 @@ PRE_LAUNCHED_VM_HIGH_MEM_END = 512 * SIZE_G # Constants for ivshmem BAR0_SHEMEM_SIZE = 4 * SIZE_K BAR1_SHEMEM_SIZE = 4 * SIZE_K -BAR2_SHEMEM_ALIGNMENT = 2 * common.SIZE_M +BAR2_SHEMEM_ALIGNMENT = 2 * acrn_config_utilities.SIZE_M # Constants for pci vuart PCI_VUART_VBAR0_SIZE = 4 * SIZE_K @@ -123,10 +124,10 @@ def insert_vuart_to_dev_dict(scenario_etree, vm_id, devdict_32bits): devdict_32bits[(f"{VUART}_{vuart_id}", "bar0")] = PCI_VUART_VBAR0_SIZE devdict_32bits[(f"{VUART}_{vuart_id}", "bar1")] = PCI_VUART_VBAR1_SIZE - vm_name = common.get_node(f"//vm[@id = '{vm_id}']/name/text()", scenario_etree) + vm_name = get_node(f"//vm[@id = '{vm_id}']/name/text()", scenario_etree) communication_vuarts = scenario_etree.xpath(f"//vuart_connection[endpoint/vm_name/text() = '{vm_name}']") for vuart_id, vuart in enumerate(communication_vuarts, start=1): - connection_type = common.get_node(f"./type/text()", vuart) + connection_type = get_node(f"./type/text()", vuart) if connection_type == "pci": devdict_32bits[(f"{VUART}_{vuart_id}", "bar0")] = PCI_VUART_VBAR0_SIZE devdict_32bits[(f"{VUART}_{vuart_id}", "bar1")] = PCI_VUART_VBAR1_SIZE @@ -159,7 +160,7 @@ def insert_pt_devs_to_dev_dict(board_etree, vm_node_etree, devdict_32bits, devdi dev = int(bdf.split(":")[1].split('.')[0], 16) func = int(bdf.split(":")[1].split('.')[1], 16) bdf = lib.lib.BusDevFunc(bus=bus, dev=dev, func=func) - pt_dev_node = common.get_node(f"//bus[@type = 'pci' and @address = '{hex(bus)}']/device[@address = '{hex((dev << 16) | func)}']", board_etree) + pt_dev_node = get_node(f"//bus[@type = 'pci' and @address = '{hex(bus)}']/device[@address = '{hex((dev << 16) | func)}']", board_etree) if pt_dev_node is not None: insert_vmsix_to_dev_dict(pt_dev_node, devdict_32bits) pt_dev_resources = pt_dev_node.xpath(".//resource[@type = 'memory' and @len != '0x0' and @id and @width]") @@ -184,7 +185,7 @@ def get_pt_devs_io_port(board_etree, vm_node_etree): dev = int(bdf.split(":")[1].split('.')[0], 16) func = int(bdf.split(":")[1].split('.')[1], 16) bdf = lib.lib.BusDevFunc(bus=bus, dev=dev, func=func) - pt_dev_node = common.get_node(f"//bus[@type = 'pci' and @address = '{hex(bus)}']/device[@address = '{hex((dev << 16) | func)}']", board_etree) + pt_dev_node = get_node(f"//bus[@type = 'pci' and @address = '{hex(bus)}']/device[@address = '{hex((dev << 16) | func)}']", board_etree) if pt_dev_node is not None: pt_dev_resources = pt_dev_node.xpath(".//resource[@type = 'io_port' and @id[starts-with(., 'bar')]]") for pt_dev_resource in pt_dev_resources: @@ -200,8 +201,8 @@ def insert_vmsix_to_dev_dict(pt_dev_node, devdict): 2. Find the first unused region index for the vmsix bar. 3. Allocate an unused mmio window for this bar. """ - vendor = common.get_node("./vendor/text()", pt_dev_node) - identifier = common.get_node("./identifier/text()", pt_dev_node) + vendor = get_node("./vendor/text()", pt_dev_node) + identifier = get_node("./identifier/text()", pt_dev_node) if vendor is None or identifier is None: return @@ -222,8 +223,8 @@ def insert_vmsix_to_dev_dict(pt_dev_node, devdict): next_bar_region = unused_bar_index.pop(0) except IndexError: raise lib.error.ResourceError(f"Cannot allocate a bar index for vmsix supported device: {vendor}:{identifier}, used bar idx list: {used_bar_index}") - address = common.get_node("./@address", pt_dev_node) - bus = common.get_node(f"../@address", pt_dev_node) + address = get_node("./@address", pt_dev_node) + bus = get_node(f"../@address", pt_dev_node) if bus is not None and address is not None: bdf = lib.lib.BusDevFunc(bus=int(bus, 16), dev=int(address, 16) >> 16, func=int(address, 16) & 0xffff) dev_name = str(bdf) @@ -349,44 +350,44 @@ def create_device_node(allocation_etree, vm_id, devdict): bar_region = dev[1].split('bar')[-1] bar_base = devdict.get(dev) - vm_node = common.get_node(f"/acrn-config/vm[@id = '{vm_id}']", allocation_etree) + vm_node = get_node(f"/acrn-config/vm[@id = '{vm_id}']", allocation_etree) if vm_node is None: - vm_node = common.append_node("/acrn-config/vm", None, allocation_etree, id = vm_id) - dev_node = common.get_node(f"./device[@name = '{dev_name}']", vm_node) + vm_node = acrn_config_utilities.append_node("/acrn-config/vm", None, allocation_etree, id = vm_id) + dev_node = get_node(f"./device[@name = '{dev_name}']", vm_node) if dev_node is None: - dev_node = common.append_node("./device", None, vm_node, name = dev_name) - if common.get_node(f"./bar[@id='{bar_region}']", dev_node) is None: - common.append_node(f"./bar", hex(bar_base), dev_node, id = bar_region) + dev_node = acrn_config_utilities.append_node("./device", None, vm_node, name = dev_name) + if get_node(f"./bar[@id='{bar_region}']", dev_node) is None: + acrn_config_utilities.append_node(f"./bar", hex(bar_base), dev_node, id = bar_region) if IVSHMEM in dev_name and bar_region == '2': - common.update_text(f"./bar[@id = '2']", hex(bar_base | PREFETCHABLE_BIT | MEMORY_BAR_LOCATABLE_64BITS), dev_node, True) + acrn_config_utilities.update_text(f"./bar[@id = '2']", hex(bar_base | PREFETCHABLE_BIT | MEMORY_BAR_LOCATABLE_64BITS), dev_node, True) def create_vuart_node(allocation_etree, vm_id, devdict): for dev in devdict: vuart_id = dev[0][-1] bar_base = devdict.get(dev) - vm_node = common.get_node(f"/acrn-config/vm[@id = '{vm_id}']", allocation_etree) + vm_node = get_node(f"/acrn-config/vm[@id = '{vm_id}']", allocation_etree) if vm_node is None: - vm_node = common.append_node("/acrn-config/vm", None, allocation_etree, id = vm_id) - vuart_node = common.get_node(f"./legacy_vuart[@id = '{vuart_id}']", vm_node) + vm_node = acrn_config_utilities.append_node("/acrn-config/vm", None, allocation_etree, id = vm_id) + vuart_node = get_node(f"./legacy_vuart[@id = '{vuart_id}']", vm_node) if vuart_node is None: - vuart_node = common.append_node("./legacy_vuart", None, vm_node, id = vuart_id) - if common.get_node(f"./base", vuart_node) is None: - common.append_node(f"./base", hex(bar_base), vuart_node) + vuart_node = acrn_config_utilities.append_node("./legacy_vuart", None, vm_node, id = vuart_id) + if get_node(f"./base", vuart_node) is None: + acrn_config_utilities.append_node(f"./base", hex(bar_base), vuart_node) def create_native_pci_hole_node(allocation_etree, low_mem, high_mem): - common.append_node("/acrn-config/hv/MMIO/MMIO32_START", hex(low_mem[0].start).upper(), allocation_etree) - common.append_node("/acrn-config/hv/MMIO/MMIO32_END", hex(low_mem[-1].end + 1).upper(), allocation_etree) + acrn_config_utilities.append_node("/acrn-config/hv/MMIO/MMIO32_START", hex(low_mem[0].start).upper(), allocation_etree) + acrn_config_utilities.append_node("/acrn-config/hv/MMIO/MMIO32_END", hex(low_mem[-1].end + 1).upper(), allocation_etree) if len(high_mem): - common.append_node("/acrn-config/hv/MMIO/MMIO64_START", hex(high_mem[0].start).upper(), allocation_etree) - common.append_node("/acrn-config/hv/MMIO/MMIO64_END", hex(high_mem[-1].end + 1).upper(), allocation_etree) - common.append_node("/acrn-config/hv/MMIO/HI_MMIO_START", hex(high_mem[0].start).upper(), allocation_etree) - common.append_node("/acrn-config/hv/MMIO/HI_MMIO_END", hex(high_mem[0].end + 1).upper(), allocation_etree) + acrn_config_utilities.append_node("/acrn-config/hv/MMIO/MMIO64_START", hex(high_mem[0].start).upper(), allocation_etree) + acrn_config_utilities.append_node("/acrn-config/hv/MMIO/MMIO64_END", hex(high_mem[-1].end + 1).upper(), allocation_etree) + acrn_config_utilities.append_node("/acrn-config/hv/MMIO/HI_MMIO_START", hex(high_mem[0].start).upper(), allocation_etree) + acrn_config_utilities.append_node("/acrn-config/hv/MMIO/HI_MMIO_END", hex(high_mem[0].end + 1).upper(), allocation_etree) else: - common.append_node("/acrn-config/hv/MMIO/MMIO64_START", "~0".upper(), allocation_etree) - common.append_node("/acrn-config/hv/MMIO/MMIO64_END", "~0", allocation_etree) - common.append_node("/acrn-config/hv/MMIO/HI_MMIO_START", "~0".upper(), allocation_etree) - common.append_node("/acrn-config/hv/MMIO/HI_MMIO_END", "0", allocation_etree) + acrn_config_utilities.append_node("/acrn-config/hv/MMIO/MMIO64_START", "~0".upper(), allocation_etree) + acrn_config_utilities.append_node("/acrn-config/hv/MMIO/MMIO64_END", "~0", allocation_etree) + acrn_config_utilities.append_node("/acrn-config/hv/MMIO/HI_MMIO_START", "~0".upper(), allocation_etree) + acrn_config_utilities.append_node("/acrn-config/hv/MMIO/HI_MMIO_END", "0", allocation_etree) def get_free_addr(windowslist, used, size, alignment): if not size: @@ -396,11 +397,11 @@ def get_free_addr(windowslist, used, size, alignment): alignment = max(alignment, size) for w in windowslist: - new_w_start = common.round_up(w.start, alignment) + new_w_start = acrn_config_utilities.round_up(w.start, alignment) window = AddrWindow(start = new_w_start, end = new_w_start + size - 1) for u in used: if window.overlaps(u): - new_u_end = common.round_up(u.end + 1, alignment) + new_u_end = acrn_config_utilities.round_up(u.end + 1, alignment) window = AddrWindow(start = new_u_end, end = new_u_end + size - 1) continue if window.overlaps(w): @@ -439,7 +440,7 @@ def allocate_pci_bar(board_etree, scenario_etree, allocation_etree): used_low_mem = [] used_high_mem = [] - load_order = common.get_node("./load_order/text()", vm_node) + load_order = get_node("./load_order/text()", vm_node) if load_order is not None and lib.lib.is_pre_launched_vm(load_order): low_mem = [AddrWindow(start = PRE_LAUNCHED_VM_LOW_MEM_START, end = PRE_LAUNCHED_VM_LOW_MEM_END - 1)] high_mem = [AddrWindow(start = PRE_LAUNCHED_VM_HIGH_MEM_START, end = PRE_LAUNCHED_VM_HIGH_MEM_END - 1)] @@ -474,7 +475,7 @@ def allocate_io_port(board_etree, scenario_etree, allocation_etree): io_port_range_list = [] used_io_port_list = [] - load_order = common.get_node("./load_order/text()", vm_node) + load_order = get_node("./load_order/text()", vm_node) if load_order is not None and lib.lib.is_service_vm(load_order): io_port_range_list = io_port_range_list_native io_port_passthrough = get_pt_devs_io_port_passthrough(board_etree, scenario_etree) @@ -491,9 +492,9 @@ def allocate_io_port(board_etree, scenario_etree, allocation_etree): def allocate_ssram_region(board_etree, scenario_etree, allocation_etree): # Guest physical address of the SW SRAM allocated to a pre-launched VM ssram_area_max_size = 0 - enabled = common.get_node("//SSRAM_ENABLED/text()", scenario_etree) + enabled = get_node("//SSRAM_ENABLED/text()", scenario_etree) if enabled == "y": - pre_rt_vms = common.get_node("//vm[load_order = 'PRE_LAUNCHED_VM' and vm_type = 'RTVM']", scenario_etree) + pre_rt_vms = get_node("//vm[load_order = 'PRE_LAUNCHED_VM' and vm_type = 'RTVM']", scenario_etree) if pre_rt_vms is not None: vm_id = pre_rt_vms.get("id") l3_sw_sram = board_etree.xpath("//cache[@level='3']/capability[@id='Software SRAM']") @@ -502,32 +503,32 @@ def allocate_ssram_region(board_etree, scenario_etree, allocation_etree): top = 0 base = 0 for ssram in board_etree.xpath("//cache/capability[@id='Software SRAM']"): - entry_base = int(common.get_node("./start/text()", ssram), 16) - entry_size = int(common.get_node("./size/text()", ssram)) + entry_base = int(get_node("./start/text()", ssram), 16) + entry_size = int(get_node("./size/text()", ssram)) top = (entry_base + entry_size) if top < (entry_base + entry_size) else top base = entry_base if base == 0 or entry_base < base else base ssram_area_max_size = math.ceil((top - base)/0x1000) * 0x1000 - allocation_vm_node = common.get_node(f"/acrn-config/vm[@id = '{vm_id}']", allocation_etree) + allocation_vm_node = get_node(f"/acrn-config/vm[@id = '{vm_id}']", allocation_etree) if allocation_vm_node is None: - allocation_vm_node = common.append_node("/acrn-config/vm", None, allocation_etree, id = vm_id) - common.append_node("./ssram/start_gpa", hex(PRE_RTVM_SW_SRAM_END_GPA - ssram_area_max_size + 1), allocation_vm_node) - common.append_node("./ssram/end_gpa", hex(PRE_RTVM_SW_SRAM_END_GPA), allocation_vm_node) - common.append_node("./ssram/max_size", str(ssram_area_max_size), allocation_vm_node) + allocation_vm_node = acrn_config_utilities.append_node("/acrn-config/vm", None, allocation_etree, id = vm_id) + acrn_config_utilities.append_node("./ssram/start_gpa", hex(PRE_RTVM_SW_SRAM_END_GPA - ssram_area_max_size + 1), allocation_vm_node) + acrn_config_utilities.append_node("./ssram/end_gpa", hex(PRE_RTVM_SW_SRAM_END_GPA), allocation_vm_node) + acrn_config_utilities.append_node("./ssram/max_size", str(ssram_area_max_size), allocation_vm_node) def allocate_log_area(board_etree, scenario_etree, allocation_etree): - tpm2_enabled = common.get_node(f"//vm[@id = '0']/mmio_resources/TPM2/text()", scenario_etree) + tpm2_enabled = get_node(f"//vm[@id = '0']/mmio_resources/TPM2/text()", scenario_etree) if tpm2_enabled is None or tpm2_enabled == 'n': return - if common.get_node("//capability[@id='log_area']", board_etree) is not None: - log_area_min_len_native = int(common.get_node(f"//log_area_minimum_length/text()", board_etree), 16) - log_area_start_address = common.round_up(VIRT_ACPI_NVS_ADDR, 0x10000) + RESERVED_NVS_AREA - allocation_vm_node = common.get_node(f"/acrn-config/vm[@id = '0']", allocation_etree) + if get_node("//capability[@id='log_area']", board_etree) is not None: + log_area_min_len_native = int(get_node(f"//log_area_minimum_length/text()", board_etree), 16) + log_area_start_address = acrn_config_utilities.round_up(VIRT_ACPI_NVS_ADDR, 0x10000) + RESERVED_NVS_AREA + allocation_vm_node = get_node(f"/acrn-config/vm[@id = '0']", allocation_etree) if allocation_vm_node is None: - allocation_vm_node = common.append_node("/acrn-config/vm", None, allocation_etree, id = '0') - common.append_node("./log_area_start_address", hex(log_area_start_address).upper(), allocation_vm_node) - common.append_node("./log_area_minimum_length", hex(log_area_min_len_native).upper(), allocation_vm_node) + allocation_vm_node = acrn_config_utilities.append_node("/acrn-config/vm", None, allocation_etree, id = '0') + acrn_config_utilities.append_node("./log_area_start_address", hex(log_area_start_address).upper(), allocation_vm_node) + acrn_config_utilities.append_node("./log_area_minimum_length", hex(log_area_min_len_native).upper(), allocation_vm_node) def pt_dev_io_port_passthrough(board_etree, scenario_etree, allocation_etree): vm_nodes = scenario_etree.xpath("//vm") diff --git a/misc/config_tools/static_allocators/guest_flags.py b/misc/config_tools/static_allocators/guest_flags.py index 79cd6e5d9..97f11302d 100644 --- a/misc/config_tools/static_allocators/guest_flags.py +++ b/misc/config_tools/static_allocators/guest_flags.py @@ -7,8 +7,9 @@ import sys, os, re sys.path.append(os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', 'library')) -import common, lib.error, lib.lib +import acrn_config_utilities, lib.error, lib.lib from collections import namedtuple +from acrn_config_utilities import get_node class GuestFlagPolicy(namedtuple("GuestFlagPolycy", ["condition", "guest_flag"])): pass @@ -30,10 +31,10 @@ policies = [ def fn(board_etree, scenario_etree, allocation_etree): for vm_node in scenario_etree.xpath("//vm"): vm_id = vm_node.get('id') - allocation_vm_node = common.get_node(f"/acrn-config/vm[@id = '{vm_id}']", allocation_etree) + allocation_vm_node = get_node(f"/acrn-config/vm[@id = '{vm_id}']", allocation_etree) if allocation_vm_node is None: - allocation_vm_node = common.append_node("/acrn-config/vm", None, allocation_etree, id = vm_id) + allocation_vm_node = acrn_config_utilities.append_node("/acrn-config/vm", None, allocation_etree, id = vm_id) for policy in policies: if vm_node.xpath(policy.condition): - common.append_node("./guest_flags/guest_flag", str(policy.guest_flag), allocation_vm_node) - common.append_node("./guest_flags/guest_flag",'GUEST_FLAG_STATIC_VM', allocation_vm_node) + acrn_config_utilities.append_node("./guest_flags/guest_flag", str(policy.guest_flag), allocation_vm_node) + acrn_config_utilities.append_node("./guest_flags/guest_flag",'GUEST_FLAG_STATIC_VM', allocation_vm_node) diff --git a/misc/config_tools/static_allocators/hv_ram.py b/misc/config_tools/static_allocators/hv_ram.py index c7c509c17..604991ae8 100644 --- a/misc/config_tools/static_allocators/hv_ram.py +++ b/misc/config_tools/static_allocators/hv_ram.py @@ -7,19 +7,20 @@ import sys, os sys.path.append(os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', 'library')) -import common, board_cfg_lib, scenario_cfg_lib +import acrn_config_utilities, board_cfg_lib, scenario_cfg_lib +from acrn_config_utilities import get_node HV_RAM_SIZE_MAX = 0x40000000 -MEM_ALIGN = 2 * common.SIZE_M +MEM_ALIGN = 2 * acrn_config_utilities.SIZE_M def fn(board_etree, scenario_etree, allocation_etree): # this dictonary mapped with 'address start':'mem range' ram_range = {} - max_vm_num = int(common.get_node(f"//hv/CAPACITIES/MAX_VM_NUM/text()", scenario_etree)) + max_vm_num = int(get_node(f"//hv/CAPACITIES/MAX_VM_NUM/text()", scenario_etree)) max_trusty_vm = len(scenario_etree.xpath(f"//vm[./secure_world_support/text() = 'y']")) - hv_ram_size = common.HV_BASE_RAM_SIZE + common.VM_RAM_SIZE * max_vm_num + max_trusty_vm * common.TRUSTY_RAM_SIZE + hv_ram_size = acrn_config_utilities.HV_BASE_RAM_SIZE + acrn_config_utilities.VM_RAM_SIZE * max_vm_num + max_trusty_vm * acrn_config_utilities.TRUSTY_RAM_SIZE ivshmem_list = scenario_etree.xpath("//IVSHMEM_SIZE/text()") total_shm_size = 0 for ram_size in ivshmem_list: @@ -41,7 +42,7 @@ def fn(board_etree, scenario_etree, allocation_etree): avl_start_addr = board_cfg_lib.find_avl_memory(ram_range, str(hv_ram_size), hv_start_offset) hv_start_addr = int(avl_start_addr, 16) - hv_start_addr = common.round_up(hv_start_addr, MEM_ALIGN) + hv_start_addr = acrn_config_utilities.round_up(hv_start_addr, MEM_ALIGN) board_cfg_lib.USED_RAM_RANGE[hv_start_addr] = hv_ram_size - common.append_node("/acrn-config/hv/MEMORY/HV_RAM_START", hex(hv_start_addr), allocation_etree) - common.append_node("/acrn-config/hv/MEMORY/HV_RAM_SIZE", hex(hv_ram_size), allocation_etree) + acrn_config_utilities.append_node("/acrn-config/hv/MEMORY/HV_RAM_START", hex(hv_start_addr), allocation_etree) + acrn_config_utilities.append_node("/acrn-config/hv/MEMORY/HV_RAM_SIZE", hex(hv_ram_size), allocation_etree) diff --git a/misc/config_tools/static_allocators/intx.py b/misc/config_tools/static_allocators/intx.py index bde41b10b..7fd15d7c5 100644 --- a/misc/config_tools/static_allocators/intx.py +++ b/misc/config_tools/static_allocators/intx.py @@ -7,10 +7,11 @@ import sys, os sys.path.append(os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', 'library')) -import common, board_cfg_lib, lib.error, lib.lib +import acrn_config_utilities, board_cfg_lib, lib.error, lib.lib import re from collections import defaultdict from itertools import combinations +from acrn_config_utilities import get_node LEGACY_IRQ_MAX = 16 @@ -20,7 +21,7 @@ def get_native_valid_irq(): :return: native available irq list """ val_irq = [] - irq_info_lines = board_cfg_lib.get_info(common.BOARD_INFO_FILE, "", "") + irq_info_lines = board_cfg_lib.get_info(acrn_config_utilities.BOARD_INFO_FILE, "", "") for irq_string in irq_info_lines: val_irq = [int(x.strip()) for x in irq_string.split(',')] return val_irq @@ -48,15 +49,15 @@ def remove_irq(irq_list, irq): raise ValueError("Cannot remove irq:{} from available irq list:{}, {}". format(irq, e, irq_list)) from e def create_vuart_irq_node(etree, vm_id, load_order, vuart_id, irq): - allocation_vm_node = common.get_node(f"/acrn-config/vm[@id = '{vm_id}']", etree) + allocation_vm_node = get_node(f"/acrn-config/vm[@id = '{vm_id}']", etree) if allocation_vm_node is None: - allocation_vm_node = common.append_node("/acrn-config/vm", None, etree, id = vm_id) - if common.get_node("./load_order", allocation_vm_node) is None: - common.append_node("./load_order", load_order, allocation_vm_node) - if common.get_node(f"./legacy_vuart[@id = '{vuart_id}']", allocation_vm_node) is None: - common.append_node("./legacy_vuart", None, allocation_vm_node, id = vuart_id) + allocation_vm_node = acrn_config_utilities.append_node("/acrn-config/vm", None, etree, id = vm_id) + if get_node("./load_order", allocation_vm_node) is None: + acrn_config_utilities.append_node("./load_order", load_order, allocation_vm_node) + if get_node(f"./legacy_vuart[@id = '{vuart_id}']", allocation_vm_node) is None: + acrn_config_utilities.append_node("./legacy_vuart", None, allocation_vm_node, id = vuart_id) - common.append_node(f"./legacy_vuart[@id = '{vuart_id}']/irq", irq, allocation_vm_node) + acrn_config_utilities.append_node(f"./legacy_vuart[@id = '{vuart_id}']/irq", irq, allocation_vm_node) def alloc_vuart_connection_irqs(board_etree, scenario_etree, allocation_etree): native_ttys = lib.lib.get_native_ttys() @@ -65,7 +66,7 @@ def alloc_vuart_connection_irqs(board_etree, scenario_etree, allocation_etree): vm_node_list = scenario_etree.xpath("//vm") for vm_node in vm_node_list: - load_order = common.get_node("./load_order/text()", vm_node) + load_order = get_node("./load_order/text()", vm_node) irq_list = get_native_valid_irq() if load_order == "SERVICE_VM" else [f"{d}" for d in list(range(5,15))] if load_order == "SERVICE_VM": @@ -75,34 +76,34 @@ def alloc_vuart_connection_irqs(board_etree, scenario_etree, allocation_etree): remove_irq(irq_list, 4) vuart_id = 1 legacy_vuart_irq = "0" - vmname = common.get_node("./name/text()", vm_node) + vmname = get_node("./name/text()", vm_node) vuart_connections = scenario_etree.xpath("//vuart_connection") for connection in vuart_connections: endpoint_list = connection.xpath(".//endpoint") for endpoint in endpoint_list: - vm_name = common.get_node("./vm_name/text()", endpoint) + vm_name = get_node("./vm_name/text()", endpoint) if vm_name == vmname: - vuart_type = common.get_node("./type/text()", connection) + vuart_type = get_node("./type/text()", connection) if vuart_type == "legacy": - io_port = common.get_node("./io_port/text()", endpoint) + io_port = get_node("./io_port/text()", endpoint) legacy_vuart_irq = alloc_standard_irq(io_port) if legacy_vuart_irq == "0" and load_order != "SERVICE_VM": legacy_vuart_irq = alloc_irq(irq_list) else: legacy_vuart_irq = alloc_irq(irq_list) - create_vuart_irq_node(allocation_etree, common.get_node("./@id", vm_node), load_order, str(vuart_id), legacy_vuart_irq) + create_vuart_irq_node(allocation_etree, get_node("./@id", vm_node), load_order, str(vuart_id), legacy_vuart_irq) vuart_id = vuart_id + 1 # Allocate irq for S5 vuart, we have to use the irq of COM2 if load_order != "SERVICE_VM": legacy_vuart_irq = alloc_standard_irq("0x2F8") - create_vuart_irq_node(allocation_etree, common.get_node("./@id", vm_node), load_order, str(vuart_id), legacy_vuart_irq) + create_vuart_irq_node(allocation_etree, get_node("./@id", vm_node), load_order, str(vuart_id), legacy_vuart_irq) vuart_id = vuart_id + 1 user_vm_list = scenario_etree.xpath(f"//vm[load_order != 'SERVICE_VM']/name/text()") - service_vm_id = common.get_node(f"//vm[load_order = 'SERVICE_VM']/@id", scenario_etree) - service_vm_name = common.get_node(f"//vm[load_order = 'SERVICE_VM']/name/text()", scenario_etree) + service_vm_id = get_node(f"//vm[load_order = 'SERVICE_VM']/@id", scenario_etree) + service_vm_name = get_node(f"//vm[load_order = 'SERVICE_VM']/name/text()", scenario_etree) service_vuart_list = scenario_etree.xpath(f"//endpoint[vm_name = '{service_vm_name}']") if service_vm_id is not None: for index in range(0, len(user_vm_list)): @@ -130,7 +131,7 @@ def get_irqs_of_device(device_node): else: # Interrupts from another device index = res.get("index", "0") - irq = common.get_node(f"//device[acpi_object='{source}']/resource[@id='res{index}' and @type='irq']/@int", device_node.getroottree()) + irq = get_node(f"//device[acpi_object='{source}']/resource[@id='res{index}' and @type='irq']/@int", device_node.getroottree()) if irq is not None: irqs.add(int(irq)) @@ -152,7 +153,7 @@ def alloc_device_irqs(board_etree, scenario_etree, allocation_etree): load_order = vm.find("load_order").text vm_id = int(vm.get("id")) if lib.lib.is_pre_launched_vm(load_order): - pt_intx_text = common.get_node("pt_intx/text()", vm) + pt_intx_text = get_node("pt_intx/text()", vm) if pt_intx_text is not None: pt_intx_mapping = dict(eval(f"[{pt_intx_text.replace(')(', '), (')}]")) for irq in pt_intx_mapping.keys(): @@ -160,7 +161,7 @@ def alloc_device_irqs(board_etree, scenario_etree, allocation_etree): for pci_dev in vm.xpath("pci_devs/pci_dev/text()"): bdf = lib.lib.BusDevFunc.from_str(pci_dev.split(" ")[0]) address = hex((bdf.dev << 16) | (bdf.func)) - device_node = common.get_node(f"//bus[@address='{hex(bdf.bus)}']/device[@address='{address}']", board_etree) + device_node = get_node(f"//bus[@address='{hex(bdf.bus)}']/device[@address='{address}']", board_etree) if device_node in device_nodes: irqs = get_irqs_of_device(device_node) for irq in irqs: @@ -168,7 +169,7 @@ def alloc_device_irqs(board_etree, scenario_etree, allocation_etree): device_nodes.discard(device_node) # Raise error when any pre-launched VM with LAPIC passthrough requires any interrupt line. - lapic_passthru_flag = common.get_node("lapic_passthrough[text() = 'y']", vm) + lapic_passthru_flag = get_node("lapic_passthrough[text() = 'y']", vm) if lapic_passthru_flag is not None and irq_allocation[vm_id]: for irq, devices in irq_allocation[vm_id].items(): print(f"Interrupt line {irq} is used by the following device(s).") @@ -226,10 +227,10 @@ def alloc_device_irqs(board_etree, scenario_etree, allocation_etree): # stated in the scenario configuration. # for vm_id, alloc in irq_allocation.items(): - vm_node = common.get_node(f"/acrn-config/vm[@id = '{vm_id}']", allocation_etree) + vm_node = get_node(f"/acrn-config/vm[@id = '{vm_id}']", allocation_etree) if vm_node is None: - vm_node = common.append_node("/acrn-config/vm", None, allocation_etree, id = str(vm_id)) - pt_intx_text = common.get_node(f"//vm[@id='{vm_id}']/pt_intx/text()", scenario_etree) + vm_node = acrn_config_utilities.append_node("/acrn-config/vm", None, allocation_etree, id = str(vm_id)) + pt_intx_text = get_node(f"//vm[@id='{vm_id}']/pt_intx/text()", scenario_etree) pt_intx_mapping = dict(eval(f"[{pt_intx_text.replace(')(', '), (')}]")) if pt_intx_text is not None else {} for irq, devs in alloc.items(): for dev in devs: @@ -237,13 +238,13 @@ def alloc_device_irqs(board_etree, scenario_etree, allocation_etree): continue bdf = dev.split(" ")[0] dev_name = f"PTDEV_{bdf}" - dev_node = common.get_node(f"device[@name = '{dev_name}']", vm_node) + dev_node = get_node(f"device[@name = '{dev_name}']", vm_node) if dev_node is None: - dev_node = common.append_node("./device", None, vm_node, name = dev_name) - pt_intx_node = common.get_node(f"pt_intx", dev_node) + dev_node = acrn_config_utilities.append_node("./device", None, vm_node, name = dev_name) + pt_intx_node = get_node(f"pt_intx", dev_node) virq = pt_intx_mapping.get(irq, irq) if pt_intx_node is None: - common.append_node(f"./pt_intx", f"({irq}, {virq})", dev_node) + acrn_config_utilities.append_node(f"./pt_intx", f"({irq}, {virq})", dev_node) else: pt_intx_node.text += f" ({irq}, {virq})" diff --git a/misc/config_tools/static_allocators/lib/lib.py b/misc/config_tools/static_allocators/lib/lib.py index 4f10270b4..491242147 100644 --- a/misc/config_tools/static_allocators/lib/lib.py +++ b/misc/config_tools/static_allocators/lib/lib.py @@ -8,8 +8,9 @@ import sys, os, re sys.path.append(os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', 'library')) -import common, board_cfg_lib +import acrn_config_utilities, board_cfg_lib from collections import namedtuple +from acrn_config_utilities import get_node PRE_LAUNCHED_VMS_TYPE = ["SAFETY_VM", "PRE_RT_VM", "PRE_STD_VM"] POST_LAUNCHED_VMS_TYPE = ["POST_STD_VM", "POST_RT_VM"] @@ -60,7 +61,7 @@ def parse_hv_console(scenario_etree): 4. "None" """ ttys_n = '' - ttys = common.get_node("//SERIAL_CONSOLE/text()", scenario_etree) + ttys = get_node("//SERIAL_CONSOLE/text()", scenario_etree) if not ttys or ttys == None or ttys == 'None': return ttys_n @@ -74,7 +75,7 @@ def parse_hv_console(scenario_etree): def get_native_ttys(): native_ttys = {} - ttys_lines = board_cfg_lib.get_info(common.BOARD_INFO_FILE, "", "") + ttys_lines = board_cfg_lib.get_info(acrn_config_utilities.BOARD_INFO_FILE, "", "") if ttys_lines: for tty_line in ttys_lines: tmp_dic = {} @@ -98,18 +99,18 @@ def get_ivshmem_regions_by_tree(etree): ivshmem_regions = etree.xpath("//IVSHMEM_REGION") shmem_regions = {} for idx in range(len(ivshmem_regions)): - provided_by = common.get_node("./PROVIDED_BY/text()", ivshmem_regions[idx]) + provided_by = get_node("./PROVIDED_BY/text()", ivshmem_regions[idx]) if provided_by != "Hypervisor": continue - shm_name = common.get_node("./NAME/text()", ivshmem_regions[idx]) + shm_name = get_node("./NAME/text()", ivshmem_regions[idx]) if shm_name is None: continue - shm_size = common.get_node("./IVSHMEM_SIZE/text()", ivshmem_regions[idx]) + shm_size = get_node("./IVSHMEM_SIZE/text()", ivshmem_regions[idx]) shm_vm_list = ivshmem_regions[idx].xpath(".//IVSHMEM_VM") for shm_vm in shm_vm_list: - vm_name = common.get_node("./VM_NAME/text()", shm_vm) - vm_id = common.get_node(f"//vm[name = '{vm_name}']/@id", etree) - vbdf = common.get_node("./VBDF/text()", shm_vm) + vm_name = get_node("./VM_NAME/text()", shm_vm) + vm_id = get_node(f"//vm[name = '{vm_name}']/@id", etree) + vbdf = get_node("./VBDF/text()", shm_vm) if vm_id not in shmem_regions: shmem_regions[vm_id] = {} shmem_regions[vm_id][shm_name] = {'id' : str(idx), 'size' : shm_size, 'vbdf' : vbdf} diff --git a/misc/config_tools/static_allocators/main.py b/misc/config_tools/static_allocators/main.py index d5e1c3c56..b8732cb31 100755 --- a/misc/config_tools/static_allocators/main.py +++ b/misc/config_tools/static_allocators/main.py @@ -9,15 +9,15 @@ import sys, os import lxml.etree import argparse sys.path.append(os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', 'library')) -import common +import acrn_config_utilities from importlib import import_module def main(args): # Initialize configuration libraries for backward compatibility - common.BOARD_INFO_FILE = args.board - common.SCENARIO_INFO_FILE = args.scenario - common.get_vm_num(args.scenario) - common.get_load_order() + acrn_config_utilities.BOARD_INFO_FILE = args.board + acrn_config_utilities.SCENARIO_INFO_FILE = args.scenario + acrn_config_utilities.get_vm_num(args.scenario) + acrn_config_utilities.get_load_order() scripts_path = os.path.dirname(os.path.realpath(__file__)) current = os.path.basename(__file__) diff --git a/misc/config_tools/static_allocators/memory_allocator.py b/misc/config_tools/static_allocators/memory_allocator.py index 2e09c73c0..234578499 100644 --- a/misc/config_tools/static_allocators/memory_allocator.py +++ b/misc/config_tools/static_allocators/memory_allocator.py @@ -9,15 +9,16 @@ import os import sys import logging sys.path.append(os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', 'library')) -import common, math, logging +import acrn_config_utilities, math, logging +from acrn_config_utilities import get_node class RamRange(): ram_range = {} @classmethod def import_memory_info(cls, board_etree, allocation_etree): - hv_start = int(common.get_node("/acrn-config/hv/MEMORY/HV_RAM_START/text()", allocation_etree), 16) - hv_size = int(common.get_node("/acrn-config/hv/MEMORY/HV_RAM_SIZE/text()", allocation_etree), 16) + hv_start = int(get_node("/acrn-config/hv/MEMORY/HV_RAM_START/text()", allocation_etree), 16) + hv_size = int(get_node("/acrn-config/hv/MEMORY/HV_RAM_SIZE/text()", allocation_etree), 16) for memory_range in board_etree.xpath("/acrn-config/memory/range[not(@id) or @id = 'RAM']"): start = int(memory_range.get("start"), base=16) size = int(memory_range.get("size"), base=10) @@ -45,7 +46,7 @@ class RamRange(): size_hpa = [] hpa_info = {} - size_node = common.get_node("./memory/size", vm_node_info) + size_node = get_node("./memory/size", vm_node_info) if size_node is not None: size_byte = int(size_node.text) * 0x100000 hpa_info[0] = size_byte @@ -137,26 +138,26 @@ def write_hpa_info(allocation_etree, mem_info_list, vm_node_index_list): for i in range(len(vm_node_index_list)): vm_id = vm_node_index_list[i] hpa_info = mem_info_list[i] - vm_node = common.get_node(f"/acrn-config/vm[@id = '{vm_id}']", allocation_etree) + vm_node = get_node(f"/acrn-config/vm[@id = '{vm_id}']", allocation_etree) if vm_node is None: - vm_node = common.append_node("/acrn-config/vm", None, allocation_etree, id=vm_id) - memory_node = common.get_node("./memory", vm_node) + vm_node = acrn_config_utilities.append_node("/acrn-config/vm", None, allocation_etree, id=vm_id) + memory_node = get_node("./memory", vm_node) if memory_node is None: - memory_node = common.append_node(f"./memory", None, vm_node) + memory_node = acrn_config_utilities.append_node(f"./memory", None, vm_node) region_index = 1 start_key = sorted(hpa_info) for start_hpa in start_key: - hpa_region_node = common.get_node(f"./hpa_region[@id='{region_index}']", memory_node) + hpa_region_node = get_node(f"./hpa_region[@id='{region_index}']", memory_node) if hpa_region_node is None: - hpa_region_node = common.append_node("./hpa_region", None, memory_node, id=str(region_index).encode('UTF-8')) + hpa_region_node = acrn_config_utilities.append_node("./hpa_region", None, memory_node, id=str(region_index).encode('UTF-8')) - start_hpa_node = common.get_node("./start_hpa", hpa_region_node) + start_hpa_node = get_node("./start_hpa", hpa_region_node) if start_hpa_node is None: - common.append_node("./start_hpa", hex(start_hpa), hpa_region_node) + acrn_config_utilities.append_node("./start_hpa", hex(start_hpa), hpa_region_node) - size_hpa_node = common.get_node("./size_hpa", hpa_region_node) + size_hpa_node = get_node("./size_hpa", hpa_region_node) if size_hpa_node is None: - common.append_node("./size_hpa", hex(hpa_info[start_hpa]), hpa_region_node) + acrn_config_utilities.append_node("./size_hpa", hex(hpa_info[start_hpa]), hpa_region_node) region_index = region_index + 1 def alloc_vm_memory(board_etree, scenario_etree, allocation_etree): @@ -175,7 +176,7 @@ def allocate_hugepages(board_etree, scenario_etree, allocation_etree): post_launch_vms = scenario_etree.xpath("//vm[load_order = 'POST_LAUNCHED_VM']") if len(post_launch_vms) > 0: for post_launch_vm in post_launch_vms: - size = common.get_node("./memory/size/text()", post_launch_vm) + size = get_node("./memory/size/text()", post_launch_vm) if size is not None: mb, gb = math.modf(int(size)/1024) hugepages_1gb = int(hugepages_1gb + gb) @@ -186,10 +187,10 @@ def allocate_hugepages(board_etree, scenario_etree, allocation_etree): logging.debug(f"The sum {post_vms_memory} of memory configured in post launch VMs should not be larger than " \ f"the calculated total hugepages {total_hugepages} of service VMs. Please update the configuration in post launch VMs") - allocation_service_vm_node = common.get_node("/acrn-config/vm[load_order = 'SERVICE_VM']", allocation_etree) + allocation_service_vm_node = get_node("/acrn-config/vm[load_order = 'SERVICE_VM']", allocation_etree) if allocation_service_vm_node is not None: - common.append_node("./hugepages/gb", int(hugepages_1gb), allocation_service_vm_node) - common.append_node("./hugepages/mb", int(hugepages_2mb), allocation_service_vm_node) + acrn_config_utilities.append_node("./hugepages/gb", int(hugepages_1gb), allocation_service_vm_node) + acrn_config_utilities.append_node("./hugepages/mb", int(hugepages_2mb), allocation_service_vm_node) def fn(board_etree, scenario_etree, allocation_etree): alloc_vm_memory(board_etree, scenario_etree, allocation_etree) diff --git a/misc/config_tools/static_allocators/pio.py b/misc/config_tools/static_allocators/pio.py index c5604fe93..efc3d5480 100644 --- a/misc/config_tools/static_allocators/pio.py +++ b/misc/config_tools/static_allocators/pio.py @@ -7,7 +7,7 @@ import sys, os, logging sys.path.append(os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', 'library')) -import common, lib.lib, lib.error +import lib.lib, lib.error def fn(board_etree, scenario_etree, allocation_etree): # With the console vUART explicitly specified as COM port and communication vUART with explicit I/O port base diff --git a/misc/config_tools/static_allocators/s5_vuart.py b/misc/config_tools/static_allocators/s5_vuart.py index 4fde680cc..bc4d5dfb0 100644 --- a/misc/config_tools/static_allocators/s5_vuart.py +++ b/misc/config_tools/static_allocators/s5_vuart.py @@ -6,32 +6,33 @@ # import sys -import common, lib.error +import acrn_config_utilities, lib.error +from acrn_config_utilities import get_node # The COM1 was used for console vUART, so we alloc io_port frome COM2~COM4 service_port_list = list(range(0x9000, 0x9100, 8)) def create_s5_vuart_connection(allocation_etree, service_vm_name, service_vm_port, user_vm_name, user_vm_port): - vuart_connections_node = common.get_node(f"/acrn-config/hv/vuart_connections", allocation_etree) + vuart_connections_node = get_node(f"/acrn-config/hv/vuart_connections", allocation_etree) if vuart_connections_node is None: - vuart_connections_node = common.append_node("/acrn-config/hv/vuart_connections", None, allocation_etree) + vuart_connections_node = acrn_config_utilities.append_node("/acrn-config/hv/vuart_connections", None, allocation_etree) connection_name = service_vm_name + "_" + user_vm_name - vuart_connection_node = common.append_node(f"./vuart_connection", None, vuart_connections_node) - common.append_node(f"./name", connection_name, vuart_connection_node) - common.append_node(f"./type", "legacy", vuart_connection_node) + vuart_connection_node = acrn_config_utilities.append_node(f"./vuart_connection", None, vuart_connections_node) + acrn_config_utilities.append_node(f"./name", connection_name, vuart_connection_node) + acrn_config_utilities.append_node(f"./type", "legacy", vuart_connection_node) - service_vm_endpoint = common.append_node(f"./endpoint", None, vuart_connection_node) - common.append_node(f"./vm_name", service_vm_name, service_vm_endpoint) - common.append_node(f"./io_port", service_vm_port, service_vm_endpoint) + service_vm_endpoint = acrn_config_utilities.append_node(f"./endpoint", None, vuart_connection_node) + acrn_config_utilities.append_node(f"./vm_name", service_vm_name, service_vm_endpoint) + acrn_config_utilities.append_node(f"./io_port", service_vm_port, service_vm_endpoint) - user_vm_endpoint = common.append_node(f"./endpoint", None, vuart_connection_node) - common.append_node(f"./vm_name", user_vm_name, user_vm_endpoint) - common.append_node(f"./io_port", user_vm_port, user_vm_endpoint) + user_vm_endpoint = acrn_config_utilities.append_node(f"./endpoint", None, vuart_connection_node) + acrn_config_utilities.append_node(f"./vm_name", user_vm_name, user_vm_endpoint) + acrn_config_utilities.append_node(f"./io_port", user_vm_port, user_vm_endpoint) def get_console_vuart_port(scenario_etree, vm_name): - port = common.get_node(f"//vm[name = '{vm_name}']/console_vuart/text()", scenario_etree) + port = get_node(f"//vm[name = '{vm_name}']/console_vuart/text()", scenario_etree) if port == "COM Port 1": port = "0x3F8U" @@ -68,16 +69,16 @@ def alloc_free_port(scenario_etree, load_order, vm_name): def alloc_vuart_connection_info(board_etree, scenario_etree, allocation_etree): user_vm_list = scenario_etree.xpath(f"//vm[load_order != 'SERVICE_VM']") - service_vm_id = common.get_node(f"//vm[load_order = 'SERVICE_VM']/@id", scenario_etree) - service_vm_name = common.get_node(f"//vm[load_order = 'SERVICE_VM']/name/text()", scenario_etree) + service_vm_id = get_node(f"//vm[load_order = 'SERVICE_VM']/@id", scenario_etree) + service_vm_name = get_node(f"//vm[load_order = 'SERVICE_VM']/name/text()", scenario_etree) if (service_vm_id is None) or (service_vm_name is None): return for index,vm_node in enumerate(user_vm_list): - vm_id = common.get_node("./@id", vm_node) - load_order = common.get_node("./load_order/text()", vm_node) - user_vm_name = common.get_node(f"./name/text()", vm_node) + vm_id = get_node("./@id", vm_node) + load_order = get_node("./load_order/text()", vm_node) + user_vm_name = get_node(f"./name/text()", vm_node) service_vm_port = alloc_free_port(scenario_etree, "SERVICE_VM", user_vm_name) user_vm_port = alloc_free_port(scenario_etree, load_order, user_vm_name)