1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
|
/*
* Copyright (C) 2019 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <map>
#include <memory>
#include <mutex>
#include <sstream>
#include <string>
#include <vector>
#include <android-base/unique_fd.h>
#include <android/gsi/BnGsiService.h>
#include <android/gsi/BnGsid.h>
#include <binder/BinderService.h>
#include <libfiemap/split_fiemap_writer.h>
#include <liblp/builder.h>
#include "libgsi/libgsi.h"
#include "partition_installer.h"
namespace android {
namespace gsi {
class Gsid : public BinderService<Gsid>, public BnGsid {
public:
static void Register();
static char const* getServiceName() { return kGsiServiceName; }
binder::Status getClient(android::sp<IGsiService>* _aidl_return) override;
private:
friend class GsiService;
friend class ImageService;
std::mutex& lock() { return lock_; }
std::mutex lock_;
};
class GsiService : public BinderService<GsiService>, public BnGsiService {
public:
~GsiService() override;
static android::sp<IGsiService> Get(Gsid* parent);
binder::Status openInstall(const std::string& install_dir, int* _aidl_return) override;
binder::Status closeInstall(int32_t* _aidl_return) override;
binder::Status createPartition(const ::std::string& name, int64_t size, bool readOnly,
int32_t* _aidl_return) override;
binder::Status commitGsiChunkFromStream(const ::android::os::ParcelFileDescriptor& stream,
int64_t bytes, bool* _aidl_return) override;
binder::Status getInstallProgress(::android::gsi::GsiProgress* _aidl_return) override;
binder::Status setGsiAshmem(const ::android::os::ParcelFileDescriptor& ashmem, int64_t size,
bool* _aidl_return) override;
binder::Status commitGsiChunkFromAshmem(int64_t bytes, bool* _aidl_return) override;
binder::Status cancelGsiInstall(bool* _aidl_return) override;
binder::Status enableGsi(bool oneShot, const std::string& dsuSlot, int* _aidl_return) override;
binder::Status isGsiEnabled(bool* _aidl_return) override;
binder::Status removeGsi(bool* _aidl_return) override;
binder::Status disableGsi(bool* _aidl_return) override;
binder::Status isGsiInstalled(bool* _aidl_return) override;
binder::Status isGsiRunning(bool* _aidl_return) override;
binder::Status isGsiInstallInProgress(bool* _aidl_return) override;
binder::Status getInstalledGsiImageDir(std::string* _aidl_return) override;
binder::Status getActiveDsuSlot(std::string* _aidl_return) override;
binder::Status getInstalledDsuSlots(std::vector<std::string>* _aidl_return) override;
binder::Status zeroPartition(const std::string& name, int* _aidl_return) override;
binder::Status openImageService(const std::string& prefix,
android::sp<IImageService>* _aidl_return) override;
binder::Status dumpDeviceMapperDevices(std::string* _aidl_return) override;
binder::Status getAvbPublicKey(AvbPublicKey* dst, int32_t* _aidl_return) override;
// This is in GsiService, rather than GsiInstaller, since we need to access
// it outside of the main lock which protects the unique_ptr.
void StartAsyncOperation(const std::string& step, int64_t total_bytes);
void UpdateProgress(int status, int64_t bytes_processed);
// Helper methods for GsiInstaller.
static bool RemoveGsiFiles(const std::string& install_dir);
bool should_abort() const { return should_abort_; }
Gsid* parent() const { return parent_.get(); }
static void RunStartupTasks();
static std::string GetInstalledImageDir();
std::string GetActiveDsuSlot();
std::string GetActiveInstalledImageDir();
static std::vector<std::string> GetInstalledDsuSlots();
private:
GsiService(Gsid* parent);
static int ValidateInstallParams(std::string& install_dir);
bool DisableGsiInstall();
int ReenableGsi(bool one_shot);
static void CleanCorruptedInstallation();
static int SaveInstallation(const std::string&);
static bool IsInstallationComplete(const std::string&);
static std::string GetCompleteIndication(const std::string&);
enum class AccessLevel { System, SystemOrShell };
binder::Status CheckUid(AccessLevel level = AccessLevel::System);
bool CreateInstallStatusFile();
bool SetBootMode(bool one_shot);
static android::wp<GsiService> sInstance;
std::string install_dir_ = {};
android::sp<Gsid> parent_;
std::unique_ptr<PartitionInstaller> installer_;
// These are initialized or set in StartInstall().
std::atomic<bool> should_abort_ = false;
// Progress bar state.
std::mutex progress_lock_;
GsiProgress progress_;
};
} // namespace gsi
} // namespace android
|
