Always search TIDs for the crashing processes.

base/linux_util.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.
 
 #include "base/linux_util.h"
 
 #include <dirent.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <glib.h>
@@ skipping 234 matching lines @@
         }
       }
     }
 
     closedir(fd);
   }
 
   return already_found;
 }
 
-pid_t FindThreadIDWithSyscall(pid_t pid, const std::string& expected_data) {
+pid_t FindThreadIDWithSyscall(pid_t pid, const std::string& expected_data,
+                              bool* syscall_supported) {
   char buf[256];
   snprintf(buf, sizeof(buf), "/proc/%d/task", pid);
   DIR* task = opendir(buf);
   if (!task) {
     LOG(WARNING) << "Cannot open " << buf;
     return -1;
   }
 
   std::vector<pid_t> tids;
   struct dirent* dent;
   while ((dent = readdir(task))) {
     char *endptr;
     const unsigned long int tid_ul = strtoul(dent->d_name, &endptr, 10);
     if (tid_ul == ULONG_MAX || *endptr)
       continue;
     tids.push_back(tid_ul);
   }
   closedir(task);
 
   scoped_array<char> syscall_data(new char[expected_data.length()]);
+  *syscall_supported = false;

[Mark Mentovai, 2011/06/21 00:11:24]

Can you do this at the very beginning of the function so that it’s always set
regardless of whether this function returns early? Right now, there’s one
early-return (-1) above where it won’t be set, and a return -1 below with this
already set.

[kmixter1, 2011/06/21 00:55:33]

Good catch.  Moved it up so that it's always set to something on all return
paths.  It's ok for the result to be -1 and *syscall_supported==true.  This
means we know for certain that no thread for this pid was running the expected
syscall (compared to -1 and *syscall_supported==false) when we just don't know.

   for (std::vector<pid_t>::const_iterator
        i = tids.begin(); i != tids.end(); ++i) {
     const pid_t current_tid = *i;
     snprintf(buf, sizeof(buf), "/proc/%d/task/%d/syscall", pid, current_tid);
     int fd = open(buf, O_RDONLY);
     if (fd < 0)
       continue;
+    *syscall_supported = true;
     bool read_ret =
         file_util::ReadFromFD(fd, syscall_data.get(), expected_data.length());
     close(fd);
     if (!read_ret)
       continue;
 
     if (0 == strncmp(expected_data.c_str(), syscall_data.get(),
                      expected_data.length())) {
       return current_tid;
     }
   }
   return -1;
 }
 
 }  // namespace base