1 /** 2 * \file 3 * Monitor locking functions 4 * 5 * Author: 6 * Dick Porter (dick@ximian.com) 7 * 8 * (C) 2003 Ximian, Inc 9 */ 10 11 #ifndef _MONO_METADATA_MONITOR_H_ 12 #define _MONO_METADATA_MONITOR_H_ 13 14 #include <glib.h> 15 #include <mono/metadata/object.h> 16 #include <mono/utils/mono-compiler.h> 17 #include <mono/utils/mono-coop-semaphore.h> 18 19 G_BEGIN_DECLS 20 21 #define OWNER_MASK 0x0000ffff 22 #define ENTRY_COUNT_MASK 0xffff0000 23 #define ENTRY_COUNT_WAITERS 0x80000000 24 #define ENTRY_COUNT_ZERO 0x7fff0000 25 #define ENTRY_COUNT_SHIFT 16 26 27 struct _MonoThreadsSync 28 { 29 /* 30 * The entry count field can be negative, which would mean that the entry_sem is 31 * signaled and nobody is waiting to acquire it. This can happen when the thread 32 * that was waiting is either interrupted or timeouts, and the owner releases 33 * the lock before the forementioned thread updates the entry count. 34 * 35 * The 0 entry_count value is encoded as ENTRY_COUNT_ZERO, positive numbers being 36 * greater than it and negative numbers smaller than it. 37 */ 38 guint32 status; /* entry_count (16) | owner_id (16) */ 39 guint32 nest; 40 #ifdef HAVE_MOVING_COLLECTOR 41 gint32 hash_code; 42 #endif 43 GSList *wait_list; 44 void *data; 45 MonoCoopSem *entry_sem; 46 }; 47 48 /* 49 * Lock word format: 50 * 51 * The least significant bit stores whether a hash for the object is computed 52 * which is stored either in the lock word or in the MonoThreadsSync structure 53 * that the lock word points to. 54 * 55 * The second bit stores whether the lock word is inflated, containing an 56 * address to the MonoThreadsSync structure. 57 * 58 * If both bits are 0, either the lock word is free (entire lock word is 0) 59 * or it is a thin/flat lock. 60 * 61 * 32-bit 62 * LOCK_WORD_FLAT: [owner:22 | nest:8 | status:2] 63 * LOCK_WORD_THIN_HASH: [hash:30 | status:2] 64 * LOCK_WORD_INFLATED: [sync:30 | status:2] 65 * LOCK_WORD_FAT_HASH: [sync:30 | status:2] 66 * 67 * 64-bit 68 * LOCK_WORD_FLAT: [unused:22 | owner:32 | nest:8 | status:2] 69 * LOCK_WORD_THIN_HASH: [hash:62 | status:2] 70 * LOCK_WORD_INFLATED: [sync:62 | status:2] 71 * LOCK_WORD_FAT_HASH: [sync:62 | status:2] 72 * 73 * In order to save processing time and to have one additional value, the nest 74 * count starts from 0 for the lock word (just valid thread ID in the lock word 75 * means that the thread holds the lock once, although nest is 0). 76 * FIXME Have the same convention on inflated locks 77 */ 78 79 typedef union { 80 #if SIZEOF_REGISTER == 8 81 guint64 lock_word; 82 #elif SIZEOF_REGISTER == 4 83 guint32 lock_word; 84 #endif 85 MonoThreadsSync *sync; 86 } LockWord; 87 88 89 enum { 90 LOCK_WORD_FLAT = 0, 91 LOCK_WORD_HAS_HASH = 1, 92 LOCK_WORD_INFLATED = 2, 93 94 LOCK_WORD_STATUS_BITS = 2, 95 LOCK_WORD_NEST_BITS = 8, 96 97 LOCK_WORD_STATUS_MASK = (1 << LOCK_WORD_STATUS_BITS) - 1, 98 LOCK_WORD_NEST_MASK = ((1 << LOCK_WORD_NEST_BITS) - 1) << LOCK_WORD_STATUS_BITS, 99 100 LOCK_WORD_HASH_SHIFT = LOCK_WORD_STATUS_BITS, 101 LOCK_WORD_NEST_SHIFT = LOCK_WORD_STATUS_BITS, 102 LOCK_WORD_OWNER_SHIFT = LOCK_WORD_STATUS_BITS + LOCK_WORD_NEST_BITS 103 }; 104 105 MONO_API void mono_locks_dump (gboolean include_untaken); 106 107 void mono_monitor_init (void); 108 void mono_monitor_cleanup (void); 109 110 MonoBoolean mono_monitor_enter_internal (MonoObject *obj); 111 void mono_monitor_enter_v4_internal (MonoObject *obj, MonoBoolean *lock_taken); 112 113 guint32 mono_monitor_enter_fast (MonoObject *obj); 114 guint32 mono_monitor_enter_v4_fast (MonoObject *obj, MonoBoolean *lock_taken); 115 116 guint32 mono_monitor_get_object_monitor_gchandle (MonoObject *object); 117 118 void mono_monitor_threads_sync_members_offset (int *status_offset, int *nest_offset); 119 #define MONO_THREADS_SYNC_MEMBER_OFFSET(o) ((o)>>8) 120 #define MONO_THREADS_SYNC_MEMBER_SIZE(o) ((o)&0xff) 121 122 extern MonoBoolean ves_icall_System_Threading_Monitor_Monitor_test_owner(MonoObject *obj); 123 extern MonoBoolean ves_icall_System_Threading_Monitor_Monitor_test_synchronised(MonoObject *obj); 124 extern void ves_icall_System_Threading_Monitor_Monitor_pulse(MonoObject *obj); 125 extern void ves_icall_System_Threading_Monitor_Monitor_pulse_all(MonoObject *obj); 126 extern MonoBoolean ves_icall_System_Threading_Monitor_Monitor_wait(MonoObject *obj, guint32 ms); 127 extern void ves_icall_System_Threading_Monitor_Monitor_try_enter_with_atomic_var (MonoObject *obj, guint32 ms, MonoBoolean *lockTaken); 128 extern void ves_icall_System_Threading_Monitor_Monitor_Enter (MonoObject *obj); 129 G_END_DECLS 130 131 #endif /* _MONO_METADATA_MONITOR_H_ */ 132