Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Written 2000,2002 by Andi Kleen. |
| 3 | * |
| 4 | * Loosely based on the sparc64 and IA64 32bit emulation loaders. |
| 5 | * This tricks binfmt_elf.c into loading 32bit binaries using lots |
| 6 | * of ugly preprocessor tricks. Talk about very very poor man's inheritance. |
| 7 | */ |
| 8 | #include <linux/types.h> |
| 9 | #include <linux/config.h> |
| 10 | #include <linux/stddef.h> |
| 11 | #include <linux/rwsem.h> |
| 12 | #include <linux/sched.h> |
| 13 | #include <linux/compat.h> |
| 14 | #include <linux/string.h> |
| 15 | #include <linux/binfmts.h> |
| 16 | #include <linux/mm.h> |
| 17 | #include <linux/security.h> |
| 18 | |
| 19 | #include <asm/segment.h> |
| 20 | #include <asm/ptrace.h> |
| 21 | #include <asm/processor.h> |
| 22 | #include <asm/user32.h> |
| 23 | #include <asm/sigcontext32.h> |
| 24 | #include <asm/fpu32.h> |
| 25 | #include <asm/i387.h> |
| 26 | #include <asm/uaccess.h> |
| 27 | #include <asm/ia32.h> |
| 28 | #include <asm/vsyscall32.h> |
| 29 | |
| 30 | #define ELF_NAME "elf/i386" |
| 31 | |
| 32 | #define AT_SYSINFO 32 |
| 33 | #define AT_SYSINFO_EHDR 33 |
| 34 | |
| 35 | int sysctl_vsyscall32 = 1; |
| 36 | |
| 37 | #define ARCH_DLINFO do { \ |
| 38 | if (sysctl_vsyscall32) { \ |
| 39 | NEW_AUX_ENT(AT_SYSINFO, (u32)(u64)VSYSCALL32_VSYSCALL); \ |
| 40 | NEW_AUX_ENT(AT_SYSINFO_EHDR, VSYSCALL32_BASE); \ |
| 41 | } \ |
| 42 | } while(0) |
| 43 | |
| 44 | struct file; |
| 45 | struct elf_phdr; |
| 46 | |
| 47 | #define IA32_EMULATOR 1 |
| 48 | |
Suresh Siddha | 8492980 | 2005-06-21 17:14:32 -0700 | [diff] [blame] | 49 | #define ELF_ET_DYN_BASE (TASK_UNMAPPED_BASE + 0x1000000) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 50 | |
| 51 | #undef ELF_ARCH |
| 52 | #define ELF_ARCH EM_386 |
| 53 | |
| 54 | #undef ELF_CLASS |
| 55 | #define ELF_CLASS ELFCLASS32 |
| 56 | |
| 57 | #define ELF_DATA ELFDATA2LSB |
| 58 | |
| 59 | #define USE_ELF_CORE_DUMP 1 |
| 60 | |
Dave Jones | e6fc99c | 2006-03-25 16:30:16 +0100 | [diff] [blame] | 61 | /* Override elfcore.h */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 62 | #define _LINUX_ELFCORE_H 1 |
| 63 | typedef unsigned int elf_greg_t; |
| 64 | |
| 65 | #define ELF_NGREG (sizeof (struct user_regs_struct32) / sizeof(elf_greg_t)) |
| 66 | typedef elf_greg_t elf_gregset_t[ELF_NGREG]; |
| 67 | |
| 68 | /* |
| 69 | * These macros parameterize elf_core_dump in fs/binfmt_elf.c to write out |
| 70 | * extra segments containing the vsyscall DSO contents. Dumping its |
| 71 | * contents makes post-mortem fully interpretable later without matching up |
| 72 | * the same kernel and hardware config to see what PC values meant. |
| 73 | * Dumping its extra ELF program headers includes all the other information |
| 74 | * a debugger needs to easily find how the vsyscall DSO was being used. |
| 75 | */ |
| 76 | #define ELF_CORE_EXTRA_PHDRS (VSYSCALL32_EHDR->e_phnum) |
| 77 | #define ELF_CORE_WRITE_EXTRA_PHDRS \ |
| 78 | do { \ |
| 79 | const struct elf32_phdr *const vsyscall_phdrs = \ |
| 80 | (const struct elf32_phdr *) (VSYSCALL32_BASE \ |
| 81 | + VSYSCALL32_EHDR->e_phoff); \ |
| 82 | int i; \ |
| 83 | Elf32_Off ofs = 0; \ |
| 84 | for (i = 0; i < VSYSCALL32_EHDR->e_phnum; ++i) { \ |
| 85 | struct elf32_phdr phdr = vsyscall_phdrs[i]; \ |
| 86 | if (phdr.p_type == PT_LOAD) { \ |
| 87 | BUG_ON(ofs != 0); \ |
| 88 | ofs = phdr.p_offset = offset; \ |
| 89 | phdr.p_memsz = PAGE_ALIGN(phdr.p_memsz); \ |
| 90 | phdr.p_filesz = phdr.p_memsz; \ |
| 91 | offset += phdr.p_filesz; \ |
| 92 | } \ |
| 93 | else \ |
| 94 | phdr.p_offset += ofs; \ |
| 95 | phdr.p_paddr = 0; /* match other core phdrs */ \ |
| 96 | DUMP_WRITE(&phdr, sizeof(phdr)); \ |
| 97 | } \ |
| 98 | } while (0) |
| 99 | #define ELF_CORE_WRITE_EXTRA_DATA \ |
| 100 | do { \ |
| 101 | const struct elf32_phdr *const vsyscall_phdrs = \ |
| 102 | (const struct elf32_phdr *) (VSYSCALL32_BASE \ |
| 103 | + VSYSCALL32_EHDR->e_phoff); \ |
| 104 | int i; \ |
| 105 | for (i = 0; i < VSYSCALL32_EHDR->e_phnum; ++i) { \ |
| 106 | if (vsyscall_phdrs[i].p_type == PT_LOAD) \ |
| 107 | DUMP_WRITE((void *) (u64) vsyscall_phdrs[i].p_vaddr, \ |
| 108 | PAGE_ALIGN(vsyscall_phdrs[i].p_memsz)); \ |
| 109 | } \ |
| 110 | } while (0) |
| 111 | |
| 112 | struct elf_siginfo |
| 113 | { |
| 114 | int si_signo; /* signal number */ |
| 115 | int si_code; /* extra code */ |
| 116 | int si_errno; /* errno */ |
| 117 | }; |
| 118 | |
| 119 | #define jiffies_to_timeval(a,b) do { (b)->tv_usec = 0; (b)->tv_sec = (a)/HZ; }while(0) |
| 120 | |
| 121 | struct elf_prstatus |
| 122 | { |
| 123 | struct elf_siginfo pr_info; /* Info associated with signal */ |
| 124 | short pr_cursig; /* Current signal */ |
| 125 | unsigned int pr_sigpend; /* Set of pending signals */ |
| 126 | unsigned int pr_sighold; /* Set of held signals */ |
| 127 | pid_t pr_pid; |
| 128 | pid_t pr_ppid; |
| 129 | pid_t pr_pgrp; |
| 130 | pid_t pr_sid; |
| 131 | struct compat_timeval pr_utime; /* User time */ |
| 132 | struct compat_timeval pr_stime; /* System time */ |
| 133 | struct compat_timeval pr_cutime; /* Cumulative user time */ |
| 134 | struct compat_timeval pr_cstime; /* Cumulative system time */ |
| 135 | elf_gregset_t pr_reg; /* GP registers */ |
| 136 | int pr_fpvalid; /* True if math co-processor being used. */ |
| 137 | }; |
| 138 | |
| 139 | #define ELF_PRARGSZ (80) /* Number of chars for args */ |
| 140 | |
| 141 | struct elf_prpsinfo |
| 142 | { |
| 143 | char pr_state; /* numeric process state */ |
| 144 | char pr_sname; /* char for pr_state */ |
| 145 | char pr_zomb; /* zombie */ |
| 146 | char pr_nice; /* nice val */ |
| 147 | unsigned int pr_flag; /* flags */ |
| 148 | __u16 pr_uid; |
| 149 | __u16 pr_gid; |
| 150 | pid_t pr_pid, pr_ppid, pr_pgrp, pr_sid; |
| 151 | /* Lots missing */ |
| 152 | char pr_fname[16]; /* filename of executable */ |
| 153 | char pr_psargs[ELF_PRARGSZ]; /* initial part of arg list */ |
| 154 | }; |
| 155 | |
| 156 | #define __STR(x) #x |
| 157 | #define STR(x) __STR(x) |
| 158 | |
| 159 | #define _GET_SEG(x) \ |
| 160 | ({ __u32 seg; asm("movl %%" STR(x) ",%0" : "=r"(seg)); seg; }) |
| 161 | |
| 162 | /* Assumes current==process to be dumped */ |
| 163 | #define ELF_CORE_COPY_REGS(pr_reg, regs) \ |
| 164 | pr_reg[0] = regs->rbx; \ |
| 165 | pr_reg[1] = regs->rcx; \ |
| 166 | pr_reg[2] = regs->rdx; \ |
| 167 | pr_reg[3] = regs->rsi; \ |
| 168 | pr_reg[4] = regs->rdi; \ |
| 169 | pr_reg[5] = regs->rbp; \ |
| 170 | pr_reg[6] = regs->rax; \ |
| 171 | pr_reg[7] = _GET_SEG(ds); \ |
| 172 | pr_reg[8] = _GET_SEG(es); \ |
| 173 | pr_reg[9] = _GET_SEG(fs); \ |
| 174 | pr_reg[10] = _GET_SEG(gs); \ |
| 175 | pr_reg[11] = regs->orig_rax; \ |
| 176 | pr_reg[12] = regs->rip; \ |
| 177 | pr_reg[13] = regs->cs; \ |
| 178 | pr_reg[14] = regs->eflags; \ |
| 179 | pr_reg[15] = regs->rsp; \ |
| 180 | pr_reg[16] = regs->ss; |
| 181 | |
| 182 | #define user user32 |
| 183 | |
| 184 | #define __ASM_X86_64_ELF_H 1 |
| 185 | #define elf_read_implies_exec(ex, have_pt_gnu_stack) (!(have_pt_gnu_stack)) |
| 186 | //#include <asm/ia32.h> |
| 187 | #include <linux/elf.h> |
| 188 | |
| 189 | typedef struct user_i387_ia32_struct elf_fpregset_t; |
| 190 | typedef struct user32_fxsr_struct elf_fpxregset_t; |
| 191 | |
| 192 | |
| 193 | static inline void elf_core_copy_regs(elf_gregset_t *elfregs, struct pt_regs *regs) |
| 194 | { |
| 195 | ELF_CORE_COPY_REGS((*elfregs), regs) |
| 196 | } |
| 197 | |
| 198 | static inline int elf_core_copy_task_regs(struct task_struct *t, elf_gregset_t* elfregs) |
| 199 | { |
Al Viro | bb04923 | 2006-01-12 01:05:38 -0800 | [diff] [blame] | 200 | struct pt_regs *pp = task_pt_regs(t); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 201 | ELF_CORE_COPY_REGS((*elfregs), pp); |
| 202 | /* fix wrong segments */ |
| 203 | (*elfregs)[7] = t->thread.ds; |
| 204 | (*elfregs)[9] = t->thread.fsindex; |
| 205 | (*elfregs)[10] = t->thread.gsindex; |
| 206 | (*elfregs)[8] = t->thread.es; |
| 207 | return 1; |
| 208 | } |
| 209 | |
| 210 | static inline int |
| 211 | elf_core_copy_task_fpregs(struct task_struct *tsk, struct pt_regs *regs, elf_fpregset_t *fpu) |
| 212 | { |
| 213 | struct _fpstate_ia32 *fpstate = (void*)fpu; |
| 214 | mm_segment_t oldfs = get_fs(); |
| 215 | |
| 216 | if (!tsk_used_math(tsk)) |
| 217 | return 0; |
| 218 | if (!regs) |
Al Viro | bb04923 | 2006-01-12 01:05:38 -0800 | [diff] [blame] | 219 | regs = task_pt_regs(tsk); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 220 | if (tsk == current) |
| 221 | unlazy_fpu(tsk); |
| 222 | set_fs(KERNEL_DS); |
| 223 | save_i387_ia32(tsk, fpstate, regs, 1); |
| 224 | /* Correct for i386 bug. It puts the fop into the upper 16bits of |
| 225 | the tag word (like FXSAVE), not into the fcs*/ |
| 226 | fpstate->cssel |= fpstate->tag & 0xffff0000; |
| 227 | set_fs(oldfs); |
| 228 | return 1; |
| 229 | } |
| 230 | |
| 231 | #define ELF_CORE_COPY_XFPREGS 1 |
| 232 | static inline int |
| 233 | elf_core_copy_task_xfpregs(struct task_struct *t, elf_fpxregset_t *xfpu) |
| 234 | { |
Al Viro | bb04923 | 2006-01-12 01:05:38 -0800 | [diff] [blame] | 235 | struct pt_regs *regs = task_pt_regs(t); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 236 | if (!tsk_used_math(t)) |
| 237 | return 0; |
| 238 | if (t == current) |
| 239 | unlazy_fpu(t); |
| 240 | memcpy(xfpu, &t->thread.i387.fxsave, sizeof(elf_fpxregset_t)); |
| 241 | xfpu->fcs = regs->cs; |
| 242 | xfpu->fos = t->thread.ds; /* right? */ |
| 243 | return 1; |
| 244 | } |
| 245 | |
| 246 | #undef elf_check_arch |
| 247 | #define elf_check_arch(x) \ |
| 248 | ((x)->e_machine == EM_386) |
| 249 | |
| 250 | extern int force_personality32; |
| 251 | |
| 252 | #define ELF_EXEC_PAGESIZE PAGE_SIZE |
| 253 | #define ELF_HWCAP (boot_cpu_data.x86_capability[0]) |
| 254 | #define ELF_PLATFORM ("i686") |
| 255 | #define SET_PERSONALITY(ex, ibcs2) \ |
| 256 | do { \ |
| 257 | unsigned long new_flags = 0; \ |
| 258 | if ((ex).e_ident[EI_CLASS] == ELFCLASS32) \ |
| 259 | new_flags = _TIF_IA32; \ |
| 260 | if ((current_thread_info()->flags & _TIF_IA32) \ |
| 261 | != new_flags) \ |
| 262 | set_thread_flag(TIF_ABI_PENDING); \ |
| 263 | else \ |
| 264 | clear_thread_flag(TIF_ABI_PENDING); \ |
| 265 | /* XXX This overwrites the user set personality */ \ |
| 266 | current->personality |= force_personality32; \ |
| 267 | } while (0) |
| 268 | |
| 269 | /* Override some function names */ |
| 270 | #define elf_format elf32_format |
| 271 | |
| 272 | #define init_elf_binfmt init_elf32_binfmt |
| 273 | #define exit_elf_binfmt exit_elf32_binfmt |
| 274 | |
| 275 | #define load_elf_binary load_elf32_binary |
| 276 | |
| 277 | #define ELF_PLAT_INIT(r, load_addr) elf32_init(r) |
| 278 | #define setup_arg_pages(bprm, stack_top, exec_stack) \ |
| 279 | ia32_setup_arg_pages(bprm, stack_top, exec_stack) |
| 280 | int ia32_setup_arg_pages(struct linux_binprm *bprm, unsigned long stack_top, int executable_stack); |
| 281 | |
| 282 | #undef start_thread |
| 283 | #define start_thread(regs,new_rip,new_rsp) do { \ |
| 284 | asm volatile("movl %0,%%fs" :: "r" (0)); \ |
| 285 | asm volatile("movl %0,%%es; movl %0,%%ds": :"r" (__USER32_DS)); \ |
| 286 | load_gs_index(0); \ |
| 287 | (regs)->rip = (new_rip); \ |
| 288 | (regs)->rsp = (new_rsp); \ |
| 289 | (regs)->eflags = 0x200; \ |
| 290 | (regs)->cs = __USER32_CS; \ |
| 291 | (regs)->ss = __USER32_DS; \ |
| 292 | set_fs(USER_DS); \ |
| 293 | } while(0) |
| 294 | |
| 295 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 296 | #include <linux/module.h> |
| 297 | |
| 298 | MODULE_DESCRIPTION("Binary format loader for compatibility with IA32 ELF binaries."); |
| 299 | MODULE_AUTHOR("Eric Youngdale, Andi Kleen"); |
| 300 | |
| 301 | #undef MODULE_DESCRIPTION |
| 302 | #undef MODULE_AUTHOR |
| 303 | |
| 304 | #define elf_addr_t __u32 |
| 305 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 306 | static void elf32_init(struct pt_regs *); |
| 307 | |
Andi Kleen | 1e01441 | 2005-04-16 15:24:55 -0700 | [diff] [blame] | 308 | #define ARCH_HAS_SETUP_ADDITIONAL_PAGES 1 |
| 309 | #define arch_setup_additional_pages syscall32_setup_pages |
| 310 | extern int syscall32_setup_pages(struct linux_binprm *, int exstack); |
| 311 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 312 | #include "../../../fs/binfmt_elf.c" |
| 313 | |
| 314 | static void elf32_init(struct pt_regs *regs) |
| 315 | { |
| 316 | struct task_struct *me = current; |
| 317 | regs->rdi = 0; |
| 318 | regs->rsi = 0; |
| 319 | regs->rdx = 0; |
| 320 | regs->rcx = 0; |
| 321 | regs->rax = 0; |
| 322 | regs->rbx = 0; |
| 323 | regs->rbp = 0; |
| 324 | regs->r8 = regs->r9 = regs->r10 = regs->r11 = regs->r12 = |
| 325 | regs->r13 = regs->r14 = regs->r15 = 0; |
| 326 | me->thread.fs = 0; |
| 327 | me->thread.gs = 0; |
| 328 | me->thread.fsindex = 0; |
| 329 | me->thread.gsindex = 0; |
| 330 | me->thread.ds = __USER_DS; |
| 331 | me->thread.es = __USER_DS; |
| 332 | } |
| 333 | |
Andi Kleen | ea0be47 | 2005-11-05 17:25:54 +0100 | [diff] [blame] | 334 | int ia32_setup_arg_pages(struct linux_binprm *bprm, unsigned long stack_top, |
| 335 | int executable_stack) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 336 | { |
| 337 | unsigned long stack_base; |
| 338 | struct vm_area_struct *mpnt; |
| 339 | struct mm_struct *mm = current->mm; |
| 340 | int i, ret; |
| 341 | |
Andi Kleen | 6ae53cd | 2006-05-30 22:47:45 +0200 | [diff] [blame] | 342 | stack_base = stack_top - MAX_ARG_PAGES * PAGE_SIZE; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 343 | mm->arg_start = bprm->p + stack_base; |
| 344 | |
| 345 | bprm->p += stack_base; |
| 346 | if (bprm->loader) |
| 347 | bprm->loader += stack_base; |
| 348 | bprm->exec += stack_base; |
| 349 | |
| 350 | mpnt = kmem_cache_alloc(vm_area_cachep, SLAB_KERNEL); |
| 351 | if (!mpnt) |
| 352 | return -ENOMEM; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 353 | |
| 354 | memset(mpnt, 0, sizeof(*mpnt)); |
| 355 | |
| 356 | down_write(&mm->mmap_sem); |
| 357 | { |
| 358 | mpnt->vm_mm = mm; |
| 359 | mpnt->vm_start = PAGE_MASK & (unsigned long) bprm->p; |
Andi Kleen | 6ae53cd | 2006-05-30 22:47:45 +0200 | [diff] [blame] | 360 | mpnt->vm_end = stack_top; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 361 | if (executable_stack == EXSTACK_ENABLE_X) |
| 362 | mpnt->vm_flags = VM_STACK_FLAGS | VM_EXEC; |
| 363 | else if (executable_stack == EXSTACK_DISABLE_X) |
| 364 | mpnt->vm_flags = VM_STACK_FLAGS & ~VM_EXEC; |
| 365 | else |
| 366 | mpnt->vm_flags = VM_STACK_FLAGS; |
| 367 | mpnt->vm_page_prot = (mpnt->vm_flags & VM_EXEC) ? |
| 368 | PAGE_COPY_EXEC : PAGE_COPY; |
| 369 | if ((ret = insert_vm_struct(mm, mpnt))) { |
| 370 | up_write(&mm->mmap_sem); |
| 371 | kmem_cache_free(vm_area_cachep, mpnt); |
| 372 | return ret; |
| 373 | } |
| 374 | mm->stack_vm = mm->total_vm = vma_pages(mpnt); |
| 375 | } |
| 376 | |
| 377 | for (i = 0 ; i < MAX_ARG_PAGES ; i++) { |
| 378 | struct page *page = bprm->page[i]; |
| 379 | if (page) { |
| 380 | bprm->page[i] = NULL; |
| 381 | install_arg_page(mpnt, page, stack_base); |
| 382 | } |
| 383 | stack_base += PAGE_SIZE; |
| 384 | } |
| 385 | up_write(&mm->mmap_sem); |
| 386 | |
| 387 | return 0; |
| 388 | } |
Andi Kleen | ea0be47 | 2005-11-05 17:25:54 +0100 | [diff] [blame] | 389 | EXPORT_SYMBOL(ia32_setup_arg_pages); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 390 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 391 | #ifdef CONFIG_SYSCTL |
| 392 | /* Register vsyscall32 into the ABI table */ |
| 393 | #include <linux/sysctl.h> |
| 394 | |
| 395 | static ctl_table abi_table2[] = { |
| 396 | { 99, "vsyscall32", &sysctl_vsyscall32, sizeof(int), 0644, NULL, |
| 397 | proc_dointvec }, |
| 398 | { 0, } |
| 399 | }; |
| 400 | |
| 401 | static ctl_table abi_root_table2[] = { |
| 402 | { .ctl_name = CTL_ABI, .procname = "abi", .mode = 0555, |
| 403 | .child = abi_table2 }, |
| 404 | { 0 }, |
| 405 | }; |
| 406 | |
| 407 | static __init int ia32_binfmt_init(void) |
| 408 | { |
| 409 | register_sysctl_table(abi_root_table2, 1); |
| 410 | return 0; |
| 411 | } |
| 412 | __initcall(ia32_binfmt_init); |
| 413 | #endif |