def share_mem_check(shmem_regions, raw_shmem_regions, vm_type_info, prime_item, item, sub_item): shmem_names = {} MAX_SHMEM_REGION_NUM = 8 shmem_region_num = 0 for raw_shmem_region in raw_shmem_regions: if raw_shmem_region is not None and raw_shmem_region.strip() != '': shmem_region_num += 1 if shmem_region_num > MAX_SHMEM_REGION_NUM: key = "hv,{},{},{},{}".format(prime_item, item, sub_item, MAX_SHMEM_REGION_NUM) ERR_LIST[ key] = "The number of hv-land shmem regions should not be greater than {}.".format( MAX_SHMEM_REGION_NUM) return for shm_i, shm_list in shmem_regions.items(): for shm_str in shm_list: index = -1 if shm_i == 'err': for i in range(len(raw_shmem_regions)): if raw_shmem_regions[i] == shm_str: index = i break if index == -1: try: for i in range(len(raw_shmem_regions)): if raw_shmem_regions[i].split(',')[0].strip( ) == shm_str.split(',')[0].strip(): index = i break except: index = 0 key = "hv,{},{},{},{}".format(prime_item, item, sub_item, index) shm_str_splited = shm_str.split(',') if len(shm_str_splited) < 3: ERR_LIST[key] = "The name, size, communication VM IDs of the share memory should be separated " \ "by comma and not be empty." return try: curr_vm_id = int(shm_i) except: ERR_LIST[ key] = "share memory region should be configured with format like this: hv:/shm_region_0, 0x200000, 0:2" return name = shm_str_splited[0].strip() size = shm_str_splited[1].strip() vmid_list = shm_str_splited[2].split(':') int_vmid_list = [] for vmid in vmid_list: try: int_vmid = int(vmid) int_vmid_list.append(int_vmid) except: ERR_LIST[ key] = "The communication VM IDs of the share memory should be decimal and separated by comma." return if not int_vmid_list: ERR_LIST[ key] = "The communication VM IDs of the share memory should be decimal and separated by comma." return if curr_vm_id in int_vmid_list or len( set(int_vmid_list)) != len(int_vmid_list): ERR_LIST[ key] = "The communication VM IDs of the share memory should not be duplicated." return for target_vm_id in int_vmid_list: if curr_vm_id not in vm_type_info.keys() or target_vm_id not in vm_type_info.keys() \ or vm_type_info[curr_vm_id] in ['SOS_VM'] or vm_type_info[target_vm_id] in ['SOS_VM']: ERR_LIST[ key] = "Shared Memory can be only configured for existed Pre-launched VMs and Post-launched VMs." return if name == '' or size == '': ERR_LIST[ key] = "The name, size of the share memory should not be empty." return name_len = len(name) if name_len > 32 or name_len == 0: ERR_LIST[ key] = "The size of share Memory name should be in range [1,32] bytes." return int_size = 0 try: if size.isdecimal(): int_size = int(size) else: int_size = int(size, 16) except: ERR_LIST[ key] = "The size of share Memory region should be decimal or hexadecimal." return if int_size < 0x200000 or int_size > 0x20000000: ERR_LIST[ key] = "The size of share Memory region should be in [2MB, 512MB]." return if not ((int_size & (int_size - 1) == 0) and int_size != 0): ERR_LIST[ key] = "The size of share Memory region should be a power of 2." return if name in shmem_names.keys(): shmem_names[name] += 1 else: shmem_names[name] = 1 if shmem_names[name] > len(vmid_list) + 1: ERR_LIST[ key] = "The names of share memory regions should not be duplicated: {}".format( name) return board_cfg_lib.parse_mem() for shm_i, shm_list in shmem_regions.items(): for shm_str in shm_list: shm_str_splited = shm_str.split(',') name = shm_str_splited[0].strip() index = 0 try: for i in range(len(raw_shmem_regions)): if raw_shmem_regions[i].split( ',')[0].strip() == shm_str.split(',')[0].strip(): index = i break except: index = 0 key = "hv,{},{},{},{}".format(prime_item, item, sub_item, index) if 'IVSHMEM_' + name in board_cfg_lib.PCI_DEV_BAR_DESC.shm_bar_dic.keys( ): bar_attr_dic = board_cfg_lib.PCI_DEV_BAR_DESC.shm_bar_dic[ 'IVSHMEM_' + name] if (0 in bar_attr_dic.keys() and int(bar_attr_dic[0].addr, 16) < 0x80000000) \ or (2 in bar_attr_dic.keys() and int(bar_attr_dic[2].addr, 16) < 0x100000000): ERR_LIST[ key] = "Failed to get the start address of the shared memory, please check the size of it." return
def generate_file(vm_info, config): """ Generate pci_dev.c for Pre-Launched VMs in a scenario. :param config: it is pointer for for file write to :return: None """ board_cfg_lib.parser_pci() board_cfg_lib.parse_mem() compared_bdf = [] for cnt_sub_name in board_cfg_lib.SUB_NAME_COUNT.keys(): i_cnt = 0 for bdf, bar_attr in board_cfg_lib.PCI_DEV_BAR_DESC.pci_dev_dic.items( ): if cnt_sub_name == bar_attr.name and bdf not in compared_bdf: compared_bdf.append(bdf) else: continue add_instance_to_name(i_cnt, bdf, bar_attr) i_cnt += 1 idx = 0 print("{}".format(scenario_cfg_lib.HEADER_LICENSE), file=config) print("", file=config) print("#include <vm_config.h>", file=config) print("#include <pci_devices.h>", file=config) print("#include <vpci.h>", file=config) print("#include <vbar_base.h>", file=config) print("#include <mmu.h>", file=config) print("#include <page.h>", file=config) if vm_info.shmem.shmem_enabled == 'y': print("#include <ivshmem.h>", file=config) for vm_i, pci_bdf_devs_list in vm_info.cfg_pci.pci_devs.items(): if not pci_bdf_devs_list: continue pci_cnt = 1 if idx == 0: print("", file=config) print("/*", file=config) print( " * TODO: remove PTDEV macro and add DEV_PRIVINFO macro to initialize pbdf for", file=config) print( " * passthrough device configuration and shm_name for ivshmem device configuration.", file=config) print(" */", file=config) print("#define PTDEV(PCI_DEV)\t\tPCI_DEV, PCI_DEV##_VBAR", file=config) print("", file=config) print("/*", file=config) print( " * TODO: add DEV_PCICOMMON macro to initialize emu_type, vbdf and vdev_ops", file=config) print(" * to simplify the code.", file=config) print(" */", file=config) print("struct acrn_vm_pci_dev_config " + "vm{}_pci_devs[VM{}_CONFIG_PCI_DEV_NUM] = {{".format(vm_i, vm_i), file=config) print("\t{", file=config) print("\t\t.emu_type = {},".format(PCI_DEV_TYPE[0]), file=config) print("\t\t.vbdf.bits = {.b = 0x00U, .d = 0x00U, .f = 0x00U},", file=config) print("\t\t.vdev_ops = &vhostbridge_ops,", file=config) print("\t},", file=config) idx += 1 for pci_bdf_dev in pci_bdf_devs_list: if not pci_bdf_dev: continue bus = int(pci_bdf_dev.split(':')[0], 16) dev = int(pci_bdf_dev.split(':')[1].split('.')[0], 16) fun = int(pci_bdf_dev.split('.')[1], 16) print("\t{", file=config) print("\t\t.emu_type = {},".format(PCI_DEV_TYPE[1]), file=config) print( "\t\t.vbdf.bits = {{.b = 0x00U, .d = 0x{0:02d}U, .f = 0x00U}}," .format(pci_cnt), file=config) for bdf, bar_attr in board_cfg_lib.PCI_DEV_BAR_DESC.pci_dev_dic.items( ): if bdf == pci_bdf_dev: print( "\t\tPTDEV({}),".format(board_cfg_lib.PCI_DEV_BAR_DESC. pci_dev_dic[bdf].name_w_i_cnt), file=config) else: continue print("\t},", file=config) pci_cnt += 1 if vm_info.shmem.shmem_enabled == 'y' and vm_i in vm_info.shmem.shmem_regions.keys() \ and len(vm_info.shmem.shmem_regions[vm_i]) > 0: raw_shm_list = vm_info.shmem.shmem_regions[vm_i] for shm in raw_shm_list: shm_splited = shm.split(',') print("\t{", file=config) print("\t\t.emu_type = {},".format(PCI_DEV_TYPE[0]), file=config) print( "\t\t.vbdf.bits = {{.b = 0x00U, .d = 0x{0:02d}U, .f = 0x00U}}," .format(pci_cnt), file=config) print("\t\t.vdev_ops = &vpci_ivshmem_ops,", file=config) for shm_name, bar_attr in board_cfg_lib.PCI_DEV_BAR_DESC.shm_bar_dic.items( ): index = shm_name[:shm_name.find('_')] shm_name = shm_name[shm_name.find('_') + 1:] if shm_name == shm_splited[0].strip(): print("\t\t.shm_region_name = IVSHMEM_SHM_REGION_{},". format(index), file=config) print("\t\tIVSHMEM_DEVICE_{}_VBAR".format(index), file=config) # print("\t\t.vbar_size[0] = 0x100,", file=config) # print("\t\t.vbar_size[2] = {},".format(shm_splited[1].strip()), file=config) # print('\t\t.shm_name = "{}",'.format(shm_splited[0].strip()), file=config) print("\t},", file=config) pci_cnt += 1 print("};", file=config) if vm_info.shmem.shmem_enabled == 'y': for shm_i, raw_shm_list in vm_info.shmem.shmem_regions.items(): shm_cnt = 0 if shm_i not in vm_info.cfg_pci.pci_devs.keys( ) and len(raw_shm_list) > 0: print("", file=config) print("struct acrn_vm_pci_dev_config " + "vm{}_pci_devs[VM{}_CONFIG_PCI_DEV_NUM] = {{".format( shm_i, shm_i), file=config) for shm in raw_shm_list: shm_splited = shm.split(',') print("\t{", file=config) print("\t\t.emu_type = {},".format(PCI_DEV_TYPE[0]), file=config) if shm_i in common.VM_TYPES.keys( ) and common.VM_TYPES[shm_i] in [ 'PRE_RT_VM', 'PRE_STD_VM', 'SAFETY_VM' ]: print( "\t\t.vbdf.bits = {{.b = 0x00U, .d = 0x{0:02d}U, .f = 0x00U}}," .format(shm_cnt), file=config) else: print("\t\t.vbdf.value = UNASSIGNED_VBDF,".format( shm_cnt), file=config) print("\t\t.vdev_ops = &vpci_ivshmem_ops,", file=config) for shm_name, bar_attr in board_cfg_lib.PCI_DEV_BAR_DESC.shm_bar_dic.items( ): index = shm_name[:shm_name.find('_')] shm_name = shm_name[shm_name.find('_') + 1:] if shm_name == shm_splited[0].strip(): if shm_i in common.VM_TYPES.keys( ) and common.VM_TYPES[shm_i] in [ 'PRE_RT_VM', 'PRE_STD_VM', 'SAFETY_VM' ]: print( "\t\t.shm_region_name = IVSHMEM_SHM_REGION_{}," .format(index), file=config) print( "\t\tIVSHMEM_DEVICE_{}_VBAR".format(index), file=config) break else: print( "\t\t.shm_region_name = IVSHMEM_SHM_REGION_{}" .format(index), file=config) break shm_cnt += 1 print("\t},", file=config) print("};", file=config)
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() pre_vm = False for vm_type in common.VM_TYPES.values(): if scenario_cfg_lib.VM_DB[vm_type]['load_type'] == "PRE_LAUNCHED_VM": pre_vm = True if not pre_vm: print(VBAR_INFO_ENDIF, file=config) return compared_bdf = [] for cnt_sub_name in board_cfg_lib.SUB_NAME_COUNT.keys(): i_cnt = 0 for bdf, bar_attr in board_cfg_lib.PCI_DEV_BAR_DESC.pci_dev_dic.items( ): if cnt_sub_name == bar_attr.name and bdf not in compared_bdf: compared_bdf.append(bdf) else: continue write_vbar(i_cnt, bdf, board_cfg_lib.PCI_DEV_BAR_DESC.pci_bar_dic, bar_attr, config) i_cnt += 1 ivshmem_enabled = common.get_hv_item_tag(common.SCENARIO_INFO_FILE, "FEATURES", "IVSHMEM", "IVSHMEM_ENABLED") if ivshmem_enabled == 'y': board_cfg_lib.parse_mem() for shm_name, bar_attr_dic in board_cfg_lib.PCI_DEV_BAR_DESC.shm_bar_dic.items( ): index = shm_name[:shm_name.find('_')] i_cnt = 0 for bar_i, bar_attr in bar_attr_dic.items(): i_cnt += 1 if bar_i == 0: if len(bar_attr_dic.keys()) == 1: print("#define IVSHMEM_DEVICE_%-23s" % (str(index) + "_VBAR"), " .vbar_base[{}] = {}UL".format( bar_i, bar_attr.addr), file=config) else: print("#define IVSHMEM_DEVICE_%-23s" % (str(index) + "_VBAR"), " .vbar_base[{}] = {}UL, \\".format( bar_i, bar_attr.addr), file=config) elif i_cnt == len(bar_attr_dic.keys()): print("{}.vbar_base[{}] = {}UL".format( ' ' * 54, bar_i, bar_attr.addr), file=config) else: print("{}.vbar_base[{}] = {}UL, \\".format( ' ' * 54, bar_i, bar_attr.addr), file=config) print("", file=config) print(VBAR_INFO_ENDIF, file=config)
def generate_file(vm_info, config): """ Generate pci_dev.c for Pre-Launched VMs in a scenario. :param config: it is pointer for for file write to :return: None """ board_cfg_lib.parser_pci() board_cfg_lib.parse_mem() compared_bdf = [] sos_used_bdf = [] for cnt_sub_name in board_cfg_lib.SUB_NAME_COUNT.keys(): i_cnt = 0 for bdf, bar_attr in board_cfg_lib.PCI_DEV_BAR_DESC.pci_dev_dic.items( ): if cnt_sub_name == bar_attr.name and bdf not in compared_bdf: compared_bdf.append(bdf) else: continue add_instance_to_name(i_cnt, bdf, bar_attr) i_cnt += 1 for bdf in compared_bdf: bdf_tuple = BusDevFunc.from_str(bdf) sos_used_bdf.append(bdf_tuple) bdf_tuple = BusDevFunc(bus=0, dev=1, func=0) sos_used_bdf.append(bdf_tuple) vuarts = common.get_vuart_info(common.SCENARIO_INFO_FILE) vuarts_num = scenario_cfg_lib.get_vuart_num(vuarts) pci_vuart_enabled = False for vm_i in common.VM_TYPES: if vuarts_num[vm_i] > 0: pci_vuart_enabled = True break print("{}".format(scenario_cfg_lib.HEADER_LICENSE), file=config) print("", file=config) print("#include <vm_config.h>", file=config) print("#include <pci_devices.h>", file=config) print("#include <vpci.h>", file=config) print("#include <vbar_base.h>", file=config) print("#include <mmu.h>", file=config) print("#include <page.h>", file=config) if pci_vuart_enabled: print("#include <vmcs9900.h>", file=config) # Insert header for share memory if vm_info.shmem.shmem_enabled == 'y': print("#include <ivshmem_cfg.h>", file=config) # Insert comments and macros for passthrough devices if any((p for _, p in vm_info.cfg_pci.pci_devs.items())): print("", file=config) print("/*", file=config) print( " * TODO: remove PTDEV macro and add DEV_PRIVINFO macro to initialize pbdf for", file=config) print( " * passthrough device configuration and shm_name for ivshmem device configuration.", file=config) print(" */", file=config) print("#define PTDEV(PCI_DEV)\t\tPCI_DEV, PCI_DEV##_VBAR", file=config) print("", file=config) print("/*", file=config) print( " * TODO: add DEV_PCICOMMON macro to initialize emu_type, vbdf and vdev_ops", file=config) print(" * to simplify the code.", file=config) print(" */", file=config) if pci_vuart_enabled: print("#define INVALID_PCI_BASE\t0U", file=config) for vm_i, vm_type in common.VM_TYPES.items(): vm_used_bdf = [] # Skip this vm if there is no any pci device and virtual device if not scenario_cfg_lib.get_pci_dev_num_per_vm()[vm_i] and \ scenario_cfg_lib.VM_DB[vm_type]['load_type'] != "SOS_VM": continue if not scenario_cfg_lib.get_pci_dev_num_per_vm()[vm_i] and \ scenario_cfg_lib.VM_DB[vm_type]['load_type'] == "SOS_VM": print("", file=config) print("struct acrn_vm_pci_dev_config " + "sos_pci_devs[CONFIG_MAX_PCI_DEV_NUM];", file=config) continue pci_cnt = 1 # Insert device structure and bracket print("", file=config) if scenario_cfg_lib.VM_DB[vm_type]['load_type'] == "SOS_VM": print("struct acrn_vm_pci_dev_config " + "sos_pci_devs[CONFIG_MAX_PCI_DEV_NUM] = {", file=config) else: print("struct acrn_vm_pci_dev_config " + "vm{}_pci_devs[VM{}_CONFIG_PCI_DEV_NUM] = {{".format( vm_i, vm_i), file=config) # Insert passtrough devices data if vm_i in vm_info.cfg_pci.pci_devs.keys(): pci_bdf_devs_list = vm_info.cfg_pci.pci_devs[vm_i] if pci_bdf_devs_list: # Insert pci hostbridge for passtrough devices: if pci_cnt == 1: print("\t{", file=config) print("\t\t.emu_type = {},".format(PCI_DEV_TYPE[0]), file=config) print( "\t\t.vbdf.bits = {.b = 0x00U, .d = 0x00U, .f = 0x00U},", file=config) print("\t\t.vdev_ops = &vhostbridge_ops,", file=config) print("\t},", file=config) bdf_tuple = BusDevFunc.from_str("00:00.0") vm_used_bdf.append(bdf_tuple) for pci_bdf_dev in pci_bdf_devs_list: if not pci_bdf_dev: continue bus = int(pci_bdf_dev.split(':')[0], 16) dev = int(pci_bdf_dev.split(':')[1].split('.')[0], 16) fun = int(pci_bdf_dev.split('.')[1], 16) print("\t{", file=config) print("\t\t.emu_type = {},".format(PCI_DEV_TYPE[1]), file=config) print( "\t\t.vbdf.bits = {{.b = 0x00U, .d = 0x{0:02x}U, .f = 0x00U}}," .format(pci_cnt), file=config) for bdf, bar_attr in board_cfg_lib.PCI_DEV_BAR_DESC.pci_dev_dic.items( ): if bdf == pci_bdf_dev: print("\t\tPTDEV({}),".format( board_cfg_lib.PCI_DEV_BAR_DESC. pci_dev_dic[bdf].name_w_i_cnt), file=config) else: continue print("\t},", file=config) bdf_tuple = BusDevFunc(0, pci_cnt, 0) vm_used_bdf.append(bdf_tuple) pci_cnt += 1 # Insert ivshmem information if vm_info.shmem.shmem_enabled == 'y' and vm_i in vm_info.shmem.shmem_regions.keys() \ and len(vm_info.shmem.shmem_regions[vm_i]) > 0: raw_shm_list = vm_info.shmem.shmem_regions[vm_i] for shm in raw_shm_list: shm_splited = shm.split(',') print("\t{", file=config) print("\t\t.emu_type = {},".format(PCI_DEV_TYPE[0]), file=config) if vm_i in vm_info.cfg_pci.pci_devs.keys(): if scenario_cfg_lib.VM_DB[vm_type][ 'load_type'] == "SOS_VM": free_bdf = find_unused_bdf(sos_used_bdf, "ivshmem") print("\t\t.vbdf.bits = {{.b = 0x00U, .d = 0x{:02x}U, .f = 0x{:02x}U}}," \ .format(free_bdf.dev,free_bdf.func), file=config) print("\t\t.vdev_ops = &vpci_ivshmem_ops,", file=config) sos_used_bdf.append(free_bdf) else: print( "\t\t.vbdf.bits = {{.b = 0x00U, .d = 0x{0:02x}U, .f = 0x00U}}," .format(pci_cnt), file=config) print("\t\t.vdev_ops = &vpci_ivshmem_ops,", file=config) bdf_tuple = BusDevFunc(0, pci_cnt, 0) vm_used_bdf.append(bdf_tuple) elif vm_i not in vm_info.cfg_pci.pci_devs.keys(): if scenario_cfg_lib.VM_DB[vm_type][ 'load_type'] == "PRE_LAUNCHED_VM": print( "\t\t.vbdf.bits = {{.b = 0x00U, .d = 0x{0:02x}U, .f = 0x00U}}," .format(pci_cnt), file=config) bdf_tuple = BusDevFunc(0, pci_cnt, 0) vm_used_bdf.append(bdf_tuple) elif scenario_cfg_lib.VM_DB[vm_type][ 'load_type'] == "POST_LAUNCHED_VM": print("\t\t.vbdf.value = UNASSIGNED_VBDF,", file=config) print("\t\t.vdev_ops = &vpci_ivshmem_ops,", file=config) for shm_name, bar_attr in board_cfg_lib.PCI_DEV_BAR_DESC.shm_bar_dic.items( ): index = shm_name[:shm_name.find('_')] shm_name = shm_name[shm_name.find('_') + 1:] if shm_name == shm_splited[0].strip(): if scenario_cfg_lib.VM_DB[vm_type][ 'load_type'] == "PRE_LAUNCHED_VM": print( "\t\t.shm_region_name = IVSHMEM_SHM_REGION_{}," .format(index), file=config) print("\t\tIVSHMEM_DEVICE_{}_VBAR".format(index), file=config) break elif scenario_cfg_lib.VM_DB[vm_type][ 'load_type'] == "SOS_VM": print( "\t\t.shm_region_name = IVSHMEM_SHM_REGION_{}," .format(index), file=config) print( "\t\tSOS_IVSHMEM_DEVICE_{}_VBAR".format(index), file=config) break else: print( "\t\t.shm_region_name = IVSHMEM_SHM_REGION_{}". format(index), file=config) break pci_cnt += 1 print("\t},", file=config) if vm_i in vuarts.keys(): # 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) for vuart_id in vuarts[vm_i].keys(): if vuarts[vm_i][vuart_id]['base'] == "INVALID_PCI_BASE": continue # skip pci vuart 0 for post-launched vm if vuart_id == 0 and scenario_cfg_lib.VM_DB[vm_type][ 'load_type'] == "POST_LAUNCHED_VM": continue # Skip pci vuart 0 if the legacy vuart 0 is enabled if vuart_id == 0 and vm_i in vuart0_setting and vuart0_setting[ vm_i]['base'] != "INVALID_COM_BASE": continue # Skip pci vuart 1 if the legacy vuart 1 is enabled if vuart_id == 1 and vm_i in vuart1_setting and vuart1_setting[ vm_i]['base'] != "INVALID_COM_BASE": continue print("\t{", file=config) print("\t\t.vuart_idx = {:1d},".format(vuart_id), file=config) print("\t\t.emu_type = {},".format(PCI_DEV_TYPE[0]), file=config) print("\t\t.vdev_ops = &vmcs9900_ops,", file=config) if vuart_id != 0 and scenario_cfg_lib.VM_DB[vm_type][ 'load_type'] == "POST_LAUNCHED_VM": print("\t\t.vbar_base[0] = INVALID_PCI_BASE,", file=config) print("\t\t.vbdf.value = UNASSIGNED_VBDF,", file=config) if scenario_cfg_lib.VM_DB[vm_type][ 'load_type'] != "POST_LAUNCHED_VM": print("\t\tVM{:1d}_VUART_{:1d}_VBAR,".format( vm_i, vuart_id), file=config) if scenario_cfg_lib.VM_DB[vm_type][ 'load_type'] == "PRE_LAUNCHED_VM": free_bdf = find_unused_bdf(vm_used_bdf, "vuart") vm_used_bdf.append(free_bdf) elif scenario_cfg_lib.VM_DB[vm_type][ 'load_type'] == "SOS_VM": free_bdf = find_unused_bdf(sos_used_bdf, "vuart") sos_used_bdf.append(free_bdf) print( "\t\t.vbdf.bits = {{.b = 0x00U, .d = 0x{:02x}U, .f = 0x00U}}," .format(free_bdf.dev, free_bdf.func), file=config) if vuart_id != 0: print("\t\t.t_vuart.vm_id = {},".format( vuarts[vm_i][vuart_id]['target_vm_id']), file=config) print("\t\t.t_vuart.vuart_id = {},".format( vuarts[vm_i][vuart_id]['target_uart_id']), file=config) pci_cnt += 1 print("\t},", file=config) # Insert the end bracket of the pci_dev.c file print("};", file=config)
def generate_file(config): matching_mmios, non_matching_mmios = get_mmio_windows_with_key( ['PCI Bus 0000:00']) matching_mmios = removed_nested(matching_mmios, non_matching_mmios) non_matching_mmios = [ w for w in non_matching_mmios if any((w.overlaps(w2) for w2 in matching_mmios)) ] non_matching_mmios = merged_windows(non_matching_mmios) # 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_devs = scenario_cfg_lib.get_pci_devs(pci_items) pci_devs_per_vm = get_devs_per_vm_with_key(pci_devs, bdf_list) # list SOS vmsix supported devices without other PRE_LAUNCHED_VMs' in bdf format sos_bdf_list = [ d for d in bdf_list if all((d not in pci_devs_per_vm[i] for i in pci_devs_per_vm)) ] for vm_i in pci_devs_per_vm: vm_type = common.VM_TYPES[vm_i] if scenario_cfg_lib.VM_DB[vm_type]['load_type'] == "SOS_VM": pci_devs_per_vm[vm_i] = sos_bdf_list mmiolist_per_vm = {} for vm_i, vm_type in common.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'] == "SOS_VM": mmiolist_per_vm[vm_i] = non_matching_mmios else: if vm_i in pci_devs.keys(): match, _ = get_mmio_windows_with_key(pci_devs[vm_i]) mmiolist_per_vm[vm_i] = match if scenario_cfg_lib.VM_DB[vm_type][ 'load_type'] == "PRE_LAUNCHED_VM": if vm_i not in mmiolist_per_vm.keys(): mmiolist_per_vm[vm_i] = [] # TSN reserved region mmiolist_per_vm[vm_i].append( MmioWindow(start=0xffff0000, end=0xffffffff)) # For the pre-launched vm, if the TPM is passtrough, this address is used if vm_i == 0 and board_cfg_lib.is_tpm_passthru(): mmiolist_per_vm[vm_i].append( MmioWindow(start=0xfed40000, end=0xfed40000 + 0x5000 - 1)) # For the pre-launched vm o ehl-crb-b, if the p2sb is passtrough, this address is used if board_cfg_lib.is_matched_board(('ehl-crb-b')): p2sb_start = board_cfg_lib.find_p2sb_bar_addr() mmiolist_per_vm[vm_i].append( MmioWindow(start=p2sb_start, end=p2sb_start + 0x1000000 - 1)) mmiolist_per_vm[vm_i].sort() # 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() pre_vm = False sos_vm = False for vm_type in common.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'] == "SOS_VM": sos_vm = True if not pre_vm and not sos_vm: print(VBAR_INFO_ENDIF, file=config) return ivshmem_enabled = common.get_hv_item_tag(common.SCENARIO_INFO_FILE, "FEATURES", "IVSHMEM", "IVSHMEM_ENABLED") if ivshmem_enabled == 'y': for vm_id, vm_type in common.VM_TYPES.items(): free_bar = [] if scenario_cfg_lib.VM_DB[vm_type][ 'load_type'] == "PRE_LAUNCHED_VM": board_cfg_lib.parse_mem() for shm_name, bar_attr_dic in board_cfg_lib.PCI_DEV_BAR_DESC.shm_bar_dic.items( ): index = shm_name[:shm_name.find('_')] i_cnt = 0 for bar_i, bar_attr in bar_attr_dic.items(): i_cnt += 1 if bar_i == 2: raw_shmem_regions = common.get_hv_item_tag( common.SCENARIO_INFO_FILE, "FEATURES", "IVSHMEM", "IVSHMEM_REGION") for shm in raw_shmem_regions: if shm is None or shm.strip() == '': continue shm_splited = shm.split(',') name = shm_splited[0].strip() size = shm_splited[1].strip() try: int_size = int(size) * 0x100000 except: int_size = 0 bar_2 = int(bar_attr.addr, 16) mmiolist_per_vm[vm_id].append( MmioWindow(start=bar_2, end=bar_2 + int_size - 1)) mmiolist_per_vm[vm_id].sort() if bar_i == 0: bar_0 = MmioWindow(start=int(bar_attr.addr, 16), end=int(bar_attr.addr, 16) + 0x100 - 1) mmiolist_per_vm[vm_id].append(bar_0) mmiolist_per_vm[vm_id].sort() if len(bar_attr_dic.keys()) == 1: print("#define IVSHMEM_DEVICE_%-23s" % (str(index) + "_VBAR"), " .vbar_base[{}] = {}UL".format( bar_i, bar_attr.addr), file=config) else: print( "#define IVSHMEM_DEVICE_%-23s" % (str(index) + "_VBAR"), " .vbar_base[{}] = {}UL, \\".format( bar_i, bar_attr.addr), file=config) # vbar[1] for share memory is fix to 4K free_bar = get_free_mmio([MmioWindow(start=common.SIZE_2G, end=common.SIZE_4G-1)], \ mmiolist_per_vm[vm_id], BAR1_SHEMEM_ALIGNMENT + BAR1_SHEMEM_SIZE) free_bar_start_addr = common.round_up( free_bar.start, BAR1_SHEMEM_ALIGNMENT) free_bar_end_addr = free_bar_start_addr + BAR1_SHEMEM_SIZE - 1 free_bar = MmioWindow(free_bar_start_addr, free_bar_end_addr) mmiolist_per_vm[vm_id].append(free_bar) mmiolist_per_vm[vm_id].sort() print("{}.vbar_base[1] = {:#x}UL, \\".format( ' ' * 54, free_bar.start), file=config) elif i_cnt == len(bar_attr_dic.keys()): print("{}.vbar_base[{}] = {}UL".format( ' ' * 54, bar_i, bar_attr.addr), file=config) else: print("{}.vbar_base[{}] = {}UL, \\".format( ' ' * 54, bar_i, bar_attr.addr), file=config) print("", file=config) elif scenario_cfg_lib.VM_DB[vm_type]['load_type'] == "SOS_VM": ivshmem_region = common.get_hv_item_tag( common.SCENARIO_INFO_FILE, "FEATURES", "IVSHMEM", "IVSHMEM_REGION") shmem_regions = scenario_cfg_lib.get_shmem_regions( ivshmem_region) if vm_id not in shmem_regions.keys(): continue idx = 0 for shm in ivshmem_region: if shm is None or shm.strip() == '': continue shm_splited = shm.split(',') name = shm_splited[0].strip() size = shm_splited[1].strip() try: int_size = int(size) * 0x100000 except: int_size = 0 # vbar[0] for shared memory is 0x100 free_bar0 = get_free_mmio( matching_mmios, 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_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( matching_mmios, 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_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(matching_mmios, 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_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) mmiolist_per_vm[vm_id].sort() print("#define SOS_IVSHMEM_DEVICE_%-19s" % (str(idx) + "_VBAR"), " .vbar_base[0] = {:#x}UL, \\".format( free_bar0.start), file=config) print("{}.vbar_base[1] = {:#x}UL, \\".format( ' ' * 54, free_bar1.start), file=config) print("{}.vbar_base[2] = {:#x}UL".format( ' ' * 54, free_bar2.start), file=config) print("", file=config) idx += 1 # Get passthrough devices vbar bases compared_bdf = [] for cnt_sub_name in board_cfg_lib.SUB_NAME_COUNT.keys(): i_cnt = 0 for bdf, bar_attr in board_cfg_lib.PCI_DEV_BAR_DESC.pci_dev_dic.items( ): if cnt_sub_name == bar_attr.name and bdf not in compared_bdf: compared_bdf.append(bdf) else: continue write_vbar(i_cnt, bdf, board_cfg_lib.PCI_DEV_BAR_DESC.pci_bar_dic, bar_attr, \ pci_devs_per_vm, mmiolist_per_vm, matching_mmios, config) i_cnt += 1 write_vuart_vbar(mmiolist_per_vm, matching_mmios, config) print(VBAR_INFO_ENDIF, file=config)