acrn-config: generate a scenario patch and apply to acrn-hypervisor

1.the script will parse the the board information which already
generated, $(scenario).xml modified by user, generate scenario
vm configuration and apply to the acrn-hypervisor source code base.

2.parse cpu/memory/ttys/rootfs information from native os and store it to
the source code

3.implemnt scenario_config and it's usage

usage: scenario_cfg_gen.py --board <board_info_file> -scenario <scenario_info_file>
board_info_file :  file name of the board info
scenario_info_file :  file name of the scenario info

sample:
	$ python3 scenario_cfg_gen.py --board ../board-xmls/apl-mrb.xml
--scenario ../config-xmls/scenarios/sdc.xml

Also improvement board config generate usage:
sample:
	$ python3 board_cfg_gen.py --board ../board-xmls/apl-mrb.xml
--scenario ../config-xmls/scenarios/sdc.xml

V1-V2:
    1). parse board_setting.xml was removed as these configuration will be
stitch into scenario configuration
    2). parse console for different formats
    3). parse epc sections
    4). add logical partition rootfs
    5). support to parse clos, while webui set to None type
    6). support to parse bootargs, while webui set to nul
    7). convert '-' to '_' for pci sub class name while generating source file

Tracked-On: #3602
Signed-off-by: Wei Liu <weix.w.liu@intel.com>
Acked-by: Terry Zou <terry.zou@intel.com>

Author: Wei Liu

misc/acrn-config/board_config/acpi_platform_h.py

@@ -14,24 +14,26 @@
 
 PLATFORM_END_HEADER = "\n#endif /* PLATFORM_ACPI_INFO_H */"
 
+
 class OverridAccessSize():
-    """The Pm access size which are needed to redefine"""
+    """ The Pm access size which are needed to redefine """
     def __init__(self):
         self.pm1a_cnt_ac_sz = True
         self.pm1b_cnt_ac_sz = True
         self.pm1b_evt_ac_sz = True
 
     def style_check_1(self):
-        """Style check if have public method"""
+        """ Style check if have public method """
         self.pm1a_cnt_ac_sz = True
 
     def style_check_2(self):
-        """Style check if have public method"""
+        """ Style check if have public method """
         self.pm1a_cnt_ac_sz = True
 
 
 def multi_parser(line, s_line, pm_ac_sz, config):
-    """Multi parser the line
+    """
+    Multi parse the line
     :param line: it is a line read from default_acpi_info.h
     :param s_line: it is a line read from board information file
     :param pm_ac_sz: it is a class for access size which would be override
@@ -76,7 +78,8 @@ def multi_parser(line, s_line, pm_ac_sz, config):
 
 
 def multi_info_parser(config, default_platform, msg_s, msg_e):
-    """Parser multi information
+    """
+    Parse multi information
     :param config: it is a file pointer to write acpi information
     :param default_platform: it is the default_acpi_info.h in acrn-hypervisor
     :param msg_s: it is a pattern of key stings what start to match from board information
@@ -109,7 +112,8 @@ def multi_info_parser(config, default_platform, msg_s, msg_e):
 
 
 def write_direct_info_parser(config, msg_s, msg_e):
-    """Direct to write
+    """
+    Direct to write
     :param config: it is a file pointer to write acpi information
     :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
@@ -123,7 +127,8 @@ def write_direct_info_parser(config, msg_s, msg_e):
 
 
 def drhd_info_parser(config):
-    """Parser DRHD information
+    """
+    Parse DRHD information
     :param config: it is a file pointer to write acpi information
     """
     prev_num = 0
@@ -149,7 +154,8 @@ def drhd_info_parser(config):
 
 
 def platform_info_parser(config, default_platform):
-    """Parser ACPI information
+    """
+    Parse ACPI information
     :param config: it is a file pointer to write acpi information
     :param default_platform: it is the default_acpi_info.h in acrn-hypervisor
     """
@@ -165,7 +171,8 @@ def platform_info_parser(config, default_platform):
 
 
 def generate_file(config, default_platform):
-    """write board_name_acpi_info.h
+    """
+    write board_name_acpi_info.h
     :param config: it is a file pointer to write acpi information
     :param default_platform: it is the default_acpi_info.h in acrn-hypervisor
     """
@@ -174,7 +181,7 @@ def generate_file(config, default_platform):
     print("{}".format(PLATFORM_HEADER), file=config)
 
     board_cfg_lib.handle_bios_info(config)
-    # parser for the platform info
+    # parse for the platform info
     platform_info_parser(config, default_platform)
 
     print("{}".format(PLATFORM_END_HEADER), file=config)

misc/acrn-config/board_config/board_c.py

@@ -7,32 +7,17 @@
 import board_cfg_lib
 
 
-def clos_info_parser():
-    """Parser CLOS information"""
-
-    cache_support = False
-    clos_max = 0
-
-    cat_lines = board_cfg_lib.get_info(
-        board_cfg_lib.BOARD_INFO_FILE, "<CLOS_INFO>", "</CLOS_INFO>")
-
-    for line in cat_lines:
-        if line.split(':')[0] == "clos supported by cache":
-            cache_support = line.split(':')[1].strip()
-        elif line.split(':')[0] == "clos max":
-            clos_max = int(line.split(':')[1])
-
-    return (cache_support, clos_max)
-
-
 def gen_cat(config):
-    """Get CAT information
+    """
+    Get CAT information
     :param config: it is a file pointer of board information for writing to
     """
-    (cache_support, clos_max) = clos_info_parser()
+    err_dic = {}
+    (cache_support, clos_max) = board_cfg_lib.clos_info_parser(board_cfg_lib.BOARD_INFO_FILE)
 
     print("\n#include <board.h>", file=config)
     print("#include <acrn_common.h>", file=config)
+    print("#include <msr.h>", file=config)
 
     if cache_support == "False" or clos_max == 0:
         print("\nstruct platform_clos_info platform_clos_array[0];", file=config)
@@ -50,9 +35,8 @@ def gen_cat(config):
             elif cache_support == "L3":
                 print("\t\t.msr_index = {0}U,".format(hex(0x00000C90+i_cnt)), file=config)
             else:
-                board_cfg_lib.print_red("The input of {} was corrupted!".format(
-                    board_cfg_lib.BOARD_INFO_FILE))
-                sys.exit(1)
+                err_dic['board config: generate board.c failed'] = "The input of {} was corrupted!".format(board_cfg_lib.BOARD_INFO_FILE)
+                return err_dic
             print("\t},", file=config)
 
         print("};\n", file=config)
@@ -61,10 +45,12 @@ def gen_cat(config):
               file=config)
 
     print("", file=config)
+    return err_dic
 
 
 def gen_px_cx(config):
-    """Get Px/Cx and store them to board.c
+    """
+    Get Px/Cx and store them to board.c
     :param config: it is a file pointer of board information for writing to
     """
     cpu_brand_lines = board_cfg_lib.get_info(
@@ -97,16 +83,22 @@ def gen_px_cx(config):
 
 
 def generate_file(config):
-    """Start to generate board.c
+    """
+    Start to generate board.c
     :param config: it is a file pointer of board information for writing to
     """
+    err_dic = {}
     print("{0}".format(board_cfg_lib.HEADER_LICENSE), file=config)
 
     # insert bios info into board.c
     board_cfg_lib.handle_bios_info(config)
 
     # start to parser to get CAT info
-    gen_cat(config)
+    err_dic = gen_cat(config)
+    if err_dic:
+        return err_dic
 
     # start to parser PX/CX info
     gen_px_cx(config)
+
+    return err_dic

misc/acrn-config/board_config/board_cfg_gen.py

@@ -6,97 +6,79 @@
 
 import os
 import sys
-import shutil
-import subprocess
+sys.path.append(os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', 'library'))
 import board_cfg_lib
 import board_c
 import pci_devices_h
 import acpi_platform_h
+import misc_cfg_h
+import ve820_c
+import new_board_kconfig
 
-ACRN_PATH = "../../../"
+ACRN_PATH = board_cfg_lib.SOURCE_ROOT_DIR
 ACRN_CONFIG = ACRN_PATH + "hypervisor/arch/x86/configs/"
 
 BOARD_NAMES = ['apl-mrb', 'apl-nuc', 'apl-up2', 'dnv-cb2', 'nuc6cayh',
                'nuc7i7dnb', 'kbl-nuc-i7', 'icl-rvp']
 
 ACRN_DEFAULT_PLATFORM = ACRN_PATH + "hypervisor/include/arch/x86/default_acpi_info.h"
-GEN_FILE = ["vm_configurations.h", "vm_configurations.c", "pt_dev.c", "pci_devices.h",
-            "board.c", "_acpi_info.h"]
+GEN_FILE = ["pci_devices.h", "board.c", "_acpi_info.h", "misc_cfg.h", "ve820.c", ".config"]
 
-PY_CACHES = ["__pycache__", "board_config/__pycache__"]
-BIN_LIST = ['git']
 
-
-def prepare():
-    """Prepare to check the environment"""
-    for excute in BIN_LIST:
-        res = subprocess.Popen("which {}".format(excute), shell=True, stdout=subprocess.PIPE,
-                               stderr=subprocess.PIPE, close_fds=True)
-
-        line = res.stdout.readline().decode('ascii')
-
-        if not line:
-            board_cfg_lib.print_yel("'{}' not found, please install it!".format(excute))
-            sys.exit(1)
-
-        if excute == "git":
-            res = subprocess.Popen("git tag -l", shell=True, stdout=subprocess.PIPE,
-                                   stderr=subprocess.PIPE, close_fds=True)
-            line = res.stdout.readline().decode("ascii")
-
-            if "acrn" not in line:
-                board_cfg_lib.print_red("Run this tool in acrn-hypervisor mainline source code!")
-                sys.exit(1)
-
-    for py_cache in PY_CACHES:
-        if os.path.exists(py_cache):
-            shutil.rmtree(py_cache)
-
-
-def gen_patch(srcs_list, board_name):
-    """Generate patch and apply to local source code
-    :param srcs_list: it is a list what contains source files
-    :param board_name: board name
+def main(args):
     """
-    changes = ' '.join(srcs_list)
-    git_add = "git add {}".format(changes)
-    subprocess.call(git_add, shell=True, stdout=subprocess.PIPE,
-                    stderr=subprocess.PIPE, close_fds=True)
-
-    # commit this changes
-    git_commit = 'git commit -sm "acrn-config: config board patch for {}"'.format(board_name)
-    subprocess.call(git_commit, shell=True, stdout=subprocess.PIPE,
-                    stderr=subprocess.PIPE, close_fds=True)
-
-
-def main(board_info_file):
-    """This is main function to start generate source code related with board
-    :param board_info_file: it is a file what contains board information for script to read from
+    This is main function to start generate source code related with board
+    :param args: it is a command line args for the script
     """
-    board = ''
+    err_dic = {}
     config_srcs = []
     config_dirs = []
 
+    (err_dic, board_info_file, scenario_info_file) = board_cfg_lib.get_param(args)
+    if err_dic:
+        return err_dic
+
+    board_cfg_lib.BOARD_INFO_FILE = board_info_file
+    board_cfg_lib.SCENARIO_INFO_FILE = scenario_info_file
+    board_cfg_lib.get_vm_count(scenario_info_file)
+
     # get board name
-    board = board_cfg_lib.get_board_name(board_info_file)
+    (err_dic, board) = board_cfg_lib.get_board_name()
+    if err_dic:
+        return err_dic
+    board_cfg_lib.BOARD_NAME = board
+
+    # check if this is the scenario config which matched board info
+    (err_dic, status) = board_cfg_lib.is_config_file_match()
+    if not status:
+        err_dic['board config: Not match'] = "The board xml and scenario xml should be matched"
+        return err_dic
 
     config_dirs.append(ACRN_CONFIG + board)
     if board not in BOARD_NAMES:
         for config_dir in config_dirs:
             if not os.path.exists(config_dir):
                 os.makedirs(config_dir)
 
-    config_pci = config_dirs[0] + '/' + GEN_FILE[3]
-    config_board = config_dirs[0] + '/' + GEN_FILE[4]
-    config_platform = config_dirs[0] + '/' + board + GEN_FILE[5]
+    config_pci = config_dirs[0] + '/' + GEN_FILE[0]
+    config_board = config_dirs[0] + '/' + GEN_FILE[1]
+    config_platform = config_dirs[0] + '/' + board + GEN_FILE[2]
+    config_misc_cfg = config_dirs[0] + '/' + GEN_FILE[3]
+    config_ve820 = config_dirs[0] + '/' + GEN_FILE[4]
+    config_board_kconfig = ACRN_CONFIG + board + GEN_FILE[5]
 
     config_srcs.append(config_pci)
     config_srcs.append(config_board)
     config_srcs.append(config_platform)
+    config_srcs.append(config_misc_cfg)
+    config_srcs.append(config_ve820)
+    config_srcs.append(config_board_kconfig)
 
     # generate board.c
     with open(config_board, 'w+') as config:
-        board_c.generate_file(config)
+        err_dic = board_c.generate_file(config)
+        if err_dic:
+            return err_dic
 
     # generate pci_devices.h
     with open(config_pci, 'w+') as config:
@@ -106,36 +88,61 @@ def main(board_info_file):
     with open(config_platform, 'w+') as config:
         acpi_platform_h.generate_file(config, ACRN_DEFAULT_PLATFORM)
 
-    # move changes to patch, and apply to the source code
-    gen_patch(config_srcs, board)
+    # generate acpi_platform.h
+    with open(config_ve820, 'w+') as config:
+        err_dic = ve820_c.generate_file(config)
+        if err_dic:
+            return err_dic
+
+    # generate acpi_platform.h
+    with open(config_misc_cfg, 'w+') as config:
+        err_dic = misc_cfg_h.generate_file(config)
+        if err_dic:
+            return err_dic
 
+    # generate new board_name.config
     if board not in BOARD_NAMES:
+        with open(config_board_kconfig, 'w+') as config:
+            err_dic = new_board_kconfig.generate_file(config)
+            if err_dic:
+                return err_dic
+
+    # move changes to patch, and apply to the source code
+    err_dic = board_cfg_lib.gen_patch(config_srcs, board)
+
+    if board not in BOARD_NAMES and not err_dic:
         print("Config patch for NEW board {} is committed successfully!".format(board))
-    else:
+    elif not err_dic:
         print("Config patch for {} is committed successfully!".format(board))
+    else:
+        print("Config patch for {} is failed".format(board))
 
+    return err_dic
 
-def usage():
-    """This is usage for how to use this tool"""
-    print("usage= [h] --board <board_info_file>'")
-    print('board_info_file, :  file name of the board info"')
-    sys.exit(1)
 
+def ui_entry_api(board_info,scenario_info):
 
-if __name__ == '__main__':
-    prepare()
+    arg_list = ['board_cfg_gen.py', '--board', board_info, '--scenario', scenario_info]
 
-    ARGS = sys.argv[1:]
+    err_dic = board_cfg_lib.prepare()
+    if err_dic:
+        return err_dic
 
-    if ARGS[0] != '--board':
-        usage()
-        sys.exit(1)
+    err_dic = main(arg_list)
+
+    return err_dic
 
-    BOARD_INFO_FILE = ARGS[1]
-    if not os.path.exists(BOARD_INFO_FILE):
-        board_cfg_lib.print_red("{} is not exist!".format(BOARD_INFO_FILE))
-        sys.exit(1)
 
-    board_cfg_lib.BOARD_INFO_FILE = BOARD_INFO_FILE
+if __name__ == '__main__':
+
+    err_dic = board_cfg_lib.prepare()
+    if err_dic:
+        for err_k, err_v in err_dic.items():
+            board_cfg_lib.print_red("{}: {}".format(err_k, err_v), err=True)
+        sys.exit(1)
 
-    main(BOARD_INFO_FILE)
+    ARGS = sys.argv
+    err_dic = main(ARGS)
+    if err_dic:
+        for err_k, err_v in err_dic.items():
+            board_cfg_lib.print_red("{}: {}".format(err_k, err_v), err=True)