1 /*
2 * Copyright (c) 2022 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_mem.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
PurgeableMem(size_t dataSize,std::unique_ptr<PurgeableMemBuilder> builder)45 PurgeableMem::PurgeableMem(size_t dataSize, std::unique_ptr<PurgeableMemBuilder> builder)
46 {
47 dataPtr_ = nullptr;
48 builder_ = nullptr;
49 pageTable_ = nullptr;
50 buildDataCount_ = 0;
51
52 if (dataSize <= 0 || dataSize >= OHOS_MAXIMUM_PURGEABLE_MEMORY) {
53 PM_HILOG_DEBUG(LOG_CORE, "Failed to apply for memory");
54 return;
55 }
56 dataSizeInput_ = dataSize;
57 IF_NULL_LOG_ACTION(builder, "%{public}s: input builder nullptr", return);
58
59 if (!CreatePurgeableData()) {
60 PM_HILOG_DEBUG(LOG_CORE, "Failed to create purgeabledata");
61 return;
62 }
63 builder_ = std::move(builder);
64 PM_HILOG_DEBUG(LOG_CORE, "%{public}s init succ. %{public}s", __func__, ToString().c_str());
65 }
66
~PurgeableMem()67 PurgeableMem::~PurgeableMem()
68 {
69 PM_HILOG_DEBUG(LOG_CORE, "%{public}s %{public}s", __func__, ToString().c_str());
70 if (dataPtr_) {
71 if (munmap(dataPtr_, RoundUp(dataSizeInput_, PAGE_SIZE)) != 0) {
72 PM_HILOG_ERROR(LOG_CORE, "%{public}s: munmap dataPtr fail", __func__);
73 } else {
74 if (UxpteIsEnabled() && !IsPurged()) {
75 PM_HILOG_ERROR(LOG_CORE, "%{public}s: munmap dataPtr succ, but uxpte present", __func__);
76 }
77 dataPtr_ = nullptr;
78 }
79 }
80 builder_.reset();
81 pageTable_.reset();
82 }
83
IsPurged()84 bool PurgeableMem::IsPurged()
85 {
86 IF_NULL_LOG_ACTION(pageTable_, "pageTable_ is nullptrin BeginWrite", return false);
87 return !(pageTable_->CheckPresent((uint64_t)dataPtr_, dataSizeInput_));
88 }
89
CreatePurgeableData()90 bool PurgeableMem::CreatePurgeableData()
91 {
92 PM_HILOG_DEBUG(LOG_CORE, "%{public}s", __func__);
93 pageTable_ = nullptr;
94 size_t size = RoundUp(dataSizeInput_, PAGE_SIZE);
95 unsigned int utype = MAP_ANONYMOUS;
96 utype |= (UxpteIsEnabled() ? MAP_PURGEABLE : MAP_PRIVATE);
97 int type = static_cast<int>(utype);
98
99 dataPtr_ = mmap(nullptr, size, PROT_READ | PROT_WRITE, type, -1, 0);
100 if (dataPtr_ == MAP_FAILED) {
101 PM_HILOG_ERROR(LOG_CORE, "%{public}s: mmap fail", __func__);
102 dataPtr_ = nullptr;
103 return false;
104 }
105 MAKE_UNIQUE(pageTable_, UxPageTable, "constructor uxpt make_unique fail", return false, (uint64_t)dataPtr_, size);
106 return true;
107 }
108
Pin()109 bool PurgeableMem::Pin()
110 {
111 IF_NULL_LOG_ACTION(pageTable_, "pageTable_ is nullptrin BeginWrite", return false);
112 pageTable_->GetUxpte((uint64_t)dataPtr_, dataSizeInput_);
113 return true;
114 }
115
Unpin()116 bool PurgeableMem::Unpin()
117 {
118 IF_NULL_LOG_ACTION(pageTable_, "pageTable_ is nullptrin BeginWrite", return false);
119 pageTable_->PutUxpte((uint64_t)dataPtr_, dataSizeInput_);
120 return true;
121 }
122
AfterRebuildSucc()123 void PurgeableMem::AfterRebuildSucc()
124 {
125 }
126
GetPinStatus() const127 int PurgeableMem::GetPinStatus() const
128 {
129 return 0;
130 }
131
ResizeData(size_t newSize)132 void PurgeableMem::ResizeData(size_t newSize)
133 {
134 if (newSize <= 0 || newSize >= OHOS_MAXIMUM_PURGEABLE_MEMORY) {
135 PM_HILOG_DEBUG(LOG_CORE, "Failed to apply for memory");
136 return;
137 }
138 if (dataPtr_) {
139 if (munmap(dataPtr_, RoundUp(dataSizeInput_, PAGE_SIZE)) != 0) {
140 PM_HILOG_ERROR(LOG_CORE, "%{public}s: munmap dataPtr fail", __func__);
141 } else {
142 dataPtr_ = nullptr;
143 }
144 }
145 dataSizeInput_ = newSize;
146 if (!CreatePurgeableData()) {
147 PM_HILOG_DEBUG(LOG_CORE, "Failed to create purgeabledata");
148 return;
149 }
150 }
151
ToString() const152 inline std::string PurgeableMem::ToString() const
153 {
154 std::string dataptrStr = dataPtr_ ? std::to_string((unsigned long long)dataPtr_) : "0";
155 std::string pageTableStr = pageTable_ ? pageTable_->ToString() : "0";
156 return "dataAddr:" + dataptrStr + " dataSizeInput:" + std::to_string(dataSizeInput_) +
157 " " + pageTableStr;
158 }
159 } /* namespace PurgeableMem */
160 } /* namespace OHOS */
161