static S mk_trie_dirs(const TF * const fort, void * hash, size_t hashlen, sds * path) {
*path = sdsnew(fort->path);
*path = sdscat(*path, "/");
char dir_node[(fort->cfg.width * 2) + 2];
uint8_t * hashb = hash;
for (size_t i = 0; i < fort->cfg.depth; i++) {
for (size_t j = 0; j < fort->cfg.width; j++) {
char * strpos = &dir_node[j * 2];
size_t hashix = (i * fort->cfg.width) + j;
snprintf(strpos, sizeof(dir_node), "%02x/", hashb[hashix]);
}
*path = sdscat(*path, dir_node);
if (dir_exists(*path)) {
continue;
} else {
PANIC_IF(0 != mkdir(*path, DIRMODE));
}
}
sds hash_str = mk_hash_str(hash, hashlen);
*path = sdscatsds(*path, hash_str);
sdsfree(hash_str);
if (!dir_exists(*path)) {
PANIC_IF(0 != mkdir(*path, DIRMODE));
}
return triefort_ok;
}
void spawner_new_c::setup_stream_(const options_class::redirect redirect, std_stream_type source_type, runner* this_runner) {
auto source_pipe = this_runner->get_pipe(source_type);
if (redirect.type == options_class::std) {
if (source_type == std_stream_input) {
get_std(std_stream_input, redirect.flags)->connect(source_pipe);
}
else {
source_pipe->connect(get_std(source_type, redirect.flags));
}
return;
}
PANIC_IF(redirect.type != options_class::pipe);
auto index = redirect.pipe_index;
auto stream = redirect.name;
PANIC_IF(index < 0 || index >= runners.size());
auto target_runner = runners[index];
multipipe_ptr target_pipe;
if (stream == "stdin") {
PANIC_IF(source_type == std_stream_input);
target_pipe = target_runner->get_pipe(std_stream_input, redirect.flags);
source_pipe->connect(target_pipe);
}
else if (stream == "stdout") {
PANIC_IF(source_type != std_stream_input);
target_pipe = target_runner->get_pipe(std_stream_output, redirect.flags);
target_pipe->connect(source_pipe);
}
else if (stream == "stderr") {
PANIC_IF(source_type != std_stream_input);
target_pipe = target_runner->get_pipe(std_stream_error, redirect.flags);
target_pipe->connect(source_pipe);
}
else {
PANIC("invalid stream name");
}
if (control_mode_enabled) {
if (source_type == std_stream_output) {
setup_stream_in_control_mode_(this_runner, source_pipe);
}
else if (stream == "stdout") {
setup_stream_in_control_mode_(target_runner, target_pipe);
}
}
}
S triefort_put(TF * fort,
const void * const buffer, const size_t bufferlen,
void * const hash) {
NULLCHK(fort);
NULLCHK(buffer);
NULLCHK(hash);
const size_t hashlen = fort->cfg.hash_len;
triefort_hasher_fn * hfn = fort->hcfg->hasher;
if (0 != hfn(hash, hashlen, buffer, bufferlen)) {
return triefort_err_hasher_error;
}
sds sdata_path = NULL;
PANIC_IF(triefort_ok != mk_trie_dirs(fort, hash, hashlen, &sdata_path));
sdata_path = sdscat(sdata_path, "/triefort.data");
S s = triefort_ok;
if (file_exists(sdata_path)) {
s = triefort_err_hash_already_exists;
} else {
if (!file_exists(sdata_path)) {
s = write_file(sdata_path, buffer, bufferlen);
}
}
sdsfree(sdata_path);
return s;
}
int spawner_new_c::normal_to_runner_index_(int normal_index) {
// normal_index must be valid here
int normal_runner_index = normal_index - 1;
if (normal_runner_index >= controller_index_) {
normal_runner_index++;
}
PANIC_IF(normal_runner_index <= 0 || normal_runner_index >= (int)runners.size());
return normal_runner_index;
}
int spawner_new_c::agent_to_runner_index_(int agent_index) {
// agent_index must be valid here
int agent_runner_index = agent_index - 1;
if (agent_runner_index >= controller_index_) {
agent_runner_index++;
}
PANIC_IF(agent_runner_index <= 0 || agent_runner_index >= (int)runners.size());
return agent_runner_index;
}
S triefort_exists_with_key(TF * const fort, const void * const key, const size_t keylen) {
NULLCHK(fort);
NULLCHK(key);
void * hash = calloc(1, fort->cfg.hash_len);
PANIC_IF(0 != fort->hcfg->hasher(hash, fort->cfg.hash_len, key, keylen));
S s = triefort_exists(fort, hash);
free(hash);
return s;
}
static S mk_info_from_path(const TF * const fort, sds path, const void * const hash, INFO ** info) {
sds data_path = sdsdup(path);
sds key_path = sdsdup(path);
data_path = sdscat(data_path, "/triefort.data");
key_path = sdscat(key_path, "/triefort.key");
S status = triefort_ok;
if (file_exists(data_path)) {
struct stat s;
PANIC_IF(0 != stat(data_path, &s));
*info = calloc(1, sizeof(**info));
INFO * inf = *info;
inf->hash = calloc(1, fort->cfg.hash_len);
memcpy(inf->hash, hash, fort->cfg.hash_len);
inf->hashlen = fort->cfg.hash_len;
inf->length = s.st_size;
if (file_exists(key_path)) {
FILE * kh = fopen(key_path, "rb");
PANIC_IF(NULL == kh);
PANIC_IF(0 != fstat(fileno(kh), &s));
inf->keylen = s.st_size;
inf->key = calloc(1, s.st_size);
PANIC_IF(1 != fread(inf->key, s.st_size, 1, kh));
fclose(kh);
} else {
inf->keylen = 0;
inf->key = NULL;
}
} else {
status = triefort_err_hash_does_not_exist;
}
sdsfree(data_path);
sdsfree(key_path);
return status;
}
/* Set an interrupt handler routine
* Parameters:
* interrupt - the interrupt number (NOT the IRQ number)
* handler - pointer to the handler function
*
* Returns:
* void
*/
void int_register_handler(uint8_t interrupt, int_handler_t handler)
{
KASSERT(interrupt < INT_NUM_INTERRUPTS);
// Make sure we're not trying to change any special interrupts
PANIC_IF(interrupt == INT_SYSCALL_INTERRUPT,
"tried to change syscall interrupt handler");
PANIC_IF(interrupt >= FIRST_IRQ_INT && interrupt < FIRST_IRQ_INT + NUM_IRQS,
"tried to change IRQ-aware interrupt handler");
// If handler is null, reset the handler function to the default
if (!handler)
{
g_int_handler_table[interrupt] = unexpected_int_handler;
}
else
{
g_int_handler_table[interrupt] = handler;
}
}
S triefort_get_with_key(TF * const fort, const void * const key, size_t keylen, void * buffer, size_t bufferlen, size_t * readlen) {
NULLCHK(fort);
NULLCHK(key);
NULLCHK(buffer);
NULLCHK(readlen);
void * hash = calloc(1, fort->cfg.hash_len);
PANIC_IF(0 != fort->hcfg->hasher(hash, fort->cfg.hash_len, key, keylen));
S s = triefort_get(fort, hash, buffer, bufferlen, readlen);
free(hash);
return s;
}
void mem_init(struct multiboot_info *boot_record)
{
struct scan_region_data data = { 0 };
mem_init_segments();
mem_create_framelist(boot_record, &s_framelist, &s_numframes);
mem_scan_regions(boot_record, &mem_scan_region, &data);
PANIC_IF(!data.heap_created, "Couldn't create kernel heap!");
cons_printf("Memory: %u bytes in heap, %u available pages\n",
data.heap_size, data.avail_pages);
}
void CookerRegistry::register_cooker(UniquePtr<Cooker> pCooker)
{
for (const ChefString & rawExt : pCooker->rawExts())
{
PANIC_IF(sRawExtToCooker.find(rawExt) != sRawExtToCooker.end(),
"Multiple cookers registered for same raw extension: %s",
rawExt);
sRawExtToCooker[rawExt] = pCooker.get();
}
for (const ChefString & cookedExt : pCooker->cookedExtsExclusive())
{
PANIC_IF(sCookedExtToCooker.find(cookedExt) != sCookedExtToCooker.end(),
"Multiple cookers registered for same cooked extension: %s",
cookedExt);
sCookedExtToCooker[cookedExt] = pCooker.get();
}
sCookers.emplace_back(std::move(pCooker));
}
u16 ModelPhysics::maskFromHash(u32 hash)
{
ASSERT(hash != 0);
auto it = mMaskBits.find(hash);
if (it != mMaskBits.end())
return it->second;
else
{
PANIC_IF(mMaskBits.size() >= 12, "Too many mask bits defined, Bullet only allows for 12(ish)");
u16 mask = (u16)(1 << mMaskBits.size());
mMaskBits[hash] = mask;
return mask;
}
}
S triefort_info_with_key(
const TF * const fort,
const void * const key,
const size_t keylen,
INFO ** const info) {
NULLCHK(fort);
NULLCHK(key);
NULLCHK(info);
void * hash = calloc(1, fort->cfg.hash_len);
PANIC_IF(0 != fort->hcfg->hasher(hash, fort->cfg.hash_len, key, keylen));
S s = triefort_info(fort, hash, info);
free(hash);
return s;
}
S triefort_get_stream_with_key(
TF * const fort,
const void * const key,
const size_t keylen,
FILE ** const hdl) {
NULLCHK(fort);
NULLCHK(key);
NULLCHK(hdl);
void * hash = calloc(1, fort->cfg.hash_len);
PANIC_IF(0 != fort->hcfg->hasher(hash, fort->cfg.hash_len, key, keylen));
S s = triefort_get_stream(fort, hash, hdl);
free(hash);
return s;
}
static S write_file(const char * const filename, const void * const data, const size_t datalen) {
S s = triefort_ok;
if (file_exists(filename)) {
s = triefort_err_path_already_exists;
} else {
FILE * fh = fopen(filename, "wb");
PANIC_IF(NULL == fh);
size_t wlen = fwrite(data, datalen, 1, fh);
if (wlen != 1) {
s = triefort_err_write_error;
}
fclose(fh);
}
return s;
}
S triefort_put_with_key(TF * fort,
const void * const key, const size_t keylen,
const void * const buffer, const size_t bufferlen,
void * const hash) {
NULLCHK(fort);
NULLCHK(key);
NULLCHK(buffer);
NULLCHK(hash);
if (keylen > fort->cfg.max_key_len) {
return triefort_err_key_too_long;
}
triefort_hasher_fn * hfn = fort->hcfg->hasher;
const size_t hashlen = fort->cfg.hash_len;
if (0 != hfn(hash, hashlen, key, keylen)) {
return triefort_err_hasher_error;
}
S s;
sds dir_path = NULL;
PANIC_IF(triefort_ok != mk_trie_dirs(fort, hash, hashlen, &dir_path));
sds skey_path = sdsdup(dir_path);
sds sdata_path = sdsdup(dir_path);
sdata_path = sdscat(sdata_path, "/triefort.data");
skey_path = sdscat(skey_path, "/triefort.key");
if (file_exists(sdata_path)) {
s = triefort_err_hash_already_exists;
} else {
s = write_file(skey_path, key, keylen);
if (triefort_ok == s) {
s = write_file(sdata_path, buffer, bufferlen);
}
}
sdsfree(skey_path);
sdsfree(sdata_path);
sdsfree(dir_path);
return s;
}
int iwch_poll_cq(struct ib_cq *ibcq, int num_entries, struct ib_wc *wc)
{
struct iwch_dev *rhp;
struct iwch_cq *chp;
int npolled;
int err = 0;
chp = to_iwch_cq(ibcq);
rhp = chp->rhp;
mtx_lock(&chp->lock);
for (npolled = 0; npolled < num_entries; ++npolled) {
#ifdef DEBUG
int i=0;
#endif
/*
* Because T3 can post CQEs that are _not_ associated
* with a WR, we might have to poll again after removing
* one of these.
*/
do {
err = iwch_poll_cq_one(rhp, chp, wc + npolled);
#ifdef DEBUG
PANIC_IF(++i > 1000);
#endif
} while (err == -EAGAIN);
if (err <= 0)
break;
}
mtx_unlock(&chp->lock);
if (err < 0) {
return err;
} else {
return npolled;
}
}
static S load_cfg(CFG * const cfg, const char * const path) {
NULLCHK(cfg);
NULLCHK(path);
FILE * cfghdl = fopen(path, "rb");
if (NULL == cfghdl) {
return triefort_err_config_could_not_be_opened;
} else {
PANIC_IF(1 != fread(&cfg->depth, sizeof(cfg->depth), 1, cfghdl));
PANIC_IF(1 != fread(&cfg->width, sizeof(cfg->width), 1, cfghdl));
PANIC_IF(1 != fread(&cfg->hash_len, sizeof(cfg->hash_len), 1, cfghdl));
PANIC_IF(1 != fread(&cfg->max_key_len, sizeof(cfg->max_key_len), 1, cfghdl));
uint8_t nlenb = 0;
PANIC_IF(1 != fread(&nlenb, sizeof(nlenb), 1, cfghdl));
PANIC_IF(nlenb != fread(&cfg->hash_name, 1, nlenb, cfghdl));
fclose(cfghdl);
}
return triefort_ok;
}
static S store_cfg(const CFG * const cfg, const char * const path) {
NULLCHK(cfg);
NULLCHK(path);
FILE * cfghdl = fopen(path, "wb");
if (NULL == cfghdl) {
return triefort_err_config_could_not_be_created;
} else {
PANIC_IF(1 != fwrite(&cfg->depth, sizeof(cfg->depth), 1, cfghdl));
PANIC_IF(1 != fwrite(&cfg->width, sizeof(cfg->width), 1, cfghdl));
PANIC_IF(1 != fwrite(&cfg->hash_len, sizeof(cfg->hash_len), 1, cfghdl));
PANIC_IF(1 != fwrite(&cfg->max_key_len, sizeof(cfg->max_key_len), 1, cfghdl));
size_t nlen = strnlen(cfg->hash_name, sizeof(cfg->hash_name) - 1);
uint8_t nlenb = nlen;
PANIC_IF(1 != fwrite(&nlenb, sizeof(nlenb), 1, cfghdl));
PANIC_IF(nlen != fwrite(&cfg->hash_name, 1, nlen, cfghdl));
fclose(cfghdl);
}
return triefort_ok;
}
static void
cpu_initialize_context(unsigned int cpu)
{
/* vcpu_guest_context_t is too large to allocate on the stack.
* Hence we allocate statically and protect it with a lock */
vm_page_t m[NPGPTD + 2];
static vcpu_guest_context_t ctxt;
vm_offset_t boot_stack;
vm_offset_t newPTD;
vm_paddr_t ma[NPGPTD];
int i;
/*
* Page 0,[0-3] PTD
* Page 1, [4] boot stack
* Page [5] PDPT
*
*/
for (i = 0; i < NPGPTD + 2; i++) {
m[i] = vm_page_alloc(NULL, 0,
VM_ALLOC_NORMAL | VM_ALLOC_NOOBJ | VM_ALLOC_WIRED |
VM_ALLOC_ZERO);
pmap_zero_page(m[i]);
}
boot_stack = kmem_alloc_nofault(kernel_map, PAGE_SIZE);
newPTD = kmem_alloc_nofault(kernel_map, NPGPTD * PAGE_SIZE);
ma[0] = VM_PAGE_TO_MACH(m[0])|PG_V;
#ifdef PAE
pmap_kenter(boot_stack, VM_PAGE_TO_PHYS(m[NPGPTD + 1]));
for (i = 0; i < NPGPTD; i++) {
((vm_paddr_t *)boot_stack)[i] =
ma[i] = VM_PAGE_TO_MACH(m[i])|PG_V;
}
#endif
/*
* Copy cpu0 IdlePTD to new IdlePTD - copying only
* kernel mappings
*/
pmap_qenter(newPTD, m, 4);
memcpy((uint8_t *)newPTD + KPTDI*sizeof(vm_paddr_t),
(uint8_t *)PTOV(IdlePTD) + KPTDI*sizeof(vm_paddr_t),
nkpt*sizeof(vm_paddr_t));
pmap_qremove(newPTD, 4);
kmem_free(kernel_map, newPTD, 4 * PAGE_SIZE);
/*
* map actual idle stack to boot_stack
*/
pmap_kenter(boot_stack, VM_PAGE_TO_PHYS(m[NPGPTD]));
xen_pgdpt_pin(VM_PAGE_TO_MACH(m[NPGPTD + 1]));
rw_wlock(&pvh_global_lock);
for (i = 0; i < 4; i++) {
int pdir = (PTDPTDI + i) / NPDEPG;
int curoffset = (PTDPTDI + i) % NPDEPG;
xen_queue_pt_update((vm_paddr_t)
((ma[pdir] & ~PG_V) + (curoffset*sizeof(vm_paddr_t))),
ma[i]);
}
PT_UPDATES_FLUSH();
rw_wunlock(&pvh_global_lock);
memset(&ctxt, 0, sizeof(ctxt));
ctxt.flags = VGCF_IN_KERNEL;
ctxt.user_regs.ds = GSEL(GDATA_SEL, SEL_KPL);
ctxt.user_regs.es = GSEL(GDATA_SEL, SEL_KPL);
ctxt.user_regs.fs = GSEL(GPRIV_SEL, SEL_KPL);
ctxt.user_regs.gs = GSEL(GDATA_SEL, SEL_KPL);
ctxt.user_regs.cs = GSEL(GCODE_SEL, SEL_KPL);
ctxt.user_regs.ss = GSEL(GDATA_SEL, SEL_KPL);
ctxt.user_regs.eip = (unsigned long)init_secondary;
ctxt.user_regs.eflags = PSL_KERNEL | 0x1000; /* IOPL_RING1 */
memset(&ctxt.fpu_ctxt, 0, sizeof(ctxt.fpu_ctxt));
smp_trap_init(ctxt.trap_ctxt);
ctxt.ldt_ents = 0;
ctxt.gdt_frames[0] = (uint32_t)((uint64_t)vtomach(bootAPgdt) >> PAGE_SHIFT);
ctxt.gdt_ents = 512;
#ifdef __i386__
ctxt.user_regs.esp = boot_stack + PAGE_SIZE;
ctxt.kernel_ss = GSEL(GDATA_SEL, SEL_KPL);
ctxt.kernel_sp = boot_stack + PAGE_SIZE;
ctxt.event_callback_cs = GSEL(GCODE_SEL, SEL_KPL);
ctxt.event_callback_eip = (unsigned long)Xhypervisor_callback;
ctxt.failsafe_callback_cs = GSEL(GCODE_SEL, SEL_KPL);
ctxt.failsafe_callback_eip = (unsigned long)failsafe_callback;
ctxt.ctrlreg[3] = VM_PAGE_TO_MACH(m[NPGPTD + 1]);
#else /* __x86_64__ */
ctxt.user_regs.esp = idle->thread.rsp0 - sizeof(struct pt_regs);
ctxt.kernel_ss = GSEL(GDATA_SEL, SEL_KPL);
ctxt.kernel_sp = idle->thread.rsp0;
ctxt.event_callback_eip = (unsigned long)hypervisor_callback;
ctxt.failsafe_callback_eip = (unsigned long)failsafe_callback;
ctxt.syscall_callback_eip = (unsigned long)system_call;
ctxt.ctrlreg[3] = xen_pfn_to_cr3(virt_to_mfn(init_level4_pgt));
ctxt.gs_base_kernel = (unsigned long)(cpu_pda(cpu));
#endif
printf("gdtpfn=%lx pdptpfn=%lx\n",
ctxt.gdt_frames[0],
ctxt.ctrlreg[3] >> PAGE_SHIFT);
PANIC_IF(HYPERVISOR_vcpu_op(VCPUOP_initialise, cpu, &ctxt));
DELAY(3000);
PANIC_IF(HYPERVISOR_vcpu_op(VCPUOP_up, cpu, NULL));
}
void vm_init_paging(struct multiboot_info *boot_info)
{
struct x86_cpuid_info cpuid_info;
struct frame *pgdir_frame;
struct frame *pgtab_frame;
pte_t *pgtab;
ulong_t paddr, mem_max;
/*
* Check CPUID instruction to see if large pages (PSE feature)
* is supported.
*/
PANIC_IF(!x86_cpuid(&cpuid_info), "GeekOS requires a Pentium-class CPU");
PANIC_IF(!cpuid_info.feature_info_edx.pse, "Processor does not support PSE");
cons_printf("CPU supports PSE\n");
/*
* Enable PSE by setting the PSE bit in CR4.
*/
x86_set_cr4(x86_get_cr4() | CR4_PSE);
/*
* Allocate kernel page directory.
*/
pgdir_frame = mem_alloc_frame(FRAME_KERN, 1);
s_kernel_pagedir = mem_frame_to_pa(pgdir_frame);
memset(s_kernel_pagedir, '\0', PAGE_SIZE);
/*
* We will support at most 2G of physical memory.
*/
mem_max = ((ulong_t) boot_info->mem_upper) * 1024;
if (mem_max > (1 << 31)) {
mem_max = (ulong_t) (1 << 31);
}
/*
* We need a page table for the low 4M of the kernel address space,
* since we want to leave the zero page unmapped (to catch null pointer derefs).
*/
pgtab_frame = mem_alloc_frame(FRAME_KERN, 1);
pgtab = mem_frame_to_pa(pgtab_frame);
memset(pgtab, '\0', PAGE_SIZE);
/*
* Initialize low page table, leaving page 0 unmapped
*/
for (paddr = PAGE_SIZE; paddr < VM_PT_SPAN; paddr += PAGE_SIZE) {
vm_set_pte(pgtab, VM_WRITE|VM_READ|VM_EXEC, paddr, paddr);
}
/*
* Add low page table to the kernel pagedir.
*/
vm_set_pde(s_kernel_pagedir, VM_WRITE|VM_READ|VM_EXEC, 0UL, (u32_t) pgtab);
/*
* Use 4M pages to map the rest of the low 2G of memory
*/
for (paddr = VM_PT_SPAN; paddr < mem_max; paddr += VM_PT_SPAN) {
vm_set_pde_4m(s_kernel_pagedir, VM_WRITE|VM_READ|VM_EXEC, paddr, paddr);
}
/*
* Turn on paging!
*/
x86_set_cr3((u32_t) s_kernel_pagedir); /* set the kernel page directory */
x86_set_cr0(x86_get_cr0() | CR0_PG); /* turn on the paging bit in cr0 */
cons_printf("Paging enabled\n");
}
bool spawner_new_c::init() {
if (!init_runner() || !runners.size()) {
return false;
}
for (size_t i = 0; i < runners.size(); i++) {
if (runners[i]->get_options().controller) {
// there must be only one controller process
PANIC_IF(controller_index_ != -1);
controller_index_ = i;
control_mode_enabled = true;
controller_input_lock = multipipe::create_pipe(write_mode, true, 0);
controller_input_lock->get_pipe()->close();
// Lock controller stdin
controller_input_lock->connect(runners[i]->get_pipe(std_stream_input));
controller_input_ = runners[i]->get_pipe(std_stream_input)->get_pipe();
controller_output_ = runners[i]->get_pipe(std_stream_output);
}
}
if (controller_index_ != -1) {
awaited_agents_.resize(runners.size() - 1);
for (size_t i = 0; i < runners.size(); i++) {
secure_runner* sr = static_cast<secure_runner*>(runners[i]);
sr->start_suspended = true;
if (i != controller_index_) {
sr->on_terminate = [=]() {
LOG("runner", i, "terminated");
on_terminate_mutex_.lock();
wait_agent_mutex_.lock();
awaited_agents_[i - 1] = false;
std::string message = std::to_string(i) + "T#\n";
// Send message to controller only.
controller_input_->write(message.c_str(), message.size());
bool have_running_agents = false;
for (auto j = 0; j < runners.size(); j++) {
if (j != controller_index_ && j != i && runners[j]->is_running()) {
have_running_agents = true;
break;
}
}
if (!have_running_agents) {
// Unlock controller stdin
controller_input_lock->finalize();
}
wait_agent_mutex_.unlock();
on_terminate_mutex_.unlock();
};
} else {
sr->on_terminate = [=]() {
LOG("controller terminated");
for (size_t j = 0; j < runners.size(); j++) {
if (j != controller_index_) {
runners[j]->resume();
}
}
};
}
}
}
for (auto runner : runners) {
options_class runner_options = runner->get_options();
const struct {
std::vector<options_class::redirect> &streams;
std_stream_type type;
} redirects_all[] = {
{ runner_options.stdinput, std_stream_input },
{ runner_options.stdoutput, std_stream_output },
{ runner_options.stderror, std_stream_error },
};
for (const auto& redirects : redirects_all) {
for (const auto& redirect : redirects.streams) {
PANIC_IF(redirect.original.size() == 0);
if (redirect.type == options_class::file) {
continue;
}
setup_stream_(redirect, redirects.type, runner);
}
}
}
return true;
}
bool spawner_new_c::init() {
if (!init_runner() || !runners.size()) {
return false;
}
for (size_t i = 0; i < runners.size(); i++) {
if (runners[i]->get_options().controller) {
// there must be only one controller process
PANIC_IF(controller_index_ != -1);
controller_index_ = i;
control_mode_enabled = true;
controller_buffer_ = std::make_shared<pipe_buffer_c>(runners[i]->get_input_pipe());
}
}
if (controller_index_ != -1) {
awaited_normals_.resize(runners.size() - 1);
for (size_t i = 0; i < runners.size(); i++) {
secure_runner* sr = static_cast<secure_runner*>(runners[i]);
if (i != controller_index_) {
sr->start_suspended = true;
}
sr->on_terminate = [=]() {
on_terminate_mutex_.lock();
for (auto& r : runners) {
if (r == sr) {
continue;
}
for (auto& b : sr->duplex_buffers) {
for (int pi = STD_INPUT_PIPE; pi <= STD_ERROR_PIPE; pi++) {
auto&& p = r->get_pipe(static_cast<const pipes_t>(pi));
p->remove_buffer(b);
}
}
}
if (i > 0 && awaited_normals_[i - 1]) {
wait_normal_mutex_.lock();
awaited_normals_[i - 1] = false;
std::string message = std::to_string(i) + "I#\n";
controller_buffer_->write(message.c_str(), message.size());
wait_normal_mutex_.unlock();
}
on_terminate_mutex_.unlock();
};
}
}
for (auto& runner : runners) {
options_class runner_options = runner->get_options();
struct {
std::vector<std::string> &streams;
pipes_t pipe_type;
} streams[] = {
{ runner_options.stdinput, STD_INPUT_PIPE },
{ runner_options.stdoutput, STD_OUTPUT_PIPE },
{ runner_options.stderror, STD_ERROR_PIPE },
};
for (auto& stream_item : streams) {
for (auto& stream_str : stream_item.streams) {
PANIC_IF(stream_str.size() == 0);
if (stream_str[0] != '*') {
continue;
}
setup_stream_(stream_str, stream_item.pipe_type, runner);
}
}
}
return true;
}
void spawner_new_c::setup_stream_(const std::string& stream_str, pipes_t this_pipe_type, runner* this_runner) {
size_t pos = stream_str.find(".");
// malformed argument
PANIC_IF(pos == std::string::npos);
size_t index = stoi(stream_str.substr(1, pos - 1), nullptr, 10);
std::string stream = stream_str.substr(pos + 1);
// invalid index
PANIC_IF(index >= runners.size() || index < 0);
pipes_t other_pipe_type;
if (stream == "stderr") {
other_pipe_type = STD_ERROR_PIPE;
}
else if (stream == "stdin") {
other_pipe_type = STD_INPUT_PIPE;
}
else if (stream == "stdout") {
other_pipe_type = STD_OUTPUT_PIPE;
}
else {
PANIC("invalid stream name");
}
runner *target_runner = runners[index];
std::shared_ptr<input_pipe_c> input_pipe = nullptr;
std::shared_ptr<output_pipe_c> output_pipe = nullptr;
pipes_t out_pipe_type = STD_ERROR_PIPE;
runner* out_pipe_runner = nullptr;
runner* in_pipe_runner = nullptr;
if (this_pipe_type == STD_INPUT_PIPE && other_pipe_type != STD_INPUT_PIPE) {
input_pipe = std::static_pointer_cast<input_pipe_c>(this_runner->get_pipe(this_pipe_type));
output_pipe = std::static_pointer_cast<output_pipe_c>(target_runner->get_pipe(other_pipe_type));
out_pipe_type = other_pipe_type;
out_pipe_runner = target_runner;
in_pipe_runner = this_runner;
} else if (this_pipe_type != STD_INPUT_PIPE && other_pipe_type == STD_INPUT_PIPE) {
input_pipe = std::static_pointer_cast<input_pipe_c>(target_runner->get_pipe(other_pipe_type));
output_pipe = std::static_pointer_cast<output_pipe_c>(this_runner->get_pipe(this_pipe_type));
out_pipe_type = this_pipe_type;
out_pipe_runner = this_runner;
in_pipe_runner = target_runner;
} else {
PANIC("invalid pipe mapping");
}
std::shared_ptr<duplex_buffer_c> buffer = std::make_shared<duplex_buffer_c>();
in_pipe_runner->duplex_buffers.push_back(buffer);
out_pipe_runner->duplex_buffers.push_back(buffer);
input_pipe->add_input_buffer(buffer);
output_pipe->add_output_buffer(buffer);
int out_runner_index = -1;
int in_runner_index = -1;
for (size_t i = 0; i < runners.size(); i++) {
if (runners[i] == out_pipe_runner) {
out_runner_index = i;
}
if (runners[i] == in_pipe_runner) {
in_runner_index = i;
}
}
if (out_runner_index == controller_index_) {
int index = in_runner_index;
if (index > controller_index_) {
index--;
}
buffer_to_runner_index_[buffer] = index + 1;
}
if (control_mode_enabled
&& out_pipe_type == STD_OUTPUT_PIPE
&& !output_pipe->process_message) {
if (out_pipe_runner->get_options().controller) {
output_pipe->process_message = [=](const std::string& message, output_pipe_c* pipe) {
process_controller_message_(message, pipe);
};
} else {
int index = out_runner_index;
if (index > controller_index_) {
index--;
}
output_pipe->process_message = [=](const std::string& message, output_pipe_c* pipe) {
process_normal_message_(message, pipe, index + 1);
};
}
}
}
void Material::registerVec4Var(u32 nameHash, const vec4 & value)
{
PANIC_IF(mVec4VarCount >= kMaxVec4Vars, "Too many Vec4 material vars");
mVec4Vars[mVec4VarCount++] = Material::Vec4Var(nameHash, value);
}
void Material::registerTexture(u32 nameHash, const Asset * pGimgAsset)
{
PANIC_IF(mTextureCount >= kMaxTextures, "Too many textures for material");
mTextures[mTextureCount++] = Material::TextureInfo(nameHash, 0, pGimgAsset);
AssetMgr::addref_asset(kRendererTaskId, pGimgAsset);
}
