static void load_libraries (void)
{
/* we will not make any assumption for where the libraries are loaded */
char cfgbuf[CONFIG_MAX];
int len, ret = 0;
/* loader.preload:
any other libraries to preload. The can be multiple URIs,
seperated by commas */
len = get_config(pal_state.root_config, "loader.preload", cfgbuf,
CONFIG_MAX);
if (len <= 0)
return;
char * c = cfgbuf, * library_name = c;
for (;; c++)
if (*c == ',' || !(*c)) {
if (c > library_name) {
#if PROFILING == 1
unsigned long before_load_library = _DkSystemTimeQuery();
#endif
*c = 0;
if ((ret = load_elf_object(library_name, OBJECT_PRELOAD)) < 0)
init_fail(-ret, "Unable to load preload library");
#if PROFILING == 1
pal_state.linking_time +=
_DkSystemTimeQuery() - before_load_library;
#endif
}
if (c == cfgbuf + len)
break;
library_name = c + 1;
}
}
int shim_do_execve_rtld (struct shim_handle * hdl, const char ** argv,
const char ** envp)
{
BEGIN_PROFILE_INTERVAL();
struct shim_thread * cur_thread = get_cur_thread();
int ret;
if ((ret = close_cloexec_handle(cur_thread->handle_map)) < 0)
return ret;
SAVE_PROFILE_INTERVAL(close_CLOEXEC_files_for_exec);
void * tcb = malloc(sizeof(__libc_tcb_t));
if (!tcb)
return -ENOMEM;
populate_tls(tcb, false);
__disable_preempt(&((__libc_tcb_t *) tcb)->shim_tcb); // Temporarily disable preemption
// during execve().
debug("set tcb to %p\n", tcb);
put_handle(cur_thread->exec);
get_handle(hdl);
cur_thread->exec = hdl;
old_stack_top = cur_thread->stack_top;
old_stack = cur_thread->stack;
old_stack_red = cur_thread->stack_red;
cur_thread->stack_top = NULL;
cur_thread->stack = NULL;
cur_thread->stack_red = NULL;
initial_envp = NULL;
new_argc = 0;
for (const char ** a = argv ; *a ; a++, new_argc++);
new_argcp = &new_argc;
if ((ret = init_stack(argv, envp, &new_argcp, &new_argp,
REQUIRED_ELF_AUXV, &new_auxp)) < 0)
return ret;
SAVE_PROFILE_INTERVAL(alloc_new_stack_for_exec);
SWITCH_STACK(new_argp);
cur_thread = get_cur_thread();
UPDATE_PROFILE_INTERVAL();
DkVirtualMemoryFree(old_stack, old_stack_top - old_stack);
DkVirtualMemoryFree(old_stack_red, old_stack - old_stack_red);
if (bkeep_munmap(old_stack, old_stack_top - old_stack, 0) < 0 ||
bkeep_munmap(old_stack_red, old_stack - old_stack_red, 0) < 0)
BUG();
remove_loaded_libraries();
clean_link_map_list();
SAVE_PROFILE_INTERVAL(unmap_loaded_binaries_for_exec);
reset_brk();
size_t count = DEFAULT_VMA_COUNT;
struct shim_vma_val * vmas = malloc(sizeof(struct shim_vma_val) * count);
if (!vmas)
return -ENOMEM;
retry_dump_vmas:
ret = dump_all_vmas(vmas, count);
if (ret == -EOVERFLOW) {
struct shim_vma_val * new_vmas
= malloc(sizeof(struct shim_vma_val) * count * 2);
if (!new_vmas) {
free(vmas);
return -ENOMEM;
}
free(vmas);
vmas = new_vmas;
count *= 2;
goto retry_dump_vmas;
}
if (ret < 0) {
free(vmas);
return ret;
}
count = ret;
for (struct shim_vma_val * vma = vmas ; vma < vmas + count ; vma++) {
/* Don't free the current stack */
if (vma->addr == cur_thread->stack)
continue;
/* Free all the mapped VMAs */
if (!(vma->flags & VMA_UNMAPPED))
DkVirtualMemoryFree(vma->addr, vma->length);
/* Remove the VMAs */
bkeep_munmap(vma->addr, vma->length, vma->flags);
}
free_vma_val_array(vmas, count);
SAVE_PROFILE_INTERVAL(unmap_all_vmas_for_exec);
if ((ret = load_elf_object(cur_thread->exec, NULL, 0)) < 0)
shim_terminate(ret);
init_brk_from_executable(cur_thread->exec);
load_elf_interp(cur_thread->exec);
SAVE_PROFILE_INTERVAL(load_new_executable_for_exec);
cur_thread->robust_list = NULL;
#ifdef PROFILE
if (ENTER_TIME)
SAVE_PROFILE_INTERVAL_SINCE(syscall_execve, ENTER_TIME);
#endif
debug("execve: start execution\n");
execute_elf_object(cur_thread->exec, new_argcp, new_argp,
REQUIRED_ELF_AUXV, new_auxp);
return 0;
}
int shim_do_execve_rtld (struct shim_handle * hdl, const char ** argv,
const char ** envp)
{
BEGIN_PROFILE_INTERVAL();
struct shim_thread * cur_thread = get_cur_thread();
int ret;
if ((ret = close_cloexec_handle(cur_thread->handle_map)) < 0)
return ret;
SAVE_PROFILE_INTERVAL(close_CLOEXEC_files_for_exec);
void * tcb = malloc(sizeof(__libc_tcb_t));
if (!tcb)
return -ENOMEM;
populate_tls(tcb);
put_handle(cur_thread->exec);
get_handle(hdl);
cur_thread->exec = hdl;
old_stack_top = cur_thread->stack_top;
old_stack = cur_thread->stack;
old_stack_red = cur_thread->stack_red;
cur_thread->stack_top = NULL;
cur_thread->stack = NULL;
cur_thread->stack_red = NULL;
initial_envp = NULL;
new_argc = 0;
for (const char ** a = argv ; *a ; a++, new_argc++);
if ((ret = init_stack(argv, envp, &new_argp,
REQUIRED_ELF_AUXV, &new_auxp)) < 0)
return ret;
SAVE_PROFILE_INTERVAL(alloc_new_stack_for_exec);
switch_stack(new_argp);
cur_thread = get_cur_thread();
UPDATE_PROFILE_INTERVAL();
DkVirtualMemoryFree(old_stack, old_stack_top - old_stack);
DkVirtualMemoryFree(old_stack_red, old_stack - old_stack_red);
int flags = VMA_INTERNAL;
bkeep_munmap(old_stack, old_stack_top - old_stack, &flags);
bkeep_munmap(old_stack_red, old_stack - old_stack_red, &flags);
remove_loaded_libraries();
clean_link_map_list();
SAVE_PROFILE_INTERVAL(unmap_loaded_binaries_for_exec);
init_brk();
unmap_all_vmas();
SAVE_PROFILE_INTERVAL(unmap_all_vmas_for_exec);
if ((ret = load_elf_object(cur_thread->exec, NULL, 0)) < 0)
shim_terminate();
load_elf_interp(cur_thread->exec);
SAVE_PROFILE_INTERVAL(load_new_executable_for_exec);
debug("execve: start execution\n");
execute_elf_object(cur_thread->exec, new_argc, new_argp,
REQUIRED_ELF_AUXV, new_auxp);
return 0;
}