| /* |
| * Copyright (C) 2008 Google Inc. |
| * |
| * 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. |
| */ |
| |
| package com.android.hit; |
| |
| import java.io.ByteArrayOutputStream; |
| import java.io.DataInputStream; |
| import java.io.InputStream; |
| import java.io.EOFException; |
| import java.io.IOException; |
| import java.util.HashMap; |
| |
| public class HprofParser |
| { |
| private static final int STRING_IN_UTF8 = 0x01; |
| private static final int LOAD_CLASS = 0x02; |
| private static final int UNLOAD_CLASS = 0x03; // unused |
| private static final int STACK_FRAME = 0x04; |
| private static final int STACK_TRACE = 0x05; |
| private static final int ALLOC_SITES = 0x06; // unused |
| private static final int HEAP_SUMMARY = 0x07; |
| private static final int START_THREAD = 0x0a; // unused |
| private static final int END_THREAD = 0x0b; // unused |
| private static final int HEAP_DUMP = 0x0c; |
| private static final int HEAP_DUMP_SEGMENT = 0x1c; |
| private static final int HEAP_DUMP_END = 0x2c; |
| private static final int CPU_SAMPLES = 0x0d; // unused |
| private static final int CONTROL_SETTINGS = 0x0e; // unused |
| |
| private static final int ROOT_UNKNOWN = 0xff; |
| private static final int ROOT_JNI_GLOBAL = 0x01; |
| private static final int ROOT_JNI_LOCAL = 0x02; |
| private static final int ROOT_JAVA_FRAME = 0x03; |
| private static final int ROOT_NATIVE_STACK = 0x04; |
| private static final int ROOT_STICKY_CLASS = 0x05; |
| private static final int ROOT_THREAD_BLOCK = 0x06; |
| private static final int ROOT_MONITOR_USED = 0x07; |
| private static final int ROOT_THREAD_OBJECT = 0x08; |
| private static final int ROOT_CLASS_DUMP = 0x20; |
| private static final int ROOT_INSTANCE_DUMP = 0x21; |
| private static final int ROOT_OBJECT_ARRAY_DUMP = 0x22; |
| private static final int ROOT_PRIMITIVE_ARRAY_DUMP = 0x23; |
| |
| /** |
| * Android format addition |
| * |
| * Specifies information about which heap certain objects came from. |
| * When a sub-tag of this type appears in a HPROF_HEAP_DUMP or |
| * HPROF_HEAP_DUMP_SEGMENT record, entries that follow it will be |
| * associated with the specified heap. The HEAP_DUMP_INFO data is reset |
| * at the end of the HEAP_DUMP[_SEGMENT]. Multiple HEAP_DUMP_INFO entries |
| * may appear in a single HEAP_DUMP[_SEGMENT]. |
| * |
| * Format: |
| * u1: Tag value (0xFE) |
| * u4: heap ID |
| * ID: heap name string ID |
| */ |
| private static final int ROOT_HEAP_DUMP_INFO = 0xfe; |
| private static final int ROOT_INTERNED_STRING = 0x89; |
| private static final int ROOT_FINALIZING = 0x8a; |
| private static final int ROOT_DEBUGGER = 0x8b; |
| private static final int ROOT_REFERENCE_CLEANUP = 0x8c; |
| private static final int ROOT_VM_INTERNAL = 0x8d; |
| private static final int ROOT_JNI_MONITOR = 0x8e; |
| private static final int ROOT_UNREACHABLE = 0x90; |
| private static final int ROOT_PRIMITIVE_ARRAY_NODATA= 0xc3; |
| |
| DataInputStream mInput; |
| int mIdSize; |
| State mState; |
| |
| byte[] mFieldBuffer = new byte[8]; |
| |
| /* |
| * These are only needed while parsing so are not kept as part of the |
| * heap data. |
| */ |
| HashMap<Long, String> mStrings = new HashMap<Long, String>(); |
| HashMap<Long, String> mClassNames = new HashMap<Long, String>(); |
| |
| public HprofParser(DataInputStream in) { |
| mInput = in; |
| } |
| |
| public final State parse() { |
| State state = new State(); |
| mState = state; |
| |
| try { |
| String s = readNullTerminatedString(); |
| DataInputStream in = mInput; |
| |
| mIdSize = in.readInt(); |
| Types.setIdSize(mIdSize); |
| |
| in.readLong(); // Timestamp, ignored for now |
| |
| while (true) { |
| int tag = in.readUnsignedByte(); |
| int timestamp = in.readInt(); |
| int length = in.readInt(); |
| |
| switch (tag) { |
| case STRING_IN_UTF8: |
| loadString(length - 4); |
| break; |
| |
| case LOAD_CLASS: |
| loadClass(); |
| break; |
| |
| case STACK_FRAME: |
| loadStackFrame(); |
| break; |
| |
| case STACK_TRACE: |
| loadStackTrace(); |
| break; |
| |
| case HEAP_DUMP: |
| loadHeapDump(length); |
| mState.setToDefaultHeap(); |
| break; |
| |
| case HEAP_DUMP_SEGMENT: |
| loadHeapDump(length); |
| mState.setToDefaultHeap(); |
| break; |
| |
| default: |
| skipFully(length); |
| } |
| |
| } |
| } catch (EOFException eof) { |
| // this is fine |
| } catch (Exception e) { |
| e.printStackTrace(); |
| } |
| |
| mState.resolveReferences(); |
| |
| return state; |
| } |
| |
| private String readNullTerminatedString() throws IOException { |
| StringBuilder s = new StringBuilder(); |
| DataInputStream in = mInput; |
| |
| for (int c = in.read(); c != 0; c = in.read()) { |
| s.append((char) c); |
| } |
| |
| return s.toString(); |
| } |
| |
| private long readId() throws IOException { |
| switch (mIdSize) { |
| case 1: return mInput.readUnsignedByte(); |
| case 2: return mInput.readUnsignedShort(); |
| case 4: return ((long) mInput.readInt()) & 0x00000000ffffffffL; |
| case 8: return mInput.readLong(); |
| } |
| |
| throw new IllegalArgumentException("ID Length must be 1, 2, 4, or 8"); |
| } |
| |
| private String readUTF8(int length) throws IOException { |
| byte[] b = new byte[length]; |
| |
| mInput.read(b); |
| |
| return new String(b, "utf-8"); |
| } |
| |
| private void loadString(int length) throws IOException { |
| long id = readId(); |
| String string = readUTF8(length); |
| |
| mStrings.put(id, string); |
| } |
| |
| private void loadClass() throws IOException { |
| DataInputStream in = mInput; |
| int serial = in.readInt(); |
| long id = readId(); |
| int stackTrace = in.readInt(); // unused |
| String name = mStrings.get(readId()); |
| |
| mClassNames.put(id, name); |
| } |
| |
| private void loadStackFrame() throws IOException { |
| long id = readId(); |
| String methodName = mStrings.get(readId()); |
| String methodSignature = mStrings.get(readId()); |
| String sourceFile = mStrings.get(readId()); |
| int serial = mInput.readInt(); |
| int lineNumber = mInput.readInt(); |
| |
| StackFrame frame = new StackFrame(id, methodName, methodSignature, |
| sourceFile, serial, lineNumber); |
| |
| mState.addStackFrame(frame); |
| } |
| |
| private void loadStackTrace() throws IOException { |
| int serialNumber = mInput.readInt(); |
| int threadSerialNumber = mInput.readInt(); |
| final int numFrames = mInput.readInt(); |
| StackFrame[] frames = new StackFrame[numFrames]; |
| |
| for (int i = 0; i < numFrames; i++) { |
| frames[i] = mState.getStackFrame(readId()); |
| } |
| |
| StackTrace trace = new StackTrace(serialNumber, threadSerialNumber, |
| frames); |
| |
| mState.addStackTrace(trace); |
| } |
| |
| private void loadHeapDump(int length) throws IOException { |
| DataInputStream in = mInput; |
| |
| while (length > 0) { |
| int tag = in.readUnsignedByte(); |
| length--; |
| |
| switch (tag) { |
| case ROOT_UNKNOWN: |
| length -= loadBasicObj(RootType.UNKNOWN); |
| break; |
| |
| case ROOT_JNI_GLOBAL: |
| length -= loadBasicObj(RootType.NATIVE_STATIC); |
| readId(); // ignored |
| length -= mIdSize; |
| break; |
| |
| case ROOT_JNI_LOCAL: |
| length -= loadJniLocal(); |
| break; |
| |
| case ROOT_JAVA_FRAME: |
| length -= loadJavaFrame(); |
| break; |
| |
| case ROOT_NATIVE_STACK: |
| length -= loadNativeStack(); |
| break; |
| |
| case ROOT_STICKY_CLASS: |
| length -= loadBasicObj(RootType.SYSTEM_CLASS); |
| break; |
| |
| case ROOT_THREAD_BLOCK: |
| length -= loadThreadBlock(); |
| break; |
| |
| case ROOT_MONITOR_USED: |
| length -= loadBasicObj(RootType.BUSY_MONITOR); |
| break; |
| |
| case ROOT_THREAD_OBJECT: |
| length -= loadThreadObject(); |
| break; |
| |
| case ROOT_CLASS_DUMP: |
| length -= loadClassDump(); |
| break; |
| |
| case ROOT_INSTANCE_DUMP: |
| length -= loadInstanceDump(); |
| break; |
| |
| case ROOT_OBJECT_ARRAY_DUMP: |
| length -= loadObjectArrayDump(); |
| break; |
| |
| case ROOT_PRIMITIVE_ARRAY_DUMP: |
| length -= loadPrimitiveArrayDump(); |
| break; |
| |
| case ROOT_PRIMITIVE_ARRAY_NODATA: |
| System.err.println("+--- PRIMITIVE ARRAY NODATA DUMP"); |
| length -= loadPrimitiveArrayDump(); |
| |
| throw new IllegalArgumentException( |
| "Don't know how to load a nodata array"); |
| |
| case ROOT_HEAP_DUMP_INFO: |
| int heapId = mInput.readInt(); |
| long heapNameId = readId(); |
| String heapName = mStrings.get(heapNameId); |
| |
| mState.setHeapTo(heapId, heapName); |
| length -= 4 + mIdSize; |
| break; |
| |
| case ROOT_INTERNED_STRING: |
| length -= loadBasicObj(RootType.INTERNED_STRING); |
| break; |
| |
| case ROOT_FINALIZING: |
| length -= loadBasicObj(RootType.FINALIZING); |
| break; |
| |
| case ROOT_DEBUGGER: |
| length -= loadBasicObj(RootType.DEBUGGER); |
| break; |
| |
| case ROOT_REFERENCE_CLEANUP: |
| length -= loadBasicObj(RootType.REFERENCE_CLEANUP); |
| break; |
| |
| case ROOT_VM_INTERNAL: |
| length -= loadBasicObj(RootType.VM_INTERNAL); |
| break; |
| |
| case ROOT_JNI_MONITOR: |
| length -= loadJniMonitor(); |
| break; |
| |
| case ROOT_UNREACHABLE: |
| length -= loadBasicObj(RootType.UNREACHABLE); |
| break; |
| |
| default: |
| throw new IllegalArgumentException( |
| "loadHeapDump loop with unknown tag " + tag |
| + " with " + mInput.available() |
| + " bytes possibly remaining"); |
| } |
| } |
| } |
| |
| private int loadJniLocal() throws IOException { |
| long id = readId(); |
| int threadSerialNumber = mInput.readInt(); |
| int stackFrameNumber = mInput.readInt(); |
| ThreadObj thread = mState.getThread(threadSerialNumber); |
| StackTrace trace = mState.getStackTraceAtDepth(thread.mStackTrace, |
| stackFrameNumber); |
| RootObj root = new RootObj(RootType.NATIVE_LOCAL, id, |
| threadSerialNumber, trace); |
| |
| root.setHeap(mState.mCurrentHeap); |
| mState.addRoot(root); |
| |
| return mIdSize + 4 + 4; |
| } |
| |
| private int loadJavaFrame() throws IOException { |
| long id = readId(); |
| int threadSerialNumber = mInput.readInt(); |
| int stackFrameNumber = mInput.readInt(); |
| ThreadObj thread = mState.getThread(threadSerialNumber); |
| StackTrace trace = mState.getStackTraceAtDepth(thread.mStackTrace, |
| stackFrameNumber); |
| RootObj root = new RootObj(RootType.JAVA_LOCAL, id, threadSerialNumber, |
| trace); |
| |
| root.setHeap(mState.mCurrentHeap); |
| mState.addRoot(root); |
| |
| return mIdSize + 4 + 4; |
| } |
| |
| private int loadNativeStack() throws IOException { |
| long id = readId(); |
| int threadSerialNumber = mInput.readInt(); |
| ThreadObj thread = mState.getThread(threadSerialNumber); |
| StackTrace trace = mState.getStackTrace(thread.mStackTrace); |
| RootObj root = new RootObj(RootType.NATIVE_STACK, id, |
| threadSerialNumber, trace); |
| |
| root.setHeap(mState.mCurrentHeap); |
| mState.addRoot(root); |
| |
| return mIdSize + 4; |
| } |
| |
| private int loadBasicObj(RootType type) throws IOException { |
| long id = readId(); |
| RootObj root = new RootObj(type, id); |
| |
| root.setHeap(mState.mCurrentHeap); |
| mState.addRoot(root); |
| |
| return mIdSize; |
| } |
| |
| private int loadThreadBlock() throws IOException { |
| long id = readId(); |
| int threadSerialNumber = mInput.readInt(); |
| ThreadObj thread = mState.getThread(threadSerialNumber); |
| StackTrace stack = mState.getStackTrace(thread.mStackTrace); |
| RootObj root = new RootObj(RootType.THREAD_BLOCK, id, |
| threadSerialNumber, stack); |
| |
| root.setHeap(mState.mCurrentHeap); |
| mState.addRoot(root); |
| |
| return mIdSize + 4; |
| } |
| |
| private int loadThreadObject() throws IOException { |
| long id = readId(); |
| int threadSerialNumber = mInput.readInt(); |
| int stackSerialNumber = mInput.readInt(); |
| ThreadObj thread = new ThreadObj(id, stackSerialNumber); |
| |
| mState.addThread(thread, threadSerialNumber); |
| |
| return mIdSize + 4 + 4; |
| } |
| |
| private int loadClassDump() throws IOException { |
| int bytesRead = 0; |
| DataInputStream in = mInput; |
| long id = readId(); |
| int stackSerialNumber = in.readInt(); |
| StackTrace stack = mState.getStackTrace(stackSerialNumber); |
| long superClassId = readId(); |
| long classLoaderId = readId(); |
| long signersId = readId(); |
| long protectionDomainId = readId(); |
| long reserved1 = readId(); |
| long reserved2 = readId(); |
| int instanceSize = in.readInt(); |
| |
| bytesRead = (7 * mIdSize) + 4 + 4; |
| |
| // Skip over the constant pool |
| int numEntries = in.readUnsignedShort(); |
| bytesRead += 2; |
| |
| for (int i = 0; i < numEntries; i++) { |
| in.readUnsignedShort(); |
| bytesRead += 2 + skipValue(); |
| } |
| |
| // Static fields |
| numEntries = in.readUnsignedShort(); |
| bytesRead += 2; |
| |
| String[] staticFieldNames = new String[numEntries]; |
| int[] staticFieldTypes = new int[numEntries]; |
| ByteArrayOutputStream staticFieldValues = new ByteArrayOutputStream(); |
| byte[] buffer = mFieldBuffer; |
| |
| for (int i = 0; i < numEntries; i++) { |
| staticFieldNames[i] = mStrings.get(readId()); |
| |
| int fieldType = in.readByte(); |
| int fieldSize = Types.getTypeSize(fieldType); |
| staticFieldTypes[i] = fieldType; |
| |
| in.readFully(buffer, 0, fieldSize); |
| staticFieldValues.write(buffer, 0, fieldSize); |
| |
| bytesRead += mIdSize + 1 + fieldSize; |
| } |
| |
| // Instance fields |
| numEntries = in.readUnsignedShort(); |
| bytesRead += 2; |
| |
| String[] names = new String[numEntries]; |
| int[] types = new int[numEntries]; |
| |
| for (int i = 0; i < numEntries; i++) { |
| long fieldName = readId(); |
| int type = in.readUnsignedByte(); |
| |
| names[i] = mStrings.get(fieldName); |
| types[i] = type; |
| |
| bytesRead += mIdSize + 1; |
| } |
| |
| ClassObj theClass = new ClassObj(id, stack, mClassNames.get(id)); |
| |
| theClass.setStaticFieldNames(staticFieldNames); |
| theClass.setStaticFieldTypes(staticFieldTypes); |
| theClass.setStaticFieldValues(staticFieldValues.toByteArray()); |
| |
| theClass.setSuperclassId(superClassId); |
| theClass.setFieldNames(names); |
| theClass.setFieldTypes(types); |
| theClass.setSize(instanceSize); |
| |
| theClass.setHeap(mState.mCurrentHeap); |
| |
| mState.addClass(id, theClass); |
| |
| return bytesRead; |
| } |
| |
| private int loadInstanceDump() throws IOException { |
| long id = readId(); |
| int stackId = mInput.readInt(); |
| StackTrace stack = mState.getStackTrace(stackId); |
| long classId = readId(); |
| int remaining = mInput.readInt(); |
| ClassInstance instance = new ClassInstance(id, stack, classId); |
| |
| instance.loadFieldData(mInput, remaining); |
| instance.setHeap(mState.mCurrentHeap); |
| mState.addInstance(id, instance); |
| |
| return mIdSize + 4 + mIdSize + 4 + remaining; |
| } |
| |
| private int loadObjectArrayDump() throws IOException { |
| long id = readId(); |
| int stackId = mInput.readInt(); |
| StackTrace stack = mState.getStackTrace(stackId); |
| int numElements = mInput.readInt(); |
| long classId = readId(); |
| int totalBytes = numElements * mIdSize; |
| byte[] data = new byte[totalBytes]; |
| String className = mClassNames.get(classId); |
| |
| mInput.readFully(data); |
| |
| ArrayInstance array = new ArrayInstance(id, stack, Types.OBJECT, |
| numElements, data); |
| |
| array.mClassId = classId; |
| array.setHeap(mState.mCurrentHeap); |
| mState.addInstance(id, array); |
| |
| return mIdSize + 4 + 4 + mIdSize + totalBytes; |
| } |
| |
| private int loadPrimitiveArrayDump() throws IOException { |
| long id = readId(); |
| int stackId = mInput.readInt(); |
| StackTrace stack = mState.getStackTrace(stackId); |
| int numElements = mInput.readInt(); |
| int type = mInput.readUnsignedByte(); |
| int size = Types.getTypeSize(type); |
| int totalBytes = numElements * size; |
| byte[] data = new byte[totalBytes]; |
| |
| mInput.readFully(data); |
| |
| ArrayInstance array = new ArrayInstance(id, stack, type, numElements, |
| data); |
| |
| array.setHeap(mState.mCurrentHeap); |
| mState.addInstance(id, array); |
| |
| return mIdSize + 4 + 4 + 1 + totalBytes; |
| } |
| |
| private int loadJniMonitor() throws IOException { |
| long id = readId(); |
| int threadSerialNumber = mInput.readInt(); |
| int stackDepth = mInput.readInt(); |
| ThreadObj thread = mState.getThread(threadSerialNumber); |
| StackTrace trace = mState.getStackTraceAtDepth(thread.mStackTrace, |
| stackDepth); |
| RootObj root = new RootObj(RootType.NATIVE_MONITOR, id, |
| threadSerialNumber, trace); |
| |
| root.setHeap(mState.mCurrentHeap); |
| mState.addRoot(root); |
| |
| return mIdSize + 4 + 4; |
| } |
| |
| private int skipValue() throws IOException { |
| int type = mInput.readUnsignedByte(); |
| int size = Types.getTypeSize(type); |
| |
| skipFully(size); |
| |
| return size + 1; |
| } |
| |
| /* |
| * BufferedInputStream will not skip(int) the entire requested number |
| * of bytes if it extends past the current buffer boundary. So, this |
| * routine is needed to actually skip over the requested number of bytes |
| * using as many iterations as needed. |
| */ |
| private void skipFully(long numBytes) throws IOException { |
| while (numBytes > 0) { |
| long skipped = mInput.skip(numBytes); |
| |
| numBytes -= skipped; |
| } |
| } |
| } |
