strace - Unix, Linux Command

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 ‘‘cat /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 666’’ 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
strsize (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.

ltrace (1)
ltrace (1)
time (1)
time (1)
ptrace (2)
ptrace (2)

It is instructive to think about system call inputs and outputs
as data-flow across the user/kernel boundary.  Because user-space
and kernel-space are separate and address-protected, it is
sometimes possible to make deductive inferences about process
behavior using inputs and outputs as propositions.


In some cases, a system call will differ from the documented behavior
or have a different name.  For example, on System V-derived systems
the true
time(2)
system call does not take an argument and the
stat function is called
xstat and takes an extra leading argument.  These
discrepancies are normal but idiosyncratic characteristics of the
system call interface and are accounted for by C library wrapper
functions.


On some platforms a process that has a system call trace applied
to it with the
-p option will receive a
SIGSTOP. This signal may interrupt a system call that is not restartable.
This may have an unpredictable effect on the process
if the process takes no action to restart the system call.


A traced process ignores
SIGSTOP except on SVR4 platforms.


A traced process which tries to block SIGTRAP will be sent a SIGSTOP
in an attempt to force continuation of tracing.


A traced process runs slowly.


Traced processes which are descended from
command may be left running after an interrupt signal (
CTRL-C). 

On Linux, exciting as it would be, tracing the init process is forbidden.


The
-i option is weakly supported.


Advertisements


    129 Lectures 
     23 hours 

 Eduonix Learning Solutions

    5 Lectures 
     4.5 hours 

 Frahaan Hussain

    35 Lectures 
     2 hours 

 Pradeep D

    41 Lectures 
     2.5 hours 

 Musab Zayadneh

    46 Lectures 
     4 hours 

 GUHARAJANM

    6 Lectures 
     4 hours 

 Uplatz
 Print
 Add Notes
 Bookmark this page