/*

 * Copyright 1997-2008 Sun Microsystems, Inc.  All Rights Reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 *

 */

# include "incls/_precompiled.incl"

# include "incls/_thread.cpp.incl"

#ifdef DTRACE_ENABLED

// Only bother with this argument setup if dtrace is available

HS_DTRACE_PROBE_DECL(hotspot, vm__init__begin);

HS_DTRACE_PROBE_DECL(hotspot, vm__init__end);

HS_DTRACE_PROBE_DECL5(hotspot, thread__start, char*, intptr_t,

  intptr_t, intptr_t, bool);

HS_DTRACE_PROBE_DECL5(hotspot, thread__stop, char*, intptr_t,

  intptr_t, intptr_t, bool);

#define DTRACE_THREAD_PROBE(probe, javathread)                             \

  {                                                                        \

    ResourceMark rm(this);                                                 \

    int len = 0;                                                           \

    const char* name = (javathread)->get_thread_name();                    \

    len = strlen(name);                                                    \

    HS_DTRACE_PROBE5(hotspot, thread__##probe,                             \

      name, len,                                                           \

      java_lang_Thread::thread_id((javathread)->threadObj()),              \

      (javathread)->osthread()->thread_id(),                               \

      java_lang_Thread::is_daemon((javathread)->threadObj()));             \

  }

#else //  ndef DTRACE_ENABLED

#define DTRACE_THREAD_PROBE(probe, javathread)

#endif // ndef DTRACE_ENABLED

// Class hierarchy

// - Thread

//   - VMThread

//   - WatcherThread

//   - ConcurrentMarkSweepThread

//   - JavaThread

//     - CompilerThread

// ======= Thread ========

// Support for forcing alignment of thread objects for biased locking

void* Thread::operator new(size_t size) {

  if (UseBiasedLocking) {

    const int alignment = markOopDesc::biased_lock_alignment;

    size_t aligned_size = size + (alignment - sizeof(intptr_t));

    void* real_malloc_addr = CHeapObj::operator new(aligned_size);

    void* aligned_addr     = (void*) align_size_up((intptr_t) real_malloc_addr, alignment);

    assert(((uintptr_t) aligned_addr + (uintptr_t) size) <=

           ((uintptr_t) real_malloc_addr + (uintptr_t) aligned_size),

           "JavaThread alignment code overflowed allocated storage");

    if (TraceBiasedLocking) {

      if (aligned_addr != real_malloc_addr)

        tty->print_cr("Aligned thread " INTPTR_FORMAT " to " INTPTR_FORMAT,

                      real_malloc_addr, aligned_addr);

    }

    ((Thread*) aligned_addr)->_real_malloc_address = real_malloc_addr;

    return aligned_addr;

  } else {

    return CHeapObj::operator new(size);

  }

}

void Thread::operator delete(void* p) {

  if (UseBiasedLocking) {

    void* real_malloc_addr = ((Thread*) p)->_real_malloc_address;

    CHeapObj::operator delete(real_malloc_addr);

  } else {

    CHeapObj::operator delete(p);

  }

}

// Base class for all threads: VMThread, WatcherThread, ConcurrentMarkSweepThread,

// JavaThread

Thread::Thread() {

  // stack

  _stack_base   = NULL;

  _stack_size   = 0;

  _self_raw_id  = 0;

  _lgrp_id      = -1;

  _osthread     = NULL;

  // allocated data structures

  set_resource_area(new ResourceArea());

  set_handle_area(new HandleArea(NULL));

  set_active_handles(NULL);

  set_free_handle_block(NULL);

  set_last_handle_mark(NULL);

  set_osthread(NULL);

  // This initial value ==> never claimed.

  _oops_do_parity = 0;

  // the handle mark links itself to last_handle_mark

  new HandleMark(this);

  // plain initialization

  debug_only(_owned_locks = NULL;)

  debug_only(_allow_allocation_count = 0;)

  NOT_PRODUCT(_allow_safepoint_count = 0;)

  CHECK_UNHANDLED_OOPS_ONLY(_gc_locked_out_count = 0;)

  _highest_lock = NULL;

  _jvmti_env_iteration_count = 0;

  _vm_operation_started_count = 0;

  _vm_operation_completed_count = 0;

  _current_pending_monitor = NULL;

  _current_pending_monitor_is_from_java = true;

  _current_waiting_monitor = NULL;

  _num_nested_signal = 0;

  omFreeList = NULL ;

  omFreeCount = 0 ;

  omFreeProvision = 32 ;

  _SR_lock = new Monitor(Mutex::suspend_resume, "SR_lock", true);

  _suspend_flags = 0;

  // thread-specific hashCode stream generator state - Marsaglia shift-xor form

  _hashStateX = os::random() ;

  _hashStateY = 842502087 ;

  _hashStateZ = 0x8767 ;    // (int)(3579807591LL & 0xffff) ;

  _hashStateW = 273326509 ;

  _OnTrap   = 0 ;

  _schedctl = NULL ;

  _Stalled  = 0 ;

  _TypeTag  = 0x2BAD ;

  // Many of the following fields are effectively final - immutable

  // Note that nascent threads can't use the Native Monitor-Mutex

  // construct until the _MutexEvent is initialized ...

  // CONSIDER: instead of using a fixed set of purpose-dedicated ParkEvents

  // we might instead use a stack of ParkEvents that we could provision on-demand.

  // The stack would act as a cache to avoid calls to ParkEvent::Allocate()

  // and ::Release()

  _ParkEvent   = ParkEvent::Allocate (this) ;

  _SleepEvent  = ParkEvent::Allocate (this) ;

  _MutexEvent  = ParkEvent::Allocate (this) ;

  _MuxEvent    = ParkEvent::Allocate (this) ;

#ifdef CHECK_UNHANDLED_OOPS

  if (CheckUnhandledOops) {

    _unhandled_oops = new UnhandledOops(this);

  }

#endif // CHECK_UNHANDLED_OOPS

#ifdef ASSERT

  if (UseBiasedLocking) {

    assert((((uintptr_t) this) & (markOopDesc::biased_lock_alignment - 1)) == 0, "forced alignment of thread object failed");

    assert(this == _real_malloc_address ||

           this == (void*) align_size_up((intptr_t) _real_malloc_address, markOopDesc::biased_lock_alignment),

           "bug in forced alignment of thread objects");

  }

#endif /* ASSERT */

}

void Thread::initialize_thread_local_storage() {

  // Note: Make sure this method only calls

  // non-blocking operations. Otherwise, it might not work

  // with the thread-startup/safepoint interaction.

  // During Java thread startup, safepoint code should allow this

  // method to complete because it may need to allocate memory to

  // store information for the new thread.

  // initialize structure dependent on thread local storage

  ThreadLocalStorage::set_thread(this);

  // set up any platform-specific state.

  os::initialize_thread();

}

void Thread::record_stack_base_and_size() {

  set_stack_base(os::current_stack_base());

  set_stack_size(os::current_stack_size());

}

Thread::~Thread() {

  // Reclaim the objectmonitors from the omFreeList of the moribund thread.

  ObjectSynchronizer::omFlush (this) ;

  // deallocate data structures

  delete resource_area();

  // since the handle marks are using the handle area, we have to deallocated the root

  // handle mark before deallocating the thread's handle area,

  assert(last_handle_mark() != NULL, "check we have an element");

  delete last_handle_mark();

  assert(last_handle_mark() == NULL, "check we have reached the end");

  // It's possible we can encounter a null _ParkEvent, etc., in stillborn threads.

  // We NULL out the fields for good hygiene.

  ParkEvent::Release (_ParkEvent)   ; _ParkEvent   = NULL ;

  ParkEvent::Release (_SleepEvent)  ; _SleepEvent  = NULL ;

  ParkEvent::Release (_MutexEvent)  ; _MutexEvent  = NULL ;

  ParkEvent::Release (_MuxEvent)    ; _MuxEvent    = NULL ;

  delete handle_area();

  // osthread() can be NULL, if creation of thread failed.

  if (osthread() != NULL) os::free_thread(osthread());

  delete _SR_lock;

  // clear thread local storage if the Thread is deleting itself

  if (this == Thread::current()) {

    ThreadLocalStorage::set_thread(NULL);

  } else {

    // In the case where we're not the current thread, invalidate all the

    // caches in case some code tries to get the current thread or the

    // thread that was destroyed, and gets stale information.

    ThreadLocalStorage::invalidate_all();

  }

  CHECK_UNHANDLED_OOPS_ONLY(if (CheckUnhandledOops) delete unhandled_oops();)

}

// NOTE: dummy function for assertion purpose.

void Thread::run() {

  ShouldNotReachHere();

}

#ifdef ASSERT

// Private method to check for dangling thread pointer

void check_for_dangling_thread_pointer(Thread *thread) {

 assert(!thread->is_Java_thread() || Thread::current() == thread || Threads_lock->owned_by_self(),

         "possibility of dangling Thread pointer");

}

#endif

#ifndef PRODUCT

// Tracing method for basic thread operations

void Thread::trace(const char* msg, const Thread* const thread) {

  if (!TraceThreadEvents) return;

  ResourceMark rm;

  ThreadCritical tc;

  const char *name = "non-Java thread";

  int prio = -1;

  if (thread->is_Java_thread()

      && !thread->is_Compiler_thread()) {

    // The Threads_lock must be held to get information about

    // this thread but may not be in some situations when

    // tracing  thread events.

    bool release_Threads_lock = false;

    if (!Threads_lock->owned_by_self()) {

      Threads_lock->lock();

      release_Threads_lock = true;

    }

    JavaThread* jt = (JavaThread *)thread;

    name = (char *)jt->get_thread_name();

    oop thread_oop = jt->threadObj();

    if (thread_oop != NULL) {

      prio = java_lang_Thread::priority(thread_oop);

    }

    if (release_Threads_lock) {

      Threads_lock->unlock();

    }

  }

  tty->print_cr("Thread::%s " INTPTR_FORMAT " [%lx] %s (prio: %d)", msg, thread, thread->osthread()->thread_id(), name, prio);

}

#endif

ThreadPriority Thread::get_priority(const Thread* const thread) {

  trace("get priority", thread);

  ThreadPriority priority;

  // Can return an error!

  (void)os::get_priority(thread, priority);

  assert(MinPriority <= priority && priority <= MaxPriority, "non-Java priority found");

  return priority;

}

void Thread::set_priority(Thread* thread, ThreadPriority priority) {

  trace("set priority", thread);

  debug_only(check_for_dangling_thread_pointer(thread);)

  // Can return an error!

  (void)os::set_priority(thread, priority);

}

void Thread::start(Thread* thread) {

  trace("start", thread);

  // Start is different from resume in that its safety is guaranteed by context or

  // being called from a Java method synchronized on the Thread object.

  if (!DisableStartThread) {

    if (thread->is_Java_thread()) {

      // Initialize the thread state to RUNNABLE before starting this thread.

      // Can not set it after the thread started because we do not know the

      // exact thread state at that time. It could be in MONITOR_WAIT or

      // in SLEEPING or some other state.

      java_lang_Thread::set_thread_status(((JavaThread*)thread)->threadObj(),

                                          java_lang_Thread::RUNNABLE);

    }

    os::start_thread(thread);

  }

}

// Enqueue a VM_Operation to do the job for us - sometime later

void Thread::send_async_exception(oop java_thread, oop java_throwable) {

  VM_ThreadStop* vm_stop = new VM_ThreadStop(java_thread, java_throwable);

  VMThread::execute(vm_stop);

}

//

// Check if an external suspend request has completed (or has been

// cancelled). Returns true if the thread is externally suspended and

// false otherwise.

//

// The bits parameter returns information about the code path through

// the routine. Useful for debugging:

//

// set in is_ext_suspend_completed():

// 0x00000001 - routine was entered

// 0x00000010 - routine return false at end

// 0x00000100 - thread exited (return false)

// 0x00000200 - suspend request cancelled (return false)

// 0x00000400 - thread suspended (return true)

// 0x00001000 - thread is in a suspend equivalent state (return true)

// 0x00002000 - thread is native and walkable (return true)

// 0x00004000 - thread is native_trans and walkable (needed retry)

//

// set in wait_for_ext_suspend_completion():

// 0x00010000 - routine was entered

// 0x00020000 - suspend request cancelled before loop (return false)

// 0x00040000 - thread suspended before loop (return true)

// 0x00080000 - suspend request cancelled in loop (return false)

// 0x00100000 - thread suspended in loop (return true)

// 0x00200000 - suspend not completed during retry loop (return false)

//

// Helper class for tracing suspend wait debug bits.

//

// 0x00000100 indicates that the target thread exited before it could

// self-suspend which is not a wait failure. 0x00000200, 0x00020000 and

// 0x00080000 each indicate a cancelled suspend request so they don't

// count as wait failures either.

#define DEBUG_FALSE_BITS (0x00000010 | 0x00200000)

class TraceSuspendDebugBits : public StackObj {

 private:

  JavaThread * jt;

  bool         is_wait;

  bool         called_by_wait;  // meaningful when !is_wait

  uint32_t *   bits;

 public:

  TraceSuspendDebugBits(JavaThread *_jt, bool _is_wait, bool _called_by_wait,

                        uint32_t *_bits) {

    jt             = _jt;

    is_wait        = _is_wait;

    called_by_wait = _called_by_wait;

    bits           = _bits;

  }

  ~TraceSuspendDebugBits() {

    if (!is_wait) {

#if 1

      // By default, don't trace bits for is_ext_suspend_completed() calls.

      // That trace is very chatty.

      return;

#else

      if (!called_by_wait) {

        // If tracing for is_ext_suspend_completed() is enabled, then only

        // trace calls to it from wait_for_ext_suspend_completion()

        return;

      }

#endif

    }

    if (AssertOnSuspendWaitFailure || TraceSuspendWaitFailures) {

      if (bits != NULL && (*bits & DEBUG_FALSE_BITS) != 0) {

        MutexLocker ml(Threads_lock);  // needed for get_thread_name()

        ResourceMark rm;

        tty->print_cr(

            "Failed wait_for_ext_suspend_completion(thread=%s, debug_bits=%x)",

            jt->get_thread_name(), *bits);

        guarantee(!AssertOnSuspendWaitFailure, "external suspend wait failed");

      }

    }

  }

};

#undef DEBUG_FALSE_BITS

bool JavaThread::is_ext_suspend_completed(bool called_by_wait, int delay, uint32_t *bits) {

  TraceSuspendDebugBits tsdb(this, false /* !is_wait */, called_by_wait, bits);

  bool did_trans_retry = false;  // only do thread_in_native_trans retry once

  bool do_trans_retry;           // flag to force the retry

  *bits |= 0x00000001;

  do {

    do_trans_retry = false;

    if (is_exiting()) {

      // Thread is in the process of exiting. This is always checked

      // first to reduce the risk of dereferencing a freed JavaThread.

      *bits |= 0x00000100;

      return false;

    }

    if (!is_external_suspend()) {

      // Suspend request is cancelled. This is always checked before

      // is_ext_suspended() to reduce the risk of a rogue resume

      // confusing the thread that made the suspend request.

      *bits |= 0x00000200;

      return false;

    }

    if (is_ext_suspended()) {

      // thread is suspended

      *bits |= 0x00000400;

      return true;

    }

    // Now that we no longer do hard suspends of threads running

    // native code, the target thread can be changing thread state

    // while we are in this routine:

    //

    //   _thread_in_native -> _thread_in_native_trans -> _thread_blocked

    //

    // We save a copy of the thread state as observed at this moment

    // and make our decision about suspend completeness based on the

    // copy. This closes the race where the thread state is seen as

    // _thread_in_native_trans in the if-thread_blocked check, but is

    // seen as _thread_blocked in if-thread_in_native_trans check.

    JavaThreadState save_state = thread_state();

    if (save_state == _thread_blocked && is_suspend_equivalent()) {

      // If the thread's state is _thread_blocked and this blocking

      // condition is known to be equivalent to a suspend, then we can

      // consider the thread to be externally suspended. This means that

      // the code that sets _thread_blocked has been modified to do

      // self-suspension if the blocking condition releases. We also

      // used to check for CONDVAR_WAIT here, but that is now covered by

      // the _thread_blocked with self-suspension check.

      //

      // Return true since we wouldn't be here unless there was still an

      // external suspend request.

      *bits |= 0x00001000;

      return true;

    } else if (save_state == _thread_in_native && frame_anchor()->walkable()) {

      // Threads running native code will self-suspend on native==>VM/Java

      // transitions. If its stack is walkable (should always be the case

      // unless this function is called before the actual java_suspend()

      // call), then the wait is done.

      *bits |= 0x00002000;

      return true;

    } else if (!called_by_wait && !did_trans_retry &&

               save_state == _thread_in_native_trans &&

               frame_anchor()->walkable()) {

      // The thread is transitioning from thread_in_native to another

      // thread state. check_safepoint_and_suspend_for_native_trans()

      // will force the thread to self-suspend. If it hasn't gotten

      // there yet we may have caught the thread in-between the native

      // code check above and the self-suspend. Lucky us. If we were

      // called by wait_for_ext_suspend_completion(), then it

      // will be doing the retries so we don't have to.

      //

      // Since we use the saved thread state in the if-statement above,

      // there is a chance that the thread has already transitioned to

      // _thread_blocked by the time we get here. In that case, we will

      // make a single unnecessary pass through the logic below. This

      // doesn't hurt anything since we still do the trans retry.

      *bits |= 0x00004000;

      // Once the thread leaves thread_in_native_trans for another

      // thread state, we break out of this retry loop. We shouldn't

      // need this flag to prevent us from getting back here, but

      // sometimes paranoia is good.

      did_trans_retry = true;

      // We wait for the thread to transition to a more usable state.

      for (int i = 1; i <= SuspendRetryCount; i++) {

        // We used to do an "os::yield_all(i)" call here with the intention

        // that yielding would increase on each retry. However, the parameter

        // is ignored on Linux which means the yield didn't scale up. Waiting

        // on the SR_lock below provides a much more predictable scale up for

        // the delay. It also provides a simple/direct point to check for any

        // safepoint requests from the VMThread

        // temporarily drops SR_lock while doing wait with safepoint check

        // (if we're a JavaThread - the WatcherThread can also call this)

        // and increase delay with each retry

        SR_lock()->wait(!Thread::current()->is_Java_thread(), i * delay);

        // check the actual thread state instead of what we saved above

        if (thread_state() != _thread_in_native_trans) {

          // the thread has transitioned to another thread state so

          // try all the checks (except this one) one more time.

          do_trans_retry = true;

          break;

        }

      } // end retry loop