HandleNativeHeap.java

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

package com.android.ddmlib;

import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;

/**
 * Handle thread status updates.
 */
final class HandleNativeHeap extends ChunkHandler {

    public static final int CHUNK_NHGT = type("NHGT"); //$NON-NLS-1$
    public static final int CHUNK_NHSG = type("NHSG"); //$NON-NLS-1$
    public static final int CHUNK_NHST = type("NHST"); //$NON-NLS-1$
    public static final int CHUNK_NHEN = type("NHEN"); //$NON-NLS-1$

    private static final HandleNativeHeap mInst = new HandleNativeHeap();

    /**
     * Handle getting different sized size_t and pointer reads.
     */
    abstract class NativeBuffer {
        public NativeBuffer(ByteBuffer buffer) {
            mBuffer = buffer;
        }

        public abstract int getSizeT();
        public abstract long getPtr();

        protected ByteBuffer mBuffer;
    }

    /**
     * This class treats size_t and pointer values as 32 bit.
     */
    final class NativeBuffer32 extends NativeBuffer {
        public NativeBuffer32(ByteBuffer buffer) {
          super(buffer);
        }

        @Override
        public int getSizeT() {
            return mBuffer.getInt();
        }
        @Override
        public long getPtr() {
            return (long)mBuffer.getInt() & 0x00000000ffffffffL;
        }
    }

    /**
     * This class treats size_t and pointer values as 64 bit.
     */
    final class NativeBuffer64 extends NativeBuffer {
        public NativeBuffer64(ByteBuffer buffer) {
          super(buffer);
        }

        @Override
        public int getSizeT() {
            return (int)mBuffer.getLong();
        }
        @Override
        public long getPtr() {
            return mBuffer.getLong();
        }
    }

    private HandleNativeHeap() {
    }


    /**
     * Register for the packets we expect to get from the client.
     */
    public static void register(MonitorThread mt) {
        mt.registerChunkHandler(CHUNK_NHGT, mInst);
        mt.registerChunkHandler(CHUNK_NHSG, mInst);
        mt.registerChunkHandler(CHUNK_NHST, mInst);
        mt.registerChunkHandler(CHUNK_NHEN, mInst);
    }

    /**
     * Client is ready.
     */
    @Override
    public void clientReady(Client client) throws IOException {}

    /**
     * Client went away.
     */
    @Override
    public void clientDisconnected(Client client) {}

    /**
     * Chunk handler entry point.
     */
    @Override
    public void handleChunk(Client client, int type, ByteBuffer data, boolean isReply, int msgId) {

        Log.d("ddm-nativeheap", "handling " + ChunkHandler.name(type));

        if (type == CHUNK_NHGT) {
            handleNHGT(client, data);
        } else if (type == CHUNK_NHST) {
            // start chunk before any NHSG chunk(s)
            client.getClientData().getNativeHeapData().clearHeapData();
        } else if (type == CHUNK_NHEN) {
            // end chunk after NHSG chunk(s)
            client.getClientData().getNativeHeapData().sealHeapData();
        } else if (type == CHUNK_NHSG) {
            handleNHSG(client, data);
        } else {
            handleUnknownChunk(client, type, data, isReply, msgId);
        }

        client.update(Client.CHANGE_NATIVE_HEAP_DATA);
    }

    /**
     * Send an NHGT (Native Thread GeT) request to the client.
     */
    public static void sendNHGT(Client client) throws IOException {

        ByteBuffer rawBuf = allocBuffer(0);
        JdwpPacket packet = new JdwpPacket(rawBuf);
        ByteBuffer buf = getChunkDataBuf(rawBuf);

        // no data in request message

        finishChunkPacket(packet, CHUNK_NHGT, buf.position());
        Log.d("ddm-nativeheap", "Sending " + name(CHUNK_NHGT));
        client.sendAndConsume(packet, mInst);

        rawBuf = allocBuffer(2);
        packet = new JdwpPacket(rawBuf);
        buf = getChunkDataBuf(rawBuf);

        buf.put((byte)HandleHeap.WHEN_DISABLE);
        buf.put((byte)HandleHeap.WHAT_OBJ);

        finishChunkPacket(packet, CHUNK_NHSG, buf.position());
        Log.d("ddm-nativeheap", "Sending " + name(CHUNK_NHSG));
        client.sendAndConsume(packet, mInst);
    }

    /*
     * Handle our native heap data.
     */
    private void handleNHGT(Client client, ByteBuffer data) {
        ClientData clientData = client.getClientData();

        Log.d("ddm-nativeheap", "NHGT: " + data.limit() + " bytes");

        data.order(ByteOrder.LITTLE_ENDIAN);

        // There are two supported header formats.
        //
        // The original version of the header for 32 bit processes:
        //
        //   uint32_t mapSize;
        //   uint32_t mapSize;
        //   uint32_t allocSize;
        //   uint32_t allocInfoSize;
        //   uint32_t totalMemory;
        //   uint32_t backtrace_size;
        //
        // The new header which includes a signature and pointer size:
        //
        //   uint32_t signature;   (Which is always 0x812345dd)
        //   uint16_t version;     (Only version 2 of the new format supported)
        //   uint16_t pointerSize; (Size in bytes of size_t/pointer values)
        //   size_t mapSize;
        //   size_t allocSize;
        //   size_t allocInfoSize;
        //   size_t totalMemory;
        //   size_t backtrace_size;
        //
        // If the signature doesn't match, then the code uses the original
        // header format. If the signature matches, then use the new
        // header format with variable sizes of size_t and pointers.
        int signature = data.getInt(0);
        short pointerSize = 4;
        if (signature == 0x812345dd) {
            // Consume signature value.
            int ignore = data.getInt();
            short version = data.getShort();
            if (version != 2) {
                Log.e("ddms", "Unknown header version: " + version);
                return;
            }
            pointerSize = data.getShort();
        }
        NativeBuffer buffer;
        if (pointerSize == 4) {
            buffer = new NativeBuffer32(data);
        } else if (pointerSize == 8) {
            buffer = new NativeBuffer64(data);
        } else {
            Log.e("ddms", "Unknown pointer size: " + pointerSize);
            return;
        }

        // clear the previous run
        clientData.clearNativeAllocationInfo();

        int mapSize = buffer.getSizeT();
        int allocSize = buffer.getSizeT();
        int allocInfoSize = buffer.getSizeT();
        int totalMemory = buffer.getSizeT();
        int backtraceSize = buffer.getSizeT();

        Log.d("ddms", "mapSize: " + mapSize);
        Log.d("ddms", "allocSize: " + allocSize);
        Log.d("ddms", "allocInfoSize: " + allocInfoSize);
        Log.d("ddms", "totalMemory: " + totalMemory);

        clientData.setTotalNativeMemory(totalMemory);

        // this means that updates aren't turned on.
        if (allocInfoSize == 0) {
          return;
        }

        if (mapSize > 0) {
            byte[] maps = new byte[mapSize];
            data.get(maps, 0, mapSize);
            parseMaps(clientData, maps);
        }

        int iterations = allocSize / allocInfoSize;
        for (int i = 0 ; i < iterations ; i++) {
            NativeAllocationInfo info = new NativeAllocationInfo(
                    buffer.getSizeT() /* size */,
                    buffer.getSizeT() /* allocations */);

            for (int j = 0 ; j < backtraceSize ; j++) {
                long addr = buffer.getPtr();
                if (addr == 0x0) {
                    // skip past null addresses
                    continue;
                }

                info.addStackCallAddress(addr);
            }
            clientData.addNativeAllocation(info);
        }
    }

    private void handleNHSG(Client client, ByteBuffer data) {
        byte dataCopy[] = new byte[data.limit()];
        data.rewind();
        data.get(dataCopy);
        data = ByteBuffer.wrap(dataCopy);
        client.getClientData().getNativeHeapData().addHeapData(data);

        if (true) {
            return;
        }

        byte[] copy = new byte[data.limit()];
        data.get(copy);

        ByteBuffer buffer = ByteBuffer.wrap(copy);
        buffer.order(ByteOrder.BIG_ENDIAN);

        int id = buffer.getInt();
        int unitsize = buffer.get();
        long startAddress = buffer.getInt() & 0x00000000ffffffffL;
        int offset = buffer.getInt();
        int allocationUnitCount = buffer.getInt();

        // read the usage
        while (buffer.position() < buffer.limit()) {
            int eState = buffer.get() & 0x000000ff;
            int eLen = (buffer.get() & 0x000000ff) + 1;
        }
    }

    private void parseMaps(ClientData clientData, byte[] maps) {
        InputStreamReader input = new InputStreamReader(new ByteArrayInputStream(maps));
        BufferedReader reader = new BufferedReader(input);

        String line;

        try {
            while ((line = reader.readLine()) != null) {
                Log.d("ddms", "line: " + line);
                // Expected format:
                //   7fe51f2000-7fe5213000 rw-p 00000000 00:00 0      [stack]

                int library_start = line.lastIndexOf(' ');
                if (library_start == -1) {
                    continue;
                }

                // Assume that any string that starts with a / is a
                // shared library or executable that we will try to symbolize.
                String library = line.substring(library_start+1);
                if (!library.startsWith("/")) {
                    continue;
                }

                // Parse the start and end address range.
                int dashIndex = line.indexOf('-');
                int spaceIndex = line.indexOf(' ', dashIndex);
                if (dashIndex == -1 || spaceIndex == -1) {
                    continue;
                }

                long startAddr = 0;
                long endAddr = 0;
                try {
                    startAddr = Long.parseLong(line.substring(0, dashIndex), 16);
                    endAddr = Long.parseLong(line.substring(dashIndex+1, spaceIndex), 16);
                } catch (NumberFormatException e) {
                    e.printStackTrace();
                    continue;
                }

                clientData.addNativeLibraryMapInfo(startAddr, endAddr, library);
                Log.d("ddms", library + "(" + Long.toHexString(startAddr) +
                      " - " + Long.toHexString(endAddr) + ")");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }


}