/*Busca y almacena en el arbol un nuevo camino a un spot libre
*/
void network_newFreeSpot (AbbNet net){
/*Precondicion: network_newFreeSpot() se tiene que llamar despues de haber agregado un elemento*/
networkNode * pivot;
networkNode * ancestor;
pivot = STACK_TOP(net->freeSpot);
STACK_POP(net->freespot);
assert(pivot->left == Leaf);
if(pivote->right != Leaf){
if(!STACK_IS_EMPTY(net->freeSpot)){
ancestor = STACK_TOP(net->freeSpot);
/*mientras el hijo derecho del ancestro es el pivote*/
while(networkNode_compare(ancestor->right, pivot) && STACK_SIZE(net->freeSpot) > 1 ){
/*sigo subiendo en el arbol*/
pivot = ancestor;
STACK_POP(net->freespot);
ancestor = STACK_TOP(net->freeSpot);
}
/*pude haber salido por que el stack esta vacion o porque ancestor->right != pivot
* si sali por que el ancestro->right es diferente al pivote, entonces me voy por el
* el hijo derecho del ancestro todo a la izquierda.
* si sali porque llegue a la copa del arbol me voo todo a la izq a iniciar un nivel del arbol nuevo
*/
if(!networkNode_compare(ancestor->right, pivot){
ancestro = ancestro->right;
}
while(ancestor->left != Leaf){
STACK_ADD(net->freeSpot, ancestor);
ancestor = ancestor->left;
}
}
}
/*
* create_elf_tables
*/
static int
create_elf_tables_aux(struct linux_binprm *bprm,
unsigned long ntdll_load_addr, elf_off_t ntdll_phoff, elf_half_t ntdll_phnum, unsigned long ntdll_start_thunk,
unsigned long exeso_load_addr, elf_off_t exeso_phoff, elf_half_t exeso_phnum, unsigned long exeso_start_thunk,
unsigned long interp_load_addr, unsigned long interp_entry, unsigned long init_entry)
{
unsigned long p = bprm->p;
int argc = bprm->argc;
int envc = bprm->envc;
elf_addr_t __user *argv;
elf_addr_t __user *envp;
elf_addr_t __user *sp;
elf_addr_t __user *u_platform;
const char *k_platform = ELF_PLATFORM;
int items;
elf_addr_t *elf_info;
elf_addr_t *elf_info2;
int ei_index = 0;
const struct cred *cred = current_cred();
/*
* If this architecture has a platform capability string, copy it
* to userspace. In some cases (Sparc), this info is impossible
* for userspace to get any other way, in others (i386) it is
* merely difficult.
*/
u_platform = NULL;
if (k_platform) {
size_t len = strlen(k_platform) + 1;
/*
* In some cases (e.g. Hyper-Threading), we want to avoid L1
* evictions by the processes running on the same package. One
* thing we can do is to shuffle the initial stack for them.
*/
p = arch_align_stack(p);
u_platform = (elf_addr_t __user *)STACK_ALLOC(p, len);
if (__copy_to_user(u_platform, k_platform, len))
return -EFAULT;
}
/* Create the ELF interpreter info */
elf_info = (elf_addr_t *) current->mm->saved_auxv;
#define NEW_AUX_ENT(id, val) \
do { elf_info[ei_index++] = id; elf_info[ei_index++] = val; } while (0)
#ifdef ARCH_DLINFO11
/*
* ARCH_DLINFO must come first so PPC can do its special alignment of
* AUXV.
*/
ARCH_DLINFO;
#endif
NEW_AUX_ENT(AT_HWCAP, ELF_HWCAP);
NEW_AUX_ENT(AT_PAGESZ, ELF_EXEC_PAGESIZE);
NEW_AUX_ENT(AT_CLKTCK, CLOCKS_PER_SEC);
NEW_AUX_ENT(AT_PHDR, ntdll_load_addr + ntdll_phoff);
NEW_AUX_ENT(AT_PHENT, sizeof(struct elf_phdr));
NEW_AUX_ENT(AT_PHNUM, ntdll_phnum);
NEW_AUX_ENT(AT_BASE, interp_load_addr);
NEW_AUX_ENT(AT_FLAGS, 0);
NEW_AUX_ENT(AT_ENTRY, ntdll_start_thunk);
NEW_AUX_ENT(AT_UID, cred->uid);
NEW_AUX_ENT(AT_EUID, cred->euid);
NEW_AUX_ENT(AT_GID, cred->gid);
NEW_AUX_ENT(AT_EGID, cred->egid);
NEW_AUX_ENT(AT_SECURE, (elf_addr_t) security_bprm_secureexec(bprm));
#if 0
if (k_platform) {
/* FIXME */
NEW_AUX_ENT(AT_PLATFORM, (elf_addr_t)(unsigned long)u_platform);
}
#endif
if (bprm->interp_flags & BINPRM_FLAGS_EXECFD) {
NEW_AUX_ENT(AT_EXECFD, (elf_addr_t) bprm->interp_data);
}
#undef NEW_AUX_ENT
/* AT_NULL is zero; clear the rest too */
memset(&elf_info[ei_index], 0,
sizeof current->mm->saved_auxv - ei_index * sizeof elf_info[0]);
/* And advance past the AT_NULL entry. */
ei_index += 2;
sp = STACK_ADD(p, ei_index * 2);
items = (argc + 1) + (envc + 1);
items += 1; /* ELF interpreters only put argc on the stack */
items += 3; /* interp entry address & _init address & load_base */
bprm->p = STACK_ROUND(sp, items);
/* Point sp at the lowest address on the stack */
#ifdef CONFIG_STACK_GROWSUP
sp = (elf_addr_t __user *)bprm->p - items - ei_index;
bprm->exec = (unsigned long) sp; /* XXX: PARISC HACK */
#else
sp = (elf_addr_t __user *)bprm->p;
#endif
/* Now, let's put argc (and argv, envp if appropriate) on the stack */
if (__put_user(argc, sp))
return -EFAULT;
++sp;
argv = sp;
envp = argv + argc + 1;
/* Populate argv and envp */
p = current->mm->arg_end = current->mm->arg_start;
while (argc-- > 0) {
size_t len;
__put_user((elf_addr_t)p, argv);
++argv;
len = strnlen_user((void __user *)p, MAX_ARG_STRLEN);
if (!len || len > MAX_ARG_STRLEN)
return 0;
p += len;
}
if (__put_user(0, argv))
return -EFAULT;
current->mm->arg_end = current->mm->env_start = p;
while (envc-- > 0) {
size_t len;
__put_user((elf_addr_t)p, envp);
++envp;
len = strnlen_user((void __user *)p, MAX_ARG_STRLEN);
if (!len || len > MAX_ARG_STRLEN)
return 0;
p += len;
}
if (__put_user(0, envp))
return -EFAULT;
current->mm->env_end = p;
/* Put the elf_info on the stack in the right place. */
sp = (elf_addr_t __user *)envp + 1;
if (copy_to_user(sp, elf_info, ei_index * sizeof(elf_addr_t)))
return -EFAULT;
sp += ei_index;
elf_info2 = (elf_addr_t *)kmalloc(sizeof(current->mm->saved_auxv), GFP_KERNEL);
if(!elf_info2)
return -ENOMEM;
ei_index = 0;
#define NEW_AUX_ENT(id, val) \
do { elf_info2[ei_index++] = id; elf_info2[ei_index++] = val; } while (0)
#ifdef ARCH_DLINFO11
/*
* ARCH_DLINFO must come first so PPC can do its special alignment of
* AUXV.
*/
ARCH_DLINFO;
#endif
NEW_AUX_ENT(AT_HWCAP, ELF_HWCAP);
NEW_AUX_ENT(AT_PAGESZ, ELF_EXEC_PAGESIZE);
NEW_AUX_ENT(AT_CLKTCK, CLOCKS_PER_SEC);
NEW_AUX_ENT(AT_PHDR, exeso_load_addr + exeso_phoff);
NEW_AUX_ENT(AT_PHENT, sizeof(struct elf_phdr));
NEW_AUX_ENT(AT_PHNUM, exeso_phnum);
NEW_AUX_ENT(AT_BASE, interp_load_addr);
NEW_AUX_ENT(AT_FLAGS, 0);
NEW_AUX_ENT(AT_ENTRY, exeso_start_thunk);
NEW_AUX_ENT(AT_UID, cred->uid);
NEW_AUX_ENT(AT_EUID, cred->euid);
NEW_AUX_ENT(AT_GID, cred->gid);
NEW_AUX_ENT(AT_EGID, cred->egid);
NEW_AUX_ENT(AT_SECURE, (elf_addr_t) security_bprm_secureexec(bprm));
#if 0
if (k_platform) {
/* FIXME */
NEW_AUX_ENT(AT_PLATFORM, (elf_addr_t)(unsigned long)u_platform);
}
#endif
if (bprm->interp_flags & BINPRM_FLAGS_EXECFD) {
NEW_AUX_ENT(AT_EXECFD, (elf_addr_t) bprm->interp_data);
}
#undef NEW_AUX_ENT
/* AT_NULL is zero; clear the rest too */
memset(&elf_info2[ei_index], 0,
sizeof(current->mm->saved_auxv) - ei_index * sizeof elf_info2[0]);
ei_index += 2;
if (copy_to_user(sp, elf_info2, ei_index * sizeof(elf_addr_t))) {
kfree(elf_info2);
return -EFAULT;
}
kfree(elf_info2);
sp += ei_index;
__put_user(interp_entry, sp);
++sp;
__put_user(init_entry, sp);
++sp;
__put_user(exeso_load_addr, sp);
memset(current->mm->saved_auxv, 0, sizeof(current->mm->saved_auxv));
return 0;
} /* end create_elf_tables */
