A method, system and product for processing image files

Abstract

The present application relates to the field of server technology, and discloses a method, system and product for image file processing. The method is applied to a target processor, including: receiving a first instruction sent by a central processing unit; performing an image switching operation according to the first instruction; or, receiving a second instruction sent by the central processing unit; performing an image refresh operation according to the second instruction. The method can realize redundant switching of multiple versions of image files in the MCU, simplify the version control process, save system resources and time costs, and improve the overall performance of the edge server.

Description

Technical Field

[0001] The present application relates to the field of server technology, and in particular to a method, system and product for processing image files. Background Art

[0002] Edge servers are widely used in outdoor and mobile terminal environments, placing computing and storage resources as close to users as possible to reduce data transmission delays and network congestion, and provide low-latency, high-efficiency data processing services. With the continuous innovation of technology, there is a need to upgrade the firmware of server hardware devices.

[0003] In related solutions, the device firmware version is switched by flashing a new image file into the server's hardware device from the outside. However, this method of switching firmware versions has limitations. For users who have multiple versions of customization requirements, frequent firmware flashing is cumbersome and time-consuming, and occupies bandwidth resources. Especially for edge servers, the firmware refresh process is easily affected by network or external factors, resulting in data loss and affecting the normal operation of business. Summary of the invention

[0004] In view of this, the present application aims to propose an image file processing method, system and product to solve the above technical problems.

[0005] To achieve the above purpose, the technical solution of this application is as follows:

[0006] A first aspect of an embodiment of the present application provides an image file processing method, which is applied to a target processor and includes:

[0007] receiving a first instruction sent by a central processing unit;

[0008] According to the first instruction, performing a mirror switching operation;

[0009] The image switching operation includes: determining a sector where a second image file that is not currently running is located based on a currently running first image file; wherein the first image file and the second image file are image files of the same type pre-stored in different sectors of a memory; and reading the second image file from the sector and running it;

[0010] or, receiving a second instruction sent by the central processing unit;

[0011] According to the second instruction, performing an image refresh operation;

[0012] The image refresh operation includes: determining the sector where the second image file that is not currently running is located based on the currently running first image file; writing a third image file into the sector and replacing the second image file; the third image file is of the same type as the first image file.

[0013] Optionally, based on the currently running first image file, determining the sector where the currently not running second image file is located includes:

[0014] According to the first instruction, updating a switch flag bit; the switch flag bit is used to indicate the type of operation performed by the target processor;

[0015] Reading a version flag, and determining the first sector where the currently running first image file is located according to the version flag; the version flag is used to indicate the version of the currently running image file;

[0016] Based on the first sector, a second sector where a second image file that is not currently running is located is determined.

[0017] Optionally, reading the second image file from the sector and running it includes:

[0018] Performing a reset operation, and updating the version flag based on the second sector;

[0019] After resetting, based on the updated version flag, the second image file is read from the second sector and loaded into the memory for execution.

[0020] Optionally, the version flag includes: a main version flag and a startup version flag;

[0021] Updating the version flag based on the second sector includes:

[0022] In the case where the second image file stored in the second sector is a main program file, updating the main version flag;

[0023] When the second image file stored in the second sector is a startup program file, the startup version flag is updated.

[0024] Optionally, based on the currently running first image file, determining the sector where the currently not running second image file is located includes:

[0025] According to the second instruction, updating a switch flag bit; the switch flag bit is used to indicate the type of operation performed by the target processor;

[0026] Reading a version flag, and determining the first sector where the currently running first image file is located according to the version flag; the version flag is used to indicate the version of the currently running image file;

[0027] Based on the first sector, a second sector where a second image file that is not currently running is located is determined.

[0028] Optionally, writing the third image file into the sector and replacing the second image file includes:

[0029] Receiving a third image file sent by the central processing unit;

[0030] Performing integrity check on the third image file;

[0031] If the integrity check passes, the third image file is written into the second sector and replaces the second image file.

[0032] Optionally, after writing the third image file into the second sector and replacing the second image file, the method further includes:

[0033] Perform a reset operation, and update the version flag based on the second sector; the version flag includes: a main version flag and a startup version flag;

[0034] After resetting, based on the updated version flag, the third image file is read from the second sector and loaded into the memory for execution.

[0035] Optionally, the version flag includes: a main version flag and a startup version flag;

[0036] Updating the version flag based on the second sector includes:

[0037] In the case where the third image file stored in the second sector is a main program file, updating the main version flag;

[0038] When the third image file stored in the second sector is a startup program file, the startup version flag is updated.

[0039] Optionally, after performing the image switching operation or the image refreshing operation, the method further includes:

[0040] Sending operation completion information to the central processing unit;

[0041] A viewing request sent by the central processing unit is received, and version information of the currently running image file is sent to the central processing unit.

[0042] Optionally, the memory includes: a non-volatile memory in the target processor; the non-volatile memory is pre-divided into a plurality of sectors and is used to store: a first image file of a main program, a second image file of the main program, a third image file of the main program, a first image file of a startup program, a second image file of a startup program, a third image file of a startup program, or at least one of a flag bit;

[0043] The flag bits include: a switch flag bit and a version flag bit; the switch flag bit is used to indicate the type of operation performed by the target processor, and the version flag bit is used to indicate the version of the currently running image file.

[0044] Optionally, the memory also includes: an external memory connected to the target processor; the external memory is used to store at least one of the following when the storage space of the non-volatile memory in the target processor is insufficient: the first image file of the main program, the second image file of the main program, the third image file of the main program, the first image file of the startup program, the second image file of the startup program, the third image file of the startup program or a flag.

[0045] According to a second aspect of an embodiment of the present application, there is provided an image file processing method, which is applied to a central processing unit, and the method includes:

[0046] Acquire a first task, the first task being used to instruct a target processor to perform an image switching operation; the image switching operation comprising: determining a sector where a second image file that is not currently running is located based on a currently running first image file; wherein the first image file and the second image file are image files of the same type pre-stored in different sectors of a memory; and reading the second image file from the sector and running it;

[0047] Or, obtain a second task, the second task is used to instruct the target processor to perform an image refresh operation; the image refresh operation includes: based on the currently running first image file, determining the sector where the currently not running second image file is located; writing a third image file into the sector and replacing the second image file; the third image file is of the same type as the second image file.

[0048] Optionally, the image file processing method further includes:

[0049] Receiving operation completion information sent by the target processor;

[0050] A query request is sent to the target processor to obtain version information of the image file currently running in the target processor.

[0051] According to a third aspect of an embodiment of the present application, there is provided an image file processing system, including:

[0052] A central processing unit, configured to execute the steps of the method according to the second aspect of the embodiment of the present application, so as to control the target processor to perform a mirror switching operation or a mirror refresh operation;

[0053] The target processor is used to execute the steps of the mirror switching operation or the mirror refresh operation in the method described in the first aspect of the embodiment of the present application.

[0054] Optionally, the image file processing system further includes:

[0055] An external memory is connected to the target processor and is used to store at least one of the following when the storage space of the non-volatile memory in the target processor is insufficient: a first image file of a main program, a second image file of a main program, a third image file of a main program, a first image file of a startup program, a second image file of a startup program, a third image file of a startup program, or a flag.

[0056] Optionally, the image file processing system further includes:

[0057] The baseboard management controller is connected to the target processor via an integrated circuit bus and is used to obtain version information of the image file currently running in the target processor.

[0058] According to a fourth aspect of an embodiment of the present application, a computer program product is provided, comprising a computer program, wherein when the computer program is executed by a processor, the steps in the method described in the first aspect or the second aspect of the embodiment of the present application are implemented.

[0059] According to the fifth aspect of the embodiments of the present application, a computer-readable storage medium is provided, on which a computer program is stored. When the computer program is executed by a processor, the steps in the method described in the first aspect or the second aspect of the embodiments of the present application are implemented.

[0060] According to the sixth aspect of the embodiments of the present application, an electronic device is provided, comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein when the processor executes the computer program, the steps in the method described in the first aspect or the second aspect of the embodiments of the present application are implemented.

[0061] The image file processing method provided by the present application is adopted to divide a plurality of sectors in the memory, and two image files (the first image file and the second image file) of the same type but different versions are stored in different sectors respectively. The target processor receives the first / second instruction sent by the CPU, switches the currently running first image file to the redundant second image file, or uses an external third image file to refresh the redundant second image file.

[0062] In this application, the target processor can switch the running firmware version by switching to read different sectors. For customers who have customized version requirements, by retaining two versions of available image files in different sectors of the memory, it is possible to easily switch between the two versions of image files quickly, meeting the user's frequent switching needs for different versions, without the need to flash data to the target processor from the outside every time the version is switched, saving a lot of bandwidth resources, and ensuring the stability of the service provided by the server. For production line engineers, retaining both the old and new versions of the image files in the memory facilitates firmware version rollback, production line problem location, troubleshooting and management, and greatly simplifies the version control process. BRIEF DESCRIPTION OF THE DRAWINGS

[0063] In order to more clearly illustrate the technical solutions of the embodiments of the present application, the drawings required for use in the description of the embodiments of the present application will be briefly introduced below. Obviously, the drawings described below are only some embodiments of the present application. For ordinary technicians in this field, other drawings can be obtained based on these drawings without paying any creative labor.

[0064] Figure 1 This is one of the flow charts of the image file processing method proposed in one embodiment of the present application;

[0065] Figure 2 This is the second flowchart of the image file processing method proposed in one embodiment of the present application;

[0066] Figure 3 Schematic diagram of sector division of the internal Flash memory of the MCU in one embodiment of the present application;

[0067] Figure 4 This is a flowchart of MCU processing an image file in an embodiment of the present application;

[0068] Figure 5 is a schematic diagram of an image file processing system in one embodiment of the present application;

[0069] Figure 6 It is a schematic diagram of an electronic device proposed in an embodiment of the present application. DETAILED DESCRIPTION

[0070] The following will be combined with the drawings in the embodiments of the present application to clearly and completely describe the technical solutions in the embodiments of the present application. Obviously, the described embodiments are part of the embodiments of the present application, not all of the embodiments. Based on the embodiments in the present application, all other embodiments obtained by ordinary technicians in this field without creative work are within the scope of protection of this application.

[0071] It should be understood that the references to "one embodiment" or "an embodiment" throughout the specification mean that the specific features, structures, or characteristics associated with the embodiment are included in at least one embodiment of the present application. Therefore, the references to "in one embodiment" or "in an embodiment" appearing throughout the specification do not necessarily refer to the same embodiment. In addition, these specific features, structures, or characteristics may be combined in any suitable manner in one or more embodiments.

[0072] In the various embodiments of the present application, it should be understood that the size of the serial numbers of the following processes does not mean the order of execution. The execution order of each process should be determined by its function and internal logic, and should not constitute any limitation on the implementation process of the embodiments of the present application.

[0073] Exemplary embodiments will be described in detail herein, examples of which are shown in the accompanying drawings. When the following description refers to the drawings, unless otherwise indicated, the same numbers in different drawings represent the same or similar elements. The embodiments described in the following exemplary embodiments do not represent all embodiments consistent with the present application. Instead, they are merely examples of devices and methods consistent with some aspects as detailed in the present application.

[0074] It should be noted that, in the absence of conflict, the embodiments and features in the embodiments of the present application may be combined with each other.

[0075] After the server is powered on, each hardware device reads the image from a fixed location in the memory and runs. In the related art, when the hardware device needs to switch the firmware version, the new version of the image file is flashed into a fixed location from the outside and overwrites the original image file. This method requires an external image flash and overwrite operation every time the firmware version is switched. For users with multiple version customization requirements, the firmware version needs to be switched frequently, which leads to frequent data flashing, cumbersome operations and occupies bandwidth resources. Especially for edge servers, since their usage scenarios are mostly outdoors, the firmware version switching process is easily affected by network or external factors, which may cause data loss and affect the normal business operation of the server.

[0076] This application proposes a method for processing an image file, which can achieve fast and stable firmware version switching and ensure the stability of services provided by the server. Taking MCU (Microcontroller Unit) as an example, the application will be described in detail below with reference to the accompanying drawings and in combination with embodiments.

[0077] Figure 1 This is one of the flow charts of the image file processing method proposed in one embodiment of the present application. Figure 1 (a) is the process of the target processor performing the mirror switching operation. As shown in the figure, the method includes:

[0078] S11: receiving a first instruction sent by a central processing unit;

[0079] S12: According to the first instruction, perform an image switching operation; the image switching operation includes: based on the currently running first image file, determining the sector where the currently non-running second image file is located; wherein the first image file and the second image file are image files of the same type pre-stored in different sectors of the memory; and reading the second image file from the sector and running it.

[0080] Figure 1 (b) is a flow chart of the target processor performing the image refresh operation. As shown in the figure, the method includes:

[0081] S11': receiving a second instruction sent by the central processing unit;

[0082] S12': according to the second instruction, perform an image refresh operation; the image refresh operation includes: based on the currently running first image file, determining the sector where the currently non-running second image file is located; writing a third image file into the sector and replacing the second image file; the third image file is of the same type as the first image file.

[0083] In this embodiment, when the edge server is turned on, the MCU inside it first reads a version of the image file (i.e., the first image file) from the memory and runs it in the memory, and another version of the image file (the second image file) is used as a redundant image file. In the process of the MCU running the first image file, a first instruction sent by the host CPU is received, and a mirror switching operation is performed according to the first instruction. This solution stores two versions of image files in different sectors of the memory in advance. For example, the first image file is stored in the first sector, and the second image file is stored in the second sector. After receiving the first instruction from the host CPU, the mirror switching operation is performed to determine the second sector where the second image file that is not currently running is located, and then read the second image file from the second sector and run it, thereby realizing the mirror switching. That is, the currently running first image file is switched to run the second image file.

[0084] When the MCU runs the first image file, it receives the second instruction sent by the host CPU and performs the image refresh operation according to the second instruction. The CPU sends a new version of the image file (the third image file) to the MCU, and the MCU uses the third image file to refresh the redundant image file (the second image file) in the memory. Specifically, the third image file is written to the second sector where the second image file is located, and the second image file is replaced.

[0085] By adopting this method, two versions of available image files are always maintained in the memory, and the MCU switches to read different sectors to quickly switch the running firmware version, meeting the user's frequent switching needs for different versions. There is no need to flash data to the MCU from the outside every time the version is switched, saving a lot of bandwidth resources, ensuring the stability of the service provided by the server, improving the overall performance of the edge server, and simplifying the version control process.

[0086] For production line engineers, it is possible to better control and locate production line errors. By retaining both the old and new versions of the firmware and recording the timestamp of the version refresh, the error logs of the new and old versions can be matched, making it easier to locate, troubleshoot, and manage problems on the production line. For example, if it is suspected that the DIAG (Diagnostic, diagnostic process) record error is due to the new and old versions, it can be verified by switching versions. There is no need to frequently flash the firmware to prevent production line errors due to additional refresh operations.

[0087] In terms of product quality, this method provides a convenient firmware rollback method for MCU. When there is a problem with the new version of the firmware, the MCU can quickly roll back to the stable old version by switching the sectors to be read, ensuring the continuous availability of the device and the stability of business operations.

[0088] For customers who need customized versions, this application can retain two versions of available image files in different sectors of the memory. When switching between the two versions of the image files, there is no need to frequently flash data to the MCU from the outside, saving a lot of bandwidth resources. At the same time, it ensures the stability of the services provided by the server, greatly simplifies the management and control process, and improves the scalability and adaptability of the edge server in different scenarios.

[0089] Based on the same inventive concept, an embodiment of the present application provides a method for processing an image file. Figure 2 This is the second flowchart of the image file processing method proposed in one embodiment of the present application. Figure 2 (a) is a flow chart of the central processing unit performing the mirror switching operation. As shown in the figure, the method includes:

[0090] S21: Obtain a first task, where the first task is used to instruct the target processor to perform an image switching operation; the image switching operation includes: determining a sector where a second image file that is not currently running is located based on a currently running first image file; wherein the first image file and the second image file are image files of the same type pre-stored in different sectors of a memory; and reading the second image file from the sector and running it.

[0091] Figure 2 (b) is the process of the central processing unit performing the image refresh operation. As shown in the figure, the method includes:

[0092] S21': Obtain a second task, where the second task is used to instruct the target processor to perform an image refresh operation; the image refresh operation includes: based on the currently running first image file, determining a sector where a second image file that is not currently running is located; writing a third image file into the sector and replacing the second image file; the third image file is of the same type as the first image file.

[0093] In this embodiment, the host CPU generates a first instruction based on the first task submitted by the user (i.e., switching the running version), and sends the first instruction to the micro-control unit of the edge server so that the micro-control unit performs the mirror switching operation. Optionally, in this application, the first instruction is a command line containing custom variables. After receiving the first instruction, the MCU reads the custom variables therein to determine the type of operation to be performed (e.g., mirror switching operation).

[0094] The CPU generates a second instruction based on the second task submitted by the user (i.e., flashing a new version of the firmware), and sends the second instruction to the MCU so that the MCU performs an image refresh operation. Optionally, in the present application, the second instruction is a command line containing custom variables. After receiving the second instruction, the MCU reads the custom variables therein to determine the type of operation to be performed (e.g., image refresh operation), and at the same time receives the new image file (i.e., the third image file) sent by the CPU, writes it to the buffer of the memory, and waits for integrity verification.

[0095] In this embodiment, the user host CPU and the edge server MCU communicate through the serial port. Before the CPU sends instructions, it is necessary to first establish a communication link between the CPU and the MCU. This solution is based on the first port on the CPU side and the second port on the MCU side, and configures the serial port information, including: the port number of the first port, the port number of the second port, the baud rate, and the data transmission and reception rules. The specific steps are as follows:

[0096] (1) Determine the serial port number for communication between the MCU and the host CPU;

[0097] (2) Implement serial port communication between CPU and MCU in the operating system, use the program library to configure the serial port, including port number, baud rate, etc. to establish communication, configure serial port read and write functions, and configure file transfer protocol and other functions.

[0098] After the MCU is powered on, one of the stored versions of the image file will be loaded first. In this embodiment, the image file includes a bootloader file and a main program file. After the MCU is powered on, the bootloader will be loaded first, and then the main program will be loaded. During the operation of the image file, the instructions sent by the CPU are received, and the corresponding operations are performed on the image file in the memory.

[0099] In one embodiment, the user host communicates with the edge server through a network. The mirror switching operation or mirror refresh operation performed by the target processor is packaged as an HTTP service and provided to the outside, and the remote control edge server is implemented based on the HTTP protocol to perform firmware version switching or firmware refresh. Specifically, the host CPU is deployed in a remote server, and communicates with the target processor in the edge server based on the HTTP protocol. The CPU packaged the first instruction in the form of an HTTP request, and sent the request to the target processor of the edge server based on the HTTP protocol to use the HTTP service (mirror switching / mirror refresh) provided by the target processor. In order to ensure the security of the data, during the use of the HTTP service, a Token is used between the CPU and the target processor for identity authentication to ensure the legitimacy of the operation and data security.

[0100] As an implementation manner of the present application, based on the currently running first image file, determining the sector where the currently non-running second image file is located includes:

[0101] According to the first instruction, updating a switch flag bit; the switch flag bit is used to indicate the type of operation performed by the target processor;

[0102] Reading a version flag, and determining the first sector where the currently running first image file is located according to the version flag; the version flag is used to indicate the version of the currently running image file;

[0103] Based on the first sector, a second sector where a second image file that is not currently running is located is determined.

[0104] In one embodiment, a mirror switching operation is performed, and the switching flag is first updated. In this embodiment, 2-bit binary data is used to represent the switching flag. The specific meaning of the switching flag is as follows: 00: switch bootloader version; 01: switch main program version; 10: refresh bootloader version; 11: refresh main program version. The MCU updates the switching flag according to the first instruction, and then performs a reset operation to enable the flag. For example, in the case where the first instruction is to switch the bootloader version, the corresponding update switching flag is "00", and the MCU is reset to enable.

[0105] At the same time, the current version flag is read to determine the sector where the currently running image file is located. Since the first and second image files are stored in two sectors respectively in this solution, when the first sector where the currently running first image file is located is determined, the second sector where the currently non-running second image file is located can be directly determined.

[0106] As an implementation manner of the present application, reading the second image file from the sector and running it includes:

[0107] Performing a reset operation, and updating the version flag based on the second sector;

[0108] After resetting, based on the updated version flag, the second image file is read from the second sector and loaded into the memory for execution.

[0109] In one embodiment, after determining the second sector, MCU Reset is performed, and the version flag is updated based on the sector. In this embodiment, the MCU maintains the version flag in real time, and the version flag corresponds to the sector where the currently running image file is located. When performing the image switching operation, the MCU will update the version flag. For example, the current version flag indicates that the value corresponding to "image file 1 in the first sector is running" is updated to the value corresponding to "image file 2 in the second sector is running".

[0110] As an implementation mode of the present application, the version flag includes: a main version flag and a startup version flag;

[0111] Updating the version flag based on the second sector includes:

[0112] In the case where the second image file stored in the second sector is a main program file, updating the main version flag;

[0113] When the second image file stored in the second sector is a startup program file, the startup version flag is updated.

[0114] In one embodiment, 8-bit binary is used to represent the main version flag and the boot version flag, and different values ​​are used to distinguish image files in different sectors, as follows:

[0115] Main version flag "00000000": corresponds to the sector where the main program 1 is located;

[0116] Main version flag "00000001": corresponds to the sector where the main program 2 is located;

[0117] Boot version flag "00000000": corresponds to the sector where bootloader 1 is located;

[0118] Boot version flag "00000001": corresponds to the sector where bootloader 2 is located.

[0119] Figure 4 This is a flow chart of MCU processing image files in one embodiment of the present application. Figure 4As shown, after the MCU receives the first instruction sent by the central processing unit, the switch flag is first updated, and then the MCU Reset is executed to reset the microcontroller unit, and the corresponding version flag is updated. When updating the version flag, the type of the image file stored in the sector to be read is updated according to the need to switch. For example, in the case where the second image file stored in the second sector to be read is the main program file, the main version flag is updated accordingly, and in the case where the second image file is the startup program file, the startup version flag is updated accordingly. After reset, the MCU reads the image file from the corresponding sector to the memory for execution according to the current version flag.

[0120] As an implementation manner of the present application, based on the currently running first image file, determining the sector where the currently non-running second image file is located includes:

[0121] According to the second instruction, updating a switch flag bit; the switch flag bit is used to indicate the type of operation performed by the target processor;

[0122] Reading a version flag, and determining the first sector where the currently running first image file is located according to the version flag; the version flag is used to indicate the version of the currently running image file;

[0123] Based on the first sector, a second sector where a second image file that is not currently running is located is determined.

[0124] like Figure 4 As shown, in this embodiment, after receiving the second instruction sent by the central processing unit, the MCU first updates the switching flag, and then determines the sector where the external third image file needs to be written, that is, the sector where the second image file that is not currently running is stored. Specifically, the current version flag is read to determine the sector where the image file that is currently running is located. Since the first and second image files are stored respectively in two sectors in this solution, when the first sector where the first image file that is currently running is located is determined, the second sector where the second image file that is not currently running is located can be directly determined.

[0125] As an implementation manner of the present application, writing the third image file into the sector and replacing the second image file includes:

[0126] Receiving a third image file sent by the central processing unit;

[0127] Performing integrity check on the third image file;

[0128] If the integrity check passes, the third image file is written into the second sector and replaces the second image file.

[0129] In one embodiment, after receiving the second instruction, the MCU also receives the third image file sent by the central processing unit (CPU), and writes the new image file (i.e., the third image file) into the buffer of the memory. The MCU performs an integrity check on the third image file. If the integrity check succeeds, the third image file is written into the sector where the second image file that is not currently running is located, replacing the second image file, and realizing the version refresh of the redundant firmware. If the integrity check fails, the third image file is discarded, and the switch flag is restored.

[0130] For example, when the new image file is main program 3 and main program 2 is not currently running, main program 2 is replaced by main program 3 that has passed the integrity check.

[0131] As an implementation manner of the present application, after writing the third image file into the second sector and replacing the second image file, the method further includes:

[0132] Perform a reset operation, and update the version flag based on the second sector; the version flag includes: a main version flag and a startup version flag;

[0133] After resetting, based on the updated version flag, the third image file is read from the second sector and loaded into the memory for execution.

[0134] As an implementation mode of the present application, the version flag includes: a main version flag and a startup version flag;

[0135] Updating the version flag based on the second sector includes:

[0136] In the case where the third image file stored in the second sector is a main program file, updating the main version flag;

[0137] When the third image file stored in the second sector is a startup program file, the startup version flag is updated.

[0138] In one embodiment, after the new third image file is written to the second sector, the MCU automatically switches to run the third image file. Specifically, after the writing is completed, the MCU Reset operation is performed, and the version flag is updated according to the type of the image file stored in the second sector. After the MCU is reset, according to the updated version flag, the third image file is read from the second sector and loaded into the memory for execution.

[0139] Optionally, when the CPU generates the second instruction based on the second task submitted by the user, the host provides an option for the user to choose through the user interface, whether to switch to running the new version of the firmware after flashing the firmware. In the case where the user selects "only flash the firmware without switching to run", a third instruction is generated based on the second task submitted by the user and sent to the target processor. The target processor performs the above-mentioned image refresh operation based on the third instruction, does not automatically perform the reset operation after flashing the third image file, and still maintains the currently running first image file.

[0140] By adopting the method provided in this embodiment, the user can preset the target processor to perform subsequent operations of firmware refresh, improve the flexibility and controllability of the target processor, and avoid business interruption caused by switching firmware versions of the edge server during business operation.

[0141] As an implementation manner of the present application, after performing the mirror switching operation or the mirror refresh operation, it also includes:

[0142] Sending operation completion information to the central processing unit;

[0143] A viewing request sent by the central processing unit is received, and version information of the currently running image file is sent to the central processing unit.

[0144] As an implementation manner of the present application, the image file processing method further includes:

[0145] Receiving operation completion information sent by the target processor;

[0146] A query request is sent to the target processor to obtain version information of the image file currently running in the target processor.

[0147] In this embodiment, the MCU performs the image switching operation or the image refreshing operation according to the first instruction or the second instruction. After the server where the MCU is located is powered on, the MCU upgrade is completed, and the operation completion information is returned to the CPU of the host side to prompt the user in time. The user can send a viewing request to the MCU through the central processor to obtain the firmware version currently running in the MCU and view it through the user interface of the host side.

[0148] As an implementation mode of the present application, the memory includes: a non-volatile memory in the target processor; the non-volatile memory is pre-divided into a plurality of sectors and is used to store: a first image file of a main program, a second image file of the main program, a third image file of the main program, a first image file of a startup program, a second image file of a startup program, a third image file of a startup program, or at least one of a flag bit;

[0149] The flag bits include: a switch flag bit and a version flag bit; the switch flag bit is used to indicate the type of operation performed by the target processor, and the version flag bit is used to indicate the version of the currently running image file.

[0150] In one embodiment, the Flash memory in the micro control unit is used to store the image file and the flag bit. In order to adapt to the switching solution of the dual-image redundancy, the Flash memory is pre-divided into multiple sectors. Figure 3 FIG. 1 is a schematic diagram of the sector division of the internal Flash memory of the MCU in an embodiment of the present application. Figure 3 As shown, Flash is divided into 7 sectors:

[0151] Sector 1 and sector 2 are used to store two versions of boot program files (boot program 1 and boot program 2).

[0152] Sector 3 and sector 4 are used to store two versions of main program files (main program 1 and main program 2).

[0153] Sector 5 is a buffer, which is used to temporarily store the third image file (main program file or startup program file) to be verified;

[0154] Sector 6 (flag area) is used to store all flags, including: switch flag, main version flag and boot version flag;

[0155] Sector 7 is used to store other data of the MCU.

[0156] After power-on, the MCU continuously reads each flag bit in sector 6 at a time interval, and determines the type of operation to be performed (i.e., whether the operation is image switching or image refresh) by reading the switch flag bit. The version of the image file currently running is determined by reading the main version flag bit and the startup version flag bit. It is worth noting that the update of the switch flag bit needs to be enabled by the MCU reset operation (MCU Reset). After the sectors are divided, the version flag bits are matched with the sectors. For example, the main version flag bit "00000000" corresponds to sector 3, and the main version flag bit "00000001" corresponds to sector 4. When the MCU is reset and the main version flag bit "00000001" is read, it means that the main program currently running should be the image file in sector 4 (main program 2).

[0157] When the running main program 1 needs to be switched to the running main program 2, the switch flag is updated to "01" and the MCU is reset to enable the switch flag. At the same time, the main version flag is correspondingly updated to "00000001". After the reset, the MCU first reads the switch flag "01" to know that the main program needs to be switched, and then reads the main version flag "00000001" to know that the main program 2 in sector 4 needs to be run. Based on the flag reading result, the mirror switching operation is performed accordingly, and the main program file (main program 2) in sector 4 is read into the memory to run, completing the mirror switching operation.

[0158] In this embodiment, by dividing sectors, different versions of image files are isolated, so as to avoid the impact on the currently running data during data update, resulting in the image file being unable to operate normally. For example, when flashing a new image file, the new image file in the buffer is overwritten and written to the sector where the image that is not currently running is located (for example, the new main program 3 is overwritten and written to sector 4), replacing the old version of the image file (main program 2) that is not currently running in the sector, avoiding the impact of writing new data on the currently running image (for example, main program 1), ensuring the stability of the system and the normal operation of the business.

[0159] As an embodiment of the present application, the memory also includes: an external memory connected to the target processor; the external memory is used to store at least one of the following when the storage space of the non-volatile memory in the target processor is insufficient: the first image file of the main program, the second image file of the main program, the third image file of the main program, the first image file of the startup program, the second image file of the startup program, the third image file of the startup program or a flag.

[0160] In some scenarios, the problem of insufficient memory capacity in the target processor may occur. Since multiple redundant image files are stored in the memory in this solution, insufficient storage capacity may occur when the image file is large. For example, when the Flash memory capacity of the MCU is 128KB and a main program occupies 70KB, the Flash memory of the MCU does not have enough space to store two complete main program image files. Based on this, in one embodiment, the problem of insufficient storage space capacity is solved by connecting the target processor to an external memory.

[0161] In one embodiment, an EEPROM (Electrically Erasable Programmable ReadOnly Memory) is used as an external memory. In an edge server, the baseboard MCU is usually connected to an EEPROM to collect and record relevant logs of the MCU. Since the storage capacity of the EEPROM is usually large, the EEPROM can be used as a part of the memory in this solution to expand the storage space of redundant image files. Specifically, when the flash memory space inside the MCU is insufficient, the data that needs to be stored in one or more sectors of the flash memory (for example: the main program 2 in sector 4) is stored in one or more sectors of the external memory. It is worth noting that it is necessary to pre-initialize the serial port communication between the MCU and the external memory, and to pre-divide the external memory into sectors to achieve isolation of each version of the image file and improve data security and system stability.

[0162] In this embodiment, when the storage capacity of the target processor's internal memory is insufficient, the external memory is used to store the image file, and the operation on the target processor's internal memory is replaced by the operation on the external memory to achieve the same effect. In this way, without changing the overall logic, support for large-capacity firmware files is achieved, while maintaining the logical consistency of image switching and refreshing, and improving the flexibility and adaptability of the system.

[0163] Based on the same inventive concept, an embodiment of the present application provides an image file processing system. The system includes:

[0164] A central processing unit, used to execute the image file processing method described in the above embodiment to control the target processor to perform an image switching operation or an image refresh operation;

[0165] The target processor is used to execute the image switching operation or the image refreshing operation in the image file processing method described in the above embodiment.

[0166] As an implementation manner of the present application, the image file processing system further includes:

[0167] An external memory is connected to the target processor and is used to store at least one of the following when the storage space of the non-volatile memory in the target processor is insufficient: a first image file of a main program, a second image file of a main program, a third image file of a main program, a first image file of a startup program, a second image file of a startup program, a third image file of a startup program, or a flag.

[0168] As an implementation manner of the present application, the image file processing system further includes: a baseboard management controller, which is connected to the target processor via an integrated circuit bus and is used to obtain version information of the image file currently running in the target processor.

[0169] Figure 5 Schematic diagram of an image file processing system in one embodiment of the present application. Figure 5 As shown, the CPU 101 and the MCU 102 use a serial communication method, and the MCU 102 and the BMC 104 use an integrated circuit bus (I2C bus) for communication. The MCU 102 is connected to the external memory 103, and the two use a serial communication method. When the Flash memory in the MCU 102 is insufficient, the storage address of the image file or the flag bit is migrated to the external memory 103.

[0170] In one embodiment, a BMC is also installed inside the server. After the server is started, the user on the host side can remotely connect to the BMC through the host, and send a second view request to the MCU through the BMC to obtain the version information of the currently running image file. After the BMC obtains the firmware version information currently running on the MCU, it is displayed in the BMC user interface. In this embodiment, the BMC can enable users to remotely monitor the running status of the MCU firmware version of the edge server, saving time and labor costs.

[0171] Based on the same inventive concept, an embodiment of the present application provides an image file processing device, comprising:

[0172] A first communication module is configured to receive a first instruction sent by a central processing unit; or receive a second instruction sent by the central processing unit;

[0173] The first processing module is configured to perform an image switching operation according to the first instruction; the image switching operation includes: determining a sector where a second image file that is not currently running is located based on a currently running first image file; wherein the first image file and the second image file are image files of the same type pre-stored in different sectors of a memory; and reading the second image file from the sector and running it;

[0174] The second processing module is configured to perform an image refresh operation according to the second instruction; the image refresh operation includes: based on the currently running first image file, determining the sector where the currently not running second image file is located; writing a third image file into the sector and replacing the second image file; the third image file is of the same type as the first image file.

[0175] As an implementation manner of the present application, the first processing module is configured to determine the sector where the second image file that is not currently running is located based on the first image file that is currently running, including:

[0176] According to the first instruction, updating a switch flag bit; the switch flag bit is used to indicate the type of operation performed by the target processor;

[0177] Reading a version flag, and determining the first sector where the currently running first image file is located according to the version flag; the version flag is used to indicate the version of the currently running image file;

[0178] Based on the first sector, a second sector where a second image file that is not currently running is located is determined.

[0179] As an implementation manner of the present application, the first processing module is configured to read the second image file from the sector and run it, including:

[0180] Performing a reset operation, and updating the version flag based on the second sector;

[0181] After resetting, based on the updated version flag, the second image file is read from the second sector and loaded into the memory for execution.

[0182] As an implementation mode of the present application, the version flag includes: a main version flag and a startup version flag;

[0183] The first processing module is configured to update the version flag based on the second sector, including:

[0184] In the case where the second image file stored in the second sector is a main program file, updating the main version flag;

[0185] When the second image file stored in the second sector is a startup program file, the startup version flag is updated.

[0186] As an implementation manner of the present application, the second processing module is configured to determine the sector where the second image file that is not currently running is located based on the first image file that is currently running, including:

[0187] According to the second instruction, updating a switch flag bit; the switch flag bit is used to indicate the type of operation performed by the target processor;

[0188] Reading a version flag, and determining the first sector where the currently running first image file is located according to the version flag; the version flag is used to indicate the version of the currently running image file;

[0189] Based on the first sector, a second sector where a second image file that is not currently running is located is determined.

[0190] As an implementation manner of the present application, the second processing module is configured to write the third image file into the sector and replace the second image file, including:

[0191] Receiving a third image file sent by the central processing unit;

[0192] Performing integrity check on the third image file;

[0193] If the integrity check passes, the third image file is written into the second sector and replaces the second image file.

[0194] As an implementation manner of the present application, the second processing module is further configured to perform the following steps after writing the third image file into the second sector and replacing the second image file:

[0195] Perform a reset operation, and update the version flag based on the second sector; the version flag includes: a main version flag and a startup version flag;

[0196] After resetting, based on the updated version flag, the third image file is read from the second sector and loaded into the memory for execution.

[0197] As an implementation mode of the present application, the version flag includes: a main version flag and a startup version flag;

[0198] The second processing module is configured to update the version flag based on the second sector, including:

[0199] In the case where the third image file stored in the second sector is a main program file, updating the main version flag;

[0200] When the third image file stored in the second sector is a startup program file, the startup version flag is updated.

[0201] As an implementation manner of the present application, the first communication module is further configured to perform the following operations after performing the mirror switching operation or the mirror refresh operation:

[0202] Sending operation completion information to the central processing unit;

[0203] A viewing request sent by the central processing unit is received, and version information of the currently running image file is sent to the central processing unit.

[0204] Based on the same inventive concept, an embodiment of the present application provides an image file processing device, which is deployed in a central processing unit, and the device includes:

[0205] The first task acquisition module is configured to acquire a first task, wherein the first task is used to instruct the target processor to perform an image switching operation; the image switching operation includes: determining a sector where a second image file that is not currently running is located based on a currently running first image file; wherein the first image file and the second image file are image files of the same type pre-stored in different sectors of a memory; and reading the second image file from the sector and running it;

[0206] a second task acquisition module, configured to acquire a second task, wherein the second task is used to instruct the target processor to perform an image refresh operation; the image refresh operation includes: determining a sector where a second image file that is not currently running is located based on a currently running first image file; writing a third image file into the sector and replacing the second image file; the third image file is of the same type as the first image file;

[0207] an instruction generating module, configured to generate a first instruction based on the first task, or to generate a second instruction based on the second task;

[0208] The second communication module is configured to send the first instruction or the second instruction to the target processor.

[0209] As an implementation manner of the present application, the second communication module is further configured to perform the following operations:

[0210] Receiving operation completion information sent by the target processor;

[0211] A query request is sent to the target processor to obtain version information of the image file currently running in the target processor.

[0212] Based on the same inventive concept, an embodiment of the present application provides a computer program product, including a computer program. When the computer program is executed by a processor, the steps in the image file processing method described in any of the above embodiments of the present application are implemented.

[0213] Based on the same inventive concept, an embodiment of the present application provides a readable storage medium on which a computer program is stored. When the program is executed by a processor, the steps in the image file processing method described in any of the above embodiments of the present application are implemented.

[0214] Based on the same inventive concept, an embodiment of the present application provides an electronic device. Figure 6 Schematic diagram of an electronic device according to an embodiment of the present application. Figure 6As shown, the electronic device includes: a memory, a processor, and a computer program stored in the memory and executable on the processor. When the processor executes the computer program, the steps in the image file processing method described in any of the above embodiments of the present application are implemented.

[0215] Regarding the device in the above embodiment, the specific manner in which each module performs operations has been described in detail in the embodiment of the method, and will not be elaborated here.

[0216] The above description is only a preferred embodiment of the present application and is not intended to limit the present application. Any modifications, equivalent substitutions, improvements, etc. made within the spirit and principles of the present application should be included in the protection scope of the present application.

[0217] For the method embodiments, for the sake of simplicity, they are all described as a series of action combinations, but those skilled in the art should be aware that the present application is not limited by the order of the actions described, because according to the present application, some steps can be performed in other orders or simultaneously. Secondly, those skilled in the art should also be aware that the embodiments described in the specification are all preferred embodiments, and the actions and components involved are not necessarily required by the present application.

[0218] Those skilled in the art will appreciate that the embodiments of the present application may be provided as methods, devices, or computer program products. Therefore, the embodiments of the present application may adopt the form of a complete hardware embodiment, a complete software embodiment, or an embodiment in combination with software and hardware. Moreover, the embodiments of the present application may adopt the form of a computer program product implemented on one or more computer-usable storage media (including but not limited to disk storage, CD-ROM, optical storage, etc.) containing computer-usable program codes.

[0219] The embodiments of the present application are described with reference to the flowcharts and / or block diagrams of the methods, terminal devices (systems), and computer program products according to the embodiments of the present application. It should be understood that each process and / or box in the flowchart and / or block diagram, as well as the combination of the processes and / or boxes in the flowchart and / or block diagram, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, a special-purpose computer, an embedded processor, or other programmable data processing terminal device to generate a machine, so that the instructions executed by the processor of the computer or other programmable data processing terminal device generate instructions for implementing the processes in the flowchart and / or block diagram. Figure 1 A process or multiple processes and / or boxes Figure 1 A device that provides the functions specified in a block or multiple blocks.

[0220] These computer program instructions may also be stored in a computer readable memory capable of directing a computer or other programmable data processing terminal device to operate in a specific manner, so that the instructions stored in the computer readable memory produce a manufactured product including an instruction device, which implements the process Figure 1 A process or multiple processes and / or boxes Figure 1 A function specified in one or more boxes.

[0221] These computer program instructions can also be loaded onto a computer or other programmable data processing terminal device so that a series of operating steps are executed on the computer or other programmable terminal device to produce a computer-implemented process, thereby providing instructions for executing on the computer or other programmable terminal device to implement the process. Figure 1 A process or multiple processes and / or boxes Figure 1 The steps for the functions specified in one or more boxes.

[0222] Although the preferred embodiments of the present application have been described, those skilled in the art may make additional changes and modifications to these embodiments once they are aware of the basic creative concepts. Therefore, the present application is interpreted as including the preferred embodiments and all changes and modifications that fall within the scope of the embodiments of the present application.

[0223] Finally, it should be noted that, in this article, relational terms such as first and second, etc. are only used to distinguish one entity or operation from another entity or operation, and do not necessarily require or imply any such actual relationship or order between these entities or operations. Moreover, the terms "include", "comprise" or any other variants thereof are intended to cover non-exclusive inclusion, so that a process, method, article or terminal device including a series of elements includes not only those elements, but also other elements not explicitly listed, or also includes elements inherent to such process, method, article or terminal device. In the absence of further restrictions, the elements defined by the sentence "comprise a ..." do not exclude the existence of other identical elements in the process, method, article or terminal device including the elements.

[0224] The image file processing method, system and product provided by the present application are introduced in detail above. Specific examples are used in this article to illustrate the principles and implementation methods of the present application. The description of the above embodiments is only used to help understand the method and core idea of ​​the present application. At the same time, for those skilled in the art, according to the idea of ​​the present application, there will be changes in the specific implementation method and application scope. In summary, the content of this specification should not be understood as a limitation on the present application.

Claims

1. A method for processing an image file, characterized in that: Apply to the target processor; The method comprises: receiving a first instruction sent by a central processing unit; According to the first instruction, performing a mirror switching operation; The image switching operation includes: based on the currently running first image file, determining the sector where the currently non-running second image file is located, specifically including: according to the first instruction, updating the switching flag bit; the switching flag bit is used to indicate the type of operation performed by the target processor; reading the version flag bit, and determining the first sector where the currently running first image file is located according to the version flag bit; the version flag bit is used to indicate the version of the currently running image file; based on the first sector, determining the second sector where the currently non-running second image file is located; wherein the first image file and the second image file are image files of the same type pre-stored in different sectors of the memory; reading the second image file from the sector and running it; or, receiving a second instruction sent by the central processing unit; According to the second instruction, performing an image refresh operation; The image refresh operation includes: based on the currently running first image file, determining the sector where the currently not running second image file is located, specifically including: according to the second instruction, updating the switch flag; the switch flag is used to indicate the type of operation performed by the target processor; reading the version flag, and determining the first sector where the currently running first image file is located according to the version flag; the version flag is used to indicate the version of the currently running image file; based on the first sector, determining the second sector where the currently not running second image file is located; writing the third image file into the sector and replacing the second image file; the third image file is of the same type as the first image file.

2. The image file processing method according to claim 1, characterized in that: Reading the second image file from the sector and running it includes: Performing a reset operation, and updating the version flag based on the second sector; After resetting, based on the updated version flag, the second image file is read from the second sector and loaded into the memory for execution.

3. The image file processing method according to claim 2, characterized in that: The version flags include: a main version flag and a startup version flag; Updating the version flag based on the second sector includes: In the case where the second image file stored in the second sector is a main program file, updating the main version flag; When the second image file stored in the second sector is a startup program file, the startup version flag is updated.

4. The image file processing method according to claim 1, characterized in that: Writing the third image file into the sector and replacing the second image file comprises: Receiving a third image file sent by the central processing unit; Performing integrity check on the third image file; If the integrity check passes, the third image file is written into the second sector and replaces the second image file.

5. The image file processing method according to claim 4, characterized in that: After writing the third image file into the second sector and replacing the second image file, the method further includes: Perform a reset operation, and update the version flag based on the second sector; the version flag includes: a main version flag and a startup version flag; After resetting, based on the updated version flag, the third image file is read from the second sector and loaded into the memory for execution.

6. The image file processing method according to claim 5, characterized in that: The version flags include: a main version flag and a startup version flag; Updating the version flag based on the second sector includes: In the case where the third image file stored in the second sector is a main program file, updating the main version flag; When the third image file stored in the second sector is a startup program file, the startup version flag is updated.

7. The image file processing method according to claim 1, characterized in that: After performing a mirror switch operation or a mirror refresh operation, the following steps are also included: Sending operation completion information to the central processing unit; A viewing request sent by the central processing unit is received, and version information of the currently running image file is sent to the central processing unit.

8. The image file processing method according to claim 1, characterized in that: The memory comprises: a non-volatile memory in the target processor; the non-volatile memory is pre-divided into a plurality of sectors and is used to store: a first image file of a main program, a second image file of the main program, a third image file of the main program, a first image file of a startup program, a second image file of a startup program, a third image file of a startup program, or at least one of a flag bit; The flag bits include: a switch flag bit and a version flag bit; the switch flag bit is used to indicate the type of operation performed by the target processor, and the version flag bit is used to indicate the version of the currently running image file.

9. The image file processing method according to claim 8, characterized in that: The memory also includes: an external memory connected to the target processor; the external memory is used to store at least one of the following when the storage space of the non-volatile memory in the target processor is insufficient: a first image file of the main program, a second image file of the main program, a third image file of the main program, a first image file of the startup program, a second image file of the startup program, a third image file of the startup program, or a flag.

10. A method for processing an image file, characterized in that: Applicable to CPU, including: Acquire a first task, the first task is used to instruct a target processor to perform an image switching operation; the image switching operation includes: determining a sector where a second image file that is not currently running is located based on a currently running first image file; wherein the first image file and the second image file are image files of the same type pre-stored in different sectors of a memory; reading the second image file from the sector and running it; determining the sector where the second image file that is not currently running is located based on the currently running first image file, including: updating a switching flag bit according to a first instruction; the switching flag bit is used to indicate the type of operation performed by the target processor; reading a version flag bit, and determining a first sector where the first image file that is currently running is located according to the version flag bit; the version flag bit is used to indicate the version of the currently running image file; based on the first sector, determining a second sector where the second image file that is not currently running is located; Or, obtain a second task, the second task is used to instruct the target processor to perform an image refresh operation; the image refresh operation includes: based on the currently running first image file, determine the sector where the currently not running second image file is located; write a third image file into the sector and replace the second image file; the third image file is of the same type as the first image file; based on the currently running first image file, determine the sector where the currently not running second image file is located, including: according to the second instruction, update the switch flag; the switch flag is used to indicate the type of operation performed by the target processor; read the version flag, and determine the first sector where the currently running first image file is located according to the version flag; the version flag is used to indicate the version of the currently running image file; based on the first sector, determine the second sector where the currently not running second image file is located.

11. The image file processing method according to claim 10, characterized in that: Also includes: Receiving operation completion information sent by the target processor; A query request is sent to the target processor to obtain version information of the image file currently running in the target processor.

12. A mirror file processing system, characterized in that: include: A central processing unit, configured to execute the method according to claim 10 or 11, so as to control the target processor to execute a mirror switching operation or a mirror refresh operation; The target processor is used to perform the mirror switching operation or the mirror refresh operation in any one of the methods described in claims 1-9.

13. The image file processing system according to claim 12, characterized in that: Also includes: An external memory is connected to the target processor and is used to store at least one of the following when the storage space of the non-volatile memory in the target processor is insufficient: a first image file of a main program, a second image file of a main program, a third image file of a main program, a first image file of a startup program, a second image file of a startup program, a third image file of a startup program, or a flag.

14. The image file processing system according to claim 12, characterized in that: Also includes: The baseboard management controller is connected to the target processor via an integrated circuit bus and is used to obtain version information of the image file currently running in the target processor.

15. A computer program product comprising a computer program, characterized in that When the computer program is executed by a processor, the method according to any one of claims 1 to 9 or the steps in the method according to any one of claims 10 to 11 are implemented.

16. A computer-readable storage medium having a computer program stored thereon, characterized in that: When the computer program is executed by a processor, the method according to any one of claims 1 to 9 or the steps in the method according to any one of claims 10 to 11 are implemented.

17. An electronic device comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, characterized in that: When the processor executes the computer program, it implements the method according to any one of claims 1 to 9, or the steps in the method according to any one of claims 10 to 11.

Images