1 /*
2 * Copyright (c) 2003, 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 *
23 */
24
25 #include "precompiled.hpp"
26 #include "prims/jvmtiRawMonitor.hpp"
27 #include "runtime/interfaceSupport.hpp"
28 #include "runtime/orderAccess.inline.hpp"
29 #include "runtime/thread.inline.hpp"
30
31 GrowableArray<JvmtiRawMonitor*> *JvmtiPendingMonitors::_monitors = new (ResourceObj::C_HEAP, mtInternal) GrowableArray<JvmtiRawMonitor*>(1,true);
32
33 void JvmtiPendingMonitors::transition_raw_monitors() {
34 assert((Threads::number_of_threads()==1),
35 "Java thread has not created yet or more than one java thread \
36 is running. Raw monitor transition will not work");
37 JavaThread *current_java_thread = JavaThread::current();
38 assert(current_java_thread->thread_state() == _thread_in_vm, "Must be in vm");
39 {
40 ThreadBlockInVM __tbivm(current_java_thread);
41 for(int i=0; i< count(); i++) {
42 JvmtiRawMonitor *rmonitor = monitors()->at(i);
43 int r = rmonitor->raw_enter(current_java_thread);
44 assert(r == ObjectMonitor::OM_OK, "raw_enter should have worked");
45 }
46 }
47 // pending monitors are converted to real monitor so delete them all.
48 dispose();
49 }
50
51 //
52 // class JvmtiRawMonitor
53 //
54
55 JvmtiRawMonitor::JvmtiRawMonitor(const char *name) {
56 #ifdef ASSERT
57 _name = strcpy(NEW_C_HEAP_ARRAY(char, strlen(name) + 1, mtInternal), name);
58 #else
59 _name = NULL;
60 #endif
61 _magic = JVMTI_RM_MAGIC;
62 }
63
64 JvmtiRawMonitor::~JvmtiRawMonitor() {
65 #ifdef ASSERT
66 FreeHeap(_name);
67 #endif
68 _magic = 0;
69 }
70
71
72 bool
73 JvmtiRawMonitor::is_valid() {
74 int value = 0;
75
76 // This object might not be a JvmtiRawMonitor so we can't assume
77 // the _magic field is properly aligned. Get the value in a safe
78 // way and then check against JVMTI_RM_MAGIC.
79
80 switch (sizeof(_magic)) {
81 case 2:
82 value = Bytes::get_native_u2((address)&_magic);
83 break;
84
85 case 4:
86 value = Bytes::get_native_u4((address)&_magic);
87 break;
88
89 case 8:
90 value = Bytes::get_native_u8((address)&_magic);
91 break;
92
93 default:
94 guarantee(false, "_magic field is an unexpected size");
95 }
96
97 return value == JVMTI_RM_MAGIC;
98 }
99
100 // -------------------------------------------------------------------------
101 // The raw monitor subsystem is entirely distinct from normal
102 // java-synchronization or jni-synchronization. raw monitors are not
103 // associated with objects. They can be implemented in any manner
104 // that makes sense. The original implementors decided to piggy-back
105 // the raw-monitor implementation on the existing Java objectMonitor mechanism.
106 // This flaw needs to fixed. We should reimplement raw monitors as sui-generis.
107 // Specifically, we should not implement raw monitors via java monitors.
108 // Time permitting, we should disentangle and deconvolve the two implementations
109 // and move the resulting raw monitor implementation over to the JVMTI directories.
110 // Ideally, the raw monitor implementation would be built on top of
111 // park-unpark and nothing else.
112 //
113 // raw monitors are used mainly by JVMTI
114 // The raw monitor implementation borrows the ObjectMonitor structure,
115 // but the operators are degenerate and extremely simple.
116 //
117 // Mixed use of a single objectMonitor instance -- as both a raw monitor
118 // and a normal java monitor -- is not permissible.
119 //
120 // Note that we use the single RawMonitor_lock to protect queue operations for
121 // _all_ raw monitors. This is a scalability impediment, but since raw monitor usage
122 // is deprecated and rare, this is not of concern. The RawMonitor_lock can not
123 // be held indefinitely. The critical sections must be short and bounded.
124 //
125 // -------------------------------------------------------------------------
126
127 int JvmtiRawMonitor::SimpleEnter (Thread * Self) {
128 for (;;) {
129 if (Atomic::cmpxchg_ptr (Self, &_owner, NULL) == NULL) {
130 return OS_OK ;
131 }
132
133 ObjectWaiter Node (Self) ;
134 Self->_ParkEvent->reset() ; // strictly optional
135 Node.TState = ObjectWaiter::TS_ENTER ;
136
137 RawMonitor_lock->lock_without_safepoint_check() ;
138 Node._next = _EntryList ;
139 _EntryList = &Node ;
140 OrderAccess::fence() ;
141 if (_owner == NULL && Atomic::cmpxchg_ptr (Self, &_owner, NULL) == NULL) {
142 _EntryList = Node._next ;
143 RawMonitor_lock->unlock() ;
144 return OS_OK ;
145 }
146 RawMonitor_lock->unlock() ;
147 while (Node.TState == ObjectWaiter::TS_ENTER) {
148 Self->_ParkEvent->park() ;
149 }
150 }
151 }
152
153 int JvmtiRawMonitor::SimpleExit (Thread * Self) {
154 guarantee (_owner == Self, "invariant") ;
155 OrderAccess::release_store_ptr (&_owner, NULL) ;
156 OrderAccess::fence() ;
157 if (_EntryList == NULL) return OS_OK ;
158 ObjectWaiter * w ;
159
160 RawMonitor_lock->lock_without_safepoint_check() ;
161 w = _EntryList ;
162 if (w != NULL) {
163 _EntryList = w->_next ;
164 }
165 RawMonitor_lock->unlock() ;
166 if (w != NULL) {
167 guarantee (w ->TState == ObjectWaiter::TS_ENTER, "invariant") ;
168 ParkEvent * ev = w->_event ;
169 w->TState = ObjectWaiter::TS_RUN ;
170 OrderAccess::fence() ;
171 ev->unpark() ;
172 }
173 return OS_OK ;
174 }
175
176 int JvmtiRawMonitor::SimpleWait (Thread * Self, jlong millis) {
177 guarantee (_owner == Self , "invariant") ;
178 guarantee (_recursions == 0, "invariant") ;
179
180 ObjectWaiter Node (Self) ;
181 Node._notified = 0 ;
182 Node.TState = ObjectWaiter::TS_WAIT ;
183
184 RawMonitor_lock->lock_without_safepoint_check() ;
185 Node._next = _WaitSet ;
186 _WaitSet = &Node ;
187 RawMonitor_lock->unlock() ;
188
189 SimpleExit (Self) ;
190 guarantee (_owner != Self, "invariant") ;
191
192 int ret = OS_OK ;
193 if (millis <= 0) {
194 Self->_ParkEvent->park();
195 } else {
196 ret = Self->_ParkEvent->park(millis);
197 }
198
199 // If thread still resides on the waitset then unlink it.
200 // Double-checked locking -- the usage is safe in this context
201 // as we TState is volatile and the lock-unlock operators are
202 // serializing (barrier-equivalent).
203
204 if (Node.TState == ObjectWaiter::TS_WAIT) {
205 RawMonitor_lock->lock_without_safepoint_check() ;
206 if (Node.TState == ObjectWaiter::TS_WAIT) {
207 // Simple O(n) unlink, but performance isn't critical here.
208 ObjectWaiter * p ;
209 ObjectWaiter * q = NULL ;
210 for (p = _WaitSet ; p != &Node; p = p->_next) {
211 q = p ;
212 }
213 guarantee (p == &Node, "invariant") ;
214 if (q == NULL) {
215 guarantee (p == _WaitSet, "invariant") ;
216 _WaitSet = p->_next ;
217 } else {
218 guarantee (p == q->_next, "invariant") ;
219 q->_next = p->_next ;
220 }
221 Node.TState = ObjectWaiter::TS_RUN ;
222 }
223 RawMonitor_lock->unlock() ;
224 }
225
226 guarantee (Node.TState == ObjectWaiter::TS_RUN, "invariant") ;
227 SimpleEnter (Self) ;
228
229 guarantee (_owner == Self, "invariant") ;
230 guarantee (_recursions == 0, "invariant") ;
231 return ret ;
232 }
233
234 int JvmtiRawMonitor::SimpleNotify (Thread * Self, bool All) {
235 guarantee (_owner == Self, "invariant") ;
236 if (_WaitSet == NULL) return OS_OK ;
237
238 // We have two options:
239 // A. Transfer the threads from the WaitSet to the EntryList
240 // B. Remove the thread from the WaitSet and unpark() it.
241 //
242 // We use (B), which is crude and results in lots of futile
243 // context switching. In particular (B) induces lots of contention.
244
245 ParkEvent * ev = NULL ; // consider using a small auto array ...
246 RawMonitor_lock->lock_without_safepoint_check() ;
247 for (;;) {
248 ObjectWaiter * w = _WaitSet ;
249 if (w == NULL) break ;
250 _WaitSet = w->_next ;
251 if (ev != NULL) { ev->unpark(); ev = NULL; }
252 ev = w->_event ;
253 OrderAccess::loadstore() ;
254 w->TState = ObjectWaiter::TS_RUN ;
255 OrderAccess::storeload();
256 if (!All) break ;
257 }
258 RawMonitor_lock->unlock() ;
259 if (ev != NULL) ev->unpark();
260 return OS_OK ;
261 }
262
263 // Any JavaThread will enter here with state _thread_blocked
264 int JvmtiRawMonitor::raw_enter(TRAPS) {
265 TEVENT (raw_enter) ;
266 void * Contended ;
267
268 // don't enter raw monitor if thread is being externally suspended, it will
269 // surprise the suspender if a "suspended" thread can still enter monitor
270 JavaThread * jt = (JavaThread *)THREAD;
271 if (THREAD->is_Java_thread()) {
272 jt->SR_lock()->lock_without_safepoint_check();
273 while (jt->is_external_suspend()) {
274 jt->SR_lock()->unlock();
275 jt->java_suspend_self();
276 jt->SR_lock()->lock_without_safepoint_check();
277 }
278 // guarded by SR_lock to avoid racing with new external suspend requests.
279 Contended = Atomic::cmpxchg_ptr (THREAD, &_owner, NULL) ;
280 jt->SR_lock()->unlock();
281 } else {
282 Contended = Atomic::cmpxchg_ptr (THREAD, &_owner, NULL) ;
283 }
284
285 if (Contended == THREAD) {
286 _recursions ++ ;
287 return OM_OK ;
288 }
289
290 if (Contended == NULL) {
291 guarantee (_owner == THREAD, "invariant") ;
292 guarantee (_recursions == 0, "invariant") ;
293 return OM_OK ;
294 }
295
296 THREAD->set_current_pending_monitor(this);
297
298 if (!THREAD->is_Java_thread()) {
299 // No other non-Java threads besides VM thread would acquire
300 // a raw monitor.
301 assert(THREAD->is_VM_thread(), "must be VM thread");
302 SimpleEnter (THREAD) ;
303 } else {
304 guarantee (jt->thread_state() == _thread_blocked, "invariant") ;
305 for (;;) {
306 jt->set_suspend_equivalent();
307 // cleared by handle_special_suspend_equivalent_condition() or
308 // java_suspend_self()
309 SimpleEnter (THREAD) ;
310
311 // were we externally suspended while we were waiting?
312 if (!jt->handle_special_suspend_equivalent_condition()) break ;
313
314 // This thread was externally suspended
315 //
316 // This logic isn't needed for JVMTI raw monitors,
317 // but doesn't hurt just in case the suspend rules change. This
318 // logic is needed for the JvmtiRawMonitor.wait() reentry phase.
319 // We have reentered the contended monitor, but while we were
320 // waiting another thread suspended us. We don't want to reenter
321 // the monitor while suspended because that would surprise the
322 // thread that suspended us.
323 //
324 // Drop the lock -
325 SimpleExit (THREAD) ;
326
327 jt->java_suspend_self();
328 }
329
330 assert(_owner == THREAD, "Fatal error with monitor owner!");
331 assert(_recursions == 0, "Fatal error with monitor recursions!");
332 }
333
334 THREAD->set_current_pending_monitor(NULL);
335 guarantee (_recursions == 0, "invariant") ;
336 return OM_OK;
337 }
338
339 // Used mainly for JVMTI raw monitor implementation
340 // Also used for JvmtiRawMonitor::wait().
341 int JvmtiRawMonitor::raw_exit(TRAPS) {
342 TEVENT (raw_exit) ;
343 if (THREAD != _owner) {
344 return OM_ILLEGAL_MONITOR_STATE;
345 }
346 if (_recursions > 0) {
347 --_recursions ;
348 return OM_OK ;
349 }
350
351 void * List = _EntryList ;
352 SimpleExit (THREAD) ;
353
354 return OM_OK;
355 }
356
357 // Used for JVMTI raw monitor implementation.
358 // All JavaThreads will enter here with state _thread_blocked
359
360 int JvmtiRawMonitor::raw_wait(jlong millis, bool interruptible, TRAPS) {
361 TEVENT (raw_wait) ;
362 if (THREAD != _owner) {
363 return OM_ILLEGAL_MONITOR_STATE;
364 }
365
366 // To avoid spurious wakeups we reset the parkevent -- This is strictly optional.
367 // The caller must be able to tolerate spurious returns from raw_wait().
368 THREAD->_ParkEvent->reset() ;
369 OrderAccess::fence() ;
370
371 // check interrupt event
372 if (interruptible && Thread::is_interrupted(THREAD, true)) {
373 return OM_INTERRUPTED;
374 }
375
376 intptr_t save = _recursions ;
377 _recursions = 0 ;
378 _waiters ++ ;
379 if (THREAD->is_Java_thread()) {
380 guarantee (((JavaThread *) THREAD)->thread_state() == _thread_blocked, "invariant") ;
381 ((JavaThread *)THREAD)->set_suspend_equivalent();
382 }
383 int rv = SimpleWait (THREAD, millis) ;
384 _recursions = save ;
385 _waiters -- ;
386
387 guarantee (THREAD == _owner, "invariant") ;
388 if (THREAD->is_Java_thread()) {
389 JavaThread * jSelf = (JavaThread *) THREAD ;
390 for (;;) {
391 if (!jSelf->handle_special_suspend_equivalent_condition()) break ;
392 SimpleExit (THREAD) ;
393 jSelf->java_suspend_self();
394 SimpleEnter (THREAD) ;
395 jSelf->set_suspend_equivalent() ;
396 }
397 }
398 guarantee (THREAD == _owner, "invariant") ;
399
400 if (interruptible && Thread::is_interrupted(THREAD, true)) {
401 return OM_INTERRUPTED;
402 }
403 return OM_OK ;
404 }
405
406 int JvmtiRawMonitor::raw_notify(TRAPS) {
407 TEVENT (raw_notify) ;
408 if (THREAD != _owner) {
409 return OM_ILLEGAL_MONITOR_STATE;
410 }
411 SimpleNotify (THREAD, false) ;
412 return OM_OK;
413 }
414
415 int JvmtiRawMonitor::raw_notifyAll(TRAPS) {
416 TEVENT (raw_notifyAll) ;
417 if (THREAD != _owner) {
418 return OM_ILLEGAL_MONITOR_STATE;
419 }
420 SimpleNotify (THREAD, true) ;
421 return OM_OK;
422 }
423