JP4125055B2 - 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, The The 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; Log recording means for recording a log; and 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 unit, a selection unit, and a calling unit realized by executing a program stored in
The selection means is for the functions in the dynamic link library. list User from inside But Selection instruction Function Functions that should get logs As A selection process to select;
The rewriting means loads a function for log acquisition corresponding to each function selected in the selection step into the dynamic link library and stores it in the import function address table before executing the target program. Rewriting the address of the selected function with the address of the function for acquiring the corresponding log;
Log acquisition realized by the calling means calling the function for log acquisition and causing the execution means to execute based on the rewritten address on the import function address table for the selected function Invoking means;
The log acquisition unit records a log related to the call by the calling unit in the log recording unit, calls the selected function corresponding to the function for log acquisition called by the calling unit, and Causing the execution means to execute a selected function;
The log acquisition unit includes a step of receiving an execution result of the selected function, recording a log related to the execution result in the log recording unit, and 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 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 (175).
[0025]
<User interface>
FIG. 10 is a user interface for setting a function / method for starting log acquisition in the software evaluation system that implements the log acquisition method according to the first embodiment of the present invention.
[0026]
The user interface is exported with the drop-down list (183, 184) for selecting which module / interface to set from the module / interface (181) subject to log acquisition, and the module / interface selected there. A drop-down list (185, 186) for selecting which function / method is set from the function / method (182) that is set.
[0027]
FIG. 11 is a diagram showing a flow when a log is acquired according to the contents set in FIG. 10 in the software evaluation system that implements the log acquisition method according to the first embodiment of the present invention.
[0028]
When the process is started (step S1), the log acquisition code determines whether the called function / method is set as a log acquisition start trigger (step S2). If it matches the log acquisition start trigger, log acquisition is started, and the module name, interface name, and function / method name are stored in the HDD (step S3). Next, the log acquisition code stores the calling time, parameters, and memory contents pointed to by the pointer parameters in the HDD (step S4), and calls the original function / method (step S5). When returning from the function / method, 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 S6). This process is continued until an end command is issued from the user (step S7), but at that time, the log acquisition start trigger is not determined.
[0029]
As is apparent from the above description, according to the present embodiment, in acquiring a processing log of software divided into a plurality of modules, any function / preparation provided in the module can be obtained without changing the module itself. Processing logs can be easily acquired from the method, which has the effect of reducing the man-hours for analyzing the cause of failures in software. Furthermore, by making it possible to arbitrarily select a function / method for acquiring a log, an effect of facilitating log analysis is brought about.
[0030]
[Second Embodiment]
In the first embodiment, the user interface that allows the user to arbitrarily select a function / method for acquiring a log has been described. In the present embodiment, a function / method for stopping log acquisition is arbitrarily selected. A possible user interface is described.
[0031]
FIG. 12 is a user interface for setting a function / method for stopping log acquisition in the software evaluation system that implements the log acquisition method according to the present embodiment.
[0032]
The user interface is exported with the drop-down list (189, 190) for selecting which module / interface to set from the module / interface (187) that is the log acquisition target, and the module / interface selected there. A drop-down list (191, 192) for selecting which function / method to set from the existing function / method (188).
[0033]
FIG. 13 is a diagram illustrating a flow when a log is acquired according to the contents set in FIG. 12 in the software evaluation system that implements the log acquisition method according to the present embodiment.
[0034]
When the process is started (step S9), log acquisition is started, and the module name, interface name, and function / method name are stored in the HDD (step S10). Next, the log acquisition code stores the calling time, parameters, and memory contents pointed to by the pointer parameters in the HDD (step S11), and calls the original function / method (step S12). When returning from the function / method, 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 S13). Thereafter, it is determined whether the called function / method is set as a log acquisition stop trigger (step S14). If it coincides with the log acquisition stop trigger, the log acquisition process ends (step S16). Even when the log acquisition stop trigger does not coincide with the log acquisition stop trigger, this process is ended when the user gives an end command (step S15).
[0035]
As a result, the log acquisition of an arbitrary function / method can be stopped, and only the log requested by the user can be acquired, which brings about an effect that the analysis of the log becomes easy.
[0036]
[Third Embodiment]
In the user interfaces described in the first and second embodiments above, the user arbitrarily selects log acquisition start / stop using an arbitrary function / method selected by the user. It is also possible to set to start / stop log acquisition only when a function / method ends with an error.
[0037]
FIG. 14 shows a trigger function (only when a user interface for setting a function / method for starting / stopping log acquisition is terminated due to an error in the software evaluation system for realizing the log acquisition method according to the present embodiment). The setting to use the log acquisition start / stop function) is added. This user interface can be applied to both FIG. 10 and FIG.
[0038]
The user interface is exported with the drop-down list (195, 196) for selecting which module / interface to set from the module / interface (193) that is the log acquisition target, and the module / interface selected there. Drop-down list (197, 198) for selecting which function / method to set from the function / method (194) that is set, and a check to enable the trigger function only when the function / method ends with an error With a box.
[0039]
FIG. 15 shows the contents of function / method error definitions in the software evaluation system that implements the log acquisition method according to the present embodiment. In this embodiment, an error definition is a file, and parameters and return values of each function / method, error conditions thereof, and the like are defined and described in the file.
[0040]
FIG. 16 is a diagram showing a flow when a log is acquired in accordance with the contents set in FIG. 14 of the software evaluation system that realizes the log acquisition method according to the present embodiment, and is triggered only at the start of log acquisition and an error. This is the case where the function that uses is set together.
[0041]
When the process is started (step S17), the log acquisition code determines whether the called function / method is set as a log acquisition start trigger (step S18). If it is set as a log acquisition start trigger, the module name, interface name, and function / method name are temporarily stored in the memory (step S19).
[0042]
Next, the log acquisition code temporarily stores the time at the time of calling, the parameter, and the contents of the memory indicated by the pointer parameter in the memory (step S20), and calls the original function / method (step S21). When returning from the method, the log acquisition code temporarily stores the return time, the return value, and the contents of the memory indicated by the pointer parameter in the memory (step S22).
[0043]
Next, it is determined whether the log acquisition start trigger is used only for an error (step S23). If so, it is determined whether the function / method is an error (step S24). If it is not an error, the log stored in the temporary memory is discarded (step S25), and the process returns to the beginning. If the function / method is an error, the log stored in the temporary memory is stored in the HDD (step S26), and normal log acquisition processing is continued (step S27). This process is continued until an end command is received from the user (step S28).
[0044]
FIG. 17 is a diagram showing a detailed flow of the normal log acquisition process shown in step S27 of FIG. 16 in the software evaluation system that implements the log acquisition method according to the present embodiment.
[0045]
When the process is started (step S30), log acquisition is started, and the module name, interface name, and function / method name are stored in the HDD (step S31). Next, the log acquisition code stores the calling time, parameters, and memory contents pointed to by the pointer parameters in the HDD (step S32), and calls the original function / method (step S33). When returning from the function / method, 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 S34).
[0046]
FIG. 18 is a diagram showing a flow when a log is acquired in accordance with the contents set in FIG. 14 of the software evaluation system that realizes the log acquisition method according to the present embodiment. This is the case where the setting is used together with the function that uses.
[0047]
When the process is started (step S40), log acquisition is started and the module name, interface name, and function / method name are stored in the HDD (step S41). Next, the log acquisition code stores the calling time, parameters, and memory contents pointed to by the pointer parameters in the HDD (step S42), and calls the original function / method (step S43). When returning from the function / method, 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 S34). Thereafter, it is determined whether the called function / method is set as a log acquisition stop trigger (step S45). If it matches the log acquisition stop trigger, it is next determined whether or not the log acquisition stop trigger is used only for an error (step S46), and if so, it is determined whether the function / method is an error ( Step S47). If there is an error, the log acquisition process ends (step S48). Further, this process is terminated when an instruction for termination is issued from the user (step S49).
[0048]
This makes it possible to start or stop log acquisition when an error occurs in any function / method, acquire the log requested by the user, and analyze the log. The effect is that it becomes easier.
[0049]
[Fourth Embodiment]
In the user interfaces in the first to third embodiments, the selectable functions / methods are merely arranged in a predetermined order. However, the user interface is a tree display so that the relationship between the interfaces and methods can be easily grasped. Also good.
[0050]
FIG. 19 relates to a user interface for displaying a tree of interfaces and methods in a software evaluation system that implements a log acquisition method according to the fourth embodiment of the present invention.
[0051]
The user interface is provided with a view (200) for displaying a tree of interfaces and methods. When the user checks the interface InterfaceA (201), all the methods MethodAA, MethodAB, and MethodAC (202 to 204) in the interface are all selected and become logs acquisition targets. Also, by unchecking the interface InterfaceB (205), all the methods MethodBA, MethodBB, and MethodBC (205 to 208) in the interface are all deselected and excluded from log acquisition targets.
[0052]
FIG. 20 is a diagram showing a flow of processing when acquiring a log when a log acquisition target is selected as shown in FIG. 19 in the software evaluation system according to the present embodiment.
[0053]
When the process is started (step S51), the log acquisition code determines whether the interface of the method is a log acquisition target every time an interface method is called (step S52). If it is a log acquisition target, the module name, interface, and method name are stored in the HDD (step S53).
[0054]
Next, the log acquisition code stores 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 S54), and calls the original method (step S55). When returning from the method, 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 S56). This process is continued until an end command is received from the user (step S57).
[0055]
As a result, the relationship between the interface and the method can be more easily known, and the interface from which the log is to be acquired can be easily selected, and the user can easily obtain the desired log.
[0056]
[Fifth Embodiment]
In the first to third embodiments, when an arbitrary method is selected, selection is performed in units of interfaces. However, selection can be performed in units of methods.
[0057]
FIG. 21 relates to a user interface that displays a tree of interfaces and methods in the software evaluation system that implements the log acquisition method according to the present embodiment, and is the same as FIG. 19, but the selection method is different.
[0058]
The user interface is provided with a view (209) for displaying the interface and method as a tree. When the user checks the method MethodAA (211), MethodAC (213), MethodBA (215), and unchecks MethodAB (212), MethodBB (216), MethodBC (217), the interface InterfaceA (210), Bter It is possible to make the log acquisition target only the method checked by each interface, not all the methods in 214).
[0059]
FIG. 22 is a diagram illustrating a flow of processing when acquiring a log when a log acquisition target is selected as illustrated in FIG. 21 in the software evaluation system that implements the log acquisition method according to the present embodiment.
[0060]
When processing is started (step S59), the log acquisition code determines whether a method of the interface is a log acquisition target every time an interface method is called (step S60). If it is a log acquisition target, the module name, interface, and method name are stored in the HDD (step S61).
[0061]
Next, the log acquisition code saves the time at the time of calling, the parameter, and the contents of the memory indicated by the pointer parameter in the HDD (step S62), and calls the original method (step S63). When returning from the method, 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 S64). This process is continued until an end command is received from the user (step S65).
[0062]
As a result, it is possible to easily select a method for which a log is to be acquired for each method instead of a large range for each interface, and it is possible to easily acquire a log requested by a user.
[0063]
[Sixth Embodiment]
In each of the above embodiments, the acquired log is stored in an arbitrary location of the HDD. However, the log may be stored for each date so that the log can be easily analyzed.
[0064]
FIG. 23 is a diagram showing a flow of processing when logs are stored separately for each date.
[0065]
When the process is started (step S71), log acquisition is started, and the module name, interface name, and function / method name are stored in the memory (step S72).
[0066]
Next, the log acquisition code stores the date / time at the time of calling, the parameter, and the contents of the memory pointed to by the pointer / parameter in the memory (step S73), and calls the original function / method (step S74). When the function / method returns, the log acquisition code stores the return date / time, the return value, and the contents of the memory indicated by the pointer / parameter in the memory (step S75). Thereafter, it is determined whether the return date of the called function / method is different from the return date of the previously saved log (step S76). If the dates are different, a new log file is created and the log is saved in the file (step S77). If the dates are the same, the log is saved in a conventional log file (step S78). This process is terminated when there is a termination command from the user (step S79) (step S80).
[0067]
As a result, the user can obtain a desired log for each date, and the log can be easily analyzed.
[0068]
[Seventh embodiment]
In the sixth embodiment, the case of storing the log for each date has been described, but the log may be divided and stored for each size or number.
[0069]
FIG. 24 is a diagram showing the flow of processing when logs are stored separately for each size or number.
[0070]
When the process is started (step S71), log acquisition is started, and the module name, interface name, and function / method name are stored in the memory (step S72). Next, the log acquisition code saves the time at the time of calling, the parameter, and the contents of the memory indicated by the pointer parameter in the memory (step S73), and calls the original function / method (step S74). When the function / method returns, the log acquisition code stores the return time, the return value, and the contents of the memory indicated by the pointer parameter in the memory (step S75). Thereafter, when new log data is stored in a conventional log file, it is determined whether the file size exceeds a certain value or a certain number of logs (step S76).
[0071]
If it exceeds a certain size or exceeds a certain number, a new log file is created and the log is saved in that file (step S77). The log is saved in (Step S18). When a new log file is created, it is determined whether or not the ring buffer is used and the number of created log files is greater than 2 (step S79). If the condition is met, the oldest log file is deleted (step S90). This process is terminated when the user gives a termination command (step S91) (step S92).
[0072]
As a result, the user can acquire a plurality of logs created within a certain size, or can acquire them for each certain number of logs, thereby providing an effect of easy handling. Also, by using the ring buffer, it is possible to keep the load applied to the resources of the PC by this software evaluation system constant, and it becomes possible to acquire stable logs.
[0073]
[Eighth embodiment]
FIG. 25 is a schematic diagram of a memory when a certain number of acquired logs are stored in the memory.
[0074]
There are n log storage memory areas for storing a certain number of logs (218), and each log storage memory area stores a log of function / method for one time, and the information includes module name and interface name. , Function / method name, calling time, calling parameter data, ending time, ending parameter data, return value data, and the like are stored (219), and have a variable size. In this memory area, log data is stored in order from the log storage memory area 1, and when the log storage memory area n is used up, the log is overwritten again from the log storage memory area 1 and stored.
[0075]
FIG. 26 is a diagram showing a flow of log acquisition when a certain number of acquired logs are stored in the memory.
[0076]
When the process is started (step S93), a variable x indicating the location of the log storage memory area is initialized to 1 (step S94). Then, log acquisition is started, and the module name, interface name, and function / method name are stored in the log storage memory area x (step S95).
[0077]
Next, the log acquisition code saves the time of calling, the parameter, and the memory contents pointed to by the pointer parameter in the log storage memory area x (step S96), and calls the original function / method (step S97). When returning from the function / method, the log acquisition code stores the return time, the return value, and the contents of the memory indicated by the pointer parameter in the log storage memory area x (step S98). Thereafter, 1 is added to the variable x indicating the location of the log storage memory area (step S99), and it is determined whether x is larger than the number n of log storage memory areas (step S100).
[0078]
If x is larger than n, 1 is substituted for x, and the log storage memory area is set to be used again from the beginning (step S101). After that, it is determined whether or not the ring buffer is used (step S102). If not used, all log data on the memory is saved in the log file (step S103), and all log data on the memory is deleted. (Step S104). This process is terminated when the user gives a termination command (step S105) (step S106).
[0079]
As a result, the amount of memory used can be limited to a certain value, the load that the software evaluation system gives to the resources of the PC can be suppressed, and stable log acquisition can be performed.
[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 showing a user interface for setting a function / method for starting log acquisition in the software evaluation system that implements the log acquisition method according to the first embodiment of the present invention;
FIG. 11 is a diagram showing a flow when a log is acquired according to the contents set in FIG. 10 in the software evaluation system that implements the log acquisition method according to the first embodiment of the present invention;
FIG. 12 is a diagram showing a user interface for setting a function / method for stopping log acquisition 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 showing a flow when a log is acquired according to the contents set in FIG. 12 in the software evaluation system for realizing the log acquisition method according to the second embodiment of the present invention.
FIG. 14 is a diagram showing an example of a software evaluation system that implements a log acquisition method according to the third embodiment of the present invention. The user interface for setting a function / method for starting / stopping log acquisition ends with an error. It is a figure which shows the user interface which added the setting which uses a trigger function only in the case.
FIG. 15 is a diagram showing the contents of function / method error definitions in 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 a log is acquired according to the contents set 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 showing a detailed flow of a normal log acquisition process shown in step S27 of FIG. 16 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 showing a flow when a log is acquired according to the contents set in 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 user interface for displaying a tree of interfaces and methods in a software evaluation system that implements a log acquisition method according to a fourth embodiment of the present invention;
FIG. 20 is a diagram showing a flow of processing when acquiring a log when a log acquisition target is selected as shown in FIG. 19 in the software evaluation system according to the fourth embodiment of the present invention;
FIG. 21 is a diagram showing a user interface for displaying a tree of interfaces and methods in a software evaluation system that implements a log acquisition method according to a fifth embodiment of the present invention;
FIG. 22 shows the flow of processing when acquiring a log when a log acquisition target is selected as shown in FIG. 21, in a software evaluation system that implements a log acquisition method according to a fifth embodiment of the present invention; FIG.
FIG. 23 is a diagram showing a processing flow when a log is divided and stored for each date in a software evaluation system that implements a log acquisition method according to a sixth embodiment of the present invention;
FIG. 24 is a diagram showing a processing flow when a log is divided and stored for each size or number in the software evaluation system for realizing the log acquisition method according to the seventh embodiment of the present invention.
FIG. 25 is a schematic diagram of a memory when a certain number of acquired logs are stored in a memory in a software evaluation system that implements a log acquisition method according to an eighth embodiment of the present invention;
FIG. 26 is a diagram showing a flow of log acquisition when a predetermined number of acquired logs are stored in a memory in a software evaluation system that implements a log acquisition method according to an eighth 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 (17)

A dynamic link library that stores functions, and import function address table storing an address of the function number, a program storage means for storing a target program to be executed by calling a function in the dynamic link libraries, memory for storing programs a medium, and logging means logs are recorded, and a means for executing the program, and rewriting means for the execution unit is realized by executing a program stored in the storage medium, selection means And a log acquisition method for acquiring a log during execution of the target program in an information processing apparatus comprising a calling unit,
It said selection means, the function selected by the user instruction from the list of functions in the dynamic link library, a selection step of selecting as a function should retrieve log,
The rewriting means loads a function for log acquisition corresponding to each function selected in the selection step into the dynamic link library and stores it in the import function address table before executing the target program. Rewriting the address of the selected function with the address of the function for acquiring the corresponding log;
Log acquisition realized by the calling means calling the function for log acquisition and causing the execution means to execute based on the rewritten address on the import function address table for the selected function Invoking means;
The log acquisition unit records a log related to the call by the calling unit in the log recording unit, calls the selected function corresponding to the function for log acquisition called by the calling unit, and Causing the execution means to execute a selected function;
The log acquisition unit includes a step of receiving an execution result of the selected function, recording a log related to the execution result in the log recording unit, and passing the execution result to the target program. Log acquisition method. A dynamic link library that stores functions, and import function address table storing an address of the function number, a program storage means for storing a target program to be executed by calling a function in the dynamic link libraries, memory for storing programs a medium, and logging means logs are recorded, and a means for executing the program, and rewriting means for the execution unit is realized by executing a program stored in the storage medium, selection means And in an information processing apparatus comprising a calling unit and a stopping unit, a log acquisition method for acquiring a log during execution of the target program,
It said selection means comprises a selection step of the function selected by the user instruction from the list of functions in dynamic link libraries, selected as a function to be triggered in the log acquisition stop,
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 records a log related to a call by the calling unit in the log recording unit, calls the function to be called corresponding to the function for log acquisition called by the calling unit, and Causing the execution means to execute a function to be called;
The log acquisition means receives the execution result of the function to be called, records a log related to the execution result in the log recording means, and passes the execution result to the target program; and the stopping means includes the log A log acquisition method comprising: a stop step of stopping recording of subsequent logs if the function to be called called by the acquisition means is a function selected in the selection step. The information processing apparatus further includes a determination unit that determines whether there is an error, and the log acquisition method further includes a step in which the determination unit determines whether there is an error after executing the function selected in the selection step. ,
The log acquisition method according to claim 1, wherein the log acquisition unit records the log in the log recording unit when it is determined that there is an error in the step of determining whether there is an error. The information processing apparatus further includes an error determination unit that determines whether there is an error, and the log acquisition method further includes a step in which the determination unit determines whether there is an error after executing the function selected in the selection step. Prepared,
The log acquisition method according to claim 2, wherein, in the stop step, subsequent log recording is stopped when it is determined that there is an error in the step of determining whether or not there is an error. 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 a program, logs A log recording means to be recorded; an execution means for executing a program; the rewriting means realized by the execution means executing the program stored in the storage medium ; a calling means; and a selection means; In an information processing apparatus comprising: a log acquisition method for acquiring a log during execution of the target program,
Said selection means, the method that the user from the list of methods in the interface selected instruction, a selection step of selecting a method should acquire log,
The rewriting means loads a method for log acquisition corresponding to each method selected in the selection step into the interface before execution of the target program, and stores the selection stored in the virtual address table. Rewriting the address of the registered method with the address of the method for acquiring the corresponding log,
Log acquisition means realized by calling the method for log acquisition and causing the execution means to execute based on the rewritten address on the virtual address table for the selected method. Starting the process,
The log acquisition unit records a log related to the call by the calling unit in the log recording unit, calls the selected method corresponding to the method for log acquisition called by the calling unit, and Causing the execution means to execute the selected method;
The log acquisition unit includes a step of receiving an execution result of the selected method, recording a log related to the execution result in the log recording unit, and passing the execution result to the target program. Log acquisition method. 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 a program, logs Rewriting means realized by executing a program stored in the storage medium , a selection means, and a calling means, having log recording means to be recorded and execution means for executing a program; In the information processing apparatus comprising a stopping unit, a log acquisition method for acquiring a log during execution of the target program,
Said selection means, the method that the user from the list of methods in the interface selected instruction, a selection step of selecting a method to be a trigger for log acquisition stop,
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 sets the address of each method stored in the virtual address table. Rewriting the address of the corresponding 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 records a log related to a call by the calling unit in the log recording unit, calls the method to be called corresponding to the method for log acquisition called by the calling unit, and Causing the execution means to execute a method to be called;
The log acquisition means receives the execution result of the method to be called, records a log related to the execution result in the log recording means, and passes the execution result to the target program; and the stopping means includes the log If the method to be called that is called by the acquisition means is the method selected in the selection step, the log acquisition method further comprises a stop step for stopping log recording thereafter. The information processing apparatus further includes a determination unit that determines whether there is an error, and the log acquisition method further includes a step in which the determination unit determines whether there is an error after executing the method selected in the selection step. ,
6. The log acquisition method according to claim 5, wherein the log acquisition unit records the log in the log recording unit when it is determined that there is an error in the step of determining whether there is an error. The information processing apparatus further includes an error determination unit that determines whether there is an error, and the log acquisition method further includes a step in which the determination unit determines whether there is an error after executing the method selected in the selection step. Prepared,
The log acquisition method according to claim 6, wherein, in the stopping step, when it is determined that there is an error in the step of determining whether or not there is an error, the subsequent log recording is stopped.   The information processing apparatus further includes a display unit, and in the selection step, the interface and a method belonging to the interface are displayed on the display unit in a tree structure, and a method is selected through the display. The log acquisition method according to claim 5 or 6.   The log acquisition method according to claim 1, wherein the log acquisition unit is capable of recording a log for each date.   2. The log acquisition method according to claim 1, wherein when the log size exceeds a certain size, the log acquisition unit newly creates another file and deletes a log having an old creation date and time. .   2. The log acquisition method according to claim 1, wherein when the number of logs reaches a predetermined number or more, the log acquisition unit newly creates another file and deletes a log having an old creation date and time. .   The log acquisition unit, when the number of logs recorded in the log recording unit exceeds a certain number, moves the log recorded in the log recording unit to a disk device and stores the log. The log acquisition method according to 1.   The log acquisition method according to claim 5, wherein the log acquisition unit is capable of recording a log for each date.   The log acquisition method according to claim 5, wherein the log acquisition unit creates a new file and deletes a log with an old creation date and time when the log size exceeds a certain size. .   6. The log acquisition method according to claim 5, wherein when the number of logs reaches a predetermined number or more, the log acquisition unit newly creates another file and deletes a log having an old creation date and time. .   The log acquisition unit, when the number of logs recorded in the log recording unit exceeds a certain number, moves the log recorded in the log recording unit to a disk device and stores the log. 5. The log acquisition method according to 5.

Images