Merge

src/os/bsd/vm/attachListener_bsd.cpp

@@ -342,7 +342,6 @@ BsdAttachOperation* BsdAttachListener::dequeue() {
 
     // get the credentials of the peer and check the effective uid/guid
     // - check with jeff on this.
-#ifdef _ALLBSD_SOURCE
     uid_t puid;
     gid_t pgid;
     if (::getpeereid(s, &puid, &pgid) != 0) {
@@ -350,17 +349,6 @@ BsdAttachOperation* BsdAttachListener::dequeue() {
       RESTARTABLE(::close(s), res);
       continue;
     }
-#else
-    struct ucred cred_info;
-    socklen_t optlen = sizeof(cred_info);
-    if (::getsockopt(s, SOL_SOCKET, SO_PEERCRED, (void*)&cred_info, &optlen) == -1) {
-      int res;
-      RESTARTABLE(::close(s), res);
-      continue;
-    }
-    uid_t puid = cred_info.uid;
-    gid_t pgid = cred_info.gid;
-#endif
     uid_t euid = geteuid();
     gid_t egid = getegid();
 

src/os/bsd/vm/osThread_bsd.hpp

@@ -39,18 +39,12 @@
 
  private:
 
-#ifdef _ALLBSD_SOURCE
-
 #ifdef __APPLE__
   typedef thread_t thread_id_t;
 #else
   typedef pthread_t thread_id_t;
 #endif
 
-#else
-  typedef pid_t thread_id_t;
-#endif
-
   // _pthread_id is the pthread id, which is used by library calls
   // (e.g. pthread_kill).
   pthread_t _pthread_id;

src/os/bsd/vm/os_bsd.hpp

@@ -56,19 +56,6 @@ class Bsd {
   static int sigflags[MAXSIGNUM];
 
   static int (*_clock_gettime)(clockid_t, struct timespec *);
-#ifndef _ALLBSD_SOURCE
-  static int (*_pthread_getcpuclockid)(pthread_t, clockid_t *);
-
-  static address   _initial_thread_stack_bottom;
-  static uintptr_t _initial_thread_stack_size;
-
-  static const char *_glibc_version;
-  static const char *_libpthread_version;
-
-  static bool _is_floating_stack;
-  static bool _is_NPTL;
-  static bool _supports_fast_thread_cpu_time;
-#endif
 
   static GrowableArray<int>* _cpu_to_node;
 
@@ -76,28 +63,14 @@ class Bsd {
 
   static julong _physical_memory;
   static pthread_t _main_thread;
-#ifndef _ALLBSD_SOURCE
-  static Mutex* _createThread_lock;
-#endif
   static int _page_size;
 
   static julong available_memory();
   static julong physical_memory() { return _physical_memory; }
   static void initialize_system_info();
 
-#ifndef _ALLBSD_SOURCE
-  static void set_glibc_version(const char *s)      { _glibc_version = s; }
-  static void set_libpthread_version(const char *s) { _libpthread_version = s; }
-#endif
-
   static bool supports_variable_stack_size();
 
-#ifndef _ALLBSD_SOURCE
-  static void set_is_NPTL()                   { _is_NPTL = true;  }
-  static void set_is_BsdThreads()           { _is_NPTL = false; }
-  static void set_is_floating_stack()         { _is_floating_stack = true; }
-#endif
-
   static void rebuild_cpu_to_node_map();
   static GrowableArray<int>* cpu_to_node()    { return _cpu_to_node; }
 
@@ -106,25 +79,10 @@ class Bsd {
  public:
 
   static void init_thread_fpu_state();
-#ifndef _ALLBSD_SOURCE
-  static int  get_fpu_control_word();
-  static void set_fpu_control_word(int fpu_control);
-#endif
   static pthread_t main_thread(void)                                { return _main_thread; }
 
-#ifndef _ALLBSD_SOURCE
-  // returns kernel thread id (similar to LWP id on Solaris), which can be
-  // used to access /proc
-  static pid_t gettid();
-  static void set_createThread_lock(Mutex* lk)                      { _createThread_lock = lk; }
-  static Mutex* createThread_lock(void)                             { return _createThread_lock; }
-#endif
   static void hotspot_sigmask(Thread* thread);
 
-#ifndef _ALLBSD_SOURCE
-  static address   initial_thread_stack_bottom(void)                { return _initial_thread_stack_bottom; }
-  static uintptr_t initial_thread_stack_size(void)                  { return _initial_thread_stack_size; }
-#endif
   static bool is_initial_thread(void);
 
   static int page_size(void)                                        { return _page_size; }
@@ -161,23 +119,6 @@ class Bsd {
   static struct sigaction *get_chained_signal_action(int sig);
   static bool chained_handler(int sig, siginfo_t* siginfo, void* context);
 
-#ifndef _ALLBSD_SOURCE
-  // GNU libc and libpthread version strings
-  static const char *glibc_version()          { return _glibc_version; }
-  static const char *libpthread_version()     { return _libpthread_version; }
-
-  // NPTL or BsdThreads?
-  static bool is_BsdThreads()               { return !_is_NPTL; }
-  static bool is_NPTL()                       { return _is_NPTL;  }
-
-  // NPTL is always floating stack. BsdThreads could be using floating
-  // stack or fixed stack.
-  static bool is_floating_stack()             { return _is_floating_stack; }
-
-  static void libpthread_init();
-  static bool libnuma_init();
-  static void* libnuma_dlsym(void* handle, const char* name);
-#endif
   // Minimum stack size a thread can be created with (allowing
   // the VM to completely create the thread and enter user code)
   static size_t min_stack_allowed;
@@ -186,22 +127,9 @@ class Bsd {
   static size_t default_stack_size(os::ThreadType thr_type);
   static size_t default_guard_size(os::ThreadType thr_type);
 
-#ifndef _ALLBSD_SOURCE
-  static void capture_initial_stack(size_t max_size);
-
-  // Stack overflow handling
-  static bool manually_expand_stack(JavaThread * t, address addr);
-  static int max_register_window_saves_before_flushing();
-#endif
-
   // Real-time clock functions
   static void clock_init(void);
 
-#ifndef _ALLBSD_SOURCE
-  // fast POSIX clocks support
-  static void fast_thread_clock_init(void);
-#endif
-
   static inline bool supports_monotonic_clock() {
     return _clock_gettime != NULL;
   }
@@ -210,18 +138,6 @@ class Bsd {
     return _clock_gettime ? _clock_gettime(clock_id, tp) : -1;
   }
 
-#ifndef _ALLBSD_SOURCE
-  static int pthread_getcpuclockid(pthread_t tid, clockid_t *clock_id) {
-    return _pthread_getcpuclockid ? _pthread_getcpuclockid(tid, clock_id) : -1;
-  }
-
-  static bool supports_fast_thread_cpu_time() {
-    return _supports_fast_thread_cpu_time;
-  }
-
-  static jlong fast_thread_cpu_time(clockid_t clockid);
-#endif
-
   // Stack repair handling
 
   // none present

src/os_cpu/bsd_x86/vm/bytes_bsd_x86.inline.hpp

@@ -25,10 +25,6 @@
 #ifndef OS_CPU_BSD_X86_VM_BYTES_BSD_X86_INLINE_HPP
 #define OS_CPU_BSD_X86_VM_BYTES_BSD_X86_INLINE_HPP
 
-#ifndef _ALLBSD_SOURCE
-#include <byteswap.h>
-#endif
-
 #ifdef __APPLE__
 #include <libkern/OSByteOrder.h>
 #endif

src/os_cpu/bsd_x86/vm/os_bsd_x86.cpp

@@ -76,7 +76,7 @@
 # include <ucontext.h>
 #endif
 
-#if defined(_ALLBSD_SOURCE) && !defined(__APPLE__) && !defined(__NetBSD__)
+#if !defined(__APPLE__) && !defined(__NetBSD__)
 # include <pthread_np.h>
 #endif
 
@@ -489,23 +489,6 @@ JVM_handle_bsd_signal(int sig,
           // to handle_unexpected_exception way down below.
           thread->disable_stack_red_zone();
           tty->print_raw_cr("An irrecoverable stack overflow has occurred.");
-#ifndef _ALLBSD_SOURCE
-        } else {
-          // Accessing stack address below sp may cause SEGV if current
-          // thread has MAP_GROWSDOWN stack. This should only happen when
-          // current thread was created by user code with MAP_GROWSDOWN flag
-          // and then attached to VM. See notes in os_bsd.cpp.
-          if (thread->osthread()->expanding_stack() == 0) {
-             thread->osthread()->set_expanding_stack();
-             if (os::Bsd::manually_expand_stack(thread, addr)) {
-               thread->osthread()->clear_expanding_stack();
-               return 1;
-             }
-             thread->osthread()->clear_expanding_stack();
-          } else {
-             fatal("recursive segv. expanding stack.");
-          }
-#endif
         }
       }
     }
@@ -744,61 +727,21 @@ JVM_handle_bsd_signal(int sig,
   ShouldNotReachHere();
 }
 
-#ifdef _ALLBSD_SOURCE
 // From solaris_i486.s ported to bsd_i486.s
 extern "C" void fixcw();
-#endif
 
 void os::Bsd::init_thread_fpu_state(void) {
 #ifndef AMD64
-# ifdef _ALLBSD_SOURCE
   // Set fpu to 53 bit precision. This happens too early to use a stub.
   fixcw();
-# else
-  // set fpu to 53 bit precision
-  set_fpu_control_word(0x27f);
-# endif
 #endif // !AMD64
 }
 
-#ifndef _ALLBSD_SOURCE
-int os::Bsd::get_fpu_control_word(void) {
-#ifdef AMD64
-  return 0;
-#else
-  int fpu_control;
-  _FPU_GETCW(fpu_control);
-  return fpu_control & 0xffff;
-#endif // AMD64
-}
-
-void os::Bsd::set_fpu_control_word(int fpu_control) {
-#ifndef AMD64
-  _FPU_SETCW(fpu_control);
-#endif // !AMD64
-}
-#endif
 
 // Check that the bsd kernel version is 2.4 or higher since earlier
 // versions do not support SSE without patches.
 bool os::supports_sse() {
-#if defined(AMD64) || defined(_ALLBSD_SOURCE)
   return true;
-#else
-  struct utsname uts;
-  if( uname(&uts) != 0 ) return false; // uname fails?
-  char *minor_string;
-  int major = strtol(uts.release,&minor_string,10);
-  int minor = strtol(minor_string+1,NULL,10);
-  bool result = (major > 2 || (major==2 && minor >= 4));
-#ifndef PRODUCT
-  if (PrintMiscellaneous && Verbose) {
-    tty->print("OS version is %d.%d, which %s support SSE/SSE2\n",
-               major,minor, result ? "DOES" : "does NOT");
-  }
-#endif
-  return result;
-#endif // AMD64
 }
 
 bool os::is_allocatable(size_t bytes) {
@@ -836,46 +779,7 @@ size_t os::Bsd::min_stack_allowed  =  (48 DEBUG_ONLY(+4))*K;
 #define GET_GS() ({int gs; __asm__ volatile("movw %%gs, %w0":"=q"(gs)); gs&0xffff;})
 #endif
 
-#ifdef _ALLBSD_SOURCE
 bool os::Bsd::supports_variable_stack_size() { return true; }
-#else
-// Test if pthread library can support variable thread stack size. BsdThreads
-// in fixed stack mode allocates 2M fixed slot for each thread. BsdThreads
-// in floating stack mode and NPTL support variable stack size.
-bool os::Bsd::supports_variable_stack_size() {
-  if (os::Bsd::is_NPTL()) {
-     // NPTL, yes
-     return true;
-
-  } else {
-    // Note: We can't control default stack size when creating a thread.
-    // If we use non-default stack size (pthread_attr_setstacksize), both
-    // floating stack and non-floating stack BsdThreads will return the
-    // same value. This makes it impossible to implement this function by
-    // detecting thread stack size directly.
-    //
-    // An alternative approach is to check %gs. Fixed-stack BsdThreads
-    // do not use %gs, so its value is 0. Floating-stack BsdThreads use
-    // %gs (either as LDT selector or GDT selector, depending on kernel)
-    // to access thread specific data.
-    //
-    // Note that %gs is a reserved glibc register since early 2001, so
-    // applications are not allowed to change its value (Ulrich Drepper from
-    // Redhat confirmed that all known offenders have been modified to use
-    // either %fs or TSD). In the worst case scenario, when VM is embedded in
-    // a native application that plays with %gs, we might see non-zero %gs
-    // even BsdThreads is running in fixed stack mode. As the result, we'll
-    // return true and skip _thread_safety_check(), so we may not be able to
-    // detect stack-heap collisions. But otherwise it's harmless.
-    //
-#ifdef __GNUC__
-    return (GET_GS() != 0);
-#else
-    return false;
-#endif
-  }
-}
-#endif
 #endif // AMD64
 
 // return default stack size for thr_type
@@ -943,7 +847,7 @@ static void current_stack_region(address * bottom, size_t * size) {
 
   *bottom = (address)((char *)ss.ss_sp - ss.ss_size);
   *size   = ss.ss_size;
-#elif defined(_ALLBSD_SOURCE)
+#else
   pthread_attr_t attr;
 
   int rslt = pthread_attr_init(&attr);
@@ -963,33 +867,6 @@ static void current_stack_region(address * bottom, size_t * size) {
   }
 
   pthread_attr_destroy(&attr);
-#else
-  if (os::Bsd::is_initial_thread()) {
-     // initial thread needs special handling because pthread_getattr_np()
-     // may return bogus value.
-     *bottom = os::Bsd::initial_thread_stack_bottom();
-     *size   = os::Bsd::initial_thread_stack_size();
-  } else {
-     pthread_attr_t attr;
-
-     int rslt = pthread_getattr_np(pthread_self(), &attr);
-
-     // JVM needs to know exact stack location, abort if it fails
-     if (rslt != 0) {
-       if (rslt == ENOMEM) {
-         vm_exit_out_of_memory(0, "pthread_getattr_np");
-       } else {
-         fatal(err_msg("pthread_getattr_np failed with errno = %d", rslt));
-       }
-     }
-
-     if (pthread_attr_getstack(&attr, (void **)bottom, size) != 0) {
-         fatal("Can not locate current stack attributes!");
-     }
-
-     pthread_attr_destroy(&attr);
-
-  }
 #endif
   assert(os::current_stack_pointer() >= *bottom &&
          os::current_stack_pointer() < *bottom + *size, "just checking");

src/os_cpu/bsd_zero/vm/os_bsd_zero.cpp

@@ -23,7 +23,7 @@
  *
  */
 
-#if defined(_ALLBSD_SOURCE) && !defined(__APPLE__) && !defined(__NetBSD__)
+#if !defined(__APPLE__) && !defined(__NetBSD__)
 #include <pthread.h>
 # include <pthread_np.h> /* For pthread_attr_get_np */
 #endif
@@ -178,26 +178,6 @@ JVM_handle_bsd_signal(int sig,
           thread->disable_stack_red_zone();
           ShouldNotCallThis();
         }
-#ifndef _ALLBSD_SOURCE
-        else {
-          // Accessing stack address below sp may cause SEGV if
-          // current thread has MAP_GROWSDOWN stack. This should
-          // only happen when current thread was created by user
-          // code with MAP_GROWSDOWN flag and then attached to VM.
-          // See notes in os_bsd.cpp.
-          if (thread->osthread()->expanding_stack() == 0) {
-            thread->osthread()->set_expanding_stack();
-            if (os::Bsd::manually_expand_stack(thread, addr)) {
-              thread->osthread()->clear_expanding_stack();
-              return true;
-            }
-            thread->osthread()->clear_expanding_stack();
-          }
-          else {
-            fatal("recursive segv. expanding stack.");
-          }
-        }
-#endif
       }
     }
 
@@ -266,16 +246,6 @@ void os::Bsd::init_thread_fpu_state(void) {
   // Nothing to do
 }
 
-#ifndef _ALLBSD_SOURCE
-int os::Bsd::get_fpu_control_word() {
-  ShouldNotCallThis();
-}
-
-void os::Bsd::set_fpu_control_word(int fpu) {
-  ShouldNotCallThis();
-}
-#endif
-
 bool os::is_allocatable(size_t bytes) {
 #ifdef _LP64
   return true;
@@ -339,7 +309,7 @@ static void current_stack_region(address *bottom, size_t *size) {
   stack_top = (address) ss.ss_sp;
   stack_bytes  = ss.ss_size;
   stack_bottom = stack_top - stack_bytes;
-#elif defined(_ALLBSD_SOURCE)
+#else
   pthread_attr_t attr;
 
   int rslt = pthread_attr_init(&attr);
@@ -362,67 +332,6 @@ static void current_stack_region(address *bottom, size_t *size) {
   pthread_attr_destroy(&attr);
 
   stack_top = stack_bottom + stack_bytes;
-#else /* Linux */
-  pthread_attr_t attr;
-  int res = pthread_getattr_np(pthread_self(), &attr);
-  if (res != 0) {
-    if (res == ENOMEM) {
-      vm_exit_out_of_memory(0, "pthread_getattr_np");
-    }
-    else {
-      fatal(err_msg("pthread_getattr_np failed with errno = " INT32_FORMAT,
-            res));
-    }
-  }
-
-  res = pthread_attr_getstack(&attr, (void **) &stack_bottom, &stack_bytes);
-  if (res != 0) {
-    fatal(err_msg("pthread_attr_getstack failed with errno = " INT32_FORMAT,
-          res));
-  }
-  stack_top = stack_bottom + stack_bytes;
-
-  // The block of memory returned by pthread_attr_getstack() includes
-  // guard pages where present.  We need to trim these off.
-  size_t page_bytes = os::Bsd::page_size();
-  assert(((intptr_t) stack_bottom & (page_bytes - 1)) == 0, "unaligned stack");
-
-  size_t guard_bytes;
-  res = pthread_attr_getguardsize(&attr, &guard_bytes);
-  if (res != 0) {
-    fatal(err_msg(
-        "pthread_attr_getguardsize failed with errno = " INT32_FORMAT, res));
-  }
-  int guard_pages = align_size_up(guard_bytes, page_bytes) / page_bytes;
-  assert(guard_bytes == guard_pages * page_bytes, "unaligned guard");
-
-#ifdef IA64
-  // IA64 has two stacks sharing the same area of memory, a normal
-  // stack growing downwards and a register stack growing upwards.
-  // Guard pages, if present, are in the centre.  This code splits
-  // the stack in two even without guard pages, though in theory
-  // there's nothing to stop us allocating more to the normal stack
-  // or more to the register stack if one or the other were found
-  // to grow faster.
-  int total_pages = align_size_down(stack_bytes, page_bytes) / page_bytes;
-  stack_bottom += (total_pages - guard_pages) / 2 * page_bytes;
-#endif // IA64
-
-  stack_bottom += guard_bytes;
-
-  pthread_attr_destroy(&attr);
-
-  // The initial thread has a growable stack, and the size reported
-  // by pthread_attr_getstack is the maximum size it could possibly
-  // be given what currently mapped.  This can be huge, so we cap it.
-  if (os::Bsd::is_initial_thread()) {
-    stack_bytes = stack_top - stack_bottom;
-
-    if (stack_bytes > JavaThread::stack_size_at_create())
-      stack_bytes = JavaThread::stack_size_at_create();
-
-    stack_bottom = stack_top - stack_bytes;
-  }
 #endif
 
   assert(os::current_stack_pointer() >= stack_bottom, "should do");