Alex Deymo | 40d86b2 | 2015-09-03 22:27:10 -0700 | [diff] [blame] | 1 | // |
| 2 | // Copyright (C) 2015 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 | |
Alex Deymo | 1b03f9f | 2015-12-09 00:38:36 -0800 | [diff] [blame] | 17 | #include "update_engine/hardware_android.h" |
Alex Deymo | 40d86b2 | 2015-09-03 22:27:10 -0700 | [diff] [blame] | 18 | |
Alex Deymo | fb905d9 | 2016-06-03 19:26:58 -0700 | [diff] [blame] | 19 | #include <sys/types.h> |
| 20 | |
Tom Cherry | fadd03c | 2017-10-10 14:45:09 -0700 | [diff] [blame] | 21 | #include <memory> |
Alex Deymo | fb905d9 | 2016-06-03 19:26:58 -0700 | [diff] [blame] | 22 | |
Tom Cherry | fadd03c | 2017-10-10 14:45:09 -0700 | [diff] [blame] | 23 | #include <android-base/properties.h> |
Alex Deymo | dd132f3 | 2015-09-14 19:12:07 -0700 | [diff] [blame] | 24 | #include <base/files/file_util.h> |
Tao Bao | 304680c | 2018-03-31 10:36:52 -0700 | [diff] [blame] | 25 | #include <bootloader_message/bootloader_message.h> |
Alex Deymo | 40d86b2 | 2015-09-03 22:27:10 -0700 | [diff] [blame] | 26 | |
Alex Deymo | 39910dc | 2015-11-09 17:04:30 -0800 | [diff] [blame] | 27 | #include "update_engine/common/hardware.h" |
Sen Jiang | 9c12346 | 2015-11-19 13:16:23 -0800 | [diff] [blame] | 28 | #include "update_engine/common/platform_constants.h" |
Alex Deymo | 40d86b2 | 2015-09-03 22:27:10 -0700 | [diff] [blame] | 29 | |
Tom Cherry | fadd03c | 2017-10-10 14:45:09 -0700 | [diff] [blame] | 30 | using android::base::GetBoolProperty; |
| 31 | using android::base::GetIntProperty; |
| 32 | using android::base::GetProperty; |
Alex Deymo | 40d86b2 | 2015-09-03 22:27:10 -0700 | [diff] [blame] | 33 | using std::string; |
| 34 | |
| 35 | namespace chromeos_update_engine { |
| 36 | |
Alex Deymo | fb905d9 | 2016-06-03 19:26:58 -0700 | [diff] [blame] | 37 | namespace { |
| 38 | |
Alex Deymo | ebf6e12 | 2017-03-10 16:12:01 -0800 | [diff] [blame] | 39 | // Android properties that identify the hardware and potentially non-updatable |
| 40 | // parts of the bootloader (such as the bootloader version and the baseband |
| 41 | // version). |
| 42 | const char kPropBootBootloader[] = "ro.boot.bootloader"; |
| 43 | const char kPropBootBaseband[] = "ro.boot.baseband"; |
| 44 | const char kPropProductManufacturer[] = "ro.product.manufacturer"; |
| 45 | const char kPropBootHardwareSKU[] = "ro.boot.hardware.sku"; |
| 46 | const char kPropBootRevision[] = "ro.boot.revision"; |
Sen Jiang | 5011df6 | 2017-06-28 17:13:19 -0700 | [diff] [blame] | 47 | const char kPropBuildDateUTC[] = "ro.build.date.utc"; |
Alex Deymo | ebf6e12 | 2017-03-10 16:12:01 -0800 | [diff] [blame] | 48 | |
Alex Deymo | fb905d9 | 2016-06-03 19:26:58 -0700 | [diff] [blame] | 49 | } // namespace |
| 50 | |
Alex Deymo | 40d86b2 | 2015-09-03 22:27:10 -0700 | [diff] [blame] | 51 | namespace hardware { |
| 52 | |
| 53 | // Factory defined in hardware.h. |
| 54 | std::unique_ptr<HardwareInterface> CreateHardware() { |
Ben Chan | ab5a0af | 2017-10-12 14:57:50 -0700 | [diff] [blame] | 55 | return std::make_unique<HardwareAndroid>(); |
Alex Deymo | 40d86b2 | 2015-09-03 22:27:10 -0700 | [diff] [blame] | 56 | } |
| 57 | |
| 58 | } // namespace hardware |
| 59 | |
Alex Deymo | 1c4e84a | 2015-09-22 16:58:10 -0700 | [diff] [blame] | 60 | // In Android there are normally three kinds of builds: eng, userdebug and user. |
| 61 | // These builds target respectively a developer build, a debuggable version of |
| 62 | // the final product and the pristine final product the end user will run. |
| 63 | // Apart from the ro.build.type property name, they differ in the following |
| 64 | // properties that characterize the builds: |
| 65 | // * eng builds: ro.secure=0 and ro.debuggable=1 |
| 66 | // * userdebug builds: ro.secure=1 and ro.debuggable=1 |
| 67 | // * user builds: ro.secure=1 and ro.debuggable=0 |
| 68 | // |
| 69 | // See IsOfficialBuild() and IsNormalMode() for the meaning of these options in |
| 70 | // Android. |
| 71 | |
Alex Deymo | 40d86b2 | 2015-09-03 22:27:10 -0700 | [diff] [blame] | 72 | bool HardwareAndroid::IsOfficialBuild() const { |
Alex Deymo | 1c4e84a | 2015-09-22 16:58:10 -0700 | [diff] [blame] | 73 | // We run an official build iff ro.secure == 1, because we expect the build to |
| 74 | // behave like the end user product and check for updates. Note that while |
| 75 | // developers are able to build "official builds" by just running "make user", |
| 76 | // that will only result in a more restrictive environment. The important part |
| 77 | // is that we don't produce and push "non-official" builds to the end user. |
| 78 | // |
| 79 | // In case of a non-bool value, we take the most restrictive option and |
| 80 | // assume we are in an official-build. |
Tom Cherry | fadd03c | 2017-10-10 14:45:09 -0700 | [diff] [blame] | 81 | return GetBoolProperty("ro.secure", true); |
Alex Deymo | 40d86b2 | 2015-09-03 22:27:10 -0700 | [diff] [blame] | 82 | } |
| 83 | |
| 84 | bool HardwareAndroid::IsNormalBootMode() const { |
Alex Deymo | 1c4e84a | 2015-09-22 16:58:10 -0700 | [diff] [blame] | 85 | // We are running in "dev-mode" iff ro.debuggable == 1. In dev-mode the |
| 86 | // update_engine will allow extra developers options, such as providing a |
| 87 | // different update URL. In case of error, we assume the build is in |
| 88 | // normal-mode. |
Tom Cherry | fadd03c | 2017-10-10 14:45:09 -0700 | [diff] [blame] | 89 | return !GetBoolProperty("ro.debuggable", false); |
Alex Deymo | 40d86b2 | 2015-09-03 22:27:10 -0700 | [diff] [blame] | 90 | } |
| 91 | |
Sen Jiang | e67bb5b | 2016-06-20 15:53:56 -0700 | [diff] [blame] | 92 | bool HardwareAndroid::AreDevFeaturesEnabled() const { |
| 93 | return !IsNormalBootMode(); |
| 94 | } |
| 95 | |
Alex Deymo | 46a9aae | 2016-05-04 20:20:11 -0700 | [diff] [blame] | 96 | bool HardwareAndroid::IsOOBEEnabled() const { |
| 97 | // No OOBE flow blocking updates for Android-based boards. |
| 98 | return false; |
| 99 | } |
| 100 | |
Alex Deymo | 40d86b2 | 2015-09-03 22:27:10 -0700 | [diff] [blame] | 101 | bool HardwareAndroid::IsOOBEComplete(base::Time* out_time_of_oobe) const { |
Alex Deymo | 46a9aae | 2016-05-04 20:20:11 -0700 | [diff] [blame] | 102 | LOG(WARNING) << "OOBE is not enabled but IsOOBEComplete() called."; |
Alex Deymo | 4d2990d | 2015-09-15 12:11:26 -0700 | [diff] [blame] | 103 | if (out_time_of_oobe) |
| 104 | *out_time_of_oobe = base::Time(); |
Alex Deymo | 40d86b2 | 2015-09-03 22:27:10 -0700 | [diff] [blame] | 105 | return true; |
| 106 | } |
| 107 | |
| 108 | string HardwareAndroid::GetHardwareClass() const { |
Tom Cherry | fadd03c | 2017-10-10 14:45:09 -0700 | [diff] [blame] | 109 | auto manufacturer = GetProperty(kPropProductManufacturer, ""); |
| 110 | auto sku = GetProperty(kPropBootHardwareSKU, ""); |
| 111 | auto revision = GetProperty(kPropBootRevision, ""); |
Alex Deymo | ebf6e12 | 2017-03-10 16:12:01 -0800 | [diff] [blame] | 112 | |
Tom Cherry | fadd03c | 2017-10-10 14:45:09 -0700 | [diff] [blame] | 113 | return manufacturer + ":" + sku + ":" + revision; |
Alex Deymo | 40d86b2 | 2015-09-03 22:27:10 -0700 | [diff] [blame] | 114 | } |
| 115 | |
| 116 | string HardwareAndroid::GetFirmwareVersion() const { |
Tom Cherry | fadd03c | 2017-10-10 14:45:09 -0700 | [diff] [blame] | 117 | return GetProperty(kPropBootBootloader, ""); |
Alex Deymo | 40d86b2 | 2015-09-03 22:27:10 -0700 | [diff] [blame] | 118 | } |
| 119 | |
| 120 | string HardwareAndroid::GetECVersion() const { |
Tom Cherry | fadd03c | 2017-10-10 14:45:09 -0700 | [diff] [blame] | 121 | return GetProperty(kPropBootBaseband, ""); |
Alex Deymo | 40d86b2 | 2015-09-03 22:27:10 -0700 | [diff] [blame] | 122 | } |
| 123 | |
Zentaro Kavanagh | baacb98 | 2018-02-20 17:48:39 -0800 | [diff] [blame] | 124 | int HardwareAndroid::GetMinKernelKeyVersion() const { |
| 125 | LOG(WARNING) << "STUB: No Kernel key version is available."; |
| 126 | return -1; |
| 127 | } |
| 128 | |
Marton Hunyady | 99ced78 | 2018-05-08 12:59:50 +0200 | [diff] [blame] | 129 | int HardwareAndroid::GetMinFirmwareKeyVersion() const { |
| 130 | LOG(WARNING) << "STUB: No Firmware key version is available."; |
| 131 | return -1; |
| 132 | } |
| 133 | |
Zentaro Kavanagh | 8f6f243 | 2018-05-16 13:48:12 -0700 | [diff] [blame] | 134 | int HardwareAndroid::GetMaxFirmwareKeyRollforward() const { |
| 135 | LOG(WARNING) << "STUB: Getting firmware_max_rollforward is not supported."; |
| 136 | return -1; |
| 137 | } |
| 138 | |
| 139 | bool HardwareAndroid::SetMaxFirmwareKeyRollforward( |
| 140 | int firmware_max_rollforward) { |
| 141 | LOG(WARNING) << "STUB: Setting firmware_max_rollforward is not supported."; |
| 142 | return false; |
| 143 | } |
| 144 | |
Zentaro Kavanagh | 5d95615 | 2018-05-15 09:40:33 -0700 | [diff] [blame] | 145 | bool HardwareAndroid::SetMaxKernelKeyRollforward(int kernel_max_rollforward) { |
| 146 | LOG(WARNING) << "STUB: Setting kernel_max_rollforward is not supported."; |
Zentaro Kavanagh | baacb98 | 2018-02-20 17:48:39 -0800 | [diff] [blame] | 147 | return false; |
| 148 | } |
| 149 | |
Alex Deymo | 40d86b2 | 2015-09-03 22:27:10 -0700 | [diff] [blame] | 150 | int HardwareAndroid::GetPowerwashCount() const { |
| 151 | LOG(WARNING) << "STUB: Assuming no factory reset was performed."; |
| 152 | return 0; |
| 153 | } |
| 154 | |
Zentaro Kavanagh | 0418de3 | 2019-01-15 10:29:35 -0800 | [diff] [blame] | 155 | bool HardwareAndroid::SchedulePowerwash(bool is_rollback) { |
Alex Deymo | fb905d9 | 2016-06-03 19:26:58 -0700 | [diff] [blame] | 156 | LOG(INFO) << "Scheduling a powerwash to BCB."; |
Zentaro Kavanagh | 0418de3 | 2019-01-15 10:29:35 -0800 | [diff] [blame] | 157 | LOG_IF(WARNING, is_rollback) << "is_rollback was true but isn't supported."; |
Sen Jiang | d944faa | 2018-08-22 18:46:39 -0700 | [diff] [blame] | 158 | string err; |
| 159 | if (!update_bootloader_message({"--wipe_data", "--reason=wipe_data_from_ota"}, |
| 160 | &err)) { |
| 161 | LOG(ERROR) << "Failed to update bootloader message: " << err; |
| 162 | return false; |
| 163 | } |
| 164 | return true; |
Alex Deymo | fb905d9 | 2016-06-03 19:26:58 -0700 | [diff] [blame] | 165 | } |
| 166 | |
| 167 | bool HardwareAndroid::CancelPowerwash() { |
Sen Jiang | d944faa | 2018-08-22 18:46:39 -0700 | [diff] [blame] | 168 | string err; |
| 169 | if (!clear_bootloader_message(&err)) { |
| 170 | LOG(ERROR) << "Failed to clear bootloader message: " << err; |
| 171 | return false; |
| 172 | } |
| 173 | return true; |
Alex Deymo | fb905d9 | 2016-06-03 19:26:58 -0700 | [diff] [blame] | 174 | } |
| 175 | |
Alex Deymo | dd132f3 | 2015-09-14 19:12:07 -0700 | [diff] [blame] | 176 | bool HardwareAndroid::GetNonVolatileDirectory(base::FilePath* path) const { |
Sen Jiang | 9c12346 | 2015-11-19 13:16:23 -0800 | [diff] [blame] | 177 | base::FilePath local_path(constants::kNonVolatileDirectory); |
Alex Deymo | dd132f3 | 2015-09-14 19:12:07 -0700 | [diff] [blame] | 178 | if (!base::PathExists(local_path)) { |
| 179 | LOG(ERROR) << "Non-volatile directory not found: " << local_path.value(); |
| 180 | return false; |
| 181 | } |
| 182 | *path = local_path; |
| 183 | return true; |
| 184 | } |
| 185 | |
| 186 | bool HardwareAndroid::GetPowerwashSafeDirectory(base::FilePath* path) const { |
| 187 | // On Android, we don't have a directory persisted across powerwash. |
| 188 | return false; |
| 189 | } |
| 190 | |
Sen Jiang | 5011df6 | 2017-06-28 17:13:19 -0700 | [diff] [blame] | 191 | int64_t HardwareAndroid::GetBuildTimestamp() const { |
Tom Cherry | fadd03c | 2017-10-10 14:45:09 -0700 | [diff] [blame] | 192 | return GetIntProperty<int64_t>(kPropBuildDateUTC, 0); |
Sen Jiang | 5011df6 | 2017-06-28 17:13:19 -0700 | [diff] [blame] | 193 | } |
| 194 | |
Tianjie Xu | 4ad3af6 | 2019-10-30 11:59:45 -0700 | [diff] [blame] | 195 | // Returns true if the device runs an userdebug build, and explicitly allows OTA |
| 196 | // downgrade. |
| 197 | bool HardwareAndroid::AllowDowngrade() const { |
| 198 | return GetBoolProperty("ro.ota.allow_downgrade", false) && |
| 199 | GetBoolProperty("ro.debuggable", false); |
| 200 | } |
| 201 | |
Amin Hassani | 1677e81 | 2017-06-21 13:36:36 -0700 | [diff] [blame] | 202 | bool HardwareAndroid::GetFirstActiveOmahaPingSent() const { |
| 203 | LOG(WARNING) << "STUB: Assuming first active omaha was never set."; |
| 204 | return false; |
| 205 | } |
| 206 | |
Amin Hassani | 80f4d4c | 2018-05-16 13:34:00 -0700 | [diff] [blame] | 207 | bool HardwareAndroid::SetFirstActiveOmahaPingSent() { |
| 208 | LOG(WARNING) << "STUB: Assuming first active omaha is set."; |
| 209 | // We will set it true, so its failure doesn't cause escalation. |
| 210 | return true; |
Amin Hassani | 1677e81 | 2017-06-21 13:36:36 -0700 | [diff] [blame] | 211 | } |
| 212 | |
Tianjie Xu | d6aa91f | 2019-11-14 11:55:10 -0800 | [diff] [blame] | 213 | void HardwareAndroid::SetWarmReset(bool warm_reset) { |
| 214 | constexpr char warm_reset_prop[] = "ota.warm_reset"; |
| 215 | if (!android::base::SetProperty(warm_reset_prop, warm_reset ? "1" : "0")) { |
| 216 | LOG(WARNING) << "Failed to set prop " << warm_reset_prop; |
| 217 | } |
| 218 | } |
| 219 | |
Alex Deymo | 40d86b2 | 2015-09-03 22:27:10 -0700 | [diff] [blame] | 220 | } // namespace chromeos_update_engine |