1 /* 2 * Copyright (C) 2007 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package android.ddm; 18 19 import org.apache.harmony.dalvik.ddmc.Chunk; 20 import org.apache.harmony.dalvik.ddmc.ChunkHandler; 21 import org.apache.harmony.dalvik.ddmc.DdmServer; 22 import org.apache.harmony.dalvik.ddmc.DdmVmInternal; 23 import android.os.Debug; 24 import android.util.Config; 25 import android.util.Log; 26 import java.io.IOException; 27 import java.nio.ByteBuffer; 28 29 /** 30 * Handle native and virtual heap requests. 31 */ 32 public class DdmHandleHeap extends ChunkHandler { 33 34 public static final int CHUNK_HPIF = type("HPIF"); 35 public static final int CHUNK_HPSG = type("HPSG"); 36 public static final int CHUNK_HPDU = type("HPDU"); 37 public static final int CHUNK_HPDS = type("HPDS"); 38 public static final int CHUNK_NHSG = type("NHSG"); 39 public static final int CHUNK_HPGC = type("HPGC"); 40 public static final int CHUNK_REAE = type("REAE"); 41 public static final int CHUNK_REAQ = type("REAQ"); 42 public static final int CHUNK_REAL = type("REAL"); 43 44 private static DdmHandleHeap mInstance = new DdmHandleHeap(); 45 46 47 /* singleton, do not instantiate */ 48 private DdmHandleHeap() {} 49 50 /** 51 * Register for the messages we're interested in. 52 */ 53 public static void register() { 54 DdmServer.registerHandler(CHUNK_HPIF, mInstance); 55 DdmServer.registerHandler(CHUNK_HPSG, mInstance); 56 DdmServer.registerHandler(CHUNK_HPDU, mInstance); 57 DdmServer.registerHandler(CHUNK_HPDS, mInstance); 58 DdmServer.registerHandler(CHUNK_NHSG, mInstance); 59 DdmServer.registerHandler(CHUNK_HPGC, mInstance); 60 DdmServer.registerHandler(CHUNK_REAE, mInstance); 61 DdmServer.registerHandler(CHUNK_REAQ, mInstance); 62 DdmServer.registerHandler(CHUNK_REAL, mInstance); 63 } 64 65 /** 66 * Called when the DDM server connects. The handler is allowed to 67 * send messages to the server. 68 */ 69 public void connected() {} 70 71 /** 72 * Called when the DDM server disconnects. Can be used to disable 73 * periodic transmissions or clean up saved state. 74 */ 75 public void disconnected() {} 76 77 /** 78 * Handle a chunk of data. 79 */ 80 public Chunk handleChunk(Chunk request) { 81 if (Config.LOGV) 82 Log.v("ddm-heap", "Handling " + name(request.type) + " chunk"); 83 int type = request.type; 84 85 if (type == CHUNK_HPIF) { 86 return handleHPIF(request); 87 } else if (type == CHUNK_HPSG) { 88 return handleHPSGNHSG(request, false); 89 } else if (type == CHUNK_HPDU) { 90 return handleHPDU(request); 91 } else if (type == CHUNK_HPDS) { 92 return handleHPDS(request); 93 } else if (type == CHUNK_NHSG) { 94 return handleHPSGNHSG(request, true); 95 } else if (type == CHUNK_HPGC) { 96 return handleHPGC(request); 97 } else if (type == CHUNK_REAE) { 98 return handleREAE(request); 99 } else if (type == CHUNK_REAQ) { 100 return handleREAQ(request); 101 } else if (type == CHUNK_REAL) { 102 return handleREAL(request); 103 } else { 104 throw new RuntimeException("Unknown packet " 105 + ChunkHandler.name(type)); 106 } 107 } 108 109 /* 110 * Handle a "HeaP InFo" request. 111 */ 112 private Chunk handleHPIF(Chunk request) { 113 ByteBuffer in = wrapChunk(request); 114 115 int when = in.get(); 116 if (Config.LOGV) 117 Log.v("ddm-heap", "Heap segment enable: when=" + when); 118 119 boolean ok = DdmVmInternal.heapInfoNotify(when); 120 if (!ok) { 121 return createFailChunk(1, "Unsupported HPIF what"); 122 } else { 123 return null; // empty response 124 } 125 } 126 127 /* 128 * Handle a "HeaP SeGment" or "Native Heap SeGment" request. 129 */ 130 private Chunk handleHPSGNHSG(Chunk request, boolean isNative) { 131 ByteBuffer in = wrapChunk(request); 132 133 int when = in.get(); 134 int what = in.get(); 135 if (Config.LOGV) 136 Log.v("ddm-heap", "Heap segment enable: when=" + when 137 + ", what=" + what + ", isNative=" + isNative); 138 139 boolean ok = DdmVmInternal.heapSegmentNotify(when, what, isNative); 140 if (!ok) { 141 return createFailChunk(1, "Unsupported HPSG what/when"); 142 } else { 143 // TODO: if "when" is non-zero and we want to see a dump 144 // right away, initiate a GC. 145 return null; // empty response 146 } 147 } 148 149 /* 150 * Handle a "HeaP DUmp" request. 151 * 152 * This currently just returns a result code. We could pull up 153 * the entire contents of the file and return them, but hprof dump 154 * files can be a few megabytes. 155 */ 156 private Chunk handleHPDU(Chunk request) { 157 ByteBuffer in = wrapChunk(request); 158 byte result; 159 160 /* get the filename for the output file */ 161 int len = in.getInt(); 162 String fileName = getString(in, len); 163 if (Config.LOGD) 164 Log.d("ddm-heap", "Heap dump: file='" + fileName + "'"); 165 166 try { 167 Debug.dumpHprofData(fileName); 168 result = 0; 169 } catch (UnsupportedOperationException uoe) { 170 Log.w("ddm-heap", "hprof dumps not supported in this VM"); 171 result = -1; 172 } catch (IOException ioe) { 173 result = -1; 174 } catch (RuntimeException re) { 175 result = -1; 176 } 177 178 /* create a non-empty reply so the handler fires on completion */ 179 byte[] reply = { result }; 180 return new Chunk(CHUNK_HPDU, reply, 0, reply.length); 181 } 182 183 /* 184 * Handle a "HeaP Dump Streaming" request. 185 * 186 * This tells the VM to create a heap dump and send it directly to 187 * DDMS. The dumps are large enough that we don't want to copy the 188 * data into a byte[] and send it from here. 189 */ 190 private Chunk handleHPDS(Chunk request) { 191 ByteBuffer in = wrapChunk(request); 192 byte result; 193 194 /* get the filename for the output file */ 195 if (Config.LOGD) 196 Log.d("ddm-heap", "Heap dump: [DDMS]"); 197 198 String failMsg = null; 199 try { 200 Debug.dumpHprofDataDdms(); 201 } catch (UnsupportedOperationException uoe) { 202 failMsg = "hprof dumps not supported in this VM"; 203 } catch (RuntimeException re) { 204 failMsg = "Exception: " + re.getMessage(); 205 } 206 207 if (failMsg != null) { 208 Log.w("ddm-heap", failMsg); 209 return createFailChunk(1, failMsg); 210 } else { 211 return null; 212 } 213 } 214 215 /* 216 * Handle a "HeaP Garbage Collection" request. 217 */ 218 private Chunk handleHPGC(Chunk request) { 219 //ByteBuffer in = wrapChunk(request); 220 221 if (Config.LOGD) 222 Log.d("ddm-heap", "Heap GC request"); 223 System.gc(); 224 225 return null; // empty response 226 } 227 228 /* 229 * Handle a "REcent Allocation Enable" request. 230 */ 231 private Chunk handleREAE(Chunk request) { 232 ByteBuffer in = wrapChunk(request); 233 boolean enable; 234 235 enable = (in.get() != 0); 236 237 if (Config.LOGD) 238 Log.d("ddm-heap", "Recent allocation enable request: " + enable); 239 240 DdmVmInternal.enableRecentAllocations(enable); 241 242 return null; // empty response 243 } 244 245 /* 246 * Handle a "REcent Allocation Query" request. 247 */ 248 private Chunk handleREAQ(Chunk request) { 249 //ByteBuffer in = wrapChunk(request); 250 251 byte[] reply = new byte[1]; 252 reply[0] = DdmVmInternal.getRecentAllocationStatus() ? (byte)1 :(byte)0; 253 return new Chunk(CHUNK_REAQ, reply, 0, reply.length); 254 } 255 256 /* 257 * Handle a "REcent ALlocations" request. 258 */ 259 private Chunk handleREAL(Chunk request) { 260 //ByteBuffer in = wrapChunk(request); 261 262 if (Config.LOGD) 263 Log.d("ddm-heap", "Recent allocations request"); 264 265 /* generate the reply in a ready-to-go format */ 266 byte[] reply = DdmVmInternal.getRecentAllocations(); 267 return new Chunk(CHUNK_REAL, reply, 0, reply.length); 268 } 269 } 270 271
