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");
}