1 // 2 // Copyright (c) 2013 The WebRTC project authors. All Rights Reserved. 3 // 4 // Use of this source code is governed by a BSD-style license 5 // that can be found in the LICENSE file in the root of the source 6 // tree. An additional intellectual property rights grant can be found 7 // in the file PATENTS. All contributing project authors may 8 // be found in the AUTHORS file in the root of the source tree. 9 // 10 // Borrowed from 11 // https://code.google.com/p/gperftools/source/browse/src/base/thread_annotations.h 12 // but adapted for clang attributes instead of the gcc. 13 // 14 // This header file contains the macro definitions for thread safety 15 // annotations that allow the developers to document the locking policies 16 // of their multi-threaded code. The annotations can also help program 17 // analysis tools to identify potential thread safety issues. 18 19 #ifndef BASE_THREAD_ANNOTATIONS_H_ 20 #define BASE_THREAD_ANNOTATIONS_H_ 21 22 #if defined(__clang__) && (!defined(SWIG)) 23 #define THREAD_ANNOTATION_ATTRIBUTE__(x) __attribute__((x)) 24 #else 25 #define THREAD_ANNOTATION_ATTRIBUTE__(x) // no-op 26 #endif 27 28 // Document if a shared variable/field needs to be protected by a lock. 29 // GUARDED_BY allows the user to specify a particular lock that should be 30 // held when accessing the annotated variable, while GUARDED_VAR only 31 // indicates a shared variable should be guarded (by any lock). GUARDED_VAR 32 // is primarily used when the client cannot express the name of the lock. 33 #define GUARDED_BY(x) THREAD_ANNOTATION_ATTRIBUTE__(guarded_by(x)) 34 #define GUARDED_VAR THREAD_ANNOTATION_ATTRIBUTE__(guarded) 35 36 // Document if the memory location pointed to by a pointer should be guarded 37 // by a lock when dereferencing the pointer. Similar to GUARDED_VAR, 38 // PT_GUARDED_VAR is primarily used when the client cannot express the name 39 // of the lock. Note that a pointer variable to a shared memory location 40 // could itself be a shared variable. For example, if a shared global pointer 41 // q, which is guarded by mu1, points to a shared memory location that is 42 // guarded by mu2, q should be annotated as follows: 43 // int *q GUARDED_BY(mu1) PT_GUARDED_BY(mu2); 44 #define PT_GUARDED_BY(x) THREAD_ANNOTATION_ATTRIBUTE__(point_to_guarded_by(x)) 45 #define PT_GUARDED_VAR THREAD_ANNOTATION_ATTRIBUTE__(point_to_guarded) 46 47 // Document the acquisition order between locks that can be held 48 // simultaneously by a thread. For any two locks that need to be annotated 49 // to establish an acquisition order, only one of them needs the annotation. 50 // (i.e. You don't have to annotate both locks with both ACQUIRED_AFTER 51 // and ACQUIRED_BEFORE.) 52 #define ACQUIRED_AFTER(x) THREAD_ANNOTATION_ATTRIBUTE__(acquired_after(x)) 53 #define ACQUIRED_BEFORE(x) THREAD_ANNOTATION_ATTRIBUTE__(acquired_before(x)) 54 55 // The following three annotations document the lock requirements for 56 // functions/methods. 57 58 // Document if a function expects certain locks to be held before it is called 59 #define EXCLUSIVE_LOCKS_REQUIRED(...) \ 60 THREAD_ANNOTATION_ATTRIBUTE__(exclusive_locks_required(__VA_ARGS__)) 61 62 #define SHARED_LOCKS_REQUIRED(...) \ 63 THREAD_ANNOTATION_ATTRIBUTE__(shared_locks_required(__VA_ARGS__)) 64 65 // Document the locks acquired in the body of the function. These locks 66 // cannot be held when calling this function (as google3's Mutex locks are 67 // non-reentrant). 68 #define LOCKS_EXCLUDED(x) THREAD_ANNOTATION_ATTRIBUTE__(locks_excluded(x)) 69 70 // Document the lock the annotated function returns without acquiring it. 71 #define LOCK_RETURNED(x) THREAD_ANNOTATION_ATTRIBUTE__(lock_returned(x)) 72 73 // Document if a class/type is a lockable type (such as the Mutex class). 74 #define LOCKABLE THREAD_ANNOTATION_ATTRIBUTE__(lockable) 75 76 // Document if a class is a scoped lockable type (such as the MutexLock class). 77 #define SCOPED_LOCKABLE THREAD_ANNOTATION_ATTRIBUTE__(scoped_lockable) 78 79 // The following annotations specify lock and unlock primitives. 80 #define EXCLUSIVE_LOCK_FUNCTION(...) \ 81 THREAD_ANNOTATION_ATTRIBUTE__(exclusive_lock_function(__VA_ARGS__)) 82 83 #define SHARED_LOCK_FUNCTION(...) \ 84 THREAD_ANNOTATION_ATTRIBUTE__(shared_lock_function(__VA_ARGS__)) 85 86 #define EXCLUSIVE_TRYLOCK_FUNCTION(...) \ 87 THREAD_ANNOTATION_ATTRIBUTE__(exclusive_trylock_function(__VA_ARGS__)) 88 89 #define SHARED_TRYLOCK_FUNCTION(...) \ 90 THREAD_ANNOTATION_ATTRIBUTE__(shared_trylock_function(__VA_ARGS__)) 91 92 #define UNLOCK_FUNCTION(...) \ 93 THREAD_ANNOTATION_ATTRIBUTE__(unlock_function(__VA_ARGS__)) 94 95 // An escape hatch for thread safety analysis to ignore the annotated function. 96 #define NO_THREAD_SAFETY_ANALYSIS \ 97 THREAD_ANNOTATION_ATTRIBUTE__(no_thread_safety_analysis) 98 99 #endif // BASE_THREAD_ANNOTATIONS_H_ 100
