ViewVC Help
View File | Revision Log | Show Annotations | Revision Graph | Root Listing
root/cebix/SheepShaver/src/Unix/main_unix.cpp
(Generate patch)

Comparing SheepShaver/src/Unix/main_unix.cpp (file contents):
Revision 1.35 by gbeauche, 2004-05-20T12:33:57Z vs.
Revision 1.98 by asvitkine, 2011-12-30T17:38:39Z

# Line 1 | Line 1
1   /*
2   *  main_unix.cpp - Emulation core, Unix implementation
3   *
4 < *  SheepShaver (C) 1997-2004 Christian Bauer and Marc Hellwig
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
# Line 27 | Line 27
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 no TOC under Linux; r2 is free for the user
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 < *    - As there is no TOC, there are also no TVECTs under Linux;
37 < *      function pointers point directly to the function code
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
# Line 65 | Line 67
67   *  ExecutePPC (or any function that might cause a mode switch). The signal
68   *  stack is restored before exiting the SIGUSR2 handler.
69   *
70 < *  There is apparently another problem when processing signals. In
71 < *  fullscreen mode, we get quick updates of the mouse position. This
72 < *  causes an increased number of calls to TriggerInterrupt(). And,
73 < *  since IRQ_NEST is not fully handled atomically, nested calls to
74 < *  ppc_interrupt() may cause stack corruption to eventually crash the
75 < *  emulator.
74 < *
75 < *  FIXME:
76 < *  The current solution is to allocate another signal stack when
77 < *  processing ppc_interrupt(). However, it may be better to detect
78 < *  the INTFLAG_ADB case and handle it specifically with some extra mutex?
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!)
# Line 92 | Line 89
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"
# Line 105 | Line 103
103   #include "xpram.h"
104   #include "timer.h"
105   #include "adb.h"
108 #include "sony.h"
109 #include "disk.h"
110 #include "cdrom.h"
111 #include "scsi.h"
106   #include "video.h"
113 #include "audio.h"
114 #include "ether.h"
115 #include "serial.h"
116 #include "clip.h"
117 #include "extfs.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 "thunks.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>
# Line 136 | Line 136
136   #ifdef ENABLE_XF86_DGA
137   #include <X11/Xlib.h>
138   #include <X11/Xutil.h>
139 < #include <X11/extensions/xf86dga.h>
139 > #include <X11/extensions/Xxf86dga.h>
140   #endif
141  
142   #ifdef ENABLE_MON
# Line 156 | Line 156
156   // Interrupts in native mode?
157   #define INTERRUPTS_IN_NATIVE_MODE 1
158  
159 // Number of alternate stacks for signal handlers?
160 #define SIG_STACK_COUNT 4
161
159  
160   // Constants
161   const char ROM_FILE_NAME[] = "ROM";
162   const char ROM_FILE_NAME2[] = "Mac OS ROM";
163  
164 < const uintptr RAM_BASE = 0x20000000;            // Base address of RAM
165 < const uint32 SIG_STACK_SIZE = 0x10000;          // Size of signal stack
166 <
167 <
168 < #if !EMULATED_PPC
169 < struct sigregs {
170 <        uint32 nip;
174 <        uint32 link;
175 <        uint32 ctr;
176 <        uint32 msr;
177 <        uint32 xer;
178 <        uint32 ccr;
179 <        uint32 gpr[32];
180 < };
181 <
182 < #if defined(__linux__)
183 < #include <sys/ucontext.h>
184 < #define MACHINE_REGISTERS(scp)  ((machine_regs *)(((ucontext_t *)scp)->uc_mcontext.regs))
185 <
186 < struct machine_regs : public pt_regs
187 < {
188 <        u_long & cr()                           { return pt_regs::ccr; }
189 <        uint32 cr() const                       { return pt_regs::ccr; }
190 <        uint32 lr() const                       { return pt_regs::link; }
191 <        uint32 ctr() const                      { return pt_regs::ctr; }
192 <        uint32 xer() const                      { return pt_regs::xer; }
193 <        uint32 msr() const                      { return pt_regs::msr; }
194 <        uint32 dar() const                      { return pt_regs::dar; }
195 <        u_long & pc()                           { return pt_regs::nip; }
196 <        uint32 pc() const                       { return pt_regs::nip; }
197 <        u_long & gpr(int i)                     { return pt_regs::gpr[i]; }
198 <        uint32 gpr(int i) const         { return pt_regs::gpr[i]; }
199 < };
200 < #endif
201 <
202 < #if defined(__APPLE__) && defined(__MACH__)
203 < #include <sys/signal.h>
204 < extern "C" int sigaltstack(const struct sigaltstack *ss, struct sigaltstack *oss);
205 <
206 < #include <sys/ucontext.h>
207 < #define MACHINE_REGISTERS(scp)  ((machine_regs *)(((ucontext_t *)scp)->uc_mcontext))
208 <
209 < struct machine_regs : public mcontext
210 < {
211 <        uint32 & cr()                           { return ss.cr; }
212 <        uint32 cr() const                       { return ss.cr; }
213 <        uint32 lr() const                       { return ss.lr; }
214 <        uint32 ctr() const                      { return ss.ctr; }
215 <        uint32 xer() const                      { return ss.xer; }
216 <        uint32 msr() const                      { return ss.srr1; }
217 <        uint32 dar() const                      { return es.dar; }
218 <        uint32 & pc()                           { return ss.srr0; }
219 <        uint32 pc() const                       { return ss.srr0; }
220 <        uint32 & gpr(int i)                     { return (&ss.r0)[i]; }
221 <        uint32 gpr(int i) const         { return (&ss.r0)[i]; }
222 < };
223 < #endif
224 <
225 < static void build_sigregs(sigregs *srp, machine_regs *mrp)
226 < {
227 <        srp->nip = mrp->pc();
228 <        srp->link = mrp->lr();
229 <        srp->ctr = mrp->ctr();
230 <        srp->msr = mrp->msr();
231 <        srp->xer = mrp->xer();
232 <        srp->ccr = mrp->cr();
233 <        for (int i = 0; i < 32; i++)
234 <                srp->gpr[i] = mrp->gpr(i);
235 < }
236 <
237 < static struct sigaltstack sig_stacks[SIG_STACK_COUNT];  // Stacks for signal handlers
238 < static int sig_stack_id = 0;                                                    // Stack slot currently used
239 <
240 < static inline void sig_stack_acquire(void)
241 < {
242 <        if (++sig_stack_id == SIG_STACK_COUNT) {
243 <                printf("FATAL: signal stack overflow\n");
244 <                return;
245 <        }
246 <        sigaltstack(&sig_stacks[sig_stack_id], NULL);
247 < }
248 <
249 < static inline void sig_stack_release(void)
250 < {
251 <        if (--sig_stack_id < 0) {
252 <                printf("FATAL: signal stack underflow\n");
253 <                return;
254 <        }
255 <        sigaltstack(&sig_stacks[sig_stack_id], NULL);
256 < }
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;                              // Small data pointer (r13)
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  
# Line 302 | Line 229 | static uintptr sig_stack = 0;                          // Stac
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::top = 0;                                      // Top of SheepShaver data (stack like storage)
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);
# Line 322 | Line 257 | static void *tick_func(void *arg);
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 < static void sigusr2_handler(int sig, siginfo_t *sip, void *scp);
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
# Line 331 | Line 268 | static void sigill_handler(int sig, sigi
268  
269   // From asm_linux.S
270   #if !EMULATED_PPC
334 extern "C" void *get_toc(void);
271   extern "C" void *get_sp(void);
272 < extern "C" void flush_icache_range(void *start, void *end);
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);
# Line 397 | Line 337 | int atomic_or(int *var, int v)
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  
# Line 409 | Line 369 | static void usage(const char *prg_name)
369          exit(0);
370   }
371  
372 < int main(int argc, char **argv)
372 > static bool valid_vmdir(const char *path)
373   {
374 <        char str[256];
375 <        uint32 *boot_globs;
376 <        int16 i16;
377 <        int rom_fd;
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 <        const char *rom_path;
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 >                sprintf(str, GetString(STR_PROC_CPUINFO_WARN), strerror(errno));
531 >                WarningAlert(str);
532 >        }
533 >
534 >        // Get actual bus frequency
535 >        proc_file = fopen("/proc/device-tree/clock-frequency", "r");
536 >        if (proc_file) {
537 >                union { uint8 b[4]; uint32 l; } value;
538 >                if (fread(value.b, sizeof(value), 1, proc_file) == 1)
539 >                        BusClockSpeed = value.l;
540 >                fclose(proc_file);
541 >        }
542 >
543 >        // Get actual timebase frequency
544 >        TimebaseSpeed = BusClockSpeed / 4;
545 >        DIR *cpus_dir;
546 >        if ((cpus_dir = opendir("/proc/device-tree/cpus")) != NULL) {
547 >                struct dirent *cpu_entry;
548 >                while ((cpu_entry = readdir(cpus_dir)) != NULL) {
549 >                        if (strstr(cpu_entry->d_name, "PowerPC,") == cpu_entry->d_name) {
550 >                                char timebase_freq_node[256];
551 >                                sprintf(timebase_freq_node, "/proc/device-tree/cpus/%s/timebase-frequency", cpu_entry->d_name);
552 >                                proc_file = fopen(timebase_freq_node, "r");
553 >                                if (proc_file) {
554 >                                        union { uint8 b[4]; uint32 l; } value;
555 >                                        if (fread(value.b, sizeof(value), 1, proc_file) == 1)
556 >                                                TimebaseSpeed = value.l;
557 >                                        fclose(proc_file);
558 >                                }
559 >                        }
560 >                }
561 >                closedir(cpus_dir);
562 >        }
563 > #endif
564 >
565 >        // Remap any newer G4/G5 processor to plain G4 for compatibility
566 >        switch (PVR >> 16) {
567 >        case 0x8000:                            // 7450
568 >        case 0x8001:                            // 7455
569 >        case 0x8002:                            // 7457
570 >        case 0x8003:                            // 7447A
571 >        case 0x8004:                            // 7448
572 >        case 0x0039:                            //  970
573 >        case 0x003c:                            //  970FX
574 >        case 0x0044:                            //  970MP
575 >                PVR = 0x000c0000;               // 7400
576 >                break;
577 >        }
578 >        D(bug("PVR: %08x (assumed)\n", PVR));
579 > }
580 >
581 > static bool load_mac_rom(void)
582 > {
583          uint32 rom_size, actual;
584          uint8 *rom_tmp;
585 <        time_t now, expire;
585 >        const char *rom_path = PrefsFindString("rom");
586 >        int rom_fd = open(rom_path && *rom_path ? rom_path : ROM_FILE_NAME, O_RDONLY);
587 >        if (rom_fd < 0) {
588 >                rom_fd = open(ROM_FILE_NAME2, O_RDONLY);
589 >                if (rom_fd < 0) {
590 >                        ErrorAlert(GetString(STR_NO_ROM_FILE_ERR));
591 >                        return false;
592 >                }
593 >        }
594 >        printf("%s", GetString(STR_READING_ROM_FILE));
595 >        rom_size = lseek(rom_fd, 0, SEEK_END);
596 >        lseek(rom_fd, 0, SEEK_SET);
597 >        rom_tmp = new uint8[ROM_SIZE];
598 >        actual = read(rom_fd, (void *)rom_tmp, ROM_SIZE);
599 >        close(rom_fd);
600 >        
601 >        // Decode Mac ROM
602 >        if (!DecodeROM(rom_tmp, actual)) {
603 >                if (rom_size != 4*1024*1024) {
604 >                        ErrorAlert(GetString(STR_ROM_SIZE_ERR));
605 >                        return false;
606 >                } else {
607 >                        ErrorAlert(GetString(STR_ROM_FILE_READ_ERR));
608 >                        return false;
609 >                }
610 >        }
611 >        delete[] rom_tmp;
612 >        return true;
613 > }
614 >
615 > static bool install_signal_handlers(void)
616 > {
617 >        char str[256];
618 > #if !EMULATED_PPC
619 >        // Create and install stacks for signal handlers
620 >        sig_stack.ss_sp = malloc(SIG_STACK_SIZE);
621 >        D(bug("Signal stack at %p\n", sig_stack.ss_sp));
622 >        if (sig_stack.ss_sp == NULL) {
623 >                ErrorAlert(GetString(STR_NOT_ENOUGH_MEMORY_ERR));
624 >                return false;
625 >        }
626 >        sig_stack.ss_flags = 0;
627 >        sig_stack.ss_size = SIG_STACK_SIZE;
628 >        if (sigaltstack(&sig_stack, NULL) < 0) {
629 >                sprintf(str, GetString(STR_SIGALTSTACK_ERR), strerror(errno));
630 >                ErrorAlert(str);
631 >                return false;
632 >        }
633 >        extra_stack.ss_sp = malloc(SIG_STACK_SIZE);
634 >        D(bug("Extra stack at %p\n", extra_stack.ss_sp));
635 >        if (extra_stack.ss_sp == NULL) {
636 >                ErrorAlert(GetString(STR_NOT_ENOUGH_MEMORY_ERR));
637 >                return false;
638 >        }
639 >        extra_stack.ss_flags = 0;
640 >        extra_stack.ss_size = SIG_STACK_SIZE;
641 >
642 >        // Install SIGSEGV and SIGBUS handlers
643 >        sigemptyset(&sigsegv_action.sa_mask);   // Block interrupts during SEGV handling
644 >        sigaddset(&sigsegv_action.sa_mask, SIGUSR2);
645 >        sigsegv_action.sa_sigaction = sigsegv_handler;
646 >        sigsegv_action.sa_flags = SA_ONSTACK | SA_SIGINFO;
647 > #ifdef HAVE_SIGNAL_SA_RESTORER
648 >        sigsegv_action.sa_restorer = NULL;
649 > #endif
650 >        if (sigaction(SIGSEGV, &sigsegv_action, NULL) < 0) {
651 >                sprintf(str, GetString(STR_SIG_INSTALL_ERR), "SIGSEGV", strerror(errno));
652 >                ErrorAlert(str);
653 >                return false;
654 >        }
655 >        if (sigaction(SIGBUS, &sigsegv_action, NULL) < 0) {
656 >                sprintf(str, GetString(STR_SIG_INSTALL_ERR), "SIGBUS", strerror(errno));
657 >                ErrorAlert(str);
658 >                return false;
659 >        }
660 > #else
661 >        // Install SIGSEGV handler for CPU emulator
662 >        if (!sigsegv_install_handler(sigsegv_handler)) {
663 >                sprintf(str, GetString(STR_SIG_INSTALL_ERR), "SIGSEGV", strerror(errno));
664 >                ErrorAlert(str);
665 >                return false;
666 >        }
667 > #endif
668 >        return true;
669 > }
670 >
671 > static bool init_sdl()
672 > {
673 >        int sdl_flags = 0;
674 > #ifdef USE_SDL_VIDEO
675 >        sdl_flags |= SDL_INIT_VIDEO;
676 > #endif
677 > #ifdef USE_SDL_AUDIO
678 >        sdl_flags |= SDL_INIT_AUDIO;
679 > #endif
680 >        assert(sdl_flags != 0);
681 >
682 > #ifdef USE_SDL_VIDEO
683 >        // Don't let SDL block the screensaver
684 >        setenv("SDL_VIDEO_ALLOW_SCREENSAVER", "1", TRUE);
685 >
686 >        // Make SDL pass through command-clicks and option-clicks unaltered
687 >        setenv("SDL_HAS3BUTTONMOUSE", "1", TRUE);
688 > #endif
689 >
690 >        if (SDL_Init(sdl_flags) == -1) {
691 >                char str[256];
692 >                sprintf(str, "Could not initialize SDL: %s.\n", SDL_GetError());
693 >                ErrorAlert(str);
694 >                return false;
695 >        }
696 >        atexit(SDL_Quit);
697 >
698 >        // Don't let SDL catch SIGINT and SIGTERM signals
699 >        signal(SIGINT, SIG_DFL);
700 >        signal(SIGTERM, SIG_DFL);
701 >        return true;
702 > }
703 >
704 > int main(int argc, char **argv)
705 > {
706 >        char str[256];
707 >        bool memory_mapped_from_zero, ram_rom_areas_contiguous;
708 >        const char *vmdir = NULL;
709  
710          // Initialize variables
711          RAMBase = 0;
# Line 430 | Line 716 | int main(int argc, char **argv)
716          printf(" %s\n", GetString(STR_ABOUT_TEXT2));
717  
718   #if !EMULATED_PPC
719 + #ifdef SYSTEM_CLOBBERS_R2
720          // Get TOC pointer
721 <        TOC = get_toc();
721 >        TOC = get_r2();
722 > #endif
723 > #ifdef SYSTEM_CLOBBERS_R13
724 >        // Get r13 register
725 >        R13 = get_r13();
726   #endif
436
437 #ifdef ENABLE_GTK
438        // Init GTK
439        gtk_set_locale();
440        gtk_init(&argc, &argv);
727   #endif
442
443        // Read preferences
444        PrefsInit(argc, argv);
728  
729          // Parse command line arguments
730          for (int i=1; i<argc; i++) {
731                  if (strcmp(argv[i], "--help") == 0) {
732                          usage(argv[0]);
733 + #ifndef USE_SDL_VIDEO
734                  } else if (strcmp(argv[i], "--display") == 0) {
735                          i++;
736                          if (i < argc)
737                                  x_display_name = strdup(argv[i]);
738 <                } else if (argv[i][0] == '-') {
738 > #endif
739 >                } else if (strcmp(argv[i], "--gui-connection") == 0) {
740 >                        argv[i++] = NULL;
741 >                        if (i < argc) {
742 >                                gui_connection_path = argv[i];
743 >                                argv[i] = NULL;
744 >                        }
745 >                } else if (valid_vmdir(argv[i])) {
746 >                        vmdir = argv[i];
747 >                        argv[i] = NULL;
748 >                        printf("Using %s as vmdir.\n", vmdir);
749 >                        if (chdir(vmdir)) {
750 >                                printf("Failed to chdir to %s. Good bye.", vmdir);
751 >                                exit(1);
752 >                        }
753 >                        break;
754 >                }
755 >        }
756 >
757 >        // Remove processed arguments
758 >        for (int i=1; i<argc; i++) {
759 >                int k;
760 >                for (k=i; k<argc; k++)
761 >                        if (argv[k] != NULL)
762 >                                break;
763 >                if (k > i) {
764 >                        k -= i;
765 >                        for (int j=i+k; j<argc; j++)
766 >                                argv[j-k] = argv[j];
767 >                        argc -= k;
768 >                }
769 >        }
770 >
771 >        // Connect to the external GUI
772 >        if (gui_connection_path) {
773 >                if ((gui_connection = rpc_init_client(gui_connection_path)) == NULL) {
774 >                        fprintf(stderr, "Failed to initialize RPC client connection to the GUI\n");
775 >                        return 1;
776 >                }
777 >        }
778 >
779 > #ifdef ENABLE_GTK
780 >        if (!gui_connection) {
781 >                // Init GTK
782 >                gtk_set_locale();
783 >                gtk_init(&argc, &argv);
784 >        }
785 > #endif
786 >
787 >        // Read preferences
788 >        PrefsInit(vmdir, argc, argv);
789 >
790 >        // Any command line arguments left?
791 >        for (int i=1; i<argc; i++) {
792 >                if (argv[i][0] == '-') {
793                          fprintf(stderr, "Unrecognized option '%s'\n", argv[i]);
794                          usage(argv[0]);
795                  }
796          }
797  
798 + #ifdef USE_SDL
799 +        // Initialize SDL system
800 +        if (!init_sdl())
801 +                goto quit;
802 + #endif
803 +
804 + #ifndef USE_SDL_VIDEO
805          // Open display
806          x_display = XOpenDisplay(x_display_name);
807          if (x_display == NULL) {
# Line 470 | Line 815 | int main(int argc, char **argv)
815          // Fork out, so we can return from fullscreen mode when things get ugly
816          XF86DGAForkApp(DefaultScreen(x_display));
817   #endif
818 + #endif
819  
820   #ifdef ENABLE_MON
821          // Initialize mon
822          mon_init();
823   #endif
824  
825 <        // Get system info
826 <        PVR = 0x00040000;                       // Default: 604
827 <        CPUClockSpeed = 100000000;      // Default: 100MHz
482 <        BusClockSpeed = 100000000;      // Default: 100MHz
483 < #if EMULATED_PPC
484 <        PVR = 0x000c0000;                       // Default: 7400 (with AltiVec)
485 < #else
486 <        proc_file = fopen("/proc/cpuinfo", "r");
487 <        if (proc_file) {
488 <                char line[256];
489 <                while(fgets(line, 255, proc_file)) {
490 <                        // Read line
491 <                        int len = strlen(line);
492 <                        if (len == 0)
493 <                                continue;
494 <                        line[len-1] = 0;
825 >  // Install signal handlers
826 >        if (!install_signal_handlers())
827 >                goto quit;
828  
829 <                        // Parse line
830 <                        int i;
498 <                        char value[256];
499 <                        if (sscanf(line, "cpu : %[0-9A-Za-a]", value) == 1) {
500 <                                if (strcmp(value, "601") == 0)
501 <                                        PVR = 0x00010000;
502 <                                else if (strcmp(value, "603") == 0)
503 <                                        PVR = 0x00030000;
504 <                                else if (strcmp(value, "604") == 0)
505 <                                        PVR = 0x00040000;
506 <                                else if (strcmp(value, "603e") == 0)
507 <                                        PVR = 0x00060000;
508 <                                else if (strcmp(value, "603ev") == 0)
509 <                                        PVR = 0x00070000;
510 <                                else if (strcmp(value, "604e") == 0)
511 <                                        PVR = 0x00090000;
512 <                                else if (strcmp(value, "604ev5") == 0)
513 <                                        PVR = 0x000a0000;
514 <                                else if (strcmp(value, "750") == 0)
515 <                                        PVR = 0x00080000;
516 <                                else if (strcmp(value, "821") == 0)
517 <                                        PVR = 0x00320000;
518 <                                else if (strcmp(value, "860") == 0)
519 <                                        PVR = 0x00500000;
520 <                                else if (strcmp(value, "7400") == 0)
521 <                                        PVR = 0x000c0000;
522 <                                else if (strcmp(value, "7410") == 0)
523 <                                        PVR = 0x800c0000;
524 <                                else
525 <                                        printf("WARNING: Unknown CPU type '%s', assuming 604\n", value);
526 <                        }
527 <                        if (sscanf(line, "clock : %dMHz", &i) == 1)
528 <                                CPUClockSpeed = BusClockSpeed = i * 1000000;
529 <                }
530 <                fclose(proc_file);
531 <        } else {
532 <                sprintf(str, GetString(STR_PROC_CPUINFO_WARN), strerror(errno));
533 <                WarningAlert(str);
534 <        }
829 >        // Initialize VM system
830 >        vm_init();
831  
832 <        // Get actual bus frequency
833 <        proc_file = fopen("/proc/device-tree/clock-frequency", "r");
538 <        if (proc_file) {
539 <                union { uint8 b[4]; uint32 l; } value;
540 <                if (fread(value.b, sizeof(value), 1, proc_file) == 1)
541 <                        BusClockSpeed = value.l;
542 <                fclose(proc_file);
543 <        }
544 < #endif
545 <        D(bug("PVR: %08x (assumed)\n", PVR));
832 >        // Get system info
833 >        get_system_info();
834  
835          // Init system routines
836          SysInit();
# Line 565 | Line 853 | int main(int argc, char **argv)
853                  goto quit;
854          }
855  
856 < #ifndef PAGEZERO_HACK
857 <        // Create Low Memory area (0x0000..0x3000)
570 <        if (vm_acquire_fixed((char *)0, 0x3000) < 0) {
571 <                sprintf(str, GetString(STR_LOW_MEM_MMAP_ERR), strerror(errno));
572 <                ErrorAlert(str);
856 >        // Create areas for Kernel Data
857 >        if (!kernel_data_init())
858                  goto quit;
859 <        }
860 <        lm_area_mapped = true;
861 < #endif
859 >        kernel_data = (KernelData *)Mac2HostAddr(KERNEL_DATA_BASE);
860 >        emulator_data = &kernel_data->ed;
861 >        KernelDataAddr = KERNEL_DATA_BASE;
862 >        D(bug("Kernel Data at %p (%08x)\n", kernel_data, KERNEL_DATA_BASE));
863 >        D(bug("Emulator Data at %p (%08x)\n", emulator_data, KERNEL_DATA_BASE + offsetof(KernelData, ed)));
864  
865 <        // Create areas for Kernel Data
866 <        kernel_area = shmget(IPC_PRIVATE, KERNEL_AREA_SIZE, 0600);
867 <        if (kernel_area == -1) {
581 <                sprintf(str, GetString(STR_KD_SHMGET_ERR), strerror(errno));
865 >        // Create area for DR Cache
866 >        if (vm_mac_acquire_fixed(DR_EMULATOR_BASE, DR_EMULATOR_SIZE) < 0) {
867 >                sprintf(str, GetString(STR_DR_EMULATOR_MMAP_ERR), strerror(errno));
868                  ErrorAlert(str);
869                  goto quit;
870          }
871 <        if (shmat(kernel_area, (void *)KERNEL_DATA_BASE, 0) < 0) {
872 <                sprintf(str, GetString(STR_KD_SHMAT_ERR), strerror(errno));
871 >        dr_emulator_area_mapped = true;
872 >        if (vm_mac_acquire_fixed(DR_CACHE_BASE, DR_CACHE_SIZE) < 0) {
873 >                sprintf(str, GetString(STR_DR_CACHE_MMAP_ERR), strerror(errno));
874                  ErrorAlert(str);
875                  goto quit;
876          }
877 <        if (shmat(kernel_area, (void *)KERNEL_DATA2_BASE, 0) < 0) {
878 <                sprintf(str, GetString(STR_KD2_SHMAT_ERR), strerror(errno));
877 >        dr_cache_area_mapped = true;
878 > #if !EMULATED_PPC
879 >        if (vm_protect((char *)DR_CACHE_BASE, DR_CACHE_SIZE, VM_PAGE_READ | VM_PAGE_WRITE | VM_PAGE_EXECUTE) < 0) {
880 >                sprintf(str, GetString(STR_DR_CACHE_MMAP_ERR), strerror(errno));
881                  ErrorAlert(str);
882                  goto quit;
883          }
884 <        kernel_data = (KernelData *)KERNEL_DATA_BASE;
885 <        emulator_data = &kernel_data->ed;
886 <        KernelDataAddr = KERNEL_DATA_BASE;
598 <        D(bug("Kernel Data at %p, Emulator Data at %p\n", kernel_data, emulator_data));
884 > #endif
885 >        DRCacheAddr = DR_CACHE_BASE;
886 >        D(bug("DR Cache at %p\n", DRCacheAddr));
887  
888          // Create area for SheepShaver data
889          if (!SheepMem::Init()) {
# Line 603 | Line 891 | int main(int argc, char **argv)
891                  ErrorAlert(str);
892                  goto quit;
893          }
894 <
607 <        // Create area for Mac ROM
608 <        if (vm_acquire_fixed((char *)ROM_BASE, ROM_AREA_SIZE) < 0) {
609 <                sprintf(str, GetString(STR_ROM_MMAP_ERR), strerror(errno));
610 <                ErrorAlert(str);
611 <                goto quit;
612 <        }
613 < #if !EMULATED_PPC
614 <        if (vm_protect((char *)ROM_BASE, ROM_AREA_SIZE, VM_PAGE_READ | VM_PAGE_WRITE | VM_PAGE_EXECUTE) < 0) {
615 <                sprintf(str, GetString(STR_ROM_MMAP_ERR), strerror(errno));
616 <                ErrorAlert(str);
617 <                goto quit;
618 <        }
619 < #endif
620 <        rom_area_mapped = true;
621 <        D(bug("ROM area at %08x\n", ROM_BASE));
622 <
894 >        
895          // Create area for Mac RAM
896          RAMSize = PrefsFindInt32("ramsize");
897          if (RAMSize < 8*1024*1024) {
898                  WarningAlert(GetString(STR_SMALL_RAM_WARN));
899                  RAMSize = 8*1024*1024;
900          }
901 <
902 <        if (vm_acquire_fixed((char *)RAM_BASE, RAMSize) < 0) {
903 <                sprintf(str, GetString(STR_RAM_MMAP_ERR), strerror(errno));
904 <                ErrorAlert(str);
905 <                goto quit;
901 >        memory_mapped_from_zero = false;
902 >        ram_rom_areas_contiguous = false;
903 > #if REAL_ADDRESSING && HAVE_LINKER_SCRIPT
904 >        if (vm_mac_acquire_fixed(0, RAMSize) == 0) {
905 >                D(bug("Could allocate RAM from 0x0000\n"));
906 >                RAMBase = 0;
907 >                RAMBaseHost = Mac2HostAddr(RAMBase);
908 >                memory_mapped_from_zero = true;
909 >        }
910 > #endif
911 >        if (!memory_mapped_from_zero) {
912 > #ifndef PAGEZERO_HACK
913 >                // Create Low Memory area (0x0000..0x3000)
914 >                if (vm_mac_acquire_fixed(0, 0x3000) < 0) {
915 >                        sprintf(str, GetString(STR_LOW_MEM_MMAP_ERR), strerror(errno));
916 >                        ErrorAlert(str);
917 >                        goto quit;
918 >                }
919 >                lm_area_mapped = true;
920 > #endif
921 > #if REAL_ADDRESSING
922 >                // Allocate RAM at any address. Since ROM must be higher than RAM, allocate the RAM
923 >                // and ROM areas contiguously, plus a little extra to allow for ROM address alignment.
924 >                RAMBaseHost = vm_mac_acquire(RAMSize + ROM_AREA_SIZE + ROM_ALIGNMENT);
925 >                if (RAMBaseHost == VM_MAP_FAILED) {
926 >                        sprintf(str, GetString(STR_RAM_ROM_MMAP_ERR), strerror(errno));
927 >                        ErrorAlert(str);
928 >                        goto quit;
929 >                }
930 >                RAMBase = Host2MacAddr(RAMBaseHost);
931 >                ROMBase = (RAMBase + RAMSize + ROM_ALIGNMENT -1) & -ROM_ALIGNMENT;
932 >                ROMBaseHost = Mac2HostAddr(ROMBase);
933 >                ram_rom_areas_contiguous = true;
934 > #else
935 >                if (vm_mac_acquire_fixed(RAM_BASE, RAMSize) < 0) {
936 >                        sprintf(str, GetString(STR_RAM_MMAP_ERR), strerror(errno));
937 >                        ErrorAlert(str);
938 >                        goto quit;
939 >                }
940 >                RAMBase = RAM_BASE;
941 >                RAMBaseHost = Mac2HostAddr(RAMBase);
942 > #endif
943          }
944   #if !EMULATED_PPC
945 <        if (vm_protect((char *)RAM_BASE, RAMSize, VM_PAGE_READ | VM_PAGE_WRITE | VM_PAGE_EXECUTE) < 0) {
945 >        if (vm_protect(RAMBaseHost, RAMSize, VM_PAGE_READ | VM_PAGE_WRITE | VM_PAGE_EXECUTE) < 0) {
946                  sprintf(str, GetString(STR_RAM_MMAP_ERR), strerror(errno));
947                  ErrorAlert(str);
948                  goto quit;
949          }
950   #endif
642        RAMBase = RAM_BASE;
951          ram_area_mapped = true;
952 <        D(bug("RAM area at %08x\n", RAMBase));
952 >        D(bug("RAM area at %p (%08x)\n", RAMBaseHost, RAMBase));
953  
954 <        if (RAMBase > ROM_BASE) {
955 <                ErrorAlert(GetString(STR_RAM_HIGHER_THAN_ROM_ERR));
954 >        if (RAMBase > KernelDataAddr) {
955 >                ErrorAlert(GetString(STR_RAM_AREA_TOO_HIGH_ERR));
956                  goto quit;
957          }
650
651        // Load Mac ROM
652        rom_path = PrefsFindString("rom");
653        rom_fd = open(rom_path ? rom_path : ROM_FILE_NAME, O_RDONLY);
654        if (rom_fd < 0) {
655                rom_fd = open(rom_path ? rom_path : ROM_FILE_NAME2, O_RDONLY);
656                if (rom_fd < 0) {
657                        ErrorAlert(GetString(STR_NO_ROM_FILE_ERR));
658                        goto quit;
659                }
660        }
661        printf(GetString(STR_READING_ROM_FILE));
662        rom_size = lseek(rom_fd, 0, SEEK_END);
663        lseek(rom_fd, 0, SEEK_SET);
664        rom_tmp = new uint8[ROM_SIZE];
665        actual = read(rom_fd, (void *)rom_tmp, ROM_SIZE);
666        close(rom_fd);
958          
959 <        // Decode Mac ROM
960 <        if (!DecodeROM(rom_tmp, actual)) {
961 <                if (rom_size != 4*1024*1024) {
962 <                        ErrorAlert(GetString(STR_ROM_SIZE_ERR));
963 <                        goto quit;
673 <                } else {
674 <                        ErrorAlert(GetString(STR_ROM_FILE_READ_ERR));
959 >        // Create area for Mac ROM
960 >        if (!ram_rom_areas_contiguous) {
961 >                if (vm_mac_acquire_fixed(ROM_BASE, ROM_AREA_SIZE) < 0) {
962 >                        sprintf(str, GetString(STR_ROM_MMAP_ERR), strerror(errno));
963 >                        ErrorAlert(str);
964                          goto quit;
965                  }
966 +                ROMBase = ROM_BASE;
967 +                ROMBaseHost = Mac2HostAddr(ROMBase);
968          }
969 <        delete[] rom_tmp;
970 <
971 <        // Load NVRAM
972 <        XPRAMInit();
682 <
683 <        // Load XPRAM default values if signature not found
684 <        if (XPRAM[0x130c] != 0x4e || XPRAM[0x130d] != 0x75
685 <         || XPRAM[0x130e] != 0x4d || XPRAM[0x130f] != 0x63) {
686 <                D(bug("Loading XPRAM default values\n"));
687 <                memset(XPRAM + 0x1300, 0, 0x100);
688 <                XPRAM[0x130c] = 0x4e;   // "NuMc" signature
689 <                XPRAM[0x130d] = 0x75;
690 <                XPRAM[0x130e] = 0x4d;
691 <                XPRAM[0x130f] = 0x63;
692 <                XPRAM[0x1301] = 0x80;   // InternalWaitFlags = DynWait (don't wait for SCSI devices upon bootup)
693 <                XPRAM[0x1310] = 0xa8;   // Standard PRAM values
694 <                XPRAM[0x1311] = 0x00;
695 <                XPRAM[0x1312] = 0x00;
696 <                XPRAM[0x1313] = 0x22;
697 <                XPRAM[0x1314] = 0xcc;
698 <                XPRAM[0x1315] = 0x0a;
699 <                XPRAM[0x1316] = 0xcc;
700 <                XPRAM[0x1317] = 0x0a;
701 <                XPRAM[0x131c] = 0x00;
702 <                XPRAM[0x131d] = 0x02;
703 <                XPRAM[0x131e] = 0x63;
704 <                XPRAM[0x131f] = 0x00;
705 <                XPRAM[0x1308] = 0x13;
706 <                XPRAM[0x1309] = 0x88;
707 <                XPRAM[0x130a] = 0x00;
708 <                XPRAM[0x130b] = 0xcc;
709 <                XPRAM[0x1376] = 0x00;   // OSDefault = MacOS
710 <                XPRAM[0x1377] = 0x01;
711 <        }
712 <
713 <        // Set boot volume
714 <        i16 = PrefsFindInt32("bootdrive");
715 <        XPRAM[0x1378] = i16 >> 8;
716 <        XPRAM[0x1379] = i16 & 0xff;
717 <        i16 = PrefsFindInt32("bootdriver");
718 <        XPRAM[0x137a] = i16 >> 8;
719 <        XPRAM[0x137b] = i16 & 0xff;
720 <
721 <        // Create BootGlobs at top of Mac memory
722 <        memset((void *)(RAMBase + RAMSize - 4096), 0, 4096);
723 <        BootGlobsAddr = RAMBase + RAMSize - 0x1c;
724 <        boot_globs = (uint32 *)BootGlobsAddr;
725 <        boot_globs[-5] = htonl(RAMBase + RAMSize);      // MemTop
726 <        boot_globs[0] = htonl(RAMBase);                         // First RAM bank
727 <        boot_globs[1] = htonl(RAMSize);
728 <        boot_globs[2] = htonl((uint32)-1);                      // End of bank table
729 <
730 <        // Init thunks
731 <        if (!ThunksInit())
969 > #if !EMULATED_PPC
970 >        if (vm_protect(ROMBaseHost, ROM_AREA_SIZE, VM_PAGE_READ | VM_PAGE_WRITE | VM_PAGE_EXECUTE) < 0) {
971 >                sprintf(str, GetString(STR_ROM_MMAP_ERR), strerror(errno));
972 >                ErrorAlert(str);
973                  goto quit;
974 +        }
975 + #endif
976 +        rom_area_mapped = true;
977 +        D(bug("ROM area at %p (%08x)\n", ROMBaseHost, ROMBase));
978  
979 <        // Init drivers
980 <        SonyInit();
981 <        DiskInit();
982 <        CDROMInit();
738 <        SCSIInit();
739 <
740 <        // Init external file system
741 <        ExtFSInit();
742 <
743 <        // Init ADB
744 <        ADBInit();
745 <
746 <        // Init audio
747 <        AudioInit();
748 <
749 <        // Init network
750 <        EtherInit();
751 <
752 <        // Init serial ports
753 <        SerialInit();
754 <
755 <        // Init Time Manager
756 <        TimerInit();
757 <
758 <        // Init clipboard
759 <        ClipInit();
979 >        if (RAMBase > ROMBase) {
980 >                ErrorAlert(GetString(STR_RAM_HIGHER_THAN_ROM_ERR));
981 >                goto quit;
982 >        }
983  
984 <        // Init video
985 <        if (!VideoInit())
984 >        // Load Mac ROM
985 >        if (!load_mac_rom())
986                  goto quit;
987  
988 <        // Install ROM patches
989 <        if (!PatchROM()) {
767 <                ErrorAlert(GetString(STR_UNSUPPORTED_ROM_TYPE_ERR));
988 >        // Initialize everything
989 >        if (!InitAll(vmdir))
990                  goto quit;
991 <        }
991 >        D(bug("Initialization complete\n"));
992  
993          // Clear caches (as we loaded and patched code) and write protect ROM
994   #if !EMULATED_PPC
995 <        MakeExecutable(0, (void *)ROM_BASE, ROM_AREA_SIZE);
995 >        flush_icache_range(ROMBase, ROMBase + ROM_AREA_SIZE);
996   #endif
997 <        vm_protect((char *)ROM_BASE, ROM_AREA_SIZE, VM_PAGE_READ | VM_PAGE_EXECUTE);
776 <
777 <        // Initialize Kernel Data
778 <        memset(kernel_data, 0, sizeof(KernelData));
779 <        if (ROMType == ROMTYPE_NEWWORLD) {
780 <                uintptr of_dev_tree = SheepMem::Reserve(4 * sizeof(uint32));
781 <                memset((void *)of_dev_tree, 0, 4 * sizeof(uint32));
782 <                uintptr vector_lookup_tbl = SheepMem::Reserve(128);
783 <                uintptr vector_mask_tbl = SheepMem::Reserve(64);
784 <                memset((uint8 *)kernel_data + 0xb80, 0x3d, 0x80);
785 <                memset((void *)vector_lookup_tbl, 0, 128);
786 <                memset((void *)vector_mask_tbl, 0, 64);
787 <                kernel_data->v[0xb80 >> 2] = htonl(ROM_BASE);
788 <                kernel_data->v[0xb84 >> 2] = htonl(of_dev_tree);                        // OF device tree base
789 <                kernel_data->v[0xb90 >> 2] = htonl(vector_lookup_tbl);
790 <                kernel_data->v[0xb94 >> 2] = htonl(vector_mask_tbl);
791 <                kernel_data->v[0xb98 >> 2] = htonl(ROM_BASE);                           // OpenPIC base
792 <                kernel_data->v[0xbb0 >> 2] = htonl(0);                                          // ADB base
793 <                kernel_data->v[0xc20 >> 2] = htonl(RAMSize);
794 <                kernel_data->v[0xc24 >> 2] = htonl(RAMSize);
795 <                kernel_data->v[0xc30 >> 2] = htonl(RAMSize);
796 <                kernel_data->v[0xc34 >> 2] = htonl(RAMSize);
797 <                kernel_data->v[0xc38 >> 2] = htonl(0x00010020);
798 <                kernel_data->v[0xc3c >> 2] = htonl(0x00200001);
799 <                kernel_data->v[0xc40 >> 2] = htonl(0x00010000);
800 <                kernel_data->v[0xc50 >> 2] = htonl(RAMBase);
801 <                kernel_data->v[0xc54 >> 2] = htonl(RAMSize);
802 <                kernel_data->v[0xf60 >> 2] = htonl(PVR);
803 <                kernel_data->v[0xf64 >> 2] = htonl(CPUClockSpeed);                      // clock-frequency
804 <                kernel_data->v[0xf68 >> 2] = htonl(BusClockSpeed);                      // bus-frequency
805 <                kernel_data->v[0xf6c >> 2] = htonl(BusClockSpeed / 4);          // timebase-frequency
806 <        } else {
807 <                kernel_data->v[0xc80 >> 2] = htonl(RAMSize);
808 <                kernel_data->v[0xc84 >> 2] = htonl(RAMSize);
809 <                kernel_data->v[0xc90 >> 2] = htonl(RAMSize);
810 <                kernel_data->v[0xc94 >> 2] = htonl(RAMSize);
811 <                kernel_data->v[0xc98 >> 2] = htonl(0x00010020);
812 <                kernel_data->v[0xc9c >> 2] = htonl(0x00200001);
813 <                kernel_data->v[0xca0 >> 2] = htonl(0x00010000);
814 <                kernel_data->v[0xcb0 >> 2] = htonl(RAMBase);
815 <                kernel_data->v[0xcb4 >> 2] = htonl(RAMSize);
816 <                kernel_data->v[0xf80 >> 2] = htonl(PVR);
817 <                kernel_data->v[0xf84 >> 2] = htonl(CPUClockSpeed);                      // clock-frequency
818 <                kernel_data->v[0xf88 >> 2] = htonl(BusClockSpeed);                      // bus-frequency
819 <                kernel_data->v[0xf8c >> 2] = htonl(BusClockSpeed / 4);          // timebase-frequency
820 <        }
821 <
822 <        // Initialize extra low memory
823 <        D(bug("Initializing Low Memory...\n"));
824 <        memset(NULL, 0, 0x3000);
825 <        WriteMacInt32(XLM_SIGNATURE, FOURCC('B','a','a','h'));                  // Signature to detect SheepShaver
826 <        WriteMacInt32(XLM_KERNEL_DATA, KernelDataAddr);                                 // For trap replacement routines
827 <        WriteMacInt32(XLM_PVR, PVR);                                                                    // Theoretical PVR
828 <        WriteMacInt32(XLM_BUS_CLOCK, BusClockSpeed);                                    // For DriverServicesLib patch
829 <        WriteMacInt16(XLM_EXEC_RETURN_OPCODE, M68K_EXEC_RETURN);                // For Execute68k() (RTS from the executed 68k code will jump here and end 68k mode)
830 <        WriteMacInt32(XLM_ZERO_PAGE, SheepMem::ZeroPage());                             // Pointer to read-only page with all bits set to 0
831 < #if !EMULATED_PPC
832 <        WriteMacInt32(XLM_TOC, (uint32)TOC);                                                            // TOC pointer of emulator
833 < #endif
834 <        WriteMacInt32(XLM_ETHER_INIT, NativeFunction(NATIVE_ETHER_INIT));       // DLPI ethernet driver functions
835 <        WriteMacInt32(XLM_ETHER_TERM, NativeFunction(NATIVE_ETHER_TERM));
836 <        WriteMacInt32(XLM_ETHER_OPEN, NativeFunction(NATIVE_ETHER_OPEN));
837 <        WriteMacInt32(XLM_ETHER_CLOSE, NativeFunction(NATIVE_ETHER_CLOSE));
838 <        WriteMacInt32(XLM_ETHER_WPUT, NativeFunction(NATIVE_ETHER_WPUT));
839 <        WriteMacInt32(XLM_ETHER_RSRV, NativeFunction(NATIVE_ETHER_RSRV));
840 <        WriteMacInt32(XLM_VIDEO_DOIO, NativeFunction(NATIVE_VIDEO_DO_DRIVER_IO));
841 <        D(bug("Low Memory initialized\n"));
997 >        vm_protect(ROMBaseHost, ROM_AREA_SIZE, VM_PAGE_READ | VM_PAGE_EXECUTE);
998  
999          // Start 60Hz thread
1000 +        tick_thread_cancel = false;
1001          tick_thread_active = (pthread_create(&tick_thread, NULL, tick_func, NULL) == 0);
1002          D(bug("Tick thread installed (%ld)\n", tick_thread));
1003  
1004          // Start NVRAM watchdog thread
1005          memcpy(last_xpram, XPRAM, XPRAM_SIZE);
1006 +        nvram_thread_cancel = false;
1007          nvram_thread_active = (pthread_create(&nvram_thread, NULL, nvram_func, NULL) == 0);
1008          D(bug("NVRAM thread installed (%ld)\n", nvram_thread));
1009  
1010   #if !EMULATED_PPC
853        // Create and install stacks for signal handlers
854        for (int i = 0; i < SIG_STACK_COUNT; i++) {
855                void *sig_stack = malloc(SIG_STACK_SIZE);
856                D(bug("Signal stack %d at %p\n", i, sig_stack));
857                if (sig_stack == NULL) {
858                        ErrorAlert(GetString(STR_NOT_ENOUGH_MEMORY_ERR));
859                        goto quit;
860                }
861                sig_stacks[i].ss_sp = sig_stack;
862                sig_stacks[i].ss_flags = 0;
863                sig_stacks[i].ss_size = SIG_STACK_SIZE;
864        }
865        sig_stack_id = 0;
866        if (sigaltstack(&sig_stacks[0], NULL) < 0) {
867                sprintf(str, GetString(STR_SIGALTSTACK_ERR), strerror(errno));
868                ErrorAlert(str);
869                goto quit;
870        }
871 #endif
872
873 #if !EMULATED_PPC
874        // Install SIGSEGV and SIGBUS handlers
875        sigemptyset(&sigsegv_action.sa_mask);   // Block interrupts during SEGV handling
876        sigaddset(&sigsegv_action.sa_mask, SIGUSR2);
877        sigsegv_action.sa_sigaction = sigsegv_handler;
878        sigsegv_action.sa_flags = SA_ONSTACK | SA_SIGINFO;
879 #ifdef HAVE_SIGNAL_SA_RESTORER
880        sigsegv_action.sa_restorer = NULL;
881 #endif
882        if (sigaction(SIGSEGV, &sigsegv_action, NULL) < 0) {
883                sprintf(str, GetString(STR_SIGSEGV_INSTALL_ERR), strerror(errno));
884                ErrorAlert(str);
885                goto quit;
886        }
887        if (sigaction(SIGBUS, &sigsegv_action, NULL) < 0) {
888                sprintf(str, GetString(STR_SIGSEGV_INSTALL_ERR), strerror(errno));
889                ErrorAlert(str);
890                goto quit;
891        }
892
1011          // Install SIGILL handler
1012          sigemptyset(&sigill_action.sa_mask);    // Block interrupts during ILL handling
1013          sigaddset(&sigill_action.sa_mask, SIGUSR2);
# Line 899 | Line 1017 | int main(int argc, char **argv)
1017          sigill_action.sa_restorer = NULL;
1018   #endif
1019          if (sigaction(SIGILL, &sigill_action, NULL) < 0) {
1020 <                sprintf(str, GetString(STR_SIGILL_INSTALL_ERR), strerror(errno));
1020 >                sprintf(str, GetString(STR_SIG_INSTALL_ERR), "SIGILL", strerror(errno));
1021                  ErrorAlert(str);
1022                  goto quit;
1023          }
# Line 908 | Line 1026 | int main(int argc, char **argv)
1026   #if !EMULATED_PPC
1027          // Install interrupt signal handler
1028          sigemptyset(&sigusr2_action.sa_mask);
1029 <        sigusr2_action.sa_sigaction = sigusr2_handler;
1029 >        sigusr2_action.sa_sigaction = sigusr2_handler_init;
1030          sigusr2_action.sa_flags = SA_ONSTACK | SA_RESTART | SA_SIGINFO;
1031   #ifdef HAVE_SIGNAL_SA_RESTORER
1032          sigusr2_action.sa_restorer = NULL;
1033   #endif
1034          if (sigaction(SIGUSR2, &sigusr2_action, NULL) < 0) {
1035 <                sprintf(str, GetString(STR_SIGUSR2_INSTALL_ERR), strerror(errno));
1035 >                sprintf(str, GetString(STR_SIG_INSTALL_ERR), "SIGUSR2", strerror(errno));
1036                  ErrorAlert(str);
1037                  goto quit;
1038          }
# Line 944 | Line 1062 | static void Quit(void)
1062  
1063          // Stop 60Hz thread
1064          if (tick_thread_active) {
1065 +                tick_thread_cancel = true;
1066                  pthread_cancel(tick_thread);
1067                  pthread_join(tick_thread, NULL);
1068          }
1069  
1070          // Stop NVRAM watchdog thread
1071          if (nvram_thread_active) {
1072 +                nvram_thread_cancel = true;
1073                  pthread_cancel(nvram_thread);
1074                  pthread_join(nvram_thread, NULL);
1075          }
# Line 969 | Line 1089 | static void Quit(void)
1089          sigaction(SIGILL, &sigill_action, NULL);
1090  
1091          // Delete stacks for signal handlers
1092 <        for (int i = 0; i < SIG_STACK_COUNT; i++) {
1093 <                void *sig_stack = sig_stacks[i].ss_sp;
1094 <                if (sig_stack)
1095 <                        free(sig_stack);
976 <        }
1092 >        if (sig_stack.ss_sp)
1093 >                free(sig_stack.ss_sp);
1094 >        if (extra_stack.ss_sp)
1095 >                free(extra_stack.ss_sp);
1096   #endif
1097  
1098 <        // Save NVRAM
1099 <        XPRAMExit();
981 <
982 <        // Exit clipboard
983 <        ClipExit();
984 <
985 <        // Exit Time Manager
986 <        TimerExit();
987 <
988 <        // Exit serial
989 <        SerialExit();
990 <
991 <        // Exit network
992 <        EtherExit();
993 <
994 <        // Exit audio
995 <        AudioExit();
996 <
997 <        // Exit ADB
998 <        ADBExit();
999 <
1000 <        // Exit video
1001 <        VideoExit();
1002 <
1003 <        // Exit external file system
1004 <        ExtFSExit();
1005 <
1006 <        // Exit drivers
1007 <        SCSIExit();
1008 <        CDROMExit();
1009 <        DiskExit();
1010 <        SonyExit();
1011 <
1012 <        // Delete thunks
1013 <        ThunksExit();
1098 >        // Deinitialize everything
1099 >        ExitAll();
1100  
1101          // Delete SheepShaver globals
1102          SheepMem::Exit();
1103  
1104          // Delete RAM area
1105          if (ram_area_mapped)
1106 <                vm_release((char *)RAM_BASE, RAMSize);
1106 >                vm_mac_release(RAMBase, RAMSize);
1107  
1108          // Delete ROM area
1109          if (rom_area_mapped)
1110 <                vm_release((char *)ROM_BASE, ROM_AREA_SIZE);
1110 >                vm_mac_release(ROMBase, ROM_AREA_SIZE);
1111 >
1112 >        // Delete DR cache areas
1113 >        if (dr_emulator_area_mapped)
1114 >                vm_mac_release(DR_EMULATOR_BASE, DR_EMULATOR_SIZE);
1115 >        if (dr_cache_area_mapped)
1116 >                vm_mac_release(DR_CACHE_BASE, DR_CACHE_SIZE);
1117  
1118          // Delete Kernel Data area
1119 <        if (kernel_area >= 0) {
1028 <                shmdt((void *)KERNEL_DATA_BASE);
1029 <                shmdt((void *)KERNEL_DATA2_BASE);
1030 <                shmctl(kernel_area, IPC_RMID, NULL);
1031 <        }
1119 >        kernel_data_exit();
1120  
1121          // Delete Low Memory area
1122          if (lm_area_mapped)
1123 <                munmap((char *)0x0000, 0x3000);
1123 >                vm_mac_release(0, 0x3000);
1124  
1125          // Close /dev/zero
1126          if (zero_fd > 0)
# Line 1050 | Line 1138 | static void Quit(void)
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 +        uint32 kernel_area_size = (KERNEL_AREA_SIZE + SHMLBA - 1) & -SHMLBA;
1164 +
1165 +        kernel_area = shmget(IPC_PRIVATE, kernel_area_size, 0600);
1166 +        if (kernel_area == -1) {
1167 +                sprintf(str, GetString(STR_KD_SHMGET_ERR), strerror(errno));
1168 +                ErrorAlert(str);
1169 +                return false;
1170 +        }
1171 +        void *kernel_addr = Mac2HostAddr(KERNEL_DATA_BASE & -SHMLBA);
1172 +        if (shmat(kernel_area, kernel_addr, 0) != kernel_addr) {
1173 +                sprintf(str, GetString(STR_KD_SHMAT_ERR), strerror(errno));
1174 +                ErrorAlert(str);
1175 +                return false;
1176 +        }
1177 +        kernel_addr = Mac2HostAddr(KERNEL_DATA2_BASE & -SHMLBA);
1178 +        if (shmat(kernel_area, kernel_addr, 0) != kernel_addr) {
1179 +                sprintf(str, GetString(STR_KD2_SHMAT_ERR), strerror(errno));
1180 +                ErrorAlert(str);
1181 +                return false;
1182 +        }
1183 +        return true;
1184 + }
1185 +
1186 +
1187 + /*
1188 + *  Deallocate Kernel Data segments
1189 + */
1190 +
1191 + static void kernel_data_exit(void)
1192 + {
1193 +        if (kernel_area >= 0) {
1194 +                shmdt(Mac2HostAddr(KERNEL_DATA_BASE & -SHMLBA));
1195 +                shmdt(Mac2HostAddr(KERNEL_DATA2_BASE & -SHMLBA));
1196 +                shmctl(kernel_area, IPC_RMID, NULL);
1197 +        }
1198 + }
1199 +
1200 +
1201 + /*
1202   *  Jump into Mac ROM, start 680x0 emulator
1203   */
1204  
# Line 1085 | Line 1226 | static void *emul_func(void *arg)
1226          // Jump to ROM boot routine
1227          D(bug("Jumping to ROM\n"));
1228   #if EMULATED_PPC
1229 <        jump_to_rom(ROM_BASE + 0x310000);
1229 >        jump_to_rom(ROMBase + 0x310000);
1230   #else
1231 <        jump_to_rom(ROM_BASE + 0x310000, (uint32)emulator_data);
1231 >        jump_to_rom(ROMBase + 0x310000, (uint32)emulator_data);
1232   #endif
1233          D(bug("Returned from ROM\n"));
1234  
# Line 1144 | Line 1285 | void QuitEmulator(void)
1285  
1286  
1287   /*
1147 *  Pause/resume emulator
1148 */
1149
1150 void PauseEmulator(void)
1151 {
1152        pthread_kill(emul_thread, SIGSTOP);
1153 }
1154
1155 void ResumeEmulator(void)
1156 {
1157        pthread_kill(emul_thread, SIGCONT);
1158 }
1159
1160
1161 /*
1288   *  Dump 68k registers
1289   */
1290  
# Line 1186 | Line 1312 | void Dump68kRegs(M68kRegisters *r)
1312   *  Make code executable
1313   */
1314  
1315 < void MakeExecutable(int dummy, void *start, uint32 length)
1315 > void MakeExecutable(int dummy, uint32 start, uint32 length)
1316   {
1317 <        if (((uintptr)start >= ROM_BASE) && ((uintptr)start < (ROM_BASE + ROM_SIZE)))
1317 >        if ((start >= ROMBase) && (start < (ROMBase + ROM_SIZE)))
1318                  return;
1319   #if EMULATED_PPC
1320 <        FlushCodeCache((uintptr)start, (uintptr)start + length);
1320 >        FlushCodeCache(start, start + length);
1321   #else
1322 <        flush_icache_range(start, (void *)((uintptr)start + length));
1322 >        flush_icache_range(start, start + length);
1323   #endif
1324   }
1325  
1326  
1327   /*
1328 < *  Patch things after system startup (gets called by disk driver accRun routine)
1328 > *  NVRAM watchdog thread (saves NVRAM every minute)
1329   */
1330  
1331 < void PatchAfterStartup(void)
1331 > static void nvram_watchdog(void)
1332   {
1333 <        ExecuteNative(NATIVE_VIDEO_INSTALL_ACCEL);
1334 <        InstallExtFS();
1333 >        if (memcmp(last_xpram, XPRAM, XPRAM_SIZE)) {
1334 >                memcpy(last_xpram, XPRAM, XPRAM_SIZE);
1335 >                SaveXPRAM();
1336 >        }
1337   }
1338  
1211
1212 /*
1213 *  NVRAM watchdog thread (saves NVRAM every minute)
1214 */
1215
1339   static void *nvram_func(void *arg)
1340   {
1341 <        struct timespec req = {60, 0};  // 1 minute
1342 <
1343 <        for (;;) {
1344 <                pthread_testcancel();
1222 <                nanosleep(&req, NULL);
1223 <                pthread_testcancel();
1224 <                if (memcmp(last_xpram, XPRAM, XPRAM_SIZE)) {
1225 <                        memcpy(last_xpram, XPRAM, XPRAM_SIZE);
1226 <                        SaveXPRAM();
1227 <                }
1341 >        while (!nvram_thread_cancel) {
1342 >                for (int i=0; i<60 && !nvram_thread_cancel; i++)
1343 >                        Delay_usec(999999);             // Only wait 1 second so we quit promptly when nvram_thread_cancel becomes true
1344 >                nvram_watchdog();
1345          }
1346          return NULL;
1347   }
# Line 1237 | Line 1354 | static void *nvram_func(void *arg)
1354   static void *tick_func(void *arg)
1355   {
1356          int tick_counter = 0;
1357 <        struct timespec req = {0, 16625000};
1357 >        uint64 start = GetTicks_usec();
1358 >        int64 ticks = 0;
1359 >        uint64 next = GetTicks_usec();
1360  
1361 <        for (;;) {
1361 >        while (!tick_thread_cancel) {
1362  
1363                  // Wait
1364 <                nanosleep(&req, NULL);
1364 >                next += 16625;
1365 >                int64 delay = next - GetTicks_usec();
1366 >                if (delay > 0)
1367 >                        Delay_usec(delay);
1368 >                else if (delay < -16625)
1369 >                        next = GetTicks_usec();
1370 >                ticks++;
1371  
1372   #if !EMULATED_PPC
1373                  // Did we crash?
# Line 1300 | Line 1425 | static void *tick_func(void *arg)
1425                          TriggerInterrupt();
1426                  }
1427          }
1428 +
1429 +        uint64 end = GetTicks_usec();
1430 +        D(bug("%lld ticks in %lld usec = %f ticks/sec\n", ticks, end - start, ticks * 1000000.0 / (end - start)));
1431          return NULL;
1432   }
1433  
# Line 1349 | Line 1477 | struct B2_mutex {
1477              pthread_mutexattr_init(&attr);
1478              // Initialize the mutex for priority inheritance --
1479              // required for accurate timing.
1480 < #ifdef HAVE_PTHREAD_MUTEXATTR_SETPROTOCOL
1480 > #if defined(HAVE_PTHREAD_MUTEXATTR_SETPROTOCOL) && !defined(__CYGWIN__)
1481              pthread_mutexattr_setprotocol(&attr, PTHREAD_PRIO_INHERIT);
1482   #endif
1483   #if defined(HAVE_PTHREAD_MUTEXATTR_SETTYPE) && defined(PTHREAD_MUTEX_NORMAL)
# Line 1423 | Line 1551 | void B2_delete_mutex(B2_mutex *mutex)
1551   #if !EMULATED_PPC
1552   void TriggerInterrupt(void)
1553   {
1554 <        if (ready_for_signals)
1554 >        if (ready_for_signals) {
1555 >                idle_resume();
1556                  pthread_kill(emul_thread, SIGUSR2);
1557 +        }
1558   }
1559   #endif
1560  
# Line 1452 | Line 1582 | void ClearInterruptFlag(uint32 flag)
1582  
1583   void DisableInterrupt(void)
1584   {
1585 + #if EMULATED_PPC
1586 +        WriteMacInt32(XLM_IRQ_NEST, int32(ReadMacInt32(XLM_IRQ_NEST)) + 1);
1587 + #else
1588          atomic_add((int *)XLM_IRQ_NEST, 1);
1589 + #endif
1590   }
1591  
1592  
# Line 1462 | Line 1596 | void DisableInterrupt(void)
1596  
1597   void EnableInterrupt(void)
1598   {
1599 + #if EMULATED_PPC
1600 +        WriteMacInt32(XLM_IRQ_NEST, int32(ReadMacInt32(XLM_IRQ_NEST)) - 1);
1601 + #else
1602          atomic_add((int *)XLM_IRQ_NEST, -1);
1603 + #endif
1604   }
1605  
1606  
# Line 1471 | Line 1609 | void EnableInterrupt(void)
1609   */
1610  
1611   #if !EMULATED_PPC
1612 < static void sigusr2_handler(int sig, siginfo_t *sip, void *scp)
1612 > void sigusr2_handler(int sig, siginfo_t *sip, void *scp)
1613   {
1614          machine_regs *r = MACHINE_REGISTERS(scp);
1615  
1616 + #ifdef SYSTEM_CLOBBERS_R2
1617 +        // Restore pointer to Thread Local Storage
1618 +        set_r2(TOC);
1619 + #endif
1620 + #ifdef SYSTEM_CLOBBERS_R13
1621 +        // Restore pointer to .sdata section
1622 +        set_r13(R13);
1623 + #endif
1624 +
1625 + #ifdef USE_SDL_VIDEO
1626 +        // We must fill in the events queue in the same thread that did call SDL_SetVideoMode()
1627 +        SDL_PumpEvents();
1628 + #endif
1629 +
1630          // Do nothing if interrupts are disabled
1631          if (*(int32 *)XLM_IRQ_NEST > 0)
1632                  return;
# Line 1495 | Line 1647 | static void sigusr2_handler(int sig, sig
1647                          // 68k emulator inactive, in nanokernel?
1648                          if (r->gpr(1) != KernelDataAddr) {
1649  
1650 <                                // Set extra stack for nested interrupts
1651 <                                sig_stack_acquire();
1650 >                                // Set extra stack for SIGSEGV handler
1651 >                                sigaltstack(&extra_stack, NULL);
1652                                  
1653                                  // Prepare for 68k interrupt level 1
1654                                  WriteMacInt16(ntohl(kernel_data->v[0x67c >> 2]), 1);
# Line 1505 | Line 1657 | static void sigusr2_handler(int sig, sig
1657                                  // Execute nanokernel interrupt routine (this will activate the 68k emulator)
1658                                  DisableInterrupt();
1659                                  if (ROMType == ROMTYPE_NEWWORLD)
1660 <                                        ppc_interrupt(ROM_BASE + 0x312b1c, KernelDataAddr);
1660 >                                        ppc_interrupt(ROMBase + 0x312b1c, KernelDataAddr);
1661                                  else
1662 <                                        ppc_interrupt(ROM_BASE + 0x312a3c, KernelDataAddr);
1662 >                                        ppc_interrupt(ROMBase + 0x312a3c, KernelDataAddr);
1663  
1664 <                                // Reset normal signal stack
1665 <                                sig_stack_release();
1664 >                                // Reset normal stack
1665 >                                sigaltstack(&sig_stack, NULL);
1666                          }
1667                          break;
1668   #endif
# Line 1521 | Line 1673 | static void sigusr2_handler(int sig, sig
1673                          if ((ReadMacInt32(XLM_68K_R25) & 7) == 0) {
1674  
1675                                  // Set extra stack for SIGSEGV handler
1676 <                                sig_stack_acquire();
1676 >                                sigaltstack(&extra_stack, NULL);
1677   #if 1
1678                                  // Execute full 68k interrupt routine
1679                                  M68kRegisters r;
# Line 1547 | Line 1699 | static void sigusr2_handler(int sig, sig
1699                                          }
1700                                  }
1701   #endif
1702 <                                // Reset normal signal stack
1703 <                                sig_stack_release();
1702 >                                // Reset normal stack
1703 >                                sigaltstack(&sig_stack, NULL);
1704                          }
1705                          break;
1706   #endif
# Line 1569 | Line 1721 | static void sigsegv_handler(int sig, sig
1721          // Get effective address
1722          uint32 addr = r->dar();
1723          
1724 + #ifdef SYSTEM_CLOBBERS_R2
1725 +        // Restore pointer to Thread Local Storage
1726 +        set_r2(TOC);
1727 + #endif
1728 + #ifdef SYSTEM_CLOBBERS_R13
1729 +        // Restore pointer to .sdata section
1730 +        set_r13(R13);
1731 + #endif
1732 +
1733   #if ENABLE_VOSF
1734 <        // Handle screen fault.
1735 <        extern bool Screen_fault_handler(sigsegv_address_t fault_address, sigsegv_address_t fault_instruction);
1736 <        if (Screen_fault_handler((sigsegv_address_t)addr, (sigsegv_address_t)r->pc()))
1734 >        // Handle screen fault
1735 > #if SIGSEGV_CHECK_VERSION(1,0,0)
1736 >        sigsegv_info_t si;
1737 >        si.addr = (sigsegv_address_t)addr;
1738 >        si.pc = (sigsegv_address_t)r->pc();
1739 > #endif
1740 >        extern bool Screen_fault_handler(sigsegv_info_t *sip);
1741 >        if (Screen_fault_handler(&si))
1742                  return;
1743   #endif
1744  
1745          num_segv++;
1746  
1747 <        // Fault in Mac ROM or RAM?
1748 <        bool mac_fault = (r->pc() >= ROM_BASE) && (r->pc() < (ROM_BASE + ROM_AREA_SIZE)) || (r->pc() >= RAMBase) && (r->pc() < (RAMBase + RAMSize));
1747 >        // Fault in Mac ROM or RAM or DR Cache?
1748 >        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));
1749          if (mac_fault) {
1750  
1751                  // "VM settings" during MacOS 8 installation
1752 <                if (r->pc() == ROM_BASE + 0x488160 && r->gpr(20) == 0xf8000000) {
1752 >                if (r->pc() == ROMBase + 0x488160 && r->gpr(20) == 0xf8000000) {
1753                          r->pc() += 4;
1754                          r->gpr(8) = 0;
1755                          return;
1756          
1757                  // MacOS 8.5 installation
1758 <                } else if (r->pc() == ROM_BASE + 0x488140 && r->gpr(16) == 0xf8000000) {
1758 >                } else if (r->pc() == ROMBase + 0x488140 && r->gpr(16) == 0xf8000000) {
1759                          r->pc() += 4;
1760                          r->gpr(8) = 0;
1761                          return;
1762          
1763                  // MacOS 8 serial drivers on startup
1764 <                } else if (r->pc() == ROM_BASE + 0x48e080 && (r->gpr(8) == 0xf3012002 || r->gpr(8) == 0xf3012000)) {
1764 >                } else if (r->pc() == ROMBase + 0x48e080 && (r->gpr(8) == 0xf3012002 || r->gpr(8) == 0xf3012000)) {
1765                          r->pc() += 4;
1766                          r->gpr(8) = 0;
1767                          return;
1768          
1769                  // MacOS 8.1 serial drivers on startup
1770 <                } else if (r->pc() == ROM_BASE + 0x48c5e0 && (r->gpr(20) == 0xf3012002 || r->gpr(20) == 0xf3012000)) {
1770 >                } else if (r->pc() == ROMBase + 0x48c5e0 && (r->gpr(20) == 0xf3012002 || r->gpr(20) == 0xf3012000)) {
1771                          r->pc() += 4;
1772                          return;
1773 <                } else if (r->pc() == ROM_BASE + 0x4a10a0 && (r->gpr(20) == 0xf3012002 || r->gpr(20) == 0xf3012000)) {
1773 >                } else if (r->pc() == ROMBase + 0x4a10a0 && (r->gpr(20) == 0xf3012002 || r->gpr(20) == 0xf3012000)) {
1774 >                        r->pc() += 4;
1775 >                        return;
1776 >        
1777 >                // MacOS 8.6 serial drivers on startup (with DR Cache and OldWorld ROM)
1778 >                } else if ((r->pc() - DR_CACHE_BASE) < DR_CACHE_SIZE && (r->gpr(16) == 0xf3012002 || r->gpr(16) == 0xf3012000)) {
1779 >                        r->pc() += 4;
1780 >                        return;
1781 >                } else if ((r->pc() - DR_CACHE_BASE) < DR_CACHE_SIZE && (r->gpr(20) == 0xf3012002 || r->gpr(20) == 0xf3012000)) {
1782                          r->pc() += 4;
1783                          return;
1784                  }
# Line 1729 | Line 1903 | static void sigsegv_handler(int sig, sig
1903          
1904                  // Ignore ROM writes (including to the zero page, which is read-only)
1905                  if (transfer_type == TYPE_STORE &&
1906 <                        ((addr >= ROM_BASE && addr < ROM_BASE + ROM_SIZE) ||
1906 >                        ((addr >= ROMBase && addr < ROMBase + ROM_SIZE) ||
1907                           (addr >= SheepMem::ZeroPage() && addr < SheepMem::ZeroPage() + SheepMem::PageSize()))) {
1908   //                      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()));
1909                          if (addr_mode == MODE_U || addr_mode == MODE_UX)
# Line 1810 | Line 1984 | static void sigill_handler(int sig, sigi
1984          machine_regs *r = MACHINE_REGISTERS(scp);
1985          char str[256];
1986  
1987 + #ifdef SYSTEM_CLOBBERS_R2
1988 +        // Restore pointer to Thread Local Storage
1989 +        set_r2(TOC);
1990 + #endif
1991 + #ifdef SYSTEM_CLOBBERS_R13
1992 +        // Restore pointer to .sdata section
1993 +        set_r13(R13);
1994 + #endif
1995 +
1996          // Fault in Mac ROM or RAM?
1997 <        bool mac_fault = (r->pc() >= ROM_BASE) && (r->pc() < (ROM_BASE + ROM_AREA_SIZE)) || (r->pc() >= RAMBase) && (r->pc() < (RAMBase + RAMSize));
1997 >        bool mac_fault = (r->pc() >= ROMBase) && (r->pc() < (ROMBase + ROM_AREA_SIZE)) || (r->pc() >= RAMBase) && (r->pc() < (RAMBase + RAMSize));
1998          if (mac_fault) {
1999  
2000                  // Get opcode and divide into fields
# Line 1978 | Line 2161 | bool SheepMem::Init(void)
2161          page_size = getpagesize();
2162  
2163          // Allocate SheepShaver globals
2164 <        if (vm_acquire_fixed((char *)base, size) < 0)
2164 >        proc = base;
2165 >        if (vm_mac_acquire_fixed(base, size) < 0)
2166                  return false;
2167  
2168 <        // Allocate page with all bits set to 0
2169 <        zero_page = base + size;
2170 <        if (vm_acquire_fixed((char *)zero_page, page_size) < 0)
2171 <                return false;
2172 <        memset((char *)zero_page, 0, page_size);
1989 <        if (vm_protect((char *)zero_page, page_size, VM_PAGE_READ) < 0)
2168 >        // Allocate page with all bits set to 0, right in the middle
2169 >        // This is also used to catch undesired overlaps between proc and data areas
2170 >        zero_page = proc + (size / 2);
2171 >        Mac_memset(zero_page, 0, page_size);
2172 >        if (vm_protect(Mac2HostAddr(zero_page), page_size, VM_PAGE_READ) < 0)
2173                  return false;
2174  
2175   #if EMULATED_PPC
2176          // Allocate alternate stack for PowerPC interrupt routine
2177 <        sig_stack = zero_page + page_size;
2178 <        if (vm_acquire_fixed((char *)sig_stack, SIG_STACK_SIZE) < 0)
2177 >        sig_stack = base + size;
2178 >        if (vm_mac_acquire_fixed(sig_stack, SIG_STACK_SIZE) < 0)
2179                  return false;
2180   #endif
2181  
2182 <        top = base + size;
2182 >        data = base + size;
2183          return true;
2184   }
2185  
2186   void SheepMem::Exit(void)
2187   {
2188 <        if (top) {
2188 >        if (data) {
2189                  // Delete SheepShaver globals
2190 <                vm_release((void *)base, size);
2008 <
2009 <                // Delete zero page
2010 <                vm_release((void *)zero_page, page_size);
2190 >                vm_mac_release(base, size);
2191  
2192   #if EMULATED_PPC
2193                  // Delete alternate stack for PowerPC interrupt routine
2194 <                vm_release((void *)sig_stack, SIG_STACK_SIZE);
2194 >                vm_mac_release(sig_stack, SIG_STACK_SIZE);
2195   #endif
2196          }
2197   }
# Line 2066 | Line 2246 | void display_alert(int title_id, int pre
2246  
2247   void ErrorAlert(const char *text)
2248   {
2249 < #ifdef ENABLE_GTK
2249 >        if (gui_connection) {
2250 >                if (rpc_method_invoke(gui_connection, RPC_METHOD_ERROR_ALERT, RPC_TYPE_STRING, text, RPC_TYPE_INVALID) == RPC_ERROR_NO_ERROR &&
2251 >                        rpc_method_wait_for_reply(gui_connection, RPC_TYPE_INVALID) == RPC_ERROR_NO_ERROR)
2252 >                        return;
2253 >        }
2254 > #if defined(ENABLE_GTK) && !defined(USE_SDL_VIDEO)
2255          if (PrefsFindBool("nogui") || x_display == NULL) {
2256                  printf(GetString(STR_SHELL_ERROR_PREFIX), text);
2257                  return;
# Line 2085 | Line 2270 | void ErrorAlert(const char *text)
2270  
2271   void WarningAlert(const char *text)
2272   {
2273 < #ifdef ENABLE_GTK
2273 >        if (gui_connection) {
2274 >                if (rpc_method_invoke(gui_connection, RPC_METHOD_WARNING_ALERT, RPC_TYPE_STRING, text, RPC_TYPE_INVALID) == RPC_ERROR_NO_ERROR &&
2275 >                        rpc_method_wait_for_reply(gui_connection, RPC_TYPE_INVALID) == RPC_ERROR_NO_ERROR)
2276 >                        return;
2277 >        }
2278 > #if defined(ENABLE_GTK) && !defined(USE_SDL_VIDEO)
2279          if (PrefsFindBool("nogui") || x_display == NULL) {
2280                  printf(GetString(STR_SHELL_WARNING_PREFIX), text);
2281                  return;

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines