Method and system for positioning cause of crash of sub-process
By collecting and filtering crash files, establishing mapping tables and dynamically setting log switch identifiers, efficient positioning of the causes of software crashes is achieved, difficulty in positioning the cause of crashes and solving the problems of inefficiency, and improving software stability and user experience.
Patent Information
- Application Number
- CN202411066160.6
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2024-08-05
- Publication Date
- 2024-11-22
AI Technical Summary
The existing technology is difficult to capture and locate the detailed information of software crashes in real time, resulting in difficult positioning due to crashes, inefficient resolution and poor user experience, especially in case of crashes caused by non-program own code or lack of debug files.
By collecting crash files and log files, filtering out the exit code of the crash module and child process, establishing a mapping table, dynamically setting the log switch identifier, the child process performs detailed log printing when crashes, the parent process judges the exit code and passes the log switch identifier to the new child process, locate the cause of crash.
Improve the accuracy and efficiency of crash cause positioning, enhance software stability and user experience, and reduce the frequency and duration of software crashes.
Smart Images

Figure CN119003219A_ABST
Abstract
Description
Technical Field
[0001] The present invention relates to the field of computer technology, and in particular to a method and system for locating the cause of a subprocess crash. Background Art
[0002] In the field of software development and operation and maintenance, software crashes have always been a key factor affecting user experience and product quality. Traditional methods, such as static logging and post-debugging, make it difficult to capture detailed information at the moment of the crash in real time, resulting in difficulty in locating the cause of the crash and inefficient resolution. With the increase in software complexity and the shortening of release cycles, higher requirements are placed on the ability to respond quickly to and resolve crash issues. Therefore, it is particularly important to develop a technology that can dynamically set log printing and accurately locate the cause of the crash, in order to improve the stability, reliability and user experience of the software.
[0003] Currently, there are the following technical problems in locating the cause of the crash:
[0004] (1) Difficulty in locating the cause of the crash: The location of software crashes often relies on static logging and post-analysis, which makes it difficult to capture and accurately record the execution status and context information when the crash occurs in real time. In particular, when the crash is caused by non-program code or lacks necessary debugging files (such as PDB files), the location process is even more difficult and the success rate is low.
[0005] (2) Low crash resolution efficiency: Due to the difficulty in locating the cause of the crash, developers often face the dilemma of insufficient information and unclear direction when solving crash problems, resulting in low crash resolution efficiency and difficulty in meeting users' requirements for software stability and reliability;
[0006] (3) Poor user experience: Software crashes and lengthy troubleshooting not only interrupt the user's operating process, but also lead to consequences such as user data loss. Summary of the invention
[0007] The purpose of the present invention is to provide a method and system for locating the cause of a subprocess crash, so as to solve the problems mentioned in the above background technology, such as difficulty in locating the existing crash cause, low crash resolution efficiency, poor user experience, etc.
[0008] To achieve the above object, the present invention adopts the following technical solutions:
[0009] According to one aspect of the present invention, a method for locating the cause of a subprocess crash is provided, the method comprising:
[0010] Collect crash files and log files and filter them to find the exit codes of crashed modules and subprocesses;
[0011] The parent process adds the log switch identifier of the crash module and the mapping value of the exit code, and stores them in the mapping table;
[0012] The subprocess adds the log switch identifier to enable each execution step and parameter value of the crash module to be logged;
[0013] After the child process crashes, the parent process determines whether the exit code of the child process is in the mapping table, and if so, passes the log switch identifier to the new child process;
[0014] After receiving the log switch identifier, the new child process executes the preset log content printing, and if there is no crash within a certain period of time, the log switch identifier is turned off;
[0015] The cause of the crash is located based on the execution operations and parameters finally printed in the log file.
[0016] Based on the above solution, the crash files and log files in which the same user subprocess crashes more than three times are screened out.
[0017] Based on the above solution, the log file includes a parent process log file and a child process log file, and the crash file is a Dump file, which is a dump file of the child process crash.
[0018] Based on the above scheme, each crash type customizes a log switch identifier. After the child process crashes, the parent process finds the log switch identifier corresponding to the exit code from the mapping table and passes it to the newly created child process to dynamically set the log printing content of the child process.
[0019] Based on the above solution, when the child process crashes and exits, the parent process captures the exit code and queries the mapping table to determine whether the exit code has a corresponding log switch identifier.
[0020] Based on the above scheme, the parent process receives the exit message of the child process. The parent process first checks whether the exit status is an abnormal exit. If it is and the exit code is in the mapping table, the parent process searches for the corresponding log switch identifier, creates the new child process, and passes the log switch identifier to the new child process.
[0021] Based on the above solution, the recording of the log file is performed synchronously with the program execution to feedback the operation and status of the sub-process crash.
[0022] Based on the above solution, the crash cause is located according to the execution operation and parameters finally printed in the log file, including direct location and indirect location;
[0023] The direct positioning includes directly displaying the abnormal information or error code in the log file to directly locate the cause of the crash; analyzing the operation and parameters last executed before the crash to determine the error point;
[0024] The indirect positioning means that there is no direct abnormal information. Based on the task parameters or resource usage abnormalities displayed in the log file, the cause of the crash is further located; and the debugging tool is used to analyze the program state at the time of the crash.
[0025] Based on the above scheme, if the cause of the crash cannot be located according to the log file, the configuration of the log file is improved, and the log information printing is increased or modified, including but not limited to adding detailed execution instructions, parameter values, resource usage, and deleting unnecessary log content.
[0026] According to another aspect of the present invention, a system for locating the cause of a subprocess crash is provided, the system comprising: a data collection module, a mapping table management module, a log configuration module, and a crash cause analysis module;
[0027] The data collection module collects crash files and log files;
[0028] The mapping table management module manages the mapping relationship between the crash module, log switch identifier and exit code of the subprocess;
[0029] The log configuration module configures the log file according to the log switch identifier and prints detailed execution steps and parameter values in the subprocess;
[0030] The crash cause analysis module analyzes the log file and locates the crash cause.
[0031] It can be seen from the above technical solutions that the present invention has at least the following advantages and positive effects compared with the prior art:
[0032] (1) By dynamically setting the execution steps and parameter log printing of the subprocess crash module, the ability to locate the crash code and cause during the software version iteration update process is greatly enhanced, solving the problem of locating crashes caused by non-program code or crashes without PDB file support;
[0033] (2) After successfully locating the cause of the crash, the present invention further improves the efficiency of problem solving and improves the stability and robustness of the software by continuously optimizing and repairing the crash problem;
[0034] (3) Reduce the frequency and duration of software crashes, reducing the obstacles and inconveniences encountered by users during use.
[0035] The present invention should be understood that the foregoing general description and the following detailed description are exemplary and explanatory only and are not restrictive of the present invention. BRIEF DESCRIPTION OF THE DRAWINGS
[0036] The drawings herein are incorporated into and constitute a part of the specification, showing embodiments consistent with the present invention, and together with the specification, are used to explain the principles of the present invention. Obviously, the drawings described below are only some embodiments of the present invention, and for those of ordinary skill in the art, other drawings can be obtained based on these drawings without creative work. In the drawings:
[0037] Figure 1 A schematic diagram of a method for locating the cause of a sub-process crash according to the present invention;
[0038] Figure 2 A schematic diagram of screening crash files and log files for the present invention;
[0039] Figure 3 A schematic diagram of a parent process receiving an exit message from a child process of the present invention;
[0040] Figure 4 A schematic diagram of a system for locating the cause of a sub-process crash according to the present invention. DETAILED DESCRIPTION
[0041] In order to more clearly explain the purpose, technical solutions and advantages of the present invention, the technical solutions in the embodiments of the present invention will be clearly and completely described below in conjunction with the drawings in the embodiments of the present invention. Obviously, the described embodiments are only part of the embodiments of the present invention, rather than all of the embodiments. The example implementation methods can be implemented in various forms and should not be understood as being limited to the examples described herein. On the contrary, these implementation methods are provided to make the present invention more comprehensive and complete, and to fully convey the concepts of the example implementation methods to those skilled in the art.
[0042] In addition, the described features, structures or characteristics may be combined in one or more embodiments in any suitable manner. In the following description, many specific details are provided to provide a full understanding of the embodiments of the present invention. However, those skilled in the art will appreciate that the technical solution of the present invention can be practiced without one or more of the specific details, or other methods, components, devices, steps, etc. may be adopted. In other cases, known methods, devices, implementations or operations are not shown or described in detail to avoid blurring various aspects of the present invention.
[0043] The block diagrams shown in the accompanying drawings are merely functional entities and do not necessarily correspond to physically independent entities. That is, these functional entities may be implemented in software form, or in one or more hardware modules or integrated circuits, or in different networks and / or processor devices and / or microcontroller devices.
[0044] The flowcharts shown in the accompanying drawings are only exemplary and do not necessarily include all the contents and operations / steps, nor must they be executed in the order described. For example, some operations / steps can be decomposed, and some operations / steps can be combined or partially combined, so the actual execution order may change according to actual conditions.
[0045] The present invention is described in detail below in conjunction with specific embodiments:
[0046] Example 1
[0047] like Figure 1 As shown, this embodiment provides a method for locating the cause of a subprocess crash, and the specific steps of the method are as follows:
[0048] S1: Collect and filter crash files and log files to find the exit codes of crash modules and subprocesses.
[0049] In this embodiment, the crash file and the log file are screened out when the same user subprocess crashes more than three times. The log file includes the parent process log file and the subprocess log file, and the crash file is a dump file, which is a dump file of the subprocess crash.
[0050] Specifically, set up an exception capture mechanism in the child process. When an unhandled exception is captured, generate a dump file and record detailed log information; ensure that all key execution steps and exception information are recorded in the log file. Optionally, write a log analysis tool to parse the log file and count the number of crashes of the user's child process.
[0051] In this embodiment, a crash data platform is used for screening. The platform includes crash data generation, sending, receiving and data management. The data can be searched and screened according to the number of crashes and crash stack identifiers. For the same crash stack, the number of crashes of each IP sub-process can be seen according to IP classification.
[0052] Furthermore, if Figure 2As shown, in order to more effectively identify and solve frequently occurring crash problems, this embodiment filters out crash files and log files of the same user subprocess, especially records of repeated crashes more than three times. This screening criterion is based on the following: when a subprocess crashes more than three times, it can be considered to crash more frequently and is likely to be caused by the same or similar reasons. Furthermore, by adding detailed log content printing, these crash scenarios can be more easily reproduced, thereby collecting more log information about the crash type, so as to more specifically solve such frequently occurring crash problems and improve the stability and reliability of the system.
[0053] Furthermore, use the debugging tool to analyze the Dump file to determine the module and call stack where the crash occurred. The log file contains the parent process and child process logs. After the child process exits, the parent process can receive the exit message and print the exit code (error code) to the parent process log. For example, the Dump file shows that the crash occurred in the ig8icd64.dll file, which is the driver file of the Intel integrated graphics card. It is determined that the image effect processing module crashed. The log file shows that the child process exit code is -1073741819, so the error code of this crash type is -1073741819.
[0054] S2: The parent process adds the log switch identifier of the crash module and the mapping value of the exit code, and stores them in a mapping table.
[0055] In this embodiment, a mapping table is maintained in the parent process, and the mapping table contains the mapping relationship between the crash module name, the log switch identifier and the process exit code; whenever a new crash mode is detected, the mapping table is updated, and the log switch identifier may be modified. Each crash type customizes a log switch identifier. After the child process crashes, the parent process finds the log switch identifier corresponding to the exit code from the mapping table and passes it to the newly created child process to dynamically set the log printing content of the child process to avoid excessive log printing under normal circumstances and affect program operation.
[0056] Furthermore, an example of a custom mapping table is as follows:
[0057] static QMap<int,int> exitCodeLogFlagMap={
[0058] {-1073741819,1},
[0059] {-1073740940,2},
[0060] {-1073741795,3}
[0061] };
[0062] The first value is the process exit code, and the second value is the log switch flag.
[0063] S3: The subprocess adds the log switch identifier to log each execution step and parameter value of the crash module.
[0064] In this embodiment, logic is added to the child process to process the log switch flag received from the parent process, and whether to print the log in a specific execution step is determined according to the value of the log switch flag. The log content is printed once before each step is executed, and once after the execution is completed. If the execution content contains parameters, the parameter values are printed.
[0065] Furthermore, for example, image processing includes tasks such as initialization, image background rendering, image matrix changes, image text, image effects, image animation, image color, image transitions, etc. Each task is preceded and followed by a log switch identification judgment and log printing. Image matrix changes include transparency, image source / target size, image width and height memory byte alignment parameter values, and the log content will print out these values. Adding log records at key locations makes it easier to track the execution flow of the program, monitor the status of key variables, and quickly locate the specific code location when problems occur.
[0066] S4: After the child process crashes, the parent process determines whether the exit code of the child process is in the mapping table, and if so, passes the log switch identifier to the new child process.
[0067] Combination Figure 3 As shown, when the child process crashes and exits, the parent process captures the exit code and queries the mapping table to determine whether the exit code has a corresponding log switch identifier. The parent process receives the exit message of the child process, and checks whether the exit status is an abnormal exit. If so and the exit code is in the mapping table, the parent process searches for the corresponding log switch identifier, creates the new child process, and passes the log switch identifier to the new child process.
[0068] Specifically, in this embodiment, some variables and mapping tables are first defined to store exit codes and corresponding log switch flags, and the exit codes and log switch flags are initialized; when the main class (MainClass) is created, it accepts an execution path (exePath), which is the path of the program to be executed by the child process; at the same time, it initializes a hash table (exitCodeLogFlagMap) for storing the child process exit code and the corresponding log switch flag; this mapping table allows the parent process to decide which log switch flag to use based on the child process exit code; then, the parent process creates a child process for the first time and passes the initial log switch flag (-1 in this embodiment, indicating that it is not set or invalid) to the child process as a command line parameter.
[0069] Furthermore, the parent process receives the exit message of the child process by connecting the finished signal of the QProcess object to its slot function onProcessFinished; when the child process exits, the finished signal will be sent with the exit code (exitCode) and exit status (exitStatus) as parameters; in the onProcessFinished slot function, the parent process first checks whether the exit status is an abnormal exit (QProcess::CrashExit); if it is and the exit code exists in exitCodeLogFlagMap, the parent process will look for the corresponding log switch flag.
[0070] Furthermore, if the corresponding log switch flag is found, the parent process will create a new QProcess object to start a new child process, and pass the new log switch flag as a command line parameter to the new child process; similar to the first creation of the child process, the new child process will also receive the log switch flag through the command line parameter and process it as needed. This process (child process execution, receiving exit message, processing and possibly starting a new child process) can be repeated as needed to support long-running applications or services, where the child process may exit for various reasons (such as crash, completion of task, etc.) and need to be replaced or restarted.
[0071] Furthermore, if the child process does not exit normally (that is, the exit status is not QProcess::NormalExit), or the exit code does not exist in exitCodeLogFlagMap, the main process needs to adopt different handling strategies. If the child process exits abnormally (the exit status is not QProcess::NormalExit): When the child process exits abnormally, it may indicate that an error or abnormal situation has occurred. The parent process can take one or a combination of the following measures: 1) Log errors: Log the exit code and possible error information (if available) to a log file or console for subsequent analysis; 2) Retry mechanism: Depending on the application's fault tolerance strategy, the parent process can try to restart the child process until the retry limit is reached or it is successfully started; 3) Alert or notification: Send an alert or notification to the administrator or user to inform the child process of the abnormal exit; 4) Clean up resources: If the child process does not properly release resources (such as file handles, network connections, etc.) before exiting, the parent process may be responsible for cleaning up these resources.
[0072] If the child process's exit code does not exist in exitCodeLogFlagMap: When the exit code does not exist in the mapping table, it may mean that the child process exited in some unexpected way or the mapping table is incomplete. The parent process can take one of the following measures: 1) Record unknown exit code: Record the unknown exit code in the log for subsequent analysis or update of the mapping table; 2) Use the default log switch flag: If the application defines a default log switch flag, the parent process can use the default value when no match is found; 3) Ignore the exit code: In some cases, if the exit code has no effect on the subsequent operation of the parent process, the parent process can choose to ignore it; 4) Update the mapping table: If a new exit code is found and special processing is required for the code, the parent process can update the mapping table to include the code.
[0073] S5: After receiving the log switch identifier, the new subprocess executes preset log content printing, and if there is no crash within a certain period of time, the log switch identifier is turned off.
[0074] In this embodiment, the new child process applies the corresponding log recording strategy according to the received log switch identifier; a monitoring mechanism is set to track the stability and crash of the child process; if the child process does not crash within a certain period of time, the log switch identifier is turned off through the logic of the parent process or the child process itself to reduce the overhead of log recording. Furthermore, the child process receives the log switch identifier, saves the identifier to the child process, and the child process performs log printing according to the print identifier; the log is printed in a synchronous manner, and if the child process does not crash for more than a certain period of time, such as 30 minutes, the log switch identifier is turned off and the log content is not printed.
[0075] S6: Locate the crash cause according to the execution operation and parameters finally printed in the log file.
[0076] In this embodiment, the cause of the crash is located based on the execution operation and parameters finally printed in the log file, including direct location and indirect location; the direct location includes directly displaying the abnormal information or error code in the log file, and directly locating the cause of the crash; analyzing the operation and parameters last executed before the crash to determine the error point; the indirect location is that there is no direct abnormal information, and the cause of the crash is further located based on the task parameters or resource usage abnormalities displayed in the log file; using the debugging tool to analyze the program state at the time of the crash, and check the call stack, variable values and other information. Analyze the task operation start information in the log file. If the corresponding end information is missing, it indicates that the crash occurred during the task execution process; check the task parameters printed in the log file to determine whether the task parameters are abnormal and cause the crash; analyze the usage of memory, video memory, and CPU in the log file to determine whether the crash is caused by insufficient resources.
[0077] Furthermore, if the cause of the crash cannot be located based on the log file, the configuration of the log file is improved. If the log content is insufficient to determine the cause of the crash, it is necessary to increase or modify the log information printing, including but not limited to adding detailed execution instructions, parameter values, resource usage, and deleting unnecessary log content to reduce the size of the log file, thereby improving analysis efficiency; based on the located crash cause and problem solution, an updated version of the software is released; the update should include code changes to fix the crash, enhanced logging, and possible user prompts.
[0078] Specifically, ensure that log records are synchronized, that is, the execution of the program and the writing of the log occur at the same time, so that as much log information as possible can be saved when the program crashes; because the logs are recorded synchronously, the last few log records before the program crash are particularly critical, and they can often directly reflect the operation or state that caused the crash. Further, analyze the content of the log file, analyze the task operation start information recorded in the log, if the corresponding end information is missing, it is likely that the crash occurred during the execution of the task; check the task parameters printed in the log, such as width and height, pixel format, sound channel, etc., and use industry knowledge and technical experience to determine whether these parameters may cause a crash (such as illegal values or beyond the expected range); by analyzing the memory, video memory, and CPU usage recorded in the log, you can preliminarily determine whether the crash is caused by insufficient resources (such as memory leaks, video memory exhaustion).
[0079] Example 2
[0080] like Figure 4As shown, this embodiment exemplarily presents a system for locating the cause of a sub-process crash, including a data collection module, a mapping table management module, a log configuration module, and a crash cause analysis module; the data collection module collects crash files and log files; the mapping table management module manages the mapping relationship between the crash module, log switch identifier, and exit code of the sub-process; the log configuration module configures the log file according to the log switch identifier, and prints detailed execution steps and parameter values in the sub-process; the crash cause analysis module analyzes the log file and locates the crash cause.
[0081] Specifically, the data collection module is responsible for monitoring the crash events of each sub-process in the system and collecting crash files and log files; listening to system or application-level crash signals; capturing dump files and log files generated during a crash; filtering and extracting key crash-related information, such as the crash module name, sub-process exit code, etc.
[0082] The mapping table management module manages the mapping relationship between crash modules, log switch identifiers and exit codes; maintains a mapping table to record crash modules, corresponding log switch identifiers and exit code mapping values; provides an interface for adding, querying and updating data in the mapping table; after detecting that the child process has crashed, the parent process queries the mapping table to decide whether additional logging needs to be enabled.
[0083] The log configuration module configures log records according to the log switch identifier and prints detailed execution steps and parameter values in the child process; receives the log switch identifier from the parent process; configures the log level and output content in the child process according to the log switch identifier; prints relevant parameter values and status information in each execution step of the crash module of the child process.
[0084] After the child process crashes, the parent process decides whether to start a new child process and passes the log switch flag; the parent process detects the exit status of the child process and queries the mapping table based on the exit code; if additional logging is required, a new child process is started and the log switch flag is passed; the running status of the new child process is monitored, and if no crash occurs within a certain period of time, the log switch flag is turned off.
[0085] The crash cause analysis module analyzes log files, locates the crash cause based on execution operations and parameter values; reads and analyzes log files to extract key execution steps and parameter values; performs comprehensive analysis based on contextual information at the time of the crash, such as stack traces, memory status, etc.; and outputs a crash analysis report that points out possible crash causes and repair suggestions.
[0086] Optionally, add a monitoring and alarm module to monitor the system operation status, promptly detect and report abnormal or crash events; monitor the operation status of each sub-process in real time; send alarm information to the administrator via email, SMS, etc. when an abnormality or crash is detected; provide a history record query function to facilitate subsequent analysis and auditing.
[0087] Those skilled in the art will readily appreciate other embodiments of the present invention after considering the specification and practicing the invention disclosed herein. This application is intended to cover any modification, use or adaptation of the present invention, which follows the general principles of the present invention and includes common knowledge or customary techniques in the art that are not disclosed by the present invention. The specification and examples are intended to be exemplary only, and the true scope and spirit of the present invention are indicated by the claims. It should be understood that the present invention is not limited to the precise structure described above and shown in the accompanying drawings, and various modifications and changes can be made without departing from the scope thereof. The scope of the present invention is limited only by the appended claims.
Claims
1. A method for locating the cause of a subprocess crash, characterized in that: The method comprises: Collect crash files and log files and filter them to find the exit codes of crashed modules and subprocesses; The parent process adds the log switch identifier of the crash module and the mapping value of the exit code, and stores them in the mapping table; The subprocess adds the log switch identifier to enable each execution step and parameter value of the crash module to be logged; After the child process crashes, the parent process determines whether the exit code of the child process is in the mapping table, and if so, passes the log switch identifier to the new child process; After receiving the log switch identifier, the new child process executes the preset log content printing, and if there is no crash within a certain period of time, the log switch identifier is turned off; The cause of the crash is located based on the execution operations and parameters finally printed in the log file.
2. The method for locating the cause of a subprocess crash according to claim 1, characterized in that: The crash files and log files in which the same user subprocess crashes more than three times are screened out.
3. The method for locating the cause of a subprocess crash according to claim 1, characterized in that: The log files include a parent process log file and a child process log file, and the crash file is a Dump file, which is a dump file of a child process crash.
4. The method for locating the cause of a subprocess crash according to claim 1, characterized in that: Each crash type customizes a log switch identifier. After the child process crashes, the parent process finds the log switch identifier corresponding to the exit code from the mapping table and passes it to the newly created child process to dynamically set the log printing content of the child process.
5. The method for locating the cause of a subprocess crash according to claim 1, characterized in that: When the child process crashes and exits, the parent process captures the exit code and queries the mapping table to determine whether the exit code has a corresponding log switch identifier.
6. The method for locating the cause of a subprocess crash according to claim 1, characterized in that: The parent process receives the exit message of the child process, and the parent process checks whether the exit status is an abnormal exit. If it is and the exit code is in the mapping table, the parent process searches for the corresponding log switch identifier, creates the new child process, and passes the log switch identifier to the new child process.
7. The method for locating the cause of a subprocess crash according to claim 1, characterized in that: The log file is recorded synchronously with the program execution to feedback the operation and status of the sub-process crash.
8. The method for locating the cause of a subprocess crash according to claim 1, characterized in that: The crash cause is located according to the execution operation and parameters finally printed in the log file, including direct location and indirect location; The direct positioning includes directly displaying the abnormal information or error code in the log file to directly locate the cause of the crash; analyzing the operation and parameters last executed before the crash to determine the error point; The indirect positioning means that there is no direct abnormal information. Based on the task parameters or resource usage abnormalities displayed in the log file, the cause of the crash is further located; and the debugging tool is used to analyze the program state at the time of the crash.
9. The method for locating the cause of a subprocess crash according to claim 1, characterized in that: If the cause of the crash cannot be located based on the log file, the configuration of the log file is improved, and the log information printing is increased or modified, including but not limited to adding detailed execution instructions, parameter values, resource usage, and deleting unnecessary log content.
10. A system for locating the cause of a subprocess crash, characterized in that: Including data collection module, mapping table management module, log configuration module, and crash cause analysis module; The data collection module collects crash files and log files; The mapping table management module manages the mapping relationship between the crash module, log switch identifier and exit code of the subprocess; The log configuration module configures the log file according to the log switch identifier and prints detailed execution steps and parameter values in the subprocess; The crash cause analysis module analyzes the log file and locates the crash cause.
