CN115840617A

CN115840617A - Debugging method, system and related device

Info

Publication number: CN115840617A
Application number: CN202211476165.7A
Authority: CN
Inventors: 陈荣文
Original assignee: XFusion Digital Technologies Co Ltd
Current assignee: XFusion Digital Technologies Co Ltd
Priority date: 2022-11-23
Filing date: 2022-11-23
Publication date: 2023-03-24

Abstract

The application provides a debugging method, a debugging system and a related device. The method comprises the following steps: receiving a debugging instruction, and acquiring a kernel dump file based on the debugging instruction; based on the kernel dump file, searching whether a target debugging container matched with the kernel dump file exists in the container pool, and if the target debugging container is searched in the container pool, calling the target debugging container to debug the kernel dump file; if the target debugging container is not found in the container pool, acquiring target container information, wherein the target container information is used for constructing a target debugging container matched with the kernel dump file; and constructing and obtaining a target debugging container according to the target container information, and calling the target debugging container to debug the kernel dump file. By implementing the embodiment of the application, different kernel dump files are debugged in the debugging container, so that hardware resources for debugging the kernel dump files can be reduced, the deployment time is also reduced, and the debugging efficiency is favorably improved.

Description

Debugging method, system and related device

Technical Field

The present invention relates to the field of computer technologies, and in particular, to a debugging method, a debugging system, and a related apparatus.

Background

With the development of computer devices, such as a server, when a hardware problem occurs or a system crashes, a memory dump is triggered to generate a kernel dump file. The kernel dump refers to a process in which an Operating System (OS) in a computer device writes a kernel of a process address space and other information about a process state into a disk file when the process terminates its operation by receiving some signal. Wherein, the technician can utilize the debugging tool to carry out debugging analysis on the kernel dump file, thereby determining the operating condition of the computer equipment. At present, before debugging a kernel dump file, a corresponding debugging environment needs to be built in a virtual machine or a physical machine, because the OS types, OS kernel versions and Central Processing Unit (CPU) architectures of computer devices are more, and a memory dump file is associated with the CPU architecture and the OS kernel version, more virtual machines or physical machines are needed to build different debugging environments before debugging, which wastes hardware resources, consumes longer time, and requires long debugging time.

Disclosure of Invention

The embodiment of the application provides a debugging method, a debugging system and a related device, which can save hardware resources for debugging a kernel dump file and can also improve debugging efficiency.

In a first aspect, embodiments of the present application provide a debugging method, which may be executed by a computer device or by a module in the computer device, such as a chip or a processor. The method can comprise the following steps: receiving a debugging instruction, and acquiring a kernel dump file based on the debugging instruction; the debugging instruction carries the kernel dump file or carries storage path information of the kernel dump file; searching whether a target debugging container matched with the kernel dump file exists in a container pool or not based on the kernel dump file, and calling the target debugging container to debug the kernel dump file if the target debugging container is searched in the container pool; if the target debugging container is not found in the container pool, acquiring target container information, wherein the target container information is used for constructing a target debugging container matched with the kernel dump file; and constructing a target debugging container according to the target container information, and calling the target debugging container to debug the kernel dump file.

By the method provided by the first aspect, before debugging the kernel dump file, the kernel debugging file can be debugged by searching the target debugging container matched with the kernel dump file to be debugged in the container pool. The debugging environment of the kernel dump file is provided by the container, and a plurality of debugging containers can be deployed on one physical machine or virtual machine, namely a plurality of debugging environments are deployed, so that different kernel dump files can be debugged by different debugging containers, hardware resources occupied by debugging different kernel dump files can be reduced, and hardware resources are saved. Moreover, a user does not need to manually build a debugging container and manually install debugging information and debugging tools, but automatically builds the debugging container for debugging dump files of different kernels through computer equipment, so that the time for building a debugging environment is reduced, the lightweight and rapid building of the debugging environment are realized, the debugging efficiency is improved, and the efficiency of solving the problem of faults of a positioning system is improved.

In one possible implementation, the method further includes: acquiring kernel version information of the kernel dump file and kernel version information corresponding to each debugging container in the container pool; and if the kernel version information of the kernel dump file is different from the kernel version information corresponding to each debugging container, determining that the target debugging container is not found from the container pool. In the embodiment of the application, it is first determined whether kernel version information corresponding to one or more debugging containers in a container pool is the same as kernel version information of a kernel dump file, and then further screening is performed, if the kernel version information corresponding to the debugging containers is not the same as the kernel version information of the kernel dump file, it is determined that a debugging environment provided by the debugging container cannot be used for debugging the kernel dump file, that is, a target debugging container used for debugging the kernel dump file is not found in the container pool.

In one possible implementation, the method further includes: if the kernel version information of the kernel dump file is the same as the kernel version information corresponding to at least one debugging container in the container pool, acquiring the kernel debugging information of the at least one debugging container; and if the kernel dump file is not matched with the kernel debugging information of each debugging container in the at least one debugging container, determining that the target debugging container is not found from the container pool. In the embodiment of the application, in the process of querying a target debugging container in a container pool, the kernel version information is only primarily screened, if a debugging container capable of providing a debugging environment of the kernel dump file needs to be determined, the kernel debugging information needs to be further screened, and the debugging container obtained after twice screening is the debugging container capable of providing the debugging environment for the kernel dump file, so that the target container matched with the kernel dump file can be quickly found in a plurality of debugging containers, the efficiency of debugging the kernel dump file is improved, and the efficiency of positioning system fault problems is improved.

In a possible implementation manner, the kernel version information corresponding to the target debugging container is the same as the kernel version information of the kernel dump file, and the kernel debugging information of the target debugging container is matched with the kernel dump file. In the embodiment of the application, the matched target debugging container is searched in the plurality of debugging containers in the container pool, and kernel version information matching and kernel debugging information matching are required, so that the target debugging container can be quickly found by searching, the debugging efficiency is improved, and the efficiency of positioning faults is also improved.

In a possible implementation manner, the target container information includes operating system information corresponding to the kernel dump file and kernel debugging information corresponding to the kernel dump file. In the embodiment of the application, the operating system information can be used for acquiring the container image file, so that an initial container corresponding to the operating system information is quickly constructed, a debugging container is constructed according to the kernel debugging information, the efficiency of constructing the debugging environment by acquiring the target container information is high, the debugging environment does not need to be manually constructed by a user, and the debugging efficiency of debugging the kernel dump file is improved.

In a possible implementation manner, the obtaining target container information includes: outputting prompt information for prompting a user to input the operating system information; and receiving the operating system information, wherein the operating system information comprises an operating system type and an operating system version. In the embodiment of the application, a user can interact with a platform for managing the debugging container, prompt information can be output in a user interface of the platform for managing the debugging container when the container is constructed, so that the computer equipment can receive operating system information input by the user and is used for constructing the container.

In a possible implementation manner, the constructing and obtaining a target debug container according to the target container information includes: acquiring a container image file according to the operating system information, wherein the container image file is used for constructing a debugging container matched with the operating system information; and constructing an initial container according to the container image file, and adding kernel debugging information corresponding to the kernel dump file into the initial container to obtain the target debugging container. In the embodiment of the application, an initial container matched with the operating system information can be obtained by installing a container mirror image file, the kernel version information of the initial container is matched with the version information of the kernel dump file, and the kernel debugging information is added into the initial container, so that the obtained target debugging container is matched with the debugging information of the kernel dump file, thereby completing the construction of a debugging environment and obtaining the target debugging container. The debugging container can be automatically constructed without manual construction of the debugging container by a user in the mode, the time for constructing the debugging environment is saved, and the lightweight rapid construction of the debugging environment is realized, so that the debugging efficiency is improved, and the efficiency of solving the problem of the fault of the positioning system is improved.

In a second aspect, an embodiment of the present application provides a debugging system, which may include: the system comprises an instruction preprocessing layer, a container management layer and a container pool; the container pool is used for storing at least one debugging container; the instruction preprocessing layer is used for receiving a debugging instruction and acquiring a kernel dump file based on the debugging instruction; the debugging instruction carries the kernel dump file or carries storage path information of the kernel dump file; the container management layer is used for searching whether a target debugging container matched with the kernel dump file exists in a container pool or not based on the kernel dump file, and calling the target debugging container to debug the kernel dump file if the target debugging container is searched in the container pool; the container management layer is further configured to obtain target container information if the target debugging container is not found in the container pool, where the target container information is used to construct a target debugging container matched with the kernel dump file; the container management layer is also used for constructing and obtaining a target debugging container according to the target container information and calling the target debugging container to debug the kernel dump file; the container management layer is further configured to add the target debug container to the container pool.

In one possible implementation manner, the instruction preprocessing layer includes an instruction parsing module, a kernel information extraction module and a request transmission module; the analysis instruction module is used for receiving the debugging instruction, acquiring the kernel dump file based on the debugging instruction, and transmitting the debugging instruction to the kernel information extraction module; the kernel information extraction module is used for extracting kernel version information of the kernel dump file and transmitting the kernel dump file and the kernel version information of the kernel dump file to the request transmission module; the request transmission module is configured to send a debug request to the container management layer, where the debug request carries kernel version information of the kernel dump file and the kernel dump file, or the kernel version information of the kernel dump file and the storage path information.

In one possible implementation, the container management layer includes a container scheduling module, a container information database; the container scheduling module is used for receiving the debugging request from the instruction preprocessing layer and acquiring kernel version information of the kernel dump file and kernel version information corresponding to each debugging container in the container pool; the container scheduling module is further configured to determine that the target debugging container is not found from the container pool if the kernel version information of the kernel dump file is different from the kernel version information corresponding to each debugging container; and the container information database is used for storing the kernel version information corresponding to each debugging container in the container pool.

In a possible implementation manner, the container scheduling module is further configured to obtain kernel debugging information of at least one debugging container in the container pool if kernel version information of the kernel dump file is the same as kernel version information corresponding to the at least one debugging container; the container scheduling module is further configured to determine that the target debug container is not found from the container pool if the kernel dump file is not matched with the kernel debug information of each of the at least one debug container.

In a possible implementation manner, the container management layer further includes a container arrangement management module; the container scheduling module is further configured to transmit the debugging request to the container arrangement management module if the target debugging container is not found in the container pool; the container arrangement management module is used for acquiring the target container information and constructing a target debugging container according to the target container information; the container scheduling module is used for calling the target debugging container to debug the kernel dump file.

In a possible implementation manner, the kernel version information corresponding to the target debugging container is the same as the kernel version information of the kernel dump file, and the kernel debugging information of the target debugging container is matched with the kernel dump file.

In a possible implementation manner, the container arrangement management module is configured to construct a target debug container according to the target container information, and specifically configured to: acquiring a container image file according to the operating system information, wherein the container image file is used for constructing a debugging container matched with the operating system information; and constructing an initial container according to the container image file, and adding kernel debugging information corresponding to the kernel dump file into the initial container to obtain the target debugging container.

In a third aspect, an embodiment of the present application provides a debugging apparatus, including:

the device comprises a receiving unit, a debugging unit and a control unit, wherein the receiving unit is used for receiving a debugging instruction and acquiring a kernel dump file based on the debugging instruction; the debugging instruction carries the kernel dump file or carries storage path information of the kernel dump file;

a searching unit, which searches whether a target debugging container matched with the kernel dump file exists in a container pool based on the kernel dump file too much, and calls the target debugging container to debug the kernel dump file if the target debugging container is searched in the container pool;

an obtaining unit, configured to obtain target container information if the target debugging container is not found in the container pool, where the target container information is used to construct a target debugging container that matches the kernel dump file;

and the construction unit is used for constructing and obtaining a target debugging container according to the target container information and calling the target debugging container to debug the kernel dump file.

In addition, in this aspect, for other alternative embodiments of the channel transmission device, reference may be made to the related contents of the first aspect, and details are not described here.

In a fourth aspect, the present application provides a chip, which includes a memory and a processor, where the memory stores a computer program, and the computer program includes program instructions, and the processor is configured to execute the program instructions to implement the method according to the first aspect.

In a fifth aspect, the present application provides a computer device, which includes a processor and a memory, where the processor and the memory are connected to each other, where the memory is used to store a computer program, and the computer program includes program instructions, and the processor is configured to call the program instructions to execute the method according to the first aspect.

In a sixth aspect, embodiments of the present application provide a computer-readable storage medium storing a computer program, the computer program comprising program instructions that, when executed, cause the method of the first aspect to be implemented.

Drawings

In order to more clearly illustrate the technical solutions in the embodiments or the background art of the present application, the drawings required to be used in the embodiments or the background art of the present application will be described below.

Fig. 1 is a schematic system structure diagram of a debugging system according to an embodiment of the present application.

Fig. 2 is another system structural diagram of a debugging system according to an embodiment of the present application.

Fig. 3 is a schematic flowchart of a debugging method according to an embodiment of the present application.

Fig. 4 is a schematic user interface diagram of a debugging method according to an embodiment of the present application.

Fig. 5 is a schematic view of another user interface of a debugging method according to an embodiment of the present application.

Fig. 6 is an architecture diagram of a debugging system according to an embodiment of the present application.

Fig. 7 is a flowchart illustrating a debugging method according to an embodiment of the present application.

Fig. 8 is a schematic structural diagram of a debugging apparatus according to an embodiment of the present application.

Fig. 9 is a schematic structural diagram of a computer device according to an embodiment of the present application.

Detailed Description

The embodiments of the present application will be described below with reference to the drawings.

The terms "first," "second," "third," and "fourth," etc. in the description and claims of this application and in the accompanying drawings are used for distinguishing between different objects and not for describing a particular order. Furthermore, the terms "include" and "have," as well as any variations thereof, are intended to cover non-exclusive inclusions. For example, a process, method, system, article, or apparatus that comprises a list of steps or elements is not limited to only those steps or elements listed, but may alternatively include other steps or elements not listed, or inherent to such process, method, article, or apparatus.

It should be understood that in the present application, "at least one" means one or more, "a plurality" means two or more. "and/or" for describing an association relationship of associated objects, indicating that there may be three relationships, e.g., "a and/or B" may indicate: only A, only B and both A and B are present, wherein A and B may be singular or plural. The character "/" generally indicates that the former and latter associated objects are in an "or" relationship. "at least one of the following" or similar expressions refer to any combination of these items, including any combination of single item(s) or plural items. For example, at least one (one) of a, b, or c, may represent: a, b, c, "a and b", "a and c", "b and c", or "a and b and c", wherein a, b and c may be single or plural.

Reference herein to "an embodiment" means that a particular feature, structure, or characteristic described in connection with the embodiment can be included in at least one embodiment of the application. The appearances of the phrase in various places in the specification are not necessarily all referring to the same embodiment, nor are separate or alternative embodiments mutually exclusive of other embodiments. It is explicitly and implicitly understood by one skilled in the art that the embodiments described herein can be combined with other embodiments.

As used in this specification, the terms "component," "module," "system," and the like are intended to refer to a computer-related entity, either hardware, firmware, a combination of hardware and software, or software in execution. For example, a component may be, but is not limited to being, a process running on a processor, an object, an executable, a thread of execution, a program, and/or a computer. By way of illustration, both an application running on a computing device and the computing device can be a component. One or more components can reside within a process and/or thread of execution and a component can be localized on one computer and/or distributed between 2 or more computers. In addition, these components can execute from various computer readable media having various data structures stored thereon. The components may communicate by way of local and/or remote processes such as in accordance with a signal having one or more data packets (e.g., data from two components interacting with another component in a local system, distributed system, and/or across a network such as the internet with other systems by way of the signal).

First, before further detailed description of the embodiments of the present application, terms and terminology referred to in the embodiments of the present application are explained to facilitate understanding for those skilled in the art. The terms and expressions referred to in the embodiments of the present application are used for the following explanations:

1. kernel Dump (Kernel Crash Dump)

The kernel dump may refer to that when a kernel thread sends an error or receives a signal to terminate execution, the system may, with the aid of some tools, write a kernel image into a file for later debugging, that is, the kernel dump may be understood as that when a program crashes (for example, a hardware error or a kernel error), the system generates a kernel (core) file in a specified directory, where the kernel file is used for debugging in a debugging environment corresponding to the kernel file to locate information or a fault root cause of the kernel that has a fault such as a crash, an error or an interrupt. The core may refer to a main memory (main memory) of the system.

It should be noted that, the kernel dump stores the running state of the process at a certain time, which is generated when the process has a problem, so that a file obtained by the kernel dump (i.e., a kernel dump file) can be debugged, and the state of the process at the moment when the kernel dump file is generated can be known, so as to find a problem point, so as to prevent the next program crash.

In the present application, a computer device may start a function such as dumping memory operation parameters, or configure a service such as dumping memory operation parameters, so that the computer device may trigger an operation of dumping memory operation parameters when a system crashes, deadlocks, or crashes. For example, a server may configure a kernel dump service (kdump) service, where the kdump service is used to dump memory when a system of the server crashes, and generate a kernel dump file.

2、OS

An OS refers to a set of interrelated system software programs that host and control computer device operations, exercise and run hardware, software resources and provide common services to organize user interactions. The OS may be classified into a desktop OS, a mobile phone OS, a server OS, an embedded OS, and the like according to different operating environments. It is understood that the OS is a part of software, which is the first layer of software on a hardware basis, and is the bridge (or interface, man-in-the-middle, intermediary, etc.) that hardware communicates with other software. The OS may also control other programs to run, manage system resources, provide the most basic computing functions, such as managing and configuring memory, determining the priority of system resource supply and demand, and provide some basic service programs, such as file systems, device drivers, user interfaces, system service programs, and the like.

In the present application, the same type of OS may also include different versions, for example, the release version of the Linux system may include RHEL, SLES, ubuntu, and the like, and for example, windows7 and Windows10 are all different versions of the Windows system. Each release may be further subdivided into large and small versions. The same or different OSs may be installed in different computer devices (e.g., servers). It will be appreciated that computer devices running different types of OS will generate different kernel dump files. The kernel dump files generated by computer devices running the same OS but with different versions are also different.

It is to be understood that "operating system" and "OS" are only words used in this embodiment, and the meaning of the words is described in this embodiment, and the name of the words does not limit this embodiment in any way. In addition, in some other embodiments of the present application, "OS" may also be referred to by other terms such as "system".

3. Inner core

The kernel refers to the most core functional framework part in the OS or corresponding software, which is the basis for realizing all functions of the software. The kernel also includes different versions, and the kernel version refers to a version number of the corresponding software kernel after the corresponding function is modified or added all the time. It should be noted that the version of the OS may be divided into two parts, namely, a kernel version and a release version. The Linux distribution in the above example refers to a system version of software including other peripheral function parts and a human-machine interaction part in addition to providing an OS kernel, such as a C/C + + compiler, a library, and the like. The OS version mentioned above refers to a release version. Kernel versions refer to the kernel of the operating system, which is responsible for controlling hardware, managing file systems, program processes, etc., and does not provide users with versions of various tools and application software.

In the present application, the large version and the small version subdivided in one release of the OS may have different kernel versions. The kernel dump files generated by computer devices running different kernel versions are also different.

4. Debugging environment

Debugging can refer to the process of debugging and debugging by various means after a program is programmed, namely the process of identifying and eliminating errors in computer hardware or software, and can also be understood as the process of deleting bugs from codes. The debug environment is an environment corresponding to a program for debugging. For example, the environment may be a Windows environment, a Linux environment, a Dos environment, etc. according to the category of the debugging environment.

In the present application, the types of the OS, kernel versions of the OS, and the like are different, kernel dump files generated by the computer device are different, and debugging environments required for debugging different kernel dump files are also different.

5. Container with a lid

A container refers to a packaged application or service independent of environment and all the means required for its operation, and can be understood as a defined package, in which there are programs to be executed and all the dependencies thereof, such as codes, system libraries, etc., so as to implement packaging or isolation of the application and its entire runtime environment (all the required files for running the application), so that the application can be migrated in different environments (such as development, test, production, etc.) while retaining all the functions of the application.

In this application, the container may be used to deploy a debugging environment, so as to debug the kernel dump file, where different containers may correspondingly debug different kernel dump files. Since multiple containers may be deployed on fewer virtual or physical machines, providing a debug environment via containers facilitates reducing the footprint of hardware resources.

It is understood that, in the embodiment of the present application, the container for deploying the debugging environment may also be referred to as a "debugging container," and the name of the container does not limit the embodiment in any way.

6. Mirror image file

The image file refers to a specific series of files which are made into a single file according to a certain format so as to be convenient for a user to download and use, such as an OS, games and the like. Wherein the image file may be stored in an image repository.

In this application, the image file may be a basic image file of the OS, and the image file may be used to construct a debugging environment of the kernel dump file, that is, a certain image file may be used to construct a corresponding container carrying the debugging environment of a certain kernel dump file.

In order to facilitate understanding of the embodiments of the present application, a description is first given below of a structure of one of the debugging systems on which the embodiments of the present application are based.

Referring to fig. 1, fig. 1 is a schematic diagram of a system structure of a debugging system according to an embodiment of the present application. As shown in fig. 1, the debugging system may include a first computer device 101, a second computer device 102, and a container information database 103. Both the first computer device 101 and the second computer device 102 may be computer devices having certain computing, storage, and communication resources. The container information database 103 may be a database storing container identifiers and debugging environment information, and the container information database 103 may further store information of kernel dump files that can be debugged by the debugging environment.

The first computer device 101 and the second computer device 102 may be terminal devices such as a tablet computer, a desktop computer, a smart car terminal, a notebook computer, and a smart phone. The first computer device 101 and the second computer device 102 may also be servers, for example, independent servers (e.g., a central server), a server cluster or a distributed system composed of multiple physical servers, servers deployed in a cloud environment, edge computing devices deployed in an edge environment, and the like. It is understood that fig. 1 illustrates and explains the first computer device 101 and the second computer device 102 as servers, and the forms of the first computer device 101 and the second computer device 102 in the embodiments of the present application are not limited.

Specifically, the first computer device 101 is a computer device that generates a kernel dump file, and the second computer device 102 is a debugging device that can be used to debug the kernel dump file generated by the first computer device 101. The first computer device 101 may start a function of dumping memory operation parameters, or configure a service of the memory dumping operation parameters, for example, after the kdenp service, and then trigger an operation of dumping the memory operation parameters when a hardware error or a kernel error occurs in the first computer device 101, dump the memory, and obtain a kernel dump file. Furthermore, the kernel dump file generated by the first computer apparatus 101 is exported and imported into the second computer apparatus 102 for debugging.

In a possible implementation manner, the second computer device 102 may be a physical machine having a debugging environment for debugging the kernel dump file of the first computer device 101, or may be a virtual machine including a debugging environment for carrying the kernel dump file for debugging the first computer device 101, and when receiving the imported kernel dump file, the second computer device 102 may debug the kernel dump file in the debugging environment of the kernel dump file.

In another possible implementation manner, the second computer device 102 may be a work node of a container cluster, where the container cluster includes a plurality of debug containers, and each debug container corresponds to a debug environment. For example, the second computer device 102 may deploy a debugging container that provides a debugging environment for debugging a kernel dump file of the first computer device 101, or may deploy multiple debugging containers, for example, the second computer device 102 may deploy a debugging container that provides a debugging environment for debugging multiple different kernel dump files, and one debugging environment may correspond to one debugging container. Specifically, the second computer device 102 may extract kernel version information according to a kernel dump file in the debugging instruction, where the kernel version information may include a kernel version corresponding to the kernel dump file, and further query a matching debugging container in the container information database 103, and if the matching debugging container is queried, debug the kernel dump file in the debugging container.

When the second computer device 102 does not query the matching debugging container in the container information database 103, the second computer device 102 may obtain information such as the OS type and the OS version corresponding to the kernel dump file, and the second computer device 102 may construct a debugging container of the kernel dump file debugging environment. Specifically, the second computer device 102 may obtain the container image according to the OS type and OS version information, and construct a debugging container of the kernel dump file debugging environment according to the container image. Further, the second computer device 102 may write the built debugging container information of the kernel dump file debugging environment into the container information database 103 for subsequent query. The second computer device 102 may also store the constructed debugging container in a container pool, where the container pool may store a plurality of debugging containers of the kernel dump file debugging environment, so as to be called in the subsequent debugging of other kernel dump files.

It is understood that the debugging system architecture in fig. 1 is used for example and does not constitute a limitation on the embodiments of the present application. Alternatively, the first computer device 101 and the second computer device 102 may be the same device.

It should be noted that the computer devices (such as the first computer device 101 and the second computer device 102 described above) referred to in this application may be computer devices, and may also be modules in the computer devices, such as chips or processors.

Another debugging system related to the embodiments of the present application is described below.

Referring to fig. 2, fig. 2 is a schematic structural diagram of a debugging system according to an embodiment of the present disclosure. As shown in fig. 2, the debugging system may include a node device cluster 204 composed of a first computer device 201, a second computer device 202, a container information database 203, and one or more node devices. Each of the first computer device 201, the second computer device 202, and the node device cluster 204 may be a computer device having certain computing, storage, and communication resources. The container information database 203 may be a database storing container identifications and debugging environment information, and the container information database 203 may further store information of a kernel dump file that can be debugged by the debugging environment. Each node device in the node device cluster 204 may deploy multiple debug containers for management and invocation by the second computer device 202.

Each node device in the first computer device 201, the second computer device 202, and the node device cluster 204 may be a terminal device, for example, a tablet computer, a desktop computer, an intelligent vehicle-mounted terminal, a notebook computer, a smart phone, and the like. The first computer device 201, the second computer device 202, and the node device cluster 204 may also be servers, for example, independent servers (e.g., central servers), a server cluster or a distributed system composed of a plurality of physical servers, servers deployed in a cloud environment, edge computing devices deployed in an edge environment, and the like. It can be understood that fig. 2 illustrates and explains an example in which the first computer device 201 is a terminal device, the second computer device 202 is a server, and each node device in the node device cluster 204 is a server, and forms of the first computer device 201, the second computer device 202, and the node device in the node device cluster 204 are not limited in this embodiment.

Specifically, the first computer device 201 may be a computer device of a user, and the user may input a debugging instruction through the computer device, where the debugging instruction may carry a path of the kernel dump file. The second computer device 202 may be a computer device providing a user interface, that is, the second computer device 202 may provide a platform for managing each debugging container, and the second computer device 202 may further obtain information of each debugging container from the container information database 203 and output the user interface, so that a user may visually view the information of each debugging container from the user interface provided by the platform. Optionally, the second computer device 202 may also display user-triggered debugging instructions, i.e. display one or more debugging tasks, and information of the debugging tasks.

In a possible implementation manner, when receiving a debugging instruction sent by the first computer device 201, the second computer device 202 extracts kernel version information of the kernel dump file according to a path of the kernel dump file in the debugging instruction, queries a matching debugging container in the container information database 203, and if a matching debugging container is queried, debugs the kernel dump file in the debugging container, that is, the second computer device 202 may invoke a debugging container deployed on a certain node device in the node device cluster 204 to debug the kernel dump file. Under the condition that the second computer device 202 does not query the matching debugging container in the container information database 203, the second computer device 202 may obtain information such as the OS type and the OS version corresponding to the kernel dump file, construct a debugging container of the debugging environment of the kernel dump file, and deploy the constructed debugging container on a certain node device in the node device cluster 204. Optionally, under the condition that each node device of the node device cluster 204 has deployed more containers, a new node device may be added to deploy the constructed containers, that is, the node device may perform dynamic capacity expansion.

Further, the second computer device 202 may write the built debugging container information of the kernel dump file debugging environment into the container information database 203 for subsequent query. The second computer device 202 may also store the built debugging container in a container pool for later invocation when debugging other kernel dump files. The container pool may store a plurality of debugging containers of the kernel dump file debugging environment, and the plurality of debugging containers in the container pool are deployed by each node device in the node device cluster 204.

It is understood that the debugging system architecture in fig. 2 is used for example and does not constitute a limitation on the embodiments of the present application. It should be noted that the computer devices (such as the first computer device 201, the second computer device 202, and each node device in the node device cluster 204) referred to in this application may be computer devices, or may be modules in the computer devices, such as chips or processors.

Based on the architectures of the debugging systems provided in fig. 1 and fig. 2, the technical problems proposed in the present application are specifically analyzed and solved in combination with the debugging method provided in the present application. Referring to fig. 3, fig. 3 is a schematic flowchart of a debugging method according to an embodiment of the present disclosure. The method may comprise 3 stages.

The first stage is as follows: the computer device extracts kernel version information of the kernel dump file.

S301, the computer device receives a debugging instruction of the kernel dump file.

The computer device may receive a debugging instruction input by a user. For example, a user may directly input a debugging instruction of a kernel dump file, the debugging instruction carrying the kernel dump file or a path of the kernel dump file. For another example, the user may input a debugging instruction through a user interface provided by the platform for managing the debugging container, where the debugging instruction may carry a path of the kernel dump file or the kernel dump file. Optionally, a use help can also be displayed in the user interface for helping the user operate the platform for managing the debugging container.

In one possible implementation, the computer device may determine whether the input instruction is legal or not according to whether the debugging instruction input by the user is wrong. For example, the computer device may determine whether a debugging instruction input by the user has a format error or other errors, and if so, output prompt information for prompting the user that the instruction has an error. Optionally, a modification suggestion may also be input for the user to modify the debugging instructions.

For example, please refer to fig. 4 together, and fig. 4 is a schematic user interface diagram of a debugging method according to an embodiment of the present application. As shown in fig. 4, the user interface may be a user interface of a platform for managing a debugging container, and the user interface may include a control for "debugging a kernel dump file", a control for "querying a debugging environment", and an interface for displaying a debugging task. The interface of the debugging task may include information such as "task name", "task ID", "task description", "modifier", "modification time", "kernel version", and "operation". It is understood that the interface of the debugging task in fig. 4 is only an example, and may further include other information, such as a container identifier, which is not limited in this application.

In one possible implementation, the computer device may trigger a debugging instruction of the kernel dump file in response to an instruction input by a user for a control of "debugging the kernel dump file". Further, the computer device may output a user interface for prompting the user to enter a kernel dump file, for example, the boxes in the user interface in the middle of FIG. 4 may include an input control for "kernel dump file path" input box and "upload kernel dump file", and a "save" control and a "cancel" control after the input is completed. Specifically, the user may input a path of the kernel dump file and/or input the kernel dump file for the input box and the input control, and trigger saving, and then the computer device may obtain the path of the kernel dump file or the kernel dump file input by the user in response to the saving control.

Further, the computer device may execute the debugging task, debug the kernel dump file in a debugging container corresponding to the debugging environment of the kernel dump file, and the computer device may provide a user interface including information of the debugging task for a user to refer. As shown in fig. 4 below, the debugging task may include information such as "task name" is "debugging task", "task ID" is "task-1", "task description" is null, "modifier" is administrator, "modification time" is "2022.11.08 19," kernel version "is" XX ", and" operation "includes" pause, delete, start, and edit ". Specifically, the debugging task may further display that "kernel dump file path" is "D: \ xx "," the execution ID "is" xxxxx "," the OS type "is" Linux ", the OS version is" version A ", and" the debug container identification "is" debug container 1", and" the status "is information in" executing ".

S302, the computer equipment extracts kernel version information of the kernel dump file.

Specifically, the computer device may extract kernel version information of the kernel dump file when determining that the debugging instruction input by the user is correct. The kernel version information is information including a kernel version corresponding to the kernel dump file. Specifically, under the condition that the debugging instruction carries the kernel dump file, the computer device may analyze the kernel dump file to obtain kernel version information. Under the condition that the debugging instruction carries the path of the kernel dump file, the computer equipment can inquire the kernel dump file through the path of the kernel dump file, and then analyze the kernel dump file to obtain kernel version information. It can be understood that the kernel dump file is a binary file, and the computer device may obtain the kernel version information of the kernel dump file by parsing the binary file. For example, a platform for managing a debugging container in a computer device may be installed with a tool for parsing a kernel dump file, for example, a crash tool, and the kernel dump file may be parsed to obtain kernel version information corresponding to the kernel dump file.

And a second stage: matching the debugging environment of the kernel dump file.

S303, the computer equipment inquires a debugging container corresponding to the kernel version information from the container information database to obtain a debugging container list.

After determining the kernel version information of the kernel dump file, the computer device may query a debugging environment of the kernel dump file, where the debugging environment of the kernel dump file is an environment that can be used to debug the kernel dump file, and different debugging environments of different kernel dump files are different. The computer device may first query whether there is a matching debugging environment in an existing debugging container, and if the matching debugging environment is queried in the existing debugging environment, the computer device may debug the kernel dump file through the debugging container corresponding to the matching debugging environment. Under the condition that a matched debugging environment is not inquired in the existing debugging environment, the computer equipment can construct a debugging container aiming at the debugging environment of the kernel dump file, and the kernel dump file is debugged through the constructed debugging container.

Specifically, the computer device may query a debug container corresponding to the kernel version information from the container information database to obtain a debug container list. The container information database may store information such as a container identifier, kernel version information, a debugging environment, an OS type, an OS version, and kernel debugging information of each of the plurality of debugging containers. Therefore, the debugging container matched with the kernel version information can be inquired in the container information database according to the kernel version information of the kernel dump file, and under the condition that the matched debugging container can be inquired, the inquiry result can comprise one debugging container or a plurality of containers, namely a debugging container list.

S304, the computer device determines whether the debugging container list is empty.

The computer device determines whether the debugging list is empty according to whether the result of the query includes a debugging container, if the result of the query does not include the debugging container, the computer device determines that the debugging list is empty, otherwise, the result of the query includes at least one debugging container, and the computer device determines that the debugging list is not empty.

S305, under the condition that the debugging container list is not empty, the computer equipment inquires whether the kernel dump file is matched with the kernel debugging information of each debugging container in the debugging container list.

It should be noted that the kernel dump files generated based on different OS versions (i.e., different release versions) are different, but the kernel versions of different OS versions (i.e., different release versions) may be the same. Similarly, among many already built debug containers, there are debug containers with the same kernel version but different OS versions (i.e., different release versions). Then, under the condition that the debugging container list obtained by the computer device through querying in the container information database is not empty, the debugging container in the debugging container list needs to be further matched with the kernel dump file, so as to determine the debugging container matched with the kernel dump file.

Specifically, the computer device may query whether the kernel dump file matches the kernel debug information of each debug container in the list of debug containers. The kernel debugging information may be a debugging file, which is installed when the computer device constructs a debugging container, and is used for debugging the kernel dump file. The kernel debugging information can be understood as a symbol table, since the kernel dump file is a binary file, the kernel dump file can include information that the computer device cannot be debugged in the direct debugging process, and the kernel debugging information can be equivalent to information that characters in the kernel dump file can be converted into the computer device can be debugged, which is similar to the process of translating characters in the kernel dump file into information that the computer device can be debugged, so that the computer device can debug the kernel dump file.

S306, the computer device determines whether the kernel dump file is matched with the kernel debugging information.

In a possible implementation manner, the computer device may control each debugging container in the debugging container list to debug the kernel dump file, if the debugging is possible, it is proved that the kernel debugging information of the debugging container matches the kernel dump file, and then the debugging environment of the debugging container matches the kernel dump file, and the debugging container may be further selected to enter a debugging process of the kernel dump file. If a plurality of debugging containers in the debugging container list can debug the kernel dump file, one debugging container can be randomly selected from the debugging containers capable of being debugged to enter a debugging process of the kernel dump file. Each debugging container in the container information database is provided with a debugging tool, such as a crash tool, which can debug a certain kernel dump file. Alternatively, the crash tool may be different in different debug containers. The computer device may attempt to debug and analyze the kernel dump file by calling the debug tool in each debug container in the list of debug containers to determine whether a match is made with the kernel dump file. Optionally, the computer device may send a crash command related to debugging the kernel dump file to each debugging container in the debugging container list when invoking the debugging tool in the debugging container, or may use other methods, which is not limited in this application.

S307, under the condition that the debugging container list is empty, the computer equipment acquires the OS type, the OS version and the corresponding kernel debugging information.

In a possible implementation manner, when the computer device queries the debug container corresponding to the kernel version information in the container information database, the computer device may construct a debug container of a debug environment of the kernel dump file under the condition that the debug container corresponding to the kernel version information is not queried, or when the kernel debug information of each debug container in the debug container list of the computer device is not matched with the kernel dump file, and the computer may obtain the OS type, the OS version, and the corresponding kernel debug information used for constructing the debug container. Wherein the computer device can output information for prompting a user to input an OS type, an OS version, and a kernel debug file for constructing a debug environment in the provided user interface so as to acquire.

For example, please refer to fig. 5 in conjunction, fig. 5 is a schematic diagram of another user interface of a debugging method according to an embodiment of the present application. As shown in fig. 5, the hint information may be a user interface for constructing debugging information, the user interface including an input control for inputting an OS type, an input control for inputting an OS version, a control for uploading a kernel debugging file, and a "save" control and a "cancel" control. Optionally, the kernel debugging file may be a file, or may be in other manners, for example, a path of the kernel debugging file, and fig. 5 explains and draws the kernel debugging information in the form of the debugging file, which is not limited herein.

Optionally, the user may not upload the kernel debugging file, and the computer device may obtain the corresponding kernel debugging file according to the OS type, the OS version, and the kernel version information, to obtain the kernel debugging information. Specifically, the user may input the OS type and the OS version in the user interface shown in fig. 5, and may also upload the kernel debug file, and the computer device may obtain the corresponding container image and the kernel debug information according to the OS type and the OS version, and construct the debug container of the debug environment of the kernel dump file according to the container image and the kernel debug information.

S308, the computer equipment acquires the container mirror image corresponding to the OS type and the OS version and builds a debugging environment.

In a possible implementation manner, the computer device may obtain a corresponding container image file from an image repository according to the OS type and the OS version, where the container image file may be a basic image and is an existing image file for the OS type and the OS version. For example, the computer device may install the container image file, resulting in an initial container. Further, the computer device may install kernel debugging information and debugging information in the initial container, thereby obtaining a debugging container, where the computer device may obtain, from a common database, a kernel debugging file corresponding to the OS type and the OS version, and obtain the kernel debugging information. For example, the computer device may transfer a kernel debugging file of the kernel debugging information into the initial container and install the kernel debugging file, and install a debugging tool, such as a crash tool, to obtain a debugging container of the debugging environment of the kernel dump file, where the debugging tool may be used to call the kernel debugging information to debug the kernel dump file.

Further, after the debug container of the debug environment of the kernel dump file is constructed, the container identifier of the debug container may be determined, and the container identifier of the debug container and the information of the debug container are written into the container information database in a corresponding manner, so as to be called later. The information of the debug container may include kernel version information, OS type, OS version, mapping information of kernel debug information and container identifier of the debug container, and is written into a container information database, that is, a mapping table of the container identifier of each debug container in the multiple debug containers and the information of the debug container is stored in the container information database, so as to perform subsequent query. If the container information data table is queried to determine whether a debugging container of a certain debugging environment exists, the kernel version information of the kernel dump file can be queried when the kernel dump file needs to be debugged. It will be appreciated that each debug container may correspond to one or more records, as there may be multiple kernel versions corresponding to the same OS version (i.e., release version).

After the building is completed, the computer device may try to debug the kernel dump file with the built debugging container, and if the built debugging container is capable of debugging the kernel dump file, it is determined that the building of the debugging container is successful, and a debugging environment corresponding to the built debugging container may be determined as a matching debugging environment.

And a third stage: and debugging the kernel dump file in the matched debugging environment.

S309, under the condition that the kernel dump file is matched with the kernel debugging information, the computer equipment selects a matched debugging container to enter a debugging process of the kernel dump file.

In one possible implementation, the computer device may select a matching debugging container for a debugging process of the kernel dump file. The debugging container may be one of a plurality of preset debugging containers in the container information database, or may be a newly constructed debugging container. The computer device may call the debugging container to debug the kernel dump file, and obtain a debugging result.

And S310, debugging the kernel dump file by the computer equipment.

Specifically, the computer device may send a crash command to the debug container, the crash command for invoking the debug container to debug the kernel dump file. The core dump file may be understood as a snapshot when the core fails, the snapshot may record information when the core fails, and the debugging may be understood as an operation of querying information, that is, querying corresponding information from the core dump file according to different input debugging commands. Illustratively, the kernel dump file may include information of objects, registers, etc. that kernel thread a calls upon a kernel failure. In the debugging process, the computer device may receive a debugging command for querying an object called by the kernel thread a when the kernel fails, where the debugging command may be input by a user, for example, what information the user wants to query, and then input a corresponding debugging command; the debugging command can also be triggered by computer equipment, and the computer equipment is sequentially triggered according to a preset debugging command triggering sequence. Therefore, the computer device can search the debugging result from the kernel dump file, namely the object called by the kernel thread A when the kernel fails. And then the user can analyze the reason of the kernel fault according to the debugging result.

Alternatively, the user may input a command to pause the debugging, such as a trigger for a "pause" control in "operation" shown in fig. 4, for pausing the debugging of the kernel dump file. The user may also input a command to suspend debugging, for example, to delete debugging of the kernel dump file for the "delete" control in "operation" shown in fig. 4. Optionally, after the debugging is finished, the user may also input an exit instruction, where the exit instruction is used to exit the debugging. For example, after the debugging result is output in the user interface, the computer device may further receive an exit instruction input by the user for the user interface, for example, close the platform that manages the debugging container, i.e., exit the debugging.

In the embodiment of the application, on one hand, different debugging containers are used for providing debugging environments of different types of kernel dump files, and the debugging environments can be realized only by fewer virtual machines or physical machines, so that the debugging requirements for debugging various different types of kernel dump files can be met, the occupation of hardware resources is reduced, and the hardware resources are saved. On the other hand, a user does not need to manually install kernel debugging information (kernel debugging files) and debugging tools in a virtual machine or a physical machine, but can directly acquire container images through computer equipment and automatically install the container images, so that the time for building a debugging environment is saved, the lightweight and rapid building of the debugging environment is realized, the debugging efficiency is improved, and the efficiency of solving the problem of the fault of the positioning system is improved.

Based on the flow of the debugging method provided in fig. 3, the technical problem provided in the present application is specifically analyzed and solved in combination with the architecture of the debugging method provided in the present application. Referring to fig. 6, fig. 6 is a schematic diagram of an architecture of a debugging system according to an embodiment of the present application.

As shown in fig. 6, the debugging system can be logically divided into three layers: an instruction preprocessing layer 61, a container management layer 62, and a container pool 63.

The instruction preprocessing layer 61 is configured to receive a debug instruction 60, and obtain a kernel dump file based on the debug instruction 60, where the debug instruction 60 carries a kernel dump file or storage path information of the kernel dump file. The instruction preprocessing layer 61 is also used to preprocess instructions input by the user. For example, the method may be used to determine whether the debugging instruction 60 input by the user is incorrect or legal, and may also be used to extract kernel version information of the kernel dump file.

The instruction preprocessing layer 61 includes three modules: a parsing instruction module 611, a kernel information extraction module 612, and a request transmission module 613. The analysis instruction module 611 is configured to receive the debug instruction 60, and after receiving the debug instruction 60, obtain a kernel dump file based on the debug instruction 60, and analyze the debug instruction 60, so as to determine whether the debug instruction 60 is incorrect. When the instruction parsing module 611 determines that the debug instruction 60 is error-free, the debug instruction is transmitted to the kernel information extraction module 612. The kernel information extraction module 612 is configured to extract kernel version information of the kernel dump file, that is, the kernel information extraction module 612 analyzes the kernel dump file indicated in the debug instruction 60 to obtain the kernel version information of the kernel dump file. The kernel dump file may be carried by the debug instruction 60, or may be indicated according to a path of the kernel dump file carried by the debug instruction 60. Furthermore, the kernel information extracting module 612 transmits the kernel version information of the kernel dump file and the kernel dump file to the request transmitting module 613, the request transmitting module 613 may send a debugging request to the container management layer 62, the debugging request may be used to query a debugging container of a debugging environment of the kernel dump file, the debugging request may carry the kernel version information and the kernel dump file, or the request may carry the kernel version information and the storage path information of the kernel dump file.

The container management layer 62 is used for performing orchestration management on each debug container, and receiving commands from the upper layer and scheduling the debug containers in the container pool 63 to execute the debug instructions 60, that is, the container management layer 62 may be understood as a debug container responsible for scheduling the debug environment matching the kernel dump file. Specifically, the container management layer may be configured to search, based on the kernel dump file, from the container pool whether a target debug container matching the kernel dump file exists, and if the target debug container is found from the container pool, call the target debug container to debug the kernel dump file; the container management layer is also used for acquiring target container information if the target debugging container is not found in the container pool, wherein the target container information is used for constructing a target debugging container matched with the kernel dump file; the container management layer is also used for constructing and obtaining a target debugging container according to the target container information and calling the target debugging container to debug the kernel dump file; and the container management layer is also used for adding the target debugging container into the container pool.

Among other things, the container management layer 62 includes three modules: a container arrangement management module 621, a container information database 622, and a container scheduling module 623. The container scheduling module 623 is configured to receive the debug request sent by the request transmission module 613 of the instruction preprocessing layer 61, and the container scheduling module 623 may further search the container pool 63 for a target debug container matching the kernel dump file. Specifically, the container scheduling module 623 may obtain kernel version information of the kernel dump file and kernel version information corresponding to each debug container in the container pool, where the kernel version information corresponding to each debug container in the container pool may be obtained from the container information database 622. The container scheduling module 623 may query, from the container information database 622, whether a debugging container corresponding to the kernel version information, that is, a debugging container identical to the kernel version information, is located according to the kernel version information of the kernel dump file, and if it is found that the kernel version information corresponding to at least one debugging container in the container pool 63 is identical to the kernel version information, a debugging container list is obtained, where the debugging container list includes the at least one debugging container. And further, whether the kernel debugging information of each debugging container included in the debugging container list is matched with the kernel dump file or not is determined, specifically, the container scheduling module 623 acquires the kernel debugging information of the at least one debugging container, matches the acquired kernel debugging information with the kernel dump file, and determines that a target debugging container is found in the container pool 63 under the condition that the debugging container with the kernel dump file matched with the kernel debugging information exists, so that the container scheduling module 623 can call the matched debugging container (namely, the target debugging container) to perform a debugging process of the kernel dump file.

The container scheduling module 623 does not query the kernel version information identical to the kernel version information from the container information database 622 according to the kernel version information, that is, if the kernel version information of the kernel dump file is different from the kernel version information corresponding to each debug container, that is, the debug container list is empty, the container scheduling module 623 determines that the target debug container is not found from the container pool. Or under the condition that the container scheduling module 623 queries that the kernel dump file and the kernel debugging information in each debugging container included in the debugging container list are not matched, the container scheduling module 623 determines that the target debugging container is not found from the container pool. Further, the container scheduling module 623 transmits the debug request to the container arrangement management module 621, and the container arrangement management module 621 constructs a debug container of the debug environment for the kernel dump file. The container arrangement management module 621 receives the debugging request carrying the kernel version information, and obtains target container information, where the target container information includes operating system information, the operating system information includes the OS type and OS version of the kernel dump file, and the target container information further includes kernel debugging information. For example, a user interface may be output for the user to enter the OS type, OS version, and kernel debug information described above. Further, the container arrangement management module 621 may obtain a corresponding container image file from the image repository 620 according to the OS type and the OS version, and install the container image file to obtain an initial container, where the container image file is used to construct a debugging container matched with the operating system information. Further, the kernel debugging information is added to the initial container, for example, a debugging tool and the kernel debugging information may be installed, a debugging container (i.e., a target debugging container) of the debugging environment of the kernel dump file is obtained, and the built debugging container (i.e., the target debugging container) is added to the container pool 63.

Further, the container orchestration management module 621 may write the information of the debug container into the container information database 622, and feed back a message of successful construction to the container scheduling module 623. Optionally, the container scheduling module 623 may determine whether the kernel dump file matches the kernel debug information of the built debug container, and in case of a match, select the built debug container to debug the kernel dump file (e.g., send a crash command to the matched debug container in the container pool 63).

The container pool 63 is a debugging environment for storing at least one debugging container, each debugging container corresponds to a kernel dump file, the debugging containers in the container pool 63 are managed by the container management layer 62, all the debugging containers in the container pool 63 are started at the same time when the computer device is started, and the number of the debugging containers in the container pool 63 will increase as the types of the kernel dump files increase. For example, the container pool 63 includes a debug container 631, a debug container 632, a debug container 633, a debug container 634, a debug container 635, and a debug container n. The container pool 63 may include a pre-constructed debug container, such as a debug container of a mainstream OS type and an OS version, and for example, the pre-set debug container may include: RHEL 7.6container, RHEL 7.5container, SLES 11SP4 container, SLES 12SP2 container, ubuntu 18.04.5container, ubuntu 20.04.1container, and the like. The container arrangement management module 621 may obtain the mainstream OS type, OS version, and kernel debugging information in batch, build a debugging container in batch, and add the debugging container into the container pool 63, or after receiving a debugging instruction, the container arrangement management module 621 may build a debugging container for a certain type of kernel dump file, and add the debugging container into the container pool 63.

Referring to fig. 7, fig. 7 is a flowchart illustrating a debugging method according to an embodiment of the present disclosure, where the debugging method includes the following steps S701 to S705.

S701, the computer equipment receives a debugging instruction and obtains a kernel dump file based on the debugging instruction.

In this embodiment of the present application, the debug instruction is used to instruct the computer device to debug the kernel dump file, where the debug instruction carries the kernel dump file, or carries storage path information of the kernel dump file. The kernel dump file is a file used for storing the running state of the process at the moment when the kernel process crashes. The storage path information of the kernel dump file may include a storage path of the kernel dump file, such as a file path. Optionally, the storage path may be a local storage path of the computer device, or may also be a cloud storage path, for example, a download link, and the like, which is not limited in this application.

In one possible implementation, the debugging instructions received by the computer device may be input by a user through a user interface provided by a platform that manages the debugging container. The debugging instruction received by the computer equipment can be input by a user through codes, so that the computer can verify the received debugging instruction and confirm whether the debugging instruction is wrong. When the debug command is incorrect, prompt information for prompting the user is output. The prompt message can be used for indicating the input error of the user and outputting information such as use help and the like so as to facilitate the operation of the user.

When receiving the debugging instruction, the computer device can directly acquire a kernel dump file carried by the debugging instruction. The computer device can also acquire the kernel dump file according to the storage path of the kernel dump file. For example, when the storage path information includes a storage path local to the computer device, the computer device may obtain the kernel dump file from the local file, and when the storage path information includes a download address of the cloud of the computer device, the computer device may obtain the kernel dump file according to the download address.

S702, the computer device searches whether a target debugging container matched with the kernel dump file exists in a container pool or not based on the kernel dump file.

In the embodiment of the present application, a plurality of debugging containers are stored in the container pool, and each debugging container can be used for debugging different kernel dump files, and corresponds to different OS systems and OS versions, respectively, where kernel version information of each debugging container may be the same. Optionally, the OS system, OS version, and kernel version information of at least one debug container may exist in the container pool are all the same, that is, at least one debug container may exist in the container pool and may be used to debug the same kernel dump file.

In a possible implementation manner, the computer device obtains kernel version information of a kernel dump file and kernel version information corresponding to each debug container in a container pool, and searches whether a target debug container matched with the kernel dump file exists in the container pool, the computer device may first determine whether the kernel version information of the kernel dump file is the same as the kernel version information corresponding to each debug container in the container pool, if the kernel version information of the kernel dump file is the same as the kernel version information corresponding to at least one debug container in the container pool, the computer device may further perform matching, and if the kernel version information of the kernel dump file is different from the kernel version information corresponding to each debug container, the computer device may determine that the target debug container is not found in the container pool.

Further, if the kernel version information of the kernel dump file is the same as the kernel version information corresponding to the at least one debugging container in the container pool, the kernel debugging information of the at least one debugging container can be acquired, the computer device can further match the kernel dump file with the kernel debugging information of each debugging container in the at least one debugging container obtained by the preliminary matching, and further determine whether the kernel dump file is matched with the kernel debugging information of each debugging container in the at least one debugging container obtained by the preliminary matching according to the matching result, so as to determine whether a target debugging container matched with the kernel dump file exists in the container pool according to the matching result.

The computer device may obtain the kernel version information of the debug container, for example, may query the kernel version information of each debug container in a container information database storing the container information of the debug container. The computer device can inquire the kernel version information of the kernel dump file by inputting an inquiry command, and then the computer device can compare the kernel version information and the kernel dump file to determine whether the kernel version information and the kernel dump file are the same. The computer device may also debug the kernel dump file using a preset debug instruction in at least one debug container obtained by the preliminary matching, and if the kernel dump file can be debugged, it is determined that the kernel dump file is matched with the kernel debug information of the debug container, otherwise, the kernel dump file is not matched. The preset debugging instruction can be a debugging instruction pre-stored by the computer device and used for attempting debugging, and the preset debugging instruction is only used for determining whether the debugging container is matched with the kernel dump file, and is not used for subsequent attempts.

And S703, if the computer device finds the target debugging container from the container pool, calling the target debugging container to debug the kernel dump file.

In a possible implementation manner, in the process of querying a target debugging container in a container pool, if the kernel version information of a kernel dump file is the same as the kernel version information corresponding to at least one debugging container in the container pool, the computer device may obtain the kernel debugging information of the at least one debugging container, the computer device may further match the kernel dump file with the kernel debugging information of each debugging container in the at least one debugging container obtained by the preliminary matching, and if one debugging container is matched with the kernel version information of the kernel dump file, the matched debugging container may be used as the found target debugging container. It can be understood that the kernel version information corresponding to the target debugging container is the same as the kernel version information of the kernel dump file, and the kernel debugging information of the target debugging container is matched with the kernel dump file.

Further, the computer device may invoke the target debugging container to debug the kernel dump file when finding the target container in the container pool. The computer device can call the target debugging container to debug the kernel dump file, and the debugging container provides a debugging environment for the kernel dump file. For example, the computer device may receive a debugging command input by a user, such as a coast command, by calling the target debugging container, and may obtain, based on the debugging command, information in the kernel dump file corresponding to the debugging command, thereby obtaining a debugging result.

And S704, if the target debugging container is not found in the container pool, the computer equipment acquires target container information under the condition that the container information of the kernel dump file and a preset debugging container does not meet the matching condition.

In a possible implementation manner, if the kernel dump file does not match the kernel debugging information of each of the at least one debugging container obtained by the preliminary matching, the computer device may determine that the target debugging container is not found in the container pool. Further, in the event that the computer device determines that the target debug container is not found from the container pool, the computer device may construct a debug container for debugging the kernel dump file.

In another possible implementation manner, the computer device may determine whether a target debugging container matched with the kernel dump file exists in the at least one debugging container obtained through the preliminary matching, if so, the computer device finds the target debugging container from the container pool, otherwise, if the target debugging container matched with the kernel dump file does not exist in the at least one debugging container obtained through the preliminary matching, the computer device determines that the target debugging container is not found from the container pool. Further, the computer device may construct a debugging container as a target debugging container to debug the kernel dump file.

Specifically, in the process of constructing the target debug container, the computer device may obtain target container information, where the target container information includes operating system information corresponding to the kernel dump file and kernel debug information corresponding to the kernel dump file. The operating system information may include the OS type, OS version, to which the kernel dump file corresponds. The computer equipment can acquire a container image file according to the operating system information, the container image file is used for constructing a debugging container matched with the operating system information, and then the computer equipment can construct an initial container according to the container image file and add kernel debugging information corresponding to a kernel dump file into the initial container to obtain a target debugging container.

The computer device may output prompt information for prompting the user to input operating system information in a provided user interface, the user interface may include an input box for inputting operating system information, and the user may input operating system information, such as OS type and OS version, in the input box. Optionally, the user may also directly upload the container image file corresponding to the operating system information. And the computer equipment receives operating system information input by a user and acquires the container image file according to the operating system information.

In a possible implementation manner, the container image file may be obtained by the computer device from the image repository according to the operating system information, or may be obtained by other manners, which is not limited in this application. The image repository may be a database for storing a plurality of common image files, and the image files stored in the image repository may be container image files corresponding to different operating system information. The kernel debugging information may be kernel debugging information corresponding to the operating system information, which is obtained from a database of related kernel debugging information, and the database of kernel debugging information may include kernel debugging information corresponding to different operating system information. Furthermore, the computer device may construct an initial container according to the container image file, where the initial container is a debugging container matched with the operating system information, and then the computer device may add kernel debugging information corresponding to the kernel dump file into the initial container to obtain a target debugging container.

S705, the computer device constructs a target debugging container according to the target container information, and calls the target debugging container to debug the kernel dump file.

In a possible implementation manner, the computer device may install a container image file to obtain an initial container, where the initial container is a debug container matched with operating system information corresponding to the kernel dump file, that is, kernel version information of the initial container is the same as kernel version information of the kernel dump file. Furthermore, in order to match the kernel debugging information of the debugging container (initial container) with the kernel dump file, the kernel debugging information corresponding to the kernel dump file may be added to the initial container so as to match the kernel dump file with the kernel debugging information of the debugging container, so that the computer device may use the initial container to which the kernel debugging information is added as a target debugging container.

Optionally, after the debug container is built, the computer device may call the built debug container to attempt to debug the kernel dump file, and if the built debug container is capable of debugging the kernel dump file, the computer device determines that the built debug container is the target debug container.

Further, the computer device may determine a container identifier of the debug container, and write the container identifier of the target debug container and the container information of the debug container into a container information database in a corresponding manner for subsequent invocation. The container information may include, in addition to the target container information, kernel version information, node device information deployed by the target debug container, and the like.

In a possible implementation manner, the computer device may invoke the target debug container to debug the kernel dump file, that is, the computer device may receive a debug command input by a user, and query corresponding information from the kernel dump file according to the debug command, thereby obtaining a debug result.

Furthermore, the computer device may further receive an exit instruction for exiting the debugging, which is input by the user, and the computer device receives the exit instruction, exits the debugging, for example, the platform for managing the debugging container may be closed.

In the embodiment of the application, on one hand, different debugging containers are used for providing debugging environments of different types of kernel dump files, and the debugging environments can be realized only by fewer virtual machines or physical machines, so that the debugging requirements of debugging various different types of kernel dump files can be met, the occupation of hardware resources is reduced, and the hardware resources are saved. On the other hand, a user does not need to manually install kernel debugging information (kernel debugging files) and debugging tools in a virtual machine or a physical machine, but can directly acquire container images through computer equipment and automatically install the container images, so that the time for building a debugging environment is saved, the lightweight and rapid building of the debugging environment is realized, the debugging efficiency is improved, and the efficiency of solving the problem of the fault of the positioning system is improved.

Please refer to fig. 8, fig. 8 is a schematic structural diagram of a debugging apparatus according to an embodiment of the present disclosure. The debugging apparatus 800 shown in fig. 8 may include: a receiving unit 801, a searching unit 802, an obtaining unit 803, a constructing unit 804 and a determining unit 805, wherein the following units are described in detail:

a receiving unit 801, configured to receive a debug instruction, and obtain a kernel dump file based on the debug instruction; the debugging instruction carries the kernel dump file or carries storage path information of the kernel dump file;

a searching unit 802, configured to search, based on the kernel dump file, whether a target debugging container matching the kernel dump file exists in a container pool, and if the target debugging container is searched in the container pool, call the target debugging container to debug the kernel dump file;

an obtaining unit 803, configured to obtain target container information if the target debugging container is not found in the container pool, where the target container information is used to construct a target debugging container that matches the kernel dump file;

and the constructing unit 804 is configured to construct a target debugging container according to the target container information, and call the target debugging container to debug the kernel dump file.

In a possible implementation manner, the obtaining unit 803 is further configured to: acquiring kernel version information of the kernel dump file and kernel version information corresponding to each debugging container in the container pool;

a determining unit 805, configured to determine that the target debug container is not found in the container pool if the kernel version information of the kernel dump file is different from the kernel version information corresponding to each debug container.

In a possible implementation manner, the obtaining unit 803 is further configured to: if the kernel version information of the kernel dump file is the same as the kernel version information corresponding to at least one debugging container in the container pool, acquiring the kernel debugging information of the at least one debugging container;

the determining unit 805 is further configured to determine that the target debug container is not found in the container pool if the kernel dump file is not matched with the kernel debug information of each of the at least one debug container.

In a possible implementation manner, the target container information includes operating system information corresponding to the kernel dump file and kernel debugging information corresponding to the kernel dump file.

In a possible implementation manner, the obtaining unit 803 is configured to obtain the target container information, and specifically configured to:

outputting prompt information for prompting a user to input the operating system information;

and receiving the operating system information, wherein the operating system information comprises an operating system type and an operating system version.

In a possible implementation manner, the constructing unit 804 is configured to construct and obtain a target debug container according to the target container information, and specifically is configured to:

acquiring a container image file according to the operating system information, wherein the container image file is used for constructing a debugging container matched with the operating system information;

and constructing an initial container according to the container image file, and adding kernel debugging information corresponding to the kernel dump file into the initial container to obtain the target debugging container.

It should be noted that, for the functions of the functional units in the debugging apparatus 800 described in the embodiment of the present application, reference may be made to the description of S701-S705 in the above method embodiment in fig. 7, which is not described herein again.

The embodiment of the present application also discloses a computer device, please refer to fig. 9, which may include at least a processor 901, a communication interface 902, and a computer storage medium 903. The processor 901, the communication interface 902, and the computer storage medium 903 in the computer device may be connected by a bus or other means.

The computer storage medium 903 is a memory device in a computer device for storing programs and data. It is understood that the computer storage medium 903 herein may include a built-in storage medium of the computer device, and may also include an extended storage medium supported by the computer device. Computer storage media 903 provides storage space that stores the operating system of the computer device. Also stored in this memory space are one or more instructions, which may be one or more computer programs (including program code), suitable for being loaded and executed by processor 901. Note that the computer storage media herein can be high-speed RAM memory; optionally, the computer storage medium may be at least one computer storage medium remote from the processor, where the processor may be referred to as a Central Processing Unit (CPU), and is a core and a control center of the computer device, and is adapted to implement one or more instructions, and specifically load and execute the one or more instructions to implement the corresponding method flow or function.

In one embodiment, one or more first instructions stored in a computer storage medium may be loaded and executed by processor 901 to implement the corresponding steps of the method in the above-described embodiment of the content push method; in particular implementations, one or more first instructions in the computer storage medium are loaded by the processor 901 and perform the following:

receiving a debugging instruction, and acquiring a kernel dump file based on the debugging instruction; the debugging instruction carries the kernel dump file or carries storage path information of the kernel dump file;

searching whether a target debugging container matched with the kernel dump file exists in a container pool or not based on the kernel dump file, and calling the target debugging container to debug the kernel dump file if the target debugging container is searched in the container pool;

if the target debugging container is not found in the container pool, acquiring target container information, wherein the target container information is used for constructing a target debugging container matched with the kernel dump file;

and constructing a target debugging container according to the target container information, and calling the target debugging container to debug the kernel dump file.

In one implementation, the processor 901 loads and executes one or more first instructions stored in a computer storage medium to further perform the following steps:

acquiring kernel version information of the kernel dump file and kernel version information corresponding to each debugging container in the container pool;

and if the kernel version information of the kernel dump file is different from the kernel version information corresponding to each debugging container, determining that the target debugging container is not found from the container pool.

if the kernel version information of the kernel dump file is the same as the kernel version information corresponding to at least one debugging container in the container pool, acquiring the kernel debugging information of the at least one debugging container;

and if the kernel dump file is not matched with the kernel debugging information of each debugging container in the at least one debugging container, determining that the target debugging container is not found from the container pool.

In one implementation manner, the kernel version information corresponding to the target debugging container is the same as the kernel version information of the kernel dump file, and the kernel debugging information of the target debugging container is matched with the kernel dump file.

In one implementation, the target container information includes operating system information corresponding to the kernel dump file and kernel debugging information corresponding to the kernel dump file.

In one implementation, the processor 901 loads and executes one or more first instructions stored in a computer storage medium to obtain target container information, which is specifically configured to:

receiving the operating system information, wherein the operating system information comprises an operating system type and an operating system version.

In an implementation manner, the processor 901 loads and executes one or more first instructions stored in a computer storage medium to construct a target debug container according to the target container information, specifically to:

The specific implementation of each step executed by the processor 901 in the embodiment of the present application can refer to the description of the related content in the foregoing embodiments, and can also achieve the same technical effect, and is not repeated herein.

The embodiment of the present application further provides a computer-readable storage medium, in which a computer program is stored, and a processor runs the computer program, so that the computer device executes the method provided by the foregoing embodiment.

Embodiments of the present application also provide a computer program product or computer program comprising computer instructions stored in a computer-readable storage medium. The processor of the computer device reads the computer instructions from the computer-readable storage medium, and the processor executes the computer instructions to cause the computer device to execute the method provided by the foregoing embodiment.

In the foregoing embodiments, the descriptions of the respective embodiments have respective emphasis, and for parts that are not described in detail in a certain embodiment, reference may be made to the related descriptions of other embodiments.

It should be noted that, for simplicity of description, the above-mentioned method embodiments are described as a series of acts or combination of acts, but those skilled in the art will recognize that the present application is not limited by the order of acts described, as some steps may occur in other orders or concurrently depending on the application. Further, those skilled in the art will recognize that the embodiments described in this specification are preferred embodiments and that acts or modules referred to are not necessarily required for this application.

In the embodiments provided in the present application, it should be understood that the disclosed apparatus may be implemented in other manners. For example, the above-described embodiments of the apparatus are merely illustrative, and for example, the above-described division of the units is only one type of division of logical functions, and other divisions may be realized in practice, for example, a plurality of units or components may be combined or integrated into another system, or some features may be omitted, or not executed. In addition, the shown or discussed mutual coupling or direct coupling or communication connection may be an indirect coupling or communication connection of some interfaces, devices or units, and may be an electric or other form.

The units described as separate parts may or may not be physically separate, and parts displayed as units may or may not be physical units, may be located in one place, or may be distributed on a plurality of network units. Some or all of the units can be selected according to actual needs to achieve the purpose of the solution of the embodiment.

In addition, functional units in the embodiments of the present application may be integrated into one processing unit, or each unit may exist alone physically, or two or more units are integrated into one unit. The integrated unit may be implemented in the form of hardware, or may also be implemented in the form of a software functional unit.

The integrated unit may be stored in a computer-readable storage medium if it is implemented in the form of a software functional unit and sold or used as a separate product. Based on such understanding, the technical solution of the present application may be substantially implemented or a part of or all or part of the technical solution contributing to the prior art may be embodied in the form of a software product stored in a storage medium, and including several instructions for enabling a computer device (which may be a personal computer, a server, or a network device, and may specifically be a processor in the computer device) to execute all or part of the steps of the above-mentioned method of the embodiments of the present application. The storage medium may include: various media capable of storing program codes, such as a usb disk, a removable hard disk, a magnetic disk, an optical disk, a Read-Only Memory (ROM) or a Random Access Memory (RAM).

The above embodiments are only used for illustrating the technical solutions of the present application, and not for limiting the same; although the present application has been described in detail with reference to the foregoing embodiments, it should be understood by those of ordinary skill in the art that: the technical solutions described in the foregoing embodiments may still be modified, or some technical features may be equivalently replaced; and such modifications or substitutions do not depart from the spirit and scope of the corresponding technical solutions in the embodiments of the present application.

Claims

1. A debugging method, comprising:

2. The method of claim 1, further comprising:

3. The method of claim 2, further comprising:

4. The method of claim 1, wherein the kernel version information corresponding to the target debug container is the same as the kernel version information of the kernel dump file, and the kernel debug information of the target debug container matches the kernel dump file.

5. The method of any of claims 1-4, wherein the target container information comprises operating system information corresponding to the kernel dump file and kernel debugging information corresponding to the kernel dump file.

6. The method of claim 5, wherein the obtaining target container information comprises:

7. The method of claim 6, wherein constructing a target debug container from the target container information comprises:

8. A debugging system, comprising: the system comprises an instruction preprocessing layer, a container management layer and a container pool;

the container pool is used for storing at least one debugging container;

the instruction preprocessing layer is used for receiving a debugging instruction and acquiring a kernel dump file based on the debugging instruction; the debugging instruction carries the kernel dump file or carries storage path information of the kernel dump file;

the container management layer is used for searching whether a target debugging container matched with the kernel dump file exists in a container pool or not based on the kernel dump file, and calling the target debugging container to debug the kernel dump file if the target debugging container is searched in the container pool;

the container management layer is further configured to obtain target container information if the target debugging container is not found in the container pool, where the target container information is used to construct a target debugging container matched with the kernel dump file;

the container management layer is also used for constructing and obtaining a target debugging container according to the target container information and calling the target debugging container to debug the kernel dump file;

the container management layer is further configured to add the target debug container to the container pool.

9. The system of claim 8, wherein the instruction preprocessing layer comprises a parse instruction module, a kernel information extraction module, and a request transmission module;

the analysis instruction module is used for receiving the debugging instruction, acquiring the kernel dump file based on the debugging instruction, and transmitting the debugging instruction to the kernel information extraction module;

the kernel information extraction module is used for extracting kernel version information of the kernel dump file and transmitting the kernel dump file and the kernel version information of the kernel dump file to the request transmission module;

the request transmission module is configured to send a debug request to the container management layer, where the debug request carries kernel version information of the kernel dump file and the kernel dump file, or the kernel version information of the kernel dump file and the storage path information.

10. The system of claim 9, wherein the container management layer comprises a container scheduling module, a container information database;

the container scheduling module is used for receiving the debugging request from the instruction preprocessing layer and acquiring kernel version information of the kernel dump file and kernel version information corresponding to each debugging container in the container pool;

the container scheduling module is further configured to determine that the target debugging container is not found from the container pool if the kernel version information of the kernel dump file is different from the kernel version information corresponding to each debugging container;

and the container information database is used for storing the kernel version information corresponding to each debugging container in the container pool.

11. The system of claim 10,

the container scheduling module is further configured to acquire kernel debugging information of the at least one debugging container if the kernel version information of the kernel dump file is the same as the kernel version information corresponding to the at least one debugging container in the container pool;

the container scheduling module is further configured to determine that the target debug container is not found from the container pool if the kernel dump file is not matched with the kernel debug information of each of the at least one debug container.

12. The system of claim 10 or 11, wherein the container management layer further comprises a container orchestration management module;

the container scheduling module is further configured to transmit the debugging request to the container arrangement management module if the target debugging container is not found in the container pool;

the container arrangement management module is used for acquiring the target container information and constructing a target debugging container according to the target container information;

the container scheduling module is used for calling the target debugging container to debug the kernel dump file.

13. The system of claim 8, wherein the kernel version information corresponding to the target debug container is the same as the kernel version information of the kernel dump file, and the kernel debug information of the target debug container matches the kernel dump file.

14. The system according to claim 12, wherein the container arrangement management module is configured to construct a target debug container according to the target container information, and is specifically configured to:

and constructing an initial container according to the container mirror image file, and adding kernel debugging information corresponding to the kernel dump file into the initial container to obtain the target debugging container.

15. A computer device comprising a processor and a memory, the processor and the memory being interconnected, wherein the memory is configured to store a computer program comprising program instructions, the processor being configured to invoke the program instructions to perform the method of any one of claims 1-7.