1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
|
#include <android-base/file.h>
#include <android-base/logging.h>
#include <protos/aconfig_storage_metadata.pb.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "rust/cxx.h"
#include "aconfig_storage/lib.rs.h"
#include "aconfig_storage/aconfig_storage_read_api.hpp"
using storage_records_pb = android::aconfig_storage_metadata::storage_files;
using storage_record_pb = android::aconfig_storage_metadata::storage_file_info;
using namespace android::base;
namespace aconfig_storage {
/// Storage location pb file
static constexpr char kAvailableStorageRecordsPb[] =
"/metadata/aconfig/boot/available_storage_file_records.pb";
/// Read aconfig storage records pb file
static Result<storage_records_pb> read_storage_records_pb(std::string const& pb_file) {
auto records = storage_records_pb();
auto content = std::string();
if (!ReadFileToString(pb_file, &content)) {
return ErrnoError() << "ReadFileToString failed";
}
if (!records.ParseFromString(content)) {
return ErrnoError() << "Unable to parse persistent storage records protobuf";
}
return records;
}
/// Get storage file path
static Result<std::string> find_storage_file(
std::string const& pb_file,
std::string const& container,
StorageFileType file_type) {
auto records_pb = read_storage_records_pb(pb_file);
if (!records_pb.ok()) {
return Error() << "Unable to read storage records from " << pb_file
<< " : " << records_pb.error();
}
for (auto& entry : records_pb->files()) {
if (entry.container() == container) {
switch(file_type) {
case StorageFileType::package_map:
return entry.package_map();
case StorageFileType::flag_map:
return entry.flag_map();
case StorageFileType::flag_val:
return entry.flag_val();
default:
return Error() << "Invalid file type " << file_type;
}
}
}
return Error() << "Unable to find storage files for container " << container;;
}
/// Map a storage file
static 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 Error() << "failed to open " << file;
};
struct stat fd_stat;
if (fstat(fd, &fd_stat) < 0) {
return Error() << "fstat failed";
}
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 Error() << "mmap failed";
}
auto mapped_file = MappedStorageFile();
mapped_file.file_ptr = map_result;
mapped_file.file_size = file_size;
return mapped_file;
}
namespace private_internal_api {
/// Get mapped file implementation.
Result<MappedStorageFile> get_mapped_file_impl(
std::string const& pb_file,
std::string const& container,
StorageFileType file_type) {
auto file_result = find_storage_file(pb_file, container, file_type);
if (!file_result.ok()) {
return Error() << file_result.error();
}
return map_storage_file(*file_result);
}
} // namespace private internal api
/// Get mapped storage file
Result<MappedStorageFile> get_mapped_file(
std::string const& container,
StorageFileType file_type) {
return private_internal_api::get_mapped_file_impl(
kAvailableStorageRecordsPb, container, file_type);
}
/// Get storage file version number
Result<uint32_t> get_storage_file_version(
std::string const& file_path) {
auto version_cxx = get_storage_file_version_cxx(
rust::Str(file_path.c_str()));
if (version_cxx.query_success) {
return version_cxx.version_number;
} else {
return Error() << version_cxx.error_message;
}
}
/// Get package offset
Result<PackageOffset> get_package_offset(
MappedStorageFile const& file,
std::string const& package) {
auto content = rust::Slice<const uint8_t>(
static_cast<uint8_t*>(file.file_ptr), file.file_size);
auto offset_cxx = get_package_offset_cxx(content, rust::Str(package.c_str()));
if (offset_cxx.query_success) {
auto offset = PackageOffset();
offset.package_exists = offset_cxx.package_exists;
offset.package_id = offset_cxx.package_id;
offset.boolean_offset = offset_cxx.boolean_offset;
return offset;
} else {
return Error() << offset_cxx.error_message;
}
}
/// Get flag offset
Result<FlagOffset> get_flag_offset(
MappedStorageFile const& file,
uint32_t package_id,
std::string const& flag_name){
auto content = rust::Slice<const uint8_t>(
static_cast<uint8_t*>(file.file_ptr), file.file_size);
auto offset_cxx = get_flag_offset_cxx(content, package_id, rust::Str(flag_name.c_str()));
if (offset_cxx.query_success) {
auto offset = FlagOffset();
offset.flag_exists = offset_cxx.flag_exists;
offset.flag_offset = offset_cxx.flag_offset;
return offset;
} else {
return Error() << offset_cxx.error_message;
}
}
/// Get boolean flag value
Result<bool> get_boolean_flag_value(
MappedStorageFile const& file,
uint32_t offset) {
auto content = rust::Slice<const uint8_t>(
static_cast<uint8_t*>(file.file_ptr), file.file_size);
auto value_cxx = get_boolean_flag_value_cxx(content, offset);
if (value_cxx.query_success) {
return value_cxx.flag_value;
} else {
return Error() << value_cxx.error_message;
}
}
} // namespace aconfig_storage
|
