JP2001325122A - Debugging system and its method - Google Patents

Abstract

PROBLEM TO BE SOLVED: To set up a brake point in a performance code to be performed in a kernel mode. SOLUTION: A brake point setting part 110 rewrites an address instruction for setting up a brake point by an exceptional processing instruction in order to set up the brake point in a performance code to be performed in the kernel mode included in a process 10 to be debugged which has a performance code to be performed in a user mode and the performance mode to be performed in the kernel mode. A debugger 20 starts the performance of the process 10, and when the process 10 arrives at the exceptional processing instruction of the set brake point, allows a brake point exceptional processing part 112 to interrupt the performance of the process 10 and debugs the performance code included in the process 10.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

The present invention relates to a debugging method and a debugging method for software in a computer system, and more particularly, to a debugging method and a debugging method for an operating system operating in a kernel mode.

[0002]

2. Description of the Related Art On an operating system (OS), a plurality of processes, which are execution units of a program, exist, and operate in parallel by time division. The application process normally operates in the user mode. When the application process calls a function of the OS, it issues a system call, changes the operation mode to the kernel mode, and executes the code in the OS. In the kernel mode, it is possible to access all data in the OS commonly used between processes.

Conventionally, as a debugging method in the kernel mode, there has been a method using a kernel debugger. The kernel debugger is a debugging function incorporated in the OS, and can perform execution control by breakpoints and reference data in the kernel. When the kernel debugger is started, the operation of the OS other than the kernel debugger is stopped, so that all execution of the processes on the OS is also stopped.

[0004] As a debugging method in the kernel mode, as described in Japanese Patent Application Laid-Open No. H8-6819, a code originally operating in the kernel mode is operated in a user process, and an OS environment is simulated therein. There was also a debugging method.

[0005]

In the above-described method using the kernel debugger, the execution of all processes on the OS is stopped, so that debugging cannot be performed in the operating state (on-line state) of the system.

In the above-described method of simulating the operation in the kernel mode and the environment of the OS by the user process, it is possible to debug a part of the functions of the OS such as a device driver. You could not debug any features.

[0007] Furthermore, there is a problem in the process of debugging in the OS that a process switching prohibition state exists. In order to maintain the consistency of the inter-process common data, there is a portion in the OS where one process must be continuously executed, and the process switching is prohibited while the code of this portion is being executed. Since the execution of the process cannot be interrupted even at the time of debugging, the debugging efficiency is reduced.

SUMMARY OF THE INVENTION The present invention has been made to solve the above problems, and enables online debugging of code in an OS executed in a kernel mode by issuing a system call from a process. The purpose is to do.

Another object of the present invention is to improve debugging efficiency when debugging in a process switching prohibited state.

[0010]

SUMMARY OF THE INVENTION A debugging method according to the present invention is a debugging method for a process in which an instruction is executed in an operating system having two operation modes of a user mode and a kernel mode. A breakpoint setting unit for setting a breakpoint in the execution code executed in the kernel mode included in the debug target process having the code and the execution mode executed in the kernel mode; and causing the debug target process to start executing When the debug target process reaches a break point in the execution code set by the break point setting unit, the execution of the debug target process is interrupted, and the execution code included in the debug target process is executed in kernel mode. Debug Characterized in that a debugger that.

[0011] The breakpoint setting unit is provided from the debugger to identify a debug target process including an execution code for setting a breakpoint, and a breakpoint setting address indicating an address of the execution code for setting a breakpoint. Is notified as a breakpoint setting instruction, and a breakpoint is set based on the notified breakpoint setting instruction.

The debugging method further includes a breakpoint recording section for recording the breakpoint setting address, the debugger process identifier, and a debugger identifier for identifying a debugger that has notified the breakpoint setting instruction. When the debug target process reaches the break point indicated by the break point setting address, the debug target process being executed is the same as the debug target process identified by the debug target process identifier recorded in the break point recording unit. If the result of the determination is that the process is the same as the debug target process, the control to execute the debug target process is shifted to the debugger identified by the debugger identifier recorded in the breakpoint recording unit. And a process control unit for interrupting a running debug target process and transferring control to execute the debug target process to the debugger in accordance with an instruction from the break point exception processing unit. It is characterized by the following.

The debugging system further includes a system state determining unit for determining whether or not the process can be switched. The breakpoint exception processing unit stores a breakpoint indicated by a breakpoint setting address recorded in the breakpoint recording unit. As the first breakpoint,
When instructing the process control unit to shift the control to execute the process to be debugged to the debugger, when the system state determination unit determines whether the process can be switched, and when it is determined that the process cannot be switched,
In the execution code executed in the kernel mode, search for a portion where the process can be switched next, set a second breakpoint to the searched address where the process can be switched next, and perform the second break. When the point is reached, the process control unit is instructed to shift the control for executing the debug target process to the debugger.

The above-mentioned debugging method further comprises a process status recording unit for recording the status of the process to be debugged being executed in the kernel mode as a process status. When you reach the first breakpoint,
If the system state determination unit determines that the process cannot be switched, the process state when the breakpoint is reached is recorded in the process state recording unit,
The debugger acquires the process status recorded in the process status recording unit when the control for executing the debugged process is transferred to itself.

In the above-mentioned debugging method, a memory change monitoring unit which is notified of a memory area to be monitored in advance from a debugger and stores a range of the notified memory area,
A memory change recording unit that records, when the content of the memory area stored by the memory change monitoring unit is changed, an instruction that changes the content of the memory area, wherein the breakpoint exception processing unit is executing When the debug target process reaches the first breakpoint,
If the system state determination unit determines that the process cannot be switched, the memory change monitoring unit executes instructions executed by the debug target process from the first breakpoint to the second breakpoint. The debugger records the instruction in which the content of the recorded memory area has been changed in the memory change recording unit. When the control to execute the debug target process is transferred to the debugger, the debugger records the memory recorded in the memory change recording unit. It is characterized by acquiring an instruction in which the contents of the area have been changed.

The debugging method further controls an execution history recording unit for recording an execution history of the execution of the instruction of the process to be debugged and a trace execution for recording an instruction for executing the process to be debugged in the execution history recording unit. A trace execution control unit to perform, the breakpoint exception processing unit, when the process to be debugged reaches the first breakpoint, when the system state determination unit determines that the process can not be switched And instructing the trace execution control unit to control the trace execution, and the debugger acquires the execution history recorded in the execution history recording unit when the control to execute the process to be debugged is transferred to itself. It is characterized by the following.

The breakpoint setting section rewrites an instruction at an address for setting a breakpoint to an exception processing instruction for generating a breakpoint.

The breakpoint setting section records the instruction at the address at which the breakpoint is set as a normal instruction in the breakpoint recording section, and converts the instruction at the address at which the breakpoint is set to an exception processing instruction for generating a breakpoint. Rewriting, if the breakpoint exception processing unit determines that the debug target process being executed is not the same as the debug target process identified by the debug target process identifier recorded in the breakpoint recording unit, the rewritten exception The processing instruction is rewritten to a normal instruction recorded in the breakpoint recording section.

A debugging method according to the present invention is a method for debugging a process in which an instruction is executed in an operating system having two operation modes of a user mode and a kernel mode. A breakpoint setting step of setting a breakpoint in an execution code executed in a kernel mode included in a debug target process having an execution mode to be executed; and a breakpoint setting step of starting execution of the debug target process. When the debuggee process reaches the breakpoint in the execution code set by the debugger, the execution of the debuggee process is interrupted, and the execution code included in the debuggee process is executed in the kernel mode for debugging. Characterized in that a degree.

The breakpoint setting step is characterized in that an instruction at an address for setting a breakpoint is rewritten to an exception processing instruction for generating a breakpoint.

[0021]

DESCRIPTION OF THE PREFERRED EMBODIMENTS Embodiment 1 FIG. 1 is a block diagram showing a first embodiment of the present invention. In the figure, reference numeral 10 denotes a process to be debugged, and 20 denotes a debugger. 100 is an operating system, and 50 is hardware. Reference numeral 101 denotes a system call interface, 102 denotes a file management subsystem, 103 denotes a memory management subsystem, and 104 denotes a device driver.

Reference numeral 106 denotes a process control unit, 110 denotes a breakpoint setting unit, 111 denotes a breakpoint recording unit,
Reference numeral 112 denotes a breakpoint exception processing unit. FIG.
4 shows an example of the structure of the breakpoint recording section 111.

The debugger 20 issues a breakpoint setting instruction including a breakpoint setting address in the kernel mode operation code and an identifier of a process to be debugged to the breakpoint setting unit 110 via the system call interface 101.

The breakpoint setting section 110 starts operating when a breakpoint setting instruction is received from the debugger 20. Hereinafter, the operation of the breakpoint setting unit 110 will be described with reference to FIG.

The break point setting unit 110 determines in S10
In step 1, the breakpoint setting address and the identifier of the process to be debugged are recorded in the breakpoint recording unit 111. In step S102, the debugger identifier is recorded in the breakpoint recording unit 111.

In step S103, the instruction code at the specified address is stored in the breakpoint recording unit 111 in order to generate a breakpoint exception due to the execution of the specified address. Perform the rewriting process.

The debugger 20 executes the process 1 to be debugged.
0 operation is started. In user mode, multiple processes are running in parallel in a time-sharing manner, so any process may issue a system call to execute code in the kernel and reach a set breakpoint .

The operation of the breakpoint exception processing unit 112 when a breakpoint exception generating instruction in the kernel code is executed and a breakpoint exception occurs will be described below with reference to FIG.

When a breakpoint exception occurs, the processing of the breakpoint exception processing unit 112 starts. In step S111, the breakpoint exception processing unit 112 checks whether the address where the exception has occurred is recorded in the breakpoint recording unit 111. If not recorded (S1
In step S116, the process is executed as an illegal instruction, and the process ends.

If the address at which the exception has occurred is recorded in the breakpoint recording unit 111 (Y in S111), in S112, the identifier of the currently executed process, that is, the process that caused the exception, is stored in the breakpoint recording unit 111. It is checked whether it matches the identifier of the process to be debugged recorded in (S112).

If the identifier of the currently executed process does not match the recorded one (N in S112), since the breakpoint has been reached by the execution of a process other than the debug target, the execution continuation process is performed in S113. finish. The operation of the execution continuation process in S113 will be described.

First, in the execution continuation processing of S113, the original instruction code of the current breakpoint setting address stored in the breakpoint recording unit 111 is written to the current breakpoint setting address, and Restore instructions. Subsequently, the restored instruction is executed in the single-step mode, and when the execution of the single-step mode is completed, the breakpoint exception generating instruction is written again at the breakpoint setting address.

At this time, since the original instruction code of the break point setting address has already been stored in the break point recording unit 111, it is not necessary to store it again.
When the restoration of the breakpoint exception generating instruction is completed, normal instruction execution is resumed from the instruction address executed next to the breakpoint setting address, and the execution of the debug target process 10 is continued.

If the identifier of the currently executed process matches the recorded one (Y in S112), it means that the breakpoint has been reached by the execution of the process to be debugged. Instructs the execution of the line process to be interrupted. S115
Then, the process control unit 106 is determined by the process identifier of the debugger recorded in the breakpoint recording unit 111.
Instructs the debugger to transfer control.

As a result, the process to be debugged is suspended at the breakpoint setting address in the kernel code, and the debugger can check the status of the process to be debugged.

On the other hand, processes other than those to be debugged continue even after the execution of the breakpoint setting address, so that the operation of the entire system is not affected.

According to the debugging method of the first embodiment, only the execution of the code in the OS executed in the kernel mode by the process to be debugged is controlled.
Debugging can be performed online without affecting the operation of other processes.

As described above, the debugging method and the debugging method according to the present embodiment can be applied to a debug target process 10 including a transition from a user mode to a kernel mode in an operating system having two operation modes of a user mode and a kernel mode. A debugging method and method for debugging the kernel mode operation from the debugger 20, wherein the breakpoint setting unit 110 sets a breakpoint in the execution code in the kernel mode.
(Breakpoint setting step), and a breakpoint recording unit 111 that records the set breakpoint, the identifier of the process to be debugged, and the identifier of the debugger. When the debug target process 10 reaches a breakpoint, execution of the debug target process 10 is interrupted, and execution is transferred to the debugger 20.

Embodiment 2 FIG. 5 is a block diagram showing a second embodiment of the present invention. In the reference numerals in the figure, reference numeral 201 denotes a system state determination unit that determines whether the process can be switched. The components of the reference numerals other than the above are:
This is the same as in the first embodiment. FIG. 6 shows a configuration of the breakpoint recording unit 111 according to the present embodiment.

The operation of the breakpoint setting section 110 according to the second embodiment of the present invention is the same as that of the first embodiment described with reference to FIG.

A breakpoint exception generating instruction in the kernel code is executed by the process, and a breakpoint exception processing unit 1 when a breakpoint exception occurs.
Operation 12 will be described with reference to FIG.

The breakpoint exception handling unit 112
In step 211, it is checked whether the address where the exception has occurred is recorded in the breakpoint recording unit 111. If it is not recorded (N in S211), a process for executing an illegal command is performed in S220, and the process ends.

If the address at which the exception has occurred is recorded in the breakpoint recording unit 111 (Y in S211), in S212, the identifier of the currently executed process, that is, the process that caused the exception, is stored in the breakpoint recording unit 111. (S212).

If the identifier of the currently executed process does not match the recorded one (N in S212), since the breakpoint has been reached by the execution of the process other than the debug target, the execution continuation process is performed in S213. finish. The execution continuation process is the same as that described in S113.

If the identifier of the currently executed process matches the recorded one (Y in S212), the system status determining unit 201 is referred to in S214 to determine whether the system is in a process switchable state (S214). .

If the process switching is prohibited (N in S214), an alternative breakpoint setting process is performed in S215. In the alternative breakpoint setting process, for the unused entries in the breakpoint recording unit 111, the end address of the system state change process is recorded as the breakpoint setting address, and the identifier of the currently executed process is recorded as the identifier of the process to be debugged. I do.

Subsequently, a pointer to the entry in the breakpoint recording unit 111 where the current breakpoint is recorded is recorded as original breakpoint information, and the debugger identifier recorded in the entry corresponding to the current breakpoint is recorded. To the entry corresponding to the alternate breakpoint. Further, after storing the instruction code of the end address of the system state change processing in the breakpoint recording unit 111, the instruction code of the end address of the system state change processing is rewritten to a breakpoint exception occurrence instruction.

Here, the system state change process is a process for setting whether or not process switching commonly used in the OS can be performed, and is always executed when shifting from the process switching disabled state to the process switchable state. It is. The end address of the system state change process is (second
The breakpoint setting address and the identifier of the currently executed process correspond to the debug target process identifier.

After the alternative break point setting processing, S21
In step 3, the execution continuation process is performed, and the debug target process 10 continues execution.

If it is determined in S214 that the process can be switched (Y in S214), then
In step S216, it is determined whether the current breakpoint is an alternative breakpoint by referring to the breakpoint recording unit 111. If it is determined that the break point is an alternative break point (Y in S216), a process of deleting an alternative break point is performed in S217.

In the process of deleting the substitute break point, the instruction recorded in the instruction storage area is written back to the address recorded at the break point setting address in the break point recording unit 111. Subsequently, the breakpoint recording unit 11 indicated by the original breakpoint information
After obtaining the entry in 1, delete the record for the alternate breakpoint.

If it is determined in S216 that the current breakpoint is not an alternative breakpoint (N in S216), or after completion of the alternative breakpoint deletion processing in S217, the process control unit 106 is instructed in S218.
Instructs execution of the current execution process to be interrupted. Then, in step S219, the process control unit 106 is instructed to transfer control to the debugger 20 using the debugger process identifier recorded in the breakpoint recording unit 111.

According to the debugging method of the second embodiment, even when the system is in the process switching prohibited state at the time when the set breakpoint is reached, the system state always executed when the process switching is enabled. By setting an alternative breakpoint at the end address of the change process, the execution of the process to be debugged can be interrupted as soon as possible to perform debugging, and the debugging efficiency can be improved.

As described above, the debugging method and the debugging method according to this embodiment further include the system state determination unit 201 for determining whether or not the process can be switched, and the first instruction break in the execution code in the kernel mode. If the process cannot be switched when the point is reached, a second breakpoint is set at a location in the executable code in the kernel mode where the process can be switched, and the execution of the debug target process 10 is performed when the second breakpoint is reached. It is characterized in that the execution is interrupted and the execution is transferred to the debugger 20.

Embodiment 3 FIG. 8 is a block diagram showing a third embodiment of the present invention. In the figure, reference numeral 301 denotes a process state recording unit that records process information such as the contents of a processor register when a kernel breakpoint is set, that is, when a debug exception occurs. The components other than those described above are the same as those in the first and second embodiments.

The operation of the breakpoint setting unit 110 according to the third embodiment of the present invention is the same as that of the first embodiment described with reference to FIG.

A breakpoint exception generating instruction in the kernel code is executed by the process, and a breakpoint exception processing unit 1 when a breakpoint exception occurs.
Operation 12 will be described with reference to FIG.

The breakpoint exception handling unit 112
In 311, it is checked whether the address where the exception has occurred is recorded in the breakpoint recording unit 111. If it is not recorded (N in S311), a process for executing an illegal command is performed in S320, and the process ends.

If the address where the exception has occurred is recorded in the breakpoint recording unit 111 (Y in S311), in S312, the identifier of the currently executed process, that is, the process that caused the exception, is stored in the breakpoint recording unit 111. (S312).

If the identifier of the currently executed process does not match the recorded one (N in S312), since the breakpoint has been reached by the execution of a process other than the debug target, execution continuation processing is performed in S313. finish.

If the identifier of the currently executed process matches the recorded one (Y in S312), the system status determination unit is referred to in S314 to determine whether the system is in a process switchable state.

If the process switching is prohibited (N in S314), in S320, the process information such as the contents of the processor register at the time of setting the kernel breakpoint, that is, when a debug exception occurs, is stored in the process information recording unit. Record in 301. Then, S
At 315, an alternative breakpoint setting process is performed, and at S31
In step 3, the execution continuation process is performed, and the debug target process 10 continues execution. The alternative breakpoint setting process is as described in the second embodiment.

If it is determined in S314 that the process can be switched (Y in S314), the processes from S316 to S319 are performed in S216 in the second embodiment.
To S219.

When the process 10 to be debugged enters a process switchable state and reaches an alternative breakpoint, control is transferred to the debugger. The debugger 20 reads the process state such as the contents of the processor register at the original breakpoint setting location from the process state recording unit 301 via the system call interface.

According to the debugging method of the third embodiment, even if the system is in the process switching prohibition state at the time when the set breakpoint is reached, the process information at that time is recorded. After the process can be switched, the status of the process to be debugged at the time of setting the original breakpoint can be known from the debugger, and more effective debugging can be performed.

As described above, the debugging method and the debugging method according to the present embodiment further include the process state storage unit 301 for recording the process state in the kernel mode, and the first state in the execution code in the kernel mode. If it is not possible to switch the process when the breakpoint is reached, the state of the process to be debugged when the first breakpoint is reached is recorded, and the second breakpoint is set at a location in the executable code in the kernel mode where the process can be switched. Is set, the execution of the process to be debugged is interrupted when the second breakpoint is reached, execution is transferred to the debugger,
The debugger acquires the process state.

Embodiment 4 FIG. 10 is a block diagram showing a fourth embodiment of the present invention. In the reference numerals in the figure, 401 is a memory change recording unit, and 402 is a memory change monitoring unit. The components other than those described above are the same as those in the second embodiment.

The operation of break point setting section 110 according to the second embodiment of the present invention is the same as that of the first embodiment.

The debugger 20 executes the process 1 to be debugged.
The memory change monitoring unit 402 designates an address to be monitored for a memory change due to 0 through the system call interface.
Set to.

The operation of the breakpoint exception processing unit 112 when the breakpoint exception generating instruction in the kernel code is executed by the debugger 20 and a breakpoint exception occurs will be described with reference to FIG.

The breakpoint exception processing unit 112
At 411, it is checked whether the address where the exception has occurred is recorded in the breakpoint recording unit 111. If it is not recorded (N in S411), a process for executing an invalid instruction is performed in S421, and the process ends.

If the address at which the exception has occurred is recorded in the breakpoint recording unit 111 (Y in S411), in S412, the identifier of the currently executed process, that is, the process that caused the exception, is stored in the breakpoint recording unit 111. Check that it matches the identifier of the process to be debugged recorded in.

If the identifier of the currently executed process does not match the recorded one (N in S412), since the breakpoint has been reached by the execution of a process other than the debug target, the execution continuation process is performed in S413. finish.

When the identifier of the currently executed process matches the recorded one (Y in S412), the system status determination unit 201 is referred to in S414 to determine whether the system is in a process switchable state.

When the process switching is prohibited (N in S414), the memory change monitoring unit 402 is instructed to perform memory monitoring setting in S415.
The memory change monitoring unit 402 writes a monitoring target memory address set in advance by the debugger 20 into a watchpoint (data breakpoint) register provided in the processor, and generates a debug exception by writing to the set address. Set.

Subsequently, an alternative breakpoint setting process is performed in S416, an execution continuation process is performed in S413, and the process to be debugged continues execution.

Here, if the debugged process 10 whose execution has been continued writes to the address for which the memory change monitoring setting has been made until the alternative breakpoint is reached, a debug exception of the processor occurs. appear. When a debug exception occurs, the memory change monitoring unit 4
02 records the instruction that caused the exception and the data written at the monitoring target address in the memory change recording unit 401, and returns from the debug exception.

If it is determined in S414 that the process can be switched (Y in S414), the process proceeds to S4.
At 17, the breakpoint recording unit 111 is referenced to determine whether the current breakpoint is an alternative breakpoint. If an alternative breakpoint is determined,
In step S418, the release of the memory monitoring is notified by the memory change monitoring unit 402.
Then, in step S419, a process of deleting an alternative breakpoint is performed.

If it is determined in S 417 that the current break point is not an alternative break point (N in S 417), or after the alternative break point deletion processing is completed in S 419, the process control unit 106 is notified to the process control unit 106 in S 420. To stop the execution of. Next, in step S421, the process control unit 106 is instructed to transfer control to the debugger 20 based on the process identifier of the debugger 20 recorded in the breakpoint recording unit 111.

When the process 10 to be debugged enters a process switchable state and reaches an alternative breakpoint, the control is transferred to the debugger 20. The debugger 20 reads the record of the change for the specified memory address from the memory change recording unit 401 via the system call interface.

According to the debugging method of the fourth embodiment, even when the system is in the process switching prohibition state at the time when the set breakpoint is reached, the designated system is not changed until the process switching becomes possible. Since the location where the change is made to the memory address is recorded and the record of the memory change can be read from the debugger 20 after the process can be switched, the debugging efficiency can be improved.

As described above, the debugging method and the debugging method according to the present embodiment further detect the memory change monitoring unit 402 which specifies a specific memory address from the debugger and the change in the content of the specified memory address. Means (data breakpoints), and a memory change recording unit 401 for recording an instruction for changing the memory contents.
If the process cannot be switched when the first breakpoint in the execution code in the kernel mode is reached, a second breakpoint is set in a location where the process can be switched in the execution code in the kernel mode, and the first breakpoint is set. When the content of the specified memory address is changed between the break point of the first time and the arrival of the second break point, the instruction whose memory content has been changed is recorded, and when the second break point is reached, the debug target process 10 Is interrupted, execution is transferred to the debugger 20, and the debugger 20 is executed.
Is characterized in that a memory content change command recorded in the memory change recording unit 401 is acquired.

Embodiment 5 FIG. 12 is a block diagram showing a fifth embodiment of the present invention. In the reference numerals in the drawing, reference numeral 501 denotes an execution history recording unit that records a register changed by execution of an instruction, and reference numeral 502 denotes a trace that sets a trace execution mode in which a process is executed while tracing a process when process switching is prohibited. An execution control unit. Components other than those described above are the same as those in the second embodiment.
Is the same as

The operation of breakpoint setting section 110 according to the second embodiment of the present invention is the same as that of the first embodiment.

The operation of the breakpoint exception processing unit 112 when the breakpoint exception generation instruction in the kernel code is executed by the debugger 20 and a breakpoint exception occurs will be described with reference to FIG.

The breakpoint exception processing unit 112
In 511, it is checked whether the address where the exception has occurred is recorded in the breakpoint recording unit 111. If it is not recorded (N in S511), a process for executing an illegal command is performed in S522, and the process ends.

If the address where the exception has occurred is recorded in the breakpoint recording unit 111 (Y in S511), in S512, the identifier of the currently executed process, that is, the process which caused the exception, is stored in the breakpoint recording unit 111. Check that it matches the identifier of the process to be debugged recorded in.

If the identifier of the currently executed process does not match the recorded one (N in S512), since the breakpoint has been reached by the execution of a process other than the debug target, the execution continuation process is performed in S513. finish.

When the identifier of the currently executed process matches the recorded one (Y in S512), the system status determination unit 201 is referred to in S514 to determine whether the system is in a process switchable state.

If the process switching is prohibited (N in S514), in S515, the trace execution control unit 502 is instructed to enter the trace execution mode. The trace execution control unit 502 sets a trace mode control flag of the processor. continue,
In S516, one instruction from the breakpoint setting position is executed, and in S517, the address of the executed instruction, the instruction code, and the register changed by the instruction execution are recorded in the execution history recording unit 501. The trace execution is repeated until it is determined in step S518 that the process can be switched. If it is determined in step S518 that the process can be switched, the trace mode setting is canceled in step S519.

When it is determined in S514 that the process can be switched (Y in S514), or after the process can be switched after the trace is executed, an instruction is given in S520 to interrupt the execution of the currently executed process. Subsequently, in step S521, the process control unit 106 is instructed to transfer control to the debugger 20 by using the process identifier of the debugger 20 recorded in the breakpoint recording unit 111.

The debugger 20 reads the execution history recorded from the time when the breakpoint is set to the time when the execution is interrupted from the execution history recording unit 501 via the system call interface.

According to the debugging method of the fifth embodiment, even if the system is in the process switching prohibition state at the time when the set breakpoint is reached, all the execution histories until the process switching state becomes possible. Is stored, and after the process can be switched, the execution history can be read from the debugger, and the operation of the process to be debugged can be known, so that efficient debugging can be performed.

As described above, the debugging method and the debugging method according to the present embodiment further include a system state determining unit 201 for determining whether or not the process can be switched, and a trace execution for controlling the trace execution for tracing and executing the process. A control unit 502 and an execution history recording unit 501 for recording an execution history of a process. When a process cannot be switched when a breakpoint in the execution code in the kernel mode is reached, the process in the execution code in the kernel mode is disabled. The execution history of the wrestling target wrestling until the switching becomes possible is recorded in the execution history recording unit 501, and when the process switching becomes possible, the execution of the debugging target process 10 is interrupted, and the execution is transferred to the debugger. The execution history is acquired from

[0095]

According to the breakpoint setting unit of the debugging method and the breakpoint setting step of the debugging method, a breakpoint can be set in the execution mode executed in the kernel mode, that is, the code in the OS. .

According to the break point setting unit of the debugging method and the break point setting step of the debugging method, it is possible to instruct the debugger to set a break point to the execution mode executed in the kernel mode.

According to the breakpoint exception handling unit of the debugging method, the execution of the process to be debugged can be controlled by the debugger when the process of the process to be debugged is executed. Can be performed.

According to the system state determination unit of the debugging method, it is possible to determine whether the process can be switched. If the process cannot be switched, the next breakpoint is set by the breakpoint exception processing unit. be able to.

According to the process status recording unit of the debugging system, when the process cannot be switched, the process status can be recorded.

According to the memory change recording unit and the memory change monitoring unit of the debugging system, when the process cannot be switched, it is possible to record the instruction in which the contents of the predetermined memory area have been changed.

According to the execution history recording unit of this debugging method, when the process cannot be switched, the history of executed instructions can be recorded.

According to the breakpoint setting unit of the debugging method and the breakpoint setting step of the debugging method, exception processing can be generated by rewriting the instruction for setting a breakpoint.

According to the breakpoint setting section of the debugging method and the breakpoint setting step of the debugging method, an exception process is generated by rewriting an instruction for setting a breakpoint, and a process which is not a process to be debugged is executed. , Normal processing can be executed.

[Brief description of the drawings]

FIG. 1 is a block diagram illustrating an example of a configuration of a debugging method according to a first embodiment.

FIG. 2 is a diagram illustrating an example of a breakpoint recording unit of a debugging method according to the first embodiment;

FIG. 3 is a flowchart showing an example of an operation (breakpoint setting step) of setting a breakpoint by a breakpoint setting unit of the debugging method.

FIG. 4 is a flowchart showing an example of an operation when the breakpoint exception handling unit of the debugging method according to the first embodiment debugs;

FIG. 5 is a block diagram illustrating an example of a configuration of a debugging method according to a second embodiment.

FIG. 6 is a diagram illustrating an example of a breakpoint recording unit using a debugging method according to the second to fifth embodiments.

FIG. 7 is a flowchart illustrating an example of an operation when a debugger breakpoint exception handling unit according to the second embodiment debugs;

FIG. 8 is a block diagram illustrating an example of a configuration of a debugging method according to a third embodiment.

FIG. 9 is a flowchart illustrating an example of an operation when a debugger breakpoint exception processing unit according to the third embodiment debugs;

FIG. 10 is a block diagram illustrating an example of a configuration of a debugging method according to a fourth embodiment.

FIG. 11 is a flowchart illustrating an example of an operation when a debugger breakpoint exception handling unit according to the fourth embodiment performs debugging.

FIG. 12 is a block diagram illustrating an example of a configuration of a debugging method according to a fifth embodiment.

FIG. 13 is a flowchart showing an example of an operation when a debugger breakpoint exception processing unit according to the fifth embodiment performs debugging.

[Explanation of symbols]

10 process to be debugged, 20 debugger, 50
Hardware, 100 operating systems, 10
1 system call interface, 102 file management subsystem, 103 memory management subsystem, 1
04 device driver, 106 process control unit, 1
10 breakpoint setting section, 111 breakpoint recording section, 112 breakpoint exception processing section, 2
01 system status determination unit, 301 process status storage unit, 401 memory change recording unit, 402 memory change monitoring unit, 501 execution history recording unit, 502 trace execution control unit.

Claims (11)

[Claims] 1. A method for debugging a process in which an instruction is executed in an operating system having two operation modes, a user mode and a kernel mode, comprising: an execution code executed in a user mode; and an execution mode executed in a kernel mode. A breakpoint setting unit that sets a breakpoint in the execution code executed in the kernel mode included in the debug target process, and an execution code set by the breakpoint setting unit that starts execution of the debug target process A debugger that interrupts the execution of the debuggee process when the debuggee process reaches a breakpoint in the debugger and executes the execution code included in the debuggee process in a kernel mode to debug. Debug Method. 2. The breakpoint setting section, comprising: a debugger process identifier for identifying a debug target process including an execution code for setting a breakpoint from the debugger; and a breakpoint indicating an address of an execution code for setting a breakpoint. 2. The debugging method according to claim 1, wherein the set address is notified as a breakpoint setting instruction, and a breakpoint is set based on the notified breakpoint setting instruction. 3. The debug method further comprises: a breakpoint recording unit that records the breakpoint setting address, the debug target process identifier, and a debugger identifier that identifies a debugger that has notified the breakpoint setting instruction. When the running debug target process reaches the breakpoint indicated by the breakpoint setting address,
It is determined whether or not the debugged process being executed is the same as the debugged process identified by the debugged process identifier recorded in the breakpoint recording unit. A breakpoint exception processing unit that instructs to shift control of executing the debugged process to the debugger identified by the debugger identifier recorded in the breakpoint recording unit; and an instruction from the breakpoint exception processing unit.
3. The debugging method according to claim 2, further comprising: a process control unit that suspends a currently executing debug target process and transfers control to execute the debug target process to the debugger. 4. The debugging system according to claim 1, further comprising a system state determining unit for determining whether or not the process can be switched, wherein the breakpoint exception processing unit includes a breakpoint indicated by a breakpoint setting address recorded in the breakpoint recording unit. When the point is set as the first break point and the process control unit is instructed to shift the control to execute the process to be debugged to the debugger, the system state determination unit determines whether the process can be switched, and the process cannot be switched. If it is determined that, in the execution code executed in the kernel mode, search for the next process switchable location, set a second breakpoint to the searched next address where the process switchable To the debugger when the second breakpoint is reached Debugging method of claim 3, wherein the indicating that shifts the control to execute the bag target process to said process control unit. 5. The debugging method according to claim 1, further comprising a process state recording unit that records a state of the process to be debugged being executed in the kernel mode as a process state, wherein the breakpoint exception processing unit is configured to execute the process to be debugged. When the system state determination unit determines that the process cannot be switched when the first breakpoint is reached, the process state when the breakpoint is reached is recorded in the process state recording unit. 5. The debugging method according to claim 4, wherein when the control for executing the process to be debugged is transferred to itself, the process status recorded in the process status recording unit is acquired. 6. The debugging system according to claim 1, further comprising a memory change monitoring unit that is notified of a memory area to be monitored in advance from a debugger and stores a range of the notified memory area; and a memory stored by the memory change monitoring unit. A memory change recording unit that records, when the contents of the area are changed, an instruction that changes the contents of the memory area, wherein the breakpoint exception processing unit executes When reaching the point, if it is determined that the process can not be switched by the system state determination unit, among the instructions executed by the debug target process from the first breakpoint to the second breakpoint, An instruction that changes the contents of the memory area recorded by the memory Wherein the debugger acquires an instruction in which the content of the memory area recorded in the memory change recording unit is changed when the control for executing the process to be debugged is transferred to itself. The debugging method according to claim 4, wherein 7. The debugging system according to claim 1, further comprising: an execution history recording unit that records an execution history of execution of an instruction of the debug target process; and a trace execution unit that records an instruction to execute the debug target process in the execution history recording unit. And a trace execution control unit for controlling the execution of the program. The breakpoint exception processing unit determines that the system state determination unit cannot switch the process when the debug target process being executed reaches the first breakpoint. In this case, the trace execution control unit is instructed to control the trace execution, and when the control to execute the process to be debugged is transferred to itself, the debugger records the execution history recorded in the execution history recording unit. 5. The debugging method according to claim 4, wherein the information is acquired. 8. The debugging method according to claim 1, wherein the breakpoint setting unit rewrites an instruction at an address at which a breakpoint is set to an exception processing instruction that causes a breakpoint. 9. The exception processing for recording an instruction at an address at which a breakpoint is to be set as a normal instruction in the breakpoint recording unit, and an instruction at an address at which a breakpoint is to be set to generate a breakpoint. The breakpoint exception processing unit is rewritten when it determines that the debugged process being executed is not the same as the debugged process identified by the debugged process identifier recorded in the breakpoint recording unit. 4. The debugging method according to claim 3, wherein the exception processing instruction is rewritten to a normal instruction recorded in the breakpoint recording unit. 10. A method for debugging a process in which an instruction is executed in an operating system having two operation modes, a user mode and a kernel mode, comprising: an execution code executed in a user mode; an execution mode executed in a kernel mode; A breakpoint setting step of setting a breakpoint in the execution code executed in the kernel mode included in the debug target process having: a start of the debug target process, and the execution code set by the breakpoint setting step A debug step of suspending execution of the debug target process when the debug target process reaches a breakpoint within the debugger, and executing and executing the execution code included in the debug target process in kernel mode. When Debug how. 11. The debugging method according to claim 10, wherein in the step of setting a breakpoint, an instruction at an address for setting a breakpoint is rewritten to an exception processing instruction for generating a breakpoint.