Statistics
| Branch: | Revision:

root / linux-user / elfload.c @ e85e7c6e

History | View | Annotate | Download (40.5 kB)

1
/* This is the Linux kernel elf-loading code, ported into user space */
2

    
3
#include <stdio.h>
4
#include <sys/types.h>
5
#include <fcntl.h>
6
#include <errno.h>
7
#include <unistd.h>
8
#include <sys/mman.h>
9
#include <stdlib.h>
10
#include <string.h>
11

    
12
#include "qemu.h"
13
#include "disas.h"
14

    
15
/* from personality.h */
16

    
17
/*
18
 * Flags for bug emulation.
19
 *
20
 * These occupy the top three bytes.
21
 */
22
enum {
23
        ADDR_NO_RANDOMIZE =         0x0040000,        /* disable randomization of VA space */
24
        FDPIC_FUNCPTRS =        0x0080000,        /* userspace function ptrs point to descriptors
25
                                                 * (signal handling)
26
                                                 */
27
        MMAP_PAGE_ZERO =        0x0100000,
28
        ADDR_COMPAT_LAYOUT =        0x0200000,
29
        READ_IMPLIES_EXEC =        0x0400000,
30
        ADDR_LIMIT_32BIT =        0x0800000,
31
        SHORT_INODE =                0x1000000,
32
        WHOLE_SECONDS =                0x2000000,
33
        STICKY_TIMEOUTS        =        0x4000000,
34
        ADDR_LIMIT_3GB =         0x8000000,
35
};
36

    
37
/*
38
 * Personality types.
39
 *
40
 * These go in the low byte.  Avoid using the top bit, it will
41
 * conflict with error returns.
42
 */
43
enum {
44
        PER_LINUX =                0x0000,
45
        PER_LINUX_32BIT =        0x0000 | ADDR_LIMIT_32BIT,
46
        PER_LINUX_FDPIC =        0x0000 | FDPIC_FUNCPTRS,
47
        PER_SVR4 =                0x0001 | STICKY_TIMEOUTS | MMAP_PAGE_ZERO,
48
        PER_SVR3 =                0x0002 | STICKY_TIMEOUTS | SHORT_INODE,
49
        PER_SCOSVR3 =                0x0003 | STICKY_TIMEOUTS |
50
                                         WHOLE_SECONDS | SHORT_INODE,
51
        PER_OSR5 =                0x0003 | STICKY_TIMEOUTS | WHOLE_SECONDS,
52
        PER_WYSEV386 =                0x0004 | STICKY_TIMEOUTS | SHORT_INODE,
53
        PER_ISCR4 =                0x0005 | STICKY_TIMEOUTS,
54
        PER_BSD =                0x0006,
55
        PER_SUNOS =                0x0006 | STICKY_TIMEOUTS,
56
        PER_XENIX =                0x0007 | STICKY_TIMEOUTS | SHORT_INODE,
57
        PER_LINUX32 =                0x0008,
58
        PER_LINUX32_3GB =        0x0008 | ADDR_LIMIT_3GB,
59
        PER_IRIX32 =                0x0009 | STICKY_TIMEOUTS,/* IRIX5 32-bit */
60
        PER_IRIXN32 =                0x000a | STICKY_TIMEOUTS,/* IRIX6 new 32-bit */
61
        PER_IRIX64 =                0x000b | STICKY_TIMEOUTS,/* IRIX6 64-bit */
62
        PER_RISCOS =                0x000c,
63
        PER_SOLARIS =                0x000d | STICKY_TIMEOUTS,
64
        PER_UW7 =                0x000e | STICKY_TIMEOUTS | MMAP_PAGE_ZERO,
65
        PER_OSF4 =                0x000f,                         /* OSF/1 v4 */
66
        PER_HPUX =                0x0010,
67
        PER_MASK =                0x00ff,
68
};
69

    
70
/*
71
 * Return the base personality without flags.
72
 */
73
#define personality(pers)        (pers & PER_MASK)
74

    
75
/* this flag is uneffective under linux too, should be deleted */
76
#ifndef MAP_DENYWRITE
77
#define MAP_DENYWRITE 0
78
#endif
79

    
80
/* should probably go in elf.h */
81
#ifndef ELIBBAD
82
#define ELIBBAD 80
83
#endif
84

    
85
#ifdef TARGET_I386
86

    
87
#define ELF_PLATFORM get_elf_platform()
88

    
89
static const char *get_elf_platform(void)
90
{
91
    static char elf_platform[] = "i386";
92
    int family = (global_env->cpuid_version >> 8) & 0xff;
93
    if (family > 6)
94
        family = 6;
95
    if (family >= 3)
96
        elf_platform[1] = '0' + family;
97
    return elf_platform;
98
}
99

    
100
#define ELF_HWCAP get_elf_hwcap()
101

    
102
static uint32_t get_elf_hwcap(void)
103
{
104
  return global_env->cpuid_features;
105
}
106

    
107
#ifdef TARGET_X86_64
108
#define ELF_START_MMAP 0x2aaaaab000ULL
109
#define elf_check_arch(x) ( ((x) == ELF_ARCH) )
110

    
111
#define ELF_CLASS      ELFCLASS64
112
#define ELF_DATA       ELFDATA2LSB
113
#define ELF_ARCH       EM_X86_64
114

    
115
static inline void init_thread(struct target_pt_regs *regs, struct image_info *infop)
116
{
117
    regs->rax = 0;
118
    regs->rsp = infop->start_stack;
119
    regs->rip = infop->entry;
120
}
121

    
122
#else
123

    
124
#define ELF_START_MMAP 0x80000000
125

    
126
/*
127
 * This is used to ensure we don't load something for the wrong architecture.
128
 */
129
#define elf_check_arch(x) ( ((x) == EM_386) || ((x) == EM_486) )
130

    
131
/*
132
 * These are used to set parameters in the core dumps.
133
 */
134
#define ELF_CLASS        ELFCLASS32
135
#define ELF_DATA        ELFDATA2LSB
136
#define ELF_ARCH        EM_386
137

    
138
static inline void init_thread(struct target_pt_regs *regs, struct image_info *infop)
139
{
140
    regs->esp = infop->start_stack;
141
    regs->eip = infop->entry;
142

    
143
    /* SVR4/i386 ABI (pages 3-31, 3-32) says that when the program
144
       starts %edx contains a pointer to a function which might be
145
       registered using `atexit'.  This provides a mean for the
146
       dynamic linker to call DT_FINI functions for shared libraries
147
       that have been loaded before the code runs.
148

149
       A value of 0 tells we have no such handler.  */
150
    regs->edx = 0;
151
}
152
#endif
153

    
154
#define USE_ELF_CORE_DUMP
155
#define ELF_EXEC_PAGESIZE        4096
156

    
157
#endif
158

    
159
#ifdef TARGET_ARM
160

    
161
#define ELF_START_MMAP 0x80000000
162

    
163
#define elf_check_arch(x) ( (x) == EM_ARM )
164

    
165
#define ELF_CLASS        ELFCLASS32
166
#ifdef TARGET_WORDS_BIGENDIAN
167
#define ELF_DATA        ELFDATA2MSB
168
#else
169
#define ELF_DATA        ELFDATA2LSB
170
#endif
171
#define ELF_ARCH        EM_ARM
172

    
173
static inline void init_thread(struct target_pt_regs *regs, struct image_info *infop)
174
{
175
    abi_long stack = infop->start_stack;
176
    memset(regs, 0, sizeof(*regs));
177
    regs->ARM_cpsr = 0x10;
178
    if (infop->entry & 1)
179
      regs->ARM_cpsr |= CPSR_T;
180
    regs->ARM_pc = infop->entry & 0xfffffffe;
181
    regs->ARM_sp = infop->start_stack;
182
    regs->ARM_r2 = tgetl(stack + 8); /* envp */
183
    regs->ARM_r1 = tgetl(stack + 4); /* envp */
184
    /* XXX: it seems that r0 is zeroed after ! */
185
    regs->ARM_r0 = 0;
186
    /* For uClinux PIC binaries.  */
187
    /* XXX: Linux does this only on ARM with no MMU (do we care ?) */
188
    regs->ARM_r10 = infop->start_data;
189
}
190

    
191
#define USE_ELF_CORE_DUMP
192
#define ELF_EXEC_PAGESIZE        4096
193

    
194
enum
195
{
196
  ARM_HWCAP_ARM_SWP       = 1 << 0,
197
  ARM_HWCAP_ARM_HALF      = 1 << 1,
198
  ARM_HWCAP_ARM_THUMB     = 1 << 2,
199
  ARM_HWCAP_ARM_26BIT     = 1 << 3,
200
  ARM_HWCAP_ARM_FAST_MULT = 1 << 4,
201
  ARM_HWCAP_ARM_FPA       = 1 << 5,
202
  ARM_HWCAP_ARM_VFP       = 1 << 6,
203
  ARM_HWCAP_ARM_EDSP      = 1 << 7,
204
};
205

    
206
#define ELF_HWCAP (ARM_HWCAP_ARM_SWP | ARM_HWCAP_ARM_HALF              \
207
                    | ARM_HWCAP_ARM_THUMB | ARM_HWCAP_ARM_FAST_MULT     \
208
                    | ARM_HWCAP_ARM_FPA | ARM_HWCAP_ARM_VFP)
209

    
210
#endif
211

    
212
#ifdef TARGET_SPARC
213
#ifdef TARGET_SPARC64
214

    
215
#define ELF_START_MMAP 0x80000000
216

    
217
#ifndef TARGET_ABI32
218
#define elf_check_arch(x) ( (x) == EM_SPARCV9 || (x) == EM_SPARC32PLUS )
219
#else
220
#define elf_check_arch(x) ( (x) == EM_SPARC32PLUS || (x) == EM_SPARC )
221
#endif
222

    
223
#define ELF_CLASS   ELFCLASS64
224
#define ELF_DATA    ELFDATA2MSB
225
#define ELF_ARCH    EM_SPARCV9
226

    
227
#define STACK_BIAS                2047
228

    
229
static inline void init_thread(struct target_pt_regs *regs, struct image_info *infop)
230
{
231
#ifndef TARGET_ABI32
232
    regs->tstate = 0;
233
#endif
234
    regs->pc = infop->entry;
235
    regs->npc = regs->pc + 4;
236
    regs->y = 0;
237
#ifdef TARGET_ABI32
238
    regs->u_regs[14] = infop->start_stack - 16 * 4;
239
#else
240
    if (personality(infop->personality) == PER_LINUX32)
241
        regs->u_regs[14] = infop->start_stack - 16 * 4;
242
    else
243
        regs->u_regs[14] = infop->start_stack - 16 * 8 - STACK_BIAS;
244
#endif
245
}
246

    
247
#else
248
#define ELF_START_MMAP 0x80000000
249

    
250
#define elf_check_arch(x) ( (x) == EM_SPARC )
251

    
252
#define ELF_CLASS   ELFCLASS32
253
#define ELF_DATA    ELFDATA2MSB
254
#define ELF_ARCH    EM_SPARC
255

    
256
static inline void init_thread(struct target_pt_regs *regs, struct image_info *infop)
257
{
258
    regs->psr = 0;
259
    regs->pc = infop->entry;
260
    regs->npc = regs->pc + 4;
261
    regs->y = 0;
262
    regs->u_regs[14] = infop->start_stack - 16 * 4;
263
}
264

    
265
#endif
266
#endif
267

    
268
#ifdef TARGET_PPC
269

    
270
#define ELF_START_MMAP 0x80000000
271

    
272
#if defined(TARGET_PPC64) && !defined(TARGET_ABI32)
273

    
274
#define elf_check_arch(x) ( (x) == EM_PPC64 )
275

    
276
#define ELF_CLASS        ELFCLASS64
277

    
278
#else
279

    
280
#define elf_check_arch(x) ( (x) == EM_PPC )
281

    
282
#define ELF_CLASS        ELFCLASS32
283

    
284
#endif
285

    
286
#ifdef TARGET_WORDS_BIGENDIAN
287
#define ELF_DATA        ELFDATA2MSB
288
#else
289
#define ELF_DATA        ELFDATA2LSB
290
#endif
291
#define ELF_ARCH        EM_PPC
292

    
293
/*
294
 * We need to put in some extra aux table entries to tell glibc what
295
 * the cache block size is, so it can use the dcbz instruction safely.
296
 */
297
#define AT_DCACHEBSIZE          19
298
#define AT_ICACHEBSIZE          20
299
#define AT_UCACHEBSIZE          21
300
/* A special ignored type value for PPC, for glibc compatibility.  */
301
#define AT_IGNOREPPC            22
302
/*
303
 * The requirements here are:
304
 * - keep the final alignment of sp (sp & 0xf)
305
 * - make sure the 32-bit value at the first 16 byte aligned position of
306
 *   AUXV is greater than 16 for glibc compatibility.
307
 *   AT_IGNOREPPC is used for that.
308
 * - for compatibility with glibc ARCH_DLINFO must always be defined on PPC,
309
 *   even if DLINFO_ARCH_ITEMS goes to zero or is undefined.
310
 */
311
#define DLINFO_ARCH_ITEMS       5
312
#define ARCH_DLINFO                                                     \
313
do {                                                                    \
314
        NEW_AUX_ENT(AT_DCACHEBSIZE, 0x20);                              \
315
        NEW_AUX_ENT(AT_ICACHEBSIZE, 0x20);                              \
316
        NEW_AUX_ENT(AT_UCACHEBSIZE, 0);                                 \
317
        /*                                                              \
318
         * Now handle glibc compatibility.                              \
319
         */                                                             \
320
        NEW_AUX_ENT(AT_IGNOREPPC, AT_IGNOREPPC);                        \
321
        NEW_AUX_ENT(AT_IGNOREPPC, AT_IGNOREPPC);                        \
322
 } while (0)
323

    
324
static inline void init_thread(struct target_pt_regs *_regs, struct image_info *infop)
325
{
326
    abi_ulong pos = infop->start_stack;
327
    abi_ulong tmp;
328
#if defined(TARGET_PPC64) && !defined(TARGET_ABI32)
329
    abi_ulong entry, toc;
330
#endif
331

    
332
    _regs->msr = 1 << MSR_PR; /* Set user mode */
333
    _regs->gpr[1] = infop->start_stack;
334
#if defined(TARGET_PPC64) && !defined(TARGET_ABI32)
335
    entry = ldq_raw(infop->entry) + infop->load_addr;
336
    toc = ldq_raw(infop->entry + 8) + infop->load_addr;
337
    _regs->gpr[2] = toc;
338
    infop->entry = entry;
339
#endif
340
    _regs->nip = infop->entry;
341
    /* Note that isn't exactly what regular kernel does
342
     * but this is what the ABI wants and is needed to allow
343
     * execution of PPC BSD programs.
344
     */
345
    _regs->gpr[3] = tgetl(pos);
346
    pos += sizeof(abi_ulong);
347
    _regs->gpr[4] = pos;
348
    for (tmp = 1; tmp != 0; pos += sizeof(abi_ulong))
349
        tmp = ldl(pos);
350
    _regs->gpr[5] = pos;
351
}
352

    
353
#define USE_ELF_CORE_DUMP
354
#define ELF_EXEC_PAGESIZE        4096
355

    
356
#endif
357

    
358
#ifdef TARGET_MIPS
359

    
360
#define ELF_START_MMAP 0x80000000
361

    
362
#define elf_check_arch(x) ( (x) == EM_MIPS )
363

    
364
#ifdef TARGET_MIPS64
365
#define ELF_CLASS   ELFCLASS64
366
#else
367
#define ELF_CLASS   ELFCLASS32
368
#endif
369
#ifdef TARGET_WORDS_BIGENDIAN
370
#define ELF_DATA        ELFDATA2MSB
371
#else
372
#define ELF_DATA        ELFDATA2LSB
373
#endif
374
#define ELF_ARCH    EM_MIPS
375

    
376
static inline void init_thread(struct target_pt_regs *regs, struct image_info *infop)
377
{
378
    regs->cp0_status = CP0St_UM;
379
    regs->cp0_epc = infop->entry;
380
    regs->regs[29] = infop->start_stack;
381
}
382

    
383
#define USE_ELF_CORE_DUMP
384
#define ELF_EXEC_PAGESIZE        4096
385

    
386
#endif /* TARGET_MIPS */
387

    
388
#ifdef TARGET_SH4
389

    
390
#define ELF_START_MMAP 0x80000000
391

    
392
#define elf_check_arch(x) ( (x) == EM_SH )
393

    
394
#define ELF_CLASS ELFCLASS32
395
#define ELF_DATA  ELFDATA2LSB
396
#define ELF_ARCH  EM_SH
397

    
398
static inline void init_thread(struct target_pt_regs *regs, struct image_info *infop)
399
{
400
  /* Check other registers XXXXX */
401
  regs->pc = infop->entry;
402
  regs->regs[15] = infop->start_stack;
403
}
404

    
405
#define USE_ELF_CORE_DUMP
406
#define ELF_EXEC_PAGESIZE        4096
407

    
408
#endif
409

    
410
#ifdef TARGET_CRIS
411

    
412
#define ELF_START_MMAP 0x80000000
413

    
414
#define elf_check_arch(x) ( (x) == EM_CRIS )
415

    
416
#define ELF_CLASS ELFCLASS32
417
#define ELF_DATA  ELFDATA2LSB
418
#define ELF_ARCH  EM_CRIS
419

    
420
static inline void init_thread(struct target_pt_regs *regs, struct image_info *infop)
421
{
422
  regs->erp = infop->entry;
423
}
424

    
425
#define USE_ELF_CORE_DUMP
426
#define ELF_EXEC_PAGESIZE        8192
427

    
428
#endif
429

    
430
#ifdef TARGET_M68K
431

    
432
#define ELF_START_MMAP 0x80000000
433

    
434
#define elf_check_arch(x) ( (x) == EM_68K )
435

    
436
#define ELF_CLASS        ELFCLASS32
437
#define ELF_DATA        ELFDATA2MSB
438
#define ELF_ARCH        EM_68K
439

    
440
/* ??? Does this need to do anything?
441
#define ELF_PLAT_INIT(_r) */
442

    
443
static inline void init_thread(struct target_pt_regs *regs, struct image_info *infop)
444
{
445
    regs->usp = infop->start_stack;
446
    regs->sr = 0;
447
    regs->pc = infop->entry;
448
}
449

    
450
#define USE_ELF_CORE_DUMP
451
#define ELF_EXEC_PAGESIZE        8192
452

    
453
#endif
454

    
455
#ifdef TARGET_ALPHA
456

    
457
#define ELF_START_MMAP (0x30000000000ULL)
458

    
459
#define elf_check_arch(x) ( (x) == ELF_ARCH )
460

    
461
#define ELF_CLASS      ELFCLASS64
462
#define ELF_DATA       ELFDATA2MSB
463
#define ELF_ARCH       EM_ALPHA
464

    
465
static inline void init_thread(struct target_pt_regs *regs, struct image_info *infop)
466
{
467
    regs->pc = infop->entry;
468
    regs->ps = 8;
469
    regs->usp = infop->start_stack;
470
    regs->unique = infop->start_data; /* ? */
471
    printf("Set unique value to " TARGET_FMT_lx " (" TARGET_FMT_lx ")\n",
472
           regs->unique, infop->start_data);
473
}
474

    
475
#define USE_ELF_CORE_DUMP
476
#define ELF_EXEC_PAGESIZE        8192
477

    
478
#endif /* TARGET_ALPHA */
479

    
480
#ifndef ELF_PLATFORM
481
#define ELF_PLATFORM (NULL)
482
#endif
483

    
484
#ifndef ELF_HWCAP
485
#define ELF_HWCAP 0
486
#endif
487

    
488
#ifdef TARGET_ABI32
489
#undef ELF_CLASS
490
#define ELF_CLASS ELFCLASS32
491
#undef bswaptls
492
#define bswaptls(ptr) bswap32s(ptr)
493
#endif
494

    
495
#include "elf.h"
496

    
497
struct exec
498
{
499
  unsigned int a_info;   /* Use macros N_MAGIC, etc for access */
500
  unsigned int a_text;   /* length of text, in bytes */
501
  unsigned int a_data;   /* length of data, in bytes */
502
  unsigned int a_bss;    /* length of uninitialized data area, in bytes */
503
  unsigned int a_syms;   /* length of symbol table data in file, in bytes */
504
  unsigned int a_entry;  /* start address */
505
  unsigned int a_trsize; /* length of relocation info for text, in bytes */
506
  unsigned int a_drsize; /* length of relocation info for data, in bytes */
507
};
508

    
509

    
510
#define N_MAGIC(exec) ((exec).a_info & 0xffff)
511
#define OMAGIC 0407
512
#define NMAGIC 0410
513
#define ZMAGIC 0413
514
#define QMAGIC 0314
515

    
516
/* max code+data+bss space allocated to elf interpreter */
517
#define INTERP_MAP_SIZE (32 * 1024 * 1024)
518

    
519
/* max code+data+bss+brk space allocated to ET_DYN executables */
520
#define ET_DYN_MAP_SIZE (128 * 1024 * 1024)
521

    
522
/* Necessary parameters */
523
#define TARGET_ELF_EXEC_PAGESIZE TARGET_PAGE_SIZE
524
#define TARGET_ELF_PAGESTART(_v) ((_v) & ~(unsigned long)(TARGET_ELF_EXEC_PAGESIZE-1))
525
#define TARGET_ELF_PAGEOFFSET(_v) ((_v) & (TARGET_ELF_EXEC_PAGESIZE-1))
526

    
527
#define INTERPRETER_NONE 0
528
#define INTERPRETER_AOUT 1
529
#define INTERPRETER_ELF 2
530

    
531
#define DLINFO_ITEMS 12
532

    
533
static inline void memcpy_fromfs(void * to, const void * from, unsigned long n)
534
{
535
        memcpy(to, from, n);
536
}
537

    
538
extern unsigned long x86_stack_size;
539

    
540
static int load_aout_interp(void * exptr, int interp_fd);
541

    
542
#ifdef BSWAP_NEEDED
543
static void bswap_ehdr(struct elfhdr *ehdr)
544
{
545
    bswap16s(&ehdr->e_type);                        /* Object file type */
546
    bswap16s(&ehdr->e_machine);                /* Architecture */
547
    bswap32s(&ehdr->e_version);                /* Object file version */
548
    bswaptls(&ehdr->e_entry);                /* Entry point virtual address */
549
    bswaptls(&ehdr->e_phoff);                /* Program header table file offset */
550
    bswaptls(&ehdr->e_shoff);                /* Section header table file offset */
551
    bswap32s(&ehdr->e_flags);                /* Processor-specific flags */
552
    bswap16s(&ehdr->e_ehsize);                /* ELF header size in bytes */
553
    bswap16s(&ehdr->e_phentsize);                /* Program header table entry size */
554
    bswap16s(&ehdr->e_phnum);                /* Program header table entry count */
555
    bswap16s(&ehdr->e_shentsize);                /* Section header table entry size */
556
    bswap16s(&ehdr->e_shnum);                /* Section header table entry count */
557
    bswap16s(&ehdr->e_shstrndx);                /* Section header string table index */
558
}
559

    
560
static void bswap_phdr(struct elf_phdr *phdr)
561
{
562
    bswap32s(&phdr->p_type);                        /* Segment type */
563
    bswaptls(&phdr->p_offset);                /* Segment file offset */
564
    bswaptls(&phdr->p_vaddr);                /* Segment virtual address */
565
    bswaptls(&phdr->p_paddr);                /* Segment physical address */
566
    bswaptls(&phdr->p_filesz);                /* Segment size in file */
567
    bswaptls(&phdr->p_memsz);                /* Segment size in memory */
568
    bswap32s(&phdr->p_flags);                /* Segment flags */
569
    bswaptls(&phdr->p_align);                /* Segment alignment */
570
}
571

    
572
static void bswap_shdr(struct elf_shdr *shdr)
573
{
574
    bswap32s(&shdr->sh_name);
575
    bswap32s(&shdr->sh_type);
576
    bswaptls(&shdr->sh_flags);
577
    bswaptls(&shdr->sh_addr);
578
    bswaptls(&shdr->sh_offset);
579
    bswaptls(&shdr->sh_size);
580
    bswap32s(&shdr->sh_link);
581
    bswap32s(&shdr->sh_info);
582
    bswaptls(&shdr->sh_addralign);
583
    bswaptls(&shdr->sh_entsize);
584
}
585

    
586
static void bswap_sym(struct elf_sym *sym)
587
{
588
    bswap32s(&sym->st_name);
589
    bswaptls(&sym->st_value);
590
    bswaptls(&sym->st_size);
591
    bswap16s(&sym->st_shndx);
592
}
593
#endif
594

    
595
/*
596
 * 'copy_elf_strings()' copies argument/envelope strings from user
597
 * memory to free pages in kernel mem. These are in a format ready
598
 * to be put directly into the top of new user memory.
599
 *
600
 */
601
static abi_ulong copy_elf_strings(int argc,char ** argv, void **page,
602
                                  abi_ulong p)
603
{
604
    char *tmp, *tmp1, *pag = NULL;
605
    int len, offset = 0;
606

    
607
    if (!p) {
608
        return 0;       /* bullet-proofing */
609
    }
610
    while (argc-- > 0) {
611
        tmp = argv[argc];
612
        if (!tmp) {
613
            fprintf(stderr, "VFS: argc is wrong");
614
            exit(-1);
615
        }
616
        tmp1 = tmp;
617
        while (*tmp++);
618
        len = tmp - tmp1;
619
        if (p < len) {  /* this shouldn't happen - 128kB */
620
                return 0;
621
        }
622
        while (len) {
623
            --p; --tmp; --len;
624
            if (--offset < 0) {
625
                offset = p % TARGET_PAGE_SIZE;
626
                pag = (char *)page[p/TARGET_PAGE_SIZE];
627
                if (!pag) {
628
                    pag = (char *)malloc(TARGET_PAGE_SIZE);
629
                    memset(pag, 0, TARGET_PAGE_SIZE);
630
                    page[p/TARGET_PAGE_SIZE] = pag;
631
                    if (!pag)
632
                        return 0;
633
                }
634
            }
635
            if (len == 0 || offset == 0) {
636
                *(pag + offset) = *tmp;
637
            }
638
            else {
639
              int bytes_to_copy = (len > offset) ? offset : len;
640
              tmp -= bytes_to_copy;
641
              p -= bytes_to_copy;
642
              offset -= bytes_to_copy;
643
              len -= bytes_to_copy;
644
              memcpy_fromfs(pag + offset, tmp, bytes_to_copy + 1);
645
            }
646
        }
647
    }
648
    return p;
649
}
650

    
651
static abi_ulong setup_arg_pages(abi_ulong p, struct linux_binprm *bprm,
652
                                 struct image_info *info)
653
{
654
    abi_ulong stack_base, size, error;
655
    int i;
656

    
657
    /* Create enough stack to hold everything.  If we don't use
658
     * it for args, we'll use it for something else...
659
     */
660
    size = x86_stack_size;
661
    if (size < MAX_ARG_PAGES*TARGET_PAGE_SIZE)
662
        size = MAX_ARG_PAGES*TARGET_PAGE_SIZE;
663
    error = target_mmap(0,
664
                        size + qemu_host_page_size,
665
                        PROT_READ | PROT_WRITE,
666
                        MAP_PRIVATE | MAP_ANONYMOUS,
667
                        -1, 0);
668
    if (error == -1) {
669
        perror("stk mmap");
670
        exit(-1);
671
    }
672
    /* we reserve one extra page at the top of the stack as guard */
673
    target_mprotect(error + size, qemu_host_page_size, PROT_NONE);
674

    
675
    stack_base = error + size - MAX_ARG_PAGES*TARGET_PAGE_SIZE;
676
    p += stack_base;
677

    
678
    for (i = 0 ; i < MAX_ARG_PAGES ; i++) {
679
        if (bprm->page[i]) {
680
            info->rss++;
681

    
682
            memcpy_to_target(stack_base, bprm->page[i], TARGET_PAGE_SIZE);
683
            free(bprm->page[i]);
684
        }
685
        stack_base += TARGET_PAGE_SIZE;
686
    }
687
    return p;
688
}
689

    
690
static void set_brk(abi_ulong start, abi_ulong end)
691
{
692
        /* page-align the start and end addresses... */
693
        start = HOST_PAGE_ALIGN(start);
694
        end = HOST_PAGE_ALIGN(end);
695
        if (end <= start)
696
                return;
697
        if(target_mmap(start, end - start,
698
                       PROT_READ | PROT_WRITE | PROT_EXEC,
699
                       MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0) == -1) {
700
            perror("cannot mmap brk");
701
            exit(-1);
702
        }
703
}
704

    
705

    
706
/* We need to explicitly zero any fractional pages after the data
707
   section (i.e. bss).  This would contain the junk from the file that
708
   should not be in memory. */
709
static void padzero(abi_ulong elf_bss, abi_ulong last_bss)
710
{
711
        abi_ulong nbyte;
712

    
713
        if (elf_bss >= last_bss)
714
                return;
715

    
716
        /* XXX: this is really a hack : if the real host page size is
717
           smaller than the target page size, some pages after the end
718
           of the file may not be mapped. A better fix would be to
719
           patch target_mmap(), but it is more complicated as the file
720
           size must be known */
721
        if (qemu_real_host_page_size < qemu_host_page_size) {
722
            abi_ulong end_addr, end_addr1;
723
            end_addr1 = (elf_bss + qemu_real_host_page_size - 1) &
724
                ~(qemu_real_host_page_size - 1);
725
            end_addr = HOST_PAGE_ALIGN(elf_bss);
726
            if (end_addr1 < end_addr) {
727
                mmap((void *)g2h(end_addr1), end_addr - end_addr1,
728
                     PROT_READ|PROT_WRITE|PROT_EXEC,
729
                     MAP_FIXED|MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
730
            }
731
        }
732

    
733
        nbyte = elf_bss & (qemu_host_page_size-1);
734
        if (nbyte) {
735
            nbyte = qemu_host_page_size - nbyte;
736
            do {
737
                tput8(elf_bss, 0);
738
                elf_bss++;
739
            } while (--nbyte);
740
        }
741
}
742

    
743

    
744
static abi_ulong create_elf_tables(abi_ulong p, int argc, int envc,
745
                                   struct elfhdr * exec,
746
                                   abi_ulong load_addr,
747
                                   abi_ulong load_bias,
748
                                   abi_ulong interp_load_addr, int ibcs,
749
                                   struct image_info *info)
750
{
751
        abi_ulong sp;
752
        int size;
753
        abi_ulong u_platform;
754
        const char *k_platform;
755
        const int n = sizeof(elf_addr_t);
756

    
757
        sp = p;
758
        u_platform = 0;
759
        k_platform = ELF_PLATFORM;
760
        if (k_platform) {
761
            size_t len = strlen(k_platform) + 1;
762
            sp -= (len + n - 1) & ~(n - 1);
763
            u_platform = sp;
764
            memcpy_to_target(sp, k_platform, len);
765
        }
766
        /*
767
         * Force 16 byte _final_ alignment here for generality.
768
         */
769
        sp = sp &~ (abi_ulong)15;
770
        size = (DLINFO_ITEMS + 1) * 2;
771
        if (k_platform)
772
          size += 2;
773
#ifdef DLINFO_ARCH_ITEMS
774
        size += DLINFO_ARCH_ITEMS * 2;
775
#endif
776
        size += envc + argc + 2;
777
        size += (!ibcs ? 3 : 1);        /* argc itself */
778
        size *= n;
779
        if (size & 15)
780
            sp -= 16 - (size & 15);
781

    
782
        /* This is correct because Linux defines
783
         * elf_addr_t as Elf32_Off / Elf64_Off
784
         */
785
#if ELF_CLASS == ELFCLASS32
786
#define NEW_AUX_ENT(id, val) do { \
787
            sp -= n; tput32(sp, val); \
788
            sp -= n; tput32(sp, id); \
789
          } while(0)
790
#else
791
#define NEW_AUX_ENT(id, val) do { \
792
            sp -= n; tput64(sp, val); \
793
            sp -= n; tput64(sp, id); \
794
          } while(0)
795
#endif
796
        NEW_AUX_ENT (AT_NULL, 0);
797

    
798
        /* There must be exactly DLINFO_ITEMS entries here.  */
799
        NEW_AUX_ENT(AT_PHDR, (abi_ulong)(load_addr + exec->e_phoff));
800
        NEW_AUX_ENT(AT_PHENT, (abi_ulong)(sizeof (struct elf_phdr)));
801
        NEW_AUX_ENT(AT_PHNUM, (abi_ulong)(exec->e_phnum));
802
        NEW_AUX_ENT(AT_PAGESZ, (abi_ulong)(TARGET_PAGE_SIZE));
803
        NEW_AUX_ENT(AT_BASE, (abi_ulong)(interp_load_addr));
804
        NEW_AUX_ENT(AT_FLAGS, (abi_ulong)0);
805
        NEW_AUX_ENT(AT_ENTRY, load_bias + exec->e_entry);
806
        NEW_AUX_ENT(AT_UID, (abi_ulong) getuid());
807
        NEW_AUX_ENT(AT_EUID, (abi_ulong) geteuid());
808
        NEW_AUX_ENT(AT_GID, (abi_ulong) getgid());
809
        NEW_AUX_ENT(AT_EGID, (abi_ulong) getegid());
810
        NEW_AUX_ENT(AT_HWCAP, (abi_ulong) ELF_HWCAP);
811
        if (k_platform)
812
            NEW_AUX_ENT(AT_PLATFORM, u_platform);
813
#ifdef ARCH_DLINFO
814
        /*
815
         * ARCH_DLINFO must come last so platform specific code can enforce
816
         * special alignment requirements on the AUXV if necessary (eg. PPC).
817
         */
818
        ARCH_DLINFO;
819
#endif
820
#undef NEW_AUX_ENT
821

    
822
        sp = loader_build_argptr(envc, argc, sp, p, !ibcs);
823
        return sp;
824
}
825

    
826

    
827
static abi_ulong load_elf_interp(struct elfhdr * interp_elf_ex,
828
                                 int interpreter_fd,
829
                                 abi_ulong *interp_load_addr)
830
{
831
        struct elf_phdr *elf_phdata  =  NULL;
832
        struct elf_phdr *eppnt;
833
        abi_ulong load_addr = 0;
834
        int load_addr_set = 0;
835
        int retval;
836
        abi_ulong last_bss, elf_bss;
837
        abi_ulong error;
838
        int i;
839

    
840
        elf_bss = 0;
841
        last_bss = 0;
842
        error = 0;
843

    
844
#ifdef BSWAP_NEEDED
845
        bswap_ehdr(interp_elf_ex);
846
#endif
847
        /* First of all, some simple consistency checks */
848
        if ((interp_elf_ex->e_type != ET_EXEC &&
849
             interp_elf_ex->e_type != ET_DYN) ||
850
           !elf_check_arch(interp_elf_ex->e_machine)) {
851
                return ~((abi_ulong)0UL);
852
        }
853

    
854

    
855
        /* Now read in all of the header information */
856

    
857
        if (sizeof(struct elf_phdr) * interp_elf_ex->e_phnum > TARGET_PAGE_SIZE)
858
            return ~(abi_ulong)0UL;
859

    
860
        elf_phdata =  (struct elf_phdr *)
861
                malloc(sizeof(struct elf_phdr) * interp_elf_ex->e_phnum);
862

    
863
        if (!elf_phdata)
864
          return ~((abi_ulong)0UL);
865

    
866
        /*
867
         * If the size of this structure has changed, then punt, since
868
         * we will be doing the wrong thing.
869
         */
870
        if (interp_elf_ex->e_phentsize != sizeof(struct elf_phdr)) {
871
            free(elf_phdata);
872
            return ~((abi_ulong)0UL);
873
        }
874

    
875
        retval = lseek(interpreter_fd, interp_elf_ex->e_phoff, SEEK_SET);
876
        if(retval >= 0) {
877
            retval = read(interpreter_fd,
878
                           (char *) elf_phdata,
879
                           sizeof(struct elf_phdr) * interp_elf_ex->e_phnum);
880
        }
881
        if (retval < 0) {
882
                perror("load_elf_interp");
883
                exit(-1);
884
                free (elf_phdata);
885
                return retval;
886
         }
887
#ifdef BSWAP_NEEDED
888
        eppnt = elf_phdata;
889
        for (i=0; i<interp_elf_ex->e_phnum; i++, eppnt++) {
890
            bswap_phdr(eppnt);
891
        }
892
#endif
893

    
894
        if (interp_elf_ex->e_type == ET_DYN) {
895
            /* in order to avoid hardcoding the interpreter load
896
               address in qemu, we allocate a big enough memory zone */
897
            error = target_mmap(0, INTERP_MAP_SIZE,
898
                                PROT_NONE, MAP_PRIVATE | MAP_ANON,
899
                                -1, 0);
900
            if (error == -1) {
901
                perror("mmap");
902
                exit(-1);
903
            }
904
            load_addr = error;
905
            load_addr_set = 1;
906
        }
907

    
908
        eppnt = elf_phdata;
909
        for(i=0; i<interp_elf_ex->e_phnum; i++, eppnt++)
910
          if (eppnt->p_type == PT_LOAD) {
911
            int elf_type = MAP_PRIVATE | MAP_DENYWRITE;
912
            int elf_prot = 0;
913
            abi_ulong vaddr = 0;
914
            abi_ulong k;
915

    
916
            if (eppnt->p_flags & PF_R) elf_prot =  PROT_READ;
917
            if (eppnt->p_flags & PF_W) elf_prot |= PROT_WRITE;
918
            if (eppnt->p_flags & PF_X) elf_prot |= PROT_EXEC;
919
            if (interp_elf_ex->e_type == ET_EXEC || load_addr_set) {
920
                    elf_type |= MAP_FIXED;
921
                    vaddr = eppnt->p_vaddr;
922
            }
923
            error = target_mmap(load_addr+TARGET_ELF_PAGESTART(vaddr),
924
                 eppnt->p_filesz + TARGET_ELF_PAGEOFFSET(eppnt->p_vaddr),
925
                 elf_prot,
926
                 elf_type,
927
                 interpreter_fd,
928
                 eppnt->p_offset - TARGET_ELF_PAGEOFFSET(eppnt->p_vaddr));
929

    
930
            if (error == -1) {
931
              /* Real error */
932
              close(interpreter_fd);
933
              free(elf_phdata);
934
              return ~((abi_ulong)0UL);
935
            }
936

    
937
            if (!load_addr_set && interp_elf_ex->e_type == ET_DYN) {
938
              load_addr = error;
939
              load_addr_set = 1;
940
            }
941

    
942
            /*
943
             * Find the end of the file  mapping for this phdr, and keep
944
             * track of the largest address we see for this.
945
             */
946
            k = load_addr + eppnt->p_vaddr + eppnt->p_filesz;
947
            if (k > elf_bss) elf_bss = k;
948

    
949
            /*
950
             * Do the same thing for the memory mapping - between
951
             * elf_bss and last_bss is the bss section.
952
             */
953
            k = load_addr + eppnt->p_memsz + eppnt->p_vaddr;
954
            if (k > last_bss) last_bss = k;
955
          }
956

    
957
        /* Now use mmap to map the library into memory. */
958

    
959
        close(interpreter_fd);
960

    
961
        /*
962
         * Now fill out the bss section.  First pad the last page up
963
         * to the page boundary, and then perform a mmap to make sure
964
         * that there are zeromapped pages up to and including the last
965
         * bss page.
966
         */
967
        padzero(elf_bss, last_bss);
968
        elf_bss = TARGET_ELF_PAGESTART(elf_bss + qemu_host_page_size - 1); /* What we have mapped so far */
969

    
970
        /* Map the last of the bss segment */
971
        if (last_bss > elf_bss) {
972
            target_mmap(elf_bss, last_bss-elf_bss,
973
                        PROT_READ|PROT_WRITE|PROT_EXEC,
974
                        MAP_FIXED|MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
975
        }
976
        free(elf_phdata);
977

    
978
        *interp_load_addr = load_addr;
979
        return ((abi_ulong) interp_elf_ex->e_entry) + load_addr;
980
}
981

    
982
/* Best attempt to load symbols from this ELF object. */
983
static void load_symbols(struct elfhdr *hdr, int fd)
984
{
985
    unsigned int i;
986
    struct elf_shdr sechdr, symtab, strtab;
987
    char *strings;
988
    struct syminfo *s;
989
#if (ELF_CLASS == ELFCLASS64)
990
    // Disas uses 32 bit symbols
991
    struct elf32_sym *syms32 = NULL;
992
    struct elf_sym *sym;
993
#endif
994

    
995
    lseek(fd, hdr->e_shoff, SEEK_SET);
996
    for (i = 0; i < hdr->e_shnum; i++) {
997
        if (read(fd, &sechdr, sizeof(sechdr)) != sizeof(sechdr))
998
            return;
999
#ifdef BSWAP_NEEDED
1000
        bswap_shdr(&sechdr);
1001
#endif
1002
        if (sechdr.sh_type == SHT_SYMTAB) {
1003
            symtab = sechdr;
1004
            lseek(fd, hdr->e_shoff
1005
                  + sizeof(sechdr) * sechdr.sh_link, SEEK_SET);
1006
            if (read(fd, &strtab, sizeof(strtab))
1007
                != sizeof(strtab))
1008
                return;
1009
#ifdef BSWAP_NEEDED
1010
            bswap_shdr(&strtab);
1011
#endif
1012
            goto found;
1013
        }
1014
    }
1015
    return; /* Shouldn't happen... */
1016

    
1017
 found:
1018
    /* Now know where the strtab and symtab are.  Snarf them. */
1019
    s = malloc(sizeof(*s));
1020
    s->disas_symtab = malloc(symtab.sh_size);
1021
#if (ELF_CLASS == ELFCLASS64)
1022
    syms32 = malloc(symtab.sh_size / sizeof(struct elf_sym)
1023
                    * sizeof(struct elf32_sym));
1024
#endif
1025
    s->disas_strtab = strings = malloc(strtab.sh_size);
1026
    if (!s->disas_symtab || !s->disas_strtab)
1027
        return;
1028

    
1029
    lseek(fd, symtab.sh_offset, SEEK_SET);
1030
    if (read(fd, s->disas_symtab, symtab.sh_size) != symtab.sh_size)
1031
        return;
1032

    
1033
    for (i = 0; i < symtab.sh_size / sizeof(struct elf_sym); i++) {
1034
#ifdef BSWAP_NEEDED
1035
        bswap_sym(s->disas_symtab + sizeof(struct elf_sym)*i);
1036
#endif
1037
#if (ELF_CLASS == ELFCLASS64)
1038
        sym = s->disas_symtab + sizeof(struct elf_sym)*i;
1039
        syms32[i].st_name = sym->st_name;
1040
        syms32[i].st_info = sym->st_info;
1041
        syms32[i].st_other = sym->st_other;
1042
        syms32[i].st_shndx = sym->st_shndx;
1043
        syms32[i].st_value = sym->st_value & 0xffffffff;
1044
        syms32[i].st_size = sym->st_size & 0xffffffff;
1045
#endif
1046
    }
1047

    
1048
#if (ELF_CLASS == ELFCLASS64)
1049
    free(s->disas_symtab);
1050
    s->disas_symtab = syms32;
1051
#endif
1052
    lseek(fd, strtab.sh_offset, SEEK_SET);
1053
    if (read(fd, strings, strtab.sh_size) != strtab.sh_size)
1054
        return;
1055
    s->disas_num_syms = symtab.sh_size / sizeof(struct elf_sym);
1056
    s->next = syminfos;
1057
    syminfos = s;
1058
}
1059

    
1060
int load_elf_binary(struct linux_binprm * bprm, struct target_pt_regs * regs,
1061
                    struct image_info * info)
1062
{
1063
    struct elfhdr elf_ex;
1064
    struct elfhdr interp_elf_ex;
1065
    struct exec interp_ex;
1066
    int interpreter_fd = -1; /* avoid warning */
1067
    abi_ulong load_addr, load_bias;
1068
    int load_addr_set = 0;
1069
    unsigned int interpreter_type = INTERPRETER_NONE;
1070
    unsigned char ibcs2_interpreter;
1071
    int i;
1072
    abi_ulong mapped_addr;
1073
    struct elf_phdr * elf_ppnt;
1074
    struct elf_phdr *elf_phdata;
1075
    abi_ulong elf_bss, k, elf_brk;
1076
    int retval;
1077
    char * elf_interpreter;
1078
    abi_ulong elf_entry, interp_load_addr = 0;
1079
    int status;
1080
    abi_ulong start_code, end_code, start_data, end_data;
1081
    abi_ulong reloc_func_desc = 0;
1082
    abi_ulong elf_stack;
1083
    char passed_fileno[6];
1084

    
1085
    ibcs2_interpreter = 0;
1086
    status = 0;
1087
    load_addr = 0;
1088
    load_bias = 0;
1089
    elf_ex = *((struct elfhdr *) bprm->buf);          /* exec-header */
1090
#ifdef BSWAP_NEEDED
1091
    bswap_ehdr(&elf_ex);
1092
#endif
1093

    
1094
    /* First of all, some simple consistency checks */
1095
    if ((elf_ex.e_type != ET_EXEC && elf_ex.e_type != ET_DYN) ||
1096
                                       (! elf_check_arch(elf_ex.e_machine))) {
1097
            return -ENOEXEC;
1098
    }
1099

    
1100
    bprm->p = copy_elf_strings(1, &bprm->filename, bprm->page, bprm->p);
1101
    bprm->p = copy_elf_strings(bprm->envc,bprm->envp,bprm->page,bprm->p);
1102
    bprm->p = copy_elf_strings(bprm->argc,bprm->argv,bprm->page,bprm->p);
1103
    if (!bprm->p) {
1104
        retval = -E2BIG;
1105
    }
1106

    
1107
    /* Now read in all of the header information */
1108
    elf_phdata = (struct elf_phdr *)malloc(elf_ex.e_phentsize*elf_ex.e_phnum);
1109
    if (elf_phdata == NULL) {
1110
        return -ENOMEM;
1111
    }
1112

    
1113
    retval = lseek(bprm->fd, elf_ex.e_phoff, SEEK_SET);
1114
    if(retval > 0) {
1115
        retval = read(bprm->fd, (char *) elf_phdata,
1116
                                elf_ex.e_phentsize * elf_ex.e_phnum);
1117
    }
1118

    
1119
    if (retval < 0) {
1120
        perror("load_elf_binary");
1121
        exit(-1);
1122
        free (elf_phdata);
1123
        return -errno;
1124
    }
1125

    
1126
#ifdef BSWAP_NEEDED
1127
    elf_ppnt = elf_phdata;
1128
    for (i=0; i<elf_ex.e_phnum; i++, elf_ppnt++) {
1129
        bswap_phdr(elf_ppnt);
1130
    }
1131
#endif
1132
    elf_ppnt = elf_phdata;
1133

    
1134
    elf_bss = 0;
1135
    elf_brk = 0;
1136

    
1137

    
1138
    elf_stack = ~((abi_ulong)0UL);
1139
    elf_interpreter = NULL;
1140
    start_code = ~((abi_ulong)0UL);
1141
    end_code = 0;
1142
    start_data = 0;
1143
    end_data = 0;
1144

    
1145
    for(i=0;i < elf_ex.e_phnum; i++) {
1146
        if (elf_ppnt->p_type == PT_INTERP) {
1147
            if ( elf_interpreter != NULL )
1148
            {
1149
                free (elf_phdata);
1150
                free(elf_interpreter);
1151
                close(bprm->fd);
1152
                return -EINVAL;
1153
            }
1154

    
1155
            /* This is the program interpreter used for
1156
             * shared libraries - for now assume that this
1157
             * is an a.out format binary
1158
             */
1159

    
1160
            elf_interpreter = (char *)malloc(elf_ppnt->p_filesz);
1161

    
1162
            if (elf_interpreter == NULL) {
1163
                free (elf_phdata);
1164
                close(bprm->fd);
1165
                return -ENOMEM;
1166
            }
1167

    
1168
            retval = lseek(bprm->fd, elf_ppnt->p_offset, SEEK_SET);
1169
            if(retval >= 0) {
1170
                retval = read(bprm->fd, elf_interpreter, elf_ppnt->p_filesz);
1171
            }
1172
            if(retval < 0) {
1173
                 perror("load_elf_binary2");
1174
                exit(-1);
1175
            }
1176

    
1177
            /* If the program interpreter is one of these two,
1178
               then assume an iBCS2 image. Otherwise assume
1179
               a native linux image. */
1180

    
1181
            /* JRP - Need to add X86 lib dir stuff here... */
1182

    
1183
            if (strcmp(elf_interpreter,"/usr/lib/libc.so.1") == 0 ||
1184
                strcmp(elf_interpreter,"/usr/lib/ld.so.1") == 0) {
1185
              ibcs2_interpreter = 1;
1186
            }
1187

    
1188
#if 0
1189
            printf("Using ELF interpreter %s\n", elf_interpreter);
1190
#endif
1191
            if (retval >= 0) {
1192
                retval = open(path(elf_interpreter), O_RDONLY);
1193
                if(retval >= 0) {
1194
                    interpreter_fd = retval;
1195
                }
1196
                else {
1197
                    perror(elf_interpreter);
1198
                    exit(-1);
1199
                    /* retval = -errno; */
1200
                }
1201
            }
1202

    
1203
            if (retval >= 0) {
1204
                retval = lseek(interpreter_fd, 0, SEEK_SET);
1205
                if(retval >= 0) {
1206
                    retval = read(interpreter_fd,bprm->buf,128);
1207
                }
1208
            }
1209
            if (retval >= 0) {
1210
                interp_ex = *((struct exec *) bprm->buf); /* aout exec-header */
1211
                interp_elf_ex=*((struct elfhdr *) bprm->buf); /* elf exec-header */
1212
            }
1213
            if (retval < 0) {
1214
                perror("load_elf_binary3");
1215
                exit(-1);
1216
                free (elf_phdata);
1217
                free(elf_interpreter);
1218
                close(bprm->fd);
1219
                return retval;
1220
            }
1221
        }
1222
        elf_ppnt++;
1223
    }
1224

    
1225
    /* Some simple consistency checks for the interpreter */
1226
    if (elf_interpreter){
1227
        interpreter_type = INTERPRETER_ELF | INTERPRETER_AOUT;
1228

    
1229
        /* Now figure out which format our binary is */
1230
        if ((N_MAGIC(interp_ex) != OMAGIC) && (N_MAGIC(interp_ex) != ZMAGIC) &&
1231
                    (N_MAGIC(interp_ex) != QMAGIC)) {
1232
          interpreter_type = INTERPRETER_ELF;
1233
        }
1234

    
1235
        if (interp_elf_ex.e_ident[0] != 0x7f ||
1236
                    strncmp(&interp_elf_ex.e_ident[1], "ELF",3) != 0) {
1237
            interpreter_type &= ~INTERPRETER_ELF;
1238
        }
1239

    
1240
        if (!interpreter_type) {
1241
            free(elf_interpreter);
1242
            free(elf_phdata);
1243
            close(bprm->fd);
1244
            return -ELIBBAD;
1245
        }
1246
    }
1247

    
1248
    /* OK, we are done with that, now set up the arg stuff,
1249
       and then start this sucker up */
1250

    
1251
    {
1252
        char * passed_p;
1253

    
1254
        if (interpreter_type == INTERPRETER_AOUT) {
1255
            snprintf(passed_fileno, sizeof(passed_fileno), "%d", bprm->fd);
1256
            passed_p = passed_fileno;
1257

    
1258
            if (elf_interpreter) {
1259
                bprm->p = copy_elf_strings(1,&passed_p,bprm->page,bprm->p);
1260
                bprm->argc++;
1261
            }
1262
        }
1263
        if (!bprm->p) {
1264
            if (elf_interpreter) {
1265
                free(elf_interpreter);
1266
            }
1267
            free (elf_phdata);
1268
            close(bprm->fd);
1269
            return -E2BIG;
1270
        }
1271
    }
1272

    
1273
    /* OK, This is the point of no return */
1274
    info->end_data = 0;
1275
    info->end_code = 0;
1276
    info->start_mmap = (abi_ulong)ELF_START_MMAP;
1277
    info->mmap = 0;
1278
    elf_entry = (abi_ulong) elf_ex.e_entry;
1279

    
1280
    /* Do this so that we can load the interpreter, if need be.  We will
1281
       change some of these later */
1282
    info->rss = 0;
1283
    bprm->p = setup_arg_pages(bprm->p, bprm, info);
1284
    info->start_stack = bprm->p;
1285

    
1286
    /* Now we do a little grungy work by mmaping the ELF image into
1287
     * the correct location in memory.  At this point, we assume that
1288
     * the image should be loaded at fixed address, not at a variable
1289
     * address.
1290
     */
1291

    
1292
    for(i = 0, elf_ppnt = elf_phdata; i < elf_ex.e_phnum; i++, elf_ppnt++) {
1293
        int elf_prot = 0;
1294
        int elf_flags = 0;
1295
        abi_ulong error;
1296

    
1297
        if (elf_ppnt->p_type != PT_LOAD)
1298
            continue;
1299

    
1300
        if (elf_ppnt->p_flags & PF_R) elf_prot |= PROT_READ;
1301
        if (elf_ppnt->p_flags & PF_W) elf_prot |= PROT_WRITE;
1302
        if (elf_ppnt->p_flags & PF_X) elf_prot |= PROT_EXEC;
1303
        elf_flags = MAP_PRIVATE | MAP_DENYWRITE;
1304
        if (elf_ex.e_type == ET_EXEC || load_addr_set) {
1305
            elf_flags |= MAP_FIXED;
1306
        } else if (elf_ex.e_type == ET_DYN) {
1307
            /* Try and get dynamic programs out of the way of the default mmap
1308
               base, as well as whatever program they might try to exec.  This
1309
               is because the brk will follow the loader, and is not movable.  */
1310
            /* NOTE: for qemu, we do a big mmap to get enough space
1311
               without hardcoding any address */
1312
            error = target_mmap(0, ET_DYN_MAP_SIZE,
1313
                                PROT_NONE, MAP_PRIVATE | MAP_ANON,
1314
                                -1, 0);
1315
            if (error == -1) {
1316
                perror("mmap");
1317
                exit(-1);
1318
            }
1319
            load_bias = TARGET_ELF_PAGESTART(error - elf_ppnt->p_vaddr);
1320
        }
1321

    
1322
        error = target_mmap(TARGET_ELF_PAGESTART(load_bias + elf_ppnt->p_vaddr),
1323
                            (elf_ppnt->p_filesz +
1324
                             TARGET_ELF_PAGEOFFSET(elf_ppnt->p_vaddr)),
1325
                            elf_prot,
1326
                            (MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE),
1327
                            bprm->fd,
1328
                            (elf_ppnt->p_offset -
1329
                             TARGET_ELF_PAGEOFFSET(elf_ppnt->p_vaddr)));
1330
        if (error == -1) {
1331
            perror("mmap");
1332
            exit(-1);
1333
        }
1334

    
1335
#ifdef LOW_ELF_STACK
1336
        if (TARGET_ELF_PAGESTART(elf_ppnt->p_vaddr) < elf_stack)
1337
            elf_stack = TARGET_ELF_PAGESTART(elf_ppnt->p_vaddr);
1338
#endif
1339

    
1340
        if (!load_addr_set) {
1341
            load_addr_set = 1;
1342
            load_addr = elf_ppnt->p_vaddr - elf_ppnt->p_offset;
1343
            if (elf_ex.e_type == ET_DYN) {
1344
                load_bias += error -
1345
                    TARGET_ELF_PAGESTART(load_bias + elf_ppnt->p_vaddr);
1346
                load_addr += load_bias;
1347
                reloc_func_desc = load_bias;
1348
            }
1349
        }
1350
        k = elf_ppnt->p_vaddr;
1351
        if (k < start_code)
1352
            start_code = k;
1353
        if (start_data < k)
1354
            start_data = k;
1355
        k = elf_ppnt->p_vaddr + elf_ppnt->p_filesz;
1356
        if (k > elf_bss)
1357
            elf_bss = k;
1358
        if ((elf_ppnt->p_flags & PF_X) && end_code <  k)
1359
            end_code = k;
1360
        if (end_data < k)
1361
            end_data = k;
1362
        k = elf_ppnt->p_vaddr + elf_ppnt->p_memsz;
1363
        if (k > elf_brk) elf_brk = k;
1364
    }
1365

    
1366
    elf_entry += load_bias;
1367
    elf_bss += load_bias;
1368
    elf_brk += load_bias;
1369
    start_code += load_bias;
1370
    end_code += load_bias;
1371
    start_data += load_bias;
1372
    end_data += load_bias;
1373

    
1374
    if (elf_interpreter) {
1375
        if (interpreter_type & 1) {
1376
            elf_entry = load_aout_interp(&interp_ex, interpreter_fd);
1377
        }
1378
        else if (interpreter_type & 2) {
1379
            elf_entry = load_elf_interp(&interp_elf_ex, interpreter_fd,
1380
                                            &interp_load_addr);
1381
        }
1382
        reloc_func_desc = interp_load_addr;
1383

    
1384
        close(interpreter_fd);
1385
        free(elf_interpreter);
1386

    
1387
        if (elf_entry == ~((abi_ulong)0UL)) {
1388
            printf("Unable to load interpreter\n");
1389
            free(elf_phdata);
1390
            exit(-1);
1391
            return 0;
1392
        }
1393
    }
1394

    
1395
    free(elf_phdata);
1396

    
1397
    if (loglevel)
1398
        load_symbols(&elf_ex, bprm->fd);
1399

    
1400
    if (interpreter_type != INTERPRETER_AOUT) close(bprm->fd);
1401
    info->personality = (ibcs2_interpreter ? PER_SVR4 : PER_LINUX);
1402

    
1403
#ifdef LOW_ELF_STACK
1404
    info->start_stack = bprm->p = elf_stack - 4;
1405
#endif
1406
    bprm->p = create_elf_tables(bprm->p,
1407
                    bprm->argc,
1408
                    bprm->envc,
1409
                    &elf_ex,
1410
                    load_addr, load_bias,
1411
                    interp_load_addr,
1412
                    (interpreter_type == INTERPRETER_AOUT ? 0 : 1),
1413
                    info);
1414
    info->load_addr = reloc_func_desc;
1415
    info->start_brk = info->brk = elf_brk;
1416
    info->end_code = end_code;
1417
    info->start_code = start_code;
1418
    info->start_data = start_data;
1419
    info->end_data = end_data;
1420
    info->start_stack = bprm->p;
1421

    
1422
    /* Calling set_brk effectively mmaps the pages that we need for the bss and break
1423
       sections */
1424
    set_brk(elf_bss, elf_brk);
1425

    
1426
    padzero(elf_bss, elf_brk);
1427

    
1428
#if 0
1429
    printf("(start_brk) %x\n" , info->start_brk);
1430
    printf("(end_code) %x\n" , info->end_code);
1431
    printf("(start_code) %x\n" , info->start_code);
1432
    printf("(end_data) %x\n" , info->end_data);
1433
    printf("(start_stack) %x\n" , info->start_stack);
1434
    printf("(brk) %x\n" , info->brk);
1435
#endif
1436

    
1437
    if ( info->personality == PER_SVR4 )
1438
    {
1439
            /* Why this, you ask???  Well SVr4 maps page 0 as read-only,
1440
               and some applications "depend" upon this behavior.
1441
               Since we do not have the power to recompile these, we
1442
               emulate the SVr4 behavior.  Sigh.  */
1443
            mapped_addr = target_mmap(0, qemu_host_page_size, PROT_READ | PROT_EXEC,
1444
                                      MAP_FIXED | MAP_PRIVATE, -1, 0);
1445
    }
1446

    
1447
    info->entry = elf_entry;
1448

    
1449
    return 0;
1450
}
1451

    
1452
static int load_aout_interp(void * exptr, int interp_fd)
1453
{
1454
    printf("a.out interpreter not yet supported\n");
1455
    return(0);
1456
}
1457

    
1458
void do_init_thread(struct target_pt_regs *regs, struct image_info *infop)
1459
{
1460
    init_thread(regs, infop);
1461
}