A Linux LXC-based automotive cockpit domain control operating system deployment method

Abstract

The application relates to the field of automobile electronics, and provides a Linux LXC-based automobile cabin domain control operation system deployment method. The method first starts a Linux LXC container in a main operation system of a cabin domain controller to provide a light-weight resource isolation environment; then configures and runs a light-weight Linux environment specially built based on a Yocto project in the LXC container; and finally runs an automobile instrument application program in the customized Linux environment. The application combines the LXC container and the customized Yocto environment to provide an isolated running environment with low resource consumption, fast startup speed and meeting functional safety and real-time requirements for automobile instrument functions, realizes simplification and performance optimization of the cabin domain control system architecture, and reduces software cost.

Description

Technical Field

[0001] This invention relates to the field of automotive electronics technology, and more specifically, to a method for deploying an automotive cockpit domain control operating system based on Linux LXC. Background Technology

[0002] Currently, automotive cockpits are evolving towards greater integration, with traditional standalone infotainment systems and digital instrument clusters being consolidated into a single hardware platform—the cockpit domain controller. However, the underlying operating system requirements of different functional domains within the cockpit vary significantly. Infotainment systems are typically developed based on user-friendly open-source systems (such as Android or general-purpose Linux), while digital instrument clusters, directly related to driving safety, have extremely high requirements for functional safety, real-time performance, and reliability, traditionally requiring a dedicated real-time operating system that meets functional safety standards.

[0003] To meet these differentiated needs, a mainstream solution is to use a hypervisor technology on the cockpit domain controller, such as the QNX Hypervisor provided by a certain manufacturer. This creates virtual machines on top of the hardware layer, running the QNX system (for the instrument cluster) and the Android system (for infotainment). This solution achieves hardware integration and functional safety isolation, but its core components, the QNX operating system and its hypervisor, are both commercial closed-source software, resulting in high usage costs. This has become a significant factor restricting the widespread adoption of the solution and the optimization of overall vehicle costs.

[0004] To optimize costs, the industry has explored alternative technological approaches. For example, some have considered adopting entirely open-source solutions or running instrument cluster functions on lightweight virtualization technologies such as containers. However, these solutions face challenges in balancing resource isolation, real-time performance, and system complexity to meet automotive-grade requirements. While existing technologies involve using container technology in automotive environments, their design focuses primarily on improving startup speed or enabling flexible deployment. They do not effectively address the core issue at the system architecture level: how to completely replace a dedicated real-time operating system while ensuring functional safety and real-time performance. Summary of the Invention

[0005] This invention addresses the technical problems existing in the prior art by providing a method for deploying an automotive cockpit domain controller operating system based on Linux LXC. By using LXC (Linux Containers), an operating system-level virtualization technology natively supported by the Linux kernel, an isolated operating environment is provided on the automotive cockpit domain controller to provide instrument functions with both functional safety and real-time requirements, while also reducing software costs.

[0006] According to a first aspect of the present invention, a method for deploying an automotive cockpit domain control operating system based on Linux LXC is provided, comprising: Start the LXC container in the main operating system of the cockpit domain controller; In the LXC container, a lightweight Linux environment built based on the Yocto project is configured and run; The automotive instrumentation application runs in the lightweight Linux environment built on Yocto.

[0007] Based on the above technical solution, the present invention can also be improved as follows.

[0008] Optionally, starting the LXC container in the main operating system of the cockpit domain controller includes: In the main operating system of the cockpit domain controller, a container runtime environment containing a root file system and configuration files is created for the LXC container.

[0009] Optionally, configuring and running a lightweight Linux environment built based on the Yocto project within the LXC container includes: In the main operating system, start the build environment based on the Yocto project and generate the Yocto root file system; Deploy the generated Yocto root file system to the specified storage path of the host operating system.

[0010] Optionally, starting the build environment based on the Yocto project and generating the Yocto root file system includes: Create a custom Yocto layer for automotive instrument panel functions; In the configuration of the Yocto customization layer, enable the LXC package, kernel virtualization features, and user namespace functionality; Based on the configuration, a build is performed to generate a minimal Yocto root file system image containing the LXC runtime environment.

[0011] Optionally, deploying the generated Yocto root file system to a specified storage path of the host operating system includes: Extract the minimized Yocto root file system image to the target directory under the main operating system data partition; The device file system of the main operating system is mounted to the corresponding path under the target directory to provide a hardware access interface for the Yocto environment.

[0012] Optionally, after deployment and mounting are complete, the lightweight Linux environment built on Yocto is run, including: Perform a root directory switch operation to change the root directory of the current process to the target directory, thereby starting an independent Yocto Linux user space environment within the main operating system.

[0013] Optionally, the method also includes: The input events and display outputs of the instrument application within the LXC container are routed and managed to ensure normal hardware interaction between the instrument application and the cockpit domain controller.

[0014] According to a second aspect of the present invention, a deployment system for an automotive cockpit domain control operating system based on Linux LXC is provided, comprising: A container startup module is used to start a Linux LXC container in the host operating system of the cockpit domain controller. The environment configuration and operation module is used to configure and run a lightweight Linux environment based on the Yocto project in the LXC container. The application runtime module is used to run the automotive instrumentation application in the lightweight Linux environment built on Yocto.

[0015] According to a third aspect of the present invention, an electronic device is provided, including a memory and a processor, wherein the processor is configured to implement the steps of the above-described deployment method of the Linux LXC-based automotive cockpit domain control operating system when executing a computer management program stored in the memory.

[0016] According to a fourth aspect of the present invention, a computer-readable storage medium is provided, on which a computer management class program is stored, wherein when the computer management class program is executed by a processor, the steps of the above-described deployment method of the automotive cockpit domain control operating system based on Linux LXC are implemented.

[0017] This invention provides a method, system, electronic devices, and storage medium for deploying an automotive cockpit domain controller operating system based on Linux LXC. First, a lightweight LXC container is started within the main operating system of the cockpit domain controller to provide resource isolation. Then, a highly streamlined Linux environment specifically customized by the Yocto project is configured and run within this container. Finally, the automotive instrument cluster application is deployed and runs within this customized environment. This invention achieves isolation through an LXC container instead of a traditional hypervisor, reducing system resource overhead and startup time. Simultaneously, by using a dedicated Linux environment built with Yocto to replace general-purpose commercial or distribution systems, system redundancy is significantly reduced, and operational efficiency and determinism are improved. Thus, while ensuring the functional safety and real-time performance required for instrument cluster functionality, better resource utilization and system performance are achieved, and software costs are reduced. Attached Figure Description

[0018] Figure 1 A flowchart illustrating a method for deploying a Linux LXC-based automotive cockpit domain control operating system, provided by this invention. Figure 2 A schematic diagram comparing the system architecture of a traditional solution and the improved solution of this invention in a certain implementation scenario; Figure 3 A flowchart illustrating a method for deploying a Linux LXC-based automotive cockpit domain control operating system, as provided in one embodiment. Figure 4 A block diagram of a deployment system for an automotive cockpit domain control operating system based on Linux LXC, provided by this invention; Figure 5 A schematic diagram of the hardware structure of a possible electronic device provided by the present invention; Figure 6 This is a schematic diagram of the hardware structure of a possible computer-readable storage medium provided by the present invention. Detailed Implementation

[0019] The specific embodiments of the present invention will be described in further detail below with reference to the accompanying drawings and examples. The following examples are for illustrative purposes only and are not intended to limit the scope of the invention.

[0020] In this embodiment of the invention, when collecting, processing, and storing user personal information (such as images, behavioral characteristics, etc.), the implementation of the technical solution strictly adheres to the principles of legality, legitimacy, and necessity, as well as the core rule of "notification-consent." Specifically, before information collection, the system clearly informs the user of the purpose, method, scope, and usage rules of information collection through an interactive interface, and requires the user's active authorization and consent. The entire information processing process employs data encryption, access control, and other technical measures to ensure information security, and establishes mechanisms to facilitate users' exercise of their rights (such as querying, correcting, withdrawing consent, and deleting information). For exceptions stipulated by law (such as those necessary for fulfilling statutory duties or responding to public health emergencies), their application is strictly limited to the scope and limits authorized by law, ensuring that the technical solution does not contain any content that violates the law, social morality, or harms the public interest.

[0021] Figure 1 This invention provides a flowchart of a method for deploying a vehicle cockpit domain control operating system based on Linux LXC. Figure 2 This is a schematic diagram comparing the system architecture of a traditional solution and the improved solution of this invention in a specific implementation scenario. Figure 1 and Figure 2 As shown, the method includes steps S1 to S3.

[0022] S1, starts the LXC container in the main operating system of the cockpit domain controller.

[0023] This step starts a Linux LXC container in the main operating system of the cockpit domain controller. Leveraging the virtualization capabilities provided by the main operating system kernel, such as namespaces and control groups, it creates an initial, resource-isolated sandbox for the subsequent runtime environment. This step, by creating a container runtime environment containing an independent root file system and configuration files, establishes a basic process space isolated from the main system and other functions for the automotive instrument application. This is the primary technical operation for achieving lightweight virtualization.

[0024] S2, within the LXC container, configure and run a lightweight Linux environment built on the Yocto project.

[0025] This step configures and runs a lightweight Linux environment built on the Yocto project within an LXC container, which is crucial for enabling feature customization. The Yocto Project is an open-source collaborative project for Linux systems, providing a powerful set of tools, templates, and methodologies. This step begins by using the Yocto project to customize a minimal Linux root filesystem specifically for automotive instrument cluster functionality, requiring the enabling of necessary kernel features such as LXC support. After the build is complete, the generated system image is deployed and mounted to the target path of the LXC container. Then, a root directory switch operation is performed to activate a separate, highly streamlined, and dedicated Linux userspace instance within the LXC container.

[0026] S3 runs the automotive instrumentation application within the lightweight Linux environment built on Yocto.

[0027] This step, running the automotive instrument cluster application in a lightweight Linux environment built on Yocto, is the ultimate goal of the entire solution. Within this lightweight Linux environment, the automotive instrument cluster application, designed specifically for functional safety and real-time requirements, is started and runs. Because the application runs in a dedicated environment customized by Yocto and isolated via an LXC container, it achieves a deterministic execution environment and the necessary operational isolation guarantees with low resource overhead, thereby meeting the functional requirements of the automotive instrument cluster.

[0028] Understandably, given the deficiencies in the background technology, this invention proposes a method for deploying an automotive cockpit domain controller operating system based on Linux LXC. This method first starts a lightweight LXC container within the main operating system of the cockpit domain controller to provide resource isolation. Then, it configures and runs an extremely streamlined Linux environment specifically customized by the Yocto project within this container. Finally, it deploys the automotive instrument cluster application within this customized environment.

[0029] like Figure 2 As shown on the left, the traditional solution relies on the QNX Hypervisor to create two independent virtual machines above the hardware layer, running a complete Android system and a complete QNX system respectively, to achieve hardware integration and isolation of infotainment and instrumentation functions. In contrast, as... Figure 2 As shown on the right, the present invention eliminates the QNX Hypervisor and the independent QNX system. Instead, it creates an isolated environment within a single Android main system framework using lightweight Linux LXC container technology, and runs a streamlined Linux system based on Yocto specifically in this container to carry the instrumentation functions.

[0030] This invention achieves isolation through LXC containers instead of traditional virtual machine monitoring programs, reducing system resource overhead and startup time. At the same time, by using a dedicated Linux environment built with Yocto to replace general commercial or distribution systems, system redundancy can be significantly reduced, and operating efficiency and determinism can be improved. Thus, while ensuring the functional safety and real-time performance required for instrument functions, better resource utilization and system performance are achieved, and software costs can be reduced.

[0031] Based on the above technical solutions, the embodiments of the present invention can be further improved as follows.

[0032] In one possible embodiment, step S1, which involves starting the LXC container in the main operating system of the cockpit domain controller, includes: In the main operating system of the cockpit domain controller, a container runtime environment containing a root file system and configuration files is created for the LXC container.

[0033] Combination Figure 2 As shown, within the main operating system of the cockpit domain controller, such as the Android system, an LXC container instance with an independent root file system and dedicated configuration files is created by calling the LXC toolchain. For example, the container environment is initialized by using the lxc-create command and specifying a minimal root file system template.

[0034] Understandably, this embodiment pre-builds a standardized and resource-constrained isolated sandbox for running the instrumentation application. The container's root file system ensures the integrity and independence of runtime dependencies, while the configuration file precisely defines its resource quotas and security policies. This lays a reliable and reproducible foundation for the subsequent deployment of a customized Linux environment, improving the determinism and maintainability of the entire system deployment.

[0035] In one possible embodiment, step S2, which involves configuring and running a lightweight Linux environment built on the Yocto project in the LXC container, includes sub-steps S201 to S202.

[0036] S201, In the main operating system, start the build environment based on the Yocto project and generate the Yocto root file system. Specifically, this includes: Create a custom Yocto layer for automotive instrument panel functions; In the configuration of the Yocto customization layer, enable the LXC package, kernel virtualization features, and user namespace functionality; Based on the configuration, a build is performed to generate a minimal Yocto root file system image containing the LXC runtime environment.

[0037] In this embodiment, a dedicated Yocto customization layer is created for automotive instrument cluster functions. For example, a recipe is written in the meta-cockpit-layer, and the lxc package is explicitly added to the configuration file of the meta-cockpit-layer layer, enabling the kernel's namespace and control group virtualization features. Then, a build command is executed to generate a minimal root filesystem image that has removed all unnecessary components but has integrated full LXC runtime support.

[0038] This embodiment achieves precise and in-depth customization of the runtime environment through the Yocto project. The generated image is not only extremely streamlined to save storage and memory resources, but also inherently contains all the basic support required for containerization, ensuring environmental consistency, functional integrity and reliability when running instrument applications in LXC containers, thus guaranteeing the quality and determinism of the customized system from the source.

[0039] S202, deploy the generated Yocto root file system to the specified storage path of the host operating system. Specifically, this includes: Extract the minimized Yocto root file system image to the target directory under the main operating system data partition; The device file system of the main operating system is mounted to the corresponding path under the target directory to provide a hardware access interface for the Yocto environment.

[0040] In this embodiment, the generated minimal Yocto root file system image is extracted. For example, a tar archive named core-image-minimal is extracted to a predetermined directory under the data partition of the host operating system, such as Android, for example, / data / yocto_root; then, the critical device file systems in the host operating system, such as dev, proc, and sys, are mounted to the corresponding subpaths under the target directory.

[0041] This embodiment materializes a customized lightweight operating environment into the storage space through decompression and securely bridges the hardware access interface of the main system to this environment through mounting. This provides the necessary channel for the Yocto environment to access actual hardware resources, ensuring that the instrument application running in the independent environment can interact normally with the underlying hardware of the cockpit domain controller. This is a key connection step to achieve environment nesting and functional availability.

[0042] In one possible embodiment, after deployment and mounting are complete, step S3 involves running the lightweight Linux environment built on Yocto, including: Perform a root directory switch operation to change the root directory of the current process to the target directory, thereby starting an independent Yocto Linux user space environment within the main operating system.

[0043] In this embodiment, after the file system is mounted, the chroot command is executed in the process environment of the main operating system to switch the root directory of the current process to the target directory of the deployed Yocto root file system, such as data / yocto_root, thereby restricting the process's view and switching it to the complete Linux file system hierarchy under that directory, thereby activating the independent Yocto Linux user space runtime environment.

[0044] This embodiment efficiently completes the final switch of the runtime environment through simple system calls, so that all subsequent operations are strictly limited to the customized Yocto environment. It provides the LXC container in the main operating system with a dedicated Linux runtime that is fully functional, controllable in behavior, and highly isolated from the host system, laying a direct software foundation for the stable and reliable operation of the instrument application.

[0045] In one possible embodiment, such as Figure 3 As shown, the method further includes step S4: S4. Perform routing management on the input events and display outputs of the instrument application within the LXC container to ensure normal hardware interaction between the instrument application and the cockpit domain controller.

[0046] In this embodiment, an event forwarding service is set up in the main operating system, such as a daemon process running on the Android framework. This process listens for raw input events from physical input devices (such as touch screens or steering wheels), encapsulates them, and forwards them to the instrument application in the LXC container through an inter-process communication mechanism. At the same time, the graphical interface data rendered by the instrument application in the container is passed back to the display compositor of the main operating system through shared memory or virtual graphics device channels, and finally output to the vehicle physical screen by the compositor.

[0047] This embodiment constructs an input / output bridging channel that spans the container isolation boundary, enabling instrument applications running in an independent container environment to interact transparently and with low latency with the real hardware of the cockpit domain controller. This ensures application isolation while guaranteeing normal user control and visual experience of instrument functions, achieving seamless integration between the virtualized environment and the real hardware platform.

[0048] Figure 4 A system architecture diagram of a Linux LXC-based automotive cockpit domain control operating system deployment system is provided for embodiments of the present invention, as shown below. Figure 4 As shown, a Linux LXC-based automotive cockpit domain controller operating system deployment system is applied to the cockpit domain controller, including a container startup module, an environment configuration and running module, and an application running module, wherein: A container startup module is used to start a Linux LXC container in the host operating system of the cockpit domain controller. The environment configuration and operation module is used to configure and run a lightweight Linux environment based on the Yocto project in the LXC container. The application runtime module is used to run the automotive instrumentation application in the lightweight Linux environment built on Yocto.

[0049] It is understood that the Linux LXC-based automotive cockpit domain control operating system deployment system provided by this invention corresponds to the Linux LXC-based automotive cockpit domain control operating system deployment method provided in the foregoing embodiments. The relevant technical features of the Linux LXC-based automotive cockpit domain control operating system deployment system can be referred to the relevant technical features of the Linux LXC-based automotive cockpit domain control operating system deployment method, and will not be repeated here.

[0050] Please see Figure 5 , Figure 5 This is a schematic diagram illustrating an embodiment of the electronic device provided in this invention. For example... Figure 5As shown, this embodiment of the invention provides an electronic device 500, including a memory 510, a processor 520, and a computer program 511 stored in the memory 510 and executable on the processor 520. When the processor 520 executes the computer program 511, it performs the following steps: S1, Start the LXC container in the main operating system of the cockpit domain controller; S2, In the LXC container, configure and run a lightweight Linux environment built based on the Yocto project; S3 runs the automotive instrumentation application within the lightweight Linux environment built on Yocto.

[0051] Please see Figure 6 , Figure 6 This is a schematic diagram illustrating an embodiment of a computer-readable storage medium provided by the present invention. (See diagram below.) Figure 6 As shown, this embodiment provides a computer-readable storage medium 600, on which a computer program 511 is stored. When the computer program 511 is executed by a processor, it performs the following steps: S1, Start the LXC container in the main operating system of the cockpit domain controller; S2, In the LXC container, configure and run a lightweight Linux environment built based on the Yocto project; S3 runs the automotive instrumentation application within the lightweight Linux environment built on Yocto.

[0052] This invention provides a method, system, electronic device, and storage medium for deploying an automotive cockpit domain controller operating system based on Linux LXC. First, a lightweight Linux LXC container is started within the main operating system of the cockpit domain controller to provide resource isolation. Then, within this container, a highly streamlined Linux root file system optimized specifically for instrument cluster functions is custom-built using the Yocto project and runs within it, thus forming a highly customized lightweight runtime environment. Finally, the automotive instrument cluster application is directly deployed and executed within this customized environment. This invention utilizes LXC container technology to achieve lower resource overhead and faster startup speed than traditional virtual machines. Simultaneously, the dedicated Linux environment built using Yocto ensures system minimization and determinism. While meeting the functional safety and real-time requirements of the instrument cluster functions, it effectively improves the overall resource utilization efficiency, deployment flexibility, and operational reliability of the system.

[0053] It should be noted that the descriptions of each embodiment in the above embodiments have different focuses. For parts that are not described in detail in a certain embodiment, please refer to the relevant descriptions in other embodiments.

[0054] Those skilled in the art will understand that embodiments of the present invention can be provided as methods, systems, or computer program products. Therefore, the present invention can take the form of a completely hardware embodiment, a completely software embodiment, or an embodiment combining software and hardware aspects. Furthermore, the present invention can take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, etc.) containing computer-usable program code.

[0055] This invention is described with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the invention. It will be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, special-purpose computer, embedded computer, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, generate instructions for implementing the flowchart illustrations. Figure 1 One or more processes and / or boxes Figure 1 A device that provides the functions specified in one or more boxes.

[0056] These computer program instructions may also be stored in a computer-readable storage medium that can direct a computer or other programmable data processing device to function in a particular manner, such that the instructions stored in the computer-readable storage medium produce an article of manufacture including instruction means, which are implemented in a process Figure 1 One or more processes and / or boxes Figure 1 The function specified in one or more boxes.

[0057] These computer program instructions may also be loaded onto a computer or other programmable data processing equipment to cause a series of operational steps to be performed on the computer or other programmable equipment to produce a computer-implemented process, thereby providing instructions that execute on the computer or other programmable equipment for implementing the process. Figure 1 One or more processes and / or boxes Figure 1 The steps of the function specified in one or more boxes.

[0058] Although preferred embodiments of the invention have been described, those skilled in the art, upon learning the basic inventive concept, can make other changes and modifications to these embodiments. Therefore, the appended claims are intended to be interpreted as including both the preferred embodiments and all changes and modifications falling within the scope of the invention.

[0059] Obviously, those skilled in the art can make various modifications and variations to this invention without departing from its spirit and scope. Therefore, if these modifications and variations fall within the scope of the claims of this invention and their equivalents, this invention also intends to include these modifications and variations.

Claims

1. A method for deploying a vehicle cockpit domain control operating system based on Linux LXC, characterized in that, include: Start the LXC container in the main operating system of the cockpit domain controller; In the LXC container, a lightweight Linux environment built based on the Yocto project is configured and run; The automotive instrumentation application runs in the lightweight Linux environment built on Yocto.

2. The method for deploying a Linux LXC-based automotive cockpit domain control operating system according to claim 1, characterized in that, The step of starting the LXC container in the main operating system of the cockpit domain controller includes: In the main operating system of the cockpit domain controller, a container runtime environment containing a root file system and configuration files is created for the LXC container.

3. A method for deploying a Linux LXC-based automotive cockpit domain control operating system according to claim 1 or 2, characterized in that, The process of configuring and running a lightweight Linux environment based on the Yocto project within the LXC container includes: In the main operating system, start the build environment based on the Yocto project and generate the Yocto root file system; Deploy the generated Yocto root file system to the specified storage path of the host operating system.

4. The method for deploying a vehicle cockpit domain control operating system based on Linux LXC according to claim 3, characterized in that, The process of launching the Yocto project-based build environment and generating the Yocto root file system includes: Create a custom Yocto layer for automotive instrument panel functions; In the configuration of the Yocto customization layer, enable the LXC package, kernel virtualization features, and user namespace functionality; Based on the configuration, a build is performed to generate a minimal Yocto root file system image containing the LXC runtime environment.

5. The method for deploying a Linux LXC-based automotive cockpit domain control operating system according to claim 4, characterized in that, Deploying the generated Yocto root file system to the specified storage path of the main operating system includes: Extract the minimized Yocto root file system image to the target directory under the main operating system data partition; The device file system of the main operating system is mounted to the corresponding path under the target directory to provide a hardware access interface for the Yocto environment.

6. The method for deploying a Linux LXC-based automotive cockpit domain control operating system according to claim 5, characterized in that, After deployment and mounting are complete, run the lightweight Linux environment built on Yocto, including: Perform a root directory switch operation to change the root directory of the current process to the target directory, thereby starting an independent Yocto Linux user space environment within the main operating system.

7. The method for deploying a vehicle cockpit domain control operating system based on Linux LXC according to claim 1, characterized in that, The method also includes: The input events and display outputs of the instrument application within the LXC container are routed and managed to ensure normal hardware interaction between the instrument application and the cockpit domain controller.

8. A deployment system for an automotive cockpit domain controller operating system based on Linux LXC, applied to a cockpit domain controller, characterized in that, include: A container startup module is used to start a Linux LXC container in the host operating system of the cockpit domain controller. The environment configuration and operation module is used to configure and run a lightweight Linux environment based on the Yocto project in the LXC container. The application runtime module is used to run the automotive instrumentation application in the lightweight Linux environment built on Yocto.

9. An electronic device, characterized in that, It includes a memory and a processor, wherein the processor is used to implement the steps of the Linux LXC-based automotive cockpit domain control operating system deployment method as described in any one of claims 1-7 when executing computer management programs stored in the memory.

10. A computer-readable storage medium, characterized in that, It stores computer management programs, which, when executed by a processor, implement the steps of the Linux LXC-based automotive cockpit domain control operating system deployment method as described in any one of claims 1-7.

Images