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