Alex Deymo | aea4c1c | 2015-08-19 20:24:43 -0700 | [diff] [blame] | 1 | // |
| 2 | // Copyright (C) 2012 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 | // |
Jay Srinivasan | 4348879 | 2012-06-19 00:25:31 -0700 | [diff] [blame] | 16 | |
Alex Deymo | 94c0616 | 2014-03-21 20:34:46 -0700 | [diff] [blame] | 17 | #include "update_engine/real_system_state.h" |
| 18 | |
Alex Deymo | f7ead81 | 2015-10-23 17:37:27 -0700 | [diff] [blame] | 19 | #include <string> |
| 20 | |
Alex Deymo | e97b39c | 2016-01-20 13:22:17 -0800 | [diff] [blame] | 21 | #include <base/bind.h> |
Ben Chan | 06c76a4 | 2014-09-05 08:21:06 -0700 | [diff] [blame] | 22 | #include <base/files/file_util.h> |
Alex Deymo | e97b39c | 2016-01-20 13:22:17 -0800 | [diff] [blame] | 23 | #include <base/location.h> |
Gilad Arnold | b227199 | 2014-06-19 12:35:24 -0700 | [diff] [blame] | 24 | #include <base/time/time.h> |
David Zeuthen | 6eddf26 | 2015-10-16 15:23:53 -0400 | [diff] [blame] | 25 | #include <brillo/make_unique_ptr.h> |
Alex Deymo | e97b39c | 2016-01-20 13:22:17 -0800 | [diff] [blame] | 26 | #include <brillo/message_loops/message_loop.h> |
Amin Hassani | e94ece5 | 2017-08-01 15:03:08 -0700 | [diff] [blame] | 27 | #if USE_CHROME_KIOSK_APP || USE_CHROME_NETWORK_PROXY |
Daniel Erat | e5f6f25 | 2017-04-20 12:09:58 -0600 | [diff] [blame] | 28 | #include <chromeos/dbus/service_constants.h> |
Amin Hassani | e94ece5 | 2017-08-01 15:03:08 -0700 | [diff] [blame] | 29 | #endif // USE_CHROME_KIOSK_APP || USE_CHROME_NETWORK_PROXY |
Jay Srinivasan | 4348879 | 2012-06-19 00:25:31 -0700 | [diff] [blame] | 30 | |
Alex Deymo | 39910dc | 2015-11-09 17:04:30 -0800 | [diff] [blame] | 31 | #include "update_engine/common/boot_control.h" |
| 32 | #include "update_engine/common/boot_control_stub.h" |
| 33 | #include "update_engine/common/constants.h" |
| 34 | #include "update_engine/common/hardware.h" |
| 35 | #include "update_engine/common/utils.h" |
Daniel Erat | e5f6f25 | 2017-04-20 12:09:58 -0600 | [diff] [blame] | 36 | #if USE_DBUS |
| 37 | #include "update_engine/dbus_connection.h" |
| 38 | #endif // USE_DBUS |
Alex Deymo | 63784a5 | 2014-05-28 10:46:14 -0700 | [diff] [blame] | 39 | #include "update_engine/update_manager/state_factory.h" |
Jay Srinivasan | 4348879 | 2012-06-19 00:25:31 -0700 | [diff] [blame] | 40 | |
Alex Deymo | e97b39c | 2016-01-20 13:22:17 -0800 | [diff] [blame] | 41 | using brillo::MessageLoop; |
| 42 | |
Jay Srinivasan | 4348879 | 2012-06-19 00:25:31 -0700 | [diff] [blame] | 43 | namespace chromeos_update_engine { |
| 44 | |
Alex Deymo | 8c21b35 | 2016-01-20 16:38:33 -0800 | [diff] [blame] | 45 | RealSystemState::~RealSystemState() { |
| 46 | // Prevent any DBus communication from UpdateAttempter when shutting down the |
| 47 | // daemon. |
| 48 | if (update_attempter_) |
Alex Deymo | fa78f14 | 2016-01-26 21:36:16 -0800 | [diff] [blame] | 49 | update_attempter_->ClearObservers(); |
Alex Deymo | 8c21b35 | 2016-01-20 16:38:33 -0800 | [diff] [blame] | 50 | } |
| 51 | |
Nam T. Nguyen | 7d623eb | 2014-05-13 16:06:28 -0700 | [diff] [blame] | 52 | bool RealSystemState::Initialize() { |
Jay Srinivasan | 6f6ea00 | 2012-12-14 11:26:28 -0800 | [diff] [blame] | 53 | metrics_lib_.Init(); |
| 54 | |
Alex Deymo | b17327c | 2015-09-04 10:29:00 -0700 | [diff] [blame] | 55 | boot_control_ = boot_control::CreateBootControl(); |
David Zeuthen | 6eddf26 | 2015-10-16 15:23:53 -0400 | [diff] [blame] | 56 | if (!boot_control_) { |
| 57 | LOG(WARNING) << "Unable to create BootControl instance, using stub " |
| 58 | << "instead. All update attempts will fail."; |
| 59 | boot_control_ = brillo::make_unique_ptr(new BootControlStub()); |
| 60 | } |
Alex Deymo | 763e7db | 2015-08-27 21:08:08 -0700 | [diff] [blame] | 61 | |
Alex Deymo | 40d86b2 | 2015-09-03 22:27:10 -0700 | [diff] [blame] | 62 | hardware_ = hardware::CreateHardware(); |
| 63 | if (!hardware_) { |
| 64 | LOG(ERROR) << "Error intializing the HardwareInterface."; |
| 65 | return false; |
| 66 | } |
| 67 | |
Amin Hassani | e94ece5 | 2017-08-01 15:03:08 -0700 | [diff] [blame] | 68 | #if USE_CHROME_KIOSK_APP |
Daniel Erat | e5f6f25 | 2017-04-20 12:09:58 -0600 | [diff] [blame] | 69 | libcros_proxy_.reset(new org::chromium::LibCrosServiceInterfaceProxy( |
| 70 | DBusConnection::Get()->GetDBus(), chromeos::kLibCrosServiceName)); |
Amin Hassani | e94ece5 | 2017-08-01 15:03:08 -0700 | [diff] [blame] | 71 | #endif // USE_CHROME_KIOSK_APP |
| 72 | #if USE_CHROME_NETWORK_PROXY |
Daniel Erat | e5f6f25 | 2017-04-20 12:09:58 -0600 | [diff] [blame] | 73 | network_proxy_service_proxy_.reset( |
| 74 | new org::chromium::NetworkProxyServiceInterfaceProxy( |
| 75 | DBusConnection::Get()->GetDBus(), |
| 76 | chromeos::kNetworkProxyServiceName)); |
Amin Hassani | e94ece5 | 2017-08-01 15:03:08 -0700 | [diff] [blame] | 77 | #endif // USE_CHROME_NETWORK_PROXY |
Daniel Erat | e5f6f25 | 2017-04-20 12:09:58 -0600 | [diff] [blame] | 78 | |
Alex Deymo | 1c4e84a | 2015-09-22 16:58:10 -0700 | [diff] [blame] | 79 | LOG_IF(INFO, !hardware_->IsNormalBootMode()) << "Booted in dev mode."; |
| 80 | LOG_IF(INFO, !hardware_->IsOfficialBuild()) << "Booted non-official build."; |
| 81 | |
Sen Jiang | f5bebae | 2016-06-03 15:36:54 -0700 | [diff] [blame] | 82 | connection_manager_ = connection_manager::CreateConnectionManager(this); |
| 83 | if (!connection_manager_) { |
| 84 | LOG(ERROR) << "Error intializing the ConnectionManagerInterface."; |
Alex Deymo | 3053450 | 2015-07-20 15:06:33 -0700 | [diff] [blame] | 85 | return false; |
| 86 | } |
| 87 | |
Sen Jiang | b8c6a8f | 2016-06-07 17:33:17 -0700 | [diff] [blame] | 88 | power_manager_ = power_manager::CreatePowerManager(); |
| 89 | if (!power_manager_) { |
| 90 | LOG(ERROR) << "Error intializing the PowerManagerInterface."; |
| 91 | return false; |
| 92 | } |
| 93 | |
Alex Deymo | dd132f3 | 2015-09-14 19:12:07 -0700 | [diff] [blame] | 94 | // Initialize standard and powerwash-safe prefs. |
| 95 | base::FilePath non_volatile_path; |
| 96 | // TODO(deymo): Fall back to in-memory prefs if there's no physical directory |
| 97 | // available. |
| 98 | if (!hardware_->GetNonVolatileDirectory(&non_volatile_path)) { |
| 99 | LOG(ERROR) << "Failed to get a non-volatile directory."; |
| 100 | return false; |
| 101 | } |
| 102 | Prefs* prefs; |
| 103 | prefs_.reset(prefs = new Prefs()); |
| 104 | if (!prefs->Init(non_volatile_path.Append(kPrefsSubDirectory))) { |
Jay Srinivasan | 6f6ea00 | 2012-12-14 11:26:28 -0800 | [diff] [blame] | 105 | LOG(ERROR) << "Failed to initialize preferences."; |
| 106 | return false; |
| 107 | } |
| 108 | |
Alex Deymo | dd132f3 | 2015-09-14 19:12:07 -0700 | [diff] [blame] | 109 | base::FilePath powerwash_safe_path; |
| 110 | if (!hardware_->GetPowerwashSafeDirectory(&powerwash_safe_path)) { |
| 111 | // TODO(deymo): Fall-back to in-memory prefs if there's no powerwash-safe |
| 112 | // directory, or disable powerwash feature. |
| 113 | powerwash_safe_path = non_volatile_path.Append("powerwash-safe"); |
| 114 | LOG(WARNING) << "No powerwash-safe directory, using non-volatile one."; |
| 115 | } |
| 116 | powerwash_safe_prefs_.reset(prefs = new Prefs()); |
| 117 | if (!prefs->Init( |
| 118 | powerwash_safe_path.Append(kPowerwashSafePrefsSubDirectory))) { |
Chris Sosa | aa18e16 | 2013-06-20 13:20:30 -0700 | [diff] [blame] | 119 | LOG(ERROR) << "Failed to initialize powerwash preferences."; |
| 120 | return false; |
| 121 | } |
| 122 | |
Alex Deymo | dd132f3 | 2015-09-14 19:12:07 -0700 | [diff] [blame] | 123 | // Check the system rebooted marker file. |
| 124 | std::string boot_id; |
| 125 | if (utils::GetBootId(&boot_id)) { |
| 126 | std::string prev_boot_id; |
| 127 | system_rebooted_ = (!prefs_->GetString(kPrefsBootId, &prev_boot_id) || |
| 128 | prev_boot_id != boot_id); |
| 129 | prefs_->SetString(kPrefsBootId, boot_id); |
| 130 | } else { |
| 131 | LOG(WARNING) << "Couldn't detect the bootid, assuming system was rebooted."; |
Chris Sosa | be45bef | 2013-04-09 18:25:12 -0700 | [diff] [blame] | 132 | system_rebooted_ = true; |
| 133 | } |
| 134 | |
Alex Deymo | 5378f5e | 2015-11-10 15:02:50 -0800 | [diff] [blame] | 135 | // Initialize the OmahaRequestParams with the default settings. These settings |
| 136 | // will be re-initialized before every request using the actual request |
| 137 | // options. This initialization here pre-loads current channel and version, so |
| 138 | // the DBus service can access it. |
| 139 | if (!request_params_.Init("", "", false)) { |
| 140 | LOG(WARNING) << "Ignoring OmahaRequestParams initialization error. Some " |
| 141 | "features might not work properly."; |
| 142 | } |
| 143 | |
Alex Deymo | 33e91e7 | 2015-12-01 18:26:08 -0300 | [diff] [blame] | 144 | certificate_checker_.reset( |
| 145 | new CertificateChecker(prefs_.get(), &openssl_wrapper_)); |
| 146 | certificate_checker_->Init(); |
| 147 | |
Amin Hassani | e94ece5 | 2017-08-01 15:03:08 -0700 | [diff] [blame] | 148 | update_attempter_.reset( |
| 149 | new UpdateAttempter(this, |
| 150 | certificate_checker_.get(), |
| 151 | #if USE_CHROME_NETWORK_PROXY |
| 152 | network_proxy_service_proxy_.get())); |
Sen Jiang | c92195c | 2016-06-13 15:48:44 -0700 | [diff] [blame] | 153 | #else |
Alex Deymo | 209e57a | 2017-08-23 19:23:00 +0200 | [diff] [blame] | 154 | nullptr)); |
Amin Hassani | e94ece5 | 2017-08-01 15:03:08 -0700 | [diff] [blame] | 155 | #endif // USE_CHROME_NETWORK_PROXY |
Sen Jiang | c92195c | 2016-06-13 15:48:44 -0700 | [diff] [blame] | 156 | |
Alex Deymo | 33e91e7 | 2015-12-01 18:26:08 -0300 | [diff] [blame] | 157 | // Initialize the UpdateAttempter before the UpdateManager. |
Alex Deymo | 33e91e7 | 2015-12-01 18:26:08 -0300 | [diff] [blame] | 158 | update_attempter_->Init(); |
| 159 | |
Alex Deymo | 63784a5 | 2014-05-28 10:46:14 -0700 | [diff] [blame] | 160 | // Initialize the Update Manager using the default state factory. |
| 161 | chromeos_update_manager::State* um_state = |
Amin Hassani | e94ece5 | 2017-08-01 15:03:08 -0700 | [diff] [blame] | 162 | chromeos_update_manager::DefaultStateFactory(&policy_provider_, |
| 163 | #if USE_CHROME_KIOSK_APP |
| 164 | libcros_proxy_.get(), |
| 165 | #else |
| 166 | nullptr, |
| 167 | #endif // USE_CHROME_KIOSK_APP |
| 168 | this); |
| 169 | |
Alex Deymo | 63784a5 | 2014-05-28 10:46:14 -0700 | [diff] [blame] | 170 | if (!um_state) { |
| 171 | LOG(ERROR) << "Failed to initialize the Update Manager."; |
Jay Srinivasan | 6f6ea00 | 2012-12-14 11:26:28 -0800 | [diff] [blame] | 172 | return false; |
Gilad Arnold | 1f84723 | 2014-04-07 12:07:49 -0700 | [diff] [blame] | 173 | } |
Alex Deymo | 63784a5 | 2014-05-28 10:46:14 -0700 | [diff] [blame] | 174 | update_manager_.reset( |
Gilad Arnold | b227199 | 2014-06-19 12:35:24 -0700 | [diff] [blame] | 175 | new chromeos_update_manager::UpdateManager( |
Gilad Arnold | fd45a73 | 2014-08-07 15:53:46 -0700 | [diff] [blame] | 176 | &clock_, base::TimeDelta::FromSeconds(5), |
| 177 | base::TimeDelta::FromHours(12), um_state)); |
Gilad Arnold | 1f84723 | 2014-04-07 12:07:49 -0700 | [diff] [blame] | 178 | |
Gilad Arnold | 4a0321b | 2014-10-28 15:57:30 -0700 | [diff] [blame] | 179 | // The P2P Manager depends on the Update Manager for its initialization. |
| 180 | p2p_manager_.reset(P2PManager::Construct( |
| 181 | nullptr, &clock_, update_manager_.get(), "cros_au", |
| 182 | kMaxP2PFilesToKeep, base::TimeDelta::FromDays(kMaxP2PFileAgeDays))); |
| 183 | |
Gilad Arnold | 1f84723 | 2014-04-07 12:07:49 -0700 | [diff] [blame] | 184 | if (!payload_state_.Initialize(this)) { |
| 185 | LOG(ERROR) << "Failed to initialize the payload state object."; |
| 186 | return false; |
| 187 | } |
Jay Srinivasan | 6f6ea00 | 2012-12-14 11:26:28 -0800 | [diff] [blame] | 188 | |
| 189 | // All is well. Initialization successful. |
| 190 | return true; |
| 191 | } |
Jay Srinivasan | 4348879 | 2012-06-19 00:25:31 -0700 | [diff] [blame] | 192 | |
Alex Deymo | fa78f14 | 2016-01-26 21:36:16 -0800 | [diff] [blame] | 193 | bool RealSystemState::StartUpdater() { |
Alex Deymo | e97b39c | 2016-01-20 13:22:17 -0800 | [diff] [blame] | 194 | // Initiate update checks. |
| 195 | update_attempter_->ScheduleUpdates(); |
| 196 | |
| 197 | // Update boot flags after 45 seconds. |
| 198 | MessageLoop::current()->PostDelayedTask( |
| 199 | FROM_HERE, |
| 200 | base::Bind(&UpdateAttempter::UpdateBootFlags, |
| 201 | base::Unretained(update_attempter_.get())), |
| 202 | base::TimeDelta::FromSeconds(45)); |
| 203 | |
| 204 | // Broadcast the update engine status on startup to ensure consistent system |
| 205 | // state on crashes. |
| 206 | MessageLoop::current()->PostTask(FROM_HERE, base::Bind( |
| 207 | &UpdateAttempter::BroadcastStatus, |
| 208 | base::Unretained(update_attempter_.get()))); |
| 209 | |
| 210 | // Run the UpdateEngineStarted() method on |update_attempter|. |
| 211 | MessageLoop::current()->PostTask(FROM_HERE, base::Bind( |
| 212 | &UpdateAttempter::UpdateEngineStarted, |
| 213 | base::Unretained(update_attempter_.get()))); |
Alex Deymo | fa78f14 | 2016-01-26 21:36:16 -0800 | [diff] [blame] | 214 | return true; |
| 215 | } |
| 216 | |
| 217 | void RealSystemState::AddObserver(ServiceObserverInterface* observer) { |
| 218 | CHECK(update_attempter_.get()); |
| 219 | update_attempter_->AddObserver(observer); |
| 220 | } |
| 221 | |
| 222 | void RealSystemState::RemoveObserver(ServiceObserverInterface* observer) { |
| 223 | CHECK(update_attempter_.get()); |
| 224 | update_attempter_->RemoveObserver(observer); |
Alex Deymo | e97b39c | 2016-01-20 13:22:17 -0800 | [diff] [blame] | 225 | } |
| 226 | |
Jay Srinivasan | 4348879 | 2012-06-19 00:25:31 -0700 | [diff] [blame] | 227 | } // namespace chromeos_update_engine |