Index: compiler-rt/include/xray/xray_records.h =================================================================== --- compiler-rt/include/xray/xray_records.h +++ compiler-rt/include/xray/xray_records.h @@ -95,8 +95,11 @@ // The thread ID for the currently running thread. uint32_t TId = 0; + // The ID of process that is currently running + uint32_t Pid = 0; + // Use some bytes in the end of the record for buffers. - char Buffer[12] = {}; + char Buffer[8] = {}; } __attribute__((packed)); static_assert(sizeof(XRayRecord) == 32, "XRayRecord != 32 bytes"); @@ -115,8 +118,8 @@ // The thread ID for the currently running thread. uint32_t TId = 0; - // Add more padding. - uint8_t Padding2[4] = {}; + // The ID of process that is currently running + uint32_t Pid = 0; // The argument payload. uint64_t Arg = 0; Index: compiler-rt/lib/xray/xray_basic_logging.cc =================================================================== --- compiler-rt/lib/xray/xray_basic_logging.cc +++ compiler-rt/lib/xray/xray_basic_logging.cc @@ -227,7 +227,8 @@ R.RecordType = RecordTypes::NORMAL; R.CPU = CPU; R.TSC = TSC; - R.TId = TLD.TID; + R.TId = GetTid(); + R.Pid = getpid(); R.Type = Type; R.FuncId = FuncId; auto FirstEntry = reinterpret_cast(TLD.InMemoryBuffer); @@ -274,7 +275,8 @@ XRayArgPayload R; R.RecordType = RecordTypes::ARG_PAYLOAD; R.FuncId = FuncId; - R.TId = TLD.TID; + R.TId = GetTid(); + R.Pid = getpid(); R.Arg = Arg1; internal_memcpy(FirstEntry + TLD.BufferOffset, &R, sizeof(R)); if (++TLD.BufferOffset == BuffLen) { Index: compiler-rt/lib/xray/xray_fdr_log_records.h =================================================================== --- compiler-rt/lib/xray/xray_fdr_log_records.h +++ compiler-rt/lib/xray/xray_fdr_log_records.h @@ -33,6 +33,7 @@ CallArgument, BufferExtents, TypedEventMarker, + Pid, }; // Use 7 bits to identify this record type. Index: compiler-rt/lib/xray/xray_fdr_logging.cc =================================================================== --- compiler-rt/lib/xray/xray_fdr_logging.cc +++ compiler-rt/lib/xray/xray_fdr_logging.cc @@ -125,9 +125,9 @@ return TLD; } -static void writeNewBufferPreamble(tid_t Tid, +static void writeNewBufferPreamble(pid_t Pid, tid_t Tid, timespec TS) XRAY_NEVER_INSTRUMENT { - static constexpr int InitRecordsCount = 2; + static constexpr int InitRecordsCount = 3; auto &TLD = getThreadLocalData(); MetadataRecord Metadata[InitRecordsCount]; { @@ -161,6 +161,16 @@ sizeof(Micros)); } + // Also write the Pid record. + { + // Write out a MetadataRecord that contains the current pid + auto &PidMetadata = Metadata[2]; + PidMetadata.Type = uint8_t(RecordType::Metadata); + PidMetadata.RecordKind = uint8_t(MetadataRecord::RecordKinds::Pid); + int32_t pid = static_cast(Pid); + internal_memcpy(&PidMetadata.Data, &pid, sizeof(pid)); + } + TLD.NumConsecutiveFnEnters = 0; TLD.NumTailCalls = 0; if (TLD.BQ == nullptr || TLD.BQ->finalizing()) @@ -178,11 +188,12 @@ auto &TLD = getThreadLocalData(); auto &B = TLD.Buffer; TLD.RecordPtr = static_cast(B.Data); + pid_t Pid = getpid(); tid_t Tid = GetTid(); timespec TS{0, 0}; // This is typically clock_gettime, but callers have injection ability. wall_clock_reader(CLOCK_MONOTONIC, &TS); - writeNewBufferPreamble(Tid, TS); + writeNewBufferPreamble(Pid, Tid, TS); TLD.NumConsecutiveFnEnters = 0; TLD.NumTailCalls = 0; } Index: compiler-rt/test/xray/TestCases/Posix/fork_basic_logging.cc =================================================================== --- /dev/null +++ compiler-rt/test/xray/TestCases/Posix/fork_basic_logging.cc @@ -0,0 +1,100 @@ +// Check that when forking in basic logging mode, we get the different tids for child and parent +// RUN: %clangxx_xray -g -std=c++11 %s -o %t +// RUN: rm -f fork-basic-logging-test-* +// RUN: XRAY_OPTIONS="patch_premain=true xray_logfile_base=fork-basic-logging-test- \ +// RUN: xray_mode=xray-basic verbosity=1" \ +// RUN: %run %t 2>&1 | FileCheck %s +// RUN: %llvm_xray convert --symbolize --output-format=yaml -instr_map=%t \ +// RUN: "`ls -S fork-basic-logging-test-* | head -1`" \ +// RUN: | FileCheck %s --check-prefix=TRACE + +// REQUIRES: x86_64-target-arch +// REQUIRES: built-in-llvm-tree + +#include "xray/xray_log_interface.h" +#include +#include +#include +#include + +//modified from sanitizer + +static uintptr_t syscall_gettid() { + uint64_t retval; + asm volatile("syscall" : "=a"(retval) : "a"(__NR_gettid) : "rcx", "r11", + "memory", "cc"); + return retval; +} + +///////////// + +static uint64_t parent_tid; + +[[clang::xray_always_instrument]] +uint64_t __attribute__((noinline)) log_syscall_gettid() +{ + //don't optimize this function away + uint64_t tid = syscall_gettid(); + printf("Logging tid %lu\n", tid); + return tid; +} + +[[clang::xray_always_instrument, clang::xray_log_args(1)]] +void __attribute__((noinline)) print_parent_tid(uint64_t tid) +{ + printf("Parent with tid %lu", tid); +} + +[[clang::xray_always_instrument, clang::xray_log_args(1)]] +void __attribute__((noinline)) print_child_tid(uint64_t tid) +{ + printf("Child with tid %lu", tid); +} + +[[clang::xray_always_instrument]] void __attribute__((noinline)) print_parent_or_child() +{ + uint64_t tid = syscall_gettid(); + if(tid == parent_tid) + { + print_parent_tid(tid); + } + else + { + print_child_tid(tid); + } +} + +int main() +{ + parent_tid = log_syscall_gettid(); + if(fork()) + { + print_parent_or_child(); + // CHECK: Parent with tid + } + else + { + print_parent_or_child(); + // CHECK: Child with tid + } + return 0; +} + +// Make sure we know which thread is the parent process +// TRACE-DAG: - { type: 0, func-id: [[LSGT:[0-9]+]], function: {{.*log_syscall_gettid.*}}, cpu: {{.*}}, thread: [[THREAD1:[0-9]+]], kind: function-enter, tsc: {{[0-9]+}} } + +// TRACE-DAG: - { type: 0, func-id: [[PPOC:[0-9]+]], function: {{.*print_parent_or_child.*}}, cpu: {{.*}}, thread: [[THREAD1]], kind: function-enter, tsc: {{[0-9]+}} } +// +// The parent will print its pid first +// TRACE-DAG: - { type: 0, func-id: [[PPTARG:[0-9]+]], function: {{.*print_parent_tid.*}}, args: [ [[THREAD1]] ], cpu: {{.*}}, thread: [[THREAD1]], kind: function-enter-arg, tsc: {{[0-9]+}} } +// TRACE-DAG: - { type: 0, func-id: [[PPTARG]], function: {{.*print_parent_tid.*}}, cpu: {{.*}}, thread: [[THREAD1]], kind: function-exit, tsc: {{[0-9]+}} } +// +// TRACE: - { type: 0, func-id: [[PPOC]], function: {{.*print_parent_or_child.*}}, cpu: {{.*}}, thread: [[THREAD1]], kind: function-{{exit|tail-exit}}, tsc: {{[0-9]+}} } + +// TRACE-DAG: - { type: 0, func-id: [[PPOC]], function: {{.*print_parent_or_child.*}}, cpu: {{.*}}, thread: [[THREAD2:[0-9]+]], kind: function-enter, tsc: {{[0-9]+}} } +// +// The child will print its pid now +// TRACE-DAG: - { type: 0, func-id: [[PCTARG:[0-9]+]], function: {{.*print_child_tid.*}}, args: [ [[THREAD2]] ], cpu: {{.*}}, thread: [[THREAD2]], kind: function-enter-arg, tsc: {{[0-9]+}} } +// TRACE-DAG: - { type: 0, func-id: [[PCTARG]], function: {{.*print_child_tid.*}}, cpu: {{.*}}, thread: [[THREAD2]], kind: function-exit, tsc: {{[0-9]+}} } +// +// TRACE: - { type: 0, func-id: [[PPOC]], function: {{.*print_parent_or_child.*}}, cpu: {{.*}}, thread: [[THREAD2]], kind: function-{{exit|tail-exit}}, tsc: {{[0-9]+}} }