mirror of
https://github.com/Amulet-Team/leveldb-mcpe.git
synced 2024-11-24 11:06:16 +00:00
8415f00eee
BTRFS reorders rename and write operations, so it is possible that a filesystem crash and recovery results in a situation where the file pointed to by CURRENT does not exist. DB::Open currently reports an I/O error in this case. Reporting database corruption is a better hint to the caller, which can attempt to recover the database or erase it and start over. This issue is not merely theoretical. It was reported as having showed up in the wild at https://github.com/google/leveldb/issues/195 and at https://crbug.com/738961. Also, asides from the BTRFS case described above, incorrect data in CURRENT seems like a possible corruption case that should be handled gracefully. The Env API changes here can be considered backwards compatible, because an implementation that returns Status::IOError instead of Status::NotFound will still get the same functionality as before. ------------- Created by MOE: https://github.com/google/moe MOE_MIGRATED_REVID=161432630
125 lines
3.1 KiB
C++
125 lines
3.1 KiB
C++
// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file. See the AUTHORS file for names of contributors.
|
|
|
|
#include "leveldb/env.h"
|
|
|
|
#include "port/port.h"
|
|
#include "util/testharness.h"
|
|
|
|
namespace leveldb {
|
|
|
|
static const int kDelayMicros = 100000;
|
|
static const int kReadOnlyFileLimit = 4;
|
|
static const int kMMapLimit = 4;
|
|
|
|
class EnvTest {
|
|
private:
|
|
port::Mutex mu_;
|
|
std::string events_;
|
|
|
|
public:
|
|
Env* env_;
|
|
EnvTest() : env_(Env::Default()) { }
|
|
};
|
|
|
|
static void SetBool(void* ptr) {
|
|
reinterpret_cast<port::AtomicPointer*>(ptr)->NoBarrier_Store(ptr);
|
|
}
|
|
|
|
TEST(EnvTest, RunImmediately) {
|
|
port::AtomicPointer called (NULL);
|
|
env_->Schedule(&SetBool, &called);
|
|
env_->SleepForMicroseconds(kDelayMicros);
|
|
ASSERT_TRUE(called.NoBarrier_Load() != NULL);
|
|
}
|
|
|
|
TEST(EnvTest, RunMany) {
|
|
port::AtomicPointer last_id (NULL);
|
|
|
|
struct CB {
|
|
port::AtomicPointer* last_id_ptr; // Pointer to shared slot
|
|
uintptr_t id; // Order# for the execution of this callback
|
|
|
|
CB(port::AtomicPointer* p, int i) : last_id_ptr(p), id(i) { }
|
|
|
|
static void Run(void* v) {
|
|
CB* cb = reinterpret_cast<CB*>(v);
|
|
void* cur = cb->last_id_ptr->NoBarrier_Load();
|
|
ASSERT_EQ(cb->id-1, reinterpret_cast<uintptr_t>(cur));
|
|
cb->last_id_ptr->Release_Store(reinterpret_cast<void*>(cb->id));
|
|
}
|
|
};
|
|
|
|
// Schedule in different order than start time
|
|
CB cb1(&last_id, 1);
|
|
CB cb2(&last_id, 2);
|
|
CB cb3(&last_id, 3);
|
|
CB cb4(&last_id, 4);
|
|
env_->Schedule(&CB::Run, &cb1);
|
|
env_->Schedule(&CB::Run, &cb2);
|
|
env_->Schedule(&CB::Run, &cb3);
|
|
env_->Schedule(&CB::Run, &cb4);
|
|
|
|
env_->SleepForMicroseconds(kDelayMicros);
|
|
void* cur = last_id.Acquire_Load();
|
|
ASSERT_EQ(4, reinterpret_cast<uintptr_t>(cur));
|
|
}
|
|
|
|
struct State {
|
|
port::Mutex mu;
|
|
int val;
|
|
int num_running;
|
|
};
|
|
|
|
static void ThreadBody(void* arg) {
|
|
State* s = reinterpret_cast<State*>(arg);
|
|
s->mu.Lock();
|
|
s->val += 1;
|
|
s->num_running -= 1;
|
|
s->mu.Unlock();
|
|
}
|
|
|
|
TEST(EnvTest, StartThread) {
|
|
State state;
|
|
state.val = 0;
|
|
state.num_running = 3;
|
|
for (int i = 0; i < 3; i++) {
|
|
env_->StartThread(&ThreadBody, &state);
|
|
}
|
|
while (true) {
|
|
state.mu.Lock();
|
|
int num = state.num_running;
|
|
state.mu.Unlock();
|
|
if (num == 0) {
|
|
break;
|
|
}
|
|
env_->SleepForMicroseconds(kDelayMicros);
|
|
}
|
|
ASSERT_EQ(state.val, 3);
|
|
}
|
|
|
|
TEST(EnvTest, TestOpenNonExistentFile) {
|
|
// Write some test data to a single file that will be opened |n| times.
|
|
std::string test_dir;
|
|
ASSERT_OK(env_->GetTestDirectory(&test_dir));
|
|
|
|
std::string non_existent_file = test_dir + "/non_existent_file";
|
|
ASSERT_TRUE(!env_->FileExists(non_existent_file));
|
|
|
|
RandomAccessFile* random_access_file;
|
|
Status status = env_->NewRandomAccessFile(
|
|
non_existent_file, &random_access_file);
|
|
ASSERT_TRUE(status.IsNotFound());
|
|
|
|
SequentialFile* sequential_file;
|
|
status = env_->NewSequentialFile(non_existent_file, &sequential_file);
|
|
ASSERT_TRUE(status.IsNotFound());
|
|
}
|
|
|
|
} // namespace leveldb
|
|
|
|
int main(int argc, char** argv) {
|
|
return leveldb::test::RunAllTests();
|
|
}
|