Ensure synchronized access to the perf dump file.

src/perf-jit.cc

 // Copyright 2016 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 72 matching lines @@
   uint64_t address_;
   uint64_t entry_count_;
   // Followed by entry_count_ instances of PerfJitDebugEntry.
 };
 
 const char PerfJitLogger::kFilenameFormatString[] = "./jit-%d.dump";
 
 // Extra padding for the PID in the filename
 const int PerfJitLogger::kFilenameBufferPadding = 16;
 
+base::LazyRecursiveMutex PerfJitLogger::file_mutex_;
+// The following static variables are protected by PerfJitLogger::file_mutex_.
+uint64_t PerfJitLogger::reference_count_ = 0;
+void* PerfJitLogger::marker_address_ = nullptr;
+uint64_t PerfJitLogger::code_index_ = 0;
+FILE* PerfJitLogger::perf_output_handle_ = nullptr;
+
 void PerfJitLogger::OpenJitDumpFile() {
   // Open the perf JIT dump file.
   perf_output_handle_ = nullptr;
 
   int bufferSize = sizeof(kFilenameFormatString) + kFilenameBufferPadding;
   ScopedVector<char> perf_dump_name(bufferSize);
   int size = SNPrintF(perf_dump_name, kFilenameFormatString,
                       base::OS::GetCurrentProcessId());
   CHECK_NE(size, -1);
 
@@ skipping 27 matching lines @@
   return (marker_address == MAP_FAILED) ? nullptr : marker_address;
 }
 
 void PerfJitLogger::CloseMarkerFile(void* marker_address) {
   if (marker_address == nullptr) return;
   long page_size = sysconf(_SC_PAGESIZE);  // NOLINT(runtime/int)
   if (page_size == -1) return;
   munmap(marker_address, page_size);
 }
 
-PerfJitLogger::PerfJitLogger()
-    : perf_output_handle_(nullptr), code_index_(0), marker_address_(nullptr) {
-  OpenJitDumpFile();
-  if (perf_output_handle_ == nullptr) return;
-  LogWriteHeader();
+PerfJitLogger::PerfJitLogger() {
+  base::LockGuard<base::RecursiveMutex> guard_file(file_mutex_.Pointer());
+
+  reference_count_++;
+  // If this is the first logger, open the file and write the header.
+  if (reference_count_ == 1) {
+    OpenJitDumpFile();
+    if (perf_output_handle_ == nullptr) return;
+    LogWriteHeader();
+  }
 }
 
-PerfJitLogger::~PerfJitLogger() { CloseJitDumpFile(); }
+PerfJitLogger::~PerfJitLogger() {
+  base::LockGuard<base::RecursiveMutex> guard_file(file_mutex_.Pointer());
+
+  reference_count_--;
+  // If this was the last logger, close the file.
+  if (reference_count_ == 0) {
+    CloseJitDumpFile();
+  }
+}
 
 uint64_t PerfJitLogger::GetTimestamp() {
   struct timespec ts;
   int result = clock_gettime(CLOCK_MONOTONIC, &ts);
   DCHECK_EQ(0, result);
   USE(result);
   static const uint64_t kNsecPerSec = 1000000000;
   return (ts.tv_sec * kNsecPerSec) + ts.tv_nsec;
 }
 
 void PerfJitLogger::LogRecordedBuffer(AbstractCode* abstract_code,
                                       SharedFunctionInfo* shared,
                                       const char* name, int length) {
-  if (perf_output_handle_ == nullptr) return;
   if (FLAG_perf_basic_prof_only_functions &&
       (abstract_code->kind() != AbstractCode::FUNCTION &&
        abstract_code->kind() != AbstractCode::INTERPRETED_FUNCTION &&
        abstract_code->kind() != AbstractCode::OPTIMIZED_FUNCTION)) {
     return;
   }
 
+  base::LockGuard<base::RecursiveMutex> guard_file(file_mutex_.Pointer());
+
+  if (perf_output_handle_ == nullptr) return;
+
   // We only support non-interpreted functions.
   if (!abstract_code->IsCode()) return;
   Code* code = abstract_code->GetCode();
   DCHECK(code->instruction_start() == code->address() + Code::kHeaderSize);
 
   // Debug info has to be emitted first.
-  if (FLAG_perf_prof_debug_info) {
+  if (FLAG_perf_prof_debug_info && shared != nullptr) {
     LogWriteDebugInfo(code, shared);
   }
 
   const char* code_name = name;
   uint8_t* code_pointer = reinterpret_cast<uint8_t*>(code->instruction_start());
   uint32_t code_size = code->is_crankshafted() ? code->safepoint_table_offset()
                                                : code->instruction_size();
 
   static const char string_terminator[] = "\0";
 
@@ skipping 118 matching lines @@
   header.time_stamp_ =
       static_cast<uint64_t>(base::OS::TimeCurrentMillis() * 1000.0);
   header.flags_ = 0;
 
   LogWriteBytes(reinterpret_cast<const char*>(&header), sizeof(header));
 }
 
 #endif  // V8_OS_LINUX
 }  // namespace internal
 }  // namespace v8