CN110750450A

CN110750450A - Method, device and system for positioning software endless loop and storage medium

Info

Publication number: CN110750450A
Application number: CN201910886437.2A
Authority: CN
Inventors: 李小军; 吴闽华; 孟庆晓
Original assignee: Shenzhen Genew Technologies Co Ltd
Current assignee: Shenzhen Genew Technologies Co Ltd
Priority date: 2019-09-19
Filing date: 2019-09-19
Publication date: 2020-02-04
Anticipated expiration: 2039-09-19
Also published as: CN110750450B

Abstract

The invention discloses a method, a device, a system and a storage medium for positioning software endless loop, wherein the method comprises the following steps: receiving a debug command provided by a CPU (Central processing Unit), and monitoring a branch instruction; when the branch instruction is executed, the CPU triggers an exception and enters an exception handler; judging in the exception handling program, if the current call stack is in the stack of the monitored task, allowing to record the call record, and if the current call stack is not in the stack of the monitored task, not recording; forcibly terminating the exception handling program, reading the valid information and storing the valid information as a file; disassembling the exception handler to determine a location of a dead loop. Compared with the existing positioning method, the method is very simple and efficient, and effectively solves the problems of complex operation, low positioning efficiency, high configuration requirement and the like in the existing software closed-loop positioning method.

Description

Method, device and system for positioning software endless loop and storage medium

Technical Field

The invention relates to the technical field of computers, in particular to a method, a device and a system for positioning software endless loop and a storage medium.

Background

Applications are typically installed on a computer device and may experience exceptions during runtime, such as trapping of the application in a loop. An endless loop means that an application cannot terminate its process under its own control. When the application program falls into the dead loop, the fault position corresponding to the dead loop needs to be positioned so as to enable the application program to work normally.

The following methods are common: firstly, adding printing in suspicious codes, recording program running tracks, and circularly printing the added information once a CPU enters a dead loop. And secondly, monitoring the target program by using third-party software or tools for task detection, such as gdb, and determining the position of the dead loop by methods such as setting a breakpoint.

The first method is to carry out positioning by guessing, which has high requirements on the skills of developers, and meanwhile, the printing adding positions need to be frequently modified, the printing information is increased, codes are compiled, and debugging and running are carried out for many times, which is very inconvenient. The second method is to use third-party software or source code, which needs to obtain the license of the software or the source code, is very familiar with the third-party software, can only run on a target environment, and is very troublesome to configure the third-party software, and some systems even do not support the third-party software to run in the system.

Therefore, the existing software endless loop positioning technology has the problems of complex operation, low positioning efficiency, high configuration requirement and the like, and needs to be improved.

Disclosure of Invention

In view of the defects of the prior art, the invention aims to provide a method, a device, a system and a storage medium for positioning software endless loop, and aims to solve the problems of complex operation, low positioning efficiency, high configuration requirement and the like in the conventional method for positioning software endless loop.

In order to achieve the purpose, the invention adopts the following technical scheme:

a method for positioning software endless loop, wherein the method comprises the following steps:

a. receiving a debug command provided by a CPU (Central processing Unit), and monitoring a branch instruction;

b. when the branch instruction is executed, the CPU triggers an exception and enters an exception handler;

c. judging in the exception handling program, if the current call stack is in the stack of the monitored task, allowing to record the call record, and if the current call stack is not in the stack of the monitored task, not recording;

d. forcibly terminating the exception handling program, reading the valid information and storing the valid information as a file;

e. disassembling the exception handler, saving the disassembled result as a file, determining which section of code the CPU executes in a continuous loop, and failing to exit to determine the location of a dead loop.

The method for positioning software dead loop, wherein the step a of receiving a debug command provided by a CPU comprises the following steps of:

and (4) initializing and setting the branch instruction, enabling the branch instruction to be abnormal, and enabling the branch instruction to monitor.

In the method for locating a software dead loop, when the branch instruction in step b is executed, the CPU triggers an exception and enters an exception handler, further comprising the steps of:

b1, in the exception handling program, the control operation system saves each register before entering the exception program and transfers the registers to the exception handling function, and the exception handling program can acquire each register of the CPU.

The method for positioning software endless loop, wherein the step d of forcibly terminating the exception handler, reading valid information and storing the valid information as a document comprises the following steps:

d0, determining that the exception handler has been loop-locked, and then running for a period of time.

The method for positioning software dead loop, wherein the step e disassembles the exception handler, saves the disassembled result as a file, determines the section of code between which the CPU executes the loop without stopping, and cannot exit, so as to determine the position of the dead loop, further comprising the steps of:

e1, searching in the disassembled result by using the PC value in each piece of record information of the call stack, and obtaining the function of the PC value, thereby finding out the function of each piece of call stack information.

A software closed loop positioning device, comprising: a processor, a memory, and a communication bus;

the memory stores a software dead-cycle positioning method program executable by the processor;

the communication bus realizes connection communication between the processor and the memory;

when the processor executes the program of the positioning method of the software endless loop, the following steps are realized:

The device for positioning software endless loop, when the processor executes the program of the method for positioning software endless loop, the following steps are further implemented:

The positioning device for software endless loop, when the processor executes the positioning method program for software endless loop, the following steps are also implemented:

A software closed loop positioning system, comprising:

the receiving module is used for receiving a debug command provided by the CPU and monitoring a branch instruction;

an exception triggering module for triggering an exception by the CPU and entering an exception handler when the branch instruction is executed;

the judging module is used for judging in the exception handling program, if the current call stack is in the stack of the monitored task, the call record is allowed to be recorded, and if the current call stack is not in the stack of the monitored task, the call record is not recorded;

the program termination module is used for forcibly terminating the exception handling program, reading the valid information and storing the valid information as a file;

and the analysis module is used for disassembling the exception handling program, saving a disassembling result as a file, and determining that the CPU continuously executes the loop between the sections of codes and cannot exit so as to determine the position of the dead loop.

A storage medium having one or more programs stored thereon, the one or more programs being executable by one or more processors for performing any of the steps in a method for software closed loop positioning.

Compared with the prior art, the invention provides a method, a device, a system and a storage medium for positioning software endless loop, which utilize a debug function provided by a CPU (central processing unit), trigger an exception when a branch instruction is executed, record and process analysis in an exception handling program, allow recording of a call record and record to a specified memory position if a current call stack is in a stack of a monitored task, and continue to operate the CPU, or directly return to the program to continue to operate normally without recording. And after the dead loop runs for a certain time, forcibly terminating the application program, reading stack information kept by the fixed memory, analyzing, and determining the section of the code between which the CPU executes the loop continuously and cannot exit, so that the position of the dead loop is determined. Therefore, compared with the existing positioning method, the method is very simple and efficient, and effectively solves the problems of complex operation, low positioning efficiency, high configuration requirement and the like in the existing software closed-loop positioning method.

Drawings

Fig. 1 is a flowchart of a method for positioning a software loop.

FIG. 2 is a diagram illustrating an exemplary branch instruction initialization configuration according to the present invention.

FIG. 3 is a diagram illustrating the execution of task A according to an embodiment of the present invention.

FIG. 4 is a detailed flow chart of the embodiment of the present invention before entering an exception handler until the exception handler is terminated.

Fig. 5 is a functional schematic block diagram of a positioning apparatus for software dead loop provided in the present invention.

Fig. 6 is a functional block diagram of a software loop-locked positioning system according to the present invention.

Detailed Description

In order to make the objects, technical solutions and effects of the present invention clearer and clearer, the present invention is further described in detail below with reference to the accompanying drawings and examples. It should be understood that the specific embodiments described herein are merely illustrative of the invention and are not intended to limit the invention.

Referring to fig. 1 to 4, the method for positioning a software loop in a dead state according to the present invention includes the following steps:

s100, receiving a debug command provided by a CPU, and monitoring a branch instruction;

in the embodiment of the present invention, before the step S100, the method includes:

Specifically, a closed loop task ID is set, the number N of call stack layers is set, the bottom S of a task stack is obtained, and a record stack memory address A is set. FIG. 2 is a diagram illustrating initialization of branch instructions.

Further, the developer provides task IDs of dead cycles to be monitored, each task is assigned a task stack (a segment of available memory space) by the operating system, and all stacks to be used by function calls come from the task stack. The stack address allocated by the operating system is the task stack bottom. Please refer to fig. 3, which is a diagram illustrating the execution of task a. The stack bottom of the task a is sp ═ 0x04806400, the first calling function of the task a is F1, then F1 calls F2, and so on, each function call needs to open up a stack space for storing the local variables defined in the function execution. Note that here is just the call stack of the function, not where the program instructions are stored. When the function Fn is executed, SP is 0x0480589, and according to the traceability of the stack, SP is 0x04806400 at the bottom of the stack. It may then be found that the top of the stack is the bottom of the stack of task A, and it is determined that the current function was executed by task A, and it is also determined that task A is currently executing.

S200, when the branch instruction is executed, triggering an exception by a CPU and entering an exception handling program;

in this embodiment of the present invention, the step S200 further includes the steps of:

Specifically, the registers include a stack register sp, general registers r0 to r31, a pc register, and the like. The stack register sp is a key register for backtracking the function call relation, and can backtrack to the stack bottom of the current task according to sp;

specifically, a call stack at the abnormal position is obtained, a call stack bottom s is traced back, and then the number n of layers at the stack bottom is recorded.

S300, judging in the exception handling program, if the current call stack is in the stack of the monitored task, allowing to record the call record, and if the current call stack is not in the stack of the monitored task, not recording;

specifically, recording and processing and analyzing in an exception handling program, if a current call stack is in a stack of a monitored task, allowing the call record to be recorded, recording to a specified memory position, and continuing to enable a CPU to execute a branch instruction, and if the current call stack is not in the stack of the monitored task, not recording, and directly returning to enable the CPU to continue to execute the branch instruction;

further, the deeper the number of function call layers, the more the number of function call stack stages. If the calling relations of the four functions A- > B- > C- > D are satisfied, the call stack obtained in the D function has 4 levels of stack address information. In order to simplify the positioning process, only a specified number of stages of calling functions need to be monitored, and the number of stages can be configured. If only the 4-level call stack is monitored, the D function calls the E function, and call stack information cannot be recorded in the E function, so that stack information can be greatly reduced, and a dead loop position can be located more quickly.

In order to further understand the steps S200-S300 of the present invention, the detailed implementation flow from the current entering of the exception handling routine to the termination of the exception handling routine is described. Please refer to fig. 4, which is a flowchart illustrating an embodiment of the present invention before an exception handler is entered and terminated.

S400, forcibly terminating the exception handling program, reading effective information and storing the effective information as a file;

in this embodiment of the present invention, before the step S400, the method further includes the steps of:

Specifically, after determining that the exception handling program is in a loop, running for 1 minute, and forcibly stopping running the program;

furthermore, an interface for reading records is provided, stack information held by the fixed memory is read out and stored in a PC text document. One stack record includes the stack address ulsackaddr, PC value ulNextInstAddr.

S500, disassembling the exception handling program, saving a disassembling result as a file, and determining the section of code between which the CPU executes the loop without stopping, wherein the loop cannot be withdrawn so as to determine the position of the dead loop.

In this embodiment of the present invention, the step S500 further includes the steps of:

Specifically, disassembling an application program generating dead cycles on a PC, storing a disassembling result in a text file, searching the disassembling result by using a PC value in each piece of record information of a call stack, and acquiring a function where the PC value is located. By the method, the function where each piece of call stack information is located is found out and analyzed, so that the continuous running of the loop between the code sections can be quickly found out, and the loop cannot exit, so that the position of the dead loop can be determined.

For a better understanding of the invention, we now exemplify a section of dead loop code:

testDeadLoopTask is a test task body, a call stack is set to be 4 layers, and after the test task body runs for one minute, the information of monitoring records after exception is as follows:

0x04806400	0x00251ca4	printf
			0x04806380	0x00284cd0	function1
0x04806294	0x0028594a	function2
			0x04806380	0x00284cd0	function1
0x04806294	0x0028594a	function2
			0x04806380	0x00284cd0	function1
0x04806294	0x0028594a	function2
			0x04806380	0x00284cd0	function1
0x04806294	0x0028594a	function2
			0x04806380	0x00284cd0	function1
0x04806294	0x0028594a	function2
			。。。	。。。	。。。

from the above table, it can be seen that the task testloadtask always runs in the functions 1 and 2, and then the position of the dead loop can be directly found out by combining the actual code.

Referring to fig. 5, based on the above method for positioning software endless loop, the present invention further provides a device for positioning software endless loop, including: a processor 10, a memory 20, a communication bus 30, and a communication interface 50, wherein the processor 10 is connected to the memory 20 through the communication bus 30, and the communication interface 50 is connected to the processor 10 through the communication bus 30;

the memory 20 has stored thereon a software dead-loop positioning method program 40 executable by the processor 10;

fig. 5 shows only some of the components of the positioning apparatus in a software dead loop, but it should be understood that not all of the shown components are required and that more or fewer components may be implemented instead.

When the processor 10 executes the positioning method program 40 of the software dead loop, the following steps are realized:

Please refer to fig. 6, which is a functional block diagram of a software loop locking positioning system according to the present invention. In this embodiment, the system installed with the program of the positioning method of the software dead loop may be divided into one or more modules, and the one or more modules are stored in the memory 20 and executed by one or more processors (in this embodiment, the processor 10) to complete the present invention. In fig. 6, the system in which the positioning method program of the software loop can be installed can be divided into a receiving module 21, an abnormality triggering module 22, a judging module 23, a program terminating module 24, and an analyzing module 25. The module referred to in the invention refers to a series of computer program instruction segments capable of performing specific functions, and is more suitable than a program for describing the execution process of the positioning method program of the software dead loop in the equipment. The following description will specifically describe the functionality of the modules 21-25.

The receiving module 21 is configured to receive a debug command provided by the CPU and monitor a branch instruction;

an exception triggering module 22, configured to, when the branch instruction is executed, trigger an exception by the CPU and enter an exception handler;

a judging module 23, configured to judge in the exception handling program, if the current call stack is in the stack of the monitored task, allow to record the call record, and if the current call stack is not in the stack of the monitored task, not record the call record;

a program termination module 24, configured to terminate the exception handler forcibly, read valid information, and store the valid information as a file;

and the analysis module 25 is used for disassembling the exception handler, saving the disassembling result as a file, and determining that the CPU continuously executes the loop between the sections of the codes and cannot exit so as to determine the position of the dead loop.

Based on the foregoing embodiments, the present invention further provides a storage medium, where the storage medium stores one or more programs, and the one or more programs are executable by one or more processors to implement any one of the steps in the method for positioning a software dead loop, which is specifically described above.

In summary, the present invention provides a method, an apparatus, a system, and a storage medium for positioning a software loop, where an exception is triggered when a branch instruction is executed by using a debug function provided by a CPU, and then recorded in an exception handling program and processed and analyzed, if a current call stack is in a stack of a monitored task, the call record is allowed to be recorded and recorded to a specified memory location, and the CPU is allowed to continue to run, otherwise, the call is directly returned to continue to run normally without recording. And after the dead loop runs for a certain time, forcibly terminating the application program, reading stack information kept by the fixed memory, analyzing, and determining the section of the code between which the CPU executes the loop continuously and cannot exit, so that the position of the dead loop is determined. Therefore, compared with the existing positioning method, the method is very simple and efficient, and effectively solves the problems of complex operation, low positioning efficiency, high configuration requirement and the like in the existing software closed-loop positioning method.

Of course, it will be understood by those skilled in the art that all or part of the processes of the methods of the above embodiments may be implemented by a computer program instructing relevant hardware (such as a processor, a controller, etc.), and the program may be stored in a computer readable storage medium, and when executed, the program may include the processes of the above method embodiments. The storage medium may be a memory, a magnetic disk, an optical disk, etc.

It is to be understood that the invention is not limited to the examples described above, but that modifications and variations may be effected thereto by those of ordinary skill in the art in light of the foregoing description, and that all such modifications and variations are intended to be within the scope of the invention as defined by the appended claims.

Claims

1. A method for positioning software endless loop is characterized by comprising the following steps:

2. The method as claimed in claim 1, wherein the step a of receiving a debug command provided by the CPU comprises, before monitoring the branch instruction:

3. The method as claimed in claim 1, wherein said step b, when said branch instruction is executed, the CPU triggers an exception and enters an exception handler, further comprises the steps of:

4. The method as claimed in claim 1, wherein said step d comprises the steps of, before forcibly terminating said exception handler, reading valid information and storing the valid information as a document:

5. The method as claimed in claim 1, wherein said step e disassembling said exception handler, saving the disassembled result as a file, determining which section of code the CPU executes without stopping in a loop, and cannot exit to determine the location of the dead loop further comprises the steps of:

6. A software loop-through positioning device, comprising: a processor, a memory, and a communication bus;

7. The apparatus according to claim 6, wherein the processor further implements, when executing the program of the method for locating software dead loop, the following steps:

8. The apparatus according to claim 6, wherein the processor executes the program of the method for positioning software dead loop to further implement the following steps:

9. A system for locating software loops, comprising:

10. A storage medium storing one or more programs, the one or more programs being executable by one or more processors to perform the steps of a method for locating software dead loops as claimed in any one of claims 1 to 5.