1 /*
   2  * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #ifndef OS_SOLARIS_VM_OSTHREAD_SOLARIS_HPP
  26 #define OS_SOLARIS_VM_OSTHREAD_SOLARIS_HPP
  27 
  28 // This is embedded via include into the class OSThread
  29 
  30  private:
  31   thread_t _thread_id;         // Solaris thread id
  32   uint     _lwp_id;            // lwp ID, only used with bound threads
  33   int      _native_priority;   // Saved native priority when starting
  34                                // a bound thread
  35   sigset_t _caller_sigmask;    // Caller's signal mask
  36   bool     _vm_created_thread; // true if the VM create this thread,
  37                                // false if primary thread or attached thread
  38  public:
  39   thread_t thread_id() const       { return _thread_id; }
  40   uint     lwp_id() const          { return _lwp_id; }
  41   int      native_priority() const { return _native_priority; }
  42 
  43   // Set and get state of _vm_created_thread flag
  44   void set_vm_created()           { _vm_created_thread = true; }
  45   bool is_vm_created()            { return _vm_created_thread; }
  46 
  47   // Methods to save/restore caller's signal mask
  48   sigset_t  caller_sigmask() const       { return _caller_sigmask; }
  49   void    set_caller_sigmask(sigset_t sigmask)  { _caller_sigmask = sigmask; }
  50 
  51 #ifndef PRODUCT
  52   // Used for debugging, return a unique integer for each thread.
  53   int thread_identifier() const   { return _thread_id; }
  54 #endif
  55 #ifdef ASSERT
  56   // On solaris reposition can fail in two ways:
  57   // 1: a mismatched pc, because signal is delivered too late, target thread
  58   //    is resumed.
  59   // 2: on a timeout where signal is lost, target thread is resumed.
  60   bool valid_reposition_failure() {
  61     // only 1 and 2 can happen and we can handle both of them
  62     return true;
  63   }
  64 #endif
  65   void set_thread_id(thread_t id)    { _thread_id = id; }
  66   void set_lwp_id(uint id)           { _lwp_id = id; }
  67   void set_native_priority(int prio) { _native_priority = prio; }
  68 
  69  // ***************************************************************
  70  // interrupt support.  interrupts (using signals) are used to get
  71  // the thread context (get_thread_pc), to set the thread context
  72  // (set_thread_pc), and to implement java.lang.Thread.interrupt.
  73  // ***************************************************************
  74 
  75  public:
  76 
  77   class InterruptArguments : StackObj {
  78    private:
  79     Thread*     _thread;   // the thread to signal was dispatched to
  80     ucontext_t* _ucontext; // the machine context at the time of the signal
  81 
  82    public:
  83     InterruptArguments(Thread* thread, ucontext_t* ucontext) {
  84       _thread   = thread;
  85       _ucontext = ucontext;
  86     }
  87 
  88     Thread*     thread()   const { return _thread;   }
  89     ucontext_t* ucontext() const { return _ucontext; }
  90   };
  91 
  92   // There are currently no asynchronous callbacks - and we'd better not
  93   // support them in the future either, as they need to be deallocated from
  94   // the interrupt handler, which is not safe; they also require locks to
  95   // protect the callback queue.
  96 
  97   class Sync_Interrupt_Callback : private StackObj {
  98    protected:
  99     volatile bool _is_done;
 100     Monitor*      _sync;
 101     Thread*       _target;
 102    public:
 103     Sync_Interrupt_Callback(Monitor * sync) {
 104       _is_done = false;  _target = NULL;  _sync = sync;
 105     }
 106 
 107     bool is_done() const               { return _is_done; }
 108     Thread* target() const             { return _target;  }
 109 
 110     int interrupt(Thread * target, int timeout);
 111 
 112     // override to implement the callback.
 113     virtual void execute(InterruptArguments *args) = 0;
 114 
 115     void leave_callback();
 116   };
 117 
 118  private:
 119 
 120   Sync_Interrupt_Callback * volatile _current_callback;
 121   enum {
 122     callback_in_progress = 1
 123   };
 124   Mutex * _current_callback_lock;       // only used on v8
 125 
 126  public:
 127 
 128   int set_interrupt_callback    (Sync_Interrupt_Callback * cb);
 129   void remove_interrupt_callback(Sync_Interrupt_Callback * cb);
 130   void do_interrupt_callbacks_at_interrupt(InterruptArguments *args);
 131 
 132  // ***************************************************************
 133  // java.lang.Thread.interrupt state.
 134  // ***************************************************************
 135 
 136  private:
 137 
 138   JavaThreadState      _saved_interrupt_thread_state;       // the thread state before a system call -- restored afterward
 139 
 140  public:
 141 
 142 
 143   JavaThreadState   saved_interrupt_thread_state()                              { return _saved_interrupt_thread_state; }
 144   void              set_saved_interrupt_thread_state(JavaThreadState state)     { _saved_interrupt_thread_state = state; }
 145 
 146   static void       handle_spinlock_contention(int tries);                      // Used for thread local eden locking
 147 
 148   // ***************************************************************
 149   // Platform dependent initialization and cleanup
 150   // ***************************************************************
 151 
 152 private:
 153 
 154   void pd_initialize();
 155   void pd_destroy();
 156 
 157 #endif // OS_SOLARIS_VM_OSTHREAD_SOLARIS_HPP