JPH0667942A - Log extraction system - Google Patents

Abstract

PURPOSE:To obtain a log extraction system by which log can efficiently be extracted. CONSTITUTION:An argument 1 transferred from a function on a calling-side to a function on a called-side, a return address 2 storing the address of the function on the calling-side and the individual local variable 3 of the function on the called-side are stored in a stack by a stack means. When the function is called, a log means records the return address 2 in a log buffer based on a pointer to a first argument (4). At the same time, the address 5 of the function itself on the called-side and the argument 1 are recorded in the log buffer by the log means (6). A function identification means identifies the function on the calling-side based on the return address 2.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a method for collecting log data of function and procedure calls in a programming language for calling functions and procedures using a stack.

[0002]

2. Description of the Related Art Generally, when calling a function in a program, if an attempt is made to record the function of the calling side (where it is called) in a log buffer, a unique number is assigned to all functions. Allocating, adding this number to the argument of the calling function, and recording this in the called function. In this method, it is necessary to change the program code in both the called function and the calling function.

Further, in the function call, the information to be recorded in the log buffer is the called function,
Arguments, return values, calling functions, etc. Of these pieces of information, the arguments in particular depend on the called function, and the number and length thereof change. The following two methods are used to record variable-length data such as this argument. (1) Divide the log buffer into fixed sizes according to the maximum length of data. (2) Dynamically allocate a log buffer of the required size for the data.

[0004]

In the conventional log collection method, since the program code is changed when the function is called, if there is even one modification error, a malfunction or an incorrect log result will occur. cause. Particularly in a large-scale program that requires such log data, the number of repair points increases, and the possibility of repair errors increases accordingly. Depending on the type of repair error, the program may cause a fatal failure. If this modification is to be automated by a program, and if the macro and the function call are described in the same format in a programming language (for example, C language) that can describe the macro
It is difficult to judge immediately whether it is a macro or a function call, and a parsing routine at the same level as the compiler is required.

The method of recording variable-length log data in the log buffer has the following problems. (1) With the method of dividing the log buffer with a fixed size, for log data shorter than the maximum length, an unused log area (memory) occurs, and if there are only a few functions that require a large log area, The area that is not used increases, and the efficiency of using the area deteriorates. (2) In the method of dynamically allocating the log buffer, a dynamic memory management mechanism is required, and the mechanism for logging becomes complicated. Time is spent.

As described above, the conventional log collecting method has a high possibility of making a bug by modifying the program code for collecting the log, and it is difficult to make a program for automatically making the log code. There was a problem that the method for recording the log was not efficient.

The present invention has been made to solve the above problems, and an object of the present invention is to obtain a log collecting method capable of collecting logs efficiently.

[0008]

[Means for Solving the Problems] Claim 1 according to the present invention
In the log collection method in, when a function is called with another function, stacking return information indicating the address where the called function returns to after the execution ends A log unit for storing the return information stored in the stack unit, the return information stored in the stack unit in a log buffer that is an area for collecting a log, and the return information collected as a log by the log unit. Then, the function identifying means for identifying which function the calling function was was provided.

According to a second aspect of the present invention, in a log collection method, when a function is called by another function, a variable length argument passed from the calling function to the called function is passed. For example, a backward pointer is added as a delimiter at the end of each group of passed arguments, and the argument of the function called before is stored in the log buffer. It is possible to use a log for each function on the called side based on the identification information storage means that stores the address indicating whether the location is recorded as the backward pointer and the address stored in the backward pointer. A means for utilizing call information is provided.

[0010]

The log collecting method according to claim 1 of the present invention is as follows.
Stack means for storing the address of the calling function in the stack, log means for recording the address of the calling function in the log buffer, and the calling side based on the address of the calling function collected as a log With the function identification means that can identify the function of, the function of the calling side can be identified by adding the program code for logging the address of the function of the calling side to the function of the called side. Can be identified.

According to the second aspect of the present invention, the log collection method includes call information storage means for recording a variable length argument in the log buffer, and identification information indicating a recording location of the argument for each called function as a backward pointer. Equipped with a storage unit and a call information utilization unit that can use the log of the called function, the recording location of the information for each called function is efficiently managed based on the identification information such as the backward pointer. it can.

[0012]

【Example】

Example 1. An embodiment of the present invention will be described below with reference to the drawings. FIG. 1 is a diagram showing a state of a stack when a function is called from another function in C language and data transferred from the stack to a log buffer, for example. In the present embodiment, the stack is used to perform the last-in first-out operation, and the data set later can be taken out earlier. 1 is an argument passed from the calling function to the called function, 2 is a return address for storing the address of the calling function, and 3 is a unique local variable of the called function. When a function is called, the stack unit sets the argument 1 to the stack before the control is transferred from the calling function to the called function, and then the control is transferred to the called function. At this time, the return address 2 for returning control to the calling function is set in the stack. Then, the local variable 3 is set on the stack.

When the function is called, first, based on the pointer to the first argument of the stack, the return address 2 is recorded in the log buffer by the log means 4. At this time, if there is no argument in the called function, a dummy argument is set and the return address is obtained using this. At the same time, the address 5 of the called function itself
The argument 1 is also recorded in the log buffer by the log unit 6. In this log buffer, only the return address 2 and the address of the function are recorded in order to minimize the overhead for collecting the log. By collecting such a log, it becomes possible to identify which function was the calling side by the function identification means according to the address of the calling function stored in the return address 2. That is, the return address 2 and the function address can be searched for the corresponding function name by comparing with the symbol table of the program at the time of analysis after collecting the log data.

In the log buffer, a variable length argument information recorded for each called function is delimited at the end.
Provide backward pointer. The backward pointer stores the address where the break of the information of the function which is called and recorded one before the information of the function to which the backward pointer is added as the end is stored. is there. This makes it possible to know from which address the information for which the log should be collected starts. The information indicating the position of the current backward pointer is stored by the current pointer.
For example, in FIG. 1, when the information of a certain function is recorded in the log buffer, the backward pointer, which is an example of the identification information storage unit, is provided at the end of the variable-length argument stored by the call information storage unit. 21 is added.
The backward pointer 21 is an address indicating at which position the argument of the previously recorded function is divided, that is, the existence of the backward pointer added to the argument of the previously recorded function. The address to be stored is stored, and the address is pointed to 7. Incidentally. At this time, the current pointer 20 always stores, as an address, the position of the last backward pointer, which is how far the log is currently recorded. Each time a new function is called, information is recorded in the log buffer, and each time a new backward pointer is added, the backward pointer added to the end of the argument of the previous function is written. The address is stored and points to that address. Then, the contents of the current pointer are rewritten at that time to the address of the new backward pointer. Thus, by using the backward pointer that is the identification information storage unit, the call information utilization unit can efficiently collect the variable-length argument as a log.

An example of program code for log collection shown in FIG. 2 will be described. A fixed-size log buffer 8 on the memory and a current pointer 9 indicating the end of the current log data are prepared as global variables. Further, in each function, the pointer 10 pointing to the log buffer is locally held, and data is written into the log buffer based on this pointer.

When the function is called, processing is performed at the head of the function as shown in the flowchart of FIG. 3, and the log data is recorded in the log buffer. In this case, if it exceeds the end of the log buffer, it is reused from the beginning of the log buffer. The numbers in the flowchart of FIG. 3 correspond to the program code numbers of FIG. In FIG. 3, first, the address of the called function is recorded 11. Then, based on the pointer to the first argument,
The return address 2 is obtained and recorded in the log buffer 12. Next, the address storing the argument is obtained 13, and the argument is written 14 in the log buffer. Then, the contents of the current pointer are copied to the log buffer, and the contents of the current pointer are changed to the value of the end address 15. In this way, the log can be collected when the function is called by simply setting the log collection program code in the called function.

Next, the analysis of the collected log data will be described. The collected log data is as shown in FIG. 4 or FIG. In FIG. 4, from the current pointer, N
Log information for each function can be sequentially traced from the last backward pointer 42 until the ULL pointer 41 is reached. Further, the log buffer has a property that when the recording is completed up to the end of the area, the log buffer continuously records again from the head of the area. In this way, when the data in the log buffer area continues at the last data and the first data in the area, the information for each function is traced in order until the backward pointer straddling the address pointed to by the current pointer is found. Then, you can retrieve the log data. As shown in FIG. 5, the information of the function F is continued at the end and the beginning of the log buffer.
At this time, the end of the information of the function G is the end of the log. Here, based on the address of the current pointer 20, the address is sequentially traced from the backward pointer 51, and the information is traced until the point 56 where the address indicated by the backward pointer 55 crosses the address indicated by the current pointer 20, You can retrieve log data.
As described above, the recording range of each log data is from the address pointed to by the backward pointer to immediately before the backward pointer.

The fixed length portion of each data (address of the calling function, address of the called function)
Is placed at a common position (the beginning or the end of each log data) so that it can be distinguished from the variable length part (argument).

Example 2. In the first embodiment, the backward pointer, which is the identification information storage means, is added to the end of the information of the function called immediately before, but, for example, the head of the information or a determined relative position. An address indicating where the function information is divided may be stored in the address position. The backward pointer stores the start address of the function information, or stores the information amount (number of bytes) of the recorded function in addition to storing the end address of the immediately preceding function. Then, the log information may be sequentially traced based on the amount.

Example 3. In Example 1, the stack,
Also, the order of setting the data in the log buffer is as shown in FIG.
However, the order is not particularly limited to this.

Example 4. In the first embodiment, as shown in FIGS. 4 and 5, in the log buffer, the log information can be traced until the NULL pointer is reached or the backward pointer straddling the address pointed to by the current pointer is found. For example, a condition such as a special address may be set, and the log information may be traced until the condition is met (until the address is reached).

Embodiment 5. In the first embodiment, the example in which the present invention is implemented in the C language has been described, but the present invention is also effective in other programming languages, for example.

Example 6. In the present invention, a function is a generic term for a subroutine, a procedure name and the like.

[0024]

As described above, in the log collecting system according to the first aspect of the present invention, the return information for returning from the called function to the calling function is stored in the stack and the stack means is stored in the stack means. By providing the log means for transferring the returned information to the area for log collection as a log, and the function identification means for identifying the calling function from the return information collected as a log by the log means,
The function information of the calling side can be stored as an address, and the program code for log collection is added to the called function, so the function of the calling side can be identified when the log is collected, and the program code can be modified. The number of bugs can be reduced.

As described above, in the log collecting method according to the second aspect of the present invention, call information of any length is added to the call information storage means for storing as a log, and the call information stored by the call information storage means, By providing the identification information storage means for storing the identification information for identifying the call information and the call information utilization means for utilizing the call information of an arbitrary length as a log based on the identification information stored by the identification information storage means. Since the recording location of the information for each called function can be managed by the identification information such as the back pointer, it is possible to efficiently and sequentially store the arguments of variable length data without making space in the log buffer. Therefore, log data can be efficiently collected for each function.

[Brief description of drawings]

FIG. 1 is a diagram showing a stack state when a function calls another function and data transferred from the stack to a log buffer according to a first embodiment of the present invention.

FIG. 2 is a diagram showing an example of a program code for log collection according to the first embodiment of the present invention.

FIG. 3 is a diagram showing a flowchart corresponding to a program code example for log collection in the first embodiment of the present invention.

FIG. 4 is NUL for log collection in the first embodiment of the present invention.
It is a figure which shows the example of the log buffer which ends with an L pointer.

FIG. 5 is a diagram showing an example of a log buffer in which log collection ends with a back pointer that straddles a current pointer according to the first embodiment of the present invention.

[Explanation of symbols]

 1 Argument 2 Address of Function to Call (Return Address) 3 Area of Local Variable 4 Log Means 5 Address of Function to be Called 6 Log Means 7 Identification Information Storage Means 20 Current Pointer 21 Backward Pointer

Claims (2)

[Claims] 1. A log collection method having the following elements in a log collection method for calling another function from an arbitrary function through a stack that puts data in last in first out and fetches the call information to a log collection area. (A) Stack means for storing return information for returning from the called function to the calling function in the stack, (b) Log for transferring the return information stored in the stack means to the area for log collection as a log Means, (c) function identifying means for identifying the function to be called from the return information collected as a log by the log means. 2. A log collection method for calling another function from an arbitrary function and extracting the call information to a log collection area, the log collection method having the following elements: (a) call information of an arbitrary length Call information storage means for storing as a log, (b) identification information storage means for storing identification information for identifying the call information, which is added to the call information stored by the call information storage means, (c) stored by the identification information storage means Call information utilizing means for utilizing the call information of an arbitrary length as a log based on the identified information.