WO2023098569A1

WO2023098569A1 - Patch processing method and apparatus, and computer device

Info

Publication number: WO2023098569A1
Application number: PCT/CN2022/134180
Authority: WO
Inventors: 宋东匡; 李佩聪; 樊文跃
Original assignee: 华为技术有限公司
Priority date: 2021-12-01
Filing date: 2022-11-24
Publication date: 2023-06-08
Also published as: CN116204216A

Abstract

Provided in the present application are a patch processing method and apparatus, and a computer device. The computer device stores a first program and a firmware program of the computer device, wherein the firmware program comprises a firmware starting program and a firmware running program. The method comprises: a firmware running program acquiring a firmware patch, wherein the firmware patch is from a first program; and the firmware running program executing the firmware patch, and the firmware patch taking effect. Therefore, a fault of a computer device is handled, or an update/upgrade of firmware is realized. Since a firmware program of the computer device is not updated during the process, there is no need to restart the computer device, and thus a service of the computer device is not affected.

Description

Patch processing method, device and computer equipment

This application claims the priority of the Chinese patent application with application number 202111455778.8 and application title "patch processing method, device and computer equipment" filed with China Patent Office on December 01, 2021, the entire contents of which are incorporated by reference in this application middle.

technical field

The present application relates to the field of computer technology, in particular to a patch processing method, device and computer equipment.

Background technique

Firmware programs are an integral part of computer equipment. For example, the Basic Input Output System (BIOS) is a firmware program of computer equipment. BIOS is a bridge between the operating system (OS) and computer hardware, and is responsible for the hardware configuration when the computer is turned on. Detection, device initialization, operating system boot and providing service interface to the operating system.

After the computer equipment is powered on, the BIOS first completes the hardware initialization process of the computer equipment, and then starts the OS to execute user services. In some scenarios, the BIOS may need to be modified during the operation of the computer device. For example, when a computer device fails, the failure can be resolved by modifying the BIOS. For another example, when the BIOS needs to be updated/upgraded, the BIOS also needs to be modified. Usually, the following method is adopted: modifying the BIOS, storing the updated BIOS in the computer device, and restarting the computer device, so that the computer device executes the updated BIOS after restarting.

However, the above-mentioned process needs to restart the computer equipment, which will cause business interruption, and may even cause the risk that the computer equipment cannot be started.

Contents of the invention

The present application provides a patch processing method, device, and computer equipment, which can solve computer equipment failures or implement firmware updates/upgrades by executing firmware patches without restarting the computer equipment, thereby avoiding business interruption.

In a first aspect, the present application provides a patch processing method, and the execution subject of the method may be a computer device. The computer device stores a first program and a firmware program of the computer device, the firmware program includes a firmware startup program and a firmware running program, and the method includes: the firmware running program obtains a firmware patch, and the firmware patch comes from the first program; the firmware running program executes Firmware patch, the firmware patch takes effect.

Wherein, the firmware patch refers to a section of program written to solve computer equipment failures or to implement firmware updates/upgrades. The above-mentioned computer equipment faults may be hardware firmware, firmware program faults, etc. Firmware updates/upgrades may include, but are not limited to: improving existing firmware functions, patching vulnerabilities of existing firmware functions, adding new firmware functions, enhancing firmware stability, etc. The first program may be other programs except the firmware program executed by the computer device during the running phase. In some embodiments, the first program may be an operating system. In some other embodiments, the first program may be a baseboard management controller (Baseboard Management Controller, BMC) program.

In this application, during the operation of the computer equipment, the firmware patch from the first program is acquired through the firmware running program, and the firmware patch is executed to make the patch take effect, thereby solving the failure of the computer equipment or implementing firmware update/upgrade. Since the above-mentioned process does not update the firmware program of the computer equipment, the above-mentioned process does not need to restart the computer equipment, therefore, it will not affect the business of the computer equipment.

In a possible implementation manner, the firmware running program may obtain the firmware patch in the following manner: the firmware running program obtains patch location information from the first storage space, and the patch location information is used to indicate that the firmware patch is in the second storage space storage location; the firmware running program obtains the firmware patch from the second storage space according to the patch location information.

In a possible implementation manner, before the firmware running program obtains the patch location information from the first storage space, it also includes: the first program stores the firmware patch in the second storage space; the first program stores the patch location information in the second storage space; a storage space.

In this way, the first program transfers the firmware patch to the firmware running program through the first storage space and the second storage space. Both the first storage space and the second storage space are storage spaces that can be accessed jointly by the first program and the firmware running program.

Optionally, the first storage space may be a shared memory between the first program and the firmware running program. The second storage space may be a register, a mailbox, a shared memory, and the like that are jointly accessible by the first program and the second firmware running program.

In a possible implementation manner, before the first program stores the firmware patch in the second storage space, it also includes: the first program obtains the firmware calling method; the first program determines the first storage space and the second storage space according to the firmware calling method. space.

The firmware invoking method refers to a method in which the operating system notifies/calls the firmware running program, so that the firmware running program executes the firmware patch. The firmware calling method can be divided into internal calling method and external calling method. The internal calling method refers to calling within the same processor, and the external calling method refers to calling across processors.

In a possible implementation manner, the first program may acquire the firmware calling method in the following manner: the first program receives the firmware calling method sent by the firmware program.

Taking the first program as the operating system as an example, optionally, in the startup stage of the computer device, when the firmware startup program starts and loads the operating system, the firmware startup program sends the firmware calling method to the operating system. Optionally, in the running phase of the computer device, the firmware running program sends the firmware calling method to the operating system.

In a possible implementation manner, the computer device includes at least one processor; the first program determines the first storage space and the second storage space according to a firmware calling method, including:

If the calling method of the firmware is an internal calling method, the first program determines the first storage space and the second storage space in the storage space of the first processor; the first processor runs the processor of the first program.

Taking the first program as the operating system as an example, it should be understood that if the firmware calling method is an internal calling method, it means that the firmware running program and the operating system run on the same processor, that is, both run on the first processor. Therefore, the operating system can determine the first storage space and the second storage space in the storage space of the first processor. Since the firmware running program is also executed by the first processor, the first storage space and the second storage space can also be accessed by the firmware running program.

Optionally, the second storage space may be the memory space of the first processor. The first storage space may be a preset register of the first processor.

If the calling method of the firmware is an external calling method, the first program determines the first storage space and the second storage space in the storage space accessible by the first processor and the second processor; wherein, the first processor is to run the second A processor with a program, the second processor is a processor that does not run the first program.

It should be understood that if the firmware calling method is an external calling method, it means that the firmware running program and the operating system run on different processors. Therefore, the operating system can determine the first storage space and the second storage space in the storage spaces commonly accessible by the first processor and the second processor. In this way, it is ensured that the first storage space and the second storage space can also be accessed by the firmware running program.

Optionally, the second storage space may be a shared memory space of the first processor and the second processor. The first storage space may be a preset mailbox.

In a possible implementation, the first program and the firmware running program run on the same processor, and the firmware calling method is an internal calling method; the first program and the firmware running program run on different processors, and the firmware calling method For external calls.

Wherein, different processors refer to two physically different processors, and the two processors may be of the same type or of different types. These two processors can be packaged in a system-on-chip (SoC).

In a possible implementation, the firmware calling method is an internal calling method; before the firmware running program obtains the patch location information from the first storage space, it also includes: the first program executes a preset instruction, so that the processor where the first program is located Execute the firmware runner.

Wherein, the preset instruction refers to an instruction for adjusting the execution authority of the processor.

When the firmware calling method is an internal calling method, the firmware running program and the first program run in the same processor, and the execution rights of the processor to execute the firmware running program and the first program are usually different. Therefore, by executing the preset instruction through the first program, the execution authority of the processor can be switched to the execution authority corresponding to the firmware execution program, so that the processor executes the firmware execution program.

In a possible implementation, after the firmware running program executes the firmware patch, it further includes: the firmware running program executes a preset instruction, so as to switch the execution authority of the processor to the execution authority corresponding to the first program, so that the processor continues to Execute the first program.

In a possible implementation manner, the method further includes: the firmware running program acquires the firmware patch function identifier from the first storage space; the firmware running program obtains the firmware patch function identifier from the patch location information according to the Obtaining the firmware patch in the second storage space includes: the firmware running program determines the firmware service interface corresponding to the firmware patch function identifier according to the firmware patch function identifier; through the firmware service interface according to the patch location information, and acquire the firmware patch from the second storage space.

Wherein, the firmware service interface is a software interface. For example, it may be an API interface.

In a possible implementation manner, the firmware running program may acquire the firmware patch in the following manner: the firmware running program receives a first message from the first program, where the first message includes the firmware patch.

In this manner, there is a message interaction interface between the first program and the firmware running program. The first program can deliver the firmware patch to the firmware running program through the message interaction interface.

In a possible implementation, the firmware running program may execute the firmware patch in the following manner: obtain signature information from the firmware patch; verify the integrity and/or legality of the firmware patch according to the signature information , to obtain a verification result; if the verification result is verified, execute the firmware patch.

In this implementation manner, before executing the firmware patch, the integrity and/or legality of the firmware patch is verified, and the firmware patch is executed only when the verification is passed, so as to ensure safe operation of the computer device.

In a possible implementation, the firmware running program can execute the firmware patch in the following manner: determine the file format type of the firmware patch, the file format type is binary type or bytecode type; if the file format type is byte code type, then parse and execute the firmware patch to make the firmware patch take effect; if the file format type is binary type, execute the firmware patch to make the firmware patch take effect.

In this implementation, the firmware running program adopts different execution methods for different file format types by judging the file format type of the firmware patch, so that the application scheme is not only applicable to the firmware patch in the binary format, but also applicable to the bytecode format The firmware patch makes the application scenarios more extensive.

In a second aspect, the present application provides a patch processing device, including: a first processing module and a second processing module; wherein the second processing module is used to obtain a firmware patch, the firmware patch comes from the first processing module, The second processing module is also used to execute the firmware patch, and the firmware patch takes effect.

In a possible implementation manner, the second processing module is specifically configured to: acquire patch location information from the first storage space, where the patch location information is used to indicate the storage location of the firmware patch in the second storage space; The patch location information is used to obtain the firmware patch from the second storage space.

In a possible implementation manner, the first processing module is configured to: store the firmware patch in the second storage space, and store the patch location information in the first storage space.

In a possible implementation manner, the first processing module is further configured to: acquire a firmware calling method; and determine the first storage space and the second storage space according to the firmware calling method.

In a possible implementation manner, the first processing module is specifically configured to: receive the firmware calling manner sent by the second processing module.

In a possible implementation manner, the patch processing apparatus is applied to computer equipment, and the computer equipment includes at least one processor; the first processing module is specifically configured to: if the firmware calling method is an internal calling method, then determining said first memory space and said second memory space in a memory space of a first processor; or,

If the calling method of the firmware is an external calling method, then determining the first storage space and the second storage space in a storage space commonly accessible by the first processor and the second processor;

Wherein, the first processor runs the first processing module, and the second processor does not run the first processing module.

In a possible implementation manner, the first processing module and the second processing module run in the same processor, and the firmware calling method is the internal calling method; the first processing module and the second processing module The two processing modules run in different processors, and the firmware calling method is the external calling method.

In a possible implementation manner, the firmware calling method is the internal calling method; the first processing module is further configured to: execute a preset instruction, so that the processor where the first processing module is located executes the Second processing module.

In a possible implementation manner, the second processing module is further configured to: obtain the firmware patch function identifier from the first storage space; determine the corresponding A firmware service interface; acquiring the firmware patch from the second storage space through the firmware service interface according to the patch location information.

In a possible implementation manner, the second processing module is specifically configured to: receive a first message from the first processing module, where the first message includes the firmware patch.

In a possible implementation manner, the first processing module is an operating system OS; or, the first processing module is a baseboard management controller (BMC) program.

In a third aspect, the present application provides a computer device, including:

one or more processors,

and, memory; where,

The memory stores a computer program; the one or more processors run the computer program to implement the method described in the first aspect or any possible implementation manner of the first aspect.

In a fourth aspect, the present application provides a chip, including:

one or more processors,

and, memory; where,

In a fifth aspect, the present application provides a computer-readable storage medium, the computer-readable storage medium stores a computer program, and when the computer program is executed, any possible Implement the method described in the manner.

In a sixth aspect, the present application provides a computer program product, where the computer program product includes a computer program, and when the computer program is run, it implements the first aspect or any possible implementation of the first aspect. method.

The present application provides a patch processing method, device, and computer equipment. The computer equipment stores a first program and a firmware program of the computer equipment. The firmware program includes a firmware startup program and a firmware running program. The method includes: the firmware running program acquires a firmware patch, The firmware patch comes from the first program; the firmware running program executes the firmware patch, and the firmware patch takes effect, so as to solve computer equipment failure or implement firmware update/upgrade. Since the above-mentioned process does not update the firmware program of the computer equipment, the above-mentioned process does not need to restart the computer equipment, therefore, it will not affect the business of the computer equipment.

Description of drawings

FIG. 1 is a schematic diagram of a hardware structure of a computer device provided by an embodiment of the present application;

FIG. 2 is a schematic diagram of a layered architecture of a computer device provided by an embodiment of the present application;

FIG. 3 is a schematic diagram of the running sequence of the computer equipment provided by the embodiment of the present application;

FIG. 4 is a schematic flowchart of a patch processing method provided in an embodiment of the present application;

FIG. 5 is a schematic diagram of a manner in which a firmware running program provided by an embodiment of the present application obtains a firmware patch;

FIG. 6 is a schematic diagram of another way for the firmware running program to obtain the firmware patch provided by the embodiment of the present application;

FIG. 7 is a schematic diagram of the running state of a computer device provided by the embodiment of the present application;

FIG. 8 is a schematic diagram of another computer device operating state provided by the embodiment of the present application;

FIG. 9 is a schematic flow chart of another patch processing method provided by the embodiment of the present application;

FIG. 10 is a schematic flowchart of another patch processing method provided by the embodiment of the present application;

FIG. 11 is a schematic diagram of an interaction process between an operating system and a firmware program provided by an embodiment of the present application;

FIG. 12 is a schematic structural diagram of a patch processing device provided by an embodiment of the present application.

Detailed ways

In this application, computer equipment refers to a machine that can perform number crunching. Computer equipment includes but is not limited to: mobile phone (cellphone), smart phone (smartphone), computer (computer), tablet computer (tablet computer), wearable device (wearable device), personal digital assistant (personal digital assistant, PDA), Mobile Internet device (mobile internet device, MID), IoT device, e-book reader (e-book reader), server, etc.

In order to facilitate the understanding of the technical solution of the present application, firstly, the structure of the computer equipment will be described with reference to FIG. 1 .

FIG. 1 is a schematic diagram of a hardware structure of a computer device provided by an embodiment of the present application. As shown in FIG. 1 , a computer device 100 includes: a processor 101 and a memory 102 . Optionally, a processor 101, a memory 102, and a communication interface 103. Wherein, the processor 101, the memory 102, and the communication interface 103 are communicatively connected to each other. For example, the processor 101, the memory 102, and the communication interface 103 may be connected by a network to realize a communication connection. Alternatively, as shown in FIG. 1 , the above computer device 100 may further include a bus 104 . The processor 101 , the memory 102 , and the communication interface 103 are connected to each other through the bus 104 .

Wherein, the number of processors 101 may be one or more. Each processor 101 may include one or more processing cores. The processor 101 may also be called a processing unit, a processing subsystem, and the like. The processor 101 may include at least one of the following: a central processing unit (central processing unit, CPU), an application specific integrated circuit (application specific integrated circuit, ASIC), an application processor (application processor, AP), a modem processing processor, graphics processing unit (graphics processing unit, GPU), image signal processor (image signal processor, ISP), controller, video codec, digital signal processor (digital signal processor, DSP), baseband processor, neural Network processor (neural-network processing unit, NPU), etc.

The memory 102 may include: a non-volatile memory (non-volatile memory, NVM) and a random access memory (random access memory, RAM).

Wherein, the non-volatile memory can be read-only memory (read-only memory, ROM), such as programmable read-only memory (programmable read-only memory, PROM), erasable programmable read-only memory (erasable programmable read-only memory) only memory, EPROM), electrically erasable programmable read-only memory (electrically erasable programmable read-only memory, EEPROM), etc. The non-volatile memory may also be a flash memory, a magnetic memory, such as a magnetic tape, a floppy disk, a hard disk, and the like. The non-volatile memory can also be an optical disk. When the computer equipment is powered off, the data stored in the non-volatile memory will not be lost.

Random access memory, also called main memory, is an internal memory that directly exchanges data with the processor 101 . It can be read and written at any time, and the speed is very fast, and it is usually used as a temporary data storage medium for operating systems or other running programs. When RAM is working, information can be written (stored) or read (taken out) from any specified address at any time. The biggest difference between it and ROM is the volatility of data, that is, the stored data will be lost once the power is turned off. RAM is used in computers and digital systems to temporarily store programs, data, and intermediate results.

The communication interface 103 uses a transceiver module such as but not limited to a transceiver to implement communication between the computer device 100 and other devices or communication networks. For example, in the embodiment of the present application, the computer device can acquire the firmware patch through the communication interface 103 .

The bus 104 may be an industry standard architecture (industry standard architecture, ISA) bus, a peripheral component interconnect (peripheral component, PCI) bus, or an extended industry standard architecture (extended industry standard architecture, EISA) bus, etc. The bus can be divided into address bus, data bus, control bus and so on. For ease of representation, the buses in the drawings of the present application are not limited to only one bus or one type of bus.

It can be understood that, the structure illustrated in the embodiment of the present application does not constitute a specific limitation on the electronic device 100 . In other embodiments of the present application, the electronic device 100 may include more or fewer components than shown in the figure, or combine certain components, or separate certain components, or adopt different component arrangements.

In this embodiment of the present application, the memory 102 may be used to store firmware programs, operating systems (operating system, OS), application programs, and the like. Exemplarily, the above-mentioned firmware program, operating system, application program, etc. may be stored in a non-volatile memory. The processor 101 can execute firmware programs, operating systems, application programs, etc. stored in the memory 102 to make the computer device perform certain functions.

The memory 102 may also store data, intermediate results, etc. created during the operation of the computer device. Exemplarily, the data and intermediate results created during the operation of the above-mentioned computer device may be stored in a random access memory.

In the embodiment of the present application, the firmware program may include a basic input output system (basic input output system, BIOS) and other firmware programs. The BIOS stores the most important basic input and output programs of computer equipment, self-test programs after power-on, and system self-start programs. It can read and write specific information about system settings from complementary metal oxide semiconductors (CMOS). The main function of BIOS is to provide the lowest-level and most direct hardware setting and control for computer equipment. In addition, BIOS also provides some system parameters to the operating system.

FIG. 2 is a schematic diagram of a layered architecture of a computer device provided by an embodiment of the present application. As shown in FIG. 2 , the bottom layer is the hardware layer of the computer equipment, the firmware program layer is above the hardware layer, and the operating system layer is above the firmware program layer.

Continuing to refer to FIG. 2, in the embodiment of the present application, the firmware program includes a firmware startup program (ie, boot-time firmware) and a firmware running program (ie, run-time firmware). Wherein, the firmware startup program is used to provide functions such as hardware detection, hardware configuration, hardware initialization, and operating system booting during the startup process of the computer device. The firmware running program is used to provide runtime services, system parameters, etc. to the operating system during the running of the operating system.

FIG. 3 is a schematic diagram of the running sequence of the computer device provided by the embodiment of the present application. As shown in FIG. 3 , the running process of the computer device can be divided into a startup phase and a running phase. In the startup phase, the computer device executes the firmware startup program to detect and initialize the hardware, and guide the operating system to start. After the operating system is started, the firmware startup program ends. During the run phase, the computer device executes the operating system and firmware running programs.

In the technical solution provided by this application, the firmware running program provides the operating system with the service of executing firmware patches. When the computer equipment fails or needs to be updated/upgraded, the operating system can call this service to make the firmware running program execute Firmware patch, the firmware patch takes effect, so as to solve the fault or implement firmware update/upgrade. There is no need to restart the computer equipment during this process, and the business of the computer equipment will not be affected.

The technical solutions provided by the present application will be described in detail below in conjunction with specific embodiments. The following specific embodiments may be combined with each other, and the same or similar concepts or processes may not be repeated in some embodiments.

FIG. 4 is a schematic flowchart of a patch processing method provided by an embodiment of the present application. The method in this embodiment can be executed by a computer device. The computer device stores the first program and the firmware program of the computer device. The firmware program includes a firmware running program and a firmware starting program. In some scenarios, the patch processing method described in the embodiment of the present application may also be called a firmware patch processing method, or a firmware update method, or a firmware upgrade method.

As shown in Figure 4, the method of this embodiment includes:

S401: A firmware running program acquires a firmware patch, where the firmware patch comes from the first program.

The first program may be other programs except the firmware program executed by the computer device during the running phase. In some embodiments, the first program may be an operating system. In some other embodiments, the first program may be a baseboard management controller (Baseboard Management Controller, BMC) program.

Among them, the operating system can be any one of the following: Windows, MacOS, Linux, Chrome OS, iOS, Android, Hongmeng OS, KaiOS, Ipad OS, Fuchsia OS. This embodiment does not limit it.

BMC is used to monitor and control the system hardware of computer equipment, for example, monitor the temperature, voltage, fan, power supply, etc. of the system hardware, and make corresponding adjustments to ensure that the system hardware is in a healthy operating state. The BMC program can be regarded as an independent system, which does not depend on other hardware (such as processor, memory, etc.) on the computer device, nor does it depend on BIOS, operating system, etc. Messages can be exchanged between the BMC and the BIOS.

In this embodiment of the application, a firmware patch refers to a program written to solve computer equipment failures or to implement firmware updates/upgrades. The above-mentioned computer equipment faults may be hardware firmware, firmware program faults, etc. Firmware updates/upgrades may include, but are not limited to: improving existing firmware functions, patching vulnerabilities of existing firmware functions, adding new firmware functions, enhancing firmware stability, etc. A firmware patch includes independent and complete code for realizing a certain function, without relying on other programs other than the firmware patch. Firmware patches can be in binary or bytecode file format.

For example, suppose that during the operation of the computer device, it is found that the Flash of the computer device is faulty, and the security access control bit of the Flash needs to be modified. The control bit is a register. The operating system or the BMC program has low execution authority and has no right to access the register. The register can only be modified by a firmware program with higher execution authority. In this case, the following firmware patch can be written to modify the above registers:

In the embodiment of the present application, the firmware running program may acquire the firmware patch from the first program in the following possible ways.

Method 1:

FIG. 5 is a schematic diagram of a manner in which a firmware running program obtains a firmware patch provided by an embodiment of the present application. As shown in FIG. 5 , the first program stores the firmware patch in the second storage space, and stores the patch location information in the first storage space. Wherein, the patch location information is used to indicate the storage location of the firmware patch in the second storage space. Correspondingly, the firmware running program obtains the patch location information from the first storage space, and obtains the firmware patch from the second storage space according to the patch location information.

Exemplarily, the patch location information may include a start address and an end address of the firmware patch in the second storage space. Alternatively, the patch location information may include a starting location of the firmware patch in the second storage space and a length of the firmware patch.

Optionally, the first storage space may be a shared memory between the first program and the firmware running program. The second storage space may be a register, a mailbox (Mailbox), a shared memory, and the like that are jointly accessible by the first program and the second firmware running program.

Method 2:

FIG. 6 is a schematic diagram of another manner in which a firmware running program obtains a firmware patch provided by an embodiment of the present application. As shown in FIG. 6 , the first program sends a first message to the firmware running program, and the first message includes a firmware patch. Correspondingly, the firmware running program receives the first message from the first program, and obtains the firmware patch from the first message.

S402: The firmware running program executes the firmware patch, and the firmware patch takes effect.

In this embodiment, after the firmware running program acquires the firmware patch, it executes the firmware patch to make the firmware patch take effect, so as to solve the failure of the computer equipment or implement firmware update/upgrade.

Wherein, other expression forms of executing the firmware patch may be: executing the code in the firmware patch; performing corresponding processing according to the code logic of the firmware patch to realize the function/logic implemented by the firmware patch.

Another form of expression for the firmware patch to take effect may be: the computer device implements the function/logic implemented by the firmware patch; the computer device continues to run according to the function/logic implemented by the firmware patch. Taking the computer equipment failure scenario as an example, after the firmware running program executes the firmware patch, the failure of the computer equipment is resolved, so that the computer equipment resumes normal operation. Taking the firmware update/upgrade scenario as an example, when the firmware running program executes the firmware patch, the computer equipment runs according to the updated/upgraded firmware, and achieves the operation effect after the firmware update/upgrade, for example, the function of the original firmware is improved. , Repair the loopholes of the original firmware function, increase the new firmware function, improve the stability of the firmware, etc.

For example, in an exemplary scenario, during the operation of the computer device, the firmware server pushes the firmware patch to the computer device, or the developer uploads the firmware patch to the computer device, so that the first program of the computer device obtains Firmware patches. The first program may use the above-mentioned method 1 or the above-mentioned method 2 to transfer the firmware patch to the firmware running program, so that the firmware running program obtains the firmware patch. Furthermore, the firmware running program executes the firmware patch, so that the firmware patch takes effect, solves the failure of the computer equipment or implements firmware update/upgrade.

It can be seen that in this embodiment, during the operation of the computer equipment, the firmware patch from the first program is acquired through the firmware running program, and the firmware patch is executed to make the firmware patch take effect, thereby solving the problem of the computer equipment or realizing Firmware update/upgrade. Since the above-mentioned process does not update the firmware program of the computer equipment, the above-mentioned process does not need to restart the computer equipment, therefore, it will not affect the business of the computer equipment.

On the basis of the foregoing embodiments, the solution of the present application will be described in more detail below by taking the first program as an operating system as an example.

In practical applications, computer equipment may include one or more processors. Referring to the aforementioned FIG. 3 , when the computer device is running, the firmware running program and the operating system run simultaneously. In this way, the operation of the firmware running program and the operating system can be divided into the following two situations.

Case 1: The firmware runner and the operating system run on the same processor.

Case 2: The firmware runner and the operating system run on different processors. The different processors refer to two physically different processors, and the two processors may be of the same type or of different types, which is not limited in this embodiment. These two processors can be packaged in a system-on-chip (SoC).

In a possible scenario, the computer device includes a processor. Both the operating system and firmware runners are executed by the processor. This scenario belongs to case 1 above. FIG. 7 is a schematic diagram of the running state of a computer device provided by the embodiment of the present application. As shown in FIG. 7 , both the operating system and the firmware running program are executed by the processor. In this scenario, the processor executes the operating system and the firmware running program in a time-sharing manner, that is, only one of the operating system and the firmware running program can be executed at the same time. Exemplarily, when the processor is executing the operating system, the firmware running program is in a suspended state (or called a sleep state). When the processor needs to execute the firmware running program, it can suspend the execution of the operating system and wake up the firmware running program. When the execution of the firmware running program is completed, the processor wakes up the operating system so that the operating system can continue to execute. In some possible scenarios, the operating system is run by the CPU of the processor, and the firmware running program can be run by a supporting chip of the processor, such as a bridge chip.

In another possible scenario, the computer device includes multiple processors. In this scenario, the operating system can be executed by one of the processors, and the firmware running program can be distributed and executed by different processors. FIG. 8 is a schematic diagram of another operating state of a computer device provided by an embodiment of the present application. As shown in FIG. 8 , it is illustrated by taking a computer device including a processor A and a processor B as an example. The processor A executes an operating system and a firmware running program, and the processor B executes the firmware running program. In this case, the firmware running programs executed by the processor A and the processor B may be completely the same or different. For example, processor A executes part of the functions of the firmware running program, and processor B executes part of the functions of the firmware running program. In some scenarios, some functions of the firmware running program executed by the processor A may overlap with some functions of the firmware running program executed by the processor B.

In this scenario, for the firmware running program in processor A, the firmware running program and the operating system run on the same processor, which belongs to the above case 1. In some possible scenarios, the operating system is run by the CPU of processor A, and the firmware running program can be run by a supporting chip of processor A, such as a bridge chip.

For the firmware running program in processor B, the firmware running program and the operating system run on different processors, which belongs to the above-mentioned case 2.

It should be understood that FIG. 8 uses two processors as an example for illustration, and when the computer device includes more processors, the principle is similar, and details are not repeated here.

In the above-mentioned embodiment shown in FIG. 4 , when the operating system and the firmware running program use the above-mentioned method 1 to transfer the firmware patch, the specific implementation methods are different for the above-mentioned case 1 and case 2. In the following, the two cases will be described respectively with reference to the embodiment shown in FIG. 9 .

FIG. 9 is a schematic flowchart of another patch processing method provided by the embodiment of the present application. The method in this embodiment may be executed when the operating system determines that a firmware patch needs to be applied during the execution of the computer device. As shown in Figure 9, the method of this embodiment includes:

S901: The operating system determines a firmware calling method.

In the embodiment of the present application, the method of invoking the firmware refers to a method in which the operating system notifies/calls the firmware running program, so that the firmware running program executes the firmware patch. Firmware calling methods can be divided into internal calling methods and external calling methods. The internal calling method refers to calling within the same processor, and the external calling method refers to calling across processors.

For the above case 1, the operating system and the firmware running program run on the same processor, and the calling method of the firmware is an internal calling method.

For the above case 2, the operating system and the firmware running program run on different processors, and the firmware calling method is an external calling method.

S902: If the calling method of the firmware is an internal calling method, the operating system determines the first storage space and the second storage space in the storage space of the first processor, where the first processor is a processor running the operating system.

S903: The operating system stores the firmware patch in the second storage space, and stores patch location information in the first storage space, where the patch location information is used to indicate a storage location of the firmware patch in the second storage space.

It should be understood that if the firmware calling method is an internal calling method, it means that the firmware running program and the operating system run on the same processor, that is, both run on the first processor, which corresponds to the above case 1. Therefore, the operating system can determine the first storage space and the second storage space in the storage space of the first processor. Since the firmware running program is also executed by the first processor, the first storage space and the second storage space can also be accessed by the firmware running program.

Exemplarily, the second storage space may be the memory space of the first processor. The first storage space may be a preset register of the first processor.

For the scenario where both the operating system and the firmware running program are executed by the first processor (for example, the first processor is the processor in FIG. 7, or the processor A in FIG. 8), the first processor executes the operating system Execute permissions when executing the firmware are usually different from the execution permissions when executing the firmware runtime program. Exemplarily, the execution authority corresponding to the firmware running program may be higher than the execution authority corresponding to the operating system. Therefore, in some possible implementation manners, after performing S903, the operating system may further perform the following S904.

S904: The operating system executes a preset instruction, so that the first processor executes a firmware running program.

Wherein, the preset instruction refers to an instruction for adjusting the execution permission of the first processor. For processors with different architectures, the preset instructions to be executed by the operating system are usually different. In this embodiment, the operating system executes a preset instruction to switch the execution authority of the first processor to the execution authority corresponding to the firmware running program, so that the first processor executes the firmware running program.

The following takes the firmware running program as the BIOS running program as an example for illustration.

Example 1, if the first processor is an ARM architecture processor, the execution rights of the first processor can be divided into four levels: EL3, EL2, EL1, and EL0 from high to low. The execution permission corresponding to the operating system is usually EL2 or EL1. The execution authority corresponding to the BIOS running program is usually EL3. The operating system may switch the execution authority of the first processor from EL2/EL1 to EL3 by executing the SMC instruction, so that the first processor executes the BIOS running program.

Example 2, if the first processor is a RISC-V architecture processor, the execution rights of the first processor can be divided into three levels: M-mode, S-mode, and U-mode from high to low. The execution permission corresponding to the operating system is usually S-mode. The execution permission corresponding to the BIOS running program is usually M-mode. The operating system may switch the execution authority of the first processor from S-mode to M-mode by executing the ECLL instruction, so that the first processor executes the BIOS running program.

Example 3, if the first processor is a processor of X86 architecture. The execution permission corresponding to the operating system is non-SMM mode, and the execution permission corresponding to the BIOS running program is SMM mode. The operating system can switch the execution authority of the first processor from non-SMM mode to SMM mode by executing an operation instruction that generates an SMI interrupt, so that the first processor executes the BIOS running program.

S905: If the calling method of the firmware is an external calling method, the operating system determines the first storage space and the second storage space in the storage space accessible by the first processor and the second processor, and the first processor runs the operating system processor, and the second processor is a processor that does not run an operating system.

S906: The operating system stores the firmware patch in the second storage space, and stores patch location information in the first storage space, where the patch location information is used to indicate a storage location of the firmware patch in the second storage space.

It should be understood that if the firmware calling method is an external calling method, it means that the firmware running program and the operating system implementing the embodiment of the present application run on different processors, which corresponds to the above case 2. For example, in the example shown in FIG. 8 , the firmware execution program implementing the embodiment of the present application is executed by processor B, and the operating system is executed by processor A. Therefore, the operating system can determine the first storage space and the second storage space in the storage spaces accessible by both processor A and processor B. In this way, it is ensured that the first storage space and the second storage space can also be accessed by the firmware running program.

Exemplarily, the second storage space may be a shared memory space of the first processor and the second processor. The first storage space may be a preset mailbox.

S907: The firmware running program acquires patch location information from the first storage space, and acquires a firmware patch from the second storage space according to the patch location information.

S908: The firmware running program executes the firmware patch, and the firmware patch takes effect.

In a possible implementation, for the above case 1, that is, the scenario where the operating system and the firmware running program run on the same processor, if the execution permissions of the firmware running program and the operating system are different, the firmware running program finishes executing the firmware After the patch, it also includes: the firmware running program executes preset instructions to switch the execution authority of the processor to the execution authority corresponding to the operating system, so that the first processor continues to execute the operating system.

The above embodiment shown in FIG. 9 mainly describes how the operating system transfers the firmware patch to the firmware running program in the case 1 and the case 2. The specific implementation process of the firmware patch after the firmware running program acquires the firmware patch is described below in conjunction with a specific embodiment.

FIG. 10 is a schematic flowchart of another patch processing method provided by the embodiment of the present application. As shown in Figure 10, the method of this embodiment includes:

S1001: The firmware running program obtains the patch location information and the firmware patch function identifier from the first storage space, and the patch location is used to indicate the storage location of the firmware patch in the second storage space.

S1002: The firmware running program determines the firmware service interface corresponding to the firmware patch function identifier according to the firmware patch function identifier.

In this embodiment, the firmware running program can provide various calling functions to the operating system. The firmware patch function is one of them. Each calling function corresponds to a service interface. The service interface corresponding to the firmware patch function is the firmware service interface.

It should be understood that the firmware service interface is a software interface. For example, it may be an application programming interface (Application Programming Interface, API) or the like.

When the operating system stores the patch location information in the first storage space, it may also store the firmware patch function identifier in the first storage space. Wherein, the firmware patch function identifier is used to inform the firmware that the running program needs to call the firmware patch function. In this way, the firmware running program can determine that the firmware service interface needs to be executed according to the firmware patch function identifier. Furthermore, the following firmware patch execution process from S1003 to S1007 is completed by calling the firmware service interface.

S1003: Obtain the firmware patch from the second storage space according to the patch location information through the firmware service interface.

In an example, as shown in Table 1, the firmware patch may include a file header, a code area and a signature area.

Table 1

S1004: Obtain signature information from the firmware patch through the firmware service interface, and verify the integrity and/or legality of the firmware patch according to the signature information, and obtain a verification result.

Exemplarily, according to the file structure of the firmware patch shown in Table 1, the signature information can be obtained from the signature area of the firmware patch. The integrity and/or legality of the firmware patch is verified by using the signature information, and a verification result is obtained.

If the verification result is that the verification fails, the firmware patch will not be executed. If the verification result is that the verification is passed, continue to execute subsequent steps S1005 to S1007.

In this embodiment, before executing the firmware patch, the integrity and/or legality of the firmware patch is verified, and the firmware patch is executed only when the verification is passed, so as to ensure safe operation of the computer equipment.

S1005: If the verification result is that the verification is passed, determine the file format type of the firmware patch through the firmware service interface, and the file format type is a binary type or a bytecode type.

It should be understood that the computer device cannot directly recognize the firmware patch of the bytecode type, and needs to be parsed first, converted into a form that the computer device can recognize, and then executed. For the firmware patch of the binary type, the computer device can directly execute it. As described in S1006 and S1007 below.

S1006: If the file format type is a bytecode type, parse and execute the firmware patch through the firmware service interface, so that the firmware patch takes effect.

S1007: If the file format type is a binary type, execute the firmware patch through the firmware service interface, so that the firmware patch takes effect.

In this embodiment, the firmware running program adopts different execution methods for different file format types by judging the file format type of the firmware patch, so that the solution of this application is not only applicable to the firmware patch in the binary format, but also applicable to the bytecode format The firmware patch makes the application scenarios more extensive.

In the above-mentioned embodiment shown in FIG. 9 , when the operating system needs to apply a firmware patch, it needs to determine which method to use to notify/call the firmware running program according to the firmware calling method. In some possible implementation manners, a firmware program may specify a firmware calling method, and notify the operating system of the firmware calling method.

FIG. 11 is a schematic diagram of an interaction process between an operating system and a firmware program provided by an embodiment of the present application. As shown in FIG. 11 , the firmware program can send the firmware calling method to the operating system, and correspondingly, the operating system receives the firmware calling method from the firmware program, so that the operating system can learn the firmware calling method.

Optionally, in the startup stage of the computer device, when the firmware startup program starts and loads the operating system, the firmware startup program sends the firmware calling method to the operating system.

Optionally, in the running phase of the computer device, the firmware running program sends the firmware calling method to the operating system.

The following takes the firmware program as the BIOS program as an example for illustration. The BIOS program sends the function information table to the operating system. The function information table includes calling functions supported by the BIOS running program, and a BIOS calling method corresponding to each calling function.

In an example, the content of the function information table is shown in Table 2. The function information table includes header information (Header) and a function list (Call ID[n]). Wherein, the function list adopts the form of an array, and the subscript of the array element is the identification of the calling function supported by the BIOS running program, and the value of Call ID[n] indicates the BIOS calling method corresponding to the calling function identification n.

It should be understood that the identifier of each calling function may be agreed in advance. For example, the identifier of the firmware patch function is 0, the corresponding identifier of another calling function is 1, and so on. The meaning of the value of Call ID[n] is as follows:

00h means the function is not supported;

01h represents that the BIOS call mode is a special instruction call (that is, the internal call mode in the above-mentioned embodiment);

10h represents that the BIOS call method is a mailbox call (that is, the external call method in the above-mentioned embodiment);

11h means undefined.

In this way, the operating system can determine the firmware call method corresponding to the firmware patch function according to the value of Call ID[0].

Table 2

Optionally, as shown in Table 2, the function information table may also include mailbox information (Mailbox). The mailbox information includes address information of at least one mailbox. For example, when the firmware call method corresponding to the firmware patch function is mailbox call (that is, the external call method in the above-mentioned embodiment), the mailbox specified in the mailbox information may be used to transmit the patch location information of the firmware patch.

In this embodiment, the function information table is sent to the operating system through the BIOS, so that the operating system can know whether the BIOS running program supports the firmware patch function, and which firmware calling method is adopted. In this way, when the operating system needs to apply a firmware patch, it can call the BIOS running program to execute the firmware patch based on the firmware calling method.

FIG. 12 is a schematic structural diagram of a patch processing device provided by an embodiment of the present application. As shown in FIG. 12 , the patch processing apparatus 1200 provided in this embodiment includes: a first processing module 1201 and a second processing module 1202 .

Wherein, the second processing module 1202 is used to obtain a firmware patch, the firmware patch is from the first processing module 1201, and the second processing module 1202 is also used to execute the firmware patch, and the firmware patch takes effect.

In a possible implementation manner, the second processing module 1202 is specifically configured to: acquire patch location information from the first storage space, where the patch location information is used to indicate the storage location of the firmware patch in the second storage space; The patch location information is to obtain the firmware patch from the second storage space.

In a possible implementation manner, the first processing module 1201 is configured to: store the firmware patch in the second storage space, and store the patch location information in the first storage space.

In a possible implementation manner, the first processing module 1201 is further configured to: obtain a firmware calling method; and determine the first storage space and the second storage space according to the firmware calling method.

In a possible implementation manner, the first processing module 1201 is specifically configured to: receive the firmware calling manner sent by the second processing module.

In a possible implementation manner, the patch processing apparatus provided in this embodiment is applied to computer equipment, and the computer equipment includes at least one processor; the first processing module 1201 is specifically configured to: if the firmware calling method is internal calling mode, then determine the first storage space and the second storage space in the storage space of the first processor; or,

In a possible implementation manner, the first processing module 1201 and the second processing module 1202 run on the same processor, and the firmware calling method is the internal calling method; the first processing module 1201 and the The second processing module 1202 runs in a different processor, and the firmware calling method is the external calling method.

In a possible implementation manner, the firmware calling method is the internal calling method; the first processing module 1201 is further configured to: execute a preset instruction, so that the processor where the first processing module 1201 is located executes The second processing module 1202 .

In a possible implementation manner, the second processing module 1202 is further configured to: acquire the firmware patch function identifier from the first storage space; determine the firmware patch function identifier according to the firmware patch function identifier A corresponding firmware service interface: acquiring the firmware patch from the second storage space through the firmware service interface according to the patch location information.

In a possible implementation manner, the second processing module 1202 is specifically configured to: receive a first message from the first processing module 1201, where the first message includes the firmware patch.

In a possible implementation manner, the first processing module 1201 is an operating system OS; or, the first processing module 1201 is a baseboard management controller (BMC) program.

The patch processing device provided in this embodiment can be used to execute the patch processing method provided in any of the above method embodiments, and its implementation principle and technical effect are similar, and details are not described here.

An embodiment of the present application further provides a computer device, the structure of which may be shown in FIG. 1 , and the computer device includes one or more processors, and a memory. Wherein, the memory stores computer programs. Optionally, the computer program may include the first program and a firmware program of the computer device, and the firmware program includes a firmware running program. The one or more processors run the computer program to implement the patch processing method provided by the above method embodiment, the implementation principle and technical effect are similar, and will not be repeated here.

An embodiment of the present application further provides a chip, and the chip includes: one or more processors, and a memory. Wherein, the memory stores computer programs. Optionally, the computer program may include the first program and a firmware program of the chip, and the firmware program includes a firmware running program. The one or more processors run the computer program to implement the patch processing method provided by the above method embodiment, the implementation principle and technical effect are similar, and will not be repeated here.

An embodiment of the present application also provides a computer-readable storage medium, where a computer program is stored in the computer-readable storage medium. Optionally, the computer program includes a first program and/or a firmware program. The firmware program includes a firmware running program. When the above computer program is run, the patch processing method provided by the above method embodiment is implemented, and its implementation principle and technical effect are similar, and details are not described here.

An embodiment of the present application further provides a computer program product, where the computer program product includes a computer program. Optionally, the computer program includes a first program and/or a firmware program, and the firmware program includes a firmware running program. When the computer program is run, the patch processing method provided by the above method embodiment is implemented, and its implementation principle and technical effect are similar, and details are not described here.

In the several embodiments provided in this application, it should be understood that the disclosed devices and methods may be implemented in other ways. For example, the device embodiments described above are only illustrative. For example, the division of the modules is only a logical function division. In actual implementation, there may be other division methods, for example, multiple modules can be combined or integrated. to another system, or some features may be ignored, or not implemented. In another point, the mutual coupling or direct coupling or communication connection shown or discussed may be through some interfaces, and the indirect coupling or communication connection of devices or modules may be in electrical, mechanical or other forms.

The modules described as separate components may or may not be physically separated, and the components shown as modules may or may not be physical units, that is, they may be located in one place, or may be distributed to multiple network units. Part or all of the modules can be selected according to actual needs to achieve the purpose of the solution of this embodiment.

In addition, each functional module in each embodiment of the present application may be integrated into one processing unit, each module may exist separately physically, or two or more modules may be integrated into one unit. The units formed by the above modules can be implemented in the form of hardware, or in the form of hardware plus software functional units.

The above-mentioned integrated modules implemented in the form of software function modules can be stored in a computer-readable storage medium. The above-mentioned software functional modules are stored in a storage medium, and include several instructions to enable a computer device (which may be a personal computer, server, or network device, etc.) or a processor (English: processor) to execute the functions described in various embodiments of the present application. part of the method.

The above-mentioned storage medium can be realized by any type of volatile or non-volatile storage device or their combination, such as static random access memory (SRAM), electrically erasable programmable read-only memory (EEPROM), erasable In addition to programmable read-only memory (EPROM), programmable read-only memory (PROM), read-only memory (ROM), magnetic memory, flash memory, magnetic disk or optical disk. A storage media may be any available media that can be accessed by a general purpose or special purpose computer.

An exemplary storage medium is coupled to the processor such the processor can read information from, and write information to, the storage medium. Of course, the storage medium may also be a component of the processor. The processor and the storage medium may be located in Application Specific Integrated Circuits (ASIC for short). Of course, the processor and the storage medium can also exist in the electronic device or the main control device as discrete components.

The above is only the specific implementation of the embodiment of the present application, but the scope of protection of the embodiment of the present application is not limited thereto. Anyone familiar with the technical field can easily Any changes or substitutions that come to mind should be covered within the protection scope of the embodiments of the present application. Therefore, the protection scope of the embodiments of the present application should be determined by the protection scope of the claims.

Claims

A patch processing method, characterized in that it is applied to a computer device, the computer device stores a first program and a firmware program of the computer device, the firmware program includes a firmware running program, and the method includes:

The firmware running program obtains a firmware patch, and the firmware patch comes from the first program;

The firmware running program executes the firmware patch, and the firmware patch takes effect.
The method according to claim 1, wherein the firmware running program obtains a firmware patch, comprising:

The firmware running program obtains patch location information from the first storage space, and the patch location information is used to indicate the storage location of the firmware patch in the second storage space;

The firmware running program acquires the firmware patch from the second storage space according to the patch location information.
The method according to claim 2, wherein, before the firmware running program obtains the patch location information from the first storage space, further comprising:

The first program stores the firmware patch in the second storage space;

The first program stores the patch location information in the first storage space.
The method according to claim 3, wherein before the first program stores the firmware patch in the second storage space, it also includes:

The first program acquires a firmware calling method;

The first program determines the first storage space and the second storage space according to the calling method of the firmware.
The method according to claim 4, wherein said first program obtains a firmware calling method, comprising:

The first program receives the firmware calling method sent by the firmware program.
The method according to claim 4 or 5, wherein the computer device includes at least one processor; the first program determines the first storage space and the second storage space according to the calling method of the firmware. space, including:

If the firmware calling method is an internal calling method, the first program determines the first storage space and the second storage space in the storage space of the first processor;

or,

If the calling method of the firmware is an external calling method, the first program determines the first storage space and the second storage space in a storage space accessible by the first processor and the second processor;

Wherein, the first processor runs the first program, and the second processor does not run the first program.
The method according to claim 6, characterized in that,

The first program and the firmware running program run in the same processor, and the firmware calling method is the internal calling method;

The first program and the firmware running program run on different processors, and the firmware calling method is the external calling method.
The method according to claim 6 or 7, wherein the calling method of the firmware is the internal calling method; before the firmware running program obtains the patch location information from the first storage space, it also includes:

The first program executes preset instructions, so that the processor where the first program resides executes the firmware running program.
The method according to any one of claims 2 to 8, wherein the method further comprises:

The firmware running program acquires the firmware patch function identifier from the first storage space;

The firmware running program obtains the firmware patch from the second storage space according to the patch location information, including:

The firmware running program determines the firmware service interface corresponding to the firmware patch function identifier according to the firmware patch function identifier;

Obtain the firmware patch from the second storage space through the firmware service interface according to the patch location information.
The method according to claim 1, wherein the firmware running program obtains a firmware patch, comprising:

The firmware running program receives a first message from the first program, and the first message includes the firmware patch.
The method according to any one of claims 1 to 10, wherein the first program is an operating system OS; or,

The first program is a baseboard management controller (BMC) program.
A patch processing device, characterized by comprising: a first processing module and a second processing module;

The second processing module is used to acquire a firmware patch, and the firmware patch comes from the first processing module;

The second processing module is further configured to execute the firmware patch, and the firmware patch takes effect.
The device according to claim 12, wherein the second processing module is specifically used for:

Obtain patch location information from the first storage space, where the patch location information is used to indicate the storage location of the firmware patch in the second storage space;

Acquire the firmware patch from the second storage space according to the patch location information.
The device according to claim 13, wherein the first processing module is used for:

storing the firmware patch in the second storage space;

storing the patch location information in the first storage space.
The device according to claim 14, wherein the first processing module is also used for:

Get the firmware calling method;

The first storage space and the second storage space are determined according to the calling method of the firmware.
The device according to claim 15, wherein the first processing module is specifically used for:

Receive the firmware calling method sent by the second processing module.
The apparatus according to claim 15 or 16, wherein the patch processing apparatus is applied to computer equipment, and the computer equipment includes at least one processor; the first processing module is specifically used for:

If the firmware calling method is an internal calling method, then determine the first storage space and the second storage space in the storage space of the first processor;

or,

If the firmware calling method is an external calling method, then determine the first storage space and the second storage space in a storage space that can be accessed by the first processor and the second processor;

Wherein, the first processor runs the first processing module, and the second processor does not run the first processing module.
The device according to claim 17, characterized in that,

The first processing module and the second processing module run in the same processor, and the firmware calling method is the internal calling method;

The first processing module and the second processing module run in different processors, and the firmware calling method is the external calling method.
The device according to claim 17 or 18, wherein the firmware calling method is the internal calling method; the first processing module is also used for:

Executing preset instructions, so that the processor where the first processing module is located executes the second processing module.
The device according to any one of claims 13 to 19, wherein the second processing module is further configured to:

Obtain the firmware patch function identifier from the first storage space;

According to the firmware patch function identifier, determine the firmware service interface corresponding to the firmware patch function identifier;

Obtain the firmware patch from the second storage space through the firmware service interface according to the patch location information.
The device according to claim 12, wherein the second processing module is specifically used for:

A first message is received from the first processing module, the first message includes the firmware patch.
The device according to any one of claims 12 to 21, wherein the first processing module is an operating system OS; or,

The first processing module is a baseboard management controller (BMC) program.
A computer device, characterized in that it includes:

one or more processors, and,

memory; of which,

The memory stores a computer program; the one or more processors run the computer program to implement the method according to any one of claims 1 to 11.
A chip, characterized in that it comprises:

one or more processors, and,

memory; of which,

The memory stores a computer program; the one or more processors run the computer program to implement the method according to any one of claims 1 to 11.
A computer-readable storage medium, wherein the computer-readable storage medium stores a computer program, and when the computer program is executed, the method according to any one of claims 1 to 11 is realized.
A computer program product, characterized in that the computer program product includes a computer program, and when the computer program is executed, the method according to any one of claims 1 to 11 is implemented.