blob: fcf7ca8825c685c69f78303eeaecac7ad2efd87c [file] [log] [blame]
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001/*
2 * Copyright (C) 2008 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
Tom Cherry3f5eaae52017-04-06 16:30:22 -070017#include "util.h"
18
Mark Salyzyn62767fe2016-10-27 07:45:34 -070019#include <ctype.h>
20#include <errno.h>
21#include <fcntl.h>
Mark Salyzyn62767fe2016-10-27 07:45:34 -070022#include <pwd.h>
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080023#include <stdarg.h>
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080024#include <stdio.h>
Tom Cherry3f5eaae52017-04-06 16:30:22 -070025#include <stdlib.h>
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080026#include <string.h>
Tom Cherry3f5eaae52017-04-06 16:30:22 -070027#include <sys/socket.h>
28#include <sys/un.h>
Colin Cross504bc512010-04-13 19:35:09 -070029#include <time.h>
Mark Salyzyn62767fe2016-10-27 07:45:34 -070030#include <unistd.h>
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080031
Elliott Hughes290a2282016-11-14 17:08:47 -080032#include <thread>
33
Elliott Hughes4f713192015-12-04 22:00:26 -080034#include <android-base/file.h>
Elliott Hughesf86b5a62016-06-24 15:12:21 -070035#include <android-base/logging.h>
Tom Cherryccf23532017-03-28 16:40:41 -070036#include <android-base/properties.h>
Mark Salyzyn62767fe2016-10-27 07:45:34 -070037#include <android-base/stringprintf.h>
Elliott Hughes4f713192015-12-04 22:00:26 -080038#include <android-base/strings.h>
Mark Salyzyndb691072016-11-07 10:16:53 -080039#include <android-base/unique_fd.h>
Elliott Hughes331cf2f2016-11-29 19:20:58 +000040#include <cutils/android_reboot.h>
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080041#include <cutils/sockets.h>
Tom Cherry3f5eaae52017-04-06 16:30:22 -070042#include <selinux/android.h>
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080043
Keun-young Park8d01f632017-03-13 11:54:47 -070044#include "reboot.h"
Tom Cherry0c8d6d22017-08-10 12:22:44 -070045#include "selinux.h"
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080046
Tom Cherrye7656b72017-05-01 17:10:09 -070047#ifdef _INIT_INIT_H
48#error "Do not include init.h in files used by ueventd or watchdogd; it will expose init's globals"
49#endif
50
James Hawkinse78ea772017-03-24 11:43:02 -070051using android::base::boot_clock;
Tom Cherry517e1f12017-05-04 17:40:33 -070052using namespace std::literals::string_literals;
James Hawkinse78ea772017-03-24 11:43:02 -070053
Tom Cherry81f5d3e2017-06-22 12:53:17 -070054namespace android {
55namespace init {
56
Yu Ningc01022a2017-07-26 17:54:08 +080057const std::string kDefaultAndroidDtDir("/proc/device-tree/firmware/android/");
58
Tom Cherry517e1f12017-05-04 17:40:33 -070059// DecodeUid() - decodes and returns the given string, which can be either the
Tom Cherry11a3aee2017-08-03 12:54:07 -070060// numeric or name representation, into the integer uid or gid.
61Result<uid_t> DecodeUid(const std::string& name) {
Tom Cherry517e1f12017-05-04 17:40:33 -070062 if (isalpha(name[0])) {
63 passwd* pwd = getpwnam(name.c_str());
Tom Cherry11a3aee2017-08-03 12:54:07 -070064 if (!pwd) return ErrnoError() << "getpwnam failed";
65
66 return pwd->pw_uid;
William Roberts3792e6c2016-04-06 19:18:50 -070067 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080068
69 errno = 0;
Tom Cherry517e1f12017-05-04 17:40:33 -070070 uid_t result = static_cast<uid_t>(strtoul(name.c_str(), 0, 0));
Tom Cherry11a3aee2017-08-03 12:54:07 -070071 if (errno) return ErrnoError() << "strtoul failed";
72
73 return result;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080074}
75
76/*
Mark Salyzynb066fcc2017-05-05 14:44:35 -070077 * CreateSocket - creates a Unix domain socket in ANDROID_SOCKET_DIR
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080078 * ("/dev/socket") as dictated in init.rc. This socket is inherited by the
79 * daemon. We communicate the file descriptor's value via the environment
80 * variable ANDROID_SOCKET_ENV_PREFIX<name> ("ANDROID_SOCKET_foo").
81 */
Mark Salyzynb066fcc2017-05-05 14:44:35 -070082int CreateSocket(const char* name, int type, bool passcred, mode_t perm, uid_t uid, gid_t gid,
Tom Cherry0c8d6d22017-08-10 12:22:44 -070083 const char* socketcon) {
Nick Kralevich83ccb1c2015-11-23 16:26:42 -080084 if (socketcon) {
85 if (setsockcreatecon(socketcon) == -1) {
Elliott Hughesf86b5a62016-06-24 15:12:21 -070086 PLOG(ERROR) << "setsockcreatecon(\"" << socketcon << "\") failed";
Nick Kralevich83ccb1c2015-11-23 16:26:42 -080087 return -1;
88 }
89 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080090
Mark Salyzyndb691072016-11-07 10:16:53 -080091 android::base::unique_fd fd(socket(PF_UNIX, type, 0));
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080092 if (fd < 0) {
Elliott Hughesf86b5a62016-06-24 15:12:21 -070093 PLOG(ERROR) << "Failed to open socket '" << name << "'";
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080094 return -1;
95 }
96
Mark Salyzyndb691072016-11-07 10:16:53 -080097 if (socketcon) setsockcreatecon(NULL);
Stephen Smalley8348d272013-05-13 12:37:04 -040098
Mark Salyzyndb691072016-11-07 10:16:53 -080099 struct sockaddr_un addr;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800100 memset(&addr, 0 , sizeof(addr));
101 addr.sun_family = AF_UNIX;
102 snprintf(addr.sun_path, sizeof(addr.sun_path), ANDROID_SOCKET_DIR"/%s",
103 name);
104
Mark Salyzyndb691072016-11-07 10:16:53 -0800105 if ((unlink(addr.sun_path) != 0) && (errno != ENOENT)) {
Elliott Hughesf86b5a62016-06-24 15:12:21 -0700106 PLOG(ERROR) << "Failed to unlink old socket '" << name << "'";
Mark Salyzyndb691072016-11-07 10:16:53 -0800107 return -1;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800108 }
109
Tom Cherry0c8d6d22017-08-10 12:22:44 -0700110 std::string secontext;
111 if (SelabelLookupFileContext(addr.sun_path, S_IFSOCK, &secontext) && !secontext.empty()) {
112 setfscreatecon(secontext.c_str());
Stephen Smalleye46f9d52012-01-13 08:48:47 -0500113 }
Stephen Smalleye46f9d52012-01-13 08:48:47 -0500114
Mark Salyzynb066fcc2017-05-05 14:44:35 -0700115 if (passcred) {
116 int on = 1;
117 if (setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &on, sizeof(on))) {
118 PLOG(ERROR) << "Failed to set SO_PASSCRED '" << name << "'";
119 return -1;
120 }
121 }
122
Mark Salyzyndb691072016-11-07 10:16:53 -0800123 int ret = bind(fd, (struct sockaddr *) &addr, sizeof (addr));
124 int savederrno = errno;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800125
Tom Cherry0c8d6d22017-08-10 12:22:44 -0700126 if (!secontext.empty()) {
127 setfscreatecon(nullptr);
128 }
Stephen Smalleye46f9d52012-01-13 08:48:47 -0500129
Nick Kralevich9bcfd642016-02-24 15:50:52 -0800130 if (ret) {
Mark Salyzyndb691072016-11-07 10:16:53 -0800131 errno = savederrno;
Elliott Hughesf86b5a62016-06-24 15:12:21 -0700132 PLOG(ERROR) << "Failed to bind socket '" << name << "'";
Nick Kralevich9bcfd642016-02-24 15:50:52 -0800133 goto out_unlink;
134 }
135
Mark Salyzyndb691072016-11-07 10:16:53 -0800136 if (lchown(addr.sun_path, uid, gid)) {
Elliott Hughesf86b5a62016-06-24 15:12:21 -0700137 PLOG(ERROR) << "Failed to lchown socket '" << addr.sun_path << "'";
Nick Kralevich9bcfd642016-02-24 15:50:52 -0800138 goto out_unlink;
139 }
Mark Salyzyndb691072016-11-07 10:16:53 -0800140 if (fchmodat(AT_FDCWD, addr.sun_path, perm, AT_SYMLINK_NOFOLLOW)) {
Elliott Hughesf86b5a62016-06-24 15:12:21 -0700141 PLOG(ERROR) << "Failed to fchmodat socket '" << addr.sun_path << "'";
Nick Kralevich9bcfd642016-02-24 15:50:52 -0800142 goto out_unlink;
143 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800144
Elliott Hughesf86b5a62016-06-24 15:12:21 -0700145 LOG(INFO) << "Created socket '" << addr.sun_path << "'"
146 << ", mode " << std::oct << perm << std::dec
147 << ", user " << uid
148 << ", group " << gid;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800149
Mark Salyzyndb691072016-11-07 10:16:53 -0800150 return fd.release();
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800151
152out_unlink:
153 unlink(addr.sun_path);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800154 return -1;
155}
156
Tom Cherry11a3aee2017-08-03 12:54:07 -0700157Result<std::string> ReadFile(const std::string& path) {
Tom Cherry53089aa2017-03-31 15:47:33 -0700158 android::base::unique_fd fd(
159 TEMP_FAILURE_RETRY(open(path.c_str(), O_RDONLY | O_NOFOLLOW | O_CLOEXEC)));
Elliott Hughesf682b472015-02-06 12:19:48 -0800160 if (fd == -1) {
Tom Cherry11a3aee2017-08-03 12:54:07 -0700161 return ErrnoError() << "open() failed";
Elliott Hughesf682b472015-02-06 12:19:48 -0800162 }
163
164 // For security reasons, disallow world-writable
165 // or group-writable files.
Nick Kralevich38f368c2012-01-18 10:39:01 -0800166 struct stat sb;
Elliott Hughesf682b472015-02-06 12:19:48 -0800167 if (fstat(fd, &sb) == -1) {
Tom Cherry11a3aee2017-08-03 12:54:07 -0700168 return ErrnoError() << "fstat failed()";
Nick Kralevich38f368c2012-01-18 10:39:01 -0800169 }
170 if ((sb.st_mode & (S_IWGRP | S_IWOTH)) != 0) {
Tom Cherry11a3aee2017-08-03 12:54:07 -0700171 return Error() << "Skipping insecure file";
Nick Kralevich38f368c2012-01-18 10:39:01 -0800172 }
173
Tom Cherry11a3aee2017-08-03 12:54:07 -0700174 std::string content;
175 if (!android::base::ReadFdToString(fd, &content)) {
176 return ErrnoError() << "Unable to read file contents";
Tom Cherry2cbbe9f2017-05-04 18:17:33 -0700177 }
Tom Cherry11a3aee2017-08-03 12:54:07 -0700178 return content;
Elliott Hughesf682b472015-02-06 12:19:48 -0800179}
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800180
Tom Cherry11a3aee2017-08-03 12:54:07 -0700181Result<Success> WriteFile(const std::string& path, const std::string& content) {
Yongqin Liudbe88e72016-12-28 16:06:19 +0800182 android::base::unique_fd fd(TEMP_FAILURE_RETRY(
183 open(path.c_str(), O_WRONLY | O_CREAT | O_NOFOLLOW | O_TRUNC | O_CLOEXEC, 0600)));
Elliott Hughesf682b472015-02-06 12:19:48 -0800184 if (fd == -1) {
Tom Cherry11a3aee2017-08-03 12:54:07 -0700185 return ErrnoError() << "open() failed";
Elliott Hughesf682b472015-02-06 12:19:48 -0800186 }
Tom Cherry2cbbe9f2017-05-04 18:17:33 -0700187 if (!android::base::WriteStringToFd(content, fd)) {
Tom Cherry11a3aee2017-08-03 12:54:07 -0700188 return ErrnoError() << "Unable to write file contents";
Nick Kralevicheedbe812015-04-25 14:10:03 -0700189 }
Tom Cherry11a3aee2017-08-03 12:54:07 -0700190 return Success();
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800191}
192
Tom Cherry0c8d6d22017-08-10 12:22:44 -0700193bool mkdir_recursive(const std::string& path, mode_t mode) {
Tom Cherry060b74b2017-04-12 14:27:51 -0700194 std::string::size_type slash = 0;
195 while ((slash = path.find('/', slash + 1)) != std::string::npos) {
196 auto directory = path.substr(0, slash);
197 struct stat info;
198 if (stat(directory.c_str(), &info) != 0) {
Tom Cherry0c8d6d22017-08-10 12:22:44 -0700199 auto ret = make_dir(directory, mode);
200 if (!ret && errno != EEXIST) return false;
Colin Crossb0ab94b2010-04-08 16:16:20 -0700201 }
202 }
Tom Cherry0c8d6d22017-08-10 12:22:44 -0700203 auto ret = make_dir(path, mode);
204 if (!ret && errno != EEXIST) return false;
205 return true;
Colin Crossb0ab94b2010-04-08 16:16:20 -0700206}
207
Elliott Hughes9605a942016-11-10 17:43:47 -0800208int wait_for_file(const char* filename, std::chrono::nanoseconds timeout) {
209 boot_clock::time_point timeout_time = boot_clock::now() + timeout;
210 while (boot_clock::now() < timeout_time) {
211 struct stat sb;
212 if (stat(filename, &sb) != -1) return 0;
Colin Crosscd0f1732010-04-19 17:10:24 -0700213
Elliott Hughes290a2282016-11-14 17:08:47 -0800214 std::this_thread::sleep_for(10ms);
Elliott Hughes9605a942016-11-10 17:43:47 -0800215 }
216 return -1;
Colin Crosscd0f1732010-04-19 17:10:24 -0700217}
Colin Crossf83d0b92010-04-21 12:04:20 -0700218
Elliott Hughese5ce30f2015-05-06 19:19:24 -0700219void import_kernel_cmdline(bool in_qemu,
Chih-Hung Hsieh8f7b9e32016-07-27 16:25:51 -0700220 const std::function<void(const std::string&, const std::string&, bool)>& fn) {
Elliott Hughese5ce30f2015-05-06 19:19:24 -0700221 std::string cmdline;
222 android::base::ReadFileToString("/proc/cmdline", &cmdline);
Vladimir Chtchetkine2b995432011-09-28 09:55:31 -0700223
Elliott Hughese5ce30f2015-05-06 19:19:24 -0700224 for (const auto& entry : android::base::Split(android::base::Trim(cmdline), " ")) {
225 std::vector<std::string> pieces = android::base::Split(entry, "=");
226 if (pieces.size() == 2) {
227 fn(pieces[0], pieces[1], in_qemu);
228 }
Vladimir Chtchetkine2b995432011-09-28 09:55:31 -0700229 }
230}
Stephen Smalleye096e362012-06-11 13:37:39 -0400231
Tom Cherry0c8d6d22017-08-10 12:22:44 -0700232bool make_dir(const std::string& path, mode_t mode) {
233 std::string secontext;
234 if (SelabelLookupFileContext(path, mode, &secontext) && !secontext.empty()) {
235 setfscreatecon(secontext.c_str());
Stephen Smalleye096e362012-06-11 13:37:39 -0400236 }
Stephen Smalleye096e362012-06-11 13:37:39 -0400237
Tom Cherry0c8d6d22017-08-10 12:22:44 -0700238 int rc = mkdir(path.c_str(), mode);
Stephen Smalleye096e362012-06-11 13:37:39 -0400239
Tom Cherry0c8d6d22017-08-10 12:22:44 -0700240 if (!secontext.empty()) {
Stephen Smalleye096e362012-06-11 13:37:39 -0400241 int save_errno = errno;
Tom Cherry0c8d6d22017-08-10 12:22:44 -0700242 setfscreatecon(nullptr);
Stephen Smalleye096e362012-06-11 13:37:39 -0400243 errno = save_errno;
244 }
Kenny Rootb5982bf2012-10-16 23:07:05 -0700245
Tom Cherry0c8d6d22017-08-10 12:22:44 -0700246 return rc == 0;
Stephen Smalleye096e362012-06-11 13:37:39 -0400247}
248
Andres Moralesdb5f5d42015-05-08 08:30:33 -0700249/*
250 * Writes hex_len hex characters (1/2 byte) to hex from bytes.
251 */
252std::string bytes_to_hex(const uint8_t* bytes, size_t bytes_len) {
253 std::string hex("0x");
254 for (size_t i = 0; i < bytes_len; i++)
255 android::base::StringAppendF(&hex, "%02x", bytes[i]);
256 return hex;
257}
Lee Campbellf13b1b32015-07-24 16:57:14 -0700258
259/*
260 * Returns true is pathname is a directory
261 */
262bool is_dir(const char* pathname) {
263 struct stat info;
264 if (stat(pathname, &info) == -1) {
265 return false;
266 }
267 return S_ISDIR(info.st_mode);
268}
Tom Cherryb7349902015-08-26 11:43:36 -0700269
270bool expand_props(const std::string& src, std::string* dst) {
271 const char* src_ptr = src.c_str();
272
273 if (!dst) {
274 return false;
275 }
276
277 /* - variables can either be $x.y or ${x.y}, in case they are only part
278 * of the string.
279 * - will accept $$ as a literal $.
280 * - no nested property expansion, i.e. ${foo.${bar}} is not supported,
281 * bad things will happen
Mark Salyzyn4b561622016-06-07 08:49:01 -0700282 * - ${x.y:-default} will return default value if property empty.
Tom Cherryb7349902015-08-26 11:43:36 -0700283 */
284 while (*src_ptr) {
285 const char* c;
286
287 c = strchr(src_ptr, '$');
288 if (!c) {
289 dst->append(src_ptr);
290 return true;
291 }
292
293 dst->append(src_ptr, c);
294 c++;
295
296 if (*c == '$') {
297 dst->push_back(*(c++));
298 src_ptr = c;
299 continue;
300 } else if (*c == '\0') {
301 return true;
302 }
303
304 std::string prop_name;
Mark Salyzyn4b561622016-06-07 08:49:01 -0700305 std::string def_val;
Tom Cherryb7349902015-08-26 11:43:36 -0700306 if (*c == '{') {
307 c++;
308 const char* end = strchr(c, '}');
309 if (!end) {
310 // failed to find closing brace, abort.
Elliott Hughesf86b5a62016-06-24 15:12:21 -0700311 LOG(ERROR) << "unexpected end of string in '" << src << "', looking for }";
Tom Cherryb7349902015-08-26 11:43:36 -0700312 return false;
313 }
314 prop_name = std::string(c, end);
315 c = end + 1;
Mark Salyzyn4b561622016-06-07 08:49:01 -0700316 size_t def = prop_name.find(":-");
317 if (def < prop_name.size()) {
318 def_val = prop_name.substr(def + 2);
319 prop_name = prop_name.substr(0, def);
320 }
Tom Cherryb7349902015-08-26 11:43:36 -0700321 } else {
322 prop_name = c;
Elliott Hughesf86b5a62016-06-24 15:12:21 -0700323 LOG(ERROR) << "using deprecated syntax for specifying property '" << c << "', use ${name} instead";
Tom Cherryb7349902015-08-26 11:43:36 -0700324 c += prop_name.size();
325 }
326
327 if (prop_name.empty()) {
Elliott Hughesf86b5a62016-06-24 15:12:21 -0700328 LOG(ERROR) << "invalid zero-length property name in '" << src << "'";
Tom Cherryb7349902015-08-26 11:43:36 -0700329 return false;
330 }
331
Tom Cherryccf23532017-03-28 16:40:41 -0700332 std::string prop_val = android::base::GetProperty(prop_name, "");
Tom Cherryb7349902015-08-26 11:43:36 -0700333 if (prop_val.empty()) {
Mark Salyzyn4b561622016-06-07 08:49:01 -0700334 if (def_val.empty()) {
Elliott Hughesf86b5a62016-06-24 15:12:21 -0700335 LOG(ERROR) << "property '" << prop_name << "' doesn't exist while expanding '" << src << "'";
Mark Salyzyn4b561622016-06-07 08:49:01 -0700336 return false;
337 }
338 prop_val = def_val;
Tom Cherryb7349902015-08-26 11:43:36 -0700339 }
340
341 dst->append(prop_val);
342 src_ptr = c;
343 }
344
345 return true;
346}
Elliott Hughes331cf2f2016-11-29 19:20:58 +0000347
Elliott Hughes331cf2f2016-11-29 19:20:58 +0000348void panic() {
349 LOG(ERROR) << "panic: rebooting to bootloader";
Wei Wangeeab4912017-06-27 22:08:45 -0700350 // Do not queue "shutdown" trigger since we want to shutdown immediately
Keun-young Park8d01f632017-03-13 11:54:47 -0700351 DoReboot(ANDROID_RB_RESTART2, "reboot", "bootloader", false);
Elliott Hughes331cf2f2016-11-29 19:20:58 +0000352}
353
Yu Ningc01022a2017-07-26 17:54:08 +0800354static std::string init_android_dt_dir() {
355 // Use the standard procfs-based path by default
356 std::string android_dt_dir = kDefaultAndroidDtDir;
357 // The platform may specify a custom Android DT path in kernel cmdline
358 import_kernel_cmdline(false,
359 [&](const std::string& key, const std::string& value, bool in_qemu) {
360 if (key == "androidboot.android_dt_dir") {
361 android_dt_dir = value;
362 }
363 });
364 LOG(INFO) << "Using Android DT directory " << android_dt_dir;
365 return android_dt_dir;
366}
367
368// FIXME: The same logic is duplicated in system/core/fs_mgr/
369const std::string& get_android_dt_dir() {
370 // Set once and saves time for subsequent calls to this function
371 static const std::string kAndroidDtDir = init_android_dt_dir();
372 return kAndroidDtDir;
373}
374
375// Reads the content of device tree file under the platform's Android DT directory.
Bowgo Tsaid2620172017-04-17 22:17:09 +0800376// Returns true if the read is success, false otherwise.
377bool read_android_dt_file(const std::string& sub_path, std::string* dt_content) {
Yu Ningc01022a2017-07-26 17:54:08 +0800378 const std::string file_name = get_android_dt_dir() + sub_path;
Bowgo Tsaid2620172017-04-17 22:17:09 +0800379 if (android::base::ReadFileToString(file_name, dt_content)) {
380 if (!dt_content->empty()) {
381 dt_content->pop_back(); // Trims the trailing '\0' out.
382 return true;
383 }
384 }
385 return false;
386}
387
388bool is_android_dt_value_expected(const std::string& sub_path, const std::string& expected_content) {
389 std::string dt_content;
390 if (read_android_dt_file(sub_path, &dt_content)) {
391 if (dt_content == expected_content) {
392 return true;
393 }
394 }
395 return false;
396}
Tom Cherry81f5d3e2017-06-22 12:53:17 -0700397
398} // namespace init
399} // namespace android