@) Preliminary Draft @) under construction

Contents

  1. Introduction
    1. Rationale
  2. Downloads
    1. LTTng
    2. Sample i386 trace for LTTng
    3. 0.9.6 Release (Nov 21, 2004)
    4. Older stuff
    5. getting attachments from ltt-dev archive
    6. Patch
    7. Utility programs
  3. How To Use
    1. Building the software
    2. Using the software
  4. References
  5. Sample Results
  6. Future Work
  7. LKML Reaction to tracing

Introduction

The Linux Trace Toolkit is used to examine the flow of execution (between processes, kernel threads, and interrupts) in a Linux system. This is useful for analyzing where delays occur in the system, and to see how processes interact (especially with regard to scheduling, interrupts, synchronization primitives, etc.)

/!\ - Note that as of 2.6.14, LTT is being replaced with LTTng. See http://ltt.polymtl.ca/

See also the announcement here: http://lwn.net/Articles/170198/

Rationale

Tracing is useful for analyzing stuff.

Downloads

LTTng

See the QUICKSTART guide at: http://ltt.polymtl.ca/svn/ltt/branches/poly/QUICKSTART

Sample i386 trace for LTTng

Here is a zip file containing a sample trace on an i386 machine: i386-ltt-trace.zip

0.9.6 Release (Nov 21, 2004)

I found it a bit difficult to get the appropriate set of patches for LTT. After a bit of frustration, I built my own release for Nov. 23, 2004. The release is 0.9.6 (no 'pre') and it works with the Linux kernel 2.6.9. The tar file for the release is in the PatchArchive.

Older stuff

The latest stable release is 0.9.5a, but this release is over 2 years old.

Here is the patch set I finally used, for kernel 2.6.8.1:

getting attachments from ltt-dev archive

I had to use 'munpack' to extract the compressed patches from the mail messages in the archive. 'munpack' is part of the package 'mpack', which is available at: ftp://ftp.andrew.cmu.edu/pub/mpack/

Patch

These are bundles with multiple sub-patches and sub-tars. To install them, do the following:

Now, follow the build and usage instructions for the software in the include docs (!TraceToolkit/Help/index.html). For cross-compiling, use the instructions on this wiki page.

Utility programs

How To Use

Building the software

Apply the ltt and relayfs patches to your kernel:

make menuconfig {{{File systems ---> Pseudo filesystems ---> <*> Relayfs file system support (exit, exit) General Setup ---> [*] Linux Trace Toolkit support }}} You can leave klog debugging support turned off.

Compile the user-space tracedaemon program:

I couldn't figure out if the tracevisualizer tools handle cross-compilation correctly (by which I mean that you can natively compile the tracevisualizer but cross-compile the tracedaemon). Instead of blindly trying configure tricks, I instead used the instructions from Karim's book "Building Embedded Linux Systems". In a nutshell, the instructions go something like this:

Overview:

Detail (in my case):

Using the software

In April, 2004, Karim wrote: (see http://lkml.org/lkml/2004/4/3/100) 

The documentation is out of date. Basically, the createdev.sh script isn't
needed anymore because of relayfs. You need to mount relayfs to use LTT.
See the classic dox on filesystem mounting for this kind of thing. It's
going to be something like:
# mount -t relayfs nodev /mnt/relay

There's no insmod for LTT. It isn't a device driver module, following LKML
recommendations.

References

Sample Results

Future Work

Here is a list of things that could be worked on for this feature:

LKML Reaction to tracing

their concerns about tracing infrastructure in the kernel.

{{{my problem with this stuff is conceptual: it introduces a constant drag on the kernel sourcecode, while 99% of development will not want to trace, ever. When i do need tracing occasionally, then i take those 30 minutes to write up a tracer from pre-existing tracing patches, tailored to specific problems. ... so use the power of the GPL-ed kernel and keep your patches separate, releasing them for specific stable kernel branches (or even development kernels).}}} 

> To summarize: You find tracing useful, but software tracing is only of
> limited value in areas you're working at.
>
> What about other developers, which only want to develop a simple driver,
> without having to understand the whole kernel? Traces still work where
> printk() or kgdb don't work. I think it's reasonable to ask an user to
> enable tracing and reproduce the problem, which you can't reproduce
> yourself.

That makes adding source bloat ok? I've debugged some drivers with
dprintk() style tracing, and it often makes the code harder to follow,
even if it ends up being compiled away.

From what I've seen from the LTT thing, it's too heavy-weight to be good
for many things (taking SMP-global locks for trace events is _not_ a good
idea if the trace is for doing things like doing performance tracing,
where a tracer that adds synchronization fundamentally _changes_ what is
going on in ways that have nothing to do with timing).

I suspect we'll want to have some form of event tracing eventually, but
I'm personally pretty convinced that it needs to be a per-CPU thing, and
the core mechanism would need to be very lightweight. It's easier to build
up complexity on top of a lightweight interface than it is to make a
lightweight interface out of a heavy one.

LinuxTraceToolkit (last edited 2008-05-07 18:21:51 by localhost)