crash_reporter/crash_reporter.cc

   1 /*
   2  * Copyright (C) 2012 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <fcntl.h>  // for open
  18
  19 #include <string>
  20 #include <vector>
  21
  22 #include <base/files/file_util.h>
  23 #include <base/guid.h>
  24 #include <base/logging.h>
  25 #include <base/strings/string_split.h>
  26 #include <base/strings/string_util.h>
  27 #include <base/strings/stringprintf.h>
  28 #include <binder/IServiceManager.h>
  29 #include <brillo/flag_helper.h>
  30 #include <brillo/syslog_logging.h>
  31 #include <metrics/metrics_collector_service_client.h>
  32 #include <metrics/metrics_library.h>
  33 #include <utils/String16.h>
  34
  35
  36 #include "kernel_collector.h"
  37 #include "kernel_warning_collector.h"
  38 #include "unclean_shutdown_collector.h"
  39 #include "user_collector.h"
  40
  41 #if !defined(__ANDROID__)
  42 #include "udev_collector.h"
  43 #endif
  44
  45 static const char kCrashCounterHistogram[] = "Logging.CrashCounter";
  46 static const char kKernelCrashDetected[] =
  47     "/data/misc/crash_reporter/run/kernel-crash-detected";
  48 static const char kUncleanShutdownDetected[] =
  49     "/var/run/unclean-shutdown-detected";
  50 static const char kGUIDFileName[] = "/data/misc/crash_reporter/guid";
  51
  52 // Enumeration of kinds of crashes to be used in the CrashCounter histogram.
  53 enum CrashKinds {
  54   kCrashKindUncleanShutdown = 1,
  55   kCrashKindUser = 2,
  56   kCrashKindKernel = 3,
  57   kCrashKindUdev = 4,
  58   kCrashKindKernelWarning = 5,
  59   kCrashKindMax
  60 };
  61
  62 static MetricsLibrary s_metrics_lib;
  63
  64 using android::brillo::metrics::IMetricsCollectorService;
  65 using base::FilePath;
  66 using base::StringPrintf;
  67
  68 static bool IsFeedbackAllowed() {
  69   return s_metrics_lib.AreMetricsEnabled();
  70 }
  71
  72 static bool TouchFile(const FilePath &file_path) {
  73   return base::WriteFile(file_path, "", 0) == 0;
  74 }
  75
  76 static void SendCrashMetrics(CrashKinds type, const char* name) {
  77   // TODO(kmixter): We can remove this histogram as part of
  78   // crosbug.com/11163.
  79   s_metrics_lib.SendEnumToUMA(kCrashCounterHistogram, type, kCrashKindMax);
  80   s_metrics_lib.SendCrashToUMA(name);
  81 }
  82
  83 static void CountKernelCrash() {
  84   SendCrashMetrics(kCrashKindKernel, "kernel");
  85 }
  86
  87 static void CountUdevCrash() {
  88   SendCrashMetrics(kCrashKindUdev, "udevcrash");
  89 }
  90
  91 static void CountUncleanShutdown() {
  92   SendCrashMetrics(kCrashKindUncleanShutdown, "uncleanshutdown");
  93 }
  94
  95 static void CountUserCrash() {
  96   SendCrashMetrics(kCrashKindUser, "user");
  97   // Tell the metrics collector about the user crash, in order to log active
  98   // use time between crashes.
  99   MetricsCollectorServiceClient metrics_collector_service;
 100
 101   if (metrics_collector_service.Init())
 102     metrics_collector_service.notifyUserCrash();
 103   else
 104     LOG(ERROR) << "Failed to send user crash notification to metrics_collector";
 105 }
 106
 107
 108 static int Initialize(KernelCollector *kernel_collector,
 109                       UserCollector *user_collector,
 110                       UncleanShutdownCollector *unclean_shutdown_collector,
 111                       const bool unclean_check,
 112                       const bool clean_shutdown) {
 113   CHECK(!clean_shutdown) << "Incompatible options";
 114
 115   // Try to read the GUID from kGUIDFileName.  If the file doesn't exist, is
 116   // blank, or the read fails, generate a new GUID and write it to the file.
 117   std::string guid;
 118   base::FilePath filepath(kGUIDFileName);
 119   if (!base::ReadFileToString(filepath, &guid) || guid.empty()) {
 120     guid = base::GenerateGUID();
 121     // If we can't read or write the file, log an error.  However it is not
 122     // a fatal error, as the crash server will assign a random GUID based
 123     // on a hash of the IP address if one is not provided in the report.
 124     if (base::WriteFile(filepath, guid.c_str(), guid.size()) <= 0) {
 125       LOG(ERROR) << "Could not write guid " << guid << " to file "
 126                  << filepath.value();
 127     }
 128   }
 129
 130   bool was_kernel_crash = false;
 131   bool was_unclean_shutdown = false;
 132   kernel_collector->Enable();
 133   if (kernel_collector->is_enabled()) {
 134     was_kernel_crash = kernel_collector->Collect();
 135   }
 136
 137   if (unclean_check) {
 138     was_unclean_shutdown = unclean_shutdown_collector->Collect();
 139   }
 140
 141   // Touch a file to notify the metrics daemon that a kernel
 142   // crash has been detected so that it can log the time since
 143   // the last kernel crash.
 144   if (IsFeedbackAllowed()) {
 145     if (was_kernel_crash) {
 146       TouchFile(FilePath(kKernelCrashDetected));
 147     } else if (was_unclean_shutdown) {
 148       // We only count an unclean shutdown if it did not come with
 149       // an associated kernel crash.
 150       TouchFile(FilePath(kUncleanShutdownDetected));
 151     }
 152   }
 153
 154   // Must enable the unclean shutdown collector *after* collecting.
 155   unclean_shutdown_collector->Enable();
 156   user_collector->Enable();
 157
 158   return 0;
 159 }
 160
 161 static int HandleUserCrash(UserCollector *user_collector,
 162                            const std::string& user, const bool crash_test) {
 163   // Handle a specific user space crash.
 164   CHECK(!user.empty()) << "--user= must be set";
 165
 166   // Make it possible to test what happens when we crash while
 167   // handling a crash.
 168   if (crash_test) {
 169     *(volatile char *)0 = 0;
 170     return 0;
 171   }
 172
 173   // Accumulate logs to help in diagnosing failures during user collection.
 174   brillo::LogToString(true);
 175   // Handle the crash, get the name of the process from procfs.
 176   bool handled = user_collector->HandleCrash(user, nullptr);
 177   brillo::LogToString(false);
 178   if (!handled)
 179     return 1;
 180   return 0;
 181 }
 182
 183 #if !defined(__ANDROID__)
 184 static int HandleUdevCrash(UdevCollector *udev_collector,
 185                            const std::string& udev_event) {
 186   // Handle a crash indicated by a udev event.
 187   CHECK(!udev_event.empty()) << "--udev= must be set";
 188
 189   // Accumulate logs to help in diagnosing failures during user collection.
 190   brillo::LogToString(true);
 191   bool handled = udev_collector->HandleCrash(udev_event);
 192   brillo::LogToString(false);
 193   if (!handled)
 194     return 1;
 195   return 0;
 196 }
 197 #endif
 198
 199 static int HandleKernelWarning(KernelWarningCollector
 200                                *kernel_warning_collector) {
 201   // Accumulate logs to help in diagnosing failures during collection.
 202   brillo::LogToString(true);
 203   bool handled = kernel_warning_collector->Collect();
 204   brillo::LogToString(false);
 205   if (!handled)
 206     return 1;
 207   return 0;
 208 }
 209
 210 // Interactive/diagnostics mode for generating kernel crash signatures.
 211 static int GenerateKernelSignature(KernelCollector *kernel_collector,
 212                                    const std::string& kernel_signature_file) {
 213   std::string kcrash_contents;
 214   std::string signature;
 215   if (!base::ReadFileToString(FilePath(kernel_signature_file),
 216                               &kcrash_contents)) {
 217     fprintf(stderr, "Could not read file.\n");
 218     return 1;
 219   }
 220   if (!kernel_collector->ComputeKernelStackSignature(
 221           kcrash_contents,
 222           &signature,
 223           true)) {
 224     fprintf(stderr, "Signature could not be generated.\n");
 225     return 1;
 226   }
 227   printf("Kernel crash signature is \"%s\".\n", signature.c_str());
 228   return 0;
 229 }
 230
 231 // Ensure stdout, stdin, and stderr are open file descriptors.  If
 232 // they are not, any code which writes to stderr/stdout may write out
 233 // to files opened during execution.  In particular, when
 234 // crash_reporter is run by the kernel coredump pipe handler (via
 235 // kthread_create/kernel_execve), it will not have file table entries
 236 // 1 and 2 (stdout and stderr) populated.  We populate them here.
 237 static void OpenStandardFileDescriptors() {
 238   int new_fd = -1;
 239   // We open /dev/null to fill in any of the standard [0, 2] file
 240   // descriptors.  We leave these open for the duration of the
 241   // process.  This works because open returns the lowest numbered
 242   // invalid fd.
 243   do {
 244     new_fd = open("/dev/null", 0);
 245     CHECK_GE(new_fd, 0) << "Unable to open /dev/null";
 246   } while (new_fd >= 0 && new_fd <= 2);
 247   close(new_fd);
 248 }
 249
 250 int main(int argc, char *argv[]) {
 251   DEFINE_bool(init, false, "Initialize crash logging");
 252   DEFINE_bool(clean_shutdown, false, "Signal clean shutdown");
 253   DEFINE_string(generate_kernel_signature, "",
 254                 "Generate signature from given kcrash file");
 255   DEFINE_bool(crash_test, false, "Crash test");
 256   DEFINE_string(user, "", "User crash info (pid:signal:exec_name)");
 257   DEFINE_bool(unclean_check, true, "Check for unclean shutdown");
 258
 259 #if !defined(__ANDROID__)
 260   DEFINE_string(udev, "", "Udev event description (type:device:subsystem)");
 261 #endif
 262
 263   DEFINE_bool(kernel_warning, false, "Report collected kernel warning");
 264   DEFINE_string(pid, "", "PID of crashing process");
 265   DEFINE_string(uid, "", "UID of crashing process");
 266   DEFINE_string(exe, "", "Executable name of crashing process");
 267   DEFINE_bool(core2md_failure, false, "Core2md failure test");
 268   DEFINE_bool(directory_failure, false, "Spool directory failure test");
 269   DEFINE_string(filter_in, "",
 270                 "Ignore all crashes but this for testing");
 271
 272   OpenStandardFileDescriptors();
 273   FilePath my_path = base::MakeAbsoluteFilePath(FilePath(argv[0]));
 274   s_metrics_lib.Init();
 275   brillo::FlagHelper::Init(argc, argv, "Chromium OS Crash Reporter");
 276   brillo::OpenLog(my_path.BaseName().value().c_str(), true);
 277   brillo::InitLog(brillo::kLogToSyslog);
 278
 279   KernelCollector kernel_collector;
 280   kernel_collector.Initialize(CountKernelCrash, IsFeedbackAllowed);
 281   UserCollector user_collector;
 282   user_collector.Initialize(CountUserCrash,
 283                             my_path.value(),
 284                             IsFeedbackAllowed,
 285                             true,  // generate_diagnostics
 286                             FLAGS_core2md_failure,
 287                             FLAGS_directory_failure,
 288                             FLAGS_filter_in);
 289   UncleanShutdownCollector unclean_shutdown_collector;
 290   unclean_shutdown_collector.Initialize(CountUncleanShutdown,
 291                                         IsFeedbackAllowed);
 292
 293 #if !defined(__ANDROID__)
 294   UdevCollector udev_collector;
 295   udev_collector.Initialize(CountUdevCrash, IsFeedbackAllowed);
 296 #endif
 297
 298   KernelWarningCollector kernel_warning_collector;
 299   kernel_warning_collector.Initialize(CountUdevCrash, IsFeedbackAllowed);
 300
 301   if (FLAGS_init) {
 302     return Initialize(&kernel_collector,
 303                       &user_collector,
 304                       &unclean_shutdown_collector,
 305                       FLAGS_unclean_check,
 306                       FLAGS_clean_shutdown);
 307   }
 308
 309   if (FLAGS_clean_shutdown) {
 310     unclean_shutdown_collector.Disable();
 311     user_collector.Disable();
 312     return 0;
 313   }
 314
 315   if (!FLAGS_generate_kernel_signature.empty()) {
 316     return GenerateKernelSignature(&kernel_collector,
 317                                    FLAGS_generate_kernel_signature);
 318   }
 319
 320 #if !defined(__ANDROID__)
 321   if (!FLAGS_udev.empty()) {
 322     return HandleUdevCrash(&udev_collector, FLAGS_udev);
 323   }
 324 #endif
 325
 326   if (FLAGS_kernel_warning) {
 327     return HandleKernelWarning(&kernel_warning_collector);
 328   }
 329
 330   return HandleUserCrash(&user_collector, FLAGS_user, FLAGS_crash_test);
 331 }