WO2013155822A1

WO2013155822A1 - Method, device and system for realizing pass-by data breakpoint

Info

Publication number: WO2013155822A1
Application number: PCT/CN2012/083108
Authority: WO
Inventors: 黄见辉
Original assignee: 华为技术有限公司
Priority date: 2012-04-17
Filing date: 2012-10-17
Publication date: 2013-10-24
Also published as: CN102662845A; CN102662845B

Abstract

The embodiment of the present invention provides a method, a device and a system for realizing a pass-by data breakpoint, relates to the field of computers, and is used for realizing the pass-by data breakpoint in a Linux ARM or Unix ARM system and simultaneously using the data breakpoint repeatedly. The method comprises: canceling the data breakpoint when a source program reaches an instruction provided with the data breakpoint; decoding the instruction provided with the data breakpoint; executing the instruction after decoding; re-setting the data breakpoint at the instruction provided with the data breakpoint; and enabling a program counter PC pointer to point to the next instruction relative to the instruction provided with the data breakpoint, wherein the program counter PC pointer is used for storing the address of the next instruction to be implemented. The embodiment of the present invention is used for realizing the pass-by data breakpoint.

Description

Method, device and system for realizing transitive data breakpoints The present application claims to be filed on the Chinese Patent Office on April 17, 2001, the application number is 201 2 1 01 1 2766. X , the invention name is "a kind of The priority of the Chinese Patent Application, which is hereby incorporated by reference in its entirety in its entirety in its entirety in the the the the the the the the the

Technical field

The present invention relates to the field of computers, and in particular, to a method, device and system for implementing transitive data breakpoints.

Background technique

The pass-through data breakpoint is a necessary function for rewriting after the software locates the data or instructions. The basic principle of the data breakpoint is to set the data or instruction address to be monitored to the debug register of the CPU. When the CPU accesses the monitored data or instruction address, a trap exception handler is triggered. After the trap exception handler, it will return to the context that triggered the trap exception handler and continue execution. The entire process does not affect the state of the original system.

However, existing Linux ARM or Unix ARM systems have the following problems when implementing breakpoint processing:

When the source program runs to the address of the monitored data or instruction, the CPU will trigger a trap exception handler. In Linux ARM or Unix ARM systems, since the trap is a synchronous exception, after executing the trap exception handler, , will re-execute the instruction that triggered the trap. In this way, the trap exception handler is triggered again, resulting in a loop trigger, which fails to implement the traversal data breakpoint, which in turn leads to the interruption of the service of the existing software system. Summary of the invention

Embodiments of the present invention provide a method, apparatus, and system for implementing transitive data breakpoints for implementing transitive data breakpoints in a Linux ARM or Unix ARM system. In order to achieve the above object, the embodiment of the present invention adopts the following technical solutions:

In one aspect, a method for implementing a transitive data breakpoint is provided, which is applied to a Linux ARM or Unix ARM system running an active program, wherein at least one number is set in the source program. According to the breakpoint; the method includes: canceling the data breakpoint when the source program runs to an instruction set with a data breakpoint;

Decoding the instruction with the data breakpoint set; executing the decoded instruction;

Resetting the data breakpoint at the instruction set with the data breakpoint; pointing the program counter PC pointer to the next instruction of the instruction set with the data breakpoint, wherein the program counter PC pointer is used to store the The address of the next instruction executed.

In one aspect, a method for implementing a transitive data breakpoint is provided for use in a Linux ARM or Unix ARM system running an active program; the source program is provided with at least one data breakpoint; the method includes: When the source program runs to an instruction set with a data breakpoint, the data breakpoint is canceled;

Backing up the next instruction of the instruction with the data breakpoint as the backup instruction; modifying the next instruction of the instruction with the data breakpoint as an illegal instruction; executing the instruction and the data breakpoint setting Describe the modified next instruction; recover the data breakpoint at the instruction with the data breakpoint set;

The modified next instruction is restored to the backup instruction.

In one aspect, a communication system is provided, the communication system including a memory and at least one

CPU;

An operating system is running in the CPU, and at least one sequence is run on the operating system; the source program and the exception handling program are loaded in the memory, and at least one of the source program is set a data breakpoint, the exception handler is triggered when the source program runs to an instruction having a data breakpoint, the exception handler is further used,

The data breakpoint is canceled when the source program runs to an instruction set with a data breakpoint. Decoding the instruction with the data breakpoint set; executing the decoded instruction;

An operating system is run in the CPU, and at least one sequence is run on the operating system; the source program and the exception processing program are loaded in the memory, and the source program is set At least one data breakpoint, triggering an exception handler when the source program runs to an instruction having a data breakpoint, the exception handler also being used,

The data breakpoint is canceled when the source program runs to an instruction set with a data breakpoint;

The modified next instruction is restored to the backup instruction.

In one aspect, a device for implementing a transitive data breakpoint is provided for use in a Linux ARM or Unix ARM system running an active program, wherein the source program is provided with at least one data breakpoint, wherein the The device for breaking the data data includes: a first canceling module, configured to cancel the data breakpoint when the source program runs to an instruction set with a data breakpoint;

a decoding module, configured to decode the instruction with a data breakpoint; a first execution module, configured to execute the decoded instruction; a setting module, configured to re-set a data breakpoint at the instruction with the data breakpoint set; a pointing module, configured to point the program counter PC pointer to the next instruction of the instruction set with the data breakpoint, wherein The program counter PC pointer is used to store the address of the next instruction to be executed.

In one aspect, a device for implementing a transitive data breakpoint is provided for use in a Linux ARM or Unix ARM system running an active program; the source program is provided with at least one data breakpoint, wherein the Devices for sexual data breakpoints include:

a second canceling module, configured to cancel the data breakpoint when the source program runs to an instruction set with a data breakpoint; and a backup module, configured to back up the next instruction of the instruction with a data breakpoint , as a backup instruction; a modification module, configured to modify the next instruction of the instruction with the data breakpoint to be an illegal instruction;

a second execution module, configured to execute the instruction with a data breakpoint and the modified next instruction; and a recovery module, configured to recover a data breakpoint at the instruction with the data breakpoint set; And for restoring the modified next instruction to the backup instruction. The method, device and system for implementing a transitive data breakpoint provided by an embodiment of the present invention, after executing an instruction for triggering an exception handler in an exception handler, returning to the source program to execute a next instruction of an instruction that triggers the exception handler, or The data breakpoint of the trigger exception handler is canceled in the exception handler, and the next instruction of the instruction that triggered the exception handler is saved, and the next instruction is set as an illegal instruction, thereby achieving the effect of implementing the breakpoint of the traversing data. , and the exception handler is not triggered again, causing a loop trigger, and the data breakpoint can be reused.

BRIEF DESCRIPTION OF THE DRAWINGS In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the drawings used in the embodiments or the prior art description will be briefly described below, and obviously, in the following description The drawings are only some embodiments of the present invention, and those skilled in the art can obtain the drawings according to the drawings without any creative work. Other drawings. FIG. 1 is a schematic diagram of a method for implementing a transitive data breakpoint according to an embodiment of the present invention; FIG. 2 is a schematic diagram of another method for implementing a transitive data breakpoint according to an embodiment of the present invention; Another method for implementing a breakpoint of a transitive data; FIG. 4a is a schematic structural diagram of a communication system according to an embodiment of the present invention;

4b is a partial schematic diagram of a communication system according to an embodiment of the present invention;

Figure 4c is a schematic diagram of the principle of a conventional application compilation process;

FIG. 5 is a schematic diagram of an apparatus for implementing a transitive data breakpoint according to an embodiment of the present invention; FIG. 6 is a schematic diagram of another apparatus for implementing a transitive data breakpoint according to an embodiment of the present invention; Yet another device that implements breakpoints in transit data. The technical solutions in the embodiments of the present invention are clearly and completely described in the following with reference to the accompanying drawings in the embodiments of the present invention. It is obvious that the described embodiments are only a part of the embodiments of the present invention, and not all of the embodiments. example. All other embodiments obtained by a person of ordinary skill in the art based on the embodiments of the present invention without creative efforts are within the scope of the present invention.

The method for implementing the transitive data breakpoint provided by the embodiment of the present invention is applied to a Linux ARM or Unix ARM system running an active program, wherein at least one data breakpoint is set in the source program; the method is as shown in FIG. , including:

5101. When the source program runs to an instruction set with a data breakpoint, cancel the data breakpoint.

Specifically, canceling the data breakpoint at the breakpoint of the source program can directly invoke the method of canceling the data breakpoint in the operating system.

5102. Decode the instruction with the data breakpoint set.

Specifically, when the CPU executes the data breakpoint in the source program, after the abnormal program is triggered, the context information of the instruction that triggers the exception handler is saved, so that the CPU will resume the interrupt after executing the exception handler. The context of the source program continues to be implemented, and the process can be implemented by the prior art, and details are not described herein again. In this step, the instruction is found by the saved context information of the instruction that triggers the exception handler. Since the instruction is an unpredictable machine language, the instruction needs to be decoded at this time to obtain the information of the instruction, which lays the next step for the operation. basis.

5103. Perform the decoded instruction. Specifically, according to the instruction of the trigger exception handler decoded in the previous step, the corresponding method is called to execute.

5104. Set a data breakpoint again at the instruction with the data breakpoint set.

Specifically, the method for setting data breakpoints provided by the kernel can be directly called in the abnormal program to be set.

5105. Point the program counter PC pointer to the next instruction of the instruction set with a data breakpoint, wherein the program counter PC pointer is used to store the address of the next instruction to be executed.

Specifically, before the execution of the trigger exception handler, since the instruction with the data breakpoint is not executed, the program counter PC pointer still points to the instruction with the data breakpoint set. In this case, in order to ensure that the CPU is executing the exception. After the program returns to the source program, the next instruction that executes the instruction that triggered the exception handler needs to point the PC pointer to the next instruction of the instruction with the data breakpoint set. For example, the PC pointer can be used. The location of the PC=PC+4, and the process of returning to the source program by the exception handler can be implemented by the prior art, and details are not described herein again. The method for implementing the traversal data breakpoint provided by the embodiment of the present invention achieves the implementation of the instruction that triggers the exception handler by executing the instruction that triggers the exception handler in the exception handler and then returns to the source program to execute the next instruction that triggers the exception handler. The effect of the data breakpoint, and will not trigger the exception handler again, causing a loop trigger, and the data breakpoint can be reused.

Preferably, as shown in FIG. 2, the method for implementing a transitive data breakpoint further includes:

5106. Create at least one data breakpoint file, where the data breakpoint file is used to record information of a breakpoint to be monitored. Specifically, the process of creating a data breakpoint file is:

First, create a data breakpoint file directory, this step can be invoked by calling the Linux system. The kernel_kobj property to create a data breakpoint directory, exemplarily, create the hwbrk directory, which is implemented by the following program:

Hw_breakpoint_kobj=kobject_create_and_add(" hwbrk", kernel_kobj); if ( !hw_breakpoint_kobj)

Return -ENOMEM; Secondly, create at least one data breakpoint file in the data breakpoint directory, the process creates a file by calling a function provided by the Linux system kernel, such as sysfs_create_group, etc., in the hwbrk data breakpoint directory The file that creates the data breakpoint can be implemented by the following program code: retval = sysfs_create_group(hw_breakpoint_kobj, &attr_group);

If (retval)

Kobject_put(hw_breakpoint_kobj);

Printk( " Hardware Breakpoint Manager init...\n");

Return retval; It should be noted that data breakpoints can be set in the source program by calling the data breakpoint-related functions provided by the Linux system kernel in the write attribute of the data breakpoint file.

Specifically, the breakpoint address to be monitored is written in the data breakpoint file, and the data breakpoint is set in the source program according to the breakpoint address in the data breakpoint file. Similarly, the user needs The monitored breakpoint parameter is written into the data breakpoint file; the data breakpoint file searches for a corresponding breakpoint address according to the breakpoint parameter to a preset symbol table, and according to the breakpoint address Set data breakpoints in the source program.

Wherein, when the data breakpoint file is written into the data, the data is determined to be a breakpoint address or a breakpoint parameter, and when the data is a breakpoint address, the data breakpoint file sets the data at the corresponding position of the source program. a breakpoint, so that when the source program runs to the data breakpoint, the exception handler is triggered; when the data is a breakpoint parameter, the data breakpoint file finds the corresponding breakpoint address of the breakpoint parameter, and Setting a data breakpoint at the breakpoint address to trigger an exception handler when the source program runs to an instruction having the breakpoint parameter, wherein the breakpoint parameter More specifically, the following program code can be used to set data breakpoints in the source program based on the written breakpoint address:

Static ssize_t symbol_store(struct kobject *kobj, struct kobj_attribute *attr, const char *buf, size_t count)

{ / * Initialize data breakpoints * /

Hw_breakpoint_init(&atribs); sscanf(buf, "%s", hwbrk_data[index] .symbol);

/ * Determine whether the user entered the address or breakpoint parameters * /

If (hwbrk_data[index] .symbol[0] == Ό' && (hwbrk_data[index] .symbol [ 1 ] == 'x' II hwbrk_data[index] .symbol[ 1 ] == 'X')) { sscanf (hwbrk_data[index]. symbol, "%Lx",&atribs.bp_addr);

Else { / * If it is a breakpoint parameter, go to the symbol table to find the corresponding address */ atribs.bp_addr=kallsyms_lookup_name(hwbrk_data[index]. symbol);

Atribs.bp_len = sizeof(long); atribs.bp_type = hwbrk_data[index] .type = hwbrk_type;

//HW_B EAKPOINT_W is default

If (atribs.bp_addr > 0) { hwbrk_data[index] .addr = atribs.bp_addr; hwbrk_data[index] .value = *((u32*)(atribs.bp_addr));

/*Register data breakpoints and callbacks callback*/

Hwbrk_data[index].hbp=register_wide_hw_breakpoint(&atribs, callback );

If (IS_ERR((void― force *)hwbrk_data[index] .hbp)) { ret = PTR_ERR((void― force *)hwbrk_data[index] .hbp); goto fail;

Return ret;

In this way, by writing the breakpoint parameter or the breakpoint address to be monitored in the data breakpoint file, the data breakpoint is set at the corresponding position in the source program, which is convenient for the user to use. It should be noted that the breakpoint is The parameter can be a symbolic name or a parameter value.

It should be noted that the read attribute of the data breakpoint file can also be set to perform some operation restrictions on the data breakpoint file. The specific implementation process is as follows:

Static ssize_t symbol_show(struct kobject *kobj, struct kobj_attribute *attr,char *buf)

Sm_fk_index[att]; { len = sprintf(buf, "Debug symbol %s and has value 0x%d\n", hwbrk_data[index] .symbol, hwbrk_data[index] .value); len += printBreakpointType(buf+len); Return len;

Further, the breakpoint parameter that the user needs to monitor and the type of the breakpoint parameter to be monitored may be written into the data breakpoint file; and the corresponding break is found according to the breakpoint parameter and the type of the breakpoint parameter. Point address, and set a data breakpoint in the source program according to the breakpoint address, the type of the breakpoint parameter is: a readable type, a writable type, and a readable and writable type.

In this way, not only can you write the breakpoint parameter to be monitored in the data breakpoint file, but you can also set the data breakpoint at the corresponding position of the source program by writing the type of the breakpoint parameter to be monitored in the data breakpoint file. , further convenient for users to use. It should be noted that, according to the breakpoint parameter and the type of the breakpoint parameter, the corresponding breakpoint address is searched, and the corresponding breakpoint address can be found in the corresponding table. The process is prior art, and is no longer here. Narration. Exemplarily, the table may be a symbol table stored in an operating system. When the data breakpoint file writes a type of a breakpoint parameter and a breakpoint parameter, the data breakpoint file is found in the symbol table to match the break. The breakpoint address of the breakpoint parameter of the point parameter type, and the data breakpoint is set in the source program according to the breakpoint address.

Further, the breakpoint parameter that the user needs to monitor and the range of the breakpoint parameter to be monitored may be written into the data breakpoint file; and the corresponding range is found according to the breakpoint parameter and the range of the breakpoint parameter. A breakpoint address, and a data breakpoint is set in the source program according to the breakpoint address.

In this way, not only can you write the breakpoint parameter to be monitored in the data breakpoint file, but also set the data at the corresponding position of the source program by writing the range of the breakpoint parameter to be monitored in the data breakpoint file. Breakpoints further facilitate the use of the user.

Exemplarily, when the data breakpoint file writes the breakpoint parameter and the range of the breakpoint parameter to be monitored, the data breakpoint file finds a breakpoint in the symbol table that meets the breakpoint parameter of the breakpoint parameter range. Address, and set data breakpoints in the source program based on the breakpoint address.

It should be noted that when the data breakpoint file only writes the breakpoint parameter of the above content, the breakpoint address, the type of the breakpoint parameter, and any one or more of the breakpoint parameter ranges, the others are default values, obviously , which makes it more flexible to pass the data breakpoint file in the source program. Set data breakpoints.

A method for implementing a transitive data breakpoint according to an embodiment of the present invention is applied to a Linux ARM or Unix ARM system running an active program, wherein at least one data breakpoint is set in the source program, and the method is as shown in FIG. Show,

Do the following in the exception handler:

S301: Cancel the data breakpoint when the source program runs to an instruction set with a data breakpoint.

Specifically, canceling the data breakpoint at the breakpoint of the source program can directly call the method of canceling the data breakpoint in the kernel.

5302. Back up the next instruction of the instruction with the data breakpoint set as the backup instruction.

Specifically, the process can be implemented by using the prior art, and details are not described herein again.

5303. Modify the next instruction of the instruction with the data breakpoint to an illegal instruction.

5304. Execute the instruction for setting a data breakpoint and the modified next instruction.

It should be noted that, after executing step 303, an emulation execution instruction with a data breakpoint is required, and after executing the instruction with the data breakpoint set, it is necessary to return to the source program, and execute the modified next one. In the process, a person skilled in the art can specifically complete the foregoing process according to the description of the embodiments of the present invention, and details are not described herein again.

5305. Restore a data breakpoint at the instruction where the data breakpoint is set. Specifically, the process can reset the data breakpoint at the breakpoint by calling the set data breakpoint provided by the kernel.

5306. Restore the modified next instruction to the backup instruction.

The method for implementing the transitive data breakpoint provided by the embodiment of the present invention cancels the data breakpoint of the trigger exception handler in the exception handler, saves the next instruction of the instruction that triggers the exception handler, and sets the next one. The instruction is an illegal instruction, so that the effect of implementing the breakpoint of the data is achieved, and the exception handler is not triggered again, causing the loop trigger, and the data breakpoint can be reused. Preferably, the method for implementing a transitive data breakpoint, as shown in FIG. 3, further includes

S307. Create at least one data breakpoint file, where the data breakpoint file is used to record information of a breakpoint to be monitored. The process of creating a data breakpoint file may refer to step 106 in the foregoing embodiment. Specifically, the breakpoint address to be monitored is written in the data breakpoint file, and the data breakpoint is set in the source program according to the breakpoint address in the data breakpoint file. Similarly, the user needs The monitored breakpoint parameter is written into the data breakpoint file; the data breakpoint file searches for a corresponding breakpoint address according to the breakpoint parameter to a preset symbol table, and according to the breakpoint address Set data breakpoints in the source program.

Wherein, when the data breakpoint file is written into the data, the data is determined to be a breakpoint address or a breakpoint parameter, and when the data is a breakpoint address, the data breakpoint file sets the data at the corresponding position of the source program. a breakpoint, so that when the source program runs to the data breakpoint, the exception handler is triggered; when the data is a breakpoint parameter, the data breakpoint file finds the corresponding breakpoint address of the breakpoint parameter, and The data breakpoint is set at the breakpoint address to trigger the exception handler when the source program runs to the instruction having the breakpoint parameter, wherein the breakpoint parameter includes a symbol name or a parameter value. In this way, the data breakpoint can be set at the corresponding position in the source program by writing the breakpoint value or address to be monitored in the data breakpoint file, which is convenient for the user to use. Further, the breakpoint parameter that the user needs to monitor and the type of the breakpoint parameter to be monitored may be written into the data breakpoint file; and the corresponding break is found according to the breakpoint parameter and the type of the breakpoint parameter. Point address, and set a data breakpoint in the source program according to the breakpoint address, the type of the breakpoint parameter is: a readable type, a writable type, and a readable and writable type.

In this way, not only can you write the breakpoint parameter to be monitored in the data breakpoint file, but you can also set the data breakpoint at the corresponding position of the source program by writing the type of the breakpoint parameter to be monitored in the data breakpoint file. , further convenient for users to use.

It should be noted that, according to the breakpoint parameter and the type of the breakpoint parameter, the corresponding breakpoint address is searched, and the corresponding breakpoint address can be found in the corresponding table. The process is prior art, and is no longer here. Narration. Exemplarily, the table can be a symbol table stored in the operating system, when the data breaks the text After writing the breakpoint parameter and the type of the breakpoint parameter, the data breakpoint file finds the breakpoint address of the breakpoint parameter that matches the breakpoint parameter type in the symbol table, and according to the breakpoint address in the source program Set data breakpoints in .

It should be noted that when the data breakpoint file only writes the breakpoint parameter of the above content, the breakpoint address, the type of the breakpoint parameter, and any one or more of the breakpoint parameter ranges, the others are default values, obviously This makes it more flexible to set data breakpoints in the source program through the data breakpoint file. A communication system provided by an embodiment of the present invention has a system structure diagram and a partial logic diagram as shown in FIG. 4a and FIG. 4b respectively. FIG. 4a includes three CPUs, namely, CPU1, CPU2, and CPU3, and the CPU accesses the memory through the bus. It should be understood that the communication system of the embodiment of the present invention may include a CPU, that is, a single CPU communication system, and may also include multiple CPUs, that is, multiple CPU (multi-core) communication systems. That is, the communication system of the embodiment of the present invention includes at least one CPU and a memory, the CPU runs an operating system, and the operating system runs on at least one application (also referred to as software) for executing a specific Wherein: '','一, , , - the memory program is loaded with the source program and the exception handler, the source program is provided with at least one data breakpoint, when the source program runs to An exception handler is triggered when the instruction has a data breakpoint, and the exception handler is used to cancel the method of canceling the data breakpoint in the operating system when the source program runs to the instruction where the data breakpoint is set. The data breakpoint; decoding the instruction with the data breakpoint set, and executing the decoded instruction, specifically, calling the corresponding method to execute; re-instructing the instruction with the data breakpoint Setting a data breakpoint; pointing the program counter PC pointer to the next instruction of the instruction set with a data breakpoint, wherein the program counter PC pointer is used to store the address of the next instruction to be executed.

The communication system of the embodiment of the present invention further includes: a compiler (not shown in the figure), a schematic diagram of the principle of the compilation process of the application, as shown in FIG. 4c, the conventional compilation process includes: the source file (.c) is compiled by the compiler. The file is compiled into a target file (.0 file, that is, a binary file), and then multiple target files are linked into an executable file. Before the compiler compiles the source program, the user can set some traversal data breakpoints, so that when the source program runs to the instruction with the data breakpoint, the exception handler is triggered; the basic principle of the sci-fi data breakpoint is that The monitored data/instruction address is set to the debug register of the cpu. When the cpu accesses the monitored data/instruction address, an exception handler is triggered. After the exception handler is processed, the context of the trigger exception handler is restored. Execution, the whole process does not affect the state of the original system, and achieves the effect of "passing data breakpoints". In the embodiment of the present invention, a data breakpoint is also set in the source program by providing a data breakpoint file, where the directory of the data breakpoint file is created in the kernel of the operating system; Creating at least one data breakpoint file in the point directory; the data breakpoint file is used to write a breakpoint address to be monitored, and set a data breakpoint in the source program according to the breakpoint address, so that In this file, the breakpoint address of the data breakpoint is written, and the data breakpoint can be set in the source program, which is convenient for the user to use. In addition, the data breakpoint file can also set the data by writing the breakpoint parameter. Breakpoints, and you can further set data breakpoints by writing breakpoint parameter types, and you can also set data breakpoints by writing breakpoint parameter ranges.

It should be understood that the communication system of the embodiment of the present invention may specifically be a Linux arm system, or a Unix ARM system, or may be a Linux X86 system, a Unix-like system such as Solaris, aix, or the like. For example, in the Linux arm system, the CPU includes at least one arm architecture, and the CPU runs on the CPU. The Linux operating system runs at least one exception handler (the specific function is the same as above, so it will not be described again). . The communication system provided by the embodiment of the present invention returns to the source program to execute the next instruction of the instruction that triggers the exception processing program after executing the instruction that triggers the exception processing program in the exception processing program, or cancels the trigger exception processing in the exception handling program. The data breakpoint of the program, and saves the next instruction of the instruction that triggered the exception handler and sets the next instruction as an illegal instruction, thereby achieving the effect of implementing the breakpoint of the traversing data, and does not trigger the trap exception handler again. , causing a loop trigger, and the data breakpoint can be reused.

The communication system provided by the embodiment of the present invention may include a CPU, that is, a single CPU communication system, and may also include multiple CPUs, that is, a multi-CPU (multi-core) communication system. That is, the communication system of the embodiment of the present invention includes at least one CPU and an internal memory, and the operating system runs on the CPU, and at least one application (also referred to as software) runs on the operating system for executing a specific a task, the application includes a source program and at least one exception handler associated therewith, where: the active program and the exception handler are loaded in the memory, and at least one data is set in the source program a breakpoint, triggering an exception handler when the source program runs to an instruction having a data breakpoint, the exception handler is further configured to cancel when the source program runs to an instruction set with a data breakpoint The data breakpoint; backing up the next instruction of the instruction with the data breakpoint as the backup instruction; modifying the next instruction of the instruction with the data breakpoint as an illegal instruction; performing the setting with the data a breakpoint instruction and the modified next instruction; restoring the data breakpoint at the instruction with the data breakpoint set; Modifying the next instruction after said restore the backup instruction.

It should be understood that the communication system of the embodiment of the present invention may specifically be a Linux arm system, or a Unix ARM system, or a Linux X86 system, a Unix system such as Solaris, aix, or the like. For example, in the Linux arm system, the CPU includes at least one arm architecture, and the CPU runs on the CPU. The Linux operating system runs at least one exception handler (the specific function is the same as above, so it will not be described again). .

The communication system provided by the embodiment of the present invention returns to the source program to execute the next instruction of the instruction that triggers the exception processing program after executing the instruction that triggers the exception processing program in the exception processing program, or cancels the trigger exception processing in the exception handling program. The data breakpoint of the program, and saves the next instruction of the instruction that triggered the exception handler and sets the next instruction as an illegal instruction, thereby achieving the effect of implementing the breakpoint of the traversing data, and does not trigger the trap exception handler again. , causing a loop trigger, and the data breakpoint can be reused.

An apparatus for implementing a transitive data breakpoint according to an embodiment of the present invention is applied to a Linux ARM or Unix ARM system running an active program, wherein at least one data breakpoint is set in the source program, as shown in FIG. , the device 50 includes:

The first canceling module 501 is configured to cancel the data breakpoint when the source program runs to an instruction set with a data breakpoint. The decoding module 502 is configured to decode the instruction with the data breakpoint set.

The first execution module 503 is configured to execute the decoded instruction.

The setting module 504 is configured to re-set a data breakpoint at the instruction with the data breakpoint set. The pointing module 505 is configured to point the program counter PC pointer to the next instruction of the instruction set with the data breakpoint, wherein the program counter PC pointer is used to store the address of the next instruction to be executed.

The device for implementing the transitive data breakpoint provided by the embodiment of the present invention returns to the source program to execute the next instruction of the instruction that triggers the exception handler by executing the instruction that triggers the exception handler in the exception handler, thereby achieving The effect of passing data breakpoints is achieved, and the data breakpoints can be reused. Preferably, as shown in FIG. 6, the device for traversing data breakpoints 50 further includes: a create file module 506, configured to create at least one data breakpoint file.

The write module 507 is configured to write a breakpoint address that the user needs to monitor into the data breakpoint file.

The setting module 508 is configured to set a data breakpoint in the source program according to a breakpoint address in the data breakpoint file.

Specifically, the write module 507 writes a breakpoint address to be monitored in the data breakpoint file, and the setting module 508 sets a data breakpoint in the source program according to the breakpoint address in the data breakpoint file, and the same. The write module 507 can also write the breakpoint parameter that the user needs to monitor into the data breakpoint file; the setting module 508 searches the preset symbol table according to the breakpoint parameter to find the corresponding breakpoint address, And setting a data breakpoint in the source program according to the breakpoint address.

In this way, the data breakpoint can be set at the corresponding position in the source program by writing the breakpoint value or address to be monitored in the data breakpoint file, which is convenient for the user to use. Further, the writing module 507 can also write the breakpoint parameter that the user needs to monitor and the type of the breakpoint parameter to be monitored into the data breakpoint file; the setting module 508 according to the breakpoint parameter and the breakpoint The type of the parameter finds the corresponding breakpoint address, and sets a data breakpoint in the source program according to the breakpoint address. The type of the breakpoint parameter is: a readable type, a writable type, and a readable and writable type. In this way, not only can you write the breakpoint parameter to be monitored in the data breakpoint file, but you can also set the data breakpoint at the corresponding position of the source program by writing the type of the breakpoint parameter to be monitored in the data breakpoint file. , further convenient for users to use. It should be noted that, according to the breakpoint parameter and the type of the breakpoint parameter, the corresponding breakpoint address is searched, and the corresponding breakpoint address can be found in the corresponding table. The process is prior art, and is no longer here. Narration.

Exemplarily, the table may be a symbol table stored in an operating system. When the data breakpoint file writes a type of a breakpoint parameter and a breakpoint parameter, the data breakpoint file is found in the symbol table to match the break. The breakpoint address of the breakpoint parameter of the point parameter type, and the data breakpoint is set in the source program according to the breakpoint address.

Further, the writing module 507 can also write the breakpoint parameter that the user needs to monitor and the range of the breakpoint parameter to be monitored into the data breakpoint file; the setting module 508 according to the breakpoint parameter and the break The range of point parameters finds the corresponding breakpoint address, and a data breakpoint is set in the source program according to the breakpoint address. In this way, not only can you write the breakpoint parameter to be monitored in the data breakpoint file, but also set the data at the corresponding position of the source program by writing the range of the breakpoint parameter to be monitored in the data breakpoint file. Breakpoints further facilitate the use of the user.

It should be noted that when the data breakpoint file only writes the breakpoint parameter of the above content, the breakpoint address, the type of the breakpoint parameter, and any one or more of the breakpoint parameter ranges, the others are default values, obviously This makes it more flexible to set data breakpoints in the source program through the data breakpoint file.

An apparatus for implementing a transitive data breakpoint is provided in a Linux ARM or Unix ARM system running an active program, wherein at least one data breakpoint is set in the source program, the device 70, such as As shown in Figure 7, it includes:

a second canceling module 701, configured to cancel the data breakpoint when the source program runs to an instruction set with a data breakpoint; and the backup module 702 is configured to back up the instruction that is set with a data breakpoint An instruction as a backup instruction; a modification module 703, configured to repair the next instruction of the instruction with the data breakpoint Changed to an illegal order;

a second execution module 704, configured to execute the instruction with a data breakpoint and the modified next instruction; and the recovery module 705 is configured to restore a data breakpoint at the instruction with the data breakpoint set; The replacement module 706 is configured to restore the modified next instruction to the backup instruction.

The device for implementing the transitive data breakpoint provided by the embodiment of the present invention cancels the data breakpoint of the trigger exception handler in the exception handler, saves the next instruction of the instruction that triggers the exception handler, and sets the next one. The instruction is an illegal instruction. When the source program runs to the next instruction of the instruction that triggered the exception handler, an illegal exception handler is triggered. In the illegal exception handler, the previous data breakpoint is restored and the saved instruction is replaced. This instruction, in this way, achieves the effect of implementing a transitive data breakpoint when the source program runs to the data breakpoint, and can also reuse the data breakpoint.

Preferably, the device 70 for passing data breakpoints further comprises:

Create a file module 707 for creating at least one data breakpoint file. The write module 708 is configured to write a breakpoint address that the user needs to monitor into the data breakpoint file.

The setting module 709 is configured to set a data breakpoint in the source program according to a breakpoint address in the data breakpoint file. Specifically, the created file module 707 provided by the preferred content is created by the file module 506 as shown in FIG. 6, the writing module 708 is written by the writing module 507, and the setting module 709 is set by the setting module 508. .

Specifically, the writing module 708 can write a breakpoint address to be monitored in the data breakpoint file, and the setting module 709 sets a data breakpoint in the source program according to the breakpoint address in the data breakpoint file. Similarly, the write module 708 can also write the breakpoint parameter that the user needs to monitor into the data breakpoint file; the setting module 709 searches the preset symbol table according to the breakpoint parameter to find the corresponding breakpoint address. And set a data breakpoint in the source program according to the breakpoint address.

In this way, you can write the breakpoint value or address to be monitored in the data breakpoint file. It is convenient for the user to set the data breakpoint at the corresponding position in the source program. Further, the writing module 708 can also write the breakpoint parameter that the user needs to monitor and the type of the breakpoint parameter to be monitored into the data breakpoint file; the setting module 709 is configured according to the breakpoint parameter and the breakpoint The type of the parameter finds the corresponding breakpoint address, and sets a data breakpoint in the source program according to the breakpoint address. The type of the breakpoint parameter is: a readable type, a writable type, and a readable and writable type. In this way, not only can you write the breakpoint parameter to be monitored in the data breakpoint file, but you can also set the data breakpoint at the corresponding position of the source program by writing the type of the breakpoint parameter to be monitored in the data breakpoint file. , further convenient for users to use.

It should be noted that, according to the breakpoint parameter and the type of the breakpoint parameter, the corresponding breakpoint address is searched, and the corresponding breakpoint address can be found in the corresponding table. The process is prior art, and is no longer here. Narration. Exemplarily, the table may be a symbol table stored in an operating system. When the data breakpoint file writes a type of a breakpoint parameter and a breakpoint parameter, the data breakpoint file is found in the symbol table to match the break. The breakpoint address of the breakpoint parameter of the point parameter type, and the data breakpoint is set in the source program according to the breakpoint address.

Further, the writing module 708 can also write the breakpoint parameter that the user needs to monitor and the range of the breakpoint parameter to be monitored into the data breakpoint file; the setting module 709 according to the breakpoint parameter and the break The range of point parameters finds the corresponding breakpoint address, and a data breakpoint is set in the source program according to the breakpoint address. In this way, not only can you write the breakpoint parameter to be monitored in the data breakpoint file, but also set the data at the corresponding position of the source program by writing the range of the breakpoint parameter to be monitored in the data breakpoint file. Breakpoints further facilitate the use of the user.

It should be noted that when the data breakpoint file only writes the breakpoint parameter of the above content, the breakpoint address, the type of the breakpoint parameter, and any one or more of the breakpoint parameter ranges, the others are default values, obviously This makes it more flexible to set data breakpoints in the source program through the data breakpoint file. The above is only the specific embodiment of the present invention, but the scope of the present invention is not limited thereto, and any person skilled in the art can easily think of changes or substitutions within the technical scope of the present invention. It should be covered by the scope of the present invention. Therefore, the scope of the invention should be determined by the scope of the appended claims.

Claims

Claim

A method for implementing a transitive data breakpoint, which is applied to a Linux ARM or Unix ARM system running an active program, wherein the source program is provided with at least one data breakpoint; wherein the method comprises:

Decoding the instruction with the data breakpoint set;

Executing the decoded instruction;

Resetting the data breakpoint at the instruction with the data breakpoint set;

The program counter PC pointer is directed to the next instruction of the instruction set with a data breakpoint, wherein the program counter PC pointer is used to store the address of the next instruction to be executed.

2. The method of claim 1, further comprising:

At least one data breakpoint file is created, the data breakpoint file being used to record information about the breakpoint to be monitored.

3. The method according to claim 2, further comprising:

Write a breakpoint address that the user needs to monitor into the data breakpoint file;

A data breakpoint is set in the source program based on a breakpoint address in the data breakpoint file.

4. The method according to claim 2, further comprising:

Write a breakpoint parameter that the user needs to monitor into the data breakpoint file;

And searching for a corresponding breakpoint address according to the breakpoint parameter to a preset symbol table, and setting a data breakpoint in the source program according to the breakpoint address.

5. The method of claim 2, further comprising:

Write the breakpoint parameter that the user needs to monitor and the type of the breakpoint parameter to be monitored into the data breakpoint file;

Finding a corresponding breakpoint address according to the breakpoint parameter and the type of the breakpoint parameter, and setting a data breakpoint in the source program according to the breakpoint address.

6. The method according to claim 2, further comprising:

Write the breakpoint parameter that the user needs to monitor and the range of the breakpoint parameter to be monitored into the data breakpoint file;

And searching for a corresponding breakpoint address according to the range of the breakpoint parameter and the breakpoint parameter, and setting a data breakpoint in the source program according to the breakpoint address.

A method for implementing a transitive data breakpoint, which is applied to a Linux ARM or Unix ARM system running an active program; the source program is provided with at least one data breakpoint; and the method includes:

The modified next instruction is restored to the backup instruction.

The method for implementing a transitive data breakpoint according to claim 7, further comprising:

The method for implementing a transitive data breakpoint according to claim 8, further comprising:

Write the breakpoint parameters that the user needs to monitor and the range of breakpoint parameters to be monitored. Data breakpoint file;

13. A communication system, the communication system comprising a memory and at least one CPU;

An operating system is run in the CPU, and at least one sequence is run on the operating system; the source program and the exception handling program are loaded in the memory, and at least one of the source programs is set a data breakpoint, the exception handler is triggered when the source program runs to an instruction having a data breakpoint, wherein the exception handler is further configured to:

Decoding the instruction with the data breakpoint set;

Executing the decoded instruction;

Resetting the data breakpoint at the instruction with the data breakpoint set;

14. The communication system according to claim 13, wherein the exception handling program is further configured to:

Creating at least one data breakpoint file; writing a breakpoint address that the user needs to monitor into the data breakpoint file;

15. A communication system, characterized in that said communication system comprises a memory and at least one

CPU;

An operating system is run in the CPU, and at least one sequence is run on the operating system; the source program and the exception handling program are loaded in the memory, and at least one of the source programs is set a data breakpoint, triggering an exception handler when the source program runs to an instruction having a data breakpoint, wherein the exception handler is further configured to:

Deactivating the data breakpoint when the source program runs to an instruction set with a data breakpoint; Backing up the next instruction of the instruction with the data breakpoint as the backup instruction; modifying the next instruction of the instruction with the data breakpoint as an illegal instruction; executing the instruction and the data breakpoint setting Describe the modified next instruction; recover the data breakpoint at the instruction with the data breakpoint set;

The modified next instruction is restored to the backup instruction.

The communication system according to claim 15, wherein said exception handling program is further configured to:

17. A device for implementing a transitive data breakpoint, in a Linux ARM or Unix ARM system running an active program, wherein the source program is provided with at least one data breakpoint, wherein the transitive data Breakpoint devices include:

a first canceling module, configured to cancel the data breakpoint when the source program runs to an instruction set with a data breakpoint;

a decoding module, configured to decode the instruction with a data breakpoint set;

a first execution module, configured to execute the decoded instruction;

a setting module, configured to re-set a data breakpoint at the instruction with the data breakpoint set; a pointing module, configured to point the program counter PC pointer to the next instruction of the instruction with the data breakpoint set, where The program counter PC pointer is used to store the address of the next instruction to be executed.

The device for implementing a transitive data breakpoint according to claim 17, wherein the means for implementing the transitive data breakpoint further comprises:

Creating a file module for creating at least one data breakpoint file;

a write module, configured to write a breakpoint address that the user needs to monitor into the data breakpoint file;

And a setting module, configured to set a data breakpoint in the source program according to a breakpoint address in the data breakpoint file.

19. A device for implementing a transitive data breakpoint, applied to a Linux ARM or Unix ARM system running an active program; wherein the source program is provided with at least one data breakpoint, wherein the transitive data Breakpoint devices include:

a second canceling module, configured to: when the source program runs to an instruction set with a data breakpoint When the data breakpoint is canceled;

a backup module, configured to back up the next instruction of the instruction with a data breakpoint as a backup instruction;

a modifying module, configured to modify the next instruction of the instruction with the data breakpoint to be an illegal instruction;

a second execution module, configured to execute the instruction with a data breakpoint and the modified next instruction;

And a recovery module, configured to restore the data breakpoint at the instruction with the data breakpoint set; and a replacement module, configured to restore the modified next instruction to the backup instruction.

The device for implementing a transitive data breakpoint according to claim 19, wherein the means for implementing the transitive data breakpoint further comprises:

Creating a file module for creating at least one data breakpoint file;