Software debugging technology (2)--How to implement coredump_PHP tutorial

Software debugging technology (2)--How to implement coredump

I recently learned at work that application software can be set to generate a dump file when it crashes. This function is coredump. Whether it is an application crash or a kernel crash, the dump function is a very practical technology. This article is intended to understand the implementation methods of these two technologies from the perspective of implementation principles. First, let’s analyze the implementation method of application coredump.

What conditions trigger the transfer
This transfer occurs when the application receives a fatal signal. When processing this signal, the application's transfer will be performed and the execution will exit afterwards. One thing that must be noted is that if the user installs a custom handler for these fatal signals, the transfer will not occur. OK, then here are two points:
1. Fatal signals will start to be transferred. These signals include the following content.

1. 398 #define SIG_KERNEL_COREDUMP_MASK(
   
2. 399 rt_sigmask(SIGQUIT)|rt_sigmask(SIGILL)|
   
3. 400 rt_sigmask(SIGTRAP)|rt_sigmask(SIGABRT)|
   
4. 401 rt_sigmask(SIGFPE)|rt_sigmask(SIGSEGV)|
   
5. 402 rt_sigmask(SIGBUS)|rt_sigmask(SIGSYS)|
   
6. 403 rt_sigmask(SIGXCPU)|rt_sigmask(SIGXFSZ)|
   
7. 404 SIGEMT_MASK

2, if the above fatal signal is installed by the user Without a custom handler function, coredump will not occur. 2265/*Run the handler.*/

2266 ksig->ka=*ka;

1. 
   2267
2. 
   2268if(ka- >sa.sa_flags&SA_ONESHOT)
3. 
   2269 ka->sa.sa_handler=SIG_DFL;
4. 
   2270
5. 
   2271 break;/*will return non-zero "signr" value*/
6. 
   2272}
7. 
   When the kernel looks for the signal that needs to be processed, it will first determine whether the signal is the default processing method. If it is the default processing, it will continue to the coredump branch, otherwise it will jump out of the search link and execute the user-defined processing method
8. that triggers coredump execution branch
   
9. . 2335if(sig_kernel_coredump(signr)){

2336if(print_fatal_signals)


2337 print_fatal_signal(ksig->info.si_signo);

2338 proc_coredump_connector (current); groupandsynchronizes with
1. 
   
2342*their demise.Ifwe lost the race with another
2. 
   
2343*thread getting here,itsetgroup_exit_code
3. 
   
2344*firstandour do_group_exitcallbelow will use
4. 
   
2345*that value and ignore the one we pass it.
5. 
   
2346*/
6. 
   
2347 do_coredump(&ksig->info );
7. 
   
2348}
8. 
   
9. 
   
10. Tips for printing fatal signals to the console
    If you enable it as follows The option in the proc directory will enable the function of printing fatal signals to the console.
/proc/sys/kernel/print-fatal-signals
11. 
    Main steps of coredump
In fact, the process of writing this application to disk must be very responsible. I won’t miss out on any details here. Some theoretical details may be pushed to later parts for detailed study and analysis. However, here we need to understand the following key processing processes about coredump.
12. 1. Before coredump, first check whether all threads in the thread group have entered the dormant state. If we want coredump, we must ensure that when we copy the memory space of this process, some threads in the process are still running and rewriting the memory space.
    2. There is nothing special about directly dumping process memory to a file. It just opens a file and starts writing.
3. For the case where user space scripts are formulated and some compression operations are performed, a user mode process will be started and a pipeline will be established between the kernel and the user mode process.
13. kernel====== ===Read============User mode process (compression)----------Write-------->File
    
For the first step of processing, the kernel sends a kill signal to all threads in the process group, and then waits for all processes to no longer be running.
14. For the second step, the processing is relatively simple, but if you are interested, you can further study what the format of the coredump file looks like.
The third step is relatively complicated. The clever part is to establish a pipeline in the kernel. The kernel processes the signal part and writes the coredump into the pipeline, and the other end of the pipeline in the newly created process is set to the standard input.
15. 
    For the method of dumping the compression process
We can create a shell executable file

#!/bin/shexecgzip->/root/$1.core.$2.gz
Then write
|/usr/sbin/core_helper%e%p


in /proc/sys/kernel/core_pattern

http://www.bkjia.com/PHPjc/1086427.htmlwww.bkjia.comtruehttp: //www.bkjia.com/PHPjc/1086427.htmlTechArticleSoftware debugging technology (2)--How to implement coredump. I recently learned at work that application software can crash when it crashes. Set to generate a dump file. This function is coredump. Whether it is an application...