1 /* 2 * Copyright (C) 2008 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 * Heap object dump 18 */ 19 #include "Hprof.h" 20 21 #include "alloc/HeapInternal.h" 22 #include "alloc/HeapSource.h" 23 24 /* Set DUMP_PRIM_DATA to 1 if you want to include the contents 25 * of primitive arrays (byte arrays, character arrays, etc.) 26 * in heap dumps. This can be a large amount of data. 27 */ 28 #define DUMP_PRIM_DATA 1 29 30 #define OBJECTS_PER_SEGMENT ((size_t)128) 31 #define BYTES_PER_SEGMENT ((size_t)4096) 32 33 /* The static field-name for the synthetic object generated to account 34 * for class Static overhead. 35 */ 36 #define STATIC_OVERHEAD_NAME "$staticOverhead" 37 /* The ID for the synthetic object generated to account for class 38 * Static overhead. 39 */ 40 #define CLASS_STATICS_ID(clazz) ((hprof_object_id)(((u4)(clazz)) | 1)) 41 42 int 43 hprofStartHeapDump(hprof_context_t *ctx) 44 { 45 UNUSED_PARAMETER(ctx); 46 47 ctx->objectsInSegment = OBJECTS_PER_SEGMENT; 48 ctx->currentHeap = HPROF_HEAP_DEFAULT; 49 return 0; 50 } 51 52 int 53 hprofFinishHeapDump(hprof_context_t *ctx) 54 { 55 return hprofStartNewRecord(ctx, HPROF_TAG_HEAP_DUMP_END, HPROF_TIME); 56 } 57 58 int 59 hprofSetGcScanState(hprof_context_t *ctx, 60 hprof_heap_tag_t state, u4 threadSerialNumber) 61 { 62 /* Used by hprofMarkRootObject() 63 */ 64 ctx->gcScanState = state; 65 ctx->gcThreadSerialNumber = threadSerialNumber; 66 return 0; 67 } 68 69 static hprof_basic_type 70 signatureToBasicTypeAndSize(const char *sig, size_t *sizeOut) 71 { 72 char c = sig[0]; 73 hprof_basic_type ret; 74 size_t size; 75 76 switch (c) { 77 case '[': 78 case 'L': ret = hprof_basic_object; size = 4; break; 79 case 'Z': ret = hprof_basic_boolean; size = 1; break; 80 case 'C': ret = hprof_basic_char; size = 2; break; 81 case 'F': ret = hprof_basic_float; size = 4; break; 82 case 'D': ret = hprof_basic_double; size = 8; break; 83 case 'B': ret = hprof_basic_byte; size = 1; break; 84 case 'S': ret = hprof_basic_short; size = 2; break; 85 default: assert(false); 86 case 'I': ret = hprof_basic_int; size = 4; break; 87 case 'J': ret = hprof_basic_long; size = 8; break; 88 } 89 90 if (sizeOut != NULL) { 91 *sizeOut = size; 92 } 93 94 return ret; 95 } 96 97 static hprof_basic_type 98 primitiveToBasicTypeAndSize(PrimitiveType prim, size_t *sizeOut) 99 { 100 hprof_basic_type ret; 101 size_t size; 102 103 switch (prim) { 104 case PRIM_BOOLEAN: ret = hprof_basic_boolean; size = 1; break; 105 case PRIM_CHAR: ret = hprof_basic_char; size = 2; break; 106 case PRIM_FLOAT: ret = hprof_basic_float; size = 4; break; 107 case PRIM_DOUBLE: ret = hprof_basic_double; size = 8; break; 108 case PRIM_BYTE: ret = hprof_basic_byte; size = 1; break; 109 case PRIM_SHORT: ret = hprof_basic_short; size = 2; break; 110 default: assert(false); 111 case PRIM_INT: ret = hprof_basic_int; size = 4; break; 112 case PRIM_LONG: ret = hprof_basic_long; size = 8; break; 113 } 114 115 if (sizeOut != NULL) { 116 *sizeOut = size; 117 } 118 119 return ret; 120 } 121 122 /* Always called when marking objects, but only does 123 * something when ctx->gcScanState is non-zero, which is usually 124 * only true when marking the root set or unreachable 125 * objects. Used to add rootset references to obj. 126 */ 127 int 128 hprofMarkRootObject(hprof_context_t *ctx, const Object *obj, jobject jniObj) 129 { 130 hprof_record_t *rec = &ctx->curRec; 131 int err; 132 hprof_heap_tag_t heapTag = ctx->gcScanState; 133 134 if (heapTag == 0) { 135 return 0; 136 } 137 138 if (ctx->objectsInSegment >= OBJECTS_PER_SEGMENT || 139 rec->length >= BYTES_PER_SEGMENT) 140 { 141 /* This flushes the old segment and starts a new one. 142 */ 143 hprofStartNewRecord(ctx, HPROF_TAG_HEAP_DUMP_SEGMENT, HPROF_TIME); 144 ctx->objectsInSegment = 0; 145 } 146 147 switch (heapTag) { 148 /* ID: object ID 149 */ 150 case HPROF_ROOT_UNKNOWN: 151 case HPROF_ROOT_STICKY_CLASS: 152 case HPROF_ROOT_MONITOR_USED: 153 case HPROF_ROOT_INTERNED_STRING: 154 case HPROF_ROOT_FINALIZING: 155 case HPROF_ROOT_DEBUGGER: 156 case HPROF_ROOT_REFERENCE_CLEANUP: 157 case HPROF_ROOT_VM_INTERNAL: 158 hprofAddU1ToRecord(rec, heapTag); 159 hprofAddIdToRecord(rec, (hprof_object_id)obj); 160 break; 161 162 /* ID: object ID 163 * ID: JNI global ref ID 164 */ 165 case HPROF_ROOT_JNI_GLOBAL: 166 hprofAddU1ToRecord(rec, heapTag); 167 hprofAddIdToRecord(rec, (hprof_object_id)obj); 168 hprofAddIdToRecord(rec, (hprof_id)jniObj); 169 break; 170 171 /* ID: object ID 172 * u4: thread serial number 173 * u4: frame number in stack trace (-1 for empty) 174 */ 175 case HPROF_ROOT_JNI_LOCAL: 176 case HPROF_ROOT_JNI_MONITOR: 177 case HPROF_ROOT_JAVA_FRAME: 178 hprofAddU1ToRecord(rec, heapTag); 179 hprofAddIdToRecord(rec, (hprof_object_id)obj); 180 hprofAddU4ToRecord(rec, ctx->gcThreadSerialNumber); 181 hprofAddU4ToRecord(rec, (u4)-1); 182 break; 183 184 /* ID: object ID 185 * u4: thread serial number 186 */ 187 case HPROF_ROOT_NATIVE_STACK: 188 case HPROF_ROOT_THREAD_BLOCK: 189 hprofAddU1ToRecord(rec, heapTag); 190 hprofAddIdToRecord(rec, (hprof_object_id)obj); 191 hprofAddU4ToRecord(rec, ctx->gcThreadSerialNumber); 192 break; 193 194 /* ID: thread object ID 195 * u4: thread serial number 196 * u4: stack trace serial number 197 */ 198 case HPROF_ROOT_THREAD_OBJECT: 199 hprofAddU1ToRecord(rec, heapTag); 200 hprofAddIdToRecord(rec, (hprof_object_id)obj); 201 hprofAddU4ToRecord(rec, ctx->gcThreadSerialNumber); 202 hprofAddU4ToRecord(rec, (u4)-1); //xxx 203 break; 204 205 default: 206 err = 0; 207 break; 208 } 209 210 ctx->objectsInSegment++; 211 212 return err; 213 } 214 215 static int 216 stackTraceSerialNumber(const void *obj) 217 218 { 219 #if WITH_HPROF_STACK 220 DvmHeapChunk *chunk = ptr2chunk(obj); 221 return chunk->stackTraceSerialNumber; 222 #else 223 return HPROF_NULL_STACK_TRACE; 224 #endif 225 } 226 227 int 228 hprofDumpHeapObject(hprof_context_t *ctx, const Object *obj) 229 { 230 const ClassObject *clazz; 231 hprof_record_t *rec = &ctx->curRec; 232 HprofHeapId desiredHeap; 233 234 desiredHeap = 235 dvmHeapSourceGetPtrFlag(obj, HS_ALLOCATED_IN_ZYGOTE) ? 236 HPROF_HEAP_ZYGOTE : HPROF_HEAP_APP; 237 238 if (ctx->objectsInSegment >= OBJECTS_PER_SEGMENT || 239 rec->length >= BYTES_PER_SEGMENT) 240 { 241 /* This flushes the old segment and starts a new one. 242 */ 243 hprofStartNewRecord(ctx, HPROF_TAG_HEAP_DUMP_SEGMENT, HPROF_TIME); 244 ctx->objectsInSegment = 0; 245 246 /* Starting a new HEAP_DUMP resets the heap to default. 247 */ 248 ctx->currentHeap = HPROF_HEAP_DEFAULT; 249 } 250 251 if (desiredHeap != ctx->currentHeap) { 252 hprof_string_id nameId; 253 254 /* This object is in a different heap than the current one. 255 * Emit a HEAP_DUMP_INFO tag to change heaps. 256 */ 257 hprofAddU1ToRecord(rec, HPROF_HEAP_DUMP_INFO); 258 hprofAddU4ToRecord(rec, (u4)desiredHeap); // u4: heap id 259 switch (desiredHeap) { 260 case HPROF_HEAP_APP: 261 nameId = hprofLookupStringId("app"); 262 break; 263 case HPROF_HEAP_ZYGOTE: 264 nameId = hprofLookupStringId("zygote"); 265 break; 266 default: 267 /* Internal error. */ 268 assert(!"Unexpected desiredHeap"); 269 nameId = hprofLookupStringId("<ILLEGAL>"); 270 break; 271 } 272 hprofAddIdToRecord(rec, nameId); 273 ctx->currentHeap = desiredHeap; 274 } 275 276 clazz = obj->clazz; 277 278 if (clazz == NULL) { 279 /* This object will bother HprofReader, because it has a NULL 280 * class, so just don't dump it. It could be 281 * gDvm.unlinkedJavaLangClass or it could be an object just 282 * allocated which hasn't been initialized yet. 283 */ 284 } else { 285 hprof_class_object_id clazzId; 286 287 clazzId = hprofLookupClassId(clazz); 288 289 if (clazz == gDvm.classJavaLangClass) { 290 const ClassObject *thisClass = (const ClassObject *)obj; 291 int i, sFieldCount, iFieldCount; 292 /* obj is a ClassObject. 293 */ 294 sFieldCount = thisClass->sfieldCount; 295 if (sFieldCount != 0) { 296 int byteLength = sFieldCount*sizeof(StaticField); 297 /* Create a byte array to reflect the allocation of the 298 * StaticField array at the end of this class. 299 */ 300 hprofAddU1ToRecord(rec, HPROF_PRIMITIVE_ARRAY_DUMP); 301 hprofAddIdToRecord(rec, CLASS_STATICS_ID(obj)); 302 hprofAddU4ToRecord(rec, stackTraceSerialNumber(obj)); 303 hprofAddU4ToRecord(rec, byteLength); 304 hprofAddU1ToRecord(rec, hprof_basic_byte); 305 for (i = 0; i < byteLength; i++) { 306 hprofAddU1ToRecord(rec, 0); 307 } 308 } 309 310 hprofAddU1ToRecord(rec, HPROF_CLASS_DUMP); 311 hprofAddIdToRecord(rec, hprofLookupClassId(thisClass)); 312 hprofAddU4ToRecord(rec, stackTraceSerialNumber(thisClass)); 313 hprofAddIdToRecord(rec, hprofLookupClassId(thisClass->super)); 314 hprofAddIdToRecord(rec, (hprof_object_id)thisClass->classLoader); 315 hprofAddIdToRecord(rec, (hprof_object_id)0); // no signer 316 hprofAddIdToRecord(rec, (hprof_object_id)0); // no prot domain 317 hprofAddIdToRecord(rec, (hprof_id)0); // reserved 318 hprofAddIdToRecord(rec, (hprof_id)0); // reserved 319 if (obj == (Object *)gDvm.classJavaLangClass) { 320 // ClassObjects have their static fields appended, so 321 // aren't all the same size. But they're at least this 322 // size. 323 hprofAddU4ToRecord(rec, sizeof(ClassObject)); // instance size 324 } else { 325 hprofAddU4ToRecord(rec, thisClass->objectSize); // instance size 326 } 327 328 hprofAddU2ToRecord(rec, 0); // empty const pool 329 330 /* Static fields 331 */ 332 if (sFieldCount == 0) { 333 hprofAddU2ToRecord(rec, (u2)0); 334 } else { 335 hprofAddU2ToRecord(rec, (u2)(sFieldCount+1)); 336 hprofAddIdToRecord(rec, 337 hprofLookupStringId(STATIC_OVERHEAD_NAME)); 338 hprofAddU1ToRecord(rec, hprof_basic_object); 339 hprofAddIdToRecord(rec, CLASS_STATICS_ID(obj)); 340 for (i = 0; i < sFieldCount; i++) { 341 hprof_basic_type t; 342 size_t size; 343 const StaticField *f = &thisClass->sfields[i]; 344 345 t = signatureToBasicTypeAndSize(f->field.signature, &size); 346 hprofAddIdToRecord(rec, hprofLookupStringId(f->field.name)); 347 hprofAddU1ToRecord(rec, t); 348 if (size == 1) { 349 hprofAddU1ToRecord(rec, (u1)f->value.b); 350 } else if (size == 2) { 351 hprofAddU2ToRecord(rec, (u2)f->value.c); 352 } else if (size == 4) { 353 hprofAddU4ToRecord(rec, (u4)f->value.i); 354 } else if (size == 8) { 355 hprofAddU8ToRecord(rec, (u8)f->value.j); 356 } else { 357 assert(false); 358 } 359 } 360 } 361 362 /* Instance fields for this class (no superclass fields) 363 */ 364 iFieldCount = thisClass->ifieldCount; 365 hprofAddU2ToRecord(rec, (u2)iFieldCount); 366 for (i = 0; i < iFieldCount; i++) { 367 const InstField *f = &thisClass->ifields[i]; 368 hprof_basic_type t; 369 370 t = signatureToBasicTypeAndSize(f->field.signature, NULL); 371 hprofAddIdToRecord(rec, hprofLookupStringId(f->field.name)); 372 hprofAddU1ToRecord(rec, t); 373 } 374 } else if (IS_CLASS_FLAG_SET(clazz, CLASS_ISARRAY)) { 375 const ArrayObject *aobj = (const ArrayObject *)obj; 376 u4 length = aobj->length; 377 378 if (IS_CLASS_FLAG_SET(clazz, CLASS_ISOBJECTARRAY)) { 379 /* obj is an object array. 380 */ 381 hprofAddU1ToRecord(rec, HPROF_OBJECT_ARRAY_DUMP); 382 383 hprofAddIdToRecord(rec, (hprof_object_id)obj); 384 hprofAddU4ToRecord(rec, stackTraceSerialNumber(obj)); 385 hprofAddU4ToRecord(rec, length); 386 hprofAddIdToRecord(rec, hprofLookupClassId(clazz)); 387 388 /* Dump the elements, which are always objects or NULL. 389 */ 390 hprofAddIdListToRecord(rec, 391 (const hprof_object_id *)aobj->contents, length); 392 } else { 393 hprof_basic_type t; 394 size_t size; 395 396 t = primitiveToBasicTypeAndSize(clazz->elementClass-> 397 primitiveType, &size); 398 399 /* obj is a primitive array. 400 */ 401 #if DUMP_PRIM_DATA 402 hprofAddU1ToRecord(rec, HPROF_PRIMITIVE_ARRAY_DUMP); 403 #else 404 hprofAddU1ToRecord(rec, HPROF_PRIMITIVE_ARRAY_NODATA_DUMP); 405 #endif 406 407 hprofAddIdToRecord(rec, (hprof_object_id)obj); 408 hprofAddU4ToRecord(rec, stackTraceSerialNumber(obj)); 409 hprofAddU4ToRecord(rec, length); 410 hprofAddU1ToRecord(rec, t); 411 412 #if DUMP_PRIM_DATA 413 /* Dump the raw, packed element values. 414 */ 415 if (size == 1) { 416 hprofAddU1ListToRecord(rec, (const u1 *)aobj->contents, 417 length); 418 } else if (size == 2) { 419 hprofAddU2ListToRecord(rec, (const u2 *)aobj->contents, 420 length); 421 } else if (size == 4) { 422 hprofAddU4ListToRecord(rec, (const u4 *)aobj->contents, 423 length); 424 } else if (size == 8) { 425 hprofAddU8ListToRecord(rec, (const u8 *)aobj->contents, 426 length); 427 } 428 #endif 429 } 430 } else { 431 const ClassObject *sclass; 432 size_t sizePatchOffset, savedLen; 433 434 /* obj is an instance object. 435 */ 436 hprofAddU1ToRecord(rec, HPROF_INSTANCE_DUMP); 437 hprofAddIdToRecord(rec, (hprof_object_id)obj); 438 hprofAddU4ToRecord(rec, stackTraceSerialNumber(obj)); 439 hprofAddIdToRecord(rec, hprofLookupClassId(clazz)); 440 441 /* Reserve some space for the length of the instance 442 * data, which we won't know until we're done writing 443 * it. 444 */ 445 sizePatchOffset = rec->length; 446 hprofAddU4ToRecord(rec, 0x77777777); 447 448 /* Write the instance data; fields for this 449 * class, followed by super class fields, and so on. 450 */ 451 sclass = clazz; 452 while (sclass != NULL) { 453 int i, ifieldCount; 454 455 ifieldCount = sclass->ifieldCount; 456 for (i = 0; i < ifieldCount; i++) { 457 const InstField *f = &sclass->ifields[i]; 458 hprof_basic_type t; 459 size_t size; 460 461 t = signatureToBasicTypeAndSize(f->field.signature, &size); 462 if (size == 1) { 463 hprofAddU1ToRecord(rec, 464 (u1)dvmGetFieldByte(obj, f->byteOffset)); 465 } else if (size == 2) { 466 hprofAddU2ToRecord(rec, 467 (u2)dvmGetFieldChar(obj, f->byteOffset)); 468 } else if (size == 4) { 469 hprofAddU4ToRecord(rec, 470 (u4)dvmGetFieldInt(obj, f->byteOffset)); 471 } else if (size == 8) { 472 hprofAddU8ToRecord(rec, 473 (u8)dvmGetFieldLong(obj, f->byteOffset)); 474 } else { 475 assert(false); 476 } 477 } 478 479 sclass = sclass->super; 480 } 481 482 /* Patch the instance field length. 483 */ 484 savedLen = rec->length; 485 rec->length = sizePatchOffset; 486 hprofAddU4ToRecord(rec, savedLen - (sizePatchOffset + 4)); 487 rec->length = savedLen; 488 } 489 } 490 491 ctx->objectsInSegment++; 492 493 return 0; 494 } 495
