libs/androidfw/CursorWindow.cpp

   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
  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
  39 CursorWindow::~CursorWindow() {
  40     ::munmap(mData, mSize);
  41     ::close(mAshmemFd);
  42 }
  43
  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
  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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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