src/os/linux/vm/os_linux.cpp

*** 1,7 ****
  /*
!  * Copyright (c) 1999, 2013, Oracle and/or its affiliates. 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.
--- 1,7 ----
  /*
!  * Copyright (c) 1999, 2014, Oracle and/or its affiliates. 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.
*** 3790,3883 ****
  
  size_t os::read(int fd, void *buf, unsigned int nBytes) {
    return ::read(fd, buf, nBytes);
  }
  
- // TODO-FIXME: reconcile Solaris' os::sleep with the linux variation.
- // Solaris uses poll(), linux uses park().
- // Poll() is likely a better choice, assuming that Thread.interrupt()
- // generates a SIGUSRx signal. Note that SIGUSR1 can interfere with
- // SIGSEGV, see 4355769.
- 
- int os::sleep(Thread* thread, jlong millis, bool interruptible) {
-   assert(thread == Thread::current(),  "thread consistency check");
- 
-   ParkEvent * const slp = thread->_SleepEvent ;
-   slp->reset() ;
-   OrderAccess::fence() ;
- 
-   if (interruptible) {
-     jlong prevtime = javaTimeNanos();
- 
-     for (;;) {
-       if (os::is_interrupted(thread, true)) {
-         return OS_INTRPT;
-       }
- 
-       jlong newtime = javaTimeNanos();
- 
-       if (newtime - prevtime < 0) {
-         // time moving backwards, should only happen if no monotonic clock
-         // not a guarantee() because JVM should not abort on kernel/glibc bugs
-         assert(!Linux::supports_monotonic_clock(), "time moving backwards");
-       } else {
-         millis -= (newtime - prevtime) / NANOSECS_PER_MILLISEC;
-       }
- 
-       if(millis <= 0) {
-         return OS_OK;
-       }
- 
-       prevtime = newtime;
- 
-       {
-         assert(thread->is_Java_thread(), "sanity check");
-         JavaThread *jt = (JavaThread *) thread;
-         ThreadBlockInVM tbivm(jt);
-         OSThreadWaitState osts(jt->osthread(), false /* not Object.wait() */);
- 
-         jt->set_suspend_equivalent();
-         // cleared by handle_special_suspend_equivalent_condition() or
-         // java_suspend_self() via check_and_wait_while_suspended()
- 
-         slp->park(millis);
- 
-         // were we externally suspended while we were waiting?
-         jt->check_and_wait_while_suspended();
-       }
-     }
-   } else {
-     OSThreadWaitState osts(thread->osthread(), false /* not Object.wait() */);
-     jlong prevtime = javaTimeNanos();
- 
-     for (;;) {
-       // It'd be nice to avoid the back-to-back javaTimeNanos() calls on
-       // the 1st iteration ...
-       jlong newtime = javaTimeNanos();
- 
-       if (newtime - prevtime < 0) {
-         // time moving backwards, should only happen if no monotonic clock
-         // not a guarantee() because JVM should not abort on kernel/glibc bugs
-         assert(!Linux::supports_monotonic_clock(), "time moving backwards");
-       } else {
-         millis -= (newtime - prevtime) / NANOSECS_PER_MILLISEC;
-       }
- 
-       if(millis <= 0) break ;
- 
-       prevtime = newtime;
-       slp->park(millis);
-     }
-     return OS_OK ;
-   }
- }
- 
- int os::naked_sleep() {
-   // %% make the sleep time an integer flag. for now use 1 millisec.
-   return os::sleep(Thread::current(), 1, false);
- }
- 
  // Sleep forever; naked call to OS-specific sleep; use with CAUTION
  void os::infinite_sleep() {
    while (true) {    // sleep forever ...
      ::sleep(100);   // ... 100 seconds at a time
    }
--- 3790,3799 ----
*** 4197,4250 ****
    }
  
    guarantee(osthread->sr.is_running(), "Must be running!");
  }
  
- ////////////////////////////////////////////////////////////////////////////////
- // interrupt support
- 
- void os::interrupt(Thread* thread) {
-   assert(Thread::current() == thread || Threads_lock->owned_by_self(),
-     "possibility of dangling Thread pointer");
- 
-   OSThread* osthread = thread->osthread();
- 
-   if (!osthread->interrupted()) {
-     osthread->set_interrupted(true);
-     // More than one thread can get here with the same value of osthread,
-     // resulting in multiple notifications.  We do, however, want the store
-     // to interrupted() to be visible to other threads before we execute unpark().
-     OrderAccess::fence();
-     ParkEvent * const slp = thread->_SleepEvent ;
-     if (slp != NULL) slp->unpark() ;
-   }
- 
-   // For JSR166. Unpark even if interrupt status already was set
-   if (thread->is_Java_thread())
-     ((JavaThread*)thread)->parker()->unpark();
- 
-   ParkEvent * ev = thread->_ParkEvent ;
-   if (ev != NULL) ev->unpark() ;
- 
- }
- 
- bool os::is_interrupted(Thread* thread, bool clear_interrupted) {
-   assert(Thread::current() == thread || Threads_lock->owned_by_self(),
-     "possibility of dangling Thread pointer");
- 
-   OSThread* osthread = thread->osthread();
- 
-   bool interrupted = osthread->interrupted();
- 
-   if (interrupted && clear_interrupted) {
-     osthread->set_interrupted(false);
-     // consider thread->_SleepEvent->reset() ... optional optimization
-   }
- 
-   return interrupted;
- }
- 
  ///////////////////////////////////////////////////////////////////////////////////
  // signal handling (except suspend/resume)
  
  // This routine may be used by user applications as a "hook" to catch signals.
  // The user-defined signal handler must pass unrecognized signals to this
--- 4113,4122 ----