tequilaOS/platform_build
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Merge "aconfig: remove read api lib's dependency on libbase and liblog" into main

Browse source
This commit is contained in:
Dennis Shen 2024-05-23 15:27:16 +00:00 committed by Gerrit Code Review
commit 25889d80af
7 changed files with 113 additions and 59 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
tools/aconfig/aconfig/templates/cpp_source_file.template
View file

@ -124,14 +124,14 @@ bool {header}_{item.flag_name}() \{
"{item.container}",
aconfig_storage::StorageFileType::package_map);
if (!package_map_file.ok()) \{
ALOGI("error: failed to get package map file: %s", package_map_file.error().message().c_str());
ALOGI("error: failed to get package map file: %s", package_map_file.error().c_str());
return result;
}
auto package_read_context = aconfig_storage::get_package_read_context(
**package_map_file, "{package}");
if (!package_read_context.ok()) \{
ALOGI("error: failed to get package read context: %s", package_map_file.error().message().c_str());
ALOGI("error: failed to get package read context: %s", package_map_file.error().c_str());
return result;
}
@ -141,7 +141,7 @@ bool {header}_{item.flag_name}() \{
"{item.container}",
aconfig_storage::StorageFileType::flag_val);
if (!flag_val_map.ok()) \{
ALOGI("error: failed to get flag val map: %s", package_map_file.error().message().c_str());
ALOGI("error: failed to get flag val map: %s", package_map_file.error().c_str());
return result;
}
@ -149,7 +149,7 @@ bool {header}_{item.flag_name}() \{
**flag_val_map,
package_read_context->boolean_start_index + {item.flag_offset});
if (!value.ok()) \{
ALOGI("error: failed to get flag val: %s", package_map_file.error().message().c_str());
ALOGI("error: failed to get flag val: %s", package_map_file.error().c_str());
return result;
}

5
tools/aconfig/aconfig_storage_read_api/Android.bp
View file

@ -90,10 +90,6 @@ cc_library {
host_supported: true,
vendor_available: true,
product_available: true,
shared_libs: [
"liblog",
"libbase",
],
apex_available: [
"//apex_available:platform",
"//apex_available:anyapex",
@ -105,6 +101,7 @@ cc_library {
},
},
double_loadable: true,
afdo: true,
}
cc_defaults {

53
tools/aconfig/aconfig_storage_read_api/aconfig_storage_read_api.cpp
View file

@ -1,16 +1,13 @@
#include <android-base/file.h>
#include <android-base/logging.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#include "rust/cxx.h"
#include "aconfig_storage/lib.rs.h"
#include "aconfig_storage/aconfig_storage_read_api.hpp"
using namespace android::base;
namespace aconfig_storage {
/// Storage location pb file
@ -36,7 +33,9 @@ static Result<std::string> find_storage_file(
case StorageFileType::flag_info:
return storage_dir + "/boot/" + container + ".info";
default:
return Error() << "Invalid file type " << file_type;
auto result = Result<std::string>();
result.errmsg = "Invalid storage file type";
return result;
}
}
@ -49,7 +48,9 @@ Result<MappedStorageFile*> get_mapped_file_impl(
StorageFileType file_type) {
auto file_result = find_storage_file(storage_dir, container, file_type);
if (!file_result.ok()) {
return Error() << file_result.error();
auto result = Result<MappedStorageFile*>();
result.errmsg = file_result.error();
return result;
}
return map_storage_file(*file_result);
}
@ -60,18 +61,24 @@ Result<MappedStorageFile*> get_mapped_file_impl(
Result<MappedStorageFile*> map_storage_file(std::string const& file) {
int fd = open(file.c_str(), O_CLOEXEC | O_NOFOLLOW | O_RDONLY);
if (fd == -1) {
return ErrnoError() << "failed to open " << file;
auto result = Result<MappedStorageFile*>();
result.errmsg = std::string("failed to open ") + file + ": " + strerror(errno);
return result;
};
struct stat fd_stat;
if (fstat(fd, &fd_stat) < 0) {
return ErrnoError() << "fstat failed";
auto result = Result<MappedStorageFile*>();
result.errmsg = std::string("fstat failed: ") + strerror(errno);
return result;
}
size_t file_size = fd_stat.st_size;
void* const map_result = mmap(nullptr, file_size, PROT_READ, MAP_SHARED, fd, 0);
if (map_result == MAP_FAILED) {
return ErrnoError() << "mmap failed";
auto result = Result<MappedStorageFile*>();
result.errmsg = std::string("mmap failed: ") + strerror(errno);
return result;
}
auto mapped_file = new MappedStorageFile();
@ -82,7 +89,7 @@ Result<MappedStorageFile*> map_storage_file(std::string const& file) {
}
/// Map from StoredFlagType to FlagValueType
android::base::Result<FlagValueType> map_to_flag_value_type(
Result<FlagValueType> map_to_flag_value_type(
StoredFlagType stored_type) {
switch (stored_type) {
case StoredFlagType::ReadWriteBoolean:
@ -90,7 +97,9 @@ android::base::Result<FlagValueType> map_to_flag_value_type(
case StoredFlagType::FixedReadOnlyBoolean:
return FlagValueType::Boolean;
default:
return Error() << "Unsupported stored flag type";
auto result = Result<FlagValueType>();
result.errmsg = "Unsupported stored flag type";
return result;
}
}
@ -110,7 +119,9 @@ Result<uint32_t> get_storage_file_version(
if (version_cxx.query_success) {
return version_cxx.version_number;
} else {
return Error() << version_cxx.error_message;
auto result = Result<uint32_t>();
result.errmsg = version_cxx.error_message.c_str();
return result;
}
}
@ -128,7 +139,9 @@ Result<PackageReadContext> get_package_read_context(
context.boolean_start_index = context_cxx.boolean_start_index;
return context;
} else {
return Error() << context_cxx.error_message;
auto result = Result<PackageReadContext>();
result.errmsg = context_cxx.error_message.c_str();
return result;
}
}
@ -147,7 +160,9 @@ Result<FlagReadContext> get_flag_read_context(
context.flag_index = context_cxx.flag_index;
return context;
} else {
return Error() << context_cxx.error_message;
auto result = Result<FlagReadContext>();
result.errmsg = context_cxx.error_message.c_str();
return result;
}
}
@ -161,7 +176,9 @@ Result<bool> get_boolean_flag_value(
if (value_cxx.query_success) {
return value_cxx.flag_value;
} else {
return Error() << value_cxx.error_message;
auto result = Result<bool>();
result.errmsg = value_cxx.error_message.c_str();
return result;
}
}
@ -177,7 +194,9 @@ Result<uint8_t> get_flag_attribute(
if (info_cxx.query_success) {
return info_cxx.flag_attribute;
} else {
return Error() << info_cxx.error_message;
auto result = Result<uint8_t>();
result.errmsg = info_cxx.error_message.c_str();
return result;
}
}
} // namespace aconfig_storage

62
tools/aconfig/aconfig_storage_read_api/include/aconfig_storage/aconfig_storage_read_api.hpp
View file

@ -2,7 +2,7 @@
#include <stdint.h>
#include <string>
#include <android-base/result.h>
#include <cassert>
namespace aconfig_storage {
@ -58,46 +58,86 @@ struct FlagReadContext {
uint16_t flag_index;
};
template <class T>
class Result {
public:
Result()
: data()
, errmsg()
, has_data(false)
{}
Result(T const& value)
: data(value)
, errmsg()
, has_data(true)
{}
bool ok() {
return has_data;
}
T& operator*() {
assert(has_data);
return data;
}
T* operator->() {
assert(has_data);
return &data;
}
std::string const& error() {
assert(!has_data);
return errmsg;
}
T data;
std::string errmsg;
bool has_data;
};
/// DO NOT USE APIS IN THE FOLLOWING NAMESPACE DIRECTLY
namespace private_internal_api {
android::base::Result<MappedStorageFile*> get_mapped_file_impl(
Result<MappedStorageFile*> get_mapped_file_impl(
std::string const& pb_file,
std::string const& container,
StorageFileType file_type);
} // namespace private_internal_api
/// Map a storage file
android::base::Result<MappedStorageFile*> map_storage_file(
Result<MappedStorageFile*> map_storage_file(
std::string const& file);
/// Map from StoredFlagType to FlagValueType
/// \input stored_type: stored flag type in the storage file
/// \returns the flag value type enum
android::base::Result<FlagValueType> map_to_flag_value_type(
Result<FlagValueType> map_to_flag_value_type(
StoredFlagType stored_type);
/// Get mapped storage file
/// \input container: stoarge container name
/// \input file_type: storage file type enum
/// \returns a MappedStorageFileQuery
android::base::Result<MappedStorageFile*> get_mapped_file(
Result<MappedStorageFile*> get_mapped_file(
std::string const& container,
StorageFileType file_type);
/// Get storage file version number
/// \input file_path: the path to the storage file
/// \returns the storage file version
android::base::Result<uint32_t> get_storage_file_version(
Result<uint32_t> get_storage_file_version(
std::string const& file_path);
/// Get package read context
/// \input file: mapped storage file
/// \input package: the flag package name
/// \returns a package read context
android::base::Result<PackageReadContext> get_package_read_context(
Result<PackageReadContext> get_package_read_context(
MappedStorageFile const& file,
std::string const& package);
@ -106,7 +146,7 @@ android::base::Result<PackageReadContext> get_package_read_context(
/// \input package_id: the flag package id obtained from package offset query
/// \input flag_name: flag name
/// \returns the flag read context
android::base::Result<FlagReadContext> get_flag_read_context(
Result<FlagReadContext> get_flag_read_context(
MappedStorageFile const& file,
uint32_t package_id,
std::string const& flag_name);
@ -115,7 +155,7 @@ android::base::Result<FlagReadContext> get_flag_read_context(
/// \input file: mapped storage file
/// \input index: the boolean flag index in the file
/// \returns the boolean flag value
android::base::Result<bool> get_boolean_flag_value(
Result<bool> get_boolean_flag_value(
MappedStorageFile const& file,
uint32_t index);
@ -124,7 +164,7 @@ android::base::Result<bool> get_boolean_flag_value(
/// \input value_type: flag value type
/// \input index: the boolean flag index in the file
/// \returns the boolean flag attribute
android::base::Result<uint8_t> get_flag_attribute(
Result<uint8_t> get_flag_attribute(
MappedStorageFile const& file,
FlagValueType value_type,
uint32_t index);

6
tools/aconfig/aconfig_storage_read_api/tests/storage_read_api_test.cpp
View file

@ -97,7 +97,7 @@ TEST_F(AconfigStorageTest, test_none_exist_storage_file_mapping) {
auto mapped_file_result = private_api::get_mapped_file_impl(
storage_dir, "vendor", api::StorageFileType::package_map);
ASSERT_FALSE(mapped_file_result.ok());
ASSERT_EQ(mapped_file_result.error().message(),
ASSERT_EQ(mapped_file_result.error(),
std::string("failed to open ") + storage_dir
+ "/maps/vendor.package.map: No such file or directory");
}
@ -211,7 +211,7 @@ TEST_F(AconfigStorageTest, test_invalid_boolean_flag_value_query) {
auto value = api::get_boolean_flag_value(*mapped_file, 8);
ASSERT_FALSE(value.ok());
ASSERT_EQ(value.error().message(),
ASSERT_EQ(value.error(),
std::string("InvalidStorageFileOffset(Flag value offset goes beyond the end of the file.)"));
}
@ -243,6 +243,6 @@ TEST_F(AconfigStorageTest, test_invalid_boolean_flag_info_query) {
auto attribute = api::get_flag_attribute(*mapped_file, api::FlagValueType::Boolean, 8);
ASSERT_FALSE(attribute.ok());
ASSERT_EQ(attribute.error().message(),
ASSERT_EQ(attribute.error(),
std::string("InvalidStorageFileOffset(Flag info offset goes beyond the end of the file.)"));
}

27
tools/aconfig/aconfig_storage_write_api/aconfig_storage_write_api.cpp
View file

@ -10,32 +10,31 @@
#include "aconfig_storage/lib.rs.h"
#include "aconfig_storage/aconfig_storage_write_api.hpp"
using namespace android::base;
namespace aconfig_storage {
/// Map a storage file
Result<MutableMappedStorageFile*> map_mutable_storage_file(std::string const& file) {
android::base::Result<MutableMappedStorageFile*> map_mutable_storage_file(
std::string const& file) {
struct stat file_stat;
if (stat(file.c_str(), &file_stat) < 0) {
return ErrnoError() << "stat failed";
return android::base::ErrnoError() << "stat failed";
}
if ((file_stat.st_mode & (S_IWUSR | S_IWGRP | S_IWOTH)) == 0) {
return Error() << "cannot map nonwriteable file";
return android::base::Error() << "cannot map nonwriteable file";
}
size_t file_size = file_stat.st_size;
const int fd = open(file.c_str(), O_RDWR | O_NOFOLLOW | O_CLOEXEC);
if (fd == -1) {
return ErrnoError() << "failed to open " << file;
return android::base::ErrnoError() << "failed to open " << file;
};
void* const map_result =
mmap(nullptr, file_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
if (map_result == MAP_FAILED) {
return ErrnoError() << "mmap failed";
return android::base::ErrnoError() << "mmap failed";
}
auto mapped_file = new MutableMappedStorageFile();
@ -46,7 +45,7 @@ Result<MutableMappedStorageFile*> map_mutable_storage_file(std::string const& fi
}
/// Set boolean flag value
Result<void> set_boolean_flag_value(
android::base::Result<void> set_boolean_flag_value(
const MutableMappedStorageFile& file,
uint32_t offset,
bool value) {
@ -54,13 +53,13 @@ Result<void> set_boolean_flag_value(
static_cast<uint8_t*>(file.file_ptr), file.file_size);
auto update_cxx = update_boolean_flag_value_cxx(content, offset, value);
if (!update_cxx.update_success) {
return Error() << std::string(update_cxx.error_message.c_str());
return android::base::Error() << update_cxx.error_message.c_str();
}
return {};
}
/// Set if flag has server override
Result<void> set_flag_has_server_override(
android::base::Result<void> set_flag_has_server_override(
const MutableMappedStorageFile& file,
FlagValueType value_type,
uint32_t offset,
@ -70,13 +69,13 @@ Result<void> set_flag_has_server_override(
auto update_cxx = update_flag_has_server_override_cxx(
content, static_cast<uint16_t>(value_type), offset, value);
if (!update_cxx.update_success) {
return Error() << std::string(update_cxx.error_message.c_str());
return android::base::Error() << update_cxx.error_message.c_str();
}
return {};
}
/// Set if flag has local override
Result<void> set_flag_has_local_override(
android::base::Result<void> set_flag_has_local_override(
const MutableMappedStorageFile& file,
FlagValueType value_type,
uint32_t offset,
@ -86,12 +85,12 @@ Result<void> set_flag_has_local_override(
auto update_cxx = update_flag_has_local_override_cxx(
content, static_cast<uint16_t>(value_type), offset, value);
if (!update_cxx.update_success) {
return Error() << std::string(update_cxx.error_message.c_str());
return android::base::Error() << update_cxx.error_message.c_str();
}
return {};
}
Result<void> create_flag_info(
android::base::Result<void> create_flag_info(
std::string const& package_map,
std::string const& flag_map,
std::string const& flag_info_out) {

11
tools/aconfig/aconfig_storage_write_api/include/aconfig_storage/aconfig_storage_write_api.hpp
View file

@ -6,7 +6,6 @@
#include <android-base/result.h>
#include <aconfig_storage/aconfig_storage_read_api.hpp>
using namespace android::base;
namespace aconfig_storage {
@ -14,24 +13,24 @@ namespace aconfig_storage {
struct MutableMappedStorageFile : MappedStorageFile {};
/// Map a storage file
Result<MutableMappedStorageFile*> map_mutable_storage_file(
android::base::Result<MutableMappedStorageFile*> map_mutable_storage_file(
std::string const& file);
/// Set boolean flag value
Result<void> set_boolean_flag_value(
android::base::Result<void> set_boolean_flag_value(
const MutableMappedStorageFile& file,
uint32_t offset,
bool value);
/// Set if flag has server override
Result<void> set_flag_has_server_override(
android::base::Result<void> set_flag_has_server_override(
const MutableMappedStorageFile& file,
FlagValueType value_type,
uint32_t offset,
bool value);
/// Set if flag has local override
Result<void> set_flag_has_local_override(
android::base::Result<void> set_flag_has_local_override(
const MutableMappedStorageFile& file,
FlagValueType value_type,
uint32_t offset,
@ -41,7 +40,7 @@ Result<void> set_flag_has_local_override(
/// \input package_map: package map file
/// \input flag_map: flag map file
/// \input flag_info_out: flag info file to be created
Result<void> create_flag_info(
android::base::Result<void> create_flag_info(
std::string const& package_map,
std::string const& flag_map,
std::string const& flag_info_out);