![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to main.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / darwin-user|
Return to main.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / darwin-user |
1.1 root 1: /*
2: * qemu user main
3: *
4: * Copyright (c) 2003 Fabrice Bellard
5: * Copyright (c) 2006 Pierre d'Herbemont
6: *
7: * This program is free software; you can redistribute it and/or modify
8: * it under the terms of the GNU General Public License as published by
9: * the Free Software Foundation; either version 2 of the License, or
10: * (at your option) any later version.
11: *
12: * This program is distributed in the hope that it will be useful,
13: * but WITHOUT ANY WARRANTY; without even the implied warranty of
14: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15: * GNU General Public License for more details.
16: *
17: * You should have received a copy of the GNU General Public License
18: * along with this program; if not, write to the Free Software
19: * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20: */
21: #include <stdlib.h>
22: #include <stdio.h>
23: #include <stdarg.h>
24: #include <string.h>
25: #include <errno.h>
26: #include <unistd.h>
27:
28: #include <sys/syscall.h>
29: #include <sys/mman.h>
30:
31: #include "qemu.h"
32:
33: #define DEBUG_LOGFILE "/tmp/qemu.log"
34:
35: #ifdef __APPLE__
36: #include <crt_externs.h>
37: # define environ (*_NSGetEnviron())
38: #endif
39:
40: #include <mach/mach_init.h>
41: #include <mach/vm_map.h>
42:
43: const char *interp_prefix = "";
44:
45: asm(".zerofill __STD_PROG_ZONE, __STD_PROG_ZONE, __std_prog_zone, 0x0dfff000");
46:
47: /* XXX: on x86 MAP_GROWSDOWN only works if ESP <= address + 32, so
48: we allocate a bigger stack. Need a better solution, for example
49: by remapping the process stack directly at the right place */
50: unsigned long stack_size = 512 * 1024;
51:
52: void qerror(const char *fmt, ...)
53: {
54: va_list ap;
55:
56: va_start(ap, fmt);
57: vfprintf(stderr, fmt, ap);
58: va_end(ap);
59: fprintf(stderr, "\n");
60: exit(1);
61: }
62:
63: void gemu_log(const char *fmt, ...)
64: {
65: va_list ap;
66:
67: va_start(ap, fmt);
68: vfprintf(stderr, fmt, ap);
69: va_end(ap);
70: }
71:
72: void cpu_outb(CPUState *env, int addr, int val)
73: {
74: fprintf(stderr, "outb: port=0x%04x, data=%02x\n", addr, val);
75: }
76:
77: void cpu_outw(CPUState *env, int addr, int val)
78: {
79: fprintf(stderr, "outw: port=0x%04x, data=%04x\n", addr, val);
80: }
81:
82: void cpu_outl(CPUState *env, int addr, int val)
83: {
84: fprintf(stderr, "outl: port=0x%04x, data=%08x\n", addr, val);
85: }
86:
87: int cpu_inb(CPUState *env, int addr)
88: {
89: fprintf(stderr, "inb: port=0x%04x\n", addr);
90: return 0;
91: }
92:
93: int cpu_inw(CPUState *env, int addr)
94: {
95: fprintf(stderr, "inw: port=0x%04x\n", addr);
96: return 0;
97: }
98:
99: int cpu_inl(CPUState *env, int addr)
100: {
101: fprintf(stderr, "inl: port=0x%04x\n", addr);
102: return 0;
103: }
104:
105: int cpu_get_pic_interrupt(CPUState *env)
106: {
107: return -1;
108: }
109: #ifdef TARGET_PPC
110:
111: static inline uint64_t cpu_ppc_get_tb (CPUState *env)
112: {
113: /* TO FIX */
114: return 0;
115: }
116:
117: uint32_t cpu_ppc_load_tbl (CPUState *env)
118: {
119: return cpu_ppc_get_tb(env) & 0xFFFFFFFF;
120: }
121:
122: uint32_t cpu_ppc_load_tbu (CPUState *env)
123: {
124: return cpu_ppc_get_tb(env) >> 32;
125: }
126:
127: static void cpu_ppc_store_tb (CPUState *env, uint64_t value)
128: {
129: /* TO FIX */
130: }
131:
132: void cpu_ppc_store_tbu (CPUState *env, uint32_t value)
133: {
134: cpu_ppc_store_tb(env, ((uint64_t)value << 32) | cpu_ppc_load_tbl(env));
135: }
136:
137: void cpu_ppc_store_tbl (CPUState *env, uint32_t value)
138: {
139: cpu_ppc_store_tb(env, ((uint64_t)cpu_ppc_load_tbl(env) << 32) | value);
140: }
141:
142: uint32_t cpu_ppc_load_decr (CPUState *env)
143: {
144: /* TO FIX */
145: return -1;
146: }
147:
148: void cpu_ppc_store_decr (CPUState *env, uint32_t value)
149: {
150: /* TO FIX */
151: }
152:
153: void cpu_loop(CPUPPCState *env)
154: {
155: int trapnr;
156: uint32_t ret;
157: target_siginfo_t info;
158:
159: for(;;) {
160: trapnr = cpu_ppc_exec(env);
161: if (trapnr != EXCP_SYSCALL_USER && trapnr != EXCP_BRANCH &&
162: trapnr != EXCP_TRACE) {
163: if (loglevel > 0) {
164: cpu_dump_state(env, logfile, fprintf, 0);
165: }
166: }
167: switch(trapnr) {
168: case EXCP_NONE:
169: break;
170: case EXCP_SYSCALL_USER:
171: /* system call */
172: if(((int)env->gpr[0]) <= SYS_MAXSYSCALL && ((int)env->gpr[0])>0)
173: ret = do_unix_syscall(env, env->gpr[0]/*, env->gpr[3], env->gpr[4],
174: env->gpr[5], env->gpr[6], env->gpr[7],
175: env->gpr[8], env->gpr[9], env->gpr[10]*/);
176: else if(((int)env->gpr[0])<0)
177: ret = do_mach_syscall(env, env->gpr[0], env->gpr[3], env->gpr[4],
178: env->gpr[5], env->gpr[6], env->gpr[7],
179: env->gpr[8], env->gpr[9], env->gpr[10]);
180: else
181: ret = do_thread_syscall(env, env->gpr[0], env->gpr[3], env->gpr[4],
182: env->gpr[5], env->gpr[6], env->gpr[7],
183: env->gpr[8], env->gpr[9], env->gpr[10]);
184:
185: /* Unix syscall error signaling */
186: if(((int)env->gpr[0]) <= SYS_MAXSYSCALL && ((int)env->gpr[0])>0)
187: {
188: if( (int)ret < 0 )
189: env->nip += 0;
190: else
191: env->nip += 4;
192: }
193:
194: /* Return value */
195: env->gpr[3] = ret;
196: break;
197: case EXCP_RESET:
198: /* Should not happen ! */
199: fprintf(stderr, "RESET asked... Stop emulation\n");
200: if (loglevel)
201: fprintf(logfile, "RESET asked... Stop emulation\n");
202: abort();
203: case EXCP_MACHINE_CHECK:
204: fprintf(stderr, "Machine check exeption... Stop emulation\n");
205: if (loglevel)
206: fprintf(logfile, "RESET asked... Stop emulation\n");
207: info.si_signo = SIGBUS;
208: info.si_errno = 0;
209: info.si_code = BUS_OBJERR;
210: info.si_addr = (void*)(env->nip - 4);
211: queue_signal(info.si_signo, &info);
212: case EXCP_DSI:
213: #ifndef DAR
214: /* To deal with multiple qemu header version as host for the darwin-user code */
215: # define DAR SPR_DAR
216: #endif
217: fprintf(stderr, "Invalid data memory access: 0x%08x\n", env->spr[DAR]);
218: if (loglevel) {
219: fprintf(logfile, "Invalid data memory access: 0x%08x\n",
220: env->spr[DAR]);
221: }
222: /* Handle this via the gdb */
223: gdb_handlesig (env, SIGSEGV);
224:
225: info.si_addr = (void*)env->nip;
226: queue_signal(info.si_signo, &info);
227: break;
228: case EXCP_ISI:
229: fprintf(stderr, "Invalid instruction fetch\n");
230: if (loglevel)
231: fprintf(logfile, "Invalid instruction fetch\n");
232: /* Handle this via the gdb */
233: gdb_handlesig (env, SIGSEGV);
234:
235: info.si_addr = (void*)(env->nip - 4);
236: queue_signal(info.si_signo, &info);
237: break;
238: case EXCP_EXTERNAL:
239: /* Should not happen ! */
240: fprintf(stderr, "External interruption... Stop emulation\n");
241: if (loglevel)
242: fprintf(logfile, "External interruption... Stop emulation\n");
243: abort();
244: case EXCP_ALIGN:
245: fprintf(stderr, "Invalid unaligned memory access\n");
246: if (loglevel)
247: fprintf(logfile, "Invalid unaligned memory access\n");
248: info.si_signo = SIGBUS;
249: info.si_errno = 0;
250: info.si_code = BUS_ADRALN;
251: info.si_addr = (void*)(env->nip - 4);
252: queue_signal(info.si_signo, &info);
253: break;
254: case EXCP_PROGRAM:
255: switch (env->error_code & ~0xF) {
256: case EXCP_FP:
257: fprintf(stderr, "Program exception\n");
258: if (loglevel)
259: fprintf(logfile, "Program exception\n");
260: /* Set FX */
261: env->fpscr[7] |= 0x8;
262: /* Finally, update FEX */
263: if ((((env->fpscr[7] & 0x3) << 3) | (env->fpscr[6] >> 1)) &
264: ((env->fpscr[1] << 1) | (env->fpscr[0] >> 3)))
265: env->fpscr[7] |= 0x4;
266: info.si_signo = SIGFPE;
267: info.si_errno = 0;
268: switch (env->error_code & 0xF) {
269: case EXCP_FP_OX:
270: info.si_code = FPE_FLTOVF;
271: break;
272: case EXCP_FP_UX:
273: info.si_code = FPE_FLTUND;
274: break;
275: case EXCP_FP_ZX:
276: case EXCP_FP_VXZDZ:
277: info.si_code = FPE_FLTDIV;
278: break;
279: case EXCP_FP_XX:
280: info.si_code = FPE_FLTRES;
281: break;
282: case EXCP_FP_VXSOFT:
283: info.si_code = FPE_FLTINV;
284: break;
285: case EXCP_FP_VXNAN:
286: case EXCP_FP_VXISI:
287: case EXCP_FP_VXIDI:
288: case EXCP_FP_VXIMZ:
289: case EXCP_FP_VXVC:
290: case EXCP_FP_VXSQRT:
291: case EXCP_FP_VXCVI:
292: info.si_code = FPE_FLTSUB;
293: break;
294: default:
295: fprintf(stderr, "Unknown floating point exception "
296: "(%02x)\n", env->error_code);
297: if (loglevel) {
298: fprintf(logfile, "Unknown floating point exception "
299: "(%02x)\n", env->error_code & 0xF);
300: }
301: }
302: break;
303: case EXCP_INVAL:
304: fprintf(stderr, "Invalid instruction\n");
305: if (loglevel)
306: fprintf(logfile, "Invalid instruction\n");
307: info.si_signo = SIGILL;
308: info.si_errno = 0;
309: switch (env->error_code & 0xF) {
310: case EXCP_INVAL_INVAL:
311: info.si_code = ILL_ILLOPC;
312: break;
313: case EXCP_INVAL_LSWX:
314: info.si_code = ILL_ILLOPN;
315: break;
316: case EXCP_INVAL_SPR:
317: info.si_code = ILL_PRVREG;
318: break;
319: case EXCP_INVAL_FP:
320: info.si_code = ILL_COPROC;
321: break;
322: default:
323: fprintf(stderr, "Unknown invalid operation (%02x)\n",
324: env->error_code & 0xF);
325: if (loglevel) {
326: fprintf(logfile, "Unknown invalid operation (%02x)\n",
327: env->error_code & 0xF);
328: }
329: info.si_code = ILL_ILLADR;
330: break;
331: }
332: /* Handle this via the gdb */
333: gdb_handlesig (env, SIGSEGV);
334: break;
335: case EXCP_PRIV:
336: fprintf(stderr, "Privilege violation\n");
337: if (loglevel)
338: fprintf(logfile, "Privilege violation\n");
339: info.si_signo = SIGILL;
340: info.si_errno = 0;
341: switch (env->error_code & 0xF) {
342: case EXCP_PRIV_OPC:
343: info.si_code = ILL_PRVOPC;
344: break;
345: case EXCP_PRIV_REG:
346: info.si_code = ILL_PRVREG;
347: break;
348: default:
349: fprintf(stderr, "Unknown privilege violation (%02x)\n",
350: env->error_code & 0xF);
351: info.si_code = ILL_PRVOPC;
352: break;
353: }
354: break;
355: case EXCP_TRAP:
356: fprintf(stderr, "Tried to call a TRAP\n");
357: if (loglevel)
358: fprintf(logfile, "Tried to call a TRAP\n");
359: abort();
360: default:
361: /* Should not happen ! */
362: fprintf(stderr, "Unknown program exception (%02x)\n",
363: env->error_code);
364: if (loglevel) {
365: fprintf(logfile, "Unknwon program exception (%02x)\n",
366: env->error_code);
367: }
368: abort();
369: }
370: info.si_addr = (void*)(env->nip - 4);
371: queue_signal(info.si_signo, &info);
372: break;
373: case EXCP_NO_FP:
374: fprintf(stderr, "No floating point allowed\n");
375: if (loglevel)
376: fprintf(logfile, "No floating point allowed\n");
377: info.si_signo = SIGILL;
378: info.si_errno = 0;
379: info.si_code = ILL_COPROC;
380: info.si_addr = (void*)(env->nip - 4);
381: queue_signal(info.si_signo, &info);
382: break;
383: case EXCP_DECR:
384: /* Should not happen ! */
385: fprintf(stderr, "Decrementer exception\n");
386: if (loglevel)
387: fprintf(logfile, "Decrementer exception\n");
388: abort();
389: case EXCP_TRACE:
390: /* Pass to gdb: we use this to trace execution */
391: gdb_handlesig (env, SIGTRAP);
392: break;
393: case EXCP_FP_ASSIST:
394: /* Should not happen ! */
395: fprintf(stderr, "Floating point assist exception\n");
396: if (loglevel)
397: fprintf(logfile, "Floating point assist exception\n");
398: abort();
399: case EXCP_MTMSR:
400: /* We reloaded the msr, just go on */
401: if (msr_pr == 0) {
402: fprintf(stderr, "Tried to go into supervisor mode !\n");
403: if (loglevel)
404: fprintf(logfile, "Tried to go into supervisor mode !\n");
405: abort();
406: }
407: break;
408: case EXCP_BRANCH:
409: /* We stopped because of a jump... */
410: break;
411: case EXCP_INTERRUPT:
412: /* Don't know why this should ever happen... */
413: fprintf(stderr, "EXCP_INTERRUPT\n");
414: break;
415: case EXCP_DEBUG:
416: gdb_handlesig (env, SIGTRAP);
417: break;
418: default:
419: fprintf(stderr, "qemu: unhandled CPU exception 0x%x - aborting\n",
420: trapnr);
421: if (loglevel) {
422: fprintf(logfile, "qemu: unhandled CPU exception 0x%02x - "
423: "0x%02x - aborting\n", trapnr, env->error_code);
424: }
425: abort();
426: }
427: process_pending_signals(env);
428: }
429: }
430: #endif
431:
432:
433: #ifdef TARGET_I386
434:
435: /***********************************************************/
436: /* CPUX86 core interface */
437:
438: uint64_t cpu_get_tsc(CPUX86State *env)
439: {
440: return cpu_get_real_ticks();
441: }
442:
443: void
444: write_dt(void *ptr, unsigned long addr, unsigned long limit,
445: int flags)
446: {
447: unsigned int e1, e2;
448: e1 = (addr << 16) | (limit & 0xffff);
449: e2 = ((addr >> 16) & 0xff) | (addr & 0xff000000) | (limit & 0x000f0000);
450: e2 |= flags;
451: stl((uint8_t *)ptr, e1);
452: stl((uint8_t *)ptr + 4, e2);
453: }
454:
455: static void set_gate(void *ptr, unsigned int type, unsigned int dpl,
456: unsigned long addr, unsigned int sel)
457: {
458: unsigned int e1, e2;
459: e1 = (addr & 0xffff) | (sel << 16);
460: e2 = (addr & 0xffff0000) | 0x8000 | (dpl << 13) | (type << 8);
461: stl((uint8_t *)ptr, e1);
462: stl((uint8_t *)ptr + 4, e2);
463: }
464:
465: #define GDT_TABLE_SIZE 14
466: #define LDT_TABLE_SIZE 15
467: #define IDT_TABLE_SIZE 256
468: #define TSS_SIZE 104
469: uint64_t gdt_table[GDT_TABLE_SIZE];
470: uint64_t ldt_table[LDT_TABLE_SIZE];
471: uint64_t idt_table[IDT_TABLE_SIZE];
472: uint32_t tss[TSS_SIZE];
473:
474: /* only dpl matters as we do only user space emulation */
475: static void set_idt(int n, unsigned int dpl)
476: {
477: set_gate(idt_table + n, 0, dpl, 0, 0);
478: }
479:
480: /* ABI convention: after a syscall if there was an error the CF flag is set */
481: static inline void set_error(CPUX86State *env, int ret)
482: {
483: if(ret<0)
484: env->eflags = env->eflags | 0x1;
485: else
486: env->eflags &= ~0x1;
487: env->regs[R_EAX] = ret;
488: }
489:
490: void cpu_loop(CPUX86State *env)
491: {
492: int trapnr;
493: int ret;
494: uint8_t *pc;
495: target_siginfo_t info;
496:
497: for(;;) {
498: trapnr = cpu_x86_exec(env);
499: uint32_t *params = (uint32_t *)env->regs[R_ESP];
500: switch(trapnr) {
501: case 0x79: /* Our commpage hack back door exit is here */
502: do_commpage(env, env->eip, *(params + 1), *(params + 2),
503: *(params + 3), *(params + 4),
504: *(params + 5), *(params + 6),
505: *(params + 7), *(params + 8));
506: break;
507: case 0x81: /* mach syscall */
508: {
509: ret = do_mach_syscall(env, env->regs[R_EAX],
510: *(params + 1), *(params + 2),
511: *(params + 3), *(params + 4),
512: *(params + 5), *(params + 6),
513: *(params + 7), *(params + 8));
514: set_error(env, ret);
515: break;
516: }
517: case 0x90: /* unix backdoor */
518: {
519: /* after sysenter, stack is in R_ECX, new eip in R_EDX (sysexit will flip them back)*/
520: int saved_stack = env->regs[R_ESP];
521: env->regs[R_ESP] = env->regs[R_ECX];
522:
523: ret = do_unix_syscall(env, env->regs[R_EAX]);
524:
525: env->regs[R_ECX] = env->regs[R_ESP];
526: env->regs[R_ESP] = saved_stack;
527:
528: set_error(env, ret);
529: break;
530: }
531: case 0x80: /* unix syscall */
532: {
533: ret = do_unix_syscall(env, env->regs[R_EAX]/*,
534: *(params + 1), *(params + 2),
535: *(params + 3), *(params + 4),
536: *(params + 5), *(params + 6),
537: *(params + 7), *(params + 8)*/);
538: set_error(env, ret);
539: break;
540: }
541: case 0x82: /* thread syscall */
542: {
543: ret = do_thread_syscall(env, env->regs[R_EAX],
544: *(params + 1), *(params + 2),
545: *(params + 3), *(params + 4),
546: *(params + 5), *(params + 6),
547: *(params + 7), *(params + 8));
548: set_error(env, ret);
549: break;
550: }
551: case EXCP0B_NOSEG:
552: case EXCP0C_STACK:
553: info.si_signo = SIGBUS;
554: info.si_errno = 0;
555: info.si_code = BUS_NOOP;
556: info.si_addr = 0;
557: gdb_handlesig (env, SIGBUS);
558: queue_signal(info.si_signo, &info);
559: break;
560: case EXCP0D_GPF:
561: info.si_signo = SIGSEGV;
562: info.si_errno = 0;
563: info.si_code = SEGV_NOOP;
564: info.si_addr = 0;
565: gdb_handlesig (env, SIGSEGV);
566: queue_signal(info.si_signo, &info);
567: break;
568: case EXCP0E_PAGE:
569: info.si_signo = SIGSEGV;
570: info.si_errno = 0;
571: if (!(env->error_code & 1))
572: info.si_code = SEGV_MAPERR;
573: else
574: info.si_code = SEGV_ACCERR;
575: info.si_addr = (void*)env->cr[2];
576: gdb_handlesig (env, SIGSEGV);
577: queue_signal(info.si_signo, &info);
578: break;
579: case EXCP00_DIVZ:
580: /* division by zero */
581: info.si_signo = SIGFPE;
582: info.si_errno = 0;
583: info.si_code = FPE_INTDIV;
584: info.si_addr = (void*)env->eip;
585: gdb_handlesig (env, SIGFPE);
586: queue_signal(info.si_signo, &info);
587: break;
588: case EXCP01_SSTP:
589: case EXCP03_INT3:
590: info.si_signo = SIGTRAP;
591: info.si_errno = 0;
592: info.si_code = TRAP_BRKPT;
593: info.si_addr = (void*)env->eip;
594: gdb_handlesig (env, SIGTRAP);
595: queue_signal(info.si_signo, &info);
596: break;
597: case EXCP04_INTO:
598: case EXCP05_BOUND:
599: info.si_signo = SIGSEGV;
600: info.si_errno = 0;
601: info.si_code = SEGV_NOOP;
602: info.si_addr = 0;
603: gdb_handlesig (env, SIGSEGV);
604: queue_signal(info.si_signo, &info);
605: break;
606: case EXCP06_ILLOP:
607: info.si_signo = SIGILL;
608: info.si_errno = 0;
609: info.si_code = ILL_ILLOPN;
610: info.si_addr = (void*)env->eip;
611: gdb_handlesig (env, SIGILL);
612: queue_signal(info.si_signo, &info);
613: break;
614: case EXCP_INTERRUPT:
615: /* just indicate that signals should be handled asap */
616: break;
617: case EXCP_DEBUG:
618: {
619: int sig;
620:
621: sig = gdb_handlesig (env, SIGTRAP);
622: if (sig)
623: {
624: info.si_signo = sig;
625: info.si_errno = 0;
626: info.si_code = TRAP_BRKPT;
627: queue_signal(info.si_signo, &info);
628: }
629: }
630: break;
631: default:
632: pc = (void*)(env->segs[R_CS].base + env->eip);
633: fprintf(stderr, "qemu: 0x%08lx: unhandled CPU exception 0x%x - aborting\n",
634: (long)pc, trapnr);
635: abort();
636: }
637: process_pending_signals(env);
638: }
639: }
640: #endif
641:
642: void usage(void)
643: {
644: printf("qemu-" TARGET_ARCH " version " QEMU_VERSION ", Copyright (c) 2003-2004 Fabrice Bellard\n"
645: "usage: qemu-" TARGET_ARCH " [-h] [-d opts] [-L path] [-s size] program [arguments...]\n"
646: "Darwin CPU emulator (compiled for %s emulation)\n"
647: "\n"
648: "-h print this help\n"
649: "-L path set the %s library path (default='%s')\n"
650: "-s size set the stack size in bytes (default=%ld)\n"
651: "\n"
652: "debug options:\n"
653: #ifdef USE_CODE_COPY
654: "-no-code-copy disable code copy acceleration\n"
655: #endif
656: "-d options activate log (logfile='%s')\n"
657: "-g wait for gdb on port 1234\n"
658: "-p pagesize set the host page size to 'pagesize'\n",
659: TARGET_ARCH,
660: TARGET_ARCH,
661: interp_prefix,
662: stack_size,
663: DEBUG_LOGFILE);
664: _exit(1);
665: }
666:
667: /* XXX: currently only used for async signals (see signal.c) */
668: CPUState *global_env;
669: /* used only if single thread */
670: CPUState *cpu_single_env = NULL;
671:
672: /* used to free thread contexts */
673: TaskState *first_task_state;
674:
675: int main(int argc, char **argv)
676: {
677: const char *filename;
678: struct target_pt_regs regs1, *regs = ®s1;
679: TaskState ts1, *ts = &ts1;
680: CPUState *env;
681: int optind;
682: short use_gdbstub = 0;
683: const char *r;
684:
685: if (argc <= 1)
686: usage();
687:
688: /* init debug */
689: cpu_set_log_filename(DEBUG_LOGFILE);
690:
691: optind = 1;
692: for(;;) {
693: if (optind >= argc)
694: break;
695: r = argv[optind];
696: if (r[0] != '-')
697: break;
698: optind++;
699: r++;
700: if (!strcmp(r, "-")) {
701: break;
702: } else if (!strcmp(r, "d")) {
703: int mask;
704: CPULogItem *item;
705:
706: if (optind >= argc)
707: break;
708:
709: r = argv[optind++];
710: mask = cpu_str_to_log_mask(r);
711: if (!mask) {
712: printf("Log items (comma separated):\n");
713: for(item = cpu_log_items; item->mask != 0; item++) {
714: printf("%-10s %s\n", item->name, item->help);
715: }
716: exit(1);
717: }
718: cpu_set_log(mask);
719: } else if (!strcmp(r, "s")) {
720: r = argv[optind++];
721: stack_size = strtol(r, (char **)&r, 0);
722: if (stack_size <= 0)
723: usage();
724: if (*r == 'M')
725: stack_size *= 1024 * 1024;
726: else if (*r == 'k' || *r == 'K')
727: stack_size *= 1024;
728: } else if (!strcmp(r, "L")) {
729: interp_prefix = argv[optind++];
730: } else if (!strcmp(r, "p")) {
731: qemu_host_page_size = atoi(argv[optind++]);
732: if (qemu_host_page_size == 0 ||
733: (qemu_host_page_size & (qemu_host_page_size - 1)) != 0) {
734: fprintf(stderr, "page size must be a power of two\n");
735: exit(1);
736: }
737: } else
738: if (!strcmp(r, "g")) {
739: use_gdbstub = 1;
740: } else
741: #ifdef USE_CODE_COPY
742: if (!strcmp(r, "no-code-copy")) {
743: code_copy_enabled = 0;
744: } else
745: #endif
746: {
747: usage();
748: }
749: }
750: if (optind >= argc)
751: usage();
752: filename = argv[optind];
753:
754: /* Zero out regs */
755: memset(regs, 0, sizeof(struct target_pt_regs));
756:
757: /* NOTE: we need to init the CPU at this stage to get
758: qemu_host_page_size */
759: env = cpu_init();
760:
761: printf("Starting %s with qemu\n----------------\n", filename);
762:
763: commpage_init();
764:
765: if (mach_exec(filename, argv+optind, environ, regs) != 0) {
766: printf("Error loading %s\n", filename);
767: _exit(1);
768: }
769:
770: syscall_init();
771: signal_init();
772: global_env = env;
773:
774: /* build Task State */
775: memset(ts, 0, sizeof(TaskState));
776: env->opaque = ts;
777: ts->used = 1;
778: env->user_mode_only = 1;
779:
780: #if defined(TARGET_I386)
781: cpu_x86_set_cpl(env, 3);
782:
783: env->cr[0] = CR0_PG_MASK | CR0_WP_MASK | CR0_PE_MASK;
784: env->hflags |= HF_PE_MASK;
785:
786: if (env->cpuid_features & CPUID_SSE) {
787: env->cr[4] |= CR4_OSFXSR_MASK;
788: env->hflags |= HF_OSFXSR_MASK;
789: }
790:
791: /* flags setup : we activate the IRQs by default as in user mode */
792: env->eflags |= IF_MASK;
793:
794: /* darwin register setup */
795: env->regs[R_EAX] = regs->eax;
796: env->regs[R_EBX] = regs->ebx;
797: env->regs[R_ECX] = regs->ecx;
798: env->regs[R_EDX] = regs->edx;
799: env->regs[R_ESI] = regs->esi;
800: env->regs[R_EDI] = regs->edi;
801: env->regs[R_EBP] = regs->ebp;
802: env->regs[R_ESP] = regs->esp;
803: env->eip = regs->eip;
804:
805: /* Darwin LDT setup */
806: /* 2 - User code segment
807: 3 - User data segment
808: 4 - User cthread */
809: bzero(ldt_table, LDT_TABLE_SIZE * sizeof(ldt_table[0]));
810: env->ldt.base = (uint32_t) ldt_table;
811: env->ldt.limit = sizeof(ldt_table) - 1;
812:
813: write_dt(ldt_table + 2, 0, 0xfffff,
814: DESC_G_MASK | DESC_B_MASK | DESC_P_MASK | DESC_S_MASK |
815: (3 << DESC_DPL_SHIFT) | (0xa << DESC_TYPE_SHIFT));
816: write_dt(ldt_table + 3, 0, 0xfffff,
817: DESC_G_MASK | DESC_B_MASK | DESC_P_MASK | DESC_S_MASK |
818: (3 << DESC_DPL_SHIFT) | (0x2 << DESC_TYPE_SHIFT));
819: write_dt(ldt_table + 4, 0, 0xfffff,
820: DESC_G_MASK | DESC_B_MASK | DESC_P_MASK | DESC_S_MASK |
821: (3 << DESC_DPL_SHIFT) | (0x2 << DESC_TYPE_SHIFT));
822:
823: /* Darwin GDT setup.
824: * has changed a lot between old Darwin/x86 (pre-Mac Intel) and Mac OS X/x86,
825: now everything is done via int 0x81(mach) int 0x82 (thread) and sysenter/sysexit(unix) */
826: bzero(gdt_table, sizeof(gdt_table));
827: env->gdt.base = (uint32_t)gdt_table;
828: env->gdt.limit = sizeof(gdt_table) - 1;
829:
830: /* Set up a back door to handle sysenter syscalls (unix) */
831: char * syscallbackdoor = malloc(64);
832: page_set_flags((int)syscallbackdoor, (int)syscallbackdoor + 64, PROT_EXEC | PROT_READ | PAGE_VALID);
833:
834: int i = 0;
835: syscallbackdoor[i++] = 0xcd;
836: syscallbackdoor[i++] = 0x90; /* int 0x90 */
837: syscallbackdoor[i++] = 0x0F;
838: syscallbackdoor[i++] = 0x35; /* sysexit */
839:
840: /* Darwin sysenter/sysexit setup */
841: env->sysenter_cs = 0x1; //XXX
842: env->sysenter_eip = (int)syscallbackdoor;
843: env->sysenter_esp = (int)malloc(64);
844:
845: /* Darwin TSS setup
846: This must match up with GDT[4] */
847: env->tr.base = (uint32_t) tss;
848: env->tr.limit = sizeof(tss) - 1;
849: env->tr.flags = DESC_P_MASK | (0x9 << DESC_TYPE_SHIFT);
850: stw(tss + 2, 0x10); // ss0 = 0x10 = GDT[2] = Kernel Data Segment
851:
852: /* Darwin interrupt setup */
853: bzero(idt_table, sizeof(idt_table));
854: env->idt.base = (uint32_t) idt_table;
855: env->idt.limit = sizeof(idt_table) - 1;
856: set_idt(0, 0);
857: set_idt(1, 0);
858: set_idt(2, 0);
859: set_idt(3, 3);
860: set_idt(4, 3);
861: set_idt(5, 3);
862: set_idt(6, 0);
863: set_idt(7, 0);
864: set_idt(8, 0);
865: set_idt(9, 0);
866: set_idt(10, 0);
867: set_idt(11, 0);
868: set_idt(12, 0);
869: set_idt(13, 0);
870: set_idt(14, 0);
871: set_idt(15, 0);
872: set_idt(16, 0);
873: set_idt(17, 0);
874: set_idt(18, 0);
875: set_idt(19, 0);
876: /* Syscalls are done via
877: int 0x80 (unix) (rarely used)
878: int 0x81 (mach)
879: int 0x82 (thread)
880: int 0x83 (diag) (not handled here)
881: sysenter/sysexit (unix) -> we redirect that to int 0x90 */
882: set_idt(0x79, 3); /* Commpage hack, here is our backdoor interrupt */
883: set_idt(0x80, 3); /* Unix Syscall */
884: set_idt(0x81, 3); /* Mach Syscalls */
885: set_idt(0x82, 3); /* thread Syscalls */
886:
887: set_idt(0x90, 3); /* qemu-darwin-user's Unix syscalls backdoor */
888:
889:
890: cpu_x86_load_seg(env, R_CS, __USER_CS);
891: cpu_x86_load_seg(env, R_DS, __USER_DS);
892: cpu_x86_load_seg(env, R_ES, __USER_DS);
893: cpu_x86_load_seg(env, R_SS, __USER_DS);
894: cpu_x86_load_seg(env, R_FS, __USER_DS);
895: cpu_x86_load_seg(env, R_GS, __USER_DS);
896:
897: #elif defined(TARGET_PPC)
898: {
899: int i;
900: env->nip = regs->nip;
901: for(i = 0; i < 32; i++) {
902: env->gpr[i] = regs->gpr[i];
903: }
904: }
905: #else
906: #error unsupported target CPU
907: #endif
908:
909: if (use_gdbstub) {
910: printf("Waiting for gdb Connection on port 1234...\n");
911: gdbserver_start (1234);
912: gdb_handlesig(env, 0);
913: }
914:
915: cpu_loop(env);
916: /* never exits */
917: return 0;
918: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.