static void
Game_mark(Game* game)
{
if (game && !NIL_P(game->screen)) {
rb_gc_mark(game->screen);
}
}
static int
vm_mark_each_thread_func(st_data_t key, st_data_t value, st_data_t dummy)
{
VALUE thval = (VALUE)key;
rb_gc_mark(thval);
return ST_CONTINUE;
}
static int
frame_mark_i(st_data_t key, st_data_t val, st_data_t arg)
{
VALUE frame = (VALUE)key;
rb_gc_mark(frame);
return ST_CONTINUE;
}
static void
context_mark(void *data)
{
debug_context_t *context = (debug_context_t *) data;
rb_gc_mark(context->backtrace);
}
static void oci8_lob_mark(oci8_base_t *base)
{
oci8_lob_t *lob = (oci8_lob_t *)base;
if (lob->svcctx != NULL) {
rb_gc_mark(lob->svcctx->base.self);
}
}
static void mark(xmlNodePtr node)
{
/* it's OK if the document isn't fully realized (as in XML::Reader). */
/* see http://github.com/tenderlove/nokogiri/issues/closed/#issue/95 */
if (DOC_RUBY_OBJECT_TEST(node->doc) && DOC_RUBY_OBJECT(node->doc))
rb_gc_mark(DOC_RUBY_OBJECT(node->doc));
}
static void
rb_grn_database_mark_existing_ruby_object (grn_ctx *context, grn_obj *database)
{
grn_table_cursor *cursor;
grn_id id;
cursor = grn_table_cursor_open(context, database, NULL, 0, NULL, 0,
0, -1, GRN_CURSOR_ASCENDING);
if (!cursor)
return;
while ((id = grn_table_cursor_next(context, cursor)) != GRN_ID_NIL) {
grn_obj *object;
grn_user_data *user_data;
RbGrnObject *rb_grn_object;
object = grn_ctx_at(context, id);
if (!object)
continue;
user_data = grn_obj_user_data(context, object);
if (!user_data)
continue;
rb_grn_object = RB_GRN_OBJECT(user_data->ptr);
if (!rb_grn_object)
continue;
rb_gc_mark(rb_grn_object->self);
}
grn_table_cursor_close(context, cursor);
}
static void
cont_mark(void *ptr)
{
RUBY_MARK_ENTER("cont");
if (ptr) {
rb_context_t *cont = ptr;
rb_gc_mark(cont->value);
rb_thread_mark(&cont->saved_thread);
if (cont->vm_stack) {
#ifdef CAPTURE_JUST_VALID_VM_STACK
rb_gc_mark_locations(cont->vm_stack,
cont->vm_stack + cont->vm_stack_slen + cont->vm_stack_clen);
#else
rb_gc_mark_localtion(cont->vm_stack,
cont->vm_stack, cont->saved_thread.stack_size);
#endif
}
if (cont->machine_stack) {
rb_gc_mark_locations(cont->machine_stack,
cont->machine_stack + cont->machine_stack_size);
}
#ifdef __ia64
if (cont->machine_register_stack) {
rb_gc_mark_locations(cont->machine_register_stack,
cont->machine_register_stack + cont->machine_register_stack_size);
}
#endif
}
RUBY_MARK_LEAVE("cont");
}
void helium_rb_callback(const helium_connection_t *conn, uint64_t sender_mac, char * const message, size_t n)
{
struct helium_queued_callback queued = {
.sender_mac = sender_mac,
.message = malloc(n),
.count = n,
.conn = (helium_connection_t *)conn,
.mutex = PTHREAD_MUTEX_INITIALIZER,
.cond = PTHREAD_COND_INITIALIZER,
.next = NULL
};
memcpy(queued.message, message, n);
add_queued_callback(&queued);
pthread_cond_signal(&g_callback_cond);
pthread_mutex_lock(&queued.mutex);
pthread_cond_wait(&queued.cond, &queued.mutex);
pthread_mutex_unlock(&queued.mutex);
}
void helium_rb_mark(void * p) {
helium_connection_t *conn = (helium_connection_t*)p;
// make sure we mark the callback proc too so it doesn't get GCed
rb_gc_mark(helium_get_context(conn));
}
void
rb_vm_mark(void *ptr)
{
int i;
RUBY_MARK_ENTER("vm");
RUBY_GC_INFO("-------------------------------------------------\n");
if (ptr) {
rb_vm_t *vm = ptr;
if (vm->living_threads) {
st_foreach(vm->living_threads, vm_mark_each_thread_func, 0);
}
RUBY_MARK_UNLESS_NULL(vm->thgroup_default);
RUBY_MARK_UNLESS_NULL(vm->mark_object_ary);
RUBY_MARK_UNLESS_NULL(vm->load_path);
RUBY_MARK_UNLESS_NULL(vm->loaded_features);
RUBY_MARK_UNLESS_NULL(vm->top_self);
RUBY_MARK_UNLESS_NULL(vm->coverages);
rb_gc_mark_locations(vm->special_exceptions, vm->special_exceptions + ruby_special_error_count);
if (vm->loading_table) {
rb_mark_tbl(vm->loading_table);
}
mark_event_hooks(vm->event_hooks);
for (i = 0; i < RUBY_NSIG; i++) {
if (vm->trap_list[i].cmd)
rb_gc_mark(vm->trap_list[i].cmd);
}
}
RUBY_MARK_LEAVE("vm");
}
static void
cont_mark(void *ptr)
{
RUBY_MARK_ENTER("cont");
if (ptr) {
rb_context_t *cont = ptr;
rb_gc_mark(cont->value);
rb_thread_mark(&cont->saved_thread);
rb_gc_mark(cont->saved_thread.self);
if (cont->vm_stack) {
#ifdef CAPTURE_JUST_VALID_VM_STACK
rb_gc_mark_locations(cont->vm_stack,
cont->vm_stack + cont->vm_stack_slen + cont->vm_stack_clen);
#else
rb_gc_mark_locations(cont->vm_stack,
cont->vm_stack, cont->saved_thread.stack_size);
#endif
}
if (cont->machine.stack) {
if (cont->type == CONTINUATION_CONTEXT) {
/* cont */
rb_gc_mark_locations(cont->machine.stack,
cont->machine.stack + cont->machine.stack_size);
}
else {
/* fiber */
rb_thread_t *th;
rb_fiber_t *fib = (rb_fiber_t*)cont;
GetThreadPtr(cont->saved_thread.self, th);
if ((th->fiber != fib) && fib->status == RUNNING) {
rb_gc_mark_locations(cont->machine.stack,
cont->machine.stack + cont->machine.stack_size);
}
}
}
#ifdef __ia64
if (cont->machine.register_stack) {
rb_gc_mark_locations(cont->machine.register_stack,
cont->machine.register_stack + cont->machine.register_stack_size);
}
#endif
}
RUBY_MARK_LEAVE("cont");
}
static void
mark(struct png_data *reader)
{
VALUE io = reader->io;
if (io)
rb_gc_mark(io);
}
void
cb_http_request_mark(void *ptr)
{
struct cb_http_request_st *request = ptr;
if (request) {
rb_gc_mark(request->on_body_callback);
}
}
/*
* Mark root object. (protect from GC)
*/
void
mark_root_object(void *ptr)
{
VALUE value;
if (ptr && st_lookup(root_table, (st_data_t)ptr, (st_data_t*)&value)) {
rb_gc_mark(value);
}
}
void
cb_timer_mark(void *ptr)
{
struct timer_st *timer = ptr;
if (timer) {
rb_gc_mark(timer->callback);
}
}
static void
mark_event_hooks(rb_event_hook_t *hook)
{
while (hook) {
rb_gc_mark(hook->data);
hook = hook->next;
}
}
static void
location_mark(void *ptr)
{
if (ptr) {
struct valued_frame_info *vfi = (struct valued_frame_info *)ptr;
rb_gc_mark(vfi->btobj);
}
}
static void
dlcfunc_mark(void *ptr)
{
struct cfunc_data *data = ptr;
if (data->wrap) {
rb_gc_mark(data->wrap);
}
}
static void
mark_list(List *list)
{
Entry *entry;
for (entry = list->entries; entry; entry = entry->next) {
rb_gc_mark(entry->value);
}
}
static void c_CompletionResult_mark(void *s)
{
if (s)
{
CompletionResult_t *t = (CompletionResult_t *) s;
rb_gc_mark(t->parent);
}
}
/* GC helper functions */
void rbll_mark(ruby_liblicense *license) {
rb_gc_mark(license->uri);
rb_gc_mark(license->name);
rb_gc_mark(license->jurisdiction);
rb_gc_mark(license->version);
rb_gc_mark(license->permits);
rb_gc_mark(license->prohibits);
rb_gc_mark(license->requires);
rb_gc_mark(license->filename);
}
static void
tree_mark(void *ptr)
{
struct redtree *p = (struct redtree*)ptr;
int idx, max = p->line_count;
for (idx=0; idx < max; ++idx) {
rb_gc_mark(p->lines[idx]);
}
}
static void parent_context_mark(redisParentContext *pc) {
VALUE root;
if (pc->context && pc->context->reader) {
root = (VALUE)redisReplyReaderGetObject(pc->context->reader);
if (root != 0 && TYPE(root) == T_ARRAY) {
rb_gc_mark(root);
}
}
}
static void mark_for_ruby_gc(DownpourWrapper *wrapper)
{
if(wrapper == NULL)
return;
rb_gc_mark(wrapper->rb_object);
mark_for_ruby_gc(wrapper->parent);
}
static void
stackprof_gc_mark(void *data)
{
if (RTEST(_stackprof.out))
rb_gc_mark(_stackprof.out);
if (_stackprof.frames)
st_foreach(_stackprof.frames, frame_mark_i, 0);
}
static void
task_mark(void *ptr)
{
if (ptr) {
rb_task_t *task = (rb_task_t *)ptr;
int i;
if (task->result != Qundef) {
rb_gc_mark(task->result);
}
if (task->argc > 0) {
for (i=0; i<task->argc; i++) {
rb_gc_mark(task->argv[i]);
}
}
}
}
/* Protects the mark object from GC */
static void grpc_rb_channel_mark(void *p) {
grpc_rb_channel *channel = NULL;
if (p == NULL) {
return;
}
channel = (grpc_rb_channel *)p;
if (channel->credentials != Qnil) {
rb_gc_mark(channel->credentials);
}
}
void
vm_trace_mark_event_hooks(rb_hook_list_t *hooks)
{
rb_event_hook_t *hook = hooks->hooks;
while (hook) {
rb_gc_mark(hook->data);
hook = hook->next;
}
}
/* Protects the mark object from GC */
static void grpc_rb_server_mark(void *p) {
grpc_rb_server *server = NULL;
if (p == NULL) {
return;
}
server = (grpc_rb_server *)p;
if (server->mark != Qnil) {
rb_gc_mark(server->mark);
}
}
/* Protects the mark object from GC */
static void grpc_rb_call_credentials_mark(void* p) {
grpc_rb_call_credentials* wrapper = NULL;
if (p == NULL) {
return;
}
wrapper = (grpc_rb_call_credentials*)p;
if (wrapper->mark != Qnil) {
rb_gc_mark(wrapper->mark);
}
}
