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                 // the size of the ashmem descriptor can be modified between ashmem_get_size_region
102                 // call and mmap, so we'll check again immediately after memory is mapped
103                 void* data = ::mmap(NULL, size, PROT_READ, MAP_SHARED, dupAshmemFd, 0);
104                 if (data == MAP_FAILED) {
105                     result = -errno;
106                 } else if (ashmem_get_size_region(dupAshmemFd) != size) {
107                     ::munmap(data, size);
108                     result = BAD_VALUE;
109                 } else {
110                     CursorWindow* window = new CursorWindow(name, dupAshmemFd,
111                             data, size, true /*readOnly*/);
112                     LOG_WINDOW("Created CursorWindow from parcel: freeOffset=%d, "
113                             "numRows=%d, numColumns=%d, mSize=%d, mData=%p",
114                             window->mHeader->freeOffset,
115                             window->mHeader->numRows,
116                             window->mHeader->numColumns,
117                             window->mSize, window->mData);
118                     *outCursorWindow = window;
119                     return OK;
120                 }
121                 ::close(dupAshmemFd);
122             }
123         }
124     }
125     *outCursorWindow = NULL;
126     return result;
127 }
128 
writeToParcel(Parcel * parcel)129 status_t CursorWindow::writeToParcel(Parcel* parcel) {
130     status_t status = parcel->writeString8(mName);
131     if (!status) {
132         status = parcel->writeDupFileDescriptor(mAshmemFd);
133     }
134     return status;
135 }
136 
clear()137 status_t CursorWindow::clear() {
138     if (mReadOnly) {
139         return INVALID_OPERATION;
140     }
141 
142     mHeader->freeOffset = sizeof(Header) + sizeof(RowSlotChunk);
143     mHeader->firstChunkOffset = sizeof(Header);
144     mHeader->numRows = 0;
145     mHeader->numColumns = 0;
146 
147     RowSlotChunk* firstChunk = static_cast<RowSlotChunk*>(offsetToPtr(mHeader->firstChunkOffset));
148     firstChunk->nextChunkOffset = 0;
149     return OK;
150 }
151 
setNumColumns(uint32_t numColumns)152 status_t CursorWindow::setNumColumns(uint32_t numColumns) {
153     if (mReadOnly) {
154         return INVALID_OPERATION;
155     }
156 
157     uint32_t cur = mHeader->numColumns;
158     if ((cur > 0 || mHeader->numRows > 0) && cur != numColumns) {
159         ALOGE("Trying to go from %d columns to %d", cur, numColumns);
160         return INVALID_OPERATION;
161     }
162     mHeader->numColumns = numColumns;
163     return OK;
164 }
165 
allocRow()166 status_t CursorWindow::allocRow() {
167     if (mReadOnly) {
168         return INVALID_OPERATION;
169     }
170 
171     // Fill in the row slot
172     RowSlot* rowSlot = allocRowSlot();
173     if (rowSlot == NULL) {
174         return NO_MEMORY;
175     }
176 
177     // Allocate the slots for the field directory
178     size_t fieldDirSize = mHeader->numColumns * sizeof(FieldSlot);
179     uint32_t fieldDirOffset = alloc(fieldDirSize, true /*aligned*/);
180     if (!fieldDirOffset) {
181         mHeader->numRows--;
182         LOG_WINDOW("The row failed, so back out the new row accounting "
183                 "from allocRowSlot %d", mHeader->numRows);
184         return NO_MEMORY;
185     }
186     FieldSlot* fieldDir = static_cast<FieldSlot*>(offsetToPtr(fieldDirOffset));
187     memset(fieldDir, 0, fieldDirSize);
188 
189     LOG_WINDOW("Allocated row %u, rowSlot is at offset %u, fieldDir is %d bytes at offset %u\n",
190             mHeader->numRows - 1, offsetFromPtr(rowSlot), fieldDirSize, fieldDirOffset);
191     rowSlot->offset = fieldDirOffset;
192     return OK;
193 }
194 
freeLastRow()195 status_t CursorWindow::freeLastRow() {
196     if (mReadOnly) {
197         return INVALID_OPERATION;
198     }
199 
200     if (mHeader->numRows > 0) {
201         mHeader->numRows--;
202     }
203     return OK;
204 }
205 
alloc(size_t size,bool aligned)206 uint32_t CursorWindow::alloc(size_t size, bool aligned) {
207     uint32_t padding;
208     if (aligned) {
209         // 4 byte alignment
210         padding = (~mHeader->freeOffset + 1) & 3;
211     } else {
212         padding = 0;
213     }
214 
215     uint32_t offset = mHeader->freeOffset + padding;
216     uint32_t nextFreeOffset = offset + size;
217     if (nextFreeOffset > mSize) {
218         ALOGW("Window is full: requested allocation %zu bytes, "
219                 "free space %zu bytes, window size %zu bytes",
220                 size, freeSpace(), mSize);
221         return 0;
222     }
223 
224     mHeader->freeOffset = nextFreeOffset;
225     return offset;
226 }
227 
getRowSlot(uint32_t row)228 CursorWindow::RowSlot* CursorWindow::getRowSlot(uint32_t row) {
229     uint32_t chunkPos = row;
230     RowSlotChunk* chunk = static_cast<RowSlotChunk*>(
231             offsetToPtr(mHeader->firstChunkOffset));
232     while (chunkPos >= ROW_SLOT_CHUNK_NUM_ROWS) {
233         chunk = static_cast<RowSlotChunk*>(offsetToPtr(chunk->nextChunkOffset));
234         chunkPos -= ROW_SLOT_CHUNK_NUM_ROWS;
235     }
236     return &chunk->slots[chunkPos];
237 }
238 
allocRowSlot()239 CursorWindow::RowSlot* CursorWindow::allocRowSlot() {
240     uint32_t chunkPos = mHeader->numRows;
241     RowSlotChunk* chunk = static_cast<RowSlotChunk*>(
242             offsetToPtr(mHeader->firstChunkOffset));
243     while (chunkPos > ROW_SLOT_CHUNK_NUM_ROWS) {
244         chunk = static_cast<RowSlotChunk*>(offsetToPtr(chunk->nextChunkOffset));
245         chunkPos -= ROW_SLOT_CHUNK_NUM_ROWS;
246     }
247     if (chunkPos == ROW_SLOT_CHUNK_NUM_ROWS) {
248         if (!chunk->nextChunkOffset) {
249             chunk->nextChunkOffset = alloc(sizeof(RowSlotChunk), true /*aligned*/);
250             if (!chunk->nextChunkOffset) {
251                 return NULL;
252             }
253         }
254         chunk = static_cast<RowSlotChunk*>(offsetToPtr(chunk->nextChunkOffset));
255         chunk->nextChunkOffset = 0;
256         chunkPos = 0;
257     }
258     mHeader->numRows += 1;
259     return &chunk->slots[chunkPos];
260 }
261 
getFieldSlot(uint32_t row,uint32_t column)262 CursorWindow::FieldSlot* CursorWindow::getFieldSlot(uint32_t row, uint32_t column) {
263     if (row >= mHeader->numRows || column >= mHeader->numColumns) {
264         ALOGE("Failed to read row %d, column %d from a CursorWindow which "
265                 "has %d rows, %d columns.",
266                 row, column, mHeader->numRows, mHeader->numColumns);
267         return NULL;
268     }
269     RowSlot* rowSlot = getRowSlot(row);
270     if (!rowSlot) {
271         ALOGE("Failed to find rowSlot for row %d.", row);
272         return NULL;
273     }
274     FieldSlot* fieldDir = static_cast<FieldSlot*>(offsetToPtr(rowSlot->offset));
275     return &fieldDir[column];
276 }
277 
putBlob(uint32_t row,uint32_t column,const void * value,size_t size)278 status_t CursorWindow::putBlob(uint32_t row, uint32_t column, const void* value, size_t size) {
279     return putBlobOrString(row, column, value, size, FIELD_TYPE_BLOB);
280 }
281 
putString(uint32_t row,uint32_t column,const char * value,size_t sizeIncludingNull)282 status_t CursorWindow::putString(uint32_t row, uint32_t column, const char* value,
283         size_t sizeIncludingNull) {
284     return putBlobOrString(row, column, value, sizeIncludingNull, FIELD_TYPE_STRING);
285 }
286 
putBlobOrString(uint32_t row,uint32_t column,const void * value,size_t size,int32_t type)287 status_t CursorWindow::putBlobOrString(uint32_t row, uint32_t column,
288         const void* value, size_t size, int32_t type) {
289     if (mReadOnly) {
290         return INVALID_OPERATION;
291     }
292 
293     FieldSlot* fieldSlot = getFieldSlot(row, column);
294     if (!fieldSlot) {
295         return BAD_VALUE;
296     }
297 
298     uint32_t offset = alloc(size);
299     if (!offset) {
300         return NO_MEMORY;
301     }
302 
303     memcpy(offsetToPtr(offset), value, size);
304 
305     fieldSlot->type = type;
306     fieldSlot->data.buffer.offset = offset;
307     fieldSlot->data.buffer.size = size;
308     return OK;
309 }
310 
putLong(uint32_t row,uint32_t column,int64_t value)311 status_t CursorWindow::putLong(uint32_t row, uint32_t column, int64_t value) {
312     if (mReadOnly) {
313         return INVALID_OPERATION;
314     }
315 
316     FieldSlot* fieldSlot = getFieldSlot(row, column);
317     if (!fieldSlot) {
318         return BAD_VALUE;
319     }
320 
321     fieldSlot->type = FIELD_TYPE_INTEGER;
322     fieldSlot->data.l = value;
323     return OK;
324 }
325 
putDouble(uint32_t row,uint32_t column,double value)326 status_t CursorWindow::putDouble(uint32_t row, uint32_t column, double value) {
327     if (mReadOnly) {
328         return INVALID_OPERATION;
329     }
330 
331     FieldSlot* fieldSlot = getFieldSlot(row, column);
332     if (!fieldSlot) {
333         return BAD_VALUE;
334     }
335 
336     fieldSlot->type = FIELD_TYPE_FLOAT;
337     fieldSlot->data.d = value;
338     return OK;
339 }
340 
putNull(uint32_t row,uint32_t column)341 status_t CursorWindow::putNull(uint32_t row, uint32_t column) {
342     if (mReadOnly) {
343         return INVALID_OPERATION;
344     }
345 
346     FieldSlot* fieldSlot = getFieldSlot(row, column);
347     if (!fieldSlot) {
348         return BAD_VALUE;
349     }
350 
351     fieldSlot->type = FIELD_TYPE_NULL;
352     fieldSlot->data.buffer.offset = 0;
353     fieldSlot->data.buffer.size = 0;
354     return OK;
355 }
356 
357 }; // namespace android
358