Don’t log an error when creating a new crash report database

client/settings.cc

 // Copyright 2015 The Crashpad Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 53 matching lines @@
 
 Settings::Settings(const base::FilePath& file_path)
     : file_path_(file_path),
       initialized_() {
 }
 
 Settings::~Settings() {
 }
 
 bool Settings::Initialize() {
-  INITIALIZATION_STATE_SET_INITIALIZING(initialized_);
+  initialized_.set_invalid();
 
   Data settings;
   if (!OpenForWritingAndReadSettings(&settings).is_valid())
     return false;
 
-  INITIALIZATION_STATE_SET_VALID(initialized_);
+  initialized_.set_valid();
   return true;
 }
 
 bool Settings::GetClientID(UUID* client_id) {
-  INITIALIZATION_STATE_DCHECK_VALID(initialized_);
+  DCHECK(initialized_.is_valid());
 
   Data settings;
   if (!OpenAndReadSettings(&settings))
     return false;
 
   *client_id = settings.client_id;
   return true;
 }
 
 bool Settings::GetUploadsEnabled(bool* enabled) {
-  INITIALIZATION_STATE_DCHECK_VALID(initialized_);
+  DCHECK(initialized_.is_valid());
 
   Data settings;
   if (!OpenAndReadSettings(&settings))
     return false;
 
   *enabled = (settings.options & Data::Options::kUploadsEnabled) != 0;
   return true;
 }
 
 bool Settings::SetUploadsEnabled(bool enabled) {
-  INITIALIZATION_STATE_DCHECK_VALID(initialized_);
+  DCHECK(initialized_.is_valid());
 
   Data settings;
   ScopedLockedFileHandle handle = OpenForWritingAndReadSettings(&settings);
   if (!handle.is_valid())
     return false;
 
   if (enabled)
     settings.options |= Data::Options::kUploadsEnabled;
   else
     settings.options &= ~Data::Options::kUploadsEnabled;
 
   return WriteSettings(handle.get(), settings);
 }
 
 bool Settings::GetLastUploadAttemptTime(time_t* time) {
-  INITIALIZATION_STATE_DCHECK_VALID(initialized_);
+  DCHECK(initialized_.is_valid());
 
   Data settings;
   if (!OpenAndReadSettings(&settings))
     return false;
 
   *time = InRangeCast<time_t>(settings.last_upload_attempt_time,
                               std::numeric_limits<time_t>::max());
   return true;
 }
 
 bool Settings::SetLastUploadAttemptTime(time_t time) {
-  INITIALIZATION_STATE_DCHECK_VALID(initialized_);
+  DCHECK(initialized_.is_valid());
 
   Data settings;
   ScopedLockedFileHandle handle = OpenForWritingAndReadSettings(&settings);
   if (!handle.is_valid())
     return false;
 
   settings.last_upload_attempt_time = InRangeCast<uint64_t>(time, 0);
 
   return WriteSettings(handle.get(), settings);
 }
 
 // static
 Settings::ScopedLockedFileHandle Settings::MakeScopedLockedFileHandle(
     FileHandle file,
     FileLocking locking) {
   ScopedFileHandle scoped(file);
   if (scoped.is_valid()) {
     if (!LoggingLockFile(scoped.get(), locking))
       scoped.reset();
   }
   return ScopedLockedFileHandle(scoped.release());
 }
 
 Settings::ScopedLockedFileHandle Settings::OpenForReading() {
   return MakeScopedLockedFileHandle(LoggingOpenFileForRead(file_path()),
                                     FileLocking::kShared);
 }
 
-Settings::ScopedLockedFileHandle Settings::OpenForReadingAndWriting() {
-  return MakeScopedLockedFileHandle(
-      LoggingOpenFileForReadAndWrite(file_path(),
-                                     FileWriteMode::kReuseOrCreate,
-                                     FilePermissions::kWorldReadable),
-      FileLocking::kExclusive);
+Settings::ScopedLockedFileHandle Settings::OpenForReadingAndWriting(
+    FileWriteMode mode, bool log_open_error) {
+  DCHECK(mode != FileWriteMode::kTruncateOrCreate);
+
+  FileHandle handle;
+  if (log_open_error) {
+    handle = LoggingOpenFileForReadAndWrite(
+        file_path(), mode, FilePermissions::kWorldReadable);
+  } else {
+    handle = OpenFileForReadAndWrite(
+        file_path(), mode, FilePermissions::kWorldReadable);
+  }
+
+  return MakeScopedLockedFileHandle(handle, FileLocking::kExclusive);
 }
 
 bool Settings::OpenAndReadSettings(Data* out_data) {
   ScopedLockedFileHandle handle = OpenForReading();
   if (!handle.is_valid())
     return false;
 
-  if (ReadSettings(handle.get(), out_data))
+  if (ReadSettings(handle.get(), out_data, true))
     return true;
 
   // The settings file is corrupt, so reinitialize it.
   handle.reset();
 
   // The settings failed to be read, so re-initialize them.
   return RecoverSettings(kInvalidFileHandle, out_data);
 }
 
 Settings::ScopedLockedFileHandle Settings::OpenForWritingAndReadSettings(
     Data* out_data) {
-  ScopedLockedFileHandle handle = OpenForReadingAndWriting();
+  ScopedLockedFileHandle handle;
+  bool created = false;
+  if (!initialized_.is_valid()) {
+    // If this object is initializing, it hasn’t seen a settings file already,
+    // so go easy on errors. Creating a new settings file for the first time
+    // shouldn’t spew log messages.
+    //
+    // First, try to use an existing settings file.
+    handle = OpenForReadingAndWriting(FileWriteMode::kReuseOrFail, false);
+
+    if (!handle.is_valid()) {
+      // Create a new settings file if it didn’t already exist.
+      handle = OpenForReadingAndWriting(FileWriteMode::kCreateOrFail, false);
+
+      if (handle.is_valid()) {
+        created = true;
+      }
+
+      // There may have been a race to create the file, and something else may
+      // have won. There will be one more attempt to try to open or create the
+      // file below.
+    }
+  }
+
+  if (!handle.is_valid()) {
+    // Either the object is initialized, meaning it’s already seen a valid
+    // settings file, or the object is initializing and none of the above
+    // attempts to create the settings file succeeded. Either way, this is the
+    // last chance for success, so if this fails, log a message.
+    handle = OpenForReadingAndWriting(FileWriteMode::kReuseOrCreate, true);
+  }
+
   if (!handle.is_valid())
     return ScopedLockedFileHandle();
 
-  if (!ReadSettings(handle.get(), out_data)) {
+  // Attempt reading the settings even if the file is known to have just been
+  // created. The file-create and file-lock operations don’t occur atomically,
+  // and something else may have written the settings before this invocation
+  // took the lock. If the settings file was definitely just created, though,
+  // don’t log any read errors. The expected non-race behavior in this case is a
+  // zero-length read, with ReadSettings() failing.
+  if (!ReadSettings(handle.get(), out_data, !created)) {
     if (!RecoverSettings(handle.get(), out_data))
       return ScopedLockedFileHandle();
   }
 
   return handle.Pass();
 }
 
-bool Settings::ReadSettings(FileHandle handle, Data* out_data) {
+bool Settings::ReadSettings(FileHandle handle,
+                            Data* out_data,
+                            bool log_read_error) {
   if (LoggingSeekFile(handle, 0, SEEK_SET) != 0)
     return false;
 
-  if (!LoggingReadFile(handle, out_data, sizeof(*out_data)))
+  bool read_result;
+  if (log_read_error)
+    read_result = LoggingReadFile(handle, out_data, sizeof(*out_data));
+  else
+    read_result = ReadFile(handle, out_data, sizeof(*out_data));
+
+  if (!read_result)
     return false;
 
   if (out_data->magic != Data::kSettingsMagic) {
     LOG(ERROR) << "Settings magic is not " << Data::kSettingsMagic;
     return false;
   }
 
   if (out_data->version != Data::kSettingsVersion) {
     LOG(ERROR) << "Settings version is not " << Data::kSettingsVersion;
     return false;
   }
 
   return true;
 }
 
 bool Settings::WriteSettings(FileHandle handle, const Data& data) {
   if (LoggingSeekFile(handle, 0, SEEK_SET) != 0)
     return false;
 
   if (!LoggingTruncateFile(handle))
     return false;
 
   return LoggingWriteFile(handle, &data, sizeof(Data));
 }
 
 bool Settings::RecoverSettings(FileHandle handle, Data* out_data) {
   ScopedLockedFileHandle scoped_handle;
   if (handle == kInvalidFileHandle) {
-    scoped_handle = OpenForReadingAndWriting();
+    scoped_handle =
+        OpenForReadingAndWriting(FileWriteMode::kReuseOrCreate, true);
     handle = scoped_handle.get();
 
     // Test if the file has already been recovered now that the exclusive lock
     // is held.
-    if (ReadSettings(handle, out_data))
+    if (ReadSettings(handle, out_data, true))
       return true;
   }
 
   if (handle == kInvalidFileHandle) {
     LOG(ERROR) << "Invalid file handle";
     return false;
   }
 
   if (!InitializeSettings(handle))
     return false;
 
-  return ReadSettings(handle, out_data);
+  return ReadSettings(handle, out_data, true);
 }
 
 bool Settings::InitializeSettings(FileHandle handle) {
   Data settings;
   if (!settings.client_id.InitializeWithNew())
     return false;
 
   return WriteSettings(handle, settings);
 }
 
 }  // namespace crashpad