1 //
2 // Copyright (C) 2019 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 #if !defined(__ANDROID_RECOVERY__)
18 #include <android-base/logging.h>
19 #include <android-base/properties.h>
20 #include <android/gsi/BnProgressCallback.h>
21 #include <android/gsi/IGsiService.h>
22 #include <libfiemap/image_manager.h>
23 #include <libgsi/libgsi.h>
24 #include <libgsi/libgsid.h>
25
26 namespace android {
27 namespace fiemap {
28
29 using namespace android::gsi;
30 using namespace std::chrono_literals;
31
32 class ProgressCallback final : public BnProgressCallback {
33 public:
ProgressCallback(std::function<bool (uint64_t,uint64_t)> && callback)34 ProgressCallback(std::function<bool(uint64_t, uint64_t)>&& callback)
35 : callback_(std::move(callback)) {
36 CHECK(callback_);
37 }
onProgress(int64_t current,int64_t total)38 android::binder::Status onProgress(int64_t current, int64_t total) {
39 if (callback_(static_cast<uint64_t>(current), static_cast<uint64_t>(total))) {
40 return android::binder::Status::ok();
41 }
42 return android::binder::Status::fromServiceSpecificError(UNKNOWN_ERROR,
43 "Progress callback failed");
44 }
45
46 private:
47 std::function<bool(uint64_t, uint64_t)> callback_;
48 };
49
50 class ImageManagerBinder final : public IImageManager {
51 public:
52 ImageManagerBinder(android::sp<IGsiService>&& service, android::sp<IImageService>&& manager);
53 FiemapStatus CreateBackingImage(const std::string& name, uint64_t size, int flags,
54 std::function<bool(uint64_t, uint64_t)>&& on_progress) override;
55 bool DeleteBackingImage(const std::string& name) override;
56 bool MapImageDevice(const std::string& name, const std::chrono::milliseconds& timeout_ms,
57 std::string* path) override;
58 bool UnmapImageDevice(const std::string& name) override;
59 bool BackingImageExists(const std::string& name) override;
60 bool IsImageMapped(const std::string& name) override;
61 bool MapImageWithDeviceMapper(const IPartitionOpener& opener, const std::string& name,
62 std::string* dev) override;
63 FiemapStatus ZeroFillNewImage(const std::string& name, uint64_t bytes) override;
64 bool RemoveAllImages() override;
65 bool DisableImage(const std::string& name) override;
66 bool RemoveDisabledImages() override;
67 bool GetMappedImageDevice(const std::string& name, std::string* device) override;
68 bool MapAllImages(const std::function<bool(std::set<std::string>)>& init) override;
69
70 std::vector<std::string> GetAllBackingImages() override;
71
72 private:
73 android::sp<IGsiService> service_;
74 android::sp<IImageService> manager_;
75 };
76
ToFiemapStatus(const char * func,const binder::Status & status)77 static FiemapStatus ToFiemapStatus(const char* func, const binder::Status& status) {
78 if (!status.isOk()) {
79 LOG(ERROR) << func << " binder returned: " << status.toString8().string();
80 if (status.serviceSpecificErrorCode() != 0) {
81 return FiemapStatus::FromErrorCode(status.serviceSpecificErrorCode());
82 } else {
83 return FiemapStatus::Error();
84 }
85 }
86 return FiemapStatus::Ok();
87 }
88
ImageManagerBinder(android::sp<IGsiService> && service,android::sp<IImageService> && manager)89 ImageManagerBinder::ImageManagerBinder(android::sp<IGsiService>&& service,
90 android::sp<IImageService>&& manager)
91 : service_(std::move(service)), manager_(std::move(manager)) {}
92
CreateBackingImage(const std::string & name,uint64_t size,int flags,std::function<bool (uint64_t,uint64_t)> && on_progress)93 FiemapStatus ImageManagerBinder::CreateBackingImage(
94 const std::string& name, uint64_t size, int flags,
95 std::function<bool(uint64_t, uint64_t)>&& on_progress) {
96 sp<IProgressCallback> callback = nullptr;
97 if (on_progress) {
98 callback = new ProgressCallback(std::move(on_progress));
99 }
100 auto status = manager_->createBackingImage(name, size, flags, callback);
101 return ToFiemapStatus(__PRETTY_FUNCTION__, status);
102 }
103
DeleteBackingImage(const std::string & name)104 bool ImageManagerBinder::DeleteBackingImage(const std::string& name) {
105 auto status = manager_->deleteBackingImage(name);
106 if (!status.isOk()) {
107 LOG(ERROR) << __PRETTY_FUNCTION__
108 << " binder returned: " << status.exceptionMessage().string();
109 return false;
110 }
111 return true;
112 }
113
MapImageDevice(const std::string & name,const std::chrono::milliseconds & timeout_ms,std::string * path)114 bool ImageManagerBinder::MapImageDevice(const std::string& name,
115 const std::chrono::milliseconds& timeout_ms,
116 std::string* path) {
117 int32_t timeout_ms_count =
118 static_cast<int32_t>(std::clamp<typename std::chrono::milliseconds::rep>(
119 timeout_ms.count(), INT32_MIN, INT32_MAX));
120 MappedImage map;
121 auto status = manager_->mapImageDevice(name, timeout_ms_count, &map);
122 if (!status.isOk()) {
123 LOG(ERROR) << __PRETTY_FUNCTION__
124 << " binder returned: " << status.exceptionMessage().string();
125 return false;
126 }
127 *path = map.path;
128 return true;
129 }
130
UnmapImageDevice(const std::string & name)131 bool ImageManagerBinder::UnmapImageDevice(const std::string& name) {
132 auto status = manager_->unmapImageDevice(name);
133 if (!status.isOk()) {
134 LOG(ERROR) << __PRETTY_FUNCTION__
135 << " binder returned: " << status.exceptionMessage().string();
136 return false;
137 }
138 return true;
139 }
140
BackingImageExists(const std::string & name)141 bool ImageManagerBinder::BackingImageExists(const std::string& name) {
142 bool retval;
143 auto status = manager_->backingImageExists(name, &retval);
144 if (!status.isOk()) {
145 LOG(ERROR) << __PRETTY_FUNCTION__
146 << " binder returned: " << status.exceptionMessage().string();
147 return false;
148 }
149 return retval;
150 }
151
IsImageMapped(const std::string & name)152 bool ImageManagerBinder::IsImageMapped(const std::string& name) {
153 bool retval;
154 auto status = manager_->isImageMapped(name, &retval);
155 if (!status.isOk()) {
156 LOG(ERROR) << __PRETTY_FUNCTION__
157 << " binder returned: " << status.exceptionMessage().string();
158 return false;
159 }
160 return retval;
161 }
162
MapImageWithDeviceMapper(const IPartitionOpener & opener,const std::string & name,std::string * dev)163 bool ImageManagerBinder::MapImageWithDeviceMapper(const IPartitionOpener& opener,
164 const std::string& name, std::string* dev) {
165 (void)opener;
166 (void)name;
167 (void)dev;
168 LOG(ERROR) << "MapImageWithDeviceMapper is not available over binder.";
169 return false;
170 }
171
GetAllBackingImages()172 std::vector<std::string> ImageManagerBinder::GetAllBackingImages() {
173 std::vector<std::string> retval;
174 auto status = manager_->getAllBackingImages(&retval);
175 if (!status.isOk()) {
176 LOG(ERROR) << __PRETTY_FUNCTION__
177 << " binder returned: " << status.exceptionMessage().string();
178 }
179 return retval;
180 }
181
ZeroFillNewImage(const std::string & name,uint64_t bytes)182 FiemapStatus ImageManagerBinder::ZeroFillNewImage(const std::string& name, uint64_t bytes) {
183 auto status = manager_->zeroFillNewImage(name, bytes);
184 return ToFiemapStatus(__PRETTY_FUNCTION__, status);
185 }
186
RemoveAllImages()187 bool ImageManagerBinder::RemoveAllImages() {
188 auto status = manager_->removeAllImages();
189 if (!status.isOk()) {
190 LOG(ERROR) << __PRETTY_FUNCTION__
191 << " binder returned: " << status.exceptionMessage().string();
192 return false;
193 }
194 return true;
195 }
196
DisableImage(const std::string &)197 bool ImageManagerBinder::DisableImage(const std::string&) {
198 LOG(ERROR) << __PRETTY_FUNCTION__ << " is not available over binder";
199 return false;
200 }
201
RemoveDisabledImages()202 bool ImageManagerBinder::RemoveDisabledImages() {
203 auto status = manager_->removeDisabledImages();
204 if (!status.isOk()) {
205 LOG(ERROR) << __PRETTY_FUNCTION__
206 << " binder returned: " << status.exceptionMessage().string();
207 return false;
208 }
209 return true;
210 }
211
GetMappedImageDevice(const std::string & name,std::string * device)212 bool ImageManagerBinder::GetMappedImageDevice(const std::string& name, std::string* device) {
213 auto status = manager_->getMappedImageDevice(name, device);
214 if (!status.isOk()) {
215 LOG(ERROR) << __PRETTY_FUNCTION__
216 << " binder returned: " << status.exceptionMessage().string();
217 return false;
218 }
219 return !device->empty();
220 }
221
MapAllImages(const std::function<bool (std::set<std::string>)> &)222 bool ImageManagerBinder::MapAllImages(const std::function<bool(std::set<std::string>)>&) {
223 LOG(ERROR) << __PRETTY_FUNCTION__ << " not available over binder";
224 return false;
225 }
226
Open(const std::string & dir,const std::chrono::milliseconds &,const DeviceInfo &)227 std::unique_ptr<IImageManager> IImageManager::Open(const std::string& dir,
228 const std::chrono::milliseconds& /*timeout_ms*/,
229 const DeviceInfo&) {
230 android::sp<IGsiService> service = android::gsi::GetGsiService();
231 android::sp<IImageService> manager;
232
233 auto status = service->openImageService(dir, &manager);
234 if (!status.isOk() || !manager) {
235 LOG(ERROR) << "Could not acquire IImageManager: " << status.exceptionMessage().string();
236 return nullptr;
237 }
238 return std::make_unique<ImageManagerBinder>(std::move(service), std::move(manager));
239 }
240
241 } // namespace fiemap
242 } // namespace android
243
244 #endif // __ANDROID_RECOVERY__
245