Change cygprofile to work on Android.

tools/cygprofile/cygprofile.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 // Tool to log the execution of the process (Chrome). Writes logs containing
 // time and address of the callback being called for the first time.
 //
 // To speed up the logging, buffering logs is implemented. Every thread have its
 // own buffer and log file so the contention between threads is minimal. As a
 // side-effect, functions called might be mentioned in many thread logs.
@@ skipping 14 matching lines @@
 
 #include <fcntl.h>
 #include <fstream>
 #include <pthread.h>
 #include <stdarg.h>
 #include <string>
 #include <sys/stat.h>
 #include <sys/syscall.h>
 #include <sys/time.h>
 #include <sys/types.h>
-#include <unordered_set>
 #include <vector>
 
+#include "base/hash_tables.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/singleton.h"
 #include "base/synchronization/lock.h"
 
 namespace cygprofile {
 
 extern "C" {
 
 // Note that these are linked internally by the compiler. Don't call
@@ skipping 76 matching lines @@
   // A lock that guards buf_ usage between per-thread instrumentation
   // routine and timer flush callback. So the contention could happen
   // only during the flush, every 30 secs.
   base::Lock log_mutex_;
 
   // Current thread is inside the instrumentation routine.
   bool in_use_;
 
   // Keeps track of all functions that have been logged on this thread
   // so we do not record dublicates.
-  std::unordered_set<void*> functions_called_;
+  std::hash_set<void*> functions_called_;
 
   // Thread identifier as Linux kernel shows it. For debugging purposes.
   // LWP (light-weight process) is a unique ID of the thread in the system,
   // unlike pthread_self() which is the same for fork()-ed threads.
   pid_t lwp_;
   pthread_t pthread_self_;
 
   DISALLOW_COPY_AND_ASSIGN(CygTlsLog);
 };
 
 // Storage for logs for all threads in the process.
 // Using std::list may be better, but it fails when used before main().
 struct AllLogs {
   std::vector<CygTlsLog*> logs;
   base::Lock mutex;
 };
 
 base::LazyInstance<AllLogs>::Leaky all_logs_ = LAZY_INSTANCE_INITIALIZER;
 
 // Per-thread pointer to the current log object.
-__thread CygTlsLog* tls_current_log = NULL;
+static __thread CygTlsLog* tls_current_log = NULL;
 
 // Magic value of above to prevent the instrumentation. Used when CygTlsLog is
 // being constructed (to prevent reentering by malloc, for example) and by
 // the FlushLogThread (to prevent it being logged - see comment in its code).
 CygTlsLog* const kMagicBeingConstructed = reinterpret_cast<CygTlsLog*>(1);
 
 // Number of entries in the per-thread log buffer before we flush.
 // Note, that we also flush by timer so not all thread logs may grow up to this.
 const int CygTlsLog::kBufMaxSize = 3000;
 
 // "cyglog.PID.LWP.pthread_self.PPID"
+#if defined(OS_ANDROID)

[bulach, 2012/12/03 16:48:30]

maybe splitting this would be nicer:

#if defined(OS_ANDROID)
const char CytTlsLog::kLogFileNamePrefix =
"/data/local/tmp/chrome/cyglog/cyglog.";
#else
const char CytTlsLog::kLogFileNamePrefix = "/var/log/chrome/cyglog.";
#endif

const char CygTlsLog::kLogFilenameFmt[] = "%s%d.%d.%ld-%d"

this way if the format changes we'd need to change just one place.. wdyt?

[felipeg, 2012/12/03 16:56:44]

Done.

+const char CygTlsLog::kLogFilenameFmt[] =
+    "/data/local/tmp/chrome/cyglog/cyglog.%d.%d.%ld-%d";
+#else
 const char CygTlsLog::kLogFilenameFmt[] = "/var/log/chrome/cyglog.%d.%d.%ld-%d";
+#endif
 
 CygCommon* CygCommon::GetInstance() {
   return Singleton<CygCommon>::get();
 }
 
 CygCommon::CygCommon() {
   // Determine our module addresses.
   std::ifstream mapsfile("/proc/self/maps");
   CHECK(mapsfile.good());
   static const int kMaxLineSize = 512;
@@ skipping 96 matching lines @@
 void CygTlsLog::StartFlushLogThread() {
   pthread_t tid;
   CHECK(!pthread_create(&tid, NULL, &CygTlsLog::FlushLogThread, NULL));
 }
 
 void CygTlsLog::AddNewLog(CygTlsLog* newlog) {
   CHECK(tls_current_log == kMagicBeingConstructed);
   AllLogs& all_logs = all_logs_.Get();
   base::AutoLock lock(all_logs.mutex);
   if (all_logs.logs.empty()) {
+
+#if !defined(OS_ANDROID)

[glotov, 2012/12/03 16:42:17]

Could you please make a simple test that verifies that cygprofile still records
all routines in a simple multi-threaded program for OS_ANDROID.

[felipeg, 2012/12/03 16:56:44]

Done.

[glotov, 2012/12/03 17:10:08]

Well, actually it is up to you. Are you 100% sure that android does not use fork
(internally) for creating child processes? If so, please add the comment to your
#if.

Without these hooks child process will produce incorrect log (see comments for
AtForkChild), but you may not notice it at first sight. That's why I would
create a test. What do you think?

[felipeg, 2012/12/03 18:51:20]

I am 100% sure that we don't fork and we will never fork on chrome for android.
See the added comments.
Thanks for the heads up about this issue.

     CHECK(!pthread_atfork(CygTlsLog::AtForkPrepare,
                           CygTlsLog::AtForkParent,
                           CygTlsLog::AtForkChild));
+#endif
 
     // The very first process starts its flush thread here. Forked processes
     // will do it in AtForkChild().
     StartFlushLogThread();
   }
   all_logs.logs.push_back(newlog);
 }
 
 // Printf-style routine to write to open file.
 static void WriteLogLine(int fd, const char* fmt, ...) {
   va_list arg_ptr;
   va_start(arg_ptr, fmt);
   char msg[160];
   int len = vsnprintf(msg, sizeof(msg), fmt, arg_ptr);
   int rc = write(fd, msg, (len > sizeof(msg))? sizeof(msg): len);
   va_end(arg_ptr);
 };
 
 void CygTlsLog::FlushLog() {
   bool first_log_write = false;
-
   if (log_filename_.empty()) {
     first_log_write = true;
     char buf[80];
     snprintf(buf, sizeof(buf), kLogFilenameFmt,
              getpid(), lwp_, pthread_self_, getppid());
     log_filename_ = buf;
     unlink(log_filename_.c_str());
   }
 
   int file = open(log_filename_.c_str(), O_CREAT | O_WRONLY | O_APPEND, 00600);
@@ skipping 59 matching lines @@
     tls_current_log->LogEnter(this_fn);
   }
 }
 
 // Gcc Compiler callback, called after every function invocation providing
 // addresses of caller and callee codes.
 void __cyg_profile_func_exit(void* this_fn, void* call_site) {
 }
 
 }  // namespace cygprofile