drgreen/android_frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Use ashmem for CursorWindows. Bug: 5332296" into ics-mr0

Browse Source
This commit is contained in:
Jeff Brown
2011-10-11 13:54:45 -07:00
committed by Android (Google) Code Review
parent a72a80632b 0cde89f5f0
commit 58bf986c3e
13 changed files with 696 additions and 818 deletions
Download Patch File Download Diff File Expand all files Collapse all files

110
core/java/android/content/ContentProviderNative.java
View File

@ -108,21 +108,22 @@ abstract public class ContentProviderNative extends Binder implements IContentPr
String sortOrder = data.readString(); String sortOrder = data.readString();
IContentObserver observer = IContentObserver.Stub.asInterface( IContentObserver observer = IContentObserver.Stub.asInterface(
data.readStrongBinder()); data.readStrongBinder());
CursorWindow window = CursorWindow.CREATOR.createFromParcel(data);
Cursor cursor = query(url, projection, selection, selectionArgs, sortOrder); Cursor cursor = query(url, projection, selection, selectionArgs, sortOrder);
if (cursor != null) { if (cursor != null) {
CursorToBulkCursorAdaptor adaptor = new CursorToBulkCursorAdaptor( CursorToBulkCursorAdaptor adaptor = new CursorToBulkCursorAdaptor(
cursor, observer, getProviderName(), window); cursor, observer, getProviderName());
final IBinder binder = adaptor.asBinder(); final IBinder binder = adaptor.asBinder();
final int count = adaptor.count(); final int count = adaptor.count();
final int index = BulkCursorToCursorAdaptor.findRowIdColumnIndex( final int index = BulkCursorToCursorAdaptor.findRowIdColumnIndex(
adaptor.getColumnNames()); adaptor.getColumnNames());
final boolean wantsAllOnMoveCalls = adaptor.getWantsAllOnMoveCalls();
reply.writeNoException(); reply.writeNoException();
reply.writeStrongBinder(binder); reply.writeStrongBinder(binder);
reply.writeInt(count); reply.writeInt(count);
reply.writeInt(index); reply.writeInt(index);
reply.writeInt(wantsAllOnMoveCalls ? 1 : 0);
} else { } else {
reply.writeNoException(); reply.writeNoException();
reply.writeStrongBinder(null); reply.writeStrongBinder(null);
@ -324,67 +325,58 @@ final class ContentProviderProxy implements IContentProvider
public Cursor query(Uri url, String[] projection, String selection, public Cursor query(Uri url, String[] projection, String selection,
String[] selectionArgs, String sortOrder) throws RemoteException { String[] selectionArgs, String sortOrder) throws RemoteException {
CursorWindow window = new CursorWindow(false /* window will be used remotely */); BulkCursorToCursorAdaptor adaptor = new BulkCursorToCursorAdaptor();
Parcel data = Parcel.obtain();
Parcel reply = Parcel.obtain();
try { try {
BulkCursorToCursorAdaptor adaptor = new BulkCursorToCursorAdaptor(); data.writeInterfaceToken(IContentProvider.descriptor);
Parcel data = Parcel.obtain();
Parcel reply = Parcel.obtain();
try {
data.writeInterfaceToken(IContentProvider.descriptor);
url.writeToParcel(data, 0); url.writeToParcel(data, 0);
int length = 0; int length = 0;
if (projection != null) { if (projection != null) {
length = projection.length; length = projection.length;
}
data.writeInt(length);
for (int i = 0; i < length; i++) {
data.writeString(projection[i]);
}
data.writeString(selection);
if (selectionArgs != null) {
length = selectionArgs.length;
} else {
length = 0;
}
data.writeInt(length);
for (int i = 0; i < length; i++) {
data.writeString(selectionArgs[i]);
}
data.writeString(sortOrder);
data.writeStrongBinder(adaptor.getObserver().asBinder());
window.writeToParcel(data, 0);
mRemote.transact(IContentProvider.QUERY_TRANSACTION, data, reply, 0);
DatabaseUtils.readExceptionFromParcel(reply);
IBulkCursor bulkCursor = BulkCursorNative.asInterface(reply.readStrongBinder());
if (bulkCursor != null) {
int rowCount = reply.readInt();
int idColumnPosition = reply.readInt();
adaptor.initialize(bulkCursor, rowCount, idColumnPosition);
} else {
adaptor.close();
adaptor = null;
}
return adaptor;
} catch (RemoteException ex) {
adaptor.close();
throw ex;
} catch (RuntimeException ex) {
adaptor.close();
throw ex;
} finally {
data.recycle();
reply.recycle();
} }
data.writeInt(length);
for (int i = 0; i < length; i++) {
data.writeString(projection[i]);
}
data.writeString(selection);
if (selectionArgs != null) {
length = selectionArgs.length;
} else {
length = 0;
}
data.writeInt(length);
for (int i = 0; i < length; i++) {
data.writeString(selectionArgs[i]);
}
data.writeString(sortOrder);
data.writeStrongBinder(adaptor.getObserver().asBinder());
mRemote.transact(IContentProvider.QUERY_TRANSACTION, data, reply, 0);
DatabaseUtils.readExceptionFromParcel(reply);
IBulkCursor bulkCursor = BulkCursorNative.asInterface(reply.readStrongBinder());
if (bulkCursor != null) {
int rowCount = reply.readInt();
int idColumnPosition = reply.readInt();
boolean wantsAllOnMoveCalls = reply.readInt() != 0;
adaptor.initialize(bulkCursor, rowCount, idColumnPosition, wantsAllOnMoveCalls);
} else {
adaptor.close();
adaptor = null;
}
return adaptor;
} catch (RemoteException ex) {
adaptor.close();
throw ex;
} catch (RuntimeException ex) {
adaptor.close();
throw ex;
} finally { } finally {
// We close the window now because the cursor adaptor does not data.recycle();
// take ownership of the window until the first call to onMove. reply.recycle();
// The adaptor will obtain a fresh reference to the window when
// it is filled.
window.close();
} }
} }

6
core/java/android/database/AbstractWindowedCursor.java
View File

@ -189,12 +189,14 @@ public abstract class AbstractWindowedCursor extends AbstractCursor {
/** /**
* If there is a window, clear it. * If there is a window, clear it.
* Otherwise, creates a local window. * Otherwise, creates a local window.
*
* @param name The window name.
* @hide * @hide
*/ */
protected void clearOrCreateLocalWindow() { protected void clearOrCreateLocalWindow(String name) {
if (mWindow == null) { if (mWindow == null) {
// If there isn't a window set already it will only be accessed locally // If there isn't a window set already it will only be accessed locally
mWindow = new CursorWindow(true /* the window is local only */); mWindow = new CursorWindow(name, true /* the window is local only */);
} else { } else {
mWindow.clear(); mWindow.clear();
} }

8
core/java/android/database/BulkCursorNative.java
View File

@ -109,9 +109,8 @@ public abstract class BulkCursorNative extends Binder implements IBulkCursor
case REQUERY_TRANSACTION: { case REQUERY_TRANSACTION: {
data.enforceInterface(IBulkCursor.descriptor); data.enforceInterface(IBulkCursor.descriptor);
IContentObserver observer = IContentObserver observer =
IContentObserver.Stub.asInterface(data.readStrongBinder()); IContentObserver.Stub.asInterface(data.readStrongBinder());
CursorWindow window = CursorWindow.CREATOR.createFromParcel(data); int count = requery(observer);
int count = requery(observer, window);
reply.writeNoException(); reply.writeNoException();
reply.writeInt(count); reply.writeInt(count);
reply.writeBundle(getExtras()); reply.writeBundle(getExtras());
@ -294,13 +293,12 @@ final class BulkCursorProxy implements IBulkCursor {
} }
} }
public int requery(IContentObserver observer, CursorWindow window) throws RemoteException { public int requery(IContentObserver observer) throws RemoteException {
Parcel data = Parcel.obtain(); Parcel data = Parcel.obtain();
Parcel reply = Parcel.obtain(); Parcel reply = Parcel.obtain();
try { try {
data.writeInterfaceToken(IBulkCursor.descriptor); data.writeInterfaceToken(IBulkCursor.descriptor);
data.writeStrongInterface(observer); data.writeStrongInterface(observer);
window.writeToParcel(data, 0);
boolean result = mRemote.transact(REQUERY_TRANSACTION, data, reply, 0); boolean result = mRemote.transact(REQUERY_TRANSACTION, data, reply, 0);
DatabaseUtils.readExceptionFromParcel(reply); DatabaseUtils.readExceptionFromParcel(reply);

47
core/java/android/database/BulkCursorToCursorAdaptor.java
View File

@ -38,11 +38,13 @@ public final class BulkCursorToCursorAdaptor extends AbstractWindowedCursor {
* Initializes the adaptor. * Initializes the adaptor.
* Must be called before first use. * Must be called before first use.
*/ */
public void initialize(IBulkCursor bulkCursor, int count, int idIndex) { public void initialize(IBulkCursor bulkCursor, int count, int idIndex,
boolean wantsAllOnMoveCalls) {
mBulkCursor = bulkCursor; mBulkCursor = bulkCursor;
mColumns = null; // lazily retrieved mColumns = null; // lazily retrieved
mCount = count; mCount = count;
mRowIdColumnIndex = idIndex; mRowIdColumnIndex = idIndex;
mWantsAllOnMoveCalls = wantsAllOnMoveCalls;
} }
/** /**
@ -86,15 +88,12 @@ public final class BulkCursorToCursorAdaptor extends AbstractWindowedCursor {
try { try {
// Make sure we have the proper window // Make sure we have the proper window
if (mWindow != null) { if (mWindow == null
if (newPosition < mWindow.getStartPosition() || || newPosition < mWindow.getStartPosition()
newPosition >= (mWindow.getStartPosition() + mWindow.getNumRows())) { || newPosition >= mWindow.getStartPosition() + mWindow.getNumRows()) {
setWindow(mBulkCursor.getWindow(newPosition));
} else if (mWantsAllOnMoveCalls) {
mBulkCursor.onMove(newPosition);
}
} else {
setWindow(mBulkCursor.getWindow(newPosition)); setWindow(mBulkCursor.getWindow(newPosition));
} else if (mWantsAllOnMoveCalls) {
mBulkCursor.onMove(newPosition);
} }
} catch (RemoteException ex) { } catch (RemoteException ex) {
// We tried to get a window and failed // We tried to get a window and failed
@ -145,25 +144,19 @@ public final class BulkCursorToCursorAdaptor extends AbstractWindowedCursor {
throwIfCursorIsClosed(); throwIfCursorIsClosed();
try { try {
CursorWindow newWindow = new CursorWindow(false /* create a remote window */); mCount = mBulkCursor.requery(getObserver());
try { if (mCount != -1) {
mCount = mBulkCursor.requery(getObserver(), newWindow); mPos = -1;
if (mCount != -1) { closeWindow();
mPos = -1;
closeWindow();
// super.requery() will call onChanged. Do it here instead of relying on the // super.requery() will call onChanged. Do it here instead of relying on the
// observer from the far side so that observers can see a correct value for mCount // observer from the far side so that observers can see a correct value for mCount
// when responding to onChanged. // when responding to onChanged.
super.requery(); super.requery();
return true; return true;
} else { } else {
deactivate(); deactivate();
return false; return false;
}
} finally {
// Don't take ownership of the window until the next call to onMove.
newWindow.close();
} }
} catch (Exception ex) { } catch (Exception ex) {
Log.e(TAG, "Unable to requery because the remote process exception " + ex.getMessage()); Log.e(TAG, "Unable to requery because the remote process exception " + ex.getMessage());

85
core/java/android/database/CursorToBulkCursorAdaptor.java
View File

@ -53,6 +53,7 @@ public final class CursorToBulkCursorAdaptor extends BulkCursorNative
* for managing the lifetime of their window. * for managing the lifetime of their window.
*/ */
private CursorWindow mWindowForNonWindowedCursor; private CursorWindow mWindowForNonWindowedCursor;
private boolean mWindowForNonWindowedCursorWasFilled;
private static final class ContentObserverProxy extends ContentObserver { private static final class ContentObserverProxy extends ContentObserver {
protected IContentObserver mRemote; protected IContentObserver mRemote;
@ -87,26 +88,11 @@ public final class CursorToBulkCursorAdaptor extends BulkCursorNative
} }
} }
public CursorToBulkCursorAdaptor(Cursor cursor, IContentObserver observer, String providerName, public CursorToBulkCursorAdaptor(Cursor cursor, IContentObserver observer,
CursorWindow window) { String providerName) {
try { try {
mCursor = (CrossProcessCursor) cursor; mCursor = (CrossProcessCursor) cursor;
if (mCursor instanceof AbstractWindowedCursor) {
AbstractWindowedCursor windowedCursor = (AbstractWindowedCursor) cursor;
if (windowedCursor.hasWindow()) {
if (Log.isLoggable(TAG, Log.VERBOSE) || false) {
Log.v(TAG, "Cross process cursor has a local window before setWindow in "
+ providerName, new RuntimeException());
}
}
windowedCursor.setWindow(window); // cursor takes ownership of window
} else {
mWindowForNonWindowedCursor = window; // we own the window
mCursor.fillWindow(0, window);
}
} catch (ClassCastException e) { } catch (ClassCastException e) {
// TODO Implement this case.
window.close();
throw new UnsupportedOperationException( throw new UnsupportedOperationException(
"Only CrossProcessCursor cursors are supported across process for now", e); "Only CrossProcessCursor cursors are supported across process for now", e);
} }
@ -117,17 +103,22 @@ public final class CursorToBulkCursorAdaptor extends BulkCursorNative
} }
} }
private void closeCursorAndWindowLocked() { private void closeWindowForNonWindowedCursorLocked() {
if (mWindowForNonWindowedCursor != null) {
mWindowForNonWindowedCursor.close();
mWindowForNonWindowedCursor = null;
mWindowForNonWindowedCursorWasFilled = false;
}
}
private void disposeLocked() {
if (mCursor != null) { if (mCursor != null) {
unregisterObserverProxyLocked(); unregisterObserverProxyLocked();
mCursor.close(); mCursor.close();
mCursor = null; mCursor = null;
} }
if (mWindowForNonWindowedCursor != null) { closeWindowForNonWindowedCursorLocked();
mWindowForNonWindowedCursor.close();
mWindowForNonWindowedCursor = null;
}
} }
private void throwIfCursorIsClosed() { private void throwIfCursorIsClosed() {
@ -139,7 +130,7 @@ public final class CursorToBulkCursorAdaptor extends BulkCursorNative
@Override @Override
public void binderDied() { public void binderDied() {
synchronized (mLock) { synchronized (mLock) {
closeCursorAndWindowLocked(); disposeLocked();
} }
} }
@ -148,17 +139,30 @@ public final class CursorToBulkCursorAdaptor extends BulkCursorNative
synchronized (mLock) { synchronized (mLock) {
throwIfCursorIsClosed(); throwIfCursorIsClosed();
mCursor.moveToPosition(startPos); CursorWindow window;
final CursorWindow window;
if (mCursor instanceof AbstractWindowedCursor) { if (mCursor instanceof AbstractWindowedCursor) {
window = ((AbstractWindowedCursor)mCursor).getWindow(); AbstractWindowedCursor windowedCursor = (AbstractWindowedCursor)mCursor;
window = windowedCursor.getWindow();
if (window == null) {
window = new CursorWindow(mProviderName, false /*localOnly*/);
windowedCursor.setWindow(window);
}
mCursor.moveToPosition(startPos);
} else { } else {
window = mWindowForNonWindowedCursor; window = mWindowForNonWindowedCursor;
if (window != null if (window == null) {
&& (startPos < window.getStartPosition() || window = new CursorWindow(mProviderName, false /*localOnly*/);
startPos >= (window.getStartPosition() + window.getNumRows()))) { mWindowForNonWindowedCursor = window;
}
mCursor.moveToPosition(startPos);
if (!mWindowForNonWindowedCursorWasFilled
|| startPos < window.getStartPosition()
|| startPos >= window.getStartPosition() + window.getNumRows()) {
mCursor.fillWindow(startPos, window); mCursor.fillWindow(startPos, window);
mWindowForNonWindowedCursorWasFilled = true;
} }
} }
@ -206,29 +210,24 @@ public final class CursorToBulkCursorAdaptor extends BulkCursorNative
unregisterObserverProxyLocked(); unregisterObserverProxyLocked();
mCursor.deactivate(); mCursor.deactivate();
} }
closeWindowForNonWindowedCursorLocked();
} }
} }
@Override @Override
public void close() { public void close() {
synchronized (mLock) { synchronized (mLock) {
closeCursorAndWindowLocked(); disposeLocked();
} }
} }
@Override @Override
public int requery(IContentObserver observer, CursorWindow window) { public int requery(IContentObserver observer) {
synchronized (mLock) { synchronized (mLock) {
throwIfCursorIsClosed(); throwIfCursorIsClosed();
if (mCursor instanceof AbstractWindowedCursor) { closeWindowForNonWindowedCursorLocked();
((AbstractWindowedCursor) mCursor).setWindow(window);
} else {
if (mWindowForNonWindowedCursor != null) {
mWindowForNonWindowedCursor.close();
}
mWindowForNonWindowedCursor = window;
}
try { try {
if (!mCursor.requery()) { if (!mCursor.requery()) {
@ -241,12 +240,6 @@ public final class CursorToBulkCursorAdaptor extends BulkCursorNative
throw leakProgram; throw leakProgram;
} }
if (!(mCursor instanceof AbstractWindowedCursor)) {
if (window != null) {
mCursor.fillWindow(0, window);
}
}
unregisterObserverProxyLocked(); unregisterObserverProxyLocked();
createAndRegisterObserverProxyLocked(observer); createAndRegisterObserverProxyLocked(observer);
return mCursor.getCount(); return mCursor.getCount();

53
core/java/android/database/CursorWindow.java
View File

@ -22,7 +22,6 @@ import android.content.res.Resources;
import android.database.sqlite.SQLiteClosable; import android.database.sqlite.SQLiteClosable;
import android.database.sqlite.SQLiteException; import android.database.sqlite.SQLiteException;
import android.os.Binder; import android.os.Binder;
import android.os.IBinder;
import android.os.Parcel; import android.os.Parcel;
import android.os.Parcelable; import android.os.Parcelable;
import android.os.Process; import android.os.Process;
@ -31,6 +30,13 @@ import android.util.SparseIntArray;
/** /**
* A buffer containing multiple cursor rows. * A buffer containing multiple cursor rows.
* <p>
* A {@link CursorWindow} is read-write when created and used locally. When sent
* to a remote process (by writing it to a {@link Parcel}), the remote process
* receives a read-only view of the cursor window. Typically the cursor window
* will be allocated by the producer, filled with data, and then sent to the
* consumer for reading.
* </p>
*/ */
public class CursorWindow extends SQLiteClosable implements Parcelable { public class CursorWindow extends SQLiteClosable implements Parcelable {
private static final String STATS_TAG = "CursorWindowStats"; private static final String STATS_TAG = "CursorWindowStats";
@ -52,10 +58,11 @@ public class CursorWindow extends SQLiteClosable implements Parcelable {
private final CloseGuard mCloseGuard = CloseGuard.get(); private final CloseGuard mCloseGuard = CloseGuard.get();
private static native int nativeInitializeEmpty(int cursorWindowSize, boolean localOnly); private static native int nativeCreate(String name,
private static native int nativeInitializeFromBinder(IBinder nativeBinder); int cursorWindowSize, boolean localOnly);
private static native int nativeCreateFromParcel(Parcel parcel);
private static native void nativeDispose(int windowPtr); private static native void nativeDispose(int windowPtr);
private static native IBinder nativeGetBinder(int windowPtr); private static native void nativeWriteToParcel(int windowPtr, Parcel parcel);
private static native void nativeClear(int windowPtr); private static native void nativeClear(int windowPtr);
@ -78,6 +85,30 @@ public class CursorWindow extends SQLiteClosable implements Parcelable {
private static native boolean nativePutDouble(int windowPtr, double value, int row, int column); private static native boolean nativePutDouble(int windowPtr, double value, int row, int column);
private static native boolean nativePutNull(int windowPtr, int row, int column); private static native boolean nativePutNull(int windowPtr, int row, int column);
/**
* Creates a new empty cursor window and gives it a name.
* <p>
* The cursor initially has no rows or columns. Call {@link #setNumColumns(int)} to
* set the number of columns before adding any rows to the cursor.
* </p>
*
* @param name The name of the cursor window, or null if none.
* @param localWindow True if this window will be used in this process only,
* false if it might be sent to another processes.
*
* @hide
*/
public CursorWindow(String name, boolean localWindow) {
mStartPos = 0;
mWindowPtr = nativeCreate(name, sCursorWindowSize, localWindow);
if (mWindowPtr == 0) {
throw new CursorWindowAllocationException("Cursor window allocation of " +
(sCursorWindowSize / 1024) + " kb failed. " + printStats());
}
mCloseGuard.open("close");
recordNewWindow(Binder.getCallingPid(), mWindowPtr);
}
/** /**
* Creates a new empty cursor window. * Creates a new empty cursor window.
* <p> * <p>
@ -89,20 +120,12 @@ public class CursorWindow extends SQLiteClosable implements Parcelable {
* false if it might be sent to another processes. * false if it might be sent to another processes.
*/ */
public CursorWindow(boolean localWindow) { public CursorWindow(boolean localWindow) {
mStartPos = 0; this(null, localWindow);
mWindowPtr = nativeInitializeEmpty(sCursorWindowSize, localWindow);
if (mWindowPtr == 0) {
throw new CursorWindowAllocationException("Cursor window allocation of " +
(sCursorWindowSize / 1024) + " kb failed. " + printStats());
}
mCloseGuard.open("close");
recordNewWindow(Binder.getCallingPid(), mWindowPtr);
} }
private CursorWindow(Parcel source) { private CursorWindow(Parcel source) {
IBinder binder = source.readStrongBinder();
mStartPos = source.readInt(); mStartPos = source.readInt();
mWindowPtr = nativeInitializeFromBinder(binder); mWindowPtr = nativeCreateFromParcel(source);
if (mWindowPtr == 0) { if (mWindowPtr == 0) {
throw new CursorWindowAllocationException("Cursor window could not be " throw new CursorWindowAllocationException("Cursor window could not be "
+ "created from binder."); + "created from binder.");
@ -687,8 +710,8 @@ public class CursorWindow extends SQLiteClosable implements Parcelable {
} }
public void writeToParcel(Parcel dest, int flags) { public void writeToParcel(Parcel dest, int flags) {
dest.writeStrongBinder(nativeGetBinder(mWindowPtr));
dest.writeInt(mStartPos); dest.writeInt(mStartPos);
nativeWriteToParcel(mWindowPtr, dest);
if ((flags & Parcelable.PARCELABLE_WRITE_RETURN_VALUE) != 0) { if ((flags & Parcelable.PARCELABLE_WRITE_RETURN_VALUE) != 0) {
releaseReference(); releaseReference();

2
core/java/android/database/IBulkCursor.java
View File

@ -56,7 +56,7 @@ public interface IBulkCursor extends IInterface {
public void close() throws RemoteException; public void close() throws RemoteException;
public int requery(IContentObserver observer, CursorWindow window) throws RemoteException; public int requery(IContentObserver observer) throws RemoteException;
boolean getWantsAllOnMoveCalls() throws RemoteException; boolean getWantsAllOnMoveCalls() throws RemoteException;

2
core/java/android/database/sqlite/SQLiteCursor.java
View File

@ -155,7 +155,7 @@ public class SQLiteCursor extends AbstractWindowedCursor {
} }
private void fillWindow(int startPos) { private void fillWindow(int startPos) {
clearOrCreateLocalWindow(); clearOrCreateLocalWindow(getDatabase().getPath());
mWindow.setStartPosition(startPos); mWindow.setStartPosition(startPos);
int count = getQuery().fillWindow(mWindow); int count = getQuery().fillWindow(mWindow);
if (startPos == 0) { // fillWindow returns count(*) only for startPos = 0 if (startPos == 0) { // fillWindow returns count(*) only for startPos = 0

314
core/jni/android_database_CursorWindow.cpp
View File

@ -57,14 +57,23 @@ static void throwUnknownTypeException(JNIEnv * env, jint type) {
jniThrowException(env, "java/lang/IllegalStateException", msg.string()); jniThrowException(env, "java/lang/IllegalStateException", msg.string());
} }
static jint nativeInitializeEmpty(JNIEnv* env, jclass clazz, static jint nativeCreate(JNIEnv* env, jclass clazz,
jint cursorWindowSize, jboolean localOnly) { jstring nameObj, jint cursorWindowSize, jboolean localOnly) {
CursorWindow* window = new CursorWindow(cursorWindowSize); String8 name;
if (!window) { if (nameObj) {
return 0; const char* nameStr = env->GetStringUTFChars(nameObj, NULL);
name.setTo(nameStr);
env->ReleaseStringUTFChars(nameObj, nameStr);
} }
if (!window->initBuffer(localOnly)) { if (name.size() == 0) {
delete window; name.setTo("<unnamed>");
}
CursorWindow* window;
status_t status = CursorWindow::create(name, cursorWindowSize, localOnly, &window);
if (status || !window) {
LOGE("Could not allocate CursorWindow '%s' of size %d due to error %d.",
name.string(), cursorWindowSize, status);
return 0; return 0;
} }
@ -72,19 +81,13 @@ static jint nativeInitializeEmpty(JNIEnv* env, jclass clazz,
return reinterpret_cast<jint>(window); return reinterpret_cast<jint>(window);
} }
static jint nativeInitializeFromBinder(JNIEnv* env, jclass clazz, jobject binderObj) { static jint nativeCreateFromParcel(JNIEnv* env, jclass clazz, jobject parcelObj) {
sp<IMemory> memory = interface_cast<IMemory>(ibinderForJavaObject(env, binderObj)); Parcel* parcel = parcelForJavaObject(env, parcelObj);
if (memory == NULL) {
jniThrowException(env, "java/lang/IllegalStateException", "Couldn't get native binder");
return 0;
}
CursorWindow* window = new CursorWindow(); CursorWindow* window;
if (!window) { status_t status = CursorWindow::createFromParcel(parcel, &window);
return 0; if (status || !window) {
} LOGE("Could not create CursorWindow from Parcel due to error %d.", status);
if (!window->setMemory(memory)) {
delete window;
return 0; return 0;
} }
@ -101,22 +104,26 @@ static void nativeDispose(JNIEnv* env, jclass clazz, jint windowPtr) {
} }
} }
static jobject nativeGetBinder(JNIEnv * env, jclass clazz, jint windowPtr) { static void nativeWriteToParcel(JNIEnv * env, jclass clazz, jint windowPtr,
jobject parcelObj) {
CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr);
if (window) { Parcel* parcel = parcelForJavaObject(env, parcelObj);
sp<IMemory> memory = window->getMemory();
if (memory != NULL) { status_t status = window->writeToParcel(parcel);
sp<IBinder> binder = memory->asBinder(); if (status) {
return javaObjectForIBinder(env, binder); String8 msg;
} msg.appendFormat("Could not write CursorWindow to Parcel due to error %d.", status);
jniThrowRuntimeException(env, msg.string());
} }
return NULL;
} }
static void nativeClear(JNIEnv * env, jclass clazz, jint windowPtr) { static void nativeClear(JNIEnv * env, jclass clazz, jint windowPtr) {
CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr);
LOG_WINDOW("Clearing window %p", window); LOG_WINDOW("Clearing window %p", window);
window->clear(); status_t status = window->clear();
if (status) {
LOG_WINDOW("Could not clear window. error=%d", status);
}
} }
static jint nativeGetNumRows(JNIEnv* env, jclass clazz, jint windowPtr) { static jint nativeGetNumRows(JNIEnv* env, jclass clazz, jint windowPtr) {
@ -127,12 +134,14 @@ static jint nativeGetNumRows(JNIEnv* env, jclass clazz, jint windowPtr) {
static jboolean nativeSetNumColumns(JNIEnv* env, jclass clazz, jint windowPtr, static jboolean nativeSetNumColumns(JNIEnv* env, jclass clazz, jint windowPtr,
jint columnNum) { jint columnNum) {
CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr);
return window->setNumColumns(columnNum); status_t status = window->setNumColumns(columnNum);
return status == OK;
} }
static jboolean nativeAllocRow(JNIEnv* env, jclass clazz, jint windowPtr) { static jboolean nativeAllocRow(JNIEnv* env, jclass clazz, jint windowPtr) {
CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr);
return window->allocRow() != NULL; status_t status = window->allocRow();
return status == OK;
} }
static void nativeFreeLastRow(JNIEnv* env, jclass clazz, jint windowPtr) { static void nativeFreeLastRow(JNIEnv* env, jclass clazz, jint windowPtr) {
@ -145,14 +154,14 @@ static jint nativeGetType(JNIEnv* env, jclass clazz, jint windowPtr,
CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr);
LOG_WINDOW("returning column type affinity for %d,%d from %p", row, column, window); LOG_WINDOW("returning column type affinity for %d,%d from %p", row, column, window);
field_slot_t* fieldSlot = window->getFieldSlotWithCheck(row, column); CursorWindow::FieldSlot* fieldSlot = window->getFieldSlot(row, column);
if (!fieldSlot) { if (!fieldSlot) {
// FIXME: This is really broken but we have CTS tests that depend // FIXME: This is really broken but we have CTS tests that depend
// on this legacy behavior. // on this legacy behavior.
//throwExceptionWithRowCol(env, row, column); //throwExceptionWithRowCol(env, row, column);
return FIELD_TYPE_NULL; return CursorWindow::FIELD_TYPE_NULL;
} }
return fieldSlot->type; return window->getFieldSlotType(fieldSlot);
} }
static jbyteArray nativeGetBlob(JNIEnv* env, jclass clazz, jint windowPtr, static jbyteArray nativeGetBlob(JNIEnv* env, jclass clazz, jint windowPtr,
@ -160,29 +169,29 @@ static jbyteArray nativeGetBlob(JNIEnv* env, jclass clazz, jint windowPtr,
CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr);
LOG_WINDOW("Getting blob for %d,%d from %p", row, column, window); LOG_WINDOW("Getting blob for %d,%d from %p", row, column, window);
field_slot_t* fieldSlot = window->getFieldSlotWithCheck(row, column); CursorWindow::FieldSlot* fieldSlot = window->getFieldSlot(row, column);
if (!fieldSlot) { if (!fieldSlot) {
throwExceptionWithRowCol(env, row, column); throwExceptionWithRowCol(env, row, column);
return NULL; return NULL;
} }
uint8_t type = fieldSlot->type; int32_t type = window->getFieldSlotType(fieldSlot);
if (type == FIELD_TYPE_BLOB || type == FIELD_TYPE_STRING) { if (type == CursorWindow::FIELD_TYPE_BLOB || type == CursorWindow::FIELD_TYPE_STRING) {
uint32_t size = fieldSlot->data.buffer.size; size_t size;
const void* value = window->getFieldSlotValueBlob(fieldSlot, &size);
jbyteArray byteArray = env->NewByteArray(size); jbyteArray byteArray = env->NewByteArray(size);
if (!byteArray) { if (!byteArray) {
env->ExceptionClear(); env->ExceptionClear();
throw_sqlite3_exception(env, "Native could not create new byte[]"); throw_sqlite3_exception(env, "Native could not create new byte[]");
return NULL; return NULL;
} }
env->SetByteArrayRegion(byteArray, 0, size, env->SetByteArrayRegion(byteArray, 0, size, static_cast<const jbyte*>(value));
reinterpret_cast<jbyte*>(window->offsetToPtr(fieldSlot->data.buffer.offset)));
return byteArray; return byteArray;
} else if (type == FIELD_TYPE_INTEGER) { } else if (type == CursorWindow::FIELD_TYPE_INTEGER) {
throw_sqlite3_exception(env, "INTEGER data in nativeGetBlob "); throw_sqlite3_exception(env, "INTEGER data in nativeGetBlob ");
} else if (type == FIELD_TYPE_FLOAT) { } else if (type == CursorWindow::FIELD_TYPE_FLOAT) {
throw_sqlite3_exception(env, "FLOAT data in nativeGetBlob "); throw_sqlite3_exception(env, "FLOAT data in nativeGetBlob ");
} else if (type == FIELD_TYPE_NULL) { } else if (type == CursorWindow::FIELD_TYPE_NULL) {
// do nothing // do nothing
} else { } else {
throwUnknownTypeException(env, type); throwUnknownTypeException(env, type);
@ -195,43 +204,37 @@ static jstring nativeGetString(JNIEnv* env, jclass clazz, jint windowPtr,
CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr);
LOG_WINDOW("Getting string for %d,%d from %p", row, column, window); LOG_WINDOW("Getting string for %d,%d from %p", row, column, window);
field_slot_t* fieldSlot = window->getFieldSlotWithCheck(row, column); CursorWindow::FieldSlot* fieldSlot = window->getFieldSlot(row, column);
if (!fieldSlot) { if (!fieldSlot) {
throwExceptionWithRowCol(env, row, column); throwExceptionWithRowCol(env, row, column);
return NULL; return NULL;
} }
uint8_t type = fieldSlot->type; int32_t type = window->getFieldSlotType(fieldSlot);
if (type == FIELD_TYPE_STRING) { if (type == CursorWindow::FIELD_TYPE_STRING) {
uint32_t size = fieldSlot->data.buffer.size; size_t sizeIncludingNull;
#if WINDOW_STORAGE_UTF8 const char* value = window->getFieldSlotValueString(fieldSlot, &sizeIncludingNull);
if (size <= 1) { if (sizeIncludingNull <= 1) {
return gEmptyString; return gEmptyString;
} }
// Convert to UTF-16 here instead of calling NewStringUTF. NewStringUTF // Convert to UTF-16 here instead of calling NewStringUTF. NewStringUTF
// doesn't like UTF-8 strings with high codepoints. It actually expects // doesn't like UTF-8 strings with high codepoints. It actually expects
// Modified UTF-8 with encoded surrogate pairs. // Modified UTF-8 with encoded surrogate pairs.
String16 utf16(window->getFieldSlotValueString(fieldSlot), size - 1); String16 utf16(value, sizeIncludingNull - 1);
return env->NewString(reinterpret_cast<const jchar*>(utf16.string()), utf16.size()); return env->NewString(reinterpret_cast<const jchar*>(utf16.string()), utf16.size());
#else } else if (type == CursorWindow::FIELD_TYPE_INTEGER) {
size_t chars = size / sizeof(char16_t);
return chars ? env->NewString(reinterpret_cast<jchar*>(
window->getFieldSlotValueString(fieldSlot)), chars)
: gEmptyString;
#endif
} else if (type == FIELD_TYPE_INTEGER) {
int64_t value = window->getFieldSlotValueLong(fieldSlot); int64_t value = window->getFieldSlotValueLong(fieldSlot);
char buf[32]; char buf[32];
snprintf(buf, sizeof(buf), "%lld", value); snprintf(buf, sizeof(buf), "%lld", value);
return env->NewStringUTF(buf); return env->NewStringUTF(buf);
} else if (type == FIELD_TYPE_FLOAT) { } else if (type == CursorWindow::FIELD_TYPE_FLOAT) {
double value = window->getFieldSlotValueDouble(fieldSlot); double value = window->getFieldSlotValueDouble(fieldSlot);
char buf[32]; char buf[32];
snprintf(buf, sizeof(buf), "%g", value); snprintf(buf, sizeof(buf), "%g", value);
return env->NewStringUTF(buf); return env->NewStringUTF(buf);
} else if (type == FIELD_TYPE_NULL) { } else if (type == CursorWindow::FIELD_TYPE_NULL) {
return NULL; return NULL;
} else if (type == FIELD_TYPE_BLOB) { } else if (type == CursorWindow::FIELD_TYPE_BLOB) {
throw_sqlite3_exception(env, "Unable to convert BLOB to string"); throw_sqlite3_exception(env, "Unable to convert BLOB to string");
return NULL; return NULL;
} else { } else {
@ -281,21 +284,6 @@ static void fillCharArrayBufferUTF(JNIEnv* env, jobject bufferObj,
} }
} }
#if !WINDOW_STORAGE_UTF8
static void fillCharArrayBuffer(JNIEnv* env, jobject bufferObj,
const char16_t* str, size_t len) {
jcharArray dataObj = allocCharArrayBuffer(env, bufferObj, len);
if (dataObj) {
if (len) {
jchar* data = static_cast<jchar*>(env->GetPrimitiveArrayCritical(dataObj, NULL));
memcpy(data, str, len * sizeof(jchar));
env->ReleasePrimitiveArrayCritical(dataObj, data, 0);
}
env->SetIntField(bufferObj, gCharArrayBufferClassInfo.sizeCopied, len);
}
}
#endif
static void clearCharArrayBuffer(JNIEnv* env, jobject bufferObj) { static void clearCharArrayBuffer(JNIEnv* env, jobject bufferObj) {
jcharArray dataObj = allocCharArrayBuffer(env, bufferObj, 0); jcharArray dataObj = allocCharArrayBuffer(env, bufferObj, 0);
if (dataObj) { if (dataObj) {
@ -308,44 +296,34 @@ static void nativeCopyStringToBuffer(JNIEnv* env, jclass clazz, jint windowPtr,
CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr);
LOG_WINDOW("Copying string for %d,%d from %p", row, column, window); LOG_WINDOW("Copying string for %d,%d from %p", row, column, window);
field_slot_t* fieldSlot = window->getFieldSlotWithCheck(row, column); CursorWindow::FieldSlot* fieldSlot = window->getFieldSlot(row, column);
if (!fieldSlot) { if (!fieldSlot) {
throwExceptionWithRowCol(env, row, column); throwExceptionWithRowCol(env, row, column);
return; return;
} }
uint8_t type = fieldSlot->type; int32_t type = window->getFieldSlotType(fieldSlot);
if (type == FIELD_TYPE_STRING) { if (type == CursorWindow::FIELD_TYPE_STRING) {
uint32_t size = fieldSlot->data.buffer.size; size_t sizeIncludingNull;
#if WINDOW_STORAGE_UTF8 const char* value = window->getFieldSlotValueString(fieldSlot, &sizeIncludingNull);
if (size > 1) { if (sizeIncludingNull > 1) {
fillCharArrayBufferUTF(env, bufferObj, fillCharArrayBufferUTF(env, bufferObj, value, sizeIncludingNull - 1);
window->getFieldSlotValueString(fieldSlot), size - 1);
} else { } else {
clearCharArrayBuffer(env, bufferObj); clearCharArrayBuffer(env, bufferObj);
} }
#else } else if (type == CursorWindow::FIELD_TYPE_INTEGER) {
size_t chars = size / sizeof(char16_t);
if (chars) {
fillCharArrayBuffer(env, bufferObj,
window->getFieldSlotValueString(fieldSlot), chars);
} else {
clearCharArrayBuffer(env, bufferObj);
}
#endif
} else if (type == FIELD_TYPE_INTEGER) {
int64_t value = window->getFieldSlotValueLong(fieldSlot); int64_t value = window->getFieldSlotValueLong(fieldSlot);
char buf[32]; char buf[32];
snprintf(buf, sizeof(buf), "%lld", value); snprintf(buf, sizeof(buf), "%lld", value);
fillCharArrayBufferUTF(env, bufferObj, buf, strlen(buf)); fillCharArrayBufferUTF(env, bufferObj, buf, strlen(buf));
} else if (type == FIELD_TYPE_FLOAT) { } else if (type == CursorWindow::FIELD_TYPE_FLOAT) {
double value = window->getFieldSlotValueDouble(fieldSlot); double value = window->getFieldSlotValueDouble(fieldSlot);
char buf[32]; char buf[32];
snprintf(buf, sizeof(buf), "%g", value); snprintf(buf, sizeof(buf), "%g", value);
fillCharArrayBufferUTF(env, bufferObj, buf, strlen(buf)); fillCharArrayBufferUTF(env, bufferObj, buf, strlen(buf));
} else if (type == FIELD_TYPE_NULL) { } else if (type == CursorWindow::FIELD_TYPE_NULL) {
clearCharArrayBuffer(env, bufferObj); clearCharArrayBuffer(env, bufferObj);
} else if (type == FIELD_TYPE_BLOB) { } else if (type == CursorWindow::FIELD_TYPE_BLOB) {
throw_sqlite3_exception(env, "Unable to convert BLOB to string"); throw_sqlite3_exception(env, "Unable to convert BLOB to string");
} else { } else {
throwUnknownTypeException(env, type); throwUnknownTypeException(env, type);
@ -357,29 +335,24 @@ static jlong nativeGetLong(JNIEnv* env, jclass clazz, jint windowPtr,
CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr);
LOG_WINDOW("Getting long for %d,%d from %p", row, column, window); LOG_WINDOW("Getting long for %d,%d from %p", row, column, window);
field_slot_t* fieldSlot = window->getFieldSlotWithCheck(row, column); CursorWindow::FieldSlot* fieldSlot = window->getFieldSlot(row, column);
if (!fieldSlot) { if (!fieldSlot) {
throwExceptionWithRowCol(env, row, column); throwExceptionWithRowCol(env, row, column);
return 0; return 0;
} }
uint8_t type = fieldSlot->type; int32_t type = window->getFieldSlotType(fieldSlot);
if (type == FIELD_TYPE_INTEGER) { if (type == CursorWindow::FIELD_TYPE_INTEGER) {
return window->getFieldSlotValueLong(fieldSlot); return window->getFieldSlotValueLong(fieldSlot);
} else if (type == FIELD_TYPE_STRING) { } else if (type == CursorWindow::FIELD_TYPE_STRING) {
uint32_t size = fieldSlot->data.buffer.size; size_t sizeIncludingNull;
#if WINDOW_STORAGE_UTF8 const char* value = window->getFieldSlotValueString(fieldSlot, &sizeIncludingNull);
return size > 1 ? strtoll(window->getFieldSlotValueString(fieldSlot), NULL, 0) : 0L; return sizeIncludingNull > 1 ? strtoll(value, NULL, 0) : 0L;
#else } else if (type == CursorWindow::FIELD_TYPE_FLOAT) {
size_t chars = size / sizeof(char16_t);
return chars ? strtoll(String8(window->getFieldSlotValueString(fieldSlot), chars)
.string(), NULL, 0) : 0L;
#endif
} else if (type == FIELD_TYPE_FLOAT) {
return jlong(window->getFieldSlotValueDouble(fieldSlot)); return jlong(window->getFieldSlotValueDouble(fieldSlot));
} else if (type == FIELD_TYPE_NULL) { } else if (type == CursorWindow::FIELD_TYPE_NULL) {
return 0; return 0;
} else if (type == FIELD_TYPE_BLOB) { } else if (type == CursorWindow::FIELD_TYPE_BLOB) {
throw_sqlite3_exception(env, "Unable to convert BLOB to long"); throw_sqlite3_exception(env, "Unable to convert BLOB to long");
return 0; return 0;
} else { } else {
@ -393,29 +366,24 @@ static jdouble nativeGetDouble(JNIEnv* env, jclass clazz, jint windowPtr,
CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr);
LOG_WINDOW("Getting double for %d,%d from %p", row, column, window); LOG_WINDOW("Getting double for %d,%d from %p", row, column, window);
field_slot_t* fieldSlot = window->getFieldSlotWithCheck(row, column); CursorWindow::FieldSlot* fieldSlot = window->getFieldSlot(row, column);
if (!fieldSlot) { if (!fieldSlot) {
throwExceptionWithRowCol(env, row, column); throwExceptionWithRowCol(env, row, column);
return 0.0; return 0.0;
} }
uint8_t type = fieldSlot->type; int32_t type = window->getFieldSlotType(fieldSlot);
if (type == FIELD_TYPE_FLOAT) { if (type == CursorWindow::FIELD_TYPE_FLOAT) {
return window->getFieldSlotValueDouble(fieldSlot); return window->getFieldSlotValueDouble(fieldSlot);
} else if (type == FIELD_TYPE_STRING) { } else if (type == CursorWindow::FIELD_TYPE_STRING) {
uint32_t size = fieldSlot->data.buffer.size; size_t sizeIncludingNull;
#if WINDOW_STORAGE_UTF8 const char* value = window->getFieldSlotValueString(fieldSlot, &sizeIncludingNull);
return size > 1 ? strtod(window->getFieldSlotValueString(fieldSlot), NULL) : 0.0; return sizeIncludingNull > 1 ? strtod(value, NULL) : 0.0;
#else } else if (type == CursorWindow::FIELD_TYPE_INTEGER) {
size_t chars = size / sizeof(char16_t);
return chars ? strtod(String8(window->getFieldSlotValueString(fieldSlot), chars)
.string(), NULL) : 0.0;
#endif
} else if (type == FIELD_TYPE_INTEGER) {
return jdouble(window->getFieldSlotValueLong(fieldSlot)); return jdouble(window->getFieldSlotValueLong(fieldSlot));
} else if (type == FIELD_TYPE_NULL) { } else if (type == CursorWindow::FIELD_TYPE_NULL) {
return 0.0; return 0.0;
} else if (type == FIELD_TYPE_BLOB) { } else if (type == CursorWindow::FIELD_TYPE_BLOB) {
throw_sqlite3_exception(env, "Unable to convert BLOB to double"); throw_sqlite3_exception(env, "Unable to convert BLOB to double");
return 0.0; return 0.0;
} else { } else {
@ -427,82 +395,50 @@ static jdouble nativeGetDouble(JNIEnv* env, jclass clazz, jint windowPtr,
static jboolean nativePutBlob(JNIEnv* env, jclass clazz, jint windowPtr, static jboolean nativePutBlob(JNIEnv* env, jclass clazz, jint windowPtr,
jbyteArray valueObj, jint row, jint column) { jbyteArray valueObj, jint row, jint column) {
CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr);
field_slot_t * fieldSlot = window->getFieldSlotWithCheck(row, column);
if (fieldSlot == NULL) {
LOG_WINDOW(" getFieldSlotWithCheck error ");
return false;
}
jsize len = env->GetArrayLength(valueObj); jsize len = env->GetArrayLength(valueObj);
uint32_t offset = window->alloc(len);
if (!offset) {
LOG_WINDOW("Failed allocating %u bytes", len);
return false;
}
void* value = env->GetPrimitiveArrayCritical(valueObj, NULL); void* value = env->GetPrimitiveArrayCritical(valueObj, NULL);
window->copyIn(offset, static_cast<const uint8_t*>(value), len); status_t status = window->putBlob(row, column, value, len);
env->ReleasePrimitiveArrayCritical(valueObj, value, JNI_ABORT); env->ReleasePrimitiveArrayCritical(valueObj, value, JNI_ABORT);
fieldSlot->type = FIELD_TYPE_BLOB; if (status) {
fieldSlot->data.buffer.offset = offset; LOG_WINDOW("Failed to put blob. error=%d", status);
fieldSlot->data.buffer.size = len; return false;
LOG_WINDOW("%d,%d is BLOB with %u bytes @ %d", row, column, len, offset); }
LOG_WINDOW("%d,%d is BLOB with %u bytes", row, column, len);
return true; return true;
} }
static jboolean nativePutString(JNIEnv* env, jclass clazz, jint windowPtr, static jboolean nativePutString(JNIEnv* env, jclass clazz, jint windowPtr,
jstring valueObj, jint row, jint column) { jstring valueObj, jint row, jint column) {
CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr);
field_slot_t * fieldSlot = window->getFieldSlotWithCheck(row, column);
if (fieldSlot == NULL) {
LOG_WINDOW(" getFieldSlotWithCheck error ");
return false;
}
#if WINDOW_STORAGE_UTF8 size_t sizeIncludingNull = env->GetStringUTFLength(valueObj) + 1;
size_t size = env->GetStringUTFLength(valueObj) + 1;
const char* valueStr = env->GetStringUTFChars(valueObj, NULL); const char* valueStr = env->GetStringUTFChars(valueObj, NULL);
#else
size_t size = env->GetStringLength(valueObj) * sizeof(jchar);
const jchar* valueStr = env->GetStringChars(valueObj, NULL);
#endif
if (!valueStr) { if (!valueStr) {
LOG_WINDOW("value can't be transfer to UTFChars"); LOG_WINDOW("value can't be transferred to UTFChars");
return false; return false;
} }
status_t status = window->putString(row, column, valueStr, sizeIncludingNull);
uint32_t offset = window->alloc(size);
if (!offset) {
LOG_WINDOW("Failed allocating %u bytes", size);
#if WINDOW_STORAGE_UTF8
env->ReleaseStringUTFChars(valueObj, valueStr);
#else
env->ReleaseStringChars(valueObj, valueStr);
#endif
return false;
}
window->copyIn(offset, reinterpret_cast<const uint8_t*>(valueStr), size);
#if WINDOW_STORAGE_UTF8
env->ReleaseStringUTFChars(valueObj, valueStr); env->ReleaseStringUTFChars(valueObj, valueStr);
#else
env->ReleaseStringChars(valueObj, valueStr);
#endif
fieldSlot->type = FIELD_TYPE_STRING; if (status) {
fieldSlot->data.buffer.offset = offset; LOG_WINDOW("Failed to put string. error=%d", status);
fieldSlot->data.buffer.size = size; return false;
LOG_WINDOW("%d,%d is TEXT with %u bytes @ %d", row, column, size, offset); }
LOG_WINDOW("%d,%d is TEXT with %u bytes", row, column, sizeIncludingNull);
return true; return true;
} }
static jboolean nativePutLong(JNIEnv* env, jclass clazz, jint windowPtr, static jboolean nativePutLong(JNIEnv* env, jclass clazz, jint windowPtr,
jlong value, jint row, jint column) { jlong value, jint row, jint column) {
CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr);
if (!window->putLong(row, column, value)) { status_t status = window->putLong(row, column, value);
LOG_WINDOW(" getFieldSlotWithCheck error ");
if (status) {
LOG_WINDOW("Failed to put long. error=%d", status);
return false; return false;
} }
@ -513,8 +449,10 @@ static jboolean nativePutLong(JNIEnv* env, jclass clazz, jint windowPtr,
static jboolean nativePutDouble(JNIEnv* env, jclass clazz, jint windowPtr, static jboolean nativePutDouble(JNIEnv* env, jclass clazz, jint windowPtr,
jdouble value, jint row, jint column) { jdouble value, jint row, jint column) {
CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr);
if (!window->putDouble(row, column, value)) { status_t status = window->putDouble(row, column, value);
LOG_WINDOW(" getFieldSlotWithCheck error ");
if (status) {
LOG_WINDOW("Failed to put double. error=%d", status);
return false; return false;
} }
@ -525,8 +463,10 @@ static jboolean nativePutDouble(JNIEnv* env, jclass clazz, jint windowPtr,
static jboolean nativePutNull(JNIEnv* env, jclass clazz, jint windowPtr, static jboolean nativePutNull(JNIEnv* env, jclass clazz, jint windowPtr,
jint row, jint column) { jint row, jint column) {
CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr);
if (!window->putNull(row, column)) { status_t status = window->putNull(row, column);
LOG_WINDOW(" getFieldSlotWithCheck error ");
if (status) {
LOG_WINDOW("Failed to put null. error=%d", status);
return false; return false;
} }
@ -537,14 +477,14 @@ static jboolean nativePutNull(JNIEnv* env, jclass clazz, jint windowPtr,
static JNINativeMethod sMethods[] = static JNINativeMethod sMethods[] =
{ {
/* name, signature, funcPtr */ /* name, signature, funcPtr */
{ "nativeInitializeEmpty", "(IZ)I", { "nativeCreate", "(Ljava/lang/String;IZ)I",
(void*)nativeInitializeEmpty }, (void*)nativeCreate },
{ "nativeInitializeFromBinder", "(Landroid/os/IBinder;)I", { "nativeCreateFromParcel", "(Landroid/os/Parcel;)I",
(void*)nativeInitializeFromBinder }, (void*)nativeCreateFromParcel },
{ "nativeDispose", "(I)V", { "nativeDispose", "(I)V",
(void*)nativeDispose }, (void*)nativeDispose },
{ "nativeGetBinder", "(I)Landroid/os/IBinder;", { "nativeWriteToParcel", "(ILandroid/os/Parcel;)V",
(void*)nativeGetBinder }, (void*)nativeWriteToParcel },
{ "nativeClear", "(I)V", { "nativeClear", "(I)V",
(void*)nativeClear }, (void*)nativeClear },
{ "nativeGetNumRows", "(I)I", { "nativeGetNumRows", "(I)I",

78
core/jni/android_database_SQLiteQuery.cpp
View File

@ -61,7 +61,8 @@ static jint nativeFillWindow(JNIEnv* env, jclass clazz, jint databasePtr,
window->getNumRows(), window->size(), window->freeSpace()); window->getNumRows(), window->size(), window->freeSpace());
int numColumns = sqlite3_column_count(statement); int numColumns = sqlite3_column_count(statement);
if (!window->setNumColumns(numColumns)) { status_t status = window->setNumColumns(numColumns);
if (status) {
LOGE("Failed to change column count from %d to %d", window->getNumColumns(), numColumns); LOGE("Failed to change column count from %d to %d", window->getNumColumns(), numColumns);
jniThrowException(env, "java/lang/IllegalStateException", "numColumns mismatch"); jniThrowException(env, "java/lang/IllegalStateException", "numColumns mismatch");
return 0; return 0;
@ -88,10 +89,10 @@ static jint nativeFillWindow(JNIEnv* env, jclass clazz, jint databasePtr,
// Allocate a new field directory for the row. This pointer is not reused // Allocate a new field directory for the row. This pointer is not reused
// since it may be possible for it to be relocated on a call to alloc() when // since it may be possible for it to be relocated on a call to alloc() when
// the field data is being allocated. // the field data is being allocated.
field_slot_t* fieldDir = window->allocRow(); status = window->allocRow();
if (!fieldDir) { if (status) {
LOG_WINDOW("Failed allocating fieldDir at startPos %d row %d", LOG_WINDOW("Failed allocating fieldDir at startPos %d row %d, error=%d",
startPos, addedRows); startPos, addedRows, status);
windowFull = true; windowFull = true;
continue; continue;
} }
@ -101,37 +102,28 @@ static jint nativeFillWindow(JNIEnv* env, jclass clazz, jint databasePtr,
int type = sqlite3_column_type(statement, i); int type = sqlite3_column_type(statement, i);
if (type == SQLITE_TEXT) { if (type == SQLITE_TEXT) {
// TEXT data // TEXT data
#if WINDOW_STORAGE_UTF8 const char* text = reinterpret_cast<const char*>(
const uint8_t* text = reinterpret_cast<const uint8_t*>(
sqlite3_column_text(statement, i)); sqlite3_column_text(statement, i));
// SQLite does not include the NULL terminator in size, but does // SQLite does not include the NULL terminator in size, but does
// ensure all strings are NULL terminated, so increase size by // ensure all strings are NULL terminated, so increase size by
// one to make sure we store the terminator. // one to make sure we store the terminator.
size_t size = sqlite3_column_bytes(statement, i) + 1; size_t sizeIncludingNull = sqlite3_column_bytes(statement, i) + 1;
#else status = window->putString(addedRows, i, text, sizeIncludingNull);
const uint8_t* text = reinterpret_cast<const uint8_t*>( if (status) {
sqlite3_column_text16(statement, i)); LOG_WINDOW("Failed allocating %u bytes for text at %d,%d, error=%d",
size_t size = sqlite3_column_bytes16(statement, i); sizeIncludingNull, startPos + addedRows, i, status);
#endif
int offset = window->alloc(size);
if (!offset) {
LOG_WINDOW("Failed allocating %u bytes for text/blob at %d,%d", size,
startPos + addedRows, i);
windowFull = true; windowFull = true;
break; break;
} }
window->copyIn(offset, text, size); LOG_WINDOW("%d,%d is TEXT with %u bytes",
startPos + addedRows, i, sizeIncludingNull);
field_slot_t* fieldSlot = window->getFieldSlot(addedRows, i);
fieldSlot->type = FIELD_TYPE_STRING;
fieldSlot->data.buffer.offset = offset;
fieldSlot->data.buffer.size = size;
LOG_WINDOW("%d,%d is TEXT with %u bytes", startPos + addedRows, i, size);
} else if (type == SQLITE_INTEGER) { } else if (type == SQLITE_INTEGER) {
// INTEGER data // INTEGER data
int64_t value = sqlite3_column_int64(statement, i); int64_t value = sqlite3_column_int64(statement, i);
if (!window->putLong(addedRows, i, value)) { status = window->putLong(addedRows, i, value);
LOG_WINDOW("Failed allocating space for a long in column %d", i); if (status) {
LOG_WINDOW("Failed allocating space for a long in column %d, error=%d",
i, status);
windowFull = true; windowFull = true;
break; break;
} }
@ -139,35 +131,33 @@ static jint nativeFillWindow(JNIEnv* env, jclass clazz, jint databasePtr,
} else if (type == SQLITE_FLOAT) { } else if (type == SQLITE_FLOAT) {
// FLOAT data // FLOAT data
double value = sqlite3_column_double(statement, i); double value = sqlite3_column_double(statement, i);
if (!window->putDouble(addedRows, i, value)) { status = window->putDouble(addedRows, i, value);
LOG_WINDOW("Failed allocating space for a double in column %d", i); if (status) {
LOG_WINDOW("Failed allocating space for a double in column %d, error=%d",
i, status);
windowFull = true; windowFull = true;
break; break;
} }
LOG_WINDOW("%d,%d is FLOAT %lf", startPos + addedRows, i, value); LOG_WINDOW("%d,%d is FLOAT %lf", startPos + addedRows, i, value);
} else if (type == SQLITE_BLOB) { } else if (type == SQLITE_BLOB) {
// BLOB data // BLOB data
uint8_t const * blob = (uint8_t const *)sqlite3_column_blob(statement, i); const void* blob = sqlite3_column_blob(statement, i);
size_t size = sqlite3_column_bytes16(statement, i); size_t size = sqlite3_column_bytes(statement, i);
int offset = window->alloc(size); status = window->putBlob(addedRows, i, blob, size);
if (!offset) { if (status) {
LOG_WINDOW("Failed allocating %u bytes for blob at %d,%d", size, LOG_WINDOW("Failed allocating %u bytes for blob at %d,%d, error=%d",
startPos + addedRows, i); size, startPos + addedRows, i, status);
windowFull = true; windowFull = true;
break; break;
} }
window->copyIn(offset, blob, size); LOG_WINDOW("%d,%d is Blob with %u bytes",
startPos + addedRows, i, size);
field_slot_t* fieldSlot = window->getFieldSlot(addedRows, i);
fieldSlot->type = FIELD_TYPE_BLOB;
fieldSlot->data.buffer.offset = offset;
fieldSlot->data.buffer.size = size;
LOG_WINDOW("%d,%d is Blob with %u bytes @ %d",
startPos + addedRows, i, size, offset);
} else if (type == SQLITE_NULL) { } else if (type == SQLITE_NULL) {
// NULL field // NULL field
if (!window->putNull(addedRows, i)) { status = window->putNull(addedRows, i);
LOG_WINDOW("Failed allocating space for a null in column %d", i); if (status) {
LOG_WINDOW("Failed allocating space for a null in column %d, error=%d",
i, status);
windowFull = true; windowFull = true;
break; break;
} }

299
include/binder/CursorWindow.h
View File

@ -21,18 +21,8 @@
#include <stddef.h> #include <stddef.h>
#include <stdint.h> #include <stdint.h>
#include <binder/IMemory.h> #include <binder/Parcel.h>
#include <utils/RefBase.h> #include <utils/String8.h>
#define DEFAULT_WINDOW_SIZE 4096
#define WINDOW_ALLOCATION_SIZE 4096
#define ROW_SLOT_CHUNK_NUM_ROWS 16
// Row slots are allocated in chunks of ROW_SLOT_CHUNK_NUM_ROWS,
// with an offset after the rows that points to the next chunk
#define ROW_SLOT_CHUNK_SIZE ((ROW_SLOT_CHUNK_NUM_ROWS * sizeof(row_slot_t)) + sizeof(uint32_t))
#if LOG_NDEBUG #if LOG_NDEBUG
@ -46,176 +36,157 @@
#endif #endif
// When defined to true strings are stored as UTF8, otherwise they're UTF16
#define WINDOW_STORAGE_UTF8 1
// When defined to true numberic values are stored inline in the field_slot_t, otherwise they're allocated in the window
#define WINDOW_STORAGE_INLINE_NUMERICS 1
namespace android { namespace android {
typedef struct
{
uint32_t numRows;
uint32_t numColumns;
} window_header_t;
typedef struct
{
uint32_t offset;
} row_slot_t;
typedef struct
{
uint8_t type;
union {
double d;
int64_t l;
struct {
uint32_t offset;
uint32_t size;
} buffer;
} data;
} __attribute__((packed)) field_slot_t;
#define FIELD_TYPE_NULL 0
#define FIELD_TYPE_INTEGER 1
#define FIELD_TYPE_FLOAT 2
#define FIELD_TYPE_STRING 3
#define FIELD_TYPE_BLOB 4
/** /**
* This class stores a set of rows from a database in a buffer. The begining of the * This class stores a set of rows from a database in a buffer. The begining of the
* window has first chunk of row_slot_ts, which are offsets to the row directory, followed by * window has first chunk of RowSlots, which are offsets to the row directory, followed by
* an offset to the next chunk in a linked-list of additional chunk of row_slot_ts in case * an offset to the next chunk in a linked-list of additional chunk of RowSlots in case
* the pre-allocated chunk isn't big enough to refer to all rows. Each row directory has a * the pre-allocated chunk isn't big enough to refer to all rows. Each row directory has a
* field_slot_t per column, which has the size, offset, and type of the data for that field. * FieldSlot per column, which has the size, offset, and type of the data for that field.
* Note that the data types come from sqlite3.h. * Note that the data types come from sqlite3.h.
*
* Strings are stored in UTF-8.
*/ */
class CursorWindow class CursorWindow {
{ CursorWindow(const String8& name, int ashmemFd,
void* data, size_t size, bool readOnly);
public: public:
CursorWindow(size_t maxSize); /* Field types. */
CursorWindow(){} enum {
bool setMemory(const sp<IMemory>&); FIELD_TYPE_NULL = 0,
~CursorWindow(); FIELD_TYPE_INTEGER = 1,
FIELD_TYPE_FLOAT = 2,
FIELD_TYPE_STRING = 3,
FIELD_TYPE_BLOB = 4,
};
bool initBuffer(bool localOnly); /* Opaque type that describes a field slot. */
sp<IMemory> getMemory() {return mMemory;} struct FieldSlot {
private:
int32_t type;
union {
double d;
int64_t l;
struct {
uint32_t offset;
uint32_t size;
} buffer;
} data;
size_t size() {return mSize;} friend class CursorWindow;
uint8_t * data() {return mData;} } __attribute((packed));
uint32_t getNumRows() {return mHeader->numRows;}
uint32_t getNumColumns() {return mHeader->numColumns;}
void freeLastRow() {
if (mHeader->numRows > 0) {
mHeader->numRows--;
}
}
bool setNumColumns(uint32_t numColumns)
{
uint32_t cur = mHeader->numColumns;
if (cur > 0 && cur != numColumns) {
LOGE("Trying to go from %d columns to %d", cur, numColumns);
return false;
}
mHeader->numColumns = numColumns;
return true;
}
int32_t freeSpace(); ~CursorWindow();
void clear(); static status_t create(const String8& name, size_t size, bool localOnly,
CursorWindow** outCursorWindow);
static status_t createFromParcel(Parcel* parcel, CursorWindow** outCursorWindow);
/** status_t writeToParcel(Parcel* parcel);
* Allocate a row slot and its directory. The returned
* pointer points to the begining of the row's directory
* or NULL if there wasn't room. The directory is
* initialied with NULL entries for each field.
*/
field_slot_t * allocRow();
/** inline String8 name() { return mName; }
* Allocate a portion of the window. Returns the offset inline size_t size() { return mSize; }
* of the allocation, or 0 if there isn't enough space. inline size_t freeSpace() { return mSize - mHeader->freeOffset; }
* If aligned is true, the allocation gets 4 byte alignment. inline uint32_t getNumRows() { return mHeader->numRows; }
*/ inline uint32_t getNumColumns() { return mHeader->numColumns; }
uint32_t alloc(size_t size, bool aligned = false);
/** status_t clear();
* Copy data into the window at the given offset. status_t setNumColumns(uint32_t numColumns);
*/
void copyIn(uint32_t offset, uint8_t const * data, size_t size);
void copyIn(uint32_t offset, int64_t data);
void copyIn(uint32_t offset, double data);
void copyOut(uint32_t offset, uint8_t * data, size_t size);
int64_t copyOutLong(uint32_t offset);
double copyOutDouble(uint32_t offset);
bool putLong(unsigned int row, unsigned int col, int64_t value);
bool putDouble(unsigned int row, unsigned int col, double value);
bool putNull(unsigned int row, unsigned int col);
bool getLong(unsigned int row, unsigned int col, int64_t * valueOut);
bool getDouble(unsigned int row, unsigned int col, double * valueOut);
bool getNull(unsigned int row, unsigned int col, bool * valueOut);
uint8_t * offsetToPtr(uint32_t offset) {return mData + offset;}
row_slot_t * allocRowSlot();
row_slot_t * getRowSlot(int row);
/**
* return NULL if Failed to find rowSlot or
* Invalid rowSlot
*/
field_slot_t * getFieldSlotWithCheck(int row, int column);
field_slot_t * getFieldSlot(int row, int column)
{
int fieldDirOffset = getRowSlot(row)->offset;
return ((field_slot_t *)offsetToPtr(fieldDirOffset)) + column;
}
int64_t getFieldSlotValueLong(field_slot_t* fieldSlot) {
#if WINDOW_STORAGE_INLINE_NUMERICS
return fieldSlot->data.l;
#else
return copyOutLong(fieldSlot->data.buffer.offset);
#endif
}
double getFieldSlotValueDouble(field_slot_t* fieldSlot) {
#if WINDOW_STORAGE_INLINE_NUMERICS
return fieldSlot->data.d;
#else
return copyOutDouble(fieldSlot->data.buffer.offset);
#endif
}
#if WINDOW_STORAGE_UTF8
char* getFieldSlotValueString(field_slot_t* fieldSlot) {
return reinterpret_cast<char*>(offsetToPtr(fieldSlot->data.buffer.offset));
}
#else
char16_t* getFieldSlotValueString(field_slot_t* fieldSlot) {
return reinterpret_cast<char16_t*>(offsetToPtr(fieldSlot->data.buffer.offset));
}
#endif
private:
uint8_t * mData;
size_t mSize;
size_t mMaxSize;
window_header_t * mHeader;
sp<IMemory> mMemory;
/** /**
* Offset of the lowest unused data byte in the array. * Allocate a row slot and its directory.
* The row is initialized will null entries for each field.
*/ */
uint32_t mFreeOffset; status_t allocRow();
status_t freeLastRow();
status_t putBlob(uint32_t row, uint32_t column, const void* value, size_t size);
status_t putString(uint32_t row, uint32_t column, const char* value, size_t sizeIncludingNull);
status_t putLong(uint32_t row, uint32_t column, int64_t value);
status_t putDouble(uint32_t row, uint32_t column, double value);
status_t putNull(uint32_t row, uint32_t column);
/**
* Gets the field slot at the specified row and column.
* Returns null if the requested row or column is not in the window.
*/
FieldSlot* getFieldSlot(uint32_t row, uint32_t column);
inline int32_t getFieldSlotType(FieldSlot* fieldSlot) {
return fieldSlot->type;
}
inline int64_t getFieldSlotValueLong(FieldSlot* fieldSlot) {
return fieldSlot->data.l;
}
inline double getFieldSlotValueDouble(FieldSlot* fieldSlot) {
return fieldSlot->data.d;
}
inline const char* getFieldSlotValueString(FieldSlot* fieldSlot,
size_t* outSizeIncludingNull) {
*outSizeIncludingNull = fieldSlot->data.buffer.size;
return static_cast<char*>(offsetToPtr(fieldSlot->data.buffer.offset));
}
inline const void* getFieldSlotValueBlob(FieldSlot* fieldSlot, size_t* outSize) {
*outSize = fieldSlot->data.buffer.size;
return offsetToPtr(fieldSlot->data.buffer.offset);
}
private:
static const size_t ROW_SLOT_CHUNK_NUM_ROWS = 100;
struct Header {
// Offset of the lowest unused byte in the window.
uint32_t freeOffset;
// Offset of the first row slot chunk.
uint32_t firstChunkOffset;
uint32_t numRows;
uint32_t numColumns;
};
struct RowSlot {
uint32_t offset;
};
struct RowSlotChunk {
RowSlot slots[ROW_SLOT_CHUNK_NUM_ROWS];
uint32_t nextChunkOffset;
};
String8 mName;
int mAshmemFd;
void* mData;
size_t mSize;
bool mReadOnly;
Header* mHeader;
inline void* offsetToPtr(uint32_t offset) {
return static_cast<uint8_t*>(mData) + offset;
}
inline uint32_t offsetFromPtr(void* ptr) {
return static_cast<uint8_t*>(ptr) - static_cast<uint8_t*>(mData);
}
/**
* Allocate a portion of the window. Returns the offset
* of the allocation, or 0 if there isn't enough space.
* If aligned is true, the allocation gets 4 byte alignment.
*/
uint32_t alloc(size_t size, bool aligned = false);
RowSlot* getRowSlot(uint32_t row);
RowSlot* allocRowSlot();
status_t putBlobOrString(uint32_t row, uint32_t column,
const void* value, size_t size, int32_t type);
}; };
}; // namespace android }; // namespace android

502
libs/binder/CursorWindow.cpp
View File

@ -19,8 +19,9 @@
#include <utils/Log.h> #include <utils/Log.h>
#include <binder/CursorWindow.h> #include <binder/CursorWindow.h>
#include <binder/MemoryHeapBase.h>
#include <binder/MemoryBase.h> #include <cutils/ashmem.h>
#include <sys/mman.h>
#include <assert.h> #include <assert.h>
#include <string.h> #include <string.h>
@ -28,350 +29,325 @@
namespace android { namespace android {
CursorWindow::CursorWindow(size_t maxSize) : CursorWindow::CursorWindow(const String8& name, int ashmemFd,
mMaxSize(maxSize) void* data, size_t size, bool readOnly) :
{ mName(name), mAshmemFd(ashmemFd), mData(data), mSize(size), mReadOnly(readOnly) {
mHeader = static_cast<Header*>(mData);
} }
bool CursorWindow::setMemory(const sp<IMemory>& memory) CursorWindow::~CursorWindow() {
{ ::munmap(mData, mSize);
mMemory = memory; ::close(mAshmemFd);
mData = (uint8_t *) memory->pointer(); }
if (mData == NULL) {
return false; status_t CursorWindow::create(const String8& name, size_t size, bool localOnly,
CursorWindow** outCursorWindow) {
String8 ashmemName("CursorWindow: ");
ashmemName.append(name);
ashmemName.append(localOnly ? " (local)" : " (remote)");
status_t result;
int ashmemFd = ashmem_create_region(ashmemName.string(), size);
if (ashmemFd < 0) {
result = -errno;
} else {
result = ashmem_set_prot_region(ashmemFd, PROT_READ | PROT_WRITE);
if (result >= 0) {
void* data = ::mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, ashmemFd, 0);
if (data == MAP_FAILED) {
result = -errno;
} else {
result = ashmem_set_prot_region(ashmemFd, PROT_READ);
if (result >= 0) {
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=%d, 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);
} }
mHeader = (window_header_t *) mData; *outCursorWindow = NULL;
return result;
// Make the window read-only
ssize_t size = memory->size();
mSize = size;
mMaxSize = size;
mFreeOffset = size;
LOG_WINDOW("Created CursorWindow from existing IMemory: mFreeOffset = %d, numRows = %d, numColumns = %d, mSize = %d, mMaxSize = %d, mData = %p", mFreeOffset, mHeader->numRows, mHeader->numColumns, mSize, mMaxSize, mData);
return true;
} }
bool CursorWindow::initBuffer(bool localOnly) status_t CursorWindow::createFromParcel(Parcel* parcel, CursorWindow** outCursorWindow) {
{ String8 name = parcel->readString8();
//TODO Use a non-memory dealer mmap region for localOnly
sp<MemoryHeapBase> heap; status_t result;
heap = new MemoryHeapBase(mMaxSize, 0, "CursorWindow"); int ashmemFd = parcel->readFileDescriptor();
if (heap != NULL) { if (ashmemFd == int(BAD_TYPE)) {
mMemory = new MemoryBase(heap, 0, mMaxSize); result = BAD_TYPE;
if (mMemory != NULL) { } else {
mData = (uint8_t *) mMemory->pointer(); ssize_t size = ashmem_get_size_region(ashmemFd);
if (mData) { if (size < 0) {
mHeader = (window_header_t *) mData; result = UNKNOWN_ERROR;
mSize = mMaxSize; } else {
int dupAshmemFd = ::dup(ashmemFd);
// Put the window into a clean state if (dupAshmemFd < 0) {
clear(); result = -errno;
LOG_WINDOW("Created CursorWindow with new MemoryDealer: mFreeOffset = %d, mSize = %d, mMaxSize = %d, mData = %p", mFreeOffset, mSize, mMaxSize, mData); } else {
return true; void* data = ::mmap(NULL, size, PROT_READ, MAP_SHARED, dupAshmemFd, 0);
if (data == MAP_FAILED) {
result = -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=%d, mData=%p",
window->mHeader->freeOffset,
window->mHeader->numRows,
window->mHeader->numColumns,
window->mSize, window->mData);
*outCursorWindow = window;
return OK;
}
::close(dupAshmemFd);
} }
} }
LOGE("CursorWindow heap allocation failed");
return false;
} else {
LOGE("failed to create the CursorWindow heap");
return false;
} }
*outCursorWindow = NULL;
return result;
} }
CursorWindow::~CursorWindow() status_t CursorWindow::writeToParcel(Parcel* parcel) {
{ status_t status = parcel->writeString8(mName);
// Everything that matters is a smart pointer if (!status) {
status = parcel->writeDupFileDescriptor(mAshmemFd);
}
return status;
} }
void CursorWindow::clear() status_t CursorWindow::clear() {
{ if (mReadOnly) {
return INVALID_OPERATION;
}
mHeader->freeOffset = sizeof(Header) + sizeof(RowSlotChunk);
mHeader->firstChunkOffset = sizeof(Header);
mHeader->numRows = 0; mHeader->numRows = 0;
mHeader->numColumns = 0; mHeader->numColumns = 0;
mFreeOffset = sizeof(window_header_t) + ROW_SLOT_CHUNK_SIZE;
// Mark the first chunk's next 'pointer' as null RowSlotChunk* firstChunk = static_cast<RowSlotChunk*>(offsetToPtr(mHeader->firstChunkOffset));
*((uint32_t *)(mData + mFreeOffset - sizeof(uint32_t))) = 0; firstChunk->nextChunkOffset = 0;
return OK;
} }
int32_t CursorWindow::freeSpace() status_t CursorWindow::setNumColumns(uint32_t numColumns) {
{ if (mReadOnly) {
int32_t freeSpace = mSize - mFreeOffset; return INVALID_OPERATION;
if (freeSpace < 0) {
freeSpace = 0;
} }
return freeSpace;
uint32_t cur = mHeader->numColumns;
if ((cur > 0 || mHeader->numRows > 0) && cur != numColumns) {
LOGE("Trying to go from %d columns to %d", cur, numColumns);
return INVALID_OPERATION;
}
mHeader->numColumns = numColumns;
return OK;
} }
field_slot_t * CursorWindow::allocRow() status_t CursorWindow::allocRow() {
{ if (mReadOnly) {
return INVALID_OPERATION;
}
// Fill in the row slot // Fill in the row slot
row_slot_t * rowSlot = allocRowSlot(); RowSlot* rowSlot = allocRowSlot();
if (rowSlot == NULL) { if (rowSlot == NULL) {
return NULL; return NO_MEMORY;
} }
// Allocate the slots for the field directory // Allocate the slots for the field directory
size_t fieldDirSize = mHeader->numColumns * sizeof(field_slot_t); size_t fieldDirSize = mHeader->numColumns * sizeof(FieldSlot);
uint32_t fieldDirOffset = alloc(fieldDirSize); uint32_t fieldDirOffset = alloc(fieldDirSize, true /*aligned*/);
if (!fieldDirOffset) { if (!fieldDirOffset) {
mHeader->numRows--; mHeader->numRows--;
LOG_WINDOW("The row failed, so back out the new row accounting from allocRowSlot %d", mHeader->numRows); LOG_WINDOW("The row failed, so back out the new row accounting "
return NULL; "from allocRowSlot %d", mHeader->numRows);
return NO_MEMORY;
} }
field_slot_t * fieldDir = (field_slot_t *)offsetToPtr(fieldDirOffset); FieldSlot* fieldDir = static_cast<FieldSlot*>(offsetToPtr(fieldDirOffset));
memset(fieldDir, 0x0, fieldDirSize); memset(fieldDir, 0, fieldDirSize);
LOG_WINDOW("Allocated row %u, rowSlot is at offset %u, fieldDir is %d bytes at offset %u\n", (mHeader->numRows - 1), ((uint8_t *)rowSlot) - mData, fieldDirSize, fieldDirOffset); LOG_WINDOW("Allocated row %u, rowSlot is at offset %u, fieldDir is %d bytes at offset %u\n",
mHeader->numRows - 1, offsetFromPtr(rowSlot), fieldDirSize, fieldDirOffset);
rowSlot->offset = fieldDirOffset; rowSlot->offset = fieldDirOffset;
return OK;
return fieldDir;
} }
uint32_t CursorWindow::alloc(size_t requestedSize, bool aligned) status_t CursorWindow::freeLastRow() {
{ if (mReadOnly) {
int32_t size; return INVALID_OPERATION;
}
if (mHeader->numRows > 0) {
mHeader->numRows--;
}
return OK;
}
uint32_t CursorWindow::alloc(size_t size, bool aligned) {
uint32_t padding; uint32_t padding;
if (aligned) { if (aligned) {
// 4 byte alignment // 4 byte alignment
padding = 4 - (mFreeOffset & 0x3); padding = (~mHeader->freeOffset + 1) & 3;
} else { } else {
padding = 0; padding = 0;
} }
size = requestedSize + padding; uint32_t offset = mHeader->freeOffset + padding;
uint32_t nextFreeOffset = offset + size;
if (size > freeSpace()) { if (nextFreeOffset > mSize) {
LOGV("need to grow: mSize = %d, size = %d, freeSpace() = %d, numRows = %d", mSize, size, LOGE("Window is full: requested allocation %d bytes, "
freeSpace(), mHeader->numRows); "free space %d bytes, window size %d bytes",
// Only grow the window if the first row doesn't fit size, freeSpace(), mSize);
if (mHeader->numRows > 1) { return 0;
LOGV("not growing since there are already %d row(s), max size %d", mHeader->numRows,
mMaxSize);
return 0;
}
// Find a new size that will fit the allocation
int allocated = mSize - freeSpace();
int newSize = mSize + WINDOW_ALLOCATION_SIZE;
while (size > (newSize - allocated)) {
newSize += WINDOW_ALLOCATION_SIZE;
if (newSize > mMaxSize) {
LOGE("Attempting to grow window beyond max size (%d)", mMaxSize);
return 0;
}
}
LOG_WINDOW("found size %d", newSize);
mSize = newSize;
} }
uint32_t offset = mFreeOffset + padding; mHeader->freeOffset = nextFreeOffset;
mFreeOffset += size;
return offset; return offset;
} }
row_slot_t * CursorWindow::getRowSlot(int row) CursorWindow::RowSlot* CursorWindow::getRowSlot(uint32_t row) {
{ uint32_t chunkPos = row;
LOG_WINDOW("enter getRowSlot current row num %d, this row %d", mHeader->numRows, row); RowSlotChunk* chunk = static_cast<RowSlotChunk*>(
int chunkNum = row / ROW_SLOT_CHUNK_NUM_ROWS; offsetToPtr(mHeader->firstChunkOffset));
int chunkPos = row % ROW_SLOT_CHUNK_NUM_ROWS; while (chunkPos >= ROW_SLOT_CHUNK_NUM_ROWS) {
int chunkPtrOffset = sizeof(window_header_t) + ROW_SLOT_CHUNK_SIZE - sizeof(uint32_t); chunk = static_cast<RowSlotChunk*>(offsetToPtr(chunk->nextChunkOffset));
uint8_t * rowChunk = mData + sizeof(window_header_t); chunkPos -= ROW_SLOT_CHUNK_NUM_ROWS;
for (int i = 0; i < chunkNum; i++) {
rowChunk = offsetToPtr(*((uint32_t *)(mData + chunkPtrOffset)));
chunkPtrOffset = rowChunk - mData + (ROW_SLOT_CHUNK_NUM_ROWS * sizeof(row_slot_t));
} }
return (row_slot_t *)(rowChunk + (chunkPos * sizeof(row_slot_t))); return &chunk->slots[chunkPos];
LOG_WINDOW("exit getRowSlot current row num %d, this row %d", mHeader->numRows, row);
} }
row_slot_t * CursorWindow::allocRowSlot() CursorWindow::RowSlot* CursorWindow::allocRowSlot() {
{ uint32_t chunkPos = mHeader->numRows;
int chunkNum = mHeader->numRows / ROW_SLOT_CHUNK_NUM_ROWS; RowSlotChunk* chunk = static_cast<RowSlotChunk*>(
int chunkPos = mHeader->numRows % ROW_SLOT_CHUNK_NUM_ROWS; offsetToPtr(mHeader->firstChunkOffset));
int chunkPtrOffset = sizeof(window_header_t) + ROW_SLOT_CHUNK_SIZE - sizeof(uint32_t); while (chunkPos > ROW_SLOT_CHUNK_NUM_ROWS) {
uint8_t * rowChunk = mData + sizeof(window_header_t); chunk = static_cast<RowSlotChunk*>(offsetToPtr(chunk->nextChunkOffset));
LOG_WINDOW("Allocating row slot, mHeader->numRows is %d, chunkNum is %d, chunkPos is %d", mHeader->numRows, chunkNum, chunkPos); chunkPos -= ROW_SLOT_CHUNK_NUM_ROWS;
for (int i = 0; i < chunkNum; i++) { }
uint32_t nextChunkOffset = *((uint32_t *)(mData + chunkPtrOffset)); if (chunkPos == ROW_SLOT_CHUNK_NUM_ROWS) {
LOG_WINDOW("nextChunkOffset is %d", nextChunkOffset); if (!chunk->nextChunkOffset) {
if (nextChunkOffset == 0) { chunk->nextChunkOffset = alloc(sizeof(RowSlotChunk), true /*aligned*/);
// Allocate a new row chunk if (!chunk->nextChunkOffset) {
nextChunkOffset = alloc(ROW_SLOT_CHUNK_SIZE, true);
if (nextChunkOffset == 0) {
return NULL; return NULL;
} }
rowChunk = offsetToPtr(nextChunkOffset);
LOG_WINDOW("allocated new chunk at %d, rowChunk = %p", nextChunkOffset, rowChunk);
*((uint32_t *)(mData + chunkPtrOffset)) = rowChunk - mData;
// Mark the new chunk's next 'pointer' as null
*((uint32_t *)(rowChunk + ROW_SLOT_CHUNK_SIZE - sizeof(uint32_t))) = 0;
} else {
LOG_WINDOW("follwing 'pointer' to next chunk, offset of next pointer is %d", chunkPtrOffset);
rowChunk = offsetToPtr(nextChunkOffset);
chunkPtrOffset = rowChunk - mData + (ROW_SLOT_CHUNK_NUM_ROWS * sizeof(row_slot_t));
} }
chunk = static_cast<RowSlotChunk*>(offsetToPtr(chunk->nextChunkOffset));
chunk->nextChunkOffset = 0;
chunkPos = 0;
} }
mHeader->numRows++; mHeader->numRows += 1;
return &chunk->slots[chunkPos];
return (row_slot_t *)(rowChunk + (chunkPos * sizeof(row_slot_t)));
} }
field_slot_t * CursorWindow::getFieldSlotWithCheck(int row, int column) CursorWindow::FieldSlot* CursorWindow::getFieldSlot(uint32_t row, uint32_t column) {
{ if (row >= mHeader->numRows || column >= mHeader->numColumns) {
if (row < 0 || row >= mHeader->numRows || column < 0 || column >= mHeader->numColumns) { LOGE("Failed to read row %d, column %d from a CursorWindow which "
LOGE("Failed to read row# %d, column# from a CursorWindow which has %d rows, %d columns.", "has %d rows, %d columns.",
row, column, mHeader->numRows, mHeader->numColumns); row, column, mHeader->numRows, mHeader->numColumns);
return NULL; return NULL;
} }
row_slot_t * rowSlot = getRowSlot(row); RowSlot* rowSlot = getRowSlot(row);
if (!rowSlot) { if (!rowSlot) {
LOGE("Failed to find rowSlot for row %d", row); LOGE("Failed to find rowSlot for row %d.", row);
return NULL; return NULL;
} }
if (rowSlot->offset == 0 || rowSlot->offset >= mSize) { FieldSlot* fieldDir = static_cast<FieldSlot*>(offsetToPtr(rowSlot->offset));
LOGE("Invalid rowSlot, offset = %d", rowSlot->offset); return &fieldDir[column];
return NULL;
}
int fieldDirOffset = rowSlot->offset;
return ((field_slot_t *)offsetToPtr(fieldDirOffset)) + column;
} }
void CursorWindow::copyIn(uint32_t offset, uint8_t const * data, size_t size) 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);
assert(offset + size <= mSize);
memcpy(mData + offset, data, size);
} }
void CursorWindow::copyIn(uint32_t offset, int64_t data) status_t CursorWindow::putString(uint32_t row, uint32_t column, const char* value,
{ size_t sizeIncludingNull) {
assert(offset + sizeof(int64_t) <= mSize); return putBlobOrString(row, column, value, sizeIncludingNull, FIELD_TYPE_STRING);
memcpy(mData + offset, (uint8_t *)&data, sizeof(int64_t));
} }
void CursorWindow::copyIn(uint32_t offset, double data) status_t CursorWindow::putBlobOrString(uint32_t row, uint32_t column,
{ const void* value, size_t size, int32_t type) {
assert(offset + sizeof(double) <= mSize); if (mReadOnly) {
memcpy(mData + offset, (uint8_t *)&data, sizeof(double)); return INVALID_OPERATION;
} }
void CursorWindow::copyOut(uint32_t offset, uint8_t * data, size_t size) FieldSlot* fieldSlot = getFieldSlot(row, column);
{
assert(offset + size <= mSize);
memcpy(data, mData + offset, size);
}
int64_t CursorWindow::copyOutLong(uint32_t offset)
{
int64_t value;
assert(offset + sizeof(int64_t) <= mSize);
memcpy(&value, mData + offset, sizeof(int64_t));
return value;
}
double CursorWindow::copyOutDouble(uint32_t offset)
{
double value;
assert(offset + sizeof(double) <= mSize);
memcpy(&value, mData + offset, sizeof(double));
return value;
}
bool CursorWindow::putLong(unsigned int row, unsigned int col, int64_t value)
{
field_slot_t * fieldSlot = getFieldSlotWithCheck(row, col);
if (!fieldSlot) { if (!fieldSlot) {
return false; return BAD_VALUE;
} }
#if WINDOW_STORAGE_INLINE_NUMERICS uint32_t offset = alloc(size);
fieldSlot->data.l = value;
#else
int offset = alloc(sizeof(int64_t));
if (!offset) { if (!offset) {
return false; return NO_MEMORY;
} }
copyIn(offset, value); memcpy(offsetToPtr(offset), value, size);
fieldSlot->type = type;
fieldSlot->data.buffer.offset = offset; fieldSlot->data.buffer.offset = offset;
fieldSlot->data.buffer.size = sizeof(int64_t); fieldSlot->data.buffer.size = size;
#endif 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->type = FIELD_TYPE_INTEGER;
return true; fieldSlot->data.l = value;
return OK;
} }
bool CursorWindow::putDouble(unsigned int row, unsigned int col, double value) status_t CursorWindow::putDouble(uint32_t row, uint32_t column, double value) {
{ if (mReadOnly) {
field_slot_t * fieldSlot = getFieldSlotWithCheck(row, col); return INVALID_OPERATION;
}
FieldSlot* fieldSlot = getFieldSlot(row, column);
if (!fieldSlot) { if (!fieldSlot) {
return false; return BAD_VALUE;
} }
#if WINDOW_STORAGE_INLINE_NUMERICS
fieldSlot->data.d = value;
#else
int offset = alloc(sizeof(int64_t));
if (!offset) {
return false;
}
copyIn(offset, value);
fieldSlot->data.buffer.offset = offset;
fieldSlot->data.buffer.size = sizeof(double);
#endif
fieldSlot->type = FIELD_TYPE_FLOAT; fieldSlot->type = FIELD_TYPE_FLOAT;
return true; fieldSlot->data.d = value;
return OK;
} }
bool CursorWindow::putNull(unsigned int row, unsigned int col) status_t CursorWindow::putNull(uint32_t row, uint32_t column) {
{ if (mReadOnly) {
field_slot_t * fieldSlot = getFieldSlotWithCheck(row, col); return INVALID_OPERATION;
}
FieldSlot* fieldSlot = getFieldSlot(row, column);
if (!fieldSlot) { if (!fieldSlot) {
return false; return BAD_VALUE;
} }
fieldSlot->type = FIELD_TYPE_NULL; fieldSlot->type = FIELD_TYPE_NULL;
fieldSlot->data.buffer.offset = 0; fieldSlot->data.buffer.offset = 0;
fieldSlot->data.buffer.size = 0; fieldSlot->data.buffer.size = 0;
return true; return OK;
}
bool CursorWindow::getLong(unsigned int row, unsigned int col, int64_t * valueOut)
{
field_slot_t * fieldSlot = getFieldSlotWithCheck(row, col);
if (!fieldSlot || fieldSlot->type != FIELD_TYPE_INTEGER) {
return false;
}
*valueOut = getFieldSlotValueLong(fieldSlot);
return true;
}
bool CursorWindow::getDouble(unsigned int row, unsigned int col, double * valueOut)
{
field_slot_t * fieldSlot = getFieldSlotWithCheck(row, col);
if (!fieldSlot || fieldSlot->type != FIELD_TYPE_FLOAT) {
return false;
}
*valueOut = getFieldSlotValueDouble(fieldSlot);
return true;
}
bool CursorWindow::getNull(unsigned int row, unsigned int col, bool * valueOut)
{
field_slot_t * fieldSlot = getFieldSlotWithCheck(row, col);
if (!fieldSlot) {
return false;
}
if (fieldSlot->type != FIELD_TYPE_NULL) {
*valueOut = false;
} else {
*valueOut = true;
}
return true;
} }
}; // namespace android }; // namespace android

4
libs/binder/Parcel.cpp
View File

@ -752,7 +752,7 @@ status_t Parcel::writeBlob(size_t len, WritableBlob* outBlob)
int result = ashmem_set_prot_region(fd, PROT_READ | PROT_WRITE); int result = ashmem_set_prot_region(fd, PROT_READ | PROT_WRITE);
if (result < 0) { if (result < 0) {
status = -result; status = result;
} else { } else {
void* ptr = ::mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); void* ptr = ::mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
if (ptr == MAP_FAILED) { if (ptr == MAP_FAILED) {
@ -760,7 +760,7 @@ status_t Parcel::writeBlob(size_t len, WritableBlob* outBlob)
} else { } else {
result = ashmem_set_prot_region(fd, PROT_READ); result = ashmem_set_prot_region(fd, PROT_READ);
if (result < 0) { if (result < 0) {
status = -result; status = result;
} else { } else {
status = writeInt32(1); status = writeInt32(1);
if (!status) { if (!status) {