blob: a3f283873b553f60d644e852e15c2629b018ac2a [file] [log] [blame]
Yifan Hong4d18bcc2017-04-07 21:47:16 +00001/*
2 * Copyright (C) 2017 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include <stdlib.h>
18#include <unistd.h>
19
20#include <fstream>
21#include <iostream>
Yifan Hong4d18bcc2017-04-07 21:47:16 +000022#include <sstream>
23#include <string>
Yifan Hong8302cea2017-12-18 20:17:05 -080024#include <unordered_map>
Yifan Hong4d18bcc2017-04-07 21:47:16 +000025
Yifan Hong9a8b1a72017-08-25 17:55:33 -070026#include <android-base/file.h>
Yifan Hongdbe9db32017-12-11 19:06:11 -080027#include <android-base/parseint.h>
Yifan Hongb83e56b2018-01-09 14:36:30 -080028#include <android-base/strings.h>
Yifan Hong9a8b1a72017-08-25 17:55:33 -070029
Yifan Hong8302cea2017-12-18 20:17:05 -080030#include <vintf/AssembleVintf.h>
Yifan Hong79efa8a2017-07-06 14:10:28 -070031#include <vintf/KernelConfigParser.h>
Yifan Hong4d18bcc2017-04-07 21:47:16 +000032#include <vintf/parse_string.h>
33#include <vintf/parse_xml.h>
Yifan Hong8302cea2017-12-18 20:17:05 -080034#include "utils.h"
Yifan Hong4d18bcc2017-04-07 21:47:16 +000035
Yifan Hong79efa8a2017-07-06 14:10:28 -070036#define BUFFER_SIZE sysconf(_SC_PAGESIZE)
37
Yifan Hong4d18bcc2017-04-07 21:47:16 +000038namespace android {
39namespace vintf {
40
Yifan Hong9a8b1a72017-08-25 17:55:33 -070041static const std::string gConfigPrefix = "android-base-";
42static const std::string gConfigSuffix = ".cfg";
43static const std::string gBaseConfig = "android-base.cfg";
44
Yifan Hongaa219f52017-12-18 18:51:59 -080045// An input stream with a name.
46// The input stream may be an actual file, or a stringstream for testing.
47// It takes ownership on the istream.
48class NamedIstream {
49 public:
50 NamedIstream(const std::string& name, std::unique_ptr<std::istream>&& stream)
51 : mName(name), mStream(std::move(stream)) {}
52 const std::string& name() const { return mName; }
53 std::istream& stream() { return *mStream; }
54
55 private:
56 std::string mName;
57 std::unique_ptr<std::istream> mStream;
58};
59
Yifan Hong4d18bcc2017-04-07 21:47:16 +000060/**
61 * Slurps the device manifest file and add build time flag to it.
62 */
Yifan Hong8302cea2017-12-18 20:17:05 -080063class AssembleVintfImpl : public AssembleVintf {
Yifan Hong9a8b1a72017-08-25 17:55:33 -070064 using Condition = std::unique_ptr<KernelConfig>;
65 using ConditionedConfig = std::pair<Condition, std::vector<KernelConfig> /* configs */>;
66
67 public:
Yifan Hong8302cea2017-12-18 20:17:05 -080068 void setFakeEnv(const std::string& key, const std::string& value) { mFakeEnv[key] = value; }
69
70 std::string getEnv(const std::string& key) const {
71 auto it = mFakeEnv.find(key);
72 if (it != mFakeEnv.end()) {
73 return it->second;
74 }
75 const char* envValue = getenv(key.c_str());
76 return envValue != nullptr ? std::string(envValue) : std::string();
77 }
78
79 template <typename T>
80 bool getFlag(const std::string& key, T* value) const {
81 std::string envValue = getEnv(key);
82 if (envValue.empty()) {
83 std::cerr << "Warning: " << key << " is missing, defaulted to " << (*value) << "."
Yifan Hong488e16a2017-07-11 13:50:41 -070084 << std::endl;
85 return true;
Yifan Hong4d18bcc2017-04-07 21:47:16 +000086 }
87
88 if (!parse(envValue, value)) {
89 std::cerr << "Cannot parse " << envValue << "." << std::endl;
90 return false;
91 }
92 return true;
93 }
94
Yifan Hongeff04662017-12-18 16:27:24 -080095 /**
96 * Set *out to environment variable if *out is not a dummy value (i.e. default constructed).
97 */
98 template <typename T>
Yifan Hong8302cea2017-12-18 20:17:05 -080099 bool getFlagIfUnset(const std::string& envKey, T* out) const {
Yifan Hongeff04662017-12-18 16:27:24 -0800100 bool hasExistingValue = !(*out == T{});
101
102 bool hasEnvValue = false;
103 T envValue;
Yifan Hong8302cea2017-12-18 20:17:05 -0800104 std::string envStrValue = getEnv(envKey);
105 if (!envStrValue.empty()) {
106 if (!parse(envStrValue, &envValue)) {
107 std::cerr << "Cannot parse " << envValue << "." << std::endl;
Yifan Hongeff04662017-12-18 16:27:24 -0800108 return false;
109 }
110 hasEnvValue = true;
111 }
112
113 if (hasExistingValue) {
114 if (hasEnvValue) {
115 std::cerr << "Warning: cannot override existing value " << *out << " with "
116 << envKey << " (which is " << envValue << ")." << std::endl;
117 }
118 return false;
119 }
120 if (!hasEnvValue) {
121 std::cerr << "Warning: " << envKey << " is not specified. Default to " << T{} << "."
122 << std::endl;
123 return false;
124 }
125 *out = envValue;
126 return true;
127 }
128
Yifan Hong8302cea2017-12-18 20:17:05 -0800129 bool getBooleanFlag(const std::string& key) const { return getEnv(key) == std::string("true"); }
Yifan Hongdbe9db32017-12-11 19:06:11 -0800130
Yifan Hong8302cea2017-12-18 20:17:05 -0800131 size_t getIntegerFlag(const std::string& key, size_t defaultValue = 0) const {
132 std::string envValue = getEnv(key);
Yifan Hongdbe9db32017-12-11 19:06:11 -0800133 if (envValue.empty()) {
134 return defaultValue;
135 }
136 size_t value;
137 if (!base::ParseUint(envValue, &value)) {
138 std::cerr << "Error: " << key << " must be a number." << std::endl;
139 return defaultValue;
140 }
141 return value;
142 }
143
Yifan Hong4650ad82017-05-01 17:28:02 -0700144 static std::string read(std::basic_istream<char>& is) {
145 std::stringstream ss;
146 ss << is.rdbuf();
147 return ss.str();
148 }
149
Yifan Hong9a8b1a72017-08-25 17:55:33 -0700150 static bool isCommonConfig(const std::string& path) {
151 return ::android::base::Basename(path) == gBaseConfig;
152 }
153
Yifan Hongdbe9db32017-12-11 19:06:11 -0800154 static Level convertFromApiLevel(size_t apiLevel) {
155 if (apiLevel < 26) {
156 return Level::LEGACY;
157 } else if (apiLevel == 26) {
158 return Level::O;
159 } else if (apiLevel == 27) {
160 return Level::O_MR1;
161 } else {
162 return Level::UNSPECIFIED;
163 }
164 }
165
Yifan Hong079ec242017-08-25 18:53:38 -0700166 // nullptr on any error, otherwise the condition.
167 static Condition generateCondition(const std::string& path) {
168 std::string fname = ::android::base::Basename(path);
169 if (fname.size() <= gConfigPrefix.size() + gConfigSuffix.size() ||
170 !std::equal(gConfigPrefix.begin(), gConfigPrefix.end(), fname.begin()) ||
171 !std::equal(gConfigSuffix.rbegin(), gConfigSuffix.rend(), fname.rbegin())) {
172 return nullptr;
173 }
174
175 std::string sub = fname.substr(gConfigPrefix.size(),
176 fname.size() - gConfigPrefix.size() - gConfigSuffix.size());
177 if (sub.empty()) {
178 return nullptr; // should not happen
179 }
180 for (size_t i = 0; i < sub.size(); ++i) {
181 if (sub[i] == '-') {
182 sub[i] = '_';
183 continue;
184 }
185 if (isalnum(sub[i])) {
186 sub[i] = toupper(sub[i]);
187 continue;
188 }
189 std::cerr << "'" << fname << "' (in " << path
190 << ") is not a valid kernel config file name. Must match regex: "
191 << "android-base(-[0-9a-zA-Z-]+)?\\.cfg" << std::endl;
192 return nullptr;
193 }
194 sub.insert(0, "CONFIG_");
195 return std::make_unique<KernelConfig>(std::move(sub), Tristate::YES);
196 }
197
Yifan Hong8302cea2017-12-18 20:17:05 -0800198 static bool parseFileForKernelConfigs(std::basic_istream<char>& stream,
199 std::vector<KernelConfig>* out) {
Yifan Hong02e94002017-07-10 15:41:56 -0700200 KernelConfigParser parser(true /* processComments */, true /* relaxedFormat */);
Yifan Hong8302cea2017-12-18 20:17:05 -0800201 std::string content = read(stream);
Yifan Hong79efa8a2017-07-06 14:10:28 -0700202 status_t err = parser.process(content.c_str(), content.size());
203 if (err != OK) {
Yifan Hongae53a0e2017-07-07 15:19:06 -0700204 std::cerr << parser.error();
Yifan Hong79efa8a2017-07-06 14:10:28 -0700205 return false;
206 }
207 err = parser.finish();
208 if (err != OK) {
Yifan Hongae53a0e2017-07-07 15:19:06 -0700209 std::cerr << parser.error();
Yifan Hong79efa8a2017-07-06 14:10:28 -0700210 return false;
211 }
212
213 for (auto& configPair : parser.configs()) {
214 out->push_back({});
215 KernelConfig& config = out->back();
216 config.first = std::move(configPair.first);
217 if (!parseKernelConfigTypedValue(configPair.second, &config.second)) {
218 std::cerr << "Unknown value type for key = '" << config.first << "', value = '"
219 << configPair.second << "'\n";
220 return false;
221 }
222 }
223 return true;
224 }
225
Yifan Hong8302cea2017-12-18 20:17:05 -0800226 static bool parseFilesForKernelConfigs(std::vector<NamedIstream>* streams,
Yifan Hong9a8b1a72017-08-25 17:55:33 -0700227 std::vector<ConditionedConfig>* out) {
228 out->clear();
229 ConditionedConfig commonConfig;
230 bool foundCommonConfig = false;
Steve Muckle0bef8682017-07-31 15:47:15 -0700231 bool ret = true;
Yifan Hong8302cea2017-12-18 20:17:05 -0800232
233 for (auto& namedStream : *streams) {
234 if (isCommonConfig(namedStream.name())) {
235 ret &= parseFileForKernelConfigs(namedStream.stream(), &commonConfig.second);
Yifan Hong9a8b1a72017-08-25 17:55:33 -0700236 foundCommonConfig = true;
237 } else {
Yifan Hong8302cea2017-12-18 20:17:05 -0800238 Condition condition = generateCondition(namedStream.name());
Yifan Hong079ec242017-08-25 18:53:38 -0700239 ret &= (condition != nullptr);
240
Yifan Hong9a8b1a72017-08-25 17:55:33 -0700241 std::vector<KernelConfig> kernelConfigs;
Yifan Hong8302cea2017-12-18 20:17:05 -0800242 if ((ret &= parseFileForKernelConfigs(namedStream.stream(), &kernelConfigs)))
Yifan Hong079ec242017-08-25 18:53:38 -0700243 out->emplace_back(std::move(condition), std::move(kernelConfigs));
Yifan Hong9a8b1a72017-08-25 17:55:33 -0700244 }
Steve Muckle0bef8682017-07-31 15:47:15 -0700245 }
Yifan Hong9a8b1a72017-08-25 17:55:33 -0700246
247 if (!foundCommonConfig) {
Yifan Hong8302cea2017-12-18 20:17:05 -0800248 std::cerr << "No android-base.cfg is found in these paths:" << std::endl;
249 for (auto& namedStream : *streams) {
250 std::cerr << " " << namedStream.name() << std::endl;
251 }
Yifan Hong9a8b1a72017-08-25 17:55:33 -0700252 }
253 ret &= foundCommonConfig;
254 // first element is always common configs (no conditions).
255 out->insert(out->begin(), std::move(commonConfig));
Steve Muckle0bef8682017-07-31 15:47:15 -0700256 return ret;
257 }
258
Yifan Hong8302cea2017-12-18 20:17:05 -0800259 std::basic_ostream<char>& out() const { return mOutRef == nullptr ? std::cout : *mOutRef; }
Yifan Hong9aa63702017-05-16 16:37:50 -0700260
Yifan Hongdbe9db32017-12-11 19:06:11 -0800261 template <typename S>
Yifan Hongffcaf992018-01-09 17:08:51 -0800262 using Schemas = std::vector<Named<S>>;
Yifan Hongdbe9db32017-12-11 19:06:11 -0800263 using HalManifests = Schemas<HalManifest>;
264 using CompatibilityMatrices = Schemas<CompatibilityMatrix>;
265
266 bool assembleHalManifest(HalManifests* halManifests) {
Yifan Hong4650ad82017-05-01 17:28:02 -0700267 std::string error;
Yifan Hongffcaf992018-01-09 17:08:51 -0800268 HalManifest* halManifest = &halManifests->front().object;
Yifan Hongdbe9db32017-12-11 19:06:11 -0800269 for (auto it = halManifests->begin() + 1; it != halManifests->end(); ++it) {
Yifan Hongffcaf992018-01-09 17:08:51 -0800270 const std::string& path = it->name;
271 HalManifest& halToAdd = it->object;
Yifan Hongdbe9db32017-12-11 19:06:11 -0800272
273 if (halToAdd.level() != Level::UNSPECIFIED) {
274 if (halManifest->level() == Level::UNSPECIFIED) {
275 halManifest->mLevel = halToAdd.level();
276 } else if (halManifest->level() != halToAdd.level()) {
277 std::cerr << "Inconsistent FCM Version in HAL manifests:" << std::endl
Yifan Hongffcaf992018-01-09 17:08:51 -0800278 << " File '" << halManifests->front().name << "' has level "
Yifan Hongdbe9db32017-12-11 19:06:11 -0800279 << halManifest->level() << std::endl
280 << " File '" << path << "' has level " << halToAdd.level()
281 << std::endl;
282 return false;
283 }
284 }
285
Yifan Hongea25dd42017-12-18 17:03:24 -0800286 if (!halManifest->addAllHals(&halToAdd, &error)) {
Yifan Hongdbe9db32017-12-11 19:06:11 -0800287 std::cerr << "File \"" << path << "\" cannot be added: conflict on HAL \"" << error
288 << "\" with an existing HAL. See <hal> with the same name "
289 << "in previously parsed files or previously declared in this file."
290 << std::endl;
291 return false;
292 }
293 }
Yifan Hong9aa63702017-05-16 16:37:50 -0700294
295 if (halManifest->mType == SchemaType::DEVICE) {
296 if (!getFlag("BOARD_SEPOLICY_VERS", &halManifest->device.mSepolicyVersion)) {
297 return false;
298 }
Yifan Hongdbe9db32017-12-11 19:06:11 -0800299 if (!setDeviceFcmVersion(halManifest)) {
300 return false;
301 }
Yifan Hong9aa63702017-05-16 16:37:50 -0700302 }
303
304 if (mOutputMatrix) {
305 CompatibilityMatrix generatedMatrix = halManifest->generateCompatibleMatrix();
306 if (!halManifest->checkCompatibility(generatedMatrix, &error)) {
307 std::cerr << "FATAL ERROR: cannot generate a compatible matrix: " << error
308 << std::endl;
309 }
310 out() << "<!-- \n"
311 " Autogenerated skeleton compatibility matrix. \n"
312 " Use with caution. Modify it to suit your needs.\n"
313 " All HALs are set to optional.\n"
314 " Many entries other than HALs are zero-filled and\n"
315 " require human attention. \n"
316 "-->\n"
Yifan Honga2635c42017-12-12 13:20:33 -0800317 << gCompatibilityMatrixConverter(generatedMatrix, mSerializeFlags);
Yifan Hong9aa63702017-05-16 16:37:50 -0700318 } else {
Yifan Honga2635c42017-12-12 13:20:33 -0800319 out() << gHalManifestConverter(*halManifest, mSerializeFlags);
Yifan Hong9aa63702017-05-16 16:37:50 -0700320 }
321 out().flush();
322
Yifan Hong8302cea2017-12-18 20:17:05 -0800323 if (mCheckFile != nullptr) {
Yifan Hong9aa63702017-05-16 16:37:50 -0700324 CompatibilityMatrix checkMatrix;
Yifan Hong8302cea2017-12-18 20:17:05 -0800325 if (!gCompatibilityMatrixConverter(&checkMatrix, read(*mCheckFile))) {
Yifan Hong9aa63702017-05-16 16:37:50 -0700326 std::cerr << "Cannot parse check file as a compatibility matrix: "
327 << gCompatibilityMatrixConverter.lastError() << std::endl;
328 return false;
329 }
330 if (!halManifest->checkCompatibility(checkMatrix, &error)) {
331 std::cerr << "Not compatible: " << error << std::endl;
332 return false;
333 }
334 }
335
336 return true;
337 }
338
Yifan Honge88e1672017-08-24 14:42:54 -0700339 bool assembleFrameworkCompatibilityMatrixKernels(CompatibilityMatrix* matrix) {
Yifan Hong8302cea2017-12-18 20:17:05 -0800340 for (auto& pair : mKernels) {
Yifan Hong9a8b1a72017-08-25 17:55:33 -0700341 std::vector<ConditionedConfig> conditionedConfigs;
Yifan Hong8302cea2017-12-18 20:17:05 -0800342 if (!parseFilesForKernelConfigs(&pair.second, &conditionedConfigs)) {
Yifan Honge88e1672017-08-24 14:42:54 -0700343 return false;
344 }
Yifan Hong9a8b1a72017-08-25 17:55:33 -0700345 for (ConditionedConfig& conditionedConfig : conditionedConfigs) {
Yifan Hong48602df2017-08-28 13:04:12 -0700346 MatrixKernel kernel(KernelVersion{pair.first.majorVer, pair.first.minorVer, 0u},
347 std::move(conditionedConfig.second));
Yifan Hong079ec242017-08-25 18:53:38 -0700348 if (conditionedConfig.first != nullptr)
349 kernel.mConditions.push_back(std::move(*conditionedConfig.first));
350 matrix->framework.mKernels.push_back(std::move(kernel));
Yifan Hong9a8b1a72017-08-25 17:55:33 -0700351 }
Yifan Honge88e1672017-08-24 14:42:54 -0700352 }
353 return true;
354 }
355
Yifan Hongdbe9db32017-12-11 19:06:11 -0800356 bool setDeviceFcmVersion(HalManifest* manifest) {
357 size_t shippingApiLevel = getIntegerFlag("PRODUCT_SHIPPING_API_LEVEL");
Yifan Hong9aa63702017-05-16 16:37:50 -0700358
Yifan Hongdbe9db32017-12-11 19:06:11 -0800359 if (manifest->level() != Level::UNSPECIFIED) {
360 return true;
361 }
362 if (!getBooleanFlag("PRODUCT_ENFORCE_VINTF_MANIFEST")) {
363 manifest->mLevel = Level::LEGACY;
364 return true;
365 }
366 // TODO(b/70628538): Do not infer from Shipping API level.
367 if (shippingApiLevel) {
368 std::cerr << "Warning: Shipping FCM Version is inferred from Shipping API level. "
369 << "Declare Shipping FCM Version in device manifest directly." << std::endl;
370 manifest->mLevel = convertFromApiLevel(shippingApiLevel);
371 if (manifest->mLevel == Level::UNSPECIFIED) {
372 std::cerr << "Error: Shipping FCM Version cannot be inferred from Shipping API "
373 << "level " << shippingApiLevel << "."
374 << "Declare Shipping FCM Version in device manifest directly."
375 << std::endl;
376 return false;
377 }
378 return true;
379 }
380 // TODO(b/69638851): should be an error if Shipping API level is not defined.
381 // For now, just leave it empty; when framework compatibility matrix is built,
382 // lowest FCM Version is assumed.
383 std::cerr << "Warning: Shipping FCM Version cannot be inferred, because:" << std::endl
384 << " (1) It is not explicitly declared in device manifest;" << std::endl
385 << " (2) PRODUCT_ENFORCE_VINTF_MANIFEST is set to true;" << std::endl
386 << " (3) PRODUCT_SHIPPING_API_LEVEL is undefined." << std::endl
387 << "Assuming 'unspecified' Shipping FCM Version. " << std::endl
388 << "To remove this warning, define 'level' attribute in device manifest."
389 << std::endl;
390 return true;
391 }
392
393 Level getLowestFcmVersion(const CompatibilityMatrices& matrices) {
394 Level ret = Level::UNSPECIFIED;
395 for (const auto& e : matrices) {
Yifan Hongffcaf992018-01-09 17:08:51 -0800396 if (ret == Level::UNSPECIFIED || ret > e.object.level()) {
397 ret = e.object.level();
Yifan Hongdbe9db32017-12-11 19:06:11 -0800398 }
399 }
400 return ret;
401 }
402
403 bool assembleCompatibilityMatrix(CompatibilityMatrices* matrices) {
404 std::string error;
405 CompatibilityMatrix* matrix = nullptr;
Yifan Hongdbe9db32017-12-11 19:06:11 -0800406 std::unique_ptr<HalManifest> checkManifest;
Yifan Hongffcaf992018-01-09 17:08:51 -0800407 if (matrices->front().object.mType == SchemaType::DEVICE) {
408 matrix = &matrices->front().object;
Yifan Hongdbe9db32017-12-11 19:06:11 -0800409 }
410
Yifan Hongffcaf992018-01-09 17:08:51 -0800411 if (matrices->front().object.mType == SchemaType::FRAMEWORK) {
Yifan Hongdbe9db32017-12-11 19:06:11 -0800412 Level deviceLevel = Level::UNSPECIFIED;
Yifan Hong8302cea2017-12-18 20:17:05 -0800413 if (mCheckFile != nullptr) {
Yifan Hongdbe9db32017-12-11 19:06:11 -0800414 checkManifest = std::make_unique<HalManifest>();
Yifan Hong8302cea2017-12-18 20:17:05 -0800415 if (!gHalManifestConverter(checkManifest.get(), read(*mCheckFile))) {
Yifan Hongdbe9db32017-12-11 19:06:11 -0800416 std::cerr << "Cannot parse check file as a HAL manifest: "
417 << gHalManifestConverter.lastError() << std::endl;
418 return false;
419 }
420 deviceLevel = checkManifest->level();
421 }
422
423 if (deviceLevel == Level::UNSPECIFIED) {
424 // For GSI build, legacy devices that do not have a HAL manifest,
425 // and devices in development, merge all compatibility matrices.
426 deviceLevel = getLowestFcmVersion(*matrices);
427 }
428
Yifan Hongddae77e2017-12-18 16:57:07 -0800429 if (deviceLevel == Level::UNSPECIFIED) {
430 // building empty.xml
Yifan Hongffcaf992018-01-09 17:08:51 -0800431 matrix = &matrices->front().object;
Yifan Hongddae77e2017-12-18 16:57:07 -0800432 } else {
433 matrix = CompatibilityMatrix::combine(deviceLevel, matrices, &error);
434 if (matrix == nullptr) {
435 std::cerr << error << std::endl;
Yifan Hongdbe9db32017-12-11 19:06:11 -0800436 return false;
437 }
438 }
439
Yifan Honge88e1672017-08-24 14:42:54 -0700440 if (!assembleFrameworkCompatibilityMatrixKernels(matrix)) {
441 return false;
Yifan Hong79efa8a2017-07-06 14:10:28 -0700442 }
Yifan Honge88e1672017-08-24 14:42:54 -0700443
Yifan Hongf4135012017-12-18 17:27:19 -0800444 // set sepolicy.sepolicy-version to BOARD_SEPOLICY_VERS when none is specified.
445 std::vector<VersionRange>* sepolicyVrs =
446 &matrix->framework.mSepolicy.mSepolicyVersionRanges;
447 VersionRange sepolicyVr;
448 if (!sepolicyVrs->empty()) sepolicyVr = sepolicyVrs->front();
449 if (getFlagIfUnset("BOARD_SEPOLICY_VERS", &sepolicyVr)) {
450 *sepolicyVrs = {{sepolicyVr}};
Yifan Hong7f6c00c2017-07-06 19:50:29 +0000451 }
Yifan Hongf4135012017-12-18 17:27:19 -0800452
453 getFlagIfUnset("POLICYVERS", &matrix->framework.mSepolicy.mKernelSepolicyVersion);
454 getFlagIfUnset("FRAMEWORK_VBMETA_VERSION", &matrix->framework.mAvbMetaVersion);
Yifan Hongdbe9db32017-12-11 19:06:11 -0800455
456 out() << "<!--" << std::endl;
457 out() << " Input:" << std::endl;
Yifan Hongddae77e2017-12-18 16:57:07 -0800458 for (const auto& e : *matrices) {
Yifan Hongffcaf992018-01-09 17:08:51 -0800459 if (!e.name.empty()) {
Yifan Hong4f67f3b2018-01-11 17:05:47 -0800460 out() << " " << base::Basename(e.name) << std::endl;
Yifan Hongddae77e2017-12-18 16:57:07 -0800461 }
Yifan Hongdbe9db32017-12-11 19:06:11 -0800462 }
463 out() << "-->" << std::endl;
Yifan Hong9aa63702017-05-16 16:37:50 -0700464 }
Yifan Honga2635c42017-12-12 13:20:33 -0800465 out() << gCompatibilityMatrixConverter(*matrix, mSerializeFlags);
Yifan Hong9aa63702017-05-16 16:37:50 -0700466 out().flush();
467
Yifan Hongdbe9db32017-12-11 19:06:11 -0800468 if (checkManifest != nullptr && getBooleanFlag("PRODUCT_ENFORCE_VINTF_MANIFEST") &&
469 !checkManifest->checkCompatibility(*matrix, &error)) {
470 std::cerr << "Not compatible: " << error << std::endl;
471 return false;
Yifan Hong9aa63702017-05-16 16:37:50 -0700472 }
473
474 return true;
475 }
476
Yifan Hongbfb3c1d2017-05-24 14:38:48 -0700477 enum AssembleStatus { SUCCESS, FAIL_AND_EXIT, TRY_NEXT };
478 template <typename Schema, typename AssembleFunc>
479 AssembleStatus tryAssemble(const XmlConverter<Schema>& converter, const std::string& schemaName,
480 AssembleFunc assemble) {
Yifan Hongdbe9db32017-12-11 19:06:11 -0800481 Schemas<Schema> schemas;
Yifan Hongbfb3c1d2017-05-24 14:38:48 -0700482 Schema schema;
Yifan Hongaa219f52017-12-18 18:51:59 -0800483 if (!converter(&schema, read(mInFiles.front().stream()))) {
Yifan Hongbfb3c1d2017-05-24 14:38:48 -0700484 return TRY_NEXT;
485 }
486 auto firstType = schema.type();
Yifan Hongaa219f52017-12-18 18:51:59 -0800487 schemas.emplace_back(mInFiles.front().name(), std::move(schema));
Yifan Hongdbe9db32017-12-11 19:06:11 -0800488
Yifan Hongbfb3c1d2017-05-24 14:38:48 -0700489 for (auto it = mInFiles.begin() + 1; it != mInFiles.end(); ++it) {
490 Schema additionalSchema;
Yifan Hongaa219f52017-12-18 18:51:59 -0800491 const std::string& fileName = it->name();
492 if (!converter(&additionalSchema, read(it->stream()))) {
Yifan Hongdbe9db32017-12-11 19:06:11 -0800493 std::cerr << "File \"" << fileName << "\" is not a valid " << firstType << " "
494 << schemaName << " (but the first file is a valid " << firstType << " "
495 << schemaName << "). Error: " << converter.lastError() << std::endl;
Yifan Hongbfb3c1d2017-05-24 14:38:48 -0700496 return FAIL_AND_EXIT;
497 }
498 if (additionalSchema.type() != firstType) {
Yifan Hongdbe9db32017-12-11 19:06:11 -0800499 std::cerr << "File \"" << fileName << "\" is a " << additionalSchema.type() << " "
500 << schemaName << " (but a " << firstType << " " << schemaName
501 << " is expected)." << std::endl;
Yifan Hongbfb3c1d2017-05-24 14:38:48 -0700502 return FAIL_AND_EXIT;
503 }
Yifan Hongdbe9db32017-12-11 19:06:11 -0800504
505 schemas.emplace_back(fileName, std::move(additionalSchema));
Yifan Hongbfb3c1d2017-05-24 14:38:48 -0700506 }
Yifan Hongdbe9db32017-12-11 19:06:11 -0800507 return assemble(&schemas) ? SUCCESS : FAIL_AND_EXIT;
Yifan Hongbfb3c1d2017-05-24 14:38:48 -0700508 }
509
Yifan Hong8302cea2017-12-18 20:17:05 -0800510 bool assemble() override {
Yifan Hongbfb3c1d2017-05-24 14:38:48 -0700511 using std::placeholders::_1;
512 if (mInFiles.empty()) {
Yifan Hong9aa63702017-05-16 16:37:50 -0700513 std::cerr << "Missing input file." << std::endl;
514 return false;
515 }
516
Yifan Hongbfb3c1d2017-05-24 14:38:48 -0700517 auto status = tryAssemble(gHalManifestConverter, "manifest",
Yifan Hong8302cea2017-12-18 20:17:05 -0800518 std::bind(&AssembleVintfImpl::assembleHalManifest, this, _1));
Yifan Hongbfb3c1d2017-05-24 14:38:48 -0700519 if (status == SUCCESS) return true;
520 if (status == FAIL_AND_EXIT) return false;
Yifan Hong4d18bcc2017-04-07 21:47:16 +0000521
Yifan Hongbfb3c1d2017-05-24 14:38:48 -0700522 resetInFiles();
Yifan Honga59d2562017-04-18 18:01:16 -0700523
Yifan Hongbfb3c1d2017-05-24 14:38:48 -0700524 status = tryAssemble(gCompatibilityMatrixConverter, "compatibility matrix",
Yifan Hong8302cea2017-12-18 20:17:05 -0800525 std::bind(&AssembleVintfImpl::assembleCompatibilityMatrix, this, _1));
Yifan Hongbfb3c1d2017-05-24 14:38:48 -0700526 if (status == SUCCESS) return true;
527 if (status == FAIL_AND_EXIT) return false;
Yifan Hong4d18bcc2017-04-07 21:47:16 +0000528
Yifan Hong959ee1b2017-04-28 14:37:56 -0700529 std::cerr << "Input file has unknown format." << std::endl
530 << "Error when attempting to convert to manifest: "
531 << gHalManifestConverter.lastError() << std::endl
532 << "Error when attempting to convert to compatibility matrix: "
533 << gCompatibilityMatrixConverter.lastError() << std::endl;
534 return false;
Yifan Hong4d18bcc2017-04-07 21:47:16 +0000535 }
Yifan Hong9aa63702017-05-16 16:37:50 -0700536
Yifan Hong8302cea2017-12-18 20:17:05 -0800537 std::ostream& setOutputStream(Ostream&& out) override {
538 mOutRef = std::move(out);
539 return *mOutRef;
Yifan Hong9aa63702017-05-16 16:37:50 -0700540 }
541
Yifan Hong8302cea2017-12-18 20:17:05 -0800542 std::istream& addInputStream(const std::string& name, Istream&& in) override {
543 auto it = mInFiles.emplace(mInFiles.end(), name, std::move(in));
544 return it->stream();
Yifan Hong9aa63702017-05-16 16:37:50 -0700545 }
546
Yifan Hong8302cea2017-12-18 20:17:05 -0800547 std::istream& setCheckInputStream(Istream&& in) override {
548 mCheckFile = std::move(in);
549 return *mCheckFile;
550 }
551
552 bool hasKernelVersion(const Version& kernelVer) const override {
553 return mKernels.find(kernelVer) != mKernels.end();
554 }
555
556 std::istream& addKernelConfigInputStream(const Version& kernelVer, const std::string& name,
557 Istream&& in) override {
558 auto&& kernel = mKernels[kernelVer];
559 auto it = kernel.emplace(kernel.end(), name, std::move(in));
560 return it->stream();
Yifan Hong9aa63702017-05-16 16:37:50 -0700561 }
562
Yifan Hongbfb3c1d2017-05-24 14:38:48 -0700563 void resetInFiles() {
564 for (auto& inFile : mInFiles) {
Yifan Hongaa219f52017-12-18 18:51:59 -0800565 inFile.stream().clear();
566 inFile.stream().seekg(0);
Yifan Hongbfb3c1d2017-05-24 14:38:48 -0700567 }
568 }
569
Yifan Hong8302cea2017-12-18 20:17:05 -0800570 void setOutputMatrix() override { mOutputMatrix = true; }
Yifan Hong9aa63702017-05-16 16:37:50 -0700571
Yifan Hong8302cea2017-12-18 20:17:05 -0800572 bool setHalsOnly() override {
Yifan Honga2635c42017-12-12 13:20:33 -0800573 if (mSerializeFlags) return false;
574 mSerializeFlags |= SerializeFlag::HALS_ONLY;
575 return true;
576 }
577
Yifan Hong8302cea2017-12-18 20:17:05 -0800578 bool setNoHals() override {
Yifan Honga2635c42017-12-12 13:20:33 -0800579 if (mSerializeFlags) return false;
580 mSerializeFlags |= SerializeFlag::NO_HALS;
581 return true;
582 }
583
Yifan Hong9aa63702017-05-16 16:37:50 -0700584 private:
Yifan Hongaa219f52017-12-18 18:51:59 -0800585 std::vector<NamedIstream> mInFiles;
Yifan Hong8302cea2017-12-18 20:17:05 -0800586 Ostream mOutRef;
587 Istream mCheckFile;
Yifan Hong9aa63702017-05-16 16:37:50 -0700588 bool mOutputMatrix = false;
Yifan Honga2635c42017-12-12 13:20:33 -0800589 SerializeFlags mSerializeFlags = SerializeFlag::EVERYTHING;
Yifan Hong8302cea2017-12-18 20:17:05 -0800590 std::map<Version, std::vector<NamedIstream>> mKernels;
591 std::map<std::string, std::string> mFakeEnv;
Yifan Hong4d18bcc2017-04-07 21:47:16 +0000592};
593
Yifan Hong8302cea2017-12-18 20:17:05 -0800594bool AssembleVintf::openOutFile(const std::string& path) {
595 return static_cast<std::ofstream&>(setOutputStream(std::make_unique<std::ofstream>(path)))
596 .is_open();
597}
598
599bool AssembleVintf::openInFile(const std::string& path) {
600 return static_cast<std::ifstream&>(addInputStream(path, std::make_unique<std::ifstream>(path)))
601 .is_open();
602}
603
604bool AssembleVintf::openCheckFile(const std::string& path) {
605 return static_cast<std::ifstream&>(setCheckInputStream(std::make_unique<std::ifstream>(path)))
606 .is_open();
607}
608
609bool AssembleVintf::addKernel(const std::string& kernelArg) {
Yifan Hongb83e56b2018-01-09 14:36:30 -0800610 auto tokens = base::Split(kernelArg, ":");
Yifan Hong8302cea2017-12-18 20:17:05 -0800611 if (tokens.size() <= 1) {
612 std::cerr << "Unrecognized --kernel option '" << kernelArg << "'" << std::endl;
613 return false;
614 }
615 Version kernelVer;
616 if (!parse(tokens.front(), &kernelVer)) {
617 std::cerr << "Unrecognized kernel version '" << tokens.front() << "'" << std::endl;
618 return false;
619 }
620 if (hasKernelVersion(kernelVer)) {
621 std::cerr << "Multiple --kernel for " << kernelVer << " is specified." << std::endl;
622 return false;
623 }
624 for (auto it = tokens.begin() + 1; it != tokens.end(); ++it) {
625 bool opened =
626 static_cast<std::ifstream&>(
627 addKernelConfigInputStream(kernelVer, *it, std::make_unique<std::ifstream>(*it)))
628 .is_open();
629 if (!opened) {
630 std::cerr << "Cannot open file '" << *it << "'." << std::endl;
631 return false;
632 }
633 }
634 return true;
635}
636
637std::unique_ptr<AssembleVintf> AssembleVintf::newInstance() {
638 return std::make_unique<AssembleVintfImpl>();
639}
640
Yifan Hong4d18bcc2017-04-07 21:47:16 +0000641} // namespace vintf
642} // namespace android