void Tox_Dispatcher::start() { if (run.load()) { LOG(INFO) << "Tox dispatcher is already running"; } LOG(INFO) << "Starting Tox dispatcher"; try { init_tox(); init_callbacks(); bootstrap(); } catch (const std::exception& e) { LOG(ERROR) << e.what(); exit(-1); } dispatcher_started.Emit(this); LOG(INFO) << "Tox Id: " << get_self_id(); /* run tox main loop */ run.store(true); while (run.load()) { lock.lock(); tox_iterate(tox); uint32_t millis = tox_iteration_interval(tox); lock.unlock(); std::this_thread::sleep_for(std::chrono::milliseconds(millis)); } tox_kill(tox); tox = nullptr; LOG(INFO) << "Tox dispatcher stopped"; }
static int init(int argc, char **argv) { GLenum res; glutInit(&argc, argv); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA); glutInitWindowSize(WIN_WIDTH_I, WIN_HEIGHT_I); glutInitWindowPosition(100, 100); win_num = glutCreateWindow("Tutorial 01"); init_callbacks(); // Must be done after glut is initialized! res = glewInit(); if (res != GLEW_OK) { fprintf(stderr, "Error: '%s'\n", glewGetErrorString(res)); return -1; } glClearColor(0.0f, 0.0f, 0.0f, 0.0f); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(0.0f, WIN_WIDTH_F, WIN_HEIGHT_F, 0.0f, 0.0f, 1.0f); glMatrixMode(GL_MODELVIEW); glDisable(GL_DEPTH_TEST); particles = particle(); start_thread_pool(); return 0; }
struct snmp_gen_callback * snmp_callback_list(int major, int minor) { if (_callback_need_init) init_callbacks(); return (thecallbacks[major][minor]); }
void factor_vm::init_factor(vm_parameters *p) { /* Kilobytes */ p->datastack_size = align_page(p->datastack_size << 10); p->retainstack_size = align_page(p->retainstack_size << 10); p->callstack_size = align_page(p->callstack_size << 10); p->callback_size = align_page(p->callback_size << 10); /* Megabytes */ p->young_size <<= 20; p->aging_size <<= 20; p->tenured_size <<= 20; p->code_size <<= 20; /* Disable GC during init as a sanity check */ gc_off = true; /* OS-specific initialization */ early_init(); const vm_char *executable_path = vm_executable_path(); if(executable_path) p->executable_path = executable_path; if(p->image_path == NULL) p->image_path = default_image_path(); srand((unsigned int)nano_count()); init_ffi(); init_contexts(p->datastack_size,p->retainstack_size,p->callstack_size); init_callbacks(p->callback_size); load_image(p); init_c_io(); init_inline_caching((int)p->max_pic_size); if(p->signals) init_signals(); if(p->console) open_console(); init_profiler(); special_objects[OBJ_CPU] = allot_alien(false_object,(cell)FACTOR_CPU_STRING); special_objects[OBJ_OS] = allot_alien(false_object,(cell)FACTOR_OS_STRING); special_objects[OBJ_CELL_SIZE] = tag_fixnum(sizeof(cell)); special_objects[OBJ_EXECUTABLE] = allot_alien(false_object,(cell)p->executable_path); special_objects[OBJ_ARGS] = false_object; special_objects[OBJ_EMBEDDED] = false_object; special_objects[OBJ_VM_COMPILER] = allot_alien(false_object,(cell)FACTOR_COMPILER_VERSION); /* We can GC now */ gc_off = false; if(!to_boolean(special_objects[OBJ_STAGE2])) prepare_boot_image(); }
void new_env(ssize_t width, ssize_t height, char *title, t_env *e) { e->core = mlx_init(); e->win = mlx_new_window(e->core, width, height, title); e->img = mlx_new_image(e->core, width, height); e->finish = mlx_new_image(e->core, width, height); init_callbacks(e->callback); init_mouse_callbacks(e->mouse_callback); }
/** * This function calls the callback function for each registered callback of * type major and minor. * * @param major is the SNMP callback major type used * * @param minor is the SNMP callback minor type used * * @param caller_arg is a void pointer which is sent in as the callback's * serverarg parameter, if needed. * * @return Returns SNMPERR_GENERR if major is >= MAX_CALLBACK_IDS or * minor is >= MAX_CALLBACK_SUBIDS, otherwise SNMPERR_SUCCESS is returned. * * @see snmp_register_callback * @see snmp_unregister_callback */ int snmp_call_callbacks(int major, int minor, void *caller_arg) { struct snmp_gen_callback *scp; unsigned int count = 0; if (major >= MAX_CALLBACK_IDS || minor >= MAX_CALLBACK_SUBIDS) { return SNMPERR_GENERR; } if (_callback_need_init) init_callbacks(); #ifdef LOCK_PER_CALLBACK_SUBID _callback_lock(major,minor,"snmp_call_callbacks", 1); #else /* * Notes: * - this gets hit the first time a trap is sent after a new trap * destination has been added (session init cb during send trap cb) */ _callback_lock(major,minor, NULL, 0); #endif DEBUGMSGTL(("callback", "START calling callbacks for maj=%d min=%d\n", major, minor)); /* * for each registered callback of type major and minor */ for (scp = thecallbacks[major][minor]; scp != NULL; scp = scp->next) { /* * skip unregistered callbacks */ if(NULL == scp->sc_callback) continue; DEBUGMSGTL(("callback", "calling a callback for maj=%d min=%d\n", major, minor)); /* * call them */ (*(scp->sc_callback)) (major, minor, caller_arg, scp->sc_client_arg); count++; } DEBUGMSGTL(("callback", "END calling callbacks for maj=%d min=%d (%d called)\n", major, minor, count)); _callback_unlock(major,minor); return SNMPERR_SUCCESS; }
void *max17042_platform_data(void *info) { static struct max17042_platform_data platform_data; init_tgain_toff(&platform_data); init_callbacks(&platform_data); init_platform_params(&platform_data); init_platform_thresholds(&platform_data); if (smip) iounmap(smip); return &platform_data; }
int snmp_unregister_callback(int major, int minor, SNMPCallback * target, void *arg, int matchargs) { struct snmp_gen_callback *scp = thecallbacks[major][minor]; struct snmp_gen_callback **prevNext = &(thecallbacks[major][minor]); int count = 0; if (major >= MAX_CALLBACK_IDS || minor >= MAX_CALLBACK_SUBIDS) return SNMPERR_GENERR; if (_callback_need_init) init_callbacks(); #ifdef LOCK_PER_CALLBACK_SUBID _callback_lock(major,minor,"snmp_unregister_callback", 1); #else /* * Notes; * - this gets hit at shutdown, during cleanup. No easy fix. */ _callback_lock(major,minor,"snmp_unregister_callback", 0); #endif while (scp != NULL) { if ((scp->sc_callback == target) && (!matchargs || (scp->sc_client_arg == arg))) { DEBUGMSGTL(("callback", "unregistering (%d,%d) at %p\n", major, minor, scp)); if(1 == CALLBACK_LOCK_COUNT(major,minor)) { *prevNext = scp->next; SNMP_FREE(scp); scp = *prevNext; } else { scp->sc_callback = NULL; /** set cleanup flag? */ } count++; } else { prevNext = &(scp->next); scp = scp->next; } } _callback_unlock(major,minor); return count; }
int snmp_callback_available(int major, int minor) { if (major >= MAX_CALLBACK_IDS || minor >= MAX_CALLBACK_SUBIDS) { return SNMPERR_GENERR; } if (_callback_need_init) init_callbacks(); if (thecallbacks[major][minor] != NULL) { return SNMPERR_SUCCESS; } return SNMPERR_GENERR; }
void *max17042_platform_data(void *info) { static struct max17042_platform_data platform_data; struct i2c_board_info *i2c_info = (struct i2c_board_info *)info; int intr = get_gpio_by_name("max_fg_alert"); if (!INTEL_MID_BOARD(1, TABLET, BYT)) i2c_info->irq = intr + INTEL_MID_IRQ_OFFSET; init_tgain_toff(&platform_data); init_callbacks(&platform_data); init_platform_params(&platform_data); init_platform_thresholds(&platform_data); if (smip) iounmap(smip); return &platform_data; }
int snmp_count_callbacks(int major, int minor) { int count = 0; struct snmp_gen_callback *scp; if (major >= MAX_CALLBACK_IDS || minor >= MAX_CALLBACK_SUBIDS) { return SNMPERR_GENERR; } if (_callback_need_init) init_callbacks(); for (scp = thecallbacks[major][minor]; scp != NULL; scp = scp->next) { count++; } return count; }
void clear_callback(void) { unsigned int i = 0, j = 0; struct snmp_gen_callback *scp = NULL; if (_callback_need_init) init_callbacks(); DEBUGMSGTL(("callback", "clear callback\n")); for (i = 0; i < MAX_CALLBACK_IDS; i++) { for (j = 0; j < MAX_CALLBACK_SUBIDS; j++) { _callback_lock(i,j, "clear_callback", 1); scp = thecallbacks[i][j]; while (scp != NULL) { thecallbacks[i][j] = scp->next; /* * if there is a client arg, check for duplicates * and then free it. */ if ((NULL != scp->sc_callback) && (scp->sc_client_arg != NULL)) { void *tmp_arg; /* * save the client arg, then set it to null so that it * won't look like a duplicate, then check for duplicates * starting at the current i,j (earlier dups should have * already been found) and free the pointer. */ tmp_arg = scp->sc_client_arg; scp->sc_client_arg = NULL; DEBUGMSGTL(("9:callback", " freeing %p at [%d,%d]\n", tmp_arg, i, j)); (void)netsnmp_callback_clear_client_arg(tmp_arg, i, j); free(tmp_arg); } SNMP_FREE(scp); scp = thecallbacks[i][j]; } _callback_unlock(i,j); } } }
int netsnmp_register_callback(int major, int minor, SNMPCallback * new_callback, void *arg, int priority) { struct snmp_gen_callback *newscp = NULL, *scp = NULL; struct snmp_gen_callback **prevNext = &(thecallbacks[major][minor]); if (major >= MAX_CALLBACK_IDS || minor >= MAX_CALLBACK_SUBIDS) { return SNMPERR_GENERR; } if (_callback_need_init) init_callbacks(); _callback_lock(major,minor, "netsnmp_register_callback", 1); if ((newscp = SNMP_MALLOC_STRUCT(snmp_gen_callback)) == NULL) { _callback_unlock(major,minor); return SNMPERR_GENERR; } else { newscp->priority = priority; newscp->sc_client_arg = arg; newscp->sc_callback = new_callback; newscp->next = NULL; for (scp = thecallbacks[major][minor]; scp != NULL; scp = scp->next) { if (newscp->priority < scp->priority) { newscp->next = scp; break; } prevNext = &(scp->next); } *prevNext = newscp; DEBUGMSGTL(("callback", "registered (%d,%d) at %p with priority %d\n", major, minor, newscp, priority)); _callback_unlock(major,minor); return SNMPERR_SUCCESS; } }
void *max17042_platform_data(void *info) { static struct max17042_platform_data platform_data; struct i2c_board_info *i2c_info = (struct i2c_board_info *)info; int intr = get_gpio_by_name("max_fg_alert"); #ifndef CONFIG_ACPI if (i2c_info) i2c_info->irq = intr + INTEL_MID_IRQ_OFFSET; #endif init_tgain_toff(&platform_data); init_callbacks(&platform_data); init_platform_params(&platform_data); init_platform_thresholds(&platform_data); if (smip) iounmap(smip); return &platform_data; }
static h2_session *h2_session_create_int(conn_rec *c, request_rec *r, h2_config *config, h2_workers *workers) { nghttp2_session_callbacks *callbacks = NULL; nghttp2_option *options = NULL; apr_pool_t *pool = NULL; apr_status_t status = apr_pool_create(&pool, r? r->pool : c->pool); h2_session *session; if (status != APR_SUCCESS) { return NULL; } session = apr_pcalloc(pool, sizeof(h2_session)); if (session) { int rv; session->id = c->id; session->c = c; session->r = r; session->max_stream_count = h2_config_geti(config, H2_CONF_MAX_STREAMS); session->max_stream_mem = h2_config_geti(config, H2_CONF_STREAM_MAX_MEM); session->pool = pool; status = apr_thread_cond_create(&session->iowait, session->pool); if (status != APR_SUCCESS) { return NULL; } session->streams = h2_stream_set_create(session->pool); session->workers = workers; session->mplx = h2_mplx_create(c, session->pool, workers); h2_conn_io_init(&session->io, c); session->bbtmp = apr_brigade_create(session->pool, c->bucket_alloc); status = init_callbacks(c, &callbacks); if (status != APR_SUCCESS) { ap_log_cerror(APLOG_MARK, APLOG_ERR, status, c, APLOGNO(02927) "nghttp2: error in init_callbacks"); h2_session_destroy(session); return NULL; } rv = nghttp2_option_new(&options); if (rv != 0) { ap_log_cerror(APLOG_MARK, APLOG_ERR, APR_EGENERAL, c, APLOGNO(02928) "nghttp2_option_new: %s", nghttp2_strerror(rv)); h2_session_destroy(session); return NULL; } nghttp2_option_set_peer_max_concurrent_streams(options, (uint32_t)session->max_stream_count); /* We need to handle window updates ourself, otherwise we * get flooded by nghttp2. */ nghttp2_option_set_no_auto_window_update(options, 1); rv = nghttp2_session_server_new2(&session->ngh2, callbacks, session, options); nghttp2_session_callbacks_del(callbacks); nghttp2_option_del(options); if (rv != 0) { ap_log_cerror(APLOG_MARK, APLOG_ERR, APR_EGENERAL, c, APLOGNO(02929) "nghttp2_session_server_new: %s", nghttp2_strerror(rv)); h2_session_destroy(session); return NULL; } } return session; }
static h2_session *h2_session_create_int(conn_rec *c, request_rec *r, h2_config *config) { nghttp2_session_callbacks *callbacks = NULL; nghttp2_option *options = NULL; apr_allocator_t *allocator = NULL; apr_status_t status = apr_allocator_create(&allocator); if (status != APR_SUCCESS) { return NULL; } apr_pool_t *pool = NULL; status = apr_pool_create_ex(&pool, c->pool, NULL, allocator); if (status != APR_SUCCESS) { return NULL; } h2_session *session = apr_pcalloc(pool, sizeof(h2_session)); if (session) { session->id = c->id; session->allocator = allocator; session->pool = pool; status = apr_thread_mutex_create(&session->alock, APR_THREAD_MUTEX_DEFAULT, session->pool); if (status != APR_SUCCESS) { return NULL; } apr_allocator_mutex_set(session->allocator, session->alock); status = apr_thread_cond_create(&session->iowait, session->pool); if (status != APR_SUCCESS) { return NULL; } session->c = c; session->r = r; session->ngh2 = NULL; session->streams = h2_stream_set_create(session->pool); session->zombies = h2_stream_set_create(session->pool); session->mplx = h2_mplx_create(c, session->pool); h2_conn_io_init(&session->io, c, 0); apr_status_t status = init_callbacks(c, &callbacks); if (status != APR_SUCCESS) { ap_log_cerror(APLOG_MARK, APLOG_ERR, status, c, "nghttp2: error in init_callbacks"); h2_session_destroy(session); return NULL; } int rv = nghttp2_option_new(&options); if (rv != 0) { ap_log_cerror(APLOG_MARK, APLOG_ERR, APR_EGENERAL, c, "nghttp2_option_new: %s", nghttp2_strerror(rv)); h2_session_destroy(session); return NULL; } /* Nowadays, we handle the preface ourselves. We had problems * with nghttp2 internal state machine when traffic action occured * before the preface was read. */ nghttp2_option_set_recv_client_preface(options, 1); /* Set a value, to be observed before we receive any SETTINGS * from the client. */ nghttp2_option_set_peer_max_concurrent_streams(options, 100); /* We need to handle window updates ourself, otherwise we * get flooded by nghttp2. */ nghttp2_option_set_no_auto_window_update(options, 1); rv = nghttp2_session_server_new2(&session->ngh2, callbacks, session, options); nghttp2_session_callbacks_del(callbacks); nghttp2_option_del(options); if (rv != 0) { ap_log_cerror(APLOG_MARK, APLOG_ERR, APR_EGENERAL, c, "nghttp2_session_server_new: %s", nghttp2_strerror(rv)); h2_session_destroy(session); return NULL; } } return session; }
static void gdbsim_open (char *args, int from_tty) { int len; char *arg_buf; char **argv; if (sr_get_debug ()) printf_filtered ("gdbsim_open: args \"%s\"\n", args ? args : "(null)"); /* Remove current simulator if one exists. Only do this if the simulator has been opened because sim_close requires it. This is important because the call to push_target below will cause sim_close to be called if the simulator is already open, but push_target is called after sim_open! We can't move the call to push_target before the call to sim_open because sim_open may invoke `error'. */ if (gdbsim_desc != NULL) unpush_target (&gdbsim_ops); len = (7 + 1 /* gdbsim */ + strlen (" -E little") + strlen (" --architecture=xxxxxxxxxx") + (args ? strlen (args) : 0) + 50) /* slack */ ; arg_buf = (char *) alloca (len); strcpy (arg_buf, "gdbsim"); /* 7 */ /* Specify the byte order for the target when it is both selectable and explicitly specified by the user (not auto detected). */ switch (selected_byte_order ()) { case BFD_ENDIAN_BIG: strcat (arg_buf, " -E big"); break; case BFD_ENDIAN_LITTLE: strcat (arg_buf, " -E little"); break; case BFD_ENDIAN_UNKNOWN: break; } /* Specify the architecture of the target when it has been explicitly specified */ if (selected_architecture_name () != NULL) { strcat (arg_buf, " --architecture="); strcat (arg_buf, selected_architecture_name ()); } /* finally, any explicit args */ if (args) { strcat (arg_buf, " "); /* 1 */ strcat (arg_buf, args); } argv = buildargv (arg_buf); if (argv == NULL) error ("Insufficient memory available to allocate simulator arg list."); make_cleanup_freeargv (argv); init_callbacks (); gdbsim_desc = sim_open (SIM_OPEN_DEBUG, &gdb_callback, exec_bfd, argv); if (gdbsim_desc == 0) error ("unable to create simulator instance"); push_target (&gdbsim_ops); target_fetch_registers (-1); printf_filtered ("Connected to the simulator.\n"); }