| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "webkit/browser/fileapi/sandbox_origin_database.h" | |
| 6 | |
| 7 #include <set> | |
| 8 #include <utility> | |
| 9 | |
| 10 #include "base/files/file_enumerator.h" | |
| 11 #include "base/files/file_util.h" | |
| 12 #include "base/format_macros.h" | |
| 13 #include "base/location.h" | |
| 14 #include "base/logging.h" | |
| 15 #include "base/metrics/histogram.h" | |
| 16 #include "base/strings/string_number_conversions.h" | |
| 17 #include "base/strings/string_util.h" | |
| 18 #include "base/strings/stringprintf.h" | |
| 19 #include "third_party/leveldatabase/src/include/leveldb/db.h" | |
| 20 #include "third_party/leveldatabase/src/include/leveldb/write_batch.h" | |
| 21 #include "webkit/common/fileapi/file_system_util.h" | |
| 22 | |
| 23 namespace { | |
| 24 | |
| 25 const base::FilePath::CharType kOriginDatabaseName[] = | |
| 26 FILE_PATH_LITERAL("Origins"); | |
| 27 const char kOriginKeyPrefix[] = "ORIGIN:"; | |
| 28 const char kLastPathKey[] = "LAST_PATH"; | |
| 29 const int64 kMinimumReportIntervalHours = 1; | |
| 30 const char kInitStatusHistogramLabel[] = "FileSystem.OriginDatabaseInit"; | |
| 31 const char kDatabaseRepairHistogramLabel[] = "FileSystem.OriginDatabaseRepair"; | |
| 32 | |
| 33 enum InitStatus { | |
| 34 INIT_STATUS_OK = 0, | |
| 35 INIT_STATUS_CORRUPTION, | |
| 36 INIT_STATUS_IO_ERROR, | |
| 37 INIT_STATUS_UNKNOWN_ERROR, | |
| 38 INIT_STATUS_MAX | |
| 39 }; | |
| 40 | |
| 41 enum RepairResult { | |
| 42 DB_REPAIR_SUCCEEDED = 0, | |
| 43 DB_REPAIR_FAILED, | |
| 44 DB_REPAIR_MAX | |
| 45 }; | |
| 46 | |
| 47 std::string OriginToOriginKey(const std::string& origin) { | |
| 48 std::string key(kOriginKeyPrefix); | |
| 49 return key + origin; | |
| 50 } | |
| 51 | |
| 52 const char* LastPathKey() { | |
| 53 return kLastPathKey; | |
| 54 } | |
| 55 | |
| 56 } // namespace | |
| 57 | |
| 58 namespace storage { | |
| 59 | |
| 60 SandboxOriginDatabase::SandboxOriginDatabase( | |
| 61 const base::FilePath& file_system_directory, | |
| 62 leveldb::Env* env_override) | |
| 63 : file_system_directory_(file_system_directory), | |
| 64 env_override_(env_override) { | |
| 65 } | |
| 66 | |
| 67 SandboxOriginDatabase::~SandboxOriginDatabase() { | |
| 68 } | |
| 69 | |
| 70 bool SandboxOriginDatabase::Init(InitOption init_option, | |
| 71 RecoveryOption recovery_option) { | |
| 72 if (db_) | |
| 73 return true; | |
| 74 | |
| 75 base::FilePath db_path = GetDatabasePath(); | |
| 76 if (init_option == FAIL_IF_NONEXISTENT && !base::PathExists(db_path)) | |
| 77 return false; | |
| 78 | |
| 79 std::string path = FilePathToString(db_path); | |
| 80 leveldb::Options options; | |
| 81 options.max_open_files = 0; // Use minimum. | |
| 82 options.create_if_missing = true; | |
| 83 if (env_override_) | |
| 84 options.env = env_override_; | |
| 85 leveldb::DB* db; | |
| 86 leveldb::Status status = leveldb::DB::Open(options, path, &db); | |
| 87 ReportInitStatus(status); | |
| 88 if (status.ok()) { | |
| 89 db_.reset(db); | |
| 90 return true; | |
| 91 } | |
| 92 HandleError(FROM_HERE, status); | |
| 93 | |
| 94 // Corruption due to missing necessary MANIFEST-* file causes IOError instead | |
| 95 // of Corruption error. | |
| 96 // Try to repair database even when IOError case. | |
| 97 if (!status.IsCorruption() && !status.IsIOError()) | |
| 98 return false; | |
| 99 | |
| 100 switch (recovery_option) { | |
| 101 case FAIL_ON_CORRUPTION: | |
| 102 return false; | |
| 103 case REPAIR_ON_CORRUPTION: | |
| 104 LOG(WARNING) << "Attempting to repair SandboxOriginDatabase."; | |
| 105 | |
| 106 if (RepairDatabase(path)) { | |
| 107 UMA_HISTOGRAM_ENUMERATION(kDatabaseRepairHistogramLabel, | |
| 108 DB_REPAIR_SUCCEEDED, DB_REPAIR_MAX); | |
| 109 LOG(WARNING) << "Repairing SandboxOriginDatabase completed."; | |
| 110 return true; | |
| 111 } | |
| 112 UMA_HISTOGRAM_ENUMERATION(kDatabaseRepairHistogramLabel, | |
| 113 DB_REPAIR_FAILED, DB_REPAIR_MAX); | |
| 114 // fall through | |
| 115 case DELETE_ON_CORRUPTION: | |
| 116 if (!base::DeleteFile(file_system_directory_, true)) | |
| 117 return false; | |
| 118 if (!base::CreateDirectory(file_system_directory_)) | |
| 119 return false; | |
| 120 return Init(init_option, FAIL_ON_CORRUPTION); | |
| 121 } | |
| 122 NOTREACHED(); | |
| 123 return false; | |
| 124 } | |
| 125 | |
| 126 bool SandboxOriginDatabase::RepairDatabase(const std::string& db_path) { | |
| 127 DCHECK(!db_.get()); | |
| 128 leveldb::Options options; | |
| 129 options.max_open_files = 0; // Use minimum. | |
| 130 if (env_override_) | |
| 131 options.env = env_override_; | |
| 132 if (!leveldb::RepairDB(db_path, options).ok() || | |
| 133 !Init(FAIL_IF_NONEXISTENT, FAIL_ON_CORRUPTION)) { | |
| 134 LOG(WARNING) << "Failed to repair SandboxOriginDatabase."; | |
| 135 return false; | |
| 136 } | |
| 137 | |
| 138 // See if the repaired entries match with what we have on disk. | |
| 139 std::set<base::FilePath> directories; | |
| 140 base::FileEnumerator file_enum(file_system_directory_, | |
| 141 false /* recursive */, | |
| 142 base::FileEnumerator::DIRECTORIES); | |
| 143 base::FilePath path_each; | |
| 144 while (!(path_each = file_enum.Next()).empty()) | |
| 145 directories.insert(path_each.BaseName()); | |
| 146 std::set<base::FilePath>::iterator db_dir_itr = | |
| 147 directories.find(base::FilePath(kOriginDatabaseName)); | |
| 148 // Make sure we have the database file in its directory and therefore we are | |
| 149 // working on the correct path. | |
| 150 DCHECK(db_dir_itr != directories.end()); | |
| 151 directories.erase(db_dir_itr); | |
| 152 | |
| 153 std::vector<OriginRecord> origins; | |
| 154 if (!ListAllOrigins(&origins)) { | |
| 155 DropDatabase(); | |
| 156 return false; | |
| 157 } | |
| 158 | |
| 159 // Delete any obsolete entries from the origins database. | |
| 160 for (std::vector<OriginRecord>::iterator db_origin_itr = origins.begin(); | |
| 161 db_origin_itr != origins.end(); | |
| 162 ++db_origin_itr) { | |
| 163 std::set<base::FilePath>::iterator dir_itr = | |
| 164 directories.find(db_origin_itr->path); | |
| 165 if (dir_itr == directories.end()) { | |
| 166 if (!RemovePathForOrigin(db_origin_itr->origin)) { | |
| 167 DropDatabase(); | |
| 168 return false; | |
| 169 } | |
| 170 } else { | |
| 171 directories.erase(dir_itr); | |
| 172 } | |
| 173 } | |
| 174 | |
| 175 // Delete any directories not listed in the origins database. | |
| 176 for (std::set<base::FilePath>::iterator dir_itr = directories.begin(); | |
| 177 dir_itr != directories.end(); | |
| 178 ++dir_itr) { | |
| 179 if (!base::DeleteFile(file_system_directory_.Append(*dir_itr), | |
| 180 true /* recursive */)) { | |
| 181 DropDatabase(); | |
| 182 return false; | |
| 183 } | |
| 184 } | |
| 185 | |
| 186 return true; | |
| 187 } | |
| 188 | |
| 189 void SandboxOriginDatabase::HandleError( | |
| 190 const tracked_objects::Location& from_here, | |
| 191 const leveldb::Status& status) { | |
| 192 db_.reset(); | |
| 193 LOG(ERROR) << "SandboxOriginDatabase failed at: " | |
| 194 << from_here.ToString() << " with error: " << status.ToString(); | |
| 195 } | |
| 196 | |
| 197 void SandboxOriginDatabase::ReportInitStatus(const leveldb::Status& status) { | |
| 198 base::Time now = base::Time::Now(); | |
| 199 base::TimeDelta minimum_interval = | |
| 200 base::TimeDelta::FromHours(kMinimumReportIntervalHours); | |
| 201 if (last_reported_time_ + minimum_interval >= now) | |
| 202 return; | |
| 203 last_reported_time_ = now; | |
| 204 | |
| 205 if (status.ok()) { | |
| 206 UMA_HISTOGRAM_ENUMERATION(kInitStatusHistogramLabel, | |
| 207 INIT_STATUS_OK, INIT_STATUS_MAX); | |
| 208 } else if (status.IsCorruption()) { | |
| 209 UMA_HISTOGRAM_ENUMERATION(kInitStatusHistogramLabel, | |
| 210 INIT_STATUS_CORRUPTION, INIT_STATUS_MAX); | |
| 211 } else if (status.IsIOError()) { | |
| 212 UMA_HISTOGRAM_ENUMERATION(kInitStatusHistogramLabel, | |
| 213 INIT_STATUS_IO_ERROR, INIT_STATUS_MAX); | |
| 214 } else { | |
| 215 UMA_HISTOGRAM_ENUMERATION(kInitStatusHistogramLabel, | |
| 216 INIT_STATUS_UNKNOWN_ERROR, INIT_STATUS_MAX); | |
| 217 } | |
| 218 } | |
| 219 | |
| 220 bool SandboxOriginDatabase::HasOriginPath(const std::string& origin) { | |
| 221 if (!Init(FAIL_IF_NONEXISTENT, REPAIR_ON_CORRUPTION)) | |
| 222 return false; | |
| 223 if (origin.empty()) | |
| 224 return false; | |
| 225 std::string path; | |
| 226 leveldb::Status status = | |
| 227 db_->Get(leveldb::ReadOptions(), OriginToOriginKey(origin), &path); | |
| 228 if (status.ok()) | |
| 229 return true; | |
| 230 if (status.IsNotFound()) | |
| 231 return false; | |
| 232 HandleError(FROM_HERE, status); | |
| 233 return false; | |
| 234 } | |
| 235 | |
| 236 bool SandboxOriginDatabase::GetPathForOrigin( | |
| 237 const std::string& origin, base::FilePath* directory) { | |
| 238 if (!Init(CREATE_IF_NONEXISTENT, REPAIR_ON_CORRUPTION)) | |
| 239 return false; | |
| 240 DCHECK(directory); | |
| 241 if (origin.empty()) | |
| 242 return false; | |
| 243 std::string path_string; | |
| 244 std::string origin_key = OriginToOriginKey(origin); | |
| 245 leveldb::Status status = | |
| 246 db_->Get(leveldb::ReadOptions(), origin_key, &path_string); | |
| 247 if (status.IsNotFound()) { | |
| 248 int last_path_number; | |
| 249 if (!GetLastPathNumber(&last_path_number)) | |
| 250 return false; | |
| 251 path_string = base::StringPrintf("%03u", last_path_number + 1); | |
| 252 // store both back as a single transaction | |
| 253 leveldb::WriteBatch batch; | |
| 254 batch.Put(LastPathKey(), path_string); | |
| 255 batch.Put(origin_key, path_string); | |
| 256 status = db_->Write(leveldb::WriteOptions(), &batch); | |
| 257 if (!status.ok()) { | |
| 258 HandleError(FROM_HERE, status); | |
| 259 return false; | |
| 260 } | |
| 261 } | |
| 262 if (status.ok()) { | |
| 263 *directory = StringToFilePath(path_string); | |
| 264 return true; | |
| 265 } | |
| 266 HandleError(FROM_HERE, status); | |
| 267 return false; | |
| 268 } | |
| 269 | |
| 270 bool SandboxOriginDatabase::RemovePathForOrigin(const std::string& origin) { | |
| 271 if (!Init(CREATE_IF_NONEXISTENT, REPAIR_ON_CORRUPTION)) | |
| 272 return false; | |
| 273 leveldb::Status status = | |
| 274 db_->Delete(leveldb::WriteOptions(), OriginToOriginKey(origin)); | |
| 275 if (status.ok() || status.IsNotFound()) | |
| 276 return true; | |
| 277 HandleError(FROM_HERE, status); | |
| 278 return false; | |
| 279 } | |
| 280 | |
| 281 bool SandboxOriginDatabase::ListAllOrigins( | |
| 282 std::vector<OriginRecord>* origins) { | |
| 283 DCHECK(origins); | |
| 284 if (!Init(CREATE_IF_NONEXISTENT, REPAIR_ON_CORRUPTION)) { | |
| 285 origins->clear(); | |
| 286 return false; | |
| 287 } | |
| 288 scoped_ptr<leveldb::Iterator> iter(db_->NewIterator(leveldb::ReadOptions())); | |
| 289 std::string origin_key_prefix = OriginToOriginKey(std::string()); | |
| 290 iter->Seek(origin_key_prefix); | |
| 291 origins->clear(); | |
| 292 while (iter->Valid() && | |
| 293 StartsWithASCII(iter->key().ToString(), origin_key_prefix, true)) { | |
| 294 std::string origin = | |
| 295 iter->key().ToString().substr(origin_key_prefix.length()); | |
| 296 base::FilePath path = StringToFilePath(iter->value().ToString()); | |
| 297 origins->push_back(OriginRecord(origin, path)); | |
| 298 iter->Next(); | |
| 299 } | |
| 300 return true; | |
| 301 } | |
| 302 | |
| 303 void SandboxOriginDatabase::DropDatabase() { | |
| 304 db_.reset(); | |
| 305 } | |
| 306 | |
| 307 base::FilePath SandboxOriginDatabase::GetDatabasePath() const { | |
| 308 return file_system_directory_.Append(kOriginDatabaseName); | |
| 309 } | |
| 310 | |
| 311 void SandboxOriginDatabase::RemoveDatabase() { | |
| 312 DropDatabase(); | |
| 313 base::DeleteFile(GetDatabasePath(), true /* recursive */); | |
| 314 } | |
| 315 | |
| 316 bool SandboxOriginDatabase::GetLastPathNumber(int* number) { | |
| 317 DCHECK(db_); | |
| 318 DCHECK(number); | |
| 319 std::string number_string; | |
| 320 leveldb::Status status = | |
| 321 db_->Get(leveldb::ReadOptions(), LastPathKey(), &number_string); | |
| 322 if (status.ok()) | |
| 323 return base::StringToInt(number_string, number); | |
| 324 if (!status.IsNotFound()) { | |
| 325 HandleError(FROM_HERE, status); | |
| 326 return false; | |
| 327 } | |
| 328 // Verify that this is a totally new database, and initialize it. | |
| 329 scoped_ptr<leveldb::Iterator> iter(db_->NewIterator(leveldb::ReadOptions())); | |
| 330 iter->SeekToFirst(); | |
| 331 if (iter->Valid()) { // DB was not empty, but had no last path number! | |
| 332 LOG(ERROR) << "File system origin database is corrupt!"; | |
| 333 return false; | |
| 334 } | |
| 335 // This is always the first write into the database. If we ever add a | |
| 336 // version number, they should go in in a single transaction. | |
| 337 status = | |
| 338 db_->Put(leveldb::WriteOptions(), LastPathKey(), std::string("-1")); | |
| 339 if (!status.ok()) { | |
| 340 HandleError(FROM_HERE, status); | |
| 341 return false; | |
| 342 } | |
| 343 *number = -1; | |
| 344 return true; | |
| 345 } | |
| 346 | |
| 347 } // namespace storage | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 539143002:
Migrate webkit/browser/ to storage/browser/ (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master