ViewVC Help
View File | Revision Log | Show Annotations | Revision Graph | Root Listing
root/cebix/SheepShaver/src/Unix/main_unix.cpp
Revision: 1.102
Committed: 2012-01-01T23:18:36Z (12 years, 5 months ago) by asvitkine
Branch: MAIN
Changes since 1.101: +1 -15 lines
Log Message: 
remove some code that was accidentally committed

File Contents

# Content
1 /*
2 * main_unix.cpp - Emulation core, Unix implementation
3 *
4 * SheepShaver (C) Christian Bauer and Marc Hellwig
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 */
20
21 /*
22 * NOTES:
23 *
24 * See main_beos.cpp for a description of the three operating modes.
25 *
26 * In addition to that, we have to handle the fact that the MacOS ABI
27 * is slightly different from the SysV ABI used by Linux:
28 * - Stack frames are different (e.g. LR is stored in 8(r1) under
29 * MacOS, but in 4(r1) under Linux)
30 * - There is a pointer to Thread Local Storage (TLS) under Linux with
31 * recent enough glibc. This is r2 in 32-bit mode and r13 in
32 * 64-bit mode (PowerOpen/AIX ABI)
33 * - r13 is used as a small data pointer under Linux (but appearently
34 * it is not used this way? To be sure, we specify -msdata=none
35 * in the Makefile)
36 * - There are no TVECTs under Linux; function pointers point
37 * directly to the function code
38 * The Execute*() functions have to account for this. Additionally, we
39 * cannot simply call MacOS functions by getting their TVECT and jumping
40 * to it. Such calls are done via the call_macos*() functions in
41 * asm_linux.S that create a MacOS stack frame, load the TOC pointer
42 * and put the arguments into the right registers.
43 *
44 * As on the BeOS, we have to specify an alternate signal stack because
45 * interrupts (and, under Linux, Low Memory accesses) may occur when r1
46 * is pointing to the Kernel Data or to Low Memory. There is one
47 * problem, however, due to the alternate signal stack being global to
48 * all signal handlers. Consider the following scenario:
49 * - The main thread is executing some native PPC MacOS code in
50 * MODE_NATIVE, running on the MacOS stack (somewhere in the Mac RAM).
51 * - A SIGUSR2 interrupt occurs. The kernel switches to the signal
52 * stack and starts executing the SIGUSR2 signal handler.
53 * - The signal handler sees the MODE_NATIVE and calls ppc_interrupt()
54 * to handle a native interrupt.
55 * - ppc_interrupt() sets r1 to point to the Kernel Data and jumps to
56 * the nanokernel.
57 * - The nanokernel accesses a Low Memory global (most likely one of
58 * the XLMs), a SIGSEGV occurs.
59 * - The kernel sees that r1 does not point to the signal stack and
60 * switches to the signal stack again, thus overwriting the data that
61 * the SIGUSR2 handler put there.
62 * The same problem arises when calling ExecutePPC() inside the MODE_EMUL_OP
63 * interrupt handler.
64 *
65 * The solution is to set the signal stack to a second, "extra" stack
66 * inside the SIGUSR2 handler before entering the Nanokernel or calling
67 * ExecutePPC (or any function that might cause a mode switch). The signal
68 * stack is restored before exiting the SIGUSR2 handler.
69 *
70 * Note that POSIX standard says you can't modify the alternate
71 * signal stack while the process is executing on it. There is a
72 * hackaround though: we install a trampoline SIGUSR2 handler that
73 * sets up an alternate stack itself and calls the real handler.
74 * Then, when we call sigaltstack() there, we no longer get an EPERM,
75 * i.e. it now works.
76 *
77 * TODO:
78 * check if SIGSEGV handler works for all registers (including FP!)
79 */
80
81 #include <unistd.h>
82 #include <fcntl.h>
83 #include <time.h>
84 #include <errno.h>
85 #include <stdio.h>
86 #include <stdlib.h>
87 #include <string.h>
88 #include <pthread.h>
89 #include <sys/mman.h>
90 #include <sys/ipc.h>
91 #include <sys/shm.h>
92 #include <sys/stat.h>
93 #include <signal.h>
94
95 #include "sysdeps.h"
96 #include "main.h"
97 #include "version.h"
98 #include "prefs.h"
99 #include "prefs_editor.h"
100 #include "cpu_emulation.h"
101 #include "emul_op.h"
102 #include "xlowmem.h"
103 #include "xpram.h"
104 #include "timer.h"
105 #include "adb.h"
106 #include "video.h"
107 #include "sys.h"
108 #include "macos_util.h"
109 #include "rom_patches.h"
110 #include "user_strings.h"
111 #include "vm_alloc.h"
112 #include "sigsegv.h"
113 #include "sigregs.h"
114 #include "rpc.h"
115
116 #define DEBUG 0
117 #include "debug.h"
118
119
120 #ifdef HAVE_DIRENT_H
121 #include <dirent.h>
122 #endif
123
124 #ifdef USE_SDL
125 #include <SDL.h>
126 #endif
127
128 #ifndef USE_SDL_VIDEO
129 #include <X11/Xlib.h>
130 #endif
131
132 #ifdef ENABLE_GTK
133 #include <gtk/gtk.h>
134 #endif
135
136 #ifdef ENABLE_XF86_DGA
137 #include <X11/Xlib.h>
138 #include <X11/Xutil.h>
139 #include <X11/extensions/Xxf86dga.h>
140 #endif
141
142 #ifdef ENABLE_MON
143 #include "mon.h"
144 #endif
145
146
147 // Enable emulation of unaligned lmw/stmw?
148 #define EMULATE_UNALIGNED_LOADSTORE_MULTIPLE 1
149
150 // Enable Execute68k() safety checks?
151 #define SAFE_EXEC_68K 0
152
153 // Interrupts in EMUL_OP mode?
154 #define INTERRUPTS_IN_EMUL_OP_MODE 1
155
156 // Interrupts in native mode?
157 #define INTERRUPTS_IN_NATIVE_MODE 1
158
159
160 // Constants
161 const char ROM_FILE_NAME[] = "ROM";
162 const char ROM_FILE_NAME2[] = "Mac OS ROM";
163
164 #if !REAL_ADDRESSING
165 // FIXME: needs to be >= 0x04000000
166 const uintptr RAM_BASE = 0x10000000; // Base address of RAM
167 #endif
168 const uintptr ROM_BASE = 0x40800000; // Base address of ROM
169 #if REAL_ADDRESSING
170 const uint32 ROM_ALIGNMENT = 0x100000; // ROM must be aligned to a 1MB boundary
171 #endif
172 const uint32 SIG_STACK_SIZE = 0x10000; // Size of signal stack
173
174
175 // Global variables (exported)
176 #if !EMULATED_PPC
177 void *TOC = NULL; // Pointer to Thread Local Storage (r2)
178 void *R13 = NULL; // Pointer to .sdata section (r13 under Linux)
179 #endif
180 uint32 RAMBase; // Base address of Mac RAM
181 uint32 RAMSize; // Size of Mac RAM
182 uint32 ROMBase; // Base address of Mac ROM
183 uint32 KernelDataAddr; // Address of Kernel Data
184 uint32 BootGlobsAddr; // Address of BootGlobs structure at top of Mac RAM
185 uint32 DRCacheAddr; // Address of DR Cache
186 uint32 PVR; // Theoretical PVR
187 int64 CPUClockSpeed; // Processor clock speed (Hz)
188 int64 BusClockSpeed; // Bus clock speed (Hz)
189 int64 TimebaseSpeed; // Timebase clock speed (Hz)
190 uint8 *RAMBaseHost; // Base address of Mac RAM (host address space)
191 uint8 *ROMBaseHost; // Base address of Mac ROM (host address space)
192
193
194 // Global variables
195 #ifndef USE_SDL_VIDEO
196 char *x_display_name = NULL; // X11 display name
197 Display *x_display = NULL; // X11 display handle
198 #ifdef X11_LOCK_TYPE
199 X11_LOCK_TYPE x_display_lock = X11_LOCK_INIT; // X11 display lock
200 #endif
201 #endif
202
203 static int zero_fd = 0; // FD of /dev/zero
204 static bool lm_area_mapped = false; // Flag: Low Memory area mmap()ped
205 static int kernel_area = -1; // SHM ID of Kernel Data area
206 static bool rom_area_mapped = false; // Flag: Mac ROM mmap()ped
207 static bool ram_area_mapped = false; // Flag: Mac RAM mmap()ped
208 static bool dr_cache_area_mapped = false; // Flag: Mac DR Cache mmap()ped
209 static bool dr_emulator_area_mapped = false;// Flag: Mac DR Emulator mmap()ped
210 static KernelData *kernel_data; // Pointer to Kernel Data
211 static EmulatorData *emulator_data;
212
213 static uint8 last_xpram[XPRAM_SIZE]; // Buffer for monitoring XPRAM changes
214
215 static bool nvram_thread_active = false; // Flag: NVRAM watchdog installed
216 static volatile bool nvram_thread_cancel; // Flag: Cancel NVRAM thread
217 static pthread_t nvram_thread; // NVRAM watchdog
218 static bool tick_thread_active = false; // Flag: MacOS thread installed
219 static volatile bool tick_thread_cancel; // Flag: Cancel 60Hz thread
220 static pthread_t tick_thread; // 60Hz thread
221 static pthread_t emul_thread; // MacOS thread
222
223 static bool ready_for_signals = false; // Handler installed, signals can be sent
224 static int64 num_segv = 0; // Number of handled SEGV signals
225
226 static struct sigaction sigusr2_action; // Interrupt signal (of emulator thread)
227 #if EMULATED_PPC
228 static uintptr sig_stack = 0; // Stack for PowerPC interrupt routine
229 #else
230 static struct sigaction sigsegv_action; // Data access exception signal (of emulator thread)
231 static struct sigaction sigill_action; // Illegal instruction signal (of emulator thread)
232 static stack_t sig_stack; // Stack for signal handlers
233 static stack_t extra_stack; // Stack for SIGSEGV inside interrupt handler
234 static bool emul_thread_fatal = false; // Flag: MacOS thread crashed, tick thread shall dump debug output
235 static sigregs sigsegv_regs; // Register dump when crashed
236 static const char *crash_reason = NULL; // Reason of the crash (SIGSEGV, SIGBUS, SIGILL)
237 #endif
238
239 static rpc_connection_t *gui_connection = NULL; // RPC connection to the GUI
240 static const char *gui_connection_path = NULL; // GUI connection identifier
241
242 uint32 SheepMem::page_size; // Size of a native page
243 uintptr SheepMem::zero_page = 0; // Address of ro page filled in with zeros
244 uintptr SheepMem::base = 0x60000000; // Address of SheepShaver data
245 uintptr SheepMem::proc; // Bottom address of SheepShave procedures
246 uintptr SheepMem::data; // Top of SheepShaver data (stack like storage)
247
248
249 // Prototypes
250 static bool kernel_data_init(void);
251 static void kernel_data_exit(void);
252 static void Quit(void);
253 static void *emul_func(void *arg);
254 static void *nvram_func(void *arg);
255 static void *tick_func(void *arg);
256 #if EMULATED_PPC
257 extern void emul_ppc(uint32 start);
258 extern void init_emul_ppc(void);
259 extern void exit_emul_ppc(void);
260 sigsegv_return_t sigsegv_handler(sigsegv_info_t *sip);
261 #else
262 extern "C" void sigusr2_handler_init(int sig, siginfo_t *sip, void *scp);
263 extern "C" void sigusr2_handler(int sig, siginfo_t *sip, void *scp);
264 static void sigsegv_handler(int sig, siginfo_t *sip, void *scp);
265 static void sigill_handler(int sig, siginfo_t *sip, void *scp);
266 #endif
267
268
269 // From asm_linux.S
270 #if !EMULATED_PPC
271 extern "C" void *get_sp(void);
272 extern "C" void *get_r2(void);
273 extern "C" void set_r2(void *);
274 extern "C" void *get_r13(void);
275 extern "C" void set_r13(void *);
276 extern "C" void flush_icache_range(uint32 start, uint32 end);
277 extern "C" void jump_to_rom(uint32 entry, uint32 context);
278 extern "C" void quit_emulator(void);
279 extern "C" void execute_68k(uint32 pc, M68kRegisters *r);
280 extern "C" void ppc_interrupt(uint32 entry, uint32 kernel_data);
281 extern "C" int atomic_add(int *var, int v);
282 extern "C" int atomic_and(int *var, int v);
283 extern "C" int atomic_or(int *var, int v);
284 extern void paranoia_check(void);
285 #endif
286
287
288 #if EMULATED_PPC
289 /*
290 * Return signal stack base
291 */
292
293 uintptr SignalStackBase(void)
294 {
295 return sig_stack + SIG_STACK_SIZE;
296 }
297
298
299 /*
300 * Atomic operations
301 */
302
303 #if HAVE_SPINLOCKS
304 static spinlock_t atomic_ops_lock = SPIN_LOCK_UNLOCKED;
305 #else
306 #define spin_lock(LOCK)
307 #define spin_unlock(LOCK)
308 #endif
309
310 int atomic_add(int *var, int v)
311 {
312 spin_lock(&atomic_ops_lock);
313 int ret = *var;
314 *var += v;
315 spin_unlock(&atomic_ops_lock);
316 return ret;
317 }
318
319 int atomic_and(int *var, int v)
320 {
321 spin_lock(&atomic_ops_lock);
322 int ret = *var;
323 *var &= v;
324 spin_unlock(&atomic_ops_lock);
325 return ret;
326 }
327
328 int atomic_or(int *var, int v)
329 {
330 spin_lock(&atomic_ops_lock);
331 int ret = *var;
332 *var |= v;
333 spin_unlock(&atomic_ops_lock);
334 return ret;
335 }
336 #endif
337
338
339 /*
340 * Memory management helpers
341 */
342
343 static inline uint8 *vm_mac_acquire(uint32 size)
344 {
345 return (uint8 *)vm_acquire(size);
346 }
347
348 static inline int vm_mac_acquire_fixed(uint32 addr, uint32 size)
349 {
350 return vm_acquire_fixed(Mac2HostAddr(addr), size);
351 }
352
353 static inline int vm_mac_release(uint32 addr, uint32 size)
354 {
355 return vm_release(Mac2HostAddr(addr), size);
356 }
357
358
359 /*
360 * Main program
361 */
362
363 static void usage(const char *prg_name)
364 {
365 printf("Usage: %s [OPTION...]\n", prg_name);
366 printf("\nUnix options:\n");
367 printf(" --display STRING\n X display to use\n");
368 PrefsPrintUsage();
369 exit(0);
370 }
371
372 static bool valid_vmdir(const char *path)
373 {
374 const int suffix_len = sizeof(".sheepvm") - 1;
375 int len = strlen(path);
376 if (len && path[len - 1] == '/') // to support both ".sheepvm" and ".sheepvm/"
377 len--;
378 if (len > suffix_len && !strncmp(path + len - suffix_len, ".sheepvm", suffix_len)) {
379 struct stat d;
380 if (!stat(path, &d) && S_ISDIR(d.st_mode)) {
381 return true;
382 }
383 }
384 return false;
385 }
386
387 static void get_system_info(void)
388 {
389 #if !EMULATED_PPC
390 FILE *proc_file;
391 #endif
392
393 PVR = 0x00040000; // Default: 604
394 CPUClockSpeed = 100000000; // Default: 100MHz
395 BusClockSpeed = 100000000; // Default: 100MHz
396 TimebaseSpeed = 25000000; // Default: 25MHz
397
398 #if EMULATED_PPC
399 PVR = 0x000c0000; // Default: 7400 (with AltiVec)
400 #elif defined(__APPLE__) && defined(__MACH__)
401 proc_file = popen("ioreg -c IOPlatformDevice", "r");
402 if (proc_file) {
403 char line[256];
404 bool powerpc_node = false;
405 while (fgets(line, sizeof(line) - 1, proc_file)) {
406 // Read line
407 int len = strlen(line);
408 if (len == 0)
409 continue;
410 line[len - 1] = 0;
411
412 // Parse line
413 if (strstr(line, "o PowerPC,"))
414 powerpc_node = true;
415 else if (powerpc_node) {
416 uint32 value;
417 char head[256];
418 if (sscanf(line, "%[ |]\"cpu-version\" = <%x>", head, &value) == 2)
419 PVR = value;
420 else if (sscanf(line, "%[ |]\"clock-frequency\" = <%x>", head, &value) == 2)
421 CPUClockSpeed = value;
422 else if (sscanf(line, "%[ |]\"bus-frequency\" = <%x>", head, &value) == 2)
423 BusClockSpeed = value;
424 else if (sscanf(line, "%[ |]\"timebase-frequency\" = <%x>", head, &value) == 2)
425 TimebaseSpeed = value;
426 else if (strchr(line, '}'))
427 powerpc_node = false;
428 }
429 }
430 fclose(proc_file);
431 } else {
432 char str[256];
433 sprintf(str, GetString(STR_PROC_CPUINFO_WARN), strerror(errno));
434 WarningAlert(str);
435 }
436 #else
437 proc_file = fopen("/proc/cpuinfo", "r");
438 if (proc_file) {
439 // CPU specs from Linux kernel
440 // TODO: make it more generic with features (e.g. AltiVec) and
441 // cache information and friends for NameRegistry
442 static const struct {
443 uint32 pvr_mask;
444 uint32 pvr_value;
445 const char *cpu_name;
446 }
447 cpu_specs[] = {
448 { 0xffff0000, 0x00010000, "601" },
449 { 0xffff0000, 0x00030000, "603" },
450 { 0xffff0000, 0x00060000, "603e" },
451 { 0xffff0000, 0x00070000, "603ev" },
452 { 0xffff0000, 0x00040000, "604" },
453 { 0xfffff000, 0x00090000, "604e" },
454 { 0xffff0000, 0x00090000, "604r" },
455 { 0xffff0000, 0x000a0000, "604ev" },
456 { 0xffffffff, 0x00084202, "740/750" },
457 { 0xfffff000, 0x00083000, "745/755" },
458 { 0xfffffff0, 0x00080100, "750CX" },
459 { 0xfffffff0, 0x00082200, "750CX" },
460 { 0xfffffff0, 0x00082210, "750CXe" },
461 { 0xffffff00, 0x70000100, "750FX" },
462 { 0xffffffff, 0x70000200, "750FX" },
463 { 0xffff0000, 0x70000000, "750FX" },
464 { 0xffff0000, 0x70020000, "750GX" },
465 { 0xffff0000, 0x00080000, "740/750" },
466 { 0xffffffff, 0x000c1101, "7400 (1.1)" },
467 { 0xffff0000, 0x000c0000, "7400" },
468 { 0xffff0000, 0x800c0000, "7410" },
469 { 0xffffffff, 0x80000200, "7450" },
470 { 0xffffffff, 0x80000201, "7450" },
471 { 0xffff0000, 0x80000000, "7450" },
472 { 0xffffff00, 0x80010100, "7455" },
473 { 0xffffffff, 0x80010200, "7455" },
474 { 0xffff0000, 0x80010000, "7455" },
475 { 0xffff0000, 0x80020000, "7457" },
476 { 0xffff0000, 0x80030000, "7447A" },
477 { 0xffff0000, 0x80040000, "7448" },
478 { 0x7fff0000, 0x00810000, "82xx" },
479 { 0x7fff0000, 0x00820000, "8280" },
480 { 0xffff0000, 0x00400000, "Power3 (630)" },
481 { 0xffff0000, 0x00410000, "Power3 (630+)" },
482 { 0xffff0000, 0x00360000, "I-star" },
483 { 0xffff0000, 0x00370000, "S-star" },
484 { 0xffff0000, 0x00350000, "Power4" },
485 { 0xffff0000, 0x00390000, "PPC970" },
486 { 0xffff0000, 0x003c0000, "PPC970FX" },
487 { 0xffff0000, 0x00440000, "PPC970MP" },
488 { 0xffff0000, 0x003a0000, "POWER5 (gr)" },
489 { 0xffff0000, 0x003b0000, "POWER5+ (gs)" },
490 { 0xffff0000, 0x003e0000, "POWER6" },
491 { 0xffff0000, 0x00700000, "Cell Broadband Engine" },
492 { 0x7fff0000, 0x00900000, "PA6T" },
493 { 0, 0, 0 }
494 };
495
496 char line[256];
497 while(fgets(line, 255, proc_file)) {
498 // Read line
499 int len = strlen(line);
500 if (len == 0)
501 continue;
502 line[len-1] = 0;
503
504 // Parse line
505 int i;
506 float f;
507 char value[256];
508 if (sscanf(line, "cpu : %[^,]", value) == 1) {
509 // Search by name
510 const char *cpu_name = NULL;
511 for (int i = 0; cpu_specs[i].pvr_mask != 0; i++) {
512 if (strcmp(cpu_specs[i].cpu_name, value) == 0) {
513 cpu_name = cpu_specs[i].cpu_name;
514 PVR = cpu_specs[i].pvr_value;
515 break;
516 }
517 }
518 if (cpu_name == NULL)
519 printf("WARNING: Unknown CPU type '%s', assuming 604\n", value);
520 else
521 printf("Found a PowerPC %s processor\n", cpu_name);
522 }
523 if (sscanf(line, "clock : %fMHz", &f) == 1)
524 CPUClockSpeed = BusClockSpeed = ((int64)f) * 1000000;
525 else if (sscanf(line, "clock : %dMHz", &i) == 1)
526 CPUClockSpeed = BusClockSpeed = i * 1000000;
527 }
528 fclose(proc_file);
529 } else {
530 char str[256];
531 sprintf(str, GetString(STR_PROC_CPUINFO_WARN), strerror(errno));
532 WarningAlert(str);
533 }
534
535 // Get actual bus frequency
536 proc_file = fopen("/proc/device-tree/clock-frequency", "r");
537 if (proc_file) {
538 union { uint8 b[4]; uint32 l; } value;
539 if (fread(value.b, sizeof(value), 1, proc_file) == 1)
540 BusClockSpeed = value.l;
541 fclose(proc_file);
542 }
543
544 // Get actual timebase frequency
545 TimebaseSpeed = BusClockSpeed / 4;
546 DIR *cpus_dir;
547 if ((cpus_dir = opendir("/proc/device-tree/cpus")) != NULL) {
548 struct dirent *cpu_entry;
549 while ((cpu_entry = readdir(cpus_dir)) != NULL) {
550 if (strstr(cpu_entry->d_name, "PowerPC,") == cpu_entry->d_name) {
551 char timebase_freq_node[256];
552 sprintf(timebase_freq_node, "/proc/device-tree/cpus/%s/timebase-frequency", cpu_entry->d_name);
553 proc_file = fopen(timebase_freq_node, "r");
554 if (proc_file) {
555 union { uint8 b[4]; uint32 l; } value;
556 if (fread(value.b, sizeof(value), 1, proc_file) == 1)
557 TimebaseSpeed = value.l;
558 fclose(proc_file);
559 }
560 }
561 }
562 closedir(cpus_dir);
563 }
564 #endif
565
566 // Remap any newer G4/G5 processor to plain G4 for compatibility
567 switch (PVR >> 16) {
568 case 0x8000: // 7450
569 case 0x8001: // 7455
570 case 0x8002: // 7457
571 case 0x8003: // 7447A
572 case 0x8004: // 7448
573 case 0x0039: // 970
574 case 0x003c: // 970FX
575 case 0x0044: // 970MP
576 PVR = 0x000c0000; // 7400
577 break;
578 }
579 D(bug("PVR: %08x (assumed)\n", PVR));
580 }
581
582 static bool load_mac_rom(void)
583 {
584 uint32 rom_size, actual;
585 uint8 *rom_tmp;
586 const char *rom_path = PrefsFindString("rom");
587 int rom_fd = open(rom_path && *rom_path ? rom_path : ROM_FILE_NAME, O_RDONLY);
588 if (rom_fd < 0) {
589 rom_fd = open(ROM_FILE_NAME2, O_RDONLY);
590 if (rom_fd < 0) {
591 ErrorAlert(GetString(STR_NO_ROM_FILE_ERR));
592 return false;
593 }
594 }
595 printf("%s", GetString(STR_READING_ROM_FILE));
596 rom_size = lseek(rom_fd, 0, SEEK_END);
597 lseek(rom_fd, 0, SEEK_SET);
598 rom_tmp = new uint8[ROM_SIZE];
599 actual = read(rom_fd, (void *)rom_tmp, ROM_SIZE);
600 close(rom_fd);
601
602 // Decode Mac ROM
603 if (!DecodeROM(rom_tmp, actual)) {
604 if (rom_size != 4*1024*1024) {
605 ErrorAlert(GetString(STR_ROM_SIZE_ERR));
606 return false;
607 } else {
608 ErrorAlert(GetString(STR_ROM_FILE_READ_ERR));
609 return false;
610 }
611 }
612 delete[] rom_tmp;
613 return true;
614 }
615
616 static bool install_signal_handlers(void)
617 {
618 char str[256];
619 #if !EMULATED_PPC
620 // Create and install stacks for signal handlers
621 sig_stack.ss_sp = malloc(SIG_STACK_SIZE);
622 D(bug("Signal stack at %p\n", sig_stack.ss_sp));
623 if (sig_stack.ss_sp == NULL) {
624 ErrorAlert(GetString(STR_NOT_ENOUGH_MEMORY_ERR));
625 return false;
626 }
627 sig_stack.ss_flags = 0;
628 sig_stack.ss_size = SIG_STACK_SIZE;
629 if (sigaltstack(&sig_stack, NULL) < 0) {
630 sprintf(str, GetString(STR_SIGALTSTACK_ERR), strerror(errno));
631 ErrorAlert(str);
632 return false;
633 }
634 extra_stack.ss_sp = malloc(SIG_STACK_SIZE);
635 D(bug("Extra stack at %p\n", extra_stack.ss_sp));
636 if (extra_stack.ss_sp == NULL) {
637 ErrorAlert(GetString(STR_NOT_ENOUGH_MEMORY_ERR));
638 return false;
639 }
640 extra_stack.ss_flags = 0;
641 extra_stack.ss_size = SIG_STACK_SIZE;
642
643 // Install SIGSEGV and SIGBUS handlers
644 sigemptyset(&sigsegv_action.sa_mask); // Block interrupts during SEGV handling
645 sigaddset(&sigsegv_action.sa_mask, SIGUSR2);
646 sigsegv_action.sa_sigaction = sigsegv_handler;
647 sigsegv_action.sa_flags = SA_ONSTACK | SA_SIGINFO;
648 #ifdef HAVE_SIGNAL_SA_RESTORER
649 sigsegv_action.sa_restorer = NULL;
650 #endif
651 if (sigaction(SIGSEGV, &sigsegv_action, NULL) < 0) {
652 sprintf(str, GetString(STR_SIG_INSTALL_ERR), "SIGSEGV", strerror(errno));
653 ErrorAlert(str);
654 return false;
655 }
656 if (sigaction(SIGBUS, &sigsegv_action, NULL) < 0) {
657 sprintf(str, GetString(STR_SIG_INSTALL_ERR), "SIGBUS", strerror(errno));
658 ErrorAlert(str);
659 return false;
660 }
661 #else
662 // Install SIGSEGV handler for CPU emulator
663 if (!sigsegv_install_handler(sigsegv_handler)) {
664 sprintf(str, GetString(STR_SIG_INSTALL_ERR), "SIGSEGV", strerror(errno));
665 ErrorAlert(str);
666 return false;
667 }
668 #endif
669 return true;
670 }
671
672 #ifdef USE_SDL
673 static bool init_sdl()
674 {
675 int sdl_flags = 0;
676 #ifdef USE_SDL_VIDEO
677 sdl_flags |= SDL_INIT_VIDEO;
678 #endif
679 #ifdef USE_SDL_AUDIO
680 sdl_flags |= SDL_INIT_AUDIO;
681 #endif
682 assert(sdl_flags != 0);
683
684 #ifdef USE_SDL_VIDEO
685 // Don't let SDL block the screensaver
686 setenv("SDL_VIDEO_ALLOW_SCREENSAVER", "1", TRUE);
687
688 // Make SDL pass through command-clicks and option-clicks unaltered
689 setenv("SDL_HAS3BUTTONMOUSE", "1", TRUE);
690 #endif
691
692 if (SDL_Init(sdl_flags) == -1) {
693 char str[256];
694 sprintf(str, "Could not initialize SDL: %s.\n", SDL_GetError());
695 ErrorAlert(str);
696 return false;
697 }
698 atexit(SDL_Quit);
699
700 // Don't let SDL catch SIGINT and SIGTERM signals
701 signal(SIGINT, SIG_DFL);
702 signal(SIGTERM, SIG_DFL);
703 return true;
704 }
705 #endif
706
707 int main(int argc, char **argv)
708 {
709 char str[256];
710 bool memory_mapped_from_zero, ram_rom_areas_contiguous;
711 const char *vmdir = NULL;
712
713 // Initialize variables
714 RAMBase = 0;
715 tzset();
716
717 // Print some info
718 printf(GetString(STR_ABOUT_TEXT1), VERSION_MAJOR, VERSION_MINOR);
719 printf(" %s\n", GetString(STR_ABOUT_TEXT2));
720
721 #if !EMULATED_PPC
722 #ifdef SYSTEM_CLOBBERS_R2
723 // Get TOC pointer
724 TOC = get_r2();
725 #endif
726 #ifdef SYSTEM_CLOBBERS_R13
727 // Get r13 register
728 R13 = get_r13();
729 #endif
730 #endif
731
732 // Parse command line arguments
733 for (int i=1; i<argc; i++) {
734 if (strcmp(argv[i], "--help") == 0) {
735 usage(argv[0]);
736 #ifndef USE_SDL_VIDEO
737 } else if (strcmp(argv[i], "--display") == 0) {
738 i++;
739 if (i < argc)
740 x_display_name = strdup(argv[i]);
741 #endif
742 } else if (strcmp(argv[i], "--gui-connection") == 0) {
743 argv[i++] = NULL;
744 if (i < argc) {
745 gui_connection_path = argv[i];
746 argv[i] = NULL;
747 }
748 } else if (valid_vmdir(argv[i])) {
749 vmdir = argv[i];
750 argv[i] = NULL;
751 printf("Using %s as vmdir.\n", vmdir);
752 if (chdir(vmdir)) {
753 printf("Failed to chdir to %s. Good bye.", vmdir);
754 exit(1);
755 }
756 break;
757 }
758 }
759
760 // Remove processed arguments
761 for (int i=1; i<argc; i++) {
762 int k;
763 for (k=i; k<argc; k++)
764 if (argv[k] != NULL)
765 break;
766 if (k > i) {
767 k -= i;
768 for (int j=i+k; j<argc; j++)
769 argv[j-k] = argv[j];
770 argc -= k;
771 }
772 }
773
774 // Connect to the external GUI
775 if (gui_connection_path) {
776 if ((gui_connection = rpc_init_client(gui_connection_path)) == NULL) {
777 fprintf(stderr, "Failed to initialize RPC client connection to the GUI\n");
778 return 1;
779 }
780 }
781
782 #ifdef ENABLE_GTK
783 if (!gui_connection) {
784 // Init GTK
785 gtk_set_locale();
786 gtk_init(&argc, &argv);
787 }
788 #endif
789
790 // Read preferences
791 PrefsInit(vmdir, argc, argv);
792
793 // Any command line arguments left?
794 for (int i=1; i<argc; i++) {
795 if (argv[i][0] == '-') {
796 fprintf(stderr, "Unrecognized option '%s'\n", argv[i]);
797 usage(argv[0]);
798 }
799 }
800
801 #ifdef USE_SDL
802 // Initialize SDL system
803 if (!init_sdl())
804 goto quit;
805 #endif
806
807 #ifndef USE_SDL_VIDEO
808 // Open display
809 x_display = XOpenDisplay(x_display_name);
810 if (x_display == NULL) {
811 char str[256];
812 sprintf(str, GetString(STR_NO_XSERVER_ERR), XDisplayName(x_display_name));
813 ErrorAlert(str);
814 goto quit;
815 }
816
817 #if defined(ENABLE_XF86_DGA) && !defined(ENABLE_MON)
818 // Fork out, so we can return from fullscreen mode when things get ugly
819 XF86DGAForkApp(DefaultScreen(x_display));
820 #endif
821 #endif
822
823 #ifdef ENABLE_MON
824 // Initialize mon
825 mon_init();
826 #endif
827
828 // Install signal handlers
829 if (!install_signal_handlers())
830 goto quit;
831
832 // Initialize VM system
833 vm_init();
834
835 // Get system info
836 get_system_info();
837
838 // Init system routines
839 SysInit();
840
841 // Show preferences editor
842 if (!PrefsFindBool("nogui"))
843 if (!PrefsEditor())
844 goto quit;
845
846 #if !EMULATED_PPC
847 // Check some things
848 paranoia_check();
849 #endif
850
851 // Open /dev/zero
852 zero_fd = open("/dev/zero", O_RDWR);
853 if (zero_fd < 0) {
854 sprintf(str, GetString(STR_NO_DEV_ZERO_ERR), strerror(errno));
855 ErrorAlert(str);
856 goto quit;
857 }
858
859 // Create areas for Kernel Data
860 if (!kernel_data_init())
861 goto quit;
862 kernel_data = (KernelData *)Mac2HostAddr(KERNEL_DATA_BASE);
863 emulator_data = &kernel_data->ed;
864 KernelDataAddr = KERNEL_DATA_BASE;
865 D(bug("Kernel Data at %p (%08x)\n", kernel_data, KERNEL_DATA_BASE));
866 D(bug("Emulator Data at %p (%08x)\n", emulator_data, KERNEL_DATA_BASE + offsetof(KernelData, ed)));
867
868 // Create area for DR Cache
869 if (vm_mac_acquire_fixed(DR_EMULATOR_BASE, DR_EMULATOR_SIZE) < 0) {
870 sprintf(str, GetString(STR_DR_EMULATOR_MMAP_ERR), strerror(errno));
871 ErrorAlert(str);
872 goto quit;
873 }
874 dr_emulator_area_mapped = true;
875 if (vm_mac_acquire_fixed(DR_CACHE_BASE, DR_CACHE_SIZE) < 0) {
876 sprintf(str, GetString(STR_DR_CACHE_MMAP_ERR), strerror(errno));
877 ErrorAlert(str);
878 goto quit;
879 }
880 dr_cache_area_mapped = true;
881 #if !EMULATED_PPC
882 if (vm_protect((char *)DR_CACHE_BASE, DR_CACHE_SIZE, VM_PAGE_READ | VM_PAGE_WRITE | VM_PAGE_EXECUTE) < 0) {
883 sprintf(str, GetString(STR_DR_CACHE_MMAP_ERR), strerror(errno));
884 ErrorAlert(str);
885 goto quit;
886 }
887 #endif
888 DRCacheAddr = DR_CACHE_BASE;
889 D(bug("DR Cache at %p\n", DRCacheAddr));
890
891 // Create area for SheepShaver data
892 if (!SheepMem::Init()) {
893 sprintf(str, GetString(STR_SHEEP_MEM_MMAP_ERR), strerror(errno));
894 ErrorAlert(str);
895 goto quit;
896 }
897
898 // Create area for Mac RAM
899 RAMSize = PrefsFindInt32("ramsize");
900 if (RAMSize < 8*1024*1024) {
901 WarningAlert(GetString(STR_SMALL_RAM_WARN));
902 RAMSize = 8*1024*1024;
903 }
904 memory_mapped_from_zero = false;
905 ram_rom_areas_contiguous = false;
906 #if REAL_ADDRESSING && HAVE_LINKER_SCRIPT
907 if (vm_mac_acquire_fixed(0, RAMSize) == 0) {
908 D(bug("Could allocate RAM from 0x0000\n"));
909 RAMBase = 0;
910 RAMBaseHost = Mac2HostAddr(RAMBase);
911 memory_mapped_from_zero = true;
912 }
913 #endif
914 if (!memory_mapped_from_zero) {
915 #ifndef PAGEZERO_HACK
916 // Create Low Memory area (0x0000..0x3000)
917 if (vm_mac_acquire_fixed(0, 0x3000) < 0) {
918 sprintf(str, GetString(STR_LOW_MEM_MMAP_ERR), strerror(errno));
919 ErrorAlert(str);
920 goto quit;
921 }
922 lm_area_mapped = true;
923 #endif
924 #if REAL_ADDRESSING
925 // Allocate RAM at any address. Since ROM must be higher than RAM, allocate the RAM
926 // and ROM areas contiguously, plus a little extra to allow for ROM address alignment.
927 RAMBaseHost = vm_mac_acquire(RAMSize + ROM_AREA_SIZE + ROM_ALIGNMENT);
928 if (RAMBaseHost == VM_MAP_FAILED) {
929 sprintf(str, GetString(STR_RAM_ROM_MMAP_ERR), strerror(errno));
930 ErrorAlert(str);
931 goto quit;
932 }
933 RAMBase = Host2MacAddr(RAMBaseHost);
934 ROMBase = (RAMBase + RAMSize + ROM_ALIGNMENT -1) & -ROM_ALIGNMENT;
935 ROMBaseHost = Mac2HostAddr(ROMBase);
936 ram_rom_areas_contiguous = true;
937 #else
938 if (vm_mac_acquire_fixed(RAM_BASE, RAMSize) < 0) {
939 sprintf(str, GetString(STR_RAM_MMAP_ERR), strerror(errno));
940 ErrorAlert(str);
941 goto quit;
942 }
943 RAMBase = RAM_BASE;
944 RAMBaseHost = Mac2HostAddr(RAMBase);
945 #endif
946 }
947 #if !EMULATED_PPC
948 if (vm_protect(RAMBaseHost, RAMSize, VM_PAGE_READ | VM_PAGE_WRITE | VM_PAGE_EXECUTE) < 0) {
949 sprintf(str, GetString(STR_RAM_MMAP_ERR), strerror(errno));
950 ErrorAlert(str);
951 goto quit;
952 }
953 #endif
954 ram_area_mapped = true;
955 D(bug("RAM area at %p (%08x)\n", RAMBaseHost, RAMBase));
956
957 if (RAMBase > KernelDataAddr) {
958 ErrorAlert(GetString(STR_RAM_AREA_TOO_HIGH_ERR));
959 goto quit;
960 }
961
962 // Create area for Mac ROM
963 if (!ram_rom_areas_contiguous) {
964 if (vm_mac_acquire_fixed(ROM_BASE, ROM_AREA_SIZE) < 0) {
965 sprintf(str, GetString(STR_ROM_MMAP_ERR), strerror(errno));
966 ErrorAlert(str);
967 goto quit;
968 }
969 ROMBase = ROM_BASE;
970 ROMBaseHost = Mac2HostAddr(ROMBase);
971 }
972 #if !EMULATED_PPC
973 if (vm_protect(ROMBaseHost, ROM_AREA_SIZE, VM_PAGE_READ | VM_PAGE_WRITE | VM_PAGE_EXECUTE) < 0) {
974 sprintf(str, GetString(STR_ROM_MMAP_ERR), strerror(errno));
975 ErrorAlert(str);
976 goto quit;
977 }
978 #endif
979 rom_area_mapped = true;
980 D(bug("ROM area at %p (%08x)\n", ROMBaseHost, ROMBase));
981
982 if (RAMBase > ROMBase) {
983 ErrorAlert(GetString(STR_RAM_HIGHER_THAN_ROM_ERR));
984 goto quit;
985 }
986
987 // Load Mac ROM
988 if (!load_mac_rom())
989 goto quit;
990
991 // Initialize everything
992 if (!InitAll(vmdir))
993 goto quit;
994 D(bug("Initialization complete\n"));
995
996 // Clear caches (as we loaded and patched code) and write protect ROM
997 #if !EMULATED_PPC
998 flush_icache_range(ROMBase, ROMBase + ROM_AREA_SIZE);
999 #endif
1000 vm_protect(ROMBaseHost, ROM_AREA_SIZE, VM_PAGE_READ | VM_PAGE_EXECUTE);
1001
1002 // Start 60Hz thread
1003 tick_thread_cancel = false;
1004 tick_thread_active = (pthread_create(&tick_thread, NULL, tick_func, NULL) == 0);
1005 D(bug("Tick thread installed (%ld)\n", tick_thread));
1006
1007 // Start NVRAM watchdog thread
1008 memcpy(last_xpram, XPRAM, XPRAM_SIZE);
1009 nvram_thread_cancel = false;
1010 nvram_thread_active = (pthread_create(&nvram_thread, NULL, nvram_func, NULL) == 0);
1011 D(bug("NVRAM thread installed (%ld)\n", nvram_thread));
1012
1013 #if !EMULATED_PPC
1014 // Install SIGILL handler
1015 sigemptyset(&sigill_action.sa_mask); // Block interrupts during ILL handling
1016 sigaddset(&sigill_action.sa_mask, SIGUSR2);
1017 sigill_action.sa_sigaction = sigill_handler;
1018 sigill_action.sa_flags = SA_ONSTACK | SA_SIGINFO;
1019 #ifdef HAVE_SIGNAL_SA_RESTORER
1020 sigill_action.sa_restorer = NULL;
1021 #endif
1022 if (sigaction(SIGILL, &sigill_action, NULL) < 0) {
1023 sprintf(str, GetString(STR_SIG_INSTALL_ERR), "SIGILL", strerror(errno));
1024 ErrorAlert(str);
1025 goto quit;
1026 }
1027 #endif
1028
1029 #if !EMULATED_PPC
1030 // Install interrupt signal handler
1031 sigemptyset(&sigusr2_action.sa_mask);
1032 sigusr2_action.sa_sigaction = sigusr2_handler_init;
1033 sigusr2_action.sa_flags = SA_ONSTACK | SA_RESTART | SA_SIGINFO;
1034 #ifdef HAVE_SIGNAL_SA_RESTORER
1035 sigusr2_action.sa_restorer = NULL;
1036 #endif
1037 if (sigaction(SIGUSR2, &sigusr2_action, NULL) < 0) {
1038 sprintf(str, GetString(STR_SIG_INSTALL_ERR), "SIGUSR2", strerror(errno));
1039 ErrorAlert(str);
1040 goto quit;
1041 }
1042 #endif
1043
1044 // Get my thread ID and execute MacOS thread function
1045 emul_thread = pthread_self();
1046 D(bug("MacOS thread is %ld\n", emul_thread));
1047 emul_func(NULL);
1048
1049 quit:
1050 Quit();
1051 return 0;
1052 }
1053
1054
1055 /*
1056 * Cleanup and quit
1057 */
1058
1059 static void Quit(void)
1060 {
1061 #if EMULATED_PPC
1062 // Exit PowerPC emulation
1063 exit_emul_ppc();
1064 #endif
1065
1066 // Stop 60Hz thread
1067 if (tick_thread_active) {
1068 tick_thread_cancel = true;
1069 pthread_cancel(tick_thread);
1070 pthread_join(tick_thread, NULL);
1071 }
1072
1073 // Stop NVRAM watchdog thread
1074 if (nvram_thread_active) {
1075 nvram_thread_cancel = true;
1076 pthread_cancel(nvram_thread);
1077 pthread_join(nvram_thread, NULL);
1078 }
1079
1080 #if !EMULATED_PPC
1081 // Uninstall SIGSEGV and SIGBUS handlers
1082 sigemptyset(&sigsegv_action.sa_mask);
1083 sigsegv_action.sa_handler = SIG_DFL;
1084 sigsegv_action.sa_flags = 0;
1085 sigaction(SIGSEGV, &sigsegv_action, NULL);
1086 sigaction(SIGBUS, &sigsegv_action, NULL);
1087
1088 // Uninstall SIGILL handler
1089 sigemptyset(&sigill_action.sa_mask);
1090 sigill_action.sa_handler = SIG_DFL;
1091 sigill_action.sa_flags = 0;
1092 sigaction(SIGILL, &sigill_action, NULL);
1093
1094 // Delete stacks for signal handlers
1095 if (sig_stack.ss_sp)
1096 free(sig_stack.ss_sp);
1097 if (extra_stack.ss_sp)
1098 free(extra_stack.ss_sp);
1099 #endif
1100
1101 // Deinitialize everything
1102 ExitAll();
1103
1104 // Delete SheepShaver globals
1105 SheepMem::Exit();
1106
1107 // Delete RAM area
1108 if (ram_area_mapped)
1109 vm_mac_release(RAMBase, RAMSize);
1110
1111 // Delete ROM area
1112 if (rom_area_mapped)
1113 vm_mac_release(ROMBase, ROM_AREA_SIZE);
1114
1115 // Delete DR cache areas
1116 if (dr_emulator_area_mapped)
1117 vm_mac_release(DR_EMULATOR_BASE, DR_EMULATOR_SIZE);
1118 if (dr_cache_area_mapped)
1119 vm_mac_release(DR_CACHE_BASE, DR_CACHE_SIZE);
1120
1121 // Delete Low Memory area
1122 if (lm_area_mapped)
1123 vm_mac_release(0, 0x3000);
1124
1125 // Close /dev/zero
1126 if (zero_fd > 0)
1127 close(zero_fd);
1128
1129 // Exit system routines
1130 SysExit();
1131
1132 // Exit preferences
1133 PrefsExit();
1134
1135 #ifdef ENABLE_MON
1136 // Exit mon
1137 mon_exit();
1138 #endif
1139
1140 // Close X11 server connection
1141 #ifndef USE_SDL_VIDEO
1142 if (x_display)
1143 XCloseDisplay(x_display);
1144 #endif
1145
1146 // Notify GUI we are about to leave
1147 if (gui_connection) {
1148 if (rpc_method_invoke(gui_connection, RPC_METHOD_EXIT, RPC_TYPE_INVALID) == RPC_ERROR_NO_ERROR)
1149 rpc_method_wait_for_reply(gui_connection, RPC_TYPE_INVALID);
1150 }
1151
1152 exit(0);
1153 }
1154
1155
1156 /*
1157 * Initialize Kernel Data segments
1158 */
1159
1160 static bool kernel_data_init(void)
1161 {
1162 char str[256];
1163 void *kernel_addr1 = NULL;
1164 void *kernel_addr2 = NULL;
1165 uint32 kernel_area_size = (KERNEL_AREA_SIZE + SHMLBA - 1) & -SHMLBA;
1166
1167 kernel_area = shmget(IPC_PRIVATE, kernel_area_size, 0600);
1168 if (kernel_area == -1) {
1169 sprintf(str, GetString(STR_KD_SHMGET_ERR), strerror(errno));
1170 goto fail_shmget;
1171 }
1172 kernel_addr1 = Mac2HostAddr(KERNEL_DATA_BASE & -SHMLBA);
1173 if (shmat(kernel_area, kernel_addr1, 0) != kernel_addr1) {
1174 sprintf(str, GetString(STR_KD_SHMAT_ERR), strerror(errno));
1175 goto fail_shmat1;
1176 }
1177 kernel_addr2 = Mac2HostAddr(KERNEL_DATA2_BASE & -SHMLBA);
1178 if (shmat(kernel_area, kernel_addr2, 0) != kernel_addr2) {
1179 sprintf(str, GetString(STR_KD2_SHMAT_ERR), strerror(errno));
1180 goto fail_shmat2;
1181 }
1182 atexit(kernel_data_exit);
1183 return true;
1184
1185 fail_shmat2:
1186 shmdt(kernel_addr1);
1187 fail_shmat1:
1188 shmctl(kernel_area, IPC_RMID, NULL);
1189 fail_shmget:
1190 ErrorAlert(str);
1191 return false;
1192 }
1193
1194
1195 /*
1196 * Deallocate Kernel Data segments
1197 */
1198
1199 static void kernel_data_exit(void)
1200 {
1201 if (kernel_area >= 0) {
1202 shmdt(Mac2HostAddr(KERNEL_DATA_BASE & -SHMLBA));
1203 shmdt(Mac2HostAddr(KERNEL_DATA2_BASE & -SHMLBA));
1204 shmctl(kernel_area, IPC_RMID, NULL);
1205 kernel_area = NULL;
1206 }
1207 }
1208
1209
1210 /*
1211 * Jump into Mac ROM, start 680x0 emulator
1212 */
1213
1214 #if EMULATED_PPC
1215 void jump_to_rom(uint32 entry)
1216 {
1217 init_emul_ppc();
1218 emul_ppc(entry);
1219 }
1220 #endif
1221
1222
1223 /*
1224 * Emulator thread function
1225 */
1226
1227 static void *emul_func(void *arg)
1228 {
1229 // We're now ready to receive signals
1230 ready_for_signals = true;
1231
1232 // Decrease priority, so more time-critical things like audio will work better
1233 nice(1);
1234
1235 // Jump to ROM boot routine
1236 D(bug("Jumping to ROM\n"));
1237 #if EMULATED_PPC
1238 jump_to_rom(ROMBase + 0x310000);
1239 #else
1240 jump_to_rom(ROMBase + 0x310000, (uint32)emulator_data);
1241 #endif
1242 D(bug("Returned from ROM\n"));
1243
1244 // We're no longer ready to receive signals
1245 ready_for_signals = false;
1246 return NULL;
1247 }
1248
1249
1250 #if !EMULATED_PPC
1251 /*
1252 * Execute 68k subroutine (must be ended with RTS)
1253 * This must only be called by the emul_thread when in EMUL_OP mode
1254 * r->a[7] is unused, the routine runs on the caller's stack
1255 */
1256
1257 void Execute68k(uint32 pc, M68kRegisters *r)
1258 {
1259 #if SAFE_EXEC_68K
1260 if (ReadMacInt32(XLM_RUN_MODE) != MODE_EMUL_OP)
1261 printf("FATAL: Execute68k() not called from EMUL_OP mode\n");
1262 if (!pthread_equal(pthread_self(), emul_thread))
1263 printf("FATAL: Execute68k() not called from emul_thread\n");
1264 #endif
1265 execute_68k(pc, r);
1266 }
1267
1268
1269 /*
1270 * Execute 68k A-Trap from EMUL_OP routine
1271 * r->a[7] is unused, the routine runs on the caller's stack
1272 */
1273
1274 void Execute68kTrap(uint16 trap, M68kRegisters *r)
1275 {
1276 uint16 proc[2] = {trap, M68K_RTS};
1277 Execute68k((uint32)proc, r);
1278 }
1279 #endif
1280
1281
1282 /*
1283 * Quit emulator (cause return from jump_to_rom)
1284 */
1285
1286 void QuitEmulator(void)
1287 {
1288 #if EMULATED_PPC
1289 Quit();
1290 #else
1291 quit_emulator();
1292 #endif
1293 }
1294
1295
1296 /*
1297 * Dump 68k registers
1298 */
1299
1300 void Dump68kRegs(M68kRegisters *r)
1301 {
1302 // Display 68k registers
1303 for (int i=0; i<8; i++) {
1304 printf("d%d: %08x", i, r->d[i]);
1305 if (i == 3 || i == 7)
1306 printf("\n");
1307 else
1308 printf(", ");
1309 }
1310 for (int i=0; i<8; i++) {
1311 printf("a%d: %08x", i, r->a[i]);
1312 if (i == 3 || i == 7)
1313 printf("\n");
1314 else
1315 printf(", ");
1316 }
1317 }
1318
1319
1320 /*
1321 * Make code executable
1322 */
1323
1324 void MakeExecutable(int dummy, uint32 start, uint32 length)
1325 {
1326 if ((start >= ROMBase) && (start < (ROMBase + ROM_SIZE)))
1327 return;
1328 #if EMULATED_PPC
1329 FlushCodeCache(start, start + length);
1330 #else
1331 flush_icache_range(start, start + length);
1332 #endif
1333 }
1334
1335
1336 /*
1337 * NVRAM watchdog thread (saves NVRAM every minute)
1338 */
1339
1340 static void nvram_watchdog(void)
1341 {
1342 if (memcmp(last_xpram, XPRAM, XPRAM_SIZE)) {
1343 memcpy(last_xpram, XPRAM, XPRAM_SIZE);
1344 SaveXPRAM();
1345 }
1346 }
1347
1348 static void *nvram_func(void *arg)
1349 {
1350 while (!nvram_thread_cancel) {
1351 for (int i=0; i<60 && !nvram_thread_cancel; i++)
1352 Delay_usec(999999); // Only wait 1 second so we quit promptly when nvram_thread_cancel becomes true
1353 nvram_watchdog();
1354 }
1355 return NULL;
1356 }
1357
1358
1359 /*
1360 * 60Hz thread (really 60.15Hz)
1361 */
1362
1363 static void *tick_func(void *arg)
1364 {
1365 int tick_counter = 0;
1366 uint64 start = GetTicks_usec();
1367 int64 ticks = 0;
1368 uint64 next = GetTicks_usec();
1369
1370 while (!tick_thread_cancel) {
1371
1372 // Wait
1373 next += 16625;
1374 int64 delay = next - GetTicks_usec();
1375 if (delay > 0)
1376 Delay_usec(delay);
1377 else if (delay < -16625)
1378 next = GetTicks_usec();
1379 ticks++;
1380
1381 #if !EMULATED_PPC
1382 // Did we crash?
1383 if (emul_thread_fatal) {
1384
1385 // Yes, dump registers
1386 sigregs *r = &sigsegv_regs;
1387 char str[256];
1388 if (crash_reason == NULL)
1389 crash_reason = "SIGSEGV";
1390 sprintf(str, "%s\n"
1391 " pc %08lx lr %08lx ctr %08lx msr %08lx\n"
1392 " xer %08lx cr %08lx \n"
1393 " r0 %08lx r1 %08lx r2 %08lx r3 %08lx\n"
1394 " r4 %08lx r5 %08lx r6 %08lx r7 %08lx\n"
1395 " r8 %08lx r9 %08lx r10 %08lx r11 %08lx\n"
1396 " r12 %08lx r13 %08lx r14 %08lx r15 %08lx\n"
1397 " r16 %08lx r17 %08lx r18 %08lx r19 %08lx\n"
1398 " r20 %08lx r21 %08lx r22 %08lx r23 %08lx\n"
1399 " r24 %08lx r25 %08lx r26 %08lx r27 %08lx\n"
1400 " r28 %08lx r29 %08lx r30 %08lx r31 %08lx\n",
1401 crash_reason,
1402 r->nip, r->link, r->ctr, r->msr,
1403 r->xer, r->ccr,
1404 r->gpr[0], r->gpr[1], r->gpr[2], r->gpr[3],
1405 r->gpr[4], r->gpr[5], r->gpr[6], r->gpr[7],
1406 r->gpr[8], r->gpr[9], r->gpr[10], r->gpr[11],
1407 r->gpr[12], r->gpr[13], r->gpr[14], r->gpr[15],
1408 r->gpr[16], r->gpr[17], r->gpr[18], r->gpr[19],
1409 r->gpr[20], r->gpr[21], r->gpr[22], r->gpr[23],
1410 r->gpr[24], r->gpr[25], r->gpr[26], r->gpr[27],
1411 r->gpr[28], r->gpr[29], r->gpr[30], r->gpr[31]);
1412 printf(str);
1413 VideoQuitFullScreen();
1414
1415 #ifdef ENABLE_MON
1416 // Start up mon in real-mode
1417 printf("Welcome to the sheep factory.\n");
1418 char *arg[4] = {"mon", "-m", "-r", NULL};
1419 mon(3, arg);
1420 #endif
1421 return NULL;
1422 }
1423 #endif
1424
1425 // Pseudo Mac 1Hz interrupt, update local time
1426 if (++tick_counter > 60) {
1427 tick_counter = 0;
1428 WriteMacInt32(0x20c, TimerDateTime());
1429 }
1430
1431 // Trigger 60Hz interrupt
1432 if (ReadMacInt32(XLM_IRQ_NEST) == 0) {
1433 SetInterruptFlag(INTFLAG_VIA);
1434 TriggerInterrupt();
1435 }
1436 }
1437
1438 uint64 end = GetTicks_usec();
1439 D(bug("%lld ticks in %lld usec = %f ticks/sec\n", ticks, end - start, ticks * 1000000.0 / (end - start)));
1440 return NULL;
1441 }
1442
1443
1444 /*
1445 * Pthread configuration
1446 */
1447
1448 void Set_pthread_attr(pthread_attr_t *attr, int priority)
1449 {
1450 #ifdef HAVE_PTHREADS
1451 pthread_attr_init(attr);
1452 #if defined(_POSIX_THREAD_PRIORITY_SCHEDULING)
1453 // Some of these only work for superuser
1454 if (geteuid() == 0) {
1455 pthread_attr_setinheritsched(attr, PTHREAD_EXPLICIT_SCHED);
1456 pthread_attr_setschedpolicy(attr, SCHED_FIFO);
1457 struct sched_param fifo_param;
1458 fifo_param.sched_priority = ((sched_get_priority_min(SCHED_FIFO) +
1459 sched_get_priority_max(SCHED_FIFO)) / 2 +
1460 priority);
1461 pthread_attr_setschedparam(attr, &fifo_param);
1462 }
1463 if (pthread_attr_setscope(attr, PTHREAD_SCOPE_SYSTEM) != 0) {
1464 #ifdef PTHREAD_SCOPE_BOUND_NP
1465 // If system scope is not available (eg. we're not running
1466 // with CAP_SCHED_MGT capability on an SGI box), try bound
1467 // scope. It exposes pthread scheduling to the kernel,
1468 // without setting realtime priority.
1469 pthread_attr_setscope(attr, PTHREAD_SCOPE_BOUND_NP);
1470 #endif
1471 }
1472 #endif
1473 #endif
1474 }
1475
1476
1477 /*
1478 * Mutexes
1479 */
1480
1481 #ifdef HAVE_PTHREADS
1482
1483 struct B2_mutex {
1484 B2_mutex() {
1485 pthread_mutexattr_t attr;
1486 pthread_mutexattr_init(&attr);
1487 // Initialize the mutex for priority inheritance --
1488 // required for accurate timing.
1489 #if defined(HAVE_PTHREAD_MUTEXATTR_SETPROTOCOL) && !defined(__CYGWIN__)
1490 pthread_mutexattr_setprotocol(&attr, PTHREAD_PRIO_INHERIT);
1491 #endif
1492 #if defined(HAVE_PTHREAD_MUTEXATTR_SETTYPE) && defined(PTHREAD_MUTEX_NORMAL)
1493 pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_NORMAL);
1494 #endif
1495 #ifdef HAVE_PTHREAD_MUTEXATTR_SETPSHARED
1496 pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_PRIVATE);
1497 #endif
1498 pthread_mutex_init(&m, &attr);
1499 pthread_mutexattr_destroy(&attr);
1500 }
1501 ~B2_mutex() {
1502 pthread_mutex_trylock(&m); // Make sure it's locked before
1503 pthread_mutex_unlock(&m); // unlocking it.
1504 pthread_mutex_destroy(&m);
1505 }
1506 pthread_mutex_t m;
1507 };
1508
1509 B2_mutex *B2_create_mutex(void)
1510 {
1511 return new B2_mutex;
1512 }
1513
1514 void B2_lock_mutex(B2_mutex *mutex)
1515 {
1516 pthread_mutex_lock(&mutex->m);
1517 }
1518
1519 void B2_unlock_mutex(B2_mutex *mutex)
1520 {
1521 pthread_mutex_unlock(&mutex->m);
1522 }
1523
1524 void B2_delete_mutex(B2_mutex *mutex)
1525 {
1526 delete mutex;
1527 }
1528
1529 #else
1530
1531 struct B2_mutex {
1532 int dummy;
1533 };
1534
1535 B2_mutex *B2_create_mutex(void)
1536 {
1537 return new B2_mutex;
1538 }
1539
1540 void B2_lock_mutex(B2_mutex *mutex)
1541 {
1542 }
1543
1544 void B2_unlock_mutex(B2_mutex *mutex)
1545 {
1546 }
1547
1548 void B2_delete_mutex(B2_mutex *mutex)
1549 {
1550 delete mutex;
1551 }
1552
1553 #endif
1554
1555
1556 /*
1557 * Trigger signal USR2 from another thread
1558 */
1559
1560 #if !EMULATED_PPC
1561 void TriggerInterrupt(void)
1562 {
1563 if (ready_for_signals) {
1564 idle_resume();
1565 pthread_kill(emul_thread, SIGUSR2);
1566 }
1567 }
1568 #endif
1569
1570
1571 /*
1572 * Interrupt flags (must be handled atomically!)
1573 */
1574
1575 volatile uint32 InterruptFlags = 0;
1576
1577 void SetInterruptFlag(uint32 flag)
1578 {
1579 atomic_or((int *)&InterruptFlags, flag);
1580 }
1581
1582 void ClearInterruptFlag(uint32 flag)
1583 {
1584 atomic_and((int *)&InterruptFlags, ~flag);
1585 }
1586
1587
1588 /*
1589 * Disable interrupts
1590 */
1591
1592 void DisableInterrupt(void)
1593 {
1594 #if EMULATED_PPC
1595 WriteMacInt32(XLM_IRQ_NEST, int32(ReadMacInt32(XLM_IRQ_NEST)) + 1);
1596 #else
1597 atomic_add((int *)XLM_IRQ_NEST, 1);
1598 #endif
1599 }
1600
1601
1602 /*
1603 * Enable interrupts
1604 */
1605
1606 void EnableInterrupt(void)
1607 {
1608 #if EMULATED_PPC
1609 WriteMacInt32(XLM_IRQ_NEST, int32(ReadMacInt32(XLM_IRQ_NEST)) - 1);
1610 #else
1611 atomic_add((int *)XLM_IRQ_NEST, -1);
1612 #endif
1613 }
1614
1615
1616 /*
1617 * USR2 handler
1618 */
1619
1620 #if !EMULATED_PPC
1621 void sigusr2_handler(int sig, siginfo_t *sip, void *scp)
1622 {
1623 machine_regs *r = MACHINE_REGISTERS(scp);
1624
1625 #ifdef SYSTEM_CLOBBERS_R2
1626 // Restore pointer to Thread Local Storage
1627 set_r2(TOC);
1628 #endif
1629 #ifdef SYSTEM_CLOBBERS_R13
1630 // Restore pointer to .sdata section
1631 set_r13(R13);
1632 #endif
1633
1634 #ifdef USE_SDL_VIDEO
1635 // We must fill in the events queue in the same thread that did call SDL_SetVideoMode()
1636 SDL_PumpEvents();
1637 #endif
1638
1639 // Do nothing if interrupts are disabled
1640 if (*(int32 *)XLM_IRQ_NEST > 0)
1641 return;
1642
1643 // Disable MacOS stack sniffer
1644 WriteMacInt32(0x110, 0);
1645
1646 // Interrupt action depends on current run mode
1647 switch (ReadMacInt32(XLM_RUN_MODE)) {
1648 case MODE_68K:
1649 // 68k emulator active, trigger 68k interrupt level 1
1650 WriteMacInt16(ntohl(kernel_data->v[0x67c >> 2]), 1);
1651 r->cr() |= ntohl(kernel_data->v[0x674 >> 2]);
1652 break;
1653
1654 #if INTERRUPTS_IN_NATIVE_MODE
1655 case MODE_NATIVE:
1656 // 68k emulator inactive, in nanokernel?
1657 if (r->gpr(1) != KernelDataAddr) {
1658
1659 // Set extra stack for SIGSEGV handler
1660 sigaltstack(&extra_stack, NULL);
1661
1662 // Prepare for 68k interrupt level 1
1663 WriteMacInt16(ntohl(kernel_data->v[0x67c >> 2]), 1);
1664 WriteMacInt32(ntohl(kernel_data->v[0x658 >> 2]) + 0xdc, ReadMacInt32(ntohl(kernel_data->v[0x658 >> 2]) + 0xdc) | ntohl(kernel_data->v[0x674 >> 2]));
1665
1666 // Execute nanokernel interrupt routine (this will activate the 68k emulator)
1667 DisableInterrupt();
1668 if (ROMType == ROMTYPE_NEWWORLD)
1669 ppc_interrupt(ROMBase + 0x312b1c, KernelDataAddr);
1670 else
1671 ppc_interrupt(ROMBase + 0x312a3c, KernelDataAddr);
1672
1673 // Reset normal stack
1674 sigaltstack(&sig_stack, NULL);
1675 }
1676 break;
1677 #endif
1678
1679 #if INTERRUPTS_IN_EMUL_OP_MODE
1680 case MODE_EMUL_OP:
1681 // 68k emulator active, within EMUL_OP routine, execute 68k interrupt routine directly when interrupt level is 0
1682 if ((ReadMacInt32(XLM_68K_R25) & 7) == 0) {
1683
1684 // Set extra stack for SIGSEGV handler
1685 sigaltstack(&extra_stack, NULL);
1686 #if 1
1687 // Execute full 68k interrupt routine
1688 M68kRegisters r;
1689 uint32 old_r25 = ReadMacInt32(XLM_68K_R25); // Save interrupt level
1690 WriteMacInt32(XLM_68K_R25, 0x21); // Execute with interrupt level 1
1691 static const uint16 proc[] = {
1692 0x3f3c, 0x0000, // move.w #$0000,-(sp) (fake format word)
1693 0x487a, 0x000a, // pea @1(pc) (return address)
1694 0x40e7, // move sr,-(sp) (saved SR)
1695 0x2078, 0x0064, // move.l $64,a0
1696 0x4ed0, // jmp (a0)
1697 M68K_RTS // @1
1698 };
1699 Execute68k((uint32)proc, &r);
1700 WriteMacInt32(XLM_68K_R25, old_r25); // Restore interrupt level
1701 #else
1702 // Only update cursor
1703 if (HasMacStarted()) {
1704 if (InterruptFlags & INTFLAG_VIA) {
1705 ClearInterruptFlag(INTFLAG_VIA);
1706 ADBInterrupt();
1707 ExecuteNative(NATIVE_VIDEO_VBL);
1708 }
1709 }
1710 #endif
1711 // Reset normal stack
1712 sigaltstack(&sig_stack, NULL);
1713 }
1714 break;
1715 #endif
1716 }
1717 }
1718 #endif
1719
1720
1721 /*
1722 * SIGSEGV handler
1723 */
1724
1725 #if !EMULATED_PPC
1726 static void sigsegv_handler(int sig, siginfo_t *sip, void *scp)
1727 {
1728 machine_regs *r = MACHINE_REGISTERS(scp);
1729
1730 // Get effective address
1731 uint32 addr = r->dar();
1732
1733 #ifdef SYSTEM_CLOBBERS_R2
1734 // Restore pointer to Thread Local Storage
1735 set_r2(TOC);
1736 #endif
1737 #ifdef SYSTEM_CLOBBERS_R13
1738 // Restore pointer to .sdata section
1739 set_r13(R13);
1740 #endif
1741
1742 #if ENABLE_VOSF
1743 // Handle screen fault
1744 #if SIGSEGV_CHECK_VERSION(1,0,0)
1745 sigsegv_info_t si;
1746 si.addr = (sigsegv_address_t)addr;
1747 si.pc = (sigsegv_address_t)r->pc();
1748 #endif
1749 extern bool Screen_fault_handler(sigsegv_info_t *sip);
1750 if (Screen_fault_handler(&si))
1751 return;
1752 #endif
1753
1754 num_segv++;
1755
1756 // Fault in Mac ROM or RAM or DR Cache?
1757 bool mac_fault = (r->pc() >= ROMBase) && (r->pc() < (ROMBase + ROM_AREA_SIZE)) || (r->pc() >= RAMBase) && (r->pc() < (RAMBase + RAMSize)) || (r->pc() >= DR_CACHE_BASE && r->pc() < (DR_CACHE_BASE + DR_CACHE_SIZE));
1758 if (mac_fault) {
1759
1760 // "VM settings" during MacOS 8 installation
1761 if (r->pc() == ROMBase + 0x488160 && r->gpr(20) == 0xf8000000) {
1762 r->pc() += 4;
1763 r->gpr(8) = 0;
1764 return;
1765
1766 // MacOS 8.5 installation
1767 } else if (r->pc() == ROMBase + 0x488140 && r->gpr(16) == 0xf8000000) {
1768 r->pc() += 4;
1769 r->gpr(8) = 0;
1770 return;
1771
1772 // MacOS 8 serial drivers on startup
1773 } else if (r->pc() == ROMBase + 0x48e080 && (r->gpr(8) == 0xf3012002 || r->gpr(8) == 0xf3012000)) {
1774 r->pc() += 4;
1775 r->gpr(8) = 0;
1776 return;
1777
1778 // MacOS 8.1 serial drivers on startup
1779 } else if (r->pc() == ROMBase + 0x48c5e0 && (r->gpr(20) == 0xf3012002 || r->gpr(20) == 0xf3012000)) {
1780 r->pc() += 4;
1781 return;
1782 } else if (r->pc() == ROMBase + 0x4a10a0 && (r->gpr(20) == 0xf3012002 || r->gpr(20) == 0xf3012000)) {
1783 r->pc() += 4;
1784 return;
1785
1786 // MacOS 8.6 serial drivers on startup (with DR Cache and OldWorld ROM)
1787 } else if ((r->pc() - DR_CACHE_BASE) < DR_CACHE_SIZE && (r->gpr(16) == 0xf3012002 || r->gpr(16) == 0xf3012000)) {
1788 r->pc() += 4;
1789 return;
1790 } else if ((r->pc() - DR_CACHE_BASE) < DR_CACHE_SIZE && (r->gpr(20) == 0xf3012002 || r->gpr(20) == 0xf3012000)) {
1791 r->pc() += 4;
1792 return;
1793 }
1794
1795 // Get opcode and divide into fields
1796 uint32 opcode = *((uint32 *)r->pc());
1797 uint32 primop = opcode >> 26;
1798 uint32 exop = (opcode >> 1) & 0x3ff;
1799 uint32 ra = (opcode >> 16) & 0x1f;
1800 uint32 rb = (opcode >> 11) & 0x1f;
1801 uint32 rd = (opcode >> 21) & 0x1f;
1802 int32 imm = (int16)(opcode & 0xffff);
1803
1804 // Analyze opcode
1805 enum {
1806 TYPE_UNKNOWN,
1807 TYPE_LOAD,
1808 TYPE_STORE
1809 } transfer_type = TYPE_UNKNOWN;
1810 enum {
1811 SIZE_UNKNOWN,
1812 SIZE_BYTE,
1813 SIZE_HALFWORD,
1814 SIZE_WORD
1815 } transfer_size = SIZE_UNKNOWN;
1816 enum {
1817 MODE_UNKNOWN,
1818 MODE_NORM,
1819 MODE_U,
1820 MODE_X,
1821 MODE_UX
1822 } addr_mode = MODE_UNKNOWN;
1823 switch (primop) {
1824 case 31:
1825 switch (exop) {
1826 case 23: // lwzx
1827 transfer_type = TYPE_LOAD; transfer_size = SIZE_WORD; addr_mode = MODE_X; break;
1828 case 55: // lwzux
1829 transfer_type = TYPE_LOAD; transfer_size = SIZE_WORD; addr_mode = MODE_UX; break;
1830 case 87: // lbzx
1831 transfer_type = TYPE_LOAD; transfer_size = SIZE_BYTE; addr_mode = MODE_X; break;
1832 case 119: // lbzux
1833 transfer_type = TYPE_LOAD; transfer_size = SIZE_BYTE; addr_mode = MODE_UX; break;
1834 case 151: // stwx
1835 transfer_type = TYPE_STORE; transfer_size = SIZE_WORD; addr_mode = MODE_X; break;
1836 case 183: // stwux
1837 transfer_type = TYPE_STORE; transfer_size = SIZE_WORD; addr_mode = MODE_UX; break;
1838 case 215: // stbx
1839 transfer_type = TYPE_STORE; transfer_size = SIZE_BYTE; addr_mode = MODE_X; break;
1840 case 247: // stbux
1841 transfer_type = TYPE_STORE; transfer_size = SIZE_BYTE; addr_mode = MODE_UX; break;
1842 case 279: // lhzx
1843 transfer_type = TYPE_LOAD; transfer_size = SIZE_HALFWORD; addr_mode = MODE_X; break;
1844 case 311: // lhzux
1845 transfer_type = TYPE_LOAD; transfer_size = SIZE_HALFWORD; addr_mode = MODE_UX; break;
1846 case 343: // lhax
1847 transfer_type = TYPE_LOAD; transfer_size = SIZE_HALFWORD; addr_mode = MODE_X; break;
1848 case 375: // lhaux
1849 transfer_type = TYPE_LOAD; transfer_size = SIZE_HALFWORD; addr_mode = MODE_UX; break;
1850 case 407: // sthx
1851 transfer_type = TYPE_STORE; transfer_size = SIZE_HALFWORD; addr_mode = MODE_X; break;
1852 case 439: // sthux
1853 transfer_type = TYPE_STORE; transfer_size = SIZE_HALFWORD; addr_mode = MODE_UX; break;
1854 }
1855 break;
1856
1857 case 32: // lwz
1858 transfer_type = TYPE_LOAD; transfer_size = SIZE_WORD; addr_mode = MODE_NORM; break;
1859 case 33: // lwzu
1860 transfer_type = TYPE_LOAD; transfer_size = SIZE_WORD; addr_mode = MODE_U; break;
1861 case 34: // lbz
1862 transfer_type = TYPE_LOAD; transfer_size = SIZE_BYTE; addr_mode = MODE_NORM; break;
1863 case 35: // lbzu
1864 transfer_type = TYPE_LOAD; transfer_size = SIZE_BYTE; addr_mode = MODE_U; break;
1865 case 36: // stw
1866 transfer_type = TYPE_STORE; transfer_size = SIZE_WORD; addr_mode = MODE_NORM; break;
1867 case 37: // stwu
1868 transfer_type = TYPE_STORE; transfer_size = SIZE_WORD; addr_mode = MODE_U; break;
1869 case 38: // stb
1870 transfer_type = TYPE_STORE; transfer_size = SIZE_BYTE; addr_mode = MODE_NORM; break;
1871 case 39: // stbu
1872 transfer_type = TYPE_STORE; transfer_size = SIZE_BYTE; addr_mode = MODE_U; break;
1873 case 40: // lhz
1874 transfer_type = TYPE_LOAD; transfer_size = SIZE_HALFWORD; addr_mode = MODE_NORM; break;
1875 case 41: // lhzu
1876 transfer_type = TYPE_LOAD; transfer_size = SIZE_HALFWORD; addr_mode = MODE_U; break;
1877 case 42: // lha
1878 transfer_type = TYPE_LOAD; transfer_size = SIZE_HALFWORD; addr_mode = MODE_NORM; break;
1879 case 43: // lhau
1880 transfer_type = TYPE_LOAD; transfer_size = SIZE_HALFWORD; addr_mode = MODE_U; break;
1881 case 44: // sth
1882 transfer_type = TYPE_STORE; transfer_size = SIZE_HALFWORD; addr_mode = MODE_NORM; break;
1883 case 45: // sthu
1884 transfer_type = TYPE_STORE; transfer_size = SIZE_HALFWORD; addr_mode = MODE_U; break;
1885 #if EMULATE_UNALIGNED_LOADSTORE_MULTIPLE
1886 case 46: // lmw
1887 if ((addr % 4) != 0) {
1888 uint32 ea = addr;
1889 D(bug("WARNING: unaligned lmw to EA=%08x from IP=%08x\n", ea, r->pc()));
1890 for (int i = rd; i <= 31; i++) {
1891 r->gpr(i) = ReadMacInt32(ea);
1892 ea += 4;
1893 }
1894 r->pc() += 4;
1895 goto rti;
1896 }
1897 break;
1898 case 47: // stmw
1899 if ((addr % 4) != 0) {
1900 uint32 ea = addr;
1901 D(bug("WARNING: unaligned stmw to EA=%08x from IP=%08x\n", ea, r->pc()));
1902 for (int i = rd; i <= 31; i++) {
1903 WriteMacInt32(ea, r->gpr(i));
1904 ea += 4;
1905 }
1906 r->pc() += 4;
1907 goto rti;
1908 }
1909 break;
1910 #endif
1911 }
1912
1913 // Ignore ROM writes (including to the zero page, which is read-only)
1914 if (transfer_type == TYPE_STORE &&
1915 ((addr >= ROMBase && addr < ROMBase + ROM_SIZE) ||
1916 (addr >= SheepMem::ZeroPage() && addr < SheepMem::ZeroPage() + SheepMem::PageSize()))) {
1917 // D(bug("WARNING: %s write access to ROM at %08lx, pc %08lx\n", transfer_size == SIZE_BYTE ? "Byte" : transfer_size == SIZE_HALFWORD ? "Halfword" : "Word", addr, r->pc()));
1918 if (addr_mode == MODE_U || addr_mode == MODE_UX)
1919 r->gpr(ra) = addr;
1920 r->pc() += 4;
1921 goto rti;
1922 }
1923
1924 // Ignore illegal memory accesses?
1925 if (PrefsFindBool("ignoresegv")) {
1926 if (addr_mode == MODE_U || addr_mode == MODE_UX)
1927 r->gpr(ra) = addr;
1928 if (transfer_type == TYPE_LOAD)
1929 r->gpr(rd) = 0;
1930 r->pc() += 4;
1931 goto rti;
1932 }
1933
1934 // In GUI mode, show error alert
1935 if (!PrefsFindBool("nogui")) {
1936 char str[256];
1937 if (transfer_type == TYPE_LOAD || transfer_type == TYPE_STORE)
1938 sprintf(str, GetString(STR_MEM_ACCESS_ERR), transfer_size == SIZE_BYTE ? "byte" : transfer_size == SIZE_HALFWORD ? "halfword" : "word", transfer_type == TYPE_LOAD ? GetString(STR_MEM_ACCESS_READ) : GetString(STR_MEM_ACCESS_WRITE), addr, r->pc(), r->gpr(24), r->gpr(1));
1939 else
1940 sprintf(str, GetString(STR_UNKNOWN_SEGV_ERR), r->pc(), r->gpr(24), r->gpr(1), opcode);
1941 ErrorAlert(str);
1942 QuitEmulator();
1943 return;
1944 }
1945 }
1946
1947 // For all other errors, jump into debugger (sort of...)
1948 crash_reason = (sig == SIGBUS) ? "SIGBUS" : "SIGSEGV";
1949 if (!ready_for_signals) {
1950 printf("%s\n");
1951 printf(" sigcontext %p, machine_regs %p\n", scp, r);
1952 printf(
1953 " pc %08lx lr %08lx ctr %08lx msr %08lx\n"
1954 " xer %08lx cr %08lx \n"
1955 " r0 %08lx r1 %08lx r2 %08lx r3 %08lx\n"
1956 " r4 %08lx r5 %08lx r6 %08lx r7 %08lx\n"
1957 " r8 %08lx r9 %08lx r10 %08lx r11 %08lx\n"
1958 " r12 %08lx r13 %08lx r14 %08lx r15 %08lx\n"
1959 " r16 %08lx r17 %08lx r18 %08lx r19 %08lx\n"
1960 " r20 %08lx r21 %08lx r22 %08lx r23 %08lx\n"
1961 " r24 %08lx r25 %08lx r26 %08lx r27 %08lx\n"
1962 " r28 %08lx r29 %08lx r30 %08lx r31 %08lx\n",
1963 crash_reason,
1964 r->pc(), r->lr(), r->ctr(), r->msr(),
1965 r->xer(), r->cr(),
1966 r->gpr(0), r->gpr(1), r->gpr(2), r->gpr(3),
1967 r->gpr(4), r->gpr(5), r->gpr(6), r->gpr(7),
1968 r->gpr(8), r->gpr(9), r->gpr(10), r->gpr(11),
1969 r->gpr(12), r->gpr(13), r->gpr(14), r->gpr(15),
1970 r->gpr(16), r->gpr(17), r->gpr(18), r->gpr(19),
1971 r->gpr(20), r->gpr(21), r->gpr(22), r->gpr(23),
1972 r->gpr(24), r->gpr(25), r->gpr(26), r->gpr(27),
1973 r->gpr(28), r->gpr(29), r->gpr(30), r->gpr(31));
1974 exit(1);
1975 QuitEmulator();
1976 return;
1977 } else {
1978 // We crashed. Save registers, tell tick thread and loop forever
1979 build_sigregs(&sigsegv_regs, r);
1980 emul_thread_fatal = true;
1981 for (;;) ;
1982 }
1983 rti:;
1984 }
1985
1986
1987 /*
1988 * SIGILL handler
1989 */
1990
1991 static void sigill_handler(int sig, siginfo_t *sip, void *scp)
1992 {
1993 machine_regs *r = MACHINE_REGISTERS(scp);
1994 char str[256];
1995
1996 #ifdef SYSTEM_CLOBBERS_R2
1997 // Restore pointer to Thread Local Storage
1998 set_r2(TOC);
1999 #endif
2000 #ifdef SYSTEM_CLOBBERS_R13
2001 // Restore pointer to .sdata section
2002 set_r13(R13);
2003 #endif
2004
2005 // Fault in Mac ROM or RAM?
2006 bool mac_fault = (r->pc() >= ROMBase) && (r->pc() < (ROMBase + ROM_AREA_SIZE)) || (r->pc() >= RAMBase) && (r->pc() < (RAMBase + RAMSize));
2007 if (mac_fault) {
2008
2009 // Get opcode and divide into fields
2010 uint32 opcode = *((uint32 *)r->pc());
2011 uint32 primop = opcode >> 26;
2012 uint32 exop = (opcode >> 1) & 0x3ff;
2013 uint32 ra = (opcode >> 16) & 0x1f;
2014 uint32 rb = (opcode >> 11) & 0x1f;
2015 uint32 rd = (opcode >> 21) & 0x1f;
2016 int32 imm = (int16)(opcode & 0xffff);
2017
2018 switch (primop) {
2019 case 9: // POWER instructions
2020 case 22:
2021 power_inst: sprintf(str, GetString(STR_POWER_INSTRUCTION_ERR), r->pc(), r->gpr(1), opcode);
2022 ErrorAlert(str);
2023 QuitEmulator();
2024 return;
2025
2026 case 31:
2027 switch (exop) {
2028 case 83: // mfmsr
2029 r->gpr(rd) = 0xf072;
2030 r->pc() += 4;
2031 goto rti;
2032
2033 case 210: // mtsr
2034 case 242: // mtsrin
2035 case 306: // tlbie
2036 r->pc() += 4;
2037 goto rti;
2038
2039 case 339: { // mfspr
2040 int spr = ra | (rb << 5);
2041 switch (spr) {
2042 case 0: // MQ
2043 case 22: // DEC
2044 case 952: // MMCR0
2045 case 953: // PMC1
2046 case 954: // PMC2
2047 case 955: // SIA
2048 case 956: // MMCR1
2049 case 957: // PMC3
2050 case 958: // PMC4
2051 case 959: // SDA
2052 r->pc() += 4;
2053 goto rti;
2054 case 25: // SDR1
2055 r->gpr(rd) = 0xdead001f;
2056 r->pc() += 4;
2057 goto rti;
2058 case 287: // PVR
2059 r->gpr(rd) = PVR;
2060 r->pc() += 4;
2061 goto rti;
2062 }
2063 break;
2064 }
2065
2066 case 467: { // mtspr
2067 int spr = ra | (rb << 5);
2068 switch (spr) {
2069 case 0: // MQ
2070 case 22: // DEC
2071 case 275: // SPRG3
2072 case 528: // IBAT0U
2073 case 529: // IBAT0L
2074 case 530: // IBAT1U
2075 case 531: // IBAT1L
2076 case 532: // IBAT2U
2077 case 533: // IBAT2L
2078 case 534: // IBAT3U
2079 case 535: // IBAT3L
2080 case 536: // DBAT0U
2081 case 537: // DBAT0L
2082 case 538: // DBAT1U
2083 case 539: // DBAT1L
2084 case 540: // DBAT2U
2085 case 541: // DBAT2L
2086 case 542: // DBAT3U
2087 case 543: // DBAT3L
2088 case 952: // MMCR0
2089 case 953: // PMC1
2090 case 954: // PMC2
2091 case 955: // SIA
2092 case 956: // MMCR1
2093 case 957: // PMC3
2094 case 958: // PMC4
2095 case 959: // SDA
2096 r->pc() += 4;
2097 goto rti;
2098 }
2099 break;
2100 }
2101
2102 case 29: case 107: case 152: case 153: // POWER instructions
2103 case 184: case 216: case 217: case 248:
2104 case 264: case 277: case 331: case 360:
2105 case 363: case 488: case 531: case 537:
2106 case 541: case 664: case 665: case 696:
2107 case 728: case 729: case 760: case 920:
2108 case 921: case 952:
2109 goto power_inst;
2110 }
2111 }
2112
2113 // In GUI mode, show error alert
2114 if (!PrefsFindBool("nogui")) {
2115 sprintf(str, GetString(STR_UNKNOWN_SEGV_ERR), r->pc(), r->gpr(24), r->gpr(1), opcode);
2116 ErrorAlert(str);
2117 QuitEmulator();
2118 return;
2119 }
2120 }
2121
2122 // For all other errors, jump into debugger (sort of...)
2123 crash_reason = "SIGILL";
2124 if (!ready_for_signals) {
2125 printf("%s\n");
2126 printf(" sigcontext %p, machine_regs %p\n", scp, r);
2127 printf(
2128 " pc %08lx lr %08lx ctr %08lx msr %08lx\n"
2129 " xer %08lx cr %08lx \n"
2130 " r0 %08lx r1 %08lx r2 %08lx r3 %08lx\n"
2131 " r4 %08lx r5 %08lx r6 %08lx r7 %08lx\n"
2132 " r8 %08lx r9 %08lx r10 %08lx r11 %08lx\n"
2133 " r12 %08lx r13 %08lx r14 %08lx r15 %08lx\n"
2134 " r16 %08lx r17 %08lx r18 %08lx r19 %08lx\n"
2135 " r20 %08lx r21 %08lx r22 %08lx r23 %08lx\n"
2136 " r24 %08lx r25 %08lx r26 %08lx r27 %08lx\n"
2137 " r28 %08lx r29 %08lx r30 %08lx r31 %08lx\n",
2138 crash_reason,
2139 r->pc(), r->lr(), r->ctr(), r->msr(),
2140 r->xer(), r->cr(),
2141 r->gpr(0), r->gpr(1), r->gpr(2), r->gpr(3),
2142 r->gpr(4), r->gpr(5), r->gpr(6), r->gpr(7),
2143 r->gpr(8), r->gpr(9), r->gpr(10), r->gpr(11),
2144 r->gpr(12), r->gpr(13), r->gpr(14), r->gpr(15),
2145 r->gpr(16), r->gpr(17), r->gpr(18), r->gpr(19),
2146 r->gpr(20), r->gpr(21), r->gpr(22), r->gpr(23),
2147 r->gpr(24), r->gpr(25), r->gpr(26), r->gpr(27),
2148 r->gpr(28), r->gpr(29), r->gpr(30), r->gpr(31));
2149 exit(1);
2150 QuitEmulator();
2151 return;
2152 } else {
2153 // We crashed. Save registers, tell tick thread and loop forever
2154 build_sigregs(&sigsegv_regs, r);
2155 emul_thread_fatal = true;
2156 for (;;) ;
2157 }
2158 rti:;
2159 }
2160 #endif
2161
2162
2163 /*
2164 * Helpers to share 32-bit addressable data with MacOS
2165 */
2166
2167 bool SheepMem::Init(void)
2168 {
2169 // Size of a native page
2170 page_size = getpagesize();
2171
2172 // Allocate SheepShaver globals
2173 proc = base;
2174 if (vm_mac_acquire_fixed(base, size) < 0)
2175 return false;
2176
2177 // Allocate page with all bits set to 0, right in the middle
2178 // This is also used to catch undesired overlaps between proc and data areas
2179 zero_page = proc + (size / 2);
2180 Mac_memset(zero_page, 0, page_size);
2181 if (vm_protect(Mac2HostAddr(zero_page), page_size, VM_PAGE_READ) < 0)
2182 return false;
2183
2184 #if EMULATED_PPC
2185 // Allocate alternate stack for PowerPC interrupt routine
2186 sig_stack = base + size;
2187 if (vm_mac_acquire_fixed(sig_stack, SIG_STACK_SIZE) < 0)
2188 return false;
2189 #endif
2190
2191 data = base + size;
2192 return true;
2193 }
2194
2195 void SheepMem::Exit(void)
2196 {
2197 if (data) {
2198 // Delete SheepShaver globals
2199 vm_mac_release(base, size);
2200
2201 #if EMULATED_PPC
2202 // Delete alternate stack for PowerPC interrupt routine
2203 vm_mac_release(sig_stack, SIG_STACK_SIZE);
2204 #endif
2205 }
2206 }
2207
2208
2209 /*
2210 * Display alert
2211 */
2212
2213 #ifdef ENABLE_GTK
2214 static void dl_destroyed(void)
2215 {
2216 gtk_main_quit();
2217 }
2218
2219 static void dl_quit(GtkWidget *dialog)
2220 {
2221 gtk_widget_destroy(dialog);
2222 }
2223
2224 void display_alert(int title_id, int prefix_id, int button_id, const char *text)
2225 {
2226 char str[256];
2227 sprintf(str, GetString(prefix_id), text);
2228
2229 GtkWidget *dialog = gtk_dialog_new();
2230 gtk_window_set_title(GTK_WINDOW(dialog), GetString(title_id));
2231 gtk_container_border_width(GTK_CONTAINER(dialog), 5);
2232 gtk_widget_set_uposition(GTK_WIDGET(dialog), 100, 150);
2233 gtk_signal_connect(GTK_OBJECT(dialog), "destroy", GTK_SIGNAL_FUNC(dl_destroyed), NULL);
2234
2235 GtkWidget *label = gtk_label_new(str);
2236 gtk_widget_show(label);
2237 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), label, TRUE, TRUE, 0);
2238
2239 GtkWidget *button = gtk_button_new_with_label(GetString(button_id));
2240 gtk_widget_show(button);
2241 gtk_signal_connect_object(GTK_OBJECT(button), "clicked", GTK_SIGNAL_FUNC(dl_quit), GTK_OBJECT(dialog));
2242 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area), button, FALSE, FALSE, 0);
2243 GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
2244 gtk_widget_grab_default(button);
2245 gtk_widget_show(dialog);
2246
2247 gtk_main();
2248 }
2249 #endif
2250
2251
2252 /*
2253 * Display error alert
2254 */
2255
2256 void ErrorAlert(const char *text)
2257 {
2258 if (gui_connection) {
2259 if (rpc_method_invoke(gui_connection, RPC_METHOD_ERROR_ALERT, RPC_TYPE_STRING, text, RPC_TYPE_INVALID) == RPC_ERROR_NO_ERROR &&
2260 rpc_method_wait_for_reply(gui_connection, RPC_TYPE_INVALID) == RPC_ERROR_NO_ERROR)
2261 return;
2262 }
2263 #if defined(ENABLE_GTK) && !defined(USE_SDL_VIDEO)
2264 if (PrefsFindBool("nogui") || x_display == NULL) {
2265 printf(GetString(STR_SHELL_ERROR_PREFIX), text);
2266 return;
2267 }
2268 VideoQuitFullScreen();
2269 display_alert(STR_ERROR_ALERT_TITLE, STR_GUI_ERROR_PREFIX, STR_QUIT_BUTTON, text);
2270 #else
2271 printf(GetString(STR_SHELL_ERROR_PREFIX), text);
2272 #endif
2273 }
2274
2275
2276 /*
2277 * Display warning alert
2278 */
2279
2280 void WarningAlert(const char *text)
2281 {
2282 if (gui_connection) {
2283 if (rpc_method_invoke(gui_connection, RPC_METHOD_WARNING_ALERT, RPC_TYPE_STRING, text, RPC_TYPE_INVALID) == RPC_ERROR_NO_ERROR &&
2284 rpc_method_wait_for_reply(gui_connection, RPC_TYPE_INVALID) == RPC_ERROR_NO_ERROR)
2285 return;
2286 }
2287 #if defined(ENABLE_GTK) && !defined(USE_SDL_VIDEO)
2288 if (PrefsFindBool("nogui") || x_display == NULL) {
2289 printf(GetString(STR_SHELL_WARNING_PREFIX), text);
2290 return;
2291 }
2292 display_alert(STR_WARNING_ALERT_TITLE, STR_GUI_WARNING_PREFIX, STR_OK_BUTTON, text);
2293 #else
2294 printf(GetString(STR_SHELL_WARNING_PREFIX), text);
2295 #endif
2296 }
2297
2298
2299 /*
2300 * Display choice alert
2301 */
2302
2303 bool ChoiceAlert(const char *text, const char *pos, const char *neg)
2304 {
2305 printf(GetString(STR_SHELL_WARNING_PREFIX), text);
2306 return false; //!!
2307 }