VALUE native_slot_get(upb_fieldtype_t type,
VALUE type_class,
const void* memory) {
switch (type) {
case UPB_TYPE_FLOAT:
return DBL2NUM(DEREF(memory, float));
case UPB_TYPE_DOUBLE:
return DBL2NUM(DEREF(memory, double));
case UPB_TYPE_BOOL:
return DEREF(memory, int8_t) ? Qtrue : Qfalse;
case UPB_TYPE_STRING:
case UPB_TYPE_BYTES:
case UPB_TYPE_MESSAGE:
return DEREF(memory, VALUE);
case UPB_TYPE_ENUM: {
int32_t val = DEREF(memory, int32_t);
VALUE symbol = enum_lookup(type_class, INT2NUM(val));
if (symbol == Qnil) {
return INT2NUM(val);
} else {
return symbol;
}
}
case UPB_TYPE_INT32:
return INT2NUM(DEREF(memory, int32_t));
case UPB_TYPE_INT64:
return LL2NUM(DEREF(memory, int64_t));
case UPB_TYPE_UINT32:
return UINT2NUM(DEREF(memory, uint32_t));
case UPB_TYPE_UINT64:
return ULL2NUM(DEREF(memory, uint64_t));
default:
return Qnil;
}
}
/*ARGSUSED*/
static int
configd_thread(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
thread_info_t t;
char state[20];
char oldstate[20];
if (!(flags & DCMD_ADDRSPEC)) {
if (mdb_walk_dcmd("configd_threads", "configd_thread", argc,
argv) == -1) {
mdb_warn("can't walk 'configd_threads'");
return (DCMD_ERR);
}
return (DCMD_OK);
}
if (argc != 0)
return (DCMD_USAGE);
if (DCMD_HDRSPEC(flags)) {
mdb_printf("%<u>%-?s %5s %-12s %-12s %-?s %-?s %-?s%</u>\n",
"ADDR", "TID", "STATE", "PREV_STATE", "CLIENT", "CLIENTRQ",
"MAINREQ");
}
if (mdb_vread(&t, sizeof (t), addr) == -1) {
mdb_warn("failed to read thread_info_t at %p", addr);
return (DCMD_ERR);
}
enum_lookup(state, sizeof (state), thread_state_enum,
t.ti_state, "TI_", "");
make_lower(state, sizeof (state));
enum_lookup(oldstate, sizeof (oldstate), thread_state_enum,
t.ti_prev_state, "TI_", "");
make_lower(oldstate, sizeof (oldstate));
mdb_printf("%0?p %5d %-12s %-12s %?p %?p %?p\n",
(void *)addr, t.ti_thread, state, oldstate,
t.ti_active_client, t.ti_client_request, t.ti_main_door_request);
return (DCMD_OK);
}
static int
request_log(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
request_log_entry_t cur;
hrtime_t dur;
hrtime_t dursec;
hrtime_t durnsec;
char durstr[20];
char stampstr[20];
char requstr[30];
char respstr[30];
char typestr[30];
uintptr_t node = 0;
uintptr_t client = 0;
uint64_t clientid = 0;
int idx;
int opt_v = FALSE; /* verbose */
if (!(flags & DCMD_ADDRSPEC)) {
if (mdb_walk_dcmd("configd_log", "configd_log", argc,
argv) == -1) {
mdb_warn("can't walk 'configd_log'");
return (DCMD_ERR);
}
return (DCMD_OK);
}
if (mdb_getopts(argc, argv,
'c', MDB_OPT_UINTPTR, &client,
'i', MDB_OPT_UINT64, &clientid,
'n', MDB_OPT_UINTPTR, &node,
'v', MDB_OPT_SETBITS, TRUE, &opt_v, NULL) != argc)
return (DCMD_USAGE);
if (DCMD_HDRSPEC(flags)) {
mdb_printf("%<u>%-?s %-4s %-14s %9s %-22s %-17s\n%</u>",
"ADDR", "THRD", "START", "DURATION", "REQUEST",
"RESPONSE");
}
if (mdb_vread(&cur, sizeof (cur), addr) == -1) {
mdb_warn("couldn't read log entry at %p", addr);
return (DCMD_ERR);
}
/*
* apply filters, if any.
*/
if (clientid != 0 && clientid != cur.rl_clientid)
return (DCMD_OK);
if (client != 0 && client != (uintptr_t)cur.rl_client)
return (DCMD_OK);
if (node != 0) {
for (idx = 0; idx < MIN(MAX_PTRS, cur.rl_num_ptrs); idx++) {
if ((uintptr_t)cur.rl_ptrs[idx].rlp_data == node) {
node = 0; /* found it */
break;
}
}
if (node != 0)
return (DCMD_OK);
}
enum_lookup(requstr, sizeof (requstr), request_enum, cur.rl_request,
"REP_PROTOCOL_", "");
if (cur.rl_end != 0) {
enum_lookup(respstr, sizeof (respstr), response_enum,
cur.rl_response, "REP_PROTOCOL_", "FAIL_");
dur = cur.rl_end - cur.rl_start;
dursec = dur / NANOSEC;
durnsec = dur % NANOSEC;
if (dursec <= 9)
mdb_snprintf(durstr, sizeof (durstr),
"%lld.%06lld",
dursec, durnsec / (NANOSEC / MICROSEC));
else if (dursec <= 9999)
mdb_snprintf(durstr, sizeof (durstr),
"%lld.%03lld",
dursec, NSEC2MSEC(durnsec));
else
mdb_snprintf(durstr, sizeof (durstr),
"%lld", dursec);
} else {
(void) strcpy(durstr, "-");
(void) strcpy(respstr, "-");
}
if (max_time_seen != 0 && max_time_seen >= cur.rl_start) {
dur = max_time_seen - cur.rl_start;
dursec = dur / NANOSEC;
durnsec = dur % NANOSEC;
if (dursec <= 99ULL)
mdb_snprintf(stampstr, sizeof (stampstr),
"-%lld.%09lld", dursec, durnsec);
else if (dursec <= 99999ULL)
mdb_snprintf(stampstr, sizeof (stampstr),
"-%lld.%06lld",
dursec, durnsec / (NANOSEC / MICROSEC));
else if (dursec <= 99999999ULL)
mdb_snprintf(stampstr, sizeof (stampstr),
"-%lld.%03lld",
dursec, NSEC2MSEC(durnsec));
else
mdb_snprintf(stampstr, sizeof (stampstr),
"-%lld", dursec);
} else {
(void) strcpy(stampstr, "-");
}
mdb_printf("%0?x %4d T%13s %9s %-22s %-17s\n",
addr, cur.rl_tid, stampstr, durstr, requstr, respstr);
if (opt_v) {
mdb_printf("\tclient: %?p (%d)\tptrs: %d\tstamp: %llx\n",
cur.rl_client, cur.rl_clientid, cur.rl_num_ptrs,
cur.rl_start);
for (idx = 0; idx < MIN(MAX_PTRS, cur.rl_num_ptrs); idx++) {
enum_lookup(typestr, sizeof (typestr), ptr_type_enum,
cur.rl_ptrs[idx].rlp_type, "RC_PTR_TYPE_", "");
mdb_printf("\t\t%-7s %5d %?p %?p\n", typestr,
cur.rl_ptrs[idx].rlp_id, cur.rl_ptrs[idx].rlp_ptr,
cur.rl_ptrs[idx].rlp_data);
}
mdb_printf("\n");
}
return (DCMD_OK);
}
void
print_idmapdstate(void)
{
int i, j;
idmap_pg_config_t *pgcfg;
idmap_trustedforest_t *tf;
RDLOCK_CONFIG();
if (_idmapdstate.cfg == NULL) {
idmapdlog(LOG_INFO, "Null configuration");
UNLOCK_CONFIG();
return;
}
pgcfg = &_idmapdstate.cfg->pgcfg;
idmapdlog(LOG_DEBUG, "list_size_limit=%llu", pgcfg->list_size_limit);
idmapdlog(LOG_DEBUG, "default_domain=%s",
CHECK_NULL(pgcfg->default_domain));
idmapdlog(LOG_DEBUG, "domain_name=%s", CHECK_NULL(pgcfg->domain_name));
idmapdlog(LOG_DEBUG, "machine_sid=%s", CHECK_NULL(pgcfg->machine_sid));
if (pgcfg->domain_controller == NULL ||
pgcfg->domain_controller[0].host[0] == '\0') {
idmapdlog(LOG_DEBUG, "No domain controllers known");
} else {
for (i = 0; pgcfg->domain_controller[i].host[0] != '\0'; i++)
idmapdlog(LOG_DEBUG, "domain_controller=%s port=%d",
pgcfg->domain_controller[i].host,
pgcfg->domain_controller[i].port);
}
idmapdlog(LOG_DEBUG, "forest_name=%s", CHECK_NULL(pgcfg->forest_name));
idmapdlog(LOG_DEBUG, "site_name=%s", CHECK_NULL(pgcfg->site_name));
if (pgcfg->global_catalog == NULL ||
pgcfg->global_catalog[0].host[0] == '\0') {
idmapdlog(LOG_DEBUG, "No global catalog servers known");
} else {
for (i = 0; pgcfg->global_catalog[i].host[0] != '\0'; i++)
idmapdlog(LOG_DEBUG, "global_catalog=%s port=%d",
pgcfg->global_catalog[i].host,
pgcfg->global_catalog[i].port);
}
if (pgcfg->domains_in_forest == NULL ||
pgcfg->domains_in_forest[0].domain[0] == '\0') {
idmapdlog(LOG_DEBUG, "No domains in forest %s known",
CHECK_NULL(pgcfg->forest_name));
} else {
for (i = 0; pgcfg->domains_in_forest[i].domain[0] != '\0'; i++)
idmapdlog(LOG_DEBUG, "domains in forest %s = %s",
CHECK_NULL(pgcfg->forest_name),
pgcfg->domains_in_forest[i].domain);
}
if (pgcfg->trusted_domains == NULL ||
pgcfg->trusted_domains[0].domain[0] == '\0') {
idmapdlog(LOG_DEBUG, "No trusted domains known");
} else {
for (i = 0; pgcfg->trusted_domains[i].domain[0] != '\0'; i++)
idmapdlog(LOG_DEBUG, "trusted domain = %s",
pgcfg->trusted_domains[i].domain);
}
for (i = 0; i < pgcfg->num_trusted_forests; i++) {
tf = &pgcfg->trusted_forests[i];
for (j = 0; tf->global_catalog[j].host[0] != '\0'; j++)
idmapdlog(LOG_DEBUG,
"trusted forest %s global_catalog=%s port=%d",
tf->forest_name,
tf->global_catalog[j].host,
tf->global_catalog[j].port);
for (j = 0; tf->domains_in_forest[j].domain[0] != '\0'; j++) {
if (tf->domains_in_forest[j].trusted) {
idmapdlog(LOG_DEBUG,
"trusted forest %s domain=%s",
tf->forest_name,
tf->domains_in_forest[j].domain);
}
}
}
idmapdlog(LOG_DEBUG, "directory_based_mapping=%s",
enum_lookup(pgcfg->directory_based_mapping, directory_mapping_map));
idmapdlog(LOG_DEBUG, "ad_unixuser_attr=%s",
CHECK_NULL(pgcfg->ad_unixuser_attr));
idmapdlog(LOG_DEBUG, "ad_unixgroup_attr=%s",
CHECK_NULL(pgcfg->ad_unixgroup_attr));
idmapdlog(LOG_DEBUG, "nldap_winname_attr=%s",
CHECK_NULL(pgcfg->nldap_winname_attr));
UNLOCK_CONFIG();
}
int WorkerProcess::main_loop()
{
int single_int_buffer = 0;
int solver_choice = INITIAL_STATE;
while (solver_choice != TERMINATE) {
MPI_Bcast(&solver_choice, 1, MPI_INT, solve_options.head(), MPI_COMM_WORLD);
if ( (solve_options.id()==1) && (program_options.verbose_level()>=2)) { //(solver_choice!=0) &&
std::cout << "received call for help for solver " << enum_lookup(solver_choice) << std::endl;
}
switch (solver_choice) {
case NULLSPACE:
nullspace_slave_entry_point(this->solve_options);
break;
case MIDPOINT_SOLVER:
{
Surface S;
S.worker_connect(solve_options, program_options);
}
break;
case PARSING:
MPI_Bcast(&single_int_buffer, 1, MPI_INT, 0, MPI_COMM_WORLD); // this catches a broadcast from Bertini's parser...
if (single_int_buffer!=0) {
std::cout << single_int_buffer << std::endl;
}
break;
case MULTILIN:
multilin_slave_entry_point(this->solve_options);
break;
case SPHERE_SOLVER:
sphere_slave_entry_point(this->solve_options);
break;
case BERTINI_MAIN:
{
std::vector<std::string> command_line_options;
bertini_main_wrapper(command_line_options, solve_options.num_procs(), solve_options.id(), solve_options.head());
break;
}
case TERMINATE:
break;
default:
std::cout << "received unknown" << std::endl;
break;
}
}
return SUCCESSFUL;
}