1 /*
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
18 #define LOG_TAG "libvintf"
19 #include <android-base/logging.h>
20 #include <android-base/strings.h>
21
22 #include "RuntimeInfo.h"
23
24 #include "CompatibilityMatrix.h"
25 #include "KernelConfigParser.h"
26 #include "parse_string.h"
27
28 #include <dirent.h>
29 #include <errno.h>
30 #include <sys/utsname.h>
31 #include <unistd.h>
32
33 #include <fstream>
34 #include <iostream>
35 #include <sstream>
36
37 #include <android-base/properties.h>
38 #include <selinux/selinux.h>
39 #include <zlib.h>
40
41 #define PROC_CONFIG "/proc/config.gz"
42 #define BUFFER_SIZE sysconf(_SC_PAGESIZE)
43
44 static constexpr char kMainline[] = "-mainline-";
45 static constexpr char kMainlineSuffix[] = "-mainline";
46
47 namespace android {
48 namespace vintf {
49
50 struct RuntimeInfoFetcher {
RuntimeInfoFetcherandroid::vintf::RuntimeInfoFetcher51 RuntimeInfoFetcher(RuntimeInfo *ki) : mRuntimeInfo(ki) { }
52 status_t fetchAllInformation(RuntimeInfo::FetchFlags flags);
53
54 private:
55 status_t fetchVersion(RuntimeInfo::FetchFlags flags);
56 status_t fetchKernelConfigs(RuntimeInfo::FetchFlags flags);
57 status_t fetchCpuInfo(RuntimeInfo::FetchFlags flags);
58 status_t fetchKernelSepolicyVers(RuntimeInfo::FetchFlags flags);
59 status_t fetchAvb(RuntimeInfo::FetchFlags flags);
60 status_t parseKernelVersion();
61 RuntimeInfo *mRuntimeInfo;
62 KernelConfigParser mConfigParser;
63 };
64
65 // decompress /proc/config.gz and read its contents.
fetchKernelConfigs(RuntimeInfo::FetchFlags)66 status_t RuntimeInfoFetcher::fetchKernelConfigs(RuntimeInfo::FetchFlags) {
67 gzFile f = gzopen(PROC_CONFIG, "rb");
68 if (f == NULL) {
69 LOG(ERROR) << "Could not open /proc/config.gz: " << errno;
70 return -errno;
71 }
72
73 char buf[BUFFER_SIZE];
74 int len;
75 while ((len = gzread(f, buf, sizeof buf)) > 0) {
76 mConfigParser.process(buf, len);
77 }
78 status_t err = OK;
79 if (len < 0) {
80 int errnum;
81 const char *errmsg = gzerror(f, &errnum);
82 LOG(ERROR) << "Could not read /proc/config.gz: " << errmsg;
83 err = (errnum == Z_ERRNO ? -errno : errnum);
84 }
85 mConfigParser.finish();
86 gzclose(f);
87 mRuntimeInfo->mKernel.mConfigs = std::move(mConfigParser.configs());
88 return err;
89 }
90
fetchCpuInfo(RuntimeInfo::FetchFlags)91 status_t RuntimeInfoFetcher::fetchCpuInfo(RuntimeInfo::FetchFlags) {
92 // TODO implement this; 32-bit and 64-bit has different format.
93 std::ifstream in{"/proc/cpuinfo"};
94 if (!in.is_open()) {
95 LOG(WARNING) << "Cannot read /proc/cpuinfo";
96 return UNKNOWN_ERROR;
97 }
98 std::stringstream sstream;
99 sstream << in.rdbuf();
100 mRuntimeInfo->mCpuInfo = sstream.str();
101 return OK;
102 }
103
fetchKernelSepolicyVers(RuntimeInfo::FetchFlags)104 status_t RuntimeInfoFetcher::fetchKernelSepolicyVers(RuntimeInfo::FetchFlags) {
105 int pv;
106 #ifdef LIBVINTF_TARGET
107 pv = security_policyvers();
108 #else
109 pv = 0;
110 #endif
111 if (pv < 0) {
112 return pv;
113 }
114 mRuntimeInfo->mKernelSepolicyVersion = pv;
115 return OK;
116 }
117
fetchVersion(RuntimeInfo::FetchFlags flags)118 status_t RuntimeInfoFetcher::fetchVersion(RuntimeInfo::FetchFlags flags) {
119 struct utsname buf;
120 if (uname(&buf)) {
121 return -errno;
122 }
123 mRuntimeInfo->mOsName = buf.sysname;
124 mRuntimeInfo->mNodeName = buf.nodename;
125 mRuntimeInfo->mOsRelease = buf.release;
126 mRuntimeInfo->mOsVersion = buf.version;
127 mRuntimeInfo->mHardwareId = buf.machine;
128
129 mRuntimeInfo->mIsMainline = mRuntimeInfo->mOsRelease.find(kMainline) != std::string::npos ||
130 android::base::EndsWith(mRuntimeInfo->mOsRelease, kMainlineSuffix);
131
132 status_t err = RuntimeInfo::parseGkiKernelRelease(flags, mRuntimeInfo->mOsRelease,
133 &mRuntimeInfo->mKernel.mVersion,
134 &mRuntimeInfo->mKernel.mLevel);
135 if (err == OK) return OK;
136
137 err = parseKernelVersion();
138 if (err != OK) {
139 LOG(ERROR) << "Could not parse kernel version from \""
140 << mRuntimeInfo->mOsRelease << "\"";
141 }
142 return err;
143 }
144
parseKernelVersion()145 status_t RuntimeInfoFetcher::parseKernelVersion() {
146 auto pos = mRuntimeInfo->mOsRelease.find('.');
147 if (pos == std::string::npos) {
148 return UNKNOWN_ERROR;
149 }
150 pos = mRuntimeInfo->mOsRelease.find('.', pos + 1);
151 if (pos == std::string::npos) {
152 return UNKNOWN_ERROR;
153 }
154 pos = mRuntimeInfo->mOsRelease.find_first_not_of("0123456789", pos + 1);
155 // no need to check pos == std::string::npos, because substr will handle this
156 if (!parse(mRuntimeInfo->mOsRelease.substr(0, pos), &mRuntimeInfo->mKernel.mVersion)) {
157 return UNKNOWN_ERROR;
158 }
159 return OK;
160 }
161
fetchAvb(RuntimeInfo::FetchFlags)162 status_t RuntimeInfoFetcher::fetchAvb(RuntimeInfo::FetchFlags) {
163 std::string prop = android::base::GetProperty("ro.boot.vbmeta.avb_version", "0.0");
164 if (!parse(prop, &mRuntimeInfo->mBootVbmetaAvbVersion)) {
165 return UNKNOWN_ERROR;
166 }
167 prop = android::base::GetProperty("ro.boot.avb_version", "0.0");
168 if (!parse(prop, &mRuntimeInfo->mBootAvbVersion)) {
169 return UNKNOWN_ERROR;
170 }
171 return OK;
172 }
173
174 struct FetchFunction {
175 RuntimeInfo::FetchFlags flags;
176 std::function<status_t(RuntimeInfoFetcher*, RuntimeInfo::FetchFlags)> fetch;
177 std::string description;
178 };
179
fetchAllInformation(RuntimeInfo::FetchFlags flags)180 status_t RuntimeInfoFetcher::fetchAllInformation(RuntimeInfo::FetchFlags flags) {
181 using F = RuntimeInfo::FetchFlag;
182 using RF = RuntimeInfoFetcher;
183 // clang-format off
184 const static std::vector<FetchFunction> gFetchFunctions({
185 {F::CPU_VERSION | F::KERNEL_FCM, &RF::fetchVersion, "/proc/version"},
186 {F::CONFIG_GZ, &RF::fetchKernelConfigs, "/proc/config.gz"},
187 {F::CPU_INFO, &RF::fetchCpuInfo, "/proc/cpuinfo"},
188 {F::POLICYVERS, &RF::fetchKernelSepolicyVers, "kernel sepolicy version"},
189 {F::AVB, &RF::fetchAvb, "avb version"},
190 });
191 // clang-format on
192
193 status_t err;
194 for (const auto& fetchFunction : gFetchFunctions)
195 if ((flags & fetchFunction.flags) && ((err = fetchFunction.fetch(this, flags)) != OK))
196 LOG(WARNING) << "Cannot fetch or parse " << fetchFunction.description << ": "
197 << strerror(-err);
198
199 return OK;
200 }
201
fetchAllInformation(RuntimeInfo::FetchFlags flags)202 status_t RuntimeInfo::fetchAllInformation(RuntimeInfo::FetchFlags flags) {
203 return RuntimeInfoFetcher(this).fetchAllInformation(flags);
204 }
205
206 } // namespace vintf
207 } // namespace android
208