CN116795726B - Method for online debugging Linux kernel - Google Patents
Method for online debugging Linux kernel Download PDFInfo
- Publication number
- CN116795726B CN116795726B CN202311079306.6A CN202311079306A CN116795726B CN 116795726 B CN116795726 B CN 116795726B CN 202311079306 A CN202311079306 A CN 202311079306A CN 116795726 B CN116795726 B CN 116795726B
- Authority
- CN
- China
- Prior art keywords
- kernel
- function
- online
- detection module
- instruction
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
- 238000000034 method Methods 0.000 title claims abstract description 44
- 230000009191 jumping Effects 0.000 claims abstract description 3
- 238000001514 detection method Methods 0.000 claims description 60
- 238000012545 processing Methods 0.000 claims description 9
- 230000008569 process Effects 0.000 abstract description 4
- 230000006870 function Effects 0.000 description 93
- 238000010586 diagram Methods 0.000 description 6
- 238000011161 development Methods 0.000 description 4
- 230000009286 beneficial effect Effects 0.000 description 3
- 230000007547 defect Effects 0.000 description 3
- 238000005516 engineering process Methods 0.000 description 3
- 238000003780 insertion Methods 0.000 description 3
- 230000037431 insertion Effects 0.000 description 3
- 230000000694 effects Effects 0.000 description 2
- 239000000284 extract Substances 0.000 description 2
- 238000012986 modification Methods 0.000 description 2
- 230000004048 modification Effects 0.000 description 2
- 230000003068 static effect Effects 0.000 description 2
- 238000006467 substitution reaction Methods 0.000 description 2
- 230000009471 action Effects 0.000 description 1
- 238000013459 approach Methods 0.000 description 1
- 238000000605 extraction Methods 0.000 description 1
- 238000007429 general method Methods 0.000 description 1
- 230000007246 mechanism Effects 0.000 description 1
- 239000000523 sample Substances 0.000 description 1
- 230000001960 triggered effect Effects 0.000 description 1
Classifications
-
- Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y02—TECHNOLOGIES OR APPLICATIONS FOR MITIGATION OR ADAPTATION AGAINST CLIMATE CHANGE
- Y02D—CLIMATE CHANGE MITIGATION TECHNOLOGIES IN INFORMATION AND COMMUNICATION TECHNOLOGIES [ICT], I.E. INFORMATION AND COMMUNICATION TECHNOLOGIES AIMING AT THE REDUCTION OF THEIR OWN ENERGY USE
- Y02D10/00—Energy efficient computing, e.g. low power processors, power management or thermal management
Abstract
The invention relates to the technical field of operating systems, in particular to a method for online debugging of a Linux kernel, which aims to solve the technical problems that in the prior art, the debugging of the Linux kernel is complex to implement, complex to process and the kernel cannot be online debugged. For this purpose, the invention comprises the steps of: loading the kernel module into an online kernel; replacing an empty instruction preset at the beginning of a function to be detected by using a jump instruction, wherein the jump instruction is used for jumping to the kernel module and returning to the next instruction at the called position of the function to be detected after the execution of the kernel module is finished; after the execution of the kernel module is finished, restoring the jump instruction into the null instruction; and unloading the kernel module from the online kernel.
Description
Technical Field
The invention relates to the technical field of operating systems, and particularly provides a method for online debugging of a Linux kernel.
Background
The Linux operating system can be divided into kernel development and user space development, wherein the kernel development is more difficult than the user space development, and an important factor is that the kernel debugging is more difficult. The online debugging tool of the program in the user space can be recompiled and run by using gdb or directly adding printing information in the code. While the kernel adding print information recompilation may take longer and may require restarting the machine. Many times, for online systems, it is desirable for the kernel to detect the condition of the running time, and in fact, to detect a function, especially when the state machine is complex, and more desirable to make a branch determination, detect which branch the kernel function is executing to walk, and the value of a certain variable in the function.
There are a number of drawbacks to the prior art debugging methods for operating system kernels, such as:
(1) Chinese patent "MIPS architecture operating system kernel debugging method and device" (patent number: CN 104077220A). The patent provides a debugging method for an operating system kernel based on an MIPS architecture. The debugging method comprises the following steps: inserting a detection point at a designated address of an operating system kernel, and associating a detection point processing function with the detection point; executing a detection point processing function when the kernel executes to the detection point; hooking the MIPS architecture processor by a debugging tool preset by the kernel and collecting kernel debugging information; and after the detection point processing function is executed, returning to the kernel of the execution operating system. The principle is that the detection technology of kprobe based on Linux kernel is generally used for detecting the beginning and the return value of the function, and although the interior of the function can be detected, the defect is obvious and the offset address of the detected point needs to be added on the basis of the address of the detected function. To know the offset address, the assembly code of the detected function needs to be read to find the detected point, and then the offset address is calculated, so that a user needs to be familiar with an instruction set of the architecture of the debugged machine, the difficulty is high, and the method is not friendly to the user.
(2) Chinese patent invention "a method for debugging kernel of operating system and virtual debugging service module" (patent number: CN 102301344B). The debugging method provided by the patent comprises the following steps: the virtual debugging service module receives a breakpoint insertion request for inserting at least one breakpoint, which is sent by a debugging module in a main control operating system, wherein the breakpoint insertion request comprises the position information of the inserted breakpoint; the virtual debugging service module inserts the breakpoint at the corresponding position in the debugged operating system according to the position information of the inserted breakpoint in the breakpoint insertion request, and records the position of the inserted breakpoint in a debugging breakpoint information table; the virtual debugging service module captures the breakpoint exception triggered in the execution process of the debugged operating system, compares the captured breakpoint exception characteristics with the positions of the breakpoints recorded in the debugging breakpoint information table, and pauses the operation of the debugged operating system if the captured breakpoint exception characteristics are matched with the positions of the breakpoints recorded in the debugging breakpoint information table. The principle is that two virtual machines are built on one host machine to realize the debugging similar to gdb. However, this method is complicated to construct, and cannot simulate the environment of the online kernel, so that the online kernel cannot be debugged.
(3) Chinese invention patent "kernel debug method of Linux operating system" (patent number: CN 101281488). The patent proposes debugging the kernel of the Linux operating system using dynamic replacement and restoration techniques. Compiling the kernel function to be modified and debugged into a temporary kernel module in a kernel module mode; then, the kernel loading tool is used for loading the kernel user space, a function jump table is placed on the entry of the debugged function, and the call to the original function is intercepted, so that the temporary rewriting function to the original function is debugged, after the debugging is finished, the original function is restored by using the unloading mechanism of the module, so that the kernel is restored to the original state, and the kernel is the module loading tool. The disadvantage of this approach is that the module loading tool is complex to implement and the process of compiling the replaced function into modules is complex, and the actual implementation may require multiple compilations.
Accordingly, there is a need in the art for a new debugging Linux kernel scheme to solve the above-mentioned problems.
Disclosure of Invention
The invention is provided for overcoming the defects, and solves or at least partially solves the technical problems of complex implementation, complicated processing and incapability of debugging the kernel on line in the prior art for debugging the Linux kernel.
The invention provides a method for debugging a Linux kernel on line, which comprises the following steps:
processing to obtain a detection module according to the function to be detected;
loading the detection module into an online kernel;
replacing an empty instruction preset at the beginning of a function to be detected by using a jump instruction, wherein the jump instruction is used for jumping to the detection module and returning to the next instruction at the called position of the function to be detected after the execution of the detection module is finished;
after the detection module is executed, restoring the jump instruction into the null instruction;
and unloading the detection module from the online kernel.
In one technical scheme of the above method, the processing according to the function to be detected to obtain the detection module includes:
writing a source code, wherein the source code comprises all executives, detection points and debugging information of a function to be detected;
compiling the source code to obtain a detection module.
In one technical scheme of the above method, compiling the source code to obtain a detection module includes:
extracting all kernel header files, and summarizing the kernel header files into vmlinux.h files;
adding the vmlinux.h file to the source code;
and compiling the source code added with the vmlinux.h file to obtain a detection module.
In one technical scheme of the above method, extracting all kernel header files, and summarizing the kernel header files into vmlinux.h files includes:
logging in a Linux system, and obtaining a vmlinux file by using an ls command;
and extracting the kernel header file information in the vmlinux file by using a bpftool tool, and summarizing the kernel header file information into the vmlinux.h file.
In one technical scheme of the above method, the loading the detection module into the online kernel includes:
the instrumentation module is loaded into the online kernel using an insmod command in the Linux system.
In one aspect of the above method, unloading the probe module from the online kernel includes:
the probing module is uninstalled from the online kernel using rmmod commands in the Linux system.
In one technical scheme of the method, the jump instruction is used for replacing an empty instruction preset at the beginning of the function to be detected, and the jump instruction is restored to be the empty instruction, and is controlled in a user space through a set file system interface.
The working principle of the technical scheme of the invention is as follows:
in the technical scheme of implementing the invention, the function to be detected is rewritten and packaged into a kernel module, and the function processed in the kernel module can be replaced and executed when the function to be detected is operated by loading the kernel module into an online kernel and replacing the null instruction by means of the jump instruction, so that the null instruction is replaced and unloaded after the detection is finished to recover the site without influencing the operation of the subsequent kernel.
Drawings
The present disclosure will become more readily understood with reference to the accompanying drawings. As will be readily appreciated by those skilled in the art: the drawings are for illustrative purposes only and are not intended to limit the scope of the present invention. Moreover, like numerals in the figures are used to designate like parts, wherein:
FIG. 1 is a flow chart of main steps of a method for online debugging a Linux kernel according to the invention;
FIG. 2 is a schematic diagram illustrating the function operation before step S3 is performed in a method for online debugging of a Linux kernel according to the present invention;
FIG. 3 is a schematic diagram illustrating the function operation performed in step S3 in a method for online debugging of a Linux kernel according to the present invention;
FIG. 4 is a schematic diagram illustrating the function operation performed in step S4 in a method for online debugging of Linux kernel according to the present invention.
Detailed Description
In order to further understand the technical scheme and beneficial effects of the present invention, the technical scheme and beneficial effects thereof will be described in detail with reference to the accompanying drawings.
The invention mainly aims at the defects of the debugging method and provides a method which enables the kernel to be detected and debugged on line, and the assembly of a specific architecture is not needed to be understood, and an additional auxiliary machine is not needed; and the method can go deep to any position of the kernel function, does not need to manually calculate offset addresses, and realizes online debugging of source code level by using c language.
The invention refers to the kernel detection technology and the instruction replacement technology on the basis of the kernel detection tool, and the basic idea is to replace the detected function through a trampoline by means of a jump instruction, and to package the functions to be detected into a detection module by means of the general method of a kernel module, and to realize debugging and recovering sites by recording and unloading the detection module.
FIG. 1 is a flow chart of main steps of a method for online debugging a Linux kernel according to the invention. As shown in FIG. 1, a method for online debugging of a Linux kernel in an embodiment of the present invention mainly includes the following steps S1-S5.
Step S1: the function to be detected writes a detection module which exists in the form of a kernel module.
Kernel code exists in the Linux kernel in two ways: one is static compilation into the kernel, the other is present in the kernel in a modular fashion, known as kernel modules.
For example, a function, when written as code, may exist in the kernel in both ways. After compiling into the kernel in a static mode, the online kernel needs to be replaced entirely, and the machine can be restarted to take effect; however, in the existence mode of the kernel module, the whole kernel is not required to be replaced, the machine is not required to be restarted, and the kernel module corresponding to the function is only required to be loaded into the kernel through a command. Also, if this function is not required, the kernel module corresponding to this function may be offloaded from the kernel by a command.
The instrumentation block may be installed to the core by command insmod or may be uninstalled from the core by rmmod command.
In one embodiment, step S1 further comprises:
step S11: and writing source codes, wherein the source codes comprise all executives, detection points and debugging information of the functions to be detected.
In this embodiment, an initial source code debug u is obtainedC file by debug _ to source code>Compiling the c file to obtain the debug_ for the detection module>And (3) ko. Initial source code debug _>And c, the file writing method needs to copy all executors of the function to be detected in the file writing method, then adds detection points needed inside the function to be detected, and uses c language to write debugging information of source code level according to the needs. The purpose of the debugging information is that, for example, we want to look at the value of a certain variable in a function, and can add printing information, and obtain the value of the variable by printing to a terminal.
In order to facilitate the distinction, the processing of step S11 may be performedThe function renames to fake u. Follow-up function to be detected->Will be renamed by the function like _>Replaced (described in detail later), renaming function fake_>And the function to be detected->The system has the same function, and only adds contents to be debugged on the basis of the system.
Wherein debug is the meaning of debug,representing the function to be probed, assuming that the probed function to be debugged is a kernel function of pipe_write, the corresponding source code file is debug_pipe_write.c, the corresponding compiled kernel module is debug_pipe_write.ko, and the pipe_write function processed in step S11 is renamedIs fake_pipe_write. Step S12: compiling the source code to obtain a detection module.
In this embodiment, if the original source code debug u is obtained by direct compilingC, although a detection module for detecting the corresponding kernel function can be obtained, a lot of errors may occur due to the problem of header file missing, and in order to solve the problem of header file inclusion, step S12 in this embodiment further includes:
step S121: extracting all kernel header files and summarizing the kernel header files into vmlinux.h files.
The specific extraction method comprises the following steps: the data structure type related to the function to be probed is extracted by means of kernel tools bpftool btf dump file/sys/kernel/btf/vmlinux format c > vmlinux. bpftool btf dump file/sys/kernel/btf/vmlinux format c > vmlinux.h, the action is to extract the kernel header file information in the vmlinux file by using bpftool tool, and summarize the kernel header file information into the vmlinux.h file.
The vmlinux file mainly refers to/sys/kernel/btf/vmlinux, is a file in an operating system, stores information of a kernel header file, and can extract the information of the kernel header file in the file by using a bpftool tool.
[ root@Fedora Linux ] #ls/sys/kernel/btf/vmlinux, logging in a Linux system, and obtaining a vmlinux file by using a ls command;
step S122: and adding the vmlinux.h file into the source code.
When different kernel functions are detected/debugged, different kernel header files are needed to be loaded, in the embodiment, all the kernel header files are concentrated into vmlinux.h, no matter which kernel function is detected/debugged later, the vmlinux.h is only needed to be contained in source codes, and the vmlinux.h file is only needed to be extracted this time.
Step S123: and compiling the source code added with the vmlinux.h file to obtain a detection module.
Step S2: and loading the detection module into an online kernel.
In this embodiment, the instrumentation module is loaded into the online kernel using an insmod command in the Linux system.
Step S3: after the detection module is installed in the kernel, the function to be detected is not replaced by the function in the detection module, so that the function replacement is enabled through the kernel file system interface in the step, namely, a skip instruction is used for replacing a null instruction preset at the beginning of the function to be detected, the skip instruction is used for skipping to the detection module, when the function pipe_write function is executed, the skip instruction is walked to the skip instruction, the skip instruction is executed to the like_pipe_write function, and after the execution of the detection module is finished, the next instruction of the function to be detected is returned to the called position.
Taking a pipe_write kernel function as an example, by executing a switch instruction echo 1 >/sys/kernel/debug/pipe_write/enabled, a skip instruction replaces an empty instruction before the pipe_write kernel function, the kernel starts to normally operate, when the kernel runs to the pipe_write of the function to be detected, the kernel jumps to a detection module loaded in advance before the pipe_write of the function to be detected is normally executed, a rename pipe_write function in the detection module is executed, information of a detection point can be observed through debugging information, and meanwhile, added debug debugging information can be printed out to a terminal, so that online kernel debugging is realized.
FIG. 2 is a schematic diagram illustrating the function operation before execution of step S3 in a method for online debugging a Linux kernel according to the present invention. As shown in FIG. 2, before the kernel function is probed, the beginning of the function to be probed is a null instruction, which is inserted at compile time. Normally, after the function to be detected is executed, the next instruction at the called position is returned to continue to be executed.
FIG. 3 is a schematic diagram illustrating the function operation performed in step S3 in a method for online debugging of Linux kernel according to the present invention. As shown in fig. 3, after the detection module is installed, the function to be detected is replaced and the renamed function is executed, the null instruction is replaced as a jump instruction, the jump instruction jumps to the trampoline firstly, the trampoline is an intermediate station, the trampoline is used for executing the renamed function and the renamed function is returned, then the renamed function is executed through the trampoline, and finally the renamed function is returned to the next instruction where the function to be detected is called.
Step S4: and after the execution of the detection module is finished, restoring the jump instruction into the null instruction.
FIG. 4 is a schematic diagram illustrating the function operation performed in step S4 in a method for online debugging of Linux kernel according to the present invention. As shown in FIG. 4, after the debugging work of the function to be detected is performed, in order not to affect the subsequent use of the kernel, the null instruction before the kernel function of the pipe_write is replaced by the skip instruction by executing the switch instruction echo 0 >/sys/kernel/debug/pipe_write/enabled, so as to restore the original working scene.
In this embodiment, the replacing of the null instruction preset at the beginning of the function to be detected with the jump instruction and the restoring of the jump instruction to the null instruction are controlled in the user space through the set file system interface, so that kernel function replacement is further enabled.
Step S5: and unloading the detection module from the online kernel.
In this embodiment, the kernel module is uninstalled from the online kernel using rmmod commands in the Linux system.
Based on the steps S1-S5, the function to be detected is rewritten and packaged into a detection module, the detection module is loaded to an online kernel, and then the skip instruction is used for replacing the null instruction, so that the function processed in the detection module can be replaced and executed when the function to be detected is operated, and the null instruction is replaced and unloaded after the detection is finished to recover the site, so that the operation of the subsequent kernel is not influenced.
The beneficial effects of the invention include:
1. when kernel debugging is implemented, the detection module can be written on the site of the online kernel, debugging information is added in the source code level, and the kernel does not need to be restarted.
2. The method optimizes the compiling process of the module, extracts all header files needed by the kernel through a tool, and places the header files in vmlinux.h, wherein the compiling of the module only needs to comprise one header file. The problem of which header files the compiling detection module needs to contain at all is found out through one-time compiling trial and error, so that the module compiling is smoothly carried out.
3. And replacing the empty instruction with the jump instruction through the file system interface to realize the enabling replacement of the running function, thereby realizing the debugging function of the function to be detected.
4. After the debugging is completed, replacing a null command through a file system interface, recovering the original function execution, unloading the detection module, and recovering the original online kernel.
It should be noted that, although the foregoing embodiments describe the steps in a specific order, it will be understood by those skilled in the art that, in order to achieve the effects of the present invention, the steps are not necessarily performed in such an order, and may be performed simultaneously (in parallel) or in other orders, and these variations are within the scope of the present invention.
Thus far, the technical solution of the present invention has been described in connection with the preferred embodiments shown in the drawings, but it is easily understood by those skilled in the art that the scope of protection of the present invention is not limited to these specific embodiments. Equivalent modifications and substitutions for related technical features may be made by those skilled in the art without departing from the principles of the present invention, and such modifications and substitutions will fall within the scope of the present invention.
Claims (4)
1. The method for online debugging the Linux kernel is characterized by comprising the following steps:
processing to obtain a detection module according to the function to be detected;
loading the detection module into an online kernel;
replacing an empty instruction preset at the beginning of a function to be detected by using a jump instruction, wherein the jump instruction is used for jumping to the detection module and returning to the next instruction at the called position of the function to be detected after the execution of the detection module is finished;
after the detection module is executed, restoring the jump instruction into the null instruction;
unloading the detection module from the online kernel;
the processing to obtain the detection module according to the function to be detected comprises the following steps:
writing a source code, wherein the source code comprises all executives, detection points and debugging information of a function to be detected;
compiling the source code to obtain a detection module;
compiling the source code to obtain a detection module, including:
extracting all kernel header files, and summarizing the kernel header files into vmlinux.h files;
adding the vmlinux.h file to the source code;
compiling a source code added with the vmlinux.h file to obtain a detection module;
and extracting all kernel header files, and summarizing the kernel header files into vmlinux.h files, wherein the extracting comprises the following steps:
logging in a Linux system, and obtaining a vmlinux file by using an ls command;
and extracting the kernel header file information in the vmlinux file by using a bpftool tool, and summarizing the kernel header file information into the vmlinux.h file.
2. The method for online debugging a Linux kernel of claim 1, wherein loading the probing module into an online kernel comprises:
the instrumentation module is loaded into the online kernel using an insmod command in the Linux system.
3. The method for online debugging a Linux kernel of claim 1, wherein said unloading the probing module from the online kernel comprises:
the probing module is uninstalled from the online kernel using rmmod commands in the Linux system.
4. The method for online debugging Linux kernel according to claim 1, wherein the replacing of a null instruction preset at the beginning of a function to be detected with a jump instruction and the restoring of the jump instruction to the null instruction are controlled in user space through a set file system interface.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202311079306.6A CN116795726B (en) | 2023-08-25 | 2023-08-25 | Method for online debugging Linux kernel |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202311079306.6A CN116795726B (en) | 2023-08-25 | 2023-08-25 | Method for online debugging Linux kernel |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN116795726A CN116795726A (en) | 2023-09-22 |
| CN116795726B true CN116795726B (en) | 2023-11-28 |
Family
ID=88050043
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202311079306.6A Active CN116795726B (en) | 2023-08-25 | 2023-08-25 | Method for online debugging Linux kernel |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN116795726B (en) |
Families Citing this family (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN117234953B (en) * | 2023-11-14 | 2024-01-26 | 北京麟卓信息科技有限公司 | Kernel debugging method based on shadow code cache |
Citations (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN101281488A (en) * | 2007-04-06 | 2008-10-08 | 上海宇梦通信科技有限公司 | Inner core debug method of Linux operating system |
| CN102567068A (en) * | 2011-12-13 | 2012-07-11 | 曙光信息产业(北京)有限公司 | System and method for handling kernel mmap call failure |
| CN104077220A (en) * | 2014-06-10 | 2014-10-01 | 中标软件有限公司 | Method and device for debugging microprocessor without interlocked piped stages (MIPS) framework operating system kernel |
| WO2014173211A1 (en) * | 2013-04-23 | 2014-10-30 | Tencent Technology (Shenzhen) Company Limited | Code coverage testing method, device and system |
| CN105204998A (en) * | 2015-09-30 | 2015-12-30 | 上海斐讯数据通信技术有限公司 | Debugging method and device for mobile terminal kernel symbol table |
Family Cites Families (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20050216895A1 (en) * | 2004-03-23 | 2005-09-29 | Tran Hieu T | Method and apparatus for remote debugging of kernel and application software |
| CN112905472A (en) * | 2021-03-04 | 2021-06-04 | 黑芝麻智能科技(上海)有限公司 | Kernel debugging system and method |
-
2023
- 2023-08-25 CN CN202311079306.6A patent/CN116795726B/en active Active
Patent Citations (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN101281488A (en) * | 2007-04-06 | 2008-10-08 | 上海宇梦通信科技有限公司 | Inner core debug method of Linux operating system |
| CN102567068A (en) * | 2011-12-13 | 2012-07-11 | 曙光信息产业(北京)有限公司 | System and method for handling kernel mmap call failure |
| WO2014173211A1 (en) * | 2013-04-23 | 2014-10-30 | Tencent Technology (Shenzhen) Company Limited | Code coverage testing method, device and system |
| CN104077220A (en) * | 2014-06-10 | 2014-10-01 | 中标软件有限公司 | Method and device for debugging microprocessor without interlocked piped stages (MIPS) framework operating system kernel |
| CN105204998A (en) * | 2015-09-30 | 2015-12-30 | 上海斐讯数据通信技术有限公司 | Debugging method and device for mobile terminal kernel symbol table |
Also Published As
| Publication number | Publication date |
|---|---|
| CN116795726A (en) | 2023-09-22 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US6067641A (en) | Demand-based generation of symbolic information | |
| CN116795726B (en) | Method for online debugging Linux kernel | |
| US20030204838A1 (en) | Debugging platform-independent software applications and related code components | |
| US20090307667A1 (en) | Assisting debug memory tracing using an instruction array that tracks the addresses of instructions modifying user specified objects | |
| US20120331449A1 (en) | Device, method and computer program product for evaluating a debugger script | |
| US8732681B2 (en) | Stack analysis for post mortem analysis | |
| US8789020B2 (en) | Interactive debugging environments and methods of providing the same | |
| KR20080050118A (en) | Method of error detecting method for embedded sofeware | |
| US20080133977A1 (en) | Non-stop debugging apparatus for correcting errors in embedded systems and method thereof | |
| US20080313208A1 (en) | Apparatus, system, and method for automated context-sensitive message organization | |
| US6966051B2 (en) | Automatically generated symbol-based debug script executable by a debug program for software debugging | |
| US20070150879A1 (en) | Error Detection on the Stack | |
| US8533683B2 (en) | Stack walking enhancements using sensorpoints | |
| US6738778B1 (en) | Method and apparatus for monitoring the execution of a program | |
| CN115328796A (en) | Software vulnerability auxiliary positioning method and system for ARM architecture | |
| CN109189607B (en) | Method for restoring breakpoint of application program | |
| CN110727597B (en) | Method for checking invalid code completion case based on log | |
| JPH03118635A (en) | Incremental compiler for source code developing system | |
| KR20200082422A (en) | Lightweight crash report based debugging method considering security | |
| CN110096888B (en) | Method and system for accelerating verification and analyzing SMM potential safety hazard | |
| CN105718332A (en) | Intelligent terminal and data backup method thereof | |
| CN112052112A (en) | Bit flipping error detection method and device based on NOR Flash storage and storage medium | |
| JP3459898B2 (en) | Fault information tracer for embedded systems | |
| US20060161904A1 (en) | Semi-automated desk checking system and method | |
| JP5199975B2 (en) | Memory management method, memory management program, and information processing apparatus |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |