Scarfski/tracy
1
0
Fork 0
mirror of https://github.com/wolfpld/tracy.git synced 2026-09-10 12:28:18 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
353339cb08ecf140fe1a8d084eca353e3fb71f0a
tracy/monitor/src/monitor.cpp
Bartosz Taudul 6992454dfd Save the tracy-monitor trace to a file.
2026-09-06 01:07:47 +02:00

1257 lines
45 KiB
C++
Raw Blame History

// tracy-monitor: profile a process that was not built with the Tracy client.
// Launch mode: tracy-monitor [OPTIONS] program [args...]; attach mode:
// tracy-monitor [OPTIONS] -p PID | -n NAME. Runs the standard Tracy client in
// "external mode". With TRACY_ON_DEMAND, samples are captured only while a
// Tracy server is connected. See --help for usage and permission requirements.
//
#include <dirent.h>
#include <errno.h>
#include <fcntl.h>
#include <getopt.h>
#include <memory>
#include <sys/ioctl.h>
#include <linux/perf_event.h>
#include <netinet/in.h>
#include <signal.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/resource.h>
#include <sys/ptrace.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/syscall.h>
#include <sys/wait.h>
#include <unistd.h>
#include "../public/tracy/Tracy.hpp"
#include "../public/common/TracyVersion.hpp"
#include "../public/client/TracyCallstack.hpp"
#include "GitRef.hpp"
#include "../../server/TracyFileWrite.hpp"
#include "../../server/TracyPrint.hpp"
#include "../../server/TracyWorker.hpp"
#include "../../util/CaptureConsole.hpp"
#include "../../util/CaptureFileBackup.hpp"
// The monitor is only meaningful with the client's full sampling +
// symbolication stack. These configurations would either fail to build
// (TRACY_NO_CALLSTACK: the external-target API lives in the callstack
// code) or silently produce an empty capture (IsSystemTracingFailed()
// cannot see them), so reject them here rather than in the client.
#if defined TRACY_NO_CALLSTACK
# error "tracy-monitor requires callstack support: TRACY_NO_CALLSTACK is not supported"
#endif
#if defined TRACY_NO_SYSTEM_TRACING
# error "tracy-monitor requires system tracing: TRACY_NO_SYSTEM_TRACING is not supported"
#endif
#if defined TRACY_NO_SAMPLING
# error "tracy-monitor requires callstack sampling: TRACY_NO_SAMPLING is not supported"
#endif
#if defined TRACY_SAMPLING_PROFILER_MANUAL_START
# error "tracy-monitor starts sampling itself via StartupProfiler(): TRACY_SAMPLING_PROFILER_MANUAL_START is not supported"
#endif
static volatile sig_atomic_t s_shouldQuit = 0;
static pid_t s_targetPid = 0;
static bool s_isForked = false;
static void SignalHandler( int /*sig*/ )
{
s_shouldQuit = 1;
if( s_isForked && s_targetPid != 0 )
{
// We launched the target under ptrace, so forward the signal to wake
// a blocking waitpid and let the child exit. kill() is async-signal-safe.
kill( s_targetPid, SIGINT );
}
}
// kill( pid, 0 ) succeeds even for zombies, so liveness also checks the
// /proc state: a zombie is dead - nothing left to sample, and in attach
// mode we are not the parent, so we can neither reap it nor learn its exit.
static bool ProcessIsAlive( pid_t pid )
{
if( kill( pid, 0 ) != 0 ) return false;
char path[32];
snprintf( path, sizeof( path ), "/proc/%d/stat", (int)pid );
FILE* f = fopen( path, "r" );
if( !f ) return false;
char buf[512];
const size_t n = fread( buf, 1, sizeof( buf ) - 1, f );
fclose( f );
buf[n] = 0;
// the state char follows the last ')' (comm may contain spaces/parens)
const char* state = strrchr( buf, ')' );
return state && state[1] == ' ' && state[2] != 'Z' && state[2] != '\0';
}
// --- capability probes --------------------------------------------------
static const char* GetTraceFsPath()
{
static char path[ 4096 ];
static char debugPath[ 4096 ];
bool haveDebug = false;
FILE* f = fopen( "/proc/mounts", "r" );
if( !f ) return nullptr;
char line[ 4096 ];
while( fgets( line, sizeof( line ), f ) )
{
char dir[ 4096 ];
char type[ 64 ];
if( sscanf( line, "%*s %4095s %63s", dir, type ) != 2 ) continue;
if( strcmp( type, "tracefs" ) == 0 )
{
snprintf( path, sizeof( path ), "%s", dir );
fclose( f );
return path;
}
if( !haveDebug && strcmp( type, "debugfs" ) == 0 )
{
snprintf( debugPath, sizeof( debugPath ), "%s/tracing", dir );
haveDebug = true;
}
}
fclose( f );
if( haveDebug )
{
snprintf( path, sizeof( path ), "%s", debugPath );
return path;
}
return nullptr;
}
enum class TracepointStatus { Open, NoTraceFs, IdNotReadable, OpenDenied };
// open a system-wide per-CPU tracepoint (the client's sched/vblank shape);
// report the failure distinctly - tracefs readability (root) and the perf open (paranoid/CAP_PERFMON) are independent gates.
static TracepointStatus CheckSystemWideTracepoint( const char* eventPath )
{
const char* traceFs = GetTraceFsPath();
if( !traceFs ) return TracepointStatus::NoTraceFs;
char path[512];
snprintf( path, sizeof( path ), "%s%s/id", traceFs, eventPath );
FILE* f = fopen( path, "r" );
if( !f ) return TracepointStatus::IdNotReadable;
int id = -1;
if( fscanf( f, "%d", &id ) != 1 ) id = -1;
fclose( f );
if( id < 0 ) return TracepointStatus::IdNotReadable;
perf_event_attr pe = {};
pe.type = PERF_TYPE_TRACEPOINT;
pe.size = sizeof( pe );
pe.config = (uint64_t)id;
pe.sample_period = 1;
pe.sample_type = PERF_SAMPLE_TIME | PERF_SAMPLE_RAW;
pe.disabled = 1;
pe.inherit = 1;
const long fd = syscall( __NR_perf_event_open, &pe, -1, 0, -1, 0 );
if( fd < 0 ) return TracepointStatus::OpenDenied;
close( (int)fd );
return TracepointStatus::Open;
}
// Power plots read RAPL energy counters (the client scans the same tree).
static bool CanReadRapl()
{
const char* base = "/sys/devices/virtual/powercap/intel-rapl";
DIR* dir = opendir( base );
if( !dir ) return false;
struct dirent* ent;
bool ok = false;
while( ( ent = readdir( dir ) ) )
{
if( ent->d_type != DT_DIR || strncmp( ent->d_name, "intel-rapl:", 11 ) != 0 ) continue;
char path[512];
snprintf( path, sizeof( path ), "%s/%s/energy_uj", base, ent->d_name );
FILE* f = fopen( path, "r" );
if( f )
{
fclose( f );
ok = true;
break;
}
}
closedir( dir );
return ok;
}
// --- sampling preflight ---------------------------------------------------
// verify the per-CPU pid-filtered event mechanism the client relies on:
// perf_event_open(attr, target, cpu) with a direct mmap of the event's ring
// (the normal client's own topology); exclude_kernel=1 so it works at any
// paranoid level.
static bool PreflightOutputMechanism( pid_t pid )
{
perf_event_attr pe = {};
pe.type = PERF_TYPE_SOFTWARE;
pe.size = sizeof( pe );
pe.config = PERF_COUNT_SW_CPU_CLOCK;
pe.sample_type = PERF_SAMPLE_TID | PERF_SAMPLE_TIME;
pe.sample_freq = 100;
pe.freq = 1;
pe.disabled = 1;
pe.inherit = 1;
pe.exclude_kernel = 1;
pe.exclude_callchain_kernel = 1;
const long fd = syscall( __NR_perf_event_open, &pe, pid, 0, -1, 0 );
if( fd < 0 )
{
fprintf( stderr, "Warning: preflight per-CPU event open failed: %s\n", strerror( errno ) );
return false;
}
const size_t mapSize = 64 * 1024 + 4096;
void* map = mmap( nullptr, mapSize, PROT_READ | PROT_WRITE, MAP_SHARED, (int)fd, 0 );
bool ok = map != MAP_FAILED;
if( !ok ) fprintf( stderr, "Warning: preflight ring mmap refused: %s (kernel ABI mismatch?)\n", strerror( errno ) );
if( map != MAP_FAILED ) munmap( map, mapSize );
close( (int)fd );
return ok;
}
// probe whether the client's per-thread hardware PMU counters can open at all
// (the client drops them silently on failure, losing the IPC/cache/branch plots); informational only.
static bool ProbeHwCounters( pid_t pid, int& errOut )
{
perf_event_attr pe = {};
pe.type = PERF_TYPE_HARDWARE;
pe.size = sizeof( pe );
pe.config = PERF_COUNT_HW_CPU_CYCLES;
pe.disabled = 1;
pe.precise_ip = 3;
long fd = syscall( __NR_perf_event_open, &pe, pid, -1, -1, 0 );
while( fd < 0 && pe.precise_ip > 0 )
{
pe.precise_ip--;
fd = syscall( __NR_perf_event_open, &pe, pid, -1, -1, 0 );
}
if( fd < 0 && ( errno == EACCES || errno == EPERM ) )
{
pe.exclude_kernel = 1;
fd = syscall( __NR_perf_event_open, &pe, pid, -1, -1, 0 );
}
if( fd >= 0 )
{
close( (int)fd );
return true;
}
errOut = errno;
return false;
}
// mirror the client's exact external perf_event_open (SysTraceStart/OpenSampleEvent):
// a per-CPU event with a pid filter on the target (direct ring mmap), plus an
// informational hardware PMU probe. Failing fast here yields an accurate
// capability report instead of starting the profiler with no samples.
static bool PreflightSamplingEvent( pid_t pid, bool& kernelFrames, bool& hwStats, int& hwErrno )
{
perf_event_attr pe = {};
pe.type = PERF_TYPE_SOFTWARE;
pe.size = sizeof( pe );
pe.config = PERF_COUNT_SW_CPU_CLOCK;
pe.sample_type = PERF_SAMPLE_IP | PERF_SAMPLE_TID | PERF_SAMPLE_TIME | PERF_SAMPLE_CALLCHAIN;
pe.sample_freq = 1000;
pe.freq = 1;
pe.disabled = 1;
pe.inherit = 1;
long dataFd = syscall( __NR_perf_event_open, &pe, pid, 0, -1, 0 );
if( dataFd < 0 )
{
const int err = errno;
if( err == ESRCH )
{
fprintf( stderr, "Target process %d no longer exists.\n", (int)pid );
return false;
}
if( err == EACCES || err == EPERM )
{
// no kernel access: retry user-space-only, in both the event and the callchain
pe.exclude_kernel = 1;
pe.exclude_callchain_kernel = 1;
dataFd = syscall( __NR_perf_event_open, &pe, pid, 0, -1, 0 );
if( dataFd >= 0 )
{
close( (int)dataFd );
kernelFrames = false;
}
}
else
{
// any other error (EINVAL, ENOSYS under seccomp, exhaustion): the client's same
// event shape would fail identically and produce an empty capture, so fail here.
fprintf( stderr, "Cannot open perf events for pid %d: %s\n", (int)pid, strerror( err ) );
return false;
}
}
else
{
close( (int)dataFd );
kernelFrames = true;
}
if( dataFd < 0 )
{
fprintf( stderr, "Cannot open perf events for pid %d: %s\n", (int)pid, strerror( errno ) );
fprintf( stderr, "Profiling another process requires one of:\n" );
fprintf( stderr, " - running as root (or CAP_PERFMON + CAP_SYS_PTRACE), or\n" );
fprintf( stderr, " - /proc/sys/kernel/perf_event_paranoid <= 1 for kernel frames,\n" );
fprintf( stderr, " <= -1 for system-wide events (context switches / per-thread\n" );
fprintf( stderr, " CPU / wait stacks), or\n" );
fprintf( stderr, " - in attach mode: the target must belong to the same user\n" );
fprintf( stderr, " (uid and gid) and be dumpable, or the monitor must hold\n" );
fprintf( stderr, " CAP_SYS_PTRACE (yama ptrace_scope does not apply: sampling\n" );
fprintf( stderr, " uses ptrace READ access, and the monitor never attaches).\n" );
return false;
}
if( !PreflightOutputMechanism( pid ) )
{
fprintf( stderr, "Per-CPU sample rings are unavailable on this kernel; external sampling will not work.\n" );
return false;
}
hwStats = ProbeHwCounters( pid, hwErrno );
return true;
}
// --- reporting --------------------------------------------------------------
static const char* FormatHz( int hz )
{
static char buf[32];
if( hz >= 1000 && hz % 1000 == 0 )
{
snprintf( buf, sizeof( buf ), "%d kHz", hz / 1000 );
}
else
{
snprintf( buf, sizeof( buf ), "%d Hz", hz );
}
return buf;
}
static int EffectiveSamplingHz()
{
const char* env = getenv( "TRACY_SAMPLING_HZ" );
int hz = 10000; // client default on Linux
if( env )
{
const int parsed = atoi( env );
if( parsed > 0 ) hz = ( parsed > 1000000 ) ? 1000000 : parsed;
}
// mirror the client's clamp: the kernel caps the rate at perf_event_max_sample_rate
FILE* f = fopen( "/proc/sys/kernel/perf_event_max_sample_rate", "r" );
if( f )
{
int sysMax = 0;
if( fscanf( f, "%d", &sysMax ) == 1 && sysMax > 0 && sysMax < hz ) hz = sysMax;
fclose( f );
}
return hz;
}
static int EffectivePort()
{
const char* env = getenv( "TRACY_PORT" );
if( env )
{
const int port = atoi( env );
if( port > 0 && port <= 65535 ) return port;
}
return 8086;
}
static const char* TracepointReason( TracepointStatus status )
{
switch( status )
{
case TracepointStatus::NoTraceFs: return "tracefs is not readable — running as root is required";
case TracepointStatus::IdNotReadable: return "the event id is not readable — running as root is required";
case TracepointStatus::OpenDenied: return "system-wide events are denied — needs perf_event_paranoid <= -1 or CAP_PERFMON";
default: return nullptr;
}
}
static void PrintStartupReport( bool kernelFrames, bool hwStats, int hwErrno, const char* output )
{
const TracepointStatus ctxSwitches = CheckSystemWideTracepoint( "/events/sched/sched_switch" );
const TracepointStatus vsync = CheckSystemWideTracepoint( "/events/drm/drm_vblank_event" );
const bool power = CanReadRapl();
printf( "tracy-monitor %i.%i.%i / %s\n", tracy::Version::Major, tracy::Version::Minor, tracy::Version::Patch, tracy::GitRef );
printf( "Profiling '%s' (pid %d) on port %d\n", tracy::GetExternalTargetName(), (int)tracy::GetExternalTargetPid(), EffectivePort() );
printf( " sampling: %s, %s callchain — leaf-only stacks for -fomit-frame-pointer targets\n", FormatHz( EffectiveSamplingHz() ), kernelFrames ? "kernel" : "user-space" );
printf( " kernel frames: %s\n", kernelFrames ? "yes" : "no (kernel sampling denied — perf_event_paranoid > 1 without CAP_PERFMON)" );
if( hwStats )
{
printf( " hardware sampling statistics: yes\n" );
}
else
{
printf( " hardware sampling statistics: no (PMU counters unavailable: %s)\n", strerror( hwErrno ) );
}
if( ctxSwitches == TracepointStatus::Open )
{
printf( " ctx switches / per-thread CPU: yes\n" );
}
else
{
printf( " ctx switches / per-thread CPU: no (%s)\n", TracepointReason( ctxSwitches ) );
}
printf( " power (RAPL): %s\n", power ? "yes" : "no (needs read access to /sys/devices/virtual/powercap/intel-rapl)" );
if( vsync == TracepointStatus::Open )
{
printf( " vsync: yes\n" );
}
else
{
printf( " vsync: no (%s)\n", TracepointReason( vsync ) );
}
if( output )
{
printf( " output: %s\n", output );
}
#ifdef TRACY_ON_DEMAND
printf( " recording: on-demand: samples are captured only while a Tracy server is connected; pre-connection samples are discarded\n" );
#endif
printf( "\n" );
if( !output )
{
printf( "Open the Tracy profiler and connect to this host:port (or it will auto-discover).\n" );
}
fflush( stdout );
}
// --- trace saving ---------------------------------------------------------------
// No-op until the worker's first rate sample arrives and when stdout is not a terminal.
static void PrintProgress( tracy::Worker* worker )
{
if( !worker || !worker->HasData() ) return;
PrintCaptureProgress( *worker, worker->GetFirstTime(), -1 );
}
// True when the status line actually occupies the current line, so that a
// newline is needed to terminate it. PrintCaptureProgress skips rendering
// until the first rate sample arrives, and printing a bare "\n" then would
// add a stray blank line.
static bool ProgressLineActive( tracy::Worker* worker )
{
if( !worker || !IsTerminal() ) return false;
auto& lock = worker->GetMbpsDataLock();
lock.lock();
const bool active = !worker->GetMbpsData().empty();
lock.unlock();
return active;
}
static bool WaitForWorker( tracy::Worker& worker, const char** reasonOut )
{
*reasonOut = nullptr;
for( int i = 0; i < 100; i++ )
{
if( worker.HasData() ) return true;
if( s_shouldQuit )
{
*reasonOut = "interrupted before the capture started";
return false;
}
const auto hs = worker.GetHandshakeStatus();
if( hs != tracy::HandshakePending )
{
// the first connection was made and rejected or dropped; the worker
// never reconnects, so this outcome is final
switch( (tracy::HandshakeStatus)hs )
{
case tracy::HandshakeProtocolMismatch:
*reasonOut = "the client rejected the protocol version (the client and the worker come from the same build; this should not happen)";
break;
case tracy::HandshakeNotAvailable:
*reasonOut = "another server (e.g. the Tracy profiler GUI) is already connected to the client, and the client serves only one server at a time";
break;
default:
*reasonOut = "the client dropped the connection during the handshake";
break;
}
return false;
}
PrintProgress( &worker );
usleep( 100000 );
}
*reasonOut = "the worker did not connect to the client within 10 seconds";
return false;
}
// All of the client's data has reached the worker by the time this runs.
static int SaveTrace( tracy::Worker& worker, const char* output )
{
// IsConnected() flips only after the last data was processed, so this
// also bounds the worker's own teardown.
while( worker.IsConnected() )
{
usleep( 100000 );
}
const auto failure = worker.GetFailureType();
if( failure != tracy::Worker::Failure::None )
{
fprintf( stderr, "Capture failure: %s\n", tracy::Worker::GetFailureString( failure ) );
const auto& fd = worker.GetFailureData();
if( !fd.message.empty() )
{
fprintf( stderr, "Context: %s\n", fd.message.c_str() );
}
}
if( !worker.HasData() )
{
fprintf( stderr, "No trace saved: the worker received no data from the client.\n" );
tracy::RestoreOutputBackup();
return 1;
}
printf( "Time span: %s, callstack samples: %s\n",
tracy::TimeToString( worker.GetLastTime() - worker.GetFirstTime() ),
tracy::RealToString( worker.GetCallstackSampleCount() ) );
printf( "Saving trace to %s...", output );
fflush( stdout );
auto f = std::unique_ptr<tracy::FileWrite>( tracy::FileWrite::Open( output, tracy::FileCompression::Zstd, 3, 4 ) );
if( !f )
{
fprintf( stderr, "\nCannot open output file %s for writing!\n", output );
tracy::RestoreOutputBackup();
return 5;
}
worker.Write( *f, false );
f->Finish();
const auto stats = f->GetCompressionStatistics();
printf( " done\nTrace size %s (%.2f%% ratio)\n", tracy::MemSizeToString( stats.second ), 100.f * stats.second / stats.first );
tracy::DiscardOutputBackup();
return 0;
}
// --- attach mode ---------------------------------------------------------------
static int FindPidsByComm( const char* name, pid_t* outPids, int maxPids )
{
int count = 0;
DIR* proc = opendir( "/proc" );
if( !proc ) return 0;
struct dirent* ent;
while( ( ent = readdir( proc ) ) )
{
if( ent->d_name[0] < '0' || ent->d_name[0] > '9' ) continue;
char path[64];
snprintf( path, sizeof( path ), "/proc/%s/comm", ent->d_name );
FILE* f = fopen( path, "r" );
if( !f ) continue;
char comm[32] = {};
if( fgets( comm, sizeof( comm ), f ) )
{
size_t len = strlen( comm );
while( len > 0 && ( comm[len-1] == '\n' || comm[len-1] == '\r' ) ) comm[--len] = '\0';
if( strcmp( comm, name ) == 0 && count < maxPids )
{
// gate on /proc/<pid>/exe: zombies keep a comm but have no executable to map
char exe[256] = {};
snprintf( path, sizeof( path ), "/proc/%s/exe", ent->d_name );
if( readlink( path, exe, sizeof( exe ) - 1 ) >= 0 )
{
outPids[count++] = (pid_t)atoi( ent->d_name );
}
}
}
fclose( f );
}
closedir( proc );
return count;
}
static bool VerifyClientListening()
{
for( int i = 0; i < 40; i++ )
{
if( tracy::IsDataPortListening() ) return true;
usleep( 125000 );
}
return false;
}
static int RunAttached( pid_t pid, const char* output )
{
if( kill( pid, 0 ) != 0 )
{
fprintf( stderr, "Process %d does not exist or is not accessible.\n", (int)pid );
return 1;
}
if( !ProcessIsAlive( pid ) )
{
fprintf( stderr, "Process %d is a zombie (it has already exited); nothing to attach to.\n", (int)pid );
return 1;
}
s_targetPid = pid;
printf( "Attaching to process %d", (int)pid );
fflush( stdout );
if( !tracy::InitExternalTarget( pid ) ) return 1;
printf( " (%s)...\n", tracy::GetExternalTargetName() );
fflush( stdout );
bool kernelFrames = false;
bool hwStats = false;
int hwErrno = 0;
if( !PreflightSamplingEvent( pid, kernelFrames, hwStats, hwErrno ) ) return 1;
if( !GetTraceFsPath() )
{
fprintf( stderr, "No tracefs mount found: the client's system tracing cannot start without it, so no samples would be captured.\n" );
return 1;
}
tracy::StartupProfiler();
if( tracy::IsSystemTracingFailed() )
{
fprintf( stderr, "The client failed to start sampling although the preflight passed; the capture would contain no samples (the target may have exited between checks, or the kernel rejected the event setup).\n" );
tracy::ShutdownProfiler();
return 1;
}
if( !VerifyClientListening() )
{
if( const char* port = getenv( "TRACY_PORT" ) )
{
fprintf( stderr, "The client could not listen on port %s (the port is most likely in use, or the bind was denied). Retry, or choose another port with --port.\n", port );
}
else
{
fprintf( stderr, "The client could not listen on any of the scan ports 8086-8105 (they are most likely all in use, or the bind was denied). Retry, or choose another port with --port.\n" );
}
tracy::ShutdownProfiler();
return 1;
}
PrintStartupReport( kernelFrames, hwStats, hwErrno, output );
// The worker is created only after the client started: the worker's threads
// name themselves via the client's SetThreadName(), which requires the client
// to be up (the monitor runs it with TRACY_MANUAL_LIFETIME).
std::unique_ptr<tracy::Worker> worker;
if( output )
{
worker = std::make_unique<tracy::Worker>( "127.0.0.1", (uint16_t)EffectivePort(), -1 );
const char* reason = nullptr;
if( !WaitForWorker( *worker, &reason ) )
{
fprintf( stderr, "Cannot capture to %s: %s.\n", output, reason );
tracy::RestoreOutputBackup();
tracy::ShutdownProfiler();
return 1;
}
}
// never signal the target: attach mode must leave it running when we quit
while( !s_shouldQuit && ProcessIsAlive( pid ) )
{
PrintProgress( worker.get() );
usleep( 100000 ); // 100ms poll
}
if( ProgressLineActive( worker.get() ) ) printf( "\n" ); // terminate the status line
if( s_shouldQuit )
{
printf( "\nShutting down profiler...\n" );
}
else
{
printf( "Target exited.\n" );
}
tracy::ShutdownProfiler();
if( worker ) return SaveTrace( *worker, output );
return 0;
}
// --- launch mode ---------------------------------------------------------------
static int RunForked( int argc, char** argv, const char* output )
{
pid_t childPid = fork();
if( childPid < 0 )
{
fprintf( stderr, "Unable to fork: %s\n", strerror( errno ) );
return 2;
}
if( childPid == 0 )
{
// Child process: request ptrace stop at exec, then exec the target.
// Don't leak the monitor's own TRACY_* env into a target that links its own client.
unsetenv( "TRACY_SAMPLING_HZ" );
unsetenv( "TRACY_PORT" );
if( ptrace( PTRACE_TRACEME, 0, nullptr, nullptr ) < 0 )
{
fprintf( stderr, "ptrace(TRACEME) failed: %s\n", strerror( errno ) );
_exit( 2 );
}
execvp( argv[0], argv );
fprintf( stderr, "Unable to exec '%s': %s\n", argv[0], strerror( errno ) );
_exit( 2 );
}
// Parent: wait for the child to stop at the exec boundary (SIGTRAP)
s_targetPid = childPid;
s_isForked = true;
int status;
for(;;)
{
if( waitpid( childPid, &status, 0 ) >= 0 ) break;
if( errno == EINTR ) continue;
fprintf( stderr, "waitpid failed: %s\n", strerror( errno ) );
kill( childPid, SIGKILL );
waitpid( childPid, nullptr, 0 );
return 2;
}
while( WIFSTOPPED( status ) && WSTOPSIG( status ) != SIGTRAP )
{
// A caught signal (the handlers are inherited by the child) arriving between
// PTRACE_TRACEME and exec produces a signal-delivery stop before the exec stop.
// Re-inject it and keep waiting for the exec stop: running the setup on the
// pre-exec child would capture the monitor's own image and mis-symbolicate.
// Job-control signals must never be re-injected: re-delivering SIGSTOP/SIGTSTP
// re-stops the child, so the exec stop would never be reached (or, for a
// stop carrying the 0x80 job-control bit, PTRACE_CONT rejects the signal
// number outright). Resume those without a signal instead: the stop is
// delivered as a group stop at most once more, and the next resume lifts it.
const int rawStopSig = WSTOPSIG( status );
const int stopSig = rawStopSig & 0x7f;
const int resumeSig = ( rawStopSig & 0x80 || stopSig == SIGSTOP || stopSig == SIGTSTP ) ? 0 : stopSig;
if( ptrace( PTRACE_CONT, childPid, 0, (void*)(unsigned long)resumeSig ) != 0 )
{
fprintf( stderr, "ptrace failed: %s\n", strerror( errno ) );
kill( childPid, SIGKILL );
waitpid( childPid, nullptr, 0 );
return 2;
}
for(;;)
{
if( waitpid( childPid, &status, 0 ) >= 0 ) break;
if( errno == EINTR ) continue;
fprintf( stderr, "waitpid failed: %s\n", strerror( errno ) );
kill( childPid, SIGKILL );
waitpid( childPid, nullptr, 0 );
return 2;
}
}
if( !WIFSTOPPED( status ) )
{
// Child exited or was killed before reaching the post-exec SIGTRAP.
if( s_shouldQuit )
{
fprintf( stderr, "\nInterrupted before target started.\n" );
}
else if( WIFEXITED( status ) )
{
fprintf( stderr, "Target exited before profiling began (status %d) -- exec failed?\n", WEXITSTATUS( status ) );
}
else if( WIFSIGNALED( status ) )
{
fprintf( stderr, "Target killed by signal %d before profiling began.\n", WTERMSIG( status ) );
}
else
{
fprintf( stderr, "Child process did not stop as expected (status=0x%x).\n", status );
}
return 2;
}
// The child is stopped post-exec: read its name/exe/maps and check sampling
// permissions while we hold it stopped.
if( !tracy::InitExternalTarget( childPid ) )
{
kill( childPid, SIGKILL );
waitpid( childPid, nullptr, 0 );
return 1;
}
printf( "Profiling '%s' (pid %d)...\n", tracy::GetExternalTargetName(), (int)childPid );
fflush( stdout );
bool kernelFrames = false;
bool hwStats = false;
int hwErrno = 0;
if( !PreflightSamplingEvent( childPid, kernelFrames, hwStats, hwErrno ) )
{
kill( childPid, SIGKILL );
waitpid( childPid, nullptr, 0 );
return 1;
}
if( !GetTraceFsPath() )
{
fprintf( stderr, "No tracefs mount found: the client's system tracing cannot start without it, so no samples would be captured.\n" );
kill( childPid, SIGKILL );
waitpid( childPid, nullptr, 0 );
return 1;
}
tracy::StartupProfiler();
if( tracy::IsSystemTracingFailed() )
{
fprintf( stderr, "The client failed to start sampling although the preflight passed; the capture would contain no samples (the target may have exited between checks, or the kernel rejected the event setup).\n" );
kill( childPid, SIGKILL );
waitpid( childPid, nullptr, 0 );
tracy::ShutdownProfiler();
return 1;
}
// Detach ptrace and let the child run. If detach fails the child stays
// stopped forever, so this has to be fatal.
if( ptrace( PTRACE_DETACH, childPid, nullptr, nullptr ) < 0 )
{
fprintf( stderr, "ptrace(DETACH) failed: %s -- killing child.\n", strerror( errno ) );
kill( childPid, SIGKILL );
waitpid( childPid, nullptr, 0 );
tracy::ShutdownProfiler();
return 2;
}
if( !VerifyClientListening() )
{
if( const char* port = getenv( "TRACY_PORT" ) )
{
fprintf( stderr, "The client could not listen on port %s (the port is most likely in use, or the bind was denied). Retry, or choose another port with --port.\n", port );
}
else
{
fprintf( stderr, "The client could not listen on any of the scan ports 8086-8105 (they are most likely all in use, or the bind was denied). Retry, or choose another port with --port.\n" );
}
kill( childPid, SIGKILL );
waitpid( childPid, nullptr, 0 );
tracy::ShutdownProfiler();
return 1;
}
PrintStartupReport( kernelFrames, hwStats, hwErrno, output );
std::unique_ptr<tracy::Worker> worker;
if( output )
{
worker = std::make_unique<tracy::Worker>( "127.0.0.1", (uint16_t)EffectivePort(), -1 );
const char* reason = nullptr;
if( !WaitForWorker( *worker, &reason ) )
{
fprintf( stderr, "Cannot capture to %s: %s.\n", output, reason );
tracy::RestoreOutputBackup();
kill( childPid, SIGKILL );
waitpid( childPid, nullptr, 0 );
tracy::ShutdownProfiler();
return 1;
}
}
// Wait for child to exit, or for a signal
for(;;)
{
if( s_shouldQuit ) break;
int wstatus;
pid_t ret = waitpid( childPid, &wstatus, WNOHANG );
if( ret > 0 )
{
// the monitor's exit code reflects the monitor, not the profiled application
if( WIFEXITED( wstatus ) )
{
printf( "Target exited with status %d.\n", WEXITSTATUS( wstatus ) );
}
else if( WIFSIGNALED( wstatus ) )
{
printf( "Target exited (signal %d).\n", WTERMSIG( wstatus ) );
}
break;
}
else if( ret < 0 && errno != EINTR )
{
// Child already gone
break;
}
PrintProgress( worker.get() );
usleep( 100000 );
}
if( ProgressLineActive( worker.get() ) ) printf( "\n" ); // terminate the status line
if( s_shouldQuit && ProcessIsAlive( childPid ) )
{
printf( "\nForwarding signal to child and shutting down...\n" );
kill( childPid, SIGINT );
// Give it a moment to exit
usleep( 500000 );
if( ProcessIsAlive( childPid ) )
{
kill( childPid, SIGKILL );
}
waitpid( childPid, nullptr, 0 );
}
else if( s_shouldQuit )
{
// Child is a zombie (it died since the last poll): reap it.
waitpid( childPid, nullptr, WNOHANG );
}
tracy::ShutdownProfiler();
if( worker ) return SaveTrace( *worker, output );
return 0;
}
// --- CLI --------------------------------------------------------------------
static void PrintUsage( const char* progName )
{
printf( "tracy-monitor %i.%i.%i / %s\n\n", tracy::Version::Major, tracy::Version::Minor, tracy::Version::Patch, tracy::GitRef );
printf( "Profiles a process that was not built with the Tracy client.\n" );
printf( "\n" );
printf( "Usage: %s [OPTIONS] program [arguments...]\n", progName );
printf( " %s [OPTIONS] -p PID\n", progName );
printf( " %s [OPTIONS] -n NAME\n", progName );
printf( "\n" );
printf( "Options:\n" );
printf( " -p, --pid PID Attach to an existing process (PID)\n" );
printf( " -n, --name NAME Attach to an existing process by name; the name is the\n" );
printf( " /proc/<pid>/comm value, truncated to 15 characters. If\n" );
printf( " several processes match, their PIDs are listed; use -p.\n" );
printf( " --hz N Sampling frequency in Hz (default 10000, range 1..1000000)\n" );
printf( " --port N Listen port for Tracy servers (default 8086)\n" );
printf( " -o, --output FILE Save the trace to FILE (.tracy) when the capture\n" );
printf( " ends. While capturing, the monitor acts as the Tracy\n" );
printf( " server itself, so the profiler GUI cannot connect\n" );
printf( " -f, --force Replace the output file if it exist\n" );
printf( " -h, --help Show this help message\n" );
printf( "\n" );
printf( "Exit codes: 0 on success; 1 when the target cannot be profiled\n" );
printf( "(bad option, no matching process, permission or kernel refusal) or\n" );
printf( "the trace cannot be saved; 2 when the monitor itself fails to start the\n" );
printf( "target (fork/exec/ptrace); 4 when the output file already exists\n" );
printf( "(use -f to overwrite); 5 when the output file cannot be opened or used.\n" );
printf( "\n" );
printf( "Permission requirements (perf_event_paranoid / capabilities):\n" );
printf( " sampling + symbolication ptrace READ access to the target:\n" );
printf( " same user (uid and gid) and dumpable,\n" );
printf( " or CAP_SYS_PTRACE (yama ptrace_scope\n" );
printf( " does not apply; launch mode's\n" );
printf( " PTRACE_TRACEME needs CAP_SYS_PTRACE at\n" );
printf( " scope 2 and is blocked at scope 3)\n" );
printf( " kernel frames in callchains paranoid <= 1 or CAP_PERFMON\n" );
printf( " IPC / cache / branch statistics hardware PMU counters must be\n" );
printf( " available (often restricted in VMs\n" );
printf( " and containers)\n" );
printf( " context switches / wait stacks tracefs readable (root on most\n" );
printf( " systems) AND paranoid <= -1 or\n" );
printf( " CAP_PERFMON for the event open\n" );
printf( " power (RAPL) plot read access to\n" );
printf( " /sys/devices/virtual/powercap/intel-rapl\n" );
printf( "\n" );
printf( "Examples:\n" );
printf( " %s ./my_program arg1 arg2\n", progName );
printf( " %s -o trace.tracy -n my_program\n", progName );
printf( "\n" );
printf( "In launch mode the target is started under ptrace control so profiling\n" );
printf( "begins before its first instruction; quitting the monitor terminates the\n" );
printf( "target. In attach mode (-p/-n) the target must already be running and is\n" );
printf( "left running when the monitor quits.\n" );
}
// Reserve the first free port in the client's 8086..8105 scan range and hand the
// probe socket to the client (SetReservedListenSocket) so the reservation is atomic.
// The probe must mirror the client's bind exactly (ListenSocket::Listen): IPv6
// dual-stack first, IPv4 only if socket() itself fails, SO_REUSEADDR,
// TRACY_ONLY_LOCALHOST narrows to loopback, fd CLOEXEC (no leak into the target).
static bool ProbeClientBind( int port, bool ipv4Only, bool onlyLocalhost, int& fdOut )
{
fdOut = -1;
int s = -1;
int family = AF_INET6;
if( !ipv4Only ) s = socket( AF_INET6, SOCK_STREAM, 0 );
if( s < 0 )
{
family = AF_INET;
s = socket( AF_INET, SOCK_STREAM, 0 );
}
if( s < 0 ) return false;
fcntl( s, F_SETFD, FD_CLOEXEC );
int val = 1;
setsockopt( s, SOL_SOCKET, SO_REUSEADDR, &val, sizeof( val ) );
bool ok = false;
if( family == AF_INET6 )
{
sockaddr_in6 addr = {};
addr.sin6_family = AF_INET6;
if( onlyLocalhost ) addr.sin6_addr = in6addr_loopback;
addr.sin6_port = htons( (uint16_t)port );
ok = bind( s, (sockaddr*)&addr, sizeof( addr ) ) == 0 && listen( s, 4 ) == 0;
}
else
{
sockaddr_in addr = {};
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = onlyLocalhost ? htonl( INADDR_LOOPBACK ) : INADDR_ANY;
addr.sin_port = htons( (uint16_t)port );
ok = bind( s, (sockaddr*)&addr, sizeof( addr ) ) == 0 && listen( s, 4 ) == 0;
}
if( ok )
{
fdOut = s;
}
else
{
close( s );
}
return ok;
}
static void ReservePortIfUnpinned()
{
if( getenv( "TRACY_PORT" ) ) return;
const char* onlyIPv4 = getenv( "TRACY_ONLY_IPV4" );
const char* onlyLocalhost = getenv( "TRACY_ONLY_LOCALHOST" );
const bool ipv4Only = onlyIPv4 && onlyIPv4[0] == '1';
const bool localhost = onlyLocalhost && onlyLocalhost[0] == '1';
for( int i=0; i<20; i++ )
{
const int port = 8086 + i;
int fd = -1;
if( ProbeClientBind( port, ipv4Only, localhost, fd ) )
{
char buf[8];
snprintf( buf, sizeof( buf ), "%d", port );
setenv( "TRACY_PORT", buf, 1 );
tracy::SetReservedListenSocket( fd );
return;
}
}
}
int main( int argc, char** argv )
{
auto progName = argv[0];
InitTerminalDetection();
if( argc < 2 )
{
PrintUsage( progName );
return 1;
}
// Install signal handlers for graceful shutdown
struct sigaction sa = {};
sa.sa_handler = SignalHandler;
sigemptyset( &sa.sa_mask );
sa.sa_flags = 0;
sigaction( SIGINT, &sa, nullptr );
sigaction( SIGTERM, &sa, nullptr );
sigaction( SIGHUP, &sa, nullptr );
sigaction( SIGQUIT, &sa, nullptr );
// TRACY_NO_SYS_TRACE / TRACY_NO_SAMPLING would silently disable the monitor's
// primary data sources (IsSystemTracingFailed() stays false); refuse them up front.
const char* noSysTrace = getenv( "TRACY_NO_SYS_TRACE" );
const char* noSampling = getenv( "TRACY_NO_SAMPLING" );
if( ( noSysTrace && noSysTrace[0] == '1' ) || ( noSampling && noSampling[0] == '1' ) )
{
if( noSysTrace && noSysTrace[0] == '1' )
{
fprintf( stderr, "tracy-monitor: TRACY_NO_SYS_TRACE=1 is set; the monitor requires system tracing. Unset the variable and retry.\n" );
}
if( noSampling && noSampling[0] == '1' )
{
fprintf( stderr, "tracy-monitor: TRACY_NO_SAMPLING=1 is set; the monitor requires callstack sampling. Unset the variable and retry.\n" );
}
return 1;
}
// external sampling opens one event per CPU for each existing thread
// (attach) or per CPU (launch) per event type; raise the soft fd limit
// so multithreaded targets fit (failing opens degrade gracefully).
{
struct rlimit rl = {};
if( getrlimit( RLIMIT_NOFILE, &rl ) == 0 && rl.rlim_cur < 65536 )
{
const rlim_t want = rl.rlim_max > 65536 ? 65536 : rl.rlim_max;
if( want > rl.rlim_cur )
{
rl.rlim_cur = want;
if( setrlimit( RLIMIT_NOFILE, &rl ) != 0 )
{
fprintf( stderr, "tracy-monitor: warning: could not raise RLIMIT_NOFILE (%s); very multithreaded targets may be only partially sampled.\n", strerror( errno ) );
}
}
}
}
pid_t attachPid = 0;
char attachName[128] = {};
bool wantAttach = false;
const char* output = nullptr;
bool overwrite = false;
enum { OptHz = 256, OptPort };
static struct option longOptions[] =
{
{ "pid", required_argument, nullptr, 'p' },
{ "name", required_argument, nullptr, 'n' },
{ "hz", required_argument, nullptr, OptHz },
{ "port", required_argument, nullptr, OptPort },
{ "output", required_argument, nullptr, 'o' },
{ "force", no_argument, nullptr, 'f' },
{ "help", no_argument, nullptr, 'h' },
{ nullptr, 0, nullptr, 0 }
};
int c;
while( ( c = getopt_long( argc, argv, "+p:n:o:fh", longOptions, nullptr ) ) != -1 )
{
switch( c )
{
case 'p':
attachPid = atoi( optarg );
wantAttach = true;
break;
case 'n':
if( strlen( optarg ) >= sizeof( attachName ) )
{
fprintf( stderr, "Process name too long (max %zu characters).\n", sizeof( attachName ) - 1 );
return 1;
}
snprintf( attachName, sizeof( attachName ), "%s", optarg );
wantAttach = true;
break;
case OptHz:
{
const int hz = atoi( optarg );
if( hz < 1 || hz > 1000000 )
{
fprintf( stderr, "Invalid sample rate %s (range 1..1000000 Hz).\n", optarg );
return 1;
}
char buf[16];
snprintf( buf, sizeof( buf ), "%d", hz );
setenv( "TRACY_SAMPLING_HZ", buf, 1 );
break;
}
case OptPort:
{
const int port = atoi( optarg );
if( port < 1 || port > 65535 )
{
fprintf( stderr, "Invalid port %s (range 1..65535).\n", optarg );
return 1;
}
char buf[8];
snprintf( buf, sizeof( buf ), "%d", port );
setenv( "TRACY_PORT", buf, 1 );
break;
}
case 'o':
output = optarg;
break;
case 'f':
overwrite = true;
break;
case 'h':
PrintUsage( argv[0] );
return 0;
case '?':
fprintf( stderr, "Unknown option. Use -h for help.\n" );
return 1;
}
}
// validate a pinned TRACY_PORT like --port: the client pins to any nonzero value
// (single listen, no fallback), so a bad value would report a port never used.
{
const char* portEnv = getenv( "TRACY_PORT" );
if( portEnv )
{
char* end = nullptr;
const long port = strtol( portEnv, &end, 10 );
if( end == portEnv || *end != '\0' || port < 1 || port > 65535 )
{
fprintf( stderr, "Invalid TRACY_PORT '%s' (expected a number in 1..65535); unset it or use --port.\n", portEnv );
return 1;
}
}
}
ReservePortIfUnpinned();
if( output )
{
const char* prepError = nullptr;
const auto prep = tracy::PrepareOutputFile( output, overwrite, &prepError );
if( prep == tracy::OutputPrep::Exists )
{
fprintf( stderr, "Output file %s already exists! Use -f to force overwrite.\n", output );
return 4;
}
if( prep == tracy::OutputPrep::Unusable )
{
fprintf( stderr, "Cannot use output file: %s!\n", prepError );
return 5;
}
}
if( wantAttach )
{
if( attachName[0] )
{
pid_t pids[32] = {};
const int numPids = FindPidsByComm( attachName, pids, 32 );
if( numPids == 0 )
{
fprintf( stderr, "No process named '%s' (names are /proc/<pid>/comm values, truncated to 15 characters).\n", attachName );
return 1;
}
if( numPids > 1 )
{
fprintf( stderr, "Several processes named '%s':", attachName );
for( int i=0; i<numPids; i++ ) fprintf( stderr, " %d", (int)pids[i] );
fprintf( stderr, "\nUse -p PID to disambiguate.\n" );
return 1;
}
return RunAttached( pids[0], output );
}
if( attachPid <= 0 )
{
fprintf( stderr, "Invalid PID specified.\n" );
return 1;
}
return RunAttached( attachPid, output );
}
argv += optind;
argc -= optind;
if( argc < 1 )
{
PrintUsage( progName ); // argv[0] was shifted, use original
return 1;
}
return RunForked( argc, argv, output );
}
Reference in New Issue View Git Blame Copy Permalink