jdk-sandbox: comparison hotspot/src/share/vm/runtime/thread.cpp

equal deleted inserted replaced

-:76f4de26388d
+:996db89f378e
 // set up any platform-specific state.
 os::initialize_thread(this);
 #if INCLUDE_NMT
 // record thread's native stack, stack grows downward
-address stack_low_addr = stack_base() - stack_size();
+MemTracker::record_thread_stack(stack_end(), stack_size());
-MemTracker::record_thread_stack(stack_low_addr, stack_size());
 #endif // INCLUDE_NMT
 }
 Thread::~Thread() {
 // record_stack_base_and_size called. Although, we would like to ensure
 // that all started threads do call record_stack_base_and_size(), there is
 // not proper way to enforce that.
 #if INCLUDE_NMT
 if (_stack_base != NULL) {
-address low_stack_addr = stack_base() - stack_size();
+MemTracker::release_thread_stack(stack_end(), stack_size());
-MemTracker::release_thread_stack(low_stack_addr, stack_size());
 #ifdef ASSERT
 set_stack_base(NULL);
 #endif
 }
 #endif // INCLUDE_NMT
 else if (is_Watcher_thread())       st->print("WatcherThread");
 else if (is_ConcurrentGC_thread())  st->print("ConcurrentGCThread");
 else                                st->print("Thread");
 st->print(" [stack: " PTR_FORMAT "," PTR_FORMAT "]",
-p2i(_stack_base - _stack_size), p2i(_stack_base));
+p2i(stack_end()), p2i(stack_base()));
 if (osthread()) {
 st->print(" [id=%d]", osthread()->thread_id());
 }
 }
 if (stack_base() >= adr && adr >= end) return true;
 return false;
 }
 bool Thread::is_in_usable_stack(address adr) const {
-size_t stack_guard_size = os::uses_stack_guard_pages() ? (StackReservedPages + StackYellowPages + StackRedPages) * os::vm_page_size() : 0;
+size_t stack_guard_size = os::uses_stack_guard_pages() ? JavaThread::stack_guard_zone_size() : 0;
 size_t usable_stack_size = _stack_size - stack_guard_size;
 return ((adr < stack_base()) && (adr >= stack_base() - usable_stack_size));
 }
 }
 assert(deferred_card_mark().is_empty(), "Default MemRegion ctor");
 }
 bool JavaThread::reguard_stack(address cur_sp) {
-if (_stack_guard_state != stack_guard_yellow_disabled
+if (_stack_guard_state != stack_guard_yellow_reserved_disabled
 && _stack_guard_state != stack_guard_reserved_disabled) {
 return true; // Stack already guarded or guard pages not needed.
 }
 if (register_stack_overflow()) {
 // Java code never executes within the yellow zone: the latter is only
 // there to provoke an exception during stack banging.  If java code
 // is executing there, either StackShadowPages should be larger, or
 // some exception code in c1, c2 or the interpreter isn't unwinding
 // when it should.
-guarantee(cur_sp > stack_yellow_zone_base(), "not enough space to reguard - increase StackShadowPages");
+guarantee(cur_sp > stack_reserved_zone_base(),
-if (_stack_guard_state == stack_guard_yellow_disabled) {
+"not enough space to reguard - increase StackShadowPages");
-enable_stack_yellow_zone();
+if (_stack_guard_state == stack_guard_yellow_reserved_disabled) {
+enable_stack_yellow_reserved_zone();
 if (reserved_stack_activation() != stack_base()) {
 set_reserved_stack_activation(stack_base());
 }
 } else if (_stack_guard_state == stack_guard_reserved_disabled) {
 set_reserved_stack_activation(stack_base());
 clear_ext_suspended();
 SR_lock()->notify_all();
 }
 }
+size_t JavaThread::_stack_red_zone_size = 0;
+size_t JavaThread::_stack_yellow_zone_size = 0;
+size_t JavaThread::_stack_reserved_zone_size = 0;
+size_t JavaThread::_stack_shadow_zone_size = 0;
 void JavaThread::create_stack_guard_pages() {
-if (! os::uses_stack_guard_pages() || _stack_guard_state != stack_guard_unused) return;
+if (!os::uses_stack_guard_pages() || _stack_guard_state != stack_guard_unused) { return; }
-address low_addr = stack_base() - stack_size();
+address low_addr = stack_end();
-size_t len = (StackReservedPages + StackYellowPages + StackRedPages) * os::vm_page_size();
+size_t len = stack_guard_zone_size();
 int allocate = os::allocate_stack_guard_pages();
 // warning("Guarding at " PTR_FORMAT " for len " SIZE_FORMAT "\n", low_addr, len);
 if (allocate && !os::create_stack_guard_pages((char *) low_addr, len)) {
 }
 void JavaThread::remove_stack_guard_pages() {
 assert(Thread::current() == this, "from different thread");
 if (_stack_guard_state == stack_guard_unused) return;
-address low_addr = stack_base() - stack_size();
+address low_addr = stack_end();
-size_t len = (StackReservedPages + StackYellowPages + StackRedPages) * os::vm_page_size();
+size_t len = stack_guard_zone_size();
 if (os::allocate_stack_guard_pages()) {
 if (os::remove_stack_guard_pages((char *) low_addr, len)) {
 _stack_guard_state = stack_guard_unused;
 } else {
 warning("Attempt to unguard stack reserved zone failed.");
 }
 disable_register_stack_guard();
 }
-void JavaThread::enable_stack_yellow_zone() {
+void JavaThread::enable_stack_yellow_reserved_zone() {
 assert(_stack_guard_state != stack_guard_unused, "must be using guard pages.");
 assert(_stack_guard_state != stack_guard_enabled, "already enabled");
 // The base notation is from the stacks point of view, growing downward.
 // We need to adjust it to work correctly with guard_memory()
-address base = stack_yellow_zone_base() - stack_yellow_zone_size();
+address base = stack_red_zone_base();
 guarantee(base < stack_base(), "Error calculating stack yellow zone");
 guarantee(base < os::current_stack_pointer(), "Error calculating stack yellow zone");
-if (os::guard_memory((char *) base, stack_yellow_zone_size())) {
+if (os::guard_memory((char *) base, stack_yellow_reserved_zone_size())) {
 _stack_guard_state = stack_guard_enabled;
 } else {
 warning("Attempt to guard stack yellow zone failed.");
 }
 enable_register_stack_guard();
 }
-void JavaThread::disable_stack_yellow_zone() {
+void JavaThread::disable_stack_yellow_reserved_zone() {
 assert(_stack_guard_state != stack_guard_unused, "must be using guard pages.");
-assert(_stack_guard_state != stack_guard_yellow_disabled, "already disabled");
+assert(_stack_guard_state != stack_guard_yellow_reserved_disabled, "already disabled");
 // Simply return if called for a thread that does not use guard pages.
 if (_stack_guard_state == stack_guard_unused) return;
 // The base notation is from the stacks point of view, growing downward.
 // We need to adjust it to work correctly with guard_memory()
-address base = stack_yellow_zone_base() - stack_yellow_zone_size();
+address base = stack_red_zone_base();
-if (os::unguard_memory((char *)base, stack_yellow_zone_size())) {
+if (os::unguard_memory((char *)base, stack_yellow_reserved_zone_size())) {
-_stack_guard_state = stack_guard_yellow_disabled;
+_stack_guard_state = stack_guard_yellow_reserved_disabled;
 } else {
 warning("Attempt to unguard stack yellow zone failed.");
 }
 disable_register_stack_guard();
 }
 st->print("%s", _get_thread_state_name(_thread_state));
 if (osthread()) {
 st->print(", id=%d", osthread()->thread_id());
 }
 st->print(", stack(" PTR_FORMAT "," PTR_FORMAT ")",
-p2i(_stack_base - _stack_size), p2i(_stack_base));
+p2i(stack_end()), p2i(stack_base()));
 st->print("]");
 return;
 }
 // Verification

changeset 35201	996db89f378e
parent 35071	a0910b1d3e0d
child 35216	71c463a17b3b