1 //
2 // Copyright (C) 2013 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 "update_engine/hardware_chromeos.h"
18
19 #include <utility>
20
21 #include <base/files/file_path.h>
22 #include <base/files/file_util.h>
23 #include <base/logging.h>
24 #include <base/strings/string_number_conversions.h>
25 #include <base/strings/string_util.h>
26 #include <brillo/key_value_store.h>
27 #include <debugd/dbus-constants.h>
28 #include <vboot/crossystem.h>
29
30 extern "C" {
31 #include "vboot/vboot_host.h"
32 }
33
34 #include "update_engine/common/constants.h"
35 #include "update_engine/common/hardware.h"
36 #include "update_engine/common/hwid_override.h"
37 #include "update_engine/common/platform_constants.h"
38 #include "update_engine/common/subprocess.h"
39 #include "update_engine/common/utils.h"
40 #include "update_engine/dbus_connection.h"
41
42 using std::string;
43 using std::vector;
44
45 namespace {
46
47 const char kOOBECompletedMarker[] = "/home/chronos/.oobe_completed";
48
49 // The stateful directory used by update_engine to store powerwash-safe files.
50 // The files stored here must be whitelisted in the powerwash scripts.
51 const char kPowerwashSafeDirectory[] =
52 "/mnt/stateful_partition/unencrypted/preserve";
53
54 // The powerwash_count marker file contains the number of times the device was
55 // powerwashed. This value is incremented by the clobber-state script when
56 // a powerwash is performed.
57 const char kPowerwashCountMarker[] = "powerwash_count";
58
59 // The name of the marker file used to trigger powerwash when post-install
60 // completes successfully so that the device is powerwashed on next reboot.
61 const char kPowerwashMarkerFile[] =
62 "/mnt/stateful_partition/factory_install_reset";
63
64 // The contents of the powerwash marker file for the non-rollback case.
65 const char kPowerwashCommand[] = "safe fast keepimg reason=update_engine\n";
66
67 // The contents of the powerwas marker file for the rollback case.
68 const char kRollbackPowerwashCommand[] =
69 "safe fast keepimg rollback reason=update_engine\n";
70
71 // UpdateManager config path.
72 const char* kConfigFilePath = "/etc/update_manager.conf";
73
74 // UpdateManager config options:
75 const char* kConfigOptsIsOOBEEnabled = "is_oobe_enabled";
76
77 const char* kActivePingKey = "first_active_omaha_ping_sent";
78
79 } // namespace
80
81 namespace chromeos_update_engine {
82
83 namespace hardware {
84
85 // Factory defined in hardware.h.
CreateHardware()86 std::unique_ptr<HardwareInterface> CreateHardware() {
87 std::unique_ptr<HardwareChromeOS> hardware(new HardwareChromeOS());
88 hardware->Init();
89 return std::move(hardware);
90 }
91
92 } // namespace hardware
93
Init()94 void HardwareChromeOS::Init() {
95 LoadConfig("" /* root_prefix */, IsNormalBootMode());
96 debugd_proxy_.reset(
97 new org::chromium::debugdProxy(DBusConnection::Get()->GetDBus()));
98 }
99
IsOfficialBuild() const100 bool HardwareChromeOS::IsOfficialBuild() const {
101 return VbGetSystemPropertyInt("debug_build") == 0;
102 }
103
IsNormalBootMode() const104 bool HardwareChromeOS::IsNormalBootMode() const {
105 bool dev_mode = VbGetSystemPropertyInt("devsw_boot") != 0;
106 return !dev_mode;
107 }
108
AreDevFeaturesEnabled() const109 bool HardwareChromeOS::AreDevFeaturesEnabled() const {
110 // Even though the debugd tools are also gated on devmode, checking here can
111 // save us a D-Bus call so it's worth doing explicitly.
112 if (IsNormalBootMode())
113 return false;
114
115 int32_t dev_features = debugd::DEV_FEATURES_DISABLED;
116 brillo::ErrorPtr error;
117 // Some boards may not include debugd so it's expected that this may fail,
118 // in which case we treat it as disabled.
119 if (debugd_proxy_ && debugd_proxy_->QueryDevFeatures(&dev_features, &error) &&
120 !(dev_features & debugd::DEV_FEATURES_DISABLED)) {
121 LOG(INFO) << "Debugd dev tools enabled.";
122 return true;
123 }
124 return false;
125 }
126
IsOOBEEnabled() const127 bool HardwareChromeOS::IsOOBEEnabled() const {
128 return is_oobe_enabled_;
129 }
130
IsOOBEComplete(base::Time * out_time_of_oobe) const131 bool HardwareChromeOS::IsOOBEComplete(base::Time* out_time_of_oobe) const {
132 if (!is_oobe_enabled_) {
133 LOG(WARNING) << "OOBE is not enabled but IsOOBEComplete() was called";
134 }
135 struct stat statbuf;
136 if (stat(kOOBECompletedMarker, &statbuf) != 0) {
137 if (errno != ENOENT) {
138 PLOG(ERROR) << "Error getting information about " << kOOBECompletedMarker;
139 }
140 return false;
141 }
142
143 if (out_time_of_oobe != nullptr)
144 *out_time_of_oobe = base::Time::FromTimeT(statbuf.st_mtime);
145 return true;
146 }
147
ReadValueFromCrosSystem(const string & key)148 static string ReadValueFromCrosSystem(const string& key) {
149 char value_buffer[VB_MAX_STRING_PROPERTY];
150
151 const char* rv = VbGetSystemPropertyString(
152 key.c_str(), value_buffer, sizeof(value_buffer));
153 if (rv != nullptr) {
154 string return_value(value_buffer);
155 base::TrimWhitespaceASCII(return_value, base::TRIM_ALL, &return_value);
156 return return_value;
157 }
158
159 LOG(ERROR) << "Unable to read crossystem key " << key;
160 return "";
161 }
162
GetHardwareClass() const163 string HardwareChromeOS::GetHardwareClass() const {
164 if (USE_HWID_OVERRIDE) {
165 return HwidOverride::Read(base::FilePath("/"));
166 }
167 return ReadValueFromCrosSystem("hwid");
168 }
169
GetFirmwareVersion() const170 string HardwareChromeOS::GetFirmwareVersion() const {
171 return ReadValueFromCrosSystem("fwid");
172 }
173
GetECVersion() const174 string HardwareChromeOS::GetECVersion() const {
175 string input_line;
176 int exit_code = 0;
177 vector<string> cmd = {"/usr/sbin/mosys", "-k", "ec", "info"};
178
179 bool success = Subprocess::SynchronousExec(cmd, &exit_code, &input_line);
180 if (!success || exit_code) {
181 LOG(ERROR) << "Unable to read ec info from mosys (" << exit_code << ")";
182 return "";
183 }
184
185 return utils::ParseECVersion(input_line);
186 }
187
GetMinKernelKeyVersion() const188 int HardwareChromeOS::GetMinKernelKeyVersion() const {
189 return VbGetSystemPropertyInt("tpm_kernver");
190 }
191
GetMaxFirmwareKeyRollforward() const192 int HardwareChromeOS::GetMaxFirmwareKeyRollforward() const {
193 return VbGetSystemPropertyInt("firmware_max_rollforward");
194 }
195
SetMaxFirmwareKeyRollforward(int firmware_max_rollforward)196 bool HardwareChromeOS::SetMaxFirmwareKeyRollforward(
197 int firmware_max_rollforward) {
198 // Not all devices have this field yet. So first try to read
199 // it and if there is an error just fail.
200 if (GetMaxFirmwareKeyRollforward() == -1)
201 return false;
202
203 return VbSetSystemPropertyInt("firmware_max_rollforward",
204 firmware_max_rollforward) == 0;
205 }
206
GetMinFirmwareKeyVersion() const207 int HardwareChromeOS::GetMinFirmwareKeyVersion() const {
208 return VbGetSystemPropertyInt("tpm_fwver");
209 }
210
SetMaxKernelKeyRollforward(int kernel_max_rollforward)211 bool HardwareChromeOS::SetMaxKernelKeyRollforward(int kernel_max_rollforward) {
212 return VbSetSystemPropertyInt("kernel_max_rollforward",
213 kernel_max_rollforward) == 0;
214 }
215
GetPowerwashCount() const216 int HardwareChromeOS::GetPowerwashCount() const {
217 int powerwash_count;
218 base::FilePath marker_path =
219 base::FilePath(kPowerwashSafeDirectory).Append(kPowerwashCountMarker);
220 string contents;
221 if (!utils::ReadFile(marker_path.value(), &contents))
222 return -1;
223 base::TrimWhitespaceASCII(contents, base::TRIM_TRAILING, &contents);
224 if (!base::StringToInt(contents, &powerwash_count))
225 return -1;
226 return powerwash_count;
227 }
228
SchedulePowerwash(bool is_rollback)229 bool HardwareChromeOS::SchedulePowerwash(bool is_rollback) {
230 const char* powerwash_command =
231 is_rollback ? kRollbackPowerwashCommand : kPowerwashCommand;
232 bool result = utils::WriteFile(
233 kPowerwashMarkerFile, powerwash_command, strlen(powerwash_command));
234 if (result) {
235 LOG(INFO) << "Created " << kPowerwashMarkerFile
236 << " to powerwash on next reboot (is_rollback=" << is_rollback
237 << ")";
238 } else {
239 PLOG(ERROR) << "Error in creating powerwash marker file: "
240 << kPowerwashMarkerFile;
241 }
242
243 return result;
244 }
245
CancelPowerwash()246 bool HardwareChromeOS::CancelPowerwash() {
247 bool result = base::DeleteFile(base::FilePath(kPowerwashMarkerFile), false);
248
249 if (result) {
250 LOG(INFO) << "Successfully deleted the powerwash marker file : "
251 << kPowerwashMarkerFile;
252 } else {
253 PLOG(ERROR) << "Could not delete the powerwash marker file : "
254 << kPowerwashMarkerFile;
255 }
256
257 return result;
258 }
259
GetNonVolatileDirectory(base::FilePath * path) const260 bool HardwareChromeOS::GetNonVolatileDirectory(base::FilePath* path) const {
261 *path = base::FilePath(constants::kNonVolatileDirectory);
262 return true;
263 }
264
GetPowerwashSafeDirectory(base::FilePath * path) const265 bool HardwareChromeOS::GetPowerwashSafeDirectory(base::FilePath* path) const {
266 *path = base::FilePath(kPowerwashSafeDirectory);
267 return true;
268 }
269
GetBuildTimestamp() const270 int64_t HardwareChromeOS::GetBuildTimestamp() const {
271 // TODO(senj): implement this in Chrome OS.
272 return 0;
273 }
274
LoadConfig(const string & root_prefix,bool normal_mode)275 void HardwareChromeOS::LoadConfig(const string& root_prefix, bool normal_mode) {
276 brillo::KeyValueStore store;
277
278 if (normal_mode) {
279 store.Load(base::FilePath(root_prefix + kConfigFilePath));
280 } else {
281 if (store.Load(base::FilePath(root_prefix + kStatefulPartition +
282 kConfigFilePath))) {
283 LOG(INFO) << "UpdateManager Config loaded from stateful partition.";
284 } else {
285 store.Load(base::FilePath(root_prefix + kConfigFilePath));
286 }
287 }
288
289 if (!store.GetBoolean(kConfigOptsIsOOBEEnabled, &is_oobe_enabled_))
290 is_oobe_enabled_ = true; // Default value.
291 }
292
GetFirstActiveOmahaPingSent() const293 bool HardwareChromeOS::GetFirstActiveOmahaPingSent() const {
294 int exit_code = 0;
295 string active_ping_str;
296 vector<string> cmd = {"vpd_get_value", kActivePingKey};
297 if (!Subprocess::SynchronousExec(cmd, &exit_code, &active_ping_str) ||
298 exit_code) {
299 LOG(ERROR) << "Failed to get vpd key for " << kActivePingKey
300 << " with exit code: " << exit_code;
301 return false;
302 }
303
304 base::TrimWhitespaceASCII(active_ping_str, base::TRIM_ALL, &active_ping_str);
305 int active_ping;
306 if (active_ping_str.empty() ||
307 !base::StringToInt(active_ping_str, &active_ping)) {
308 LOG(INFO) << "Failed to parse active_ping value: " << active_ping_str;
309 return false;
310 }
311 return static_cast<bool>(active_ping);
312 }
313
SetFirstActiveOmahaPingSent()314 bool HardwareChromeOS::SetFirstActiveOmahaPingSent() {
315 int exit_code = 0;
316 string output;
317 vector<string> vpd_set_cmd = {
318 "vpd", "-i", "RW_VPD", "-s", string(kActivePingKey) + "=1"};
319 if (!Subprocess::SynchronousExec(vpd_set_cmd, &exit_code, &output) ||
320 exit_code) {
321 LOG(ERROR) << "Failed to set vpd key for " << kActivePingKey
322 << " with exit code: " << exit_code << " with error: " << output;
323 return false;
324 }
325
326 vector<string> vpd_dump_cmd = {"dump_vpd_log", "--force"};
327 if (!Subprocess::SynchronousExec(vpd_dump_cmd, &exit_code, &output) ||
328 exit_code) {
329 LOG(ERROR) << "Failed to cache " << kActivePingKey << " using dump_vpd_log"
330 << " with exit code: " << exit_code << " with error: " << output;
331 return false;
332 }
333 return true;
334 }
335
SetWarmReset(bool warm_reset)336 void HardwareChromeOS::SetWarmReset(bool warm_reset) {}
337
338 } // namespace chromeos_update_engine
339