/*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 */