Maintaining peripheral component interconnect fast pass-through configuration in virtualized environment

Abstract

Techniques described herein relate to maintaining a peripheral component interconnect fast pass-through configuration in a virtualized environment, in particular to a method of configuring components. The method may include identifying, by an operating system (OS) agent of a production host, a first change event, where: the production host includes a plurality of components, and the plurality of components are used by a plurality of virtual machines (VMs) executing on the production host; making a first determination: the first change event is associated with a component of the plurality of components; and in response to making the first determination, updating a component mapping table based on the first change event.

Description

Background Art

[0001] A computing device can provide services to a user. To provide services, the computing device can include multiple components. The components can be used to perform at least a part of the services. Over time, the components can be removed or added to the computing device. Software of the computing device (such as a virtual machine) can use the components to provide services. The computing device can include multiple virtual machines, and each virtual machine uses one or more components. The components can be mapped to the virtual machines so that the virtual machines can use the components. Summary of the Invention

[0002] Generally, in one aspect, embodiments disclosed herein relate to a method of being executed to configure components. The method includes: identifying, by an operating system (OS) agent of a production host, a first change event, wherein: the production host includes multiple components, and the multiple components are used by multiple virtual machines (VMs) executed on the production host; making a first determination that the first change event is associated with a component among the multiple components; in response to making the first determination, updating a component mapping table based on the first change event; identifying a second change event; making a second determination that the second change event is associated with a VM among the multiple VMs; in response to making the second determination, updating the component mapping table based on the second change event; and providing the updated component mapping to the OS of the production host and the multiple VMs, wherein the component mapping enables the multiple VMs to use the multiple components to perform computer-implemented services.

[0003] Generally, in one aspect, embodiments described herein relate to a non-transitory computer-readable medium including computer-readable program code that, when executed by a computer processor, enables the computer processor to execute a method of configuring components. The method includes: identifying, by an operating system (OS) agent of a production host, a first change event, wherein: the production host includes multiple components, and the multiple components are used by multiple virtual machines (VMs) executed on the production host; making a first determination that the first change event is associated with a component among the multiple components; in response to making the first determination, updating a component mapping table based on the first change event; identifying a second change event; making a second determination that the second change event is associated with a VM among the multiple VMs; in response to making the second determination, updating the component mapping table based on the second change event; and providing the updated component mapping to the OS of the production host and the multiple VMs, wherein the component mapping enables the multiple VMs to use the multiple components to perform computer-implemented services.

[0004] Other aspects of the embodiments disclosed herein will be apparent from the following description and the drawings. BRIEF DESCRIPTION OF THE DRAWINGS

[0005] Certain embodiments of the present invention will be described with reference to the accompanying drawings. However, the drawings illustrate only certain aspects or implementations of the present invention by way of example and are not meant to limit the scope of the claims.

[0006] Figure 1A A diagram of a system according to one or more embodiments disclosed herein.

[0007] Figure 1B A diagram of a storage device according to one or more embodiments disclosed herein.

[0008] Figure 2 A flowchart of a method for generating an initial component mapping table according to one or more embodiments disclosed herein.

[0009] Figures 3A to 3B A flowchart of a method for updating a component mapping table according to one or more embodiments disclosed herein.

[0010] Figure 4 A diagram of a computing device according to one or more embodiments disclosed herein. DETAILED DESCRIPTION

[0011] Specific embodiments will now be described with reference to the accompanying drawings. In the following description, numerous details are set forth as examples of the embodiments disclosed herein. Those skilled in the art will understand that one or more embodiments disclosed herein may be practiced without these specific details and that numerous variations or modifications may be possible without departing from the scope of the embodiments disclosed herein. Certain details known to those of ordinary skill in the art are omitted to avoid obscuring the description.

[0012] In the following description of the drawings, any component described with respect to one drawing may be equivalent to one or more similarly named components described with respect to any other drawing in the various embodiments disclosed herein. For the sake of brevity, the description of these components will not be repeated for each drawing. Thus, each embodiment of the components of each drawing is incorporated by reference and is assumed to optionally exist in each other drawing having one or more similarly named components. Additionally, according to the various embodiments disclosed herein, any description of the components of the drawings should be interpreted as an optional embodiment that may be implemented in addition to, in combination with, or in place of the embodiments described with respect to the corresponding similarly named components in any other drawing.

[0013] Throughout this application, elements of the drawings may be labeled A through N. As used herein, the foregoing labeling means that an element may include any number of items, and there is no requirement that an element include the same number of elements as any other item labeled A through N. For example, a data structure may include a first element labeled A and a second element labeled N. This labeling convention means that the data structure may include any number of elements. A second data structure (also labeled A through N) may also include any number of elements. The number of elements in the first data structure may be the same as or different from the number of elements in the second data structure.

[0014] Generally, embodiments of the present invention relate to methods, systems, and / or non-transitory computer-readable media for storing and updating device configurations in a virtualized environment.

[0015] Most virtual machines can use the Peripheral Component Interconnect Express (PCIe) passthrough feature to obtain the best performance of a device from the guest OS in which a computer-implemented service runs. For example, a Non-Volatile Memory Express (NVMe) storage device designated as a passthrough device can be a common use case for latency / performance-intensive applications. Initial appliance VM configuration and in-field replacement / maintenance of hot-pluggable PCIe passthrough devices can be very cumbersome. Certain tasks may be required in such cases, such as securely removing a device and reconfiguring a newly added device into a VM / container. These tasks may consume administrator cycles and may also increase downtime when the tasks involve data center / cloud / edge use cases. When redeploying an operating system (OS) or a hypervisor in-field on a bare metal server, the deployment and reconfiguration of passthrough devices can also be a use case. Currently, there is no available automated mechanism to automatically reconfigure PCIe passthrough devices into the corresponding VMs.

[0016] To at least partially address the foregoing problems discussed above, embodiments disclosed herein relate to systems, methods, and / or non-transitory computer-readable media that create a mapping between PCIe device slots and VM / container IDs during factory and runtime, store configuration information in a table, and then provide the mapping data to the operating system, thereby automating PCIe passthrough reconfiguration.

[0017] Figure 1A A diagram of a system in accordance with one or more embodiments disclosed herein is shown. The system may include a client (100) and a production host (110). Without departing from the embodiments disclosed herein, Figure 1AThe components of the system shown can be operatively connected to each other via any combination of a wired network (e.g., Ethernet) and / or a wireless network (e.g., local area network, wide area network, Internet, etc.) and / or operatively connected to other entities (not shown). As discussed below Figure 1A each component of the system shown.

[0018] In one or more embodiments, the production host (110) can be implemented using one or more computing devices. The computing device can be, for example, a mobile phone, a tablet computer, a laptop computer, a desktop computer, a server, a distributed computing system, or cloud resources. The computing device can include one or more processors, a memory (e.g., random access memory), and a persistent storage device (e.g., a disk drive, a solid state drive, etc.). The persistent storage device can store computer instructions, such as computer code, which (when executed by the processor of the computing device) cause the computing device to perform the functions of the production host (110) described herein and / or Figures 2 to 3B all or a portion of the methods shown. Without departing from the embodiments disclosed herein, the production host (110) can be implemented using other types of computing devices. For additional details regarding computing devices, reference is made to Figure 4 .

[0019] Without departing from the embodiments disclosed herein, the production host (110) can be implemented using logical devices. For example, the production host (110) can include a virtual machine that utilizes the computing resources of any number of physical computing devices to provide the functions of the production host (110). Without departing from the embodiments disclosed herein, the production host (110) can be implemented using other types of logical devices.

[0020] In one or more embodiments, the production host (110) can include the following functions or otherwise be programmed or configured to: perform computer-implemented services for the client (100) and the user of the production host (110). In one or more embodiments, the client (100) can be implemented as one or more computing devices as discussed above. The computer-implemented services can include an email communication service, a database service, a calendar service, an inference service, and / or a word processing service. Without departing from the embodiments disclosed herein, the computer-implemented services can include other and / or additional types of services. To perform computer-implemented services for the client (100), the production host (110) can also include the function of sending data, requests, and / or other information to the client (100) / obtaining data, requests, and / or other information from the client (100). The production host (110) can include performing Figures 2 to 3BAll or part of the functions of the method discussed herein. Without departing from the embodiments disclosed herein, the production host (110) may include other and / or additional functions.

[0021] As discussed above, the production host (110) may include functions for performing computer-implemented services. To perform the aforementioned computer-implemented services, the production host may include a virtual machine (112), an operating system (OS) (114), an OS agent (116), a hypervisor (118), a host controller (120), a storage device (122), and a component slot (124). Without departing from the embodiments disclosed herein, the production host (110) may include other, additional, and / or fewer components. Each of the aforementioned components of the production host (110) is discussed below.

[0022] In one or more embodiments disclosed herein, the virtual machine (112) is implemented as computer instructions, such as computer code, stored on a storage device (e.g., 122), which, when executed by a processor of the production host (110), cause the production host (110) to provide the functions of the virtual machine (112) described throughout this detailed description. The virtual machine may include functions for performing at least a portion of a computer-implemented service or otherwise providing at least a portion of a computer-implemented service to a client and / or user. Without departing from the embodiments disclosed herein, the virtual machine may include other and / or additional functions. The virtual machine (VM) (112) may include any number of virtual machines. For example, the VM (112) may include VM A (112A) and VM N (112N). Additionally, each VM (e.g., 112A, 112N) may include one or more guest OSs ( Figure 1A not shown in figure). VM functions; scheduling tasks; mediating the interaction between logic (e.g., software) and physical (e.g., hardware). Each guest OS may support basic production host (110) components (e.g., 126A, 126N) using, for example, a component mapping table; allocate production host (110) resources; and execute or invoke other computer programs or computer instructions executed on the production host (110) associated with the corresponding VM. One of ordinary skill in the art will appreciate that the guest OS may perform other functions without departing from the scope of the embodiments disclosed herein.

[0023] In one or more embodiments disclosed herein, the operating system (OS) (114) is implemented as computer instructions, such as computer code, stored on a storage device (e.g., 122), which, when executed by a processor of the production host (110), cause the production host (110) to provide the functions of the OS (114) described throughout this detailed description.

[0024] In one or more embodiments disclosed herein, the OS (114) can be designed and configured to oversee the operation of the production host (110). To that extent, the OS (114) can include the following functions: for example, supporting basic production host (110) functions; scheduling tasks; using a component mapping table to mediate the interaction between logical (e.g., software) (e.g., VM (112)) and physical (e.g., hardware) production host (110) components (e.g., 126A, 126N); allocating production host (110) resources; and executing or invoking other computer programs or computer instructions executed on the production host (110). The OS (114) can include functions that perform all or a portion of the Figures 2 to 3B method. Those of ordinary skill in the art will appreciate that the OS (114) can perform other functions without departing from the scope of the embodiments described herein. Without departing from the embodiments disclosed herein, one or more operating systems can be included in the production host (110).

[0025] In one or more embodiments disclosed herein, the operating system (OS) agent (116) can be implemented as computer instructions, such as computer code, stored on a storage device (e.g., 122), which, when executed by a processor of the production host (110), cause the production host (110) to provide the functions of the OS agent (116) described throughout this detailed description. The OS agent (116) can be a software component of the OS (114).

[0026] In one or more embodiments disclosed herein, the OS agent (116) can include functions that perform a component table mapping service. The component table mapping service can include generating and updating a component mapping table based on configuration information, or initiating the generation and updating of the component mapping table. The component table mapping service can also include distributing the component mapping table to the OS (114), the hypervisor (118), and / or the VM (112) or making the component mapping table available. Without departing from the embodiments disclosed herein, the component mapping table service can include other and / or additional services associated with the component mapping table (discussed below). The OS agent (116) can also include functions that perform all or a portion of the Figures 2 to 3B method. Without departing from the embodiments disclosed herein, the OS agent (116) can include other and / or additional functions. Without departing from the embodiments disclosed herein, there can be one or more OS agents (116), each OS agent associated with one or more OSs (114), hypervisors (118), and / or VMs (112).

[0027] In one or more embodiments disclosed herein, the hypervisor (118) may be implemented as computer instructions, such as computer code, stored on a storage device (e.g., 122), which, when executed by a processor of the production host (110), cause the production host (110) to provide the functionality of the hypervisor (118) described throughout this detailed description.

[0028] In one or more embodiments disclosed herein, the hypervisor (118) may be implemented as a physical device. The physical device may include circuitry. The physical device may be, for example, a field programmable gate array, an application specific integrated circuit, a programmable processor, a microcontroller, a digital signal processor, or other hardware processor. The physical device may be configured to provide the functionality of the hypervisor (118) described throughout this detailed description.

[0029] In one or more embodiments disclosed herein, the hypervisor (118) may include functionality to manage one or more of the VMs (112). The hypervisor (118) may generate, update, and facilitate communication of information and data between VMs (e.g., 112A, 112N) and between one or more of the VMs (112) and components of the production host (110) (e.g., 116, 118, 120, 122, 124, 126A, 126N). The hypervisor (118) may include functionality to perform Figures 2 to 3B all or a portion of the methods described. Without departing from the embodiments disclosed herein, the hypervisor (118) may include other and / or additional functionality. In one or more embodiments disclosed herein, there may be a single hypervisor (118) associated with all of the VMs (112). In alternative embodiments, although Figure 1A not shown in, there may be multiple hypervisors (118), each associated with one or more of the VMs (112).

[0030] In one or more embodiments disclosed herein, the host controller (120) may be implemented as computer instructions, such as computer code, stored on a storage device (e.g., 122), which, when executed by a processor of the production host (110), cause the production host (110) to provide the functionality of the host controller (120) described throughout this detailed description.

[0031] In one or more embodiments disclosed herein, the host controller (120) may be implemented as a physical device. The physical device may include circuitry. The physical device may be, for example, a field programmable gate array, an application specific integrated circuit, a programmable processor, a microprocessor, a microcontroller, a digital signal processor, a system-on-chip (SoC), or other hardware processor. The physical device may be configured to provide the functions of the host controller (120) described throughout this detailed description.

[0032] In one or more embodiments disclosed herein, the host controller (120) may include functions for performing production host management services. The production host management services may include: (i) monitoring component slots (124), VMs (112), the OS (114), or Figure 1A other production host components not shown therein using sensors (e.g., temperature sensors, fan speed sensors, voltage sensors, etc.) and / or monitoring services to identify changes, (ii) generating and / or obtaining log information associated with the foregoing changes, (iii) generating or obtaining configuration information (discussed below) associated with component slots (124) and VMs (112) from the hypervisor (118), the OS (114), and / or the user, and / or (iv) performing startup or power-off of the production host (110). The production host management services may include performing out-of-band management. In other words, the host controller (120) may enable access and management of devices, components, and / or other infrastructure associated with the production host (110) at a remote location through a management network or plane separate from the production network or plane (e.g., through the host controller (120) itself and / or the user (e.g., a system administrator)). Thus, without departing from the embodiments disclosed herein, the system administrator may monitor and manage the production host (110) whether the production host is powered on or the OS is running normally. The host controller (120) may communicate with the user through any suitable out-of-band network connection (e.g., an out-of-band LAN). Without departing from the embodiments disclosed herein, the host controller (120) may communicate with the user using a user interface (e.g., a graphical user interface (GUI), a command line interface, a web interface, etc.) and any suitable communication specification or protocol (e.g., the Intelligent Platform Management Interface (IPMI)). Without departing from the embodiments disclosed herein, the production host management services may include other and / or additional services associated with the production host (110). The host controller (120) may also include functions for performing Figures 2 to 3B all or a part of the method of. Without departing from the embodiments disclosed herein, the host controller (120) may include other and / or additional functions.

[0033] In one or more embodiments disclosed herein, the storage device (122) may be implemented using one or more volatile or non-volatile storage devices or any combination thereof. The storage device (122) may include the following functionality or otherwise be configured to store and provide all or part of the information that may be used by the production host (110) or its components (e.g., 112A, 112N, 114, 116, 118, 120, 126A, 126N). The information stored in the storage device (122) may include one or more data structures including a component mapping table. Without departing from the embodiments disclosed herein, the storage device (122) may include other and / or additional information. For additional information regarding the storage device (122) and the component mapping table (130, Figure 1B ), please refer to Figure 1B .

[0034] Although the above data structures (e.g., 130) and other data structures mentioned in this detailed description are shown / discussed as separate data structures and have been discussed as including a limited amount of specific information, without departing from the embodiments disclosed herein, any of the previously mentioned data structures may be divided into any number of data structures, combined with any number of other data structures, and may include additional, less, and / or different information. Additionally, although shown as stored in the storage device (122), without departing from the embodiments disclosed herein, any of the previously mentioned data structures may be stored in different locations (e.g., in the storage device of other computing devices) and / or across any number of computing devices. The data structures discussed in this detailed description may be implemented using, for example, a file system, a list, a linked list, a table, unstructured data, a database, etc.

[0035] In one or more embodiments disclosed herein, component slots (124) may be implemented as one or more physical interface connections that operatively connect removable components (e.g., 126A, 126N) to a production host (110). Over time, components (e.g., 126A, 126N) may be added to, removed from, and / or replaced in corresponding component slots (124). There may be any number of component slots (124) without departing from the embodiments disclosed herein. Without departing from the embodiments disclosed herein, component slots (124) may use any suitable expansion bus communication standard (e.g., Peripheral Component Interconnect Express (PCIe), Peripheral Component Interconnect (PCI), Peripheral Component Interconnect Extended (PCI-X), Accelerated Graphics Port (AGP), etc.) to operatively connect components (e.g., 126A, 126N) to a production host (110) to enable data transfer between the production host (110) (or its components, such as a VM (112)) and the components (126A, 126N). Without departing from the embodiments disclosed herein, component slots (124) may be implemented using any software (e.g., computer instructions), cables, physical connectors, wires, circuits, and / or any other components required to operatively connect components (126A, 126N) to a production host (110).

[0036] In one or more embodiments, components (126A, 126N) may include the following hardware components: a graphics card, a sound card, a host bus adapter for a hard disk drive, a solid state drive (SSD) (e.g., a Non-Volatile Memory Express (NVMe) drive), and / or a network interface controller (NIC). Without departing from the embodiments disclosed herein, there may be any number of components (126A, 126N). Without departing from the embodiments disclosed herein, components (126A, 126N) may include other and / or additional types of hardware components. The production host (110) and / or the VM (112) may use components (126A, 126N) to perform all or part of a computer-implemented service. For example, without departing from the embodiments disclosed herein, a NIC may perform network services of a computer-implemented service, a graphics card may perform graphics processing services of a computer-implemented service, an SSD may perform data storage services of a computer-implemented service, etc. Components (126A, 126N) may include other and / or additional functions.

[0037] Although Figure 1AThe system is shown as having a certain number of components (e.g., 100, 110, etc.), but in other embodiments disclosed herein, the system may have more or fewer components. For example, the functionality of each of the above components may be split across components or combined into a single component. Further still, each component may be reused multiple times for iterative operations. Further still, there may be multiple of each type of component of the production host (110) (e.g., 112, 112A, 112N, 114, 116, 118, 120, 122, 124, 126A, 126N).

[0038] Figure 1B A diagram of a storage device according to one or more embodiments disclosed herein is shown. The storage device (122) may be an embodiment of the storage device (122, Figure 1A ) discussed above. As discussed above, the storage device (122) may store a component mapping table (CMT) (130). The CMT may be used to transfer removable components (e.g., 126A, 126N, Figure 1A ) to a VM (112, Figure 1A ) executing on the production host (110, Figure 1A ). In other words, the CMT (130) may provide the necessary CMT information to the hypervisor (118), the OS (114), and / or the VM (112) such that the VM (112) can use the components mapped to the VM. Without departing from the embodiments disclosed herein, the CMT (130) may be implemented using any suitable type of table data structure.

[0039] As discussed above, the CMT (130) includes CMT information. The CMT information may include entries associated with components (e.g., Figure 1B the rows shown). There may be any number of entries associated with currently connected components or previously connected components (e.g., historical entries). Each entry may include a component slot identifier (140), bus device function (BDF) information (150), component type (160), mapped VM identifier (170), and configuration status (180). Without departing from the embodiments disclosed herein, the CMT information may include other and / or additional information associated with the components. Each of the previously mentioned components of the CMT information is discussed below.

[0040] In one or more embodiments, a component slot identifier (140) may specify a particular component slot associated with a component. The component slot identifier (140) may specify the component slot to which the component is currently connected or was previously connected (if not currently connected). Each component slot may be associated with a different component slot identifier. For example, a first component slot may be associated with component slot identifier A (142), a second component slot may be associated with component slot identifier B (144), a third component slot may be associated with component slot identifier C (146), and an Nth component slot may be associated with component slot identifier N (148). There may be any number of component slots, and thus any number of component slot identifiers, without departing from the embodiments disclosed herein. The component slot identifier (140) may be empty or set to a default value to indicate that the component associated with the entry has been removed and / or the entry is a historical entry. Without departing from the embodiments disclosed herein, the component slot identifier (140) may include other and / or additional information.

[0041] In one or more embodiments disclosed herein, BDF information specifies a bus number, a device number, and a function number associated with a component corresponding to an entry. In one or more embodiments, the bus number specifies the switch to which the component is connected and allows communication to be routed to the correct switch corresponding to the component. In one or more embodiments, the device number is used to identify a specific component within the switch so that an entity (e.g., a VM (112)) wishing to use the component can select the component. In one or more embodiments, the function number specifies one or more specific functions or capabilities associated with the component so that a user of the component can select the desired function. The BDF information enables a production host (110) or a VM to use the component corresponding to the BDF information. Each component in a component slot may be associated with BDF information. For example, a first component slot may be associated with a component having BDF A (152), a second component slot may be associated with a component having BDF B (154), a third component slot may be associated with a component having BDF C (156), and an Nth component slot may be associated with a component having BDF N (158). Without departing from the embodiments disclosed herein, the BDF information (150) may include other and / or additional information associated with the component.

[0042] In one or more embodiments, a component type (160) may specify the type of hardware component corresponding to a component. The component type (140) may include a label, identifier, marker, or other indicator of the hardware component type. The component type (160) may specify whether the corresponding component is, for example, a graphics card, a sound card, a host bus adapter for a hard disk drive, a solid state drive (SSD) (e.g., a non-volatile memory express (NVMe) drive), and / or a NIC. Without departing from the embodiments disclosed herein, the component type (160) may include additional information, such as the vendor associated with the corresponding component, the version number associated with the corresponding component, the component identifier, or the product number, etc. The component type may further specify whether the corresponding component is a physical component or a virtual component generated using at least a portion of a physical component (e.g., a single root I / O virtualization (SR-IOV) device). In one or more embodiments, each component or each entry may be associated with a component type. For example, a first component slot may be associated with a component having a component type A (162), a second component slot may be associated with a component having a component type B (164), a third component slot may be associated with a component having a component type C (166), and an Nth component slot may be associated with a component having a component type N (168). Without departing from the embodiments disclosed herein, the component type (160) may include other and / or additional information associated with the component.

[0043] In one or more embodiments, a mapped VM identifier (170) may specify a particular VM (e.g., 112A) in the VM (112) to which the corresponding component is mapped. In other words, the mapped VM identifier (170) may specify the VM that uses the component associated with the entry. Each component or entry may be associated with a mapped VM identifier. For example, a first component slot may be associated with a component mapped to a VM identifier A (172), a second component slot may be associated with a component mapped to a VM identifier B (174), a third component slot may be associated with a component mapped to a VM identifier C (176), and an Nth component slot may be associated with a component mapped to a VM identifier N (178). Without departing from the embodiments disclosed herein, there may be any number of component slots, components, and VMs, and thus there may be any number of mapped VM identifiers. The mapped VM identifier (170) may be empty or set to a default value to indicate that the component associated with the entry is not currently mapped to a VM. Without departing from the embodiments disclosed herein, the mapped VM identifier (170) may include other and / or additional information.

[0044] In one or more embodiments, a configuration state (180) can specify the state of a component associated with an entry. The configuration state (180) can include a label, identifier, marker, or other indicator of the component state. The configuration state (180) can specify whether the corresponding component is in an active state (e.g., ready to use and / or currently being used by a VM), an inactive state (not ready to use and / or not currently being used by a VM), powered off (e.g., the component does not include a power source), connected, removed, whether the mapped VM has been removed, and / or any other state associated with the component. The configuration state (180) can be associated with a timestamp (e.g., the time point corresponding to when the state changed to the current state). Each component or entry can be associated with a configuration state. For example, a first component slot can be associated with a component having state A (182), a second component slot can be associated with a component having state B (184), a third component slot can be associated with a component having state C (186), and an Nth component slot can be associated with a component having state N (188). Without departing from the embodiments disclosed herein, the configuration state can include other and / or additional information associated with the component state.

[0045] Figure 2 A flowchart of a method for generating an initial component mapping table in accordance with one or more embodiments disclosed herein is shown. Figure 2 The method shown can be performed by, for example, a production host (e.g., 110, Figure 1A )). Without departing from the scope of the embodiments described herein, Figures 1A to 1B other components of the system in Figure 2 can perform all or a portion of the Figure 2 method. Although

[0046] shown as a series of steps, without departing from the scope of the embodiments described herein, any step can be omitted, performed in a different order, can include additional steps, and / or any or all steps can be performed in a parallel and / or partially overlapping manner.

[0046] Initially, in step 200, the production host performs an initial power-on. In one or more embodiments, the production host can be shipped by a manufacturer and deployed in an environment (e.g., an edge environment, a data center, a cloud environment, etc.). When connected to power and turned on (e.g., by user or administrator input, such as pressing a button), the host controller of the production host can perform startup by loading computing instructions in memory and executing or starting one or more processors of the production host to execute the computing instructions. Without departing from the embodiments disclosed herein, the production host can perform the initial power-on via other and / or additional methods.

[0047] In step 202, an initial CMT associated with the production host is generated. In one or more embodiments, the OS agent of the production host generates the initial CMT using the initial configuration information. The initial configuration information may be stored in the storage device of the production host by the manufacturer or the user before the initial power-on in step 200. The initial configuration information may be one or more data structures that include component slot identifiers associated with component slots on the production host. The OS agent may generate an initial CMT that has entries associated with each component slot identifier included in the initial configuration information. The OS agent may leave other parts of the entries (e.g., component BDF information, component type, mapped VM identifier, and configuration status) blank or set to initial values / parameters. The OS agent may generate the initial CMT by making any appropriate application programming interface (API) calls (e.g., Redfish API calls, Representational State Transfer (REST) API calls, etc.) to the host controller or Figure 1A other entities capable of generating a CMT not shown herein (e.g., services, servers, processors, etc.).

[0048] In an alternative embodiment, the initial CMT associated with the production host may be manually generated by a user (e.g., a system administrator) and provided to the host controller via a user interface associated with the host controller and the user. As discussed above, the host controller may communicate directly with the user via any suitable type of user interface and an out-of-band network. The user may provide configuration information to the host controller, which includes the initial configuration information for generating the initial CMT. Alternatively, the user may generate and directly provide the initial CMT via the user interface. The initial CMT may include entries associated with each component slot identifier included in the initial configuration information. The initial CMT may include blanks or set initial values / parameters for other parts of the entries (e.g., component BDF information, component type, mapped VM identifier, and configuration status).

[0049] In additional alternative embodiments disclosed herein, the host controller directly generates an initial CMT using initial configuration information. As discussed above, the initial configuration information can be stored in a storage device of the production host and retrieved by the host controller from the storage device, or the initial configuration information can be provided to the host controller by a user via a user interface associated with the host controller and the user. In one or more embodiments, the host controller can use a device specific method (_DSM) method defined in the basic input / output system (BIOS) and the initial configuration information to generate an initial CMT to generate an initial CMT and update it to an advanced configuration and power interface (ACPI) table. The ACPI table can refer to a table data structure of an ACPI-based system. The BIOS can be firmware (e.g., computer instructions) executed by a host controller or other processor of the production host to provide hardware management (e.g., boot process, hardware initialization, etc.) for the production host. A virtual machine, hypervisor, OS, and / or OS agent can access, issue requests (e.g., API calls), trigger a system management mode (SMM) (e.g., an operating mode for pausing normal execution of the production host processor to enable unobstructed and uninterrupted access to the CMT), and / or obtain information (e.g., CMT information) from the CMT included or otherwise maintained by the host controller via the BIOS. The _DSM method can refer to custom functions, procedures, or routines included in the BIOS for generating, updating, maintaining, and allowing access to the CMT or providing CMT information from the CMT.

[0050] Without departing from the embodiments disclosed herein, the initial CMT associated with the production host can be generated via other and / or additional methods.

[0051] In step 204, configuration information associated with the production host is obtained. As discussed above, the storage device of the production host can include initial configuration information. In one or more embodiments, the initial configuration information can include configuration information. Additionally, as discussed above, in some embodiments, a user can provide configuration information to the host controller. The OS agent or the host controller can parse the initial configuration information to obtain the configuration information. Without departing from the embodiments disclosed herein, the configuration information associated with the production host can be obtained via other and / or additional methods.

[0052] In step 206, it is determined whether the production host is associated with a default configuration. The host controller can parse the configuration information to determine whether the production host is associated with a default configuration. As discussed above, the configuration information can be one or more data structures that specify the component slot identifiers associated with the production host. The configuration information can also specify the default configuration. In one or more embodiments, the default configuration can refer to a general or specified initial configuration of components that are pre - attached to component slots by the manufacturer or user and automatically assigned to a specific VM of the production host. There can be one or more different types of default configurations, each with different components installed in different component slots. In one or more embodiments disclosed herein, if the configuration information includes a default configuration, the host controller can determine that the production host is associated with the default configuration. In one or more embodiments disclosed herein, if the configuration information does not include a default configuration, the host controller can determine that the production host is not associated with the default configuration. Without departing from the embodiments disclosed herein, determining whether the production host is associated with the default configuration can be performed via other and / or additional methods.

[0053] In one or more embodiments disclosed herein, if it is determined that the production host is associated with the default configuration, the method proceeds to step 208. In one or more embodiments disclosed herein, if it is determined that the production host is not associated with the default configuration, the method proceeds to step 210.

[0054] In step 208, the CMT is updated based on the default configuration. In one or more embodiments, the OS agent of the production host uses the default configuration specified by the configuration information to update the CMT. The default configuration can specify the initial BDF information, component type, mapped VM identifier, and configuration status associated with each component slot identifier. The OS agent can update the entries associated with each component slot identifier with the CMT information associated with the component slot identifiers included in the default configuration. The OS agent can update the initial CMT by making any appropriate application programming interface (API) calls (e.g., Redfish API calls, Representational State Transfer (REST) API calls, etc.) to the host controller or Figure 1A other entities (e.g., services, servers, processors, etc., not shown) capable of updating the CMT with the CMT information included in the default configuration.

[0055] In an alternative embodiment, the initial CMT associated with the production host can be manually updated by a user (e.g., a system administrator) and provided to the host controller via a user interface associated with the host controller and the user. As discussed above, the host controller can communicate directly with the user via any suitable type of user interface and an out-of-band network. The user can provide a default configuration to the host controller (see steps 210 to 212), the default configuration including CMT information for updating the initial CMT, and the host controller can update the CMT as discussed below. Alternatively, the user can update and directly provide the updated CMT via the user interface. The updated CMT can include the initial BDF information, component type, mapped VM identifier, and configuration status associated with each component slot identifier as specified in the default configuration for each entry.

[0056] In yet another additional alternative embodiment disclosed herein, the host controller directly updates the initial CMT using the default configuration. As discussed above, the default configuration can specify the initial BDF information, component type, mapped VM identifier, and configuration status associated with each component slot identifier. In one or more embodiments, the host controller can use the _DSM method defined in the BIOS and the default configuration for updating the initial CMT to update the initial CMT.

[0057] As discussed above, the BIOS can be firmware (e.g., computer instructions) executed by the host controller or other processor of the production host to provide hardware management (e.g., boot process, hardware initialization, etc.) for the production host. The virtual machine, hypervisor, OS, and / or OS agent can access, issue requests (e.g., API calls), trigger the system management mode (SMM) (e.g., an operating mode for pausing the normal execution of the production host processor to enable unobstructed and uninterrupted access to the CMT), and / or obtain information (e.g., CMT information) from the CMT included or otherwise maintained by the host controller via the BIOS. The _DSM method can refer to a custom function, process, or routine included in the BIOS for generating, updating, maintaining, and allowing access to the CMT or providing CMT information from the CMT.

[0058] Without departing from the embodiments disclosed herein, the CMT can be updated based on the default configuration via other and / or additional methods.

[0059] In step 210, the user is requested for user configuration information. In one or more embodiments, the host controller may send a message or prompt the user to provide user configuration information via an out-of-band network connection with the user through a user interface (e.g., graphical user interface, command line interface, web interface, etc.). The message or prompt may include a request for input of CMT information associated with the component configuration (e.g., non-default configuration) of the user configuration. Without departing from the embodiments disclosed herein, the user configuration information may be requested from the user via other and / or additional methods.

[0060] In step 212, the user configuration information is obtained from the user. In one or more embodiments, in response to the prompt, the user may input CMT information associated with the production host via the user interface (e.g., by checking boxes, selecting options, and / or inputting information via a keyboard, touch screen, mouse, etc.). The host controller may obtain and / or extract the CMT information from the user interface. Without departing from the embodiments disclosed herein, the user configuration information may be obtained from the user via other and / or additional methods.

[0061] In step 214, the CMT is updated based on the user configuration information. In one or more embodiments, the OS agent of the production host uses the user configuration information to update the CMT. The default configuration may specify the initial BDF information, component type, mapped VM identifier, and configuration status associated with each component slot identifier. The OS agent may update the entry associated with each component slot identifier with the CMT information associated with the component slot identifier included in the user configuration information. The OS agent may update the CMT by making any appropriate application programming interface (API) calls (e.g., Redfish API calls, Rest API calls, etc.) to the host controller or Figure 1A other entities capable of updating the CMT not shown herein (e.g., services, servers, processors, etc.) using the CMT information included in the user configuration information.

[0062] In an alternative embodiment, the initial CMT associated with the production host can be manually updated by a user (e.g., a system administrator) and provided to the host controller via a user interface associated with the host controller and the user. As discussed above, the host controller can communicate directly with the user via any suitable type of user interface and an out-of-band network. The user can provide a user configuration to the host controller (see steps 210 to 212), the user configuration including CMT information for updating the initial CMT, and the host controller can update the CMT as discussed below. Alternatively, the user can update and directly provide the updated CMT based on the user configuration via the user interface. The updated CMT can include, for each entry, the initial BDF information, component type, mapped VM identifier, and configuration status associated with each component slot identifier as specified in the user configuration.

[0063] In additional alternative embodiments disclosed herein, the host controller directly updates the initial CMT using the user configuration. As discussed above, the user configuration can specify the initial BDF information, component type, mapped VM identifier, and configuration status associated with each component slot identifier. In one or more embodiments, the host controller can use the _DSM method defined in the BIOS and the user configuration for updating the initial CMT to update the initial CMT.

[0064] The BIOS can be firmware (e.g., computer instructions) executed by the host controller or other processor of the production host to provide hardware management (e.g., boot process, hardware initialization, etc.) for the production host. Virtual machines, hypervisors, operating systems, and / or operating system agents can access, issue requests (e.g., API calls), trigger the system management mode (SMM) (e.g., an operating mode for pausing the normal execution of the production host processor to enable unobstructed and uninterrupted access to the CMT), and / or obtain information (e.g., CMT information) from the CMT included or otherwise maintained by the host controller via the BIOS. The _DSM method can refer to custom functions, procedures, or routines included in the BIOS for generating, updating, maintaining, and allowing access to the CMT or providing CMT information from the CMT.

[0065] Without departing from the embodiments disclosed herein, the CMT can be updated based on the user configuration via other and / or additional methods.

[0066] In step 216, the component mapping is provided to the operating system based on the CMT. In one or more embodiments, the OS agent may provide all or a portion of the CMT information included in the current CMT to the OS of the production host. The OS may also distribute the CMT information to the corresponding VMs and hypervisors of the production host. Then, the OS, VMs, and hypervisors may use the CMT information of the CMT to pass the current configuration of the production host components to the mapped VMs. Thus, the CMT information of the CMT enables the VMs to perform computer-implemented services using the mapped components. In alternative embodiments disclosed herein, the host controller may notify the VMs, hypervisors, OS, and / or OS agent that the CMT has been updated and / or expose the _DSM method to the VMs, hypervisors, OS, and / or OS agent. Thus, the VMs, hypervisors, OS, and / or OS agent may access, issue requests (e.g., API calls), trigger the system management mode (SMM) (e.g., an operating mode for pausing the normal execution of the production host processor to enable unobstructed and uninterrupted access to the CMT), and / or obtain information (e.g., CMT information) from the CMT included or otherwise maintained by the host controller via the _DSM method using the BIOS. When components or VMs are added, removed, or reconfigured, the CMT may be automatically updated via the Figures 3A to 3B method. Without departing from the embodiments disclosed herein, the component mapping may be provided to the operating system based on the CMT via other and / or additional methods.

[0067] In one or more embodiments disclosed herein, the method ends after step 216. Without departing from the embodiments disclosed herein, Figure 2 the method may be performed during the production manufacturing process before deploying the production host.

[0068] Figures 3A to 3B A flowchart of a method for updating a component mapping table according to one or more embodiments disclosed herein is shown. Figures 3A to 3B The method shown may be performed by, for example, a production host (e.g., 110, Figure 1A ). Without departing from the scope of the embodiments described herein, Figures 1A to 1B other components of the Figures 3A to 3B system may perform all or a portion of the Figures 3A to 3B method. Although Figures 3A to 3B is shown as a series of steps, any step may be omitted, any step may be performed in a different order, additional steps may be included, and / or any or all steps may be performed in a parallel and / or partially overlapping manner without departing from the scope of the embodiments described herein.

[0069] Initially, at Figure 3AIn step 300, a change event is identified. In one or more embodiments, when a component changes, the host controller or other entity (e.g., a hardware monitor) can notify the OS agent. The notification can include log information associated with the change. A component change can include adding a component to a component slot or removing a component from a component slot. Similarly, when a VM changes, the hypervisor or host controller can notify the OS agent. The notification can include log information. A VM change can include adding a VM, removing a VM, or reconfiguring components associated with the VM. The OS agent can identify the notification received from the host controller and / or hypervisor associated with the component change or VM change as a change event. Without departing from the embodiments disclosed herein, change events can be identified via other and / or additional methods.

[0070] In step 302, it is determined whether the change event is associated with a component change event. In one or more embodiments disclosed herein, the OS agent can examine the log information associated with the change event included in the notification corresponding to the change event. The log information can be one or more data structures that specify whether the change is associated with a VM or a component. In one or more embodiments disclosed herein, if the log information specifies that the change event is associated with a component, the OS agent can determine that the change event is a component change event. In one or more embodiments disclosed herein, if the log information specifies that the change event is associated with a VM, the OS agent can determine that the change event is not a component change event. Without departing from the embodiments disclosed herein, other and / or additional methods can be used to determine whether the change event is associated with a component change event.

[0071] In one or more embodiments disclosed herein, if it is determined that the change event is a component change event, the method proceeds to step 304. In one or more embodiments disclosed herein, if it is determined that the change event is not a component change event, the method proceeds to Figure 3B step 318.

[0072] In step 304, it is determined whether the component change event is associated with an added component. The log information associated with the component change event can specify whether a component is added to or removed from a component slot. In one or more embodiments, the OS agent can parse the log information to determine whether the change event is associated with the addition or deletion of a component. In one or more embodiments disclosed herein, if the log information specifies that the change event is associated with an added component, the OS agent can determine that a component has been added. In one or more embodiments disclosed herein, if the log information specifies that the change event is associated with the removal of a component, the OS agent can determine that no component has been added (the component has been removed). Without departing from the embodiments disclosed herein, other and / or additional methods can be used to determine whether the change event is associated with an added component.

[0073] In one or more embodiments disclosed herein, if it is determined that the change event is associated with an added component, the method proceeds to step 306. In one or more embodiments disclosed herein, if it is determined that the change event is not associated with an added component (the change event is associated with a removed component), the method proceeds to step 310.

[0074] In step 306, it is determined whether the added component is a previous component. In one or more embodiments, the component can be a component that was previously removed from a component slot. The OS agent can compare the component identifier included in the log information with the component identifier included in the entry of the CMT. In one or more embodiments disclosed herein, if the component identifier included in the log information matches the component identifier included in the CMT, the OS agent can determine that the component is a previous component. In one or more embodiments disclosed herein, if the component identifier included in the log information does not match the component identifier included in the CMT, the OS agent can determine that the component is not a previous component (e.g., the component is a new component). Without departing from the embodiments disclosed herein, other and / or additional methods can be used to determine whether the added component is a previous component.

[0075] In one or more embodiments disclosed herein, if it is determined that the added component is a previous component, the method proceeds to step 308. In one or more embodiments disclosed herein, if it is determined that the added component is not a previous component, the method proceeds to step 312.

[0076] In step 308, the CMT is updated to indicate the addition of the previous component. In one or more embodiments, the OS agent of the production host uses the log information to update the CMT. The OS agent can update the configuration status and, if installed in a new component slot, update the component slot identifier associated with the previous component included in the entry. The log information can specify the component slot identifier and the configuration status associated with the added component. Additionally, if the component is mapped to a new VM as specified in the log information, the OS agent can use the mapped component identifier included in the log information to update the mapped VM identifier associated with the entry corresponding to the component. The OS agent can update the CMT by making any appropriate application programming interface (API) calls (e.g., Redfish API calls, Rest API calls, etc.) to the host controller or Figure 1A other entities capable of updating the CMT not shown herein (e.g., services, servers, processors, etc.) by leveraging the CMT information included in the log information discussed above.

[0077] In an alternative embodiment, the CMT associated with the production host can be manually updated by a user (e.g., a system administrator) based on the addition of the previous component and provided to the host controller via a user interface associated with the host controller and the user. As discussed above, the host controller can communicate directly with the user via any appropriate type of user interface and an out-of-band network. The user can provide the log information to the host controller (e.g., similar to the method discussed above. See steps 210 to 212), where the log information includes the CMT information for updating the CMT, and the host controller can update the CMT as discussed below. Alternatively, the user can update and directly provide the updated CMT via the user interface based on the addition of the previous component. The updated CMT can include the component slot identifier and the configuration status associated with the added component. Additionally, if the component is mapped to a new VM as specified in the log information, the updated CMT can include the updated mapped VM identifier associated with the entry.

[0078] In yet another additional alternative embodiment disclosed herein, the host controller directly updates the initial CMT using the log information. The host controller can update the configuration status and, if installed in a new component slot, update the component slot identifier associated with the previous component included in the entry. As discussed above, the log information can specify the component slot identifier and the configuration status associated with the added component. Additionally, if the component is mapped to a new VM as specified in the log information, the host controller can then use the mapped component identifier included in the log information to update the mapped VM identifier associated with the entry corresponding to the component. In one or more embodiments, the host controller can use the _DSM method defined in the BIOS and the log information to update the CMT.

[0079] As discussed above, the BIOS can be firmware (e.g., computer instructions) executed by a host controller or other processor of the production host to provide hardware management for the production host (e.g., boot process, hardware initialization, etc.). The virtual machine, hypervisor, OS, and / or OS agent can access, issue requests (e.g., API calls), trigger the system management mode (SMM) (e.g., an operating mode for pausing the normal execution of the production host processor to enable unobstructed and uninterrupted access to the CMT), and / or obtain information (e.g., CMT information) from the CMT included in or otherwise maintained by the host controller via the BIOS. The _DSM method can refer to custom functions, procedures, or routines included in the BIOS for generating, updating, maintaining, and allowing access to the CMT or providing CMT information from the CMT.

[0080] Without departing from the embodiments disclosed herein, the CMT can be updated via other and / or additional methods to indicate that a previous component has been added.

[0081] In one or more embodiments disclosed herein, after step 308, the method proceeds to step 316.

[0082] In step 310, the CMT is updated to indicate that a component has been removed. In one or more embodiments, the OS agent of the production host uses log information to update the CMT. The OS agent can update the configuration status and component slot identifier associated with the removed component included in the entry to indicate that the component has been removed. The log information can specify the component slot identifier and configuration status associated with the removed component. The OS agent can update the CMT by performing any appropriate application programming interface (API) calls (e.g., Redfish API calls, Rest API calls, etc.) on the host controller or other entities (e.g., services, servers, processors, etc.) capable of updating the CMT not shown herein by leveraging the CMT information included in the log information discussed above. Figure 1A In step 310, the CMT is updated to indicate that a component has been removed. In one or more embodiments, the OS agent of the production host uses log information to update the CMT. The OS agent can update the configuration status and component slot identifier associated with the removed component included in the entry to indicate that the component has been removed. The log information can specify the component slot identifier and configuration status associated with the removed component. The OS agent can update the CMT by performing any appropriate application programming interface (API) calls (e.g., Redfish API calls, Rest API calls, etc.) on the host controller or other entities (e.g., services, servers, processors, etc.) capable of updating the CMT not shown herein by leveraging the CMT information included in the log information discussed above.

[0083] In an alternative embodiment, the CMT associated with the production host can be manually updated by a user (e.g., a system administrator) based on the removal of a component and provided to the host controller via a user interface associated with the host controller and the user. As discussed above, the host controller can communicate directly with the user via any suitable type of user interface and an out-of-band network. The user can provide log information to the host controller (e.g., similar to the method discussed above. See steps 210 to 212), the log information includes CMT information for updating the CMT, and the host controller can update the CMT as discussed below. Alternatively, the user can update and directly provide the updated CMT based on the removal of the component via the user interface. The updated CMT can include the updated configuration status and component slot identifier associated with the removed component included in the entry to indicate that the component has been removed.

[0084] In a further additional alternative embodiment disclosed herein, the host controller directly updates the initial CMT using the log information. The host controller can update the configuration status and component slot identifier associated with the removed component included in the entry to indicate that the component has been removed. The log information can specify the component slot identifier and configuration status associated with the removed component. In one or more embodiments, the host controller can use the _DSM method defined in the BIOS and the log information to update the CMT.

[0085] As discussed above, the BIOS can be firmware (e.g., computer instructions) executed by the host controller or other processor of the production host to provide hardware management (e.g., boot process, hardware initialization, etc.) for the production host. The virtual machine, hypervisor, OS, and / or OS agent can access, issue requests (e.g., API calls), trigger the system management mode (SMM) (e.g., an operating mode for pausing the normal execution of the production host processor to enable unobstructed and uninterrupted access to the CMT), and / or obtain information (e.g., CMT information) from the CMT included or otherwise maintained by the host controller via the BIOS. The _DSM method can refer to a custom function, process, or routine included in the BIOS for generating, updating, maintaining, and allowing access to the CMT or providing CMT information from the CMT.

[0086] Without departing from the embodiments disclosed herein, the CMT can be updated via other and / or additional methods to indicate that a component has been removed.

[0087] In one or more embodiments disclosed herein, after step 308, the method proceeds to step 316.

[0088] In step 312, the CMT is updated to indicate that a new component has been added. In one or more embodiments, the OS agent of the production host uses the log information to update the CMT. The OS agent can update the CMT by generating a new entry in the CMT associated with the new component. The OS agent can include in the generated entry the component slot identifier, BDF information, component type, mapped VM identifier, and configuration status included in the log information. The OS agent can update the CMT by making any appropriate application programming interface (API) calls (e.g., Redfish API calls, Rest API calls, etc.) to a host controller or Figure 1A other entity capable of updating the CMT (e.g., a service, a server, a processor, etc.) not shown in the figure by leveraging the CMT information included in the log information discussed above.

[0089] In an alternative embodiment, the CMT associated with the production host can be manually updated by a user (e.g., a system administrator) based on the addition of the new component and provided to the host controller via a user interface associated with the host controller and the user. As discussed above, the host controller can communicate directly with the user via any appropriate type of user interface and an out-of-band network. The user can provide the log information to the host controller (e.g., similar to the method discussed above. See steps 210 to 212), the log information includes the CMT information for updating the CMT, and the host controller can update the CMT as discussed below. Alternatively, the user can update and directly provide the updated CMT based on the addition of the new component through the user interface. The updated CMT can include a new entry associated with the new addition and the component slot identifier, BDF information, component type, mapped VM identifier, and configuration status associated with the newly added component in the generated entry.

[0090] In yet another alternative embodiment disclosed herein, the host controller directly updates the initial CMT using the log information. The host controller can update the configuration status and component slot identifier associated with the removed component included in the entry to indicate that the component has been removed. The log information can specify the component slot identifier and configuration status associated with the removed component. In one or more embodiments, the host controller can use the _DSM method defined in the BIOS and the log information to update the CMT.

[0091] As discussed above, the BIOS can be firmware (e.g., computer instructions) executed by a host controller or other processor of the production host to provide hardware management (e.g., boot process, hardware initialization, etc.) for the production host. A virtual machine, hypervisor, OS, and / or OS agent can access, issue requests (e.g., API calls), trigger the system management mode (SMM) (e.g., an operating mode for pausing the normal execution of the production host processor to enable unobstructed and uninterrupted access to the CMT), and / or obtain information (e.g., CMT information) from the CMT included or otherwise maintained by the host controller via the BIOS. The _DSM method can refer to custom functions, procedures, or routines included in the BIOS for generating, updating, maintaining, and allowing access to the CMT or providing CMT information from the CMT.

[0092] Without departing from the embodiments disclosed herein, the CMT can be updated via other and / or additional methods to indicate that a new component has been added.

[0093] In step 316, an updated component mapping is provided to the OS based on the CMT. In one or more embodiments, the OS agent can provide all or a portion of the CMT information included in the updated CMT to the OS of the production host. The OS or the OS agent can also distribute the CMT information to the corresponding VMs and hypervisors of the production host. The OS, VMs, and hypervisors can then use the CMT information of the CMT to pass the current configuration of the components to the mapped VMs. In this way, the CMT information of the CMT can be automatically updated, and the VMs can be enabled to use the mapped components to perform computer-implemented services even when components or VMs are reconfigured, newly created, added, or removed. In alternative embodiments disclosed herein, the host controller can notify the VMs, hypervisors, OS, and / or OS agent that the CMT has been updated and / or expose the _DSM method to the VMs, hypervisors, OS, and / or OS agent. Thus, the VMs, hypervisors, OS, and / or OS agent can access, issue requests (e.g., API calls), trigger the system management mode (SMM) (e.g., an operating mode for pausing the normal execution of the production host processor to enable unobstructed and uninterrupted access to the CMT), and / or obtain information (e.g., CMT information) from the CMT included or otherwise maintained by the host controller via the BIOS using the _DSM method. Without departing from the embodiments disclosed herein, the updated component mapping can be provided to the operating system based on the CMT via other and / or additional methods.

[0094] In one or more embodiments disclosed herein, after step 316, the method ends.

[0095] Go toFigure 3B In step 318, it is determined whether the VM change is associated with a VM reconfiguration. Log information associated with the VM change event can specify whether a VM has been added (e.g., a VM has been created), removed, or reconfigured (mapped to different components installed on the production host). In one or more embodiments, the OS agent can parse the log information to determine whether the change event is associated with a VM reconfiguration. In one or more embodiments disclosed herein, if the log information specifies that the change event is associated with a VM reconfiguration, the OS agent can determine that the VM has been reconfigured. In one or more embodiments disclosed herein, if the log information specifies that the change event is not associated with a VM reconfiguration, the OS agent can determine that the VM has not been reconfigured. Without departing from the embodiments disclosed herein, other and / or additional methods can be used to determine whether a VM change is associated with a VM reconfiguration.

[0096] In one or more embodiments disclosed herein, if it is determined that the VM change event is associated with a VM reconfiguration, the method proceeds to step 320. In one or more embodiments disclosed herein, if it is determined that the change event is not associated with a VM reconfiguration (the change event is associated with a removed or added VM), the method proceeds to step 322.

[0097] In step 320, the CMT is updated based on the VM reconfiguration. In one or more embodiments, the OS agent of the production host uses the log information to update the CMT. The log information can specify the VM identifier associated with the reconfigured VM. The log information can also specify the component identifier or component slot identifier associated with the component that has been reconfigured to map to the VM corresponding to the VM identifier. The OS agent can update the mapped VM identifier for all entries associated with the component identifier and / or component slot identifier specified in the log information. The OS agent can update the CMT by making any appropriate application programming interface (API) calls (e.g., Redfish API calls, RestAPI calls, etc.) to the host controller or Figure 1A other entities (e.g., services, servers, processors, etc.) capable of updating the CMT that are not shown herein.

[0098] In an alternative embodiment, the CMT associated with the production host can be manually updated by a user (e.g., a system administrator) and provided to the host controller via a user interface associated with the host controller and the user. As discussed above, the host controller can communicate directly with the user via any suitable type of user interface and an out-of-band network. The user can provide log information to the host controller (see steps 210 to 212), the log information including CMT information for updating the CMT, and the host controller can update the CMT as discussed below. Alternatively, the user can update and directly provide the updated CMT based on VM reconfiguration via the user interface. The updated CMT can include an updated mapping of VM identifiers for all entries associated with component identifiers and / or component slot identifiers associated with the VM reconfiguration.

[0099] In a further additional alternative embodiment disclosed herein, the host controller directly updates the initial CMT using the log information. The log information can specify the VM identifier associated with the reconfigured VM. The log information can also specify a component identifier or a component slot identifier associated with a component reconfigured to map to the VM corresponding to the VM identifier. The host controller can update the mapped VM identifier for all entries associated with the component identifier and / or component slot identifier specified by the log information. In one or more embodiments, the host controller can use the _DSM method defined in the BIOS and the user configuration for updating the initial CMT to update the initial CMT.

[0100] The BIOS can be firmware (e.g., computer instructions) executed by the host controller or other processor of the production host to provide hardware management (e.g., boot process, hardware initialization, etc.) for the production host. The virtual machine, hypervisor, OS, and / or OS agent can access, issue requests (e.g., API calls), trigger the system management mode (SMM) (e.g., an operating mode for pausing the normal execution of the production host processor to enable unobstructed and uninterrupted access to the CMT), and / or obtain information (e.g., CMT information) from the CMT included or otherwise maintained by the host controller via the BIOS. The _DSM method can refer to a custom function, procedure, or routine included in the BIOS for generating, updating, maintaining, and allowing access to the CMT or providing CMT information from the CMT.

[0101] Without departing from the embodiments disclosed herein, the CMT can be updated based on VM reconfiguration via other and / or additional methods.

[0102] In one or more embodiments disclosed herein, after step 320, the method can proceed to Figure 3A step 316 in

[0103] In step 322, it is determined whether the VM change is associated with an added VM. Log information associated with the VM change event can specify whether a VM (mapped to different components installed on the production host) has been added, removed, or reconfigured. In one or more embodiments, the OS agent can parse the log information to determine whether the change event is associated with an added VM. In one or more embodiments disclosed herein, if the log information specifies that the change event is associated with an added VM, the OS agent can determine that the VM has been added. In one or more embodiments disclosed herein, if the log information specifies that the change event is not associated with an added VM, the OS agent can determine that the VM has not been added (the VM has been removed). Without departing from the embodiments disclosed herein, other and / or additional methods can be used to determine whether the VM change is associated with an added VM.

[0104] In one or more embodiments disclosed herein, if it is determined that the VM change event is associated with an added VM, the method proceeds to step 324. In one or more embodiments disclosed herein, if it is determined that the change event is not associated with an added VM (the change event is associated with a removed VM), the method proceeds to step 328.

[0105] In step 324, it is determined whether the added VM is a previous VM. In one or more embodiments, the VM can be a VM that was previously removed from the production host. The OS agent can compare the VM identifier included in the log information with the VM identifier included in the entry of the CMT. In one or more embodiments disclosed herein, if the VM identifier included in the log information matches the VM identifier included in the CMT, the OS agent can determine that the VM is a previous VM. In one or more embodiments disclosed herein, if the VM identifier included in the log information does not match the VM identifier included in the CMT, the OS agent can determine that the VM is not a previous component. Without departing from the embodiments disclosed herein, other and / or additional methods can be used to determine whether the added VM is a previous VM.

[0106] In one or more embodiments disclosed herein, if it is determined that the added VM is a previous VM, the method proceeds to step 326. In one or more embodiments disclosed herein, if it is determined that the added VM is not a previous VM, the method proceeds to step 330.

[0107] In step 326, the CMT is updated to indicate that the previous VM has been added. In one or more embodiments, the OS agent of the production host uses the log information to update the CMT. The OS agent can update the configuration state of all entries associated with the previous VM, changing from the removed mapped VM to the active VM. The log information can specify the VM identifier associated with the added VM. The OS agent can perform any appropriate application programming interface (API) calls (e.g., Redfish API calls, Rest API calls, etc.) to update the CMT by leveraging the CMT information included in the log information discussed above to the host controller or Figure 1A other entities (e.g., services, servers, processors, etc.) capable of updating the CMT not shown in the figure to update the CMT.

[0108] In an alternative embodiment, the CMT associated with the production host can be manually updated by a user (e.g., a system administrator) based on the addition or creation of the previous VM and provided to the host controller via a user interface associated with the host controller and the user. As discussed above, the host controller can communicate directly with the user through any appropriate type of user interface and an out-of-band network. The user can provide the log information to the host controller (e.g., similar to the method discussed above. See steps 210 to 212), the log information includes the CMT information for updating the CMT, and the host controller can update the CMT as discussed below. Alternatively, the user can update and directly provide the updated CMT through the user interface based on the addition or creation of the previous VM. The updated CMT can include the component slot identifier and the configuration state associated with the added component. Additionally, if the component is mapped to a new VM as specified in the log information, the updated CMT can include the updated mapped VM identifier associated with the entry.

[0109] In yet another additional alternative embodiment disclosed herein, the host controller directly updates the initial CMT using the log information. The host controller can update the configuration state of all entries associated with the previous VM, changing from the removed mapped VM to the active VM. The log information can specify the VM identifier associated with the added VM. In one or more embodiments, the host controller can use the _DSM method defined in the BIOS and the log information to update the CMT.

[0110] As discussed above, the BIOS can be firmware (e.g., computer instructions) executed by a host controller or other processor of the production host to provide hardware management (e.g., boot process, hardware initialization, etc.) for the production host. The virtual machine, hypervisor, OS, and / or OS agent can access, issue requests (e.g., API calls), trigger the system management mode (SMM) (e.g., an operating mode for pausing the normal execution of the production host processor to enable unobstructed and uninterrupted access to the CMT), and / or obtain information (e.g., CMT information) from the CMT included in or otherwise maintained by the host controller via the BIOS. The _DSM method can refer to custom functions, procedures, or routines included in the BIOS for generating, updating, maintaining, and allowing access to the CMT or providing CMT information from the CMT.

[0111] Without departing from the embodiments disclosed herein, the CMT can be updated via other and / or additional methods to indicate that a previous VM has been added.

[0112] In one or more embodiments disclosed herein, after step 326, the method proceeds to Figure 3A step 316.

[0113] In step 328, the CMT is updated to indicate that the VM has been removed. In one or more embodiments, the OS agent of the production host uses log information to update the CMT. The OS agent can update the configuration status of each entry having a VM identifier associated with the removed VM to indicate that the mapped VM has been removed. The log information can specify the VM identifier associated with the removed VM. The OS agent can update the CMT by performing any appropriate application programming interface (API) calls (e.g., Redfish API calls, Rest API calls, etc.) on the host controller or Figure 1A other entities (e.g., services, servers, processors, etc.) capable of updating the CMT not shown herein by leveraging the CMT information included in the log information discussed above.

[0114] In an alternative embodiment, the CMT associated with the production host can be manually updated by a user (e.g., a system administrator) based on the removal of the VM, and provided to the host controller via a user interface associated with the host controller and the user. As discussed above, the host controller can communicate directly with the user via any suitable type of user interface and an out-of-band network. The user can provide log information to the host controller (e.g., similar to the method discussed above. See steps 210 to 212), the log information includes CMT information for updating the CMT, and the host controller can update the CMT as discussed below. Alternatively, the user can update and directly provide the updated CMT based on the removal of the VM via the user interface. The updated CMT can include the updated configuration status in the entry associated with the removed VM to indicate that the mapped VM has been removed.

[0115] In a further additional alternative embodiment disclosed herein, the host controller directly updates the initial CMT using the log information. The host controller can update the configuration status of each entry having a VM identifier associated with the removed VM to indicate that the mapped VM has been removed. The log information can specify the VM identifier associated with the removed VM. In one or more embodiments, the host controller can use the _DSM method defined in the BIOS and the log information to update the CMT.

[0116] As discussed above, the BIOS can be firmware (e.g., computer instructions) executed by the host controller or other processor of the production host to provide hardware management (e.g., boot process, hardware initialization, etc.) for the production host. The virtual machine, hypervisor, OS, and / or OS agent can access, issue requests (e.g., API calls), trigger the system management mode (SMM) (e.g., an operating mode for pausing the normal execution of the production host processor to enable unobstructed and uninterrupted access to the CMT), and / or obtain information (e.g., CMT information) from the CMT included or otherwise maintained by the host controller via the BIOS. The _DSM method can refer to a custom function, process, or routine included in the BIOS for generating, updating, maintaining, and allowing access to the CMT or providing CMT information from the CMT.

[0117] Without departing from the embodiments disclosed herein, the CMT can be updated via other and / or additional methods to indicate that the VM has been removed.

[0118] In one or more embodiments disclosed herein, after step 328, the method proceeds to Figure 3A step 316.

[0119] In step 330, the CMT is updated to indicate that a new VM has been added. In one or more embodiments, the OS agent of the production host uses the log information to update the CMT. The OS agent can update the CMT by swapping the mapped VM identifiers of one or more entries associated with the component slot identifier or component identifier specified by the log information and associated with the newly added VM with the VM identifier associated with the new VM. The log information can specify the VM identifier associated with the newly added VM. The OS agent can perform any appropriate application programming interface (API) calls (e.g., Redfish API calls, Rest API calls, etc.) to update the CMT on the host controller or other entities (e.g., services, servers, processors, etc.) capable of updating the CMT that are not shown in Figure 1A to update the CMT.

[0120] In an alternative embodiment, the CMT associated with the production host can be manually updated by a user (e.g., a system administrator) based on the addition (or creation) of the new VM and provided to the host controller via a user interface associated with the host controller and the user. As discussed above, the host controller can communicate directly with the user via any appropriate type of user interface and an out-of-band network. The user can provide the log information to the host controller (e.g., similar to the method discussed above. See steps 210 to 212), the log information includes the CMT information for updating the CMT, and the host controller can update the CMT as discussed below. Alternatively, the user can update and directly provide the updated CMT via the user interface based on the addition or creation of the new VM. The updated CMT can include the updated mapped VM identifiers, which include the VM identifiers of the newly added or created VM associated with the components and / or component slots mapped to the newly added or created VM.

[0121] In yet another alternative embodiment disclosed herein, the host controller directly updates the initial CMT using the log information. The host controller can update the CMT by swapping the mapped VM identifiers of one or more entries associated with the component slot identifier or component identifier specified by the log information and associated with the newly added VM with the VM identifier associated with the new VM. The log information can specify the VM identifier associated with the newly added VM. In one or more embodiments, the host controller can use the _DSM method defined in the BIOS and the log information to update the CMT.

[0122] As discussed above, the BIOS can be firmware (e.g., computer instructions) executed by a host controller or other processor of the production host to provide hardware management (e.g., boot process, hardware initialization, etc.) for the production host. The virtual machine, hypervisor, OS, and / or OS agent can access, issue requests (e.g., API calls), trigger the system management mode (SMM) (e.g., an operating mode for pausing the normal execution of the production host processor to enable unobstructed and uninterrupted access to the CMT), and / or obtain information (e.g., CMT information) from the CMT included or otherwise maintained by the host controller via the BIOS. The _DSM method can refer to custom functions, procedures, or routines included in the BIOS for generating, updating, maintaining, and allowing access to the CMT or providing CMT information from the CMT.

[0123] Without departing from the embodiments disclosed herein, the CMT can be updated via other and / or additional methods to indicate that a new VM has been added.

[0124] In one or more embodiments disclosed herein, after step 330, the method proceeds to Figure 3A step 316.

[0125] In one or more alternative embodiments disclosed herein, without departing from the embodiments disclosed herein, steps 300 to 306, step 318, and steps 322 to 324 can be performed by the host controller.

[0126] As discussed above, embodiments of the present invention can be implemented using a computing device. Figure 4 A diagram of a computing device according to one or more embodiments of the present invention is shown. The computing device (400) can include one or more computer processors (402), non-persistent storage devices (404) (e.g., volatile memory such as random access memory (RAM), cache memory), persistent storage devices (406) (e.g., hard disks, optical disk drives such as compact disk (CD) drives or digital versatile disk (DVD) drives, flash memory, etc.), communication interfaces (412) (e.g., Bluetooth interfaces, infrared interfaces, network interfaces, optical interfaces, etc.), input devices (410), output devices (408), and numerous other elements (not shown) and functions. Each of these components is described below.

[0127] In one embodiment of the present invention, the computer processor (402) can be an integrated circuit for processing instructions. For example, the computer processor can be one or more cores or micro-cores of a processor. The computing device (400) can also include one or more input devices (410), such as a touch screen, keyboard, mouse, microphone, touchpad, electronic pen, or any other type of input device. Additionally, the communication interface (412) can include an integrated circuit for connecting the computing device (400) to a network (not shown) (e.g., a local area network (LAN), a wide area network (WAN) such as the Internet, a mobile network, or any other type of network) and / or another device (such as another computing device).

[0128] In one embodiment of the present invention, the computing device (400) can include one or more output devices (408), such as a screen (e.g., a liquid crystal display (LCD), a plasma display, a touch screen, a cathode ray tube (CRT) monitor, a projector, or other display device), a printer, an external storage device, or any other output device. The one or more output devices can be the same as or different from the input devices. The input devices and output devices can be connected locally or remotely to the computer processor (402), the non-persistent storage device (404), and the persistent storage device (406). There are many different types of computing devices, and the input devices and output devices mentioned above can take other forms.

[0129] As used herein, the phrase "operatively connected" or "operably connected" means that there is a direct or indirect connection between elements / components / devices that allows the elements to interact in some way. For example, the phrase "operatively connected" can refer to any direct connection (e.g., a direct wired connection between two devices or components) or an indirect connection (e.g., a wired and / or wireless connection between any number of devices or components that operatively connect the devices). Thus, any path through which information can travel can be considered an operative connection.

[0130] As used herein, an identifier can refer to a unique combination of alphanumeric characters that specifies a particular entity associated with the entity. An identifier can be local (usable by a single component) or global (usable by all components).

[0131] As used herein, an entity programmed or configured to perform a function (e.g., a step, an action, etc.) refers to one or more hardware devices (e.g., a processor, a digital signal processor, a field programmable gate array, an application specific integrated circuit, etc.) that provide the function. The hardware device can be programmed to achieve this by, for example, computer instructions (e.g., computer code) capable of causing the hardware device to provide the function. In another example, the hardware device can be programmed to achieve this by having circuitry that has been adapted (e.g., modified) to perform the function. An entity programmed to perform a function does not include computer instructions independent of any hardware device. The computer instructions can be used to program the hardware device, which, when programmed, provides the function.

[0132] The problems discussed above should be understood as examples of problems solved by embodiments of the present invention, and the present invention should not be limited to solving the same / similar problems. The disclosed present invention is widely applicable to solving a range of problems beyond those discussed herein.

[0133] One or more embodiments of the present invention can be implemented using instructions executed by one or more processors of a computing device. Additionally, such instructions can correspond to computer-readable instructions stored on one or more non-transitory computer-readable media.

[0134] Although the present invention has been described with respect to a limited number of embodiments, those skilled in the art who have benefited from this disclosure will understand that other embodiments can be conceived without departing from the scope of the present invention as claimed. Therefore, the scope of the present invention should be limited only by the appended claims.

Claims

1. A method for configuring components, comprising: Identifying, by an operating system (OS) agent of a production host, a first change event, wherein: The production host includes a plurality of components, and The plurality of components are used by a plurality of virtual machines (VMs) executing on the production host; Making a first determination that the first change event is associated with a component among the plurality of components; In response to making the first determination, updating a component mapping table based on the first change event; Identifying a second change event; Making a second determination that the second change event is associated with a VM among the plurality of VMs; In response to making the second determination, updating the component mapping table based on the second change event; and Providing the updated component mapping to the OS of the production host and the plurality of VMs, wherein the component mapping enables the plurality of VMs to use the plurality of components to perform computer-implemented services.

2. The method according to claim 1, wherein the plurality of components include peripheral devices operatively connected to the production host via Peripheral Component Interconnect (PCI) and Peripheral Component Interconnect Express (PCIe) connections.

3. The method according to claim 2, wherein the component mapping table includes an entry for each of the plurality of components, the entry specifying: A component slot identifier, Bus device function (BDF) information, A component type among component types, A mapped VM identifier, and A status.

4. The method according to claim 3, wherein the mapped VM identifier includes one selected from the group consisting of: A VM identifier associated with the VM among the plurality of VMs that is mapped to the corresponding component among the plurality of components; and An indication that the corresponding component among the plurality of components is not mapped to any of the plurality of VMs.

5. The method according to claim 3, wherein the status specifies whether the component is active or inactive.

6. The method according to claim 3, wherein the component types include: A network interface controller, A host bus adapter, A graphics card, and A solid state drive.

7. The method according to claim 1, wherein updating the component mapping table based on the first change event includes: Making a third determination that the first change event is associated with an addition; In response to the third determination, making a fourth determination that the component is not specified in the component mapping table; And In response to the fourth determination, generating a new entry in the component mapping table associated with the component.

8. The method according to claim 1, wherein updating the component mapping table based on the first change event includes: Making a third determination that the first change event is associated with an addition; In response to the third determination, making a fourth determination that the component is specified in the component mapping table; And In response to the fourth determination, updating the entry in the component mapping table associated with the component to change the status associated with the component from inactive to active.

9. The method according to claim 1, wherein updating the component mapping table based on the second change event includes: Make a third determination: The second change event is associated with a VM reconfiguration associated with a second component among the plurality of components; And In response to the third determination, update the entry associated with the second component to include a new mapped VM identifier.

10. The method according to claim 1, further comprising: Before identifying the first change event and after the production host is initially started: Generate an initial component mapping table associated with the production host; Obtain configuration information associated with the production host; Make a third determination: The configuration information is associated with a default configuration; In response to the third determination, update the component mapping table based on the default configuration; And Provide an initial component mapping to the OS of the production host and the plurality of VMs, wherein the initial component mapping enables the plurality of VMs to use the plurality of components to perform computer-implemented services.

11. A non-transitory computer-readable medium comprising computer-readable program code that, when executed by a computer processor, enables the computer processor to perform a method for configuring components, the method comprising: Identify a first change event by an operating system (OS) agent of a production host, wherein: The production host includes a plurality of components, and The plurality of components are used by a plurality of virtual machines (VMs) executing on the production host; Make a first determination: The first change event is associated with a component among the plurality of components; In response to making the first determination, update the component mapping table based on the first change event; Identify a second change event; Make a second determination: The second change event is associated with a VM among the plurality of VMs; In response to making the second determination, update the component mapping table based on the second change event; and Provide an updated component mapping to the OS of the production host and the plurality of VMs, wherein the component mapping enables the plurality of VMs to use the plurality of components to perform computer-implemented services.

12. The non-transitory computer-readable medium according to claim 11, wherein the plurality of components include peripheral devices operatively connected to the production host via Peripheral Component Interconnect (PCI) and Peripheral Component Interconnect Express (PCIe) connections.

13. The non-transitory computer-readable medium according to claim 12, wherein the component mapping table includes an entry for each component among the plurality of components, the entry specifying: Component slot identifier, Bus device function (BDF) information, Component type among component types, Mapped VM identifier, and Status.

14. The non-transitory computer-readable medium according to claim 13, wherein the mapped VM identifier includes one selected from the group consisting of: The VM identifier associated with the VM among the plurality of VMs that is mapped to the corresponding component among the plurality of components; and An indication that the corresponding component among the plurality of components is not mapped to any of the plurality of VMs.

15. The non-transitory computer-readable medium of claim 13, wherein the status specifies whether the component is active or inactive.

16. The non-transitory computer-readable medium of claim 13, wherein the component types include: a network interface controller, a host bus adapter, a graphics card, and a solid state drive.

17. The non-transitory computer-readable medium of claim 11, wherein updating the component mapping table based on the first change event includes: making a third determination that the first change event is associated with an addition; in response to the third determination, making a fourth determination that the component is not specified in the component mapping table; and in response to the fourth determination, generating a new entry in the component mapping table associated with the component.

18. The non-transitory computer-readable medium of claim 11, wherein updating the component mapping table based on the first change event includes: making a third determination that the first change event is associated with an addition; in response to the third determination, making a fourth determination that the component is specified in the component mapping table; and in response to the fourth determination, updating the entry in the component mapping table associated with the component to change the status associated with the component from inactive to active.

19. The non-transitory computer-readable medium of claim 11, wherein updating the component mapping table based on the second change event includes: making a third determination that the second change event is associated with a VM reconfiguration associated with a second component of the plurality of components; and in response to the third determination, updating the entry associated with the second component to include a new mapped VM identifier.

20. The non-transitory computer-readable medium of claim 11, further comprising: before identifying the first change event and after the production host is initially booted: generating an initial component mapping table associated with the production host; obtaining configuration information associated with the production host; making a third determination that the configuration information is associated with a default configuration; in response to the third determination, updating the component mapping table based on the default configuration; and providing an initial component mapping to the OS of the production host and the plurality of VMs, wherein the initial component mapping enables the plurality of VMs to use the plurality of components to perform computer-implemented services.

Images