CN116339904A - Hardware-assisted virtualization instruction simulation error detection method and system - Google Patents
Hardware-assisted virtualization instruction simulation error detection method and system Download PDFInfo
- Publication number
- CN116339904A CN116339904A CN202111597207.8A CN202111597207A CN116339904A CN 116339904 A CN116339904 A CN 116339904A CN 202111597207 A CN202111597207 A CN 202111597207A CN 116339904 A CN116339904 A CN 116339904A
- Authority
- CN
- China
- Prior art keywords
- virtual machine
- qemu
- kvm
- snapshot
- instruction
- 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
- 238000004088 simulation Methods 0.000 title claims abstract description 36
- 238000001514 detection method Methods 0.000 title claims abstract description 32
- 238000000034 method Methods 0.000 claims abstract description 27
- 230000002159 abnormal effect Effects 0.000 claims abstract description 10
- 238000012544 monitoring process Methods 0.000 claims abstract description 5
- 238000011084 recovery Methods 0.000 claims description 6
- 230000008859 change Effects 0.000 claims description 3
- 230000006870 function Effects 0.000 claims description 3
- 230000005856 abnormality Effects 0.000 claims description 2
- 238000011022 operating instruction Methods 0.000 abstract 1
- 238000004458 analytical method Methods 0.000 description 10
- 230000008569 process Effects 0.000 description 7
- 230000001360 synchronised effect Effects 0.000 description 7
- 238000005516 engineering process Methods 0.000 description 6
- 238000010586 diagram Methods 0.000 description 3
- 230000007246 mechanism Effects 0.000 description 2
- 238000013519 translation Methods 0.000 description 2
- 230000006399 behavior Effects 0.000 description 1
- 230000015556 catabolic process Effects 0.000 description 1
- 238000010276 construction Methods 0.000 description 1
- 238000011161 development Methods 0.000 description 1
- 230000000694 effects Effects 0.000 description 1
- 238000012986 modification Methods 0.000 description 1
- 230000004048 modification Effects 0.000 description 1
- 230000002093 peripheral effect Effects 0.000 description 1
- 230000008092 positive effect Effects 0.000 description 1
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/455—Emulation; Interpretation; Software simulation, e.g. virtualisation or emulation of application or operating system execution engines
- G06F9/45533—Hypervisors; Virtual machine monitors
- G06F9/45558—Hypervisor-specific management and integration aspects
-
- 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/455—Emulation; Interpretation; Software simulation, e.g. virtualisation or emulation of application or operating system execution engines
- G06F9/45533—Hypervisors; Virtual machine monitors
- G06F9/45558—Hypervisor-specific management and integration aspects
- G06F2009/45562—Creating, deleting, cloning virtual machine instances
-
- 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/455—Emulation; Interpretation; Software simulation, e.g. virtualisation or emulation of application or operating system execution engines
- G06F9/45533—Hypervisors; Virtual machine monitors
- G06F9/45558—Hypervisor-specific management and integration aspects
- G06F2009/4557—Distribution of virtual machine instances; Migration and load balancing
-
- 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/455—Emulation; Interpretation; Software simulation, e.g. virtualisation or emulation of application or operating system execution engines
- G06F9/45533—Hypervisors; Virtual machine monitors
- G06F9/45558—Hypervisor-specific management and integration aspects
- G06F2009/45575—Starting, stopping, suspending or resuming virtual machine instances
-
- 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/455—Emulation; Interpretation; Software simulation, e.g. virtualisation or emulation of application or operating system execution engines
- G06F9/45533—Hypervisors; Virtual machine monitors
- G06F9/45558—Hypervisor-specific management and integration aspects
- G06F2009/45591—Monitoring or debugging support
-
- 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/455—Emulation; Interpretation; Software simulation, e.g. virtualisation or emulation of application or operating system execution engines
- G06F9/45533—Hypervisors; Virtual machine monitors
- G06F9/45558—Hypervisor-specific management and integration aspects
- G06F2009/45595—Network integration; Enabling network access in virtual machine instances
-
- 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
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Debugging And Monitoring (AREA)
Abstract
The invention discloses a hardware-assisted virtualization instruction simulation error detection method and system. The method comprises the following steps: two hosts with the same configuration are selected, and a Qemu virtual machine is built by a Qemu system and a KVM virtual machine is built by a KVM system; when the Qemu virtual machine operates, the Qemu virtual machine operation snapshot is stored regularly; when Qemu is abnormal, the Qemu virtual machine and the KVM virtual machine are simultaneously restored to the latest snapshot position; taking a basic block as a unit, synchronously executing programs in the Qemu virtual machine and the KVM virtual machine, creating a snapshot by the Qemu virtual machine before executing, monitoring an operating instruction basic block, and detecting the occurrence position of an error; and determining a basic block with errors according to the position where the detection errors occur, and then starting the Qemu virtual machine and the KVM virtual machine by taking the latest basic block snapshot of the Qemu virtual machine as a starting point, and detecting the instruction position where the errors occur.
Description
Technical Field
The invention belongs to the field of computer science and technology, and particularly relates to a hardware-assisted virtualization instruction simulation error detection method and system. According to the invention, the actual instruction block and the single instruction are synchronized through hardware assistance, the instruction simulation error of the virtualized hardware platform is detected, the position where the error occurs is rapidly positioned, and the error reason is reported, so that the simulation rule of the virtualized platform is manually repaired, the correct instruction simulation is realized, and the normal operation of the virtualized program is ensured.
Background
Dynamic analysis based on virtualization is one of important technical means of binary program analysis, and the current analysis based on virtualization is developed based on a hardware simulator Qemu, wherein Qemu uses a dynamic decoding mechanism to translate instructions of a virtualized CPU into target instruction codes for execution through disassembly, intermediate language analysis, target instruction translation and other stages. Because of the complexity of CPU instructions and unavoidable errors generated in the process of manually formulating rules, qemu has a large number of instruction simulation problems, so that program operation is abnormal and a system is crashed. The traditional instruction simulation error detection is mainly realized by means of manual debugging or Fuzzing, the time complexity is high, false alarm is easy to generate, and the instruction simulation error detection requirement under the complex instruction condition of the CPU is difficult to meet.
Current instruction emulation error detection techniques typically use several methods as follows:
1. instruction simulation error detection based on manual analysis
Instruction simulation error detection based on manual analysis is a traditional detection scheme, errors existing in instruction simulation are judged through cross checking among developers, or breakdown is observed in the running process of a program, and the process is reproduced through manual analysis to locate and analyze the errors existing in the process. The method based on manual analysis has high technical requirements and high time complexity, and is difficult to meet the requirements of large-scale instruction detection.
2. Instruction simulation error detection based on Fuzzing
The instruction simulation error detection method based on Fuzzing is a detection method which is widely used at present, a developer writes an instruction generator by himself, randomly generates instructions to run in Qemu, and detects instruction simulation errors by observing anomalies generated by a system. The main problems of this method are: the CPU instruction addressing mode and the operand are complex and depend on the context of the program, and the Fuzzing method cannot construct the context of the program, so that the abnormality caused by lack of the context is easily mistaken for the instruction simulation error in many cases, the post analysis of the Fuzzing-based method also depends on manpower, the effect is stronger than that of direct manual analysis, and the technology and the time complexity have limitations.
To sum up, the main drawbacks of the current method for extracting program API behavior monitoring information are: due to the difficulty of context construction and the difficulty of error instruction positioning, the existing analysis method has higher time complexity and labor cost, and is difficult to realize instruction simulation error detection for a large-scale complex instruction set.
Disclosure of Invention
Aiming at the problems that the existing Qemu system hardware virtualization technology writes translation rules one by one for the instructions to be virtualized, errors are easy to occur in the writing process and system crashes are caused, the invention aims to provide a hardware-assisted virtualization instruction simulation error detection method and system.
The technical scheme of the invention is as follows:
a virtualization instruction simulation error detection method based on hardware assistance comprises the following steps:
since Qemu and KVM are both Linux-based virtualized systems, the invention selects two hosts with the same configuration, one installs the Qemu system and the other installs the KVM system, the same operating system and software are installed in the two virtualized systems (the two virtual machines are hereafter called Qemu virtual machine and KVM virtual machine), and the instruction execution program is then synchronized in the two virtual machines;
the Qemu virtual machine operation snapshot is stored at fixed time while the Qemu virtual machine is operated;
when the program inside the Qemu virtual machine is abnormal, the Qemu virtual machine and the KVM virtual machine are simultaneously restored to the latest snapshot position;
synchronous execution of programs in Qemu virtual machine and KVM virtual machine in Basic Block (Basic Block)Before each basic block is executed, the Qemu virtual machine creates a snapshot, monitors the running instruction basic block and detects the position of error occurrence, and the basic block with error can be obtained and recorded as BasicB lock Error ；
After determining the basic block with error, starting Qemu and KVM at the same time again with the last basic block snapshot of the Qemu virtual machine as the starting point, executing in synchronization with the two virtual machines with instruction as the unit, and analyzing the basic block BasicB Error Detecting the instruction position of the error occurrence;
further, on the hardware system with the same configuration as the hardware simulated by Qemu, a controllable virtual machine is constructed based on hardware virtualization, and the instruction execution program is synchronized. The purpose of comparison is to detect the error of the Qemu virtual machine in instruction simulation, and the method is to install the KVM virtual machine modified by the invention on a host computer with the same hardware configuration as that simulated by Qemu, and run an operating system with the same as that of Qemu.
Further, the modified KVM virtual machine needs to modify the mechanism of loading the image of the KVM and starting and stopping the simulation execution. The method is to modify Qemu directly the virtual registers such as EIP and CS (Code Segment) simulated by software into the mode of modifying MSR registers based on Intel CPU privilege instructions and setting the registers such as EIP and CS of hardware CPU, so that the KVM can load the mirror image generated by Qemu. And can require setting a SingleStep (single step execution flag) in the hardware CPU in a virtual execution state based on the MSR register so that it can monitor the execution of basic blocks and instructions. Based on the support of Intel VT technology, in the KVM virtual machine, the MSR register can be modified to directly set the register values of CPU EIP, CS and the like at the beginning of operation, thereby ensuring that the KVM virtual machine starts to operate from the set instruction position.
Further, the step of regularly saving the Qemu virtual machine operation snapshot while the Qemu virtual machine is operated refers to grabbing the register, interrupt, exception and memory states of the whole virtual machine according to a specific time interval during the Qemu operation, and saving the registers, interrupt, exception and memory states to a snapshot file. The snapshot time interval herein may be self-configurable by the user.
Further, when the program is abnormal, the program and the virtual machine are restored to the snapshot position, which means that when the program running by Qemu crashes or the system blue screen, the latest saved Qemu system snapshot is extracted.
Further, the basic blocks are used as units, the basic blocks are operated in the virtual machine and the synchronous execution program at the same time, the position where the error occurs is detected, namely, qemu and KVM are loaded and started at the same time by taking the last saved Qemu system snapshot as a starting point, the system snapshot is captured at the beginning of each basic block, the modified register and memory contents of the CPU of the KVM and the Qemu are compared during the execution of the basic blocks at the beginning and the end of the execution of the basic blocks, whether the modified register and the memory contents are consistent is judged, and if the modified register and the memory contents are inconsistent, the instruction simulation of the Qemu is indicated to have the error. Because the two virtual machines take the same snapshot as the starting point and only a small section of execution process after the snapshot is compared, the consistency of the operation process can be ensured.
Further, after the basic block is determined, the basic block runs in the virtual machine and the synchronous execution program by taking the instruction as a unit, and the detection of the error-occurring instruction refers to that after the error-occurring basic block is determined, the basic block is loaded and run by taking the snapshot of the basic block as a starting point, and the CPU register and the memory change of each instruction are compared. If the obtained register and memory changes are different after the same instruction is executed on Qemu and KVM, then the instruction with simulated error is considered to be positioned, the instruction EIP is extracted, the instruction is disassembled and error comparison data is reported.
A hardware-assisted virtualized instruction emulation error detection system comprising a first host and a second host configured identically, wherein:
the Qemu system is installed on the first host to construct a Qemu virtual machine, and the KVM system is installed on the second host to construct a KVM virtual machine; the same operating system and software are installed in the Qemu system and the KVM system;
the first host is used for regularly storing the Qemu virtual machine operation snapshot when the Qemu virtual machine is operated; when the program in the Qemu virtual machine is abnormal, the program is stored according to the stored speedThe Qemu virtual machine is restored to the latest snapshot position according to the information; then, executing a program in the Qemu virtual machine by taking the basic block as a unit, creating a snapshot by the Qemu virtual machine before each basic block execution, monitoring the running instruction basic block, and detecting the occurrence position of an error; determining basic block BasicBLock with error according to position of error detection Error Then starting the Qemu virtual machine by taking the last basic block snapshot of the Qemu virtual machine as a starting point, and running basic block Basicblock in the Qemu virtual machine by taking an instruction as a unit Error Instructions of (a);
the second host is used for restoring the KVM virtual machine to the latest snapshot position according to the stored snapshot information when the program in the Qemu virtual machine is abnormal; then, executing a program in the KVM virtual machine by taking the basic block as a unit; and determining the basic block BasicBLock with errors according to the position of the Qemu virtual machine where the detection error occurs Error Then starting the KVM virtual machine by taking the last basic block snapshot of the Qemu virtual machine as a starting point, and running basic blocks BasicB lock in the KVM virtual machine by taking instructions as units Error Is a command in (a).
The invention has the following advantages and positive effects:
the invention can automatically locate the position of the instruction simulation error based on hardware support (KVM uses Intel PT virtualization technology to actually execute the instruction). The method does not need program developers to manually position or analyze codes, has high accuracy and provides support for the development of the virtualization system.
Drawings
FIG. 1 is a system architecture diagram of a hardware-assisted virtualized instruction simulation error detection method according to the present invention.
FIG. 2 is a logic flow diagram of a hardware-assisted virtualized instruction simulation error detection method in accordance with the present invention.
Detailed Description
The present invention will be further described in detail below with reference to specific embodiments and with reference to the accompanying drawings, in order to make the objects, technical solutions and advantages of the present invention more apparent.
FIG. 1 is a block diagram of a hardware-assisted virtualized instruction simulation error detection method, and the specific contents are as follows:
1) The system consists of two parts, one is a Qemu virtual machine, which is the virtual machine to which the present invention is to detect instruction emulation errors. The other is a KVM virtual machine, the KVM uses Intel PT technology, and standard information is provided for Qemu instruction comparison through instruction operation simulation supported by hardware.
2) The Qemu virtual machine emulates a set of virtualized hardware, and the KVM mainly selects the same CPU type and the same memory size as the virtualized hardware. If the other peripheral devices have differences, the accuracy of instruction simulation is not affected.
3) Both systems rely on the snapshot information of Qemu, and the two virtual machines are started in the same state through the snapshot information of Qemu, only Qemu stores the snapshot, and the KVM uses the snapshot loading execution of Qemu each time.
FIG. 2 is a system flow chart of a method for detecting simulation errors of virtualized instructions based on hardware assistance, and specifically includes the following steps:
1) Because the images of Qemu and KVM are incompatible, the state recovery method used by the KVM when loading the images is different from Qemu, the invention modifies the state recovery function of the KVM, and the invention can recover the running state based on the snapshot of Qemu by reading and writing the VMCS register and writing the video memory information. Entering step 2);
2) Creating a hard disk mirror image based on Qemu, guiding by using the hard disk mirror image, installing an operating system and application software, and entering step 3);
3) After Qemu installs the operating system and application software, an initial system snapshot is created. Step 4) is entered;
4) Copying the hard disk image of Qemu, and when in debug, the KVM is started by using the image and snapshot provided by Qemu; enter step 5)
5) The user configures the time interval for snapshot capture. Step 6) is entered;
6) During operation, qemu creates snapshots continuously according to user-configured time intervals. Until an exception occurs in the program operation in Qemu, or the operating system blue screen in Qemu. Step 7) is entered;
7) After the Qemu operation is abnormal, a latest snapshot of the Qemu is found, and the KVM and the Qemu are started based on the hard disk mirror image and the snapshot at the same time. Step 8) is entered;
8) Creating a new snapshot before each basic block is executed, synchronously comparing the running results of Qemu and KVM, if no difference exists, entering the comparison of the next basic block, and if difference exists, entering the step 9);
9) And loading the snapshot before the basic block running by using Qemu and KVM, and synchronously comparing the running results of each instruction executed thereafter until an instruction simulating an error is found. Instruction information is collected and reports are generated. The comparison may be made here using a manual observation of the operation of the two machines. The running record can also be output to a file, a comparison program is run on a third party machine, and the detection is realized when the Qemu virtual machine and the KVM virtual machine EIP execute in different positions.
According to the hardware-assisted virtualized instruction simulation error detection method, the actual instruction block and the single instruction are synchronized, the instruction simulation error of the virtualized hardware platform is detected, the corresponding execution rule is quickly generated by detecting the instruction error, the simulation rule of the virtualized platform is repaired, correct instruction simulation is realized, and the normal operation of a virtualized program is ensured. Under the condition of no manual intervention, the method can rapidly detect the command simulating the error in the virtual machine, thereby achieving the purpose of rapidly improving the command simulating capability of the virtual machine.
Although specific embodiments of, and the accompanying drawings for, the present invention are disclosed for illustrative purposes only and are for the purpose of aiding in the understanding of the present invention and the practice thereof, it will be understood by those skilled in the art that: various alternatives, variations and modifications are possible without departing from the spirit and scope of the invention and the appended claims. Therefore, the present invention should not be limited to the preferred embodiments and the disclosure of the drawings, but the scope of the invention is defined by the appended claims.
Claims (9)
1. A virtualization instruction simulation error detection method based on hardware assistance comprises the following steps:
selecting two hosts with the same configuration, installing a Qemu system on a first host to construct a Qemu virtual machine, and installing a KVM system on a second host to construct a KVM virtual machine; the Qemu system and the KVM system are respectively provided with the same operating system and software;
when the Qemu virtual machine operates, the Qemu virtual machine operation snapshot is stored regularly;
when the program in the Qemu virtual machine is abnormal, the Qemu virtual machine and the KVM virtual machine are simultaneously restored to the latest snapshot position according to the stored snapshot information;
taking basic blocks as units, synchronously executing programs in the Qemu virtual machine and the KVM virtual machine, creating a snapshot by the Qemu virtual machine before each basic block execution, monitoring the running instruction basic blocks, and detecting the occurrence position of errors;
determining basic block BasicBLock with error according to position of error detection Error Then taking the last basic block snapshot of the Qemu virtual machine as a starting point, simultaneously starting the Qemu virtual machine and the KVM virtual machine, synchronously running the Qemu virtual machine and the KVM virtual machine by taking instructions as units, and detecting the basic block BasicB lock Error An instruction location where an error occurred.
2. The method according to claim 1, wherein the KVM virtual machine uses an Intel CPU privilege instruction based manner of modifying an MSR register to set EIP and CS of a hardware CPU, so that the KVM virtual machine can load a mirror image generated by Qemu; and modifying the state recovery function of the KVM virtual machine, and simultaneously writing the video memory information by reading and writing the VMCS register, so that the KVM virtual machine can perform running state recovery based on the snapshot of Qemu.
3. The method according to claim 1, wherein the method for detecting the position of occurrence of the error is as follows: taking the latest saved Qemu virtual machine snapshot as a starting point, loading and starting the Qemu virtual machine and the KVM virtual machine at the same time, grabbing system snapshots at the beginning of each basic block, comparing whether the modified register and memory contents of the CPU of the KVM virtual machine and the Qemu virtual machine are consistent during the execution of the basic block at the beginning and the end of the execution of the basic block, and if the modified register and memory contents are inconsistent, judging that the instruction simulation of the Qemu virtual machine has errors and determining the occurrence position of the errors.
4. A method according to claim 1, 2 or 3, wherein the Qemu virtual machine running snapshot includes register information, interrupt information, exception information and memory state information of the Qemu virtual machine.
5. A method according to claim 1, 2 or 3, wherein when an abnormality occurs in a program in the Qemu virtual machine, it means that the program running in the Qemu virtual machine crashes or a system blue screen.
6. A method according to claim 1, 2 or 3, wherein the method for detecting the instruction location where the error occurs is: qemu virtual machine and KVM virtual machine load running basic block BasicbLock Error Comparing the CPU register and the memory change of each instruction; if the obtained register and memory change are different after the same instruction is executed on the Qemu virtual machine and the KVM virtual machine, the instruction position simulating the error is considered to be positioned, the instruction EIP is extracted, the instruction is disassembled and error comparison data is reported.
7. A hardware-assisted virtualized instruction emulation error detection system comprising a first host and a second host configured identically, wherein:
the Qemu system is installed on the first host to construct a Qemu virtual machine, and the KVM system is installed on the second host to construct a KVM virtual machine; the same operating system and software are installed in the Qemu system and the KVM system;
the first host is used for regularly storing the Qemu virtual machine operation snapshot when the Qemu virtual machine is operated; when the program in the Qemu virtual machine is abnormal, the Qemu virtual machine is restored to the latest snapshot bit according to the stored snapshot informationPlacing; then, executing a program in the Qemu virtual machine by taking the basic block as a unit, creating a snapshot by the Qemu virtual machine before each basic block execution, monitoring the running instruction basic block, and detecting the occurrence position of an error; determining basic block BasicBLock with error according to position of error detection Error Then starting the Qemu virtual machine by taking the last basic block snapshot of the Qemu virtual machine as a starting point, and running basic block Basicblock in the Qemu virtual machine by taking an instruction as a unit Error Instructions of (a);
the second host is used for restoring the KVM virtual machine to the latest snapshot position according to the stored snapshot information when the program in the Qemu virtual machine is abnormal; then, executing a program in the KVM virtual machine by taking the basic block as a unit; and determining the basic block BasicBLock with errors according to the position of the Qemu virtual machine where the detection error occurs Error Then starting the KVM virtual machine by taking the last basic block snapshot of the Qemu virtual machine as a starting point, and running basic blocks BasicB lock in the KVM virtual machine by taking instructions as units Error Is a command in (a).
8. The system of claim 7, wherein the KVM virtual machine uses an Intel CPU privilege instruction based manner of modifying the MSR register to set the EIP and CS of the hardware CPU, so that the KVM virtual machine can load the image generated by Qemu; and modifying the state recovery function of the KVM virtual machine, and simultaneously writing the video memory information by reading and writing the VMCS register, so that the KVM virtual machine can perform running state recovery based on the snapshot of Qemu.
9. The system of claim 7, wherein the Qemu virtual machine running snapshot includes register information, interrupt information, exception information, and memory state information of the Qemu virtual machine.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202111597207.8A CN116339904A (en) | 2021-12-24 | 2021-12-24 | Hardware-assisted virtualization instruction simulation error detection method and system |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202111597207.8A CN116339904A (en) | 2021-12-24 | 2021-12-24 | Hardware-assisted virtualization instruction simulation error detection method and system |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN116339904A true CN116339904A (en) | 2023-06-27 |
Family
ID=86875043
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202111597207.8A Pending CN116339904A (en) | 2021-12-24 | 2021-12-24 | Hardware-assisted virtualization instruction simulation error detection method and system |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN116339904A (en) |
-
2021
- 2021-12-24 CN CN202111597207.8A patent/CN116339904A/en active Pending
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| Cui et al. | {REPT}: Reverse debugging of failures in deployed software | |
| US11249879B2 (en) | Time-travel debugging with hot code replacement | |
| US9720808B2 (en) | Offline debugging using a replicated operating environment | |
| KR101019209B1 (en) | Device of automatically extracting Interface of Embedded Software and Method thereof | |
| CN111936972B (en) | Data processing apparatus and method of operating the same | |
| TWI544410B (en) | Diagnosing code using single step execution | |
| CN102521105B (en) | Output method of power on self test information, virtual machine manager and processor | |
| CN105718340A (en) | Crontab-based CPU stability test method | |
| Jeong et al. | Fifa: A kernel-level fault injection framework for arm-based embedded linux system | |
| CN110704315A (en) | Fault injection device for embedded software test | |
| CN116339904A (en) | Hardware-assisted virtualization instruction simulation error detection method and system | |
| CN115599645A (en) | Method and device for testing stability of linux drive module | |
| CN114510429A (en) | Debugging method, system and medium based on dynamic symbol execution | |
| CN110096888B (en) | Method and system for accelerating verification and analyzing SMM potential safety hazard | |
| JP2828590B2 (en) | Microprogram verification method | |
| CN112527571A (en) | CPU instruction set coverage rate calculation method and device | |
| CN114327648B (en) | Driving debugging method and device, electronic equipment and storage medium | |
| CN117909160B (en) | Firmware crash analysis method and device based on Internet of things | |
| KR102421394B1 (en) | Apparatus and method for detecting malicious code using tracing based on hardware and software | |
| CN112346786B (en) | Debugging information recording method applied to startup stage and operation stage after startup | |
| JP2658982B2 (en) | Specific instruction execution detection method | |
| Beierlieb et al. | Software Testing Strategies for Detecting Hypercall Handlers' Aging-related Bugs | |
| CN117724979A (en) | Detection method, equipment and medium of real-time operating system | |
| CN116126702A (en) | Code testing method, device and system | |
| JPS6146535A (en) | Pseudo error setting control 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 |