# HG changeset patch
# User stuefe
# Date 1456157858 -3600
#      Mon Feb 22 17:17:38 2016 +0100
# Node ID 71ba4ec0bbfc7fd3589bd3f241185e20302b3e16
# Parent  1f58338cdec9946c16d2766d9801a9729858a997
8149036: Add tracing for thread related events at os level
Reviewed-by:

diff --git a/src/os/aix/vm/os_aix.cpp b/src/os/aix/vm/os_aix.cpp
--- a/src/os/aix/vm/os_aix.cpp
+++ b/src/os/aix/vm/os_aix.cpp
@@ -36,6 +36,7 @@
 #include "compiler/compileBroker.hpp"
 #include "interpreter/interpreter.hpp"
 #include "jvm_aix.h"
+#include "logging/log.hpp"
 #include "libo4.hpp"
 #include "libperfstat_aix.hpp"
 #include "libodm_aix.hpp"
@@ -791,13 +792,8 @@
   const pthread_t pthread_id = ::pthread_self();
   const tid_t kernel_thread_id = ::thread_self();
 
-  trcVerbose("newborn Thread : pthread-id %u, ktid " UINT64_FORMAT
-    ", stack %p ... %p, stacksize 0x%IX (%IB)",
-    pthread_id, kernel_thread_id,
-    thread->stack_end(),
-    thread->stack_base(),
-    thread->stack_size(),
-    thread->stack_size());
+  log_debug(os)("Thread is alive (pthread id " UINTX_FORMAT ", tid " UINTX_FORMAT ")",
+    (uintx) pthread_id, (uintx) kernel_thread_id);
 
   // Normally, pthread stacks on AIX live in the data segment (are allocated with malloc()
   // by the pthread library). In rare cases, this may not be the case, e.g. when third-party
@@ -805,7 +801,7 @@
   // guard pages on those stacks, because the stacks may reside in memory which is not
   // protectable (shmated).
   if (thread->stack_base() > ::sbrk(0)) {
-    trcVerbose("Thread " UINT64_FORMAT ": stack not in data segment.", (uint64_t) pthread_id);
+    log_warning(os)("Thread " UINTX_FORMAT ": stack not in data segment.", (uintx)pthread_id);
   }
 
   // Try to randomize the cache line index of hot stack frames.
@@ -839,8 +835,8 @@
   // Call one more level start routine.
   thread->run();
 
-  trcVerbose("Thread finished : pthread-id %u, ktid " UINT64_FORMAT ".",
-    pthread_id, kernel_thread_id);
+  log_debug(os)("Thread finished (pthread id " UINTX_FORMAT ", tid " UINTX_FORMAT ").",
+    (uintx) pthread_id, (uintx) kernel_thread_id);
 
   return 0;
 }
@@ -908,20 +904,21 @@
   pthread_t tid;
   int ret = pthread_create(&tid, &attr, (void* (*)(void*)) java_start, thread);
 
+  LogHandle(os) log;
+  if (log.is_debug()) {
+    char buf[64];
+    if (ret == 0) {
+      log.debug("Thread started (pthread id: " UINTX_FORMAT ", attributes: %s). ",
+        (uintx) tid, os::Posix::describe_pthread_attr(buf, sizeof(buf), &attr));
+    } else {
+      log.warning("Failed to start thread - pthread_create failed (%s) for attributes: %s.",
+        os::errno_name(errno), os::Posix::describe_pthread_attr(buf, sizeof(buf), &attr));
+    }
+  }
+
   pthread_attr_destroy(&attr);
 
-  if (ret == 0) {
-    trcVerbose("Created New Thread : pthread-id %u", tid);
-  } else {
-    if (os::Aix::on_pase()) {
-      // QIBM_MULTI_THREADED=Y is needed when the launcher is started on iSeries
-      // using QSH. Otherwise pthread_create fails with errno=11.
-      trcVerbose("(Please make sure you set the environment variable "
-              "QIBM_MULTI_THREADED=Y before running this program.)");
-    }
-    if (PrintMiscellaneous && (Verbose || WizardMode)) {
-      perror("pthread_create()");
-    }
+  if (ret != 0) {
     // Need to clean up stuff we've allocated so far
     thread->set_osthread(NULL);
     delete osthread;
@@ -958,13 +955,6 @@
   const pthread_t pthread_id = ::pthread_self();
   const tid_t kernel_thread_id = ::thread_self();
 
-  trcVerbose("attaching Thread : pthread-id %u, ktid " UINT64_FORMAT ", stack %p ... %p, stacksize 0x%IX (%IB)",
-    pthread_id, kernel_thread_id,
-    thread->stack_end(),
-    thread->stack_base(),
-    thread->stack_size(),
-    thread->stack_size());
-
   // OSThread::thread_id is the pthread id.
   osthread->set_thread_id(pthread_id);
 
@@ -990,6 +980,9 @@
   // and save the caller's signal mask
   os::Aix::hotspot_sigmask(thread);
 
+  log_debug(os)("Thread attached (pthread id " UINTX_FORMAT ", tid " UINTX_FORMAT ")",
+    (uintx) pthread_id, (uintx) kernel_thread_id);
+
   return true;
 }
 
diff --git a/src/os/bsd/vm/os_bsd.cpp b/src/os/bsd/vm/os_bsd.cpp
--- a/src/os/bsd/vm/os_bsd.cpp
+++ b/src/os/bsd/vm/os_bsd.cpp
@@ -32,6 +32,7 @@
 #include "compiler/disassembler.hpp"
 #include "interpreter/interpreter.hpp"
 #include "jvm_bsd.h"
+#include "logging/log.hpp"
 #include "memory/allocation.inline.hpp"
 #include "memory/filemap.hpp"
 #include "mutex_bsd.inline.hpp"
@@ -681,6 +682,9 @@
 
   osthread->set_thread_id(os::Bsd::gettid());
 
+  log_debug(os)("Thread is alive (tid: " UINTX_FORMAT ", pthread id: " UINTX_FORMAT ".",
+    os::current_thread_id(), (uintx) pthread_self());
+
 #ifdef __APPLE__
   uint64_t unique_thread_id = locate_unique_thread_id(osthread->thread_id());
   guarantee(unique_thread_id != 0, "unique thread id was not found");
@@ -716,6 +720,9 @@
   // call one more level start routine
   thread->run();
 
+  log_debug(os)("Thread finished (tid " UINTX_FORMAT ", pthread id " UINTX_FORMAT ").",
+    os::current_thread_id(), (uintx) pthread_self());
+
   return 0;
 }
 
@@ -776,12 +783,21 @@
     pthread_t tid;
     int ret = pthread_create(&tid, &attr, (void* (*)(void*)) java_start, thread);
 
+    LogHandle(os) log;
+    if (log.is_debug()) {
+      char buf[64];
+      if (ret == 0) {
+        log.debug("Thread started (pthread id: " UINTX_FORMAT ", attributes: %s). ",
+          (uintx) tid, os::Posix::describe_pthread_attr(buf, sizeof(buf), &attr));
+      } else {
+        log.warning("Failed to start thread - pthread_create failed (%s) for attributes: %s.",
+          os::errno_name(errno), os::Posix::describe_pthread_attr(buf, sizeof(buf), &attr));
+      }
+    }
+
     pthread_attr_destroy(&attr);
 
     if (ret != 0) {
-      if (PrintMiscellaneous && (Verbose || WizardMode)) {
-        perror("pthread_create()");
-      }
       // Need to clean up stuff we've allocated so far
       thread->set_osthread(NULL);
       delete osthread;
@@ -858,6 +874,9 @@
   // and save the caller's signal mask
   os::Bsd::hotspot_sigmask(thread);
 
+  log_debug(os)("Thread attached (tid: " UINTX_FORMAT ", pthread id: " UINTX_FORMAT ".",
+    os::current_thread_id(), (uintx) pthread_self());
+
   return true;
 }
 
diff --git a/src/os/linux/vm/os_linux.cpp b/src/os/linux/vm/os_linux.cpp
--- a/src/os/linux/vm/os_linux.cpp
+++ b/src/os/linux/vm/os_linux.cpp
@@ -662,6 +662,9 @@
 
   osthread->set_thread_id(os::current_thread_id());
 
+  log_debug(os)("Thread is alive (tid: " UINTX_FORMAT ", pthread id: " UINTX_FORMAT ").",
+    os::current_thread_id(), (uintx) pthread_self());
+
   if (UseNUMA) {
     int lgrp_id = os::numa_get_group_id();
     if (lgrp_id != -1) {
@@ -691,6 +694,9 @@
   // call one more level start routine
   thread->run();
 
+  log_debug(os)("Thread finished (tid " UINTX_FORMAT ", pthread id " UINTX_FORMAT ").",
+    os::current_thread_id(), (uintx) pthread_self());
+
   return 0;
 }
 
@@ -756,12 +762,21 @@
     pthread_t tid;
     int ret = pthread_create(&tid, &attr, (void* (*)(void*)) java_start, thread);
 
+    LogHandle(os) log;
+    if (log.is_debug()) {
+      char buf[64];
+      if (ret == 0) {
+        log.debug("Thread started (pthread id: " UINTX_FORMAT ", attributes: %s). ",
+          (uintx) tid, os::Posix::describe_pthread_attr(buf, sizeof(buf), &attr));
+      } else {
+        log.warning("Failed to start thread - pthread_create failed (%s) for attributes: %s.",
+          os::errno_name(errno), os::Posix::describe_pthread_attr(buf, sizeof(buf), &attr));
+      }
+    }
+
     pthread_attr_destroy(&attr);
 
     if (ret != 0) {
-      if (PrintMiscellaneous && (Verbose || WizardMode)) {
-        perror("pthread_create()");
-      }
       // Need to clean up stuff we've allocated so far
       thread->set_osthread(NULL);
       delete osthread;
@@ -858,6 +873,9 @@
   // and save the caller's signal mask
   os::Linux::hotspot_sigmask(thread);
 
+  log_debug(os)("Thread attached (tid: " UINTX_FORMAT ", pthread id: " UINTX_FORMAT ").",
+    os::current_thread_id(), (uintx) pthread_self());
+
   return true;
 }
 
diff --git a/src/os/posix/vm/os_posix.cpp b/src/os/posix/vm/os_posix.cpp
--- a/src/os/posix/vm/os_posix.cpp
+++ b/src/os/posix/vm/os_posix.cpp
@@ -1071,6 +1071,19 @@
 #endif
 }
 
+char* os::Posix::describe_pthread_attr(char* buf, size_t buflen, const pthread_attr_t* attr) {
+  size_t stack_size = 0;
+  size_t guard_size = 0;
+  int detachstate = 0;
+  pthread_attr_getstacksize(attr, &stack_size);
+  pthread_attr_getguardsize(attr, &guard_size);
+  pthread_attr_getdetachstate(attr, &detachstate);
+  jio_snprintf(buf, buflen, "stacksize: " SIZE_FORMAT "k, guardsize: " SIZE_FORMAT "k, %s",
+    stack_size / 1024, guard_size / 1024,
+    (detachstate == PTHREAD_CREATE_DETACHED ? "detached" : "joinable"));
+  return buf;
+}
+
 
 os::WatcherThreadCrashProtection::WatcherThreadCrashProtection() {
   assert(Thread::current()->is_Watcher_thread(), "Must be WatcherThread");
diff --git a/src/os/posix/vm/os_posix.hpp b/src/os/posix/vm/os_posix.hpp
--- a/src/os/posix/vm/os_posix.hpp
+++ b/src/os/posix/vm/os_posix.hpp
@@ -76,6 +76,11 @@
   static address ucontext_get_pc(const ucontext_t* ctx);
   // Set PC into context. Needed for continuation after signal.
   static void ucontext_set_pc(ucontext_t* ctx, address pc);
+
+  // Helper function; describes pthread attributes as short string. String is written
+  // to buf with len buflen; buf is returned.
+  static char* describe_pthread_attr(char* buf, size_t buflen, const pthread_attr_t* attr);
+
 };
 
 /*
diff --git a/src/os/solaris/vm/os_solaris.cpp b/src/os/solaris/vm/os_solaris.cpp
--- a/src/os/solaris/vm/os_solaris.cpp
+++ b/src/os/solaris/vm/os_solaris.cpp
@@ -32,6 +32,7 @@
 #include "compiler/disassembler.hpp"
 #include "interpreter/interpreter.hpp"
 #include "jvm_solaris.h"
+#include "logging/log.hpp"
 #include "memory/allocation.inline.hpp"
 #include "memory/filemap.hpp"
 #include "mutex_solaris.inline.hpp"
@@ -736,6 +737,9 @@
   osthr->set_lwp_id(_lwp_self());  // Store lwp in case we are bound
   thread->_schedctl = (void *) schedctl_init();
 
+  log_debug(os)("Thread is alive (tid: " UINTX_FORMAT ").",
+    os::current_thread_id());
+
   if (UseNUMA) {
     int lgrp_id = os::numa_get_group_id();
     if (lgrp_id != -1) {
@@ -781,6 +785,8 @@
     Atomic::dec(&os::Solaris::_os_thread_count);
   }
 
+  log_debug(os)("Thread finished (tid: " UINTX_FORMAT ").", os::current_thread_id());
+
   if (UseDetachedThreads) {
     thr_exit(NULL);
     ShouldNotReachHere();
@@ -853,6 +859,9 @@
   // and save the caller's signal mask
   os::Solaris::hotspot_sigmask(thread);
 
+  log_debug(os)("Thread attached (tid: " UINTX_FORMAT ").",
+    os::current_thread_id());
+
   return true;
 }
 
@@ -975,13 +984,14 @@
 
   status = thr_create(NULL, stack_size, java_start, thread, flags, &tid);
   if (status != 0) {
-    if (PrintMiscellaneous && (Verbose || WizardMode)) {
-      perror("os::create_thread");
-    }
+    log_warning(os)("Failed to start thread - thr_create failed (%s)",
+      os::errno_name(status));
     thread->set_osthread(NULL);
     // Need to clean up stuff we've allocated so far
     delete osthread;
     return false;
+  } else {
+    log_debug(os)("Thread started (tid: " UINTX_FORMAT ").", (uintx) tid);
   }
 
   Atomic::inc(&os::Solaris::_os_thread_count);
diff --git a/src/os/windows/vm/os_windows.cpp b/src/os/windows/vm/os_windows.cpp
--- a/src/os/windows/vm/os_windows.cpp
+++ b/src/os/windows/vm/os_windows.cpp
@@ -35,6 +35,7 @@
 #include "compiler/disassembler.hpp"
 #include "interpreter/interpreter.hpp"
 #include "jvm_windows.h"
+#include "logging/log.hpp"
 #include "memory/allocation.inline.hpp"
 #include "memory/filemap.hpp"
 #include "mutex_windows.inline.hpp"
@@ -436,6 +437,8 @@
     res = 20115;    // java thread
   }
 
+  log_debug(os)("Thread is alive (tid: " UINTX_FORMAT ").", os::current_thread_id());
+
   // Install a win32 structured exception handler around every thread created
   // by VM, so VM can generate error dump when an exception occurred in non-
   // Java thread (e.g. VM thread).
@@ -446,6 +449,8 @@
     // Nothing to do.
   }
 
+  log_debug(os)("Thread finished (tid: " UINTX_FORMAT ").", os::current_thread_id());
+
   // One less thread is executing
   // When the VMThread gets here, the main thread may have already exited
   // which frees the CodeHeap containing the Atomic::add code
@@ -509,6 +514,10 @@
   osthread->set_state(RUNNABLE);
 
   thread->set_osthread(osthread);
+
+  log_debug(os)("Thread attached (tid: " UINTX_FORMAT ").",
+    os::current_thread_id());
+
   return true;
 }
 
@@ -605,11 +614,16 @@
                            &thread_id);
 
   if (thread_handle == NULL) {
+    log_warning(os)("Failed to start thread - _beginthreadex failed (%s).",
+      os::errno_name(errno));
+
     // Need to clean up stuff we've allocated so far
     CloseHandle(osthread->interrupt_event());
     thread->set_osthread(NULL);
     delete osthread;
     return NULL;
+  } else {
+    log_debug(os)("Thread started (tid: %u)", thread_id);
   }
 
   Atomic::inc_ptr((intptr_t*)&os::win32::_os_thread_count);
diff --git a/src/share/vm/runtime/os.cpp b/src/share/vm/runtime/os.cpp
--- a/src/share/vm/runtime/os.cpp
+++ b/src/share/vm/runtime/os.cpp
@@ -60,6 +60,7 @@
 #include "utilities/defaultStream.hpp"
 #include "utilities/events.hpp"
 
+# include <errno.h>
 # include <signal.h>
 
 OSThread*         os::_starting_thread    = NULL;
@@ -1753,3 +1754,226 @@
 }
 
 #endif // PRODUCT
+
+
+const char* os::errno_name(int err_no) {
+  switch (err_no) {
+  case E2BIG: return "E2BIG";
+  case EACCES: return "EACCES";
+#ifdef EADDRINUSE
+  case EADDRINUSE: return "EADDRINUSE";
+#endif
+#ifdef EADDRNOTAVAIL
+  case EADDRNOTAVAIL: return "EADDRNOTAVAIL";
+#endif
+#ifdef EAFNOSUPPORT
+  case EAFNOSUPPORT: return "EAFNOSUPPORT";
+#endif
+  case EAGAIN: return "EAGAIN";
+#ifdef EALREADY
+  case EALREADY: return "EALREADY";
+#endif
+  case EBADF: return "EBADF";
+#ifdef EBADMSG
+  case EBADMSG: return "EBADMSG";
+#endif
+  case EBUSY: return "EBUSY";
+#ifdef ECANCELED
+  case ECANCELED: return "ECANCELED";
+#endif
+#ifdef ECHILD
+  case ECHILD: return "ECHILD";
+#endif
+#ifdef ECONNABORTED
+  case ECONNABORTED: return "ECONNABORTED";
+#endif
+#ifdef ECONNREFUSED
+  case ECONNREFUSED: return "ECONNREFUSED";
+#endif
+#ifdef ECONNRESET
+  case ECONNRESET: return "ECONNRESET";
+#endif
+#ifdef EDEADLK
+  case EDEADLK: return "EDEADLK";
+#endif
+#ifdef EDESTADDRREQ
+  case EDESTADDRREQ: return "EDESTADDRREQ";
+#endif
+#ifdef EDOM
+  case EDOM: return "EDOM";
+#endif
+#ifdef EDQUOT
+  case EDQUOT: return "EDQUOT";
+#endif
+#ifdef EEXIST
+  case EEXIST: return "EEXIST";
+#endif
+  case EFAULT: return "EFAULT";
+#ifdef EFBIG
+  case EFBIG: return "EFBIG";
+#endif
+#ifdef EHOSTUNREACH
+  case EHOSTUNREACH: return "EHOSTUNREACH";
+#endif
+#ifdef EIDRM
+  case EIDRM: return "EIDRM";
+#endif
+#ifdef EILSEQ
+  case EILSEQ: return "EILSEQ";
+#endif
+#ifdef EINPROGRESS
+  case EINPROGRESS: return "EINPROGRESS";
+#endif
+  case EINTR: return "EINTR";
+  case EINVAL: return "EINVAL";
+#ifdef EIO
+  case EIO: return "EIO";
+#endif
+#ifdef EISCONN
+  case EISCONN: return "EISCONN";
+#endif
+  case EISDIR: return "EISDIR";
+#ifdef ELOOP
+  case ELOOP: return "ELOOP";
+#endif
+#ifdef EMFILE
+  case EMFILE: return "EMFILE";
+#endif
+#ifdef EMLINK
+  case EMLINK: return "EMLINK";
+#endif
+#ifdef EMSGSIZE
+  case EMSGSIZE: return "EMSGSIZE";
+#endif
+#ifdef EMULTIHOP
+  case EMULTIHOP: return "EMULTIHOP";
+#endif
+  case ENAMETOOLONG: return "ENAMETOOLONG";
+#ifdef ENETDOWN
+  case ENETDOWN: return "ENETDOWN";
+#endif
+#ifdef ENETRESET
+  case ENETRESET: return "ENETRESET";
+#endif
+#ifdef ENETUNREACH
+  case ENETUNREACH: return "ENETUNREACH";
+#endif
+#ifdef ENFILE
+  case ENFILE: return "ENFILE";
+#endif
+#ifdef ENOBUFS
+  case ENOBUFS: return "ENOBUFS";
+#endif
+#ifdef ENODATA
+  case ENODATA: return "ENODATA";
+#endif
+#ifdef ENODEV
+  case ENODEV: return "ENODEV";
+#endif
+  case ENOENT: return "ENOENT";
+#ifdef ENOEXEC
+  case ENOEXEC: return "ENOEXEC";
+#endif
+#ifdef ENOLCK
+  case ENOLCK: return "ENOLCK";
+#endif
+#ifdef ENOLINK
+  case ENOLINK: return "ENOLINK";
+#endif
+  case ENOMEM: return "ENOMEM";
+#ifdef ENOMSG
+  case ENOMSG: return "ENOMSG";
+#endif
+#ifdef ENOPROTOOPT
+  case ENOPROTOOPT: return "ENOPROTOOPT";
+#endif
+#ifdef ENOSPC
+  case ENOSPC: return "ENOSPC";
+#endif
+#ifdef ENOSR
+  case ENOSR: return "ENOSR";
+#endif
+#ifdef ENOSTR
+  case ENOSTR: return "ENOSTR";
+#endif
+#ifdef ENOSYS
+  case ENOSYS: return "ENOSYS";
+#endif
+#ifdef ENOTCONN
+  case ENOTCONN: return "ENOTCONN";
+#endif
+#ifdef ENOTDIR
+  case ENOTDIR: return "ENOTDIR";
+#endif
+// AIX: ENOTEMPTY == EEXIST
+#if defined(ENOTEMPTY) && (ENOTEMPTY != EEXIST)
+  case ENOTEMPTY: return "ENOTEMPTY";
+#endif
+#ifdef ENOTSOCK
+  case ENOTSOCK: return "ENOTSOCK";
+#endif
+#ifdef ENOTSUP
+  case ENOTSUP: return "ENOTSUP";
+#endif
+#ifdef ENOTTY
+  case ENOTTY: return "ENOTTY";
+#endif
+#ifdef ENXIO
+  case ENXIO: return "ENXIO";
+#endif
+// on some unices EOPNOTSUPP==ENOTSUPP
+#if defined(ENOTSUP) && defined(EOPNOTSUPP) && (EOPNOTSUPP != ENOTSUP)
+  case EOPNOTSUPP: return "EOPNOTSUPP";
+#endif
+#ifdef EOVERFLOW
+  case EOVERFLOW: return "EOVERFLOW";
+#endif
+#ifdef EPERM
+  case EPERM: return "EPERM";
+#endif
+#ifdef EPIPE
+  case EPIPE: return "EPIPE";
+#endif
+#ifdef EPROTO
+  case EPROTO: return "EPROTO";
+#endif
+#ifdef EPROTONOSUPPORT
+  case EPROTONOSUPPORT: return "EPROTONOSUPPORT";
+#endif
+#ifdef EPROTOTYPE
+  case EPROTOTYPE: return "EPROTOTYPE";
+#endif
+  case ERANGE: return "ERANGE";
+#ifdef EROFS
+  case EROFS: return "EROFS";
+#endif
+#ifdef ESPIPE
+  case ESPIPE: return "ESPIPE";
+#endif
+#ifdef ESRCH
+  case ESRCH: return "ESRCH";
+#endif
+#ifdef ESTALE
+  case ESTALE: return "ESTALE";
+#endif
+#ifdef ETIME
+  case ETIME: return "ETIME";
+#endif
+#ifdef ETIMEDOUT
+  case ETIMEDOUT: return "ETIMEDOUT";
+#endif
+#ifdef ETXTBSY
+  case ETXTBSY: return "ETXTBSY";
+#endif
+// on some unices EWOULDBLOCK==EAGAIN
+#if defined(EWOULDBLOCK) && (EWOULDBLOCK != EAGAIN)
+  case EWOULDBLOCK: return "EWOULDBLOCK";
+#endif
+#ifdef EXDEV
+  case EXDEV: return "EXDEV";
+#endif
+  default: return "unknown";
+  }
+}
+
+
diff --git a/src/share/vm/runtime/os.hpp b/src/share/vm/runtime/os.hpp
--- a/src/share/vm/runtime/os.hpp
+++ b/src/share/vm/runtime/os.hpp
@@ -649,6 +649,11 @@
   // Returns the signal number (e.g. 11) for a given signal name (SIGSEGV).
   static int get_signal_number(const char* signal_name);
 
+  // Returns the name for a given errno (e.g. "EINVAL" for EINVAL). The returned string
+  // is a static constant and does not have to be freed, so in contrast to strerror, this
+  // function is threadsafe. For unknown errno values, "unknown" is returned.
+  static const char* errno_name(int err_no);
+
   // Returns native Java library, loads if necessary
   static void*    native_java_library();
 
diff --git a/src/share/vm/runtime/thread.cpp b/src/share/vm/runtime/thread.cpp
--- a/src/share/vm/runtime/thread.cpp
+++ b/src/share/vm/runtime/thread.cpp
@@ -324,6 +324,10 @@
   // record thread's native stack, stack grows downward
   MemTracker::record_thread_stack(stack_end(), stack_size());
 #endif // INCLUDE_NMT
+  log_debug(os)("Thread " UINTX_FORMAT " stack dimensions: "
+    PTR_FORMAT "-" PTR_FORMAT " (" SIZE_FORMAT "k).",
+    os::current_thread_id(), p2i(stack_base() - stack_size()),
+    p2i(stack_base()), stack_size()/1024);
 }
 
 
@@ -1802,6 +1806,10 @@
     // Call after last event on thread
     EVENT_THREAD_EXIT(this);
 
+    log_debug(os)("Thread " UINTX_FORMAT " %s.",
+      os::current_thread_id(),
+      exit_type == JavaThread::normal_exit ? "exiting" : "detaching");
+
     // Call Thread.exit(). We try 3 times in case we got another Thread.stop during
     // the execution of the method. If that is not enough, then we don't really care. Thread.stop
     // is deprecated anyhow.
@@ -2491,18 +2499,24 @@
   // warning("Guarding at " PTR_FORMAT " for len " SIZE_FORMAT "\n", low_addr, len);
 
   if (allocate && !os::create_stack_guard_pages((char *) low_addr, len)) {
-    warning("Attempt to allocate stack guard pages failed.");
+    log_warning(os)("Attempt to allocate stack guard pages failed.");
     return;
   }
 
   if (os::guard_memory((char *) low_addr, len)) {
     _stack_guard_state = stack_guard_enabled;
   } else {
-    warning("Attempt to protect stack guard pages failed.");
+    log_warning(os)("Attempt to protect stack guard pages failed ("
+      PTR_FORMAT "-" PTR_FORMAT ").", p2i(low_addr), p2i(low_addr + len));
     if (os::uncommit_memory((char *) low_addr, len)) {
-      warning("Attempt to deallocate stack guard pages failed.");
+      log_warning(os)("Attempt to deallocate stack guard pages failed.");
     }
   }
+
+  log_debug(os)("Thread " UINTX_FORMAT " stack guard pages activated: "
+    PTR_FORMAT "-" PTR_FORMAT ".",
+    os::current_thread_id(), p2i(low_addr), p2i(low_addr + len));
+
 }
 
 void JavaThread::remove_stack_guard_pages() {
@@ -2515,16 +2529,23 @@
     if (os::remove_stack_guard_pages((char *) low_addr, len)) {
       _stack_guard_state = stack_guard_unused;
     } else {
-      warning("Attempt to deallocate stack guard pages failed.");
+      log_warning(os)("Attempt to deallocate stack guard pages failed ("
+        PTR_FORMAT "-" PTR_FORMAT ").", p2i(low_addr), p2i(low_addr + len));
     }
   } else {
     if (_stack_guard_state == stack_guard_unused) return;
     if (os::unguard_memory((char *) low_addr, len)) {
       _stack_guard_state = stack_guard_unused;
     } else {
-      warning("Attempt to unprotect stack guard pages failed.");
+      log_warning(os)("Attempt to unprotect stack guard pages failed ("
+        PTR_FORMAT "-" PTR_FORMAT ").", p2i(low_addr), p2i(low_addr + len));
     }
   }
+
+  log_debug(os)("Thread " UINTX_FORMAT " stack guard pages removed: "
+    PTR_FORMAT "-" PTR_FORMAT ".",
+    os::current_thread_id(), p2i(low_addr), p2i(low_addr + len));
+
 }
 
 void JavaThread::enable_stack_reserved_zone() {