JP4125056B2 - Log acquisition method - Google Patents

Description

[0001]
BACKGROUND OF THE INVENTION
The present invention relates to a technique for acquiring a processing log of software divided into a plurality of modules.
[0002]
[Prior art]
In the past, for software failures with low recall, the cause of the failure has been identified by taking a software processing log and analyzing the processing log, and countermeasures have been taken.
[0003]
[Problems to be solved by the invention]
However, the acquisition of the conventional processing log has the following problems.
(1) In order to continue to acquire logs even in the user's operating environment, the software module itself has to be modified and a processing log acquisition routine has to be added, resulting in a heavy workload for acquiring the processing logs.
(2) Since processing log acquisition is performed for each module, the generated log is for each module, and it is difficult to acquire the entire software processing as a log in time order. For this reason, the prospect as the whole processing log was bad, and it took man-hours to analyze the log and discover the cause of the failure.
[0004]
The present invention has been made in view of the above problems, and can easily acquire a software processing log divided into a plurality of modules, and can reduce the number of steps for analyzing the cause of a software failure. An object of the present invention is to provide a simple log acquisition method, a program for realizing the method by a computer, and a storage medium storing the program.
[0005]
[Means for Solving the Problems]
In order to achieve the above object, a log acquisition method according to the present invention has the following configuration. That is,
A dynamic link library storing functions, an import function address table storing addresses of the functions, and a target program that calls and executes the functions in the dynamic link library; The Program storage means for storing; A storage medium for storing the program; A log memory for temporarily storing a log; a disk device; and an execution means for executing a program, wherein the execution means Storage media A log acquisition method for acquiring a log during execution of the target program in an information processing apparatus comprising a rewriting means implemented by executing a program stored in the memory and a calling means,
The rewriting means loads a log acquisition function corresponding to each function in the dynamic link library into the dynamic link library and stores it in the import function address table before executing the target program. Rewriting the address of each function to the address of the corresponding function for log acquisition;
The call means is configured to acquire the log based on the address of the corresponding function for log acquisition after rewriting on the import function address table for the function to be called that the target program is to call. Starting a log acquisition means realized by calling a function and causing the execution means to execute;
The log acquisition means determining whether a parameter is defined as a structure in the function definition in the target program; and
If the parameter is defined as a structure, the log acquisition means, based on a packing option that defines the memory arrangement of the structure in the function definition, arranges the contents of the structure in the log memory, Recording the contents of the structure arranged in the memory as a log in the disk device;
The log acquisition unit calls the function to be called corresponding to the log acquisition function called by the calling unit, causes the execution unit to execute the call target function, and receives an execution result When,
A step of secondly determining whether or not a parameter or a return value is defined as a structure in the function definition in the target program;
If the parameter or the return value is defined as a structure, the arrangement unit arranges the contents of the structure in the log memory based on a packing option that defines the memory arrangement of the structure in the function definition. And recording the contents of the structure arranged in the memory as a log in the disk device;
The log acquisition means includes a step of passing the execution result to the target program.
[0006]
DETAILED DESCRIPTION OF THE INVENTION
[First Embodiment]
In this embodiment, an import function address stored in a memory or a virtual function address table (Virtual Address Table), which is a mechanism when a function existing in another module is called from one module, is used. By hooking function calls between modules and recording them in the log, it is possible to acquire the entire software process as a log in time order without modifying the software module itself. . This will be specifically described below.
[0007]
<System configuration>
FIG. 1 is a diagram showing the configuration of a computer (software evaluation system) that implements a log acquisition method according to each embodiment of the present invention. In order to simplify the explanation, in this embodiment, it is assumed that the software evaluation system is built inside one PC, but the feature of the log acquisition method of the present invention is built inside one PC. It is effective regardless of whether it is constructed as a network system on a plurality of PCs.
[0008]
A computer on which this software evaluation system is mounted includes a CPU 1, a chip set 2, a RAM 3, a hard disk controller 4, a display controller 5, a hard disk drive 6, a CD-ROM drive 7, and a display 8. Further, a signal line 11 connecting the CPU and the chip set, a signal line 12 connecting the chip set 2 and the RAM 3, a peripheral device bus 13 connecting the chip set 2 and various peripheral devices, and a signal connecting the hard disk controller 4 and the hard disk drive 6. Line 14, signal line 15 connecting hard disk controller 4 and CD-ROM drive 7, and signal line 16 connecting display controller 5 and display 8 are mounted.
[0009]
<Acquire processing log for function processing>
In order to describe the software evaluation system that implements the log acquisition method according to the first embodiment of the present invention, first, referring to FIG. 2, how the software divided into a plurality of modules is loaded into the memory in a normal state. Explain how.
[0010]
Usually, the software divided into a plurality of modules is divided into an executable file EXE (23) that performs overall control and a dynamic link library DLL (27) that exists as a module and plays a complementary role of EXE. Is loaded with both EXE and DLL. EXE consists of a code segment (28), a data segment (29), and an import function address table (22). Furthermore, the import function address table is divided by the DLL to which the function belongs (21, 24), and the address at which each function is loaded is written for each DLL (30-35). The entity of the DLL function is loaded separately for each DLL (25, 26), and each function is loaded as a part of the corresponding DLL (36-41). This figure shows an example in which one EXE uses functions in two dynamic link libraries of A.DLL and B.DLL, and the functions actually used are Func AA, Func AB, and Func. AC, Func BA, Func BB, and Func BC.
[0011]
When the code in the EXE code segment calls the function Func AA, the Func AA address (30) written in the import function address table is first read. Here, the address of the Func AA code (36) actually read as part of A.DLL is written, and by calling that address, the EXE code calls Func AA of A.DLL. be able to.
[0012]
FIG. 3 is a diagram showing a memory configuration of the software evaluation system that implements the log acquisition method according to the first embodiment of the present invention. FIG. 2 is different from FIG. 2 in terms of IAT Patch (Import Address) for the log acquisition code. It is different in that the function call is redirected using a technique called “Table Patch”.
[0013]
When log acquisition is started, C.DLL (58), which is a DLL for IAT Patch, is loaded into the memory. C.DLL is the address of the function written in the import function address table (52), and the address of the log acquisition code in C.DLL is Func CAA, Func CAB, Func CAC, Func CBA, Func CBB, Func CBC (61-66). Func CAA, Func CAB, Func CAC, Func CBA, Func CBB, and Func CBC code (73-78) in C. DLL are logged and loaded into memory to receive the original function call The corresponding functions Func AA, Func AB, Func AC, Func BA, Func BB, and Func BC (67 to 72) are called.
[0014]
4A is a diagram showing the processing of the IAT Patch in FIG. 3, and FIG. 4B is a flowchart showing the flow of the log acquisition processing. In order to simplify the explanation, this figure shows an example of how the log acquisition code by IAT Patch operates when EXE calls Fun AA in A.DLL.
[0015]
When EXE (91 in FIG. 4A) calls Func AA (94 in FIG. 4A), the log acquisition code in C.DLL saves the DLL name / function name in memory (step S402 in FIG. 4B), and the call time Is stored in the memory, the parameter at the time of calling is stored in the memory, and the memory content pointed to by the pointer parameter at the time of calling is stored in another memory (95 in FIG. 4A, step S403 in FIG. 4B). After that, C.DLL calls Func AA in A.DLL (93 in FIG. 4A), which was supposed to be called (96 in FIG. 4A, step S404 in FIG. 4B). When the A.DLL Func AA process (97 in FIG. 4A) ends and control returns to C.DLL (98 in FIG. 4A), C.DLL stores the return time in memory and stores the return value in memory. The memory contents pointed to by the pointer parameter at the time of return are stored in another memory (99 in FIG. 4A). Thereafter, C.DLL writes the saved log information to the file (100 in FIG. 4A, step S405 in FIG. 4B), and returns to EXE as if A.DLL Func AA ended normally ( 101).
[0016]
FIG. 5 is a diagram showing the internal configuration of the software evaluation system that implements the log acquisition method according to the first embodiment of the present invention. Normally, the executable EXE (113) calls a function in the DLL-1 (116) or DLL-2 (117). Here, a log acquisition code called an API tracer is embedded (114) to generate a processing log. (115). The API tracer is based on a file (111) describing function definitions of DLL-1 and DLL-2, and a setting scenario (trace scenario 112) of rewriting the import function table of which function of which DLL and acquiring the log. To work.
[0017]
<Acquire process log for method process>
Next, in the software evaluation system that implements the log acquisition method according to the first embodiment of the present invention, when an instance of an interface in which the execution file EXE (118) is exported by a COM (Component Object Model) server is created, In order to explain how the data is loaded into the memory, first, how it is loaded into the memory in a normal state will be described with reference to FIG.
[0018]
Normally, when an instance of an interface is created, the requested interface (121, 122) and its method (: a program describing a procedure executed by an object in object-oriented programming, 130 to 135) in the COM server are displayed. They are both loaded into memory. Here, a virtual address table (virtual address table) is created for each created interface (118, 120), and passed to the EXE that made the creation request. In this virtual address table, addresses where each method is created are written (124 to 129). EXE uses these information to make a call to each interface. In this figure, one EXE creates instances of two interfaces, Interface A and Interface B, and shows an example of using the methods inside that interface. , Method AA, Method AB, Method AC, Method BA, Method BB, Method BC.
[0019]
When the EXE code calls the function Method AA, the address (124) of the Method AA written in the virtual address table is first read. Here, the address of the Method AA code (130) created as part of Interface A of the COM server is actually written, and by calling this address, the code of EXE executes Method AA of Interface A. Can be called.
[0020]
FIG. 7 is a diagram showing a memory configuration of the software evaluation system that implements the log acquisition method according to the first embodiment of the present invention. FIG. 6 is different from FIG. 6 in terms of VTable Patch (virtual address) for the log acquisition code. This method is different in that the method call is redirected using a method called “table Patch”.
[0021]
When log acquisition is started, a DLL (143) for VTable Patch is loaded in the memory. This DLL uses the address of the method written in the virtual address table (136, 138) as the method A'A, Method A'B, Method A'C, Method B'A, Method B, which is the log acquisition code in the DLL. Rewrite to the address of 'B, Method B'C (145-150). Method A'A, Method A'B, Method A'C, Method B'A, Method B'B, Method B'C code (157-162) in the DLL records the log and the original method Method AA, Method AB, Method AC, Method BA, Method BB, MethodBC (157 to 162), which are the corresponding methods loaded in the memory to receive the call, are called.
[0022]
8A is a diagram showing the processing of the VTable Patch in FIG. 7, and FIG. 8B is a flowchart showing the flow of the log acquisition processing. In order to simplify the explanation, this figure shows an example of how the log acquisition code by VTable Patch operates when EXE calls MethodAA of Interface A in the COM server.
[0023]
When EXE (163 in FIG. 8A) calls Method AA (166 in FIG. 8A), the log acquisition code in the DLL stores the module name / interface name / method name in memory (step S802 in FIG. 8B) and calls The time is saved in the memory, the parameter at the time of calling is saved in the memory, and the memory content pointed to by the pointer parameter at the time of calling is saved in another memory (167 in FIG. 8A, step S803 in FIG. 8B). Thereafter, the DLL calls Method AA in the COM server (165 in FIG. 8A), which was supposed to be called (168 in FIG. 8A, step S804 in FIG. 8B)). When the Method AA process (169 in FIG. 8A) of the COM server ends and control returns to the DLL (170 in FIG. 8A), the DLL stores the return time in the memory, stores the return value in the memory, and returns. The memory content pointed to by the pointer parameter is saved in another memory (171 in FIG. 8A). Thereafter, the DLL writes the saved log information to the file (172 in FIG. 8A, step S805 in FIG. 8B), and returns to EXE as if Method AA of the COM server was terminated normally (in FIG. 8A). 173).
[0024]
FIG. 9 is a diagram showing the internal configuration of the software evaluation system according to the first embodiment of the present invention. Normally, the execution format EXE (176) calls a method in the COM server 1 (179) or the COM server 2 (180). Here, a log acquisition code called an API tracer is embedded (177) to generate a processing log. (178). The API tracer sets a file (174) in which the function definitions of the COM server 1 (179) and the COM server 2 are described, and a virtual address table for which method of which interface of which COM server to acquire a log. Operates based on (trace scenario 175).
[0025]
<Function definition file>
FIG. 10 is a diagram of a function definition file for instructing the software evaluation system that implements the log acquisition method according to the first embodiment of the present invention, the format of each function and method parameter, and the format of the return value. It is a figure which shows an example.
[0026]
The number of bytes of the packing option (PackingOption) shown in the figure is a defining part that characterizes the present invention.
[0027]
FIG. 11 shows an example of a log acquired by the software evaluation system that implements the log acquisition method according to the first embodiment of the present invention using the function definition file shown in FIG. For each call, the time when the function / method is called and the parameters / return values at that time are generated as a log.
[0028]
Prior to the description of FIG. 12, a structure packing option widely used in the past will be described.
[0029]
The structure packing option is an agreement on the alignment of the structure entity in the memory when it is placed in the memory, and is used when passing the structure between modules. is there.
[0030]
In a normal CPU, the members of the structure are placed in a memory arrangement that allows the contents to be read into a register without slowing down the CPU. For example, in a CPU having a data bus width of 64 bits, memory contents can be read into a register without reducing the CPU speed by arranging members on the following memory boundaries.
1 byte data-> 0x00000000, 0x00000001, 0x00000002 ,,,
2 bytes data-> 0x00000000, 0x00000002, 0x00000004 ,,, (least 1 bit is zero)
4 bytes data-> 0x00000000, 0x00000004, 0x00000008 ,,, (least 2 bits are zero)
8 bytes data-> 0x00000000, 0x00000008, 0x00000010 ,,, (least 3 bits are zero)
This depends on the characteristic that when a normal CPU calculates a memory address, it is faster to read data from a memory address that is divisible by the data size than to read data from a memory address that is not.
[0031]
However, if data is arranged in this way, a large amount of unused space remains in the memory, so even if the speed can be optimized, the amount of used memory is adversely affected.
[0032]
In order to avoid this adverse effect, an ordinary compiler has an option called a structure packing option. For example, if you want to give priority to reducing the amount of memory used because 8 bytes of data calculation may be slow, if you want to prioritize speed over the amount of memory for data of 4 bytes or less, set the structure packing option to 4. By compiling the program (both EXE and DLL in this embodiment), each member of the structure can be arranged at the following memory boundary.
1 byte data-> 0x00000000, 0x00000001, 0x00000002 ,,,
2 bytes data-> 0x00000000, 0x00000002, 0x00000004 ,,, (least 1 bit is zero)
4 bytes data-> 0x00000000, 0x00000004, 0x00000008 ,,, (least 2 bits are zero)
8 bytes data-> 0x00000000, 0x00000004, 0x00000008 ,,, (least 2 bits are zero)
In this case, only data of 4 bytes or less is arranged at a memory address divisible by the data size.
[0033]
If you want to place only data of 1 byte or less at a memory address that is divisible by the data size, compile the program with the structure packing option set to 1, and place each member of the structure on the following memory boundary: Can do.
1 byte data-> 0x00000000, 0x00000001, 0x00000002 ,,,
2 bytes data-> 0x00000000, 0x00000002, 0x00000004 ,,, (least 1 bit is zero)
4 bytes data-> 0x00000000, 0x00000002, 0x00000004 ,,, (least 1 bit is zero)
8 bytes data-> 0x00000000, 0x00000002, 0x00000004 ,,, (least 1 bit is zero)
If you want to place only data of 2 bytes or less at memory addresses that are divisible by the data size, compile the program with the structure packing option set to 2, and place each member of the structure on the following memory boundary: Can do.
1 byte data-> 0x00000000, 0x00000001, 0x00000002 ,,,
2 bytes data-> 0x00000000, 0x00000001, 0x00000002 ,,,
4 bytes data-> 0x00000000, 0x00000001, 0x00000002 ,,,
8 bytes data-> 0x00000000, 0x00000001, 0x00000002 ,,,
FIG. 12 is a more specific example regarding the structure packing option described above. When there are two structure members, 1-byte data and 8-byte data, the structure passed as a parameter or return value between EXE and DLL according to the structure packing option is shown in this figure. As shown in FIG.
[0034]
FIG. 13 is another example of a structure packing option. When there are two structure members, 1-byte data and 4-byte data, the structure passed as a parameter or return value between EXE and DLL according to the packing option of the structure is shown in this figure. As shown in FIG.
[0035]
FIG. 14 is another example of a structure packing option. When there are two structure members, 1-byte data and 2-byte data, the structure passed as a parameter or return value between EXE and DLL according to the structure packing option is shown in this figure. As shown in FIG.
[0036]
These examples are merely examples for explaining the structure packing option, and the effect of the present invention is effective regardless of the type of structure packing option. The present invention automatically expands the contents of a structure according to a structure packing option specified in advance in a function definition file when a structure is included in parameters or return values of the function / method to be traced. There is a feature.
[0037]
FIG. 15 is a diagram showing the flow of processing in the software evaluation system that implements the log acquisition method according to the first embodiment of the present invention.
[0038]
When processing is started by calling the set function / method (step S1), the structure packing option is read from the function definition file (step S2), and the DLL name / function name / calling time is set. Saving in the HDD (step S3).
[0039]
Next, it is determined whether the parameter is defined as a structure based on the function definition file shown in FIG. 10 (step S4). If the parameter is not defined as a structure, the parameter for the call is determined. Is stored in the HDD (step S5). If it is defined as a structure, the contents of the structure are expanded from the memory based on the packing option of the structure read in step S2 (step S6), and each member is stored in the HDD (step S7). .
[0040]
When the processing inside the function ends (step S8), the DLL name / function name / end time is stored in the HDD (step S9). Next, it is determined whether or not the parameter and return value are defined as a structure based on the function definition file shown in FIG. 10 (step S10). All parameters and return values are stored in the HDD (step S11). If it is defined as a structure, the contents of the structure are expanded from the memory based on the packing option of the structure read in step S2 (step S12), and parameters and return values for the call are stored in the HDD. (Step S13).
[0041]
This process is continued until the program to be evaluated ends (step S14).
[0042]
As is clear from the above description, according to the log acquisition method according to the present embodiment, the acquisition of the processing log of the software divided into a plurality of modules is prepared in the module without changing the module itself. The function / method calls can be recorded as a log, and the work load for acquiring the processing log can be reduced. In addition, the generated log can be acquired as a chronological log and the log can be easily analyzed. Therefore, the number of steps for analyzing the cause of the software failure can be reduced. Furthermore, by using the packing option in the function definition, it is possible to reduce the amount of memory used at the time of log acquisition.
[0043]
[Second Embodiment]
In the first embodiment, the case where the amount of memory used at the time of log acquisition is reduced by using the packing option has been described. However, by limiting the number of log data buffered in the memory, the log at the time of log acquisition can be reduced. It is also possible to limit the amount of memory used to a certain value or less.
[0044]
FIG. 16 is a diagram of a function definition file for instructing the software evaluation system for realizing the log acquisition method according to the second embodiment of the present invention, the format of each function and method parameter, and the format of the return value. It is an example. The DLL name and the function / method name are described, and the parameter and return type for the function / method are shown. The software evaluation system that implements the log acquisition method according to the present embodiment determines what parameters / return values each function / method has based on the contents instructed by the function definition file. Then, the contents are acquired as a log.
[0045]
FIG. 17 is an example of a log acquired by the software evaluation system that implements the log acquisition method according to the present embodiment using the function definition file shown in FIG. For each call, the time when the function / method is called and the parameters / return values at that time are generated as a log.
[0046]
FIG. 18 is a diagram showing a memory configuration when the log shown in FIG. 17 is stored in the memory. For each function call, the data and index are stored for a certain memory offset.
[0047]
FIG. 19 is a diagram showing a flow of processing in the software evaluation system that implements the log acquisition method according to the present embodiment.
[0048]
When processing is started by calling the set function / method (step S21), the register or memory area designated for the index count is cleared to zero (step S22) and buffered in the memory. The setting of the number of indexes is read (step S23). Next, the Index is stored in the Index area shown in FIG. 18 (step S24), the DLL name / function name / call time is stored in the memory (step S25), and the parameters for the call are stored in the memory. (Step S26), and a function / method is called (step S27).
[0049]
When the processing inside the function ends, the DLL name / function name / end time is stored in the memory (step S28), and the parameters and return values for the call are stored in the memory (step S29). Next, the setting read in step S23 is compared with the current index (step S30). If the setting is greater than or the same as the index, the log data is not moved to the HDD. The index is simply incremented (step S31), and the process returns to step S24. If the index is larger than the setting, the data held in the memory is moved to the HDD, and the contents of the memory are cleared to zero (step S32).
[0050]
This process is continued until the program to be evaluated ends (step S33).
[0051]
[Third Embodiment]
In the second embodiment, the number of indexes is counted in order to limit the amount of memory used at the time of log acquisition to a certain value or less. However, the number of indexes can also be limited by the size of log data.
[0052]
FIG. 20 is a diagram showing a flow of processing representing another example of the software evaluation system for realizing the log acquisition method according to the third embodiment of the present invention.
[0053]
When processing is started by calling the set function / method (step S41), the register or memory area designated for the index count is cleared to zero (step S42) and buffered in the memory. The log size setting is read (step S43). Next, the Index is stored in the Index area shown in FIG. 18 (Step S44), the DLL name / function name / call time is stored in the memory (Step S45), and the parameters for the call are stored in the memory. (Step S46) and call a function / method (step S47). When the processing inside the function ends, the DLL name / function name / end time is stored in the memory (step S48), and the parameters and return value for the call are stored in the memory (step S49).
[0054]
Next, the setting read in step S43 is compared with the size of data stored in the memory up to the current index (step S50), and the set size is larger than the size of the data stored in the memory. If it is larger or the same, the index is simply incremented without moving the log data to the HDD (step S51), and the process returns to step S44. If the size of the data stored in the memory is larger than the set size, the data stored in the memory is moved to the HDD by the amount up to the previous index, and the data up to the previous index is stored. The contents of the memory are cleared to zero (step S52). By moving the previous data from the memory to the HDD, it is possible to maintain a state where the memory usage does not exceed the specified size.
[0055]
This process is continued until the program to be evaluated ends (step S53).
[0056]
[Fourth Embodiment]
FIG. 21 is a diagram showing an example of a user interface for setting the functions shown in the second and third embodiments. As settings for performing log memory buffering, designation by the number of records, that is, designation by the index of the second embodiment, designation by log data size, that is, designation by the third embodiment is possible.
[0057]
[Fifth Embodiment]
In each of the above-described embodiments, the case where the amount of memory used at the time of log acquisition is reduced has been described. However, the amount of data in the log file stored in the HDD can also be reduced.
[0058]
FIG. 22 shows a function definition file for instructing the software evaluation system that implements the log acquisition method according to the fifth embodiment of the present invention, the format of each function and method parameter, and the format of the return value. It is a figure which shows an example. The DLL name and the function / method name are described, and the parameter and return type for the function / method are shown. The software evaluation system that implements the log acquisition method according to the present embodiment determines what parameters / return values each function / method has based on the contents instructed by the function definition file. , Get the contents as a log.
[0059]
As shown in FIG. The function definition for the function FuncAB in the DLL best represents this embodiment. In the argument, a pointer pBuf shown as a data storage destination and dwBufSize shown as the size of the data are defined. The correlation between pBuf and dwBufSize, that is, the size of data stored in pBuf is indicated by dwBufSize. Correlation is defined.
[0060]
FIG. 23 is an example of a log acquired by the software evaluation system that implements the log acquisition method according to the present embodiment using the function definition file shown in FIG. For each call, the time when the function / method is called and the parameters / return values at that time are generated as a log.
[0061]
As shown in FIG. The call log for the function FuncAB in the DLL, together with the function definition file of FIG. 22, best represents the features of this embodiment. Based on the function definition shown in FIG. 22, when calling to FuncAB, not only the value of pBuf as an argument but also dwBufSize, that is, 24 bytes of data on the address indicated by the value, The ID of the corresponding FuncAB call stored in the binary log file, that is, the Data ID, is stored in the log as additional information.
[0062]
FIG. 24 is an example showing the contents of the binary log file saved together with the log shown in FIG. DataID is stored as a tag, and binary data is stored for each DataID.
[0063]
The embodiments shown in the function definition file, log, and binary log shown in FIGS. 22 to 24 are effective regardless of whether the data to be indicated is input data, output data, or a return value. For example, even when a data address is returned as an output parameter from a function and a data size is output as a return value from the function, a log of the data body can be obtained in the same manner.
[0064]
FIG. 25 is a diagram showing the flow of processing in the software evaluation system that implements the log acquisition method according to the present embodiment.
[0065]
When processing is started by calling the set function / method (step S61), the DLL name / function name / calling time is stored in the HDD (step S62), and parameters for the calling are stored. Is stored in the HDD (step S63).
[0066]
Next, it is determined whether or not the parameter is defined as a memory address based on the function definition file shown in FIG. 22 (step S64). If it is defined, the data size is obtained from the argument indicating the size. (Step S65), the data corresponding to the size is read from the memory (Step S66), and the data is added to the data and stored in the binary log file of the HDD (Step S67). If the parameter is not defined as a memory address, the processing from step S65 to step S67 is not performed.
[0067]
When the processing inside the function ends (step S68), the DLL name / function name / end time is stored in the HDD (step S69), and the parameters and return value for the call are stored in the HDD (step S70). ).
[0068]
Next, it is determined whether or not the parameter is defined as a memory address based on the function definition file shown in FIG. 22 (step S71). If the parameter is defined, the data size is obtained from the argument indicating the size. (Step S72), the data corresponding to the size is read from the memory (Step S73), and the data is added to the data and saved in the binary log file of the HDD (Step S74). If the parameter is not defined as a memory address, the processing of steps S72 to S74 is not performed.
[0069]
This process is continued until the program to be evaluated ends (step S75).
[0070]
As is clear from the above description, when a parameter is defined as a memory address in the function definition file and binary data corresponding to the memory address is saved as a log file, binary of the size defined in the function definition file is stored. By storing only data as a log file, it is possible to reduce the amount of data in the log file stored in the HDD.
[0071]
[Sixth Embodiment]
In the fifth embodiment, when storing binary parameters (binary data in which parameters are defined as memory addresses and stored on the memory addresses), data corresponding to the data size acquired from the size argument is stored. However, it is possible not to store data larger than the specified size.
[0072]
FIG. 26 and FIG. 27 are diagrams showing another example of the processing flow of the software evaluation system that implements the log acquisition method according to the sixth embodiment of the present invention.
[0073]
When processing is started by calling the set function / method (step S81), the DLL name / function name / call time is stored in the HDD (step S82), and parameters for the call are stored. Is stored in the HDD (step S83).
[0074]
Next, it is determined whether or not the parameter is defined as a memory address based on the function definition file shown in FIG. 22 (step S84). If it is defined, the data size is acquired from the argument indicating the size. (Step S85). Next, it is determined whether or not there is an upper limit setting for binary data acquisition (step S86). If the upper limit setting is not performed, data for the entire size indicated in the argument representing the size is read from the memory ( In step S87), the data is stored in the binary log file of the HDD with DataID (step S88). If the upper limit has been set, data for the set upper limit size is read from the memory (step S89), and the data is stored in the binary log file of the HDD with DataID (step S90). If the parameter is not defined as a memory address, the processing from step S85 to S90 is not performed.
[0075]
When the processing inside the function ends (step S91), the DLL name / function name / call time is stored in the HDD (step S92), and the parameters for the call are stored in the HDD (step S93).
[0076]
Next, it is determined whether or not the parameter is defined as a memory address based on the function definition file shown in FIG. 22 (step S94). If it is defined, the data size is acquired from the argument indicating the size. (Step S95). Next, it is determined whether there is an upper limit setting for binary data acquisition (step S96). If no upper limit setting has been made, data for the entire size indicated in the argument representing the size is read from the memory ( In step S97), DataID is added and the data is stored in the binary log file of the HDD (step S98). If the upper limit has been set, data for the set upper limit size is read from the memory (step S99), and the data is stored in the binary log file of the HDD with DataID (step S100). If the parameter is not defined as a memory address, the processing from step S95 to S100 is not performed.
[0077]
This process is continued until the program to be evaluated ends (step S101).
[0078]
[Seventh embodiment]
FIG. 28 is a diagram showing an example of a user interface for setting the functions shown in the fifth and sixth embodiments. As a target to be saved in the log, there is a setting for whether to save a binary parameter together with an input parameter and an output parameter, and when the setting for saving a binary parameter is performed, the processing shown in the fifth embodiment is performed. Done. Further, when the setting for saving the binary parameter is made and the setting for not saving the data larger than the designated size is made and the size is designated, the processing shown in the sixth embodiment is performed. Is called.
[0079]
[Eighth embodiment]
FIG. 29 is a diagram showing a user interface that associates the DataID described in the basic log shown in FIG. 22 with the data in the DataID of the binary log shown in FIG. With such a user interface, it is possible to easily refer to data in DataID. In the normal log display, it is clearly indicated that the parameter is a parameter representing a memory address, and when the user selects the portion by mouse click or the like, data corresponding to the DataID is displayed.
[0080]
[Other Embodiments]
Note that the present invention can be applied to a system including a plurality of devices (for example, a host computer, an interface device, a reader, and a printer), and a device (for example, a copying machine and a facsimile device) including a single device. You may apply to.
[0081]
Another object of the present invention is to supply a storage medium storing software program codes for implementing the functions of the above-described embodiments to a system or apparatus, and the computer (or CPU or MPU) of the system or apparatus stores the storage medium. Needless to say, this can also be achieved by reading and executing the program code stored in the.
[0082]
In this case, the program code itself read from the storage medium realizes the functions of the above-described embodiment, and the storage medium storing the program code constitutes the present invention.
[0083]
As a storage medium for supplying the program code, for example, a floppy (registered trademark) disk, hard disk, optical disk, magneto-optical disk, CD-ROM, CD-R, magnetic tape, nonvolatile memory card, ROM, or the like is used. be able to.
[0084]
Further, by executing the program code read by the computer, not only the functions of the above-described embodiments are realized, but also an OS (operating system) operating on the computer based on the instruction of the program code. It goes without saying that a case where the function of the above-described embodiment is realized by performing part or all of the actual processing and the processing is included.
[0085]
Further, after the program code read from the storage medium is written in a memory provided in a function expansion board inserted into the computer or a function expansion unit connected to the computer, the function expansion is performed based on the instruction of the program code. It goes without saying that the CPU or the like provided in the board or the function expansion unit performs part or all of the actual processing, and the functions of the above-described embodiments are realized by the processing.
[0086]
【The invention's effect】
As described above, according to the present invention, it is possible to easily obtain a processing log of software divided into a plurality of modules, and to reduce the man-hours for analyzing the cause of software failure.
[Brief description of the drawings]
FIG. 1 is a diagram showing a configuration of a computer (software evaluation system) that implements a log acquisition method according to a first embodiment of the present invention.
FIG. 2 is a diagram showing a normal memory configuration at the time of loading a function, for explaining a log acquisition method according to the first embodiment of the present invention;
FIG. 3 is a diagram showing a memory configuration when using the IAT Patch of the software evaluation system that implements the log acquisition method according to the first embodiment of the present invention;
FIG. 4A is a diagram showing a state when using the IAT Patch of the software evaluation system that implements the log acquisition method according to the first embodiment of the present invention;
FIG. 4B is a diagram showing a flow of log acquisition processing of the software evaluation system that implements the log acquisition method according to the first embodiment of the present invention;
FIG. 5 is a diagram showing an internal configuration when using the IAT Patch of the software evaluation system according to the first embodiment of the present invention.
FIG. 6 is a diagram showing a normal memory configuration at the time of creating an instance of a COM server interface, for explaining a log acquisition method according to the first embodiment of the present invention;
FIG. 7 is a diagram showing a memory configuration when using the VTable Patch of the software evaluation system that implements the log acquisition method according to the first embodiment of the present invention;
FIG. 8A is a diagram showing a state when using the VTable Patch of the software evaluation system that implements the log acquisition method according to the first embodiment of the present invention;
FIG. 8B is a diagram showing a flow of log acquisition processing of the software evaluation system that implements the log acquisition method according to the first embodiment of the present invention;
FIG. 9 is a diagram showing an internal configuration of a software evaluation system that implements a log acquisition method according to the first embodiment of the present invention;
FIG. 10 is a diagram of a function definition file for instructing the software evaluation system that implements the log acquisition method according to the first embodiment of the present invention, the format of each function and method parameter, and the format of a return value; It is a figure which shows an example.
FIG. 11 is a diagram showing an example of a log acquired by the software evaluation system that implements the log acquisition method according to the first embodiment of the present invention using the function definition file shown in FIG.
FIG. 12 is a diagram illustrating a specific example regarding a packing option of a structure.
FIG. 13 is a diagram illustrating another example regarding a structure packing option;
FIG. 14 is a diagram illustrating another example regarding a structure packing option;
FIG. 15 is a diagram showing a flow of processing in the software evaluation system that implements the log acquisition method according to the first embodiment of the present invention;
FIG. 16 is a function definition file for instructing the software evaluation system that implements the log acquisition method according to the second embodiment of the present invention, the format of each function and method parameter, and the format of a return value; It is a figure which shows an example.
FIG. 17 is a diagram showing an example of a log acquired by a software evaluation system that implements a log acquisition method according to the second embodiment of the present invention using the function definition file shown in FIG. 16;
18 is a diagram showing a memory configuration when the log shown in FIG. 17 is stored in the memory.
FIG. 19 is a diagram showing a flow of processing in a software evaluation system that implements a log acquisition method according to the second embodiment of the present invention;
FIG. 20 is a diagram showing a flow of processing representing another example of a software evaluation system that implements a log acquisition method according to the third embodiment of the present invention;
FIG. 21 is a diagram showing an example of a user interface for setting the functions shown in the second and third embodiments of the present invention.
FIG. 22 is a function definition file for instructing the software evaluation system that implements the log acquisition method according to the fifth embodiment of the present invention, the format of each function and method parameter, and the format of a return value; It is a figure which shows an example.
FIG. 23 is a diagram showing an example of a log acquired by a software evaluation system that implements a log acquisition method according to the fifth embodiment of the present invention using the function definition file shown in FIG. 22;
FIG. 24 is a diagram showing the contents of a binary log file saved together with the log shown in FIG.
FIG. 25 is a diagram showing a flow of processing in a software evaluation system for realizing a log acquisition method according to a fifth embodiment of the present invention.
FIG. 26 is a diagram showing another example of the process flow of the software evaluation system that implements the log acquisition method according to the sixth embodiment of the present invention;
FIG. 27 is a diagram showing another example of the process flow of the software evaluation system that implements the log acquisition method according to the sixth embodiment of the present invention;
FIG. 28 is a diagram showing an example of a user interface for setting the functions shown in the fifth and sixth embodiments of the present invention.
29 is a diagram showing a user interface for associating DataID described in the basic log shown in FIG. 22 with data in the DataID of the binary log shown in FIG.
[Explanation of symbols]
1: CPU
2: Chipset
3: RAM
4: Hard disk controller
5: Display controller
6: Hard disk drive
7: CD-ROM drive
8: Display
11: Signal line connecting CPU and chipset
12: Signal line connecting chipset and RAM
13: Peripheral device bus connecting chipset and various peripheral devices
14: Signal line connecting hard disk controller and hard disk drive
15: Signal line connecting hard disk controller and CD-ROM drive
16: Signal line connecting display controller and display

Claims (10)

A dynamic link library that stores functions, an import function address table that stores addresses of the functions, a program storage unit that stores a target program that calls and executes functions in the dynamic link library, and a memory that stores programs a medium, and the log memory for temporarily storing the log has a disk device, and execution means for executing a program, rewriting the execution unit is realized by executing a program stored in the storage medium A log acquisition method for acquiring a log during execution of the target program in an information processing apparatus comprising:
The rewriting means loads a log acquisition function corresponding to each function in the dynamic link library into the dynamic link library and stores it in the import function address table before executing the target program. Rewriting the address of each function to the address of the corresponding function for log acquisition;
The call means is configured to acquire the log based on the address of the corresponding function for log acquisition after rewriting on the import function address table for the function to be called that the target program is to call. Starting a log acquisition means realized by calling a function and causing the execution means to execute;
The log acquisition means determining whether a parameter is defined as a structure in the function definition in the target program; and
If the parameter is defined as a structure, the log acquisition means, based on a packing option that defines the memory arrangement of the structure in the function definition, arranges the contents of the structure in the log memory, Recording the contents of the structure arranged in the memory as a log in the disk device;
The log acquisition unit calls the function to be called corresponding to the log acquisition function called by the calling unit, causes the execution unit to execute the call target function, and receives an execution result When,
A step of secondly determining whether or not a parameter or a return value is defined as a structure in the function definition in the target program;
If the parameter or the return value is defined as a structure, the arrangement unit arranges the contents of the structure in the log memory based on a packing option that defines the memory arrangement of the structure in the function definition. And recording the contents of the structure arranged in the memory as a log in the disk device;
The log acquisition unit includes a step of passing the execution result to the target program. A dynamic link library that stores functions, an import function address table that stores addresses of the functions, a program storage unit that stores a target program that calls and executes functions in the dynamic link library, and a memory that stores programs a medium, and the log memory for temporarily storing the log has a disk device, and execution means for executing a program, rewriting the execution unit is realized by executing a program stored in the storage medium A log acquisition method for acquiring a log during execution of the target program in an information processing apparatus comprising:
The rewriting means loads a log acquisition function corresponding to each function in the dynamic link library into the dynamic link library and stores it in the import function address table before executing the target program. Rewriting the address of each function to the address of the corresponding function for log acquisition;
The call unit is configured to acquire the log based on an address of the corresponding log acquisition function after rewriting on the import function address table for the function to be called that the call unit is to call. Starting a log acquisition means realized by calling a function and causing the execution means to execute;
The log acquisition unit stores a log related to the call by the calling unit in the log memory, calls the function to be called corresponding to the function for log acquisition called by the calling unit, and executes the call Causing the execution means to execute a target function;
The log acquisition means receiving an execution result of the function to be called and storing a log related to the execution result in the log memory;
The log acquisition unit compares the number of calls of the function to be called with a preset number of times, and if the number is less than the set number of times, incrementing the number of calls;
The log acquisition means, if the number of calls is larger than the set number of times, moving the log stored in the log memory to the disk device, and storing the log;
The log acquisition unit includes a step of passing the execution result to the target program. A dynamic link library that stores functions, an import function address table that stores addresses of the functions, a program storage unit that stores a target program that calls and executes functions in the dynamic link library, and a memory that stores programs a medium, and the log memory for temporarily storing the log has a disk device, and execution means for executing a program, rewriting the execution unit is realized by executing a program stored in the storage medium A log acquisition method for acquiring a log during execution of the target program in an information processing apparatus comprising:
The rewriting means loads a log acquisition function corresponding to each function in the dynamic link library into the dynamic link library and stores it in the import function address table before executing the target program. Rewriting the address of each function to the address of the corresponding function for log acquisition;
The call means is configured to acquire the log based on the address of the corresponding function for log acquisition after rewriting on the import function address table for the function to be called that the target program is to call. Starting a log acquisition means realized by calling a function and causing the execution means to execute;
The log acquisition unit stores a log related to the call by the calling unit in the log memory, calls the function to be called corresponding to the function for log acquisition called by the calling unit, and executes the call Causing the execution means to execute a target function;
The log acquisition means receiving an execution result of the function to be called and storing a log related to the execution result in the log memory;
The log acquisition means compares the size of the log stored in the log memory with a preset size, and moves the log stored in the log memory to the disk device if the size is larger than the set size. A process of storing,
The log acquisition unit includes a step of passing the execution result to the target program. A dynamic link library that stores functions, an import function address table that stores addresses of the functions, a program storage unit that stores a target program that calls and executes functions in the dynamic link library, and a memory that stores programs A medium, a log memory for temporarily storing a log, and an execution means for executing a program, the rewriting means realized by executing the program stored in the storage medium by the execution means, and a call A log acquisition method for acquiring a log during execution of the target program, in an information processing apparatus comprising:
The rewriting means loads a log acquisition function corresponding to each function in the dynamic link library into the dynamic link library and stores it in the import function address table before executing the target program. Rewriting the address of each function to the address of the corresponding function for log acquisition;
The call means is configured to acquire the log based on the address of the corresponding function for log acquisition after rewriting on the import function address table for the function to be called that the target program is to call. Starting a log acquisition means realized by calling a function and causing the execution means to execute;
The log acquisition means storing a log related to a call by the calling means in the log memory;
The log acquisition means identifies whether a parameter is defined as a memory address in the function definition in the target program, and when defined as a memory address, is defined in the function definition of the program, Reading the size of the parameter;
Storing binary data on the memory address in the log memory as a log of the read size;
Calling the function to be called corresponding to the function for log acquisition called by the calling means, causing the execution means to execute the function to be called, and receiving an execution result;
The log acquisition means storing a log related to the execution result in the log memory;
The log acquisition unit identifies whether a parameter or a return value is defined as a memory address in the function definition in the target program, and if defined as a memory address, defines in the function definition of the program Reading the size of the parameter or return value,
Storing binary data on the memory address in the log memory as a log of the read size;
The log acquisition unit includes a step of passing the execution result of the function to the target program. A dynamic link library that stores functions, an import function address table that stores addresses of the functions, a program storage unit that stores a target program that calls and executes functions in the dynamic link library, and a memory that stores programs a medium, and the log memory for temporarily storing the log has a disk device, and execution means for executing a program, rewriting the execution unit is realized by executing a program stored in the storage medium A log acquisition method for acquiring a log during execution of the target program in an information processing apparatus comprising:
The rewriting means loads a log acquisition function corresponding to each function in the dynamic link library into the dynamic link library and stores it in the import function address table before executing the target program. Rewriting the address of each function to the address of the corresponding function for log acquisition;
The call means is configured to acquire the log based on the address of the corresponding function for log acquisition after rewriting on the import function address table for the function to be called that the target program is to call. Starting a log acquisition means realized by calling a function and causing the execution means to execute;
The log acquisition means storing a log related to a call by the calling means in the log memory;
The log acquisition means identifies whether a parameter is defined as a memory address in the function definition in the target program, and when defined as a memory address, is defined in the function definition of the program, Reading the size of the parameter;
Storing binary data on the memory address in the log memory as a log of the read size;
Comparing the read size with a preset size, moving binary data for a smaller size from the log memory to the disk device, and storing it;
Calling the function to be called corresponding to the function for log acquisition called by the calling means, causing the execution means to execute the function to be called, and receiving an execution result;
The log acquisition means storing a log related to the execution result in the log memory;
The log acquisition unit identifies whether a parameter or a return value is defined as a memory address in the function definition in the target program, and if defined as a memory address, defines in the function definition of the program Reading the size of the parameter or return value,
Storing binary data on the memory address in the log memory as a log of the read size;
Comparing the read size with a preset size, moving binary data for a smaller size from the log memory to the disk device, and storing it;
The log acquisition unit includes a step of passing the execution result of the function to the target program. An interface that stores methods, the virtual address table storing an address of the method, a program storage means for storing a target program to be executed by calling a method in the interface, and a storage medium for storing the program, the log Rewriting means, log means for temporarily storing, disk device, and executing means for executing a program, the execution means being realized by executing a program stored in the storage medium , and a calling means A log acquisition method for acquiring a log during execution of the target program,
Before executing the target program, the rewriting means loads a method for log acquisition corresponding to each method in the interface into the interface, and corresponds the method address stored in the virtual address table. Rewriting the address of the method for acquiring the log,
The method for acquiring the log based on the address of the corresponding method for acquiring the log after the rewriting on the virtual address table for the method to be called that the target program is to call by the target program Starting log acquisition means realized by calling and causing the execution means to execute,
The log acquisition means determining whether or not a parameter is defined as a structure in the method definition in the target program; and
When the parameter is defined as a structure, the log acquisition means arranges the contents of the structure in the log memory based on a packing option that defines the memory arrangement of the structure in the method definition, Recording the contents of the structure arranged in the log memory as a log in the disk device;
The log acquisition unit calls the method to be called corresponding to the method for log acquisition called by the calling unit, causes the execution unit to execute the method to be called, and receives an execution result When,
A step of secondly determining whether or not a parameter or a return value is defined as a structure in the method definition in the target program;
In the case where the parameter or return value is defined as a structure, the arrangement means arranges the contents of the structure in the log memory based on a packing option that defines the memory arrangement of the structure in the method definition. And recording the contents of the structure arranged in the log memory as a log in the disk device;
The log acquisition unit includes a step of passing the execution result to the target program. An interface that stores methods, the virtual address table storing an address of the method, a program storage means for storing a target program to be executed by calling a method in the interface, and a storage medium for storing the program, the log Rewriting means, log means for temporarily storing, disk device, and executing means for executing a program, the execution means being realized by executing a program stored in the storage medium , and a calling means A log acquisition method for acquiring a log during execution of the target program,
Before executing the target program, the rewriting means loads a method for log acquisition corresponding to each method in the interface into the interface, and corresponds the method address stored in the virtual address table. Rewriting the address of the method for acquiring the log,
The method for acquiring the log based on the address of the corresponding method for acquiring the log after the rewriting on the virtual address table for the method to be called that the target program is to call by the target program Starting log acquisition means realized by calling and causing the execution means to execute,
The log acquisition unit stores a log related to the call by the calling unit in the log memory, calls the method to be called corresponding to the method for log acquisition called by the calling unit, and executes the call Causing the execution means to execute a target method;
The log acquisition means receiving an execution result of the method to be called and storing a log related to the execution result in the log memory;
The log acquisition unit compares the number of calls of the method to be called with a preset number of times, and if the number is less than or equal to the set number of times, increments the number of calls.
The log acquisition means, if the number of calls is larger than the set number of times, moving the log stored in the log memory to the disk device, and storing the log;
The log acquisition unit includes a step of passing the execution result to the target program. An interface that stores methods, the virtual address table storing an address of the method, a program storage means for storing a target program to be executed by calling a method in the interface, and a storage medium for storing the program, the log Rewriting means, log means for temporarily storing, disk device, and executing means for executing a program, the execution means being realized by executing a program stored in the storage medium , and a calling means A log acquisition method for acquiring a log during execution of the target program,
Said rewriting means, before execution of the target program, the address of the method that was loaded into the interface methods, stored on the virtual address table for the log acquisition for each method in the interface, the corresponding Rewriting the address of the method for acquiring the log,
The calling means calls the method for log acquisition based on the corresponding log acquisition address after rewriting on the virtual address table for the method to be called that the target program is to call. Starting the log acquisition means realized by causing the execution means to execute,
The log acquisition unit stores a log related to the call by the calling unit in the log memory, calls the method to be called corresponding to the method for log acquisition called by the calling unit, and executes the call Causing the execution means to execute a target method;
The log acquisition means receiving an execution result of the method to be called and storing a log related to the execution result in the log memory;
The log acquisition means compares the size of the log stored in the log memory with a preset size, and moves the log stored in the log memory to the disk device if the size is larger than the set size. A process of storing,
The log acquisition unit includes a step of passing the execution result to the target program. An interface that stores methods, the virtual address table storing an address of the method, a program storage means for storing a target program to be executed by calling a method in the interface, and a storage medium for storing the program, the log A log memory for temporary storage; and an execution means for executing a program, the execution means including a rewriting means realized by executing a program stored in the storage medium , and a calling means In the information processing apparatus, a log acquisition method for acquiring a log during execution of the target program,
Before executing the target program, the rewriting means loads a method for log acquisition corresponding to each method in the interface into the interface, and corresponds the method address stored in the virtual address table. Rewriting the address of the method for acquiring the log,
The method for acquiring the log based on the address of the corresponding method for acquiring the log after the rewriting on the virtual address table for the method to be called that the target program is to call by the target program Starting log acquisition means realized by calling and causing the execution means to execute,
The log acquisition means storing a log related to a call by the calling means in the log memory;
The log acquisition means identifies whether or not a parameter is defined as a memory address in the method definition in the target program, and when defined as a memory address, is defined in the method definition of the program, Reading the size of the parameter;
Storing binary data on the memory address in the log memory as a log of the read size;
Calling the method to be called corresponding to the method for log acquisition called by the calling unit, causing the execution unit to execute the method to be called, and receiving an execution result;
The log acquisition means storing a log related to the execution result in the log memory;
The log acquisition unit identifies whether a parameter or a return value is defined as a memory address in a method definition in the target program. If the parameter is defined as a memory address, it is defined in the method definition of the program. Reading the size of the parameter or return value,
Storing binary data on the memory address in the log memory as a log of the read size;
The log acquisition unit includes a step of passing the execution result of the method to the target program. An interface that stores methods, the virtual address table storing an address of the method, a program storage means for storing a target program to be executed by calling a method in the interface, and a storage medium for storing the program, the log Rewriting means, log means for temporarily storing, disk device, and executing means for executing a program, the execution means being realized by executing a program stored in the storage medium , and a calling means A log acquisition method for acquiring a log during execution of the target program,
Before executing the target program, the rewriting means loads a method for log acquisition corresponding to each method in the interface into the interface, and corresponds the method address stored in the virtual address table. Rewriting the address of the method for acquiring the log,
The method for acquiring the log based on the address of the corresponding method for acquiring the log after the rewriting on the virtual address table for the method to be called that the target program is to call by the target program Starting log acquisition means realized by calling and causing the execution means to execute,
The log acquisition means storing a log related to a call by the calling means in the log memory;
The log acquisition means identifies whether or not a parameter is defined as a memory address in the method definition in the target program, and when defined as a memory address, is defined in the method definition of the program, Reading the size of the parameter;
Storing binary data on the memory address in the log memory as a log of the read size;
Comparing the read size with a preset size, moving binary data for a smaller size from the log memory to the disk device, and storing it;
Calling the method to be called corresponding to the method for log acquisition called by the calling unit, causing the execution unit to execute the method to be called, and receiving an execution result;
The log acquisition means storing a log related to the execution result in the log memory;
The log acquisition unit identifies whether a parameter or a return value is defined as a memory address in a method definition in the target program. If the parameter is defined as a memory address, it is defined in the method definition of the program. Reading the size of the parameter or return value,
Storing binary data on the memory address in the log memory as a log of the read size;
Comparing the read size with a preset size, moving binary data for a smaller size from the log memory to the disk device, and storing it;
The log acquisition unit includes a step of passing the execution result of the method to the target program.

Images