Back to Commands

ltrace

debuggingLinux

The ltrace command is one of the most frequently used commands in Linux/Unix-like operating systems. ltrace A library call tracer

See Examples View Syntax

Quick Reference

Command Name:

ltrace

Category:

debugging

Platform:

Linux

Basic Usage:

ltrace [options] [arguments]

Common Use Cases

Syntax

ltrace [options] [command [arg...]]

Options

Option	Description
`-c`	Count time and calls for each library call and report a summary
`-C`	Decode low-level names into user-level names
`-d`	Debug mode
`-e expr`	Choose which library calls to trace using a regular expression
`-f`	Trace child processes as they are created
`-l filename`	Only trace calls to functions within the specified library
`-L`	Don't display library calls
`-n nr`	Set the maximum nesting level for function calls
`-o filename`	Write the trace output to a file instead of stderr
`-p pid`	Attach to the process with the specified PID
`-r`	Print relative timestamps
`-s strsize`	Set the maximum string size to display
`-S`	Trace system calls as well as library calls
`-t`	Print absolute timestamps
`-T`	Show the time spent in each library call
`-u username`	Run command with the permissions of username
`-x expr`	Select which library calls NOT to trace using a regular expression

Examples

How to Use These Examples

The examples below show common ways to use the ltrace command. Try them in your terminal to see the results. You can copy any example by clicking on the code block.

# Basic Examples Basic

ltrace ls

Trace library calls made by the ls command.

ltrace -c ls

Count library calls made by the ls command.

# Advanced Examples Advanced

ltrace -e malloc+free ls Trace only malloc and free function calls. ltrace -l libc.so.6 command Trace only calls to functions in libc.so.6. ltrace -p 1234 Attach to process with PID 1234 and trace library calls. ltrace -S ls Trace both system calls and library calls. ltrace -f command Trace child processes as they are created. ltrace -o output.txt command Save trace output to a file instead of stderr. ltrace -T command Show the time spent in each library call. ltrace -n 2 -e malloc command Display a maximum of 2 levels of nested calls for malloc.

Try It Yourself

Practice makes perfect! The best way to learn is by trying these examples on your own system with real files.

Understanding Syntax

Pay attention to the syntax coloring: commands, options, and file paths are highlighted differently.

Notes

The 'ltrace' command is a debugging utility in Linux that traces library calls made by a program. Similar to 'strace', which traces system calls, ltrace focuses on library function calls, providing insights into how a program interacts with shared libraries. Key features of the ltrace command: 1. Library Call Tracing: ltrace intercepts and records dynamic library calls made by a program during its execution, showing function names, arguments, and return values. 2. Selective Tracing: It allows filtering which functions to trace, either by specifying particular libraries or by using regular expressions to match function names. 3. Process Attachment: ltrace can attach to already running processes, enabling debugging of long-running applications without restarting them. 4. Child Process Tracing: With the -f option, it can follow and trace child processes created by the main program, useful for debugging complex applications. 5. Performance Analysis: ltrace can count and time library calls, helping to identify performance bottlenecks in applications. 6. System Call Tracing: When used with the -S option, ltrace can also trace system calls along with library calls, providing a more complete picture of program execution. 7. Output Control: Various options allow controlling the format, detail level, and destination of trace output. ltrace is particularly useful for: - Debugging applications when source code is not available - Understanding how applications interact with libraries - Identifying which library functions are consuming the most time - Troubleshooting issues related to dynamic linking and library dependencies - Learning how complex applications work internally - Detecting memory leaks and other resource usage problems While ltrace is a powerful tool, it does have some limitations: - It can significantly slow down program execution - The output can be overwhelming for complex applications - Some deeply nested or optimized library calls might not be captured accurately - It may not work properly with all types of applications, especially those with complex threading models ltrace is commonly used alongside other debugging tools like strace, gdb, and valgrind to provide a comprehensive view of program behavior during troubleshooting and development.

Related Commands

These commands are frequently used alongside ltrace or serve similar purposes:

Explore All Commands

Use Cases

Learn By Doing

The best way to learn Linux commands is by practicing. Try out these examples in your terminal to build muscle memory and understand how the ltrace command works in different scenarios.

See Examples Try Lab Exercises

$ ltrace

View All Commands