This document is intended to provide information on how to obtain the backtraces required on the asterisk bug tracker, available at https://issues.asterisk.org.
- Preparing Asterisk To Produce Core Files On Crash
- Getting Information After A Crash
- Getting Information For A Deadlock
- Verify Your Backtraces
- Identifying Potential Memory Corruption
- Uploading Your Information To The Issue Tracker
The backtrace information is required by developers to help fix problems with bugs of any kind. Backtraces provide information about what was wrong when a program crashed; in our case, Asterisk.
Preparing Asterisk To Produce Core Files On Crash
First of all, when you start Asterisk, you MUST start it with option -g. This tells Asterisk to produce a core file if it crashes.
If you start Asterisk with the safe_asterisk script, it automatically starts using the option -g.
If you're not sure if Asterisk is running with the -g option, type the following command in your shell:
The interesting information is located in the last column.
Second, your copy of Asterisk must have been built without optimization or the backtrace will be (nearly) unusable. This can be done by selecting the 'DONT_OPTIMIZE' option in the Compiler Flags submenu in the 'make menuselect' tree before building Asterisk.
Running a production server with DONT_OPTIMIZE is generally safe. You'll notice the binary files may be a bit larger, but in terms of Asterisk performance, impact should be negligible.
After Asterisk crashes, a file named "core" will be dumped in the present working directory of the Linux shell from which Asterisk was started.
In the event that there are multiple core files present, it is important to look at the file timestamps in order to determine which one you really intend to look at.
Getting Information After A Crash
There are two kind of backtraces (aka 'bt') which are useful: bt and bt full.
Now that we've verified the core file has been written to disk, the final part is to extract 'bt' from the core file. Core files are pretty big, don't be scared, it's normal.
For extraction, we use a really nice tool, called gdb. To verify that you have gdb installed on your system:
If you don't have gdb installed, go install gdb. You should be able to install using something like: apt-get install gdb or yum install gdb
Now load the core file in gdb with the following command. This will also save the output of gdb to the /tmp/backtract.txt file.
In order to make extracting the gdb output easier, you may wish to turn on logging using "set logging on". This command will save all output to the default file of gdb.txt, which in the end can be uploaded as an attachment to the bug tracker.
Now at the gdb prompt, type: bt You would see output similar to:
The bt's output is the information that we need on the bug tracker.
Now do a bt full as follows:
The final "extraction" would be to know all traces by all threads. Even if Asterisk runs on the same thread for each call, it could have created some new threads.
To make sure we have the correct information, just do:
That output tells us crucial information about each thread.
Getting Information For A Deadlock
Whenever collecting information about a deadlock it is useful to have additional information about the threads involved. We can generate this information by attaching to a running Asterisk process and gathering that information. Follow the two steps below to collect debug that will be useful to Asterisk developers.
Use GDB to collect a backtrace: You can easily attach to a running Asterisk process, gather the output required and then detach from the process all in a single step. Since this gathers information from the running Asterisk process, you want to make sure you run this command immediately before or after gathering the output of 'core show locks'. Execute the following command and upload the resulting backtrace-threads.txt file to the Asterisk issue tracker:
Collecting output from the "core show locks" CLI command : After getting the backtrace with GDB, immediately run the following command from your Linux shell:
For more info on: Locking in Asterisk
Verify Your Backtraces
Before uploading your backtraces to the issue tracker, you should double check to make sure the data you have is of use to the developers.
Check your backtrace files to make sure you compiled with DONT_OPTIMIZE:
If you are seeing the above text in your backtrace, then you likely haven't compiled with DONT_OPTIMIZE. The impact of DONT_OPTIMIZE is negligible on most systems, so go ahead and enable it as with optimizations the backtraces are often not useful to the developers. Be sure you've enabled the DONT_OPTIMIZE flag within the Compiler Flags section of menuselect. After doing so, be sure to run 'make && make install' and restart Asterisk.
If you are getting a backtrace for a deadlock then be sure you compiled with DEBUG_THREADS. One way to verify this is by checking your backtrace for a thread calling ast_rentrancy_lock. For example:
Identifying Potential Memory Corruption
When you look at a backtrace, you'll usually see one of two things that indicate a memory corruption:
1. A seg fault or an abort in malloc, calloc, or realloc. This could also be an indication that someone ran out of memory, but usually Asterisk "gracefully" handles that condition (although the system will more then likely tank pretty quickly, you'll get some ERROR messages). In general, a seg fault or abort in one of those three is very likely to be a memory corruption.
2. An abort or seg fault in free. That's pretty much always a memory corruption.
If you think there is a memory corruption issue then you'll want to run valgrind to investigate further.
Uploading Your Information To The Issue Tracker
You're now ready to upload your files to the Asterisk issue tracker (located at https://issues.asterisk.org).
If you have questions or comments regarding this documentation, feel free to pass by the #asterisk-bugs channel on irc.freenode.net.