/* This is called when a thread hits an interrupt at a GC safe point. This means
* that another thread is already trying to start a GC run, so we don't need to
* try and do that, just enlist in the run. */
void MVM_gc_enter_from_interrupt(MVMThreadContext *tc) {
MVMuint8 decr = 0;
AO_t curr;
tc->gc_work_count = 0;
add_work(tc, tc);
/* grab our child */
signal_child(tc);
/* Count us in to the GC run. Wait for a vote to steal. */
GCORCH_LOG(tc, "Thread %d run %d : Entered from interrupt\n");
while ((curr = tc->instance->gc_start) < 2
|| !MVM_trycas(&tc->instance->gc_start, curr, curr - 1)) {
/* apr_sleep(1);
apr_thread_yield();*/
}
/* Wait for all threads to indicate readiness to collect. */
while (tc->instance->gc_start) {
/* apr_sleep(1);
apr_thread_yield();*/
}
run_gc(tc, MVMGCWhatToDo_NoInstance);
}
static int
add_n_work_items(threadpool_t *tp, int n)
{
int n_queued = 0;
int n_try_cancel = 0, i;
workqueue_entry_t **to_cancel;
workqueue_entry_t *ent;
to_cancel = tor_malloc(sizeof(workqueue_entry_t*) * opt_n_cancel);
while (n_queued++ < n) {
ent = add_work(tp);
if (! ent) {
tor_event_base_loopexit(tor_libevent_get_base(), NULL);
return -1;
}
if (n_try_cancel < opt_n_cancel &&
tor_weak_random_range(&weak_rng, n) < opt_n_cancel) {
to_cancel[n_try_cancel++] = ent;
}
}
for (i = 0; i < n_try_cancel; ++i) {
void *work = workqueue_entry_cancel(to_cancel[i]);
if (! work) {
n_failed_cancel++;
} else {
n_successful_cancel++;
tor_free(work);
}
}
tor_free(to_cancel);
return 0;
}
static int grep_oid(struct grep_opt *opt, const struct object_id *oid,
const char *filename, int tree_name_len,
const char *path)
{
struct strbuf pathbuf = STRBUF_INIT;
if (opt->relative && opt->prefix_length) {
quote_path_relative(filename + tree_name_len, opt->prefix, &pathbuf);
strbuf_insert(&pathbuf, 0, filename, tree_name_len);
} else {
strbuf_addstr(&pathbuf, filename);
}
#ifndef NO_PTHREADS
if (num_threads) {
add_work(opt, GREP_SOURCE_OID, pathbuf.buf, path, oid);
strbuf_release(&pathbuf);
return 0;
} else
#endif
{
struct grep_source gs;
int hit;
grep_source_init(&gs, GREP_SOURCE_OID, pathbuf.buf, path, oid);
strbuf_release(&pathbuf);
hit = grep_source(opt, &gs);
grep_source_clear(&gs);
return hit;
}
}
static int grep_sha1(struct grep_opt *opt, const unsigned char *sha1,
const char *filename, int tree_name_len,
const char *path)
{
struct strbuf pathbuf = STRBUF_INIT;
if (opt->relative && opt->prefix_length) {
quote_path_relative(filename + tree_name_len, -1, &pathbuf,
opt->prefix);
strbuf_insert(&pathbuf, 0, filename, tree_name_len);
} else {
strbuf_addstr(&pathbuf, filename);
}
#ifndef NO_PTHREADS
if (use_threads) {
add_work(opt, GREP_SOURCE_SHA1, pathbuf.buf, path, sha1);
strbuf_release(&pathbuf);
return 0;
} else
#endif
{
struct grep_source gs;
int hit;
grep_source_init(&gs, GREP_SOURCE_SHA1, pathbuf.buf, path, sha1);
strbuf_release(&pathbuf);
hit = grep_source(opt, &gs);
grep_source_clear(&gs);
return hit;
}
}
static int grep_file(struct grep_opt *opt, const char *filename)
{
struct strbuf buf = STRBUF_INIT;
struct grep_source gs;
if (opt->relative && opt->prefix_length)
quote_path_relative(filename, opt->prefix, &buf);
else
strbuf_addstr(&buf, filename);
grep_source_init(&gs, GREP_SOURCE_FILE, buf.buf, filename, filename);
strbuf_release(&buf);
#ifndef NO_PTHREADS
if (num_threads) {
/*
* add_work() copies gs and thus assumes ownership of
* its fields, so do not call grep_source_clear()
*/
add_work(opt, &gs);
return 0;
} else
#endif
{
int hit;
hit = grep_source(opt, &gs);
grep_source_clear(&gs);
return hit;
}
}
static int grep_file(struct grep_opt *opt, const char *filename)
{
struct strbuf buf = STRBUF_INIT;
if (opt->relative && opt->prefix_length)
quote_path_relative(filename, -1, &buf, opt->prefix);
else
strbuf_addstr(&buf, filename);
#ifndef NO_PTHREADS
if (use_threads) {
add_work(opt, GREP_SOURCE_FILE, buf.buf, filename, filename);
strbuf_release(&buf);
return 0;
} else
#endif
{
struct grep_source gs;
int hit;
grep_source_init(&gs, GREP_SOURCE_FILE, buf.buf, filename, filename);
strbuf_release(&buf);
hit = grep_source(opt, &gs);
grep_source_clear(&gs);
return hit;
}
}
int submit_work(work_t *work, int thread_id){
if( (thread_id>=0) && (thread_id< pool->nb_threads)){
work->thread_id = thread_id;
add_work(&pool->list_lock[thread_id], &pool->cond_var[thread_id], &pool->working_list[thread_id], work);
return 1;
}
return 0;
}
static void grep_sha1_async(struct grep_opt *opt, char *name,
const unsigned char *sha1)
{
unsigned char *s;
s = xmalloc(20);
memcpy(s, sha1, 20);
add_work(WORK_SHA1, name, s);
}
static MVMuint32 signal_all_but(MVMThreadContext *tc, MVMThread *t, MVMThread *tail) {
MVMInstance *ins = tc->instance;
MVMuint32 i;
MVMuint32 count = 0;
MVMThread *next;
if (!t) {
return 0;
}
do {
next = t->body.next;
switch (t->body.stage) {
case MVM_thread_stage_starting:
case MVM_thread_stage_waiting:
case MVM_thread_stage_started:
if (t->body.tc != tc) {
count += signal_one_thread(tc, t->body.tc);
}
break;
case MVM_thread_stage_exited:
GCORCH_LOG(tc, "Thread %d run %d : queueing to clear nursery of thread %d\n", t->body.tc->thread_id);
add_work(tc, t->body.tc);
break;
case MVM_thread_stage_clearing_nursery:
GCORCH_LOG(tc, "Thread %d run %d : queueing to destroy thread %d\n", t->body.tc->thread_id);
/* last GC run for this thread */
add_work(tc, t->body.tc);
break;
case MVM_thread_stage_destroyed:
GCORCH_LOG(tc, "Thread %d run %d : found a destroyed thread\n");
/* will be cleaned up (removed from the lists) shortly */
break;
default:
MVM_panic(MVM_exitcode_gcorch, "Corrupted MVMThread or running threads list: invalid thread stage %d", t->body.stage);
}
} while (next && (t = next));
if (tail)
MVM_WB(tc, t, tail);
t->body.next = tail;
return count;
}
int
obf_encode_layer(obf_state_t *s, uint64_t n, int **pows, fmpz_mat_t *mats,
long idx, long inp, encode_layer_randomization_flag_t rflag)
{
char tag[10];
mmap_enc_mat_t **enc_mats;
char **names;
mmap_ro_pp pp = s->vtable->sk->pp(s->mmap);
long nrows, ncols;
/* TODO: check for mismatched matrices */
nrows = mats[0]->r;
ncols = mats[0]->c;
(void) snprintf(tag, 10, "%ld", idx);
if (!(s->flags & OBFUSCATOR_FLAG_NO_RANDOMIZATION)) {
double start, end;
start = current_time();
obf_randomize_layer(s, nrows, ncols, rflag, n, mats);
end = current_time();
if (s->flags & OBFUSCATOR_FLAG_VERBOSE)
(void) fprintf(stderr, " Randomizing matrix: %f\n", end - start);
}
enc_mats = calloc(n, sizeof(mmap_enc_mat_t *));
for (uint64_t c = 0; c < n; ++c) {
enc_mats[c] = malloc(sizeof(mmap_enc_mat_t));
mmap_enc_mat_init(s->vtable, pp, *enc_mats[c], nrows, ncols);
}
names = calloc(n, sizeof(char *));
for (uint64_t c = 0; c < n; ++c) {
names[c] = calloc(10, sizeof(char));
(void) snprintf(names[c], 10, "%lu", c);
}
if (add_work_write_layer(s, n, inp, idx, nrows, ncols, names, tag, enc_mats)
== OBFUSCATOR_ERR)
return OBFUSCATOR_ERR;
for (uint64_t c = 0; c < n; ++c) {
for (long i = 0; i < nrows; ++i) {
for (long j = 0; j < ncols; ++j) {
add_work(s, mats, enc_mats, pows, c, i, j, tag);
}
}
}
return OBFUSCATOR_OK;
}
static MVMuint32 signal_all_but(MVMThreadContext *tc, MVMThread *t, MVMThread *tail) {
MVMuint32 count = 0;
MVMThread *next;
if (!t) {
return 0;
}
do {
next = t->body.next;
switch (MVM_load(&t->body.stage)) {
case MVM_thread_stage_starting:
case MVM_thread_stage_waiting:
case MVM_thread_stage_started:
if (t->body.tc != tc) {
count += signal_one_thread(tc, t->body.tc);
}
break;
case MVM_thread_stage_exited:
GCDEBUG_LOG(tc, MVM_GC_DEBUG_ORCHESTRATE, "Thread %d run %d : queueing to clear nursery of thread %d\n", t->body.tc->thread_id);
add_work(tc, t->body.tc);
break;
case MVM_thread_stage_clearing_nursery:
GCDEBUG_LOG(tc, MVM_GC_DEBUG_ORCHESTRATE, "Thread %d run %d : queueing to destroy thread %d\n", t->body.tc->thread_id);
/* last GC run for this thread */
add_work(tc, t->body.tc);
break;
case MVM_thread_stage_destroyed:
GCDEBUG_LOG(tc, MVM_GC_DEBUG_ORCHESTRATE, "Thread %d run %d : found a destroyed thread\n");
/* will be cleaned up (removed from the lists) shortly */
break;
default:
MVM_panic(MVM_exitcode_gcorch, "Corrupted MVMThread or running threads list: invalid thread stage %"MVM_PRSz"", MVM_load(&t->body.stage));
}
} while (next && (t = next));
if (tail)
MVM_gc_write_barrier(tc, (MVMCollectable *)t, (MVMCollectable *)tail);
t->body.next = tail;
return count;
}
/*
* endpoint constructor (link with either port or join id)
*/
Endpoint::Endpoint(unsigned int port_id, unsigned int join_id)
{
class Port *port;
class Endpoint **epointpointer;
int earlyb = 0;
/* epoint structure */
PDEBUG(DEBUG_EPOINT, "EPOINT(%d): Allocating enpoint %d and connecting it with:%s%s\n", epoint_serial, epoint_serial, (port_id)?" ioport":"", (join_id)?" join":"");
ep_portlist = NULL;
ep_app = NULL;
memset(&ep_delete, 0, sizeof(ep_delete));
add_work(&ep_delete, delete_endpoint, this, 0);
ep_use = 1;
/* add endpoint to chain */
next = NULL;
epointpointer = &epoint_first;
while(*epointpointer)
epointpointer = &((*epointpointer)->next);
*epointpointer = this;
/* serial */
ep_serial = epoint_serial++;
/* link to join or port */
if (port_id) {
port = find_port_id(port_id);
if (port) {
#ifdef WITH_MISDN
if ((port->p_type&PORT_CLASS_MASK) == PORT_CLASS_mISDN)
earlyb = ((class PmISDN *)port)->p_m_mISDNport->earlyb;
#else
earlyb = 0;
#endif
if (!portlist_new(port_id, port->p_type, earlyb))
FATAL("No memory for portlist.\n");
}
}
ep_join_id = join_id;
ep_park = 0;
ep_park_len = 0;
classuse++;
}
/*
* Prep grep structures for a submodule grep
* sha1: the sha1 of the submodule or NULL if using the working tree
* filename: name of the submodule including tree name of parent
* path: location of the submodule
*/
static int grep_submodule(struct grep_opt *opt, const unsigned char *sha1,
const char *filename, const char *path)
{
if (!is_submodule_initialized(path))
return 0;
if (!is_submodule_populated(path)) {
/*
* If searching history, check for the presense of the
* submodule's gitdir before skipping the submodule.
*/
if (sha1) {
const struct submodule *sub =
submodule_from_path(null_sha1, path);
if (sub)
path = git_path("modules/%s", sub->name);
if (!(is_directory(path) && is_git_directory(path)))
return 0;
} else {
return 0;
}
}
#ifndef NO_PTHREADS
if (num_threads) {
add_work(opt, GREP_SOURCE_SUBMODULE, filename, path, sha1);
return 0;
} else
#endif
{
struct work_item w;
int hit;
grep_source_init(&w.source, GREP_SOURCE_SUBMODULE,
filename, path, sha1);
strbuf_init(&w.out, 0);
opt->output_priv = &w;
hit = grep_submodule_launch(opt, &w.source);
write_or_die(1, w.out.buf, w.out.len);
grep_source_clear(&w.source);
strbuf_release(&w.out);
return hit;
}
}
/* This is called when a thread hits an interrupt at a GC safe point. This means
* that another thread is already trying to start a GC run, so we don't need to
* try and do that, just enlist in the run. */
void MVM_gc_enter_from_interrupt(MVMThreadContext *tc) {
AO_t curr;
GCDEBUG_LOG(tc, MVM_GC_DEBUG_ORCHESTRATE, "Thread %d run %d : Entered from interrupt\n");
MVM_telemetry_timestamp(tc, "gc_enter_from_interrupt");
/* If profiling, record that GC is starting. */
if (tc->instance->profiling)
MVM_profiler_log_gc_start(tc, is_full_collection(tc));
/* We'll certainly take care of our own work. */
tc->gc_work_count = 0;
add_work(tc, tc);
/* Indicate that we're ready to GC. Only want to decrement it if it's 2 or
* greater (0 should never happen; 1 means the coordinator is still counting
* up how many threads will join in, so we should wait until it decides to
* decrement.) */
while ((curr = MVM_load(&tc->instance->gc_start)) < 2
|| !MVM_trycas(&tc->instance->gc_start, curr, curr - 1)) {
/* MVM_platform_thread_yield();*/
}
/* Wait for all threads to indicate readiness to collect. */
GCDEBUG_LOG(tc, MVM_GC_DEBUG_ORCHESTRATE, "Thread %d run %d : Waiting for other threads\n");
while (MVM_load(&tc->instance->gc_start)) {
/* MVM_platform_thread_yield();*/
}
GCDEBUG_LOG(tc, MVM_GC_DEBUG_ORCHESTRATE, "Thread %d run %d : Entering run_gc\n");
run_gc(tc, MVMGCWhatToDo_NoInstance);
GCDEBUG_LOG(tc, MVM_GC_DEBUG_ORCHESTRATE, "Thread %d run %d : GC complete\n");
/* If profiling, record that GC is over. */
if (tc->instance->profiling)
MVM_profiler_log_gc_end(tc);
}
/* Goes through all threads but the current one and notifies them that a
* GC run is starting. Those that are blocked are considered excluded from
* the run, and are not counted. Returns the count of threads that should be
* added to the finished countdown. */
static MVMuint32 signal_one_thread(MVMThreadContext *tc, MVMThreadContext *to_signal) {
/* Loop here since we may not succeed first time (e.g. the status of the
* thread may change between the two ways we try to twiddle it). */
while (1) {
switch (MVM_load(&to_signal->gc_status)) {
case MVMGCStatus_NONE:
/* Try to set it from running to interrupted - the common case. */
if (MVM_cas(&to_signal->gc_status, MVMGCStatus_NONE,
MVMGCStatus_INTERRUPT) == MVMGCStatus_NONE) {
GCDEBUG_LOG(tc, MVM_GC_DEBUG_ORCHESTRATE, "Thread %d run %d : Signalled thread %d to interrupt\n", to_signal->thread_id);
return 1;
}
break;
case MVMGCStatus_INTERRUPT:
GCDEBUG_LOG(tc, MVM_GC_DEBUG_ORCHESTRATE, "Thread %d run %d : thread %d already interrupted\n", to_signal->thread_id);
return 0;
case MVMGCStatus_UNABLE:
/* Otherwise, it's blocked; try to set it to work Stolen. */
if (MVM_cas(&to_signal->gc_status, MVMGCStatus_UNABLE,
MVMGCStatus_STOLEN) == MVMGCStatus_UNABLE) {
GCDEBUG_LOG(tc, MVM_GC_DEBUG_ORCHESTRATE, "Thread %d run %d : A blocked thread %d spotted; work stolen\n", to_signal->thread_id);
add_work(tc, to_signal);
return 0;
}
break;
/* this case occurs if a child thread is Stolen by its parent
* before we get to it in the chain. */
case MVMGCStatus_STOLEN:
GCDEBUG_LOG(tc, MVM_GC_DEBUG_ORCHESTRATE, "Thread %d run %d : thread %d already stolen (it was a spawning child)\n", to_signal->thread_id);
return 0;
default:
MVM_panic(MVM_exitcode_gcorch, "invalid status %"MVM_PRSz" in GC orchestrate\n", MVM_load(&to_signal->gc_status));
return 0;
}
}
}
/*
* constructor for a new join
* the join will have a relation to the calling endpoint
*/
JoinPBX::JoinPBX(class Endpoint *epoint) : Join()
{
struct join_relation *relation;
// char filename[256];
if (!epoint)
FATAL("epoint is NULL.\n");
PDEBUG(DEBUG_JOIN, "creating new join and connecting it to the endpoint.\n");
j_type = JOIN_TYPE_PBX;
j_caller[0] = '\0';
j_caller_id[0] = '\0';
j_dialed[0] = '\0';
j_todial[0] = '\0';
j_pid = getpid();
j_partyline = 0;
j_partyline_jingle = 0;
j_3pty = 0;
j_multicause = 0;
j_multilocation = 0;
memset(&j_updatebridge, 0, sizeof(j_updatebridge));
add_work(&j_updatebridge, update_bridge, this, 0);
/* initialize a relation only to the calling interface */
relation = j_relation = (struct join_relation *)MALLOC(sizeof(struct join_relation));
cmemuse++;
relation->type = RELATION_TYPE_CALLING;
relation->channel_state = 0; /* audio is assumed on a new join */
relation->tx_state = NOTIFY_STATE_ACTIVE; /* new joins always assumed to be active */
relation->rx_state = NOTIFY_STATE_ACTIVE; /* new joins always assumed to be active */
relation->epoint_id = epoint->ep_serial;
if (options.deb & DEBUG_JOIN)
joinpbx_debug(this, "JoinPBX::Constructor(new join)");
}
static int grep_oid(struct grep_opt *opt, const struct object_id *oid,
const char *filename, int tree_name_len,
const char *path)
{
struct strbuf pathbuf = STRBUF_INIT;
struct grep_source gs;
if (opt->relative && opt->prefix_length) {
quote_path_relative(filename + tree_name_len, opt->prefix, &pathbuf);
strbuf_insert(&pathbuf, 0, filename, tree_name_len);
} else {
strbuf_addstr(&pathbuf, filename);
}
grep_source_init(&gs, GREP_SOURCE_OID, pathbuf.buf, path, oid);
strbuf_release(&pathbuf);
#ifndef NO_PTHREADS
if (num_threads) {
/*
* add_work() copies gs and thus assumes ownership of
* its fields, so do not call grep_source_clear()
*/
add_work(opt, &gs);
return 0;
} else
#endif
{
int hit;
hit = grep_source(opt, &gs);
grep_source_clear(&gs);
return hit;
}
}
/**
* do_add
*
* Prepares a PCI hot plug slot for adding an adapter, then
* configures the adapter and any PCI adapters below into
* the Open Firmware device tree.
*
* Verifies that a given hot plug PCI slot does not have an adapter
* already connected, identifies the slot to the user unless requested not
* to with the -i flag, prompts the user to connect the adapter, powers
* the slot on, and calls configure connector. When configure connector
* completes and returns the new node(s) for the new PCI adapter and any
* attached devices then the Open Firmware device tree is
* updated to reflect the new devices.
*/
static int
do_add(struct options *opts, struct dr_node *all_nodes)
{
struct dr_node *node;
int usr_key = USER_CONT;
int rc;
node = find_slot(opts->usr_drc_name, all_nodes);
if (node == NULL)
return -1;
/* Prompt user only if in interactive mode. */
if (0 == opts->noprompt) {
if (!opts->no_ident)
usr_key = identify_slot(node);
if (usr_key == USER_QUIT) {
if (node->children == NULL)
process_led(node, LED_OFF);
else
process_led(node, LED_ON);
return 0;
}
}
if (node->children != NULL) {
/* If there's already something here, turn the
* LED on and exit with user error.
*/
process_led(node, LED_ON);
say(ERROR, "The specified PCI slot is already occupied.\n");
return -1;
}
/* Now it's time to isolate, power off, set the
* action LED, and prompt the user to put the
* card in.
*/
say(DEBUG, "is calling rtas_set_indicator(ISOLATE index 0x%x)\n",
node->drc_index);
rc = rtas_set_indicator(ISOLATION_STATE, node->drc_index, ISOLATE);
if (rc) {
if (rc == HW_ERROR)
say(ERROR, "%s", hw_error);
else
say(ERROR, "%s", sw_error);
set_power(node->drc_power, POWER_OFF);
return -1;
}
say(DEBUG, "is calling set_power(POWER_OFF index 0x%x, "
"power_domain 0x%x) \n", node->drc_index, node->drc_power);
rc = set_power(node->drc_power, POWER_OFF);
if (rc) {
if (rc == HW_ERROR)
say(ERROR, "%s", hw_error);
else
say(ERROR, "%s", sw_error);
return -1;
}
if (0 == opts->noprompt) {
/* Prompt user to put in card and to press
* Enter to continue or other key to exit.
*/
if (process_led(node, LED_ACTION))
return -1;
printf("The visual indicator for the specified PCI slot has\n"
"been set to the action state. Insert the PCI card\n"
"into the identified slot, connect any devices to be\n"
"configured and press Enter to continue. Enter x to "
"exit.\n");
if (!(getchar() == '\n')) {
process_led(node, LED_OFF);
return 0;
}
}
/* Call the routine which determines
* what the user wants and does it.
*/
rc = add_work(opts, node);
if (rc)
return rc;
say(DEBUG, "is calling enable_slot to config adapter\n");
/* Try to config the adapter */
set_hp_adapter_status(PHP_CONFIG_ADAPTER, node->drc_name);
return 0;
}
static void grep_file_async(struct grep_opt *opt, char *name,
const char *filename)
{
add_work(WORK_FILE, name, xstrdup(filename));
}
/**
* do_replace
* @brief Allows the replacement of an adapter connected to a
* PCI hot plug slot
*
* A replace may be specified by the location code of the PCI slot.
* Unless the user specifies the -I flag, the slot is identified to
* the user.
* Nodes representing the old device(s) are removed from the
* Open Firmware device tree. The slot is isolated and powered off,
* and the LED is set to the ACTION state. The user is prompted to replace
* the adpater. The slot is powered on and unisolated and configure
* connector is executed.
*
* If there are any errors from the RTAS routines,
* the slot is powered off, isolated, and the LED is turned off. If the
* original adapter has been removed, it is left in that state.
* If the OF tree cannot be updated, the slot is powered
* off, isolated, and the LED is turned off.
*/
static int
do_replace(struct options *opts, struct dr_node *all_nodes)
{
struct dr_node *repl_node;
int rc;
/* Call the routine which does the work of getting the node info,
* then removing it from the OF device tree.
*/
repl_node = remove_work(opts, all_nodes);
if (repl_node == NULL)
return -1;
if (!repl_node->children) {
say(ERROR, "Bad node struct.\n");
return -1;
}
say(DEBUG, "repl_node:path=%s node:path=%s\n",
repl_node->ofdt_path, repl_node->children->ofdt_path);
/* Prompt user to replace card and to press
* Enter to continue or x to exit. Exiting here
* means the original card has been removed.
*/
if (0 == opts->noprompt) {
if (process_led(repl_node, LED_ACTION))
return -1;
printf("The visual indicator for the specified PCI slot "
"has\nbeen set to the action state. Replace the PCI "
"card\nin the identified slot and press Enter to "
"continue.\nEnter x to exit. Exiting now leaves the "
"PCI slot\nin the removed state.\n");
if (!(getchar() == '\n')) {
process_led(repl_node, LED_OFF);
return 0;
}
}
rc = add_work(opts, repl_node);
if (rc)
return rc;
say(DEBUG, "CONFIGURING the card in node[name=%s, path=%s]\n",
repl_node->drc_name, repl_node->ofdt_path);
set_hp_adapter_status(PHP_CONFIG_ADAPTER, repl_node->drc_name);
if (repl_node->post_replace_processing) {
int prompt_save = opts->noprompt;
say(DEBUG, "Doing post replacement processing...\n");
/* disable prompting for post-processing */
opts->noprompt = 1;
repl_node = remove_work(opts, repl_node);
rc = add_work(opts, repl_node);
if (!rc)
set_hp_adapter_status(PHP_CONFIG_ADAPTER,
repl_node->drc_name);
opts->noprompt = prompt_save;
}
return rc;
}
int
main(int argc, char **argv)
{
replyqueue_t *rq;
threadpool_t *tp;
int i;
tor_libevent_cfg evcfg;
struct event *ev;
uint32_t as_flags = 0;
for (i = 1; i < argc; ++i) {
if (!strcmp(argv[i], "-v")) {
opt_verbose = 1;
} else if (!strcmp(argv[i], "-T") && i+1<argc) {
opt_n_threads = atoi(argv[++i]);
} else if (!strcmp(argv[i], "-N") && i+1<argc) {
opt_n_items = atoi(argv[++i]);
} else if (!strcmp(argv[i], "-I") && i+1<argc) {
opt_n_inflight = atoi(argv[++i]);
} else if (!strcmp(argv[i], "-L") && i+1<argc) {
opt_n_lowwater = atoi(argv[++i]);
} else if (!strcmp(argv[i], "-R") && i+1<argc) {
opt_ratio_rsa = atoi(argv[++i]);
} else if (!strcmp(argv[i], "-C") && i+1<argc) {
opt_n_cancel = atoi(argv[++i]);
} else if (!strcmp(argv[i], "--no-eventfd2")) {
as_flags |= ASOCKS_NOEVENTFD2;
} else if (!strcmp(argv[i], "--no-eventfd")) {
as_flags |= ASOCKS_NOEVENTFD;
} else if (!strcmp(argv[i], "--no-pipe2")) {
as_flags |= ASOCKS_NOPIPE2;
} else if (!strcmp(argv[i], "--no-pipe")) {
as_flags |= ASOCKS_NOPIPE;
} else if (!strcmp(argv[i], "--no-socketpair")) {
as_flags |= ASOCKS_NOSOCKETPAIR;
} else if (!strcmp(argv[i], "-h")) {
help();
return 0;
} else {
help();
return 1;
}
}
if (opt_n_threads < 1 ||
opt_n_items < 1 || opt_n_inflight < 1 || opt_n_lowwater < 0 ||
opt_n_cancel > opt_n_inflight || opt_n_inflight > MAX_INFLIGHT ||
opt_ratio_rsa < 0) {
help();
return 1;
}
init_logging(1);
crypto_global_init(1, NULL, NULL);
crypto_seed_rng(1);
rq = replyqueue_new(as_flags);
tor_assert(rq);
tp = threadpool_new(opt_n_threads,
rq, new_state, free_state, NULL);
tor_assert(tp);
crypto_seed_weak_rng(&weak_rng);
memset(&evcfg, 0, sizeof(evcfg));
tor_libevent_initialize(&evcfg);
ev = tor_event_new(tor_libevent_get_base(),
replyqueue_get_socket(rq), EV_READ|EV_PERSIST,
replysock_readable_cb, tp);
event_add(ev, NULL);
#ifdef TRACK_RESPONSES
handled = bitarray_init_zero(opt_n_items);
received = bitarray_init_zero(opt_n_items);
tor_mutex_init(&bitmap_mutex);
handled_len = opt_n_items;
#endif
for (i = 0; i < opt_n_inflight; ++i) {
if (! add_work(tp)) {
puts("Couldn't add work.");
return 1;
}
}
{
struct timeval limit = { 30, 0 };
tor_event_base_loopexit(tor_libevent_get_base(), &limit);
}
event_base_loop(tor_libevent_get_base(), 0);
if (n_sent != opt_n_items || n_received+n_successful_cancel != n_sent) {
printf("%d vs %d\n", n_sent, opt_n_items);
printf("%d+%d vs %d\n", n_received, n_successful_cancel, n_sent);
puts("FAIL");
return 1;
} else {
puts("OK");
return 0;
}
}
/* This is called when the allocator finds it has run out of memory and wants
* to trigger a GC run. In this case, it's possible (probable, really) that it
* will need to do that triggering, notifying other running threads that the
* time has come to GC. */
void MVM_gc_enter_from_allocator(MVMThreadContext *tc) {
GCORCH_LOG(tc, "Thread %d run %d : Entered from allocate\n");
/* Try to start the GC run. */
if (MVM_trycas(&tc->instance->gc_start, 0, 1)) {
MVMThread *last_starter = NULL;
MVMuint32 num_threads = 0;
/* We are the winner of the GC starting race. This gives us some
* extra responsibilities as well as doing the usual things.
* First, increment GC sequence number. */
tc->instance->gc_seq_number++;
GCORCH_LOG(tc, "Thread %d run %d : GC thread elected coordinator: starting gc seq %d\n", tc->instance->gc_seq_number);
/* Ensure our stolen list is empty. */
tc->gc_work_count = 0;
/* need to wait for other threads to reset their gc_status. */
while (tc->instance->gc_ack)
apr_thread_yield();
add_work(tc, tc);
/* grab our child */
signal_child(tc);
do {
if (tc->instance->threads && tc->instance->threads != last_starter) {
MVMThread *head;
MVMuint32 add;
while (!MVM_trycas(&tc->instance->threads, (head = tc->instance->threads), NULL));
add = signal_all_but(tc, head, last_starter);
last_starter = head;
if (add) {
GCORCH_LOG(tc, "Thread %d run %d : Found %d other threads\n", add);
MVM_atomic_add(&tc->instance->gc_start, add);
num_threads += add;
}
}
} while (tc->instance->gc_start > 1);
if (!MVM_trycas(&tc->instance->threads, NULL, last_starter))
MVM_panic(MVM_exitcode_gcorch, "threads list corrupted\n");
if (tc->instance->gc_finish != 0)
MVM_panic(MVM_exitcode_gcorch, "finish votes was %d\n", tc->instance->gc_finish);
tc->instance->gc_ack = tc->instance->gc_finish = num_threads + 1;
GCORCH_LOG(tc, "Thread %d run %d : finish votes is %d\n", (int)tc->instance->gc_finish);
/* signal to the rest to start */
if (MVM_atomic_decr(&tc->instance->gc_start) != 1)
MVM_panic(MVM_exitcode_gcorch, "start votes was %d\n", tc->instance->gc_finish);
run_gc(tc, MVMGCWhatToDo_All);
}
else {
/* Another thread beat us to starting the GC sync process. Thus, act as
* if we were interrupted to GC. */
GCORCH_LOG(tc, "Thread %d run %d : Lost coordinator election\n");
MVM_gc_enter_from_interrupt(tc);
}
}
/* This is called when the allocator finds it has run out of memory and wants
* to trigger a GC run. In this case, it's possible (probable, really) that it
* will need to do that triggering, notifying other running threads that the
* time has come to GC. */
void MVM_gc_enter_from_allocator(MVMThreadContext *tc) {
GCDEBUG_LOG(tc, MVM_GC_DEBUG_ORCHESTRATE, "Thread %d run %d : Entered from allocate\n");
/* Try to start the GC run. */
if (MVM_trycas(&tc->instance->gc_start, 0, 1)) {
MVMThread *last_starter = NULL;
MVMuint32 num_threads = 0;
MVMuint32 is_full;
/* Need to wait for other threads to reset their gc_status. */
while (MVM_load(&tc->instance->gc_ack)) {
GCDEBUG_LOG(tc, MVM_GC_DEBUG_ORCHESTRATE,
"Thread %d run %d : waiting for other thread's gc_ack\n");
MVM_platform_thread_yield();
}
/* We are the winner of the GC starting race. This gives us some
* extra responsibilities as well as doing the usual things.
* First, increment GC sequence number. */
MVM_incr(&tc->instance->gc_seq_number);
GCDEBUG_LOG(tc, MVM_GC_DEBUG_ORCHESTRATE,
"Thread %d run %d : GC thread elected coordinator: starting gc seq %d\n",
(int)MVM_load(&tc->instance->gc_seq_number));
/* Decide if it will be a full collection. */
is_full = is_full_collection(tc);
/* If profiling, record that GC is starting. */
if (tc->instance->profiling)
MVM_profiler_log_gc_start(tc, is_full);
/* Ensure our stolen list is empty. */
tc->gc_work_count = 0;
/* Flag that we didn't agree on this run that all the in-trays are
* cleared (a responsibility of the co-ordinator. */
MVM_store(&tc->instance->gc_intrays_clearing, 1);
/* We'll take care of our own work. */
add_work(tc, tc);
/* Find other threads, and signal or steal. */
do {
MVMThread *threads = (MVMThread *)MVM_load(&tc->instance->threads);
if (threads && threads != last_starter) {
MVMThread *head = threads;
MVMuint32 add;
while ((threads = (MVMThread *)MVM_casptr(&tc->instance->threads, head, NULL)) != head) {
head = threads;
}
add = signal_all_but(tc, head, last_starter);
last_starter = head;
if (add) {
GCDEBUG_LOG(tc, MVM_GC_DEBUG_ORCHESTRATE, "Thread %d run %d : Found %d other threads\n", add);
MVM_add(&tc->instance->gc_start, add);
num_threads += add;
}
}
/* If there's an event loop thread, wake it up to participate. */
if (tc->instance->event_loop_wakeup)
uv_async_send(tc->instance->event_loop_wakeup);
} while (MVM_load(&tc->instance->gc_start) > 1);
/* Sanity checks. */
if (!MVM_trycas(&tc->instance->threads, NULL, last_starter))
MVM_panic(MVM_exitcode_gcorch, "threads list corrupted\n");
if (MVM_load(&tc->instance->gc_finish) != 0)
MVM_panic(MVM_exitcode_gcorch, "Finish votes was %"MVM_PRSz"\n", MVM_load(&tc->instance->gc_finish));
/* gc_ack gets an extra so the final acknowledger
* can also free the STables. */
MVM_store(&tc->instance->gc_finish, num_threads + 1);
MVM_store(&tc->instance->gc_ack, num_threads + 2);
GCDEBUG_LOG(tc, MVM_GC_DEBUG_ORCHESTRATE, "Thread %d run %d : finish votes is %d\n",
(int)MVM_load(&tc->instance->gc_finish));
/* Now we're ready to start, zero promoted since last full collection
* counter if this is a full collect. */
if (is_full)
MVM_store(&tc->instance->gc_promoted_bytes_since_last_full, 0);
/* Signal to the rest to start */
GCDEBUG_LOG(tc, MVM_GC_DEBUG_ORCHESTRATE, "Thread %d run %d : coordinator signalling start\n");
if (MVM_decr(&tc->instance->gc_start) != 1)
MVM_panic(MVM_exitcode_gcorch, "Start votes was %"MVM_PRSz"\n", MVM_load(&tc->instance->gc_start));
/* Start collecting. */
GCDEBUG_LOG(tc, MVM_GC_DEBUG_ORCHESTRATE, "Thread %d run %d : coordinator entering run_gc\n");
run_gc(tc, MVMGCWhatToDo_All);
/* Free any STables that have been marked for deletion. It's okay for
* us to muck around in another thread's fromspace while it's mutating
* tospace, really. */
GCDEBUG_LOG(tc, MVM_GC_DEBUG_ORCHESTRATE, "Thread %d run %d : Freeing STables if needed\n");
MVM_gc_collect_free_stables(tc);
/* If profiling, record that GC is over. */
if (tc->instance->profiling)
MVM_profiler_log_gc_end(tc);
GCDEBUG_LOG(tc, MVM_GC_DEBUG_ORCHESTRATE, "Thread %d run %d : GC complete (cooridnator)\n");
}
else {
/* Another thread beat us to starting the GC sync process. Thus, act as
* if we were interrupted to GC. */
GCDEBUG_LOG(tc, MVM_GC_DEBUG_ORCHESTRATE, "Thread %d run %d : Lost coordinator election\n");
MVM_gc_enter_from_interrupt(tc);
}
}
int
main(int argc, char *argv[])
{
WT_CONNECTION *wt_conn;
WT_SESSION *session;
int i;
char cmd_buf[256];
(void)argc; /* Unused variable */
(void)testutil_set_progname(argv);
(void)snprintf(cmd_buf, sizeof(cmd_buf),
"rm -rf %s && mkdir %s", home, home);
error_check(system(cmd_buf));
error_check(wiredtiger_open(home, NULL, CONN_CONFIG, &wt_conn));
setup_directories();
error_check(wt_conn->open_session(wt_conn, NULL, NULL, &session));
error_check(session->create(
session, uri, "key_format=S,value_format=S"));
printf("Adding initial data\n");
add_work(session, 0);
printf("Taking initial backup\n");
take_full_backup(session, 0);
error_check(session->checkpoint(session, NULL));
for (i = 1; i < MAX_ITERATIONS; i++) {
printf("Iteration %d: adding data\n", i);
add_work(session, i);
error_check(session->checkpoint(session, NULL));
/*
* The full backup here is only needed for testing and
* comparison purposes. A normal incremental backup
* procedure would not include this.
*/
printf("Iteration %d: taking full backup\n", i);
take_full_backup(session, i);
/*
* Taking the incremental backup also calls truncate
* to archive the log files, if the copies were successful.
* See that function for details on that call.
*/
printf("Iteration %d: taking incremental backup\n", i);
take_incr_backup(session, i);
printf("Iteration %d: dumping and comparing data\n", i);
error_check(compare_backups(i));
}
/*
* Close the connection. We're done and want to run the final
* comparison between the incremental and original.
*/
error_check(wt_conn->close(wt_conn, NULL));
printf("Final comparison: dumping and comparing data\n");
error_check(compare_backups(0));
return (EXIT_SUCCESS);
}
