|< Linux gnu ldd, readelf, od 5 |Main |Site Index |Download |

MODULE 111-6

OTHER USEFUL GDB/GCC FRIENDS 6

Compile and link (for dynamic linking).  Note the executable size difference. Statically link will result in bigger file size!

[bodo@bakawali testbed5]$ gcc -g testbuff.c -o testbuff

/tmp/ccMunGye.o(.text+0x1e): In function `Test':

/home/bodo/testbed5/testbuff.c:8: warning: the `gets' function is dangerous and should not be used.

[bodo@bakawali testbed5]$ size -d testbuff

   text     data      bss  dec      hex filename

   1031     264       4    1299     513 testbuff

The strings - Printing The Printable Characters

Examples:

[bodo@bakawali testbed5]$ strings -a -f -t x testbuff.o

testbuff.o:      94 Some input:

testbuff.o:      a2 GCC: (GNU) 3.4.2 20041017 (Red Hat 3.4.2-6.fc3)

testbuff.o:      d3 .symtab

testbuff.o:      db .strtab

testbuff.o:      e3 .shstrtab

testbuff.o:      ed .rel.text

testbuff.o:      f7 .data

testbuff.o:      fd .bss

testbuff.o:     102 .rodata

testbuff.o:     10a .note.GNU-stack

testbuff.o:     11a .comment

testbuff.o:     3ad testbuff.c

testbuff.o:     3b8 Test

testbuff.o:     3bd printf

testbuff.o:     3c4 gets

testbuff.o:     3c9 puts

testbuff.o:     3ce main

[bodo@bakawali testbed5]$ strings -a -f -t x testbuff

testbuff:     114 /lib/ld-linux.so.2

testbuff:     1fd _Jv_RegisterClasses

testbuff:     211 __gmon_start__

testbuff:     220 libc.so.6

testbuff:     22a printf

testbuff:     231 gets

testbuff:     236 puts

testbuff:     23b _IO_stdin_used

testbuff:     24a __libc_start_main

testbuff:     25c GLIBC_2.0

testbuff:     330 PTRh

testbuff:     510 Some input:

[omitted]

testbuff:     6c0 GCC: (GNU) 3.4.2 20041017 (Red Hat 3.4.2-6.fc3)

testbuff:     6f1 GCC: (GNU) 3.4.2 20041017 (Red Hat 3.4.2-6.fc3)

testbuff:     722 GCC: (GNU) 3.4.2 20041017 (Red Hat 3.4.2-6.fc3)

testbuff:     784 Test

testbuff:     78d main

testbuff:     7ae GNU C 3.4.2 20041017 (Red Hat 3.4.2-6.fc3)

testbuff:     7da testbuff.c

testbuff:     7e5 /home/bodo/testbed5

testbuff:     801 unsigned char

testbuff:     812 short unsigned int

testbuff:     828 long unsigned int

testbuff:     83d signed char

 [omitted]

testbuff:     94f argc

testbuff:     95e argv

testbuff:     a6c testbuff.c

testbuff:     a7a <internal>

testbuff:     b26 .hash

testbuff:     b2c .dynsym

 [omitted]

testbuff:     b95 .dtors

testbuff:     b9c .jcr

testbuff:     ba1 .dynamic

testbuff:     baa .got

testbuff:     baf .got.plt

testbuff:     bb8 .data

testbuff:     bbe .bss

testbuff:     bc3 .comment

testbuff:     bcc .debug_aranges

testbuff:     bdb .debug_pubnames

 [omitted]

...

...

[bodo@bakawali testbed5]$

The objcopy - Copying/Transforming A Binary File

Note: objcopy is not able to change the endianness of its input files.  If the input format has endianness (some formats do not), objcopy can only copy the inputs into file formats that have the same endianness or which have no endianness (e.g., srec).

The strace - Tracing System Calls And Signals

strace - trace system calls and signals.

SYNTAX

strace  [-dffhiqrtttTvxx] [-acolumn] [-eexpr] ... [-ofile] [-ppid] ... [-sstrsize] [-uusername] [-Evar=val] ... [-Evar] ... [command [arg ...]]

strace -c [-eexpr] ... [-Ooverhead] [-Ssortby] [command [arg ...]]

In the simplest case strace runs the specified command until it exits.   It intercepts and records the system calls which are called by a process and the signals which are received by a process.  The name of each system call, its arguments and its return value are printed on standard error or to the file specified with the -o option.

strace is a useful diagnostic, instructional, and debugging tool.  System administrators, diagnosticians and trouble-shooters will find it invaluable for solving problems with programs for which the source is not readily available since they do not need to be recompiled in order to trace them.  Students, hackers and the overly curious will find that a great deal can be learned about a system and its system calls by tracing even ordinary programs.  And programmers will find that since system calls and signals are events that happen at the user/kernel interface, a close examination of this boundary is very useful for bug isolation, sanity checking and attempting to capture race conditions.

Each  line  in  the  trace  contains  the system call name, followed by its arguments in parentheses  and  its  return  value.   An example from stracing the command at /dev/null is:

open("/dev/null", O_RDONLY) = 3

Errors (typically a return value of -1) have the errno symbol and error string appended.

open("/foo/bar", O_RDONLY) = -1 ENOENT (No such file or directory)

Signals are printed as a signal symbol and a signal string.  An excerpt from stracing and interrupting the command sleep is:

sigsuspend([] <unfinished ...>

--- SIGINT (Interrupt) ---

+++ killed by SIGINT +++

Arguments are printed in symbolic form with a passion.  This example shows the shell performing >>xyzzy output redirection:

open("xyzzy", O_WRONLY|O_APPEND|O_CREAT, 0666) = 3

Here the three argument form of open is decoded by breaking down the flag argument into its three bitwise-OR constituents and printing the mode value in octal by tradition.  Where traditional or native usage differs from ANSI or POSIX, the latter forms are preferred.  In some cases, strace output has proven to be more readable than the source.

Structure pointers are dereferenced and the members are displayed as appropriate.  In all cases arguments are formatted in the most C-like fashion possible.  For example, the essence of the command ls -l /dev/null is captured as:

lstat("/dev/null", {st_mode=S_IFCHR|0666, st_rdev=makedev(1, 3), ...}) = 0

Notice how the struct stat argument is dereferenced and how each member is displayed symbolically.  In particular, observe how the st_mode member is carefully decoded into a bitwise-OR of symbolic and numeric values.  Also notice in this example that the first argument to lstat is an input to the system call and the second argument is an output.  Since output arguments are not modified if the system call fails, arguments may not always be dereferenced.  For example, retrying the ls -l example with a non-existent file produces the following line:

lstat("/foo/bar", 0xb004) = -1 ENOENT (No such file or directory)

In this case the porch light is on but nobody is home.

Character pointers are dereferenced and printed as C strings.  Non-printing characters in strings are normally represented by ordinary C escape codes.  Only the first sstrsize (32 by default) bytes of strings are printed; longer strings have an ellipsis appended following the closing quote.  Here is a line from ls -l where the getpwuid library routine is reading the password file:

read(3, "root::0:0:System Administrator:/"..., 1024) = 422

While structures are annotated using curly braces, simple pointers and arrays are printed using square brackets with commas separating elements.  Here is an example from the command id on a system with supplementary group ids:

getgroups(32, [100, 0]) = 2

On the other hand, bit-sets are also shown using square brackets but set elements are separated only by a space.  Here is the shell preparing to execute an external command:

sigprocmask(SIG_BLOCK, [CHLD TTOU], []) = 0

Here the second argument is a bit-set of two signals,SIGCHLD and SIGTTOU.   In some cases the bit-set is so full that printing out the unset elements is more valuable.  In that case, the bit-set is prefixed by a tilde like this:

sigprocmask(SIG_UNBLOCK, ~[], NULL) = 0

Here, the second argument represents the full set of all signals.

Further related reading:

1. Check the best selling C / C++, Networking, Linux and Open Source books at Amazon.com.

2. Linux Socket programming tutorial.

3. C, Buffer overflow and stack frame (construction and destruction).

4. C, Compiler, Assembler and Linker.

|< Linux gnu ldd, readelf, od 5 |Main |Site Index |Download |

C & Linux GNU Related Utilities: Part 1 | Part 2 | Part 3 | Part 4 | Part 5 | Part 6