1 /* 2 * Copyright (c) 2003, 2025, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 25 #include "classfile/classLoaderDataGraph.hpp" 26 #include "classfile/javaClasses.inline.hpp" 27 #include "classfile/symbolTable.hpp" 28 #include "classfile/vmClasses.hpp" 29 #include "classfile/vmSymbols.hpp" 30 #include "gc/shared/collectedHeap.hpp" 31 #include "jvmtifiles/jvmtiEnv.hpp" 32 #include "logging/log.hpp" 33 #include "memory/allocation.inline.hpp" 34 #include "memory/resourceArea.hpp" 35 #include "memory/universe.hpp" 36 #include "oops/access.inline.hpp" 37 #include "oops/arrayOop.hpp" 38 #include "oops/constantPool.inline.hpp" 39 #include "oops/instanceMirrorKlass.hpp" 40 #include "oops/klass.inline.hpp" 41 #include "oops/objArrayKlass.hpp" 42 #include "oops/objArrayOop.inline.hpp" 43 #include "oops/oop.inline.hpp" 44 #include "oops/typeArrayOop.inline.hpp" 45 #include "prims/jvmtiEventController.hpp" 46 #include "prims/jvmtiEventController.inline.hpp" 47 #include "prims/jvmtiExport.hpp" 48 #include "prims/jvmtiImpl.hpp" 49 #include "prims/jvmtiTagMap.hpp" 50 #include "prims/jvmtiTagMapTable.hpp" 51 #include "prims/jvmtiThreadState.hpp" 52 #include "runtime/continuationWrapper.inline.hpp" 53 #include "runtime/deoptimization.hpp" 54 #include "runtime/frame.inline.hpp" 55 #include "runtime/handles.inline.hpp" 56 #include "runtime/interfaceSupport.inline.hpp" 57 #include "runtime/javaCalls.hpp" 58 #include "runtime/javaThread.inline.hpp" 59 #include "runtime/jniHandles.inline.hpp" 60 #include "runtime/mutex.hpp" 61 #include "runtime/mutexLocker.hpp" 62 #include "runtime/reflectionUtils.hpp" 63 #include "runtime/safepoint.hpp" 64 #include "runtime/timerTrace.hpp" 65 #include "runtime/threadSMR.hpp" 66 #include "runtime/vframe.hpp" 67 #include "runtime/vmThread.hpp" 68 #include "runtime/vmOperations.hpp" 69 #include "utilities/objectBitSet.inline.hpp" 70 #include "utilities/macros.hpp" 71 72 typedef ObjectBitSet<mtServiceability> JVMTIBitSet; 73 74 75 // Helper class to store objects to visit. 76 class JvmtiHeapwalkVisitStack { 77 private: 78 enum { 79 initial_visit_stack_size = 4000 80 }; 81 82 GrowableArray<JvmtiHeapwalkObject>* _visit_stack; 83 JVMTIBitSet _bitset; 84 85 static GrowableArray<JvmtiHeapwalkObject>* create_visit_stack() { 86 return new (mtServiceability) GrowableArray<JvmtiHeapwalkObject>(initial_visit_stack_size, mtServiceability); 87 } 88 89 public: 90 JvmtiHeapwalkVisitStack(): _visit_stack(create_visit_stack()) { 91 } 92 ~JvmtiHeapwalkVisitStack() { 93 if (_visit_stack != nullptr) { 94 delete _visit_stack; 95 } 96 } 97 98 bool is_empty() const { 99 return _visit_stack->is_empty(); 100 } 101 102 void push(const JvmtiHeapwalkObject& obj) { 103 _visit_stack->push(obj); 104 } 105 106 // If the object hasn't been visited then push it onto the visit stack 107 // so that it will be visited later. 108 void check_for_visit(const JvmtiHeapwalkObject& obj) { 109 if (!is_visited(obj)) { 110 _visit_stack->push(obj); 111 } 112 } 113 114 JvmtiHeapwalkObject pop() { 115 return _visit_stack->pop(); 116 } 117 118 bool is_visited(const JvmtiHeapwalkObject& obj) /*const*/ { // TODO: _bitset.is_marked() should be const 119 // The method is called only for objects from visit_stack to ensure an object is not visited twice. 120 // Flat objects can be added to visit_stack only when we visit their holder object, so we cannot get duplicate reference to it. 121 if (obj.is_flat()) { 122 return false; 123 } 124 return _bitset.is_marked(obj.obj()); 125 } 126 127 void mark_visited(const JvmtiHeapwalkObject& obj) { 128 if (!obj.is_flat()) { 129 _bitset.mark_obj(obj.obj()); 130 } 131 } 132 }; 133 134 135 bool JvmtiTagMap::_has_object_free_events = false; 136 137 // create a JvmtiTagMap 138 JvmtiTagMap::JvmtiTagMap(JvmtiEnv* env) : 139 _env(env), 140 _lock(Mutex::nosafepoint, "JvmtiTagMap_lock"), 141 _needs_cleaning(false), 142 _posting_events(false), 143 _converting_flat_object(false) { 144 145 assert(JvmtiThreadState_lock->is_locked(), "sanity check"); 146 assert(((JvmtiEnvBase *)env)->tag_map() == nullptr, "tag map already exists for environment"); 147 148 _hashmap = new JvmtiTagMapTable(); 149 _flat_hashmap = new JvmtiFlatTagMapTable(); 150 151 // finally add us to the environment 152 ((JvmtiEnvBase *)env)->release_set_tag_map(this); 153 } 154 155 // destroy a JvmtiTagMap 156 JvmtiTagMap::~JvmtiTagMap() { 157 158 // no lock acquired as we assume the enclosing environment is 159 // also being destroyed. 160 ((JvmtiEnvBase *)_env)->set_tag_map(nullptr); 161 162 // finally destroy the hashmap 163 delete _hashmap; 164 _hashmap = nullptr; 165 delete _flat_hashmap; 166 } 167 168 // Called by env_dispose() to reclaim memory before deallocation. 169 // Remove all the entries but keep the empty table intact. 170 // This needs the table lock. 171 void JvmtiTagMap::clear() { 172 MutexLocker ml(lock(), Mutex::_no_safepoint_check_flag); 173 _hashmap->clear(); 174 _flat_hashmap->clear(); 175 } 176 177 // returns the tag map for the given environments. If the tag map 178 // doesn't exist then it is created. 179 JvmtiTagMap* JvmtiTagMap::tag_map_for(JvmtiEnv* env) { 180 JvmtiTagMap* tag_map = ((JvmtiEnvBase*)env)->tag_map_acquire(); 181 if (tag_map == nullptr) { 182 MutexLocker mu(JvmtiThreadState_lock); 183 tag_map = ((JvmtiEnvBase*)env)->tag_map(); 184 if (tag_map == nullptr) { 185 tag_map = new JvmtiTagMap(env); 186 } 187 } else { 188 DEBUG_ONLY(JavaThread::current()->check_possible_safepoint()); 189 } 190 return tag_map; 191 } 192 193 // returns true if the hashmaps are empty 194 bool JvmtiTagMap::is_empty() const { 195 assert(SafepointSynchronize::is_at_safepoint() || is_locked(), "checking"); 196 return _hashmap->is_empty() && _flat_hashmap->is_empty(); 197 } 198 199 // This checks for posting before operations that use 200 // this tagmap table. 201 void JvmtiTagMap::check_hashmap(GrowableArray<jlong>* objects) { 202 assert(is_locked(), "checking"); 203 204 if (is_empty()) { return; } 205 206 if (_needs_cleaning && 207 objects != nullptr && 208 env()->is_enabled(JVMTI_EVENT_OBJECT_FREE)) { 209 remove_dead_entries_locked(objects); 210 } 211 } 212 213 // This checks for posting and is called from the heap walks. 214 void JvmtiTagMap::check_hashmaps_for_heapwalk(GrowableArray<jlong>* objects) { 215 assert(SafepointSynchronize::is_at_safepoint(), "called from safepoints"); 216 217 // Verify that the tag map tables are valid and unconditionally post events 218 // that are expected to be posted before gc_notification. 219 JvmtiEnvIterator it; 220 for (JvmtiEnv* env = it.first(); env != nullptr; env = it.next(env)) { 221 JvmtiTagMap* tag_map = env->tag_map_acquire(); 222 if (tag_map != nullptr) { 223 // The ZDriver may be walking the hashmaps concurrently so this lock is needed. 224 MutexLocker ml(tag_map->lock(), Mutex::_no_safepoint_check_flag); 225 tag_map->check_hashmap(objects); 226 } 227 } 228 } 229 230 // Converts entries from JvmtiFlatTagMapTable to JvmtiTagMapTable in batches. 231 // 1. (JvmtiTagMap is locked) 232 // reads entries from JvmtiFlatTagMapTable (describe flat value objects); 233 // 2. (JvmtiTagMap is unlocked) 234 // creates heap-allocated copies of the flat object; 235 // 3. (JvmtiTagMap is locked) 236 // ensures source entry still exists, removes it from JvmtiFlatTagMapTable, adds new entry to JvmtiTagMapTable. 237 // If some error occurs in step 2 (OOM?), the process stops. 238 class JvmtiTagMapFlatEntryConverter: public StackObj { 239 private: 240 struct Entry { 241 // source flat value object 242 Handle holder; 243 int offset; 244 InlineKlass* inline_klass; 245 LayoutKind layout_kind; 246 // converted heap-allocated object 247 Handle dst; 248 249 Entry(): holder(), offset(0), inline_klass(nullptr), dst() {} 250 Entry(Handle holder, int offset, InlineKlass* inline_klass, LayoutKind lk) 251 : holder(holder), offset(offset), inline_klass(inline_klass), layout_kind(lk), dst() {} 252 }; 253 254 int _batch_size; 255 GrowableArray<Entry> _entries; 256 bool _has_error; 257 258 public: 259 JvmtiTagMapFlatEntryConverter(int batch_size): _batch_size(batch_size), _entries(batch_size, mtServiceability), _has_error(false) { } 260 ~JvmtiTagMapFlatEntryConverter() {} 261 262 // returns false if there is nothing to convert 263 bool import_entries(JvmtiFlatTagMapTable* table) { 264 if (_has_error) { 265 // stop the process to avoid infinite loop 266 return false; 267 } 268 269 class Importer: public JvmtiFlatTagMapKeyClosure { 270 private: 271 GrowableArray<Entry>& _entries; 272 int _batch_size; 273 public: 274 Importer(GrowableArray<Entry>& entries, int batch_size): _entries(entries), _batch_size(batch_size) {} 275 276 bool do_entry(JvmtiFlatTagMapKey& key, jlong& tag) { 277 Entry entry(Handle(Thread::current(), key.holder()), key.offset(), key.inline_klass(), key.layout_kind()); 278 _entries.append(entry); 279 280 return _entries.length() < _batch_size; 281 } 282 } importer(_entries, _batch_size); 283 table->entry_iterate(&importer); 284 285 return !_entries.is_empty(); 286 } 287 288 void convert() { 289 for (int i = 0; i < _entries.length(); i++) { 290 EXCEPTION_MARK; 291 Entry& entry = _entries.at(i); 292 oop obj = entry.inline_klass->read_payload_from_addr(entry.holder(), entry.offset, entry.layout_kind, JavaThread::current()); 293 294 if (HAS_PENDING_EXCEPTION) { 295 tty->print_cr("Exception in JvmtiTagMapFlatEntryConverter: "); 296 java_lang_Throwable::print(PENDING_EXCEPTION, tty); 297 tty->cr(); 298 CLEAR_PENDING_EXCEPTION; 299 // stop the conversion 300 _has_error = true; 301 } else { 302 entry.dst = Handle(Thread::current(), obj); 303 } 304 } 305 } 306 307 // returns number of converted entries 308 int move(JvmtiFlatTagMapTable* src_table, JvmtiTagMapTable* dst_table) { 309 int count = 0; 310 for (int i = 0; i < _entries.length(); i++) { 311 Entry& entry = _entries.at(i); 312 if (entry.dst() == nullptr) { 313 // some error during conversion, skip the entry 314 continue; 315 } 316 JvmtiHeapwalkObject obj(entry.holder(), entry.offset, entry.inline_klass, entry.layout_kind); 317 jlong tag = src_table->remove(obj); 318 319 if (tag != 0) { // ensure the entry is still in the src_table 320 dst_table->add(entry.dst(), tag); 321 count++; 322 } else { 323 324 } 325 } 326 // and clean the array 327 _entries.clear(); 328 return count; 329 } 330 }; 331 332 333 void JvmtiTagMap::convert_flat_object_entries() { 334 Thread* current = Thread::current(); 335 assert(current->is_Java_thread(), "must be executed on JavaThread"); 336 337 log_debug(jvmti, table)("convert_flat_object_entries, main table size = %d, flat table size = %d", 338 _hashmap->number_of_entries(), _flat_hashmap->number_of_entries()); 339 340 { 341 MonitorLocker ml(lock(), Mutex::_no_safepoint_check_flag); 342 // If another thread is converting, let it finish. 343 while (_converting_flat_object) { 344 ml.wait(); 345 } 346 if (_flat_hashmap->is_empty()) { 347 // nothing to convert 348 return; 349 } 350 _converting_flat_object = true; 351 } 352 353 const int BATCH_SIZE = 1024; 354 JvmtiTagMapFlatEntryConverter converter(BATCH_SIZE); 355 356 int count = 0; 357 while (true) { 358 HandleMark hm(current); 359 { 360 MonitorLocker ml(lock(), Mutex::_no_safepoint_check_flag); 361 if (!converter.import_entries(_flat_hashmap)) { 362 break; 363 } 364 } 365 // Convert flat objects to heap-allocated without table lock (so agent callbacks can get/set tags). 366 converter.convert(); 367 { 368 MonitorLocker ml(lock(), Mutex::_no_safepoint_check_flag); 369 count += converter.move(_flat_hashmap, _hashmap); 370 } 371 } 372 373 log_info(jvmti, table)("%d flat value objects are converted, flat table size = %d", 374 count, _flat_hashmap->number_of_entries()); 375 { 376 MonitorLocker ml(lock(), Mutex::_no_safepoint_check_flag); 377 _converting_flat_object = false; 378 ml.notify_all(); 379 } 380 } 381 382 jlong JvmtiTagMap::find(const JvmtiHeapwalkObject& obj) const { 383 jlong tag = _hashmap->find(obj); 384 if (tag == 0 && obj.is_value()) { 385 tag = _flat_hashmap->find(obj); 386 } 387 return tag; 388 } 389 390 void JvmtiTagMap::add(const JvmtiHeapwalkObject& obj, jlong tag) { 391 if (obj.is_flat()) { 392 // we may have tag for equal (non-flat) object in _hashmap, try to update it 1st 393 if (!_hashmap->update(obj, tag)) { 394 // no entry in _hashmap, add to _flat_hashmap 395 _flat_hashmap->add(obj, tag); 396 } 397 } else { 398 _hashmap->add(obj, tag); 399 } 400 } 401 402 void JvmtiTagMap::remove(const JvmtiHeapwalkObject& obj) { 403 if (!_hashmap->remove(obj)) { 404 if (obj.is_value()) { 405 _flat_hashmap->remove(obj); 406 } 407 } 408 } 409 410 411 // A CallbackWrapper is a support class for querying and tagging an object 412 // around a callback to a profiler. The constructor does pre-callback 413 // work to get the tag value, klass tag value, ... and the destructor 414 // does the post-callback work of tagging or untagging the object. 415 // 416 // { 417 // CallbackWrapper wrapper(tag_map, o); 418 // 419 // (*callback)(wrapper.klass_tag(), wrapper.obj_size(), wrapper.obj_tag_p(), ...) 420 // 421 // } 422 // wrapper goes out of scope here which results in the destructor 423 // checking to see if the object has been tagged, untagged, or the 424 // tag value has changed. 425 // 426 class CallbackWrapper : public StackObj { 427 private: 428 JvmtiTagMap* _tag_map; 429 const JvmtiHeapwalkObject& _o; 430 jlong _obj_size; 431 jlong _obj_tag; 432 jlong _klass_tag; 433 434 protected: 435 JvmtiTagMap* tag_map() const { return _tag_map; } 436 437 // invoked post-callback to tag, untag, or update the tag of an object 438 void inline post_callback_tag_update(const JvmtiHeapwalkObject& o, JvmtiTagMap* tag_map, jlong obj_tag); 439 440 public: 441 CallbackWrapper(JvmtiTagMap* tag_map, const JvmtiHeapwalkObject& o) 442 : _tag_map(tag_map), _o(o) 443 { 444 assert(Thread::current()->is_VM_thread() || tag_map->is_locked(), 445 "MT unsafe or must be VM thread"); 446 447 // object size 448 if (!o.is_flat()) { 449 // common case: we have oop 450 _obj_size = (jlong)o.obj()->size() * wordSize; 451 } else { 452 // flat value object, we know its InstanceKlass 453 assert(_o.inline_klass() != nullptr, "must be"); 454 _obj_size = _o.inline_klass()->size() * wordSize;; 455 } 456 457 // get object tag 458 _obj_tag = _tag_map->find(_o); 459 460 // get the class and the class's tag value 461 assert(vmClasses::Class_klass()->is_mirror_instance_klass(), "Is not?"); 462 463 _klass_tag = _tag_map->find(_o.klass()->java_mirror()); 464 } 465 466 ~CallbackWrapper() { 467 post_callback_tag_update(_o, _tag_map, _obj_tag); 468 } 469 470 inline jlong* obj_tag_p() { return &_obj_tag; } 471 inline jlong obj_size() const { return _obj_size; } 472 inline jlong obj_tag() const { return _obj_tag; } 473 inline jlong klass_tag() const { return _klass_tag; } 474 }; 475 476 // callback post-callback to tag, untag, or update the tag of an object 477 void inline CallbackWrapper::post_callback_tag_update(const JvmtiHeapwalkObject& o, 478 JvmtiTagMap* tag_map, 479 jlong obj_tag) { 480 if (obj_tag == 0) { 481 // callback has untagged the object, remove the entry if present 482 tag_map->remove(o); 483 } else { 484 // object was previously tagged or not present - the callback may have 485 // changed the tag value 486 assert(Thread::current()->is_VM_thread(), "must be VMThread"); 487 tag_map->add(o, obj_tag); 488 } 489 } 490 491 // An extended CallbackWrapper used when reporting an object reference 492 // to the agent. 493 // 494 // { 495 // TwoOopCallbackWrapper wrapper(tag_map, referrer, o); 496 // 497 // (*callback)(wrapper.klass_tag(), 498 // wrapper.obj_size(), 499 // wrapper.obj_tag_p() 500 // wrapper.referrer_tag_p(), ...) 501 // 502 // } 503 // wrapper goes out of scope here which results in the destructor 504 // checking to see if the referrer object has been tagged, untagged, 505 // or the tag value has changed. 506 // 507 class TwoOopCallbackWrapper : public CallbackWrapper { 508 private: 509 const JvmtiHeapwalkObject& _referrer; 510 bool _is_reference_to_self; 511 jlong _referrer_obj_tag; 512 jlong _referrer_klass_tag; 513 jlong* _referrer_tag_p; 514 515 bool is_reference_to_self() const { return _is_reference_to_self; } 516 517 public: 518 TwoOopCallbackWrapper(JvmtiTagMap* tag_map, const JvmtiHeapwalkObject& referrer, const JvmtiHeapwalkObject& o) : 519 CallbackWrapper(tag_map, o), _referrer(referrer) 520 { 521 // self reference needs to be handled in a special way 522 _is_reference_to_self = (referrer == o); 523 524 if (_is_reference_to_self) { 525 _referrer_klass_tag = klass_tag(); 526 _referrer_tag_p = obj_tag_p(); 527 } else { 528 // get object tag 529 _referrer_obj_tag = tag_map->find(_referrer); 530 531 _referrer_tag_p = &_referrer_obj_tag; 532 533 // get referrer class tag. 534 _referrer_klass_tag = tag_map->find(_referrer.klass()->java_mirror()); 535 } 536 } 537 538 ~TwoOopCallbackWrapper() { 539 if (!is_reference_to_self()) { 540 post_callback_tag_update(_referrer, 541 tag_map(), 542 _referrer_obj_tag); 543 } 544 } 545 546 // address of referrer tag 547 // (for a self reference this will return the same thing as obj_tag_p()) 548 inline jlong* referrer_tag_p() { return _referrer_tag_p; } 549 550 // referrer's class tag 551 inline jlong referrer_klass_tag() { return _referrer_klass_tag; } 552 }; 553 554 // tag an object 555 // 556 // This function is performance critical. If many threads attempt to tag objects 557 // around the same time then it's possible that the Mutex associated with the 558 // tag map will be a hot lock. 559 void JvmtiTagMap::set_tag(jobject object, jlong tag) { 560 MutexLocker ml(lock(), Mutex::_no_safepoint_check_flag); 561 562 // SetTag should not post events because the JavaThread has to 563 // transition to native for the callback and this cannot stop for 564 // safepoints with the hashmap lock held. 565 check_hashmap(nullptr); /* don't collect dead objects */ 566 567 // resolve the object 568 oop o = JNIHandles::resolve_non_null(object); 569 // see if the object is already tagged 570 JvmtiHeapwalkObject obj(o); 571 if (tag == 0) { 572 // remove the entry if present 573 _hashmap->remove(obj); 574 } else { 575 // if the object is already tagged or not present then we add/update 576 // the tag 577 add(obj, tag); 578 } 579 } 580 581 // get the tag for an object 582 jlong JvmtiTagMap::get_tag(jobject object) { 583 MutexLocker ml(lock(), Mutex::_no_safepoint_check_flag); 584 585 // GetTag should not post events because the JavaThread has to 586 // transition to native for the callback and this cannot stop for 587 // safepoints with the hashmap lock held. 588 check_hashmap(nullptr); /* don't collect dead objects */ 589 590 // resolve the object 591 oop o = JNIHandles::resolve_non_null(object); 592 593 return find(o); 594 } 595 596 597 // Helper class used to describe the static or instance fields of a class. 598 // For each field it holds the field index (as defined by the JVMTI specification), 599 // the field type, and the offset. 600 601 class ClassFieldDescriptor: public CHeapObj<mtInternal> { 602 private: 603 int _field_index; 604 int _field_offset; 605 char _field_type; 606 InlineKlass* _inline_klass; // nullptr for heap object 607 LayoutKind _layout_kind; 608 public: 609 ClassFieldDescriptor(int index, const FieldStreamBase& fld) : 610 _field_index(index), _field_offset(fld.offset()), _field_type(fld.signature()->char_at(0)) { 611 if (fld.is_flat()) { 612 const fieldDescriptor& fd = fld.field_descriptor(); 613 InstanceKlass* holder_klass = fd.field_holder(); 614 InlineLayoutInfo* layout_info = holder_klass->inline_layout_info_adr(fd.index()); 615 _inline_klass = layout_info->klass(); 616 _layout_kind = layout_info->kind(); 617 } else { 618 _inline_klass = nullptr; 619 _layout_kind = LayoutKind::REFERENCE; 620 } 621 } 622 int field_index() const { return _field_index; } 623 char field_type() const { return _field_type; } 624 int field_offset() const { return _field_offset; } 625 bool is_flat() const { return _inline_klass != nullptr; } 626 InlineKlass* inline_klass() const { return _inline_klass; } 627 LayoutKind layout_kind() const { return _layout_kind; } 628 }; 629 630 class ClassFieldMap: public CHeapObj<mtInternal> { 631 private: 632 enum { 633 initial_field_count = 5 634 }; 635 636 // list of field descriptors 637 GrowableArray<ClassFieldDescriptor*>* _fields; 638 639 // constructor 640 ClassFieldMap(); 641 642 // calculates number of fields in all interfaces 643 static int interfaces_field_count(InstanceKlass* ik); 644 645 // add a field 646 void add(int index, const FieldStreamBase& fld); 647 648 public: 649 ~ClassFieldMap(); 650 651 // access 652 int field_count() { return _fields->length(); } 653 ClassFieldDescriptor* field_at(int i) { return _fields->at(i); } 654 655 // functions to create maps of static or instance fields 656 static ClassFieldMap* create_map_of_static_fields(Klass* k); 657 static ClassFieldMap* create_map_of_instance_fields(Klass* k); 658 }; 659 660 ClassFieldMap::ClassFieldMap() { 661 _fields = new (mtServiceability) 662 GrowableArray<ClassFieldDescriptor*>(initial_field_count, mtServiceability); 663 } 664 665 ClassFieldMap::~ClassFieldMap() { 666 for (int i=0; i<_fields->length(); i++) { 667 delete _fields->at(i); 668 } 669 delete _fields; 670 } 671 672 int ClassFieldMap::interfaces_field_count(InstanceKlass* ik) { 673 const Array<InstanceKlass*>* interfaces = ik->transitive_interfaces(); 674 int count = 0; 675 for (int i = 0; i < interfaces->length(); i++) { 676 FilteredJavaFieldStream fld(interfaces->at(i)); 677 count += fld.field_count(); 678 } 679 return count; 680 } 681 682 void ClassFieldMap::add(int index, const FieldStreamBase& fld) { 683 ClassFieldDescriptor* field = new ClassFieldDescriptor(index, fld); 684 _fields->append(field); 685 } 686 687 // Returns a heap allocated ClassFieldMap to describe the static fields 688 // of the given class. 689 ClassFieldMap* ClassFieldMap::create_map_of_static_fields(Klass* k) { 690 InstanceKlass* ik = InstanceKlass::cast(k); 691 692 // create the field map 693 ClassFieldMap* field_map = new ClassFieldMap(); 694 695 // Static fields of interfaces and superclasses are reported as references from the interfaces/superclasses. 696 // Need to calculate start index of this class fields: number of fields in all interfaces and superclasses. 697 int index = interfaces_field_count(ik); 698 for (InstanceKlass* super_klass = ik->java_super(); super_klass != nullptr; super_klass = super_klass->java_super()) { 699 FilteredJavaFieldStream super_fld(super_klass); 700 index += super_fld.field_count(); 701 } 702 703 for (FilteredJavaFieldStream fld(ik); !fld.done(); fld.next(), index++) { 704 // ignore instance fields 705 if (!fld.access_flags().is_static()) { 706 continue; 707 } 708 field_map->add(index, fld); 709 } 710 711 return field_map; 712 } 713 714 // Returns a heap allocated ClassFieldMap to describe the instance fields 715 // of the given class. All instance fields are included (this means public 716 // and private fields declared in superclasses too). 717 ClassFieldMap* ClassFieldMap::create_map_of_instance_fields(Klass* k) { 718 InstanceKlass* ik = InstanceKlass::cast(k); 719 720 // create the field map 721 ClassFieldMap* field_map = new ClassFieldMap(); 722 723 // fields of the superclasses are reported first, so need to know total field number to calculate field indices 724 int total_field_number = interfaces_field_count(ik); 725 for (InstanceKlass* klass = ik; klass != nullptr; klass = klass->java_super()) { 726 FilteredJavaFieldStream fld(klass); 727 total_field_number += fld.field_count(); 728 } 729 730 for (InstanceKlass* klass = ik; klass != nullptr; klass = klass->java_super()) { 731 FilteredJavaFieldStream fld(klass); 732 int start_index = total_field_number - fld.field_count(); 733 for (int index = 0; !fld.done(); fld.next(), index++) { 734 // ignore static fields 735 if (fld.access_flags().is_static()) { 736 continue; 737 } 738 field_map->add(start_index + index, fld); 739 } 740 // update total_field_number for superclass (decrease by the field count in the current class) 741 total_field_number = start_index; 742 } 743 744 return field_map; 745 } 746 747 // Helper class used to cache a ClassFileMap for the instance fields of 748 // a cache. A JvmtiCachedClassFieldMap can be cached by an InstanceKlass during 749 // heap iteration and avoid creating a field map for each object in the heap 750 // (only need to create the map when the first instance of a class is encountered). 751 // 752 class JvmtiCachedClassFieldMap : public CHeapObj<mtInternal> { 753 private: 754 enum { 755 initial_class_count = 200 756 }; 757 ClassFieldMap* _field_map; 758 759 ClassFieldMap* field_map() const { return _field_map; } 760 761 JvmtiCachedClassFieldMap(ClassFieldMap* field_map); 762 ~JvmtiCachedClassFieldMap(); 763 764 static GrowableArray<InstanceKlass*>* _class_list; 765 static void add_to_class_list(InstanceKlass* ik); 766 767 public: 768 // returns the field map for a given klass (returning map cached 769 // by InstanceKlass if possible 770 static ClassFieldMap* get_map_of_instance_fields(Klass* k); 771 772 // removes the field map from all instanceKlasses - should be 773 // called before VM operation completes 774 static void clear_cache(); 775 776 // returns the number of ClassFieldMap cached by instanceKlasses 777 static int cached_field_map_count(); 778 }; 779 780 GrowableArray<InstanceKlass*>* JvmtiCachedClassFieldMap::_class_list; 781 782 JvmtiCachedClassFieldMap::JvmtiCachedClassFieldMap(ClassFieldMap* field_map) { 783 _field_map = field_map; 784 } 785 786 JvmtiCachedClassFieldMap::~JvmtiCachedClassFieldMap() { 787 if (_field_map != nullptr) { 788 delete _field_map; 789 } 790 } 791 792 // Marker class to ensure that the class file map cache is only used in a defined 793 // scope. 794 class ClassFieldMapCacheMark : public StackObj { 795 private: 796 static bool _is_active; 797 public: 798 ClassFieldMapCacheMark() { 799 assert(Thread::current()->is_VM_thread(), "must be VMThread"); 800 assert(JvmtiCachedClassFieldMap::cached_field_map_count() == 0, "cache not empty"); 801 assert(!_is_active, "ClassFieldMapCacheMark cannot be nested"); 802 _is_active = true; 803 } 804 ~ClassFieldMapCacheMark() { 805 JvmtiCachedClassFieldMap::clear_cache(); 806 _is_active = false; 807 } 808 static bool is_active() { return _is_active; } 809 }; 810 811 bool ClassFieldMapCacheMark::_is_active; 812 813 // record that the given InstanceKlass is caching a field map 814 void JvmtiCachedClassFieldMap::add_to_class_list(InstanceKlass* ik) { 815 if (_class_list == nullptr) { 816 _class_list = new (mtServiceability) 817 GrowableArray<InstanceKlass*>(initial_class_count, mtServiceability); 818 } 819 _class_list->push(ik); 820 } 821 822 // returns the instance field map for the given klass 823 // (returns field map cached by the InstanceKlass if possible) 824 ClassFieldMap* JvmtiCachedClassFieldMap::get_map_of_instance_fields(Klass *k) { 825 assert(Thread::current()->is_VM_thread(), "must be VMThread"); 826 assert(ClassFieldMapCacheMark::is_active(), "ClassFieldMapCacheMark not active"); 827 828 InstanceKlass* ik = InstanceKlass::cast(k); 829 830 // return cached map if possible 831 JvmtiCachedClassFieldMap* cached_map = ik->jvmti_cached_class_field_map(); 832 if (cached_map != nullptr) { 833 assert(cached_map->field_map() != nullptr, "missing field list"); 834 return cached_map->field_map(); 835 } else { 836 ClassFieldMap* field_map = ClassFieldMap::create_map_of_instance_fields(k); 837 cached_map = new JvmtiCachedClassFieldMap(field_map); 838 ik->set_jvmti_cached_class_field_map(cached_map); 839 add_to_class_list(ik); 840 return field_map; 841 } 842 } 843 844 // remove the fields maps cached from all instanceKlasses 845 void JvmtiCachedClassFieldMap::clear_cache() { 846 assert(Thread::current()->is_VM_thread(), "must be VMThread"); 847 if (_class_list != nullptr) { 848 for (int i = 0; i < _class_list->length(); i++) { 849 InstanceKlass* ik = _class_list->at(i); 850 JvmtiCachedClassFieldMap* cached_map = ik->jvmti_cached_class_field_map(); 851 assert(cached_map != nullptr, "should not be null"); 852 ik->set_jvmti_cached_class_field_map(nullptr); 853 delete cached_map; // deletes the encapsulated field map 854 } 855 delete _class_list; 856 _class_list = nullptr; 857 } 858 } 859 860 // returns the number of ClassFieldMap cached by instanceKlasses 861 int JvmtiCachedClassFieldMap::cached_field_map_count() { 862 return (_class_list == nullptr) ? 0 : _class_list->length(); 863 } 864 865 // helper function to indicate if an object is filtered by its tag or class tag 866 static inline bool is_filtered_by_heap_filter(jlong obj_tag, 867 jlong klass_tag, 868 int heap_filter) { 869 // apply the heap filter 870 if (obj_tag != 0) { 871 // filter out tagged objects 872 if (heap_filter & JVMTI_HEAP_FILTER_TAGGED) return true; 873 } else { 874 // filter out untagged objects 875 if (heap_filter & JVMTI_HEAP_FILTER_UNTAGGED) return true; 876 } 877 if (klass_tag != 0) { 878 // filter out objects with tagged classes 879 if (heap_filter & JVMTI_HEAP_FILTER_CLASS_TAGGED) return true; 880 } else { 881 // filter out objects with untagged classes. 882 if (heap_filter & JVMTI_HEAP_FILTER_CLASS_UNTAGGED) return true; 883 } 884 return false; 885 } 886 887 // helper function to indicate if an object is filtered by a klass filter 888 static inline bool is_filtered_by_klass_filter(const JvmtiHeapwalkObject& obj, Klass* klass_filter) { 889 if (klass_filter != nullptr) { 890 if (obj.klass() != klass_filter) { 891 return true; 892 } 893 } 894 return false; 895 } 896 897 // helper function to tell if a field is a primitive field or not 898 static inline bool is_primitive_field_type(char type) { 899 return (type != JVM_SIGNATURE_CLASS && type != JVM_SIGNATURE_ARRAY); 900 } 901 902 // helper function to copy the value from location addr to jvalue. 903 static inline void copy_to_jvalue(jvalue *v, address addr, jvmtiPrimitiveType value_type) { 904 switch (value_type) { 905 case JVMTI_PRIMITIVE_TYPE_BOOLEAN : { v->z = *(jboolean*)addr; break; } 906 case JVMTI_PRIMITIVE_TYPE_BYTE : { v->b = *(jbyte*)addr; break; } 907 case JVMTI_PRIMITIVE_TYPE_CHAR : { v->c = *(jchar*)addr; break; } 908 case JVMTI_PRIMITIVE_TYPE_SHORT : { v->s = *(jshort*)addr; break; } 909 case JVMTI_PRIMITIVE_TYPE_INT : { v->i = *(jint*)addr; break; } 910 case JVMTI_PRIMITIVE_TYPE_LONG : { v->j = *(jlong*)addr; break; } 911 case JVMTI_PRIMITIVE_TYPE_FLOAT : { v->f = *(jfloat*)addr; break; } 912 case JVMTI_PRIMITIVE_TYPE_DOUBLE : { v->d = *(jdouble*)addr; break; } 913 default: ShouldNotReachHere(); 914 } 915 } 916 917 // helper function to invoke string primitive value callback 918 // returns visit control flags 919 static jint invoke_string_value_callback(jvmtiStringPrimitiveValueCallback cb, 920 CallbackWrapper* wrapper, 921 const JvmtiHeapwalkObject& obj, 922 void* user_data) 923 { 924 assert(!obj.is_flat(), "cannot be flat"); 925 oop str = obj.obj(); 926 assert(str->klass() == vmClasses::String_klass(), "not a string"); 927 928 typeArrayOop s_value = java_lang_String::value(str); 929 930 // JDK-6584008: the value field may be null if a String instance is 931 // partially constructed. 932 if (s_value == nullptr) { 933 return 0; 934 } 935 // get the string value and length 936 // (string value may be offset from the base) 937 int s_len = java_lang_String::length(str); 938 bool is_latin1 = java_lang_String::is_latin1(str); 939 jchar* value; 940 if (s_len > 0) { 941 if (!is_latin1) { 942 value = s_value->char_at_addr(0); 943 } else { 944 // Inflate latin1 encoded string to UTF16 945 jchar* buf = NEW_C_HEAP_ARRAY(jchar, s_len, mtInternal); 946 for (int i = 0; i < s_len; i++) { 947 buf[i] = ((jchar) s_value->byte_at(i)) & 0xff; 948 } 949 value = &buf[0]; 950 } 951 } else { 952 // Don't use char_at_addr(0) if length is 0 953 value = (jchar*) s_value->base(T_CHAR); 954 } 955 956 // invoke the callback 957 jint res = (*cb)(wrapper->klass_tag(), 958 wrapper->obj_size(), 959 wrapper->obj_tag_p(), 960 value, 961 (jint)s_len, 962 user_data); 963 964 if (is_latin1 && s_len > 0) { 965 FREE_C_HEAP_ARRAY(jchar, value); 966 } 967 return res; 968 } 969 970 // helper function to invoke string primitive value callback 971 // returns visit control flags 972 static jint invoke_array_primitive_value_callback(jvmtiArrayPrimitiveValueCallback cb, 973 CallbackWrapper* wrapper, 974 const JvmtiHeapwalkObject& obj, 975 void* user_data) 976 { 977 assert(!obj.is_flat(), "cannot be flat"); 978 assert(obj.obj()->is_typeArray(), "not a primitive array"); 979 980 // get base address of first element 981 typeArrayOop array = typeArrayOop(obj.obj()); 982 BasicType type = TypeArrayKlass::cast(array->klass())->element_type(); 983 void* elements = array->base(type); 984 985 // jvmtiPrimitiveType is defined so this mapping is always correct 986 jvmtiPrimitiveType elem_type = (jvmtiPrimitiveType)type2char(type); 987 988 return (*cb)(wrapper->klass_tag(), 989 wrapper->obj_size(), 990 wrapper->obj_tag_p(), 991 (jint)array->length(), 992 elem_type, 993 elements, 994 user_data); 995 } 996 997 // helper function to invoke the primitive field callback for all static fields 998 // of a given class 999 static jint invoke_primitive_field_callback_for_static_fields 1000 (CallbackWrapper* wrapper, 1001 oop obj, 1002 jvmtiPrimitiveFieldCallback cb, 1003 void* user_data) 1004 { 1005 // for static fields only the index will be set 1006 static jvmtiHeapReferenceInfo reference_info = { 0 }; 1007 1008 assert(obj->klass() == vmClasses::Class_klass(), "not a class"); 1009 if (java_lang_Class::is_primitive(obj)) { 1010 return 0; 1011 } 1012 Klass* klass = java_lang_Class::as_Klass(obj); 1013 1014 // ignore classes for object and type arrays 1015 if (!klass->is_instance_klass()) { 1016 return 0; 1017 } 1018 1019 // ignore classes which aren't linked yet 1020 InstanceKlass* ik = InstanceKlass::cast(klass); 1021 if (!ik->is_linked()) { 1022 return 0; 1023 } 1024 1025 // get the field map 1026 ClassFieldMap* field_map = ClassFieldMap::create_map_of_static_fields(klass); 1027 1028 // invoke the callback for each static primitive field 1029 for (int i=0; i<field_map->field_count(); i++) { 1030 ClassFieldDescriptor* field = field_map->field_at(i); 1031 1032 // ignore non-primitive fields 1033 char type = field->field_type(); 1034 if (!is_primitive_field_type(type)) { 1035 continue; 1036 } 1037 // one-to-one mapping 1038 jvmtiPrimitiveType value_type = (jvmtiPrimitiveType)type; 1039 1040 // get offset and field value 1041 int offset = field->field_offset(); 1042 address addr = cast_from_oop<address>(klass->java_mirror()) + offset; 1043 jvalue value; 1044 copy_to_jvalue(&value, addr, value_type); 1045 1046 // field index 1047 reference_info.field.index = field->field_index(); 1048 1049 // invoke the callback 1050 jint res = (*cb)(JVMTI_HEAP_REFERENCE_STATIC_FIELD, 1051 &reference_info, 1052 wrapper->klass_tag(), 1053 wrapper->obj_tag_p(), 1054 value, 1055 value_type, 1056 user_data); 1057 if (res & JVMTI_VISIT_ABORT) { 1058 delete field_map; 1059 return res; 1060 } 1061 } 1062 1063 delete field_map; 1064 return 0; 1065 } 1066 1067 // helper function to invoke the primitive field callback for all instance fields 1068 // of a given object 1069 static jint invoke_primitive_field_callback_for_instance_fields( 1070 CallbackWrapper* wrapper, 1071 const JvmtiHeapwalkObject& obj, 1072 jvmtiPrimitiveFieldCallback cb, 1073 void* user_data) 1074 { 1075 // for instance fields only the index will be set 1076 static jvmtiHeapReferenceInfo reference_info = { 0 }; 1077 1078 // get the map of the instance fields 1079 ClassFieldMap* fields = JvmtiCachedClassFieldMap::get_map_of_instance_fields(obj.klass()); 1080 1081 // invoke the callback for each instance primitive field 1082 for (int i=0; i<fields->field_count(); i++) { 1083 ClassFieldDescriptor* field = fields->field_at(i); 1084 1085 // ignore non-primitive fields 1086 char type = field->field_type(); 1087 if (!is_primitive_field_type(type)) { 1088 continue; 1089 } 1090 // one-to-one mapping 1091 jvmtiPrimitiveType value_type = (jvmtiPrimitiveType)type; 1092 1093 // get field value 1094 address addr = cast_from_oop<address>(obj.obj()) + obj.offset() + field->field_offset(); 1095 jvalue value; 1096 copy_to_jvalue(&value, addr, value_type); 1097 1098 // field index 1099 reference_info.field.index = field->field_index(); 1100 1101 // invoke the callback 1102 jint res = (*cb)(JVMTI_HEAP_REFERENCE_FIELD, 1103 &reference_info, 1104 wrapper->klass_tag(), 1105 wrapper->obj_tag_p(), 1106 value, 1107 value_type, 1108 user_data); 1109 if (res & JVMTI_VISIT_ABORT) { 1110 return res; 1111 } 1112 } 1113 return 0; 1114 } 1115 1116 1117 // VM operation to iterate over all objects in the heap (both reachable 1118 // and unreachable) 1119 class VM_HeapIterateOperation: public VM_Operation { 1120 private: 1121 ObjectClosure* _blk; 1122 GrowableArray<jlong>* const _dead_objects; 1123 public: 1124 VM_HeapIterateOperation(ObjectClosure* blk, GrowableArray<jlong>* objects) : 1125 _blk(blk), _dead_objects(objects) { } 1126 1127 VMOp_Type type() const { return VMOp_HeapIterateOperation; } 1128 void doit() { 1129 // allows class files maps to be cached during iteration 1130 ClassFieldMapCacheMark cm; 1131 1132 JvmtiTagMap::check_hashmaps_for_heapwalk(_dead_objects); 1133 1134 // make sure that heap is parsable (fills TLABs with filler objects) 1135 Universe::heap()->ensure_parsability(false); // no need to retire TLABs 1136 1137 // Verify heap before iteration - if the heap gets corrupted then 1138 // JVMTI's IterateOverHeap will crash. 1139 if (VerifyBeforeIteration) { 1140 Universe::verify(); 1141 } 1142 1143 // do the iteration 1144 Universe::heap()->object_iterate(_blk); 1145 } 1146 }; 1147 1148 1149 // An ObjectClosure used to support the deprecated IterateOverHeap and 1150 // IterateOverInstancesOfClass functions 1151 class IterateOverHeapObjectClosure: public ObjectClosure { 1152 private: 1153 JvmtiTagMap* _tag_map; 1154 Klass* _klass; 1155 jvmtiHeapObjectFilter _object_filter; 1156 jvmtiHeapObjectCallback _heap_object_callback; 1157 const void* _user_data; 1158 1159 // accessors 1160 JvmtiTagMap* tag_map() const { return _tag_map; } 1161 jvmtiHeapObjectFilter object_filter() const { return _object_filter; } 1162 jvmtiHeapObjectCallback object_callback() const { return _heap_object_callback; } 1163 Klass* klass() const { return _klass; } 1164 const void* user_data() const { return _user_data; } 1165 1166 // indicates if iteration has been aborted 1167 bool _iteration_aborted; 1168 bool is_iteration_aborted() const { return _iteration_aborted; } 1169 void set_iteration_aborted(bool aborted) { _iteration_aborted = aborted; } 1170 1171 public: 1172 IterateOverHeapObjectClosure(JvmtiTagMap* tag_map, 1173 Klass* klass, 1174 jvmtiHeapObjectFilter object_filter, 1175 jvmtiHeapObjectCallback heap_object_callback, 1176 const void* user_data) : 1177 _tag_map(tag_map), 1178 _klass(klass), 1179 _object_filter(object_filter), 1180 _heap_object_callback(heap_object_callback), 1181 _user_data(user_data), 1182 _iteration_aborted(false) 1183 { 1184 } 1185 1186 void do_object(oop o); 1187 }; 1188 1189 // invoked for each object in the heap 1190 void IterateOverHeapObjectClosure::do_object(oop o) { 1191 assert(o != nullptr, "Heap iteration should never produce null!"); 1192 // check if iteration has been halted 1193 if (is_iteration_aborted()) return; 1194 1195 // instanceof check when filtering by klass 1196 if (klass() != nullptr && !o->is_a(klass())) { 1197 return; 1198 } 1199 1200 // skip if object is a dormant shared object whose mirror hasn't been loaded 1201 if (o->klass()->java_mirror() == nullptr) { 1202 log_debug(aot, heap)("skipped dormant archived object " INTPTR_FORMAT " (%s)", p2i(o), 1203 o->klass()->external_name()); 1204 return; 1205 } 1206 1207 // prepare for the calllback 1208 JvmtiHeapwalkObject wrapper_obj(o); 1209 CallbackWrapper wrapper(tag_map(), wrapper_obj); 1210 1211 // if the object is tagged and we're only interested in untagged objects 1212 // then don't invoke the callback. Similarly, if the object is untagged 1213 // and we're only interested in tagged objects we skip the callback. 1214 if (wrapper.obj_tag() != 0) { 1215 if (object_filter() == JVMTI_HEAP_OBJECT_UNTAGGED) return; 1216 } else { 1217 if (object_filter() == JVMTI_HEAP_OBJECT_TAGGED) return; 1218 } 1219 1220 // invoke the agent's callback 1221 jvmtiIterationControl control = (*object_callback())(wrapper.klass_tag(), 1222 wrapper.obj_size(), 1223 wrapper.obj_tag_p(), 1224 (void*)user_data()); 1225 if (control == JVMTI_ITERATION_ABORT) { 1226 set_iteration_aborted(true); 1227 } 1228 } 1229 1230 // An ObjectClosure used to support the IterateThroughHeap function 1231 class IterateThroughHeapObjectClosure: public ObjectClosure { 1232 private: 1233 JvmtiTagMap* _tag_map; 1234 Klass* _klass; 1235 int _heap_filter; 1236 const jvmtiHeapCallbacks* _callbacks; 1237 const void* _user_data; 1238 1239 // accessor functions 1240 JvmtiTagMap* tag_map() const { return _tag_map; } 1241 int heap_filter() const { return _heap_filter; } 1242 const jvmtiHeapCallbacks* callbacks() const { return _callbacks; } 1243 Klass* klass() const { return _klass; } 1244 const void* user_data() const { return _user_data; } 1245 1246 // indicates if the iteration has been aborted 1247 bool _iteration_aborted; 1248 bool is_iteration_aborted() const { return _iteration_aborted; } 1249 1250 // used to check the visit control flags. If the abort flag is set 1251 // then we set the iteration aborted flag so that the iteration completes 1252 // without processing any further objects 1253 bool check_flags_for_abort(jint flags) { 1254 bool is_abort = (flags & JVMTI_VISIT_ABORT) != 0; 1255 if (is_abort) { 1256 _iteration_aborted = true; 1257 } 1258 return is_abort; 1259 } 1260 1261 void visit_object(const JvmtiHeapwalkObject& obj); 1262 void visit_flat_fields(const JvmtiHeapwalkObject& obj); 1263 void visit_flat_array_elements(const JvmtiHeapwalkObject& obj); 1264 1265 public: 1266 IterateThroughHeapObjectClosure(JvmtiTagMap* tag_map, 1267 Klass* klass, 1268 int heap_filter, 1269 const jvmtiHeapCallbacks* heap_callbacks, 1270 const void* user_data) : 1271 _tag_map(tag_map), 1272 _klass(klass), 1273 _heap_filter(heap_filter), 1274 _callbacks(heap_callbacks), 1275 _user_data(user_data), 1276 _iteration_aborted(false) 1277 { 1278 } 1279 1280 void do_object(oop obj); 1281 }; 1282 1283 // invoked for each object in the heap 1284 void IterateThroughHeapObjectClosure::do_object(oop obj) { 1285 assert(obj != nullptr, "Heap iteration should never produce null!"); 1286 // check if iteration has been halted 1287 if (is_iteration_aborted()) return; 1288 1289 // skip if object is a dormant shared object whose mirror hasn't been loaded 1290 if (obj != nullptr && obj->klass()->java_mirror() == nullptr) { 1291 log_debug(aot, heap)("skipped dormant archived object " INTPTR_FORMAT " (%s)", p2i(obj), 1292 obj->klass()->external_name()); 1293 return; 1294 } 1295 1296 visit_object(obj); 1297 } 1298 1299 void IterateThroughHeapObjectClosure::visit_object(const JvmtiHeapwalkObject& obj) { 1300 // apply class filter 1301 if (is_filtered_by_klass_filter(obj, klass())) return; 1302 1303 // prepare for callback 1304 CallbackWrapper wrapper(tag_map(), obj); 1305 1306 // check if filtered by the heap filter 1307 if (is_filtered_by_heap_filter(wrapper.obj_tag(), wrapper.klass_tag(), heap_filter())) { 1308 return; 1309 } 1310 1311 // for arrays we need the length, otherwise -1 1312 bool is_array = obj.klass()->is_array_klass(); 1313 int len = is_array ? arrayOop(obj.obj())->length() : -1; 1314 1315 // invoke the object callback (if callback is provided) 1316 if (callbacks()->heap_iteration_callback != nullptr) { 1317 jvmtiHeapIterationCallback cb = callbacks()->heap_iteration_callback; 1318 jint res = (*cb)(wrapper.klass_tag(), 1319 wrapper.obj_size(), 1320 wrapper.obj_tag_p(), 1321 (jint)len, 1322 (void*)user_data()); 1323 if (check_flags_for_abort(res)) return; 1324 } 1325 1326 // for objects and classes we report primitive fields if callback provided 1327 if (callbacks()->primitive_field_callback != nullptr && obj.klass()->is_instance_klass()) { 1328 jint res; 1329 jvmtiPrimitiveFieldCallback cb = callbacks()->primitive_field_callback; 1330 if (obj.klass() == vmClasses::Class_klass()) { 1331 assert(!obj.is_flat(), "Class object cannot be flattened"); 1332 res = invoke_primitive_field_callback_for_static_fields(&wrapper, 1333 obj.obj(), 1334 cb, 1335 (void*)user_data()); 1336 } else { 1337 res = invoke_primitive_field_callback_for_instance_fields(&wrapper, 1338 obj, 1339 cb, 1340 (void*)user_data()); 1341 } 1342 if (check_flags_for_abort(res)) return; 1343 } 1344 1345 // string callback 1346 if (!is_array && 1347 callbacks()->string_primitive_value_callback != nullptr && 1348 obj.klass() == vmClasses::String_klass()) { 1349 jint res = invoke_string_value_callback( 1350 callbacks()->string_primitive_value_callback, 1351 &wrapper, 1352 obj, 1353 (void*)user_data()); 1354 if (check_flags_for_abort(res)) return; 1355 } 1356 1357 // array callback 1358 if (is_array && 1359 callbacks()->array_primitive_value_callback != nullptr && 1360 obj.klass()->is_typeArray_klass()) { 1361 jint res = invoke_array_primitive_value_callback( 1362 callbacks()->array_primitive_value_callback, 1363 &wrapper, 1364 obj, 1365 (void*)user_data()); 1366 if (check_flags_for_abort(res)) return; 1367 } 1368 1369 // All info for the object is reported. 1370 1371 // If the object has flat fields, report them as heap objects. 1372 if (obj.klass()->is_instance_klass()) { 1373 if (InstanceKlass::cast(obj.klass())->has_inline_type_fields()) { 1374 visit_flat_fields(obj); 1375 // check if iteration has been halted 1376 if (is_iteration_aborted()) { 1377 return; 1378 } 1379 } 1380 } 1381 // If the object is flat array, report all elements as heap objects. 1382 if (is_array && obj.obj()->is_flatArray()) { 1383 assert(!obj.is_flat(), "Array object cannot be flattened"); 1384 visit_flat_array_elements(obj); 1385 } 1386 } 1387 1388 void IterateThroughHeapObjectClosure::visit_flat_fields(const JvmtiHeapwalkObject& obj) { 1389 // iterate over instance fields 1390 ClassFieldMap* fields = JvmtiCachedClassFieldMap::get_map_of_instance_fields(obj.klass()); 1391 for (int i = 0; i < fields->field_count(); i++) { 1392 ClassFieldDescriptor* field = fields->field_at(i); 1393 // skip non-flat and (for safety) primitive fields 1394 if (!field->is_flat() || is_primitive_field_type(field->field_type())) { 1395 continue; 1396 } 1397 1398 int field_offset = field->field_offset(); 1399 if (obj.is_flat()) { 1400 // the object is inlined, its fields are stored without the header 1401 field_offset += obj.offset() - obj.inline_klass()->payload_offset(); 1402 } 1403 // check for possible nulls 1404 bool can_be_null = field->layout_kind() == LayoutKind::NULLABLE_ATOMIC_FLAT; 1405 if (can_be_null) { 1406 address payload = cast_from_oop<address>(obj.obj()) + field_offset; 1407 if (field->inline_klass()->is_payload_marked_as_null(payload)) { 1408 continue; 1409 } 1410 } 1411 JvmtiHeapwalkObject field_obj(obj.obj(), field_offset, field->inline_klass(), field->layout_kind()); 1412 1413 visit_object(field_obj); 1414 1415 // check if iteration has been halted 1416 if (is_iteration_aborted()) { 1417 return; 1418 } 1419 } 1420 } 1421 1422 void IterateThroughHeapObjectClosure::visit_flat_array_elements(const JvmtiHeapwalkObject& obj) { 1423 assert(!obj.is_flat() && obj.obj()->is_flatArray() , "sanity check"); 1424 flatArrayOop array = flatArrayOop(obj.obj()); 1425 FlatArrayKlass* faklass = FlatArrayKlass::cast(array->klass()); 1426 InlineKlass* vk = InlineKlass::cast(faklass->element_klass()); 1427 bool need_null_check = faklass->layout_kind() == LayoutKind::NULLABLE_ATOMIC_FLAT; 1428 1429 for (int index = 0; index < array->length(); index++) { 1430 address addr = (address)array->value_at_addr(index, faklass->layout_helper()); 1431 // check for null 1432 if (need_null_check) { 1433 if (vk->is_payload_marked_as_null(addr)) { 1434 continue; 1435 } 1436 } 1437 1438 // offset in the array oop 1439 int offset = (int)(addr - cast_from_oop<address>(array)); 1440 JvmtiHeapwalkObject elem(obj.obj(), offset, vk, faklass->layout_kind()); 1441 1442 visit_object(elem); 1443 1444 // check if iteration has been halted 1445 if (is_iteration_aborted()) { 1446 return; 1447 } 1448 } 1449 } 1450 1451 // Deprecated function to iterate over all objects in the heap 1452 void JvmtiTagMap::iterate_over_heap(jvmtiHeapObjectFilter object_filter, 1453 Klass* klass, 1454 jvmtiHeapObjectCallback heap_object_callback, 1455 const void* user_data) 1456 { 1457 // EA based optimizations on tagged objects are already reverted. 1458 EscapeBarrier eb(object_filter == JVMTI_HEAP_OBJECT_UNTAGGED || 1459 object_filter == JVMTI_HEAP_OBJECT_EITHER, 1460 JavaThread::current()); 1461 eb.deoptimize_objects_all_threads(); 1462 Arena dead_object_arena(mtServiceability); 1463 GrowableArray <jlong> dead_objects(&dead_object_arena, 10, 0, 0); 1464 { 1465 MutexLocker ml(Heap_lock); 1466 IterateOverHeapObjectClosure blk(this, 1467 klass, 1468 object_filter, 1469 heap_object_callback, 1470 user_data); 1471 VM_HeapIterateOperation op(&blk, &dead_objects); 1472 VMThread::execute(&op); 1473 } 1474 convert_flat_object_entries(); 1475 1476 // Post events outside of Heap_lock 1477 post_dead_objects(&dead_objects); 1478 } 1479 1480 1481 // Iterates over all objects in the heap 1482 void JvmtiTagMap::iterate_through_heap(jint heap_filter, 1483 Klass* klass, 1484 const jvmtiHeapCallbacks* callbacks, 1485 const void* user_data) 1486 { 1487 // EA based optimizations on tagged objects are already reverted. 1488 EscapeBarrier eb(!(heap_filter & JVMTI_HEAP_FILTER_UNTAGGED), JavaThread::current()); 1489 eb.deoptimize_objects_all_threads(); 1490 1491 Arena dead_object_arena(mtServiceability); 1492 GrowableArray<jlong> dead_objects(&dead_object_arena, 10, 0, 0); 1493 { 1494 MutexLocker ml(Heap_lock); 1495 IterateThroughHeapObjectClosure blk(this, 1496 klass, 1497 heap_filter, 1498 callbacks, 1499 user_data); 1500 VM_HeapIterateOperation op(&blk, &dead_objects); 1501 VMThread::execute(&op); 1502 } 1503 convert_flat_object_entries(); 1504 1505 // Post events outside of Heap_lock 1506 post_dead_objects(&dead_objects); 1507 } 1508 1509 void JvmtiTagMap::remove_dead_entries_locked(GrowableArray<jlong>* objects) { 1510 assert(is_locked(), "precondition"); 1511 if (_needs_cleaning) { 1512 // Recheck whether to post object free events under the lock. 1513 if (!env()->is_enabled(JVMTI_EVENT_OBJECT_FREE)) { 1514 objects = nullptr; 1515 } 1516 log_info(jvmti, table)("TagMap table needs cleaning%s", 1517 ((objects != nullptr) ? " and posting" : "")); 1518 _hashmap->remove_dead_entries(objects); 1519 _needs_cleaning = false; 1520 } 1521 } 1522 1523 void JvmtiTagMap::remove_dead_entries(GrowableArray<jlong>* objects) { 1524 MutexLocker ml(lock(), Mutex::_no_safepoint_check_flag); 1525 remove_dead_entries_locked(objects); 1526 } 1527 1528 void JvmtiTagMap::post_dead_objects(GrowableArray<jlong>* const objects) { 1529 assert(Thread::current()->is_Java_thread(), "Must post from JavaThread"); 1530 if (objects != nullptr && objects->length() > 0) { 1531 JvmtiExport::post_object_free(env(), objects); 1532 log_info(jvmti, table)("%d free object posted", objects->length()); 1533 } 1534 } 1535 1536 void JvmtiTagMap::remove_and_post_dead_objects() { 1537 ResourceMark rm; 1538 GrowableArray<jlong> objects; 1539 remove_dead_entries(&objects); 1540 post_dead_objects(&objects); 1541 } 1542 1543 void JvmtiTagMap::flush_object_free_events() { 1544 assert_not_at_safepoint(); 1545 if (env()->is_enabled(JVMTI_EVENT_OBJECT_FREE)) { 1546 { 1547 MonitorLocker ml(lock(), Mutex::_no_safepoint_check_flag); 1548 // If another thread is posting events, let it finish 1549 while (_posting_events) { 1550 ml.wait(); 1551 } 1552 1553 if (!_needs_cleaning || is_empty()) { 1554 _needs_cleaning = false; 1555 return; 1556 } 1557 _posting_events = true; 1558 } // Drop the lock so we can do the cleaning on the VM thread. 1559 // Needs both cleaning and event posting (up to some other thread 1560 // getting there first after we dropped the lock). 1561 remove_and_post_dead_objects(); 1562 { 1563 MonitorLocker ml(lock(), Mutex::_no_safepoint_check_flag); 1564 _posting_events = false; 1565 ml.notify_all(); 1566 } 1567 } else { 1568 remove_dead_entries(nullptr); 1569 } 1570 } 1571 1572 // support class for get_objects_with_tags 1573 1574 class TagObjectCollector : public JvmtiTagMapKeyClosure { 1575 private: 1576 JvmtiEnv* _env; 1577 JavaThread* _thread; 1578 jlong* _tags; 1579 jint _tag_count; 1580 bool _some_dead_found; 1581 1582 GrowableArray<jobject>* _object_results; // collected objects (JNI weak refs) 1583 GrowableArray<uint64_t>* _tag_results; // collected tags 1584 1585 public: 1586 TagObjectCollector(JvmtiEnv* env, const jlong* tags, jint tag_count) : 1587 _env(env), 1588 _thread(JavaThread::current()), 1589 _tags((jlong*)tags), 1590 _tag_count(tag_count), 1591 _some_dead_found(false), 1592 _object_results(new (mtServiceability) GrowableArray<jobject>(1, mtServiceability)), 1593 _tag_results(new (mtServiceability) GrowableArray<uint64_t>(1, mtServiceability)) { } 1594 1595 ~TagObjectCollector() { 1596 delete _object_results; 1597 delete _tag_results; 1598 } 1599 1600 bool some_dead_found() const { return _some_dead_found; } 1601 1602 // for each tagged object check if the tag value matches 1603 // - if it matches then we create a JNI local reference to the object 1604 // and record the reference and tag value. 1605 // Always return true so the iteration continues. 1606 bool do_entry(JvmtiTagMapKey& key, jlong& value) { 1607 for (int i = 0; i < _tag_count; i++) { 1608 if (_tags[i] == value) { 1609 // The reference in this tag map could be the only (implicitly weak) 1610 // reference to that object. If we hand it out, we need to keep it live wrt 1611 // SATB marking similar to other j.l.ref.Reference referents. This is 1612 // achieved by using a phantom load in the object() accessor. 1613 oop o = key.object(); 1614 if (o == nullptr) { 1615 _some_dead_found = true; 1616 // skip this whole entry 1617 return true; 1618 } 1619 assert(o != nullptr && Universe::heap()->is_in(o), "sanity check"); 1620 jobject ref = JNIHandles::make_local(_thread, o); 1621 _object_results->append(ref); 1622 _tag_results->append(value); 1623 } 1624 } 1625 return true; 1626 } 1627 1628 // return the results from the collection 1629 // 1630 jvmtiError result(jint* count_ptr, jobject** object_result_ptr, jlong** tag_result_ptr) { 1631 jvmtiError error; 1632 int count = _object_results->length(); 1633 assert(count >= 0, "sanity check"); 1634 1635 // if object_result_ptr is not null then allocate the result and copy 1636 // in the object references. 1637 if (object_result_ptr != nullptr) { 1638 error = _env->Allocate(count * sizeof(jobject), (unsigned char**)object_result_ptr); 1639 if (error != JVMTI_ERROR_NONE) { 1640 return error; 1641 } 1642 for (int i=0; i<count; i++) { 1643 (*object_result_ptr)[i] = _object_results->at(i); 1644 } 1645 } 1646 1647 // if tag_result_ptr is not null then allocate the result and copy 1648 // in the tag values. 1649 if (tag_result_ptr != nullptr) { 1650 error = _env->Allocate(count * sizeof(jlong), (unsigned char**)tag_result_ptr); 1651 if (error != JVMTI_ERROR_NONE) { 1652 if (object_result_ptr != nullptr) { 1653 _env->Deallocate((unsigned char*)object_result_ptr); 1654 } 1655 return error; 1656 } 1657 for (int i=0; i<count; i++) { 1658 (*tag_result_ptr)[i] = (jlong)_tag_results->at(i); 1659 } 1660 } 1661 1662 *count_ptr = count; 1663 return JVMTI_ERROR_NONE; 1664 } 1665 }; 1666 1667 // return the list of objects with the specified tags 1668 jvmtiError JvmtiTagMap::get_objects_with_tags(const jlong* tags, 1669 jint count, jint* count_ptr, jobject** object_result_ptr, jlong** tag_result_ptr) { 1670 1671 // ensure flat object conversion is completed 1672 convert_flat_object_entries(); 1673 1674 TagObjectCollector collector(env(), tags, count); 1675 { 1676 // iterate over all tagged objects 1677 MutexLocker ml(lock(), Mutex::_no_safepoint_check_flag); 1678 // Can't post ObjectFree events here from a JavaThread, so this 1679 // will race with the gc_notification thread in the tiny 1680 // window where the object is not marked but hasn't been notified that 1681 // it is collected yet. 1682 _hashmap->entry_iterate(&collector); 1683 } 1684 return collector.result(count_ptr, object_result_ptr, tag_result_ptr); 1685 } 1686 1687 // helper to map a jvmtiHeapReferenceKind to an old style jvmtiHeapRootKind 1688 // (not performance critical as only used for roots) 1689 static jvmtiHeapRootKind toJvmtiHeapRootKind(jvmtiHeapReferenceKind kind) { 1690 switch (kind) { 1691 case JVMTI_HEAP_REFERENCE_JNI_GLOBAL: return JVMTI_HEAP_ROOT_JNI_GLOBAL; 1692 case JVMTI_HEAP_REFERENCE_SYSTEM_CLASS: return JVMTI_HEAP_ROOT_SYSTEM_CLASS; 1693 case JVMTI_HEAP_REFERENCE_STACK_LOCAL: return JVMTI_HEAP_ROOT_STACK_LOCAL; 1694 case JVMTI_HEAP_REFERENCE_JNI_LOCAL: return JVMTI_HEAP_ROOT_JNI_LOCAL; 1695 case JVMTI_HEAP_REFERENCE_THREAD: return JVMTI_HEAP_ROOT_THREAD; 1696 case JVMTI_HEAP_REFERENCE_OTHER: return JVMTI_HEAP_ROOT_OTHER; 1697 default: ShouldNotReachHere(); return JVMTI_HEAP_ROOT_OTHER; 1698 } 1699 } 1700 1701 // Base class for all heap walk contexts. The base class maintains a flag 1702 // to indicate if the context is valid or not. 1703 class HeapWalkContext { 1704 private: 1705 bool _valid; 1706 public: 1707 HeapWalkContext(bool valid) { _valid = valid; } 1708 void invalidate() { _valid = false; } 1709 bool is_valid() const { return _valid; } 1710 }; 1711 1712 // A basic heap walk context for the deprecated heap walking functions. 1713 // The context for a basic heap walk are the callbacks and fields used by 1714 // the referrer caching scheme. 1715 class BasicHeapWalkContext: public HeapWalkContext { 1716 private: 1717 jvmtiHeapRootCallback _heap_root_callback; 1718 jvmtiStackReferenceCallback _stack_ref_callback; 1719 jvmtiObjectReferenceCallback _object_ref_callback; 1720 1721 // used for caching 1722 JvmtiHeapwalkObject _last_referrer; 1723 jlong _last_referrer_tag; 1724 1725 public: 1726 BasicHeapWalkContext() : HeapWalkContext(false) { } 1727 1728 BasicHeapWalkContext(jvmtiHeapRootCallback heap_root_callback, 1729 jvmtiStackReferenceCallback stack_ref_callback, 1730 jvmtiObjectReferenceCallback object_ref_callback) : 1731 HeapWalkContext(true), 1732 _heap_root_callback(heap_root_callback), 1733 _stack_ref_callback(stack_ref_callback), 1734 _object_ref_callback(object_ref_callback), 1735 _last_referrer(), 1736 _last_referrer_tag(0) { 1737 } 1738 1739 // accessors 1740 jvmtiHeapRootCallback heap_root_callback() const { return _heap_root_callback; } 1741 jvmtiStackReferenceCallback stack_ref_callback() const { return _stack_ref_callback; } 1742 jvmtiObjectReferenceCallback object_ref_callback() const { return _object_ref_callback; } 1743 1744 JvmtiHeapwalkObject last_referrer() const { return _last_referrer; } 1745 void set_last_referrer(const JvmtiHeapwalkObject& referrer) { _last_referrer = referrer; } 1746 jlong last_referrer_tag() const { return _last_referrer_tag; } 1747 void set_last_referrer_tag(jlong value) { _last_referrer_tag = value; } 1748 }; 1749 1750 // The advanced heap walk context for the FollowReferences functions. 1751 // The context is the callbacks, and the fields used for filtering. 1752 class AdvancedHeapWalkContext: public HeapWalkContext { 1753 private: 1754 jint _heap_filter; 1755 Klass* _klass_filter; 1756 const jvmtiHeapCallbacks* _heap_callbacks; 1757 1758 public: 1759 AdvancedHeapWalkContext() : HeapWalkContext(false) { } 1760 1761 AdvancedHeapWalkContext(jint heap_filter, 1762 Klass* klass_filter, 1763 const jvmtiHeapCallbacks* heap_callbacks) : 1764 HeapWalkContext(true), 1765 _heap_filter(heap_filter), 1766 _klass_filter(klass_filter), 1767 _heap_callbacks(heap_callbacks) { 1768 } 1769 1770 // accessors 1771 jint heap_filter() const { return _heap_filter; } 1772 Klass* klass_filter() const { return _klass_filter; } 1773 1774 jvmtiHeapReferenceCallback heap_reference_callback() const { 1775 return _heap_callbacks->heap_reference_callback; 1776 }; 1777 jvmtiPrimitiveFieldCallback primitive_field_callback() const { 1778 return _heap_callbacks->primitive_field_callback; 1779 } 1780 jvmtiArrayPrimitiveValueCallback array_primitive_value_callback() const { 1781 return _heap_callbacks->array_primitive_value_callback; 1782 } 1783 jvmtiStringPrimitiveValueCallback string_primitive_value_callback() const { 1784 return _heap_callbacks->string_primitive_value_callback; 1785 } 1786 }; 1787 1788 // The CallbackInvoker is a class with static functions that the heap walk can call 1789 // into to invoke callbacks. It works in one of two modes. The "basic" mode is 1790 // used for the deprecated IterateOverReachableObjects functions. The "advanced" 1791 // mode is for the newer FollowReferences function which supports a lot of 1792 // additional callbacks. 1793 class CallbackInvoker : AllStatic { 1794 private: 1795 // heap walk styles 1796 enum { basic, advanced }; 1797 static int _heap_walk_type; 1798 static bool is_basic_heap_walk() { return _heap_walk_type == basic; } 1799 static bool is_advanced_heap_walk() { return _heap_walk_type == advanced; } 1800 1801 // context for basic style heap walk 1802 static BasicHeapWalkContext _basic_context; 1803 static BasicHeapWalkContext* basic_context() { 1804 assert(_basic_context.is_valid(), "invalid"); 1805 return &_basic_context; 1806 } 1807 1808 // context for advanced style heap walk 1809 static AdvancedHeapWalkContext _advanced_context; 1810 static AdvancedHeapWalkContext* advanced_context() { 1811 assert(_advanced_context.is_valid(), "invalid"); 1812 return &_advanced_context; 1813 } 1814 1815 // context needed for all heap walks 1816 static JvmtiTagMap* _tag_map; 1817 static const void* _user_data; 1818 static JvmtiHeapwalkVisitStack* _visit_stack; 1819 1820 // accessors 1821 static JvmtiTagMap* tag_map() { return _tag_map; } 1822 static const void* user_data() { return _user_data; } 1823 static JvmtiHeapwalkVisitStack* visit_stack() { return _visit_stack; } 1824 1825 // if the object hasn't been visited then push it onto the visit stack 1826 // so that it will be visited later 1827 static inline bool check_for_visit(const JvmtiHeapwalkObject&obj) { 1828 visit_stack()->check_for_visit(obj); 1829 return true; 1830 } 1831 1832 // return element count if the obj is array, -1 otherwise 1833 static jint get_array_length(const JvmtiHeapwalkObject& obj) { 1834 if (!obj.klass()->is_array_klass()) { 1835 return -1; 1836 } 1837 assert(!obj.is_flat(), "array cannot be flat"); 1838 return (jint)arrayOop(obj.obj())->length(); 1839 } 1840 1841 1842 // invoke basic style callbacks 1843 static inline bool invoke_basic_heap_root_callback 1844 (jvmtiHeapRootKind root_kind, const JvmtiHeapwalkObject& obj); 1845 static inline bool invoke_basic_stack_ref_callback 1846 (jvmtiHeapRootKind root_kind, jlong thread_tag, jint depth, jmethodID method, 1847 int slot, const JvmtiHeapwalkObject& obj); 1848 static inline bool invoke_basic_object_reference_callback 1849 (jvmtiObjectReferenceKind ref_kind, const JvmtiHeapwalkObject& referrer, const JvmtiHeapwalkObject& referree, jint index); 1850 1851 // invoke advanced style callbacks 1852 static inline bool invoke_advanced_heap_root_callback 1853 (jvmtiHeapReferenceKind ref_kind, const JvmtiHeapwalkObject& obj); 1854 static inline bool invoke_advanced_stack_ref_callback 1855 (jvmtiHeapReferenceKind ref_kind, jlong thread_tag, jlong tid, int depth, 1856 jmethodID method, jlocation bci, jint slot, const JvmtiHeapwalkObject& obj); 1857 static inline bool invoke_advanced_object_reference_callback 1858 (jvmtiHeapReferenceKind ref_kind, const JvmtiHeapwalkObject& referrer, const JvmtiHeapwalkObject& referree, jint index); 1859 1860 // used to report the value of primitive fields 1861 static inline bool report_primitive_field 1862 (jvmtiHeapReferenceKind ref_kind, const JvmtiHeapwalkObject& obj, jint index, address addr, char type); 1863 1864 public: 1865 // initialize for basic mode 1866 static void initialize_for_basic_heap_walk(JvmtiTagMap* tag_map, 1867 const void* user_data, 1868 BasicHeapWalkContext context, 1869 JvmtiHeapwalkVisitStack* visit_stack); 1870 1871 // initialize for advanced mode 1872 static void initialize_for_advanced_heap_walk(JvmtiTagMap* tag_map, 1873 const void* user_data, 1874 AdvancedHeapWalkContext context, 1875 JvmtiHeapwalkVisitStack* visit_stack); 1876 1877 // functions to report roots 1878 static inline bool report_simple_root(jvmtiHeapReferenceKind kind, const JvmtiHeapwalkObject& o); 1879 static inline bool report_jni_local_root(jlong thread_tag, jlong tid, jint depth, 1880 jmethodID m, const JvmtiHeapwalkObject& o); 1881 static inline bool report_stack_ref_root(jlong thread_tag, jlong tid, jint depth, 1882 jmethodID method, jlocation bci, jint slot, const JvmtiHeapwalkObject& o); 1883 1884 // functions to report references 1885 static inline bool report_array_element_reference(const JvmtiHeapwalkObject& referrer, const JvmtiHeapwalkObject& referree, jint index); 1886 static inline bool report_class_reference(const JvmtiHeapwalkObject& referrer, const JvmtiHeapwalkObject& referree); 1887 static inline bool report_class_loader_reference(const JvmtiHeapwalkObject& referrer, const JvmtiHeapwalkObject& referree); 1888 static inline bool report_signers_reference(const JvmtiHeapwalkObject& referrer, const JvmtiHeapwalkObject& referree); 1889 static inline bool report_protection_domain_reference(const JvmtiHeapwalkObject& referrer, const JvmtiHeapwalkObject& referree); 1890 static inline bool report_superclass_reference(const JvmtiHeapwalkObject& referrer, const JvmtiHeapwalkObject& referree); 1891 static inline bool report_interface_reference(const JvmtiHeapwalkObject& referrer, const JvmtiHeapwalkObject& referree); 1892 static inline bool report_static_field_reference(const JvmtiHeapwalkObject& referrer, const JvmtiHeapwalkObject& referree, jint slot); 1893 static inline bool report_field_reference(const JvmtiHeapwalkObject& referrer, const JvmtiHeapwalkObject& referree, jint slot); 1894 static inline bool report_constant_pool_reference(const JvmtiHeapwalkObject& referrer, const JvmtiHeapwalkObject& referree, jint index); 1895 static inline bool report_primitive_array_values(const JvmtiHeapwalkObject& array); 1896 static inline bool report_string_value(const JvmtiHeapwalkObject& str); 1897 static inline bool report_primitive_instance_field(const JvmtiHeapwalkObject& o, jint index, address value, char type); 1898 static inline bool report_primitive_static_field(const JvmtiHeapwalkObject& o, jint index, address value, char type); 1899 }; 1900 1901 // statics 1902 int CallbackInvoker::_heap_walk_type; 1903 BasicHeapWalkContext CallbackInvoker::_basic_context; 1904 AdvancedHeapWalkContext CallbackInvoker::_advanced_context; 1905 JvmtiTagMap* CallbackInvoker::_tag_map; 1906 const void* CallbackInvoker::_user_data; 1907 JvmtiHeapwalkVisitStack* CallbackInvoker::_visit_stack; 1908 1909 // initialize for basic heap walk (IterateOverReachableObjects et al) 1910 void CallbackInvoker::initialize_for_basic_heap_walk(JvmtiTagMap* tag_map, 1911 const void* user_data, 1912 BasicHeapWalkContext context, 1913 JvmtiHeapwalkVisitStack* visit_stack) { 1914 _tag_map = tag_map; 1915 _user_data = user_data; 1916 _basic_context = context; 1917 _advanced_context.invalidate(); // will trigger assertion if used 1918 _heap_walk_type = basic; 1919 _visit_stack = visit_stack; 1920 } 1921 1922 // initialize for advanced heap walk (FollowReferences) 1923 void CallbackInvoker::initialize_for_advanced_heap_walk(JvmtiTagMap* tag_map, 1924 const void* user_data, 1925 AdvancedHeapWalkContext context, 1926 JvmtiHeapwalkVisitStack* visit_stack) { 1927 _tag_map = tag_map; 1928 _user_data = user_data; 1929 _advanced_context = context; 1930 _basic_context.invalidate(); // will trigger assertion if used 1931 _heap_walk_type = advanced; 1932 _visit_stack = visit_stack; 1933 } 1934 1935 1936 // invoke basic style heap root callback 1937 inline bool CallbackInvoker::invoke_basic_heap_root_callback(jvmtiHeapRootKind root_kind, const JvmtiHeapwalkObject& obj) { 1938 // if we heap roots should be reported 1939 jvmtiHeapRootCallback cb = basic_context()->heap_root_callback(); 1940 if (cb == nullptr) { 1941 return check_for_visit(obj); 1942 } 1943 1944 CallbackWrapper wrapper(tag_map(), obj); 1945 jvmtiIterationControl control = (*cb)(root_kind, 1946 wrapper.klass_tag(), 1947 wrapper.obj_size(), 1948 wrapper.obj_tag_p(), 1949 (void*)user_data()); 1950 // push root to visit stack when following references 1951 if (control == JVMTI_ITERATION_CONTINUE && 1952 basic_context()->object_ref_callback() != nullptr) { 1953 visit_stack()->push(obj); 1954 } 1955 return control != JVMTI_ITERATION_ABORT; 1956 } 1957 1958 // invoke basic style stack ref callback 1959 inline bool CallbackInvoker::invoke_basic_stack_ref_callback(jvmtiHeapRootKind root_kind, 1960 jlong thread_tag, 1961 jint depth, 1962 jmethodID method, 1963 int slot, 1964 const JvmtiHeapwalkObject& obj) { 1965 // if we stack refs should be reported 1966 jvmtiStackReferenceCallback cb = basic_context()->stack_ref_callback(); 1967 if (cb == nullptr) { 1968 return check_for_visit(obj); 1969 } 1970 1971 CallbackWrapper wrapper(tag_map(), obj); 1972 jvmtiIterationControl control = (*cb)(root_kind, 1973 wrapper.klass_tag(), 1974 wrapper.obj_size(), 1975 wrapper.obj_tag_p(), 1976 thread_tag, 1977 depth, 1978 method, 1979 slot, 1980 (void*)user_data()); 1981 // push root to visit stack when following references 1982 if (control == JVMTI_ITERATION_CONTINUE && 1983 basic_context()->object_ref_callback() != nullptr) { 1984 visit_stack()->push(obj); 1985 } 1986 return control != JVMTI_ITERATION_ABORT; 1987 } 1988 1989 // invoke basic style object reference callback 1990 inline bool CallbackInvoker::invoke_basic_object_reference_callback(jvmtiObjectReferenceKind ref_kind, 1991 const JvmtiHeapwalkObject& referrer, 1992 const JvmtiHeapwalkObject& referree, 1993 jint index) { 1994 1995 BasicHeapWalkContext* context = basic_context(); 1996 1997 // callback requires the referrer's tag. If it's the same referrer 1998 // as the last call then we use the cached value. 1999 jlong referrer_tag; 2000 if (referrer == context->last_referrer()) { 2001 referrer_tag = context->last_referrer_tag(); 2002 } else { 2003 referrer_tag = tag_map()->find(referrer); 2004 } 2005 2006 // do the callback 2007 CallbackWrapper wrapper(tag_map(), referree); 2008 jvmtiObjectReferenceCallback cb = context->object_ref_callback(); 2009 jvmtiIterationControl control = (*cb)(ref_kind, 2010 wrapper.klass_tag(), 2011 wrapper.obj_size(), 2012 wrapper.obj_tag_p(), 2013 referrer_tag, 2014 index, 2015 (void*)user_data()); 2016 2017 // record referrer and referrer tag. For self-references record the 2018 // tag value from the callback as this might differ from referrer_tag. 2019 context->set_last_referrer(referrer); 2020 if (referrer == referree) { 2021 context->set_last_referrer_tag(*wrapper.obj_tag_p()); 2022 } else { 2023 context->set_last_referrer_tag(referrer_tag); 2024 } 2025 2026 if (control == JVMTI_ITERATION_CONTINUE) { 2027 return check_for_visit(referree); 2028 } else { 2029 return control != JVMTI_ITERATION_ABORT; 2030 } 2031 } 2032 2033 // invoke advanced style heap root callback 2034 inline bool CallbackInvoker::invoke_advanced_heap_root_callback(jvmtiHeapReferenceKind ref_kind, 2035 const JvmtiHeapwalkObject& obj) { 2036 AdvancedHeapWalkContext* context = advanced_context(); 2037 2038 // check that callback is provided 2039 jvmtiHeapReferenceCallback cb = context->heap_reference_callback(); 2040 if (cb == nullptr) { 2041 return check_for_visit(obj); 2042 } 2043 2044 // apply class filter 2045 if (is_filtered_by_klass_filter(obj, context->klass_filter())) { 2046 return check_for_visit(obj); 2047 } 2048 2049 // setup the callback wrapper 2050 CallbackWrapper wrapper(tag_map(), obj); 2051 2052 // apply tag filter 2053 if (is_filtered_by_heap_filter(wrapper.obj_tag(), 2054 wrapper.klass_tag(), 2055 context->heap_filter())) { 2056 return check_for_visit(obj); 2057 } 2058 2059 // for arrays we need the length, otherwise -1 2060 jint len = get_array_length(obj); 2061 2062 // invoke the callback 2063 jint res = (*cb)(ref_kind, 2064 nullptr, // referrer info 2065 wrapper.klass_tag(), 2066 0, // referrer_class_tag is 0 for heap root 2067 wrapper.obj_size(), 2068 wrapper.obj_tag_p(), 2069 nullptr, // referrer_tag_p 2070 len, 2071 (void*)user_data()); 2072 if (res & JVMTI_VISIT_ABORT) { 2073 return false;// referrer class tag 2074 } 2075 if (res & JVMTI_VISIT_OBJECTS) { 2076 check_for_visit(obj); 2077 } 2078 return true; 2079 } 2080 2081 // report a reference from a thread stack to an object 2082 inline bool CallbackInvoker::invoke_advanced_stack_ref_callback(jvmtiHeapReferenceKind ref_kind, 2083 jlong thread_tag, 2084 jlong tid, 2085 int depth, 2086 jmethodID method, 2087 jlocation bci, 2088 jint slot, 2089 const JvmtiHeapwalkObject& obj) { 2090 AdvancedHeapWalkContext* context = advanced_context(); 2091 2092 // check that callback is provider 2093 jvmtiHeapReferenceCallback cb = context->heap_reference_callback(); 2094 if (cb == nullptr) { 2095 return check_for_visit(obj); 2096 } 2097 2098 // apply class filter 2099 if (is_filtered_by_klass_filter(obj, context->klass_filter())) { 2100 return check_for_visit(obj); 2101 } 2102 2103 // setup the callback wrapper 2104 CallbackWrapper wrapper(tag_map(), obj); 2105 2106 // apply tag filter 2107 if (is_filtered_by_heap_filter(wrapper.obj_tag(), 2108 wrapper.klass_tag(), 2109 context->heap_filter())) { 2110 return check_for_visit(obj); 2111 } 2112 2113 // setup the referrer info 2114 jvmtiHeapReferenceInfo reference_info; 2115 reference_info.stack_local.thread_tag = thread_tag; 2116 reference_info.stack_local.thread_id = tid; 2117 reference_info.stack_local.depth = depth; 2118 reference_info.stack_local.method = method; 2119 reference_info.stack_local.location = bci; 2120 reference_info.stack_local.slot = slot; 2121 2122 // for arrays we need the length, otherwise -1 2123 jint len = get_array_length(obj); 2124 2125 // call into the agent 2126 int res = (*cb)(ref_kind, 2127 &reference_info, 2128 wrapper.klass_tag(), 2129 0, // referrer_class_tag is 0 for heap root (stack) 2130 wrapper.obj_size(), 2131 wrapper.obj_tag_p(), 2132 nullptr, // referrer_tag is 0 for root 2133 len, 2134 (void*)user_data()); 2135 2136 if (res & JVMTI_VISIT_ABORT) { 2137 return false; 2138 } 2139 if (res & JVMTI_VISIT_OBJECTS) { 2140 check_for_visit(obj); 2141 } 2142 return true; 2143 } 2144 2145 // This mask is used to pass reference_info to a jvmtiHeapReferenceCallback 2146 // only for ref_kinds defined by the JVM TI spec. Otherwise, null is passed. 2147 #define REF_INFO_MASK ((1 << JVMTI_HEAP_REFERENCE_FIELD) \ 2148 | (1 << JVMTI_HEAP_REFERENCE_STATIC_FIELD) \ 2149 | (1 << JVMTI_HEAP_REFERENCE_ARRAY_ELEMENT) \ 2150 | (1 << JVMTI_HEAP_REFERENCE_CONSTANT_POOL) \ 2151 | (1 << JVMTI_HEAP_REFERENCE_STACK_LOCAL) \ 2152 | (1 << JVMTI_HEAP_REFERENCE_JNI_LOCAL)) 2153 2154 // invoke the object reference callback to report a reference 2155 inline bool CallbackInvoker::invoke_advanced_object_reference_callback(jvmtiHeapReferenceKind ref_kind, 2156 const JvmtiHeapwalkObject& referrer, 2157 const JvmtiHeapwalkObject& obj, 2158 jint index) 2159 { 2160 // field index is only valid field in reference_info 2161 static jvmtiHeapReferenceInfo reference_info = { 0 }; 2162 2163 AdvancedHeapWalkContext* context = advanced_context(); 2164 2165 // check that callback is provider 2166 jvmtiHeapReferenceCallback cb = context->heap_reference_callback(); 2167 if (cb == nullptr) { 2168 return check_for_visit(obj); 2169 } 2170 2171 // apply class filter 2172 if (is_filtered_by_klass_filter(obj, context->klass_filter())) { 2173 return check_for_visit(obj); 2174 } 2175 2176 // setup the callback wrapper 2177 TwoOopCallbackWrapper wrapper(tag_map(), referrer, obj); 2178 2179 // apply tag filter 2180 if (is_filtered_by_heap_filter(wrapper.obj_tag(), 2181 wrapper.klass_tag(), 2182 context->heap_filter())) { 2183 return check_for_visit(obj); 2184 } 2185 2186 // field index is only valid field in reference_info 2187 reference_info.field.index = index; 2188 2189 // for arrays we need the length, otherwise -1 2190 jint len = get_array_length(obj); 2191 2192 // invoke the callback 2193 int res = (*cb)(ref_kind, 2194 (REF_INFO_MASK & (1 << ref_kind)) ? &reference_info : nullptr, 2195 wrapper.klass_tag(), 2196 wrapper.referrer_klass_tag(), 2197 wrapper.obj_size(), 2198 wrapper.obj_tag_p(), 2199 wrapper.referrer_tag_p(), 2200 len, 2201 (void*)user_data()); 2202 2203 if (res & JVMTI_VISIT_ABORT) { 2204 return false; 2205 } 2206 if (res & JVMTI_VISIT_OBJECTS) { 2207 check_for_visit(obj); 2208 } 2209 return true; 2210 } 2211 2212 // report a "simple root" 2213 inline bool CallbackInvoker::report_simple_root(jvmtiHeapReferenceKind kind, const JvmtiHeapwalkObject& obj) { 2214 assert(kind != JVMTI_HEAP_REFERENCE_STACK_LOCAL && 2215 kind != JVMTI_HEAP_REFERENCE_JNI_LOCAL, "not a simple root"); 2216 2217 if (is_basic_heap_walk()) { 2218 // map to old style root kind 2219 jvmtiHeapRootKind root_kind = toJvmtiHeapRootKind(kind); 2220 return invoke_basic_heap_root_callback(root_kind, obj); 2221 } else { 2222 assert(is_advanced_heap_walk(), "wrong heap walk type"); 2223 return invoke_advanced_heap_root_callback(kind, obj); 2224 } 2225 } 2226 2227 2228 // invoke the primitive array values 2229 inline bool CallbackInvoker::report_primitive_array_values(const JvmtiHeapwalkObject& obj) { 2230 assert(obj.klass()->is_typeArray_klass(), "not a primitive array"); 2231 2232 AdvancedHeapWalkContext* context = advanced_context(); 2233 assert(context->array_primitive_value_callback() != nullptr, "no callback"); 2234 2235 // apply class filter 2236 if (is_filtered_by_klass_filter(obj, context->klass_filter())) { 2237 return true; 2238 } 2239 2240 CallbackWrapper wrapper(tag_map(), obj); 2241 2242 // apply tag filter 2243 if (is_filtered_by_heap_filter(wrapper.obj_tag(), 2244 wrapper.klass_tag(), 2245 context->heap_filter())) { 2246 return true; 2247 } 2248 2249 // invoke the callback 2250 int res = invoke_array_primitive_value_callback(context->array_primitive_value_callback(), 2251 &wrapper, 2252 obj, 2253 (void*)user_data()); 2254 return (!(res & JVMTI_VISIT_ABORT)); 2255 } 2256 2257 // invoke the string value callback 2258 inline bool CallbackInvoker::report_string_value(const JvmtiHeapwalkObject& str) { 2259 assert(str.klass() == vmClasses::String_klass(), "not a string"); 2260 2261 AdvancedHeapWalkContext* context = advanced_context(); 2262 assert(context->string_primitive_value_callback() != nullptr, "no callback"); 2263 2264 // apply class filter 2265 if (is_filtered_by_klass_filter(str, context->klass_filter())) { 2266 return true; 2267 } 2268 2269 CallbackWrapper wrapper(tag_map(), str); 2270 2271 // apply tag filter 2272 if (is_filtered_by_heap_filter(wrapper.obj_tag(), 2273 wrapper.klass_tag(), 2274 context->heap_filter())) { 2275 return true; 2276 } 2277 2278 // invoke the callback 2279 int res = invoke_string_value_callback(context->string_primitive_value_callback(), 2280 &wrapper, 2281 str, 2282 (void*)user_data()); 2283 return (!(res & JVMTI_VISIT_ABORT)); 2284 } 2285 2286 // invoke the primitive field callback 2287 inline bool CallbackInvoker::report_primitive_field(jvmtiHeapReferenceKind ref_kind, 2288 const JvmtiHeapwalkObject& obj, 2289 jint index, 2290 address addr, 2291 char type) 2292 { 2293 // for primitive fields only the index will be set 2294 static jvmtiHeapReferenceInfo reference_info = { 0 }; 2295 2296 AdvancedHeapWalkContext* context = advanced_context(); 2297 assert(context->primitive_field_callback() != nullptr, "no callback"); 2298 2299 // apply class filter 2300 if (is_filtered_by_klass_filter(obj, context->klass_filter())) { 2301 return true; 2302 } 2303 2304 CallbackWrapper wrapper(tag_map(), obj); 2305 2306 // apply tag filter 2307 if (is_filtered_by_heap_filter(wrapper.obj_tag(), 2308 wrapper.klass_tag(), 2309 context->heap_filter())) { 2310 return true; 2311 } 2312 2313 // the field index in the referrer 2314 reference_info.field.index = index; 2315 2316 // map the type 2317 jvmtiPrimitiveType value_type = (jvmtiPrimitiveType)type; 2318 2319 // setup the jvalue 2320 jvalue value; 2321 copy_to_jvalue(&value, addr, value_type); 2322 2323 jvmtiPrimitiveFieldCallback cb = context->primitive_field_callback(); 2324 int res = (*cb)(ref_kind, 2325 &reference_info, 2326 wrapper.klass_tag(), 2327 wrapper.obj_tag_p(), 2328 value, 2329 value_type, 2330 (void*)user_data()); 2331 return (!(res & JVMTI_VISIT_ABORT)); 2332 } 2333 2334 2335 // instance field 2336 inline bool CallbackInvoker::report_primitive_instance_field(const JvmtiHeapwalkObject& obj, 2337 jint index, 2338 address value, 2339 char type) { 2340 return report_primitive_field(JVMTI_HEAP_REFERENCE_FIELD, 2341 obj, 2342 index, 2343 value, 2344 type); 2345 } 2346 2347 // static field 2348 inline bool CallbackInvoker::report_primitive_static_field(const JvmtiHeapwalkObject& obj, 2349 jint index, 2350 address value, 2351 char type) { 2352 return report_primitive_field(JVMTI_HEAP_REFERENCE_STATIC_FIELD, 2353 obj, 2354 index, 2355 value, 2356 type); 2357 } 2358 2359 // report a JNI local (root object) to the profiler 2360 inline bool CallbackInvoker::report_jni_local_root(jlong thread_tag, jlong tid, jint depth, jmethodID m, const JvmtiHeapwalkObject& obj) { 2361 if (is_basic_heap_walk()) { 2362 return invoke_basic_stack_ref_callback(JVMTI_HEAP_ROOT_JNI_LOCAL, 2363 thread_tag, 2364 depth, 2365 m, 2366 -1, 2367 obj); 2368 } else { 2369 return invoke_advanced_stack_ref_callback(JVMTI_HEAP_REFERENCE_JNI_LOCAL, 2370 thread_tag, tid, 2371 depth, 2372 m, 2373 (jlocation)-1, 2374 -1, 2375 obj); 2376 } 2377 } 2378 2379 2380 // report a local (stack reference, root object) 2381 inline bool CallbackInvoker::report_stack_ref_root(jlong thread_tag, 2382 jlong tid, 2383 jint depth, 2384 jmethodID method, 2385 jlocation bci, 2386 jint slot, 2387 const JvmtiHeapwalkObject& obj) { 2388 if (is_basic_heap_walk()) { 2389 return invoke_basic_stack_ref_callback(JVMTI_HEAP_ROOT_STACK_LOCAL, 2390 thread_tag, 2391 depth, 2392 method, 2393 slot, 2394 obj); 2395 } else { 2396 return invoke_advanced_stack_ref_callback(JVMTI_HEAP_REFERENCE_STACK_LOCAL, 2397 thread_tag, 2398 tid, 2399 depth, 2400 method, 2401 bci, 2402 slot, 2403 obj); 2404 } 2405 } 2406 2407 // report an object referencing a class. 2408 inline bool CallbackInvoker::report_class_reference(const JvmtiHeapwalkObject& referrer, const JvmtiHeapwalkObject& referree) { 2409 if (is_basic_heap_walk()) { 2410 return invoke_basic_object_reference_callback(JVMTI_REFERENCE_CLASS, referrer, referree, -1); 2411 } else { 2412 return invoke_advanced_object_reference_callback(JVMTI_HEAP_REFERENCE_CLASS, referrer, referree, -1); 2413 } 2414 } 2415 2416 // report a class referencing its class loader. 2417 inline bool CallbackInvoker::report_class_loader_reference(const JvmtiHeapwalkObject& referrer, const JvmtiHeapwalkObject& referree) { 2418 if (is_basic_heap_walk()) { 2419 return invoke_basic_object_reference_callback(JVMTI_REFERENCE_CLASS_LOADER, referrer, referree, -1); 2420 } else { 2421 return invoke_advanced_object_reference_callback(JVMTI_HEAP_REFERENCE_CLASS_LOADER, referrer, referree, -1); 2422 } 2423 } 2424 2425 // report a class referencing its signers. 2426 inline bool CallbackInvoker::report_signers_reference(const JvmtiHeapwalkObject& referrer, const JvmtiHeapwalkObject& referree) { 2427 if (is_basic_heap_walk()) { 2428 return invoke_basic_object_reference_callback(JVMTI_REFERENCE_SIGNERS, referrer, referree, -1); 2429 } else { 2430 return invoke_advanced_object_reference_callback(JVMTI_HEAP_REFERENCE_SIGNERS, referrer, referree, -1); 2431 } 2432 } 2433 2434 // report a class referencing its protection domain.. 2435 inline bool CallbackInvoker::report_protection_domain_reference(const JvmtiHeapwalkObject& referrer, const JvmtiHeapwalkObject& referree) { 2436 if (is_basic_heap_walk()) { 2437 return invoke_basic_object_reference_callback(JVMTI_REFERENCE_PROTECTION_DOMAIN, referrer, referree, -1); 2438 } else { 2439 return invoke_advanced_object_reference_callback(JVMTI_HEAP_REFERENCE_PROTECTION_DOMAIN, referrer, referree, -1); 2440 } 2441 } 2442 2443 // report a class referencing its superclass. 2444 inline bool CallbackInvoker::report_superclass_reference(const JvmtiHeapwalkObject& referrer, const JvmtiHeapwalkObject& referree) { 2445 if (is_basic_heap_walk()) { 2446 // Send this to be consistent with past implementation 2447 return invoke_basic_object_reference_callback(JVMTI_REFERENCE_CLASS, referrer, referree, -1); 2448 } else { 2449 return invoke_advanced_object_reference_callback(JVMTI_HEAP_REFERENCE_SUPERCLASS, referrer, referree, -1); 2450 } 2451 } 2452 2453 // report a class referencing one of its interfaces. 2454 inline bool CallbackInvoker::report_interface_reference(const JvmtiHeapwalkObject& referrer, const JvmtiHeapwalkObject& referree) { 2455 if (is_basic_heap_walk()) { 2456 return invoke_basic_object_reference_callback(JVMTI_REFERENCE_INTERFACE, referrer, referree, -1); 2457 } else { 2458 return invoke_advanced_object_reference_callback(JVMTI_HEAP_REFERENCE_INTERFACE, referrer, referree, -1); 2459 } 2460 } 2461 2462 // report a class referencing one of its static fields. 2463 inline bool CallbackInvoker::report_static_field_reference(const JvmtiHeapwalkObject& referrer, const JvmtiHeapwalkObject& referree, jint slot) { 2464 if (is_basic_heap_walk()) { 2465 return invoke_basic_object_reference_callback(JVMTI_REFERENCE_STATIC_FIELD, referrer, referree, slot); 2466 } else { 2467 return invoke_advanced_object_reference_callback(JVMTI_HEAP_REFERENCE_STATIC_FIELD, referrer, referree, slot); 2468 } 2469 } 2470 2471 // report an array referencing an element object 2472 inline bool CallbackInvoker::report_array_element_reference(const JvmtiHeapwalkObject& referrer, const JvmtiHeapwalkObject& referree, jint index) { 2473 if (is_basic_heap_walk()) { 2474 return invoke_basic_object_reference_callback(JVMTI_REFERENCE_ARRAY_ELEMENT, referrer, referree, index); 2475 } else { 2476 return invoke_advanced_object_reference_callback(JVMTI_HEAP_REFERENCE_ARRAY_ELEMENT, referrer, referree, index); 2477 } 2478 } 2479 2480 // report an object referencing an instance field object 2481 inline bool CallbackInvoker::report_field_reference(const JvmtiHeapwalkObject& referrer, const JvmtiHeapwalkObject& referree, jint slot) { 2482 if (is_basic_heap_walk()) { 2483 return invoke_basic_object_reference_callback(JVMTI_REFERENCE_FIELD, referrer, referree, slot); 2484 } else { 2485 return invoke_advanced_object_reference_callback(JVMTI_HEAP_REFERENCE_FIELD, referrer, referree, slot); 2486 } 2487 } 2488 2489 // report an array referencing an element object 2490 inline bool CallbackInvoker::report_constant_pool_reference(const JvmtiHeapwalkObject& referrer, const JvmtiHeapwalkObject& referree, jint index) { 2491 if (is_basic_heap_walk()) { 2492 return invoke_basic_object_reference_callback(JVMTI_REFERENCE_CONSTANT_POOL, referrer, referree, index); 2493 } else { 2494 return invoke_advanced_object_reference_callback(JVMTI_HEAP_REFERENCE_CONSTANT_POOL, referrer, referree, index); 2495 } 2496 } 2497 2498 // A supporting closure used to process simple roots 2499 class SimpleRootsClosure : public OopClosure { 2500 private: 2501 jvmtiHeapReferenceKind _kind; 2502 bool _continue; 2503 2504 jvmtiHeapReferenceKind root_kind() { return _kind; } 2505 2506 public: 2507 void set_kind(jvmtiHeapReferenceKind kind) { 2508 _kind = kind; 2509 _continue = true; 2510 } 2511 2512 inline bool stopped() { 2513 return !_continue; 2514 } 2515 2516 void do_oop(oop* obj_p) { 2517 // iteration has terminated 2518 if (stopped()) { 2519 return; 2520 } 2521 2522 oop o = NativeAccess<AS_NO_KEEPALIVE>::oop_load(obj_p); 2523 // ignore null 2524 if (o == nullptr) { 2525 return; 2526 } 2527 2528 assert(Universe::heap()->is_in(o), "should be impossible"); 2529 2530 jvmtiHeapReferenceKind kind = root_kind(); 2531 2532 // invoke the callback 2533 _continue = CallbackInvoker::report_simple_root(kind, o); 2534 2535 } 2536 virtual void do_oop(narrowOop* obj_p) { ShouldNotReachHere(); } 2537 }; 2538 2539 // A supporting closure used to process JNI locals 2540 class JNILocalRootsClosure : public OopClosure { 2541 private: 2542 jlong _thread_tag; 2543 jlong _tid; 2544 jint _depth; 2545 jmethodID _method; 2546 bool _continue; 2547 public: 2548 void set_context(jlong thread_tag, jlong tid, jint depth, jmethodID method) { 2549 _thread_tag = thread_tag; 2550 _tid = tid; 2551 _depth = depth; 2552 _method = method; 2553 _continue = true; 2554 } 2555 2556 inline bool stopped() { 2557 return !_continue; 2558 } 2559 2560 void do_oop(oop* obj_p) { 2561 // iteration has terminated 2562 if (stopped()) { 2563 return; 2564 } 2565 2566 oop o = *obj_p; 2567 // ignore null 2568 if (o == nullptr) { 2569 return; 2570 } 2571 2572 // invoke the callback 2573 _continue = CallbackInvoker::report_jni_local_root(_thread_tag, _tid, _depth, _method, o); 2574 } 2575 virtual void do_oop(narrowOop* obj_p) { ShouldNotReachHere(); } 2576 }; 2577 2578 // Helper class to collect/report stack references. 2579 class StackRefCollector { 2580 private: 2581 JvmtiTagMap* _tag_map; 2582 JNILocalRootsClosure* _blk; 2583 // java_thread is needed only to report JNI local on top native frame; 2584 // I.e. it's required only for platform/carrier threads or mounted virtual threads. 2585 JavaThread* _java_thread; 2586 2587 oop _threadObj; 2588 jlong _thread_tag; 2589 jlong _tid; 2590 2591 bool _is_top_frame; 2592 int _depth; 2593 frame* _last_entry_frame; 2594 2595 bool report_java_stack_refs(StackValueCollection* values, jmethodID method, jlocation bci, jint slot_offset); 2596 bool report_native_stack_refs(jmethodID method); 2597 2598 public: 2599 StackRefCollector(JvmtiTagMap* tag_map, JNILocalRootsClosure* blk, JavaThread* java_thread) 2600 : _tag_map(tag_map), _blk(blk), _java_thread(java_thread), 2601 _threadObj(nullptr), _thread_tag(0), _tid(0), 2602 _is_top_frame(true), _depth(0), _last_entry_frame(nullptr) 2603 { 2604 } 2605 2606 bool set_thread(oop o); 2607 // Sets the thread and reports the reference to it with the specified kind. 2608 bool set_thread(jvmtiHeapReferenceKind kind, oop o); 2609 2610 bool do_frame(vframe* vf); 2611 // Handles frames until vf->sender() is null. 2612 bool process_frames(vframe* vf); 2613 }; 2614 2615 bool StackRefCollector::set_thread(oop o) { 2616 _threadObj = o; 2617 _thread_tag = _tag_map->find(_threadObj); 2618 _tid = java_lang_Thread::thread_id(_threadObj); 2619 2620 _is_top_frame = true; 2621 _depth = 0; 2622 _last_entry_frame = nullptr; 2623 2624 return true; 2625 } 2626 2627 bool StackRefCollector::set_thread(jvmtiHeapReferenceKind kind, oop o) { 2628 return set_thread(o) 2629 && CallbackInvoker::report_simple_root(kind, _threadObj); 2630 } 2631 2632 bool StackRefCollector::report_java_stack_refs(StackValueCollection* values, jmethodID method, jlocation bci, jint slot_offset) { 2633 for (int index = 0; index < values->size(); index++) { 2634 if (values->at(index)->type() == T_OBJECT) { 2635 oop obj = values->obj_at(index)(); 2636 if (obj == nullptr) { 2637 continue; 2638 } 2639 // stack reference 2640 if (!CallbackInvoker::report_stack_ref_root(_thread_tag, _tid, _depth, method, 2641 bci, slot_offset + index, obj)) { 2642 return false; 2643 } 2644 } 2645 } 2646 return true; 2647 } 2648 2649 bool StackRefCollector::report_native_stack_refs(jmethodID method) { 2650 _blk->set_context(_thread_tag, _tid, _depth, method); 2651 if (_is_top_frame) { 2652 // JNI locals for the top frame. 2653 if (_java_thread != nullptr) { 2654 _java_thread->active_handles()->oops_do(_blk); 2655 if (_blk->stopped()) { 2656 return false; 2657 } 2658 } 2659 } else { 2660 if (_last_entry_frame != nullptr) { 2661 // JNI locals for the entry frame. 2662 assert(_last_entry_frame->is_entry_frame(), "checking"); 2663 _last_entry_frame->entry_frame_call_wrapper()->handles()->oops_do(_blk); 2664 if (_blk->stopped()) { 2665 return false; 2666 } 2667 } 2668 } 2669 return true; 2670 } 2671 2672 bool StackRefCollector::do_frame(vframe* vf) { 2673 if (vf->is_java_frame()) { 2674 // java frame (interpreted, compiled, ...) 2675 javaVFrame* jvf = javaVFrame::cast(vf); 2676 2677 jmethodID method = jvf->method()->jmethod_id(); 2678 2679 if (!(jvf->method()->is_native())) { 2680 jlocation bci = (jlocation)jvf->bci(); 2681 StackValueCollection* locals = jvf->locals(); 2682 if (!report_java_stack_refs(locals, method, bci, 0)) { 2683 return false; 2684 } 2685 if (!report_java_stack_refs(jvf->expressions(), method, bci, locals->size())) { 2686 return false; 2687 } 2688 2689 // Follow oops from compiled nmethod. 2690 if (jvf->cb() != nullptr && jvf->cb()->is_nmethod()) { 2691 _blk->set_context(_thread_tag, _tid, _depth, method); 2692 // Need to apply load barriers for unmounted vthreads. 2693 nmethod* nm = jvf->cb()->as_nmethod(); 2694 nm->run_nmethod_entry_barrier(); 2695 nm->oops_do(_blk); 2696 if (_blk->stopped()) { 2697 return false; 2698 } 2699 } 2700 } else { 2701 // native frame 2702 if (!report_native_stack_refs(method)) { 2703 return false; 2704 } 2705 } 2706 _last_entry_frame = nullptr; 2707 _depth++; 2708 } else { 2709 // externalVFrame - for an entry frame then we report the JNI locals 2710 // when we find the corresponding javaVFrame 2711 frame* fr = vf->frame_pointer(); 2712 assert(fr != nullptr, "sanity check"); 2713 if (fr->is_entry_frame()) { 2714 _last_entry_frame = fr; 2715 } 2716 } 2717 2718 _is_top_frame = false; 2719 2720 return true; 2721 } 2722 2723 bool StackRefCollector::process_frames(vframe* vf) { 2724 while (vf != nullptr) { 2725 if (!do_frame(vf)) { 2726 return false; 2727 } 2728 vf = vf->sender(); 2729 } 2730 return true; 2731 } 2732 2733 2734 // A VM operation to iterate over objects that are reachable from 2735 // a set of roots or an initial object. 2736 // 2737 // For VM_HeapWalkOperation the set of roots used is :- 2738 // 2739 // - All JNI global references 2740 // - All inflated monitors 2741 // - All classes loaded by the boot class loader (or all classes 2742 // in the event that class unloading is disabled) 2743 // - All java threads 2744 // - For each java thread then all locals and JNI local references 2745 // on the thread's execution stack 2746 // - All visible/explainable objects from Universes::oops_do 2747 // 2748 class VM_HeapWalkOperation: public VM_Operation { 2749 private: 2750 bool _is_advanced_heap_walk; // indicates FollowReferences 2751 JvmtiTagMap* _tag_map; 2752 Handle _initial_object; 2753 JvmtiHeapwalkVisitStack _visit_stack; 2754 2755 // Dead object tags in JvmtiTagMap 2756 GrowableArray<jlong>* _dead_objects; 2757 2758 bool _following_object_refs; // are we following object references 2759 2760 bool _reporting_primitive_fields; // optional reporting 2761 bool _reporting_primitive_array_values; 2762 bool _reporting_string_values; 2763 2764 // accessors 2765 bool is_advanced_heap_walk() const { return _is_advanced_heap_walk; } 2766 JvmtiTagMap* tag_map() const { return _tag_map; } 2767 Handle initial_object() const { return _initial_object; } 2768 2769 bool is_following_references() const { return _following_object_refs; } 2770 2771 bool is_reporting_primitive_fields() const { return _reporting_primitive_fields; } 2772 bool is_reporting_primitive_array_values() const { return _reporting_primitive_array_values; } 2773 bool is_reporting_string_values() const { return _reporting_string_values; } 2774 2775 JvmtiHeapwalkVisitStack* visit_stack() { return &_visit_stack; } 2776 2777 // iterate over the various object types 2778 inline bool iterate_over_array(const JvmtiHeapwalkObject& o); 2779 inline bool iterate_over_flat_array(const JvmtiHeapwalkObject& o); 2780 inline bool iterate_over_type_array(const JvmtiHeapwalkObject& o); 2781 inline bool iterate_over_class(const JvmtiHeapwalkObject& o); 2782 inline bool iterate_over_object(const JvmtiHeapwalkObject& o); 2783 2784 // root collection 2785 inline bool collect_simple_roots(); 2786 inline bool collect_stack_roots(); 2787 inline bool collect_stack_refs(JavaThread* java_thread, JNILocalRootsClosure* blk); 2788 inline bool collect_vthread_stack_refs(oop vt); 2789 2790 // visit an object 2791 inline bool visit(const JvmtiHeapwalkObject& o); 2792 2793 public: 2794 VM_HeapWalkOperation(JvmtiTagMap* tag_map, 2795 Handle initial_object, 2796 BasicHeapWalkContext callbacks, 2797 const void* user_data, 2798 GrowableArray<jlong>* objects); 2799 2800 VM_HeapWalkOperation(JvmtiTagMap* tag_map, 2801 Handle initial_object, 2802 AdvancedHeapWalkContext callbacks, 2803 const void* user_data, 2804 GrowableArray<jlong>* objects); 2805 2806 ~VM_HeapWalkOperation(); 2807 2808 VMOp_Type type() const { return VMOp_HeapWalkOperation; } 2809 void doit(); 2810 }; 2811 2812 2813 VM_HeapWalkOperation::VM_HeapWalkOperation(JvmtiTagMap* tag_map, 2814 Handle initial_object, 2815 BasicHeapWalkContext callbacks, 2816 const void* user_data, 2817 GrowableArray<jlong>* objects) { 2818 _is_advanced_heap_walk = false; 2819 _tag_map = tag_map; 2820 _initial_object = initial_object; 2821 _following_object_refs = (callbacks.object_ref_callback() != nullptr); 2822 _reporting_primitive_fields = false; 2823 _reporting_primitive_array_values = false; 2824 _reporting_string_values = false; 2825 _dead_objects = objects; 2826 CallbackInvoker::initialize_for_basic_heap_walk(tag_map, user_data, callbacks, &_visit_stack); 2827 } 2828 2829 VM_HeapWalkOperation::VM_HeapWalkOperation(JvmtiTagMap* tag_map, 2830 Handle initial_object, 2831 AdvancedHeapWalkContext callbacks, 2832 const void* user_data, 2833 GrowableArray<jlong>* objects) { 2834 _is_advanced_heap_walk = true; 2835 _tag_map = tag_map; 2836 _initial_object = initial_object; 2837 _following_object_refs = true; 2838 _reporting_primitive_fields = (callbacks.primitive_field_callback() != nullptr);; 2839 _reporting_primitive_array_values = (callbacks.array_primitive_value_callback() != nullptr);; 2840 _reporting_string_values = (callbacks.string_primitive_value_callback() != nullptr);; 2841 _dead_objects = objects; 2842 CallbackInvoker::initialize_for_advanced_heap_walk(tag_map, user_data, callbacks, &_visit_stack); 2843 } 2844 2845 VM_HeapWalkOperation::~VM_HeapWalkOperation() { 2846 } 2847 2848 // an array references its class and has a reference to 2849 // each element in the array 2850 inline bool VM_HeapWalkOperation::iterate_over_array(const JvmtiHeapwalkObject& o) { 2851 assert(!o.is_flat(), "Array object cannot be flattened"); 2852 objArrayOop array = objArrayOop(o.obj()); 2853 2854 // array reference to its class 2855 oop mirror = ObjArrayKlass::cast(array->klass())->java_mirror(); 2856 if (!CallbackInvoker::report_class_reference(o, mirror)) { 2857 return false; 2858 } 2859 2860 // iterate over the array and report each reference to a 2861 // non-null element 2862 for (int index=0; index<array->length(); index++) { 2863 oop elem = array->obj_at(index); 2864 if (elem == nullptr) { 2865 continue; 2866 } 2867 2868 // report the array reference o[index] = elem 2869 if (!CallbackInvoker::report_array_element_reference(o, elem, index)) { 2870 return false; 2871 } 2872 } 2873 return true; 2874 } 2875 2876 // similar to iterate_over_array(), but itrates over flat array 2877 inline bool VM_HeapWalkOperation::iterate_over_flat_array(const JvmtiHeapwalkObject& o) { 2878 assert(!o.is_flat(), "Array object cannot be flattened"); 2879 flatArrayOop array = flatArrayOop(o.obj()); 2880 FlatArrayKlass* faklass = FlatArrayKlass::cast(array->klass()); 2881 InlineKlass* vk = InlineKlass::cast(faklass->element_klass()); 2882 bool need_null_check = faklass->layout_kind() == LayoutKind::NULLABLE_ATOMIC_FLAT; 2883 2884 // array reference to its class 2885 oop mirror = faklass->java_mirror(); 2886 if (!CallbackInvoker::report_class_reference(o, mirror)) { 2887 return false; 2888 } 2889 2890 // iterate over the array and report each reference to a 2891 // non-null element 2892 for (int index = 0; index < array->length(); index++) { 2893 address addr = (address)array->value_at_addr(index, faklass->layout_helper()); 2894 2895 // check for null 2896 if (need_null_check) { 2897 if (vk->is_payload_marked_as_null(addr)) { 2898 continue; 2899 } 2900 } 2901 2902 // offset in the array oop 2903 int offset = (int)(addr - cast_from_oop<address>(array)); 2904 JvmtiHeapwalkObject elem(o.obj(), offset, vk, faklass->layout_kind()); 2905 2906 // report the array reference 2907 if (!CallbackInvoker::report_array_element_reference(o, elem, index)) { 2908 return false; 2909 } 2910 } 2911 return true; 2912 } 2913 2914 // a type array references its class 2915 inline bool VM_HeapWalkOperation::iterate_over_type_array(const JvmtiHeapwalkObject& o) { 2916 assert(!o.is_flat(), "Array object cannot be flattened"); 2917 Klass* k = o.klass(); 2918 oop mirror = k->java_mirror(); 2919 if (!CallbackInvoker::report_class_reference(o, mirror)) { 2920 return false; 2921 } 2922 2923 // report the array contents if required 2924 if (is_reporting_primitive_array_values()) { 2925 if (!CallbackInvoker::report_primitive_array_values(o)) { 2926 return false; 2927 } 2928 } 2929 return true; 2930 } 2931 2932 #ifdef ASSERT 2933 // verify that a static oop field is in range 2934 static inline bool verify_static_oop(InstanceKlass* ik, 2935 oop mirror, int offset) { 2936 address obj_p = cast_from_oop<address>(mirror) + offset; 2937 address start = (address)InstanceMirrorKlass::start_of_static_fields(mirror); 2938 address end = start + (java_lang_Class::static_oop_field_count(mirror) * heapOopSize); 2939 assert(end >= start, "sanity check"); 2940 2941 if (obj_p >= start && obj_p < end) { 2942 return true; 2943 } else { 2944 return false; 2945 } 2946 } 2947 #endif // #ifdef ASSERT 2948 2949 // a class references its super class, interfaces, class loader, ... 2950 // and finally its static fields 2951 inline bool VM_HeapWalkOperation::iterate_over_class(const JvmtiHeapwalkObject& o) { 2952 assert(!o.is_flat(), "Klass object cannot be flattened"); 2953 Klass* klass = java_lang_Class::as_Klass(o.obj()); 2954 int i; 2955 2956 if (klass->is_instance_klass()) { 2957 InstanceKlass* ik = InstanceKlass::cast(klass); 2958 2959 // Ignore the class if it hasn't been initialized yet 2960 if (!ik->is_linked()) { 2961 return true; 2962 } 2963 2964 // get the java mirror 2965 oop mirror_oop = klass->java_mirror(); 2966 JvmtiHeapwalkObject mirror(mirror_oop); 2967 2968 // super (only if something more interesting than java.lang.Object) 2969 InstanceKlass* java_super = ik->java_super(); 2970 if (java_super != nullptr && java_super != vmClasses::Object_klass()) { 2971 oop super = java_super->java_mirror(); 2972 if (!CallbackInvoker::report_superclass_reference(mirror, super)) { 2973 return false; 2974 } 2975 } 2976 2977 // class loader 2978 oop cl = ik->class_loader(); 2979 if (cl != nullptr) { 2980 if (!CallbackInvoker::report_class_loader_reference(mirror, cl)) { 2981 return false; 2982 } 2983 } 2984 2985 // protection domain 2986 oop pd = ik->protection_domain(); 2987 if (pd != nullptr) { 2988 if (!CallbackInvoker::report_protection_domain_reference(mirror, pd)) { 2989 return false; 2990 } 2991 } 2992 2993 // signers 2994 oop signers = ik->signers(); 2995 if (signers != nullptr) { 2996 if (!CallbackInvoker::report_signers_reference(mirror, signers)) { 2997 return false; 2998 } 2999 } 3000 3001 // references from the constant pool 3002 { 3003 ConstantPool* pool = ik->constants(); 3004 for (int i = 1; i < pool->length(); i++) { 3005 constantTag tag = pool->tag_at(i).value(); 3006 if (tag.is_string() || tag.is_klass() || tag.is_unresolved_klass()) { 3007 oop entry; 3008 if (tag.is_string()) { 3009 entry = pool->resolved_string_at(i); 3010 // If the entry is non-null it is resolved. 3011 if (entry == nullptr) { 3012 continue; 3013 } 3014 } else if (tag.is_klass()) { 3015 entry = pool->resolved_klass_at(i)->java_mirror(); 3016 } else { 3017 // Code generated by JIT compilers might not resolve constant 3018 // pool entries. Treat them as resolved if they are loaded. 3019 assert(tag.is_unresolved_klass(), "must be"); 3020 constantPoolHandle cp(Thread::current(), pool); 3021 Klass* klass = ConstantPool::klass_at_if_loaded(cp, i); 3022 if (klass == nullptr) { 3023 continue; 3024 } 3025 entry = klass->java_mirror(); 3026 } 3027 if (!CallbackInvoker::report_constant_pool_reference(mirror, entry, (jint)i)) { 3028 return false; 3029 } 3030 } 3031 } 3032 } 3033 3034 // interfaces 3035 // (These will already have been reported as references from the constant pool 3036 // but are specified by IterateOverReachableObjects and must be reported). 3037 Array<InstanceKlass*>* interfaces = ik->local_interfaces(); 3038 for (i = 0; i < interfaces->length(); i++) { 3039 oop interf = interfaces->at(i)->java_mirror(); 3040 if (interf == nullptr) { 3041 continue; 3042 } 3043 if (!CallbackInvoker::report_interface_reference(mirror, interf)) { 3044 return false; 3045 } 3046 } 3047 3048 // iterate over the static fields 3049 3050 ClassFieldMap* field_map = ClassFieldMap::create_map_of_static_fields(klass); 3051 for (i=0; i<field_map->field_count(); i++) { 3052 ClassFieldDescriptor* field = field_map->field_at(i); 3053 char type = field->field_type(); 3054 if (!is_primitive_field_type(type)) { 3055 oop fld_o = mirror_oop->obj_field(field->field_offset()); 3056 assert(verify_static_oop(ik, mirror_oop, field->field_offset()), "sanity check"); 3057 if (fld_o != nullptr) { 3058 int slot = field->field_index(); 3059 if (!CallbackInvoker::report_static_field_reference(mirror, fld_o, slot)) { 3060 delete field_map; 3061 return false; 3062 } 3063 } 3064 } else { 3065 if (is_reporting_primitive_fields()) { 3066 address addr = cast_from_oop<address>(mirror_oop) + field->field_offset(); 3067 int slot = field->field_index(); 3068 if (!CallbackInvoker::report_primitive_static_field(mirror, slot, addr, type)) { 3069 delete field_map; 3070 return false; 3071 } 3072 } 3073 } 3074 } 3075 delete field_map; 3076 3077 return true; 3078 } 3079 3080 return true; 3081 } 3082 3083 // an object references a class and its instance fields 3084 // (static fields are ignored here as we report these as 3085 // references from the class). 3086 inline bool VM_HeapWalkOperation::iterate_over_object(const JvmtiHeapwalkObject& o) { 3087 // reference to the class 3088 if (!CallbackInvoker::report_class_reference(o, o.klass()->java_mirror())) { 3089 return false; 3090 } 3091 3092 // iterate over instance fields 3093 ClassFieldMap* field_map = JvmtiCachedClassFieldMap::get_map_of_instance_fields(o.klass()); 3094 for (int i=0; i<field_map->field_count(); i++) { 3095 ClassFieldDescriptor* field = field_map->field_at(i); 3096 char type = field->field_type(); 3097 int slot = field->field_index(); 3098 int field_offset = field->field_offset(); 3099 if (o.is_flat()) { 3100 // the object is inlined, its fields are stored without the header 3101 field_offset += o.offset() - o.inline_klass()->payload_offset(); 3102 } 3103 if (!is_primitive_field_type(type)) { 3104 if (field->is_flat()) { 3105 // check for possible nulls 3106 bool can_be_null = field->layout_kind() == LayoutKind::NULLABLE_ATOMIC_FLAT; 3107 if (can_be_null) { 3108 address payload = cast_from_oop<address>(o.obj()) + field_offset; 3109 if (field->inline_klass()->is_payload_marked_as_null(payload)) { 3110 continue; 3111 } 3112 } 3113 JvmtiHeapwalkObject field_obj(o.obj(), field_offset, field->inline_klass(), field->layout_kind()); 3114 if (!CallbackInvoker::report_field_reference(o, field_obj, slot)) { 3115 return false; 3116 } 3117 } else { 3118 oop fld_o = o.obj()->obj_field_access<AS_NO_KEEPALIVE | ON_UNKNOWN_OOP_REF>(field_offset); 3119 // ignore any objects that aren't visible to profiler 3120 if (fld_o != nullptr) { 3121 assert(Universe::heap()->is_in(fld_o), "unsafe code should not have references to Klass* anymore"); 3122 if (!CallbackInvoker::report_field_reference(o, fld_o, slot)) { 3123 return false; 3124 } 3125 } 3126 } 3127 } else { 3128 if (is_reporting_primitive_fields()) { 3129 // primitive instance field 3130 address addr = cast_from_oop<address>(o.obj()) + field_offset; 3131 if (!CallbackInvoker::report_primitive_instance_field(o, slot, addr, type)) { 3132 return false; 3133 } 3134 } 3135 } 3136 } 3137 3138 // if the object is a java.lang.String 3139 if (is_reporting_string_values() && 3140 o.klass() == vmClasses::String_klass()) { 3141 if (!CallbackInvoker::report_string_value(o)) { 3142 return false; 3143 } 3144 } 3145 return true; 3146 } 3147 3148 3149 // Collects all simple (non-stack) roots except for threads; 3150 // threads are handled in collect_stack_roots() as an optimization. 3151 // if there's a heap root callback provided then the callback is 3152 // invoked for each simple root. 3153 // if an object reference callback is provided then all simple 3154 // roots are pushed onto the marking stack so that they can be 3155 // processed later 3156 // 3157 inline bool VM_HeapWalkOperation::collect_simple_roots() { 3158 SimpleRootsClosure blk; 3159 3160 // JNI globals 3161 blk.set_kind(JVMTI_HEAP_REFERENCE_JNI_GLOBAL); 3162 JNIHandles::oops_do(&blk); 3163 if (blk.stopped()) { 3164 return false; 3165 } 3166 3167 // Preloaded classes and loader from the system dictionary 3168 blk.set_kind(JVMTI_HEAP_REFERENCE_SYSTEM_CLASS); 3169 CLDToOopClosure cld_closure(&blk, ClassLoaderData::_claim_none); 3170 ClassLoaderDataGraph::always_strong_cld_do(&cld_closure); 3171 if (blk.stopped()) { 3172 return false; 3173 } 3174 3175 // threads are now handled in collect_stack_roots() 3176 3177 // Other kinds of roots maintained by HotSpot 3178 // Many of these won't be visible but others (such as instances of important 3179 // exceptions) will be visible. 3180 blk.set_kind(JVMTI_HEAP_REFERENCE_OTHER); 3181 Universe::vm_global()->oops_do(&blk); 3182 if (blk.stopped()) { 3183 return false; 3184 } 3185 3186 return true; 3187 } 3188 3189 // Reports the thread as JVMTI_HEAP_REFERENCE_THREAD, 3190 // walks the stack of the thread, finds all references (locals 3191 // and JNI calls) and reports these as stack references. 3192 inline bool VM_HeapWalkOperation::collect_stack_refs(JavaThread* java_thread, 3193 JNILocalRootsClosure* blk) 3194 { 3195 oop threadObj = java_thread->threadObj(); 3196 oop mounted_vt = java_thread->is_vthread_mounted() ? java_thread->vthread() : nullptr; 3197 if (mounted_vt != nullptr && !JvmtiEnvBase::is_vthread_alive(mounted_vt)) { 3198 mounted_vt = nullptr; 3199 } 3200 assert(threadObj != nullptr, "sanity check"); 3201 3202 StackRefCollector stack_collector(tag_map(), blk, java_thread); 3203 3204 if (!java_thread->has_last_Java_frame()) { 3205 if (!stack_collector.set_thread(JVMTI_HEAP_REFERENCE_THREAD, threadObj)) { 3206 return false; 3207 } 3208 // no last java frame but there may be JNI locals 3209 blk->set_context(_tag_map->find(threadObj), java_lang_Thread::thread_id(threadObj), 0, (jmethodID)nullptr); 3210 java_thread->active_handles()->oops_do(blk); 3211 return !blk->stopped(); 3212 } 3213 // vframes are resource allocated 3214 Thread* current_thread = Thread::current(); 3215 ResourceMark rm(current_thread); 3216 HandleMark hm(current_thread); 3217 3218 RegisterMap reg_map(java_thread, 3219 RegisterMap::UpdateMap::include, 3220 RegisterMap::ProcessFrames::include, 3221 RegisterMap::WalkContinuation::include); 3222 3223 // first handle mounted vthread (if any) 3224 if (mounted_vt != nullptr) { 3225 frame f = java_thread->last_frame(); 3226 vframe* vf = vframe::new_vframe(&f, ®_map, java_thread); 3227 // report virtual thread as JVMTI_HEAP_REFERENCE_OTHER 3228 if (!stack_collector.set_thread(JVMTI_HEAP_REFERENCE_OTHER, mounted_vt)) { 3229 return false; 3230 } 3231 // split virtual thread and carrier thread stacks by vthread entry ("enterSpecial") frame, 3232 // consider vthread entry frame as the last vthread stack frame 3233 while (vf != nullptr) { 3234 if (!stack_collector.do_frame(vf)) { 3235 return false; 3236 } 3237 if (vf->is_vthread_entry()) { 3238 break; 3239 } 3240 vf = vf->sender(); 3241 } 3242 } 3243 // Platform or carrier thread. 3244 vframe* vf = JvmtiEnvBase::get_cthread_last_java_vframe(java_thread, ®_map); 3245 if (!stack_collector.set_thread(JVMTI_HEAP_REFERENCE_THREAD, threadObj)) { 3246 return false; 3247 } 3248 return stack_collector.process_frames(vf); 3249 } 3250 3251 3252 // Collects the simple roots for all threads and collects all 3253 // stack roots - for each thread it walks the execution 3254 // stack to find all references and local JNI refs. 3255 inline bool VM_HeapWalkOperation::collect_stack_roots() { 3256 JNILocalRootsClosure blk; 3257 for (JavaThreadIteratorWithHandle jtiwh; JavaThread *thread = jtiwh.next(); ) { 3258 oop threadObj = thread->threadObj(); 3259 if (threadObj != nullptr && !thread->is_exiting() && !thread->is_hidden_from_external_view()) { 3260 if (!collect_stack_refs(thread, &blk)) { 3261 return false; 3262 } 3263 } 3264 } 3265 return true; 3266 } 3267 3268 // Reports stack references for the unmounted virtual thread. 3269 inline bool VM_HeapWalkOperation::collect_vthread_stack_refs(oop vt) { 3270 if (!JvmtiEnvBase::is_vthread_alive(vt)) { 3271 return true; 3272 } 3273 ContinuationWrapper cont(java_lang_VirtualThread::continuation(vt)); 3274 if (cont.is_empty()) { 3275 return true; 3276 } 3277 assert(!cont.is_mounted(), "sanity check"); 3278 3279 stackChunkOop chunk = cont.last_nonempty_chunk(); 3280 if (chunk == nullptr || chunk->is_empty()) { 3281 return true; 3282 } 3283 3284 // vframes are resource allocated 3285 Thread* current_thread = Thread::current(); 3286 ResourceMark rm(current_thread); 3287 HandleMark hm(current_thread); 3288 3289 RegisterMap reg_map(cont.continuation(), RegisterMap::UpdateMap::include); 3290 3291 JNILocalRootsClosure blk; 3292 // JavaThread is not required for unmounted virtual threads 3293 StackRefCollector stack_collector(tag_map(), &blk, nullptr); 3294 // reference to the vthread is already reported 3295 if (!stack_collector.set_thread(vt)) { 3296 return false; 3297 } 3298 3299 frame fr = chunk->top_frame(®_map); 3300 vframe* vf = vframe::new_vframe(&fr, ®_map, nullptr); 3301 return stack_collector.process_frames(vf); 3302 } 3303 3304 // visit an object 3305 // first mark the object as visited 3306 // second get all the outbound references from this object (in other words, all 3307 // the objects referenced by this object). 3308 // 3309 bool VM_HeapWalkOperation::visit(const JvmtiHeapwalkObject& o) { 3310 // mark object as visited 3311 assert(!visit_stack()->is_visited(o), "can't visit same object more than once"); 3312 visit_stack()->mark_visited(o); 3313 3314 Klass* klass = o.klass(); 3315 // instance 3316 if (klass->is_instance_klass()) { 3317 if (klass == vmClasses::Class_klass()) { 3318 assert(!o.is_flat(), "Class object cannot be flattened"); 3319 if (!java_lang_Class::is_primitive(o.obj())) { 3320 // a java.lang.Class 3321 return iterate_over_class(o); 3322 } 3323 } else { 3324 // we report stack references only when initial object is not specified 3325 // (in the case we start from heap roots which include platform thread stack references) 3326 if (initial_object().is_null() && java_lang_VirtualThread::is_subclass(klass)) { 3327 assert(!o.is_flat(), "VirtualThread object cannot be flattened"); 3328 if (!collect_vthread_stack_refs(o.obj())) { 3329 return false; 3330 } 3331 } 3332 return iterate_over_object(o); 3333 } 3334 } 3335 3336 // flat object array 3337 if (klass->is_flatArray_klass()) { 3338 return iterate_over_flat_array(o); 3339 } 3340 3341 // object array 3342 if (klass->is_objArray_klass()) { 3343 return iterate_over_array(o); 3344 } 3345 3346 // type array 3347 if (klass->is_typeArray_klass()) { 3348 return iterate_over_type_array(o); 3349 } 3350 3351 return true; 3352 } 3353 3354 void VM_HeapWalkOperation::doit() { 3355 ResourceMark rm; 3356 ClassFieldMapCacheMark cm; 3357 3358 JvmtiTagMap::check_hashmaps_for_heapwalk(_dead_objects); 3359 3360 assert(visit_stack()->is_empty(), "visit stack must be empty"); 3361 3362 // the heap walk starts with an initial object or the heap roots 3363 if (initial_object().is_null()) { 3364 // can result in a big performance boost for an agent that is 3365 // focused on analyzing references in the thread stacks. 3366 if (!collect_stack_roots()) return; 3367 3368 if (!collect_simple_roots()) return; 3369 } else { 3370 visit_stack()->push(initial_object()()); 3371 } 3372 3373 // object references required 3374 if (is_following_references()) { 3375 3376 // visit each object until all reachable objects have been 3377 // visited or the callback asked to terminate the iteration. 3378 while (!visit_stack()->is_empty()) { 3379 const JvmtiHeapwalkObject o = visit_stack()->pop(); 3380 if (!visit_stack()->is_visited(o)) { 3381 if (!visit(o)) { 3382 break; 3383 } 3384 } 3385 } 3386 } 3387 } 3388 3389 // iterate over all objects that are reachable from a set of roots 3390 void JvmtiTagMap::iterate_over_reachable_objects(jvmtiHeapRootCallback heap_root_callback, 3391 jvmtiStackReferenceCallback stack_ref_callback, 3392 jvmtiObjectReferenceCallback object_ref_callback, 3393 const void* user_data) { 3394 // VTMS transitions must be disabled before the EscapeBarrier. 3395 JvmtiVTMSTransitionDisabler disabler; 3396 3397 JavaThread* jt = JavaThread::current(); 3398 EscapeBarrier eb(true, jt); 3399 eb.deoptimize_objects_all_threads(); 3400 Arena dead_object_arena(mtServiceability); 3401 GrowableArray<jlong> dead_objects(&dead_object_arena, 10, 0, 0); 3402 3403 { 3404 MutexLocker ml(Heap_lock); 3405 BasicHeapWalkContext context(heap_root_callback, stack_ref_callback, object_ref_callback); 3406 VM_HeapWalkOperation op(this, Handle(), context, user_data, &dead_objects); 3407 VMThread::execute(&op); 3408 } 3409 convert_flat_object_entries(); 3410 3411 // Post events outside of Heap_lock 3412 post_dead_objects(&dead_objects); 3413 } 3414 3415 // iterate over all objects that are reachable from a given object 3416 void JvmtiTagMap::iterate_over_objects_reachable_from_object(jobject object, 3417 jvmtiObjectReferenceCallback object_ref_callback, 3418 const void* user_data) { 3419 oop obj = JNIHandles::resolve(object); 3420 Handle initial_object(Thread::current(), obj); 3421 3422 Arena dead_object_arena(mtServiceability); 3423 GrowableArray<jlong> dead_objects(&dead_object_arena, 10, 0, 0); 3424 3425 JvmtiVTMSTransitionDisabler disabler; 3426 3427 { 3428 MutexLocker ml(Heap_lock); 3429 BasicHeapWalkContext context(nullptr, nullptr, object_ref_callback); 3430 VM_HeapWalkOperation op(this, initial_object, context, user_data, &dead_objects); 3431 VMThread::execute(&op); 3432 } 3433 convert_flat_object_entries(); 3434 3435 // Post events outside of Heap_lock 3436 post_dead_objects(&dead_objects); 3437 } 3438 3439 // follow references from an initial object or the GC roots 3440 void JvmtiTagMap::follow_references(jint heap_filter, 3441 Klass* klass, 3442 jobject object, 3443 const jvmtiHeapCallbacks* callbacks, 3444 const void* user_data) 3445 { 3446 // VTMS transitions must be disabled before the EscapeBarrier. 3447 JvmtiVTMSTransitionDisabler disabler; 3448 3449 oop obj = JNIHandles::resolve(object); 3450 JavaThread* jt = JavaThread::current(); 3451 Handle initial_object(jt, obj); 3452 // EA based optimizations that are tagged or reachable from initial_object are already reverted. 3453 EscapeBarrier eb(initial_object.is_null() && 3454 !(heap_filter & JVMTI_HEAP_FILTER_UNTAGGED), 3455 jt); 3456 eb.deoptimize_objects_all_threads(); 3457 3458 Arena dead_object_arena(mtServiceability); 3459 GrowableArray<jlong> dead_objects(&dead_object_arena, 10, 0, 0); 3460 3461 { 3462 MutexLocker ml(Heap_lock); 3463 AdvancedHeapWalkContext context(heap_filter, klass, callbacks); 3464 VM_HeapWalkOperation op(this, initial_object, context, user_data, &dead_objects); 3465 VMThread::execute(&op); 3466 } 3467 convert_flat_object_entries(); 3468 3469 // Post events outside of Heap_lock 3470 post_dead_objects(&dead_objects); 3471 } 3472 3473 // Verify gc_notification follows set_needs_cleaning. 3474 DEBUG_ONLY(static bool notified_needs_cleaning = false;) 3475 3476 void JvmtiTagMap::set_needs_cleaning() { 3477 assert(SafepointSynchronize::is_at_safepoint(), "called in gc pause"); 3478 assert(Thread::current()->is_VM_thread(), "should be the VM thread"); 3479 // Can't assert !notified_needs_cleaning; a partial GC might be upgraded 3480 // to a full GC and do this twice without intervening gc_notification. 3481 DEBUG_ONLY(notified_needs_cleaning = true;) 3482 3483 JvmtiEnvIterator it; 3484 for (JvmtiEnv* env = it.first(); env != nullptr; env = it.next(env)) { 3485 JvmtiTagMap* tag_map = env->tag_map_acquire(); 3486 if (tag_map != nullptr) { 3487 tag_map->_needs_cleaning = !tag_map->is_empty(); 3488 } 3489 } 3490 } 3491 3492 void JvmtiTagMap::gc_notification(size_t num_dead_entries) { 3493 assert(notified_needs_cleaning, "missing GC notification"); 3494 DEBUG_ONLY(notified_needs_cleaning = false;) 3495 3496 // Notify ServiceThread if there's work to do. 3497 { 3498 MonitorLocker ml(Service_lock, Mutex::_no_safepoint_check_flag); 3499 _has_object_free_events = (num_dead_entries != 0); 3500 if (_has_object_free_events) ml.notify_all(); 3501 } 3502 3503 // If no dead entries then cancel cleaning requests. 3504 if (num_dead_entries == 0) { 3505 JvmtiEnvIterator it; 3506 for (JvmtiEnv* env = it.first(); env != nullptr; env = it.next(env)) { 3507 JvmtiTagMap* tag_map = env->tag_map_acquire(); 3508 if (tag_map != nullptr) { 3509 MutexLocker ml (tag_map->lock(), Mutex::_no_safepoint_check_flag); 3510 tag_map->_needs_cleaning = false; 3511 } 3512 } 3513 } 3514 } 3515 3516 // Used by ServiceThread to discover there is work to do. 3517 bool JvmtiTagMap::has_object_free_events_and_reset() { 3518 assert_lock_strong(Service_lock); 3519 bool result = _has_object_free_events; 3520 _has_object_free_events = false; 3521 return result; 3522 } 3523 3524 // Used by ServiceThread to clean up tagmaps. 3525 void JvmtiTagMap::flush_all_object_free_events() { 3526 JavaThread* thread = JavaThread::current(); 3527 JvmtiEnvIterator it; 3528 for (JvmtiEnv* env = it.first(); env != nullptr; env = it.next(env)) { 3529 JvmtiTagMap* tag_map = env->tag_map_acquire(); 3530 if (tag_map != nullptr) { 3531 tag_map->flush_object_free_events(); 3532 ThreadBlockInVM tbiv(thread); // Be safepoint-polite while looping. 3533 } 3534 } 3535 }