312 lines
9.7 KiB
Python
312 lines
9.7 KiB
Python
# Copyright (C) 2019 Intel Corporation. All rights reserved.
|
|
#
|
|
# SPDX-License-Identifier: BSD-3-Clause
|
|
#
|
|
|
|
import scenario_cfg_lib
|
|
import board_cfg_lib
|
|
|
|
|
|
class HwInfo:
|
|
""" This is Abstract of class of Hardware information """
|
|
processor_val = []
|
|
clos_val = []
|
|
root_dev_val = []
|
|
ttys_val = []
|
|
|
|
def __init__(self, board_file):
|
|
self.board_info = board_file
|
|
|
|
def get_processor_val(self):
|
|
"""
|
|
Get cpu core list
|
|
:return: cpu processor which one cpu has
|
|
"""
|
|
self.processor_val = scenario_cfg_lib.get_processor_info(self.board_info)
|
|
return self.processor_val
|
|
|
|
def get_rootdev_val(self):
|
|
"""
|
|
Get root devices from board info
|
|
:return: root devices list
|
|
"""
|
|
self.root_dev_val = scenario_cfg_lib.get_rootdev_info(self.board_info)
|
|
return self.root_dev_val
|
|
|
|
def get_ttys_val(self):
|
|
"""
|
|
Get ttySn from board info
|
|
:return: serial console list
|
|
"""
|
|
self.ttys_val = scenario_cfg_lib.get_ttys_info(self.board_info)
|
|
return self.ttys_val
|
|
|
|
def get_clos_val(self):
|
|
"""
|
|
Get clos max number from board info
|
|
:return: clos support list
|
|
"""
|
|
self.clos_val = []
|
|
(clos_support, clos_max) = board_cfg_lib.clos_info_parser(self.board_info)
|
|
if clos_support:
|
|
for i_cnt in range(clos_max):
|
|
self.clos_val.append(str(i_cnt))
|
|
|
|
return self.clos_val
|
|
|
|
def get_info(self):
|
|
"""
|
|
Get all items which belong to this class
|
|
:return: None
|
|
"""
|
|
self.processor_val = self.get_processor_val()
|
|
self.get_rootdev_val()
|
|
self.get_ttys_val()
|
|
self.get_clos_val()
|
|
|
|
|
|
class CfgOsKern:
|
|
""" This is Abstract of class of configuration of vm os kernel setting """
|
|
kern_name = {}
|
|
kern_type = {}
|
|
kern_mod = {}
|
|
kern_args = {}
|
|
kern_console = {}
|
|
kern_load_addr = {}
|
|
kern_entry_addr = {}
|
|
kern_root_dev = {}
|
|
kern_args_append = {}
|
|
|
|
def __init__(self, scenario_file):
|
|
self.scenario_info = scenario_file
|
|
|
|
def get_info(self):
|
|
"""
|
|
Get all items which belong to this class
|
|
:return: None
|
|
"""
|
|
self.kern_name = scenario_cfg_lib.get_leaf_tag_map(self.scenario_info, "os_config", "name")
|
|
self.kern_type = scenario_cfg_lib.get_leaf_tag_map(
|
|
self.scenario_info, "os_config", "kern_type")
|
|
self.kern_mod = scenario_cfg_lib.get_leaf_tag_map(
|
|
self.scenario_info, "os_config", "kern_mod")
|
|
self.kern_args = scenario_cfg_lib.get_leaf_tag_map(
|
|
self.scenario_info, "os_config", "bootargs")
|
|
self.kern_console = scenario_cfg_lib.get_leaf_tag_map(
|
|
self.scenario_info, "os_config", "console")
|
|
self.kern_load_addr = scenario_cfg_lib.get_leaf_tag_map(
|
|
self.scenario_info, "os_config", "kern_load_addr")
|
|
self.kern_entry_addr = scenario_cfg_lib.get_leaf_tag_map(
|
|
self.scenario_info, "os_config", "kern_entry_addr")
|
|
self.kern_root_dev = scenario_cfg_lib.get_leaf_tag_map(
|
|
self.scenario_info, "os_config", "rootfs")
|
|
self.kern_args_append = scenario_cfg_lib.get_leaf_tag_map(
|
|
self.scenario_info, "boot_private", "bootargs")
|
|
|
|
def check_item(self):
|
|
"""
|
|
Check all items in this class
|
|
:return: None
|
|
"""
|
|
scenario_cfg_lib.os_kern_name_check(self.kern_name, "name")
|
|
scenario_cfg_lib.os_kern_type_check(self.kern_type, "kern_type")
|
|
scenario_cfg_lib.os_kern_mod_check(self.kern_mod, "kern_mod")
|
|
scenario_cfg_lib.os_kern_args_check(self.kern_args, "kern_args")
|
|
scenario_cfg_lib.os_kern_console_check(self.kern_console, "console")
|
|
scenario_cfg_lib.os_kern_load_addr_check(self.kern_load_addr, "kern_load_addr")
|
|
scenario_cfg_lib.os_kern_entry_addr_check(self.kern_entry_addr, "kern_entry_addr")
|
|
scenario_cfg_lib.os_kern_root_dev_check(self.kern_root_dev, "rootdev")
|
|
|
|
|
|
class VuartTarget:
|
|
""" This is Abstract of class of vm target vuart """
|
|
t_vm_id = []
|
|
t_vuart_id = []
|
|
|
|
def __init__(self):
|
|
self.t_vm_id = []
|
|
|
|
def style_check_1(self):
|
|
""" This is public method for style check"""
|
|
self.t_vm_id = []
|
|
|
|
def style_check_2(self):
|
|
""" This is public method for style check"""
|
|
self.t_vm_id = []
|
|
|
|
|
|
class VuartCfg(VuartTarget):
|
|
""" This is Abstract of class of vm vuart configuration """
|
|
v_type = []
|
|
v_base = []
|
|
v_irq = []
|
|
target = VuartTarget()
|
|
|
|
def __init__(self):
|
|
self.v1_type = []
|
|
|
|
def style_check_1(self):
|
|
""" This is public method for style check"""
|
|
self.v1_type = []
|
|
|
|
|
|
class VuartInfo:
|
|
""" This is Abstract of class of vm vuart setting """
|
|
v0_vuart = VuartCfg()
|
|
v1_vuart = VuartCfg()
|
|
|
|
def __init__(self, scenario_file):
|
|
self.scenario_info = scenario_file
|
|
|
|
def style_check_1(self):
|
|
""" This is public method for style check"""
|
|
self.v1_vuart = []
|
|
|
|
def get_info(self):
|
|
"""
|
|
Get all items which belong to this class
|
|
:return: None
|
|
"""
|
|
self.v0_vuart = scenario_cfg_lib.get_vuart_info_id(self.scenario_info, 0)
|
|
self.v1_vuart = scenario_cfg_lib.get_vuart_info_id(self.scenario_info, 1)
|
|
scenario_cfg_lib.check_board_private_info()
|
|
|
|
|
|
class MemInfo:
|
|
""" This is Abstract of class of memory setting information """
|
|
mem_start_hpa = {}
|
|
mem_size = {}
|
|
|
|
def __init__(self, scenario_file):
|
|
self.scenario_info = scenario_file
|
|
|
|
def get_info(self):
|
|
"""
|
|
Get all items which belong to this class
|
|
:return: None
|
|
"""
|
|
self.mem_start_hpa = scenario_cfg_lib.get_leaf_tag_map(
|
|
self.scenario_info, "memory", "start_hpa")
|
|
self.mem_size = scenario_cfg_lib.get_leaf_tag_map(
|
|
self.scenario_info, "memory", "size")
|
|
|
|
def check_item(self):
|
|
"""
|
|
Check all items in this class
|
|
:return: None
|
|
"""
|
|
scenario_cfg_lib.mem_start_hpa_check(self.mem_start_hpa, "start_hpa")
|
|
scenario_cfg_lib.mem_size_check(self.mem_size, "size")
|
|
|
|
|
|
class CfgPci:
|
|
""" This is Abstract of class of PCi devices setting information """
|
|
pci_dev_num = {}
|
|
pci_devs = {}
|
|
|
|
def __init__(self, scenario_file):
|
|
self.scenario_info = scenario_file
|
|
|
|
def get_pci_dev_num(self):
|
|
"""
|
|
Get pci device number items
|
|
:return: None
|
|
"""
|
|
self.pci_dev_num = scenario_cfg_lib.get_branch_tag_map(self.scenario_info, "pci_dev_num")
|
|
|
|
def get_pci_devs(self):
|
|
"""
|
|
Get pci devices items
|
|
:return: None
|
|
"""
|
|
self.pci_devs = scenario_cfg_lib.get_branch_tag_map(self.scenario_info, "pci_devs")
|
|
|
|
def get_info(self):
|
|
"""
|
|
Get all items which belong to this class
|
|
:return: None
|
|
"""
|
|
self.get_pci_dev_num()
|
|
self.get_pci_devs()
|
|
|
|
def check_item(self):
|
|
""" Check all items in this class
|
|
:return: None
|
|
"""
|
|
scenario_cfg_lib.pci_dev_num_check(self.pci_dev_num, "pci_dev_num")
|
|
scenario_cfg_lib.pci_devs_check(self.pci_devs, "pci_devs")
|
|
|
|
|
|
class EpcSection:
|
|
base = {}
|
|
size = {}
|
|
|
|
def __init__(self, scenario_info):
|
|
self.scenario_info = scenario_info
|
|
|
|
def get_info(self):
|
|
self.base = scenario_cfg_lib.get_leaf_tag_map(self.scenario_info, "epc_section", "base")
|
|
self.size = scenario_cfg_lib.get_leaf_tag_map(self.scenario_info, "epc_section", "size")
|
|
|
|
|
|
class VmInfo:
|
|
""" This is Abstract of class of VM setting """
|
|
name = {}
|
|
load_order = {}
|
|
uuid = {}
|
|
clos_set = {}
|
|
guest_flag_idx = {}
|
|
cpus_per_vm = {}
|
|
|
|
def __init__(self, board_file, scenario_file):
|
|
self.board_info = board_file
|
|
self.scenario_info = scenario_file
|
|
scenario_cfg_lib.VM_COUNT = scenario_cfg_lib.get_vm_num(self.scenario_info)
|
|
|
|
self.epc_section = EpcSection(self.scenario_info)
|
|
self.mem_info = MemInfo(self.scenario_info)
|
|
self.os_cfg = CfgOsKern(self.scenario_info)
|
|
self.vuart = VuartInfo(self.scenario_info)
|
|
self.cfg_pci = CfgPci(self.scenario_info)
|
|
|
|
def get_info(self):
|
|
"""
|
|
Get all items which belong to this class
|
|
:return: None
|
|
"""
|
|
self.name = scenario_cfg_lib.get_branch_tag_map(self.scenario_info, "name")
|
|
self.load_order = scenario_cfg_lib.get_branch_tag_map(self.scenario_info, "load_order")
|
|
self.uuid = scenario_cfg_lib.get_branch_tag_map(self.scenario_info, "uuid")
|
|
self.guest_flag_idx = scenario_cfg_lib.get_sub_leaf_tag(
|
|
self.scenario_info, "guest_flags", "guest_flag")
|
|
self.cpus_per_vm = scenario_cfg_lib.get_leaf_tag_map(
|
|
self.scenario_info, "vcpu_affinity", "pcpu_id")
|
|
self.clos_set = scenario_cfg_lib.get_branch_tag_map(self.scenario_info, "clos")
|
|
self.epc_section.get_info()
|
|
self.mem_info.get_info()
|
|
self.os_cfg.get_info()
|
|
self.vuart.get_info()
|
|
self.cfg_pci.get_info()
|
|
|
|
def get_cpu_bitmap(self, index):
|
|
"""
|
|
:param index: index list in GUESF_FLAGS
|
|
:return: cpus per vm and their vm id
|
|
"""
|
|
return scenario_cfg_lib.cpus_assignment(self.cpus_per_vm, index)
|
|
|
|
def check_item(self):
|
|
"""
|
|
Check all items in this class
|
|
:return: None
|
|
"""
|
|
scenario_cfg_lib.vm_name_check(self.name, "name")
|
|
scenario_cfg_lib.load_order_check(self.load_order, "load_order")
|
|
scenario_cfg_lib.uuid_format_check(self.uuid, "uuid")
|
|
scenario_cfg_lib.guest_flag_check(self.guest_flag_idx, "guest_flags", "guest_flag")
|
|
scenario_cfg_lib.cpus_per_vm_check(self.cpus_per_vm, "pcpu_id")
|
|
|
|
self.mem_info.check_item()
|
|
self.os_cfg.check_item()
|
|
self.cfg_pci.check_item()
|