1 /*
2 * Copyright (C) 2006-2007 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 #define LOG_TAG "CursorWindow"
18
19 #include <androidfw/CursorWindow.h>
20
21 #include <sys/mman.h>
22
23 #include "android-base/logging.h"
24 #include "cutils/ashmem.h"
25
26 namespace android {
27
28 /**
29 * By default windows are lightweight inline allocations of this size;
30 * they're only inflated to ashmem regions when more space is needed.
31 */
32 static constexpr const size_t kInlineSize = 16384;
33
34 static constexpr const size_t kSlotShift = 4;
35 static constexpr const size_t kSlotSizeBytes = 1 << kSlotShift;
36
CursorWindow()37 CursorWindow::CursorWindow() {
38 }
39
~CursorWindow()40 CursorWindow::~CursorWindow() {
41 if (mAshmemFd != -1) {
42 ::munmap(mData, mSize);
43 ::close(mAshmemFd);
44 } else {
45 free(mData);
46 }
47 }
48
create(const String8 & name,size_t inflatedSize,CursorWindow ** outWindow)49 status_t CursorWindow::create(const String8 &name, size_t inflatedSize, CursorWindow **outWindow) {
50 *outWindow = nullptr;
51
52 CursorWindow* window = new CursorWindow();
53 if (!window) goto fail;
54
55 window->mName = name;
56 window->mSize = std::min(kInlineSize, inflatedSize);
57 window->mInflatedSize = inflatedSize;
58 window->mData = malloc(window->mSize);
59 if (!window->mData) goto fail;
60 window->mReadOnly = false;
61
62 window->clear();
63 window->updateSlotsData();
64
65 *outWindow = window;
66 return OK;
67
68 fail:
69 LOG(ERROR) << "Failed create";
70 fail_silent:
71 delete window;
72 return UNKNOWN_ERROR;
73 }
74
maybeInflate()75 status_t CursorWindow::maybeInflate() {
76 int ashmemFd = 0;
77 void* newData = nullptr;
78
79 // Bail early when we can't expand any further
80 if (mReadOnly || mSize == mInflatedSize) {
81 return INVALID_OPERATION;
82 }
83
84 String8 ashmemName("CursorWindow: ");
85 ashmemName.append(mName);
86
87 ashmemFd = ashmem_create_region(ashmemName.string(), mInflatedSize);
88 if (ashmemFd < 0) {
89 PLOG(ERROR) << "Failed ashmem_create_region";
90 goto fail_silent;
91 }
92
93 if (ashmem_set_prot_region(ashmemFd, PROT_READ | PROT_WRITE) < 0) {
94 PLOG(ERROR) << "Failed ashmem_set_prot_region";
95 goto fail_silent;
96 }
97
98 newData = ::mmap(nullptr, mInflatedSize, PROT_READ | PROT_WRITE, MAP_SHARED, ashmemFd, 0);
99 if (newData == MAP_FAILED) {
100 PLOG(ERROR) << "Failed mmap";
101 goto fail_silent;
102 }
103
104 if (ashmem_set_prot_region(ashmemFd, PROT_READ) < 0) {
105 PLOG(ERROR) << "Failed ashmem_set_prot_region";
106 goto fail_silent;
107 }
108
109 {
110 // Migrate existing contents into new ashmem region
111 uint32_t slotsSize = mSize - mSlotsOffset;
112 uint32_t newSlotsOffset = mInflatedSize - slotsSize;
113 memcpy(static_cast<uint8_t*>(newData),
114 static_cast<uint8_t*>(mData), mAllocOffset);
115 memcpy(static_cast<uint8_t*>(newData) + newSlotsOffset,
116 static_cast<uint8_t*>(mData) + mSlotsOffset, slotsSize);
117
118 free(mData);
119 mAshmemFd = ashmemFd;
120 mData = newData;
121 mSize = mInflatedSize;
122 mSlotsOffset = newSlotsOffset;
123
124 updateSlotsData();
125 }
126
127 LOG(DEBUG) << "Inflated: " << this->toString();
128 return OK;
129
130 fail:
131 LOG(ERROR) << "Failed maybeInflate";
132 fail_silent:
133 ::munmap(newData, mInflatedSize);
134 ::close(ashmemFd);
135 return UNKNOWN_ERROR;
136 }
137
createFromParcel(Parcel * parcel,CursorWindow ** outWindow)138 status_t CursorWindow::createFromParcel(Parcel* parcel, CursorWindow** outWindow) {
139 *outWindow = nullptr;
140
141 CursorWindow* window = new CursorWindow();
142 if (!window) goto fail;
143
144 if (parcel->readString8(&window->mName)) goto fail;
145 if (parcel->readUint32(&window->mNumRows)) goto fail;
146 if (parcel->readUint32(&window->mNumColumns)) goto fail;
147 if (parcel->readUint32(&window->mSize)) goto fail;
148
149 if ((window->mNumRows * window->mNumColumns * kSlotSizeBytes) > window->mSize) {
150 LOG(ERROR) << "Unexpected size " << window->mSize << " for " << window->mNumRows
151 << " rows and " << window->mNumColumns << " columns";
152 goto fail_silent;
153 }
154
155 bool isAshmem;
156 if (parcel->readBool(&isAshmem)) goto fail;
157 if (isAshmem) {
158 window->mAshmemFd = parcel->readFileDescriptor();
159 if (window->mAshmemFd < 0) {
160 LOG(ERROR) << "Failed readFileDescriptor";
161 goto fail_silent;
162 }
163
164 window->mAshmemFd = ::fcntl(window->mAshmemFd, F_DUPFD_CLOEXEC, 0);
165 if (window->mAshmemFd < 0) {
166 PLOG(ERROR) << "Failed F_DUPFD_CLOEXEC";
167 goto fail_silent;
168 }
169
170 window->mData = ::mmap(nullptr, window->mSize, PROT_READ, MAP_SHARED, window->mAshmemFd, 0);
171 if (window->mData == MAP_FAILED) {
172 PLOG(ERROR) << "Failed mmap";
173 goto fail_silent;
174 }
175 } else {
176 window->mAshmemFd = -1;
177
178 if (window->mSize > kInlineSize) {
179 LOG(ERROR) << "Unexpected size " << window->mSize << " for inline window";
180 goto fail_silent;
181 }
182
183 window->mData = malloc(window->mSize);
184 if (!window->mData) goto fail;
185
186 if (parcel->read(window->mData, window->mSize)) goto fail;
187 }
188
189 // We just came from a remote source, so we're read-only
190 // and we can't inflate ourselves
191 window->mInflatedSize = window->mSize;
192 window->mReadOnly = true;
193
194 window->updateSlotsData();
195
196 LOG(DEBUG) << "Created from parcel: " << window->toString();
197 *outWindow = window;
198 return OK;
199
200 fail:
201 LOG(ERROR) << "Failed createFromParcel";
202 fail_silent:
203 delete window;
204 return UNKNOWN_ERROR;
205 }
206
writeToParcel(Parcel * parcel)207 status_t CursorWindow::writeToParcel(Parcel* parcel) {
208 LOG(DEBUG) << "Writing to parcel: " << this->toString();
209
210 if (parcel->writeString8(mName)) goto fail;
211 if (parcel->writeUint32(mNumRows)) goto fail;
212 if (parcel->writeUint32(mNumColumns)) goto fail;
213 if (mAshmemFd != -1) {
214 if (parcel->writeUint32(mSize)) goto fail;
215 if (parcel->writeBool(true)) goto fail;
216 if (parcel->writeDupFileDescriptor(mAshmemFd)) goto fail;
217 } else {
218 // Since we know we're going to be read-only on the remote side,
219 // we can compact ourselves on the wire, with just enough padding
220 // to ensure our slots stay aligned
221 size_t slotsSize = mSize - mSlotsOffset;
222 size_t compactedSize = mAllocOffset + slotsSize;
223 compactedSize = (compactedSize + 3) & ~3;
224 if (parcel->writeUint32(compactedSize)) goto fail;
225 if (parcel->writeBool(false)) goto fail;
226 void* dest = parcel->writeInplace(compactedSize);
227 if (!dest) goto fail;
228 memcpy(static_cast<uint8_t*>(dest),
229 static_cast<uint8_t*>(mData), mAllocOffset);
230 memcpy(static_cast<uint8_t*>(dest) + compactedSize - slotsSize,
231 static_cast<uint8_t*>(mData) + mSlotsOffset, slotsSize);
232 }
233 return OK;
234
235 fail:
236 LOG(ERROR) << "Failed writeToParcel";
237 fail_silent:
238 return UNKNOWN_ERROR;
239 }
240
clear()241 status_t CursorWindow::clear() {
242 if (mReadOnly) {
243 return INVALID_OPERATION;
244 }
245 mAllocOffset = 0;
246 mSlotsOffset = mSize;
247 mNumRows = 0;
248 mNumColumns = 0;
249 return OK;
250 }
251
updateSlotsData()252 void CursorWindow::updateSlotsData() {
253 mSlotsStart = static_cast<uint8_t*>(mData) + mSize - kSlotSizeBytes;
254 mSlotsEnd = static_cast<uint8_t*>(mData) + mSlotsOffset;
255 }
256
offsetToPtr(uint32_t offset,uint32_t bufferSize=0)257 void* CursorWindow::offsetToPtr(uint32_t offset, uint32_t bufferSize = 0) {
258 if (offset > mSize) {
259 LOG(ERROR) << "Offset " << offset
260 << " out of bounds, max value " << mSize;
261 return nullptr;
262 }
263 if (offset + bufferSize > mSize) {
264 LOG(ERROR) << "End offset " << (offset + bufferSize)
265 << " out of bounds, max value " << mSize;
266 return nullptr;
267 }
268 return static_cast<uint8_t*>(mData) + offset;
269 }
270
offsetFromPtr(void * ptr)271 uint32_t CursorWindow::offsetFromPtr(void* ptr) {
272 return static_cast<uint8_t*>(ptr) - static_cast<uint8_t*>(mData);
273 }
274
setNumColumns(uint32_t numColumns)275 status_t CursorWindow::setNumColumns(uint32_t numColumns) {
276 if (mReadOnly) {
277 return INVALID_OPERATION;
278 }
279 uint32_t cur = mNumColumns;
280 if ((cur > 0 || mNumRows > 0) && cur != numColumns) {
281 LOG(ERROR) << "Trying to go from " << cur << " columns to " << numColumns;
282 return INVALID_OPERATION;
283 }
284 mNumColumns = numColumns;
285 return OK;
286 }
287
allocRow()288 status_t CursorWindow::allocRow() {
289 if (mReadOnly) {
290 return INVALID_OPERATION;
291 }
292 size_t size = mNumColumns * kSlotSizeBytes;
293 int32_t newOffset = mSlotsOffset - size;
294 if (newOffset < (int32_t) mAllocOffset) {
295 maybeInflate();
296 newOffset = mSlotsOffset - size;
297 if (newOffset < (int32_t) mAllocOffset) {
298 return NO_MEMORY;
299 }
300 }
301 memset(offsetToPtr(newOffset), 0, size);
302 mSlotsOffset = newOffset;
303 updateSlotsData();
304 mNumRows++;
305 return OK;
306 }
307
freeLastRow()308 status_t CursorWindow::freeLastRow() {
309 if (mReadOnly) {
310 return INVALID_OPERATION;
311 }
312 size_t size = mNumColumns * kSlotSizeBytes;
313 size_t newOffset = mSlotsOffset + size;
314 if (newOffset > mSize) {
315 return NO_MEMORY;
316 }
317 mSlotsOffset = newOffset;
318 updateSlotsData();
319 mNumRows--;
320 return OK;
321 }
322
alloc(size_t size,uint32_t * outOffset)323 status_t CursorWindow::alloc(size_t size, uint32_t* outOffset) {
324 if (mReadOnly) {
325 return INVALID_OPERATION;
326 }
327 size_t alignedSize = (size + 3) & ~3;
328 size_t newOffset = mAllocOffset + alignedSize;
329 if (newOffset > mSlotsOffset) {
330 maybeInflate();
331 newOffset = mAllocOffset + alignedSize;
332 if (newOffset > mSlotsOffset) {
333 return NO_MEMORY;
334 }
335 }
336 *outOffset = mAllocOffset;
337 mAllocOffset = newOffset;
338 return OK;
339 }
340
getFieldSlot(uint32_t row,uint32_t column)341 CursorWindow::FieldSlot* CursorWindow::getFieldSlot(uint32_t row, uint32_t column) {
342 // This is carefully tuned to use as few cycles as
343 // possible, since this is an extremely hot code path;
344 // see CursorWindow_bench.cpp for more details
345 void *result = static_cast<uint8_t*>(mSlotsStart)
346 - (((row * mNumColumns) + column) << kSlotShift);
347 if (result < mSlotsEnd || result > mSlotsStart || column >= mNumColumns) {
348 LOG(ERROR) << "Failed to read row " << row << ", column " << column
349 << " from a window with " << mNumRows << " rows, " << mNumColumns << " columns";
350 return nullptr;
351 } else {
352 return static_cast<FieldSlot*>(result);
353 }
354 }
355
putBlob(uint32_t row,uint32_t column,const void * value,size_t size)356 status_t CursorWindow::putBlob(uint32_t row, uint32_t column, const void* value, size_t size) {
357 return putBlobOrString(row, column, value, size, FIELD_TYPE_BLOB);
358 }
359
putString(uint32_t row,uint32_t column,const char * value,size_t sizeIncludingNull)360 status_t CursorWindow::putString(uint32_t row, uint32_t column, const char* value,
361 size_t sizeIncludingNull) {
362 return putBlobOrString(row, column, value, sizeIncludingNull, FIELD_TYPE_STRING);
363 }
364
putBlobOrString(uint32_t row,uint32_t column,const void * value,size_t size,int32_t type)365 status_t CursorWindow::putBlobOrString(uint32_t row, uint32_t column,
366 const void* value, size_t size, int32_t type) {
367 if (mReadOnly) {
368 return INVALID_OPERATION;
369 }
370
371 FieldSlot* fieldSlot = getFieldSlot(row, column);
372 if (!fieldSlot) {
373 return BAD_VALUE;
374 }
375
376 uint32_t offset;
377 if (alloc(size, &offset)) {
378 return NO_MEMORY;
379 }
380
381 memcpy(offsetToPtr(offset), value, size);
382
383 fieldSlot = getFieldSlot(row, column);
384 fieldSlot->type = type;
385 fieldSlot->data.buffer.offset = offset;
386 fieldSlot->data.buffer.size = size;
387 return OK;
388 }
389
putLong(uint32_t row,uint32_t column,int64_t value)390 status_t CursorWindow::putLong(uint32_t row, uint32_t column, int64_t value) {
391 if (mReadOnly) {
392 return INVALID_OPERATION;
393 }
394
395 FieldSlot* fieldSlot = getFieldSlot(row, column);
396 if (!fieldSlot) {
397 return BAD_VALUE;
398 }
399
400 fieldSlot->type = FIELD_TYPE_INTEGER;
401 fieldSlot->data.l = value;
402 return OK;
403 }
404
putDouble(uint32_t row,uint32_t column,double value)405 status_t CursorWindow::putDouble(uint32_t row, uint32_t column, double value) {
406 if (mReadOnly) {
407 return INVALID_OPERATION;
408 }
409
410 FieldSlot* fieldSlot = getFieldSlot(row, column);
411 if (!fieldSlot) {
412 return BAD_VALUE;
413 }
414
415 fieldSlot->type = FIELD_TYPE_FLOAT;
416 fieldSlot->data.d = value;
417 return OK;
418 }
419
putNull(uint32_t row,uint32_t column)420 status_t CursorWindow::putNull(uint32_t row, uint32_t column) {
421 if (mReadOnly) {
422 return INVALID_OPERATION;
423 }
424
425 FieldSlot* fieldSlot = getFieldSlot(row, column);
426 if (!fieldSlot) {
427 return BAD_VALUE;
428 }
429
430 fieldSlot->type = FIELD_TYPE_NULL;
431 fieldSlot->data.buffer.offset = 0;
432 fieldSlot->data.buffer.size = 0;
433 return OK;
434 }
435
436 }; // namespace android
437