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 #undef LOG_TAG
18 #define LOG_TAG "CursorWindow"
19
20 #include <utils/Log.h>
21 #include <androidfw/CursorWindow.h>
22
23 #include <cutils/ashmem.h>
24 #include <sys/mman.h>
25
26 #include <assert.h>
27 #include <string.h>
28 #include <stdlib.h>
29
30 namespace android {
31
CursorWindow(const String8 & name,int ashmemFd,void * data,size_t size,bool readOnly)32 CursorWindow::CursorWindow(const String8& name, int ashmemFd,
33 void* data, size_t size, bool readOnly) :
34 mName(name), mAshmemFd(ashmemFd), mData(data), mSize(size), mReadOnly(readOnly) {
35 mHeader = static_cast<Header*>(mData);
36 }
37
~CursorWindow()38 CursorWindow::~CursorWindow() {
39 ::munmap(mData, mSize);
40 ::close(mAshmemFd);
41 }
42
create(const String8 & name,size_t size,CursorWindow ** outCursorWindow)43 status_t CursorWindow::create(const String8& name, size_t size, CursorWindow** outCursorWindow) {
44 String8 ashmemName("CursorWindow: ");
45 ashmemName.append(name);
46
47 status_t result;
48 int ashmemFd = ashmem_create_region(ashmemName.string(), size);
49 if (ashmemFd < 0) {
50 result = -errno;
51 } else {
52 result = ashmem_set_prot_region(ashmemFd, PROT_READ | PROT_WRITE);
53 if (result >= 0) {
54 void* data = ::mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, ashmemFd, 0);
55 if (data == MAP_FAILED) {
56 result = -errno;
57 } else {
58 result = ashmem_set_prot_region(ashmemFd, PROT_READ);
59 if (result >= 0) {
60 CursorWindow* window = new CursorWindow(name, ashmemFd,
61 data, size, false /*readOnly*/);
62 result = window->clear();
63 if (!result) {
64 LOG_WINDOW("Created new CursorWindow: freeOffset=%d, "
65 "numRows=%d, numColumns=%d, mSize=%d, mData=%p",
66 window->mHeader->freeOffset,
67 window->mHeader->numRows,
68 window->mHeader->numColumns,
69 window->mSize, window->mData);
70 *outCursorWindow = window;
71 return OK;
72 }
73 delete window;
74 }
75 }
76 ::munmap(data, size);
77 }
78 ::close(ashmemFd);
79 }
80 *outCursorWindow = NULL;
81 return result;
82 }
83
createFromParcel(Parcel * parcel,CursorWindow ** outCursorWindow)84 status_t CursorWindow::createFromParcel(Parcel* parcel, CursorWindow** outCursorWindow) {
85 String8 name = parcel->readString8();
86
87 status_t result;
88 int ashmemFd = parcel->readFileDescriptor();
89 if (ashmemFd == int(BAD_TYPE)) {
90 result = BAD_TYPE;
91 } else {
92 ssize_t size = ashmem_get_size_region(ashmemFd);
93 if (size < 0) {
94 result = UNKNOWN_ERROR;
95 } else {
96 int dupAshmemFd = ::dup(ashmemFd);
97 if (dupAshmemFd < 0) {
98 result = -errno;
99 } else {
100 void* data = ::mmap(NULL, size, PROT_READ, MAP_SHARED, dupAshmemFd, 0);
101 if (data == MAP_FAILED) {
102 result = -errno;
103 } else {
104 CursorWindow* window = new CursorWindow(name, dupAshmemFd,
105 data, size, true /*readOnly*/);
106 LOG_WINDOW("Created CursorWindow from parcel: freeOffset=%d, "
107 "numRows=%d, numColumns=%d, mSize=%d, mData=%p",
108 window->mHeader->freeOffset,
109 window->mHeader->numRows,
110 window->mHeader->numColumns,
111 window->mSize, window->mData);
112 *outCursorWindow = window;
113 return OK;
114 }
115 ::close(dupAshmemFd);
116 }
117 }
118 }
119 *outCursorWindow = NULL;
120 return result;
121 }
122
writeToParcel(Parcel * parcel)123 status_t CursorWindow::writeToParcel(Parcel* parcel) {
124 status_t status = parcel->writeString8(mName);
125 if (!status) {
126 status = parcel->writeDupFileDescriptor(mAshmemFd);
127 }
128 return status;
129 }
130
clear()131 status_t CursorWindow::clear() {
132 if (mReadOnly) {
133 return INVALID_OPERATION;
134 }
135
136 mHeader->freeOffset = sizeof(Header) + sizeof(RowSlotChunk);
137 mHeader->firstChunkOffset = sizeof(Header);
138 mHeader->numRows = 0;
139 mHeader->numColumns = 0;
140
141 RowSlotChunk* firstChunk = static_cast<RowSlotChunk*>(offsetToPtr(mHeader->firstChunkOffset));
142 firstChunk->nextChunkOffset = 0;
143 return OK;
144 }
145
setNumColumns(uint32_t numColumns)146 status_t CursorWindow::setNumColumns(uint32_t numColumns) {
147 if (mReadOnly) {
148 return INVALID_OPERATION;
149 }
150
151 uint32_t cur = mHeader->numColumns;
152 if ((cur > 0 || mHeader->numRows > 0) && cur != numColumns) {
153 ALOGE("Trying to go from %d columns to %d", cur, numColumns);
154 return INVALID_OPERATION;
155 }
156 mHeader->numColumns = numColumns;
157 return OK;
158 }
159
allocRow()160 status_t CursorWindow::allocRow() {
161 if (mReadOnly) {
162 return INVALID_OPERATION;
163 }
164
165 // Fill in the row slot
166 RowSlot* rowSlot = allocRowSlot();
167 if (rowSlot == NULL) {
168 return NO_MEMORY;
169 }
170
171 // Allocate the slots for the field directory
172 size_t fieldDirSize = mHeader->numColumns * sizeof(FieldSlot);
173 uint32_t fieldDirOffset = alloc(fieldDirSize, true /*aligned*/);
174 if (!fieldDirOffset) {
175 mHeader->numRows--;
176 LOG_WINDOW("The row failed, so back out the new row accounting "
177 "from allocRowSlot %d", mHeader->numRows);
178 return NO_MEMORY;
179 }
180 FieldSlot* fieldDir = static_cast<FieldSlot*>(offsetToPtr(fieldDirOffset));
181 memset(fieldDir, 0, fieldDirSize);
182
183 LOG_WINDOW("Allocated row %u, rowSlot is at offset %u, fieldDir is %d bytes at offset %u\n",
184 mHeader->numRows - 1, offsetFromPtr(rowSlot), fieldDirSize, fieldDirOffset);
185 rowSlot->offset = fieldDirOffset;
186 return OK;
187 }
188
freeLastRow()189 status_t CursorWindow::freeLastRow() {
190 if (mReadOnly) {
191 return INVALID_OPERATION;
192 }
193
194 if (mHeader->numRows > 0) {
195 mHeader->numRows--;
196 }
197 return OK;
198 }
199
alloc(size_t size,bool aligned)200 uint32_t CursorWindow::alloc(size_t size, bool aligned) {
201 uint32_t padding;
202 if (aligned) {
203 // 4 byte alignment
204 padding = (~mHeader->freeOffset + 1) & 3;
205 } else {
206 padding = 0;
207 }
208
209 uint32_t offset = mHeader->freeOffset + padding;
210 uint32_t nextFreeOffset = offset + size;
211 if (nextFreeOffset > mSize) {
212 ALOGW("Window is full: requested allocation %d bytes, "
213 "free space %d bytes, window size %d bytes",
214 size, freeSpace(), mSize);
215 return 0;
216 }
217
218 mHeader->freeOffset = nextFreeOffset;
219 return offset;
220 }
221
getRowSlot(uint32_t row)222 CursorWindow::RowSlot* CursorWindow::getRowSlot(uint32_t row) {
223 uint32_t chunkPos = row;
224 RowSlotChunk* chunk = static_cast<RowSlotChunk*>(
225 offsetToPtr(mHeader->firstChunkOffset));
226 while (chunkPos >= ROW_SLOT_CHUNK_NUM_ROWS) {
227 chunk = static_cast<RowSlotChunk*>(offsetToPtr(chunk->nextChunkOffset));
228 chunkPos -= ROW_SLOT_CHUNK_NUM_ROWS;
229 }
230 return &chunk->slots[chunkPos];
231 }
232
allocRowSlot()233 CursorWindow::RowSlot* CursorWindow::allocRowSlot() {
234 uint32_t chunkPos = mHeader->numRows;
235 RowSlotChunk* chunk = static_cast<RowSlotChunk*>(
236 offsetToPtr(mHeader->firstChunkOffset));
237 while (chunkPos > ROW_SLOT_CHUNK_NUM_ROWS) {
238 chunk = static_cast<RowSlotChunk*>(offsetToPtr(chunk->nextChunkOffset));
239 chunkPos -= ROW_SLOT_CHUNK_NUM_ROWS;
240 }
241 if (chunkPos == ROW_SLOT_CHUNK_NUM_ROWS) {
242 if (!chunk->nextChunkOffset) {
243 chunk->nextChunkOffset = alloc(sizeof(RowSlotChunk), true /*aligned*/);
244 if (!chunk->nextChunkOffset) {
245 return NULL;
246 }
247 }
248 chunk = static_cast<RowSlotChunk*>(offsetToPtr(chunk->nextChunkOffset));
249 chunk->nextChunkOffset = 0;
250 chunkPos = 0;
251 }
252 mHeader->numRows += 1;
253 return &chunk->slots[chunkPos];
254 }
255
getFieldSlot(uint32_t row,uint32_t column)256 CursorWindow::FieldSlot* CursorWindow::getFieldSlot(uint32_t row, uint32_t column) {
257 if (row >= mHeader->numRows || column >= mHeader->numColumns) {
258 ALOGE("Failed to read row %d, column %d from a CursorWindow which "
259 "has %d rows, %d columns.",
260 row, column, mHeader->numRows, mHeader->numColumns);
261 return NULL;
262 }
263 RowSlot* rowSlot = getRowSlot(row);
264 if (!rowSlot) {
265 ALOGE("Failed to find rowSlot for row %d.", row);
266 return NULL;
267 }
268 FieldSlot* fieldDir = static_cast<FieldSlot*>(offsetToPtr(rowSlot->offset));
269 return &fieldDir[column];
270 }
271
putBlob(uint32_t row,uint32_t column,const void * value,size_t size)272 status_t CursorWindow::putBlob(uint32_t row, uint32_t column, const void* value, size_t size) {
273 return putBlobOrString(row, column, value, size, FIELD_TYPE_BLOB);
274 }
275
putString(uint32_t row,uint32_t column,const char * value,size_t sizeIncludingNull)276 status_t CursorWindow::putString(uint32_t row, uint32_t column, const char* value,
277 size_t sizeIncludingNull) {
278 return putBlobOrString(row, column, value, sizeIncludingNull, FIELD_TYPE_STRING);
279 }
280
putBlobOrString(uint32_t row,uint32_t column,const void * value,size_t size,int32_t type)281 status_t CursorWindow::putBlobOrString(uint32_t row, uint32_t column,
282 const void* value, size_t size, int32_t type) {
283 if (mReadOnly) {
284 return INVALID_OPERATION;
285 }
286
287 FieldSlot* fieldSlot = getFieldSlot(row, column);
288 if (!fieldSlot) {
289 return BAD_VALUE;
290 }
291
292 uint32_t offset = alloc(size);
293 if (!offset) {
294 return NO_MEMORY;
295 }
296
297 memcpy(offsetToPtr(offset), value, size);
298
299 fieldSlot->type = type;
300 fieldSlot->data.buffer.offset = offset;
301 fieldSlot->data.buffer.size = size;
302 return OK;
303 }
304
putLong(uint32_t row,uint32_t column,int64_t value)305 status_t CursorWindow::putLong(uint32_t row, uint32_t column, int64_t value) {
306 if (mReadOnly) {
307 return INVALID_OPERATION;
308 }
309
310 FieldSlot* fieldSlot = getFieldSlot(row, column);
311 if (!fieldSlot) {
312 return BAD_VALUE;
313 }
314
315 fieldSlot->type = FIELD_TYPE_INTEGER;
316 fieldSlot->data.l = value;
317 return OK;
318 }
319
putDouble(uint32_t row,uint32_t column,double value)320 status_t CursorWindow::putDouble(uint32_t row, uint32_t column, double value) {
321 if (mReadOnly) {
322 return INVALID_OPERATION;
323 }
324
325 FieldSlot* fieldSlot = getFieldSlot(row, column);
326 if (!fieldSlot) {
327 return BAD_VALUE;
328 }
329
330 fieldSlot->type = FIELD_TYPE_FLOAT;
331 fieldSlot->data.d = value;
332 return OK;
333 }
334
putNull(uint32_t row,uint32_t column)335 status_t CursorWindow::putNull(uint32_t row, uint32_t column) {
336 if (mReadOnly) {
337 return INVALID_OPERATION;
338 }
339
340 FieldSlot* fieldSlot = getFieldSlot(row, column);
341 if (!fieldSlot) {
342 return BAD_VALUE;
343 }
344
345 fieldSlot->type = FIELD_TYPE_NULL;
346 fieldSlot->data.buffer.offset = 0;
347 fieldSlot->data.buffer.size = 0;
348 return OK;
349 }
350
351 }; // namespace android
352