Program received signal SIG32, Real-time event 32.
0x0023ca84 in __pthread_sigsuspend (set=0xfffffffc) at ../linuxthreads/sysdeps/unix/sysv/linux/pt-sigsuspend.c:54
54 in ../linuxthreads/sysdeps/unix/sysv/linux/pt-sigsuspend.c
(gdb) c
Continuing.
Solution==============================================
On Sun, 19 Sep 2004 11:08:42 -0700, Chris Germano <netslayer at hotmail.com> wrote:
> Does this GDB output look normal? I hear I need to recompile gcc and glibc
> with multithread support or something?
>
...
> warning: Unable to find dynamic linker breakpoint function.
> GDB will be unable to debug shared library initializers << ?
> and track explicitly loaded dynamic code. << ?
Perhaps the executable was statically compiled?
> Program received signal SIG32, Real-time event 32. << ?
I reckon SIG32 is the signal used by the threadslib to jump into the
scheduler every timeslice.
You can try the following in GDB, before starting the program:
handle SIG32 nostop noprint pass
That will prevent GDB from stopping when it receives the signal, it
won't print any occurrances
either, and the signal will be passed to program which is being debugged.
Robert
3.ulimit
ulimit is a shell builtin command used to show and set various restrictions on resource usage for a shell. Among the limitations that can be set you find, maximum file size, maximum core file size, maximum size of resident memory. Though the restrictions are shell-independent, the exact syntax depends on what shell you are running.
It's a good practice to set some of these limitations to prevent for instance a faulty shell script to start unlimited copies of it self or to prevent users on the system to start processes that run forever.
Warning:Typing ulimit may result in the output "unlimited". That is misleading, you may have limits in place as you can find out with ulimit -a
ls3523:~ # ulimit unlimited ls3523:~ # ulimit -a core file size (blocks, -c) 0 data seg size (kbytes, -d) unlimited file size (blocks, -f) unlimited pending signals (-i) 4091 max locked memory (kbytes, -l) 32 max memory size (kbytes, -m) unlimited open files (-n) 1024 pipe size (512 bytes, -p) 8 POSIX message queues (bytes, -q) 819200 stack size (kbytes, -s) 8192 cpu time (seconds, -t) unlimited max user processes (-u) 4091 virtual memory (kbytes, -v) unlimited file locks (-x) unlimited
In general, the command ulimit -$ (where $ is some letter) will return the current value of the variable linked with $, while ulimit -$ NUMBER (again, where $ is some letter, and NUMBER is generally an integer, or "unlimited") will set that variable. Of special note is the -a option, which will display all limits for the system.
The -H and -S options are also special. -H will affect the "hard" limit, which is an absolute limit on a resource. -S will affect the "soft" limit. The major difference between the two is that hard limits can only be increased by root. Since the default for options is to affect both hard and soft limits, adding -S to a command will allow returning the variable to the previous value without root access.
Finally, all limits only apply to the thread in which they are set. For systemwide setting of limits, try /etc/security/limits.conf
Examples
- ulimit -S -c 0 (Set the maximum filesize for core files to 0, as a soft limit. This will prevent core dumps from forming, while allowing returning to the previous limit.)
- ulimit -f (Return the maximum file size.)
- ulimit -u unlimited (Remove all limits on the number of simultaneous user processes.
6. Advanced gdb Features
- How do I examine memory?
- How do I see what is in the processor registers?
- How do I debug with a core file?
- How do I step through my code at the instruction level?
- How do I see the assembly code my program is running?
Use the x command to examine memory. The syntax for the x command is x/FMT ADDRESS. The FMT field is a count followed by a format letter and a size letter. There are many options here, use the help command 'help x' to see them all. The ADDRESS argument can either be a symbol name, such as a variable, or a memory address.
If we have char *s = "Hello World\n", some uses of the x command could be:
Examine the variable as a string:
(gdb) x/s s
0x8048434 <_io_stdin_used+4>: "Hello World\n"
Examine the variable as a character:
(gdb) x/c s
0x8048434 <_io_stdin_used+4>: 72 'H'
Examine the variable as 4 characters:
(gdb) x/4c s
0x8048434 <_io_stdin_used+4>: 72 'H' 101 'e' 108 'l' 108 'l'
Examine the first 32 bits of the variable:
(gdb) x/t s
0x8048434 <_io_stdin_used+4>: 01101100011011000110010101001000
Examine the first 24 bytes of the variable in hex:
(gdb) x/3x s
0x8048434 <_io_stdin_used+4>: 0x6c6c6548 0x6f57206f 0x0a646c72
Use the info registers command. The output of this command depends on the hardware architecture. The following is part of the output on an intel machine:
(gdb) info registers
eax 0x40123460 1074934880
ecx 0x1 1
edx 0x80483c0 134513600
ebx 0x40124bf4 1074940916
esp 0xbffffa74 0xbffffa74
ebp 0xbffffa8c 0xbffffa8c
esi 0x400165e4 1073833444
...
When your program segfaults and leaves a core dump file, you can use gdb to look at the program state when it crashed. Use the core command to load a core file. The argument to the core command is the filename of the core dump file, which is usually "core", making the full command core core.
prompt > myprogram
Segmentation fault (core dumped)
prompt > gdb myprogram
...
(gdb) core core
...
There are two commands, nexti and stepi, that work similar to next and step. See the usage of those commands for an idea of how to use these two.
Use the disassemble command. The argument to this command is a memory address. Here is an example of the disassembly for the main function of a simple program on an intel machine:
(gdb) disassemble main
Dump of assembler code for function main:
0x80483c0 : push %ebp
0x80483c1 : mov %esp,%ebp
0x80483c3 : sub $0x18,%esp
0x80483c6 : movl $0x0,0xfffffffc(%ebp)
0x80483cd : mov 0xfffffffc(%ebp),%eax
0x80483d0 : movb $0x7,(%eax)
0x80483d3 : xor %eax,%eax
0x80483d5 : jmp 0x80483d7
0x80483d7 : leave
0x80483d8 : ret
End of assembler dump.
