1 /*
2  * Copyright (c) 2023 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include <sys/mman.h> /* mmap */
17 
18 #include "securec.h"
19 #include "pm_util.h"
20 #include "pm_state_c.h"
21 #include "pm_smartptr_util.h"
22 #include "pm_log.h"
23 
24 #include "purgeable_ashmem.h"
25 
26 namespace OHOS {
27 namespace PurgeableMem {
28 #ifdef LOG_TAG
29 #undef LOG_TAG
30 #endif
31 #define LOG_TAG "PurgeableMem"
32 
RoundUp(size_t val,size_t align)33 static inline size_t RoundUp(size_t val, size_t align)
34 {
35     if (val + align < val || val + align < align) {
36         PM_HILOG_ERROR(LOG_CORE, "%{public}s: Addition overflow!", __func__);
37         return val;
38     }
39     if (align == 0) {
40         return val;
41     }
42     return ((val + align - 1) / align) * align;
43 }
44 
PurgeableAshMem(std::unique_ptr<PurgeableMemBuilder> builder)45 PurgeableAshMem::PurgeableAshMem(std::unique_ptr<PurgeableMemBuilder> builder)
46 {
47     dataPtr_ = nullptr;
48     builder_ = nullptr;
49     ashmemFd_ = -1;
50     buildDataCount_ = 0;
51     isSupport_ = false;
52     isChange_ = false;
53     IF_NULL_LOG_ACTION(builder, "%{public}s: input builder nullptr", return);
54     builder_ = std::move(builder);
55     PM_HILOG_DEBUG(LOG_CORE, "%{public}s init succ. %{public}s", __func__, ToString().c_str());
56 }
57 
PurgeableAshMem(size_t dataSize,std::unique_ptr<PurgeableMemBuilder> builder)58 PurgeableAshMem::PurgeableAshMem(size_t dataSize, std::unique_ptr<PurgeableMemBuilder> builder)
59 {
60     dataPtr_ = nullptr;
61     builder_ = nullptr;
62     ashmemFd_ = -1;
63     buildDataCount_ = 0;
64     isSupport_ = false;
65     isChange_ = false;
66     if (dataSize == 0) {
67         return;
68     }
69     dataSizeInput_ = dataSize;
70     IF_NULL_LOG_ACTION(builder, "%{public}s: input builder nullptr", return);
71 
72     if (!CreatePurgeableData()) {
73         PM_HILOG_DEBUG(LOG_CORE, "Failed to create purgeabledata");
74         return;
75     }
76     builder_ = std::move(builder);
77     PM_HILOG_DEBUG(LOG_CORE, "%{public}s init succ. %{public}s", __func__, ToString().c_str());
78 }
79 
~PurgeableAshMem()80 PurgeableAshMem::~PurgeableAshMem()
81 {
82     PM_HILOG_DEBUG(LOG_CORE, "%{public}s %{public}s", __func__, ToString().c_str());
83     if (!isChange_ && dataPtr_) {
84         if (munmap(dataPtr_, RoundUp(dataSizeInput_, PAGE_SIZE)) != 0) {
85             PM_HILOG_ERROR(LOG_CORE, "%{public}s: munmap dataPtr fail", __func__);
86         } else {
87             if (UxpteIsEnabled() && !IsPurged()) {
88                 PM_HILOG_ERROR(LOG_CORE, "%{public}s: munmap dataPtr succ, but uxpte present", __func__);
89             }
90             dataPtr_ = nullptr;
91             close(ashmemFd_);
92         }
93     }
94     builder_.reset();
95 }
96 
GetAshmemFd()97 int PurgeableAshMem::GetAshmemFd()
98 {
99     return ashmemFd_;
100 }
101 
IsPurged()102 bool PurgeableAshMem::IsPurged()
103 {
104     if (!isSupport_) {
105         return false;
106     }
107     int ret = ioctl(ashmemFd_, PURGEABLE_ASHMEM_IS_PURGED);
108     PM_HILOG_DEBUG(LOG_CORE, "%{public}s: IsPurged %{public}d", __func__, ret);
109     return ret > 0 ? true : false;
110 }
111 
CreatePurgeableData()112 bool PurgeableAshMem::CreatePurgeableData()
113 {
114     PM_HILOG_DEBUG(LOG_CORE, "%{public}s", __func__);
115     if (dataSizeInput_ == 0) {
116         return false;
117     }
118     size_t size = RoundUp(dataSizeInput_, PAGE_SIZE);
119     int fd = AshmemCreate("PurgeableAshmem", size);
120     if (fd < 0) {
121         return false;
122     }
123     if (AshmemSetProt(fd, PROT_READ | PROT_WRITE) < 0) {
124         close(fd);
125         return false;
126     }
127     ashmemFd_ = fd;
128     pin_ = { static_cast<uint32_t>(0), static_cast<uint32_t>(0) };
129     dataPtr_ = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_SHARED, ashmemFd_, 0);
130     if (dataPtr_ == MAP_FAILED) {
131         PM_HILOG_ERROR(LOG_CORE, "%{public}s: mmap fail", __func__);
132         dataPtr_ = nullptr;
133         close(ashmemFd_);
134         return false;
135     }
136     TEMP_FAILURE_RETRY(ioctl(ashmemFd_, ASHMEM_SET_PURGEABLE));
137     if (TEMP_FAILURE_RETRY(ioctl(ashmemFd_, ASHMEM_GET_PURGEABLE)) == 1) {
138         isSupport_ = true;
139     }
140     Unpin();
141     return true;
142 }
143 
Pin()144 bool PurgeableAshMem::Pin()
145 {
146     if (!isSupport_) {
147         return true;
148     }
149     if (ashmemFd_ > 0) {
150         TEMP_FAILURE_RETRY(ioctl(ashmemFd_, ASHMEM_PIN, &pin_));
151         PM_HILOG_DEBUG(LOG_CORE, "%{public}s: fd:%{public}d PURGEABLE_GET_PIN_STATE: %{public}d",
152                        __func__, ashmemFd_, ioctl(ashmemFd_, ASHMEM_GET_PIN_STATUS, &pin_));
153     } else {
154         PM_HILOG_DEBUG(LOG_CORE, "ashmemFd_ not exist!!");
155         return false;
156     }
157     return true;
158 }
159 
Unpin()160 bool PurgeableAshMem::Unpin()
161 {
162     if (!isSupport_) {
163         return true;
164     }
165     if (ashmemFd_ > 0) {
166         TEMP_FAILURE_RETRY(ioctl(ashmemFd_, ASHMEM_UNPIN, &pin_));
167         PM_HILOG_DEBUG(LOG_CORE, "%{public}s: fd:%{public}d PURGEABLE_GET_PIN_STATE: %{public}d",
168                        __func__, ashmemFd_, ioctl(ashmemFd_, ASHMEM_GET_PIN_STATUS, &pin_));
169     } else {
170         PM_HILOG_DEBUG(LOG_CORE, "ashmemFd_ not exist!!");
171         return false;
172     }
173     return true;
174 }
175 
GetPinStatus() const176 int PurgeableAshMem::GetPinStatus() const
177 {
178     int ret = 0;
179     if (!isSupport_) {
180         return ret;
181     }
182     ret = ioctl(ashmemFd_, ASHMEM_GET_PIN_STATUS, &pin_);
183     PM_HILOG_DEBUG(LOG_CORE, "%{public}s: GetPinStatus %{public}d", __func__, ret);
184     return ret;
185 }
186 
AfterRebuildSucc()187 void PurgeableAshMem::AfterRebuildSucc()
188 {
189     TEMP_FAILURE_RETRY(ioctl(ashmemFd_, PURGEABLE_ASHMEM_REBUILD_SUCCESS));
190 }
191 
ResizeData(size_t newSize)192 void PurgeableAshMem::ResizeData(size_t newSize)
193 {
194     if (newSize <= 0 || newSize >= OHOS_MAXIMUM_PURGEABLE_MEMORY) {
195         PM_HILOG_DEBUG(LOG_CORE, "Failed to apply for memory");
196         return;
197     }
198     if (dataPtr_) {
199         if (munmap(dataPtr_, RoundUp(dataSizeInput_, PAGE_SIZE)) != 0) {
200             PM_HILOG_ERROR(LOG_CORE, "%{public}s: munmap dataPtr fail", __func__);
201         } else {
202             dataPtr_ = nullptr;
203             if (ashmemFd_ > 0) {
204                 close(ashmemFd_);
205             }
206         }
207     }
208     dataSizeInput_ = newSize;
209     if (!CreatePurgeableData()) {
210         PM_HILOG_DEBUG(LOG_CORE, "Failed to create purgeabledata");
211         return;
212     }
213 }
214 
ChangeAshmemData(size_t size,int fd,void * data)215 bool PurgeableAshMem::ChangeAshmemData(size_t size, int fd, void *data)
216 {
217     if (size <= 0 || size >= OHOS_MAXIMUM_PURGEABLE_MEMORY) {
218         PM_HILOG_DEBUG(LOG_CORE, "Failed to apply for memory");
219         return false;
220     }
221     if (dataPtr_) {
222         if (munmap(dataPtr_, RoundUp(dataSizeInput_, PAGE_SIZE)) != 0) {
223             PM_HILOG_ERROR(LOG_CORE, "%{public}s: munmap dataPtr fail", __func__);
224         } else {
225             dataPtr_ = nullptr;
226             if (ashmemFd_ > 0) {
227                 close(ashmemFd_);
228             }
229         }
230     }
231     dataSizeInput_ = size;
232     ashmemFd_ = fd;
233     dataPtr_ = data;
234     buildDataCount_++;
235     isChange_ = true;
236     TEMP_FAILURE_RETRY(ioctl(ashmemFd_, ASHMEM_SET_PURGEABLE));
237     if (TEMP_FAILURE_RETRY(ioctl(ashmemFd_, ASHMEM_GET_PURGEABLE)) == 1) {
238         isSupport_ = true;
239     }
240     Unpin();
241     return true;
242 }
243 
ToString() const244 inline std::string PurgeableAshMem::ToString() const
245 {
246     return "";
247 }
248 } /* namespace PurgeableMem */
249 } /* namespace OHOS */
250