1/*
2 * Copyright (c) 2002, 2015, 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 "gc/cms/cmsLockVerifier.hpp"
27#include "gc/cms/concurrentMarkSweepThread.hpp"
28#include "memory/universe.hpp"
29#include "runtime/vmThread.hpp"
30
31///////////// Locking verification specific to CMS //////////////
32// Much like "assert_lock_strong()", except that it relaxes the
33// assertion somewhat for the parallel GC case, where VM thread
34// or the CMS thread might hold the lock on behalf of the parallel
35// threads. The second argument is in support of an extra locking
36// check for CFL spaces' free list locks.
37#ifndef PRODUCT
38void CMSLockVerifier::assert_locked(const Mutex* lock,
39 const Mutex* p_lock1,
40 const Mutex* p_lock2) {
41 if (!Universe::is_fully_initialized()) {
42 return;
43 }
44
45 Thread* myThread = Thread::current();
46
47 if (lock == NULL) { // a "lock-free" structure, e.g. MUT, protected by CMS token
48 assert(p_lock1 == NULL && p_lock2 == NULL, "Unexpected caller error");
49 if (myThread->is_ConcurrentGC_thread()) {
50 // This test might have to change in the future, if there can be
51 // multiple peer CMS threads. But for now, if we're testing the CMS
52 assert(myThread == ConcurrentMarkSweepThread::cmst(),
53 "In CMS, CMS thread is the only Conc GC thread.");
54 assert(ConcurrentMarkSweepThread::cms_thread_has_cms_token(),
55 "CMS thread should have CMS token");
56 } else if (myThread->is_VM_thread()) {
57 assert(ConcurrentMarkSweepThread::vm_thread_has_cms_token(),
58 "VM thread should have CMS token");
59 } else {
60 // Token should be held on our behalf by one of the other
61 // of CMS or VM thread; not enough easily testable
62 // state info to test which here.
63 assert(myThread->is_GC_task_thread(), "Unexpected thread type");
64 }
65 return;
66 }
67
68 if (myThread->is_VM_thread()
69 || myThread->is_ConcurrentGC_thread()
70 || myThread->is_Java_thread()) {
71 // Make sure that we are holding the associated lock.
72 assert_lock_strong(lock);
73 // The checking of p_lock is a spl case for CFLS' free list
74 // locks: we make sure that none of the parallel GC work gang
75 // threads are holding "sub-locks" of freeListLock(). We check only
76 // the parDictionaryAllocLock because the others are too numerous.
77 // This spl case code is somewhat ugly and any improvements
78 // are welcome.
79 assert(p_lock1 == NULL || !p_lock1->is_locked() || p_lock1->owned_by_self(),
80 "Possible race between this and parallel GC threads");
81 assert(p_lock2 == NULL || !p_lock2->is_locked() || p_lock2->owned_by_self(),
82 "Possible race between this and parallel GC threads");
83 } else if (myThread->is_GC_task_thread()) {
84 // Make sure that the VM or CMS thread holds lock on our behalf
85 // XXX If there were a concept of a gang_master for a (set of)
86 // gang_workers, we could have used the identity of that thread
87 // for checking ownership here; for now we just disjunct.
88 assert(lock->owner() == VMThread::vm_thread() ||
89 lock->owner() == ConcurrentMarkSweepThread::cmst(),
90 "Should be locked by VM thread or CMS thread on my behalf");
91 if (p_lock1 != NULL) {
92 assert_lock_strong(p_lock1);
93 }
94 if (p_lock2 != NULL) {
95 assert_lock_strong(p_lock2);
96 }
97 } else {
98 // Make sure we didn't miss some other thread type calling into here;
99 // perhaps as a result of future VM evolution.
100 ShouldNotReachHere();
101 }
102}
103#endif
104