diff --git a/misc/acrn-config/library/common.py b/misc/acrn-config/library/common.py
index 5acd680ac..765e7c3ee 100644
--- a/misc/acrn-config/library/common.py
+++ b/misc/acrn-config/library/common.py
@@ -267,7 +267,6 @@ def get_vm_num(config_file):
         if item.tag == "vm":
             vm_count += 1
     VM_COUNT = vm_count
-    return vm_count
 
 
 # TODO: This will be abandonment in future
@@ -382,7 +381,7 @@ def get_sub_value(tmp, tag_str, vm_id):
         tmp.tag[vm_id] = tmp.multi.vir_network
 
 
-def get_leaf_tag_map(config_file, branch_tag, tag_str):
+def get_leaf_tag_map(config_file, branch_tag, tag_str=''):
     """
      This is get tag value by tag_str from config file
      :param config_file: it is a file what contains information for script to read from
diff --git a/misc/acrn-config/library/scenario_cfg_lib.py b/misc/acrn-config/library/scenario_cfg_lib.py
index 06dc85cf7..9b334c7d7 100644
--- a/misc/acrn-config/library/scenario_cfg_lib.py
+++ b/misc/acrn-config/library/scenario_cfg_lib.py
@@ -6,10 +6,7 @@
 import common
 import board_cfg_lib
 
-SOURCE_ROOT_DIR = common.SOURCE_ROOT_DIR
 HEADER_LICENSE = common.open_license()
-BOARD_INFO_FILE = "board_info.txt"
-SCENARIO_INFO_FILE = ""
 
 LOAD_ORDER_TYPE = ['PRE_LAUNCHED_VM', 'SOS_VM', 'POST_LAUNCHED_VM']
 START_HPA_LIST = ['0', '0x100000000', '0x120000000']
@@ -39,7 +36,6 @@ COMMUNICATE_VM_ID = []
 
 ERR_LIST = {}
 
-VM_COUNT = 0
 DEFAULT_VM_COUNT = {
     'sdc':2,
     'sdc2':4,
@@ -49,152 +45,10 @@ DEFAULT_VM_COUNT = {
 }
 KATA_VM_COUNT = 0
 
-LEGACY_TTYS = {
-    'ttyS0':'0x3F8',
-    'ttyS1':'0x2F8',
-    'ttyS2':'0x3E8',
-    'ttyS3':'0x2E8',
-}
-
-def prepare():
-    """ Check environment """
-    return common.prepare()
-
-
-def print_yel(msg, warn=False):
-    """
-    Print the message with color of yellow
-    :param msg: the stings which will be output to STDOUT
-    :param warn: the condition if needs to be output the color of yellow with 'Warning'
-    """
-    common.print_yel(msg, warn)
-
-
-def print_red(msg, err=False):
-    """
-    Print the message with color of red
-    :param msg: the stings which will be output to STDOUT
-    :param err: the condition if needs to be output the color of red with 'Error'
-    """
-    common.print_red(msg, err)
-
-
-def usage(file_name):
-    """ This is usage for how to use this tool """
-    common.usage(file_name)
-
-
-def get_param(args):
-    """
-    Get the script parameters from command line
-    :param args: this the command line of string for the script without script name
-    """
-    return common.get_param(args)
-
-
-def get_scenario_name():
-    """
-    Get board name from scenario.xml at fist line
-    :param scenario_file: it is a file what contains scenario information for script to read from
-    """
-    return common.get_scenario_name()
-
-
-def is_config_file_match():
-
-    return common.is_config_file_match()
-
-
-def get_info(board_info, msg_s, msg_e):
-    """
-    Get information which specify by argument
-    :param board_info: it is a file what contains board information for script to read from
-    :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
-    """
-    info_lines = board_cfg_lib.get_info(board_info, msg_s, msg_e)
-    return info_lines
-
-
-def get_processor_info(board_info):
-    """
-    Get cpu core list
-    :param board_info: it is a file what contains board information for script to read from
-    :return: cpu processor which one cpu has
-    """
-    processor_list = []
-    tmp_list = []
-    processor_info = board_cfg_lib.get_info(board_info, "<CPU_PROCESSOR_INFO>", "</CPU_PROCESSOR_INFO>")
-
-    if not processor_info:
-        key = "vm:id=0,vcpu_affinity"
-        ERR_LIST[key] = "CPU core is not exists"
-        return processor_list
-
-    for processor_line in processor_info:
-        if not processor_line:
-            break
-
-        processor_list = processor_line.strip().split(',')
-        for processor in processor_list:
-            tmp_list.append(processor.strip())
-        break
-
-    return tmp_list
-
-
-def get_rootdev_info(board_info):
-    """
-    Get root devices from board info
-    :param board_info: it is a file what contains board information for script to read from
-    :return: root devices list
-    """
-    rootdev_list = []
-    rootdev_info = board_cfg_lib.get_info(board_info, "<BLOCK_DEVICE_INFO>", "</BLOCK_DEVICE_INFO>")
-
-    # none 'BLOCK_DEVICE_INFO' tag
-    if rootdev_info == None:
-        return rootdev_list
-
-    for rootdev_line in rootdev_info:
-        if not rootdev_line:
-            break
-
-        if not board_cfg_lib.handle_root_dev(rootdev_line):
-            continue
-
-        root_dev = rootdev_line.strip().split(':')[0]
-        rootdev_list.append(root_dev)
-
-    return rootdev_list
-
-
-def get_ttys_info(board_info):
-    """
-    Get ttySn from board info
-    :param board_info: it is a file what contains board information for script to read from
-    :return: serial console list
-    """
-    ttys_list = []
-    ttys_info = board_cfg_lib.get_info(board_info, "<TTYS_INFO>", "</TTYS_INFO>")
-
-    for ttys_line in ttys_info:
-        if not ttys_line:
-            break
-
-        ttys_dev = ttys_line.split()[0].split(':')[1]
-        ttysn = ttys_dev.split('/')[-1]
-        # currently SOS console can only support legacy serial port
-        if ttysn not in list(LEGACY_TTYS.keys()):
-            continue
-        ttys_list.append(ttys_dev)
-
-    return ttys_list
-
 
 def get_board_private_info(config_file):
 
-    (err_dic, scenario_name) = get_scenario_name()
+    (err_dic, scenario_name) = common.get_scenario_name()
 
     if scenario_name == "logical_partition":
         branch_tag = "os_config"
@@ -204,7 +58,7 @@ def get_board_private_info(config_file):
     private_info = {}
     dev_private_tags = ['rootfs', 'console']
     for tag_str in dev_private_tags:
-        dev_setting = get_sub_leaf_tag(config_file, branch_tag, tag_str)
+        dev_setting = common.get_sub_leaf_tag(config_file, branch_tag, tag_str)
         if not dev_setting and tag_str == "console":
             continue
 
@@ -215,33 +69,13 @@ def get_board_private_info(config_file):
 
 def check_board_private_info():
 
-    (err_dic, private_info) = get_board_private_info(SCENARIO_INFO_FILE)
+    (err_dic, private_info) = get_board_private_info(common.SCENARIO_INFO_FILE)
 
     if not private_info['rootfs'] and err_dic:
         ERR_LIST['vm:id=0,boot_private,rootfs'] = "The board have to chose one rootfs partition"
         ERR_LIST.update(err_dic)
 
 
-def get_vm_num(config_file):
-    """
-    This is get vm count
-    :param config_file:  it is a file what contains vm information for script to read from
-    :return: number of vm
-    """
-    return common.get_vm_num(config_file)
-
-
-def get_sub_leaf_tag(config_file, branch_tag, tag_str=''):
-    """
-      This is get tag value by tag_str from config file
-      :param config_file: it is a file what contains information for script to read from
-      :param branch_tag: it is key of patter to config file branch tag item
-      :param tag_str: it is key of pattern to config file leaf tag item
-      :return: value of tag_str item
-      """
-    return common.get_sub_leaf_tag(config_file, branch_tag, tag_str)
-
-
 def get_order_type_by_vmid(idx):
     """
      Get load order by vm id
@@ -249,7 +83,7 @@ def get_order_type_by_vmid(idx):
      :param idx: index of vm id
      :return: load order type of index to vmid
      """
-    (err_dic, order_type) = common.get_load_order_by_vmid(SCENARIO_INFO_FILE, VM_COUNT, idx)
+    (err_dic, order_type) = common.get_load_order_by_vmid(common.SCENARIO_INFO_FILE, common.VM_COUNT, idx)
     if err_dic:
         ERR_LIST.update(err_dic)
 
@@ -375,17 +209,6 @@ def uuid_format_check(uuid_dic, item):
             ERR_LIST[key] = "VM uuid format unknown"
 
 
-def get_leaf_tag_map(info_file, prime_item, item=''):
-    """
-    :param info_file: some configurations in the info file
-    :param prime_item: the prime item in xml file
-    :param item: the item in xml file
-    :return: dictionary which item value could be indexed by vmid
-    """
-    vmid_item_dic = common.get_leaf_tag_map(info_file, prime_item, item)
-    return vmid_item_dic
-
-
 def cpus_per_vm_check(id_cpus_per_vm_dic, item):
     """
     Check cpu number of per vm
@@ -618,7 +441,7 @@ def get_vuart1_vmid(vm_vuart1):
     :return: dictionary of vmid:vuart1
     """
     vm_id_dic = {}
-    for i in range(VM_COUNT):
+    for i in range(common.VM_COUNT):
         for key in vm_vuart1[i].keys():
             if key == "target_vm_id":
                 vm_id_dic[i] = vm_vuart1[i][key]
@@ -685,21 +508,10 @@ def clos_assignment(clos_per_vm, index):
     vm_clos_bmp['clos_map'] = clos_str
     return vm_clos_bmp
 
-def get_vuart_info_id(config_file, idx):
-    """
-    Get vuart information by vuart id indexx
-    :param config_file: it is a file what contains information for script to read from
-    :param idx: vuart index in range: [0,1]
-    :return: dictionary which stored the vuart-id
-    """
-    tmp_tag = board_cfg_lib.get_vuart_info_id(config_file, idx)
-    return tmp_tag
-
 
 def avl_vuart_ui_select(scenario_info):
-    vm_num = get_vm_num(scenario_info)
     tmp_vuart = {}
-    for vm_i in range(vm_num):
+    for vm_i in range(common.VM_COUNT):
         vm_type = get_order_type_by_vmid(vm_i)
 
         if vm_type == "SOS_VM":
@@ -718,14 +530,9 @@ def avl_vuart_ui_select(scenario_info):
 
 def get_first_post_vm():
 
-    for i in range(VM_COUNT):
-        (err_dic, vm_type) = common.get_load_order_by_vmid(SCENARIO_INFO_FILE, VM_COUNT, i)
+    for i in range(common.VM_COUNT):
+        (err_dic, vm_type) = common.get_load_order_by_vmid(common.SCENARIO_INFO_FILE, common.VM_COUNT, i)
         if vm_type == "POST_LAUNCHED_VM":
             break
 
     return (err_dic, i)
-
-
-def mkdir(path):
-
-    common.mkdir(path)
diff --git a/misc/acrn-config/scenario_config/pci_dev_c.py b/misc/acrn-config/scenario_config/pci_dev_c.py
index a204d010b..280d71662 100644
--- a/misc/acrn-config/scenario_config/pci_dev_c.py
+++ b/misc/acrn-config/scenario_config/pci_dev_c.py
@@ -3,7 +3,9 @@
 # SPDX-License-Identifier: BSD-3-Clause
 #
 
+import common
 import scenario_cfg_lib
+
 PCI_DEV_TYPE = ['PCI_DEV_TYPE_HVEMUL', 'PCI_DEV_TYPE_PTDEV']
 
 
@@ -27,7 +29,7 @@ def generate_file(config):
     print(" * The memory range of vBAR should exactly match with the e820 layout of VM.",
           file=config)
     print(" */", file=config)
-    for i in range(scenario_cfg_lib.VM_COUNT):
+    for i in range(common.VM_COUNT):
         print("", file=config)
         print("struct acrn_vm_pci_dev_config " +
               "vm{}_pci_devs[VM{}_CONFIG_PCI_DEV_NUM] = {{".format(i, i), file=config)
diff --git a/misc/acrn-config/scenario_config/scenario_cfg_gen.py b/misc/acrn-config/scenario_config/scenario_cfg_gen.py
index d8f5cd9da..4cfb56f4b 100755
--- a/misc/acrn-config/scenario_config/scenario_cfg_gen.py
+++ b/misc/acrn-config/scenario_config/scenario_cfg_gen.py
@@ -8,14 +8,15 @@ import sys
 import copy
 sys.path.append(os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', 'library'))
 from scenario_item import HwInfo, VmInfo
+import board_cfg_lib
 import scenario_cfg_lib
 import vm_configurations_c
 import vm_configurations_h
 import pci_dev_c
 import common
 
-ACRN_PATH = scenario_cfg_lib.SOURCE_ROOT_DIR
-ACRN_CONFIG_TARGET = ACRN_PATH + 'hypervisor/scenarios/'
+ACRN_PATH = common.SOURCE_ROOT_DIR
+ACRN_CONFIG_DEF = ACRN_PATH + 'hypervisor/scenarios/'
 GEN_FILE = ["vm_configurations.h", "vm_configurations.c", "pci_dev.c"]
 
 
@@ -30,9 +31,7 @@ def get_scenario_item_values(board_info, scenario_info):
     # get vm count
     common.BOARD_INFO_FILE = board_info
     common.SCENARIO_INFO_FILE = scenario_info
-    scenario_cfg_lib.SCENARIO_INFO_FILE = scenario_info
-    scenario_cfg_lib.BOARD_INFO_FILE = board_info
-    scenario_cfg_lib.VM_COUNT = scenario_cfg_lib.get_vm_num(scenario_info)
+    common.get_vm_num(scenario_info)
 
     # pre scenario
     guest_flags = copy.deepcopy(scenario_cfg_lib.GUEST_FLAG)
@@ -45,11 +44,11 @@ def get_scenario_item_values(board_info, scenario_info):
     scenario_item_values.update(scenario_cfg_lib.avl_vuart_ui_select(scenario_info))
 
     # pre board_private
-    scenario_item_values["vm,board_private,rootfs"] = scenario_cfg_lib.get_rootdev_info(board_info)
-    scenario_item_values["vm,board_private,console"] = scenario_cfg_lib.get_ttys_info(board_info)
+    scenario_item_values["vm,board_private,rootfs"] = board_cfg_lib.get_rootfs(board_info)
+    scenario_item_values["vm,board_private,console"] = board_cfg_lib.get_ttys_info(board_info)
 
     # os config
-    scenario_item_values["vm,os_config,rootfs"] = scenario_cfg_lib.get_rootdev_info(board_info)
+    scenario_item_values["vm,os_config,rootfs"] = board_cfg_lib.get_rootfs(board_info)
 
     return scenario_item_values
 
@@ -64,8 +63,6 @@ def validate_scenario_setting(board_info, scenario_info):
     scenario_cfg_lib.ERR_LIST = {}
     common.BOARD_INFO_FILE = board_info
     common.SCENARIO_INFO_FILE = scenario_info
-    scenario_cfg_lib.BOARD_INFO_FILE = board_info
-    scenario_cfg_lib.SCENARIO_INFO_FILE = scenario_info
 
     vm_info = VmInfo(board_info, scenario_info)
 
@@ -81,39 +78,39 @@ def main(args):
     This is main function to start generate source code related with board
     :param args: it is a command line args for the script
     """
-    global ACRN_CONFIG_TARGET
     err_dic = {}
 
-    (err_dic, board_info_file, scenario_info_file, output_folder) = scenario_cfg_lib.get_param(args)
+    (err_dic, board_info_file, scenario_info_file, output_folder) = common.get_param(args)
     if err_dic:
         return err_dic
 
     if output_folder:
-        ACRN_CONFIG_TARGET = os.path.abspath(output_folder) + '/'
+        common.ACRN_CONFIG_TARGET = os.path.abspath(output_folder) + '/'
 
     # check env
-    err_dic = scenario_cfg_lib.prepare()
+    err_dic = common.prepare()
     if err_dic:
         return err_dic
 
     common.BOARD_INFO_FILE = board_info_file
     common.SCENARIO_INFO_FILE = scenario_info_file
-    scenario_cfg_lib.BOARD_INFO_FILE = board_info_file
-    scenario_cfg_lib.SCENARIO_INFO_FILE = scenario_info_file
 
     # get scenario name
-    (err_dic, scenario) = scenario_cfg_lib.get_scenario_name()
+    (err_dic, scenario) = common.get_scenario_name()
     if err_dic:
         return err_dic
 
     # check if this is the scenario config which matched board info
-    (err_dic, status) = scenario_cfg_lib.is_config_file_match()
+    (err_dic, status) = common.is_config_file_match()
     if not status:
         err_dic['scenario config: Not match'] = "The board xml and scenario xml should be matched!"
         return err_dic
 
-    scenario_dir = ACRN_CONFIG_TARGET + scenario + '/'
-    scenario_cfg_lib.mkdir(scenario_dir)
+    if common.ACRN_CONFIG_TARGET:
+        scenario_dir = common.ACRN_CONFIG_TARGET + scenario + '/'
+    else:
+        scenario_dir = ACRN_CONFIG_DEF + scenario + '/'
+    common.mkdir(scenario_dir)
 
     vm_config_h = scenario_dir + GEN_FILE[0]
     vm_config_c = scenario_dir + GEN_FILE[1]
@@ -123,12 +120,12 @@ def main(args):
     get_scenario_item_values(board_info_file, scenario_info_file)
     (err_dic, vm_info) = validate_scenario_setting(board_info_file, scenario_info_file)
     if err_dic:
-        scenario_cfg_lib.print_red("Validate the scenario item failue", err=True)
+        common.print_red("Validate the scenario item failue", err=True)
         return err_dic
 
     # get kata vm count
     if scenario != "logical_partition":
-        scenario_cfg_lib.KATA_VM_COUNT = scenario_cfg_lib.VM_COUNT - scenario_cfg_lib.DEFAULT_VM_COUNT[scenario]
+        scenario_cfg_lib.KATA_VM_COUNT = common.VM_COUNT - scenario_cfg_lib.DEFAULT_VM_COUNT[scenario]
         if scenario_cfg_lib.KATA_VM_COUNT > 1:
             err_dic['scenario config: kata vm count err'] = "Only one kata vm is supported!"
             return err_dic
@@ -160,7 +157,7 @@ def ui_entry_api(board_info, scenario_info):
 
     arg_list = ['board_cfg_gen.py', '--board', board_info, '--scenario', scenario_info]
 
-    err_dic = scenario_cfg_lib.prepare()
+    err_dic = common.prepare()
     if err_dic:
         return err_dic
 
@@ -175,5 +172,5 @@ if __name__ == '__main__':
     err_dic = main(ARGS)
     if err_dic:
         for err_k, err_v in err_dic.items():
-            scenario_cfg_lib.print_red("{}: {}".format(err_k, err_v), err=True)
+            common.print_red("{}: {}".format(err_k, err_v), err=True)
 
diff --git a/misc/acrn-config/scenario_config/scenario_item.py b/misc/acrn-config/scenario_config/scenario_item.py
index c35d019a7..7c73c7d37 100644
--- a/misc/acrn-config/scenario_config/scenario_item.py
+++ b/misc/acrn-config/scenario_config/scenario_item.py
@@ -3,8 +3,9 @@
 # SPDX-License-Identifier: BSD-3-Clause
 #
 
-import scenario_cfg_lib
+import common
 import board_cfg_lib
+import scenario_cfg_lib
 
 
 class HwInfo:
@@ -22,7 +23,7 @@ class HwInfo:
         Get cpu core list
         :return: cpu processor which one cpu has
         """
-        self.processor_val = scenario_cfg_lib.get_processor_info(self.board_info)
+        self.processor_val = board_cfg_lib.get_processor_info()
         return self.processor_val
 
     def get_rootdev_val(self):
@@ -30,7 +31,7 @@ class HwInfo:
         Get root devices from board info
         :return: root devices list
         """
-        self.root_dev_val = scenario_cfg_lib.get_rootdev_info(self.board_info)
+        self.root_dev_val = common.get_rootfs(self.board_info)
         return self.root_dev_val
 
     def get_ttys_val(self):
@@ -38,7 +39,7 @@ class HwInfo:
         Get ttySn from board info
         :return: serial console list
         """
-        self.ttys_val = scenario_cfg_lib.get_ttys_info(self.board_info)
+        self.ttys_val = board_cfg_lib.get_ttys_info(self.board_info)
         return self.ttys_val
 
     def get_clos_val(self):
@@ -87,24 +88,24 @@ class CfgOsKern:
         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.kern_name = common.get_leaf_tag_map(self.scenario_info, "os_config", "name")
+        self.kern_type = common.get_leaf_tag_map(
             self.scenario_info, "os_config", "kern_type")
-        self.kern_mod = scenario_cfg_lib.get_leaf_tag_map(
+        self.kern_mod = common.get_leaf_tag_map(
             self.scenario_info, "os_config", "kern_mod")
-        self.kern_args = scenario_cfg_lib.get_leaf_tag_map(
+        self.kern_args = common.get_leaf_tag_map(
             self.scenario_info, "os_config", "bootargs")
-        self.kern_console = scenario_cfg_lib.get_leaf_tag_map(
+        self.kern_console = common.get_leaf_tag_map(
             self.scenario_info, "os_config", "console")
-        self.kern_load_addr = scenario_cfg_lib.get_leaf_tag_map(
+        self.kern_load_addr = common.get_leaf_tag_map(
             self.scenario_info, "os_config", "kern_load_addr")
-        self.kern_entry_addr = scenario_cfg_lib.get_leaf_tag_map(
+        self.kern_entry_addr = common.get_leaf_tag_map(
             self.scenario_info, "os_config", "kern_entry_addr")
-        self.kern_root_dev = scenario_cfg_lib.get_leaf_tag_map(
+        self.kern_root_dev = common.get_leaf_tag_map(
             self.scenario_info, "os_config", "rootfs")
-        self.ramdisk_mod = scenario_cfg_lib.get_leaf_tag_map(
+        self.ramdisk_mod = common.get_leaf_tag_map(
             self.scenario_info, "os_config", "ramdisk_mod")
-        self.kern_args_append = scenario_cfg_lib.get_leaf_tag_map(
+        self.kern_args_append = common.get_leaf_tag_map(
             self.scenario_info, "boot_private", "bootargs")
 
     def check_item(self):
@@ -171,8 +172,8 @@ class VuartInfo:
         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)
+        self.v0_vuart = board_cfg_lib.get_vuart_info_id(self.scenario_info, 0)
+        self.v1_vuart = board_cfg_lib.get_vuart_info_id(self.scenario_info, 1)
         scenario_cfg_lib.check_board_private_info()
 
 
@@ -191,13 +192,13 @@ class MemInfo:
         Get all items which belong to this class
         :return: None
         """
-        self.mem_start_hpa = scenario_cfg_lib.get_leaf_tag_map(
+        self.mem_start_hpa = common.get_leaf_tag_map(
             self.scenario_info, "memory", "start_hpa")
-        self.mem_size = scenario_cfg_lib.get_leaf_tag_map(
+        self.mem_size = common.get_leaf_tag_map(
             self.scenario_info, "memory", "size")
-        self.mem_start_hpa2 = scenario_cfg_lib.get_leaf_tag_map(
+        self.mem_start_hpa2 = common.get_leaf_tag_map(
             self.scenario_info, "memory", "start_hpa2")
-        self.mem_size_hpa2 = scenario_cfg_lib.get_leaf_tag_map(
+        self.mem_size_hpa2 = common.get_leaf_tag_map(
             self.scenario_info, "memory", "size_hpa2")
 
     def check_item(self):
@@ -224,14 +225,15 @@ class CfgPci:
         Get pci device number items
         :return: None
         """
-        self.pci_dev_num = scenario_cfg_lib.get_leaf_tag_map(self.scenario_info, "pci_dev_num")
+        self.pci_dev_num = common.get_leaf_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_leaf_tag_map(self.scenario_info, "pci_devs")
+        self.pci_devs = common.get_leaf_tag_map(self.scenario_info, "pci_devs")
+
 
     def get_info(self):
         """
@@ -257,8 +259,8 @@ class EpcSection:
         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")
+        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")
 
 
 class LoadOrderNum:
@@ -286,7 +288,7 @@ class VmInfo:
     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)
+        common.get_vm_num(self.scenario_info)
 
         self.epc_section = EpcSection(self.scenario_info)
         self.mem_info = MemInfo(self.scenario_info)
@@ -300,17 +302,17 @@ class VmInfo:
         Get all items which belong to this class
         :return: None
         """
-        self.name = scenario_cfg_lib.get_leaf_tag_map(self.scenario_info, "name")
-        self.load_order = scenario_cfg_lib.get_leaf_tag_map(self.scenario_info, "load_order")
-        self.uuid = scenario_cfg_lib.get_leaf_tag_map(self.scenario_info, "uuid")
-        self.guest_flag_idx = scenario_cfg_lib.get_sub_leaf_tag(
+        self.name = common.get_leaf_tag_map(self.scenario_info, "name")
+        self.load_order = common.get_leaf_tag_map(self.scenario_info, "load_order")
+        self.uuid = common.get_leaf_tag_map(self.scenario_info, "uuid")
+        self.guest_flag_idx = common.get_sub_leaf_tag(
             self.scenario_info, "guest_flags", "guest_flag")
-        self.cpus_per_vm = scenario_cfg_lib.get_leaf_tag_map(
+        self.cpus_per_vm = common.get_leaf_tag_map(
             self.scenario_info, "vcpu_affinity", "pcpu_id")
-        self.clos_per_vm = scenario_cfg_lib.get_leaf_tag_map(
+        self.clos_per_vm = common.get_leaf_tag_map(
             self.scenario_info, "clos", "vcpu_clos")
 
-        self.severity = scenario_cfg_lib.get_leaf_tag_map(self.scenario_info, "severity")
+        self.severity = common.get_leaf_tag_map(self.scenario_info, "severity")
         self.epc_section.get_info()
         self.mem_info.get_info()
         self.os_cfg.get_info()
diff --git a/misc/acrn-config/scenario_config/vm_configurations_c.py b/misc/acrn-config/scenario_config/vm_configurations_c.py
index f202cb5d7..00260ad69 100644
--- a/misc/acrn-config/scenario_config/vm_configurations_c.py
+++ b/misc/acrn-config/scenario_config/vm_configurations_c.py
@@ -4,9 +4,9 @@
 #
 
 import sys
-import scenario_cfg_lib
-import board_cfg_lib
 import common
+import board_cfg_lib
+import scenario_cfg_lib
 
 C_HEADER = scenario_cfg_lib.HEADER_LICENSE + r"""
 #include <vm_config.h>
@@ -75,7 +75,7 @@ def vuart0_output(i, vm_type, vm_info, config):
 def vuart_map_enable(vm_info):
 
     map_dic = {}
-    for i in range(scenario_cfg_lib.VM_COUNT):
+    for i in range(common.VM_COUNT):
         base_i = vm_info.vuart.v1_vuart[i]['base']
         src_t_vm_i = vm_info.vuart.v1_vuart[i]['target_vm_id']
         src_t_vuart_i = vm_info.vuart.v1_vuart[i]['target_uart_id']
@@ -196,7 +196,7 @@ def clos_output(vm_info, i, config):
     :param config: it is the pointer which file write to
     :return: None
     """
-    (rdt_res, rdt_res_clos_max, _) = board_cfg_lib.clos_info_parser(scenario_cfg_lib.BOARD_INFO_FILE)
+    (rdt_res, rdt_res_clos_max, _) = board_cfg_lib.clos_info_parser(common.BOARD_INFO_FILE)
     if len(rdt_res_clos_max) != 0:
         common_clos_max = min(rdt_res_clos_max)
     else:
@@ -468,13 +468,13 @@ def gen_logical_partition_source(vm_info, config):
     """
     err_dic = {}
     gen_source_header(config)
-    for i in range(scenario_cfg_lib.VM_COUNT):
+    for i in range(common.VM_COUNT):
         print("extern struct acrn_vm_pci_dev_config " +
               "vm{0}_pci_devs[VM{1}_CONFIG_PCI_DEV_NUM];".format(i, i), file=config)
     print("", file=config)
     print("struct acrn_vm_config vm_configs[CONFIG_MAX_VM_NUM] = {", file=config)
 
-    for i in range(scenario_cfg_lib.VM_COUNT):
+    for i in range(common.VM_COUNT):
         uuid = uuid2str(vm_info.uuid[i])
         print("\t{{\t/* VM{0} */".format(i), file=config)
         print("\t\t.load_order = {0},".format(vm_info.load_order[i]), file=config)
@@ -533,7 +533,7 @@ def gen_industry_source(vm_info, config):
     err_dic = {}
     gen_source_header(config)
     print("struct acrn_vm_config vm_configs[CONFIG_MAX_VM_NUM] = {", file=config)
-    for i in range(scenario_cfg_lib.VM_COUNT):
+    for i in range(common.VM_COUNT):
         uuid = uuid2str(vm_info.uuid[i])
         print("\t{", file=config)
         print("\t\t.load_order = {0},".format(vm_info.load_order[i]), file=config)
@@ -604,7 +604,7 @@ def gen_hybrid_source(vm_info, config):
     gen_source_header(config)
     print("struct acrn_vm_config vm_configs[CONFIG_MAX_VM_NUM] = {", file=config)
 
-    for i in range(scenario_cfg_lib.VM_COUNT):
+    for i in range(common.VM_COUNT):
         uuid = uuid2str(vm_info.uuid[i])
         print("\t{{\t/* VM{0} */".format(i), file=config)
         print("\t\t.load_order = {0},".format(vm_info.load_order[i]), file=config)
diff --git a/misc/acrn-config/scenario_config/vm_configurations_h.py b/misc/acrn-config/scenario_config/vm_configurations_h.py
index 73ccf10bf..7e0da6b96 100644
--- a/misc/acrn-config/scenario_config/vm_configurations_h.py
+++ b/misc/acrn-config/scenario_config/vm_configurations_h.py
@@ -3,6 +3,7 @@
 # SPDX-License-Identifier: BSD-3-Clause
 #
 
+import common
 import scenario_cfg_lib
 import board_cfg_lib
 
@@ -43,7 +44,7 @@ def clos_config_output(vm_info, i, config):
     :param i: the index of vm id
     :param config: file pointor to store the information
     """
-    (rdt_res, rdt_res_clos_max, _) = board_cfg_lib.clos_info_parser(scenario_cfg_lib.BOARD_INFO_FILE)
+    (rdt_res, rdt_res_clos_max, _) = board_cfg_lib.clos_info_parser(common.BOARD_INFO_FILE)
     if len(rdt_res_clos_max) != 0:
         common_clos_max = min(rdt_res_clos_max)
     else:
@@ -128,7 +129,7 @@ def gen_sdc2_header(vm_info, config):
     print("\t\t\t\t\tSOS_BOOTARGS_DIFF", file=config)
 
     print("", file=config)
-    for i in range(scenario_cfg_lib.VM_COUNT):
+    for i in range(common.VM_COUNT):
         cpu_affinity_output(vm_info, i, config)
         clos_config_output(vm_info, i, config)
     print("", file=config)
@@ -164,7 +165,6 @@ def gen_logical_partition_header(vm_info, config):
     :param config: it is the pointer which file write to
     :return: None
     """
-    scenario_cfg_lib.vms_count = scenario_cfg_lib.VM_COUNT
     gen_common_header(config)
     # map all the needed pci sub class
     print("#include <pci_devices.h>", file=config)
@@ -176,7 +176,7 @@ def gen_logical_partition_header(vm_info, config):
 
     logic_max_vm_num(vm_info, config)
 
-    for i in range(scenario_cfg_lib.VM_COUNT):
+    for i in range(common.VM_COUNT):
 
         cpu_bits = vm_info.get_cpu_bitmap(i)
         cpu_affinity_output(vm_info, i, config)
@@ -247,7 +247,7 @@ def gen_industry_header(vm_info, config):
     print("\t\t\t\t\tSOS_CONSOLE\t\\", file=config)
     print("\t\t\t\t\tSOS_BOOTARGS_DIFF", file=config)
     print("", file=config)
-    for i in range(scenario_cfg_lib.VM_COUNT):
+    for i in range(common.VM_COUNT):
         cpu_affinity_output(vm_info, i, config)
         clos_config_output(vm_info, i, config)
     print("", file=config)
@@ -272,7 +272,7 @@ def gen_hybrid_header(vm_info, config):
     print("", file=config)
     scenario_vm_num(vm_info.load_order_cnt, config)
     print("", file=config)
-    for i in range(scenario_cfg_lib.VM_COUNT):
+    for i in range(common.VM_COUNT):
         cpu_affinity_output(vm_info, i, config)
         clos_config_output(vm_info, i, config)