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 "logging/log.hpp"
27 #include "runtime/interfaceSupport.inline.hpp"
28 #include "runtime/mutex.hpp"
29 #include "runtime/osThread.hpp"
30 #include "runtime/safepointMechanism.inline.hpp"
31 #include "runtime/thread.inline.hpp"
32 #include "utilities/events.hpp"
33 #include "utilities/macros.hpp"
34
35 #ifdef ASSERT
36 void Monitor::check_safepoint_state(Thread* thread, bool do_safepoint_check) {
37 // If the JavaThread checks for safepoint, verify that the lock wasn't created with safepoint_check_never.
38 SafepointCheckRequired not_allowed = do_safepoint_check ? Monitor::_safepoint_check_never :
39 Monitor::_safepoint_check_always;
40 assert(!thread->is_active_Java_thread() || _safepoint_check_required != not_allowed,
41 "This lock should %s have a safepoint check for Java threads: %s",
42 _safepoint_check_required ? "always" : "never", name());
43
44 // If defined with safepoint_check_never, a NonJavaThread should never ask to safepoint check either.
45 assert(thread->is_Java_thread() || !do_safepoint_check || _safepoint_check_required != Monitor::_safepoint_check_never,
46 "NonJavaThread should not check for safepoint");
47 }
48 #endif // ASSERT
49
50 void Monitor::lock(Thread * self) {
51 check_safepoint_state(self, true);
52
53 DEBUG_ONLY(check_prelock_state(self, true));
54 assert(_owner != self, "invariant");
55
56 Monitor* in_flight_monitor = NULL;
57 DEBUG_ONLY(int retry_cnt = 0;)
58 bool is_active_Java_thread = self->is_active_Java_thread();
59 while (!_lock.try_lock()) {
60 // The lock is contended
61
62 #ifdef ASSERT
63 check_block_state(self);
64 if (retry_cnt++ > 3) {
65 log_trace(vmmonitor)("JavaThread " INTPTR_FORMAT " on %d attempt trying to acquire vmmonitor %s", p2i(self), retry_cnt, _name);
66 }
67 #endif // ASSERT
68
69 // Is it a JavaThread participating in the safepoint protocol.
70 if (is_active_Java_thread) {
71 assert(rank() > Mutex::special, "Potential deadlock with special or lesser rank mutex");
72 { ThreadBlockInVMWithDeadlockCheck tbivmdc((JavaThread *) self, &in_flight_monitor);
73 in_flight_monitor = this; // save for ~ThreadBlockInVMWithDeadlockCheck
74 _lock.lock();
75 }
76 if (in_flight_monitor != NULL) {
77 // Not unlocked by ~ThreadBlockInVMWithDeadlockCheck
78 break;
79 }
80 } else {
81 _lock.lock();
82 break;
83 }
84 }
85
86 assert_owner(NULL);
87 set_owner(self);
88 }
89
90 void Monitor::lock() {
91 this->lock(Thread::current());
92 }
93
94 // Lock without safepoint check - a degenerate variant of lock() for use by
95 // JavaThreads when it is known to be safe to not check for a safepoint when
96 // acquiring this lock. If the thread blocks acquiring the lock it is not
97 // safepoint-safe and so will prevent a safepoint from being reached. If used
98 // in the wrong way this can lead to a deadlock with the safepoint code.
99
100 void Monitor::lock_without_safepoint_check(Thread * self) {
101 check_safepoint_state(self, false);
102 assert(_owner != self, "invariant");
103 _lock.lock();
104 assert_owner(NULL);
105 set_owner(self);
106 }
107
108 void Monitor::lock_without_safepoint_check() {
109 lock_without_safepoint_check(Thread::current());
110 }
111
112
113 // Returns true if thread succeeds in grabbing the lock, otherwise false.
114
115 bool Monitor::try_lock() {
116 Thread * const self = Thread::current();
117 DEBUG_ONLY(check_prelock_state(self, false);)
118
119 if (_lock.try_lock()) {
120 assert_owner(NULL);
121 set_owner(self);
122 return true;
123 }
124 return false;
125 }
126
127 void Monitor::release_for_safepoint() {
128 assert_owner(NULL);
129 _lock.unlock();
130 }
131
132 void Monitor::unlock() {
133 assert_owner(Thread::current());
134 set_owner(NULL);
135 _lock.unlock();
136 }
137
138 void Monitor::notify() {
139 assert_owner(Thread::current());
140 _lock.notify();
141 }
142
143 void Monitor::notify_all() {
144 assert_owner(Thread::current());
145 _lock.notify_all();
146 }
147
148 #ifdef ASSERT
149 void Monitor::assert_wait_lock_state(Thread* self) {
150 Monitor* least = get_least_ranked_lock_besides_this(self->owned_locks());
151 assert(least != this, "Specification of get_least_... call above");
152 if (least != NULL && least->rank() <= special) {
153 ::tty->print("Attempting to wait on monitor %s/%d while holding"
154 " lock %s/%d -- possible deadlock",
155 name(), rank(), least->name(), least->rank());
156 assert(false, "Shouldn't block(wait) while holding a lock of rank special");
157 }
158 }
159 #endif // ASSERT
160
161 bool Monitor::wait_without_safepoint_check(long timeout) {
162 Thread* const self = Thread::current();
163 check_safepoint_state(self, false);
164
165 // timeout is in milliseconds - with zero meaning never timeout
166 assert(timeout >= 0, "negative timeout");
167
168 assert_owner(self);
169 assert_wait_lock_state(self);
170
177 }
178
179 bool Monitor::wait(long timeout, bool as_suspend_equivalent) {
180 Thread* const self = Thread::current();
181 check_safepoint_state(self, true);
182
183 // timeout is in milliseconds - with zero meaning never timeout
184 assert(timeout >= 0, "negative timeout");
185
186 assert_owner(self);
187
188 // Safepoint checking logically implies an active JavaThread.
189 guarantee(self->is_active_Java_thread(), "invariant");
190 assert_wait_lock_state(self);
191
192 int wait_status;
193 // conceptually set the owner to NULL in anticipation of
194 // abdicating the lock in wait
195 set_owner(NULL);
196 JavaThread *jt = (JavaThread *)self;
197 Monitor* in_flight_monitor = NULL;
198
199 {
200 ThreadBlockInVMWithDeadlockCheck tbivmdc(jt, &in_flight_monitor);
201 OSThreadWaitState osts(self->osthread(), false /* not Object.wait() */);
202 if (as_suspend_equivalent) {
203 jt->set_suspend_equivalent();
204 // cleared by handle_special_suspend_equivalent_condition() or
205 // java_suspend_self()
206 }
207
208 wait_status = _lock.wait(timeout);
209 in_flight_monitor = this; // save for ~ThreadBlockInVMWithDeadlockCheck
210
211 // were we externally suspended while we were waiting?
212 if (as_suspend_equivalent && jt->handle_special_suspend_equivalent_condition()) {
213 // Our event wait has finished and we own the lock, but
214 // while we were waiting another thread suspended us. We don't
215 // want to hold the lock while suspended because that
216 // would surprise the thread that suspended us.
217 _lock.unlock();
218 jt->java_suspend_self();
219 _lock.lock();
220 }
221 }
222
223 if (in_flight_monitor != NULL) {
224 // Not unlocked by ~ThreadBlockInVMWithDeadlockCheck
225 assert_owner(NULL);
226 // Conceptually reestablish ownership of the lock.
227 set_owner(self);
228 } else {
229 lock(self);
230 }
231
232 return wait_status != 0; // return true IFF timeout
233 }
234
235 Monitor::~Monitor() {
236 assert_owner(NULL);
237 }
238
239 // Only Threads_lock, Heap_lock and SR_lock may be safepoint_check_sometimes.
240 bool is_sometimes_ok(const char* name) {
241 return (strcmp(name, "Threads_lock") == 0 || strcmp(name, "Heap_lock") == 0 || strcmp(name, "SR_lock") == 0);
242 }
243
244 Monitor::Monitor(int Rank, const char * name, bool allow_vm_block,
245 SafepointCheckRequired safepoint_check_required) : _owner(NULL) {
246 assert(os::mutex_init_done(), "Too early!");
247 if (name == NULL) {
248 strcpy(_name, "UNKNOWN");
249 } else {
250 strncpy(_name, name, MONITOR_NAME_LEN - 1);
251 _name[MONITOR_NAME_LEN - 1] = '\0';
252 }
253 #ifdef ASSERT
254 _allow_vm_block = allow_vm_block;
255 _rank = Rank;
256 _safepoint_check_required = safepoint_check_required;
257
258 assert(_safepoint_check_required != Monitor::_safepoint_check_sometimes || is_sometimes_ok(name),
259 "Lock has _safepoint_check_sometimes %s", name);
260 #endif
261 }
262
263 Mutex::Mutex(int Rank, const char * name, bool allow_vm_block,
264 SafepointCheckRequired safepoint_check_required) :
265 Monitor(Rank, name, allow_vm_block, safepoint_check_required) {}
266
267 bool Monitor::owned_by_self() const {
268 return _owner == Thread::current();
269 }
270
271 void Monitor::print_on_error(outputStream* st) const {
272 st->print("[" PTR_FORMAT, p2i(this));
273 st->print("] %s", _name);
274 st->print(" - owner thread: " PTR_FORMAT, p2i(_owner));
275 }
276
277 // ----------------------------------------------------------------------------------
278 // Non-product code
279
280 #ifndef PRODUCT
281 void Monitor::print_on(outputStream* st) const {
282 st->print_cr("Mutex: [" PTR_FORMAT "] %s - owner: " PTR_FORMAT,
283 p2i(this), _name, p2i(_owner));
284 }
285 #endif
286
287 #ifndef PRODUCT
288 #ifdef ASSERT
289
290 void Monitor::assert_owner(Thread * expected) {
291 const char* msg = "invalid owner";
292 if (expected == NULL) {
293 msg = "should be un-owned";
294 }
295 else if (expected == Thread::current()) {
296 msg = "should be owned by current thread";
297 }
298 assert(_owner == expected,
299 "%s: owner=" INTPTR_FORMAT ", should be=" INTPTR_FORMAT,
300 msg, p2i(_owner), p2i(expected));
301 }
302
303 Monitor * Monitor::get_least_ranked_lock(Monitor * locks) {
304 Monitor *res, *tmp;
305 for (res = tmp = locks; tmp != NULL; tmp = tmp->next()) {
306 if (tmp->rank() < res->rank()) {
307 res = tmp;
308 }
309 }
310 if (!SafepointSynchronize::is_at_safepoint()) {
311 // In this case, we expect the held locks to be
312 // in increasing rank order (modulo any native ranks)
313 for (tmp = locks; tmp != NULL; tmp = tmp->next()) {
314 if (tmp->next() != NULL) {
315 assert(tmp->rank() == Mutex::native ||
316 tmp->rank() <= tmp->next()->rank(), "mutex rank anomaly?");
317 }
318 }
319 }
320 return res;
321 }
322
323 Monitor* Monitor::get_least_ranked_lock_besides_this(Monitor* locks) {
324 Monitor *res, *tmp;
325 for (res = NULL, tmp = locks; tmp != NULL; tmp = tmp->next()) {
326 if (tmp != this && (res == NULL || tmp->rank() < res->rank())) {
327 res = tmp;
328 }
329 }
330 if (!SafepointSynchronize::is_at_safepoint()) {
331 // In this case, we expect the held locks to be
332 // in increasing rank order (modulo any native ranks)
333 for (tmp = locks; tmp != NULL; tmp = tmp->next()) {
334 if (tmp->next() != NULL) {
335 assert(tmp->rank() == Mutex::native ||
336 tmp->rank() <= tmp->next()->rank(), "mutex rank anomaly?");
337 }
338 }
339 }
340 return res;
341 }
342
343
344 bool Monitor::contains(Monitor* locks, Monitor * lock) {
345 for (; locks != NULL; locks = locks->next()) {
346 if (locks == lock) {
347 return true;
348 }
349 }
350 return false;
351 }
352 #endif
353
354 // Called immediately after lock acquisition or release as a diagnostic
355 // to track the lock-set of the thread and test for rank violations that
356 // might indicate exposure to deadlock.
357 // Rather like an EventListener for _owner (:>).
358
359 void Monitor::set_owner_implementation(Thread *new_owner) {
360 // This function is solely responsible for maintaining
361 // and checking the invariant that threads and locks
362 // are in a 1/N relation, with some some locks unowned.
363 // It uses the Mutex::_owner, Mutex::_next, and
364 // Thread::_owned_locks fields, and no other function
365 // changes those fields.
366 // It is illegal to set the mutex from one non-NULL
367 // owner to another--it must be owned by NULL as an
368 // intermediate state.
369
370 if (new_owner != NULL) {
371 // the thread is acquiring this lock
372
373 assert(new_owner == Thread::current(), "Should I be doing this?");
374 assert(_owner == NULL, "setting the owner thread of an already owned mutex");
375 _owner = new_owner; // set the owner
376
377 // link "this" into the owned locks list
378
379 #ifdef ASSERT // Thread::_owned_locks is under the same ifdef
380 Monitor* locks = get_least_ranked_lock(new_owner->owned_locks());
381 // Mutex::set_owner_implementation is a friend of Thread
382
383 assert(this->rank() >= 0, "bad lock rank");
384
385 // Deadlock avoidance rules require us to acquire Mutexes only in
386 // a global total order. For example m1 is the lowest ranked mutex
387 // that the thread holds and m2 is the mutex the thread is trying
388 // to acquire, then deadlock avoidance rules require that the rank
389 // of m2 be less than the rank of m1.
390 // The rank Mutex::native is an exception in that it is not subject
391 // to the verification rules.
392 if (this->rank() != Mutex::native &&
393 this->rank() != Mutex::suspend_resume &&
394 locks != NULL && locks->rank() <= this->rank() &&
395 !SafepointSynchronize::is_at_safepoint()) {
396 new_owner->print_owned_locks();
397 fatal("acquiring lock %s/%d out of order with lock %s/%d -- "
398 "possible deadlock", this->name(), this->rank(),
399 locks->name(), locks->rank());
400 }
401
402 this->_next = new_owner->_owned_locks;
403 new_owner->_owned_locks = this;
404 #endif
405
406 } else {
407 // the thread is releasing this lock
408
409 Thread* old_owner = _owner;
410 DEBUG_ONLY(_last_owner = old_owner;)
411
412 assert(old_owner != NULL, "removing the owner thread of an unowned mutex");
413 assert(old_owner == Thread::current(), "removing the owner thread of an unowned mutex");
414
415 _owner = NULL; // set the owner
416
417 #ifdef ASSERT
418 Monitor *locks = old_owner->owned_locks();
419
420 // remove "this" from the owned locks list
421
422 Monitor *prev = NULL;
423 bool found = false;
424 for (; locks != NULL; prev = locks, locks = locks->next()) {
425 if (locks == this) {
426 found = true;
427 break;
428 }
429 }
430 assert(found, "Removing a lock not owned");
431 if (prev == NULL) {
432 old_owner->_owned_locks = _next;
433 } else {
434 prev->_next = _next;
435 }
436 _next = NULL;
437 #endif
438 }
439 }
440
441
442 // Factored out common sanity checks for locking mutex'es. Used by lock() and try_lock()
443 void Monitor::check_prelock_state(Thread *thread, bool safepoint_check) {
444 if (safepoint_check) {
445 assert((!thread->is_active_Java_thread() || ((JavaThread *)thread)->thread_state() == _thread_in_vm)
446 || rank() == Mutex::special, "wrong thread state for using locks");
447 if (thread->is_VM_thread() && !allow_vm_block()) {
448 fatal("VM thread using lock %s (not allowed to block on)", name());
449 }
450 DEBUG_ONLY(if (rank() != Mutex::special) \
451 thread->check_for_valid_safepoint_state(false);)
452 }
453 assert(!os::ThreadCrashProtection::is_crash_protected(thread),
454 "locking not allowed when crash protection is set");
455 }
456
457 void Monitor::check_block_state(Thread *thread) {
458 if (!_allow_vm_block && thread->is_VM_thread()) {
459 warning("VM thread blocked on lock");
460 print();
461 BREAKPOINT;
462 }
463 assert(_owner != thread, "deadlock: blocking on monitor owned by current thread");
464 }
465
466 #endif // PRODUCT
|
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 "logging/log.hpp"
27 #include "runtime/interfaceSupport.inline.hpp"
28 #include "runtime/mutex.hpp"
29 #include "runtime/osThread.hpp"
30 #include "runtime/safepointMechanism.inline.hpp"
31 #include "runtime/thread.inline.hpp"
32 #include "utilities/events.hpp"
33 #include "utilities/macros.hpp"
34
35 #ifdef ASSERT
36 void Mutex::check_safepoint_state(Thread* thread, bool do_safepoint_check) {
37 // If the JavaThread checks for safepoint, verify that the lock wasn't created with safepoint_check_never.
38 SafepointCheckRequired not_allowed = do_safepoint_check ? Mutex::_safepoint_check_never :
39 Mutex::_safepoint_check_always;
40 assert(!thread->is_active_Java_thread() || _safepoint_check_required != not_allowed,
41 "This lock should %s have a safepoint check for Java threads: %s",
42 _safepoint_check_required ? "always" : "never", name());
43
44 // If defined with safepoint_check_never, a NonJavaThread should never ask to safepoint check either.
45 assert(thread->is_Java_thread() || !do_safepoint_check || _safepoint_check_required != Mutex::_safepoint_check_never,
46 "NonJavaThread should not check for safepoint");
47 }
48 #endif // ASSERT
49
50 void Mutex::lock(Thread * self) {
51 check_safepoint_state(self, true);
52
53 DEBUG_ONLY(check_prelock_state(self, true));
54 assert(_owner != self, "invariant");
55
56 Mutex* in_flight_monitor = NULL;
57 DEBUG_ONLY(int retry_cnt = 0;)
58 bool is_active_Java_thread = self->is_active_Java_thread();
59 while (!_lock.try_lock()) {
60 // The lock is contended
61
62 #ifdef ASSERT
63 check_block_state(self);
64 if (retry_cnt++ > 3) {
65 log_trace(vmmonitor)("JavaThread " INTPTR_FORMAT " on %d attempt trying to acquire vmmonitor %s", p2i(self), retry_cnt, _name);
66 }
67 #endif // ASSERT
68
69 // Is it a JavaThread participating in the safepoint protocol.
70 if (is_active_Java_thread) {
71 assert(rank() > Mutex::special, "Potential deadlock with special or lesser rank mutex");
72 { ThreadBlockInVMWithDeadlockCheck tbivmdc((JavaThread *) self, &in_flight_monitor);
73 in_flight_monitor = this; // save for ~ThreadBlockInVMWithDeadlockCheck
74 _lock.lock();
75 }
76 if (in_flight_monitor != NULL) {
77 // Not unlocked by ~ThreadBlockInVMWithDeadlockCheck
78 break;
79 }
80 } else {
81 _lock.lock();
82 break;
83 }
84 }
85
86 assert_owner(NULL);
87 set_owner(self);
88 }
89
90 void Mutex::lock() {
91 this->lock(Thread::current());
92 }
93
94 // Lock without safepoint check - a degenerate variant of lock() for use by
95 // JavaThreads when it is known to be safe to not check for a safepoint when
96 // acquiring this lock. If the thread blocks acquiring the lock it is not
97 // safepoint-safe and so will prevent a safepoint from being reached. If used
98 // in the wrong way this can lead to a deadlock with the safepoint code.
99
100 void Mutex::lock_without_safepoint_check(Thread * self) {
101 check_safepoint_state(self, false);
102 assert(_owner != self, "invariant");
103 _lock.lock();
104 assert_owner(NULL);
105 set_owner(self);
106 }
107
108 void Mutex::lock_without_safepoint_check() {
109 lock_without_safepoint_check(Thread::current());
110 }
111
112
113 // Returns true if thread succeeds in grabbing the lock, otherwise false.
114
115 bool Mutex::try_lock() {
116 Thread * const self = Thread::current();
117 DEBUG_ONLY(check_prelock_state(self, false);)
118
119 if (_lock.try_lock()) {
120 assert_owner(NULL);
121 set_owner(self);
122 return true;
123 }
124 return false;
125 }
126
127 void Mutex::release_for_safepoint() {
128 assert_owner(NULL);
129 _lock.unlock();
130 }
131
132 void Mutex::unlock() {
133 assert_owner(Thread::current());
134 set_owner(NULL);
135 _lock.unlock();
136 }
137
138 void Monitor::notify() {
139 assert_owner(Thread::current());
140 _lock.notify();
141 }
142
143 void Monitor::notify_all() {
144 assert_owner(Thread::current());
145 _lock.notify_all();
146 }
147
148 #ifdef ASSERT
149 void Monitor::assert_wait_lock_state(Thread* self) {
150 Mutex* least = get_least_ranked_lock_besides_this(self->owned_locks());
151 assert(least != this, "Specification of get_least_... call above");
152 if (least != NULL && least->rank() <= special) {
153 ::tty->print("Attempting to wait on monitor %s/%d while holding"
154 " lock %s/%d -- possible deadlock",
155 name(), rank(), least->name(), least->rank());
156 assert(false, "Shouldn't block(wait) while holding a lock of rank special");
157 }
158 }
159 #endif // ASSERT
160
161 bool Monitor::wait_without_safepoint_check(long timeout) {
162 Thread* const self = Thread::current();
163 check_safepoint_state(self, false);
164
165 // timeout is in milliseconds - with zero meaning never timeout
166 assert(timeout >= 0, "negative timeout");
167
168 assert_owner(self);
169 assert_wait_lock_state(self);
170
177 }
178
179 bool Monitor::wait(long timeout, bool as_suspend_equivalent) {
180 Thread* const self = Thread::current();
181 check_safepoint_state(self, true);
182
183 // timeout is in milliseconds - with zero meaning never timeout
184 assert(timeout >= 0, "negative timeout");
185
186 assert_owner(self);
187
188 // Safepoint checking logically implies an active JavaThread.
189 guarantee(self->is_active_Java_thread(), "invariant");
190 assert_wait_lock_state(self);
191
192 int wait_status;
193 // conceptually set the owner to NULL in anticipation of
194 // abdicating the lock in wait
195 set_owner(NULL);
196 JavaThread *jt = (JavaThread *)self;
197 Mutex* in_flight_monitor = NULL;
198
199 {
200 ThreadBlockInVMWithDeadlockCheck tbivmdc(jt, &in_flight_monitor);
201 OSThreadWaitState osts(self->osthread(), false /* not Object.wait() */);
202 if (as_suspend_equivalent) {
203 jt->set_suspend_equivalent();
204 // cleared by handle_special_suspend_equivalent_condition() or
205 // java_suspend_self()
206 }
207
208 wait_status = _lock.wait(timeout);
209 in_flight_monitor = this; // save for ~ThreadBlockInVMWithDeadlockCheck
210
211 // were we externally suspended while we were waiting?
212 if (as_suspend_equivalent && jt->handle_special_suspend_equivalent_condition()) {
213 // Our event wait has finished and we own the lock, but
214 // while we were waiting another thread suspended us. We don't
215 // want to hold the lock while suspended because that
216 // would surprise the thread that suspended us.
217 _lock.unlock();
218 jt->java_suspend_self();
219 _lock.lock();
220 }
221 }
222
223 if (in_flight_monitor != NULL) {
224 // Not unlocked by ~ThreadBlockInVMWithDeadlockCheck
225 assert_owner(NULL);
226 // Conceptually reestablish ownership of the lock.
227 set_owner(self);
228 } else {
229 lock(self);
230 }
231
232 return wait_status != 0; // return true IFF timeout
233 }
234
235 Mutex::~Mutex() {
236 assert_owner(NULL);
237 }
238
239 // Only Threads_lock, Heap_lock and SR_lock may be safepoint_check_sometimes.
240 bool is_sometimes_ok(const char* name) {
241 return (strcmp(name, "Threads_lock") == 0 || strcmp(name, "Heap_lock") == 0 || strcmp(name, "SR_lock") == 0);
242 }
243
244 Mutex::Mutex(int Rank, const char * name, bool allow_vm_block,
245 SafepointCheckRequired safepoint_check_required) : _owner(NULL) {
246 assert(os::mutex_init_done(), "Too early!");
247 if (name == NULL) {
248 strcpy(_name, "UNKNOWN");
249 } else {
250 strncpy(_name, name, MONITOR_NAME_LEN - 1);
251 _name[MONITOR_NAME_LEN - 1] = '\0';
252 }
253 #ifdef ASSERT
254 _allow_vm_block = allow_vm_block;
255 _rank = Rank;
256 _safepoint_check_required = safepoint_check_required;
257
258 assert(_safepoint_check_required != Mutex::_safepoint_check_sometimes || is_sometimes_ok(name),
259 "Lock has _safepoint_check_sometimes %s", name);
260 #endif
261 }
262
263 Monitor::Monitor(int Rank, const char * name, bool allow_vm_block,
264 SafepointCheckRequired safepoint_check_required) :
265 Mutex(Rank, name, allow_vm_block, safepoint_check_required) {}
266
267 bool Mutex::owned_by_self() const {
268 return _owner == Thread::current();
269 }
270
271 void Mutex::print_on_error(outputStream* st) const {
272 st->print("[" PTR_FORMAT, p2i(this));
273 st->print("] %s", _name);
274 st->print(" - owner thread: " PTR_FORMAT, p2i(_owner));
275 }
276
277 // ----------------------------------------------------------------------------------
278 // Non-product code
279
280 #ifndef PRODUCT
281 void Mutex::print_on(outputStream* st) const {
282 st->print_cr("Mutex: [" PTR_FORMAT "] %s - owner: " PTR_FORMAT,
283 p2i(this), _name, p2i(_owner));
284 }
285 #endif
286
287 #ifndef PRODUCT
288 #ifdef ASSERT
289
290 void Mutex::assert_owner(Thread * expected) {
291 const char* msg = "invalid owner";
292 if (expected == NULL) {
293 msg = "should be un-owned";
294 }
295 else if (expected == Thread::current()) {
296 msg = "should be owned by current thread";
297 }
298 assert(_owner == expected,
299 "%s: owner=" INTPTR_FORMAT ", should be=" INTPTR_FORMAT,
300 msg, p2i(_owner), p2i(expected));
301 }
302
303 Mutex* Mutex::get_least_ranked_lock(Mutex* locks) {
304 Mutex *res, *tmp;
305 for (res = tmp = locks; tmp != NULL; tmp = tmp->next()) {
306 if (tmp->rank() < res->rank()) {
307 res = tmp;
308 }
309 }
310 if (!SafepointSynchronize::is_at_safepoint()) {
311 // In this case, we expect the held locks to be
312 // in increasing rank order (modulo any native ranks)
313 for (tmp = locks; tmp != NULL; tmp = tmp->next()) {
314 if (tmp->next() != NULL) {
315 assert(tmp->rank() == Mutex::native ||
316 tmp->rank() <= tmp->next()->rank(), "mutex rank anomaly?");
317 }
318 }
319 }
320 return res;
321 }
322
323 Mutex* Mutex::get_least_ranked_lock_besides_this(Mutex* locks) {
324 Mutex *res, *tmp;
325 for (res = NULL, tmp = locks; tmp != NULL; tmp = tmp->next()) {
326 if (tmp != this && (res == NULL || tmp->rank() < res->rank())) {
327 res = tmp;
328 }
329 }
330 if (!SafepointSynchronize::is_at_safepoint()) {
331 // In this case, we expect the held locks to be
332 // in increasing rank order (modulo any native ranks)
333 for (tmp = locks; tmp != NULL; tmp = tmp->next()) {
334 if (tmp->next() != NULL) {
335 assert(tmp->rank() == Mutex::native ||
336 tmp->rank() <= tmp->next()->rank(), "mutex rank anomaly?");
337 }
338 }
339 }
340 return res;
341 }
342
343
344 bool Mutex::contains(Mutex* locks, Mutex* lock) {
345 for (; locks != NULL; locks = locks->next()) {
346 if (locks == lock) {
347 return true;
348 }
349 }
350 return false;
351 }
352 #endif
353
354 // Called immediately after lock acquisition or release as a diagnostic
355 // to track the lock-set of the thread and test for rank violations that
356 // might indicate exposure to deadlock.
357 // Rather like an EventListener for _owner (:>).
358
359 void Mutex::set_owner_implementation(Thread *new_owner) {
360 // This function is solely responsible for maintaining
361 // and checking the invariant that threads and locks
362 // are in a 1/N relation, with some some locks unowned.
363 // It uses the Mutex::_owner, Mutex::_next, and
364 // Thread::_owned_locks fields, and no other function
365 // changes those fields.
366 // It is illegal to set the mutex from one non-NULL
367 // owner to another--it must be owned by NULL as an
368 // intermediate state.
369
370 if (new_owner != NULL) {
371 // the thread is acquiring this lock
372
373 assert(new_owner == Thread::current(), "Should I be doing this?");
374 assert(_owner == NULL, "setting the owner thread of an already owned mutex");
375 _owner = new_owner; // set the owner
376
377 // link "this" into the owned locks list
378
379 #ifdef ASSERT // Thread::_owned_locks is under the same ifdef
380 Mutex* locks = get_least_ranked_lock(new_owner->owned_locks());
381 // Mutex::set_owner_implementation is a friend of Thread
382
383 assert(this->rank() >= 0, "bad lock rank");
384
385 // Deadlock avoidance rules require us to acquire Mutexes only in
386 // a global total order. For example m1 is the lowest ranked mutex
387 // that the thread holds and m2 is the mutex the thread is trying
388 // to acquire, then deadlock avoidance rules require that the rank
389 // of m2 be less than the rank of m1.
390 // The rank Mutex::native is an exception in that it is not subject
391 // to the verification rules.
392 if (this->rank() != Mutex::native &&
393 this->rank() != Mutex::suspend_resume &&
394 locks != NULL && locks->rank() <= this->rank() &&
395 !SafepointSynchronize::is_at_safepoint()) {
396 new_owner->print_owned_locks();
397 fatal("acquiring lock %s/%d out of order with lock %s/%d -- "
398 "possible deadlock", this->name(), this->rank(),
399 locks->name(), locks->rank());
400 }
401
402 this->_next = new_owner->_owned_locks;
403 new_owner->_owned_locks = this;
404 #endif
405
406 } else {
407 // the thread is releasing this lock
408
409 Thread* old_owner = _owner;
410 DEBUG_ONLY(_last_owner = old_owner;)
411
412 assert(old_owner != NULL, "removing the owner thread of an unowned mutex");
413 assert(old_owner == Thread::current(), "removing the owner thread of an unowned mutex");
414
415 _owner = NULL; // set the owner
416
417 #ifdef ASSERT
418 Mutex* locks = old_owner->owned_locks();
419
420 // remove "this" from the owned locks list
421
422 Mutex* prev = NULL;
423 bool found = false;
424 for (; locks != NULL; prev = locks, locks = locks->next()) {
425 if (locks == this) {
426 found = true;
427 break;
428 }
429 }
430 assert(found, "Removing a lock not owned");
431 if (prev == NULL) {
432 old_owner->_owned_locks = _next;
433 } else {
434 prev->_next = _next;
435 }
436 _next = NULL;
437 #endif
438 }
439 }
440
441
442 // Factored out common sanity checks for locking mutex'es. Used by lock() and try_lock()
443 void Mutex::check_prelock_state(Thread *thread, bool safepoint_check) {
444 if (safepoint_check) {
445 assert((!thread->is_active_Java_thread() || ((JavaThread *)thread)->thread_state() == _thread_in_vm)
446 || rank() == Mutex::special, "wrong thread state for using locks");
447 if (thread->is_VM_thread() && !allow_vm_block()) {
448 fatal("VM thread using lock %s (not allowed to block on)", name());
449 }
450 DEBUG_ONLY(if (rank() != Mutex::special) \
451 thread->check_for_valid_safepoint_state(false);)
452 }
453 assert(!os::ThreadCrashProtection::is_crash_protected(thread),
454 "locking not allowed when crash protection is set");
455 }
456
457 void Mutex::check_block_state(Thread *thread) {
458 if (!_allow_vm_block && thread->is_VM_thread()) {
459 warning("VM thread blocked on lock");
460 print();
461 BREAKPOINT;
462 }
463 assert(_owner != thread, "deadlock: blocking on monitor owned by current thread");
464 }
465
466 #endif // PRODUCT
|