nativeruntime/cpp/androidfw/CursorWindow.cpp

/*
 * Copyright (C) 2006-2007 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// Derived from
// https://cs.android.com/android/platform/superproject/+/android-11.0.0_r1:frameworks/base/libs/androidfw/CursorWindow.cpp

#undef LOG_TAG
#define LOG_TAG "CursorWindow"

#include <androidfw/CursorWindow.h>
// #include <binder/Parcel.h>
#include <assert.h>
#include <cutils/ashmem.h>
#include <log/log.h>
#include <stdlib.h>
#include <string.h>
#if !defined(_WIN32)
#include <sys/mman.h>
#endif
#include <unistd.h>

namespace android {

CursorWindow::CursorWindow(const String8& name, int ashmemFd, void* data,
                           size_t size, bool readOnly)
    : mName(name),
      mAshmemFd(ashmemFd),
      mData(data),
      mSize(size),
      mReadOnly(readOnly) {
  #if defined(_WIN32)
  mHeader = new Header;
  #else
  mHeader = static_cast<Header*>(mData);
  #endif
}

CursorWindow::~CursorWindow() {
  #if defined(_WIN32)
  delete mHeader;
  #else
  ::munmap(mData, mSize);
  ::close(mAshmemFd);
  #endif
}

#if defined(_WIN32)
status_t CursorWindow::create(const String8& name, size_t size,
                              CursorWindow** outCursorWindow) {
  String8 ashmemName("CursorWindow: ");
  ashmemName.append(name);

  status_t result;
  // We don't use ashmem here, and CursorWindow constructor will use in-memory struct
  // to support Windows.
  CursorWindow* window = new CursorWindow(name, -1, nullptr, size, true /*readOnly*/);
  LOG_WINDOW("Created CursorWindow from parcel: freeOffset=%d, "
             "numRows=%d, numColumns=%d, mSize=%zu, mData=%p",
             window->mHeader->freeOffset,
             window->mHeader->numRows,
             window->mHeader->numColumns,
             window->mSize, window->mData);
  if (window != nullptr) {
    *outCursorWindow = window;
    return OK;
  }
  *outCursorWindow = nullptr;
  return result;
}
#else
status_t CursorWindow::create(const String8& name, size_t size,
                              CursorWindow** outCursorWindow) {
  String8 ashmemName("CursorWindow: ");
  ashmemName.append(name);

  status_t result;
  int ashmemFd = ashmem_create_region(ashmemName.string(), size);
  if (ashmemFd < 0) {
    result = -errno;
    ALOGE("CursorWindow: ashmem_create_region() failed: errno=%d.", errno);
  } else {
    result = ashmem_set_prot_region(ashmemFd, PROT_READ | PROT_WRITE);
    if (result < 0) {
      ALOGE("CursorWindow: ashmem_set_prot_region() failed: errno=%d", errno);
    } else {
      void* data = ::mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_SHARED,
                          ashmemFd, 0);
      if (data == MAP_FAILED) {
        result = -errno;
        ALOGE("CursorWindow: mmap() failed: errno=%d.", errno);
      } else {
        result = ashmem_set_prot_region(ashmemFd, PROT_READ);
        if (result < 0) {
          ALOGE("CursorWindow: ashmem_set_prot_region() failed: errno=%d.",
                errno);
        } else {
          CursorWindow* window =
              new CursorWindow(name, ashmemFd, data, size, false /*readOnly*/);
          result = window->clear();
          if (!result) {
            LOG_WINDOW(
                "Created new CursorWindow: freeOffset=%d, "
                "numRows=%d, numColumns=%d, mSize=%zu, mData=%p",
                window->mHeader->freeOffset, window->mHeader->numRows,
                window->mHeader->numColumns, window->mSize, window->mData);
            *outCursorWindow = window;
            return OK;
          }
          delete window;
        }
      }
      ::munmap(data, size);
    }
    ::close(ashmemFd);
  }
  *outCursorWindow = nullptr;
  return result;
}
#endif
//
// status_t CursorWindow::createFromParcel(Parcel* parcel, CursorWindow**
// outCursorWindow) {
//  String8 name = parcel->readString8();
//
//  status_t result;
//  int actualSize;
//  int ashmemFd = parcel->readFileDescriptor();
//  if (ashmemFd == int(BAD_TYPE)) {
//    result = BAD_TYPE;
//    ALOGE("CursorWindow: readFileDescriptor() failed");
//  } else {
//    ssize_t size = ashmem_get_size_region(ashmemFd);
//    if (size < 0) {
//      result = UNKNOWN_ERROR;
//      ALOGE("CursorWindow: ashmem_get_size_region() failed: errno=%d.",
//      errno);
//    } else {
//      int dupAshmemFd = ::fcntl(ashmemFd, F_DUPFD_CLOEXEC, 0);
//      if (dupAshmemFd < 0) {
//        result = -errno;
//        ALOGE("CursorWindow: fcntl() failed: errno=%d.", errno);
//      } else {
//        // the size of the ashmem descriptor can be modified between
//        ashmem_get_size_region
//        // call and mmap, so we'll check again immediately after memory is
//        mapped void* data = ::mmap(NULL, size, PROT_READ, MAP_SHARED,
//        dupAshmemFd, 0); if (data == MAP_FAILED) {
//          result = -errno;
//          ALOGE("CursorWindow: mmap() failed: errno=%d.", errno);
//        } else if ((actualSize = ashmem_get_size_region(dupAshmemFd)) != size)
//        {
//          ::munmap(data, size);
//          result = BAD_VALUE;
//          ALOGE("CursorWindow: ashmem_get_size_region() returned %d, expected
//          %d"
//                " errno=%d",
//                actualSize, (int) size, errno);
//        } else {
//          CursorWindow* window = new CursorWindow(name, dupAshmemFd,
//                                                  data, size, true
//                                                  /*readOnly*/);
//          LOG_WINDOW("Created CursorWindow from parcel: freeOffset=%d, "
//                     "numRows=%d, numColumns=%d, mSize=%zu, mData=%p",
//                     window->mHeader->freeOffset,
//                     window->mHeader->numRows,
//                     window->mHeader->numColumns,
//                     window->mSize, window->mData);
//          *outCursorWindow = window;
//          return OK;
//        }
//        ::close(dupAshmemFd);
//      }
//    }
//  }
//  *outCursorWindow = NULL;
//  return result;
//}
//
// status_t CursorWindow::writeToParcel(Parcel* parcel) {
//  status_t status = parcel->writeString8(mName);
//  if (!status) {
//    status = parcel->writeDupFileDescriptor(mAshmemFd);
//  }
//  return status;
//}

status_t CursorWindow::clear() {
  if (mReadOnly) {
    return INVALID_OPERATION;
  }

  mHeader->freeOffset = sizeof(Header) + sizeof(RowSlotChunk);
  mHeader->firstChunkOffset = sizeof(Header);
  mHeader->numRows = 0;
  mHeader->numColumns = 0;

  RowSlotChunk* firstChunk =
      static_cast<RowSlotChunk*>(offsetToPtr(mHeader->firstChunkOffset));
  firstChunk->nextChunkOffset = 0;
  return OK;
}

status_t CursorWindow::setNumColumns(uint32_t numColumns) {
  if (mReadOnly) {
    return INVALID_OPERATION;
  }

  uint32_t cur = mHeader->numColumns;
  if ((cur > 0 || mHeader->numRows > 0) && cur != numColumns) {
    ALOGE("Trying to go from %d columns to %d", cur, numColumns);
    return INVALID_OPERATION;
  }
  mHeader->numColumns = numColumns;
  return OK;
}

status_t CursorWindow::allocRow() {
  if (mReadOnly) {
    return INVALID_OPERATION;
  }

  // Fill in the row slot
  RowSlot* rowSlot = allocRowSlot();
  if (rowSlot == nullptr) {
    return NO_MEMORY;
  }

  // Allocate the slots for the field directory
  size_t fieldDirSize = mHeader->numColumns * sizeof(FieldSlot);
  uint32_t fieldDirOffset = alloc(fieldDirSize, true /*aligned*/);
  if (!fieldDirOffset) {
    mHeader->numRows--;
    LOG_WINDOW(
        "The row failed, so back out the new row accounting "
        "from allocRowSlot %d",
        mHeader->numRows);
    return NO_MEMORY;
  }
  FieldSlot* fieldDir = static_cast<FieldSlot*>(offsetToPtr(fieldDirOffset));
  memset(fieldDir, 0, fieldDirSize);

  LOG_WINDOW(
      "Allocated row %u, rowSlot is at offset %u, fieldDir is %zu bytes at "
      "offset %u\n",
      mHeader->numRows - 1, offsetFromPtr(rowSlot), fieldDirSize,
      fieldDirOffset);
  rowSlot->offset = fieldDirOffset;
  return OK;
}

status_t CursorWindow::freeLastRow() {
  if (mReadOnly) {
    return INVALID_OPERATION;
  }

  if (mHeader->numRows > 0) {
    mHeader->numRows--;
  }
  return OK;
}

uint32_t CursorWindow::alloc(size_t size, bool aligned) {
  uint32_t padding;
  if (aligned) {
    // 4 byte alignment
    padding = (~mHeader->freeOffset + 1) & 3;
  } else {
    padding = 0;
  }

  uint32_t offset = mHeader->freeOffset + padding;
  uint32_t nextFreeOffset = offset + size;
  if (nextFreeOffset > mSize) {
    //    ALOGW("Window is full: requested allocation %zu bytes, "
    //          "free space %zu bytes, window size %zu bytes",
    //          size, freeSpace(), mSize);
    return 0;
  }

  mHeader->freeOffset = nextFreeOffset;
  return offset;
}

CursorWindow::RowSlot* CursorWindow::getRowSlot(uint32_t row) {
  uint32_t chunkPos = row;
  RowSlotChunk* chunk =
      static_cast<RowSlotChunk*>(offsetToPtr(mHeader->firstChunkOffset));
  while (chunkPos >= ROW_SLOT_CHUNK_NUM_ROWS) {
    chunk = static_cast<RowSlotChunk*>(offsetToPtr(chunk->nextChunkOffset));
    chunkPos -= ROW_SLOT_CHUNK_NUM_ROWS;
  }
  return &chunk->slots[chunkPos];
}

CursorWindow::RowSlot* CursorWindow::allocRowSlot() {
  uint32_t chunkPos = mHeader->numRows;
  RowSlotChunk* chunk =
      static_cast<RowSlotChunk*>(offsetToPtr(mHeader->firstChunkOffset));
  while (chunkPos > ROW_SLOT_CHUNK_NUM_ROWS) {
    chunk = static_cast<RowSlotChunk*>(offsetToPtr(chunk->nextChunkOffset));
    chunkPos -= ROW_SLOT_CHUNK_NUM_ROWS;
  }
  if (chunkPos == ROW_SLOT_CHUNK_NUM_ROWS) {
    if (!chunk->nextChunkOffset) {
      chunk->nextChunkOffset = alloc(sizeof(RowSlotChunk), true /*aligned*/);
      if (!chunk->nextChunkOffset) {
        return nullptr;
      }
    }
    chunk = static_cast<RowSlotChunk*>(offsetToPtr(chunk->nextChunkOffset));
    chunk->nextChunkOffset = 0;
    chunkPos = 0;
  }
  mHeader->numRows += 1;
  return &chunk->slots[chunkPos];
}

CursorWindow::FieldSlot* CursorWindow::getFieldSlot(uint32_t row,
                                                    uint32_t column) {
  if (row >= mHeader->numRows || column >= mHeader->numColumns) {
    ALOGE(
        "Failed to read row %d, column %d from a CursorWindow which "
        "has %d rows, %d columns.",
        row, column, mHeader->numRows, mHeader->numColumns);
    return nullptr;
  }
  RowSlot* rowSlot = getRowSlot(row);
  if (!rowSlot) {
    ALOGE("Failed to find rowSlot for row %d.", row);
    return nullptr;
  }
  FieldSlot* fieldDir = static_cast<FieldSlot*>(offsetToPtr(rowSlot->offset));
  return &fieldDir[column];
}

status_t CursorWindow::putBlob(uint32_t row, uint32_t column, const void* value,
                               size_t size) {
  return putBlobOrString(row, column, value, size, FIELD_TYPE_BLOB);
}

status_t CursorWindow::putString(uint32_t row, uint32_t column,
                                 const char* value, size_t sizeIncludingNull) {
  return putBlobOrString(row, column, value, sizeIncludingNull,
                         FIELD_TYPE_STRING);
}

status_t CursorWindow::putBlobOrString(uint32_t row, uint32_t column,
                                       const void* value, size_t size,
                                       int32_t type) {
  if (mReadOnly) {
    return INVALID_OPERATION;
  }

  FieldSlot* fieldSlot = getFieldSlot(row, column);
  if (!fieldSlot) {
    return BAD_VALUE;
  }

  uint32_t offset = alloc(size);
  if (!offset) {
    return NO_MEMORY;
  }

  memcpy(offsetToPtr(offset), value, size);

  fieldSlot->type = type;
  fieldSlot->data.buffer.offset = offset;
  fieldSlot->data.buffer.size = size;
  return OK;
}

status_t CursorWindow::putLong(uint32_t row, uint32_t column, int64_t value) {
  if (mReadOnly) {
    return INVALID_OPERATION;
  }

  FieldSlot* fieldSlot = getFieldSlot(row, column);
  if (!fieldSlot) {
    return BAD_VALUE;
  }

  fieldSlot->type = FIELD_TYPE_INTEGER;
  fieldSlot->data.l = value;
  return OK;
}

status_t CursorWindow::putDouble(uint32_t row, uint32_t column, double value) {
  if (mReadOnly) {
    return INVALID_OPERATION;
  }

  FieldSlot* fieldSlot = getFieldSlot(row, column);
  if (!fieldSlot) {
    return BAD_VALUE;
  }

  fieldSlot->type = FIELD_TYPE_FLOAT;
  fieldSlot->data.d = value;
  return OK;
}

status_t CursorWindow::putNull(uint32_t row, uint32_t column) {
  if (mReadOnly) {
    return INVALID_OPERATION;
  }

  FieldSlot* fieldSlot = getFieldSlot(row, column);
  if (!fieldSlot) {
    return BAD_VALUE;
  }

  fieldSlot->type = FIELD_TYPE_NULL;
  fieldSlot->data.buffer.offset = 0;
  fieldSlot->data.buffer.size = 0;
  return OK;
}

};  // namespace android