JP2679685B2 - Core file generation method - Google Patents

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a core file generation method, and in particular, a signal is generated when an abnormal operation is performed during the execution of a program, and the signal causes the operation of the program to end and the core file The present invention relates to a core file generation method in a generated operating system.

[0002]

2. Description of the Related Art As is well known, UNIX (X / OPEN
(Trademark) operating system dumps core data and stack segments of the core memory at that time when the program enters an abnormal state during operation and cannot operate anymore. A core file was created. The user was able to investigate to some extent the cause of the abnormal operation of the program by analyzing the contents of the core file with a debugger or the like.

[0003]

In the above conventional operating system, only the data segment and the stack segment are output to the core file, and the text segment is not output.
Even if you try to check the situation when the core file is generated with a debugger etc., you can refer to the value of the variable when the core file was generated, but you cannot do a valid stack trace and the signal in the program There is a problem that it is not possible to accurately know at which position the operation has ended.

Further, since the data segments of all the shared objects referred to by the program are output to the core file, even the data segments of the shared objects that have never been referenced at the time when the core file is generated are output to the core. There is a problem that the core file is output to a file and the core file becomes too large to generate a complete core file.

In view of the above points, the first object of the present invention is to
Keep the shared object invocation depth in the shared object list. If the shared object invocation depth is equal to or greater than the initial value, it is the shared object that was referenced when the core file was created. It is to provide a core file generation method that outputs a text segment and a text segment of a load module to a core file so that a stack trace can be performed.

A second object of the present invention is to create an entry for the shared object referenced in the shared object list, and if there is an entry in the shared object list, it is referenced by the time the core file is created. Since it is a shared object, only the data segment of such a shared object is output to the core file (the data segment of the shared object that has never been referenced is not output), and the core file becomes large. It is to provide a core file generation method that prevents a case where a core file having a complete content cannot be generated due to too much.

Further, a third object of the present invention is to provide the above-mentioned first object.
It is an object of the present invention to provide a core file generation method that satisfies both the purpose and the second purpose.

As a prior art, trace output is suppressed when the function call depth exceeds a certain value, and trace output is restarted from the time point when the function is restored and returned to a certain value. Although a function trace output method is known (see Japanese Patent Laid-Open No. 2-245944), this method is for performing tracing and is not related to generation of a core file as in the present invention.

[0009]

According to the core file generation method of the present invention, a signal is generated when an abnormal operation is performed during the execution of a program, and the operation of the program ends at the same time as the signal causes the core file to be generated. In the operating system in which the jump instruction embedding means for embedding the jump instruction for calling the shared object list creating means at the beginning and the end of the machine language sequence for processing each function in the text segment of each shared object referenced by the program And the calling depth of the entry of the shared object in the shared object list is increased by 1 when called at the beginning of the function, and the entry of the shared object in the shared object list is increased when called at the end of the function. The shared object that reduces the call depth by one And a text list of the load module are output to the core file, and if the call depth of the entry of the shared object in the shared object list is larger than an initial value, the text segment of the shared object is output to the core. And a core file generating means for outputting to a file.

The core file generation method of the present invention is
In operating systems where a signal is generated when an abnormal operation is performed during the execution of a program, and the signal terminates the operation of the program and at the same time a core file is generated, a text segment of each shared object that the program references Jump instruction embedding means for embedding a jump instruction for calling a shared object list creating means in a machine language string for processing each function therein, and if there is no entry of the shared object in the shared object list when called by a function The shared object list creating means for adding an entry for the shared object, and a core file generation for outputting a data segment of the shared object to the core file if the shared object list has an entry for the shared object. And a stage.

Further, according to the core file generation method of the present invention, a signal is generated when an abnormal operation is performed during the execution of a program, and the signal causes the operation of the program to end, and at the same time, the core file is generated. In the operating system, a jump instruction embedding means for embedding a jump instruction for calling the shared object list creating means at the beginning and at the end of a machine language string for processing each function in the text segment of each shared object referenced by the program, and a function If there is no entry for the shared object in the shared object list when called at the beginning, the entry for the shared object is added, and if there is an entry for the shared object, the call depth of the entry for the shared object is increased by one. ,
The shared object list creating means for reducing the calling depth of the shared object in the shared object list by one when called at the end of the function, and outputting the text segment of the load module to the core file, and the shared object. If there is an entry of the shared object in the list, the data segment of the shared object is output to the core file, and if the invocation depth of the entry of the shared object is larger than the initial value, the text segment of the shared object is output to the core file. And a core file generating means for outputting to.

[0012]

In the core file generating method of the present invention, the jump instruction embedding means has the shared object list creating means at the head and tail of the machine language string for processing each function in the text segment of each shared object referenced by the program. A jump instruction to be called is embedded, the calling depth of the entry of the shared object in the shared object list is incremented by one when the shared object list creating means is called at the beginning of the function, and the shared object is called at the end of the function. The call depth of the entry of the shared object in the list is decreased by one, the core file generation means outputs the text segment of the load module to the core file, and the call depth of the entry of the shared object in the shared object list is set to the initial value. Bigger than Output text segment of the shared object to the core file.

Further, in the core file generating method of the present invention, the jump instruction embedding means calls the shared object list creating means to a machine language string for processing each function in the text segment of each shared object referenced by the program. When an instruction is embedded and the shared object list creating means is called by a function and there is no entry for the shared object in the shared object list, the shared object entry is added, and the core file creating means adds the shared object to the shared object list. If there is an entry of, the data segment of the shared object is output to the core file.

Further, in the core file generation method of the present invention, the jump instruction embedding means creates a shared object list at the head and tail of a machine language string for processing each function in the text segment of each shared object referenced by the program. A jump instruction for calling the means is embedded, and when the shared object list creating means is called at the beginning of the function, if there is no entry for the shared object in the shared object list, the entry for the shared object is added, and the entry for the shared object is added. If there is, the call depth of the entry of the shared object is incremented by 1, and when called at the end of the function, the call depth of the shared object in the shared object list is reduced by 1, and the core file generation means sets the text of the load module. Core segment If the entry of the shared object exists in the shared object list, the data segment of the shared object is output to the core file, and if the invocation depth of the entry of the shared object is larger than the initial value, the shared object is output. Output the text segment of to the core file.

[0015]

Next, the present invention will be described in detail with reference to the drawings.

FIG. 1 is a block diagram showing the configuration of a core file generation system according to an embodiment of the present invention. In the core file generation method of this embodiment, the shared object list is provided at the beginning and the end of the machine language string for processing each function in the text segment 8a of each shared object 8 (one shown) referenced by the load module 7. With respect to the jump instruction embedding means 1 for embedding the jump instruction for calling the creating means 2 and the shared object 8 referenced by the load module 7, the depth at which the function included in the shared object 8 is called (hereinafter referred to as the call depth). A shared object list creating means 2 for creating a shared object list 5 for managing the shared object list 5, a text segment 7a of the load module 7 and a text segment 8a of the shared object 8 referred to when the core file 6 was created from within the address space 4, Data segmentation of load module 7 A data segment 8b of the shared object 8 bets 7b and program references to finish,
The stack segment 9 and the core file generating means 3 for generating the core file 6 by dumping.

Each entry in the shared object list 5 has two elements, a shared object name and a call depth. The shared object name is the name of the shared object 8 referenced by the load module 7, and the call depth is
The depth (level) at which the function included in the shared object 8 is called is shown. For example, the shared object libA. so contains the functions X, Y and Z,
If the function X is called from the load module 7 and the function Y is further called from the function X, as illustrated in the shared object list 5 in FIG. The calling depth of so is 2.

Referring to FIG. 2, the process of the shared object list creating means 2 is performed by the function head determining step 201.
And shared object entry presence / absence determination step 202
And step 203 of increasing the shared object list call depth 1 and step 2 of adding an entry / call depth 0
04 and a shared object list call depth 1 subtraction step 205.

Referring to FIG. 3, the processing of the core file generating means 3 includes a shared object list 1 entry extraction step 301, a call depth determination step 302,
It comprises a text segment output step 303, a data segment output step 304, an entry extraction end determination step 305, and a load module text segment and data segment and a stack segment output step 306.

Next, the operation of the core file generation method of this embodiment having the above-mentioned configuration will be described.

When the program is executed, first, the jump instruction embedding unit 1 executes the processing of each function in the shared object 8 on the text segment 8a of the shared object 8 in the address space 4 of the process for this program. A jump instruction for calling the shared object list creating means 2 is embedded at the beginning and the end of the word string.

After the jump instruction is embedded, the execution of the program is continued, and when the embedded jump instruction is reached, the shared object list creating means 2 is called.

The shared object list creating means 2 first determines whether or not it is the head of the function (step 20).
1) If it is at the beginning of the function, it is checked whether or not there is an entry of the shared object 8 including the function in the shared object list 5 using the shared object name as a key (step 202). If the shared object list 5 does not have an entry for the shared object 8 including the function, the shared object list creating means 2 adds the entry for this shared object 8 to the shared object list 5 and sets the call depth to 0. (Step 20
4). After the entry is added in step 204 and when there is a corresponding entry in step 202, the shared object list creating means 2 increases the calling depth of this entry by one (step 203) and ends the processing.

On the other hand, if it is the tail of the function in step 201, the shared object list creating means 2 searches the shared object list 5 for the entry of the shared object 8 including the function, and reduces the call depth by one. (Step 205), the process ends.

In this way, every time the execution of the program reaches the jump instruction embedded in the shared object 8, the content of the shared object list 5 is updated.

When an abnormal operation is performed during the execution of the program and a signal is generated and the signal is received and the process is terminated, the core file generating means 3 is called.

The core file generating means 3 first extracts one entry from the shared object list 5 (step 301).

Next, the core file generating means 3 judges whether the call depth of the entry is larger than 0 (step 302), and only when it is larger, the text segment 8a of the shared object 8 is made to be the core file 6. (Step 303).

Subsequently, the core file generation means 3 outputs the data segment 8b of the shared object 8 to the core file 6 regardless of the determination result of step 302 (step 304).

Next, the core file generating means 3 judges whether or not all the entries of the shared object list 5 have been taken out (step 305), and steps 301 to 305 are repeated until all the entries are taken out.

When it is determined in step 305 that all the entries of the shared object list 5 have been taken out, the core file generation means 3 outputs the text segment 7a and the data segment 7b of the load module 7 and the stack segment 9 to the core file 6. Then (step 306), the process ends.

As a result, as shown in FIG. 1, the text segment 7a of the load module 7, the text segment 8a of the shared object 8 referred to at the time of abnormal operation, and the data segment 7 of the load module 7 are referenced.
The core file 6 in which the data segment 8b of the shared object 8 referred to by b and the abnormal operation time and the stack segment 9 are written is generated.

In the above embodiment, the shared object call depth is held in the shared object list, and if the shared object call depth is equal to or greater than the initial value, it is referred to when the core file is created. Since it is a shared object, the text segment of this shared object and the text segment of the load module are output to the core file so that a stack trace can be performed and the entry of the referenced shared object in the shared object list is created. If there is an entry in the shared object list, it means that the shared object was referenced by the time the core file was created, so only the data segment of such a shared object should be output to the core file. Not done I tried not to output the shared object's data segment) to prevent the core file from becoming too large to generate a complete core file, but it is not necessary to do both at the same time. The object of the invention can be achieved. That is, the shared object invocation depth is held in the shared object list, and if the shared object invocation depth is equal to or greater than the initial value, it is the shared object that was referenced when the core file was created. You can simply print the object's text segment and the load module's text segment to a core file for stack tracing, or you can make an entry for the referenced shared object in the shared object list to create a shared object. If there is an entry in the list, it is a shared object that was referenced by the time the core file was created, so only the data segment of such a shared object should be output to the core file (a shared object that has never been referenced). Data segment so as not to output), may be simply so does not occur if the core file of the complete contents core file too large can not be generated.

[0034]

As described above, according to the present invention, the jump instruction embedding means, the shared object list creating means, and the core file creating means are provided so that the shared object invocation depth can be held in the shared object list. If the invocation depth of the object is greater than the initial value, it is the shared object that was referenced when the core file was created. Therefore, the text segment of this shared object and the text segment of the load module are output to the core file. As a result, the stack trace can be performed, and there is an effect that the situation when the core file is generated can be effectively analyzed.

Further, the entry of the shared object referred to in the shared object list is created,
If there is an entry in the shared object list, it is a shared object that was referenced by the time the core file was created. Therefore, only the data segment of such a shared object is output to the core file (it is never referenced. By not outputting the data segment of the shared object), it is possible to prevent the core file from becoming too large to generate a complete core file. What happens when the core file is generated? Has the effect that it can be analyzed reliably.

Further, the calling depth of the shared object is held in the shared object list, and if the calling depth of the shared object is equal to or larger than the initial value, it means that the shared object was referenced when the core file was created. , The text segment of this shared object and the text segment of the load module are output to the core file, and an entry for the shared object referenced in the shared object list is created. Since it is a shared object that has been referenced by the time of creation, only the data segment of such a shared object is output to the core file (the data segment of a shared object that has never been referenced is not output. By doing so, it becomes possible to perform a stack trace, it is possible to effectively analyze the situation when the core file is generated, and when the core file becomes too large to generate a complete core file. Is prevented from occurring, and it is possible to reliably analyze the situation when the core file is generated.

[Brief description of the drawings]

FIG. 1 is a block diagram showing a configuration of a core file generation method according to an embodiment of the present invention.

FIG. 2 is a flowchart showing a process of a shared object list creating means in FIG.

FIG. 3 is a flowchart showing a process of a core file generating means in FIG.

[Explanation of symbols]

 1 jump instruction embedding means 2 shared object list creating means 3 core file creating means 4 address space 5 shared object list 6 core file 7 load module 7a text segment 7b data segment 8 shared object 8a text segment 8b data segment 9 stack segment

Continuation of the front page (56) Reference JP-A-6-290084 (JP, A) JP-A-5-313918 (JP, A) JP-A-2-294845 (JP, A) JP-A-4-364545 (JP , A) JP-A-2-165352 (JP, A) JP-A 1-112345 (JP, A) JP-A-4-242839 (JP, A) JP-A-3-216742 (JP, A) JP-A 63-228243 (JP, A) JP 63-82528 (JP, A) JP 62-212743 (JP, A) JUICE I. Co-authored by EGAN and THOM AS TEIXEIRA, translated by Koichi Nonaka and Teruyo Onishi, "UNIX Device Driver", ASCII Corporation, November 1989, p. 182-197

Claims (3)

(57) [Claims] 1. In an operating system in which a signal is generated when an abnormal operation is performed during the execution of a program, and the operation of the program ends due to the signal, a core file is generated at the same time. A jump instruction embedding means for embedding a jump instruction for calling a shared object list creating means at the head and tail of a machine language string for processing each function in the text segment of the shared object, and the sharing when called at the head of the function. The shared object list creating means for increasing the calling depth of the entry of the shared object in the object list by one and decreasing the calling depth of the entry of the shared object in the shared object list by one when called at the end of the function. And the load module Core file generation means for outputting a text segment of the shared object to the core file and outputting the text segment of the shared object to the core file when the calling depth of the entry of the shared object in the shared object list is larger than an initial value. A core file generation method comprising: 2. An operating system in which a signal is generated when an abnormal operation is performed during the execution of a program and the operation of the program ends due to the signal and at the same time a core file is generated Jump instruction embedding means for embedding a jump instruction for calling a shared object list creating means in a machine language string for processing each function in a text segment of the shared object, and the shared object in the shared object list when called by a function If there is no entry for the shared object, the shared object list creating means for adding an entry for the shared object; and if there is an entry for the shared object in the shared object list, a command for outputting the data segment of the shared object to the core file. A core file generation method comprising: a file generation means. 3. An operating system in which a signal is generated when an abnormal operation is performed during the execution of a program and the operation of the program ends due to the signal and at the same time a core file is generated A jump instruction embedding means for embedding a jump instruction for calling a shared object list creating means at the head and tail of a machine language string for processing each function in the text segment of the shared object, and the sharing when called at the head of the function. When there is no entry for the shared object in the object list, an entry for the shared object is added, and if there is an entry for the shared object, the call depth of the entry for the shared object is incremented by 1, and when called at the end of the function To the shared object list The shared object list creating means for reducing the call depth of the entry of the shared object by one, and outputting the text segment of the load module to the core file, and if there is an entry of the shared object in the shared object list, the shared object Core file generating means for outputting the data segment of the object to the core file and outputting the text segment of the shared object to the core file if the call depth of the entry of the shared object is larger than the initial value. Characterized core file generation method.