mono/metadata/sgen-protocol.c

   1 /*
   2  * sgen-protocol.c: Binary protocol of internal activity, to aid
   3  * debugging.
   4  *
   5  * Copyright 2001-2003 Ximian, Inc
   6  * Copyright 2003-2010 Novell, Inc.
   7  * Copyright (C) 2012 Xamarin Inc
   8  *
   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;
  12  *
  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.
  17  *
  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.
  21  */
  22
  23 #ifdef HAVE_SGEN_GC
  24
  25 #include "config.h"
  26 #include "sgen-gc.h"
  27 #include "sgen-protocol.h"
  28 #include "sgen-memory-governor.h"
  29 #include "utils/mono-mmap.h"
  30 #include "utils/mono-threads.h"
  31
  32 #include <errno.h>
  33 #ifdef HAVE_UNISTD_H
  34 #include <fcntl.h>
  35 #endif
  36
  37 /* FIXME Implement binary protocol IO on systems that don't have unistd */
  38 #ifdef HAVE_UNISTD_H
  39 /* If valid, dump binary protocol to this file */
  40 static int binary_protocol_file = -1;
  41
  42 /* We set this to -1 to indicate an exclusive lock */
  43 static volatile int binary_protocol_use_count = 0;
  44
  45 #define BINARY_PROTOCOL_BUFFER_SIZE     (65536 - 2 * 8)
  46
  47 typedef struct _BinaryProtocolBuffer BinaryProtocolBuffer;
  48 struct _BinaryProtocolBuffer {
  49         BinaryProtocolBuffer * volatile next;
  50         volatile int index;
  51         unsigned char buffer [BINARY_PROTOCOL_BUFFER_SIZE];
  52 };
  53
  54 static BinaryProtocolBuffer * volatile binary_protocol_buffers = NULL;
  55
  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;
  60
  61 static char*
  62 filename_for_index (int index)
  63 {
  64         char *filename;
  65
  66         SGEN_ASSERT (0, file_size_limit > 0, "Indexed binary protocol filename must only be used with file size limit");
  67
  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);
  70
  71         return filename;
  72 }
  73
  74 static void
  75 free_filename (char *filename)
  76 {
  77         SGEN_ASSERT (0, file_size_limit > 0, "Indexed binary protocol filename must only be used with file size limit");
  78
  79         sgen_free_internal_dynamic (filename, strlen (filename_or_prefix) + 32, INTERNAL_MEM_BINARY_PROTOCOL);
  80 }
  81
  82 static void
  83 binary_protocol_open_file (void)
  84 {
  85         char *filename;
  86
  87         if (file_size_limit > 0)
  88                 filename = filename_for_index (current_file_index);
  89         else
  90                 filename = filename_or_prefix;
  91
  92         do {
  93                 binary_protocol_file = open (filename, O_CREAT|O_WRONLY|O_TRUNC, 0644);
  94                 if (binary_protocol_file == -1 && errno != EINTR)
  95                         break; /* Failed */
  96         } while (binary_protocol_file == -1);
  97
  98         if (file_size_limit > 0)
  99                 free_filename (filename);
 100 }
 101 #endif
 102
 103 void
 104 binary_protocol_init (const char *filename, long long limit)
 105 {
 106 #ifdef HAVE_UNISTD_H
 107         filename_or_prefix = sgen_alloc_internal_dynamic (strlen (filename) + 1, INTERNAL_MEM_BINARY_PROTOCOL, TRUE);
 108         strcpy (filename_or_prefix, filename);
 109
 110         file_size_limit = limit;
 111
 112         binary_protocol_open_file ();
 113 #endif
 114 }
 115
 116 gboolean
 117 binary_protocol_is_enabled (void)
 118 {
 119 #ifdef HAVE_UNISTD_H
 120         return binary_protocol_file != -1;
 121 #else
 122         return FALSE;
 123 #endif
 124 }
 125
 126 #ifdef HAVE_UNISTD_H
 127
 128 static void
 129 close_binary_protocol_file (void)
 130 {
 131         while (close (binary_protocol_file) == -1 && errno == EINTR)
 132                 ;
 133         binary_protocol_file = -1;
 134 }
 135
 136 static gboolean
 137 try_lock_exclusive (void)
 138 {
 139         do {
 140                 if (binary_protocol_use_count)
 141                         return FALSE;
 142         } while (InterlockedCompareExchange (&binary_protocol_use_count, -1, 0) != 0);
 143         mono_memory_barrier ();
 144         return TRUE;
 145 }
 146
 147 static void
 148 unlock_exclusive (void)
 149 {
 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");
 154 }
 155
 156 static void
 157 lock_recursive (void)
 158 {
 159         int old_count;
 160         do {
 161         retry:
 162                 old_count = binary_protocol_use_count;
 163                 if (old_count < 0) {
 164                         /* Exclusively locked - retry */
 165                         /* FIXME: short back-off */
 166                         goto retry;
 167                 }
 168         } while (InterlockedCompareExchange (&binary_protocol_use_count, old_count + 1, old_count) != old_count);
 169         mono_memory_barrier ();
 170 }
 171
 172 static void
 173 unlock_recursive (void)
 174 {
 175         int old_count;
 176         mono_memory_barrier ();
 177         do {
 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);
 181 }
 182
 183 static void
 184 binary_protocol_flush_buffer (BinaryProtocolBuffer *buffer)
 185 {
 186         ssize_t ret;
 187         size_t to_write = buffer->index;
 188         size_t written = 0;
 189         g_assert (buffer->index > 0);
 190
 191         while (written < to_write) {
 192                 ret = write (binary_protocol_file, buffer->buffer + written, to_write - written);
 193                 if (ret >= 0)
 194                         written += ret;
 195                 else if (errno == EINTR)
 196                         continue;
 197                 else
 198                         close_binary_protocol_file ();
 199         }
 200
 201         current_file_size += buffer->index;
 202
 203         sgen_free_os_memory (buffer, sizeof (BinaryProtocolBuffer), SGEN_ALLOC_INTERNAL);
 204 }
 205
 206 static void
 207 binary_protocol_check_file_overflow (void)
 208 {
 209         if (file_size_limit <= 0 || current_file_size < file_size_limit)
 210                 return;
 211
 212         close_binary_protocol_file ();
 213
 214         if (current_file_index > 0) {
 215                 char *filename = filename_for_index (current_file_index - 1);
 216                 unlink (filename);
 217                 free_filename (filename);
 218         }
 219
 220         ++current_file_index;
 221         current_file_size = 0;
 222
 223         binary_protocol_open_file ();
 224 }
 225 #endif
 226
 227 void
 228 binary_protocol_flush_buffers (gboolean force)
 229 {
 230 #ifdef HAVE_UNISTD_H
 231         int num_buffers = 0, i;
 232         BinaryProtocolBuffer *buf;
 233         BinaryProtocolBuffer **bufs;
 234
 235         if (binary_protocol_file == -1)
 236                 return;
 237
 238         if (!force && !try_lock_exclusive ())
 239                 return;
 240
 241         for (buf = binary_protocol_buffers; buf != NULL; buf = buf->next)
 242                 ++num_buffers;
 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++)
 245                 bufs [i] = buf;
 246         SGEN_ASSERT (0, i == num_buffers, "Binary protocol buffer count error");
 247
 248         binary_protocol_buffers = NULL;
 249
 250         for (i = num_buffers - 1; i >= 0; --i) {
 251                 binary_protocol_flush_buffer (bufs [i]);
 252                 binary_protocol_check_file_overflow ();
 253         }
 254
 255         sgen_free_internal_dynamic (buf, num_buffers * sizeof (BinaryProtocolBuffer*), INTERNAL_MEM_BINARY_PROTOCOL);
 256
 257         if (!force)
 258                 unlock_exclusive ();
 259 #endif
 260 }
 261
 262 #ifdef HAVE_UNISTD_H
 263 static BinaryProtocolBuffer*
 264 binary_protocol_get_buffer (int length)
 265 {
 266         BinaryProtocolBuffer *buffer, *new_buffer;
 267  retry:
 268         buffer = binary_protocol_buffers;
 269         if (buffer && buffer->index + length <= BINARY_PROTOCOL_BUFFER_SIZE)
 270                 return buffer;
 271
 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;
 275
 276         if (InterlockedCompareExchangePointer ((void**)&binary_protocol_buffers, new_buffer, buffer) != buffer) {
 277                 sgen_free_os_memory (new_buffer, sizeof (BinaryProtocolBuffer), SGEN_ALLOC_INTERNAL);
 278                 goto retry;
 279         }
 280
 281         return new_buffer;
 282 }
 283 #endif
 284
 285 static void
 286 protocol_entry (unsigned char type, gpointer data, int size)
 287 {
 288 #ifdef HAVE_UNISTD_H
 289         int index;
 290         BinaryProtocolBuffer *buffer;
 291
 292         if (binary_protocol_file == -1)
 293                 return;
 294
 295         if (sgen_is_worker_thread (mono_native_thread_id_get ()))
 296                 type |= 0x80;
 297
 298         lock_recursive ();
 299
 300  retry:
 301         buffer = binary_protocol_get_buffer (size + 1);
 302  retry_same_buffer:
 303         index = buffer->index;
 304         if (index + 1 + size > BINARY_PROTOCOL_BUFFER_SIZE)
 305                 goto retry;
 306
 307         if (InterlockedCompareExchange (&buffer->index, index + 1 + size, index) != index)
 308                 goto retry_same_buffer;
 309
 310         /* FIXME: if we're interrupted at this point, we have a buffer
 311            entry that contains random data. */
 312
 313         buffer->buffer [index++] = type;
 314         memcpy (buffer->buffer + index, data, size);
 315         index += size;
 316
 317         g_assert (index <= BINARY_PROTOCOL_BUFFER_SIZE);
 318
 319         unlock_recursive ();
 320 #endif
 321 }
 322
 323 void
 324 binary_protocol_collection_force (int generation)
 325 {
 326         SGenProtocolCollectionForce entry = { generation };
 327         binary_protocol_flush_buffers (FALSE);
 328         protocol_entry (SGEN_PROTOCOL_COLLECTION_FORCE, &entry, sizeof (SGenProtocolCollectionForce));
 329 }
 330
 331 void
 332 binary_protocol_collection_begin (int index, int generation)
 333 {
 334         SGenProtocolCollectionBegin entry = { index, generation };
 335         binary_protocol_flush_buffers (FALSE);
 336         protocol_entry (SGEN_PROTOCOL_COLLECTION_BEGIN, &entry, sizeof (SGenProtocolCollectionBegin));
 337 }
 338
 339 void
 340 binary_protocol_collection_end (int index, int generation, long long num_objects_scanned, long long num_unique_objects_scanned)
 341 {
 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));
 345 }
 346
 347 void
 348 binary_protocol_concurrent_start (void)
 349 {
 350         protocol_entry (SGEN_PROTOCOL_CONCURRENT_START, NULL, 0);
 351 }
 352
 353 void
 354 binary_protocol_concurrent_update (void)
 355 {
 356         protocol_entry (SGEN_PROTOCOL_CONCURRENT_UPDATE, NULL, 0);
 357 }
 358
 359 void
 360 binary_protocol_concurrent_finish (void)
 361 {
 362         protocol_entry (SGEN_PROTOCOL_CONCURRENT_FINISH, NULL, 0);
 363 }
 364
 365 void
 366 binary_protocol_world_stopping (long long timestamp)
 367 {
 368         SGenProtocolWorldStopping entry = { timestamp };
 369         protocol_entry (SGEN_PROTOCOL_WORLD_STOPPING, &entry, sizeof (SGenProtocolWorldStopping));
 370 }
 371
 372 void
 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)
 375 {
 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));
 378 }
 379
 380 void
 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)
 383 {
 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));
 386 }
 387
 388 void
 389 binary_protocol_world_restarted (int generation, long long timestamp)
 390 {
 391         SGenProtocolWorldRestarted entry = { generation, timestamp };
 392         protocol_entry (SGEN_PROTOCOL_WORLD_RESTARTED, &entry, sizeof (SGenProtocolWorldRestarted));
 393 }
 394
 395 void
 396 binary_protocol_thread_suspend (gpointer thread, gpointer stopped_ip)
 397 {
 398         SGenProtocolThreadSuspend entry = { thread, stopped_ip };
 399         protocol_entry (SGEN_PROTOCOL_THREAD_SUSPEND, &entry, sizeof (SGenProtocolThreadSuspend));
 400 }
 401
 402 void
 403 binary_protocol_thread_restart (gpointer thread)
 404 {
 405         SGenProtocolThreadRestart entry = { thread };
 406         protocol_entry (SGEN_PROTOCOL_THREAD_RESTART, &entry, sizeof (SGenProtocolThreadRestart));
 407 }
 408
 409 void
 410 binary_protocol_thread_register (gpointer thread)
 411 {
 412         SGenProtocolThreadRegister entry = { thread };
 413         protocol_entry (SGEN_PROTOCOL_THREAD_REGISTER, &entry, sizeof (SGenProtocolThreadRegister));
 414
 415 }
 416
 417 void
 418 binary_protocol_thread_unregister (gpointer thread)
 419 {
 420         SGenProtocolThreadUnregister entry = { thread };
 421         protocol_entry (SGEN_PROTOCOL_THREAD_UNREGISTER, &entry, sizeof (SGenProtocolThreadUnregister));
 422
 423 }
 424
 425 void
 426 binary_protocol_missing_remset (gpointer obj, gpointer obj_vtable, int offset, gpointer value, gpointer value_vtable, int value_pinned)
 427 {
 428         SGenProtocolMissingRemset entry = { obj, obj_vtable, offset, value, value_vtable, value_pinned };
 429         protocol_entry (SGEN_PROTOCOL_MISSING_REMSET, &entry, sizeof (SGenProtocolMissingRemset));
 430
 431 }
 432
 433 void
 434 binary_protocol_cement (gpointer obj, gpointer vtable, int size)
 435 {
 436         SGenProtocolCement entry = { obj, vtable, size };
 437         protocol_entry (SGEN_PROTOCOL_CEMENT, &entry, sizeof (SGenProtocolCement));
 438 }
 439
 440 void
 441 binary_protocol_cement_reset (void)
 442 {
 443         protocol_entry (SGEN_PROTOCOL_CEMENT_RESET, NULL, 0);
 444 }
 445
 446 void
 447 binary_protocol_domain_unload_begin (gpointer domain)
 448 {
 449         SGenProtocolDomainUnload entry = { domain };
 450         protocol_entry (SGEN_PROTOCOL_DOMAIN_UNLOAD_BEGIN, &entry, sizeof (SGenProtocolDomainUnload));
 451 }
 452
 453 void
 454 binary_protocol_domain_unload_end (gpointer domain)
 455 {
 456         SGenProtocolDomainUnload entry = { domain };
 457         protocol_entry (SGEN_PROTOCOL_DOMAIN_UNLOAD_END, &entry, sizeof (SGenProtocolDomainUnload));
 458 }
 459
 460 #ifdef SGEN_HEAVY_BINARY_PROTOCOL
 461 void
 462 binary_protocol_alloc (gpointer obj, gpointer vtable, int size)
 463 {
 464         SGenProtocolAlloc entry = { obj, vtable, size };
 465         protocol_entry (SGEN_PROTOCOL_ALLOC, &entry, sizeof (SGenProtocolAlloc));
 466 }
 467
 468 void
 469 binary_protocol_alloc_pinned (gpointer obj, gpointer vtable, int size)
 470 {
 471         SGenProtocolAlloc entry = { obj, vtable, size };
 472         protocol_entry (SGEN_PROTOCOL_ALLOC_PINNED, &entry, sizeof (SGenProtocolAlloc));
 473 }
 474
 475 void
 476 binary_protocol_alloc_degraded (gpointer obj, gpointer vtable, int size)
 477 {
 478         SGenProtocolAlloc entry = { obj, vtable, size };
 479         protocol_entry (SGEN_PROTOCOL_ALLOC_DEGRADED, &entry, sizeof (SGenProtocolAlloc));
 480 }
 481
 482 void
 483 binary_protocol_copy (gpointer from, gpointer to, gpointer vtable, int size)
 484 {
 485         SGenProtocolCopy entry = { from, to, vtable, size };
 486         protocol_entry (SGEN_PROTOCOL_COPY, &entry, sizeof (SGenProtocolCopy));
 487 }
 488
 489 void
 490 binary_protocol_pin_stage (gpointer addr_ptr, gpointer addr)
 491 {
 492         SGenProtocolPinStage entry = { addr_ptr, addr };
 493         protocol_entry (SGEN_PROTOCOL_PIN_STAGE, &entry, sizeof (SGenProtocolPinStage));
 494 }
 495
 496 void
 497 binary_protocol_pin (gpointer obj, gpointer vtable, int size)
 498 {
 499         SGenProtocolPin entry = { obj, vtable, size };
 500         protocol_entry (SGEN_PROTOCOL_PIN, &entry, sizeof (SGenProtocolPin));
 501 }
 502
 503 void
 504 binary_protocol_mark (gpointer obj, gpointer vtable, int size)
 505 {
 506         SGenProtocolMark entry = { obj, vtable, size };
 507         protocol_entry (SGEN_PROTOCOL_MARK, &entry, sizeof (SGenProtocolMark));
 508 }
 509
 510 void
 511 binary_protocol_scan_begin (gpointer obj, gpointer vtable, int size)
 512 {
 513         SGenProtocolScanBegin entry = { obj, vtable, size };
 514         protocol_entry (SGEN_PROTOCOL_SCAN_BEGIN, &entry, sizeof (SGenProtocolScanBegin));
 515 }
 516
 517 void
 518 binary_protocol_scan_vtype_begin (gpointer obj, int size)
 519 {
 520         SGenProtocolScanVTypeBegin entry = { obj, size };
 521         protocol_entry (SGEN_PROTOCOL_SCAN_VTYPE_BEGIN, &entry, sizeof (SGenProtocolScanVTypeBegin));
 522 }
 523
 524 void
 525 binary_protocol_scan_process_reference (gpointer obj, gpointer ptr, gpointer value)
 526 {
 527         SGenProtocolScanProcessReference entry = { obj, ptr, value };
 528         protocol_entry (SGEN_PROTOCOL_SCAN_PROCESS_REFERENCE, &entry, sizeof (SGenProtocolScanProcessReference));
 529 }
 530
 531 void
 532 binary_protocol_wbarrier (gpointer ptr, gpointer value, gpointer value_vtable)
 533 {
 534         SGenProtocolWBarrier entry = { ptr, value, value_vtable };
 535         protocol_entry (SGEN_PROTOCOL_WBARRIER, &entry, sizeof (SGenProtocolWBarrier));
 536 }
 537
 538 void
 539 binary_protocol_global_remset (gpointer ptr, gpointer value, gpointer value_vtable)
 540 {
 541         SGenProtocolGlobalRemset entry = { ptr, value, value_vtable };
 542         protocol_entry (SGEN_PROTOCOL_GLOBAL_REMSET, &entry, sizeof (SGenProtocolGlobalRemset));
 543 }
 544
 545 void
 546 binary_protocol_ptr_update (gpointer ptr, gpointer old_value, gpointer new_value, gpointer vtable, int size)
 547 {
 548         SGenProtocolPtrUpdate entry = { ptr, old_value, new_value, vtable, size };
 549         protocol_entry (SGEN_PROTOCOL_PTR_UPDATE, &entry, sizeof (SGenProtocolPtrUpdate));
 550 }
 551
 552 void
 553 binary_protocol_cleanup (gpointer ptr, gpointer vtable, int size)
 554 {
 555         SGenProtocolCleanup entry = { ptr, vtable, size };
 556         protocol_entry (SGEN_PROTOCOL_CLEANUP, &entry, sizeof (SGenProtocolCleanup));
 557 }
 558
 559 void
 560 binary_protocol_empty (gpointer start, int size)
 561 {
 562         SGenProtocolEmpty entry = { start, size };
 563         protocol_entry (SGEN_PROTOCOL_EMPTY, &entry, sizeof (SGenProtocolEmpty));
 564 }
 565
 566 void
 567 binary_protocol_card_scan (gpointer start, int size)
 568 {
 569         SGenProtocolCardScan entry = { start, size };
 570         protocol_entry (SGEN_PROTOCOL_CARD_SCAN, &entry, sizeof (SGenProtocolCardScan));
 571 }
 572
 573 void
 574 binary_protocol_dislink_update (gpointer link, gpointer obj, int track, int staged)
 575 {
 576         SGenProtocolDislinkUpdate entry = { link, obj, track, staged };
 577         protocol_entry (SGEN_PROTOCOL_DISLINK_UPDATE, &entry, sizeof (SGenProtocolDislinkUpdate));
 578 }
 579
 580 void
 581 binary_protocol_dislink_update_staged (gpointer link, gpointer obj, int track, int index)
 582 {
 583         SGenProtocolDislinkUpdateStaged entry = { link, obj, track, index };
 584         protocol_entry (SGEN_PROTOCOL_DISLINK_UPDATE_STAGED, &entry, sizeof (SGenProtocolDislinkUpdateStaged));
 585 }
 586
 587 void
 588 binary_protocol_dislink_process_staged (gpointer link, gpointer obj, int index)
 589 {
 590         SGenProtocolDislinkProcessStaged entry = { link, obj, index };
 591         protocol_entry (SGEN_PROTOCOL_DISLINK_PROCESS_STAGED, &entry, sizeof (SGenProtocolDislinkProcessStaged));
 592 }
 593
 594 void
 595 binary_protocol_gray_enqueue (gpointer queue, gpointer cursor, gpointer value)
 596 {
 597         SGenProtocolGrayQueue entry = { queue, cursor, value };
 598         protocol_entry (SGEN_PROTOCOL_GRAY_ENQUEUE, &entry, sizeof (SGenProtocolGrayQueue));
 599 }
 600
 601 void
 602 binary_protocol_gray_dequeue (gpointer queue, gpointer cursor, gpointer value)
 603 {
 604         SGenProtocolGrayQueue entry = { queue, cursor, value };
 605         protocol_entry (SGEN_PROTOCOL_GRAY_DEQUEUE, &entry, sizeof (SGenProtocolGrayQueue));
 606 }
 607 #endif
 608
 609 #endif /* HAVE_SGEN_GC */