| /******************************************************************************* |
| * Copyright (c) 2008, 2021 SAP AG, Netflix, IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License 2.0 |
| * which accompanies this distribution, and is available at |
| * https://www.eclipse.org/legal/epl-2.0/ |
| * |
| * SPDX-License-Identifier: EPL-2.0 |
| * |
| * Contributors: |
| * SAP AG - initial API and implementation |
| * Netflix (Jason Koch) - refactors for increased performance and concurrency |
| * IBM Corporation (Andrew Johnson) - compressed dumps |
| *******************************************************************************/ |
| package org.eclipse.mat.hprof; |
| |
| import java.io.EOFException; |
| import java.io.File; |
| import java.io.IOException; |
| import java.io.RandomAccessFile; |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.List; |
| |
| import org.eclipse.mat.SnapshotException; |
| import org.eclipse.mat.hprof.AbstractParser.Constants.Record; |
| import org.eclipse.mat.hprof.describer.Version; |
| import org.eclipse.mat.hprof.ui.HprofPreferences; |
| import org.eclipse.mat.parser.index.IIndexReader.IOne2LongIndex; |
| import org.eclipse.mat.parser.io.BufferedRandomAccessInputStream; |
| import org.eclipse.mat.parser.model.AbstractObjectImpl; |
| import org.eclipse.mat.parser.model.ClassImpl; |
| import org.eclipse.mat.parser.model.ClassLoaderImpl; |
| import org.eclipse.mat.parser.model.InstanceImpl; |
| import org.eclipse.mat.parser.model.ObjectArrayImpl; |
| import org.eclipse.mat.parser.model.PrimitiveArrayImpl; |
| import org.eclipse.mat.snapshot.ISnapshot; |
| import org.eclipse.mat.snapshot.model.Field; |
| import org.eclipse.mat.snapshot.model.FieldDescriptor; |
| import org.eclipse.mat.snapshot.model.IArray; |
| import org.eclipse.mat.snapshot.model.IClass; |
| import org.eclipse.mat.snapshot.model.IObject; |
| import org.eclipse.mat.snapshot.model.IPrimitiveArray; |
| import org.eclipse.mat.snapshot.model.ObjectReference; |
| import org.eclipse.mat.util.MessageUtil; |
| |
| public class HprofRandomAccessParser extends AbstractParser |
| { |
| public static final int LAZY_LOADING_LIMIT = 256; |
| private final IPositionInputStream in; |
| |
| public HprofRandomAccessParser(File file, Version version, int identifierSize, long len, |
| HprofPreferences.HprofStrictness strictnessPreference) throws IOException |
| { |
| super(strictnessPreference); |
| RandomAccessFile raf = new RandomAccessFile(file, "r"); //$NON-NLS-1$ |
| boolean gzip = CompressedRandomAccessFile.isGZIP(raf); |
| if (gzip) |
| { |
| ChunkedGZIPRandomAccessFile cgraf = ChunkedGZIPRandomAccessFile.get(raf, file); |
| raf.close(); |
| |
| if (cgraf != null) |
| { |
| raf = cgraf; |
| } |
| else |
| { |
| long requested = len / 10; |
| long maxFree = CompressedRandomAccessFile.checkMemSpace(requested); |
| // If we are very memory constrained use a file cache |
| if (requested > maxFree && FileCacheCompressedRandomAccessFile.isDiskSpace(file, len)) |
| raf = new FileCacheCompressedRandomAccessFile(file); |
| else |
| raf = new CompressedRandomAccessFile(file, true, len); |
| } |
| } |
| this.in = new DefaultPositionInputStream(new BufferedRandomAccessInputStream(raf, 512)); |
| this.version = version; |
| this.idSize = identifierSize; |
| } |
| |
| public synchronized void close() throws IOException |
| { |
| in.close(); |
| } |
| |
| public synchronized IObject read(int objectId, long position, ISnapshot dump, IOne2LongIndex o2hprof) throws IOException, SnapshotException |
| { |
| in.seek(position); |
| int segmentType = in.readUnsignedByte(); |
| if (objectId == -1) |
| { |
| segmentType = skipRecords(segmentType); |
| } |
| switch (segmentType) |
| { |
| case Constants.DumpSegment.INSTANCE_DUMP: |
| return readInstanceDump(objectId, dump); |
| case Constants.DumpSegment.OBJECT_ARRAY_DUMP: |
| return readObjectArrayDump(objectId, dump); |
| case Constants.DumpSegment.PRIMITIVE_ARRAY_DUMP: |
| return readPrimitiveArrayDump(objectId, dump); |
| default: |
| throw new IOException(MessageUtil.format(Messages.HprofRandomAccessParser_Error_IllegalDumpSegment, |
| segmentType, Long.toHexString(position))); |
| } |
| |
| } |
| |
| public List<IClass> resolveClassHierarchy(ISnapshot snapshot, IClass clazz) throws SnapshotException |
| { |
| List<IClass> answer = new ArrayList<IClass>(); |
| answer.add(clazz); |
| while (clazz.hasSuperClass()) |
| { |
| clazz = (IClass) snapshot.getObject(clazz.getSuperClassId()); |
| if (clazz == null) |
| return null; |
| answer.add(clazz); |
| } |
| |
| return answer; |
| } |
| |
| /** |
| * A reference to an object via its address |
| * which can handle the address not being in the index. |
| */ |
| static class ObjectAddressReference extends ObjectReference |
| { |
| private static final long serialVersionUID = 1L; |
| transient IOne2LongIndex o2hprof; |
| transient ISnapshot snapshot; |
| transient HprofRandomAccessParser parser; |
| /** |
| * Construct an {@link ObjectAddressReference} which can be used to retrieve an |
| * object by address even if it has not been indexed. |
| * Used as a proxy by {@link ObjectReference} which can change the {@link ObjectReference#address} |
| * private field. |
| * @param snapshot the snapshot |
| * @param parser the HPROF parser used to build the IObject if required |
| * @param o2hprof the index from object ID to HPROF file position |
| * @param address the address of the object |
| */ |
| public ObjectAddressReference(ISnapshot snapshot, HprofRandomAccessParser parser, IOne2LongIndex o2hprof, long address) |
| { |
| super(snapshot, address); |
| this.snapshot = snapshot; |
| this.o2hprof = o2hprof; |
| this.parser = parser; |
| } |
| @Override |
| public int getObjectId() throws SnapshotException |
| { |
| try |
| { |
| int id = super.getObjectId(); |
| return id; |
| } |
| catch (SnapshotException e) |
| { |
| return -1; |
| } |
| } |
| /** |
| * Actually construct an IObject. |
| * First try constructing by object ID. |
| * If that fails then construct by address. |
| * Find the indexed objects before and after this. |
| * Parse the HPROF file between these two points looking for an |
| * object of the correct address. |
| */ |
| @Override |
| public IObject getObject() throws SnapshotException |
| { |
| SnapshotException e1 = null; |
| try |
| { |
| int id = super.getObjectId(); |
| if (id >= 0) |
| { |
| IObject o = super.getObject(); |
| return o; |
| } |
| } |
| catch (SnapshotException e) |
| { |
| e1 = e; |
| } |
| // Find the object IDs before and after this object |
| int low = 0; |
| int high = o2hprof.size() - 1; |
| for (;low + 1 < high;) |
| { |
| int mid = (low + high) >>> 1; |
| long midAddr = snapshot.mapIdToAddress(mid); |
| if (getObjectAddress() < midAddr) |
| { |
| high = mid; |
| } |
| else if (getObjectAddress() > midAddr) |
| { |
| low = mid; |
| } |
| else |
| { |
| low = mid; |
| high = mid; |
| } |
| } |
| // Some objects don't have a position (classes?), so find valid file positions |
| long pos = 0; |
| while ((pos = o2hprof.get(low)) == 0 && low > 0) |
| --low; |
| if (pos == 0) |
| { |
| // There might be discarded objects before the first |
| Long lpos = (Long)snapshot.getSnapshotInfo().getProperty(HprofHeapObjectReader.HPROF_HEAP_START); |
| if (lpos != null) |
| pos = lpos; |
| else while ((pos = o2hprof.get(low)) == 0 && low < o2hprof.size() - 1) |
| ++low; |
| } |
| long posHigh = pos; |
| while (high >= 0 && (posHigh = o2hprof.get(high)) == 0 && high < o2hprof.size() - 1) |
| ++high; |
| if (posHigh == 0) |
| { |
| // There might be discarded objects after the last |
| Long olen = (Long)snapshot.getSnapshotInfo().getProperty(HprofHeapObjectReader.HPROF_LENGTH_PROPERTY); |
| posHigh = (olen != null) ? olen : Long.MAX_VALUE; |
| } |
| // Reparse the HPROF file looking for an object of the right address |
| try |
| { |
| do |
| { |
| IObject o; |
| synchronized (parser) |
| { |
| // Need final position without interference |
| o = parser.read(-1, pos, snapshot, o2hprof); |
| pos = parser.in.position(); |
| } |
| if (o.getObjectAddress() == getObjectAddress()) |
| { |
| // Class was discarded from the snapshot |
| if (o.getClazz() == null) |
| throw new IOException(); |
| ((AbstractObjectImpl)o).setSnapshot(snapshot); |
| return o; |
| } |
| // Gone past the object address we want |
| if (o.getObjectAddress() > getObjectAddress()) |
| break; |
| } |
| while (pos < posHigh); |
| } |
| catch (IOException e2) |
| { |
| if (e2 instanceof EOFException) |
| throw e1; |
| throw new SnapshotException(e2); |
| } |
| // Not found, so throw the original exception |
| throw e1; |
| } |
| } |
| |
| private IObject readInstanceDump(int objectId, ISnapshot dump) throws IOException, SnapshotException |
| { |
| long address = in.readID(idSize); |
| IClass oclazz; |
| if (objectId >= 0) |
| { |
| // Skip serial number, class ID, length |
| if (in.skipBytes(8 + idSize) != 8 + idSize) |
| throw new IOException(); |
| oclazz = dump.getClassOf(objectId); |
| } |
| else |
| { |
| // skip serial number |
| if (in.skipBytes(4) != 4) |
| throw new IOException(); |
| // class ID |
| long classAddr = in.readID(idSize); |
| // length |
| long len = in.readUnsignedInt(); |
| try |
| { |
| int classID = dump.mapAddressToId(classAddr); |
| IObject io = dump.getObject(classID); |
| if (io instanceof IClass) |
| oclazz = (IClass)io; |
| else |
| throw new IOException(); |
| } |
| catch (SnapshotException e) |
| { |
| // move to end of object |
| if (in.skipBytes(len) != len) |
| throw new IOException(); |
| // Invalid object, but might be good enough for skipping over |
| return new InstanceImpl(objectId, address, null, null); |
| } |
| } |
| |
| // check if we need to defer reading the class |
| List<IClass> hierarchy = resolveClassHierarchy(dump, oclazz); |
| if (hierarchy == null) |
| { |
| throw new IOException(Messages.HprofRandomAccessParser_Error_DumpIncomplete); |
| } |
| else |
| { |
| List<Field> instanceFields = new ArrayList<Field>(); |
| for (IClass clazz : hierarchy) |
| { |
| List<FieldDescriptor> fields = clazz.getFieldDescriptors(); |
| for (int ii = 0; ii < fields.size(); ii++) |
| { |
| FieldDescriptor field = fields.get(ii); |
| int type = field.getType(); |
| Object value = readValue(in, dump, type); |
| instanceFields.add(new Field(field.getName(), field.getType(), value)); |
| } |
| } |
| |
| ClassImpl classImpl = (ClassImpl) hierarchy.get(0); |
| |
| if (dump.isClassLoader(objectId)) |
| return new ClassLoaderImpl(objectId, address, classImpl, instanceFields); |
| else |
| return new InstanceImpl(objectId, address, classImpl, instanceFields); |
| } |
| } |
| |
| private IArray readObjectArrayDump(int objectId, ISnapshot dump) throws IOException, SnapshotException |
| { |
| long id = in.readID(idSize); |
| |
| in.skipBytes(4); |
| int size = in.readInt(); |
| long len = (long)size * idSize; |
| |
| long arrayClassObjectID = in.readID(idSize); |
| |
| int typeId; |
| if (objectId == -1) |
| { |
| try |
| { |
| typeId = dump.mapAddressToId(arrayClassObjectID); |
| } |
| catch (SnapshotException e) |
| { |
| ObjectArrayImpl array = new ObjectArrayImpl(objectId, id, null, size); |
| // Move to end of object |
| if (in.skipBytes(len) != len) |
| throw new IOException(); |
| return array; |
| } |
| } |
| else |
| { |
| typeId = dump.mapAddressToId(arrayClassObjectID); |
| } |
| IClass arrayType = (IClass) dump.getObject(typeId); |
| if (arrayType == null) |
| throw new RuntimeException(Messages.HprofRandomAccessParser_Error_MissingFakeClass); |
| |
| Object content = null; |
| if (len < LAZY_LOADING_LIMIT) |
| { |
| long[] data = new long[size]; |
| for (int ii = 0; ii < data.length; ii++) |
| data[ii] = in.readID(idSize); |
| content = data; |
| } |
| else |
| { |
| content = new ArrayDescription.Offline(false, in.position(), 0, size); |
| if (objectId == -1) |
| { |
| // Move to end of object |
| if (in.skipBytes(len) != len) |
| throw new IOException(); |
| } |
| } |
| |
| ObjectArrayImpl array = new ObjectArrayImpl(objectId, id, (ClassImpl) arrayType, size); |
| array.setInfo(content); |
| return array; |
| } |
| |
| private IArray readPrimitiveArrayDump(int objectId, ISnapshot dump) throws IOException, SnapshotException |
| { |
| long id = in.readID(idSize); |
| |
| in.skipBytes(4); |
| int arraySize = in.readInt(); |
| |
| long elementType = in.readByte(); |
| if ((elementType < IPrimitiveArray.Type.BOOLEAN) || (elementType > IPrimitiveArray.Type.LONG)) |
| throw new IOException(Messages.Pass1Parser_Error_IllegalType); |
| |
| int elementSize = IPrimitiveArray.ELEMENT_SIZE[(int) elementType]; |
| long len = elementSize * (long)arraySize; |
| |
| Object content = null; |
| if (len < LAZY_LOADING_LIMIT) |
| { |
| byte[] data = new byte[(int)len]; |
| in.readFully(data); |
| content = elementType == IObject.Type.BYTE ? data : new ArrayDescription.Raw(data); |
| } |
| else |
| { |
| content = new ArrayDescription.Offline(true, in.position(), elementSize, arraySize); |
| if (objectId == -1) |
| { |
| // Move to end of object |
| if (in.skipBytes(len) != len) |
| throw new IOException(); |
| } |
| } |
| |
| // lookup class by name |
| IClass clazz = null; |
| String name = IPrimitiveArray.TYPE[(int) elementType]; |
| Collection<IClass> classes = dump.getClassesByName(name, false); |
| if (classes == null || classes.isEmpty()) |
| { |
| if (objectId == -1) |
| { |
| // Return a dummy array which can be ignored |
| PrimitiveArrayImpl array = new PrimitiveArrayImpl(objectId, id, (ClassImpl) clazz, arraySize, (int) elementType); |
| return array; |
| } |
| throw new IOException(MessageUtil.format(Messages.HprofRandomAccessParser_Error_MissingClass, name)); |
| } |
| else if (classes.size() > 1) |
| throw new IOException(MessageUtil.format(Messages.HprofRandomAccessParser_Error_DuplicateClass, name)); |
| else |
| clazz = classes.iterator().next(); |
| |
| PrimitiveArrayImpl array = new PrimitiveArrayImpl(objectId, id, (ClassImpl) clazz, arraySize, (int) elementType); |
| array.setInfo(content); |
| |
| return array; |
| } |
| |
| public synchronized long[] readObjectArray(ArrayDescription.Offline descriptor, int offset, int length) |
| throws IOException |
| { |
| int elementSize = this.idSize; |
| |
| in.seek(descriptor.getPosition() + ((long)offset * elementSize)); |
| long[] data = new long[length]; |
| for (int ii = 0; ii < data.length; ii++) |
| data[ii] = in.readID(idSize); |
| return data; |
| } |
| |
| public synchronized byte[] readPrimitiveArray(ArrayDescription.Offline descriptor, int offset, int length) |
| throws IOException |
| { |
| int elementSize = descriptor.getElementSize(); |
| |
| in.seek(descriptor.getPosition() + ((long)offset * elementSize)); |
| |
| byte[] data = new byte[length * elementSize]; |
| in.readFully(data); |
| return data; |
| } |
| |
| private int skipRecords(int segmentType) throws IOException |
| { |
| boolean again = true; |
| do |
| { |
| int skip = -1; |
| switch (segmentType) |
| { |
| case Record.HEAP_DUMP_SEGMENT: |
| skip = 8; |
| break; |
| case Constants.DumpSegment.ROOT_UNKNOWN: |
| case Constants.DumpSegment.ROOT_STICKY_CLASS: |
| case Constants.DumpSegment.ROOT_MONITOR_USED: |
| skip = idSize; |
| break; |
| case Constants.DumpSegment.ROOT_JNI_GLOBAL: |
| skip = idSize * 2; |
| break; |
| case Constants.DumpSegment.ROOT_JNI_LOCAL: |
| case Constants.DumpSegment.ROOT_JAVA_FRAME: |
| case Constants.DumpSegment.ROOT_THREAD_OBJECT: |
| skip = idSize + 8; |
| break; |
| case Constants.DumpSegment.ROOT_NATIVE_STACK: |
| case Constants.DumpSegment.ROOT_THREAD_BLOCK: |
| skip = idSize + 4; |
| break; |
| case Constants.DumpSegment.CLASS_DUMP: |
| skipClassDump(); |
| // Already skipped enough, so just reread |
| skip = 0; |
| break; |
| default: |
| again = false; |
| break; |
| } |
| if (skip >= 0) |
| { |
| // Skip over new segment header etc. |
| in.skipBytes(skip); |
| segmentType = in.readUnsignedByte(); |
| } |
| } |
| while (again); |
| return segmentType; |
| } |
| |
| private void skipClassDump() throws IOException |
| { |
| in.skipBytes(7 * idSize + 8); |
| |
| int constantPoolSize = in.readUnsignedShort(); |
| for (int ii = 0; ii < constantPoolSize; ii++) |
| { |
| in.skipBytes(2); |
| skipValue(in); |
| } |
| |
| int numStaticFields = in.readUnsignedShort(); |
| for (int i = 0; i < numStaticFields; i++) |
| { |
| in.skipBytes(idSize); |
| skipValue(in); |
| } |
| |
| int numInstanceFields = in.readUnsignedShort(); |
| in.skipBytes((idSize + 1) * numInstanceFields); |
| } |
| } |
