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 //
16
17 #include "update_engine/real_system_state.h"
18
19 #include <memory>
20 #include <string>
21
22 #include <base/bind.h>
23 #include <base/files/file_util.h>
24 #include <base/location.h>
25 #include <base/time/time.h>
26 #include <brillo/message_loops/message_loop.h>
27 #if USE_CHROME_KIOSK_APP
28 #include <chromeos/dbus/service_constants.h>
29 #endif // USE_CHROME_KIOSK_APP
30
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"
36 #include "update_engine/metrics_reporter_omaha.h"
37 #if USE_DBUS
38 #include "update_engine/dbus_connection.h"
39 #endif // USE_DBUS
40 #include "update_engine/update_manager/state_factory.h"
41
42 using brillo::MessageLoop;
43
44 namespace chromeos_update_engine {
45
~RealSystemState()46 RealSystemState::~RealSystemState() {
47 // Prevent any DBus communication from UpdateAttempter when shutting down the
48 // daemon.
49 if (update_attempter_)
50 update_attempter_->ClearObservers();
51 }
52
Initialize()53 bool RealSystemState::Initialize() {
54 metrics_reporter_.Initialize();
55
56 boot_control_ = boot_control::CreateBootControl();
57 if (!boot_control_) {
58 LOG(WARNING) << "Unable to create BootControl instance, using stub "
59 << "instead. All update attempts will fail.";
60 boot_control_ = std::make_unique<BootControlStub>();
61 }
62
63 hardware_ = hardware::CreateHardware();
64 if (!hardware_) {
65 LOG(ERROR) << "Error intializing the HardwareInterface.";
66 return false;
67 }
68
69 #if USE_CHROME_KIOSK_APP
70 libcros_proxy_.reset(new org::chromium::LibCrosServiceInterfaceProxy(
71 DBusConnection::Get()->GetDBus(), chromeos::kLibCrosServiceName));
72 #endif // USE_CHROME_KIOSK_APP
73
74 LOG_IF(INFO, !hardware_->IsNormalBootMode()) << "Booted in dev mode.";
75 LOG_IF(INFO, !hardware_->IsOfficialBuild()) << "Booted non-official build.";
76
77 connection_manager_ = connection_manager::CreateConnectionManager(this);
78 if (!connection_manager_) {
79 LOG(ERROR) << "Error intializing the ConnectionManagerInterface.";
80 return false;
81 }
82
83 power_manager_ = power_manager::CreatePowerManager();
84 if (!power_manager_) {
85 LOG(ERROR) << "Error intializing the PowerManagerInterface.";
86 return false;
87 }
88
89 // Initialize standard and powerwash-safe prefs.
90 base::FilePath non_volatile_path;
91 // TODO(deymo): Fall back to in-memory prefs if there's no physical directory
92 // available.
93 if (!hardware_->GetNonVolatileDirectory(&non_volatile_path)) {
94 LOG(ERROR) << "Failed to get a non-volatile directory.";
95 return false;
96 }
97 Prefs* prefs;
98 prefs_.reset(prefs = new Prefs());
99 if (!prefs->Init(non_volatile_path.Append(kPrefsSubDirectory))) {
100 LOG(ERROR) << "Failed to initialize preferences.";
101 return false;
102 }
103
104 base::FilePath powerwash_safe_path;
105 if (!hardware_->GetPowerwashSafeDirectory(&powerwash_safe_path)) {
106 // TODO(deymo): Fall-back to in-memory prefs if there's no powerwash-safe
107 // directory, or disable powerwash feature.
108 powerwash_safe_path = non_volatile_path.Append("powerwash-safe");
109 LOG(WARNING) << "No powerwash-safe directory, using non-volatile one.";
110 }
111 powerwash_safe_prefs_.reset(prefs = new Prefs());
112 if (!prefs->Init(
113 powerwash_safe_path.Append(kPowerwashSafePrefsSubDirectory))) {
114 LOG(ERROR) << "Failed to initialize powerwash preferences.";
115 return false;
116 }
117
118 // Check the system rebooted marker file.
119 std::string boot_id;
120 if (utils::GetBootId(&boot_id)) {
121 std::string prev_boot_id;
122 system_rebooted_ = (!prefs_->GetString(kPrefsBootId, &prev_boot_id) ||
123 prev_boot_id != boot_id);
124 prefs_->SetString(kPrefsBootId, boot_id);
125 } else {
126 LOG(WARNING) << "Couldn't detect the bootid, assuming system was rebooted.";
127 system_rebooted_ = true;
128 }
129
130 // Initialize the OmahaRequestParams with the default settings. These settings
131 // will be re-initialized before every request using the actual request
132 // options. This initialization here pre-loads current channel and version, so
133 // the DBus service can access it.
134 if (!request_params_.Init("", "", false)) {
135 LOG(WARNING) << "Ignoring OmahaRequestParams initialization error. Some "
136 "features might not work properly.";
137 }
138
139 certificate_checker_.reset(
140 new CertificateChecker(prefs_.get(), &openssl_wrapper_));
141 certificate_checker_->Init();
142
143 update_attempter_.reset(new UpdateAttempter(this,
144 certificate_checker_.get()));
145
146 // Initialize the UpdateAttempter before the UpdateManager.
147 update_attempter_->Init();
148
149 // Initialize the Update Manager using the default state factory.
150 chromeos_update_manager::State* um_state =
151 chromeos_update_manager::DefaultStateFactory(&policy_provider_,
152 #if USE_CHROME_KIOSK_APP
153 libcros_proxy_.get(),
154 #else
155 nullptr,
156 #endif // USE_CHROME_KIOSK_APP
157 this);
158
159 if (!um_state) {
160 LOG(ERROR) << "Failed to initialize the Update Manager.";
161 return false;
162 }
163 update_manager_.reset(
164 new chromeos_update_manager::UpdateManager(
165 &clock_, base::TimeDelta::FromSeconds(5),
166 base::TimeDelta::FromHours(12), um_state));
167
168 // The P2P Manager depends on the Update Manager for its initialization.
169 p2p_manager_.reset(P2PManager::Construct(
170 nullptr, &clock_, update_manager_.get(), "cros_au",
171 kMaxP2PFilesToKeep, base::TimeDelta::FromDays(kMaxP2PFileAgeDays)));
172
173 if (!payload_state_.Initialize(this)) {
174 LOG(ERROR) << "Failed to initialize the payload state object.";
175 return false;
176 }
177
178 // All is well. Initialization successful.
179 return true;
180 }
181
StartUpdater()182 bool RealSystemState::StartUpdater() {
183 // Initiate update checks.
184 update_attempter_->ScheduleUpdates();
185
186 // Update boot flags after 45 seconds.
187 MessageLoop::current()->PostDelayedTask(
188 FROM_HERE,
189 base::Bind(&UpdateAttempter::UpdateBootFlags,
190 base::Unretained(update_attempter_.get())),
191 base::TimeDelta::FromSeconds(45));
192
193 // Broadcast the update engine status on startup to ensure consistent system
194 // state on crashes.
195 MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
196 &UpdateAttempter::BroadcastStatus,
197 base::Unretained(update_attempter_.get())));
198
199 // Run the UpdateEngineStarted() method on |update_attempter|.
200 MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
201 &UpdateAttempter::UpdateEngineStarted,
202 base::Unretained(update_attempter_.get())));
203 return true;
204 }
205
AddObserver(ServiceObserverInterface * observer)206 void RealSystemState::AddObserver(ServiceObserverInterface* observer) {
207 CHECK(update_attempter_.get());
208 update_attempter_->AddObserver(observer);
209 }
210
RemoveObserver(ServiceObserverInterface * observer)211 void RealSystemState::RemoveObserver(ServiceObserverInterface* observer) {
212 CHECK(update_attempter_.get());
213 update_attempter_->RemoveObserver(observer);
214 }
215
216 } // namespace chromeos_update_engine
217