2 * sgen-protocol.c: Binary protocol of internal activity, to aid
5 * Copyright 2001-2003 Ximian, Inc
6 * Copyright 2003-2010 Novell, Inc.
7 * Copyright (C) 2012 Xamarin Inc
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Library General Public
11 * License 2.0 as published by the Free Software Foundation;
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Library General Public License for more details.
18 * You should have received a copy of the GNU Library General Public
19 * License 2.0 along with this library; if not, write to the Free
20 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
27 #include "sgen-protocol.h"
28 #include "sgen-memory-governor.h"
29 #include "utils/mono-mmap.h"
30 #include "utils/mono-threads.h"
37 /* FIXME Implement binary protocol IO on systems that don't have unistd */
39 /* If valid, dump binary protocol to this file */
40 static int binary_protocol_file = -1;
42 /* We set this to -1 to indicate an exclusive lock */
43 static volatile int binary_protocol_use_count = 0;
45 #define BINARY_PROTOCOL_BUFFER_SIZE (65536 - 2 * 8)
47 typedef struct _BinaryProtocolBuffer BinaryProtocolBuffer;
48 struct _BinaryProtocolBuffer {
49 BinaryProtocolBuffer * volatile next;
51 unsigned char buffer [BINARY_PROTOCOL_BUFFER_SIZE];
54 static BinaryProtocolBuffer * volatile binary_protocol_buffers = NULL;
56 static char* filename_or_prefix = NULL;
57 static int current_file_index = 0;
58 static long long current_file_size = 0;
59 static long long file_size_limit;
62 filename_for_index (int index)
66 SGEN_ASSERT (0, file_size_limit > 0, "Indexed binary protocol filename must only be used with file size limit");
68 filename = sgen_alloc_internal_dynamic (strlen (filename_or_prefix) + 32, INTERNAL_MEM_BINARY_PROTOCOL, TRUE);
69 sprintf (filename, "%s.%d", filename_or_prefix, index);
75 free_filename (char *filename)
77 SGEN_ASSERT (0, file_size_limit > 0, "Indexed binary protocol filename must only be used with file size limit");
79 sgen_free_internal_dynamic (filename, strlen (filename_or_prefix) + 32, INTERNAL_MEM_BINARY_PROTOCOL);
83 binary_protocol_open_file (void)
87 if (file_size_limit > 0)
88 filename = filename_for_index (current_file_index);
90 filename = filename_or_prefix;
93 binary_protocol_file = open (filename, O_CREAT|O_WRONLY|O_TRUNC, 0644);
94 if (binary_protocol_file == -1 && errno != EINTR)
96 } while (binary_protocol_file == -1);
98 if (file_size_limit > 0)
99 free_filename (filename);
104 binary_protocol_init (const char *filename, long long limit)
107 filename_or_prefix = sgen_alloc_internal_dynamic (strlen (filename) + 1, INTERNAL_MEM_BINARY_PROTOCOL, TRUE);
108 strcpy (filename_or_prefix, filename);
110 file_size_limit = limit;
112 binary_protocol_open_file ();
117 binary_protocol_is_enabled (void)
120 return binary_protocol_file != -1;
129 close_binary_protocol_file (void)
131 while (close (binary_protocol_file) == -1 && errno == EINTR)
133 binary_protocol_file = -1;
137 try_lock_exclusive (void)
140 if (binary_protocol_use_count)
142 } while (InterlockedCompareExchange (&binary_protocol_use_count, -1, 0) != 0);
143 mono_memory_barrier ();
148 unlock_exclusive (void)
150 mono_memory_barrier ();
151 SGEN_ASSERT (0, binary_protocol_use_count == -1, "Exclusively locked count must be -1");
152 if (InterlockedCompareExchange (&binary_protocol_use_count, 0, -1) != -1)
153 SGEN_ASSERT (0, FALSE, "Somebody messed with the exclusive lock");
157 lock_recursive (void)
162 old_count = binary_protocol_use_count;
164 /* Exclusively locked - retry */
165 /* FIXME: short back-off */
168 } while (InterlockedCompareExchange (&binary_protocol_use_count, old_count + 1, old_count) != old_count);
169 mono_memory_barrier ();
173 unlock_recursive (void)
176 mono_memory_barrier ();
178 old_count = binary_protocol_use_count;
179 SGEN_ASSERT (0, old_count > 0, "Locked use count must be at least 1");
180 } while (InterlockedCompareExchange (&binary_protocol_use_count, old_count - 1, old_count) != old_count);
184 binary_protocol_flush_buffer (BinaryProtocolBuffer *buffer)
187 size_t to_write = buffer->index;
189 g_assert (buffer->index > 0);
191 while (written < to_write) {
192 ret = write (binary_protocol_file, buffer->buffer + written, to_write - written);
195 else if (errno == EINTR)
198 close_binary_protocol_file ();
201 current_file_size += buffer->index;
203 sgen_free_os_memory (buffer, sizeof (BinaryProtocolBuffer), SGEN_ALLOC_INTERNAL);
207 binary_protocol_check_file_overflow (void)
209 if (file_size_limit <= 0 || current_file_size < file_size_limit)
212 close_binary_protocol_file ();
214 if (current_file_index > 0) {
215 char *filename = filename_for_index (current_file_index - 1);
217 free_filename (filename);
220 ++current_file_index;
221 current_file_size = 0;
223 binary_protocol_open_file ();
228 binary_protocol_flush_buffers (gboolean force)
231 int num_buffers = 0, i;
232 BinaryProtocolBuffer *buf;
233 BinaryProtocolBuffer **bufs;
235 if (binary_protocol_file == -1)
238 if (!force && !try_lock_exclusive ())
241 for (buf = binary_protocol_buffers; buf != NULL; buf = buf->next)
243 bufs = sgen_alloc_internal_dynamic (num_buffers * sizeof (BinaryProtocolBuffer*), INTERNAL_MEM_BINARY_PROTOCOL, TRUE);
244 for (buf = binary_protocol_buffers, i = 0; buf != NULL; buf = buf->next, i++)
246 SGEN_ASSERT (0, i == num_buffers, "Binary protocol buffer count error");
248 binary_protocol_buffers = NULL;
250 for (i = num_buffers - 1; i >= 0; --i) {
251 binary_protocol_flush_buffer (bufs [i]);
252 binary_protocol_check_file_overflow ();
255 sgen_free_internal_dynamic (buf, num_buffers * sizeof (BinaryProtocolBuffer*), INTERNAL_MEM_BINARY_PROTOCOL);
263 static BinaryProtocolBuffer*
264 binary_protocol_get_buffer (int length)
266 BinaryProtocolBuffer *buffer, *new_buffer;
268 buffer = binary_protocol_buffers;
269 if (buffer && buffer->index + length <= BINARY_PROTOCOL_BUFFER_SIZE)
272 new_buffer = sgen_alloc_os_memory (sizeof (BinaryProtocolBuffer), SGEN_ALLOC_INTERNAL | SGEN_ALLOC_ACTIVATE, "debugging memory");
273 new_buffer->next = buffer;
274 new_buffer->index = 0;
276 if (InterlockedCompareExchangePointer ((void**)&binary_protocol_buffers, new_buffer, buffer) != buffer) {
277 sgen_free_os_memory (new_buffer, sizeof (BinaryProtocolBuffer), SGEN_ALLOC_INTERNAL);
286 protocol_entry (unsigned char type, gpointer data, int size)
290 BinaryProtocolBuffer *buffer;
292 if (binary_protocol_file == -1)
295 if (sgen_is_worker_thread (mono_native_thread_id_get ()))
301 buffer = binary_protocol_get_buffer (size + 1);
303 index = buffer->index;
304 if (index + 1 + size > BINARY_PROTOCOL_BUFFER_SIZE)
307 if (InterlockedCompareExchange (&buffer->index, index + 1 + size, index) != index)
308 goto retry_same_buffer;
310 /* FIXME: if we're interrupted at this point, we have a buffer
311 entry that contains random data. */
313 buffer->buffer [index++] = type;
314 memcpy (buffer->buffer + index, data, size);
317 g_assert (index <= BINARY_PROTOCOL_BUFFER_SIZE);
324 binary_protocol_collection_force (int generation)
326 SGenProtocolCollectionForce entry = { generation };
327 binary_protocol_flush_buffers (FALSE);
328 protocol_entry (SGEN_PROTOCOL_COLLECTION_FORCE, &entry, sizeof (SGenProtocolCollectionForce));
332 binary_protocol_collection_begin (int index, int generation)
334 SGenProtocolCollectionBegin entry = { index, generation };
335 binary_protocol_flush_buffers (FALSE);
336 protocol_entry (SGEN_PROTOCOL_COLLECTION_BEGIN, &entry, sizeof (SGenProtocolCollectionBegin));
340 binary_protocol_collection_end (int index, int generation, long long num_objects_scanned, long long num_unique_objects_scanned)
342 SGenProtocolCollectionEnd entry = { index, generation, num_objects_scanned, num_unique_objects_scanned };
343 binary_protocol_flush_buffers (FALSE);
344 protocol_entry (SGEN_PROTOCOL_COLLECTION_END, &entry, sizeof (SGenProtocolCollectionEnd));
348 binary_protocol_concurrent_start (void)
350 protocol_entry (SGEN_PROTOCOL_CONCURRENT_START, NULL, 0);
354 binary_protocol_concurrent_update (void)
356 protocol_entry (SGEN_PROTOCOL_CONCURRENT_UPDATE, NULL, 0);
360 binary_protocol_concurrent_finish (void)
362 protocol_entry (SGEN_PROTOCOL_CONCURRENT_FINISH, NULL, 0);
366 binary_protocol_world_stopping (long long timestamp)
368 SGenProtocolWorldStopping entry = { timestamp };
369 protocol_entry (SGEN_PROTOCOL_WORLD_STOPPING, &entry, sizeof (SGenProtocolWorldStopping));
373 binary_protocol_world_stopped (long long timestamp, long long total_major_cards,
374 long long marked_major_cards, long long total_los_cards, long long marked_los_cards)
376 SGenProtocolWorldStopped entry = { timestamp, total_major_cards, marked_major_cards, total_los_cards, marked_los_cards };
377 protocol_entry (SGEN_PROTOCOL_WORLD_STOPPED, &entry, sizeof (SGenProtocolWorldStopped));
381 binary_protocol_world_restarting (int generation, long long timestamp,
382 long long total_major_cards, long long marked_major_cards, long long total_los_cards, long long marked_los_cards)
384 SGenProtocolWorldRestarting entry = { generation, timestamp, total_major_cards, marked_major_cards, total_los_cards, marked_los_cards };
385 protocol_entry (SGEN_PROTOCOL_WORLD_RESTARTING, &entry, sizeof (SGenProtocolWorldRestarting));
389 binary_protocol_world_restarted (int generation, long long timestamp)
391 SGenProtocolWorldRestarted entry = { generation, timestamp };
392 protocol_entry (SGEN_PROTOCOL_WORLD_RESTARTED, &entry, sizeof (SGenProtocolWorldRestarted));
396 binary_protocol_thread_suspend (gpointer thread, gpointer stopped_ip)
398 SGenProtocolThreadSuspend entry = { thread, stopped_ip };
399 protocol_entry (SGEN_PROTOCOL_THREAD_SUSPEND, &entry, sizeof (SGenProtocolThreadSuspend));
403 binary_protocol_thread_restart (gpointer thread)
405 SGenProtocolThreadRestart entry = { thread };
406 protocol_entry (SGEN_PROTOCOL_THREAD_RESTART, &entry, sizeof (SGenProtocolThreadRestart));
410 binary_protocol_thread_register (gpointer thread)
412 SGenProtocolThreadRegister entry = { thread };
413 protocol_entry (SGEN_PROTOCOL_THREAD_REGISTER, &entry, sizeof (SGenProtocolThreadRegister));
418 binary_protocol_thread_unregister (gpointer thread)
420 SGenProtocolThreadUnregister entry = { thread };
421 protocol_entry (SGEN_PROTOCOL_THREAD_UNREGISTER, &entry, sizeof (SGenProtocolThreadUnregister));
426 binary_protocol_missing_remset (gpointer obj, gpointer obj_vtable, int offset, gpointer value, gpointer value_vtable, int value_pinned)
428 SGenProtocolMissingRemset entry = { obj, obj_vtable, offset, value, value_vtable, value_pinned };
429 protocol_entry (SGEN_PROTOCOL_MISSING_REMSET, &entry, sizeof (SGenProtocolMissingRemset));
434 binary_protocol_cement (gpointer obj, gpointer vtable, int size)
436 SGenProtocolCement entry = { obj, vtable, size };
437 protocol_entry (SGEN_PROTOCOL_CEMENT, &entry, sizeof (SGenProtocolCement));
441 binary_protocol_cement_reset (void)
443 protocol_entry (SGEN_PROTOCOL_CEMENT_RESET, NULL, 0);
447 binary_protocol_domain_unload_begin (gpointer domain)
449 SGenProtocolDomainUnload entry = { domain };
450 protocol_entry (SGEN_PROTOCOL_DOMAIN_UNLOAD_BEGIN, &entry, sizeof (SGenProtocolDomainUnload));
454 binary_protocol_domain_unload_end (gpointer domain)
456 SGenProtocolDomainUnload entry = { domain };
457 protocol_entry (SGEN_PROTOCOL_DOMAIN_UNLOAD_END, &entry, sizeof (SGenProtocolDomainUnload));
460 #ifdef SGEN_HEAVY_BINARY_PROTOCOL
462 binary_protocol_alloc (gpointer obj, gpointer vtable, int size)
464 SGenProtocolAlloc entry = { obj, vtable, size };
465 protocol_entry (SGEN_PROTOCOL_ALLOC, &entry, sizeof (SGenProtocolAlloc));
469 binary_protocol_alloc_pinned (gpointer obj, gpointer vtable, int size)
471 SGenProtocolAlloc entry = { obj, vtable, size };
472 protocol_entry (SGEN_PROTOCOL_ALLOC_PINNED, &entry, sizeof (SGenProtocolAlloc));
476 binary_protocol_alloc_degraded (gpointer obj, gpointer vtable, int size)
478 SGenProtocolAlloc entry = { obj, vtable, size };
479 protocol_entry (SGEN_PROTOCOL_ALLOC_DEGRADED, &entry, sizeof (SGenProtocolAlloc));
483 binary_protocol_copy (gpointer from, gpointer to, gpointer vtable, int size)
485 SGenProtocolCopy entry = { from, to, vtable, size };
486 protocol_entry (SGEN_PROTOCOL_COPY, &entry, sizeof (SGenProtocolCopy));
490 binary_protocol_pin_stage (gpointer addr_ptr, gpointer addr)
492 SGenProtocolPinStage entry = { addr_ptr, addr };
493 protocol_entry (SGEN_PROTOCOL_PIN_STAGE, &entry, sizeof (SGenProtocolPinStage));
497 binary_protocol_pin (gpointer obj, gpointer vtable, int size)
499 SGenProtocolPin entry = { obj, vtable, size };
500 protocol_entry (SGEN_PROTOCOL_PIN, &entry, sizeof (SGenProtocolPin));
504 binary_protocol_mark (gpointer obj, gpointer vtable, int size)
506 SGenProtocolMark entry = { obj, vtable, size };
507 protocol_entry (SGEN_PROTOCOL_MARK, &entry, sizeof (SGenProtocolMark));
511 binary_protocol_scan_begin (gpointer obj, gpointer vtable, int size)
513 SGenProtocolScanBegin entry = { obj, vtable, size };
514 protocol_entry (SGEN_PROTOCOL_SCAN_BEGIN, &entry, sizeof (SGenProtocolScanBegin));
518 binary_protocol_scan_vtype_begin (gpointer obj, int size)
520 SGenProtocolScanVTypeBegin entry = { obj, size };
521 protocol_entry (SGEN_PROTOCOL_SCAN_VTYPE_BEGIN, &entry, sizeof (SGenProtocolScanVTypeBegin));
525 binary_protocol_scan_process_reference (gpointer obj, gpointer ptr, gpointer value)
527 SGenProtocolScanProcessReference entry = { obj, ptr, value };
528 protocol_entry (SGEN_PROTOCOL_SCAN_PROCESS_REFERENCE, &entry, sizeof (SGenProtocolScanProcessReference));
532 binary_protocol_wbarrier (gpointer ptr, gpointer value, gpointer value_vtable)
534 SGenProtocolWBarrier entry = { ptr, value, value_vtable };
535 protocol_entry (SGEN_PROTOCOL_WBARRIER, &entry, sizeof (SGenProtocolWBarrier));
539 binary_protocol_global_remset (gpointer ptr, gpointer value, gpointer value_vtable)
541 SGenProtocolGlobalRemset entry = { ptr, value, value_vtable };
542 protocol_entry (SGEN_PROTOCOL_GLOBAL_REMSET, &entry, sizeof (SGenProtocolGlobalRemset));
546 binary_protocol_ptr_update (gpointer ptr, gpointer old_value, gpointer new_value, gpointer vtable, int size)
548 SGenProtocolPtrUpdate entry = { ptr, old_value, new_value, vtable, size };
549 protocol_entry (SGEN_PROTOCOL_PTR_UPDATE, &entry, sizeof (SGenProtocolPtrUpdate));
553 binary_protocol_cleanup (gpointer ptr, gpointer vtable, int size)
555 SGenProtocolCleanup entry = { ptr, vtable, size };
556 protocol_entry (SGEN_PROTOCOL_CLEANUP, &entry, sizeof (SGenProtocolCleanup));
560 binary_protocol_empty (gpointer start, int size)
562 SGenProtocolEmpty entry = { start, size };
563 protocol_entry (SGEN_PROTOCOL_EMPTY, &entry, sizeof (SGenProtocolEmpty));
567 binary_protocol_card_scan (gpointer start, int size)
569 SGenProtocolCardScan entry = { start, size };
570 protocol_entry (SGEN_PROTOCOL_CARD_SCAN, &entry, sizeof (SGenProtocolCardScan));
574 binary_protocol_dislink_update (gpointer link, gpointer obj, int track, int staged)
576 SGenProtocolDislinkUpdate entry = { link, obj, track, staged };
577 protocol_entry (SGEN_PROTOCOL_DISLINK_UPDATE, &entry, sizeof (SGenProtocolDislinkUpdate));
581 binary_protocol_dislink_update_staged (gpointer link, gpointer obj, int track, int index)
583 SGenProtocolDislinkUpdateStaged entry = { link, obj, track, index };
584 protocol_entry (SGEN_PROTOCOL_DISLINK_UPDATE_STAGED, &entry, sizeof (SGenProtocolDislinkUpdateStaged));
588 binary_protocol_dislink_process_staged (gpointer link, gpointer obj, int index)
590 SGenProtocolDislinkProcessStaged entry = { link, obj, index };
591 protocol_entry (SGEN_PROTOCOL_DISLINK_PROCESS_STAGED, &entry, sizeof (SGenProtocolDislinkProcessStaged));
595 binary_protocol_gray_enqueue (gpointer queue, gpointer cursor, gpointer value)
597 SGenProtocolGrayQueue entry = { queue, cursor, value };
598 protocol_entry (SGEN_PROTOCOL_GRAY_ENQUEUE, &entry, sizeof (SGenProtocolGrayQueue));
602 binary_protocol_gray_dequeue (gpointer queue, gpointer cursor, gpointer value)
604 SGenProtocolGrayQueue entry = { queue, cursor, value };
605 protocol_entry (SGEN_PROTOCOL_GRAY_DEQUEUE, &entry, sizeof (SGenProtocolGrayQueue));
609 #endif /* HAVE_SGEN_GC */