JP4125054B2 - 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; , Data and 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 storing a log related to a call by the calling means in the log memory;
The log acquisition means is Log acquisition function In the function definition in The program storage means Determining whether a predetermined setting exists for a pointer parameter pointing to
When the log acquisition unit has a predetermined setting for the pointer parameter, the log acquisition unit points to the pointer parameter based on a definition method of the pointer parameter. The program storage means Recording the contents of the disk as a log on 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,
The log acquisition means storing a log related to the execution result in the log memory;
The log acquisition means is Log acquisition function In the function definition in The program storage means Determining whether a predetermined setting exists for a pointer parameter pointing to
When the log acquisition unit has a predetermined setting for the pointer parameter, the log acquisition unit points to the pointer parameter based on a definition method of the pointer parameter. The program storage means Recording the contents of the disk as a log on 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 explain the software evaluation system for realizing the log acquisition method according to the first embodiment of the present invention, first, how the software divided into a plurality of modules is loaded into the memory in a normal state according to FIG. 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 a 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 (175).
[0025]
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.
[0026]
[Second Embodiment]
In the present embodiment, a case will be described in which pointer parameter data that cannot normally be acquired is acquired as a binary log.
[0027]
FIG. 10 is an example of a function definition of the software evaluation system that implements the log acquisition method according to the present embodiment, and is described using IDL that is generally widely used. In the software evaluation system that implements the log acquisition method according to the present embodiment, a type library file obtained by tokenizing the IDL is used as a function definition file.
[0028]
FIG. 11 is a function definition of the software evaluation system that implements the log acquisition method according to the present embodiment, and by specifying binary acquisition for the pointer parameter, the substance of the pointer parameter data is acquired as a log. It is a description by IDL for this purpose.
[0029]
In the definition of the FuncBinidId function, custum (PAT_PARAM_ATTR_ID, “binid_is ()”) is declared for long * lplParam (201). Here, PAT_PARAM_ATTR_ID (200) is an identifier used by the software evaluation system in IDL. Here, by defining “binid_is ()”, data corresponding to the data type size (long type in this case) of the parameter from the pointer pointed to by the parameter is stored in the log as binary data.
[0030]
In the definition of the FuncSizeIs function, custum (PAT_PARAM_ATTR_ID, “size_is (dwCount)”) is declared for int * lplParam (202). Here, by defining “size_is (dwCount)”, this parameter is handled as having dwCount data as the first parameter. Then, data corresponding to (dwCount × parameter data type size (here, int type)) from the pointer pointed to by this parameter is stored in the log as binary data.
[0031]
In the definition of the FuncLengthIs function, custum (PAT_PARAM_ATTR_ID, “length_is (dwLength)”) is declared for char * lpszParam (203). Here, by defining “length_is (dwLength)”, this parameter is handled as having dwLength data as the first parameter. Then, data corresponding to (dwLength × parameter data type size (here, char type)) is stored in the log as binary data from the pointer pointed to by this parameter.
[0032]
In the definition of the FuncBytesIs function, custum (PAT_PARAM_ATTR_ID, “bytes_is (dwSize)”) is declared for void * lpParam (204). Here, by defining “bytes_is (dwSize)”, this parameter is handled as having dwSizes bytes as the first parameter. Then, dwSize bytes of data are stored in the log as binary data from the pointer pointed to by this parameter.
[0033]
In the definition of the FuncBytesIs1 function, void * lpParam is declared as custum (PAT_PARAM_ATTR_ID, “bytes_is (12)”) (205). Here, by defining “bytes_is (12)”, this parameter is handled as having 12 bytes of designated data. Then, 12 bytes of data are stored in the log as binary data from the pointer indicated by this parameter.
[0034]
FIG. 12 is a diagram showing a flow when acquiring a log when a function is defined as shown in FIG. 11 in the software evaluation system that implements the log acquisition method according to the present embodiment.
[0035]
When the process is started (step S1), log acquisition is started and the module name, interface name, and function / method name are stored in the HDD (step S2). Next, the log acquisition code stores in the HDD the time at the time of calling, the parameter, and the contents of the memory pointed to by the pointer parameter (step S3). Then, it is determined whether there is a binary acquisition setting in the function definition (step S4), and if it exists, the memory size to be stored is calculated for each definition method (binid_is, size_is, length_is, bytes_is) (step S5). The contents of the memory pointed to by the pointer parameter are stored in the HDD for the calculated size (step S6). Subsequently, the original function is called (step S7). When returning from the function, the log acquisition code stores the return time, the return value, and the contents of the memory indicated by the pointer parameter in the HDD (step S8). Then, it is determined whether there is a binary acquisition setting in the function definition (step S9), and if it exists, the memory size to be stored is calculated for each definition method (binid_is, size_is, length_is, bytes_is) (step S10). The contents of the memory pointed to by the pointer parameter are stored in the HDD for the calculated size (step S11). This process is terminated when an end command is issued from the user (step S12).
[0036]
FIG. 13 is a diagram of log data acquired by the definition of FIG. 11 in the software evaluation system that implements the log acquisition method according to the present embodiment.
[0037]
According to the function definition, the log (210) that can be acquired when there is no binary acquisition setting is a part excluding DataID. When the binary acquisition setting is performed, the DataID and the binary data log (211) can be acquired. For example, when comparing the FuncSizeIs logs, if there is no binary acquisition setting, only one int type data indicated by the pointer parameter lpParam can be acquired. However, this data actually points to an array of 10 int data. Therefore, when binary acquisition is set, it is possible to acquire a total of 40 bytes of data of 4 bytes × 10 as the size of int type data.
[0038]
As is clear from the above description, according to the present embodiment, by associating the size with the pointer parameter, it is possible to acquire the log of pointer parameter data that cannot normally be acquired as binary.
[0039]
[Third Embodiment]
In the present embodiment, a case will be described in which a non-exported function such as a callback function is acquired as a log.
[0040]
FIG. 14 is a description in IDL for acquiring, as a log, an unexported function such as a callback function in the function definition of the software evaluation system that implements the log acquisition method according to the present embodiment.
[0041]
In the definition of the FuncSetCallBack function, custom (PAT_PARAM_ATTR_ID, “funcname_is (FuncCallBack)”) is declared for the DWORD pfnFuncCallBack (221). The FuncSetCallBack function is a function for setting a callback function for a module, and DWORD pfnFuncCallBack is a parameter for setting the address of the callback function. Here, by defining “funcname_is (FuncCallBack)”, the log acquisition process recognizes the value passed to this parameter as the address of the FuncCallBack function (222) and replaces it with the address of the log acquisition process. Also, the original value is stored to call the original callback function during the log acquisition process. This makes it possible to obtain a log of callback functions that have not been exported.
[0042]
In the definition of the GetFuncPointer function, custom (PAT_PARAM_ATTR_ID, "funcname_is (FuncInternal") "is declared for DWORD pfnFuncInternal (223) The GetFuncPointer function is a function that obtains a pointer to an unexported function inside the module. DWORD pfnFuncInternal is a parameter for obtaining the pointer of the non-export function, and by defining it as "funcname_is (FuncInternal)", the log acquisition process is the value passed to this parameter. Is recognized as the address of the FuncInternal function (224) and replaced with the address of the log acquisition process, and the original value is saved to call the original non-export function during the log acquisition process. The log of the function inside the module can be acquired.
[0043]
The GetFuncPointeArray function (225) is a function for acquiring, in the FUNCPOINTERARRAY structure (220), the address of a function group that is not exported in the module. Here, custom (PAT_PARAM_ATTR_ID, “funcname_is (FuncInternal1-4)”) is declared for the definition of each member of FUNCPOINTERARRAY. Here, by defining “funcname_is (FuncInternal1 to 4)”), the value passed to the member of this structure is recognized as the address of the FuncInternal1 to 4 function (226) and replaced with the address of the log acquisition process. . Also, the original value is stored to call the original non-export function during the log acquisition process. As a result, it is possible to obtain a log of functions in the module that has not been exported.
[0044]
FIG. 15 is a diagram showing a memory configuration of the software evaluation system that implements the log acquisition method according to the present embodiment, and is different from FIG. 3 in that a code for acquiring a log of a hidden function is added. . FuncAD (231) in A.DLL is a function that has not been exported, and therefore does not exist in Import Address Table (230). At this time, if funcname_is is defined for FuncAD, FuncCAD (232) for log acquisition is generated in C.DLL, and when the value of the parameter defined by funcname_is that originally returns the FuncAD address is replaced, FuncCAD Address is used.
[0045]
FIG. 16 is a diagram showing a flow when acquiring a log when a function is defined as shown in FIG. 14 in the software evaluation system that implements the log acquisition method according to the present embodiment.
[0046]
When the process is started (step S21), log acquisition is started, and the module name, interface name, and function / method name are stored in the HDD (step S22). Next, the log acquisition code saves the time at the time of calling, the parameter, and the contents of the memory pointed to by the pointer parameter in the HDD (step S23). Then, it is determined whether or not the setting of funcname_is exists in the function definition (step S24). If it exists, the function definition defined by funcname_is is acquired from the function definition file, and for log acquisition processing based on the definition Is generated (step S25). Then, the value in which funcname_is is defined is stored and replaced with the address of the generated log acquisition code (step S26).
[0047]
Subsequently, the original function is called (step S27). When returning from the function, the log acquisition code stores the return time, the return value, and the contents of the memory pointed to by the pointer parameter in the HDD (step S28). Then, it is determined whether or not the setting of funcname_is exists in the function definition (step S29). If the function definition exists, the function definition defined by funcname_is is acquired from the function definition file, and log acquisition processing is performed based on the definition. A code is generated (step S30). Then, the value in which funcname_is is defined is stored and replaced with the address of the generated log acquisition code (step S31). This process is terminated when an end command is issued from the user (step S32).
[0048]
If the parameter set by funcname_is is replaced with the address of the generated log acquisition code, the original function called using that address will be processed in the same way as a normal log (that is, The generated log acquisition code calls a function that is not exported, executes the process, passes the received execution result, and receives the execution information and the predetermined information when calling the non-exported function. And record predetermined information).
[0049]
FIG. 17 is a diagram of log data acquired when the definition of FIG. 14 is not performed in the software evaluation system that implements the log acquisition method according to the present embodiment. If settings are not made in the function definition file, the log of callback functions and unexported internal functions cannot be acquired.
[0050]
FIG. 18 is a diagram of log data acquired from the definition of FIG. 14 in the software evaluation system that implements the log acquisition method according to the present embodiment. Since the function definition file is set to acquire callback functions and unexported internal functions, it is possible to acquire logs of non-export functions such as the FuncCallBack function, FuncInternal function, and FuncInternal4 function.
[0051]
As described above, according to the present embodiment, it is possible to obtain a log of a non-export function that cannot be obtained by a normal method.
[0052]
[Fourth Embodiment]
In the present embodiment, a case will be described in which a variable log array parameter log is acquired as a function log that cannot be acquired by a normal method.
[0053]
FIG. 19 is a description in IDL for acquiring a variable length array parameter as a log in the function definition of the software evaluation system that implements the log acquisition method according to the present embodiment.
[0054]
In the definition of the FuncArrayIs function, custum (PAT_PARAM_ATTR_ID, “array_is (dwCount)”) is declared for int * lpnParam (240). Here, by defining “array_is (dwCount)”, this pointer parameter is handled as an int type array corresponding to dwCount first parameters. Then, the pointer pointed to by this pointer parameter is set to an int type dwCount array, and the data is stored in the log.
[0055]
FIG. 20 is a flowchart for acquiring a log when a function is defined as shown in FIG. 19 in the software evaluation system for realizing the log acquisition method according to the present embodiment.
[0056]
When the process is started (step S41), log acquisition is started, and the module name, interface name, and function / method name are stored in the HDD (step S42). Next, it is determined whether or not a variable length array acquisition (array_is) setting exists in the function definition (step S43). If it exists, the parameter defined by the pointer parameter is treated as an array definition (step S44). The call time, parameters, and memory contents pointed to by the pointer parameters are stored in the HDD (step S45). Then, the original function is called (step S46). When returning from the function, the log acquisition code determines whether there is a variable length array acquisition (array_is) setting in the function definition (S47). If so, the parameter defined by the pointer parameter is used to define the array definition. (Step S48), the return time, the return value, and the memory contents pointed to by the pointer parameter are stored in the HDD (step S49). This process is terminated when an end command is issued from the user (step S50).
[0057]
FIG. 21 shows the log data (250) acquired when the definition of FIG. 19 is not performed in the software evaluation system for realizing the log acquisition method according to the present embodiment, and the log data ( 251). If the setting is not made in the function definition file, the pointer parameter cannot be handled as an array, so only the top data is obtained. However, if the setting is made in the function definition file, Since the pointer parameter is treated as an array, all the data of the array has been acquired.
[0058]
As described above, according to the present embodiment, it is possible to obtain a variable length array parameter log as a function log that cannot be obtained by a normal method.
[0059]
[Fifth Embodiment]
In the present embodiment, a case will be described in which a log is acquired for a function whose parameters cannot be acquired in a normal function definition.
[0060]
FIG. 22 is a software evaluation system that implements the log acquisition method according to the present embodiment, and is an example of a function whose parameters cannot be acquired with a normal function definition.
[0061]
Three types of structures, STRUCTSIZE1, STRUCTSIZE2, and STRUCTSIZE3, are defined. The DWORD dwSize member of each structure must contain the size of its own structure. The FuncGetData function sets which of the three types of structures is passed to the first parameter dwKind and the second parameter lpBuf. The FuncGetData function handles lpBuf as a pointer to STRUCTSIZE1 when the first parameter is 1, and treats lpBuf as a pointer to STRUCTSIZE2 when the first parameter is 2. When the parameter is 3, processing is performed by treating lpBuf as a pointer of STRUCTSIZE3. In this case, if FuncGetData is defined by normal function definition, lpBuf becomes a pointer of void type, and data cannot be acquired.
[0062]
FIG. 23 is a memory diagram showing how each structure of STRUCTSIZE1, STRUCTSIZE2, and STRUCTSIZE3 uses memory in FIG. Each member of the structure STRUCTSIZE1 (260) has DWORD dwSize (261) at offset 0x000, DWORD dwParam1 (262) at 0x0004, DWORD dwParam2 at 0x0008, and DWORD dwParam3 at 0x000C. The structure STRUCTSIZE2 (265) is the same as STRUCTSIZE1 from DWORD dwSize to DWORD dwParam3 (266 to 269), and DWORD dwParam4 (270) exists at 0x0010. STRUCTSIZE3 (271) is the same as STRUCTSIZE2 from DWORD dwSize to DWORD dwParam4 (272 to 276), and DWORD dwParam5 (277) exists at 0x0014. Thus, the memory allocation from STRUCTSIZE3 to dwSize to dwParam4 is the same as STRUCTSIZE2, and the memory allocation from STRUCTSIZE2 to dwSize to dwParam3 is the same as STRUCTSIZE1.
[0063]
FIG. 24 is a description in IDL for acquiring a function parameter log as shown in FIG. 22 in the software evaluation system for realizing the log acquisition method according to the present embodiment.
[0064]
In the original function, a structure separated from STRUCTSIZE1, STRUCTSIZE2, and STRUCTSIZE3 is defined as one structure called STRUCTSIZE (291). This definition is the same as that of STRUCTSIZE3, because STRUCTSIZE3 has the same memory arrangement as STRUCTSIZE1 and STRUCTSIZE2 from the memory arrangement in FIG. Then, [custum (PAT_PARAM_ID, “structsize_is ()”)] is set to DWORD dwSize which is a member of this structure and represents the size of the structure. This makes it possible for the log acquisition process to know the size of the structure when analyzing the structure data. In the FuncGetData function, the second parameter lpBuf is defined as a STRUCTSIZE type. In this way, when this parameter is stored as a log, processing is performed as a STRUCTSIZE type. If it is described in the function definition file so that STRUCTSIZE3 data is acquired without using this method, if GetFuncData is called with dwKind = 1 or 2, STRUCTSIZE1 or STRUCTSIZE2 data exists. And dwParam3 and dwParam4 data is going to be acquired in the log and a memory exception occurs.
[0065]
FIG. 25 is a diagram showing a flow when a log is acquired when a function is defined as shown in the figure in the software evaluation system that implements the log acquisition method according to the present embodiment.
[0066]
When the process is started (step S61), log acquisition is started and the module name, interface name, and function / method name are stored in the HDD (step S62). Next, it is determined whether or not a structure size specification (structsize_is) setting exists in the function definition (step S63). If there is a structure size data, the structure parameter data is set by the size specification (structsize_is) setting. Analysis is performed within the defined data size range (step S64). Then, the calling time, the parameter, and the contents of the memory pointed to by the pointer parameter are stored in the HDD (step S65). Then, the original function is called (step S66). When the function returns, it is determined whether or not the structure size specification (structsize_is) setting exists in the function definition (step S67). If there is, the structure parameter data set is specified as the size specification (structsize_is). The analysis is performed within the data size range defined in the setting (step S68). Then, the return time, return value, and memory contents pointed to by the pointer parameter are stored in the HDD (step S69). This process is terminated when an end command is issued from the user (step S70).
[0067]
FIG. 26 is a diagram showing details of the structure parameter analysis performed in FIG. 25 based on the memory arrangement.
[0068]
When GetFuncData is used with dwKind = 1 in an actual program, the STRUCTSIZE1 structure (300) is used, and the memory usage of each member (301 to 304) at that time is as shown in the figure. If the function is defined as shown in FIG. 24, this software evaluation system recognizes it as a STRUCTSIZE structure (305), and estimates that the memory usage of each member (306-311) at that time is as shown in the figure. To do. If there is a setting for size specification (structsize_is), it is possible to know that the size of the structure is dwSize bytes by examining the value of dwSize, and dwSize bytes of the STRUCTSIZE structure ( Only the data 312) is acquired as a log.
[0069]
FIG. 27 is a diagram of log data acquired by the definition of FIG. 24 in the software evaluation system that implements the log acquisition method according to the present embodiment. In a normal function definition, it becomes void *, and data of a structure that can be obtained only by a pointer is obtained as a log depending on the type of structure used.
[0070]
As described above, according to the present embodiment, it is possible to obtain a log of parameters that cannot be obtained by a normal method.
[0071]
[Sixth Embodiment]
FIG. 28 is an example of a function that cannot acquire parameters in a normal function definition in the software evaluation system that implements the log acquisition method according to the present embodiment.
[0072]
Three types of structures, STRUCTKIND1, STRUCTKIND2, and STRUCTKIND3, are defined. The GetFuncData function sets which of the three types of structures is passed to the second parameter lpBuf to the first parameter dwKind. The FuncGetData function handles lpBuf as a pointer to STRUCTKIND1 when the first parameter is 1, and treats lpBuf as a pointer to STRUCTKIND2 when the first parameter is 2. When the parameter is 3, processing is performed by treating lpBuf as a STRUCTKIND3 pointer. In this case, if FuncGetData is defined by normal function definition, lpBuf becomes a pointer of void type, and data cannot be acquired.
[0073]
FIG. 29 is a diagram showing the memory arrangement of each structure of STRUCTKIND1, STRUCTKIND2, and STRUCTKIND3 in FIG. Each member of the structure STRUCTKIND1 (330) has a char chParam (331) at an offset 0x0000, a DWORD dwParam (332) at 0x0001, and a short shParam (333) at 0x0005. Each member of the structure STRUCTKIND2 (334) has short shParam (335) at offset 0x0000, DWORD dwParam (336) at 0x0002, and char chParam (337) at 0x0006. Each member of structure STRUCTKIND3 (338) has char chParam (339) at offset 0x0000, short shParam (340) at 0x0001, DWORD dwParam (341) at 0x0003, long lParam (342) at 0x0007, and int nParam at 0x000B Exists. As described above, since there is no size information in each structure and the memory structure of the structure data is different, the method shown in the fifth embodiment cannot be used.
[0074]
FIG. 30 is a description in IDL for acquiring a function parameter log as shown in FIG. 28 in the software evaluation system for realizing the log acquisition method according to the present embodiment.
[0075]
Each structure is defined in the usual way. [Custum (PAT_PARAM_ID, "structkind_is (dwKind: 1: STRUCTKIND1 *, 2: STRUCTKIND2 *, 3: STRUCTKIND3 *)"]] is set for the second parameter void * lpBuf of the FuncGetData function. As a result, the data type of lpBuf is treated as STRUCTKIND1 * when the value of the first parameter dwKind is 1, as STRUCTKIND2 * when 2 and as STRUCTKIND3 * when 3, and saved as a log Is done.
[0076]
FIG. 31 is a diagram showing a flow when a log is acquired when a function is defined as shown in FIG. 30 in the software evaluation system that implements the log acquisition method according to the present embodiment.
[0077]
When the process is started (step S81), log acquisition is started, and the module name, interface name, and function / method name are stored in the memory (step S82). Next, it is determined whether or not a structure type specification (structkind_is) setting exists in the function definition (step S83). If there is a structure type, the structure parameter data is set by the type specification (structkind_is) setting. Analysis is performed as a defined data type (step S84). Then, the time at the time of calling, the parameter, and the contents of the memory pointed to by the pointer parameter are stored in the memory (step S85). Then, the original function is called (step S86). When returning from the function, it is determined whether or not a structure type specification (structkind_is) setting exists in the function definition (step S87). If it exists, the data of the set structure parameter is specified (structkind_is). It is analyzed as a data type defined in the setting (step S88). Then, the return time, the return value, and the contents of the memory indicated by the pointer parameter are stored in the memory (step S89). This process is terminated when an end command is issued from the user (step S90).
[0078]
FIG. 32 is a diagram of log data acquired by the definition of FIG. 30 in the software evaluation system that implements the log acquisition method according to the present embodiment. In a normal function definition, it becomes void *, and data of a structure that can be obtained only by a pointer is obtained as a log depending on the type of structure used.
[0079]
As described above, according to the present embodiment, it is possible to obtain a log of parameters that cannot be obtained by a normal method.
[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 illustrating an example of a function definition of a software evaluation system that implements a log acquisition method according to a second embodiment of the present invention.
FIG. 11 is a function definition of the software evaluation system that implements the log acquisition method according to the second embodiment of the present invention. By specifying binary acquisition for the pointer parameter, It is a figure which shows the description by IDL for acquiring an entity as a log.
FIG. 12 is a diagram showing a flow when acquiring a log when a function is defined as shown in FIG. 11 in the software evaluation system that implements the log acquisition method according to the second embodiment of the present invention; .
FIG. 13 is a diagram of log data acquired according to the definition of FIG. 11 in the software evaluation system that implements the log acquisition method according to the second embodiment of the present invention;
FIG. 14 is an example of IDL for acquiring an unexported function such as a callback function as a log in the function definition of the software evaluation system that implements the log acquisition method according to the third embodiment of the present invention; It is a figure which shows description.
FIG. 15 is a diagram showing a memory configuration of a software evaluation system that implements a log acquisition method according to a third embodiment of the present invention;
FIG. 16 is a diagram showing a flow when acquiring a log when a function is defined as shown in FIG. 14 in the software evaluation system that implements the log acquisition method according to the third embodiment of the present invention; .
FIG. 17 is a diagram of log data acquired when the definition of FIG. 14 is not performed in the software evaluation system that implements the log acquisition method according to the third embodiment of the present invention;
FIG. 18 is a diagram of log data acquired from the definition of FIG. 14 in the software evaluation system that implements the log acquisition method according to the third embodiment of the present invention;
FIG. 19 is a diagram showing a description by IDL for acquiring a variable length array parameter as a log in the function definition of the software evaluation system for realizing the log acquisition method according to the fourth embodiment of the present invention; .
FIG. 20 is a diagram showing a flow when acquiring a log when a function is defined as shown in FIG. 19 in the software evaluation system that implements the log acquisition method according to the fourth embodiment of the present invention; .
21 is a software evaluation system that implements a log acquisition method according to the fourth embodiment of the present invention. Log data (250) acquired when the definition of FIG. 19 is not performed, and acquired according to the definition of FIG. It is the figure of the done log data (251).
FIG. 22 is a diagram illustrating an example of a function in which a parameter cannot be acquired with a normal function definition in a software evaluation system that implements a log acquisition method according to a fifth embodiment of the present invention;
FIG. 23 is a diagram showing how each structure of STRUCTSIZE1, STRUCTSIZE2, and STRUCTSIZE3 uses memory in FIG. 22;
FIG. 24 is a diagram showing a description by IDL for acquiring a function parameter log as shown in FIG. 22 in the software evaluation system for realizing the log acquisition method according to the fifth embodiment of the present invention;
FIG. 25 is a diagram showing a flow when acquiring a log when a function is defined as shown in the figure in the software evaluation system that implements the log acquisition method according to the fifth embodiment of the present invention;
FIG. 26 is a diagram showing details of the structure parameter analysis performed in FIG. 25 based on the memory arrangement.
FIG. 27 is a diagram of log data acquired according to the definition of FIG. 24 in the software evaluation system that implements the log acquisition method according to the fifth embodiment of the present invention;
FIG. 28 is a diagram illustrating an example of a function in which a parameter cannot be acquired with a normal function definition in a software evaluation system that implements a log acquisition method according to a sixth embodiment of the present invention;
FIG. 29 is a diagram showing the memory arrangement of each structure of STRUCTKIND1, STRUCTKIND2, and STRUCTKIND3 in FIG.
FIG. 30 is a diagram showing description by IDL for acquiring a function parameter log as shown in FIG. 28 in the software evaluation system for realizing the log acquisition method according to the sixth embodiment of the present invention;
FIG. 31 is a diagram showing a flow when acquiring a log when a function is defined as shown in FIG. 30 in a software evaluation system for realizing a log acquisition method according to a sixth embodiment of the present invention; .
FIG. 32 is a diagram of log data acquired by the definition of FIG. 30 in the software evaluation system that implements the log acquisition method according to the sixth embodiment of the present invention;
[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 target program that calls and executes functions in the dynamic link library, program storage means that stores data, and a program A storage medium for storing, a log memory for temporarily storing a log, a disk device, and an execution means for executing a program are implemented, and the execution means executes the program stored in the storage medium. In the information processing apparatus comprising the rewriting means and the calling means, a log acquisition method for acquiring a log during execution of the target program,
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 determining whether a predetermined setting exists for a pointer parameter indicating the program storage means in the function definition in the function for log acquisition ; and
When the log acquisition unit has a predetermined setting for the pointer parameter, the contents of the program storage unit pointed to by the pointer parameter are stored in the disk device as a log based on the pointer parameter definition method. Recording process;
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,
The log acquisition means storing a log related to the execution result in the log memory;
The log acquisition means determining whether a predetermined setting exists for a pointer parameter indicating the program storage means in the function definition in the function for log acquisition ; and
When the log acquisition unit has a predetermined setting for the pointer parameter, the contents of the program storage unit pointed to by the pointer parameter are stored in the disk device as a log based on the pointer parameter definition method. A log acquisition method comprising: a step of recording; and the log acquisition unit includes a step of passing the execution result to the target program. The log acquisition unit further includes a step of calculating a memory size based on the definition method, and in the recording step, the content of the program storage unit pointed to by the pointer parameter is the amount of the calculated memory size, The log acquisition method according to claim 1, wherein recording is performed in a disk device. A dynamic link library that stores functions, an import function address table that stores addresses of the functions, a target program that calls and executes functions in the dynamic link library, program storage means that stores data, and a program A storage medium for storing, a log memory for temporarily storing a log, a disk device, and an execution means for executing a program are implemented, and the execution means executes the program stored in the storage medium. In the information processing apparatus comprising the rewriting means and the calling means, a log acquisition method for acquiring a log during execution of the target program,
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 step of determining whether the log acquisition means defines a pointer parameter as a variable length array in the function definition in the function for acquiring the log ; and
The log acquisition means, when the pointer parameter is defined as a variable length array, the contents of the program storage means pointed to by the pointer parameter is recorded in the disk device in the defined array;
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,
The log acquisition means storing a log related to the execution result in the log memory;
The step of determining whether the log acquisition means defines a pointer parameter as a variable length array in the function definition in the function for acquiring the log ; and
The log acquisition means, when the pointer parameter is defined as a variable length array, the contents of the program storage means pointed to by the pointer parameter is recorded in the disk device in the defined array;
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 target program that calls and executes functions in the dynamic link library, program storage means that stores data, and a program A storage medium for storing, a log memory for temporarily storing a log, a disk device, and an execution means for executing a program are implemented, and the execution means executes the program stored in the storage medium. In the information processing apparatus comprising the rewriting means and the calling means, a log acquisition method for acquiring a log during execution of the target program,
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 determining whether a pointer parameter is specified as a structure in the function definition in the function for log acquisition ; and
When the pointer parameter is defined as a structure, the log acquisition unit logs the contents of the program storage unit pointed to by the pointer parameter by the size of the structure defined in the function definition in the program. Recording on the disk device as
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,
The log acquisition means storing a log related to the execution result in the log memory;
The log acquisition means determining whether a pointer parameter is specified as a structure in the function definition in the function for log acquisition ; and
When the pointer parameter is defined as a structure, the log acquisition unit logs the contents of the program storage unit pointed to by the pointer parameter by the size of the structure defined in the function definition in the program. Recording on the disk device as
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 target program that calls and executes functions in the dynamic link library, program storage means that stores data, and a program A storage medium for storing, a log memory for temporarily storing a log, a disk device, and an execution means for executing a program are implemented, and the execution means executes the program stored in the storage medium. In the information processing apparatus comprising the rewriting means and the calling means, a log acquisition method for acquiring a log during execution of the target program,
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 step of determining whether the log acquisition means defines a pointer parameter whose type is specified as a structure in the function definition in the function for acquiring the log ;
When the log acquisition means defines a pointer parameter for which the type is specified as a structure, the contents of the program storage means pointed to by the pointer parameter are used as the data type for which the type is specified. The process of recording in
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,
The log acquisition means storing a log related to the execution result in the log memory;
The step of determining whether the log acquisition means defines a pointer parameter whose type is specified as a structure in the function definition in the function for acquiring the log ;
When the log acquisition means defines a pointer parameter for which the type is specified as a structure, the contents of the program storage means pointed to by the pointer parameter are stored in the disk device as a data type for which the type is specified. Recording process;
The log acquisition unit includes a step of passing the execution result to the target program. An interface storing a method, a virtual address table storing an address of the method, a target program to call and execute a method in the interface, program storage means for storing data, and a storage medium for storing the program , a log memory for temporarily storing the log, a disk device, and an execution unit for executing a program, and rewriting means for 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 a calling unit,
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 by the handling program to be called by the handling 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 determining whether or not a predetermined setting exists for a pointer parameter indicating the program storage means in a method definition in the method for log acquisition ; and
When the log acquisition unit has a predetermined setting for the pointer parameter, the contents of the program storage unit pointed to by the pointer parameter are stored in the disk device as a log based on the pointer parameter definition method. Recording process;
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,
The log acquisition means storing a log related to the execution result in the log memory;
The step of determining whether the log acquisition unit has a predetermined setting for a pointer parameter indicating a memory in a method definition in the method for acquiring the log ; and
When the log acquisition unit has a predetermined setting for the pointer parameter, the contents of the program storage unit pointed to by the pointer parameter are stored in the disk device as a log based on the pointer parameter definition method. A log acquisition method comprising: a step of recording; and the log acquisition unit includes a step of passing the execution result to the target program. The log acquisition unit further includes a step of calculating a memory size based on the definition method, and in the recording step, the content of the program storage unit pointed to by the pointer parameter is the amount of the calculated memory size, The log acquisition method according to claim 6, wherein recording is performed on a disk device. An interface storing a method, a virtual address table storing an address of the method, a target program to call and execute a method in the interface, program storage means for storing data, and a storage medium for storing the program , a log memory for temporarily storing the log, a disk device, and an execution unit for executing a program, and rewriting means for 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 a calling unit,
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 determining whether a pointer parameter is defined as a variable-length array in a method definition in the method for acquiring the log ; and
The log acquisition means, when the pointer parameter is defined as a variable length array, the contents of the program storage means pointed to by the pointer parameter is recorded in the disk device in the defined array;
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,
The log acquisition means storing a log related to the execution result in the log memory;
The log acquisition means determining whether a pointer parameter is defined as a variable-length array in a method definition in the method for acquiring the log ; and
The log acquisition means, when the pointer parameter is defined as a variable length array, the contents of the program storage means pointed to by the pointer parameter is recorded in the disk device in the defined array;
The log acquisition unit includes a step of passing the execution result to the target program. An interface storing a method, a virtual address table storing an address of the method, a target program to call and execute a method in the interface, program storage means for storing data, and a storage medium for storing the program , a log memory for temporarily storing the log, a disk device, and an execution unit for executing a program, and rewriting means for 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 a calling unit,
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 determining whether a pointer parameter is specified as a structure in a method definition in the method for acquiring the log ; and
When the pointer parameter is defined as a structure, the log acquisition unit logs the contents of the program storage unit pointed to by the pointer parameter by the size of the structure defined in the method definition in the program. Recording on the disk device as
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,
The log acquisition means storing a log related to the execution result in the log memory;
The log acquisition means determining whether a pointer parameter is specified as a structure in a method definition in the method for acquiring the log ; and
When the pointer parameter is defined as a structure, the log acquisition unit logs the contents of the program storage unit pointed to by the pointer parameter by the size of the structure defined in the method definition in the program. Recording on the disk device as
The log acquisition unit includes a step of passing the execution result to the target program. Interface storing method, virtual address table storing method address, target program for calling and executing method in the interface, program storage means for storing data, and storage medium for storing program When the log memory for temporarily storing the log, a disk device, and an execution means for executing a program, rewriting means for the execution unit is realized by executing a program stored in the storage medium And a log acquisition method for acquiring a log during execution of the target program in an information processing apparatus comprising a calling unit,
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 step of determining whether the log acquisition means defines a pointer parameter whose type is specified as a structure in the method definition in the method for acquiring the log ;
When the log acquisition means defines a pointer parameter for which the type is specified as a structure, the contents of the program storage means pointed to by the pointer parameter are used as the data type for which the type is specified. The process of recording in
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,
The log acquisition means storing a log related to the execution result in the log memory;
The step of determining whether the log acquisition means defines a pointer parameter whose type is specified as a structure in the method definition in the method for acquiring the log ;
When the log acquisition means defines a pointer parameter for which the type is specified as a structure, the contents of the program storage means pointed to by the pointer parameter are used as the data type for which the type is specified. The process of recording in
The log acquisition unit includes a step of passing the execution result to the target program.

Images