2 * handle.c: Handle to object in native code
5 * - Ludovic Henry <ludovic@xamarin.com>
6 * - Aleksey Klieger <aleksey.klieger@xamarin.com>
7 * - Rodrigo Kumpera <kumpera@xamarin.com>
9 * Copyright 2016 Dot net foundation.
10 * Licensed under the MIT license. See LICENSE file in the project root for full license information.
16 #include <mono/metadata/handle.h>
17 #include <mono/metadata/object-internals.h>
18 #include <mono/metadata/gc-internals.h>
19 #include <mono/utils/atomic.h>
20 #include <mono/utils/mono-lazy-init.h>
21 #include <mono/utils/mono-threads.h>
22 /* TODO (missing pieces)
27 mix/max/avg size of stack marks
30 Actually do something in mono_handle_verify
32 Shrink the handles stack in mono_handle_stack_scan
33 Properly report it to the profiler.
34 Add a boehm implementation
36 TODO (things to explore):
38 There's no convenient way to wrap the object allocation function.
40 MonoCultureInfoHandle culture = MONO_HANDLE_NEW (MonoCultureInfo, mono_object_new_checked (domain, klass, &error));
42 Maybe what we need is a round of cleanup around all exposed types in the runtime to unify all helpers under the same hoof.
43 Combine: MonoDefaults, GENERATE_GET_CLASS_WITH_CACHE, TYPED_HANDLE_DECL and friends.
44 This would solve the age old issue of making it clear which types are optional and tell that to the linker.
45 We could then generate neat type safe wrappers.
51 * If we are running with cooperative GC, all the handle stack
52 * manipulation will complete before a GC thread scans the handle
53 * stack. If we are using async suspend, however, a thread may be
54 * trying to allocate a new handle, or unwind the handle stack when
55 * the GC stops the world.
57 * In particular, we need to ensure that if the mutator thread is
58 * suspended while manipulating the handle stack, the stack is in a
59 * good enough state to be scanned. In particular, the size of each
60 * chunk should be updated before an object is written into the
61 * handle, and chunks to be scanned (between bottom and top) should
64 * Note that the handle stack is scanned PRECISELY (see
65 * sgen_client_scan_thread_data ()). That means there should not be
66 * stale objects scanned. So when we manipulate the size of a chunk,
67 * wemust ensure that the newly scannable slot is either null or
68 * points to a valid value.
71 const MonoObjectHandle mono_null_value_handle = NULL;
73 #define THIS_IS_AN_OK_NUMBER_OF_HANDLES 100
76 chunk_element_objslot (HandleChunk *chunk, int idx)
78 return &chunk->objects[idx].o;
81 #ifdef MONO_HANDLE_TRACK_OWNER
82 #define SET_OWNER(chunk,idx) do { (chunk)->objects[(idx)].owner = owner; } while (0)
84 #define SET_OWNER(chunk,idx) do { } while (0)
87 /* Actual handles implementation */
89 #ifndef MONO_HANDLE_TRACK_OWNER
90 mono_handle_new (MonoObject *object)
92 mono_handle_new (MonoObject *object, const char *owner)
95 MonoThreadInfo *info = mono_thread_info_current ();
96 HandleStack *handles = (HandleStack *)info->handle_stack;
97 HandleChunk *top = handles->top;
100 if (G_LIKELY (top->size < OBJECTS_PER_HANDLES_CHUNK)) {
102 MonoObject** objslot = chunk_element_objslot (top, idx);
103 /* can be interrupted anywhere here, so:
104 * 1. make sure the new slot is null
105 * 2. make the new slot scannable (increment size)
106 * 3. put a valid object in there
108 * (have to do 1 then 3 so that if we're interrupted
109 * between 1 and 2, the object is still live)
112 mono_memory_write_barrier ();
114 mono_memory_write_barrier ();
119 if (G_LIKELY (top->next)) {
121 /* make sure size == 0 is visible to a GC thread before it sees the new top */
122 mono_memory_write_barrier ();
127 HandleChunk *new_chunk = g_new (HandleChunk, 1);
129 new_chunk->prev = top;
130 new_chunk->next = NULL;
131 /* make sure size == 0 before new chunk is visible */
132 mono_memory_write_barrier ();
133 top->next = new_chunk;
134 handles->top = new_chunk;
141 mono_handle_stack_alloc (void)
143 HandleStack *stack = g_new (HandleStack, 1);
144 HandleChunk *chunk = g_new (HandleChunk, 1);
147 chunk->prev = chunk->next = NULL;
148 mono_memory_write_barrier ();
149 stack->top = stack->bottom = chunk;
154 mono_handle_stack_free (HandleStack *stack)
158 HandleChunk *c = stack->bottom;
159 stack->top = stack->bottom = NULL;
160 mono_memory_write_barrier ();
162 HandleChunk *next = c->next;
171 mono_handle_stack_scan (HandleStack *stack, GcScanFunc func, gpointer gc_data)
173 /* if we're running, we know the world is stopped.
175 HandleChunk *cur = stack->bottom;
176 HandleChunk *last = stack->top;
183 for (i = 0; i < cur->size; ++i) {
184 MonoObject **obj_slot = chunk_element_objslot (cur, i);
185 if (*obj_slot != NULL)
186 func ((gpointer*)obj_slot, gc_data);
195 mono_stack_mark_record_size (MonoThreadInfo *info, HandleStackMark *stackmark, const char *func_name)
197 HandleStack *handles = (HandleStack *)info->handle_stack;
198 HandleChunk *cur = stackmark->chunk;
199 int size = -stackmark->size; //discard the starting point of the stack
202 if (cur == handles->top)
207 if (size > THIS_IS_AN_OK_NUMBER_OF_HANDLES)
208 g_warning ("%s USED %d handles\n", func_name, size);
212 * Pop the stack until @stackmark and make @value the top value.
214 * @return the new handle for what @value points to
217 mono_stack_mark_pop_value (MonoThreadInfo *info, HandleStackMark *stackmark, MonoRawHandle value)
219 MonoObject *obj = value ? *((MonoObject**)value) : NULL;
220 mono_stack_mark_pop (info, stackmark);
221 #ifndef MONO_HANDLE_TRACK_OWNER
222 return mono_handle_new (obj);
224 return mono_handle_new (obj, "<mono_stack_mark_pop_value>");
228 /* Temporary place for some of the handle enabled wrapper functions*/
231 mono_string_new_handle (MonoDomain *domain, const char *data, MonoError *error)
233 return MONO_HANDLE_NEW (MonoString, mono_string_new_checked (domain, data, error));
237 mono_array_new_handle (MonoDomain *domain, MonoClass *eclass, uintptr_t n, MonoError *error)
239 return MONO_HANDLE_NEW (MonoArray, mono_array_new_checked (domain, eclass, n, error));
242 #ifdef ENABLE_CHECKED_BUILD
243 /* Checked build helpers */
245 mono_handle_verify (MonoRawHandle raw_handle)
252 mono_array_handle_length (MonoArrayHandle arr)
254 MONO_REQ_GC_UNSAFE_MODE;
256 return MONO_HANDLE_RAW (arr)->max_length;
260 mono_gchandle_from_handle (MonoObjectHandle handle, mono_bool pinned)
262 return mono_gchandle_new (MONO_HANDLE_RAW(handle), pinned);
266 mono_gchandle_get_target_handle (uint32_t gchandle)
268 return MONO_HANDLE_NEW (MonoObject, mono_gchandle_get_target (gchandle));
272 mono_array_handle_pin_with_size (MonoArrayHandle handle, int size, uintptr_t idx, uint32_t *gchandle)
274 g_assert (gchandle != NULL);
275 *gchandle = mono_gchandle_from_handle (MONO_HANDLE_CAST(MonoObject,handle), TRUE);
276 MonoArray *raw = MONO_HANDLE_RAW (handle);
277 return mono_array_addr_with_size (raw, size, idx);
281 mono_array_handle_memcpy_refs (MonoArrayHandle dest, uintptr_t dest_idx, MonoArrayHandle src, uintptr_t src_idx, uintptr_t len)
283 mono_array_memcpy_refs (MONO_HANDLE_RAW (dest), dest_idx, MONO_HANDLE_RAW (src), src_idx, len);
287 mono_handle_stack_is_empty (HandleStack *stack)
289 return (stack->top == stack->bottom && stack->top->size == 0);