crash-reporter: when exe symlink read fails send diags and still ignore chrome crashes

user_collector.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 "crash-reporter/user_collector.h"
 
 #include <grp.h>  // For struct group.
 #include <pcrecpp.h>
 #include <pcrecpp.h>
 #include <pwd.h>  // For struct passwd.
@@ skipping 96 matching lines @@
 }
 
 bool UserCollector::GetSymlinkTarget(const FilePath &symlink,
                                      FilePath *target) {
   int max_size = 32;
   scoped_array<char> buffer;
   while (true) {
     buffer.reset(new char[max_size + 1]);
     ssize_t size = readlink(symlink.value().c_str(), buffer.get(), max_size);
     if (size < 0) {
+      int saved_errno = errno;
+      logger_->LogError("Readlink failed on %s with %d",
+                        symlink.value().c_str(), saved_errno);
       return false;
     }
     buffer[size] = 0;
     if (size == max_size) {
       // Avoid overflow when doubling.
       if (max_size * 2 > max_size) {
         max_size *= 2;
         continue;
       } else {
         return false;
       }
     }
     break;
   }
 
   *target = FilePath(buffer.get());
   return true;
 }
 
 bool UserCollector::GetExecutableBaseNameFromPid(uid_t pid,
                                                  std::string *base_name) {
   FilePath target;
-  if (!GetSymlinkTarget(GetProcessPath(pid).Append("exe"), &target))
+  FilePath process_path = GetProcessPath(pid);
+  FilePath exe_path = process_path.Append("exe");
+  if (!GetSymlinkTarget(exe_path, &target)) {
+    logger_->LogInfo("GetSymlinkTarget failed - Path %s DirectoryExists: %d",
+                     process_path.value().c_str(),
+                     file_util::DirectoryExists(process_path));
+    // Try to further diagnose exe readlink failure cause.
+    struct stat buf;
+    int stat_result = stat(exe_path.value().c_str(), &buf);
+    int saved_errno = errno;
+    if (stat_result < 0) {
+      logger_->LogInfo("stat %s failed: %d %d", exe_path.value().c_str(),
+                       stat_result, saved_errno);
+    } else {
+      logger_->LogInfo("stat %s succeeded: st_mode=%d",
+                       exe_path.value().c_str(), buf.st_mode);
+    }
     return false;
+  }
   *base_name = target.BaseName().value();
   return true;
 }
 
 bool UserCollector::GetIdFromStatus(const char *prefix,
                                     IdKind kind,
                                     const std::string &status_contents,
                                     int *id) {
   // From fs/proc/array.c:task_state(), this file contains:
   // \nUid:\t<uid>\t<euid>\t<suid>\t<fsuid>\n
@@ skipping 89 matching lines @@
                                              bool *out_of_capacity) {
   FilePath process_path = GetProcessPath(pid);
   std::string status;
   if (FLAGS_directory_failure) {
     logger_->LogError("Purposefully failing to create spool directory");
     return false;
   }
   if (!file_util::ReadFileToString(process_path.Append("status"),
                                    &status)) {
     logger_->LogError("Could not read status file");
-    logger_->LogInfo("Path %s FileExists: %d",
+    logger_->LogInfo("Path %s DirectoryExists: %d",
                      process_path.value().c_str(),
                      file_util::DirectoryExists(process_path));
     return false;
   }
   int process_euid;
   if (!GetIdFromStatus(kUserId, kIdEffective, status, &process_euid)) {
     logger_->LogError("Could not find euid in status file");
     return false;
   }
   if (!GetCreatedCrashDirectoryByEuid(process_euid,
@@ skipping 176 matching lines @@
 
   bool feedback = is_feedback_allowed_function_();
   const char *handling_string = "handling";
   if (!feedback) {
     handling_string = "ignoring - no consent";
   }
 
   // Treat Chrome crashes as if the user opted-out.  We stop counting Chrome
   // crashes towards user crashes, so user crashes really mean non-Chrome
   // user-space crashes.
-  if (exec == "chrome") {
+  if (exec == "chrome" || exec == "supplied_chrome") {
     feedback = false;
     handling_string = "ignoring - chrome crash";
   }
 
   logger_->LogWarning("Received crash notification for %s[%d] sig %d (%s)",
                       exec.c_str(), pid, signal, handling_string);
 
   if (feedback) {
     count_crash_function_();
 
     if (generate_diagnostics_) {
       bool out_of_capacity = false;
-      logger_->set_accumulating(true);
       bool convert_and_enqueue_result =
           ConvertAndEnqueueCrash(pid, exec, &out_of_capacity);
-      logger_->set_accumulating(false);
       if (!convert_and_enqueue_result) {
         if (!out_of_capacity)
           EnqueueCollectionErrorLog(pid, exec);
         return false;
       }
     }
   }
 
   return true;
 }