1 /*
2 * Copyright (c) 1997, 2012, 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 *
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_lwp_id(uint id) { _lwp_id = id; }
66 void set_native_priority(int prio) { _native_priority = prio; }
67
68 // ***************************************************************
69 // interrupt support. interrupts (using signals) are used to get
70 // the thread context (get_thread_pc), to set the thread context
71 // (set_thread_pc), and to implement java.lang.Thread.interrupt.
72 // ***************************************************************
73
74 public:
75
76 class InterruptArguments : StackObj {
77 private:
78 Thread* _thread; // the thread to signal was dispatched to
79 ucontext_t* _ucontext; // the machine context at the time of the signal
80
81 public:
82 InterruptArguments(Thread* thread, ucontext_t* ucontext) {
83 _thread = thread;
84 _ucontext = ucontext;
85 }
86
87 Thread* thread() const { return _thread; }
88 ucontext_t* ucontext() const { return _ucontext; }
89 };
90
91 // There are currently no asynchronous callbacks - and we'd better not
92 // support them in the future either, as they need to be deallocated from
93 // the interrupt handler, which is not safe; they also require locks to
94 // protect the callback queue.
95
96 class Sync_Interrupt_Callback : private StackObj {
97 protected:
98 volatile bool _is_done;
99 Monitor* _sync;
100 Thread* _target;
101 public:
102 Sync_Interrupt_Callback(Monitor * sync) {
103 _is_done = false; _target = NULL; _sync = sync;
104 }
105
106 bool is_done() const { return _is_done; }
107 Thread* target() const { return _target; }
108
109 int interrupt(Thread * target, int timeout);
110
111 // override to implement the callback.
112 virtual void execute(InterruptArguments *args) = 0;
113
114 void leave_callback();
115 };
116
117 private:
118
119 Sync_Interrupt_Callback * volatile _current_callback;
120 enum {
121 callback_in_progress = 1
122 };
123 Mutex * _current_callback_lock; // only used on v8
124
125 public:
126
127 int set_interrupt_callback (Sync_Interrupt_Callback * cb);
128 void remove_interrupt_callback(Sync_Interrupt_Callback * cb);
129 void do_interrupt_callbacks_at_interrupt(InterruptArguments *args);
130
131 // ***************************************************************
132 // java.lang.Thread.interrupt state.
133 // ***************************************************************
134
135 private:
136
137 JavaThreadState _saved_interrupt_thread_state; // the thread state before a system call -- restored afterward
138
139 public:
140
141
142 JavaThreadState saved_interrupt_thread_state() { return _saved_interrupt_thread_state; }
143 void set_saved_interrupt_thread_state(JavaThreadState state) { _saved_interrupt_thread_state = state; }
144
145 static void handle_spinlock_contention(int tries); // Used for thread local eden locking
146
147 // ***************************************************************
148 // Platform dependent initialization and cleanup
149 // ***************************************************************
|
1 /*
2 * Copyright (c) 1997, 2013, 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 *
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_lwp_id(uint id) { _lwp_id = id; }
66 void set_native_priority(int prio) { _native_priority = prio; }
67
68 // ***************************************************************
69 // interrupt support. interrupts (using signals) are used to get
70 // the thread context (get_thread_pc), to set the thread context
71 // (set_thread_pc), and to implement java.lang.Thread.interrupt.
72 // ***************************************************************
73
74 public:
75 os::SuspendResume sr;
76
77 private:
78 ucontext_t* _ucontext;
79
80 public:
81 ucontext_t* ucontext() const { return _ucontext; }
82 void set_ucontext(ucontext_t* ptr) { _ucontext = ptr; }
83 static void SR_handler(Thread* thread, ucontext_t* uc);
84
85 // ***************************************************************
86 // java.lang.Thread.interrupt state.
87 // ***************************************************************
88
89 private:
90
91 JavaThreadState _saved_interrupt_thread_state; // the thread state before a system call -- restored afterward
92
93 public:
94
95
96 JavaThreadState saved_interrupt_thread_state() { return _saved_interrupt_thread_state; }
97 void set_saved_interrupt_thread_state(JavaThreadState state) { _saved_interrupt_thread_state = state; }
98
99 static void handle_spinlock_contention(int tries); // Used for thread local eden locking
100
101 // ***************************************************************
102 // Platform dependent initialization and cleanup
103 // ***************************************************************
|