CN115756563A - Method for hot patching OpenGauss database - Google Patents
Method for hot patching OpenGauss database Download PDFInfo
- Publication number
- CN115756563A CN115756563A CN202211474911.9A CN202211474911A CN115756563A CN 115756563 A CN115756563 A CN 115756563A CN 202211474911 A CN202211474911 A CN 202211474911A CN 115756563 A CN115756563 A CN 115756563A
- Authority
- CN
- China
- Prior art keywords
- patch
- file
- database
- libcare
- database service
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
- 238000000034 method Methods 0.000 title claims abstract description 76
- 230000008439 repair process Effects 0.000 claims abstract description 16
- 230000006870 function Effects 0.000 claims description 16
- 230000008569 process Effects 0.000 claims description 15
- 230000007547 defect Effects 0.000 claims description 10
- 230000002950 deficient Effects 0.000 claims description 9
- 238000012423 maintenance Methods 0.000 claims description 4
- 238000011084 recovery Methods 0.000 claims description 2
- 238000012795 verification Methods 0.000 abstract description 9
- 230000004044 response Effects 0.000 abstract description 3
- 238000005516 engineering process Methods 0.000 description 6
- 230000006978 adaptation Effects 0.000 description 2
- 238000009434 installation Methods 0.000 description 2
- 230000009286 beneficial effect Effects 0.000 description 1
- 238000011161 development Methods 0.000 description 1
- 230000004048 modification Effects 0.000 description 1
- 238000012986 modification Methods 0.000 description 1
- 230000006855 networking Effects 0.000 description 1
- 238000006467 substitution reaction Methods 0.000 description 1
Images
Classifications
-
- Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y02—TECHNOLOGIES OR APPLICATIONS FOR MITIGATION OR ADAPTATION AGAINST CLIMATE CHANGE
- Y02D—CLIMATE CHANGE MITIGATION TECHNOLOGIES IN INFORMATION AND COMMUNICATION TECHNOLOGIES [ICT], I.E. INFORMATION AND COMMUNICATION TECHNOLOGIES AIMING AT THE REDUCTION OF THEIR OWN ENERGY USE
- Y02D10/00—Energy efficient computing, e.g. low power processors, power management or thermal management
Landscapes
- Stored Programmes (AREA)
Abstract
The invention relates to the technical field of database patches, and provides a method for hot patching an OpenGauss database, which comprises the following steps: generating a libcare-patch-make component by compiling source codes of a libcaraplus tool; compiling the source code of OpenGauss containing patch through a libcare-patch-make component to generate a patch file applicable to database service; and applying the generated patch file to a database service. According to the method for hot patching the OpenGauss database, disclosed by the exemplary embodiment of the invention, the repair of the program bug can be completed under the condition that the current network service is not influenced; the verification work is simplified from version verification to patch verification, the cost of database repair is reduced, and the method is more suitable for scenes needing quick response.
Description
Technical Field
The invention relates to the technical field of database patches, in particular to a method for hot patching an OpenGauss database.
Background
When a running program has a bug or a bug, the following solutions are generally available: 1. replacing the latest OS version containing the repair patch, migrating the currently running program to a standby area in a networking environment with main/standby switching capability, and migrating the program to a main area after the main area is upgraded; 2. replacing the installation package of the program, then re-running the program, wherein the compatibility of the dependency package needs to be considered at this time, and for the program with hot replacement capability, the hot replacement capability can be utilized to realize the replacement of the running content of the program; 3. and directly patching the content of the running program, replacing problematic codes and repairing the program defects or loopholes.
From the viewpoint of patch granularity, the vulnerability repair granularity of the three solutions changes from large to small: the method 1 is system-level, and mainly relates to a technology of thermomigration; the 2 nd method is at the installation package level, and the main related technology is hot replacement technology; the 3 rd method is at the program level, and the technology mainly involved is hot patching.
From the perspective of service interruption duration, in practical applications, the service interruption duration also changes from large to small: when the solution 1 is adopted, the service interruption time is generally in the minute level, and generally relates to the main/standby switching of the whole system service, the upgrading period is longest, and an upgrading window of several months is generally needed; when the 2 nd solution is adopted, the service interruption time is generally in the order of hundred milliseconds, the technology is generally not universal, a large number of service codes need to be modified and adapted in an intrusive mode, the upgrading period is relatively short, and generally only one month of upgrading window is needed; when the 3 rd solution is adopted, the service interruption time is generally in the millisecond level, the technology is universal, invasive modification and adaptation of service codes are not needed, but some universal codes need to be adapted, the adaptation workload is relatively small, the upgrading period is also relatively short compared with the former two methods, and a one-month upgrading window is also needed.
In order to guarantee the continuity of service development and operation, how to provide a database repair method which does not affect service operation and can reduce repair cost becomes a technical problem to be solved urgently.
Disclosure of Invention
In view of this, in order to overcome the defects of the prior art, the present invention aims to provide a method for hot patching an OpenGauss database, and a scheme for quickly repairing product defects at low cost is provided without interrupting database (OpenGauss) services based on a libcaraplus hot patching tool.
The invention provides a method for hot patching an OpenGauss database, which comprises the following steps:
step S1: generating a libcare-patch-make component by compiling a source code of a LibcarePlus tool;
step S2: compiling the source code of OpenGauss containing patch through a libcare-patch-make component to generate a patch file applicable to database service;
and step S3: and applying the patch file generated in the step S2 to a database service.
Further, the invention provides a method for hot patching an OpenGauss database, wherein a libcare-patch-make component in the step S1 comprises the following steps:
a compiler libcare-cc for making patch files;
a binary executable program kpatch _ gensrc for generating assembly content and difference content containing the original file;
a script file libfile-patch-make for automatically generating a patch file;
a component kpatch _ make to generate a patch;
a binary executable libcare-ctl to apply patch files, view patch information, and uninstall patches.
Further, the present invention provides a method for hot patching an OpenGauss database, and step S2 includes:
step S21: calling a compiler libcare-cc to compile the source code without patch, generating a first temporary assembly file and a first temporary relocation file, and linking the temporary relocation file to generate a database service binary program capable of applying a patch file;
step S22: calling a system command in the script file libcall-patch-make to apply a patch difference file to a source code which is not subjected to the patch, and obtaining a source code subjected to the patch;
step S23: calling a compiler libcare-cc to compile the source code which has been patched, and generating a second temporary assembly file;
step S24: calling a binary executable program kpatch _ gensrc to compare the first temporary assembly file with the second temporary assembly file, and generating an assembly file containing the first temporary assembly file and a patch difference file;
step S25: calling a compiler libfile-cc to compile the assembly file to obtain a second temporary relocation file, and linking the second relocation file to generate a database service binary program containing a patch difference file;
step S26: and (4) integrating and repairing the database service binary program which can be applied with the patch file and is generated in the step (S21) and the database service binary program which is generated in the step (S25) and contains the patch difference file to generate a patch file which can be applied to the database service.
Further, the present invention provides a method for hot patching an OpenGauss database, where step S26 includes:
step S261: deleting useless sections in the database service binary program which is generated in the step S25 and contains the patch difference file, and generating a first temporary patch file;
step S262: repairing the global variable and the function symbolic address quoted by the function in the first temporary patch file according to the database service binary process sequence which is generated in the step S21 and can be applied with the patch file, and generating a second temporary patch file;
step S263: deleting the symbol information which is useless for the hot patch relocation operation in the second temporary patch file, and generating a third temporary patch file;
step S264: changing the function symbol address in the third temporary patch file from an absolute address to a relative address according to the database service binary program of the applicable patch file generated in the step S21, and generating a fourth temporary patch file;
step S265: calling a system command in the script file libcall-patch-make to acquire the Build ID of the database service binary program which is generated in the step S21 and can be applied with the patch file;
step S266: and the calling component kpatch _ make generates a patch file applicable to the database service according to the Build ID and the fourth temporary patch file in the step S265.
Further, the present invention provides a method for hot patching an OpenGauss database, wherein step S3 includes: and starting OpenGauss database service, and applying the patch file generated in the step S2 to an operating OpenGauss database service process by adopting a libcare-ctl component.
Further, the method for hot patching the OpenGauss database adopts a libcare-ctl component to apply the patch file generated in the step S2 to the running OpenGauss database service process, and comprises the following steps:
copying part of codes of the defect code segments in the database service process to a patch area through a libcare-ctl component for storage, and recovering when the patch is unloaded;
and covering the memory space stored in the defective code segment by using the repair code address corresponding to the patch area, so that the code of the defective code segment points to the patch area, and when the database service calls the function corresponding to the defective code segment again, the function execution instruction jumps to the code segment repaired in the patch area.
Further, the method for hot patching the OpenGauss database comprises the following steps: after the patch file is applied to the database service, checking related patch information through a libcare-ctl component, wherein the patch information comprises a target process and a patch ID of the patch file application.
Further, the method for hot patching an OpenGauss database of the present invention further comprises: after the patch file is applied to the database service, patches that do not need maintenance are unloaded via the libcare-ctl component.
Further, the invention provides a method for hot patching of an OpenGauss database, wherein patches which do not need to be maintained are unloaded through a libcare-ctl component, and the method comprises the following steps: and checking related patch information through a libcare-ctl component, and unloading a corresponding patch according to a patch ID in the patch information.
Further, the method for hot patching an OpenGauss database of the present invention unloads a corresponding patch according to a patch ID in the patch information, including: and covering the memory space occupied by the repair code when the patch file is applied by using the defect code segment for recovery stored in the patch area through a libcare-ctl component.
The invention discloses a method for hot patching an OpenGauss database, which has the following beneficial effects:
1. under the condition of not influencing the current network service, the repair of the program bug can be completed;
2. the verification work is simplified from version verification to patch verification, the cost of database repair is reduced, and the method is more suitable for scenes needing quick response.
Drawings
In order to more clearly illustrate the technical solutions of the embodiments of the present invention, the drawings required to be used in the embodiments will be briefly described below, and it is obvious that the drawings in the following description are only some embodiments of the present invention, and it is obvious for those skilled in the art that other drawings can be obtained according to the drawings without creative efforts.
Fig. 1 is a flowchart illustrating a method for hot patching an OpenGauss database according to an exemplary first embodiment of the present invention.
Fig. 2 is a flowchart illustrating a method for hot patching an OpenGauss database according to an exemplary second embodiment of the present invention.
Fig. 3 is a flowchart of a method for hot patching an OpenGauss database according to an exemplary third embodiment of the present invention.
Fig. 4 is a flowchart illustrating a method for hot patching an OpenGauss database according to an exemplary fourth embodiment of the present invention.
Detailed Description
Embodiments of the present invention will be described in detail below with reference to the accompanying drawings.
It should be noted that, in the case of no conflict, the features in the following embodiments and examples may be combined with each other; moreover, based on the embodiments in the present disclosure, all other embodiments obtained by a person of ordinary skill in the art without making creative efforts shall fall within the protection scope of the present disclosure.
It is noted that various aspects of the embodiments are described below within the scope of the appended claims. It should be apparent that the aspects described herein may be embodied in a wide variety of forms and that any specific structure and/or function described herein is merely illustrative. Based on the disclosure, one skilled in the art should appreciate that one aspect described herein may be implemented independently of any other aspects and that two or more of these aspects may be combined in various ways. For example, an apparatus may be implemented and/or a method practiced using any number of the aspects set forth herein. In addition, such an apparatus may be implemented and/or such a method may be practiced using other structure and/or functionality in addition to or other than one or more of the aspects set forth herein.
The invention provides a scheme for repairing product defects quickly and with low cost under the condition of not interrupting database (OpenGauss) service based on a LibcarePlus hot patching tool. LibcarePlus is an open source user state process hot patch framework.
Fig. 1 is a flowchart of a method for hot patching an OpenGauss database according to an exemplary first embodiment of the present invention, as shown in fig. 1, the method of the present embodiment includes:
step S1: generating a libcare-patch-make component by compiling a source code of a LibcarePlus tool;
step S2: compiling the source code of OpenGauss containing patch through a libcare-patch-make component to generate a patch file applicable to database service;
and step S3: and applying the patch file generated in the step S2 to a database service.
The libcare-patch-make component in step S1 of the method of this embodiment includes:
a compiler libcare-cc for making patch files;
a binary executable program kpatch _ gensrc for generating assembly content and difference content containing the original file;
a script file libfile-patch-make for automatically generating a patch file;
a component kpatch _ make for generating a patch;
a binary executable libcare-ctl to apply patch files, view patch information, and uninstall patches.
The method can finish the repair of the program bug without affecting the current network service; the verification work is simplified from version verification to patch verification, the cost of database repair is reduced, and the method is more suitable for scenes needing quick response.
Fig. 2 is a flowchart of a method for hot patching an OpenGauss database according to an exemplary second embodiment of the present invention, where this embodiment is a preferred embodiment of the method shown in fig. 1, and as shown in fig. 2, step S2 of the method of this embodiment includes:
step S21: calling a compiler libcare-cc to compile the source code without patch, generating a first temporary assembly file and a first temporary relocation file, and linking the temporary relocation file to generate a database service binary program capable of applying a patch file;
step S22: calling a system command in a script file libcall-patch-make to apply a patch difference file to a source code which does not make a patch, and obtaining a source code which has made the patch;
step S23: calling a compiler libcare-cc to compile the source code with the patch, and generating a second temporary assembly file;
step S24: calling a binary executable program kpatch _ gensrc to compare the first temporary assembly file with the second temporary assembly file, and generating an assembly file containing the first temporary assembly file and a patch difference file;
step S25: calling a compiler libfile-cc to compile the assembly file to obtain a second temporary relocation file, and linking the second relocation file to generate a database service binary program containing a patch difference file;
step S26: and (4) integrating and repairing the database service binary program which can be applied with the patch file and is generated in the step (S21) and the database service binary program which is generated in the step (S25) and contains the patch difference file to generate a patch file which can be applied to the database service.
Fig. 3 is a flowchart of a method for hot patching an OpenGauss database according to an exemplary third embodiment of the present invention, where this embodiment is a preferred embodiment of the method shown in fig. 3, and as shown in fig. 3, step S26 of the method of this embodiment includes:
step S261: deleting useless sections in the database service binary program containing the patch difference file generated in the step S25 to generate a first temporary patch file;
step S262: repairing the global variable and the function symbolic address quoted by the function in the first temporary patch file according to the database service binary process sequence which is generated in the step S21 and can be applied with the patch file, and generating a second temporary patch file;
step S263: deleting the symbolic information which is useless for the hot patch relocation operation in the second temporary patch file, and generating a third temporary patch file;
step S264: changing the function symbol address in the third temporary patch file from an absolute address to a relative address according to the database service binary program of the applicable patch file generated in the step S21, and generating a fourth temporary patch file;
step S265: calling a system command in the script file libcall-patch-make to acquire the Build ID of the database service binary program which is generated in the step S21 and can be applied with the patch file;
step S266: and the calling component kpatch _ make generates a patch file applicable to the database service according to the Build ID and the fourth temporary patch file in the step S265.
Fig. 4 is a flowchart illustrating a method for hot patching an OpenGauss database according to an exemplary fourth embodiment of the present invention, which is a preferred embodiment of the method shown in fig. 1.
As shown in fig. 4, step S3 of the method of the present embodiment includes: starting OpenGauss database service, applying the patch file generated in the step S2 to an operating OpenGauss database service process by adopting a libcare-ctl component, and specifically implementing the following steps:
copying part of codes of the defect code segments in the database service process to a patch area through a libcare-ctl component for storage, and recovering when the patch is unloaded;
and covering the memory space stored in the defective code segment by adopting the repair code address corresponding to the patch area, so that the code of the defective code segment points to the patch area, and when the database service calls the function corresponding to the defective code segment again, the function execution instruction jumps to the code segment repaired in the patch area.
As shown in fig. 4, the method of this embodiment includes: after the patch file is applied to the database service, checking related patch information through a libcare-ctl component, wherein the patch information comprises a target process and a patch ID of the application of the patch file.
As shown in fig. 4, the method of this embodiment further includes: after the patch file is applied to the database service, uninstalling the patch which does not need maintenance through a libcare-ctl component, wherein the patch file comprises the following steps: checking related patch information through a libcare-ctl component, unloading a corresponding patch according to a patch ID in the patch information, and specifically implementing the following method: and covering the memory space occupied by the repair code when the patch file is applied by adopting a defect code segment which is stored in the patch area and is used for recovering through a libcare-ctl component.
The above description is only for the specific embodiment of the present invention, but the scope of the present invention is not limited thereto, and any changes or substitutions that can be easily conceived by those skilled in the art within the technical scope of the present invention are included in the scope of the present invention. Therefore, the protection scope of the present invention shall be subject to the protection scope of the claims.
Claims (10)
1. A method for hot patching an OpenGauss database, the method comprising:
step S1: generating a libcare-patch-make component by compiling source codes of a libcaraplus tool;
step S2: compiling the source code of OpenGauss containing patch through a libcare-patch-make component to generate a patch file applicable to database service;
and step S3: and applying the patch file generated in the step S2 to a database service.
2. The method of claim 1, wherein the libcare-patch-make component in step S1 comprises:
a compiler libcare-cc for making patch files;
a binary executable program kpatch _ gensrc for generating assembly content and difference content containing the original file;
a script file libfile-patch-make for automatically generating a patch file;
a component kpatch _ make for generating a patch;
a binary executable libcare-ctl to apply patch files, view patch information, and uninstall patches.
3. The method for hot patching an OpenGauss database as claimed in claim 1, wherein step S2 comprises:
step S21: calling a compiler libcare-cc to compile the source code without patch, generating a first temporary assembly file and a first temporary relocation file, and linking the temporary relocation file to generate a database service binary program capable of applying a patch file;
step S22: calling a system command in a script file libcall-patch-make to apply a patch difference file to a source code which does not make a patch, and obtaining a source code which has made the patch;
step S23: calling a compiler libcare-cc to compile the source code with the patch, and generating a second temporary assembly file;
step S24: calling a binary executable program kpatch _ gensrc to compare the first temporary assembly file with the second temporary assembly file, and generating an assembly file containing the first temporary assembly file and a patch difference file;
step S25: calling a compiler libfile-cc to compile the assembly file to obtain a second temporary relocation file, and linking the second relocation file to generate a database service binary program containing a patch difference file;
step S26: the database service binary program to which the patch file is applicable generated in step S21 and the database service binary program including the patch difference file generated in step S25 are integrated and repaired to generate a patch file applicable to the database service.
4. The method for hot patching an OpenGauss database as claimed in claim 3, wherein step S26 comprises:
step S261: deleting useless sections in the database service binary program which is generated in the step S25 and contains the patch difference file, and generating a first temporary patch file;
step S262: repairing the global variable and the function symbolic address quoted by the function in the first temporary patch file according to the database service binary process sequence which is generated in the step S21 and can be applied with the patch file, and generating a second temporary patch file;
step S263: deleting the symbolic information which is useless for the hot patch relocation operation in the second temporary patch file, and generating a third temporary patch file;
step S264: changing the function symbol address in the third temporary patch file from an absolute address to a relative address according to the database service binary program of the applicable patch file generated in the step S21, and generating a fourth temporary patch file;
step S265: calling a system command in the script file libcall-patch-make to acquire the Build ID of the database service binary program which is generated in the step S21 and can be applied with the patch file;
step S266: and the call component kpatch _ make generates a patch file applicable to the database service according to the Build ID and the fourth temporary patch file in the step S265.
5. The method for hot patching an OpenGauss database as claimed in claim 1, wherein step S3 comprises: and starting the OpenGauss database service, and applying the patch file generated in the step S2 to the running OpenGauss database service process by adopting a libcare-ctl component.
6. The method for hot patching an OpenGauss database according to claim 5, wherein applying the patch file generated in step S2 to an operating OpenGauss database service process by using a libcare-ctl component comprises:
copying part of codes of the defect code segments in the database service process to a patch area through a libcare-ctl component for storage, and recovering when the patch is unloaded;
and covering the memory space stored in the defective code segment by using the repair code address corresponding to the patch area, so that the code of the defective code segment points to the patch area, and when the database service calls the function corresponding to the defective code segment again, the function execution instruction jumps to the code segment repaired in the patch area.
7. The method of hot patching an OpenGauss database as claimed in claim 1, wherein the method comprises: after the patch file is applied to the database service, checking related patch information through a libcare-ctl component, wherein the patch information comprises a target process and a patch ID of the patch file application.
8. The method for hot patching an OpenGauss database as claimed in claim 1, wherein the method further comprises: after the patch file is applied to the database service, patches that do not need maintenance are unloaded through the libcare-ctl component.
9. The method of claim 8, wherein offloading patches that do not require maintenance via a libcare-ctl component comprises: and checking related patch information through a libcare-ctl component, and unloading the corresponding patch according to the patch ID in the patch information.
10. The method of claim 9, wherein the uninstalling a corresponding patch according to a patch ID in the patch information comprises: and covering the memory space occupied by the repair code when the patch file is applied by using the defect code segment for recovery stored in the patch area through a libcare-ctl component.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202211474911.9A CN115756563A (en) | 2022-11-23 | 2022-11-23 | Method for hot patching OpenGauss database |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202211474911.9A CN115756563A (en) | 2022-11-23 | 2022-11-23 | Method for hot patching OpenGauss database |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN115756563A true CN115756563A (en) | 2023-03-07 |
Family
ID=85336001
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202211474911.9A Pending CN115756563A (en) | 2022-11-23 | 2022-11-23 | Method for hot patching OpenGauss database |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN115756563A (en) |
Citations (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20120278114A1 (en) * | 2011-04-26 | 2012-11-01 | Sap Ag | Method for dynamically reversing business functions |
| CN104461625A (en) * | 2014-12-04 | 2015-03-25 | 上海斐讯数据通信技术有限公司 | Hot patch realization method and system |
| CN105159738A (en) * | 2015-08-20 | 2015-12-16 | 上海斐讯数据通信技术有限公司 | Hot patch implementation method and system |
| CN106775671A (en) * | 2016-11-30 | 2017-05-31 | 武汉虹信通信技术有限责任公司 | A kind of hot patch restorative procedure in the linux environment for communication system |
| CN114924742A (en) * | 2022-05-18 | 2022-08-19 | 京东科技信息技术有限公司 | Hot patch making and applying method and device for virtual machine simulation software |
-
2022
- 2022-11-23 CN CN202211474911.9A patent/CN115756563A/en active Pending
Patent Citations (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20120278114A1 (en) * | 2011-04-26 | 2012-11-01 | Sap Ag | Method for dynamically reversing business functions |
| CN104461625A (en) * | 2014-12-04 | 2015-03-25 | 上海斐讯数据通信技术有限公司 | Hot patch realization method and system |
| CN105159738A (en) * | 2015-08-20 | 2015-12-16 | 上海斐讯数据通信技术有限公司 | Hot patch implementation method and system |
| CN106775671A (en) * | 2016-11-30 | 2017-05-31 | 武汉虹信通信技术有限责任公司 | A kind of hot patch restorative procedure in the linux environment for communication system |
| CN114924742A (en) * | 2022-05-18 | 2022-08-19 | 京东科技信息技术有限公司 | Hot patch making and applying method and device for virtual machine simulation software |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US8499289B2 (en) | Method, device and system for realizing kernel online patching | |
| CN102609328B (en) | System difference upgrade method and device and mobile terminal | |
| CN107391104B (en) | Client and reactive native code update dependence management method, device and system | |
| US7089548B2 (en) | Method and system for nondisruptive deployment during upgrading of enterprise systems | |
| CN105487980A (en) | Method and device for repairing running abnormity of application program | |
| CN105786537A (en) | Hot patch realization method and device | |
| CN104239082A (en) | Hot patching implementation method of embedded system | |
| US7882388B2 (en) | Dual independent non volatile memory systems | |
| CA2724532A1 (en) | Enhanced upgrade path | |
| CN101895671A (en) | Set top box Loader module updating method and set top box thereof | |
| CN108829431A (en) | Update method, device, equipment and the storage medium of iOS application program | |
| CN111562934A (en) | Software system upgrading method based on hot patch, terminal and storage medium | |
| CN110806884A (en) | Method and device for repairing operating system fault | |
| CN105183580A (en) | Storage method and fault recovery method for bootstrap program, and devices | |
| CN108536444B (en) | Plug-in compiling method and device, computer equipment and storage medium | |
| KR20050088193A (en) | Mobile handset with a fault tolerant update agent | |
| US7340738B2 (en) | Time optimized replacement of a software application | |
| CN115756563A (en) | Method for hot patching OpenGauss database | |
| CN100359485C (en) | Testing device and method for flush-bonding system | |
| CN115688119A (en) | Vulnerability repairing method and device, electronic equipment and storage medium | |
| JP2013041546A (en) | Debug support program, debug support method and debug support system | |
| CN110928569A (en) | Method for realizing Live Update function of communication equipment | |
| CN110543322A (en) | hot patching method and device for Loongson platform | |
| CN114726848B (en) | Client automatic packaging and exe distribution method and device for Windows platform | |
| CN111897538B (en) | Container platform deployment method and system based on CPU and operating system |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| RJ01 | Rejection of invention patent application after publication | ||
| RJ01 | Rejection of invention patent application after publication |
Application publication date: 20230307 |