ART: Factor out stack dumping with monitor objects
Factor out generic stack walking with monitor object visitation into
MonitorObjectsStackVisitor. Rewrite StackDumpVisitor in terms of this,
removing Monitor::DescribeWait on the way.
Bug: 70538431
Test: m test-art-host
Test: manual (SIGQUIT dumping)
Change-Id: I6f359f9a5f665f308328ad466bc7a437f52aea24
diff --git a/runtime/monitor_objects_stack_visitor.h b/runtime/monitor_objects_stack_visitor.h
new file mode 100644
index 0000000..5c962c3
--- /dev/null
+++ b/runtime/monitor_objects_stack_visitor.h
@@ -0,0 +1,159 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ART_RUNTIME_MONITOR_OBJECTS_STACK_VISITOR_H_
+#define ART_RUNTIME_MONITOR_OBJECTS_STACK_VISITOR_H_
+
+#include <android-base/logging.h>
+
+#include "art_method.h"
+#include "base/mutex.h"
+#include "monitor.h"
+#include "stack.h"
+#include "thread.h"
+#include "thread_state.h"
+
+namespace art {
+
+namespace mirror {
+class Object;
+}
+
+class Context;
+
+class MonitorObjectsStackVisitor : public StackVisitor {
+ public:
+ MonitorObjectsStackVisitor(Thread* thread_in,
+ Context* context,
+ bool check_suspended = true,
+ bool dump_locks_in = true)
+ REQUIRES_SHARED(Locks::mutator_lock_)
+ : StackVisitor(thread_in,
+ context,
+ StackVisitor::StackWalkKind::kIncludeInlinedFrames,
+ check_suspended),
+ frame_count(0u),
+ dump_locks(dump_locks_in) {}
+
+ enum class VisitMethodResult {
+ kContinueMethod,
+ kSkipMethod,
+ kEndStackWalk,
+ };
+
+ bool VisitFrame() FINAL REQUIRES_SHARED(Locks::mutator_lock_) {
+ ArtMethod* m = GetMethod();
+ if (m->IsRuntimeMethod()) {
+ return true;
+ }
+
+ VisitMethodResult vmrEntry = StartMethod(m, frame_count);
+ switch (vmrEntry) {
+ case VisitMethodResult::kContinueMethod:
+ break;
+ case VisitMethodResult::kSkipMethod:
+ return true;
+ case VisitMethodResult::kEndStackWalk:
+ return false;
+ }
+
+ if (frame_count == 0) {
+ // Top frame, check for blocked state.
+
+ mirror::Object* monitor_object;
+ uint32_t lock_owner_tid;
+ ThreadState state = Monitor::FetchState(GetThread(),
+ &monitor_object,
+ &lock_owner_tid);
+ switch (state) {
+ case kWaiting:
+ case kTimedWaiting:
+ VisitWaitingObject(monitor_object, state);
+ break;
+ case kSleeping:
+ VisitSleepingObject(monitor_object);
+ break;
+
+ case kBlocked:
+ case kWaitingForLockInflation:
+ VisitBlockedOnObject(monitor_object, state, lock_owner_tid);
+ break;
+
+ default:
+ break;
+ }
+ }
+
+ if (dump_locks) {
+ // Visit locks, but do not abort on errors. This could trigger a nested abort.
+ // Skip visiting locks if dump_locks is false as it would cause a bad_mutexes_held in
+ // RegTypeCache::RegTypeCache due to thread_list_lock.
+ Monitor::VisitLocks(this, VisitLockedObject, this, false);
+ }
+
+ ++frame_count;
+
+ VisitMethodResult vmrExit = EndMethod(m);
+ switch (vmrExit) {
+ case VisitMethodResult::kContinueMethod:
+ case VisitMethodResult::kSkipMethod:
+ return true;
+
+ case VisitMethodResult::kEndStackWalk:
+ return false;
+ }
+ LOG(FATAL) << "Unreachable";
+ UNREACHABLE();
+ }
+
+ protected:
+ virtual VisitMethodResult StartMethod(ArtMethod* m, size_t frame_nr)
+ REQUIRES_SHARED(Locks::mutator_lock_) = 0;
+ virtual VisitMethodResult EndMethod(ArtMethod* m)
+ REQUIRES_SHARED(Locks::mutator_lock_) = 0;
+
+ virtual void VisitWaitingObject(mirror::Object* obj, ThreadState state)
+ REQUIRES_SHARED(Locks::mutator_lock_) = 0;
+ virtual void VisitSleepingObject(mirror::Object* obj)
+ REQUIRES_SHARED(Locks::mutator_lock_) = 0;
+ virtual void VisitBlockedOnObject(mirror::Object* obj, ThreadState state, uint32_t owner_tid)
+ REQUIRES_SHARED(Locks::mutator_lock_) = 0;
+ virtual void VisitLockedObject(mirror::Object* obj)
+ REQUIRES_SHARED(Locks::mutator_lock_) = 0;
+
+ size_t frame_count;
+
+ private:
+ static void VisitLockedObject(mirror::Object* o, void* context)
+ REQUIRES_SHARED(Locks::mutator_lock_) {
+ MonitorObjectsStackVisitor* self = reinterpret_cast<MonitorObjectsStackVisitor*>(context);
+ if (o != nullptr) {
+ if (kUseReadBarrier && Thread::Current()->GetIsGcMarking()) {
+ // We may call Thread::Dump() in the middle of the CC thread flip and this thread's stack
+ // may have not been flipped yet and "o" may be a from-space (stale) ref, in which case the
+ // IdentityHashCode call below will crash. So explicitly mark/forward it here.
+ o = ReadBarrier::Mark(o);
+ }
+ }
+ self->VisitLockedObject(o);
+ }
+
+ const bool dump_locks;
+};
+
+} // namespace art
+
+#endif // ART_RUNTIME_MONITOR_OBJECTS_STACK_VISITOR_H_