JP2001147830A - Method for changing state of real time os - Google Patents

Abstract

PROBLEM TO BE SOLVED: To provide a method for realizing the state change of a real time OS at the time of the debug of an application using the real time OS. SOLUTION: At the time of the debug of an application 104 operating on a real time OS 105 of a target system, when a state change request 102 of the real time OS 105 is issued, a debugger 103 allows a state change routine 106 placed on a monitor being one part of the debugger 103 on the target system to generate registered interruption. When the interruption is generated, the real time OS 105 executes the interruption pre-processing, and the state change routine 106 sets a system call parameter for changing the present value to a target value, and issues a system call, and the real time OS 105 processes the system call, and executes the state change processing.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention
The present invention relates to a method for changing the state of a real-time OS that can change the state of S.

[0002]

2. Description of the Related Art Conventionally, a debugger has a function of changing a variable value of an application. If the value of the variable is different from the expected value, the behavior of the application can be debugged by changing the value of the variable using the variable value change function.

[0003]

However, this prior art has the following problems. The problem is that an application on the real-time OS cannot change the state of the real-time OS.

[0004] In an application on a real-time OS, processing is divided into units called tasks, and the execution units of the tasks are controlled using a synchronization mechanism such as a semaphore or an event flag. Real-time OS
Is a change of a task state (executable, executable, waiting, etc.), a semaphore, an event flag value, and the like. These are closely related, and changing one value affects the other. Since the ordinary debugger has no knowledge about the real-time OS, such a related value cannot be grasped, and the state of the real-time OS cannot be changed.

An object of the present invention is to provide a method for changing the state of a real-time OS that can change the state of the real-time OS when debugging an application using the real-time OS.

[0006]

According to the present invention, there is provided a method for changing the state of a real-time OS, the method comprising the steps of, when debugging an application operating on the real-time OS of a target system, changing the state of the real-time OS in a debugger as interrupt processing. A change routine is provided, and the state change routine changes the state of the real-time OS using a system call of the real-time OS.

[0007]

Next, an embodiment of the present invention will be described with reference to the drawings.

FIG. 1 is a block diagram for explaining a first embodiment of a method for changing the state of a real-time OS according to the present invention. Referring to FIG. 1, an embodiment of a real-time OS state changing method according to the present invention is a real-time OS.
An application developer 101 for debugging an application operating on the host computer; a debugger 103 for operating on the host computer; a monitor 109 on the target system, which is a part of the debugger;
It comprises a state change routine 106 for changing the state of the real-time OS, a real-time OS 105 on the target system, and an application 104 running on the real-time OS 105.

Here, the state change routine is a program routine for changing the state of the real-time OS, and the state change routine is registered as interrupt processing of the target system.

Next, the operation of the first embodiment will be described in detail with reference to FIGS. FIG. 2 shows the first
5 is a flowchart illustrating the operation of the embodiment.

First, the application developer 101
Issues a status change request 102 to the debugger 103. Next, the debugger 103 generates an interrupt in which the state change routine 103 is registered (step 204). When an interrupt occurs, the real-time OS 105
Pre-interruption processing such as saving the execution task in the context is performed (step 205), and then the processing moves to the state change routine 106. Then, the state change routine 1
At 06, a system call parameter for changing to a target value is set (step 206), and a system call is issued (step 207).

Thereafter, the system call is processed by the real-time OS 105 (step 208), and the state is changed 108. Finally, after the end of the system call processing, the processing is shifted to an interrupt end processing unit of the real-time OS (step 209), and if dispatch processing is required, the dispatch is performed here. With the above operation, the state of the application 104 on the real-time OS 105 is changed.

Next, a second embodiment of the present invention will be described. FIG. 3 is a configuration diagram illustrating a second embodiment of the method for changing the state of the real-time OS according to the present invention.

In the embodiment shown in FIG. 1, since the state change routine 106 is placed on the target, it can be operated as an interrupt process. However, in the embedded field, it is rare that the target has sufficient free memory. Therefore, an embodiment in which the state change routine is not placed on the target but placed on the host will be described.

Referring to FIG. 3, an embodiment of a method for changing the state of a real-time OS according to the present invention is a real-time OS.
An application developer 301 that debugs an application 304 that runs on S305, a debugger 303 that runs on a host computer,
3, a status change routine 306, a real-time OS 305 on the target system, and an application 304 running on the real-time OS 305.

Next, the operation of the second embodiment will be described in detail with reference to FIGS. FIG.
5 is a flowchart illustrating the operation of the embodiment.

First, an application developer 301 issues a status change request 302 to a debugger 303. The state change routine 306 in the debugger 303 temporarily stops the system (step 404), and simulates pre-processing of an interrupt such as saving a context for the task being executed (step 405). Next, a system call parameter for changing to a target value is set, a program counter (PC) is changed to a head address of a system call (step 406), and a return address of the system call is set to a head address of an interrupt end part. It is set (step 407).

Here, the system is executed (step 4).
08), the system call is processed by the real-time OS (step 409), and the state is changed. After processing the system call, the real-time OS
The processing shifts to an interrupt end processing unit 305 (step 4).
10) If dispatch processing is required, dispatch is performed here and the state change processing ends.

In FIG. 3, the monitor 309 is not involved in the state change processing. As a result, the state can be changed even when the monitor 309 does not exist on the target. This is because even in the case of application development in the embedded field where sufficient free memory cannot be obtained in the target, for example, when using ICE, the real-time OS
Means that the status change function can be realized.

[0020]

As described above, the present invention is an application on a real-time OS, and
The state of S can be changed.

Further, according to the present invention, by changing the state of the real-time OS, debugging can be continued without performing operations such as defect correction, reconstruction, and re-execution. The time spent can be greatly reduced.

[Brief description of the drawings]

FIG. 1 is a configuration diagram illustrating a first embodiment of a real-time OS state changing method according to the present invention;

FIG. 2 is a flowchart illustrating the operation of the first embodiment.

FIG. 3 is a configuration diagram illustrating a second embodiment of the method for changing the state of the real-time OS according to the present invention;

FIG. 4 is a flowchart illustrating the operation of the second embodiment.

[Explanation of symbols]

 101, 301 Application developer 102, 302 State change request 103, 303 Debugger 104, 304 Application 105, 305 Real-time OS 106, 306 State change routine 107, 307 System call issuance 108, 308 State change operation 109, 309 Monitor

Claims (7)

[Claims] When debugging an application running on a real-time OS of a target system, a status change routine for changing the state of the real-time OS is provided on the debugger as an interrupt process, and the status change routine performs a system call of the real-time OS. A method of changing the state of a real-time OS, wherein the method changes the state of the real-time OS by using the method. 2. The method according to claim 1, wherein the state change routine is placed on a monitor which is on a target system and is a part of a debugger. 3. The system according to claim 1, wherein said state change routine is located on a debugger of a host computer.
3. The method for changing the state of the real-time OS described in 1. above. . 4. In debugging an application running on a real-time OS of a target system, if a request to change the state of the real-time OS is made, the debugger is placed on a monitor that is on the target system and is a part of the debugger. The change routine generates a registered interrupt. When an interrupt occurs, the real-time OS performs pre-interrupt processing, and the state change routine sets a system call parameter for changing to a target value and issues a system call. A method for changing the state of a real-time OS, wherein the real-time OS processes a system call to change the state. 5. In debugging an application running on a real-time OS of a target system, if there is a request to change the status of the real-time OS, a status change routine placed on a debugger on the host computer temporarily stops the system. Simulate interrupt preprocessing, set system call parameters to change to the desired value, change the program counter to the start address of the system call, and change the return address of the system call to the start address of the interrupt end. A real-time OS that executes a system call and changes a status by processing a system call. 6. In debugging an application running on a real-time OS of a target system, when a request to change the state of the real-time OS is made, the debugger is placed on a monitor that is on the target system and is a part of the debugger. A procedure for generating an interrupt in which the change routine is registered; a procedure for the real-time OS to perform pre-interruption processing when an interrupt occurs; and a state change routine for setting a system call parameter for changing to a target value and setting the system call parameter. A computer-readable recording medium recording a program for executing a procedure for issuing a call and a procedure for a real-time OS to process a system call and change a state. 7. In debugging an application running on a real-time OS of a target system, when there is a request to change the status of the real-time OS, a status change routine placed on a debugger on the host computer temporarily stops the system. To simulate interrupt preprocessing, to set system call parameters to change to the desired value, to change the program counter to the start address of the system call, and to return from the system call. A computer-readable program recording a program for executing a procedure for setting an address to a start address of an interrupt end unit, a procedure for executing a system, and a procedure for a real-time OS to process a system call and change a state. recoding media.