crash-reporter: Use standard logging and new libchromeos Process code

crash_reporter.cc

 // Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <fcntl.h>  // for open
+
 #include <string>
 
 #include "base/file_util.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/string_util.h"
+#include "chromeos/syslog_logging.h"
 #include "crash-reporter/kernel_collector.h"
-#include "crash-reporter/system_logging.h"
 #include "crash-reporter/unclean_shutdown_collector.h"
 #include "crash-reporter/user_collector.h"
 #include "gflags/gflags.h"
 #include "metrics/metrics_library.h"
 
 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
 DEFINE_bool(init, false, "Initialize crash logging");
 DEFINE_bool(clean_shutdown, false, "Signal clean shutdown");
 DEFINE_string(generate_kernel_signature, "",
               "Generate signature from given kcrash file");
@@ skipping 11 matching lines @@
 
 // Enumeration of kinds of crashes to be used in the CrashCounter histogram.
 enum CrashKinds {
   kCrashKindUncleanShutdown = 1,
   kCrashKindUser = 2,
   kCrashKindKernel = 3,
   kCrashKindMax
 };
 
 static MetricsLibrary s_metrics_lib;
-static SystemLoggingImpl s_system_log;
 
 static bool IsFeedbackAllowed() {
   return s_metrics_lib.AreMetricsEnabled();
 }
 
 static bool TouchFile(const FilePath &file_path) {
   return file_util::WriteFile(file_path, "", 0) == 0;
 }
 
 static void CountKernelCrash() {
@@ skipping 34 matching lines @@
   // better way to do this that doesn't rely on D-Bus.
   //
   // We run in the background in case dbus daemon itself is crashed
   // and not responding.  This allows us to not block and potentially
   // deadlock on a dbus-daemon crash.  If dbus-daemon crashes without
   // restarting, each crash will fork off a lot of dbus-send
   // processes.  Such a system is in a unusable state and will need
   // to be restarted anyway.
 
   int status = system(command.c_str());
-  if (status != 0) {
-    s_system_log.LogWarning("dbus-send running failed");
-  }
+  LOG_IF(WARNING, status != 0) << "dbus-send running failed";
 }
 
 static int Initialize(KernelCollector *kernel_collector,
                       UserCollector *user_collector,
                       UncleanShutdownCollector *unclean_shutdown_collector) {
   CHECK(!FLAGS_clean_shutdown) << "Incompatible options";
 
   bool was_kernel_crash = false;
   bool was_unclean_shutdown = false;
   kernel_collector->Enable();
@@ skipping 30 matching lines @@
   CHECK(!FLAGS_user.empty()) << "--user= must be set";
 
   // Make it possible to test what happens when we crash while
   // handling a crash.
   if (FLAGS_crash_test) {
     *(char *)0 = 0;
     return 0;
   }
 
   // Accumulate logs to help in diagnosing failures during user collection.
-  s_system_log.set_accumulating(true);
+  chromeos::LogToString(true);
   // Handle the crash, get the name of the process from procfs.
   bool handled = user_collector->HandleCrash(FLAGS_user, NULL);
-  s_system_log.set_accumulating(false);
+  chromeos::LogToString(false);
   if (!handled)
     return 1;
   return 0;
 }
 
 // Interactive/diagnostics mode for generating kernel crash signatures.
 static int GenerateKernelSignature(KernelCollector *kernel_collector) {
   std::string kcrash_contents;
   std::string signature;
   if (!file_util::ReadFileToString(FilePath(FLAGS_generate_kernel_signature),
                                    &kcrash_contents)) {
     fprintf(stderr, "Could not read file.\n");
     return 1;
   }
   if (!kernel_collector->ComputeKernelStackSignature(
           kcrash_contents,
           &signature,
           true)) {
     fprintf(stderr, "Signature could not be generated.\n");
     return 1;
   }
   printf("Kernel crash signature is \"%s\".\n", signature.c_str());
   return 0;
 }
 
+// Ensure stdout, stdin, and stderr are open file descriptors.  If
+// they are not, any code which writes to stderr/stdout may write out
+// to files opened during execution.  In particular, when
+// crash_reporter is run by the kernel coredump pipe handler (via
+// kthread_create/kernel_execve), it will not have file table entries
+// 1 and 2 (stdout and stderr).
+static void OpenStandardFileDescriptors() {
+  int new_fd = -1;
+  do {
+    new_fd = open("/dev/null", 0);
+    CHECK(new_fd >= 0) << "Unable to open /dev/null";
+  } while (new_fd >= 0 && new_fd <= 2);
+  close(new_fd);

[petkov, 2011/03/02 17:53:20]

how does this work? don't you need to close inside the loop? otherwise, you'd
open /dev/null 4 times and exit from the loop even if stderr/stdout are not
open...

and then -- really, how does this work? isn't there a race between you opening
/dev/null and ... then kernel opening stdout? maybe clarify in the comments.

[kmixter1, 2011/03/02 19:08:58]

Does the comment make sense now?

+}
+
 int main(int argc, char *argv[]) {
+  OpenStandardFileDescriptors();
   google::ParseCommandLineFlags(&argc, &argv, true);
   FilePath my_path(argv[0]);
   file_util::AbsolutePath(&my_path);
   s_metrics_lib.Init();
   CommandLine::Init(argc, argv);
-  logging::InitLogging(NULL,
-                       logging::LOG_ONLY_TO_SYSTEM_DEBUG_LOG,
-                       logging::DONT_LOCK_LOG_FILE,
-                       logging::DELETE_OLD_LOG_FILE);
-  s_system_log.Initialize(my_path.BaseName().value().c_str());
+  chromeos::OpenLog(my_path.BaseName().value().c_str(), true);
+  chromeos::InitLog(chromeos::kLogToSyslog);
   KernelCollector kernel_collector;
   kernel_collector.Initialize(CountKernelCrash,
-                              IsFeedbackAllowed,
-                              &s_system_log);
+                              IsFeedbackAllowed);
   UserCollector user_collector;
   user_collector.Initialize(CountUserCrash,
                             my_path.value(),
                             IsFeedbackAllowed,
-                            &s_system_log,
                             true);  // generate_diagnostics
   UncleanShutdownCollector unclean_shutdown_collector;
   unclean_shutdown_collector.Initialize(CountUncleanShutdown,
-                                        IsFeedbackAllowed,
-                                        &s_system_log);
+                                        IsFeedbackAllowed);
 
   if (FLAGS_init) {
     return Initialize(&kernel_collector,
                       &user_collector,
                       &unclean_shutdown_collector);
   }
 
   if (FLAGS_clean_shutdown) {
     unclean_shutdown_collector.Disable();
     user_collector.Disable();
     return 0;
   }
 
   if (!FLAGS_generate_kernel_signature.empty()) {
     return GenerateKernelSignature(&kernel_collector);
   }
 
   return HandleUserCrash(&user_collector);
 }