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