CN115629811B - System stability control method and device - Google Patents

System stability control method and device Download PDF

Info

Publication number
CN115629811B
CN115629811B CN202211647128.8A CN202211647128A CN115629811B CN 115629811 B CN115629811 B CN 115629811B CN 202211647128 A CN202211647128 A CN 202211647128A CN 115629811 B CN115629811 B CN 115629811B
Authority
CN
China
Prior art keywords
configuration file
file
config
json
storage unit
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.)
Active
Application number
CN202211647128.8A
Other languages
Chinese (zh)
Other versions
CN115629811A (en
Inventor
陈翔
沈冠宇
纪柏雄
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
Suzhou Inspur Intelligent Technology Co Ltd
Original Assignee
Suzhou Inspur Intelligent Technology Co Ltd
Priority date (The priority date 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 date listed.)
Filing date
Publication date
Application filed by Suzhou Inspur Intelligent Technology Co Ltd filed Critical Suzhou Inspur Intelligent Technology Co Ltd
Priority to CN202211647128.8A priority Critical patent/CN115629811B/en
Publication of CN115629811A publication Critical patent/CN115629811A/en
Application granted granted Critical
Publication of CN115629811B publication Critical patent/CN115629811B/en
Active legal-status Critical Current
Anticipated expiration legal-status Critical

Links

Images

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/44—Arrangements for executing specific programs
    • G06F9/4401—Bootstrapping
    • G06F9/4406—Loading of operating system
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
    • G06F16/20—Information retrieval; Database structures therefor; File system structures therefor of structured data, e.g. relational data
    • G06F16/25—Integrating or interfacing systems involving database management systems
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/44—Arrangements for executing specific programs
    • G06F9/445—Program loading or initiating
    • G06F9/44505—Configuring for program initiating, e.g. using registry, configuration files

Abstract

The application relates to a system stability control method and device. The method comprises the following steps: the system is an open source network operating system, the open source network operating system comprises a combined mount file system, and the method comprises the following steps: responding to a starting request of an open source network operating system, and acquiring a kernel configuration file and a system configuration file from a lower directory of a combined mount file system; and independently mounting the system configuration file to a readable and writable file system, independently mounting the kernel configuration file to a temporary storage file system, and setting the system configuration file and the kernel configuration file as an upper directory of a combined mounting file system.

Description

System stability control method and device
Technical Field
The present application relates to the field of system security start testing technologies, and in particular, to a method and an apparatus for controlling system stability.
Background
An Open source network operating system (called as Software for Open Networking in the Cloud; called as SONiC for short) is composed of various modules, and the modules are mutually held through a centralized and extensible basic unit, as shown in FIG. 1, which is an architecture schematic diagram of the Open source network operating system.
The File System of the current SONiC System adopts a combined mounting File System architecture (fully: overlay File System; abbreviated as Overlay FS); specifically, the current SONiC system includes: an open source read-only compressed File System (generic: squash File System GPL; abbreviated: squashFS) arranged in a lower directory of a combined mount File System architecture; loading fs.quashfs in a mirror image in a read-only file system to ensure that files in the area cannot be modified; a/host/image _ dir/rw folder created by the SONiC system mounted on the readable and writable area Ext4; system-related configuration files stored in folders (e.g., etc., home, root, etc.) under/host/image _ dir/rw, such as Linux kernel-related configuration files stored under kernel important configuration files/host/image _ dir/rw/etc., and user-side configuration files stored under system important configuration files/host/image _ dir/rw/etc/soni; fig. 2 is a schematic diagram of a structure of a file system architecture for joint mount in the prior art, in which upper is an upper directory, lower is a lower directory, and merge is an operation-level directory (also called a file-based directory).
In an actual application scenario, only after the configuration file under/host/image _ dir/rw/etc is successfully configured, the resident management program on the SONiC system can normally operate. When a user modifies a configuration file in the SONiC system under the/host/image _ dir/rw/etc, the modification can be performed in the following two ways: one is to modify the configuration file directly under the file system, and the other is to write the configuration into a CONFIG _ DB database through a CLI interface provided by the SONiC system and then store the configuration into CONFIG _ db.json under a/host/image _ dir/rw/etc/SONiC/directory; after restarting, the CONFIG _ db.json is reloaded into the CONFIG _ DB database, and at this time, the resident management program subscribing the CONFIG _ DB database in the system overwrites the configuration value set by the user to the corresponding configuration file again and applies the configuration value; fig. 3 is a schematic diagram illustrating a configuration of a CL1 interface of an operating system of an open source network in the prior art.
However, in the design of the OverlayFS architecture of the existing SONiC system, all configuration files are mounted on an upper directory upper (Ext 4) of the OverlayFS, so that when a user writes an important configuration file, once a data writing incomplete condition is caused by an unexpected accident (such as system power failure), an original configuration file is covered by current data, and the configuration file which is not complete at present is reserved; moreover, because the files in the upper directory of the overlayFS mask the files in the lower directory, the incomplete configuration file loaded on the upper directory causes abnormal operation of the system and even cannot be started when the system is restarted, and the situation is usually irreversible (for example, normal login modification or startup failure and the like cannot be realized). In order to restart the system, in the prior art, the entire system can only be restored by re-burning the image, but restoring the entire system based on the re-burning of the image causes that important files or log files on the system are permanently lost and cannot be restored.
Therefore, it is urgently needed to provide a system stability control method, device and computer equipment capable of solving the above technical problems.
Disclosure of Invention
In view of the foregoing, it is desirable to provide a method and an apparatus for controlling system stability, which can improve the system restart stability.
In one aspect, a method for controlling system stability is provided, where the system is an open-source network operating system, the open-source network operating system includes a joint mount file system, and the joint mount file system includes a writable file system and a temporary archive storage file system, and the method includes:
responding to a starting request of an open source network operating system, and acquiring a kernel configuration file and a system configuration file from a lower directory of a combined mount file system;
independently mounting the system configuration file to a readable and writable file system, and independently mounting the kernel configuration file to a temporary storage file system;
and setting the system configuration file and the kernel configuration file as an upper directory of a combined mount file system.
In one embodiment, after responding to the power-on request of the power-on network operating system, the method further includes: acquiring a configuration file for realizing the startup of the open source network operating system except the kernel configuration file and the system configuration file from a lower directory of the combined mount file system to generate a configuration file library; and mounting the configuration file library to the readable and writable file system, and setting the configuration file library as an upper-layer directory of the combined mounting file system.
In one embodiment, the method further comprises: based on the open source network operating system, acquiring a read-only compression file system, wherein the read-only compression file system comprises fs.squashfs; and setting the read-only compressed file system as a lower-layer directory of a joint mount file system.
In one embodiment, the profile library comprises: (iii) host/image _ dir/rw and/host/image _ dir/work; the kernel configuration file comprises: (iii)/host/image _ dir/rw/etc.; the system configuration file includes: the method comprises the steps of/host/image _ dir/rw/etc/sonic.
In one embodiment, the method further comprises: and setting the/host/image _ dir/work as a file base directory of a joint mount file system.
In one embodiment, the readable and writable archive system comprises/dev/loop and Ext4; the temporary file storage file system comprises TmpFS.
In one embodiment, independently mounting the system configuration file to a writable file system and independently mounting the kernel configuration file to a scratch file storage file system comprises: independently mounting the/host/image _ dir/rw/etc to the TmpFS; independently mounting the/host/image _ dir/rw/etc/sonic to the/dev/loop.
In one embodiment, the open source network operating system further comprises a database profile.
In one embodiment, the method further comprises: acquiring user data to be written into config _ db.json based on the database configuration file; writing the user data to be written into config _ db.json into a preset data storage unit; and after the user data is successfully written into the preset data storage unit, moving the preset data storage unit to config _ db.
In one embodiment, the method further comprises: responding to the open-source network operating system restart request; loading the config _ db.json to the database configuration file; overwriting the config _ db.json to the kernel configuration file based on the database configuration file.
In one embodiment, the method further comprises: generating the preset data storage unit; generating the preset data storage unit comprises: acquiring the memory capacity of the config _ db.json based on the config _ db.json; generating the preset data storage unit based on the memory capacity of config _ db.json, wherein the memory capacity of the preset data storage unit is not less than the memory capacity of config _ db.json.
In one embodiment, before obtaining user data to be written into config _ db.json based on the database configuration file, the method further includes: writing user data into the database configuration file in advance; pre-writing user data to the database configuration file, including: and writing user data into the database configuration file through a data writing instruction.
In one embodiment, the preset data storage unit comprises config _ db.tmp; shifting the preset data storage unit into config _ db.json through a pointer instruction, comprising: and moving the config _ db.tmp to config _ db.json through a Linux mv instruction.
In one embodiment, the method further comprises: mounting the/host/image _ dir/rw to the Ext4; and setting the/host/image _ dir/rw as an upper-layer directory of a combined mount file system.
In one embodiment, overwriting the config _ db.json to the kernel configuration file based on the config _ db.json comprises: a resident management program subscribing the database configuration file; overwriting the config _ db.json to the kernel configuration file based on the resident hypervisor.
In one embodiment, before writing the user data to be written into config _ db.json into a preset data storage unit, the method further includes: judging whether the preset data storage unit is in an occupied state or not; if the preset data storage unit is in an occupied state, returning an occupied state removing request to a user; and responding to a user-sent occupation removing state instruction, and erasing the data of the preset data storage unit.
In another aspect, a method for controlling system stability is provided, where the system is an embedded system, the embedded system includes a joint mount archive system, the joint mount archive system includes a writable archive system and a temporary archive storage archive system, and the method includes:
responding to a starting request of the embedded system, and acquiring a kernel configuration file and a system configuration file from a lower directory of the combined mount file system;
and independently mounting the system configuration file to a readable and writable file system, independently mounting the kernel configuration file to a temporary storage file system, and setting the system configuration file and the kernel configuration file as an upper directory of a combined mounting file system.
In one embodiment, after responding to a power-on request of the embedded system, the method further includes: acquiring configuration files for realizing the startup of the embedded system except the kernel configuration file and the system configuration file from a lower directory of the combined mount file system to generate a configuration file library; and mounting the configuration file library to the readable and writable file system, and setting the configuration file library as an upper-layer directory of the combined mounting file system.
In one embodiment, the method further comprises: based on the embedded system, acquiring a read-only compressed file system; and setting the read-only compressed file system as a lower-layer directory of a joint mount file system.
In yet another aspect, an open source network operating system is provided, which includes a processor that performs the steps of:
responding to a starting request of the embedded system, and acquiring a kernel configuration file and a system configuration file from a lower directory of the combined mount file system;
independently mounting the system configuration file to a readable and writable file system, independently mounting the kernel configuration file to a temporary file storage file system, and setting the system configuration file and the kernel configuration file as an upper directory of a combined mounting file system.
In another aspect, a system stability control apparatus is provided, where the apparatus is applied to an open source network operating system, the open source network operating system includes a combined mounted file system, the combined mounted file system includes a writable file system and a temporary storage file system, and the apparatus includes:
the response unit is used for responding to a starting request of the open source network operating system and acquiring a kernel configuration file and a system configuration file from a lower directory of the combined file system;
the mounting unit is used for independently mounting the system configuration file readable and writable file system and independently mounting the kernel configuration file to a temporary storage file system;
and the setting unit is used for setting the system configuration file and the kernel configuration file into an upper directory of a combined mount file system.
In another aspect, a computer device is provided, which includes a memory, a processor, and a computer program stored on the memory and executable on the processor, and the processor implements the following steps when executing the computer program:
responding to a starting request of an open source network operating system, and acquiring a kernel configuration file and a system configuration file from a lower directory of a combined mount file system;
and independently mounting the system configuration file to a readable and writable file system, independently mounting the kernel configuration file to a temporary storage file system, and setting the system configuration file and the kernel configuration file as an upper directory of a combined mounting file system. Wherein the combined mount archive system comprises a readable and writable archive system and a temporary archive storage archive system.
In yet another aspect, a computer-readable storage medium is provided, having stored thereon a computer program which, when executed by a processor, performs the steps of:
responding to a starting request of an open source network operating system, and acquiring a kernel configuration file and a system configuration file from a lower directory of a combined mount file system;
and independently mounting the system configuration file to a readable and writable file system, independently mounting the kernel configuration file to a temporary storage file system, and setting the system configuration file and the kernel configuration file as an upper directory of a combined mounting file system.
The system stability control method is applied to a system stability open source network operating system comprising a combined mount file system, and comprises the following steps: responding to a starting request of an open source network operating system, and acquiring a kernel configuration file and a system configuration file from a lower directory of a combined mount file system; and independently mounting the system configuration file to a readable and writable file system, independently mounting the kernel configuration file to a temporary storage file system, and setting the system configuration file and the kernel configuration file as an upper directory of a combined mounting file system. Based on the method, the system can be ensured to load a normal configuration file to realize smooth starting even if the system is restarted in case of unexpected situations such as power failure;
further, the method further comprises: acquiring user data to be written into config _ db.json based on the database configuration file; writing the user data to be written into config _ db.json into a preset data storage unit; after the user data is successfully written into the preset data storage unit, moving the preset data storage unit to config _ db.json through a pointer instruction; based on the technical scheme, the user data can be safely written into the config _ db.json, and particularly, the situation that the config _ db.json cannot be normally loaded due to incomplete user writing caused by unexpected accidents is avoided when the user data is written into the config _ db.json;
further, the method further comprises: responding to the open-source network operating system restart request; loading the config _ db.json to the database configuration file; overwriting the config _ db.json to the kernel configuration file based on the database configuration file; based on the technical scheme, after the system is restarted, the system can also retain user data before an emergency occurs, and irreversible physical damage to the system can not be caused.
Drawings
FIG. 1 is a schematic diagram of an open source network operating system;
FIG. 2 is a block diagram of a federated mount file system architecture in the prior art;
FIG. 3 is a schematic diagram of a CL1 interface configuration of an open source network operating system in the prior art
FIG. 4 is a schematic flow chart diagram illustrating a system stability control method according to one embodiment;
FIG. 5 is a flow diagram illustrating a method for controlling system stability in one embodiment;
FIG. 6 is a block diagram of a configured federated mount file system architecture in one embodiment
FIG. 7 is a flow diagram illustrating a method for controlling system stability in one embodiment;
FIG. 8 is a flow diagram illustrating a method for system stability control in one embodiment;
FIG. 9 is a flow diagram illustrating a method for controlling system stability in one embodiment;
FIG. 10 is a schematic flow chart diagram illustrating a system stability control method according to one embodiment;
FIG. 11 is a schematic diagram of the structure of a system stability control apparatus according to an embodiment;
FIG. 12 is a diagram illustrating an internal structure of a computer device according to an embodiment.
Detailed Description
In order to make the objects, technical solutions and advantages of the present application more apparent, the present application is described in further detail below with reference to the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are merely illustrative of the present application and are not intended to limit the present application.
In one embodiment, as shown in fig. 4, a system stability control method is provided, which is applied to an open source network operating system of a federated mount archive system architecture, where the federated mount archive system includes a writable archive system and a temporary archive storage archive system, and the method includes:
responding to a starting request of an open source network operating system, and acquiring a kernel configuration file and a system configuration file from a lower directory of a combined mount file system;
and independently mounting the system configuration file to a readable and writable file system, independently mounting the kernel configuration file to a temporary storage file system, and setting the system configuration file and the kernel configuration file as an upper directory of a combined mounting file system.
Mounting the kernel configuration file to a temporary storage file system by mounting the system configuration file to a readable and writable file system, and setting the system configuration file and the kernel configuration file as an upper-layer directory of the combined mounting file system; when an unexpected situation such as an emergency power-off situation occurs, the open-source network operating system can be ensured to be restarted and then a normal configuration file can be loaded, so that the system can be normally started, and finally the beneficial effect of effectively improving the stability of the system is achieved.
In one embodiment, after responding to the power-on request of the power-on network operating system, the method further comprises: acquiring a configuration file for realizing the startup of the open source network operating system except the kernel configuration file and the system configuration file from a lower directory of the combined mount file system to generate a configuration file library; and mounting the configuration file library to the readable and writable file system, and setting the configuration file library as an upper-layer directory of the combined mounting file system.
In one embodiment, the method further comprises: acquiring user data to be written into config _ db.json based on a database configuration file included in the open source network operating system; writing the user data to be written into config _ db.json into a preset data storage unit; and after the user data is successfully written into the preset data storage unit, moving the preset data storage unit to config _ db.
Writing the user data to be written into config _ db.json into a preset data storage unit by adopting the method; after the user data is successfully written into the preset data storage unit, the preset data storage unit is moved to be the config _ db.json through a pointer instruction, and then the preset data storage unit is moved, so that the data in the database configuration file can be safely written into the config _ db.json, the situation that the user set value cannot be loaded due to damage of a directly overwritten file is avoided, the situation that system failure is caused due to incomplete loading and writing of the config _ db.json is prevented, and irreversible physical damage to the system is avoided.
In one embodiment, the method further comprises: responding to the open-source network operating system restart request; loading the config _ db.json to the database configuration file; overwriting the config _ db.json to the kernel configuration file based on the database configuration file.
Overwriting the config _ db.json to the kernel configuration file by based on the database configuration file; after the open source network operating system is restarted under an unexpected condition, the relevant settings of the system in the normal running state of the system can be reserved by a user, and the system can be restored to the configuration state before the unexpected condition occurs.
In one embodiment, as shown in FIG. 5, generating the profile library comprises: and generating/host/image _ dir/rw and/host/image _ dir/work. Mounting the system configuration file and the configuration file library to a readable and writable file system, and mounting the kernel configuration file to a temporary storage file system, comprising: acquiring a kernel configuration file, a system configuration file and other related configuration files for realizing the startup of an open source network operating system from a lower directory of the combined mounting file system, and generating a host/image _ dir/rw; based on the/host/image _ dir/rw, independently taking out/host/image _ dir/rw/etc and/host/image _ dir/rw/etc/sonic folders under the/host/image _ dir/rw/sonic folders and respectively mounting the folders under the TmpFS and/dev/loop; because the important configuration files related to the Linux kernel are mainly placed under the host/image _ dir/rw/etc., the important configuration files are mounted under the TmpFS, so that the modification made by the user side cannot be saved after power failure, and the incomplete configuration files are avoided. Setting the system configuration file and the kernel configuration file as an upper directory of a joint mount archive system, including: add/host/image _ dir/rw/etc,/host/image _ dir/rw/etc/sonic and/host/image _ dir/rw to the overlayFS upper area. It should be understood that, based on the system stability control method described in the present application, host/image _ dir/rw does not include host/image _ dir/rw/etc and/host/image _ dir/rw/etc/sonic.
In one embodiment, in an existing open source network operating system, a user writes data in a CONFIG _ db.json by directly opening a file, that is, directly writing the data in CONFIG _ db.json, but based on the above data writing method, if a power failure occurs in the system during data writing, incomplete data writing in CONFIG _ db.json may occur; further, if an incomplete CONFIG _ db.json is reloaded into the CONFIG _ DB database after the system is rebooted, the adverse effect of system abnormality may be caused. In order to avoid the above situation, the present application provides a new data writing method, that is, the user data to be written into config _ db.json is written into a preset data storage unit first, and after the user data is successfully written into the preset data storage unit, the preset data storage unit is moved to config _ db.json through a pointer instruction.
Specifically, as shown in fig. 8, writing the user data to be written into config _ db.json into a preset data storage unit, and after the user data is successfully written into the preset data storage unit, moving the preset data storage unit into config _ db.json through a pointer instruction includes: before writing the data of the CONFIG _ DB database into CONFIG _ db.json, the data of the CONFIG _ DB database is written into CONFIG _ db.json.tmp, and the data of the CONFIG _ DB database is not directly read or written into CONFIG _ db.json, so that the CONFIG _ db.json is not modified even if the power is cut during the writing process. And the preset data storage unit is moved to config _ db.json based on the pointer instruction, so that the method is safer compared with the existing data writing method. Wherein the pointer instruction comprises a Linux mv instruction.
In one embodiment, since the configuration files under/host/image _ dir/rw/etc are all mounted to TmpFS, they will not be retained as long as rebooting. In order to solve the technical problem, when a system receives a restart request of an open source network operating system, loading config _ db.json to the database configuration file; overwriting the config _ db.json to the kernel configuration file based on the config _ db.json. Specifically, as shown in fig. 10, in response to a restart request of the open source network operating system, the CONFIG _ db.json is reloaded into the CONFIG _ DB database, and the resident hypervisor subscribing to the CONFIG _ DB database overwrites all the user data in the CONFIG _ db.json to/host/image _ dir/rw/etc, so as to ensure that the configuration of the user before power failure can be normally restored.
In one embodiment, the present application provides a system stability control method, where the system is an open source network operating system, the open source network operating system includes a federated mount file system, the federated mount file system includes a writable file system and a temporary archive file system, and the method includes:
responding to a starting request of an open source network operating system, and acquiring a kernel configuration file and a system configuration file from a lower directory of a combined mount file system;
and independently mounting the system configuration file to a readable and writable file system, independently mounting the kernel configuration file to a temporary storage file system, and setting the system configuration file and the kernel configuration file as an upper directory of a combined mounting file system.
In one embodiment, after responding to the power-on request of the power-on network operating system, the method further includes: acquiring a configuration file for realizing the startup of the open source network operating system except the kernel configuration file and the system configuration file from a lower directory of the combined mount file system to generate a configuration file library; and mounting the configuration file library to the readable and writable file system, and setting the configuration file library as an upper-layer directory of the combined mounting file system.
In one embodiment, the method further comprises: based on the open source network operating system, acquiring a read-only compression file system, wherein the read-only compression file system comprises fs.squashfs; and setting the read-only compressed file system as a lower-layer directory of a joint mount file system.
In one embodiment, the profile library comprises: (iii) host/image _ dir/rw and/host/image _ dir/work; the kernel configuration file comprises: the method comprises the steps of/host/image _ dir/rw/etc; the system configuration file includes: the method comprises the steps of/host/image _ dir/rw/etc/sonic.
In one embodiment, the method further comprises: and setting the/host/image _ dir/work as a file base directory of a combined mount file system.
In one embodiment, the readable and writable archive system comprises/dev/loop and Ext4; the scratch file storage file system includes TmpFS.
In one embodiment, as shown in fig. 6, independently mounting the system configuration file to a writable file system and independently mounting the kernel configuration file to a scratch pad file system comprises: independently mounting the/host/image _ dir/rw/etc to the TmpFS; independently mounting the/host/image _ dir/rw/etc/sonic to the/dev/loop.
In one embodiment, the method further comprises: independently mounting the/host/image _ dir/rw to the Ext4; and setting the/host/image _ dir/rw as an upper-layer directory of the combined mount file system.
In one embodiment, the open source network operating system further comprises a database profile.
In one embodiment, as shown in fig. 7, the method further includes: acquiring user data to be written into config _ db.json based on the database configuration file; writing the user data to be written into config _ db.json into a preset data storage unit; and after the user data is successfully written into the preset data storage unit, moving the preset data storage unit to config _ db.
In one embodiment, as shown in fig. 9, the method further includes: responding to the open-source network operating system restart request; loading the config _ db.json to the database configuration file; overwriting the config _ db.json to the kernel configuration file based on the config _ db.json.
In one embodiment, the method further comprises: generating the preset data storage unit; generating the preset data storage unit comprises: acquiring the memory capacity of the config _ db.json based on the config _ db.json; generating the preset data storage unit based on the memory capacity of the config _ db.json, wherein the memory capacity of the preset data storage unit is not less than the memory capacity of the config _ db.json.
In one embodiment, before obtaining user data to be written into config _ db.json based on the database configuration file, the method further includes: writing user data into the database configuration file in advance; pre-writing user data to the database configuration file, comprising: and writing user data into the database configuration file through a data writing instruction.
In one embodiment, the preset data storage unit comprises config _ db.tmp; shifting the preset data storage unit into config _ db.json through a pointer instruction, comprising: and moving the config _ db.tmp to config _ db.json through a Linux mv instruction.
In one embodiment, overwriting the config _ db.json to the kernel configuration file based on the config _ db.json comprises: a resident management program subscribing the database configuration file; overwriting the config _ db.json to the kernel configuration file based on the resident hypervisor.
In one embodiment, before writing the user data to be written into config _ db.json into a preset data storage unit, the method further includes: judging whether the preset data storage unit is in an occupied state or not; if the preset data storage unit is in an occupied state, returning an occupied state removing request to a user; and responding to a user-sent occupation removing state instruction, and erasing the data of the preset data storage unit.
In one embodiment, a method for controlling system stability is provided, where the system is an embedded system, the embedded system includes a joint mount file system, the joint mount file system includes a scratch file storage file system and a readable and writable file system, and the method includes: responding to a starting request of the embedded system, and acquiring a kernel configuration file and a system configuration file from a lower directory of the combined mount file system; and independently mounting the system configuration file to a readable and writable file system, independently mounting the kernel configuration file to a temporary storage file system, and setting the system configuration file and the kernel configuration file as an upper directory of a combined mounting file system.
In one embodiment, after responding to a power-on request of the embedded system, the method further includes: acquiring a configuration file for realizing the startup of the embedded system except the kernel configuration file and the system configuration file from a lower layer directory of the combined mount file system to generate a configuration file library; and mounting the configuration file library to the readable and writable file system, and setting the configuration file library as an upper directory of the combined mounted file system.
In one embodiment, the method further comprises: based on the embedded system, acquiring a read-only compressed file system; and setting the read-only compressed file system as a lower-layer directory of a joint mount file system.
It should be understood that although the various steps in the flowcharts of fig. 4-5, 7-10 are shown in order as indicated by the arrows, the steps are not necessarily performed in order as indicated by the arrows. The steps are not performed in the exact order shown and described, and may be performed in other orders, unless explicitly stated otherwise. Moreover, at least some of the steps in fig. 4-5 and 7-10 may include multiple sub-steps or multiple stages that are not necessarily performed at the same time, but may be performed at different times, and the order of performing the sub-steps or stages is not necessarily sequential, but may be performed alternately or alternatingly with other steps or at least some of the sub-steps or stages of other steps.
In one embodiment, an open source network operating system is provided, the open source network operating system comprising a federated mount archive system comprising a writable archive system and a temporary archive storage archive system, the open source network operating system comprising a processor that performs the steps of:
in response to the open source network operating system power-on request,
acquiring a kernel configuration file and a system configuration file from a lower directory of the combined mount file system;
and independently mounting the system configuration file to a readable and writable file system, independently mounting the kernel configuration file to a temporary storage file system, and setting the system configuration file and the kernel configuration file as an upper directory of a combined mounting file system.
In one embodiment, as shown in fig. 11, there is provided a system stability control apparatus including:
the response unit is used for responding to a starting request of the open source network operating system and acquiring a kernel configuration file and a system configuration file from a lower directory of the combined file system;
the mounting unit is used for independently mounting the system configuration file to a readable and writable file system and independently mounting the kernel configuration file to a temporary storage file system;
and the setting unit is used for setting the system configuration file and the kernel configuration file into an upper directory of a combined mount file system. The readable and writable file system comprises/dev/loop and Ext4; the temporary file storage file system comprises TmpFS; the kernel configuration file comprises: (iii)/host/image _ dir/rw/etc.; the system configuration file includes: the method comprises the steps of/host/image _ dir/rw/etc/sonic.
In one embodiment, the obtaining unit is configured to obtain, from a lower directory of the union mount archive system, a configuration file for implementing booting of the open-source network operating system, in addition to the kernel configuration file and the system configuration file, and generate a configuration file library; the mounting unit is also used for mounting the configuration file library to the readable and writable file system; the setting unit is used for setting the configuration file library as an upper-layer directory of the combined mount file system; wherein the profile library comprises: (iii) host/image _ dir/rw and/host/image _ dir/work; the/host/image _ dir/rw does not include: (iii)/host/image _ dir/rw/etc and/host/image _ dir/rw/etc/sonic; .
In one embodiment, the apparatus includes an obtaining unit, configured to obtain a read-only compressed file system based on the open-source network operating system, where the read-only compressed file system includes fs.squashfs; the setting unit is further configured to set the read-only compressed file system as a lower directory of a combined mount file system.
In one embodiment, the setting unit is further configured to set the/host/image _ dir/work as a file base directory of a joint mount archive system.
In one embodiment, the mounting unit is further configured to independently mount the/host/image _ dir/rw/etc. to the TmpFS; independently mounting the/host/image _ dir/rw/etc/sonic to the/dev/loop; and independently mounting the/host/image _ dir/rw to the Ext4.
In one embodiment, the obtaining unit is further configured to obtain, based on the database configuration file, user data to be written into config _ db.json; the device also comprises a writing unit, a storage unit and a control unit, wherein the writing unit is used for writing the user data to be written into config _ db.json into a preset data storage unit; the device further comprises a moving unit used for moving the preset data storage unit into config _ db.json through a pointer instruction after the user data is successfully written into the preset data storage unit.
In one embodiment, the responding unit is further configured to respond to the restart request of the open-source network operating system; the apparatus further comprises a loading unit for loading the config _ db.json into the database configuration file; the apparatus also includes an overwriting unit to overwrite the config _ db.json to the kernel configuration file based on the database configuration file.
In one embodiment, the obtaining unit is further configured to obtain a memory capacity of the config _ db.json based on the config _ db.json; the device further comprises a generating unit, configured to generate the preset data storage unit based on the memory capacity of config _ db.json, where the memory capacity of the preset data storage unit is not less than the memory capacity of config _ db.json.
In one embodiment, the writing unit is further configured to write user data to the database configuration file in advance; specifically, the writing unit writes user data to the database configuration file through a data writing instruction.
In one embodiment, the shift unit shifts the config _ db.tmp to config _ db.json through a Linux mv instruction.
In one embodiment, the writing unit is further configured to subscribe to a resident management program of the database configuration file; overwriting the config _ db.json to the kernel configuration file based on the resident hypervisor
For specific limitations of the system stability control device, reference may be made to the above limitations of the system stability control method, which are not described herein again. The modules in the system stability control device can be wholly or partially realized by software, hardware and a combination thereof. The modules can be embedded in a hardware form or independent from a processor in the computer device, and can also be stored in a memory in the computer device in a software form, so that the processor can call and execute operations corresponding to the modules.
In one embodiment, a computer device is provided, which may be a terminal, and its internal structure diagram may be as shown in fig. 12. The computer device includes a processor, a memory, a network interface, a display screen, and an input device connected by a system bus. Wherein the processor of the computer device is configured to provide computing and control capabilities. The memory of the computer device comprises a nonvolatile storage medium and an internal memory. The non-volatile storage medium stores an operating system and a computer program. The internal memory provides an environment for the operation of an operating system and computer programs in the non-volatile storage medium. The network interface of the computer device is used for communicating with an external terminal through a network connection. The computer program is executed by a processor to implement a system stability control method. The display screen of the computer equipment can be a liquid crystal display screen or an electronic ink display screen, and the input device of the computer equipment can be a touch layer covered on the display screen, a key, a track ball or a touch pad arranged on the shell of the computer equipment, an external keyboard, a touch pad or a mouse and the like.
It will be appreciated by those skilled in the art that the configuration shown in fig. 12 is a block diagram of only a portion of the configuration associated with the present application, and is not intended to limit the computing device to which the present application may be applied, and that a particular computing device may include more or fewer components than shown, or may combine certain components, or have a different arrangement of components.
In one embodiment, there is provided a computer device comprising a memory, a processor and a computer program stored on the memory and executable on the processor, the processor implementing the following steps when executing the computer program:
responding to a starting request of an open source network operating system, and acquiring a kernel configuration file and a system configuration file from a lower directory of a combined mount file system;
and independently mounting the system configuration file to a readable and writable file system, independently mounting the kernel configuration file to a temporary storage file system, and setting the system configuration file and the kernel configuration file as an upper directory of a combined mounting file system.
Specifically, the profile library includes: (iii) host/image _ dir/rw and/host/image _ dir/work; the readable and writable archive system comprises/dev/loop and Ext4; the temporary file storage file system comprises TmpFS; the open source network operating system also comprises a database configuration file; the preset data storage unit includes config _ db.tmp.
In one embodiment, the processor, when executing the computer program, further performs the steps of:
acquiring a configuration file for realizing the startup of the open source network operating system except the kernel configuration file and the system configuration file from a lower directory of the combined mount file system to generate a configuration file library; and mounting the configuration file library to the readable and writable file system, and setting the configuration file library as an upper-layer directory of the combined mounting file system.
In one embodiment, the processor, when executing the computer program, further performs the steps of:
based on the open source network operating system, acquiring a read-only compression file system, wherein the read-only compression file system comprises fs.squashfs; and setting the read-only compressed file system fs.squashfs as a lower directory of a combined mount file system.
In one embodiment, the processor, when executing the computer program, further performs the steps of:
and setting the/host/image _ dir/work as a file base directory of a combined mount file system.
In one embodiment, the processor, when executing the computer program, further performs the steps of:
independently mounting the/host/image _ dir/rw/etc to the TmpFS; independently mounting the/host/image _ dir/rw/etc/sonic to the/dev/loop; independently mounting the/host/image _ dir/rw to the Ext4.
In one embodiment, the processor, when executing the computer program, further performs the steps of:
acquiring user data to be written into config _ db.json based on the database configuration file; writing the user data to be written into config _ db.json into a preset data storage unit; and after the user data is successfully written into the preset data storage unit, moving the preset data storage unit to config _ db.
In one embodiment, the processor, when executing the computer program, further performs the steps of:
responding to the open-source network operating system restart request; loading the config _ db.json to the database configuration file; overwriting the config _ db.json to the kernel configuration file based on the database configuration file.
In one embodiment, the processor, when executing the computer program, further performs the steps of:
acquiring the memory capacity of the config _ db.json based on the config _ db.json; generating the preset data storage unit based on the memory capacity of config _ db.json, wherein the memory capacity of the preset data storage unit is not less than the memory capacity of config _ db.json.
In one embodiment, the processor, when executing the computer program, further performs the steps of:
and writing user data into the database configuration file through a data writing instruction.
In one embodiment, the processor, when executing the computer program, further performs the steps of:
and moving the config _ db.tmp to config _ db.json through a Linux mv instruction.
In one embodiment, the processor, when executing the computer program, further performs the steps of:
a resident management program subscribing the database configuration file; overwriting the config _ db.json to the kernel configuration file based on the resident hypervisor.
In one embodiment, the processor, when executing the computer program, further performs the steps of:
judging whether the preset data storage unit is in an occupied state or not; if the preset data storage unit is in an occupied state, returning an occupied state removing request to a user; and responding to a user-sent occupation removing state instruction, and erasing the data of the preset data storage unit.
In one embodiment, a computer-readable storage medium is provided, having a computer program stored thereon, which when executed by a processor, performs the steps of:
responding to a starting request of an open source network operating system, and acquiring a kernel configuration file and a system configuration file from a lower directory of a combined mount file system;
independently mounting the system configuration file to a readable and writable file system, and independently mounting the kernel configuration file to a temporary storage file system;
and setting the system configuration file and the kernel configuration file as an upper directory of a combined mount file system.
Specifically, the profile library includes: (iii) host/image _ dir/rw and/host/image _ dir/work; the/host/image _ dir/rw comprises: a kernel configuration file and a system configuration file; the readable and writable archive system comprises/dev/loop and Ext4; the temporary file storage file system comprises TmpFS; the open source network operating system also comprises a database configuration file; the preset data storage unit comprises config _ db.
In one embodiment, the computer program when executed by the processor further performs the steps of:
acquiring a read-only compressed file system fs.squashfs based on the open source network operating system; and setting the read-only compression file system fs.Squashfs as a lower directory of a combined mount file system.
In one embodiment, the computer program when executed by the processor further performs the steps of:
and setting the/host/image _ dir/work as a file base directory of a combined mount file system.
In one embodiment, the computer program when executed by the processor further performs the steps of:
independently mounting the/host/image _ dir/rw/etc to the TmpFS; independently mounting the/host/image _ dir/rw/etc/sonic to the/dev/loop; independently mounting the/host/image _ dir/rw to the Ext4.
In one embodiment, the computer program when executed by the processor further performs the steps of:
acquiring user data to be written into config _ db.json based on the database configuration file; writing the user data to be written into config _ db.json into a preset data storage unit; and after the user data is successfully written into the preset data storage unit, moving the preset data storage unit to config _ db.
In one embodiment, the computer program when executed by the processor further performs the steps of:
responding to the open-source network operating system restart request; loading the config _ db.json to the database configuration file; overwriting the config _ db.json to the kernel configuration file based on the database configuration file.
In one embodiment, the computer program when executed by the processor further performs the steps of:
acquiring the memory capacity of the config _ db.json based on the config _ db.json; generating the preset data storage unit based on the memory capacity of config _ db.json, wherein the memory capacity of the preset data storage unit is not less than the memory capacity of config _ db.json.
In one embodiment, the computer program when executed by the processor further performs the steps of:
and writing user data into the database configuration file through a data writing instruction.
In one embodiment, the computer program when executed by the processor further performs the steps of:
and moving the config _ db.tmp to config _ db.json through a Linux mv instruction.
In one embodiment, the computer program when executed by the processor further performs the steps of:
a resident management program subscribing the database configuration file; overwriting the config _ db.json to the kernel configuration file based on the resident hypervisor.
In one embodiment, the computer program when executed by the processor further performs the steps of:
judging whether the preset data storage unit is in an occupied state or not; if the preset data storage unit is in an occupied state, returning an occupied state removing request to a user; and responding to a user-sent occupation removing state instruction, and erasing the data of the preset data storage unit.
It will be understood by those skilled in the art that all or part of the processes of the methods of the embodiments described above can be implemented by hardware instructions of a computer program, which can be stored in a non-volatile computer-readable storage medium, and when executed, can include the processes of the embodiments of the methods described above. Any reference to memory, storage, database, or other medium used in the embodiments provided herein may include non-volatile and/or volatile memory, among others. Non-volatile memory can include read-only memory (ROM), programmable ROM (PROM), electrically Programmable ROM (EPROM), electrically Erasable Programmable ROM (EEPROM), or flash memory. Volatile memory can include Random Access Memory (RAM) or external cache memory. By way of illustration and not limitation, RAM is available in a variety of forms such as Static RAM (SRAM), dynamic RAM (DRAM), synchronous DRAM (SDRAM), double Data Rate SDRAM (DDRSDRAM), enhanced SDRAM (ESDRAM), synchronous link (Synchlink), DRAM (SLDRAM), rambus (Rambus) direct RAM (RDRAM), direct bused dynamic RAM (DRDRAM), and bused dynamic RAM (RDRAM).
The technical features of the above embodiments can be arbitrarily combined, and for the sake of brevity, all possible combinations of the technical features in the above embodiments are not described, but should be considered as the scope of the present specification as long as there is no contradiction between the combinations of the technical features.
The above-mentioned embodiments only express several embodiments of the present application, and the description thereof is more specific and detailed, but not construed as limiting the scope of the invention. It should be noted that, for a person skilled in the art, several variations and modifications can be made without departing from the concept of the present application, which falls within the scope of protection of the present application. Therefore, the protection scope of the present patent shall be subject to the appended claims.

Claims (21)

1. A system stability control method, wherein the system is an open-source network operating system, the open-source network operating system includes a combined mount archive system and a database configuration file, the combined mount archive system includes a writable archive system and a temporary archive storage archive system, and the method includes:
responding to a starting request of an open source network operating system, and acquiring a kernel configuration file and a system configuration file from a lower directory of a combined mount file system;
independently mounting the system configuration file to a readable and writable file system, and independently mounting the kernel configuration file to a temporary storage file system;
setting the system configuration file and the kernel configuration file as an upper-layer directory of a combined mount file system;
acquiring user data to be written into config _ db.json based on the database configuration file;
writing the user data to be written into config _ db.json into a preset data storage unit;
and after the user data is successfully written into the preset data storage unit, moving the preset data storage unit to config _ db.
2. The method of claim 1, wherein in response to a power-on request from a network operating system, the method further comprises:
acquiring a configuration file for realizing the startup of the open source network operating system except the kernel configuration file and the system configuration file from a lower directory of the combined mount file system to generate a configuration file library;
and mounting the configuration file library to the readable and writable file system, and setting the configuration file library as an upper-layer directory of the combined mounting file system.
3. The system stability control method of claim 2, further comprising:
based on the open source network operating system, acquiring a read-only compression file system, wherein the read-only compression file system comprises fs.squashfs;
and setting the read-only compressed file system as a lower-layer directory of a joint mount file system.
4. The system stability control method according to claim 3,
the profile library comprises: (iii)/host/image _ dir/rw and/host/image _ dir/work;
the kernel configuration file comprises: (iii)/host/image _ dir/rw/etc.;
the system configuration file includes: the method comprises the steps of/host/image _ dir/rw/etc/sonic.
5. The system stability control method of claim 4, further comprising:
and setting the/host/image _ dir/work as a file base directory of a combined mount file system.
6. The system stability control method according to claim 5,
the readable and writable file system comprises/dev/loop and Ext4;
the scratch file storage file system includes TmpFS.
7. The method of claim 6, wherein independently mounting the system configuration file to a writable and readable file system and independently mounting the kernel configuration file to a scratch pad storage file system comprises:
independently mounting the/host/image _ dir/rw/etc to the TmpFS;
independently mounting the/host/image _ dir/rw/etc/sonic to the/dev/loop.
8. The system stability control method of claim 7, further comprising:
mounting the/host/image _ dir/rw to the Ext4;
and setting the/host/image _ dir/rw as an upper-layer directory of the combined mount file system.
9. The system stability control method of claim 7, further comprising:
responding to the open-source network operating system restart request;
loading the config _ db.json to the database configuration file;
overwriting the config _ db.json to the kernel configuration file based on the database configuration file.
10. The system stability control method of claim 9, further comprising: generating the preset data storage unit;
generating the preset data storage unit comprises:
acquiring the memory capacity of the config _ db.json based on the config _ db.json;
generating the preset data storage unit based on the memory capacity of config _ db.json, wherein the memory capacity of the preset data storage unit is not less than the memory capacity of config _ db.json.
11. The method according to claim 10, wherein before acquiring the user data to be written into config _ db.json based on the database configuration file, the method further comprises: writing user data into the database configuration file in advance;
pre-writing user data to the database configuration file, including:
and writing user data into the database configuration file through a data writing instruction.
12. The system stability control method according to claim 11, wherein the preset data storage unit includes config _ db.tmp;
shifting the preset data storage unit into config _ db.json through a pointer instruction, comprising:
and moving the config _ db.tmp to config _ db.json through a Linux mv instruction.
13. The system stability control method of claim 12, wherein overwriting the config _ db.json to the kernel configuration file based on the database configuration file comprises:
a resident management program subscribing the database configuration file;
overwriting the config _ db.json to the kernel configuration file based on the resident hypervisor.
14. The method according to claim 13, wherein before writing the user data to be written into config _ db.
Judging whether the preset data storage unit is in an occupied state or not;
if the preset data storage unit is in an occupied state, returning an occupied state removing request to a user;
and responding to a user-sent occupation removing state instruction, and erasing the data of the preset data storage unit.
15. A system stability control method is characterized in that the system is an embedded system, the embedded system comprises a combined mounting archive system and a database configuration file, the combined mounting archive system comprises a readable and writable archive system and a temporary archive storage archive system, and the method comprises the following steps:
responding to a starting request of the embedded system, and acquiring a kernel configuration file and a system configuration file from a lower directory of the combined mount file system;
independently mounting the system configuration file to a readable and writable file system, and independently mounting the kernel configuration file to a temporary storage file system;
setting the system configuration file and the kernel configuration file as an upper-layer directory of a combined mount file system;
acquiring user data to be written into config _ db.json based on the database configuration file;
writing the user data to be written into config _ db.json into a preset data storage unit;
and after the user data is successfully written into the preset data storage unit, moving the preset data storage unit to config _ db.
16. The method of claim 15, wherein after responding to a power-on request of the embedded system, the method further comprises:
acquiring configuration files for realizing the startup of the embedded system except the kernel configuration file and the system configuration file from a lower directory of the combined mount file system to generate a configuration file library;
and mounting the configuration file library to the readable and writable file system, and setting the configuration file library as an upper-layer directory of the combined mounting file system.
17. The system stability control method of claim 16, further comprising:
based on the embedded system, acquiring a read-only compressed file system;
and setting the read-only compressed file system as a lower-layer directory of a joint mount file system.
18. An open source network operating system comprising a federated mount archive system comprising a writable archive system and a temporary archive storage archive system, the open source network operating system comprising a processor, wherein the processor performs the steps of the method of any of claims 1 to 14.
19. A system stability control apparatus, wherein the apparatus is applied to an open source network operating system, the open source network operating system includes a combined mount file system and a database configuration file, the combined mount file system includes a writable file system and a temporary storage file system, the apparatus includes:
the response unit is used for responding to a starting request of the open source network operating system;
the system comprises an acquisition unit, a storage unit and a processing unit, wherein the acquisition unit is used for acquiring a kernel configuration file and a system configuration file from a lower directory of a combined file system;
the mounting unit is used for independently mounting the system configuration file to a readable and writable file system and independently mounting the kernel configuration file to a temporary storage file system;
the setting unit is used for setting the system configuration file and the kernel configuration file as an upper-layer directory of a combined mount file system;
the obtaining unit is further configured to obtain user data to be written into config _ db.json based on the database configuration file; a writing unit, configured to write the user data to be written into config _ db.json into a preset data storage unit; and the moving unit is used for moving the preset data storage unit into config _ db.json through a pointer instruction after the user data is successfully written into the preset data storage unit.
20. A computer arrangement comprising a memory, a processor and a computer program stored on the memory and executable on the processor, characterized in that the processor realizes the steps of the method according to any of claims 1 to 14 when executing the computer program.
21. A computer-readable storage medium, on which a computer program is stored, which, when being executed by a processor, carries out the steps of the method according to any one of claims 1 to 14.
CN202211647128.8A 2022-12-21 2022-12-21 System stability control method and device Active CN115629811B (en)

Priority Applications (1)

Application Number Priority Date Filing Date Title
CN202211647128.8A CN115629811B (en) 2022-12-21 2022-12-21 System stability control method and device

Applications Claiming Priority (1)

Application Number Priority Date Filing Date Title
CN202211647128.8A CN115629811B (en) 2022-12-21 2022-12-21 System stability control method and device

Publications (2)

Publication Number Publication Date
CN115629811A CN115629811A (en) 2023-01-20
CN115629811B true CN115629811B (en) 2023-03-21

Family

ID=84909680

Family Applications (1)

Application Number Title Priority Date Filing Date
CN202211647128.8A Active CN115629811B (en) 2022-12-21 2022-12-21 System stability control method and device

Country Status (1)

Country Link
CN (1) CN115629811B (en)

Family Cites Families (3)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN105138362B (en) * 2015-08-20 2018-09-07 浪潮(北京)电子信息产业有限公司 The method and device of user configuration is preserved under a kind of Linux system
CN111090546B (en) * 2019-12-13 2023-01-10 苏州浪潮智能科技有限公司 Method, device and equipment for restarting operating system and readable storage medium
CN115080069A (en) * 2022-06-16 2022-09-20 苏州浪潮智能科技有限公司 Debugging method and device for baseboard management controller, electronic equipment and storage medium

Also Published As

Publication number Publication date
CN115629811A (en) 2023-01-20

Similar Documents

Publication Publication Date Title
US10216936B2 (en) Method of preventing computer malfunction, computer program, and computer
US9081639B2 (en) System and method for remotely re-imaging a computer system
CN112416406B (en) Terminal equipment upgrading method, device, terminal equipment and medium
CN107678762B (en) System version upgrading method and device
WO2012031567A1 (en) Fault tolerance method and device for file system
WO2019156062A1 (en) Information processing system, information processing device, bios updating method for information processing device, and bios updating program for information processing device
US7818557B2 (en) Method for re-imaging a computer system
CN114706661A (en) Disaster recovery backup method and system for virtual machine, computer equipment and storage medium
CN111651304A (en) Software recovery method and device based on double-core intelligent electric meter and computer equipment
CN114047958B (en) Starting method, equipment and medium of baseboard management controller of server
CN109582332B (en) System upgrading method and device for Internet camera
CN115629811B (en) System stability control method and device
KR20020097344A (en) Restoration Method of data on Hard Disk Drive
CN117131014A (en) Database migration method, device, equipment and storage medium
CN114356658A (en) Processing method of firmware upgrading exception, computer equipment and readable storage medium
CN114510375A (en) Flash chip data area dynamic sharing system and method
CN114035813A (en) Upgrading method, device, equipment and storage medium
US9804932B2 (en) Method and device for processing data and electronic apparatus
CN110879757B (en) Restarting method and device for abnormal operation of client and computer equipment
US20190227865A1 (en) Information processing device and information processing method
CN110162507B (en) Snapshot overwriting method, device, computer equipment and storage medium
CN116126382A (en) Online upgrade method and device for complex programmable logic device
CN114389980B (en) Test environment monitoring management method and device and computer equipment
CN114356369A (en) SSD firmware consistency loading method and device, computer equipment and storage medium
CN115756625A (en) Embedded system power-on starting method and device, computer equipment and storage medium

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
GR01 Patent grant
GR01 Patent grant