Android: Workaround for ftruncate() issues.

src/client/minidump_file_writer.cc

 // Copyright (c) 2006, Google Inc.
 // All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
@@ skipping 26 matching lines @@
 #include <string.h>
 #include <unistd.h>
 
 #include "client/minidump_file_writer-inl.h"
 #include "common/linux/linux_libc_support.h"
 #include "common/string_conversion.h"
 #if defined(__linux__) && __linux__
 #include "third_party/lss/linux_syscall_support.h"
 #endif
 
+#if defined(__ANDROID__)
+#include <errno.h>
+
+namespace {
+
+bool g_need_ftruncate_workaround = false;
+bool g_checked_need_ftruncate_workaround = false;
+
+void CheckNeedsFTruncateWorkAround(int file) {
+  if (g_checked_need_ftruncate_workaround) {
+    return;
+  }
+  g_checked_need_ftruncate_workaround = true;
+
+  // Attempt an idempotent truncate that chops off nothing and see if we
+  // run into any sort of errors.
+  off_t offset = sys_lseek(file, 0, SEEK_END);
+  if (offset == -1) {
+    // lseek failed. Don't apply work around. It's unlikely that we can write
+    // to a minidump with either method.
+    return;
+  }
+
+  int result = ftruncate(file, offset);
+  if (result == -1 && errno == EACCES) {
+    // It very likely that we are running into the kernel bug in M devices.
+    // We are going to deploy the workaround for writing minidump files
+    // without uses of ftruncate(). This workaround should be fine even
+    // for kernels without the bug.
+    // See http://crbug.com/542840 for more details.
+    g_need_ftruncate_workaround = true;
+  }
+}
+
+bool NeedsFTruncateWorkAround() {
+  return g_need_ftruncate_workaround;
+}
+
+}  // namespace
+#endif  // defined(__ANDROID__)
+
 namespace google_breakpad {
 
 const MDRVA MinidumpFileWriter::kInvalidMDRVA = static_cast<MDRVA>(-1);
 
 MinidumpFileWriter::MinidumpFileWriter()
     : file_(-1),
       close_file_when_destroyed_(true),
       position_(0),
       size_(0) {
 }
@@ skipping 11 matching lines @@
   file_ = open(path, O_WRONLY | O_CREAT | O_EXCL, 0600);
 #endif
 
   return file_ != -1;
 }
 
 void MinidumpFileWriter::SetFile(const int file) {
   assert(file_ == -1);
   file_ = file;
   close_file_when_destroyed_ = false;
+#if defined(__ANDROID__)
+  CheckNeedsFTruncateWorkAround(file);
+#endif
 }
 
 bool MinidumpFileWriter::Close() {
   bool result = true;
 
   if (file_ != -1) {
-    if (-1 == ftruncate(file_, position_)) {
+#if defined(__ANDROID__)
+    if (!NeedsFTruncateWorkAround() && ftruncate(file_, position_)) {
        return false;
     }
+#else
+    if (ftruncate(file_, position_)) {
+       return false;
+    }
+#endif
 #if defined(__linux__) && __linux__
     result = (sys_close(file_) == 0);
 #else
     result = (close(file_) == 0);
 #endif
     file_ = -1;
   }
 
   return result;
 }
@@ skipping 116 matching lines @@
 
   output->start_of_memory_range = reinterpret_cast<uint64_t>(src);
   output->memory = mem.location();
 
   return true;
 }
 
 MDRVA MinidumpFileWriter::Allocate(size_t size) {
   assert(size);
   assert(file_ != -1);
+#if defined(__ANDROID__)
+  if (NeedsFTruncateWorkAround()) {
+    // If ftruncate() is not available. We simply increase the size beyond the
+    // current file size. sys_write() will expand the file when data is written
+    // to it. Because we did not over allocate to fit memory pages, we also
+    // do not need to ftruncate() the file once we are done.
+    size_ += size;
+
+    // We don't need to seek since the file is unchanged.
+    MDRVA current_position = position_;
+    position_ += static_cast<MDRVA>(size);
+    return current_position;
+  }
+#endif
   size_t aligned_size = (size + 7) & ~7;  // 64-bit alignment
 
   if (position_ + aligned_size > size_) {
     size_t growth = aligned_size;
     size_t minimal_growth = getpagesize();
 
     // Ensure that the file grows by at least the size of a memory page
     if (growth < minimal_growth)
       growth = minimal_growth;
 
@@ skipping 16 matching lines @@
   assert(file_ != -1);
 
   // Ensure that the data will fit in the allocated space
   if (static_cast<size_t>(size + position) > size_)
     return false;
 
   // Seek and write the data
 #if defined(__linux__) && __linux__
   if (sys_lseek(file_, position, SEEK_SET) == static_cast<off_t>(position)) {
     if (sys_write(file_, src, size) == size) {
+      return true;
+    }
+  }
 #else
   if (lseek(file_, position, SEEK_SET) == static_cast<off_t>(position)) {
     if (write(file_, src, size) == size) {
-#endif
       return true;
     }
   }
-
+#endif
   return false;
 }
 
 bool UntypedMDRVA::Allocate(size_t size) {
   assert(size_ == 0);
   size_ = size;
   position_ = writer_->Allocate(size_);
   return position_ != MinidumpFileWriter::kInvalidMDRVA;
 }
 
 bool UntypedMDRVA::Copy(MDRVA pos, const void *src, size_t size) {
   assert(src);
   assert(size);
   assert(pos + size <= position_ + size_);
   return writer_->Copy(pos, src, size);
 }
 
 }  // namespace google_breakpad