From e82172884e8963163b48a393655db67526d729a4 Mon Sep 17 00:00:00 2001 From: Peter Rutenbar Date: Sat, 5 Apr 2014 19:20:53 -0400 Subject: [PATCH] - Made a lot of progress getting 3.0.0 to run. - Implemented support for reading the kernel from SVFS/UFS filesystems - Other little changes --- Makefile | 7 +- core/Makefile | 39 +- core/adb.c | 19 +- core/core_api.c | 83 +- core/core_api.h | 4 +- core/cpu.c | 17 +- core/debug_server.c | 126 ++ core/exception.c | 4 +- core/filesystem.c | 1389 +++++++++++++++++ core/fpu.c | 3 +- core/mem.c | 3 + core/{debugger.c => old_debugger.c} | 0 core/shoebill.h | 42 +- core/via.c | 4 +- gui/Shoebill.xcodeproj/project.pbxproj | 23 +- gui/Shoebill/Shoebill-Info.plist | 6 +- gui/Shoebill/shoeApplication.m | 7 +- .../shoePreferencesWindowController.m | 2 +- gui/Shoebill/shoeScreenView.m | 22 +- gui/Shoebill/shoeScreenWindow.m | 11 + test.c | 407 ----- web/2014_04_05_aux3.0.0_sorta_works.png | Bin 0 -> 154222 bytes 22 files changed, 1682 insertions(+), 536 deletions(-) create mode 100644 core/debug_server.c create mode 100644 core/filesystem.c rename core/{debugger.c => old_debugger.c} (100%) delete mode 100644 test.c create mode 100644 web/2014_04_05_aux3.0.0_sorta_works.png diff --git a/Makefile b/Makefile index 35f1e8f..3d26841 100644 --- a/Makefile +++ b/Makefile @@ -1,12 +1,13 @@ CC = clang -CFLAGS = -O4 -arch x86_64 -Wno-deprecated-declarations +CFLAGS = -O3 -arch i386 -arch x86_64 -Wno-deprecated-declarations LFLAGS = -framework OpenGL -framework GLUT all: shoebill -shoebill: make_core test.c - $(CC) $(LFLAGS) $(CFLAGS) -L intermediates -l shoebill_core test.c -o shoebill +shoebill: make_core +# shoebill: make_core test.c +# $(CC) $(LFLAGS) $(CFLAGS) -L intermediates -l shoebill_core test.c -o shoebill make_core: $(MAKE) -C core -j 4 diff --git a/core/Makefile b/core/Makefile index 83f3596..fec5999 100644 --- a/core/Makefile +++ b/core/Makefile @@ -1,20 +1,34 @@ CC = clang -CFLAGS = -O4 -ggdb -arch x86_64 -Wno-deprecated-declarations +CFLAGS = -O3 -flto -ggdb -Wno-deprecated-declarations DEPS = core_api.h coff.h mc68851.h redblack.h shoebill.h Makefile macro.pl NEED_DECODER = cpu dis NEED_PREPROCESSING = adb fpu mc68851 mem via -NEED_NOTHING = atrap_tab coff exception floppy macii_symbols redblack scsi toby_frame_buffer video core_api +NEED_NOTHING = atrap_tab coff exception floppy macii_symbols redblack scsi toby_frame_buffer video core_api filesystem debug_server +# Object files that can be compiled directly from the source OBJ_NEED_NOTHING = $(patsubst %,$(TEMP)/%.o,$(NEED_NOTHING)) + +# Object files than need preprocessing with macro.pl OBJ_NEED_PREPROCESSING = $(patsubst %,$(TEMP)/%.o,$(NEED_PREPROCESSING)) + +# Object files that depend on the instruction decoder OBJ_NEED_DECODER = $(patsubst %,$(TEMP)/%.o,$(NEED_DECODER)) # Files that NEED_DECODER also NEED_PREPROCESSING POST_PREPROCESSING = $(patsubst %,$(TEMP)/%.post.c,$(NEED_PREPROCESSING)) $(patsubst %,$(TEMP)/%.post.c,$(NEED_DECODER)) + + +# All the object files compiled for x86_64 +OBJ_x86_64 = $(OBJ_NEED_NOTHING) $(OBJ_NEED_PREPROCESSING) $(OBJ_NEED_DECODER) + +# The object files compiled for i386 (the same as x86_64 files, but with .i386 appended) +OBJ_i386 = $(patsubst %,%.i386,$(OBJ_x86_64)) + + MACRO = perl macro.pl TEMP = ../intermediates @@ -22,18 +36,29 @@ TEMP = ../intermediates all: $(TEMP)/libshoebill_core.a -$(TEMP)/libshoebill_core.a: $(TEMP) $(DEPS) $(OBJ_NEED_NOTHING) $(OBJ_NEED_PREPROCESSING) $(OBJ_NEED_DECODER) - libtool -static -o $(TEMP)/libshoebill_core.a $(OBJ_NEED_NOTHING) $(OBJ_NEED_PREPROCESSING) $(OBJ_NEED_DECODER) +$(TEMP)/libshoebill_core.a: $(TEMP) $(DEPS) $(OBJ_x86_64) + libtool -static -v -o $(TEMP)/libshoebill_core.a.x86_64 $(OBJ_x86_64) + libtool -static -v -o $(TEMP)/libshoebill_core.a.i386 $(OBJ_i386) + lipo -create -output $(TEMP)/libshoebill_core.a $(TEMP)/libshoebill_core.a.x86_64 $(TEMP)/libshoebill_core.a.i386 + + +# Split object files into i386/x86_64 versions, since it seems that libtool is unable to +# link a static universal library for -O4 object files. +# x86_64 object files have the form "intermediates/.o +# i386 object files have the form "intermediates/.o.i386 # Build object files $(OBJ_NEED_NOTHING): $(TEMP)/%.o: %.c $(DEPS) - $(CC) -c $(CFLAGS) $< -o $@ + $(CC) -c -arch x86_64 $(CFLAGS) $< -o $@ + $(CC) -c -arch i386 $(CFLAGS) $< -o $@.i386 $(OBJ_NEED_PREPROCESSING): $(TEMP)/%.o: $(TEMP)/%.post.c $(DEPS) - $(CC) -c $(CFLAGS) $< -o $@ + $(CC) -c -arch x86_64 $(CFLAGS) $< -o $@ + $(CC) -c -arch i386 $(CFLAGS) $< -o $@.i386 $(OBJ_NEED_DECODER): $(TEMP)/%.o: $(TEMP)/%.post.c $(DEPS) $(TEMP)/dis_decoder_guts.c $(TEMP)/inst_decoder_guts.c - $(CC) -c $(CFLAGS) $< -o $@ + $(CC) -c -arch x86_64 $(CFLAGS) $< -o $@ + $(CC) -c -arch i386 $(CFLAGS) $< -o $@.i386 # Preprocess C files $(POST_PREPROCESSING): $(TEMP)/%.post.c: %.c $(DEPS) diff --git a/core/adb.c b/core/adb.c index 0bfbf1e..deb385a 100644 --- a/core/adb.c +++ b/core/adb.c @@ -148,11 +148,22 @@ static void mouse_talk(uint8_t reg) case 0: if (shoe.mouse.changed) { + const int32_t hi_delta_limit = 32; + const int32_t low_delta_limit = -32; - printf("mouse_talk: x=%d, y=%d button=%u\n", shoe.mouse.delta_x, shoe.mouse.delta_y, shoe.mouse.button_down); + int32_t x = shoe.mouse.delta_x; + int32_t y = shoe.mouse.delta_y; - shoe.adb.data[1] = shoe.mouse.delta_x & 0x7f; - shoe.adb.data[0] = shoe.mouse.delta_y & 0x7f; + //printf("mouse_talk: x=%d, y=%d button=%u\n", shoe.mouse.delta_x, shoe.mouse.delta_y, shoe.mouse.button_down); + + + if (x > hi_delta_limit) x = hi_delta_limit; + if (x < low_delta_limit) x = low_delta_limit; + if (y > hi_delta_limit) y = hi_delta_limit; + if (y < low_delta_limit) y = low_delta_limit; + + shoe.adb.data[1] = x & 0x7f; + shoe.adb.data[0] = y & 0x7f; if (!shoe.mouse.button_down) { //shoe.adb.data[1] |= 0x80; shoe.adb.data[0] |= 0x80; @@ -164,7 +175,7 @@ static void mouse_talk(uint8_t reg) shoe.mouse.delta_x = 0; shoe.mouse.delta_y = 0; - // shoe.mouse.button_down = 0; + shoe.mouse.changed = 0; } else diff --git a/core/core_api.c b/core/core_api.c index 514a527..3bfee7f 100644 --- a/core/core_api.c +++ b/core/core_api.c @@ -144,9 +144,11 @@ void shoebill_start() pthread_mutex_unlock(&shoe.cpu_thread_lock); pthread_mutex_unlock(&shoe.via_clock_thread_lock); } - -static void _cpu_loop_fast() -{ + +void *_cpu_thread (void *arg) { + + pthread_mutex_lock(&shoe.cpu_thread_lock); + while (1) { if (shoe.cpu_thread_notifications) { @@ -159,16 +161,13 @@ static void _cpu_loop_fast() if (shoe.cpu_thread_notifications & SHOEBILL_STATE_STOPPED) { continue; // FIXME: yield or block on a condition variable here } - - if (shoe.cpu_thread_notifications & SHOEBILL_STATE_SWITCH_MODE) - return ; } cpu_step(); } } -static void _cpu_loop_debug() +/*static void _cpu_loop_debug() { while (1) { if (shoe.cpu_thread_notifications) { @@ -181,33 +180,9 @@ static void _cpu_loop_debug() } } -} +}*/ -void *_cpu_thread (void *arg) { - - pthread_mutex_lock(&shoe.cpu_thread_lock); - - while (1) { - shoe.cpu_thread_notifications &= ~SHOEBILL_STATE_SWITCH_MODE; - - if (shoe.cpu_mode == CPU_MODE_FAST) - _cpu_loop_fast(); - else if (shoe.cpu_mode == CPU_MODE_DEBUG) - _cpu_loop_debug(); - else if (shoe.cpu_mode == CPU_MODE_STEPI) { - cpu_step(); - shoe.cpu_mode = CPU_MODE_STEPI_COMPLETE; - while (shoe.cpu_mode == CPU_MODE_STEPI_COMPLETE) - pthread_yield_np(); - } - else if (shoe.cpu_mode == CPU_MODE_FREEZE) { - pthread_mutex_lock(&shoe.cpu_freeze_lock); - pthread_mutex_unlock(&shoe.cpu_freeze_lock); - } - } -} - -void shoebill_cpu_stepi (void) +/*void shoebill_cpu_stepi (void) { if (shoe.cpu_mode != CPU_MODE_FREEZE) return ; @@ -231,7 +206,7 @@ void shoebill_cpu_freeze (void) while (shoe.cpu_thread_notifications & SHOEBILL_STATE_SWITCH_MODE); pthread_yield_np(); -} +}*/ /* * The A/UX bootloader blasts this structure into memory @@ -338,7 +313,7 @@ static void _init_macintosh_lomem_globals (const uint32_t offset) #define hwCbADB (1<<10) #define hwCbAUX (1<<9) /* not sure if I need to set this one */ const uint16_t HWCfgFlags = hwCbSCSI | hwCbClock | hwCbFPU | hwCbMMU | hwCbADB; - pset(0xb22, 2, HWCfgFlags); // HWCfgFlags + pset(offset+0xb22, 2, HWCfgFlags); // HWCfgFlags } @@ -587,40 +562,6 @@ fail: return 0; } -/*static uint32_t _setup_nubus_cards(shoebill_control_t *control) -{ - uint32_t i; - - for (i=0; i<16; i++) { - switch (control->slots[i].card_type) { - case card_empty: - continue; - - case card_toby_frame_buffer: - case card_shoebill_ethernet: - assert(!"not implemented"); - - case card_shoebill_video: { - const uint16_t width = control->slots[i].card.video.width; - const uint16_t height = control->slots[i].card.video.height; - const uint16_t scanline_width = control->slots[i].card.video.scanline_width; - const double refresh_rate = control->slots[i].card.video.refresh_rate; - uint8_t *frame_buffer = control->slots[i].card.video.frame_buffer; - assert(scanline_width >= width); - - nubus_video_init(i, width, height, scanline_width, refresh_rate, frame_buffer); - - } - } - } - - return 1; - -fail: - - return 0; -}*/ - static uint32_t _load_aux_kernel(shoebill_control_t *control, coff_file *coff, uint32_t *_pc) { uint32_t j, i, pc = 0xffffffff; @@ -801,7 +742,8 @@ uint32_t shoebill_initialize(shoebill_control_t *control) pthread_mutex_lock(&shoe.via_clock_thread_lock); pthread_create(&control->cpu_thread_pid, NULL, _cpu_thread, NULL); - pthread_create(&control->cpu_thread_pid, NULL, via_clock_thread, NULL); + // pthread_create(&control->cpu_thread_pid, NULL, debug_cpu_thread, NULL); + pthread_create(&control->via_thread_pid, NULL, via_clock_thread, NULL); return 1; @@ -885,6 +827,7 @@ void shoebill_mouse_move(int32_t x, int32_t y) void shoebill_mouse_move_delta (int32_t x, int32_t y) { assert(pthread_mutex_lock(&shoe.adb.lock) == 0); + shoe.mouse.delta_x += x; shoe.mouse.delta_y += y; diff --git a/core/core_api.h b/core/core_api.h index db08eea..ed1e18a 100644 --- a/core/core_api.h +++ b/core/core_api.h @@ -95,7 +95,7 @@ typedef struct { } card; } slots[16]; - pthread_t cpu_thread_pid, clock_pid; + pthread_t cpu_thread_pid, via_thread_pid; char error_msg[8192]; } shoebill_control_t; @@ -126,4 +126,6 @@ void shoebill_mouse_click(uint8_t down); void shoebill_start(); +uint8_t* shoebill_extract_kernel(const char *disk_path, const char *kernel_path, char *error_str, uint32_t *len); + #endif diff --git a/core/cpu.c b/core/cpu.c index 8a75e11..bf68036 100644 --- a/core/cpu.c +++ b/core/cpu.c @@ -31,7 +31,7 @@ #include "../core/mc68851.h" global_shoebill_context_t shoe; -struct dbg_state_t dbg_state; +//struct dbg_state_t dbg_state; #define nextword() ({const uint16_t w=lget(shoe.pc,2); if (shoe.abort) {return;}; shoe.pc+=2; w;}) #define verify_supervisor() {if (!sr_s()) {throw_privilege_violation(); return;}} @@ -867,7 +867,7 @@ struct dbg_state_t dbg_state; const uint8_t Rm = mib(R, 4); const uint8_t Sm = mib(shoe.dat, 4); const uint8_t Dm = mib(shoe.a[r], 4); - set_sr_z(chop(R,sz)==0); + set_sr_z(R == 0); /* <- This is where A/UX 3.0.0 started working */ set_sr_n(Rm); set_sr_v((!Sm && Dm && !Rm) || (Sm && !Dm && Rm)); set_sr_c((Sm && !Dm) || (Rm && !Dm) || (Sm && Rm)); @@ -1162,7 +1162,8 @@ struct dbg_state_t dbg_state; // 1: reset the "enabled" bit of the TC register printf("Reset! (not implemented)\n"); - dbg_state.running = 0; + assert(!"reset called"); + //dbg_state.running = 0; }) ~inst(movec, { @@ -1359,11 +1360,13 @@ struct dbg_state_t dbg_state; shoe.dat = R; call_ea_write(M, sz); - set_sr_z(R == 0); - set_sr_n(Rm); + const uint32_t result = chop(R, sz); + + set_sr_z(result == 0); + set_sr_c(result != 0); + set_sr_x(result != 0); set_sr_v(Dm && Rm); - set_sr_c(Dm || Rm); - set_sr_x(Dm || Rm); + set_sr_n(Rm); }) ~inst(negx, { diff --git a/core/debug_server.c b/core/debug_server.c new file mode 100644 index 0000000..29b4cf0 --- /dev/null +++ b/core/debug_server.c @@ -0,0 +1,126 @@ +/* + * Copyright (c) 2014, Peter Rutenbar + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "../core/shoebill.h" +#include "../core/coff.h" + +#define DEBUG_MODE_STOPPED 0 +#define DEBUG_MODE_RUNNING 1 +#define DEBUG_MODE_STEP 2 + +#define SHOEBILL_DEBUG_PORT 0xfded +static int _start_debug_server(void) +{ + struct sockaddr_in addr; + int sock = socket(AF_INET, SOCK_STREAM, 0); + + memset(&addr, 0, sizeof(addr)); + addr.sin_len = sizeof(struct sockaddr_in); + addr.sin_family = AF_INET; + addr.sin_port = htons(SHOEBILL_DEBUG_PORT); + addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); + + if (sock == -1) { + assert(!"can't socket"); + } + else if (bind(sock, (struct sockaddr *)&addr, sizeof(struct sockaddr)) != 0) { + assert(!"can't bind"); + // return -1; + } + else if (listen(sock, 1) != 0) { + assert(!"can't listen"); + } + + return sock; +} + +void *debug_server_thread (void *arg) +{ + struct sockaddr_in addr; + socklen_t sin_size = sizeof(struct sockaddr_in); + uint8_t *inbuf = calloc(0x10000, 1); + uint8_t *outbuf = calloc(0x10000, 1); + int sock = _start_debug_server(); + int clientfd = accept(sock, (struct sockaddr*)&addr, &sin_size); + + shoe.dbg.connected = 1; + shoe.dbg.mode = DEBUG_MODE_RUNNING; + + + return NULL; +} + +void *debug_cpu_thread (void *arg) +{ + memset(&shoe.dbg, 0, sizeof(shoe.dbg)); + shoe.dbg.mode = DEBUG_MODE_STOPPED; + + pthread_t server_thread_pid; + pthread_create(&server_thread_pid, + NULL, + debug_server_thread, + NULL); + + /* + * The CPU only runs once the debugger is connected, and the + * emulator has started + */ + pthread_mutex_lock(&shoe.cpu_thread_lock); + while (!shoe.dbg.connected) + usleep(1000); + + while (1) { + if (shoe.dbg.mode == DEBUG_MODE_RUNNING) { + if (!shoe.dbg.ignore_interrupts && + (shoe.cpu_thread_notifications & 0xff)) { + process_pending_interrupt(); + } + + if (shoe.cpu_thread_notifications & SHOEBILL_STATE_STOPPED) { + continue; + } + + cpu_step(); + } + else if (shoe.dbg.mode == DEBUG_MODE_STOPPED) + pthread_yield_np(); + else if (shoe.dbg.mode == DEBUG_MODE_STEP) { + cpu_step(); + shoe.dbg.mode = DEBUG_MODE_STOPPED; + } + } +} + + + diff --git a/core/exception.c b/core/exception.c index b0b4d81..56cc605 100644 --- a/core/exception.c +++ b/core/exception.c @@ -215,9 +215,9 @@ void throw_illegal_instruction() { //printf("throw_illegal_instruction(): I'm throwing an illegal instruction exception! (shoe.pc = 0x%08x, op=0x%04x, a7=0x%08x)\n", shoe.orig_pc, shoe.op, shoe.a[7]); - if ((shoe.op != 0xf010) && ((shoe.op >> 12) != 0xa)) + /*if ((shoe.op != 0xf010) && ((shoe.op >> 12) != 0xa)) //assert(!"illegal"); - dbg_state.running = 0; + dbg_state.running = 0; */ // fetch vector number const uint32_t vector_num = diff --git a/core/filesystem.c b/core/filesystem.c new file mode 100644 index 0000000..74eab03 --- /dev/null +++ b/core/filesystem.c @@ -0,0 +1,1389 @@ +/* + * Copyright (c) 2014, Peter Rutenbar + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include +#include +#include +#include + +#pragma mark Alloc pool stuff + +/* --- alloc pool --- */ + +typedef struct _alloc_pool_t{ + struct _alloc_pool_t *prev, *next; + uint32_t size, magic; +} alloc_pool_t; + +#define fix_endian(x) do { \ + if (ntohs(1) == 1) \ + break; \ + switch (sizeof(x)) { \ + case 1: break; \ + case 2: (x) = ntohs(x); break; \ + case 4: (x) = ntohl(x); break; \ + case 8: { \ + const uint64_t n = ntohl((x) & 0xffffffff); \ + (x) = (n<<32) | ntohl((x)>>32); \ + break; \ + } \ + default: assert(!"bogus size"); \ +}} while (0) + +static void* p_alloc(alloc_pool_t *pool, uint64_t size) +{ + alloc_pool_t *buf = calloc(sizeof(alloc_pool_t) + size, 1); + buf->size = size; + buf->magic = 'moof'; + + buf->next = pool->next; + buf->prev = pool; + + if (pool->next) + pool->next->prev = buf; + pool->next = buf; + + return &buf[1]; +} + +static void* p_realloc(void *ptr, uint64_t size) +{ + alloc_pool_t *header = &((alloc_pool_t*)ptr)[-1]; + alloc_pool_t *new_header = realloc(header, size + sizeof(alloc_pool_t)); + + if (new_header) + return &new_header[1]; + + return NULL; +} + +static void p_free(void *ptr) +{ + alloc_pool_t *header = &((alloc_pool_t*)ptr)[-1]; + assert(header->magic == 'moof'); + + if (header->next) + header->next->prev = header->prev; + + if (header->prev) + header->prev->next = header->next; + + free(header); +} + +static void p_free_pool(alloc_pool_t *pool) +{ + while (pool->prev) + pool = pool->prev; + + while (pool) { + alloc_pool_t *cur = pool; + pool = cur->next; + assert(cur->magic == 'moof'); + free(cur); + } +} + +static alloc_pool_t* p_new_pool(void) +{ + alloc_pool_t *pool = calloc(sizeof(alloc_pool_t), 1); + pool->magic = 'moof'; + return pool; +} + + +/* --- Disk/partition management stuff --- */ +#pragma mark Disk/partition management stuff + +typedef struct __attribute__ ((__packed__)) { + uint32_t magic; + uint8_t cluster; + uint8_t type; + uint16_t inode; + + // no no no SLICErrr rrrrrCUR (NOPE, sys-V compiler orders these bits backwards) + // yes RUCrrrrr rrrSLICE + + uint8_t dummy:5; + uint8_t crit:1; + uint8_t usr:1; + uint8_t root:1; + + uint8_t slice:5; + uint8_t dummy2:3; + + uint16_t dummy3; + uint32_t tmade; + uint32_t tmount; + uint32_t tunmount; + + /* "Alternate block map" */ + uint32_t abm_size; + uint32_t abm_ents; + uint32_t abm_start; +} block_zero_t; + +typedef struct __attribute__ ((__packed__)) { + uint8_t pmSig[2]; + uint16_t pmSigPad; + uint32_t pmMapBlkCnt; + uint32_t pmPyPartStart; + uint32_t pmPartBlkCnt; + char pmPartName[32]; + char pmPartType[32]; + uint32_t pmLgDataStart; + uint32_t pmDataCnt; + uint32_t pmPartStatus; + uint32_t pmLgBootStart; + uint32_t pmBootSize; + uint32_t pmBootAddr; + uint32_t pmBootAddr2; + uint32_t pmBootEntry; + uint32_t pmBootEntry2; + uint32_t pmBootCksum; + char pmProcessor[16]; + block_zero_t bz; +} apple_partition_map_t; + +typedef struct __attribute__ ((__packed__)) { + uint8_t sbSig[2]; // device signature + uint16_t sbBlkSize; // block size of the device + uint32_t sbBlkCount; // number of blocks on the device + uint16_t sbDevType; // reserved + uint16_t sbDevId; // reserved + uint32_t sbData; // reserved + uint16_t sbDrvrCount; // nnumber of driver descriptor entries + uint32_t ddBlock; // first driver's starting block + uint16_t ddSize; // size of the driver, in 512-byte blocks + uint16_t ddType; // operating system type (MacOS = 1) +} driver_descriptor_record_t; + + +typedef struct { + struct _disk_t *disk; + char *error_str; + alloc_pool_t *pool; + uint32_t start_block, num_blocks; + char name[33], type[33]; +} partition_t; + +typedef struct _disk_t { + // -- fill these out -- + const char *path; + char *error_str; + + // -- "private" -- + alloc_pool_t *pool; + FILE *f; + uint32_t block_size; + + driver_descriptor_record_t ddr; + + uint32_t num_partitions; + apple_partition_map_t *partition_maps; + partition_t *partitions; +} disk_t; + +static void disk_get_block (disk_t *disk, uint8_t buf[512], uint32_t blockno) +{ + const uint32_t block_size = disk->block_size; + assert(0 == fseeko(disk->f, block_size * blockno, SEEK_SET)); + assert(fread(buf, block_size, 1, disk->f) == 1); +} + +static void part_get_block(partition_t *part, uint8_t buf[512], uint32_t blockno) +{ + assert(blockno < part->num_blocks); + disk_get_block(part->disk, buf, part->start_block + blockno); +} + +static uint8_t disk_load_partition_map(disk_t *disk, apple_partition_map_t *apm, uint32_t idx) +{ + uint8_t block[512]; + + disk_get_block(disk, block, 1 + idx); + memcpy(apm, block, sizeof(apple_partition_map_t)); + + fix_endian(apm->pmSigPad); + fix_endian(apm->pmMapBlkCnt); + fix_endian(apm->pmPyPartStart); + fix_endian(apm->pmPartBlkCnt); + fix_endian(apm->pmLgDataStart); + fix_endian(apm->pmDataCnt); + fix_endian(apm->pmPartStatus); + fix_endian(apm->pmLgBootStart); + fix_endian(apm->pmBootSize); + fix_endian(apm->pmBootAddr); + fix_endian(apm->pmBootAddr2); + fix_endian(apm->pmBootEntry); + fix_endian(apm->pmBootEntry2); + fix_endian(apm->pmBootCksum); + + fix_endian(apm->bz.magic); + fix_endian(apm->bz.inode); + fix_endian(apm->bz.tmade); + fix_endian(apm->bz.tmount); + fix_endian(apm->bz.tunmount); + fix_endian(apm->bz.abm_size); + fix_endian(apm->bz.abm_ents); + fix_endian(apm->bz.abm_start); + + if (memcmp(apm->pmSig, "PM", 2) != 0) { + sprintf(disk->error_str, "partition index %u has bad magic %02x%02x", + idx, apm->pmSig[0], apm->pmSig[1]); + return 0; + } + + return 1; +} + +static void close_disk(disk_t *disk) +{ + fclose(disk->f); + p_free_pool(disk->pool); +} + +static disk_t* open_disk (const char *disk_path, char *error_str) +{ + disk_t *disk; + uint8_t block[512]; + apple_partition_map_t apm; + uint32_t i; + alloc_pool_t *pool = p_new_pool(); + FILE *f; + + disk = p_alloc(pool, sizeof(disk_t)); + + disk->pool = pool; + disk->block_size = 512; + disk->error_str = error_str; + disk->path = disk_path; + + f = fopen(disk_path, "r"); + if (f == NULL) { + sprintf(error_str, "Can't open that path"); + goto fail; + } + + disk->f = f; + + // Load the driver descriptor record + + disk_get_block(disk, block, 0); + memcpy(&disk->ddr, block, sizeof(disk->ddr)); + + fix_endian(disk->ddr.sbBlkSize); + fix_endian(disk->ddr.sbBlkCount); + fix_endian(disk->ddr.sbDevType); + fix_endian(disk->ddr.sbDevId); + fix_endian(disk->ddr.sbData); + fix_endian(disk->ddr.sbDrvrCount); + fix_endian(disk->ddr.ddBlock); + fix_endian(disk->ddr.ddSize); + fix_endian(disk->ddr.ddType); + + // If the DDR block exists, (it doesn't have to necessarially) + if (memcmp(disk->ddr.sbSig, "ER", 2) == 0) { + // Can't handle non-512 byte block sizes + if (disk->ddr.sbBlkSize != 512) { + sprintf(error_str, "This disk uses blkSize=%u and I can't handle that", + disk->ddr.sbBlkSize); + goto fail; + } + } + + // printf("sizeof(apple_part_map_t) = %lu\n", sizeof(apple_partition_map_t)); + + // Load the partition maps + + if (!disk_load_partition_map(disk, &apm, 0)) + goto fail; + else if ((apm.pmMapBlkCnt > 256) || (apm.pmMapBlkCnt == 0)) { + sprintf(error_str, "Crazy number of partitions on this disk %u", apm.pmMapBlkCnt); + goto fail; + } + + disk->num_partitions = apm.pmMapBlkCnt; + disk->partition_maps = p_alloc(disk->pool, disk->num_partitions * sizeof(apple_partition_map_t)); + disk->partitions = p_alloc(disk->pool, disk->num_partitions * sizeof(partition_t)); + + for (i=0; inum_partitions; i++) { + if (!disk_load_partition_map(disk, &disk->partition_maps[i], i)) + goto fail; + + memset(&disk->partitions[i], 0, sizeof(partition_t)); + disk->partitions[i].disk = disk; + disk->partitions[i].pool = disk->pool; + disk->partitions[i].error_str = error_str; + disk->partitions[i].start_block = disk->partition_maps[i].pmPyPartStart; + disk->partitions[i].num_blocks = disk->partition_maps[i].pmPartBlkCnt; + + memcpy(disk->partitions[i].name, disk->partition_maps[i].pmPartName, 32); + memcpy(disk->partitions[i].type, disk->partition_maps[i].pmPartType, 32); + + // printf("%u type:%s name:%s\n", i, disk->partitions[i].type, disk->partitions[i].name); + // printf("bz_magic=0x%08x slice=%u\n", disk->partition_maps[i].bz.magic, disk->partition_maps[i].bz.slice); + } + + return disk; + +fail: + if (f) fclose(f); + p_free_pool(pool); + return NULL; +} + +/*static uint8_t translate_aux_to_apm_partition_num(disk_t *disk, + uint32_t aux_idx, + uint32_t *apm_idx) +{ + uint32_t i, aux_i = 0; + + for (i=0; inum_partitions; i++) { + partition_t *part = &disk->partitions[i]; + if (strcmp("Apple_UNIX_SVR2", part->type) != 0) + continue; + else if (strstr(part->name, "Eschatology") != NULL) + continue; + else if (aux_i == aux_idx) { + *apm_idx = i; + return 1; + } + aux_i++; + } + + return 0; +}*/ + +static int32_t find_root_partition_number(disk_t *disk, uint8_t clus_num) +{ + /* + * See the man page for bzb for the full scoop. + * Basically, A/UX partition 0 is the first partition with + * ** type="Apple_UNIX_SVR2", + * ** a matching cluster number, and + * ** the root bit set + * + * A/UX partition 1 is the first partition with + * ** type="Apple_UNIX_SVR2", + * ** a matching cluster number, and + * ** the swap filesystem type + * + * A/UX partition 2 is the next partition with + * ** type="Apple_UNIX_SVR2", + * ** a matching cluster number + * ** and the user bit set + * + * The logic is probably even more arbitrary + * and complicated than that. Why doesn't A/UX + * just use the native APM partition numbers? + */ + + uint32_t i; + for (i=0; inum_partitions; i++) { + partition_t *part = &disk->partitions[i]; + apple_partition_map_t *apm = &disk->partition_maps[i]; + + // printf("%u magic=0x%08x root=%u type=%s\n", i, apm->bz.magic, apm->bz.root, part->type); + + if (apm->bz.magic != 0xabadbabe) + continue; + + if (!apm->bz.root) + continue; + + if (apm->bz.cluster != clus_num) + continue; + + // slice==0 -> This partition doesn't prefer any particular slice number + // slice==N -> This partition prefers slice number (N-1) + // (I think) + /*if (apm->bz.slice != 0 && apm->bz.slice != 1) + continue;*/ + + if (strcmp("Apple_UNIX_SVR2", part->type) != 0) + continue; + + return (int32_t)i; + } + return -1; +} + +#pragma mark SVFS stuff +/* --- SVFS stuff --- */ + +typedef struct __attribute__ ((__packed__)) { + uint16_t isize; + uint32_t fsize; + uint16_t nfree; + uint32_t free[50]; + uint16_t ninode; + uint16_t inode[100]; + uint8_t flock; + uint8_t ilock; + uint8_t fmod; + uint8_t ronly; + uint32_t time; + uint16_t dinfo[4]; + uint32_t tfree; + uint16_t tinode; + uint8_t fname[6]; + uint8_t fpack[6]; + uint32_t _unused[13]; + uint32_t state; + uint16_t lasti; + uint16_t nbehind; + uint32_t magic; + uint32_t type; +} svfs_superblock_t; + +typedef struct __attribute__ ((__packed__)) { + uint16_t mode; + uint16_t nlink; + uint16_t uid; + uint16_t gid; + uint32_t size; + uint8_t __addr[39]; + uint8_t gen; + uint32_t atime; + uint32_t mtime; + uint32_t ctime; + + uint32_t addr[13]; +} svfs_inode_t; + +typedef struct { + char *error_str; + alloc_pool_t *pool; + partition_t *part; + + svfs_superblock_t superblock; + + uint32_t blocksize; // SVFS can use 512, 1024, 2048, 4096-byte block sizes + +} svfs_t; + +static uint8_t svfs_read_block(svfs_t *mount, uint8_t *block, uint32_t blockno) +{ + const uint32_t sectors_per_block = mount->blocksize / 512; + const uint32_t start_sector = blockno * sectors_per_block; + uint32_t i; + + // printf("sectors_per_block = %u, start_sector=%u\n", sectors_per_block, start_sector); + + for (i=0; ipart, &block[i * 512], start_sector+i); + } + + return 1; +} + +static uint8_t svfs_load_inode(svfs_t *mount, svfs_inode_t *inode, uint32_t inum) +{ + uint32_t i; + uint8_t block[4096]; + const uint32_t max_inode_blocks = mount->superblock.isize - 2; + const uint32_t max_inodes = (max_inode_blocks * mount->blocksize) / 64; + if (inum > max_inodes) { + sprintf(mount->error_str, "svfs_load_inode: inode %u too big (max=%u)", inum, max_inodes); + return 0; + } + + const uint32_t inum_byte_idx_in_partition = ((inum-1) * 64) + (2 * mount->blocksize); + const uint32_t inum_block = inum_byte_idx_in_partition / mount->blocksize; + const uint32_t inum_byte_idx_in_block = inum_byte_idx_in_partition % mount->blocksize; + + if (!svfs_read_block(mount, block, inum_block)) + return 0; + + memcpy(inode, &block[inum_byte_idx_in_block], 64); + + fix_endian(inode->mode); + fix_endian(inode->nlink); + fix_endian(inode->uid); + fix_endian(inode->gid); + fix_endian(inode->size); + fix_endian(inode->atime); + fix_endian(inode->mtime); + fix_endian(inode->ctime); + + for (i=0; i<13; i++) { + uint32_t addr = inode->__addr[i*3 + 0]; + addr = (addr << 8) + inode->__addr[i*3 + 1]; + addr = (addr << 8) + inode->__addr[i*3 + 2]; + inode->addr[i] = addr; + } + + return 1; +} + +static uint8_t svfs_read_level(svfs_t *mount, + svfs_inode_t *inode, + uint8_t *buf, + uint32_t *len, + uint32_t *indirects, + uint32_t level) +{ + uint8_t *tmp = p_alloc(mount->pool, mount->blocksize); + const uint32_t num_indirects = mount->blocksize / 4; + uint32_t i; + + for (i=0; (isize); i++) { + uint32_t chunk_size = inode->size - *len; + if (chunk_size > mount->blocksize) + chunk_size = mount->blocksize; + + const uint32_t addr = ntohl(indirects[i]); + + if (!svfs_read_block(mount, tmp, addr)) { + sprintf(mount->error_str, "couldn't read svfs block num %u at L%u", addr, level); + goto fail; + } + + if (level == 1) { + memcpy(buf + *len, tmp, chunk_size); + *len += chunk_size; + } + else { + if (!svfs_read_level(mount, inode, buf, len, (uint32_t*)tmp, level-1)) + goto fail; + } + } + + p_free(tmp); + return 1; + +fail: + p_free(tmp); + return 0; +} + + +static uint8_t* svfs_read_inode_data(svfs_t *mount, svfs_inode_t *inode) +{ + uint8_t *tmp = p_alloc(mount->pool, mount->blocksize); + uint8_t *buf = p_alloc(mount->pool, inode->size); + uint32_t i, len = 0; + + // The first 10 block pointers in the inode point to data + // The addr[10] is a L1 block pointer, [11] is L2, and [12] is L3 + for (i=0; (len < inode->size) && (i < 10); i++) { + uint32_t chunk_size = inode->size - len; + if (chunk_size > mount->blocksize) + chunk_size = mount->blocksize; + + if (!svfs_read_block(mount, tmp, inode->addr[i])) { + sprintf(mount->error_str, "couldn't read svfs block num %u at L0", inode->addr[i]); + goto fail; + } + + memcpy(buf + len, tmp, chunk_size); + len += chunk_size; + } + + + if (!svfs_read_block(mount, tmp, inode->addr[10])) { + sprintf(mount->error_str, "couldn't read svfs L1 block ptr %u", inode->addr[10]); + goto fail; + } + else if (!svfs_read_level(mount, inode, buf, &len, (uint32_t*)tmp, 1)) + goto fail; + + if (!svfs_read_block(mount, tmp, inode->addr[11])) { + sprintf(mount->error_str, "couldn't read svfs L2 block ptr %u", inode->addr[11]); + goto fail; + } + else if (!svfs_read_level(mount, inode, buf, &len, (uint32_t*)tmp, 2)) + goto fail; + + if (!svfs_read_block(mount, tmp, inode->addr[12])) { + sprintf(mount->error_str, "couldn't read svfs L3 block ptr %u", inode->addr[12]); + goto fail; + } + else if (!svfs_read_level(mount, inode, buf, &len, (uint32_t*)tmp, 3)) + goto fail; + + p_free(tmp); + return buf; + +fail: + p_free(tmp); + p_free(buf); + return NULL; +} + +static svfs_t* svfs_mount(partition_t *part) +{ + assert(sizeof(svfs_superblock_t) == 512); + + uint32_t i; + svfs_t *mount = p_alloc(part->pool, sizeof(svfs_t)); + mount->pool = part->pool; + mount->error_str = part->error_str; + mount->part = part; + + part_get_block(part, (uint8_t*)&mount->superblock, 1); + + fix_endian(mount->superblock.isize); + fix_endian(mount->superblock.fsize); + fix_endian(mount->superblock.nfree); + for (i=0; i<50; i++) { + fix_endian(mount->superblock.free[i]); + } + fix_endian(mount->superblock.ninode); + for (i=0; i<100; i++) { + fix_endian(mount->superblock.inode[i]); + } + fix_endian(mount->superblock.time); + for (i=0; i<4; i++) { + fix_endian(mount->superblock.dinfo[i]); + } + fix_endian(mount->superblock.tfree); + fix_endian(mount->superblock.tinode); + fix_endian(mount->superblock.state); + fix_endian(mount->superblock.lasti); + fix_endian(mount->superblock.nbehind); + fix_endian(mount->superblock.magic); + fix_endian(mount->superblock.type); + + if (mount->superblock.magic != 0xfd187e20) { + sprintf(part->error_str, "Magic doesn't match svfs"); + goto fail; + } + + // It is SVFS! + + const uint32_t type = mount->superblock.type; + if ((type != 1) && (type != 2) && (type != 4) && (type != 8)) { + sprintf(part->error_str, "Unknown SVFS type (%u)", type); + goto fail; + } + + mount->blocksize = 512 * type; + + return mount; + +fail: + if (mount) p_free(mount); + + return NULL; +} + +typedef struct __attribute__ ((__packed__)) { + uint16_t inum; + char name[14]; +} svfs_dir_entry_t; + +svfs_inode_t* svfs_traverse_path(svfs_t *mount, const char *_path) +{ + uint32_t i; + uint16_t inum = 2; // 2 == root + svfs_inode_t *inode = p_alloc(mount->pool, sizeof(svfs_inode_t)); + char *path = p_alloc(mount->pool, strlen(_path)+1); + strcpy(path, _path); + + if (!svfs_load_inode(mount, inode, inum)) + goto fail; + + char *last, *elem; + for (elem = strtok_r(path, "/", &last); + elem; + elem = strtok_r(NULL, "/", &last)) { + //printf("elem = [%s]\n", elem); + const uint32_t num_entries = inode->size / 16; + //printf("inode size = %u\n", inode->size); + svfs_dir_entry_t *dir = (svfs_dir_entry_t*)svfs_read_inode_data(mount, inode); + if (!dir) + goto fail; + + for (i=0; ierror_str, "'%s' in '%s' doesn't exist", elem, _path); + goto fail; + } + } + //printf("final inode size = %u\n", inode->size); + p_free(path); + return inode; + +fail: + p_free(inode); + p_free(path); + return NULL; +} + +/* --- UFS stuff --- */ +#pragma mark UFS stuff + +typedef struct __attribute__ ((__packed__)) { + uint32_t link; + uint32_t rlink; + uint32_t sblkno; + uint32_t cblkno; + uint32_t iblkno; + uint32_t dblkno; + uint32_t cgoffset; + uint32_t cgmask; + uint32_t time; + uint32_t size; + uint32_t dsize; + uint32_t ncg; + uint32_t bsize; + uint32_t fsize; + uint32_t frag; + uint32_t minfree; + uint32_t rotdelay; + uint32_t rps; + uint32_t bmask; + uint32_t fmask; + uint32_t bshift; + uint32_t fshift; + uint32_t maxcontig; + uint32_t maxbpg; + uint32_t fragshift; + uint32_t fsbtodb; + uint32_t sbsize; + uint32_t csmask; + uint32_t csshift; + uint32_t nindir; + uint32_t inopb; + uint32_t nspf; + uint32_t optim; + uint32_t dummy[2]; + uint32_t state; + uint32_t id[2]; + uint32_t csaddr; + uint32_t cssize; + uint32_t cgsize; + uint32_t ntrak; + uint32_t nsect; + uint32_t spc; + uint32_t ncyl; + uint32_t cpg; + uint32_t ipg; + uint32_t fpg; + uint32_t csum_ndir; + uint32_t csum_nbfree; + uint32_t csum_nifree; + uint32_t csum_nffree; + uint8_t fmod; + uint8_t clean; + uint8_t ronly; + uint8_t flags; + uint8_t fsmnt[500]; + uint8_t fname[6]; + uint8_t fpack[6]; + uint32_t cgrotor; + uint32_t dummy2[32]; + uint32_t cpc; + uint16_t postbl[32][8]; + uint32_t magic; +} ufs_superblock_t; + +typedef struct __attribute__ ((__packed__)) { + uint32_t link; + uint32_t rlink; + uint32_t time; + uint32_t cgx; + uint16_t ncyl; + uint16_t niblk; + uint32_t ndblk; + uint32_t csum_ndir; + uint32_t csum_nbfree; + uint32_t csum_nifree; + uint32_t csum_nffree; + uint32_t rotor; + uint32_t frotor; + uint32_t irotor; + uint32_t frsum[8]; + uint32_t btot[32]; + uint16_t b[32][8]; + uint8_t iused[256]; + uint32_t magic; +} ufs_cylinder_group_t; + +typedef struct { + char *error_str; + alloc_pool_t *pool; + partition_t *part; + + uint32_t frag_size; + uint32_t block_size; + uint32_t frag_per_block; + + ufs_superblock_t superblock; + + uint32_t num_groups; + ufs_cylinder_group_t *groups; +} ufs_t; + +typedef struct __attribute__ ((__packed__)) { + uint16_t mode; + uint16_t nlink; + uint16_t uid; + uint16_t gid; + uint64_t size; + uint32_t atime; + uint32_t dummy; + uint32_t mtime; + uint32_t dummy2; + uint32_t ctime; + uint32_t dummy3; + uint32_t direct[12]; + uint32_t indirect[3]; + uint32_t flags; + uint32_t blocks; + uint32_t gen; + uint32_t dummy4[4]; + + +} ufs_inode_t; + +/* + * I truly don't understand the concept behind cgoffset/cgmask, + * but this is apparently the algorithm for finding the fragment-offset + * into a cylinder group. + */ +#define ufs_group_base(mount, num) ( \ + ((mount)->superblock.fpg * (num)) + \ + ((mount)->superblock.cgoffset * \ + ((num) & ~(mount)->superblock.cgmask))) + +static uint8_t ufs_read_frag(ufs_t *mount, uint8_t *frag, uint32_t fragno) +{ + const uint32_t sectors_per_frag = mount->frag_size / 512; + const uint32_t start_sector = fragno * sectors_per_frag; + uint32_t i; + + for (i=0; ipart, &frag[i * 512], start_sector+i); + } + + return 1; +} + +static uint8_t ufs_read_block(ufs_t *mount, uint8_t *block, uint32_t blockno) +{ + uint32_t i; + + /* + * block numbers and fragment numbers are identical - they both refer + * to fragment numbers. But if we're reading a "block", then we're reading + * mount->frag_per_block fragments starting at that block address. + */ + + assert((blockno % mount->frag_per_block) == 0); // This had better align to a block boundary + + for (i=0; ifrag_per_block; i++) { + if (!ufs_read_frag(mount, block + i * mount->frag_size, blockno + i)) + return 0; + } + return 1; +} + +static uint8_t ufs_load_cylinder_group(ufs_t *mount, uint32_t frag_offset, ufs_cylinder_group_t *group) +{ + uint32_t numfrags = sizeof(ufs_cylinder_group_t) / mount->frag_size; + numfrags += ((sizeof(ufs_cylinder_group_t) % mount->frag_size) != 0); + + uint8_t *buf = p_alloc(mount->pool, numfrags * mount->frag_size); + uint32_t i; + + for (i=0; i <= numfrags; i++) + ufs_read_frag(mount, &buf[i * mount->frag_size], frag_offset + i); + memcpy(group, buf, sizeof(ufs_cylinder_group_t)); + + fix_endian(group->link); + fix_endian(group->rlink); + fix_endian(group->time); + fix_endian(group->cgx); + fix_endian(group->ncyl); + fix_endian(group->niblk); + fix_endian(group->ndblk); + fix_endian(group->csum_ndir); + fix_endian(group->csum_nbfree); + fix_endian(group->csum_nifree); + fix_endian(group->csum_nffree); + fix_endian(group->rotor); + fix_endian(group->frotor); + fix_endian(group->irotor); + for (i=0; i<8; i++) + fix_endian(group->frsum[i]); + for (i=0; i<(32*8); i++) + fix_endian(group->b[i/8][i%8]); + fix_endian(group->magic); + + p_free(buf); + return 1; +fail: + p_free(buf); + return 0; +} + +static uint8_t ufs_load_inode(ufs_t *mount, ufs_inode_t *inode, uint32_t inum) +{ + assert(sizeof(ufs_inode_t) == 128); + + /* Which cylinder group is this inode in? */ + const uint32_t group_num = inum / mount->superblock.ipg; + + /* Index of this inode in its cylinder group's inode table */ + const uint32_t group_ino_offset = inum % mount->superblock.ipg; + + /* Fragment address that contains inode */ + const uint32_t frag_addr = ufs_group_base(mount, group_num) + + mount->superblock.iblkno + + ((group_ino_offset * 128) / mount->frag_size); + + /* Byte offset into the fragment where the inode begins */ + const uint32_t frag_offset = (group_ino_offset * 128) % mount->frag_size; + + uint32_t i; + uint8_t *buf = p_alloc(mount->pool, mount->frag_size); + + // printf("group_num = %u, ino_offset=%u, addr = 0x%08x, offset = 0x%08x\n", group_num, group_ino_offset, frag_addr, frag_offset); + // printf("mount->superblock.iblkno = 0x%08x\n", mount->superblock.iblkno); + + if (!ufs_read_frag(mount, buf, frag_addr)) + goto fail; + + memcpy(inode, buf + frag_offset, 128); + + fix_endian(inode->mode); + fix_endian(inode->nlink); + fix_endian(inode->uid); + fix_endian(inode->gid); + fix_endian(inode->size); + fix_endian(inode->atime); + fix_endian(inode->mtime); + fix_endian(inode->ctime); + for (i=0; i<12; i++) + fix_endian(inode->direct[i]); + for (i=0; i<3; i++) + fix_endian(inode->indirect[i]); + fix_endian(inode->flags); + fix_endian(inode->blocks); + fix_endian(inode->gen); + + p_free(buf); + return 1; +fail: + if (buf) + p_free(buf); + return 0; +} + +static uint8_t ufs_read_level(ufs_t *mount, + ufs_inode_t *inode, + uint8_t *buf, + uint64_t *len, + uint32_t indirect_blockno, + uint32_t level) +{ + if (inode->size <= *len) + return 1; + + uint32_t *table = p_alloc(mount->pool, mount->block_size); + uint8_t *block = NULL; + + const uint32_t num_pointers = mount->block_size / 4; + uint32_t i; + + if (!ufs_read_block(mount, (uint8_t*)table, indirect_blockno)) + goto fail; + + // for (i=0; ipool, mount->block_size); + + for (i=0; (i < num_pointers) && (inode->size > *len); i++) { + const uint32_t blockno = ntohl(table[i]); + + if (level == 1) { + // direct block + uint64_t chunk_size = inode->size - *len; + if (chunk_size > mount->block_size) chunk_size = mount->block_size; + + // Which block are we reading, and at which byte-offset into it does our data exist + const uint32_t block_addr = (blockno / mount->frag_per_block) * mount->frag_per_block; + const uint32_t block_offset = (blockno - block_addr) * mount->frag_size; + + //printf("L%u: raw_blkno=0x%08x len=0x%08x blockno:0x%08x chunk_size=0x%08x\n", level-1, blockno, (uint32_t)*len, block_addr, (uint32_t)chunk_size); + + // If the chunk_size is a whole block, then we better be reading in a whole block + if (chunk_size == mount->block_size) { + // printf("block_offset = 0x%x\n", block_offset); + assert(block_offset == 0); + } + + if (!ufs_read_block(mount, block, block_addr)) + goto fail; + + memcpy(buf + *len, block + block_offset, chunk_size); + (*len) += chunk_size; + } + else { + // indirect block + if (!ufs_read_level(mount, inode, buf, len, blockno, level-1)) + goto fail; + } + } + + if (block) + p_free(block); + p_free(table); + return 1; +fail: + if (block) + p_free(block); + p_free(table); + return 0; +} + +static uint8_t* ufs_read_inode_data(ufs_t *mount, ufs_inode_t *inode) +{ + uint32_t i, j; + uint8_t *block = p_alloc(mount->pool, mount->block_size); + uint8_t *buf = p_alloc(mount->pool, inode->size); + uint64_t len = 0; + + /* Read in direct blocks */ + for (i=0; (i<12) && (len < inode->size); i++) { + + // How many bytes are we reading from this block? + uint64_t chunk_size = inode->size - len; + if (chunk_size > mount->block_size) chunk_size = mount->block_size; + + // Which block are we reading, and at which byte-offset into it does our data exist + const uint32_t block_addr = (inode->direct[i] / mount->frag_per_block) * mount->frag_per_block; + const uint32_t block_offset = (inode->direct[i] - block_addr) * mount->frag_size; + + // printf("block_addr=0x%08x, block_offset") + + // If the chunk_size is a whole block, then we better be reading in a whole block + if (chunk_size == mount->block_size) + assert(block_offset == 0); + + if (!ufs_read_block(mount, block, block_addr)) + goto fail; + + memcpy(buf + len, block + block_offset, chunk_size); + + len += chunk_size; + // printf("direct block %u = 0x%08x\n", i, inode->direct[i]); + } + + + for (i=0; i<3; i++) { + if (!ufs_read_level(mount, inode, buf, &len, inode->indirect[i], i+1)) + goto fail; + } + + + p_free(block); + return buf; +fail: + p_free(block); + p_free(buf); + return NULL; +} + +typedef struct __attribute__ ((__packed__)) { + uint32_t inum; + uint16_t len; + uint16_t namelen; + char name[1]; +} ufs_dir_t; + +ufs_inode_t* ufs_traverse_path(ufs_t *mount, const char *_path) +{ + uint32_t i; + uint32_t inum = 2; // 2 == root + ufs_inode_t *inode = p_alloc(mount->pool, sizeof(ufs_inode_t)); + char *path = p_alloc(mount->pool, strlen(_path)+1); + strcpy(path, _path); + + if (!ufs_load_inode(mount, inode, inum)) + goto fail; + + char *last, *elem; + for (elem = strtok_r(path, "/", &last); + elem; + elem = strtok_r(NULL, "/", &last)) { + + uint32_t next_inum = 0; + uint8_t *dir = ufs_read_inode_data(mount, inode); + if (!dir) + goto fail; + + for (i=0; inode->size; ) { + ufs_dir_t *entry = (ufs_dir_t*)&dir[i]; + fix_endian(entry->inum); + fix_endian(entry->len); + fix_endian(entry->namelen); + + if (entry->inum == 0) + break; + + if ((entry->namelen == strlen(elem)) && + (strncmp(elem, entry->name, entry->namelen) == 0)) { + next_inum = entry->inum; + break; + } + + i += entry->len; + } + + p_free(dir); + + if (next_inum == 0) { + sprintf(mount->error_str, "'%s' in '%s' doesn't exist", elem, _path); + goto fail; + } + + inum = next_inum; + if (!ufs_load_inode(mount, inode, inum)) + goto fail; + } + + p_free(path); + return inode; + +fail: + p_free(inode); + p_free(path); + return NULL; +} + +static ufs_t* ufs_mount(partition_t *part) +{ + ufs_t *mount = p_alloc(part->pool, sizeof(ufs_t)); + uint8_t *buf = p_alloc(part->pool, 32 * 512); + uint32_t i; + + mount->pool = part->pool; + mount->part = part; + mount->error_str = part->error_str; + + for (i=0; i<4; i++) + part_get_block(part, &buf[i*512], 16 + i); + memcpy(&mount->superblock, buf, sizeof(ufs_superblock_t)); + + fix_endian(mount->superblock.link); + fix_endian(mount->superblock.rlink); + fix_endian(mount->superblock.sblkno); + fix_endian(mount->superblock.cblkno); + fix_endian(mount->superblock.iblkno); + fix_endian(mount->superblock.dblkno); + fix_endian(mount->superblock.cgoffset); + fix_endian(mount->superblock.cgmask); + fix_endian(mount->superblock.time); + fix_endian(mount->superblock.size); + fix_endian(mount->superblock.dsize); + fix_endian(mount->superblock.ncg); + fix_endian(mount->superblock.bsize); + fix_endian(mount->superblock.fsize); + fix_endian(mount->superblock.frag); + fix_endian(mount->superblock.minfree); + fix_endian(mount->superblock.rotdelay); + fix_endian(mount->superblock.rps); + fix_endian(mount->superblock.bmask); + fix_endian(mount->superblock.fmask); + fix_endian(mount->superblock.bshift); + fix_endian(mount->superblock.fshift); + fix_endian(mount->superblock.maxcontig); + fix_endian(mount->superblock.maxbpg); + fix_endian(mount->superblock.fragshift); + fix_endian(mount->superblock.fsbtodb); + fix_endian(mount->superblock.sbsize); + fix_endian(mount->superblock.csmask); + fix_endian(mount->superblock.csshift); + fix_endian(mount->superblock.nindir); + fix_endian(mount->superblock.inopb); + fix_endian(mount->superblock.nspf); + fix_endian(mount->superblock.optim); + fix_endian(mount->superblock.state); + fix_endian(mount->superblock.id[0]); + fix_endian(mount->superblock.id[1]); + fix_endian(mount->superblock.csaddr); + fix_endian(mount->superblock.cssize); + fix_endian(mount->superblock.cgsize); + fix_endian(mount->superblock.ntrak); + fix_endian(mount->superblock.nsect); + fix_endian(mount->superblock.spc); + fix_endian(mount->superblock.ncyl); + fix_endian(mount->superblock.cpg); + fix_endian(mount->superblock.ipg); + fix_endian(mount->superblock.fpg); + fix_endian(mount->superblock.csum_ndir); + fix_endian(mount->superblock.csum_nbfree); + fix_endian(mount->superblock.csum_nifree); + fix_endian(mount->superblock.csum_nffree); + fix_endian(mount->superblock.cgrotor); + fix_endian(mount->superblock.cpc); + for (i=0; i<(32*8); i++) + fix_endian(mount->superblock.postbl[i/8][i%8]); + fix_endian(mount->superblock.magic); + + + if (mount->superblock.magic != 0x00011954) { + sprintf(part->error_str, "Magic doesn't match ufs"); + goto fail; + } + + // It is UFS! + + mount->frag_size = mount->superblock.fsize; + mount->frag_per_block = mount->superblock.frag; + mount->block_size = mount->frag_size * mount->frag_per_block; + assert(mount->block_size == mount->superblock.bsize); + + mount->num_groups = mount->superblock.ncg; + mount->groups = (ufs_cylinder_group_t*)p_alloc(mount->pool, + mount->num_groups * sizeof(ufs_cylinder_group_t)); + + for (i=0; inum_groups; i++) { + uint32_t group_base = ufs_group_base(mount, i) + mount->superblock.cblkno; + ufs_load_cylinder_group(mount, group_base, &mount->groups[i]); + if ((mount->groups[i].cgx != i) || (mount->groups[i].magic != 0x00090255)) { + sprintf(mount->error_str, "bad cylinder group %u frag_offset=0x%x", i, group_base); + goto fail; + } + } + + if (buf) + p_free(buf); + return mount; +fail: + if (mount) { + if (mount->groups) + p_free(mount->groups); + p_free(mount); + } + if (buf) + p_free(buf); + return NULL; +} + + + +/* --- Public interfaces --- */ +#pragma mark Public interfaces + + +uint8_t* shoebill_extract_kernel(const char *disk_path, const char *kernel_path, char *error_str, uint32_t *len) +{ + uint8_t *pool_data, *kernel_data = NULL; + disk_t *disk; + svfs_t *svfs_mount_obj; + ufs_t *ufs_mount_obj; + int32_t apm_part_num; + + strcpy(error_str, ""); + + disk = open_disk(disk_path, error_str); + if (!disk) + goto done; + + apm_part_num = find_root_partition_number(disk, 0); + if (apm_part_num == -1) { + sprintf(error_str, "Couldn't find root partition"); + goto done; + } + + svfs_mount_obj = svfs_mount(&disk->partitions[apm_part_num]); + if (svfs_mount_obj) { + svfs_inode_t *inode = svfs_traverse_path(svfs_mount_obj, kernel_path); + if (!inode) + goto done; + + pool_data = svfs_read_inode_data(svfs_mount_obj, inode); + if (!pool_data) + goto done; + + kernel_data = malloc(inode->size); + memcpy(kernel_data, pool_data, inode->size); + *len = inode->size; + goto done; + } + + ufs_mount_obj = ufs_mount(&disk->partitions[apm_part_num]); + if (ufs_mount_obj) { + ufs_inode_t *inode = ufs_traverse_path(ufs_mount_obj, kernel_path); + if (!inode) + goto done; + + pool_data = ufs_read_inode_data(ufs_mount_obj, inode); + if (!pool_data) + goto done; + + kernel_data = malloc(inode->size); + memcpy(kernel_data, pool_data, inode->size); + *len = inode->size; + goto done; + } + + sprintf(error_str, "I can read the partition map, but the filesystem doesn't seem to be UFS or SVFS"); + +done: + if (strlen(error_str)) + printf("error: [%s]\n", error_str); + if (disk) + close_disk(disk); + return kernel_data; +} + +/*int main (int argc, char **argv) +{ + uint8_t *buf; + uint32_t size; + char error_str[1024]; + + buf = extract_kernel(argv[1], argv[2], error_str, &size); + if (!buf) + return 0; + + FILE *f = fopen("result", "w"); + fwrite(buf, size, 1, f); + fclose(f); + + return 0; +}*/ + + + diff --git a/core/fpu.c b/core/fpu.c index 05cb7fc..91f9d0c 100644 --- a/core/fpu.c +++ b/core/fpu.c @@ -258,7 +258,8 @@ void inst_fpu_decode () } printf("inst_fpu_decode: unhandled instruction: %s op=0x%04x ext = 0x%04x pc=0x%08x\n", fpu_inst_table[name].name, shoe.op, ext, shoe.orig_pc); - dbg_state.running = 0; + assert(!"unknown fpu inst"); + //dbg_state.running = 0; } diff --git a/core/mem.c b/core/mem.c index 616ac7e..3d4b535 100644 --- a/core/mem.c +++ b/core/mem.c @@ -365,6 +365,9 @@ void _logical_get (void) void logical_set (void) { + if ((shoe.logical_addr >= 0xaf2) && (shoe.logical_addr < 0xaf6) && (shoe.logical_size == 1) && ((shoe.logical_dat&0xff) == 0xff)) { + shoe.logical_dat = 0; + } // if ((shoe.logical_addr >= 0x12fffff6) && (shoe.logical_addr <= 0x12ffffff)) // printf("aux3: setting 0x%08x = 0x%x\n", shoe.logical_addr, (uint32_t)shoe.logical_dat); // diff --git a/core/debugger.c b/core/old_debugger.c similarity index 100% rename from core/debugger.c rename to core/old_debugger.c diff --git a/core/shoebill.h b/core/shoebill.h index 9f2a800..6bede22 100644 --- a/core/shoebill.h +++ b/core/shoebill.h @@ -26,10 +26,12 @@ #ifndef _SHOEBILL_H #define _SHOEBILL_H +#include #include #include #include -#include +#include +//#include #include "coff.h" @@ -138,13 +140,14 @@ typedef struct dbg_breakpoint_t { uint64_t num; } dbg_breakpoint_t; -struct dbg_state_t { - EditLine *el; - uint8_t running; +typedef struct { + // EditLine *el; + uint8_t mode; + uint8_t ignore_interrupts; + uint8_t connected; uint64_t breakpoint_counter; dbg_breakpoint_t *breakpoints; -}; -extern struct dbg_state_t dbg_state; +} debugger_state_t; typedef enum { adb_talk, @@ -257,7 +260,6 @@ typedef struct { typedef struct { #define SHOEBILL_STATE_STOPPED (1<<9) -#define SHOEBILL_STATE_SWITCH_MODE (1<<10) // bits 0-6 are CPU interrupt priorities // bit 8 indicates that STOP was called @@ -267,13 +269,6 @@ typedef struct { pthread_mutex_t via_clock_thread_lock; pthread_mutex_t cpu_freeze_lock; -#define CPU_MODE_FAST 0 -#define CPU_MODE_DEBUG 1 -#define CPU_MODE_STEPI 2 -#define CPU_MODE_STEPI_COMPLETE 3 -#define CPU_MODE_FREEZE 4 - uint32_t cpu_mode; - // -- PMMU caching structures --- struct { pmmu_cache_entry_t entry[512]; @@ -427,7 +422,6 @@ typedef struct { via_clock_t via_clocks; - uint32_t dbg; struct timeval start_time; // when the emulator started (for computing timer interrupts) uint64_t total_ticks; // how many 60hz ticks have been generated @@ -437,6 +431,8 @@ typedef struct { coff_file *launch; // FIXME: delete me: coff symbols from aux 1.1.1 launch binary scsi_device_t scsi_devices[8]; // SCSI devices + + debugger_state_t dbg; } global_shoebill_context_t; extern global_shoebill_context_t shoe; // declared in cpu.c @@ -448,7 +444,7 @@ void fpu_setup_jump_table(); // cpu.c fuctions void cpu_step (void); -inline void inst_decode (void); +void inst_decode (void); // exception.c functions @@ -463,10 +459,10 @@ void throw_frame_two (uint16_t sr, uint32_t next_pc, uint32_t vector_num, uint32 // mem.c functions -void inline physical_get (void); +void physical_get (void); #define pget(addr, s) ({shoe.physical_addr=(addr); shoe.physical_size=(s); physical_get(); shoe.physical_dat;}) -void inline logical_get (void); +void logical_get (void); #define lget_fc(addr, s, fc) ({ \ shoe.logical_addr=(addr); \ shoe.logical_size=(s); \ @@ -483,10 +479,10 @@ void inline logical_get (void); shoe.logical_dat; \ }) -void inline physical_set (void); +void physical_set (void); #define pset(addr, s, val) {shoe.physical_addr=(addr); shoe.physical_size=(s); shoe.physical_dat=(val); physical_set();} -void inline logical_set (void); +void logical_set (void); #define lset_fc(addr, s, val, fc) {\ shoe.logical_addr=(addr); \ shoe.logical_size=(s); \ @@ -536,7 +532,7 @@ void ea_addr(); void disassemble_inst(uint8_t binary[24], uint32_t orig_pc, char *str, uint32_t *instlen); char* decode_ea_rw (uint8_t mr, uint8_t sz); char* decode_ea_addr (uint8_t mr); -inline void dis_decode(void); +void dis_decode(void); uint16_t dis_next_word (void); char* decode_ea_addr (uint8_t mr); char* decode_ea_rw (uint8_t mr, uint8_t sz); @@ -630,5 +626,9 @@ uint32_t nubus_video_read_func(const uint32_t rawaddr, const uint32_t size, void nubus_video_write_func(const uint32_t rawaddr, const uint32_t size, const uint32_t data, const uint8_t slotnum); +// debug_server.c +void *debug_cpu_thread (void *arg); + + #endif // _SHOEBILL_H diff --git a/core/via.c b/core/via.c index 582e7b9..44ceed3 100644 --- a/core/via.c +++ b/core/via.c @@ -414,6 +414,7 @@ void *via_clock_thread(void *arg) } // Check if any nubus cards have interrupt timers + shoe.via[1].rega = 0b00111111; for (i=9; i<15; i++) { if (!shoe.slots[i].connected) continue; @@ -424,7 +425,8 @@ void *via_clock_thread(void *arg) fire(1.0L/shoe.slots[i].interrupt_rate); if (shoe.slots[i].interrupts_enabled) { - shoe.via[1].rega = 0b00111111 & ~~(1<<(i-9)); + // shoe.via[1].rega = 0b00111111 & ~~(1<<(i-9)); + shoe.via[1].rega &= 0b00111111 & ~~(1<<(i-9)); via_raise_interrupt(2, IFR_CA1); printf("Fired nubus interrupt %u\n", i); } diff --git a/gui/Shoebill.xcodeproj/project.pbxproj b/gui/Shoebill.xcodeproj/project.pbxproj index 1cd5e59..f442d1e 100644 --- a/gui/Shoebill.xcodeproj/project.pbxproj +++ b/gui/Shoebill.xcodeproj/project.pbxproj @@ -256,9 +256,10 @@ isa = XCBuildConfiguration; buildSettings = { ALWAYS_SEARCH_USER_PATHS = NO; + ARCHS = "$(ARCHS_STANDARD_32_64_BIT)"; CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; CLANG_CXX_LIBRARY = "libc++"; - CLANG_ENABLE_OBJC_ARC = YES; + CLANG_ENABLE_OBJC_ARC = NO; CLANG_WARN_BOOL_CONVERSION = YES; CLANG_WARN_CONSTANT_CONVERSION = YES; CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; @@ -284,8 +285,9 @@ GCC_WARN_UNUSED_FUNCTION = YES; GCC_WARN_UNUSED_VARIABLE = YES; MACOSX_DEPLOYMENT_TARGET = 10.8; - ONLY_ACTIVE_ARCH = YES; - SDKROOT = macosx; + ONLY_ACTIVE_ARCH = NO; + SDKROOT = macosx10.8; + VALID_ARCHS = "x86_64 i386"; }; name = Debug; }; @@ -293,9 +295,10 @@ isa = XCBuildConfiguration; buildSettings = { ALWAYS_SEARCH_USER_PATHS = NO; + ARCHS = "$(ARCHS_STANDARD_32_64_BIT)"; CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; CLANG_CXX_LIBRARY = "libc++"; - CLANG_ENABLE_OBJC_ARC = YES; + CLANG_ENABLE_OBJC_ARC = NO; CLANG_WARN_BOOL_CONVERSION = YES; CLANG_WARN_CONSTANT_CONVERSION = YES; CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; @@ -316,15 +319,19 @@ GCC_WARN_UNUSED_FUNCTION = YES; GCC_WARN_UNUSED_VARIABLE = YES; MACOSX_DEPLOYMENT_TARGET = 10.8; - SDKROOT = macosx; + SDKROOT = macosx10.8; + VALID_ARCHS = "x86_64 i386"; }; name = Release; }; 87F9775A18987700000D589E /* Debug */ = { isa = XCBuildConfiguration; buildSettings = { + ARCHS = "$(ARCHS_STANDARD_32_64_BIT)"; ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + CLANG_ENABLE_OBJC_ARC = NO; COMBINE_HIDPI_IMAGES = YES; + GCC_FAST_OBJC_DISPATCH = YES; GCC_PRECOMPILE_PREFIX_HEADER = YES; GCC_PREFIX_HEADER = "Shoebill/Shoebill-Prefix.pch"; INFOPLIST_FILE = "Shoebill/Shoebill-Info.plist"; @@ -332,7 +339,9 @@ "$(inherited)", ../intermediates, ); + ONLY_ACTIVE_ARCH = NO; PRODUCT_NAME = "$(TARGET_NAME)"; + SDKROOT = macosx10.8; WRAPPER_EXTENSION = app; }; name = Debug; @@ -340,8 +349,11 @@ 87F9775B18987700000D589E /* Release */ = { isa = XCBuildConfiguration; buildSettings = { + ARCHS = "$(ARCHS_STANDARD_32_64_BIT)"; ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + CLANG_ENABLE_OBJC_ARC = NO; COMBINE_HIDPI_IMAGES = YES; + GCC_FAST_OBJC_DISPATCH = YES; GCC_PRECOMPILE_PREFIX_HEADER = YES; GCC_PREFIX_HEADER = "Shoebill/Shoebill-Prefix.pch"; INFOPLIST_FILE = "Shoebill/Shoebill-Info.plist"; @@ -350,6 +362,7 @@ ../intermediates, ); PRODUCT_NAME = "$(TARGET_NAME)"; + SDKROOT = macosx10.8; WRAPPER_EXTENSION = app; }; name = Release; diff --git a/gui/Shoebill/Shoebill-Info.plist b/gui/Shoebill/Shoebill-Info.plist index 620d65b..0698ae1 100644 --- a/gui/Shoebill/Shoebill-Info.plist +++ b/gui/Shoebill/Shoebill-Info.plist @@ -16,10 +16,12 @@ ${PRODUCT_NAME} CFBundlePackageType APPL - CFBundleVersion - 0.0.1 + CFBundleShortVersionString + 0.0.2 CFBundleSignature ???? + CFBundleVersion + 0.0.2 LSMinimumSystemVersion ${MACOSX_DEPLOYMENT_TARGET} NSMainNibFile diff --git a/gui/Shoebill/shoeApplication.m b/gui/Shoebill/shoeApplication.m index 839ea41..51f5a5d 100644 --- a/gui/Shoebill/shoeApplication.m +++ b/gui/Shoebill/shoeApplication.m @@ -307,7 +307,12 @@ return ; } - [self createScreenWindow:10 height:height width:width refresh_freq:200.0/3.0]; + [self createScreenWindow:9 height:height width:width refresh_freq:200.0/3.0]; + /*[self createScreenWindow:10 height:height width:width refresh_freq:200.0/3.0]; + [self createScreenWindow:11 height:height width:width refresh_freq:200.0/3.0]; + [self createScreenWindow:12 height:height width:width refresh_freq:200.0/3.0]; + [self createScreenWindow:13 height:height width:width refresh_freq:200.0/3.0]; + [self createScreenWindow:14 height:height width:width refresh_freq:200.0/3.0];*/ shoebill_start(); isRunning = true; diff --git a/gui/Shoebill/shoePreferencesWindowController.m b/gui/Shoebill/shoePreferencesWindowController.m index e923d7d..14e46f3 100644 --- a/gui/Shoebill/shoePreferencesWindowController.m +++ b/gui/Shoebill/shoePreferencesWindowController.m @@ -105,7 +105,7 @@ if ([urls count] != 1) return ; - NSURL *url = [urls firstObject]; + NSURL *url = [urls objectAtIndex:0]; if (![url isFileURL]) return ; diff --git a/gui/Shoebill/shoeScreenView.m b/gui/Shoebill/shoeScreenView.m index 47c08c1..fcc93b9 100644 --- a/gui/Shoebill/shoeScreenView.m +++ b/gui/Shoebill/shoeScreenView.m @@ -73,11 +73,17 @@ colorspace = CGColorSpaceCreateDeviceRGB(); timer = [NSTimer - scheduledTimerWithTimeInterval:(0.015/2.0) + scheduledTimerWithTimeInterval:0.001 target:self selector:@selector(timerFireMethod:) userInfo:nil repeats:YES]; + [[NSRunLoop currentRunLoop] addTimer:timer + forMode:NSDefaultRunLoopMode]; + [[NSRunLoop currentRunLoop] addTimer:timer + forMode:NSEventTrackingRunLoopMode]; + + shoebill_card_video_t *video = &control->slots[10].card.video; NSSize size = { @@ -106,7 +112,8 @@ maxX = NSMaxX(bounds); maxY = NSMaxY(bounds); - //[self update]; + GLint swapInt = 1; + [[self openGLContext] setValues:&swapInt forParameter:NSOpenGLCPSwapInterval]; if(NSIsEmptyRect([self visibleRect])) { @@ -180,7 +187,16 @@ static void _do_clut_translation(shoebill_card_video_t *ctx) glClearColor(0.0, 0.0, 0.0, 0.0); if (shoeApp->isRunning) { - shoebill_card_video_t *video = &control->slots[10].card.video; + uint8_t slotnum = ((shoeScreenWindow*)[self window])->slotnum; + shoebill_card_video_t *video = &control->slots[slotnum].card.video; + + /*NSSize size = { + .height=video->height, + .width=video->width + }; + [self setFrameSize:size]; + [[self window] setContentSize:size];*/ + _do_clut_translation(video); glViewport(0, 0, video->width, video->height); glRasterPos2i(0, video->height); diff --git a/gui/Shoebill/shoeScreenWindow.m b/gui/Shoebill/shoeScreenWindow.m index 765016d..2f127ae 100644 --- a/gui/Shoebill/shoeScreenWindow.m +++ b/gui/Shoebill/shoeScreenWindow.m @@ -32,6 +32,16 @@ - (void)configure:(uint8_t) _slotnum { slotnum = _slotnum; + + shoeApplication *shoeApp = (shoeApplication*) NSApp; + shoebill_control_t *control = &shoeApp->control; + shoebill_card_video_t *video = &control->slots[slotnum].card.video; + NSSize size = { + .height=video->height, + .width=video->width + }; + + [self setContentSize:size]; } // Called after all the shoeScreenWindows are created and configured, @@ -107,4 +117,5 @@ [self setTitle:@"Shoebill - Screen 1 (Ctrl-click to escape)"]; } + @end diff --git a/test.c b/test.c deleted file mode 100644 index 0842caa..0000000 --- a/test.c +++ /dev/null @@ -1,407 +0,0 @@ -#include -#include -#include -#include -#include -#include - -#include - -#include "core/shoebill.h" -#include "core/core_api.h" - -shoebill_control_t control; -shoebill_card_video_t *video_card = NULL; - -void glut_display_func (void) -{ - uint32_t myw = glutGet(GLUT_WINDOW_WIDTH); - uint32_t myh = glutGet(GLUT_WINDOW_HEIGHT); - uint32_t slotnum, i; - shoebill_card_video_t *ctx = video_card; - - glMatrixMode(GL_PROJECTION); - glLoadIdentity(); - glOrtho(0, myw, 0, myh, 0, 1); - glMatrixMode(GL_MODELVIEW); - glLoadIdentity(); - - glClear(GL_COLOR_BUFFER_BIT); - - glColor3f(0.1, 0.1, 0.8); - - uint32_t gli = 0; - - switch (ctx->depth) { - case 1: { - for (i=0; i < ctx->pixels/8; i++) { - const uint8_t byte = ctx->indexed_buf[i]; - ctx->direct_buf[i * 8 + 0] = ctx->clut[(byte >> 7) & 1]; - ctx->direct_buf[i * 8 + 1] = ctx->clut[(byte >> 6) & 1]; - ctx->direct_buf[i * 8 + 2] = ctx->clut[(byte >> 5) & 1]; - ctx->direct_buf[i * 8 + 3] = ctx->clut[(byte >> 4) & 1]; - ctx->direct_buf[i * 8 + 4] = ctx->clut[(byte >> 3) & 1]; - ctx->direct_buf[i * 8 + 5] = ctx->clut[(byte >> 2) & 1]; - ctx->direct_buf[i * 8 + 6] = ctx->clut[(byte >> 1) & 1]; - ctx->direct_buf[i * 8 + 7] = ctx->clut[(byte >> 0) & 1]; - } - break; - } - case 2: { - for (i=0; i < ctx->pixels/4; i++) { - const uint8_t byte = ctx->indexed_buf[i]; - ctx->direct_buf[i * 4 + 0] = ctx->clut[(byte >> 6) & 3]; - ctx->direct_buf[i * 4 + 1] = ctx->clut[(byte >> 4) & 3]; - ctx->direct_buf[i * 4 + 2] = ctx->clut[(byte >> 2) & 3]; - ctx->direct_buf[i * 4 + 3] = ctx->clut[(byte >> 0) & 3]; - } - break; - } - case 4: { - for (i=0; i < ctx->pixels/2; i++) { - const uint8_t byte = ctx->indexed_buf[i]; - ctx->direct_buf[i * 2 + 0] = ctx->clut[(byte >> 4) & 0xf]; - ctx->direct_buf[i * 2 + 1] = ctx->clut[(byte >> 0) & 0xf]; - } - break; - } - case 8: - for (i=0; i < ctx->pixels; i++) - ctx->direct_buf[i] = ctx->clut[ctx->indexed_buf[i]]; - break; - - default: - assert(!"unknown depth"); - } - - glViewport(0, 0, myw, myh); - glRasterPos2i(0, myh); - glPixelStorei(GL_UNPACK_LSB_FIRST, GL_TRUE); - glPixelStorei(GL_UNPACK_ALIGNMENT, 1); - - glPixelZoom(1.0, -1.0); - - glDrawPixels(myw, myh, GL_RGBA, GL_UNSIGNED_BYTE, ctx->direct_buf); - - glFlush(); -} - -/*void vbl_callback (shoebill_control_t *ctrl, uint8_t slotnum) -{ - - -} - -void video_depth_calback (sheobill_control_t *ctrl, uint8_t slotnum) -{ - - -}*/ - -#define KEY_SHIFT 1 - -const struct { - uint8_t code; - char c; - uint8_t modifiers; -} key_codes[] = { - {0x0, 'A', 0}, - {0x1, 'S', 0}, - {2, 'D', 0}, - {3, 'F', 0}, - {4, 'H', 0}, - {5, 'G', 0}, - {6, 'Z', 0}, - {7, 'X', 0}, - {8, 'C', 0}, - {9, 'V', 0}, - // {0xa ?? - {0xb, 'B', 0}, - {0xc, 'Q', 0}, - {0xd, 'W', 0}, - {0xe, 'E', 0}, - {0xf, 'R', 0}, - {0x10, 'Y', 0}, - {0x11, 'T', 0}, - - {0x12, '1', 0}, - {0x12, '!', KEY_SHIFT}, - - - {0x13, '2', 0}, - {0x13, '@', KEY_SHIFT}, - - {0x14, '3', 0}, - {0x14, '#', KEY_SHIFT}, - - {0x15, '4', 0}, - {0x15, '$', KEY_SHIFT}, - - {0x16, '6', 0}, - {0x16, '^', KEY_SHIFT}, - - {0x17, '5', 0}, - {0x17, '%', KEY_SHIFT}, - - {0x18, '=', 0}, - {0x18, '+', KEY_SHIFT}, - - {0x19, '9', 0}, - {0x19, '(', KEY_SHIFT}, - - {0x1a, '7', 0}, - {0x1a, '&', KEY_SHIFT}, - - {0x1b, '-', 0}, - {0x1b, '_', KEY_SHIFT}, - - {0x1c, '8', 0}, - {0x1c, '*', KEY_SHIFT}, - - {0x1d, '0', 0}, - {0x1d, ')', KEY_SHIFT}, - - {0x1e, ']', 0}, - {0x1e, '}', KEY_SHIFT}, - - {0x1f, 'O', 0}, - {0x20, 'U', 0}, - - {0x21, '[', 0}, - {0x21, '{', KEY_SHIFT}, - - {0x22, 'I', 0}, - {0x23, 'P', 0}, - - {0x24, '\n', 0}, - {0x24, '\r', 0}, - - {0x25, 'L', 0}, - {0x26, 'J', 0}, - - {0x27, '"', KEY_SHIFT}, - {0x27, '\'', 0}, - - {0x28, 'K', 0}, - - {0x29, ';', 0}, - {0x29, ':', KEY_SHIFT}, - - {0x2a, '\\', 0}, - {0x2a, '|', KEY_SHIFT}, - - {0x2b, ',', 0}, - {0x2b, '<', KEY_SHIFT}, - - {0x2c, '/', 0}, - {0x2c, '?', 0}, - - {0x2d, 'N', 0}, - {0x2e, 'M', 0}, - - {0x2f, '.', 0}, - {0x2f, '>', KEY_SHIFT}, - - {0x30, '\t', 0}, - {0x31, ' ', 0}, - - {0x32, '`', 0}, - {0x32, '~', KEY_SHIFT}, - - {0x33, '\b', 0}, - {0x33, 0x7f, 0}, - // {0x34, ?? - // {0x35 // escape char - // 0x36 // ctrl - // 0x37 // command - // 0x38 // shift - // 0x39 // caps lock - // 0x3a // option - // 0x3b // left arrow - // 0x3c // right arrow - // 0x3d // down arrow - // 0x3e // up arrow - - {0, 0, 0}, -}; - -static uint8_t lookup_key(char c) -{ - uint32_t i; - uint8_t upper=toupper(c); - - for (i=0; key_codes[i].c; i++) { - if (key_codes[i].c == upper) - return key_codes[i].code; - - } - - return 0xff; -} - -static uint8_t lookup_special(int special) -{ - switch (special) { - case GLUT_KEY_UP: return 0x3e; - case GLUT_KEY_DOWN: return 0x3d; - case GLUT_KEY_LEFT: return 0x3b; - case GLUT_KEY_RIGHT: return 0x3c; - default: return 0xff; - } -} - -static void keyboard_add_entry(uint8_t code, uint8_t up) -{ - uint8_t up_mask = up ? 0x80 : 0; - uint32_t i; - int modifiers = glutGetModifiers(); - - assert(pthread_mutex_lock(&shoe.adb.lock) == 0); - - if ((shoe.key.key_i+1) < KEYBOARD_STATE_MAX_KEYS) { - if (modifiers & GLUT_ACTIVE_SHIFT) { - shoe.key.keys[shoe.key.key_i].code_a = 0x38; - shoe.key.keys[shoe.key.key_i].code_b = 0xff; - shoe.key.key_i++; - } - else if (shoe.key.down_modifiers & GLUT_ACTIVE_SHIFT) { - shoe.key.keys[shoe.key.key_i].code_a = 0x80 | 0x38; - shoe.key.keys[shoe.key.key_i].code_b = 0xff; - shoe.key.key_i++; - } - shoe.key.keys[shoe.key.key_i].code_a = code | up_mask; - shoe.key.keys[shoe.key.key_i].code_b = 0xff; - shoe.key.key_i++; - } - - shoe.key.down_modifiers = modifiers; - - adb_request_service_request(2); - - pthread_mutex_unlock(&shoe.adb.lock); -} - -void global_mouse_func (int button, int state, int x, int y) -{ - //if (button != GLUT_LEFT_BUTTON) - // return ; - - assert(pthread_mutex_lock(&shoe.adb.lock) == 0); - - shoe.mouse.button_down = (state == GLUT_DOWN); - shoe.mouse.changed = 1; - - adb_request_service_request(3); - - pthread_mutex_unlock(&shoe.adb.lock); - - // printf("mouse_func: setting service request\n"); -} - -static void move_mouse (int x, int y, uint8_t button_down) -{ - printf("%s: lock\n", __func__); fflush(stdout); - assert(pthread_mutex_lock(&shoe.adb.lock) == 0); - - int32_t delta_x = x - shoe.mouse.old_x; - int32_t delta_y = y - shoe.mouse.old_y; - - shoe.mouse.old_x = x; - shoe.mouse.old_y = y; - - shoe.mouse.delta_x += delta_x; - shoe.mouse.delta_y += delta_y; - shoe.mouse.button_down = button_down; - shoe.mouse.changed = 1; - - adb_request_service_request(3); - printf("%s: unlock\n", __func__); fflush(stdout); - pthread_mutex_unlock(&shoe.adb.lock); - - // printf("move_mouse: setting service request\n"); -} - -void global_motion_func (int x, int y) -{ - move_mouse(x, y, 1); -} - -void global_passive_motion_func (int x, int y) -{ - move_mouse(x, y, 0); -} - -void global_keyboard_up_func (unsigned char c, int x, int y) -{ - uint8_t code = lookup_key(c); - if (code != 0xff) - keyboard_add_entry(code, 1); -} - -void global_keyboard_down_func (unsigned char c, int x, int y) -{ - uint8_t code = lookup_key(c); - if (code != 0xff) - keyboard_add_entry(code, 0); -} - -void global_special_up_func (int special, int x, int y) -{ - const uint8_t code = lookup_special(special); - if (code != 0xff) - keyboard_add_entry(code, 1); -} - -void global_special_down_func (int special, int x, int y) -{ - const uint8_t code = lookup_special(special); - if (code != 0xff) - keyboard_add_entry(code, 0); -} - -void timer_func (int arg) -{ - glutTimerFunc(15, timer_func, 0); // 66.67hz is the usual refresh interval (right?) - glutPostRedisplay(); -} - -int main (int argc, char **argv) -{ - bzero(&control, sizeof(shoebill_control_t)); - - control.aux_verbose = 1; - control.ram_size = 1024*1024*1024; - control.aux_kernel_path = "priv/unix2"; - control.rom_path = "priv/macii.rom"; - - control.scsi_devices[0].path = "priv/aux2.img"; - - uint32_t result = shoebill_initialize(&control); - if (!result) { - printf("fail: %s\n", control.error_msg); - return 0; - } - else - printf("success!\n"); - - shoebill_install_video_card(&control, 10, 800, 600, - (2.0/3.0) * 100.0); // 66.67hz - video_card = &control.slots[10].card.video; - - - int dummyargc = 1; - glutInit(&dummyargc, argv); - glutInitWindowSize(video_card->scanline_width, video_card->height); - glutCreateWindow(""); - glutDisplayFunc(glut_display_func); - glShadeModel(GL_FLAT); - glPixelStorei(GL_UNPACK_ALIGNMENT, 1); - glClearColor(0.1, 1.0, 0.1, 1.0); - - shoebill_start(); - - glutTimerFunc(15, timer_func, 0); - glutMainLoop(); - - return 0; -} diff --git a/web/2014_04_05_aux3.0.0_sorta_works.png b/web/2014_04_05_aux3.0.0_sorta_works.png new file mode 100644 index 0000000000000000000000000000000000000000..b15fa2fd27884aa4762c7e31207201657476d453 GIT binary patch literal 154222 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Μ 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�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