blob: ca6c82a472db484c1e869b9b97908265d4417f3d [file] [log] [blame]
// Copyright 2016 Google Inc. 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,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// Adapted from cobalt/storage.
#include "sql/test_vfs.h"
#include <string.h>
#include <algorithm>
#include <map>
#include "base/compiler_specific.h"
#include "base/lazy_instance.h"
#include "base/logging.h"
#include "base/rand_util.h"
#include "base/strings/string_util.h"
#include "base/synchronization/lock.h"
#include "third_party/sqlite/sqlite3.h"
namespace sql {
namespace {
// A "subclass" of sqlite3_file with our required data structures added.
struct virtual_file {
sqlite3_file sql_internal_file;
std::string* data;
base::Lock* lock;
int current_lock;
int shared;
};
// A very simple in-memory virtual file system.
class TestVfs {
public:
typedef std::map<std::string, std::string> FileMap;
public:
TestVfs() {}
~TestVfs() {}
void Register();
void Unregister();
std::string* Open(const char* path) {
return &file_map_[path];
}
void Delete(const char* path) {
file_map_.erase(path);
}
private:
sqlite3_vfs vfs_;
FileMap file_map_;
};
base::LazyInstance<TestVfs>::DestructorAtExit g_vfs = LAZY_INSTANCE_INITIALIZER;
int VfsClose(sqlite3_file* file) {
virtual_file* vfile = reinterpret_cast<virtual_file*>(file);
delete vfile->lock;
return SQLITE_OK;
}
int VfsRead(sqlite3_file* file, void* out, int bytes, sqlite_int64 offset) {
virtual_file* vfile = reinterpret_cast<virtual_file*>(file);
base::AutoLock lock(*vfile->lock);
if (offset >= static_cast<sqlite_int64>(vfile->data->length())) {
return SQLITE_OK;
}
size_t available =
std::max(static_cast<sqlite_int64>(vfile->data->length()) - offset,
static_cast<sqlite_int64>(0));
size_t to_read = std::min(available, static_cast<size_t>(bytes));
if (to_read == 0) {
return SQLITE_OK;
}
memcpy(out, &(vfile->data->c_str()[offset]), to_read);
return SQLITE_OK;
}
int VfsWrite(sqlite3_file* file,
const void* data,
int bytes,
sqlite3_int64 offset) {
size_t max = offset + bytes;
virtual_file* vfile = reinterpret_cast<virtual_file*>(file);
base::AutoLock lock(*vfile->lock);
if (vfile->data->length() < max) {
vfile->data->resize(max);
}
vfile->data->replace(offset, bytes, reinterpret_cast<const char*>(data),
bytes);
return SQLITE_OK;
}
int VfsSync(sqlite3_file* pFile, int flags) {
return SQLITE_OK;
}
int VfsFileControl(sqlite3_file* pFile, int op, void* pArg) {
return SQLITE_OK;
}
int VfsSectorSize(sqlite3_file* file) {
// The number of bytes that can be read without disturbing other bytes in the
// file.
return 1;
}
int VfsLock(sqlite3_file* file, const int mode) {
virtual_file* vfile = reinterpret_cast<virtual_file*>(file);
base::AutoLock lock(*vfile->lock);
// If there is already a lock of this type or more restrictive, do nothing
if (vfile->current_lock >= mode) {
return SQLITE_OK;
}
if (mode == SQLITE_LOCK_SHARED) {
DCHECK_EQ(vfile->current_lock, SQLITE_LOCK_NONE);
vfile->shared++;
vfile->current_lock = SQLITE_LOCK_SHARED;
}
if (mode == SQLITE_LOCK_RESERVED) {
DCHECK_EQ(vfile->current_lock, SQLITE_LOCK_SHARED);
vfile->current_lock = SQLITE_LOCK_RESERVED;
}
if (mode == SQLITE_LOCK_EXCLUSIVE) {
if (vfile->current_lock >= SQLITE_LOCK_PENDING) {
return SQLITE_BUSY;
}
vfile->current_lock = SQLITE_LOCK_PENDING;
if (vfile->shared > 1) {
// There are some outstanding shared locks (greater than one because the
// pending lock is an "upgraded" shared lock)
return SQLITE_BUSY;
}
// Acquire the exclusive lock
vfile->current_lock = SQLITE_LOCK_EXCLUSIVE;
}
return SQLITE_OK;
}
int VfsUnlock(sqlite3_file* file, int mode) {
DCHECK_LE(mode, SQLITE_LOCK_SHARED);
virtual_file* vfile = reinterpret_cast<virtual_file*>(file);
base::AutoLock lock(*vfile->lock);
#ifdef STARBOARD
#undef COMPILE_ASSERT
#define COMPILE_ASSERT static_assert
#define sqlite_lock_constants_order_has_changed \
"sqlite lock constants order has changed!"
#endif
COMPILE_ASSERT(SQLITE_LOCK_NONE < SQLITE_LOCK_SHARED,
sqlite_lock_constants_order_has_changed);
COMPILE_ASSERT(SQLITE_LOCK_SHARED < SQLITE_LOCK_RESERVED,
sqlite_lock_constants_order_has_changed);
COMPILE_ASSERT(SQLITE_LOCK_RESERVED < SQLITE_LOCK_PENDING,
sqlite_lock_constants_order_has_changed);
COMPILE_ASSERT(SQLITE_LOCK_PENDING < SQLITE_LOCK_EXCLUSIVE,
sqlite_lock_constants_order_has_changed);
if (mode == SQLITE_LOCK_NONE && vfile->current_lock >= SQLITE_LOCK_SHARED) {
vfile->shared--;
}
vfile->current_lock = mode;
return SQLITE_OK;
}
int VfsCheckReservedLock(sqlite3_file* file, int* result) {
virtual_file* vfile = reinterpret_cast<virtual_file*>(file);
base::AutoLock lock(*vfile->lock);
// The function expects a result is 1 if the lock is reserved, pending, or
// exclusive; 0 otherwise.
*result = vfile->current_lock >= SQLITE_LOCK_RESERVED ? 1 : 0;
return SQLITE_OK;
}
int VfsFileSize(sqlite3_file* file, sqlite3_int64* out_size) {
virtual_file* vfile = reinterpret_cast<virtual_file*>(file);
*out_size = vfile->data->length();
return SQLITE_OK;
}
int VfsTruncate(sqlite3_file* file, sqlite3_int64 size) {
virtual_file* vfile = reinterpret_cast<virtual_file*>(file);
base::AutoLock lock(*vfile->lock);
vfile->data->resize(size);
return SQLITE_OK;
}
int VfsDeviceCharacteristics(sqlite3_file* file) {
return 0;
}
const sqlite3_io_methods s_cobalt_vfs_io = {
1, // Structure version number
VfsClose, // xClose
VfsRead, // xRead
VfsWrite, // xWrite
VfsTruncate, // xTruncate
VfsSync, // xSync
VfsFileSize, // xFileSize
VfsLock, // xLock
VfsUnlock, // xUnlock
VfsCheckReservedLock, // xCheckReservedLock
VfsFileControl, // xFileControl
VfsSectorSize, // xSectorSize
VfsDeviceCharacteristics // xDeviceCharacteristics
};
int VfsOpen(sqlite3_vfs* sql_vfs,
const char* path,
sqlite3_file* file,
int flags,
int* out_flags) {
DCHECK(path) << "NULL filename not supported.";
virtual_file* vfile = reinterpret_cast<virtual_file*>(file);
vfile->lock = new base::Lock;
TestVfs* vfs = reinterpret_cast<TestVfs*>(sql_vfs->pAppData);
vfile->data = vfs->Open(path);
file->pMethods = &s_cobalt_vfs_io;
return SQLITE_OK;
}
int VfsDelete(sqlite3_vfs* sql_vfs, const char* path, int sync_dir) {
TestVfs* vfs = reinterpret_cast<TestVfs*>(sql_vfs->pAppData);
vfs->Delete(path);
return SQLITE_OK;
}
int VfsFullPathname(sqlite3_vfs* sql_vfs,
const char* path,
int out_size,
char* out_path) {
size_t path_size = static_cast<size_t>(out_size);
if (base::strlcpy(out_path, path, path_size) < path_size) {
return SQLITE_OK;
}
return SQLITE_ERROR;
}
int VfsAccess(sqlite3_vfs* sql_vfs, const char* name, int flags, int* result) {
// We should always have a valid, readable/writable file.
*result |= SQLITE_ACCESS_EXISTS | SQLITE_ACCESS_READWRITE;
return SQLITE_OK;
}
int VfsRandomness(sqlite3_vfs* sql_vfs, int bytes, char* out) {
base::RandBytes(out, static_cast<size_t>(bytes));
return SQLITE_OK;
}
void TestVfs::Register() {
memset(&vfs_, 0, sizeof(vfs_));
vfs_.iVersion = 1;
vfs_.szOsFile = sizeof(virtual_file);
vfs_.mxPathname = 512;
vfs_.pNext = NULL;
vfs_.zName = "test_vfs";
vfs_.pAppData = this;
vfs_.xOpen = VfsOpen;
vfs_.xDelete = VfsDelete;
vfs_.xAccess = VfsAccess;
vfs_.xFullPathname = VfsFullPathname;
vfs_.xRandomness = VfsRandomness;
// Ensure we are not registering multiple of these with the same name.
// Behavior is undefined in that case.
DCHECK(sqlite3_vfs_find(vfs_.zName) == NULL);
int ret = sqlite3_vfs_register(&vfs_, 1 /* make_default */);
DCHECK_EQ(ret, SQLITE_OK);
}
void TestVfs::Unregister() {
int ret = sqlite3_vfs_unregister(&vfs_);
file_map_.clear();
DCHECK_EQ(ret, SQLITE_OK);
}
} // namespace
void RegisterTestVfs() {
g_vfs.Get().Register();
}
void UnregisterTestVfs() {
g_vfs.Get().Unregister();
}
} // namespace sql