assemble_vintf: accept arch specific kernel fragments

It is now allowed to provide the following arg:
--kernel=3.18:.../android-base.cfg:.../android-base-arm64.cfg

assemble_vintf detects the name of these files and
sets conditions accordingly. For example,

* android-base.cfg refer to common configs (no conditions)
* android-base-foo-bar.cfg refer to configs that are
  conditioned on CONFIG_FOO_BAR being set.

Also, android-base.cfg must exist for each version.

Test: m system_compatibility_matrix.xml -j
Bug: 64124223
Change-Id: Ib852b9f0c3ce6addce18473480f3da2f221f8d92

2 files changed, 43 insertions, 8 deletions

diff --git a/Android.bp b/Android.bp
index 70c7dc8..a6bfe7f 100644
--- a/Android.bp
+++ b/Android.bp
@@ -90,7 +90,8 @@ cc_binary_host {
     name: "assemble_vintf",
     cflags: libvintf_flags,
     shared_libs: [
-        "libvintf"
+        "libvintf",
+        "libbase",
     ],
     srcs: [
         "assemble_vintf.cpp"
diff --git a/assemble_vintf.cpp b/assemble_vintf.cpp
index 60cea7d..251d4bc 100644
--- a/assemble_vintf.cpp
+++ b/assemble_vintf.cpp
@@ -24,6 +24,8 @@
 #include <sstream>
 #include <string>
 
+#include <android-base/file.h>
+
 #include <vintf/KernelConfigParser.h>
 #include <vintf/parse_string.h>
 #include <vintf/parse_xml.h>
@@ -33,11 +35,18 @@
 namespace android {
 namespace vintf {
 
+static const std::string gConfigPrefix = "android-base-";
+static const std::string gConfigSuffix = ".cfg";
+static const std::string gBaseConfig = "android-base.cfg";
+
 /**
  * Slurps the device manifest file and add build time flag to it.
  */
 class AssembleVintf {
-public:
+    using Condition = std::unique_ptr<KernelConfig>;
+    using ConditionedConfig = std::pair<Condition, std::vector<KernelConfig> /* configs */>;
+
+   public:
     template<typename T>
     static bool getFlag(const std::string& key, T* value) {
         const char *envValue = getenv(key.c_str());
@@ -60,6 +69,10 @@ public:
         return ss.str();
     }
 
+    static bool isCommonConfig(const std::string& path) {
+        return ::android::base::Basename(path) == gBaseConfig;
+    }
+
     static bool parseFileForKernelConfigs(const std::string& path, std::vector<KernelConfig>* out) {
         std::ifstream ifs{path};
         if (!ifs.is_open()) {
@@ -92,17 +105,36 @@ public:
         return true;
     }
 
-    static bool parseFilesForKernelConfigs(const std::string& path, std::vector<KernelConfig>* out) {
+    static bool parseFilesForKernelConfigs(const std::string& path,
+                                           std::vector<ConditionedConfig>* out) {
+        out->clear();
+        ConditionedConfig commonConfig;
+        bool foundCommonConfig = false;
         bool ret = true;
         char *pathIter;
         char *modPath = new char[path.length() + 1];
         strcpy(modPath, path.c_str());
         pathIter = strtok(modPath, ":");
         while (ret && pathIter != NULL) {
-            ret &= parseFileForKernelConfigs(pathIter, out);
+            if (isCommonConfig(pathIter)) {
+                ret &= parseFileForKernelConfigs(pathIter, &commonConfig.second);
+                foundCommonConfig = true;
+            } else {
+                std::vector<KernelConfig> kernelConfigs;
+                if ((ret &= parseFileForKernelConfigs(pathIter, &kernelConfigs)))
+                    out->emplace_back(nullptr, std::move(kernelConfigs));
+            }
             pathIter = strtok(NULL, ":");
         }
         delete[] modPath;
+
+        if (!foundCommonConfig) {
+            std::cerr << "No android-base.cfg is found in these paths: '" << path << "'"
+                      << std::endl;
+        }
+        ret &= foundCommonConfig;
+        // first element is always common configs (no conditions).
+        out->insert(out->begin(), std::move(commonConfig));
         return ret;
     }
 
@@ -166,12 +198,14 @@ public:
             matrix->framework.mKernels.clear();
         }
         for (const auto& pair : mKernels) {
-            std::vector<KernelConfig> configs;
-            if (!parseFilesForKernelConfigs(pair.second, &configs)) {
+            std::vector<ConditionedConfig> conditionedConfigs;
+            if (!parseFilesForKernelConfigs(pair.second, &conditionedConfigs)) {
                 return false;
             }
-            matrix->framework.mKernels.push_back(
-                MatrixKernel{KernelVersion{pair.first}, std::move(configs)});
+            for (ConditionedConfig& conditionedConfig : conditionedConfigs) {
+                matrix->framework.mKernels.push_back(
+                    MatrixKernel{KernelVersion{pair.first}, std::move(conditionedConfig.second)});
+            }
         }
         return true;
     }