verity: break libbase dependency
This removes the need for libbase for logging or special
types like scoped_ptr.
Now only gtest and gmock are required in order to run the unittests.
TEST=FEATURES=test emerge-(x86-alex|amd64-generic) verity
BUG=chromium-os:26649
Change-Id: I75643c5bdfe33b57afd0e3cfca7c49b7df6c5408
Reviewed-on: https://gerrit.chromium.org/gerrit/16411
Reviewed-by: Sonny Rao <sonnyrao@chromium.org>
Commit-Ready: Will Drewry <wad@chromium.org>
Tested-by: Will Drewry <wad@chromium.org>
diff --git a/Makefile b/Makefile
index 6afddd0..d926da8 100644
--- a/Makefile
+++ b/Makefile
@@ -11,12 +11,6 @@
CFLAGS += -I$(SRC)/include -I$(SRC)/..
CXXFLAGS += -I$(SRC)/include -I$(SRC)/..
-ifneq ($(WITH_CHROME),0)
- CXXFLAGS += -DWITH_CHROME=1
- LDFLAGS += -lbase -lpthread -lrt
- WITH_CHROME = 1
-endif
-
# Current toolchain doesn't support -pie statically linked binaries
CXX_STATIC_BINARY(verity-static): \
$(filter-out %_testrunner.o %_unittest.o,$(CXX_OBJECTS)) \
@@ -43,16 +37,13 @@
all: CXX_LIBRARY(libdm-bht.so)
clean: CLEAN(libdm-bht.so)
-# Tests require libchrome
-ifneq ($(WITH_CHROME),0)
- # For this project, only the unittests are CXX
- CXX_BINARY(verity_testrunner): $(filter-out %_main.o,$(CXX_OBJECTS)) \
- $(filter %dm-bht-userspace.o,$(C_OBJECTS)) \
+# For this project, only the unittests are CXX
+CXX_BINARY(verity_testrunner): $(filter-out %_main.o,$(CXX_OBJECTS)) \
+ $(filter %dm-bht-userspace.o,$(C_OBJECTS)) \
CXX_STATIC_LIBRARY(kernel/libkernel.pie.a) \
CXX_STATIC_LIBRARY(simple_file/libsimple_file.pie.a)
- $(call cxx_binary,-lgtest -lgmock)
+ $(call cxx_binary,-lgtest -lgmock -lpthread)
- all: CXX_BINARY(verity_testrunner)
- clean: CLEAN(verity_testrunner)
- tests: TEST(CXX_BINARY(verity_testrunner))
-endif
+all: CXX_BINARY(verity_testrunner)
+clean: CLEAN(verity_testrunner)
+tests: TEST(CXX_BINARY(verity_testrunner))
diff --git a/dm-bht_unittest.cc b/dm-bht_unittest.cc
index be68988..2eadf84 100644
--- a/dm-bht_unittest.cc
+++ b/dm-bht_unittest.cc
@@ -4,12 +4,14 @@
//
// Basic unittesting of dm-bht using google-gtest.
-#include <base/basictypes.h>
-#include <base/logging.h>
-#include <base/memory/scoped_ptr.h>
#include <gtest/gtest.h>
#include <stdlib.h>
+#include <string>
+#include <vector>
+
+#include "verity/logging.h"
+
// Pull in dm-bht.c so that we can access static functions.
// But disable verbose logging.
extern "C" {
@@ -43,7 +45,7 @@
// This should fail.
unsigned int blocks, total_blocks = 16384;
u8 *data = (u8 *)my_memalign(PAGE_SIZE, PAGE_SIZE);
- void * hash_data;
+ u8 *hash_data;
blocks = total_blocks;
@@ -66,13 +68,21 @@
0);
EXPECT_EQ(0, dm_bht_compute(&bht));
EXPECT_EQ(0, dm_bht_destroy(&bht));
- free(hash_data);
+ delete hash_data;
free(data);
}
class MemoryBhtTest : public ::testing::Test {
public:
void SetUp() {
+ bht_ = NULL;
+ }
+
+ void TearDown() {
+ hash_data_.clear();
+ if (bht_)
+ delete bht_;
+ bht_ = NULL;
}
int Read(sector_t start, u8 *dst, sector_t count) {
@@ -126,31 +136,31 @@
void SetupBht(const unsigned int total_blocks,
const char *digest_algorithm,
const char *salt) {
- bht_.reset(new dm_bht());
+ if (bht_)
+ delete bht_;
+ bht_ = new dm_bht;
- EXPECT_EQ(0, dm_bht_create(bht_.get(), total_blocks, digest_algorithm));
- if (hash_data_.get() == NULL) {
- sectors_ = dm_bht_sectors(bht_.get());
- hash_data_.reset(new u8[to_bytes(sectors_)]);
- }
+ EXPECT_EQ(0, dm_bht_create(bht_, total_blocks, digest_algorithm));
+ sectors_ = dm_bht_sectors(bht_);
+ hash_data_.resize(to_bytes(sectors_));
if (salt)
- dm_bht_set_salt(bht_.get(), salt);
+ dm_bht_set_salt(bht_, salt);
SetupHash(total_blocks, digest_algorithm, salt, &hash_data_[0]);
- dm_bht_set_read_cb(bht_.get(), MemoryBhtTest::ReadCallback);
+ dm_bht_set_read_cb(bht_, MemoryBhtTest::ReadCallback);
// Load the tree from the pre-populated hash data
unsigned int blocks;
for (blocks = 0; blocks < total_blocks; blocks += bht_->node_count)
- EXPECT_GE(dm_bht_populate(bht_.get(),
+ EXPECT_GE(dm_bht_populate(bht_,
reinterpret_cast<void *>(this),
blocks),
0);
}
- scoped_ptr<struct dm_bht> bht_;
- scoped_array<u8> hash_data_;
+ struct dm_bht *bht_;
+ std::vector<u8> hash_data_;
sector_t sectors_;
};
@@ -165,16 +175,16 @@
memset(zero_page, 0, PAGE_SIZE);
SetupBht(total_blocks, "sha256", NULL);
- dm_bht_set_root_hexdigest(bht_.get(),
+ dm_bht_set_root_hexdigest(bht_,
reinterpret_cast<const u8 *>(kRootDigest));
for (unsigned int blocks = 0; blocks < total_blocks; ++blocks) {
DLOG(INFO) << "verifying block: " << blocks;
- EXPECT_EQ(0, dm_bht_verify_block(bht_.get(), blocks,
+ EXPECT_EQ(0, dm_bht_verify_block(bht_, blocks,
virt_to_page(zero_page), 0));
}
- EXPECT_EQ(0, dm_bht_destroy(bht_.get()));
+ EXPECT_EQ(0, dm_bht_destroy(bht_));
free(zero_page);
}
@@ -189,16 +199,16 @@
memset(zero_page, 0, PAGE_SIZE);
SetupBht(total_blocks, "sha256", NULL);
- dm_bht_set_root_hexdigest(bht_.get(),
+ dm_bht_set_root_hexdigest(bht_,
reinterpret_cast<const u8 *>(kRootDigest));
for (unsigned int blocks = 0; blocks < total_blocks; ++blocks) {
DLOG(INFO) << "verifying block: " << blocks;
- EXPECT_EQ(0, dm_bht_verify_block(bht_.get(), blocks,
+ EXPECT_EQ(0, dm_bht_verify_block(bht_, blocks,
virt_to_page(zero_page), 0));
}
- EXPECT_EQ(0, dm_bht_destroy(bht_.get()));
+ EXPECT_EQ(0, dm_bht_destroy(bht_));
free(zero_page);
}
@@ -213,16 +223,16 @@
memset(zero_page, 0, PAGE_SIZE);
SetupBht(total_blocks, "sha256", NULL);
- dm_bht_set_root_hexdigest(bht_.get(),
+ dm_bht_set_root_hexdigest(bht_,
reinterpret_cast<const u8 *>(kRootDigest));
for (unsigned int blocks = 0; blocks < total_blocks; ++blocks) {
DLOG(INFO) << "verifying block: " << blocks;
- EXPECT_EQ(0, dm_bht_verify_block(bht_.get(), blocks,
+ EXPECT_EQ(0, dm_bht_verify_block(bht_, blocks,
virt_to_page(zero_page), 0));
}
- EXPECT_EQ(0, dm_bht_destroy(bht_.get()));
+ EXPECT_EQ(0, dm_bht_destroy(bht_));
free(zero_page);
}
@@ -237,16 +247,16 @@
memset(zero_page, 0, PAGE_SIZE);
SetupBht(total_blocks, "sha256", NULL);
- dm_bht_set_root_hexdigest(bht_.get(),
+ dm_bht_set_root_hexdigest(bht_,
reinterpret_cast<const u8 *>(kRootDigest));
for (unsigned int blocks = 0; blocks < total_blocks; ++blocks) {
DLOG(INFO) << "verifying block: " << blocks;
- EXPECT_EQ(0, dm_bht_verify_block(bht_.get(), blocks,
+ EXPECT_EQ(0, dm_bht_verify_block(bht_, blocks,
virt_to_page(zero_page), 0));
}
- EXPECT_EQ(0, dm_bht_destroy(bht_.get()));
+ EXPECT_EQ(0, dm_bht_destroy(bht_));
free(zero_page);
}
@@ -261,16 +271,16 @@
memset(zero_page, 0, PAGE_SIZE);
SetupBht(total_blocks, "sha256", NULL);
- dm_bht_set_root_hexdigest(bht_.get(),
+ dm_bht_set_root_hexdigest(bht_,
reinterpret_cast<const u8 *>(kRootDigest));
for (unsigned int blocks = 0; blocks < total_blocks; ++blocks) {
DLOG(INFO) << "verifying block: " << blocks;
- EXPECT_EQ(0, dm_bht_verify_block(bht_.get(), blocks,
+ EXPECT_EQ(0, dm_bht_verify_block(bht_, blocks,
virt_to_page(zero_page), 0));
}
- EXPECT_EQ(0, dm_bht_destroy(bht_.get()));
+ EXPECT_EQ(0, dm_bht_destroy(bht_));
free(zero_page);
}
@@ -286,7 +296,7 @@
SetupBht(total_blocks, "sha256", NULL);
- dm_bht_set_root_hexdigest(bht_.get(),
+ dm_bht_set_root_hexdigest(bht_,
reinterpret_cast<const u8 *>(kRootDigest));
// TODO(wad) add tests for partial tree validity/verification
@@ -295,30 +305,30 @@
static const unsigned int kBadBlock = 256;
u8 *bad_hash_block= (u8 *)my_memalign(PAGE_SIZE, PAGE_SIZE);
memset(bad_hash_block, 'A', PAGE_SIZE);
- EXPECT_EQ(dm_bht_store_block(bht_.get(), kBadBlock, bad_hash_block), 0);
+ EXPECT_EQ(dm_bht_store_block(bht_, kBadBlock, bad_hash_block), 0);
// Attempt to verify both the bad block and all the neighbors.
- EXPECT_LT(dm_bht_verify_block(bht_.get(), kBadBlock + 1,
+ EXPECT_LT(dm_bht_verify_block(bht_, kBadBlock + 1,
virt_to_page(zero_page), 0), 0);
- EXPECT_LT(dm_bht_verify_block(bht_.get(), kBadBlock + 2,
+ EXPECT_LT(dm_bht_verify_block(bht_, kBadBlock + 2,
virt_to_page(zero_page), 0), 0);
- EXPECT_LT(dm_bht_verify_block(bht_.get(), kBadBlock + (bht_->node_count / 2),
+ EXPECT_LT(dm_bht_verify_block(bht_, kBadBlock + (bht_->node_count / 2),
virt_to_page(zero_page), 0), 0);
- EXPECT_LT(dm_bht_verify_block(bht_.get(), kBadBlock,
+ EXPECT_LT(dm_bht_verify_block(bht_, kBadBlock,
virt_to_page(zero_page), 0), 0);
// Verify that the prior entry is untouched and still safe
- EXPECT_EQ(dm_bht_verify_block(bht_.get(), kBadBlock - 1,
+ EXPECT_EQ(dm_bht_verify_block(bht_, kBadBlock - 1,
virt_to_page(zero_page), 0), 0);
// Same for the next entry
- EXPECT_EQ(dm_bht_verify_block(bht_.get(), kBadBlock + bht_->node_count,
+ EXPECT_EQ(dm_bht_verify_block(bht_, kBadBlock + bht_->node_count,
virt_to_page(zero_page), 0), 0);
- EXPECT_EQ(0, dm_bht_destroy(bht_.get()));
+ EXPECT_EQ(0, dm_bht_destroy(bht_));
free(bad_hash_block);
free(zero_page);
}
@@ -329,7 +339,7 @@
// Set the root hash for a 0-filled image
static const char kRootDigest[] =
"45d65d6f9e5a962f4d80b5f1bd7a918152251c27bdad8c5f52b590c129833372";
- dm_bht_set_root_hexdigest(bht_.get(),
+ dm_bht_set_root_hexdigest(bht_,
reinterpret_cast<const u8 *>(kRootDigest));
// A corrupt page
u8 *bad_page = (u8 *)my_memalign(PAGE_SIZE, PAGE_SIZE);
@@ -337,14 +347,14 @@
memset(bad_page, 'A', PAGE_SIZE);
- EXPECT_LT(dm_bht_verify_block(bht_.get(), 0, virt_to_page(bad_page), 0), 0);
- EXPECT_LT(dm_bht_verify_block(bht_.get(), 127, virt_to_page(bad_page), 0), 0);
- EXPECT_LT(dm_bht_verify_block(bht_.get(), 128, virt_to_page(bad_page), 0), 0);
- EXPECT_LT(dm_bht_verify_block(bht_.get(), 255, virt_to_page(bad_page), 0), 0);
- EXPECT_LT(dm_bht_verify_block(bht_.get(), 256, virt_to_page(bad_page), 0), 0);
- EXPECT_LT(dm_bht_verify_block(bht_.get(), 383, virt_to_page(bad_page), 0), 0);
+ EXPECT_LT(dm_bht_verify_block(bht_, 0, virt_to_page(bad_page), 0), 0);
+ EXPECT_LT(dm_bht_verify_block(bht_, 127, virt_to_page(bad_page), 0), 0);
+ EXPECT_LT(dm_bht_verify_block(bht_, 128, virt_to_page(bad_page), 0), 0);
+ EXPECT_LT(dm_bht_verify_block(bht_, 255, virt_to_page(bad_page), 0), 0);
+ EXPECT_LT(dm_bht_verify_block(bht_, 256, virt_to_page(bad_page), 0), 0);
+ EXPECT_LT(dm_bht_verify_block(bht_, 383, virt_to_page(bad_page), 0), 0);
- EXPECT_EQ(0, dm_bht_destroy(bht_.get()));
+ EXPECT_EQ(0, dm_bht_destroy(bht_));
free(bad_page);
}
@@ -361,16 +371,16 @@
memset(zero_page, 0, PAGE_SIZE);
SetupBht(total_blocks, "sha256", salt);
- dm_bht_set_root_hexdigest(bht_.get(),
+ dm_bht_set_root_hexdigest(bht_,
reinterpret_cast<const u8 *>(kRootDigest));
for (unsigned int blocks = 0; blocks < total_blocks; ++blocks) {
DLOG(INFO) << "verifying block: " << blocks;
- EXPECT_EQ(0, dm_bht_verify_block(bht_.get(), blocks,
+ EXPECT_EQ(0, dm_bht_verify_block(bht_, blocks,
virt_to_page(zero_page), 0));
}
- EXPECT_EQ(0, dm_bht_destroy(bht_.get()));
+ EXPECT_EQ(0, dm_bht_destroy(bht_));
free(zero_page);
}
@@ -387,15 +397,15 @@
memset(zero_page, 0, PAGE_SIZE);
SetupBht(total_blocks, "sha256", salt);
- dm_bht_set_root_hexdigest(bht_.get(),
+ dm_bht_set_root_hexdigest(bht_,
reinterpret_cast<const u8 *>(kRootDigest));
for (unsigned int blocks = 0; blocks < total_blocks; ++blocks) {
DLOG(INFO) << "verifying block: " << blocks;
- EXPECT_EQ(0, dm_bht_verify_block(bht_.get(), blocks,
+ EXPECT_EQ(0, dm_bht_verify_block(bht_, blocks,
virt_to_page(zero_page), 0));
}
- EXPECT_EQ(0, dm_bht_destroy(bht_.get()));
+ EXPECT_EQ(0, dm_bht_destroy(bht_));
free(zero_page);
}
diff --git a/file_hasher_unittest.cc b/file_hasher_unittest.cc
index 3dff901..83c7af4 100644
--- a/file_hasher_unittest.cc
+++ b/file_hasher_unittest.cc
@@ -5,11 +5,10 @@
// Tests for verity::FileHasher
#include "verity/file_hasher.h"
-#include <base/basictypes.h>
-#include <base/memory/scoped_ptr.h>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
+#include "verity/logging.h"
#include "verity/simple_file/mock_file.h"
#include "verity/utils.h"
@@ -25,14 +24,21 @@
FileHasherTest() :
src_(new simple_file::MockFile()),
dst_(new simple_file::MockFile()) { }
- ~FileHasherTest() { }
+ ~FileHasherTest() {
+ delete src_;
+ delete dst_;
+ if (hasher_)
+ delete hasher_;
+ }
void SetUp() {
- hasher_.reset(new verity::FileHasher());
+ if (hasher_)
+ delete hasher_;
+ hasher_ = new verity::FileHasher();
}
protected:
- scoped_ptr<simple_file::MockFile> src_;
- scoped_ptr<simple_file::MockFile> dst_;
- scoped_ptr<verity::FileHasher> hasher_;
+ simple_file::MockFile *src_;
+ simple_file::MockFile *dst_;
+ verity::FileHasher *hasher_;
};
static char last_digest_match[256] = { 0 };
diff --git a/logging.h b/logging.h
index b86f9eb..89035d3 100644
--- a/logging.h
+++ b/logging.h
@@ -2,21 +2,11 @@
// Use of this source code is governed by the GPL v2 license that can
// be found in the LICENSE file.
//
-// Includes the correct logging library, either google-log or chrome logging.
+// Provides a crude google-log compatible logging facility.
#ifndef VERITY_LOGGING_H_
#define VERITY_LOGGING_H_
-#if defined(WITH_CHROME)
-# include <base/logging.h>
-# define INIT_LOGGING(name, flags...) { \
- logging::InitLogging(NULL, \
- logging::LOG_ONLY_TO_SYSTEM_DEBUG_LOG, \
- logging::DONT_LOCK_LOG_FILE, \
- logging::APPEND_TO_OLD_LOG_FILE); \
- }
-#else
-# include "verity/logging/logging.h"
-# define INIT_LOGGING(name, flags...) { }
-#endif
+#include "verity/logging/logging.h"
+#define INIT_LOGGING(name, flags...) { }
#endif // VERITY_LOGGING_H_
