Merge branch 'master' into esp32-mailfunction

CMakeLists.txt

@@ -6,8 +6,8 @@ cmake_minimum_required(VERSION 3.9)
 
 add_compile_options(-Wall -pedantic -Wextra)
 
-#add_compile_options(-fsanitize=address)
+#add_compile_options(-fsanitize=undefined)
-#add_link_options(-fsanitize=address)
+#add_link_options(-fsanitize=undefined)
 
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED True)

ESP32/console_esp32.cpp

@@ -1,4 +1,4 @@
-// (C) 2018-2023 by Folkert van Heusden
+// (C) 2018-2024 by Folkert van Heusden
 // Released under MIT license
 
 #include <Adafruit_NeoPixel.h>
@@ -13,7 +13,7 @@
 
 #define NEOPIXELS_PIN	25
 
-console_esp32::console_esp32(std::atomic_uint32_t *const stop_event, bus *const b, std::vector<Stream *> & io_ports, const int t_width, const int t_height) :
+console_esp32::console_esp32(std::atomic_uint32_t *const stop_event, std::vector<Stream *> & io_ports, const int t_width, const int t_height) :
 	console(stop_event, t_width, t_height),
 	io_ports(io_ports)
 {
@@ -72,7 +72,6 @@ void console_esp32::panel_update_thread()
 	pixels.begin();
 
 	pixels.clear();
-
 	pixels.show();
 
 	constexpr uint8_t brightness = 16;
@@ -103,7 +102,7 @@ void console_esp32::panel_update_thread()
 	pixels.clear();
 	pixels.show();
 
-	for(;;) {
+	while(!stop_panel) {
 		vTaskDelay(20 / portTICK_PERIOD_MS);
 
 		try {
@@ -141,5 +140,10 @@ void console_esp32::panel_update_thread()
 			put_string_lf("Unknown exception in panel thread");
 		}
 	}
+
+	pixels.clear();
+	pixels.show();
+
+	Serial.println(F("panel task terminating"));
 #endif
 }

ESP32/console_esp32.h

@@ -1,4 +1,4 @@
-// (C) 2018-2023 by Folkert van Heusden
+// (C) 2018-2024 by Folkert van Heusden
 // Released under MIT license
 
 #include <Arduino.h>
@@ -18,7 +18,7 @@ protected:
 	void put_char_ll(const char c) override;
 
 public:
-	console_esp32(std::atomic_uint32_t *const stop_event, bus *const b, std::vector<Stream *> & io_ports, const int t_width, const int t_height);
+	console_esp32(std::atomic_uint32_t *const stop_event, std::vector<Stream *> & io_ports, const int t_width, const int t_height);
 	virtual ~console_esp32();
 
 	void put_string_lf(const std::string & what) override;

ESP32/console_shabadge.cpp

@@ -15,8 +15,8 @@
 #define COLORED     0
 #define UNCOLORED   1
 
-console_shabadge::console_shabadge(std::atomic_uint32_t *const stop_event, bus *const b, std::vector<Stream *> & io_ports) :
+console_shabadge::console_shabadge(std::atomic_uint32_t *const stop_event, std::vector<Stream *> & io_ports) :
-	console_esp32(stop_event, b, io_ports, 296 / 8, 128 / 8)
+	console_esp32(stop_event, io_ports, 296 / 8, 128 / 8)
 {
 	if (epd.Init() != 0)
 		Serial.println("Init of DEPG0290B01 failed");

ESP32/console_shabadge.h

@@ -22,7 +22,7 @@ private:
 	void put_char_ll(const char c) override;
 
 public:
-	console_shabadge(std::atomic_uint32_t *const stop_event, bus *const b, std::vector<Stream *> & io_ports);
+	console_shabadge(std::atomic_uint32_t *const stop_event, std::vector<Stream *> & io_ports);
 	virtual ~console_shabadge();
 
 	void panel_update_thread() override;

ESP32/disk_backend_esp32.cpp

@@ -29,7 +29,7 @@ void disk_backend_esp32::emit_error()
 	DOLOG(ll_error, true, "SdFat error: %d/%d", sd.sdErrorCode(), sd.sdErrorData());
 }
 
-bool disk_backend_esp32::begin()
+bool disk_backend_esp32::begin(const bool dummy)
 {
 	if (!fh->open(filename.c_str(), O_RDWR)) {
 		DOLOG(ll_error, true, "rk05: cannot open \"%s\"", filename.c_str());
@@ -41,7 +41,7 @@ bool disk_backend_esp32::begin()
 	return true;
 }
 
-bool disk_backend_esp32::read(const off_t offset, const size_t n, uint8_t *const target)
+bool disk_backend_esp32::read(const off_t offset, const size_t n, uint8_t *const target, const size_t sector_size)
 {
 	DOLOG(debug, false, "disk_backend_esp32::read: read %zu bytes from offset %zu", n, offset);
 
@@ -77,7 +77,7 @@ bool disk_backend_esp32::read(const off_t offset, const size_t n, uint8_t *const
 	return true;
 }
 
-bool disk_backend_esp32::write(const off_t offset, const size_t n, const uint8_t *const from)
+bool disk_backend_esp32::write(const off_t offset, const size_t n, const uint8_t *const from, const size_t sector_size)
 {
 	DOLOG(debug, false, "disk_backend_esp32::write: write %zu bytes to offset %zu", n, offset);
 

ESP32/disk_backend_esp32.h

@@ -23,9 +23,11 @@ public:
 	disk_backend_esp32(const std::string & filename);
 	virtual ~disk_backend_esp32();
 
-	bool begin() override;
+	std::string get_identifier() const { return filename; }
 
-	bool read(const off_t offset, const size_t n, uint8_t *const target) override;
+	bool begin(const bool dummy) override;
 
-	bool write(const off_t offset, const size_t n, const uint8_t *const from) override;
+	bool read(const off_t offset, const size_t n, uint8_t *const target, const size_t sector_size) override;
+
+	bool write(const off_t offset, const size_t n, const uint8_t *const from, const size_t sector_size) override;
 };

ESP32/disk_device.h

@@ -0,0 +1 @@
+../disk_device.h

ESP32/main.ino

@@ -18,6 +18,9 @@
 #include <sys/socket.h>
 #include <sys/types.h>
 #endif
+#if defined(ESP32)
+#include "esp_heap_caps.h"
+#endif
 
 #if defined(SHA2017)
 #include "console_shabadge.h"
@@ -38,7 +41,6 @@
 #include "esp32.h"
 #endif
 #include "gen.h"
-#include "kw11-l.h"
 #include "loaders.h"
 #include "memory.h"
 #include "tty.h"
@@ -71,11 +73,16 @@ std::atomic_bool    *running         { nullptr };
 
 bool                 trace_output    { false };
 
+std::vector<disk_backend *> rk05_files;
+std::vector<disk_backend *> rl02_files;
+
 void console_thread_wrapper_panel(void *const c)
 {
 	console *const cnsl = reinterpret_cast<console *>(c);
 
 	cnsl->panel_update_thread();
+
+	vTaskSuspend(nullptr);
 }
 
 uint32_t load_serial_speed_configuration()
@@ -194,12 +201,7 @@ void recall_configuration(console *const cnsl)
 	cnsl->put_string_lf("Starting network...");
 	start_network(cnsl);
 
-	auto disk_configuration = load_disk_configuration(cnsl);
+	// TODO
-
-	if (disk_configuration.has_value()) {
-		cnsl->put_string_lf("Starting disk...");
-		set_disk_configuration(b, cnsl, disk_configuration.value());
-	}
 }
 #endif
 
@@ -211,13 +213,21 @@ void set_tty_serial_speed(console *const c, const uint32_t bps)
 		c->put_string_lf("Failed to store configuration file with serial settings");
 }
 
+#if defined(ESP32)
+void heap_caps_alloc_failed_hook(size_t requested_size, uint32_t caps, const char *function_name)
+{
+	printf("%s was called but failed to allocate %d bytes with 0x%X capabilities\r\n", function_name, requested_size, caps);
+}
+
+#endif
+
 void setup() {
 	Serial.begin(115200);
 
 	while(!Serial)
 		delay(100);
 
-	Serial.println(F("This PDP-11 emulator is called \"kek\" (reason for that is forgotten) and was written by Folkert van Heusden."));
+	Serial.println(F("PDP11 emulator, by Folkert van Heusden"));
 	Serial.print(F("GIT hash: "));
 	Serial.println(version_str);
 	Serial.println(F("Build on: " __DATE__ " " __TIME__));
@@ -225,6 +235,10 @@ void setup() {
 	Serial.print(F("Size of int: "));
 	Serial.println(sizeof(int));
 
+#if defined(ESP32)
+	heap_caps_register_failed_alloc_callback(heap_caps_alloc_failed_hook);
+#endif
+
 #if !defined(BUILD_FOR_RP2040)
 	Serial.print(F("CPU clock frequency (MHz): "));
 	Serial.println(getCpuFrequencyMhz());
@@ -264,6 +278,9 @@ void setup() {
 	Serial.println(F("Init bus"));
 	b = new bus();
 
+	Serial.println(F("Allocate memory"));
+	b->set_memory_size(DEFAULT_N_PAGES);
+
 	Serial.println(F("Init CPU"));
 	c = new cpu(b, &stop_event);
 
@@ -286,14 +303,19 @@ void setup() {
 
 	std::vector<Stream *> serial_ports { &Serial_RS232, &Serial };
 #if defined(SHA2017)
-	cnsl = new console_shabadge(&stop_event, b, serial_ports);
+	cnsl = new console_shabadge(&stop_event, serial_ports);
 #elif defined(ESP32) || defined(BUILD_FOR_RP2040)
-	cnsl = new console_esp32(&stop_event, b, serial_ports, 80, 25);
+	cnsl = new console_esp32(&stop_event, serial_ports, 80, 25);
 #endif
 	cnsl->set_bus(b);
 
 	running = cnsl->get_running_flag();
 
+	Serial.println(F("Connect RK05 and RL02 to BUS"));
+	b->add_rk05(new rk05(rk05_files, b, cnsl->get_disk_read_activity_flag(), cnsl->get_disk_write_activity_flag()));
+
+	b->add_rl02(new rl02(rl02_files, b, cnsl->get_disk_read_activity_flag(), cnsl->get_disk_write_activity_flag()));
+
 	Serial.println(F("Init TTY"));
 	tty_ = new tty(cnsl, b);
 	Serial.println(F("Connect TTY to bus"));

ESP32/platformio.ini

@@ -17,7 +17,7 @@ board_build.filesystem = littlefs
 lib_deps = greiman/SdFat@^2.1.2
 	adafruit/Adafruit NeoPixel
 	bblanchon/ArduinoJson@^6.19.4
-build_flags = -std=gnu++2a -DESP32=1 -ggdb3 -D_GLIBCXX_USE_C99
+build_flags = -std=gnu++2a -DESP32=1 -ggdb3 -D_GLIBCXX_USE_C99 -Wall
 build_unflags = -std=gnu++11 -std=gnu++17
 extra_scripts = pre:prepare.py
 
@@ -35,3 +35,18 @@ lib_deps = greiman/SdFat@^2.1.2
 build_flags = -std=gnu++2a -DESP32=1 -DSHA2017 -ggdb3 -D_GLIBCXX_USE_C99 -ISHAdisplay/Arduino/libraries/epd2in9-badge -ISHAdisplay/Arduino/libraries/epdpaint -ISHAdisplay/components/epaper-29-dke
 build_unflags = -std=gnu++11 -std=gnu++17
 upload_protocol = esptool
+
+[env:ESP32-ttgo-t-beam]
+build_src_filter = +<*> -<.git/> -<.svn/> -<example/> -<examples/> -<test/> -<tests/> -<build> -<player.cpp> -<SHAdisplay/> -<console_shabadge.cpp>
+platform = espressif32
+board = ttgo-t-beam
+framework = arduino
+monitor_speed = 115200
+upload_speed = 1000000
+board_build.filesystem = littlefs
+lib_deps = greiman/SdFat@^2.1.2
+        adafruit/Adafruit NeoPixel
+        bblanchon/ArduinoJson@^6.19.4
+build_flags = -std=gnu++17 -DESP32=1 -ggdb3 -D_GLIBCXX_USE_C99
+build_unflags = -std=gnu++11
+extra_scripts = pre:prepare.py

breakpoint_register.cpp

@@ -101,12 +101,12 @@ std::pair<breakpoint_register *, std::optional<std::string> > breakpoint_registe
 	else if (key == "PC" || key == "pc") {
 		return { new breakpoint_register(b, 7, values), { } };
 	}
-	else if (key.substr(0, 3) == "MMR" or key.substr(0, 3) == "mmr") {
+	else if (key.substr(0, 3) == "MMR" || key.substr(0, 3) == "mmr") {
 		int which = key[3] - '0';
 
 		return { new breakpoint_register(b, hr_mmr0 + which, values), { } };
 	}
-	else if (key.substr(0, 3) == "PSW" or key.substr(0, 3) == "psw") {
+	else if (key.substr(0, 3) == "PSW" || key.substr(0, 3) == "psw") {
 		return { new breakpoint_register(b, hr_psw, values), { } };
 	}
 

bus.h

@@ -119,6 +119,8 @@ public:
 	kw11_l *getKW11_L() { return kw11_l_; }
 	tty    *getTty()    { return tty_;    }
 	mmu    *getMMU()    { return mmu_;    }
+	rk05   *getRK05()   { return rk05_;   }
+	rl02   *getRL02()   { return rl02_;   }
 
 	uint16_t read    (const uint16_t a, const word_mode_t word_mode, const rm_selection_t mode_selection, const bool peek_only=false, const d_i_space_t s = i_space);
 	uint16_t readByte(const uint16_t a) { return read(a, wm_byte, rm_cur); }

console.h

@@ -30,6 +30,7 @@ private:
 
 protected:
 	std::atomic_uint32_t *const stop_event   { nullptr };
+	std::atomic_bool        stop_panel       { false   };
 
 	bus                    *b                { nullptr };
 #if !defined(BUILD_FOR_RP2040)
@@ -88,5 +89,6 @@ public:
 	std::atomic_bool * get_disk_read_activity_flag()  { return &disk_read_activity_flag; }
 	std::atomic_bool * get_disk_write_activity_flag() { return &disk_write_activity_flag; }
 
+	void         stop_panel_thread() { stop_panel = true; }
 	virtual void panel_update_thread() = 0;
 };

console_ncurses.cpp

@@ -133,7 +133,7 @@ void console_ncurses::panel_update_thread()
 
 	constexpr int refresh_rate = 50;
 
-	while(*stop_event != EVENT_TERMINATE) {
+	while(*stop_event != EVENT_TERMINATE && stop_panel == false) {
 		myusleep(1000000 / refresh_rate);
 
 		// note that these are approximately as there's no mutex on the emulation

debugger.cpp

@@ -10,7 +10,6 @@
 #include <sys/types.h>
 #else
 #include <Arduino.h>
-#include <ArduinoJson.h>
 #include <LittleFS.h>
 #endif
 
@@ -39,264 +38,46 @@
 #include "rp2040.h"
 #endif
 
-void setBootLoader(bus *const b);
+void configure_network(console *const cnsl);
-
+void check_network(console *const cnsl);
-void configure_disk(console *const c);
+void start_network(console *const cnsl);
-
-void configure_network(console *const c);
-void check_network(console *const c);
-void start_network(console *const c);
 
 void set_tty_serial_speed(console *const c, const uint32_t bps);
-
-void recall_configuration(console *const c);
 #endif
 
-#define NET_DISK_CFG_FILE "net-disk.json"
-
 #if !defined(BUILD_FOR_RP2040) && !defined(linux)
 extern SdFs SD;
 #endif
 
-#ifndef linux
-#define MAX_CFG_SIZE 1024
-StaticJsonDocument<MAX_CFG_SIZE> json_doc;
-#endif
-
-typedef enum { BE_NETWORK, BE_SD } disk_backend_t;
-
 #if !defined(BUILD_FOR_RP2040)
-std::optional<std::tuple<std::vector<disk_backend *>, std::vector<disk_backend *>, std::string> > load_disk_configuration(console *const c)
+std::optional<disk_backend *> select_nbd_server(console *const cnsl)
 {
-#if IS_POSIX
+	cnsl->flush_input();
-	json_error_t error;
-	json_t *json = json_load_file("." NET_DISK_CFG_FILE, JSON_REJECT_DUPLICATES, &error);
-	if (!json) {
-		c->put_string_lf(format("Cannot load ." NET_DISK_CFG_FILE ": %s", error.text));
 
-		return { };
+	std::string hostname = cnsl->read_line("Enter hostname (or empty to abort): ");
-	}
-
-	std::string nbd_host       = json_string_value (json_object_get(json, "NBD-host"));
-	int         nbd_port       = json_integer_value(json_object_get(json, "NBD-port"));
-
-	std::string disk_type_temp = json_string_value (json_object_get(json, "disk-type"));
-
-	std::string tape_file      = json_string_value (json_object_get(json, "tape-file"));
-
-	json_decref(json);
-#else
-	File dataFile = LittleFS.open("/" NET_DISK_CFG_FILE, "r");
-	if (!dataFile)
-		return { };
-
-	size_t size = dataFile.size();
-
-	char buffer[MAX_CFG_SIZE];
-
-	if (size > sizeof buffer) {  // this should not happen
-		dataFile.close();
-
-		return { };
-	}
-
-	dataFile.read(reinterpret_cast<uint8_t *>(buffer), size);
-	buffer[(sizeof buffer) - 1] = 0x00;
-
-	dataFile.close();
-
-	auto error = deserializeJson(json_doc, buffer);
-	if (error)  // this should not happen
-		return { };
-
-	String nbd_host = json_doc["NBD-host"];
-	int    nbd_port = json_doc["NBD-port"];
-
-	String disk_type_temp = json_doc["disk-type"];
-
-	String tape_file      = json_doc["tape-file"];
-#endif
-
-	disk_type_t disk_type = DT_RK05;
-
-	if (disk_type_temp == "rl02")
-		disk_type = DT_RL02;
-	else if (disk_type_temp == "tape")
-		disk_type = DT_TAPE;
-
-	disk_backend *d = new disk_backend_nbd(nbd_host.c_str(), nbd_port);
-
-	if (d->begin() == false) {
-		c->put_string_lf("Cannot initialize NBD client from configuration file");
-		delete d;
-		return { };
-	}
-
-	c->put_string_lf(format("Connection to NBD server at %s:%d success", nbd_host.c_str(), nbd_port));
-
-	if (disk_type == DT_RK05)
-		return { { { d }, { }, "" } };
-
-	if (disk_type == DT_RL02)
-		return { { { }, { d }, "" } };
-
-	if (disk_type == DT_TAPE)
-		return { { { }, { }, tape_file.c_str() } };
-
-	return { };
-}
-
-bool save_disk_configuration(const std::string & nbd_host, const int nbd_port, const std::optional<std::string> & tape_file, const disk_type_t dt, console *const cnsl)
-{
-#if IS_POSIX
-	json_t *json = json_object();
-
-	json_object_set(json, "NBD-host", json_string(nbd_host.c_str()));
-	json_object_set(json, "NBD-port", json_integer(nbd_port));
-
-	if (dt == DT_RK05)
-		json_object_set(json, "disk-type", json_string("rk05"));
-	else if (dt == DT_RL02)
-		json_object_set(json, "disk-type", json_string("rl02"));
-	else
-		json_object_set(json, "disk-type", json_string("tape"));
-
-	json_object_set(json, "tape-file", json_string(tape_file.has_value() ? tape_file.value().c_str() : ""));
-
-	bool succeeded = json_dump_file(json, "." NET_DISK_CFG_FILE, 0) == 0;
-	json_decref(json);
-
-	if (succeeded == false) {
-		cnsl->put_string_lf(format("Cannot write ." NET_DISK_CFG_FILE));
-
-		return false;
-	}
-#else
-	json_doc["NBD-host"] = nbd_host;
-	json_doc["NBD-port"] = nbd_port;
-
-	if (dt == DT_RK05)
-		json_doc["disk-type"] = "rk05";
-	else if (dt == DT_RL02)
-		json_doc["disk-type"] = "rl02";
-	else
-		json_doc["disk-type"] = "tape";
-
-	json_doc["tape-file"] = tape_file.has_value() ? tape_file.value() : "";
-
-	File dataFile = LittleFS.open("/" NET_DISK_CFG_FILE, "w");
-	if (!dataFile)
-		return false;
-
-	serializeJson(json_doc, dataFile);
-
-	dataFile.close();
-#endif
-
-	return true;
-}
-#endif
-
-std::optional<disk_backend_t> select_disk_backend(console *const c)
-{
-#if defined(BUILD_FOR_RP2040)
-	return BE_SD;
-#elif linux
-	c->put_string("1. network (NBD), 2. local filesystem, 9. abort");
-#else
-	c->put_string("1. network (NBD), 2. local SD card, 9. abort");
-#endif
-
-	int ch = -1;
-	while(ch == -1 && ch != '1' && ch != '2' && ch != '9') {
-		auto temp = c->wait_char(500);
-
-		if (temp.has_value())
-			ch = temp.value();
-	}
-
-	c->put_string_lf(format("%c", ch));
-
-	if (ch == '1')
-		return BE_NETWORK;
-
-	if (ch == '2')
-		return BE_SD;
-
-	return { };
-}
-
-std::optional<disk_type_t> select_disk_type(console *const c)
-{
-	c->put_string("1. RK05, 2. RL02, 3. tape/BIC, 9. abort");
-
-	int ch = -1;
-	while(ch == -1 && ch != '1' && ch != '2' && ch != '3' && ch != '9') {
-		auto temp = c->wait_char(500);
-
-		if (temp.has_value())
-			ch = temp.value();
-	}
-
-	c->put_string_lf(format("%c", ch));
-
-	if (ch == '1')
-		return DT_RK05;
-
-	if (ch == '2')
-		return DT_RL02;
-
-	if (ch == '3')
-		return DT_TAPE;
-
-	return { };
-}
-
-#if !defined(BUILD_FOR_RP2040)
-std::optional<std::tuple<std::vector<disk_backend *>, std::vector<disk_backend *>, std::string> > select_nbd_server(console *const c)
-{
-	c->flush_input();
-
-	std::string hostname = c->read_line("Enter hostname (or empty to abort): ");
 
 	if (hostname.empty())
 		return { };
 
-	std::string port_str = c->read_line("Enter port number (or empty to abort): ");
+	std::string port_str = cnsl->read_line("Enter port number (or empty to abort): ");
 
 	if (port_str.empty())
 		return { };
 
-	auto disk_type = select_disk_type(c);
-
-	if (disk_type.has_value() == false)
-		return { };
-
 	disk_backend *d = new disk_backend_nbd(hostname, atoi(port_str.c_str()));
 
-	if (d->begin() == false) {
+	if (d->begin(false) == false) {
-		c->put_string_lf("Cannot initialize NBD client");
+		cnsl->put_string_lf("Cannot initialize NBD client");
 		delete d;
 		return { };
 	}
 
-	if (save_disk_configuration(hostname, atoi(port_str.c_str()), { }, disk_type.value(), c))
+	return d;
-		c->put_string_lf("NBD disk configuration saved");
-	else
-		c->put_string_lf("NBD disk configuration NOT saved");
-
-	if (disk_type.value() == DT_RK05)
-		return { { { d }, { }, "" } };
-
-	if (disk_type.value() == DT_RL02)
-		return { { { }, { d }, "" } };
-
-	return { };
 }
 #endif
 
-// RK05, RL02 files
+// disk image files
-std::optional<std::tuple<std::vector<disk_backend *>, std::vector<disk_backend *>, std::string> > select_disk_files(console *const c)
+std::optional<disk_backend *> select_disk_file(console *const c)
 {
 #if IS_POSIX
 	c->put_string_lf("Files in current directory: ");
@@ -368,11 +149,6 @@ std::optional<std::tuple<std::vector<disk_backend *>, std::vector<disk_backend *
 		if (selected_file.empty())
 			return { };
 
-		auto disk_type = select_disk_type(c);
-
-		if (disk_type.has_value() == false)
-			return { };
-
 		c->put_string("Opening file: ");
 		c->put_string_lf(selected_file.c_str());
 
@@ -389,16 +165,13 @@ std::optional<std::tuple<std::vector<disk_backend *>, std::vector<disk_backend *
 #endif
 
 		if (can_open_file) {
-			if (disk_type.value() == DT_TAPE)
-				return { { { }, { }, selected_file } };
-
 #if IS_POSIX
 			disk_backend *temp = new disk_backend_file(selected_file);
 #else
 			disk_backend *temp = new disk_backend_esp32(selected_file);
 #endif
 
-			if (!temp->begin()) {
+			if (!temp->begin(false)) {
 				c->put_string("Cannot use: ");
 				c->put_string_lf(selected_file.c_str());
 
@@ -407,63 +180,136 @@ std::optional<std::tuple<std::vector<disk_backend *>, std::vector<disk_backend *
 				continue;
 			}
 
-			if (disk_type.value() == DT_RK05)
+			return { temp };
-				return { { { temp }, { }, "" } };
-
-			if (disk_type.value() == DT_RL02)
-				return { { { }, { temp }, "" } };
 		}
 
 		c->put_string_lf("open failed");
 	}
+
+	return { };
 }
 
-void set_disk_configuration(bus *const b, console *const cnsl, std::tuple<std::vector<disk_backend *>, std::vector<disk_backend *>, std::string> & disk_files)
+int wait_for_key(const std::string & title, console *const cnsl, const std::vector<char> & allowed)
 {
-	if (std::get<0>(disk_files).empty() == false)
+	cnsl->put_string_lf(title);
-		b->add_rk05(new rk05(std::get<0>(disk_files), b, cnsl->get_disk_read_activity_flag(), cnsl->get_disk_write_activity_flag()));
 
-	if (std::get<1>(disk_files).empty() == false)
+	cnsl->put_string("> ");
-		b->add_rl02(new rl02(std::get<1>(disk_files), b, cnsl->get_disk_read_activity_flag(), cnsl->get_disk_write_activity_flag()));
 
-	if (std::get<2>(disk_files).empty() == false) {
+	int ch = -1;
-		auto addr = loadTape(b, std::get<2>(disk_files));
+	while(ch == -1) {
+		auto temp = cnsl->wait_char(500);
 
-		if (addr.has_value())
+		if (temp.has_value()) {
-			b->getCpu()->setPC(addr.value());
+			for(auto & a: allowed) {
+				if (a == temp.value()) {
+					ch = temp.value();
+					break;
+				}
+			}
+		}
 	}
 
-	if (std::get<0>(disk_files).empty() == false)
+	cnsl->put_string_lf(format("%c", ch));
-		setBootLoader(b, BL_RK05);
+
-	else if (std::get<1>(disk_files).empty() == false)
+	return ch;
-		setBootLoader(b, BL_RL02);
+}
+
+std::optional<disk_backend *> select_disk_backend(console *const cnsl)
+{
+#if defined(BUILD_FOR_RP2040)
+	return select_disk_file(cnsl);
+#else
+	int ch = wait_for_key("1. local disk, 2. network disk (NBD), 9. abort", cnsl, { '1', '2', '9' });
+	if (ch == '9')
+		return { };
+
+	if (ch == '1')
+		return select_disk_file(cnsl);
+
+	if (ch == '2')
+		return select_nbd_server(cnsl);
+
+	return { };
+#endif
 }
 
 void configure_disk(bus *const b, console *const cnsl)
 {
+	// TODO tape
+	int ch = wait_for_key("1. RK05, 2. RL02, 9. abort", cnsl, { '1', '2', '3', '9' });
+
+	bootloader_t bl = BL_NONE;
+	disk_device *dd = nullptr;
+
+	if (ch == '1') {
+		dd = b->getRK05();
+		bl = BL_RK05;
+	}
+	else if (ch == '2') {
+		dd = b->getRL02();
+		bl = BL_RL02;
+	}
+	else if (ch == '9') {
+		return;
+	}
+
 	for(;;) {
-		cnsl->put_string_lf("Load disk");
+		std::vector<char> keys_allowed { '1', '2', '9' };
 
-		auto backend = select_disk_backend(cnsl);
+		auto cartridge_slots = dd->access_disk_backends();
+		int slot_key = 'A';
+		for(auto & slot: *cartridge_slots) {
+			cnsl->put_string_lf(format(" %c. %s", slot_key, slot ? slot->get_identifier().c_str() : "-"));
+			keys_allowed.push_back(slot_key);
+			slot_key++;
+		}
 
-		if (backend.has_value() == false)
+		int ch = wait_for_key("Select cartridge to setup, 1. to add a cartridge, 2. to load a bootloader or 9. to exit", cnsl, keys_allowed);
+		if (ch == '9')
 			break;
 
-		std::optional<std::tuple<std::vector<disk_backend *>, std::vector<disk_backend *>, std::string> > files;
+		if (ch == '1') {
+			auto image_file = select_disk_backend(cnsl);
 
-#if !defined(BUILD_FOR_RP2040)
+			if (image_file.has_value()) {
-		if (backend == BE_NETWORK)
+				cartridge_slots->push_back(image_file.value());
-			files = select_nbd_server(cnsl);
-		else // if (backend == BE_SD)
-#endif
-			files = select_disk_files(cnsl);
 
-		if (files.has_value() == false)
+				cnsl->put_string_lf("Cartridge loaded");
+			}
+		}
+		else if (ch == '2') {
+			set_boot_loader(b, bl);
+
+			cnsl->put_string_lf("Bootloader loaded");
+		}
+		else {
+			int slot = ch - 'A';
+
+			for(;;) {
+				int ch = wait_for_key("Select cartridge action: 1. load, 2. unload, 9. exit", cnsl, { '1', '2', '9' });
+				if (ch == '9')
 					break;
 
-		set_disk_configuration(b, cnsl, files.value());
+				if (ch == '1') {
+					auto image_file = select_disk_backend(cnsl);
 
-		break;
+					if (image_file.has_value()) {
+						delete cartridge_slots->at(slot);
+						cartridge_slots->at(slot) = image_file.value();
+
+						cnsl->put_string_lf("Cartridge loaded");
+					}
+				}
+				else if (ch == '2') {
+					if (cartridge_slots->at(slot)) {
+						delete cartridge_slots->at(slot);
+						cartridge_slots->at(slot) = nullptr;
+
+						cnsl->put_string_lf("Cartridge unloaded");
+					}
+				}
+			}
+		}
 	}
 }
 
@@ -976,6 +822,12 @@ void debugger(console *const cnsl, bus *const b, std::atomic_uint32_t *const sto
 				continue;
 			}
 #if defined(ESP32)
+			else if (cmd == "debug") {
+				if (heap_caps_check_integrity_all(true) == false)
+					cnsl->put_string_lf("HEAP corruption!");
+
+				continue;
+			}
 			else if (cmd == "cfgnet") {
 				configure_network(cnsl);
 
@@ -1002,11 +854,6 @@ void debugger(console *const cnsl, bus *const b, std::atomic_uint32_t *const sto
 					cnsl->put_string_lf("serspd requires an (decimal) parameter");
 				}
 
-				continue;
-			}
-			else if (cmd == "init") {
-				recall_configuration(cnsl);
-
 				continue;
 			}
 #endif
@@ -1027,7 +874,7 @@ void debugger(console *const cnsl, bus *const b, std::atomic_uint32_t *const sto
 				continue;
 			}
 			else if (parts[0] == "bl" && parts.size() == 2) {
-				setBootLoader(b, parts.at(1) == "rk05" ? BL_RK05 : BL_RL02);
+				set_boot_loader(b, parts.at(1) == "rk05" ? BL_RK05 : BL_RL02);
 				cnsl->put_string_lf("Bootloader set");
 
 				continue;
@@ -1098,7 +945,10 @@ void debugger(console *const cnsl, bus *const b, std::atomic_uint32_t *const sto
 			}
 #endif
 			else if (parts[0] == "setsl" && parts.size() == 3) {
-				setloghost(parts.at(1).c_str(), parse_ll(parts[2]));
+				if (setloghost(parts.at(1).c_str(), parse_ll(parts[2])) == false)
+					cnsl->put_string_lf("Failed parsing IP address");
+				else
+					send_syslog(info, "Hello, world!");
 
 				continue;
 			}
@@ -1107,6 +957,11 @@ void debugger(console *const cnsl, bus *const b, std::atomic_uint32_t *const sto
 
 				continue;
 			}
+			else if (cmd == "dp") {
+				cnsl->stop_panel_thread();
+
+				continue;
+			}
 			else if (cmd == "bt") {
 				if (c->get_debug() == false)
 					cnsl->put_string_lf("Debug mode is disabled!");
@@ -1160,14 +1015,15 @@ void debugger(console *const cnsl, bus *const b, std::atomic_uint32_t *const sto
 					"bl            - set bootload (rl02 or rk05)",
 #if IS_POSIX
 					"ser           - serialize state to a file",
-					"dser          - deserialize state from a file",
+//					"dser          - deserialize state from a file",
 #endif
+					"dp            - disable panel",
 #if defined(ESP32)
 					"cfgnet        - configure network (e.g. WiFi)",
 					"startnet      - start network",
 					"chknet        - check network status",
 					"serspd        - set serial speed in bps (8N1 are default)",
-					"init          - reload (disk-)configuration from flash",
+					"debug         - debugging info",
 #endif
 					"cfgdisk       - configure disk",
 					nullptr

debugger.h

@@ -6,10 +6,6 @@
 #include "gen.h"
 
 
-std::optional<std::tuple<std::vector<disk_backend *>, std::vector<disk_backend *>, std::string> > load_disk_configuration(console *const c);
-bool save_disk_configuration(const std::string & nbd_host, const int nbd_port, const disk_type_t dt);
-void set_disk_configuration(bus *const b, console *const cnsl, std::tuple<std::vector<disk_backend *>, std::vector<disk_backend *>, std::string> & disk_files);
-
 int disassemble(cpu *const c, console *const cnsl, const uint16_t pc, const bool instruction_only);
 void debugger(console *const cnsl, bus *const b, std::atomic_uint32_t *const stop_event, const bool tracing);
 

disk_backend.cpp

@@ -7,8 +7,8 @@
 #include "gen.h"
 #if IS_POSIX
 #include "disk_backend_file.h"
-#endif
 #include "disk_backend_nbd.h"
+#endif
 
 
 disk_backend::disk_backend()
@@ -20,6 +20,80 @@ disk_backend::~disk_backend()
 }
 
 #if IS_POSIX
+void disk_backend::store_object_in_overlay(const off_t id, const std::vector<uint8_t> & data)
+{
+	overlay.insert_or_assign(id, data);
+}
+
+std::optional<std::vector<uint8_t> > disk_backend::get_object_from_overlay(const off_t id)
+{
+	auto it = overlay.find(id);
+	if (it != overlay.end())
+		return it->second;
+
+	return { };
+}
+
+std::optional<std::vector<uint8_t> > disk_backend::get_from_overlay(const off_t offset, const size_t sector_size)
+{
+	assert((offset % sector_size) == 0);
+
+	if (use_overlay)
+		return get_object_from_overlay(offset / sector_size);
+
+	return { };
+}
+
+bool disk_backend::store_mem_range_in_overlay(const off_t offset, const size_t n, const uint8_t *const from, const size_t sector_size)
+{
+	assert((offset % sector_size) == 0);
+	assert((n % sector_size) == 0);
+
+	if (use_overlay) {
+		for(size_t o=0; o<n; o += sector_size)
+			store_object_in_overlay((offset + o) / sector_size, std::vector<uint8_t>(from + o, from + o + sector_size));
+
+		return true;
+	}
+
+	return false;
+}
+
+json_t *disk_backend::serialize_overlay() const
+{
+	json_t *out = json_object();
+
+	for(auto & id: overlay) {
+		json_t *j_data = json_array();
+
+		for(size_t i=0; i<id.second.size(); i++)
+			json_array_append(j_data, json_integer(id.second.at(i)));
+
+		json_object_set(out, format("%u", id.first).c_str(), j_data);
+	}
+
+	return out;
+}
+
+void disk_backend::deserialize_overlay(const json_t *const j)
+{
+	json_t *input = json_object_get(j, "overlay");
+	if (!input)  // we can have state-dumps without overlay
+		return;
+
+	const char *key   = nullptr;
+	json_t     *value = nullptr;
+	json_object_foreach(input, key, value) {
+		uint32_t id = std::atoi(key);
+
+		std::vector<uint8_t> data;
+		for(size_t i=0; i<json_array_size(value); i++)
+			data.push_back(json_integer_value(json_array_get(value, i)));
+
+		store_object_in_overlay(id, data);
+	}
+}
+
 disk_backend *disk_backend::deserialize(const json_t *const j)
 {
 	std::string   type = json_string_value(json_object_get(j, "disk-backend-type"));
@@ -35,7 +109,10 @@ disk_backend *disk_backend::deserialize(const json_t *const j)
 	// should not be reached
 	assert(d);
 
-	d->begin();
+	d->deserialize_overlay(j);
+
+	// assume we want snapshots (again?)
+	d->begin(true);
 
 	return d;
 }

disk_backend.h

@@ -3,7 +3,11 @@
 
 #pragma once
 
+#include <map>
+#include <optional>
 #include <stdint.h>
+#include <string>
+#include <vector>
 #include <sys/types.h>
 
 #include "gen.h"
@@ -11,6 +15,20 @@
 
 class disk_backend
 {
+protected:
+#if IS_POSIX
+	bool use_overlay { false };
+	std::map<off_t, std::vector<uint8_t> > overlay;
+
+	void store_object_in_overlay(const off_t id, const std::vector<uint8_t> & data);
+	bool store_mem_range_in_overlay(const off_t offset, const size_t n, const uint8_t *const from, const size_t sector_size);
+	std::optional<std::vector<uint8_t> > get_object_from_overlay(const off_t id);
+	std::optional<std::vector<uint8_t> > get_from_overlay(const off_t offset, const size_t sector_size);
+
+	json_t *serialize_overlay() const;
+	void deserialize_overlay(const json_t *const j);
+#endif
+
 public:
 	disk_backend();
 	virtual ~disk_backend();
@@ -20,9 +38,11 @@ public:
 	static disk_backend *deserialize(const json_t *const j);
 #endif
 
-	virtual bool begin() = 0;
+	virtual std::string get_identifier() const = 0;
 
-	virtual bool read(const off_t offset, const size_t n, uint8_t *const target) = 0;
+	virtual bool begin(const bool disk_snapshots) = 0;
 
-	virtual bool write(const off_t offset, const size_t n, const uint8_t *const from) = 0;
+	virtual bool read(const off_t offset, const size_t n, uint8_t *const target, const size_t sector_size) = 0;
+
+	virtual bool write(const off_t offset, const size_t n, const uint8_t *const from, const size_t sector_size) = 0;
 };

disk_backend_file.cpp

@@ -1,11 +1,13 @@
 // (C) 2018-2024 by Folkert van Heusden
 // Released under MIT license
 
+#include <cassert>
 #include <fcntl.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "disk_backend_file.h"
+#include "gen.h"
 #include "log.h"
 
 
@@ -26,6 +28,8 @@ json_t *disk_backend_file::serialize() const
 
 	json_object_set(j, "disk-backend-type", json_string("file"));
 
+	json_object_set(j, "overlay", serialize_overlay());
+
 	// TODO store checksum of backend
 	json_object_set(j, "filename", json_string(filename.c_str()));
 
@@ -39,8 +43,10 @@ disk_backend_file *disk_backend_file::deserialize(const json_t *const j)
 }
 #endif
 
-bool disk_backend_file::begin()
+bool disk_backend_file::begin(const bool snapshots)
 {
+	use_overlay = snapshots;
+
 	fd = open(filename.c_str(), O_RDWR);
 
 	if (fd == -1) {
@@ -52,30 +58,48 @@ bool disk_backend_file::begin()
 	return true;
 }
 
-bool disk_backend_file::read(const off_t offset, const size_t n, uint8_t *const target)
+bool disk_backend_file::read(const off_t offset_in, const size_t n, uint8_t *const target, const size_t sector_size)
 {
-	DOLOG(debug, false, "disk_backend_file::read: read %zu bytes from offset %zu", n, offset);
+	DOLOG(debug, false, "disk_backend_file::read: read %zu bytes from offset %zu", n, offset_in);
+
+	assert((offset % sector_size) == 0);
+	assert((n % sector_size) == 0);
+
+	for(off_t o=0; o<off_t(n); o+=sector_size) {
+		off_t offset = offset_in + o;
+#if IS_POSIX
+		auto o_rc = get_from_overlay(offset, sector_size);
+		if (o_rc.has_value()) {
+			memcpy(&target[o], o_rc.value().data(), sector_size);
+			continue;
+		}
+#endif
 
 #if defined(_WIN32) // hope for the best
 		if (lseek(fd, offset, SEEK_SET) == -1)
 			return false;
 
-	return ::read(fd, target, n) == ssize_t(n);
+		 if (::read(fd, target, n) != ssize_t(n))
+			 return false;
 #else
 		ssize_t rc = pread(fd, target, n, offset);
 		if (rc != ssize_t(n)) {
 			DOLOG(warning, false, "disk_backend_file::read: read failure. expected %zu bytes, got %zd", n, rc);
 			return false;
 		}
-
-	return true;
 #endif
 	}
 
-bool disk_backend_file::write(const off_t offset, const size_t n, const uint8_t *const from)
+	return true;
+}
+
+bool disk_backend_file::write(const off_t offset, const size_t n, const uint8_t *const from, const size_t sector_size)
 {
 	DOLOG(debug, false, "disk_backend_file::write: write %zu bytes to offset %zu", n, offset);
 
+	if (store_mem_range_in_overlay(offset, n, from, sector_size))
+		return true;
+
 #if defined(_WIN32) // hope for the best
 	if (lseek(fd, offset, SEEK_SET) == -1)
 		return false;

disk_backend_file.h

@@ -22,9 +22,11 @@ public:
 	static disk_backend_file *deserialize(const json_t *const j);
 #endif
 
-	bool begin() override;
+	std::string get_identifier() const override { return filename; }
 
-	bool read(const off_t offset, const size_t n, uint8_t *const target) override;
+	bool begin(const bool snapshots) override;
 
-	bool write(const off_t offset, const size_t n, const uint8_t *const from) override;
+	bool read(const off_t offset, const size_t n, uint8_t *const target, const size_t sector_size) override;
+
+	bool write(const off_t offset, const size_t n, const uint8_t *const from, const size_t sector_size) override;
 };

disk_backend_nbd.cpp

@@ -1,6 +1,7 @@
 // (C) 2018-2024 by Folkert van Heusden
 // Released under MIT license
 
+#include <cassert>
 #include <fcntl.h>
 #include <string.h>
 #include <unistd.h>
@@ -54,6 +55,8 @@ json_t *disk_backend_nbd::serialize() const
 
 	json_object_set(j, "disk-backend-type", json_string("nbd"));
 
+	json_object_set(j, "overlay", serialize_overlay());
+
 	// TODO store checksum of backend
 	json_object_set(j, "host", json_string(host.c_str()));
 	json_object_set(j, "port", json_integer(port));
@@ -68,8 +71,12 @@ disk_backend_nbd *disk_backend_nbd::deserialize(const json_t *const j)
 }
 #endif
 
-bool disk_backend_nbd::begin()
+bool disk_backend_nbd::begin(const bool snapshots)
 {
+#if IS_POSIX
+	use_overlay = snapshots;
+#endif
+
 	if (!connect(false)) {
 		DOLOG(ll_error, true, "disk_backend_nbd: cannot connect to NBD server");
 		return false;
@@ -130,7 +137,7 @@ bool disk_backend_nbd::connect(const bool retry)
 			uint64_t size;
 			uint32_t flags;
 			uint8_t  padding[124];
-		} nbd_hello;
+		} nbd_hello { };
 
 		if (fd != -1) {
 			if (READ(fd, reinterpret_cast<char *>(&nbd_hello), sizeof nbd_hello) != sizeof nbd_hello) {
@@ -154,14 +161,27 @@ bool disk_backend_nbd::connect(const bool retry)
 	return fd != -1;
 }
 
-bool disk_backend_nbd::read(const off_t offset, const size_t n, uint8_t *const target)
+bool disk_backend_nbd::read(const off_t offset_in, const size_t n, uint8_t *const target, const size_t sector_size)
 {
-	DOLOG(debug, false, "disk_backend_nbd::read: read %zu bytes from offset %zu", n, offset);
+	DOLOG(debug, false, "disk_backend_nbd::read: read %zu bytes from offset %zu", n, offset_in);
 
 	if (n == 0)
 		return true;
 
-	do {
+	size_t o      = 0;
+	off_t  offset = offset_in;
+
+	while(offset < offset_in + off_t(n)) {
+#if IS_POSIX
+		auto o_rc = get_from_overlay(offset, sector_size);
+		if (o_rc.has_value()) {
+			memcpy(&target[o], o_rc.value().data(), sector_size);
+			offset += sector_size;
+			o      += sector_size;
+			continue;
+		}
+#endif
+
 		if (fd == -1 && !connect(true)) {
 			DOLOG(warning, true, "disk_backend_nbd::read: (re-)connect");
 			sleep(1);
@@ -174,12 +194,12 @@ bool disk_backend_nbd::read(const off_t offset, const size_t n, uint8_t *const t
 			uint64_t handle;
 			uint64_t offset;
 			uint32_t length;
-		} nbd_request { 0 };
+		} nbd_request { };
 
 		nbd_request.magic  = ntohl(0x25609513);
 		nbd_request.type   = 0;  // READ
 		nbd_request.offset = HTONLL(uint64_t(offset));
-		nbd_request.length = htonl(n);
+		nbd_request.length = htonl(sector_size);
 
 		if (WRITE(fd, reinterpret_cast<const char *>(&nbd_request), sizeof nbd_request) != sizeof nbd_request) {
 			DOLOG(warning, true, "disk_backend_nbd::read: problem sending request");
@@ -217,26 +237,33 @@ bool disk_backend_nbd::read(const off_t offset, const size_t n, uint8_t *const t
 			return false;
 		}
 
-		if (READ(fd, reinterpret_cast<char *>(target), n) != ssize_t(n)) {
+		if (READ(fd, reinterpret_cast<char *>(target), sector_size) != ssize_t(sector_size)) {
 			DOLOG(warning, true, "disk_backend_nbd::read: problem receiving payload");
 			close(fd);
 			fd = -1;
 			sleep(1);
 			continue;
 		}
+
+		offset += sector_size;
+		o      += sector_size;
 	}
-	while(fd == -1);
 
 	return true;
 }
 
-bool disk_backend_nbd::write(const off_t offset, const size_t n, const uint8_t *const from)
+bool disk_backend_nbd::write(const off_t offset, const size_t n, const uint8_t *const from, const size_t sector_size)
 {
 	DOLOG(debug, false, "disk_backend_nbd::write: write %zu bytes to offset %zu", n, offset);
 
 	if (n == 0)
 		return true;
 
+#if IS_POSIX
+	if (store_mem_range_in_overlay(offset, n, from, sector_size))
+		return true;
+#endif
+
 	do {
 		if (!connect(true)) {
 			DOLOG(warning, true, "disk_backend_nbd::write: (re-)connect");
@@ -250,7 +277,7 @@ bool disk_backend_nbd::write(const off_t offset, const size_t n, const uint8_t *
 			uint64_t handle;
 			uint64_t offset;
 			uint32_t length;
-		} nbd_request { 0 };
+		} nbd_request { };
 
 		nbd_request.magic  = ntohl(0x25609513);
 		nbd_request.type   = 1;  // WRITE

disk_backend_nbd.h

@@ -1,4 +1,4 @@
-// (C) 2018-2023 by Folkert van Heusden
+// (C) 2018-2024 by Folkert van Heusden
 // Released under MIT license
 
 #include <string>
@@ -6,6 +6,7 @@
 
 #include "disk_backend.h"
 #include "gen.h"
+#include "utils.h"
 
 
 class disk_backend_nbd : public disk_backend
@@ -26,9 +27,11 @@ public:
 	static disk_backend_nbd *deserialize(const json_t *const j);
 #endif
 
-	bool begin() override;
+	std::string get_identifier() const override { return format("%s:%d", host.c_str(), port); }
 
-	bool read(const off_t offset, const size_t n, uint8_t *const target) override;
+	bool begin(const bool snapshots) override;
 
-	bool write(const off_t offset, const size_t n, const uint8_t *const from) override;
+	bool read(const off_t offset, const size_t n, uint8_t *const target, const size_t sector_size) override;
+
+	bool write(const off_t offset, const size_t n, const uint8_t *const from, const size_t sector_size) override;
 };

disk_device.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <vector>
+
+#include "device.h"
+#include "disk_backend.h"
+
+
+class disk_device: public device
+{
+protected:
+	std::vector<disk_backend *> fhs;
+
+public:
+	disk_device() {
+	}
+
+	virtual ~disk_device() {
+	}
+
+	std::vector<disk_backend *> * access_disk_backends() { return &fhs; }
+};

gen.h

@@ -28,5 +28,6 @@ typedef enum { rm_prev, rm_cur } rm_selection_t;
 // see also https://github.com/espressif/esp-idf/issues/1934
 #define DEFAULT_N_PAGES 12
 #else
+// more requires unibusmap support
 #define DEFAULT_N_PAGES 31
 #endif

loaders.cpp

@@ -28,7 +28,7 @@ void loadbin(bus *const b, uint16_t base, const char *const file)
 	fclose(fh);
 }
 
-void setBootLoader(bus *const b, const bootloader_t which)
+void set_boot_loader(bus *const b, const bootloader_t which)
 {
 	cpu       *const c      = b->getCpu();
 
@@ -40,7 +40,7 @@ void setBootLoader(bus *const b, const bootloader_t which)
 	if (which == BL_RK05) {
 		start = offset = 01000;
 
-		static uint16_t rk05_code[] = {
+		constexpr const uint16_t rk05_code[] = {
 			0012700,
 			0177406,
 			0012710,
@@ -92,7 +92,7 @@ void setBootLoader(bus *const b, const bootloader_t which)
 		start = offset = 01000;
 
 		/* from https://www.pdp-11.nl/peripherals/disk/rl-info.html
-		static uint16_t rl02_code[] = {
+		constexpr const uint16_t rl02_code[] = {
 			0012701,
 			0174400,
 			0012761,
@@ -120,7 +120,7 @@ void setBootLoader(bus *const b, const bootloader_t which)
 		*/
 
 		// from http://gunkies.org/wiki/RL11_disk_controller
-		static uint16_t rl02_code[] = {
+		constexpr const uint16_t rl02_code[] = {
 			0012700,
 			0174400,
 			0012760,
@@ -144,7 +144,7 @@ void setBootLoader(bus *const b, const bootloader_t which)
 	c->setRegister(7, start);
 }
 
-std::optional<uint16_t> loadTape(bus *const b, const std::string & file)
+std::optional<uint16_t> load_tape(bus *const b, const std::string & file)
 {
 #if defined(ESP32)
 	File32 fh;

loaders.h

@@ -1,4 +1,4 @@
-// (C) 2018-2023 by Folkert van Heusden
+// (C) 2018-2024 by Folkert van Heusden
 // Released under MIT license
 
 #include <optional>
@@ -11,6 +11,6 @@
 typedef enum { BL_NONE, BL_RK05, BL_RL02 } bootloader_t;
 
 void                    loadbin(bus *const b, uint16_t base, const char *const file);
-void                    setBootLoader(bus *const b, const bootloader_t which);
+void                    set_boot_loader(bus *const b, const bootloader_t which);
-std::optional<uint16_t> loadTape(bus *const b, const std::string & file);
+std::optional<uint16_t> load_tape(bus *const b, const std::string & file);
 void                    load_p11_x11(bus *const b, const std::string & file);

log.cpp

@@ -54,9 +54,10 @@ void setlogfile(const char *const lf, const log_level_t ll_file, const log_level
 	atexit(closelog);
 }
 
-void setloghost(const char *const host, const log_level_t ll)
+bool setloghost(const char *const host, const log_level_t ll)
 {
-	inet_aton(host, &syslog_ip_addr.sin_addr);
+	syslog_ip_addr.sin_family = AF_INET;
+	bool ok = inet_aton(host, &syslog_ip_addr.sin_addr) == 1;
 	syslog_ip_addr.sin_port   = htons(514);
 
 	is_file        = false;
@@ -64,6 +65,8 @@ void setloghost(const char *const host, const log_level_t ll)
 	log_level_file = ll;
 
 	l_timestamp    = false;
+
+	return ok;
 }
 
 void setll(const log_level_t ll_screen, const log_level_t ll_file)

log.h

@@ -12,9 +12,10 @@ typedef enum { ll_emerg = 0, ll_alert, ll_critical, ll_error, warning, notice, i
 
 log_level_t parse_ll(const std::string & str);
 void setlogfile(const char *const lf, const log_level_t ll_file, const log_level_t ll_screen, const bool l_timestamp);
-void setloghost(const char *const host, const log_level_t ll);
+bool setloghost(const char *const host, const log_level_t ll);
 void setll(const log_level_t ll_screen, const log_level_t ll_file);
 void setloguid(const int uid, const int gid);
+void send_syslog(const int ll, const std::string & what);
 void closelog();
 void dolog(const log_level_t ll, const char *fmt, ...);
 

main.cpp

@@ -295,10 +295,19 @@ void get_metrics(cpu *const c)
 	}
 }
 
+void start_disk_devices(const std::vector<disk_backend *> & backends, const bool enable_snapshots)
+{
+	for(auto & backend: backends) {
+		if (backend->begin(enable_snapshots) == false)
+			error_exit(false, "Failed to initialize disk backend \"%s\"", backend->get_identifier().c_str());
+	}
+}
+
 void help()
 {
 	printf("-h       this help\n");
 	printf("-D x     deserialize state from file\n");
+	printf("-P       when serializing state to file (in the debugger), include an overlay: changes to disk-files are then non-persistent, they only exist in the state-dump\n");
 	printf("-T t.bin load file as a binary tape file (like simh \"load\" command), also for .BIC files\n");
 	printf("-B       run tape file as a unit test (for .BIC files)\n");
 	printf("-R d.rk  load file as a RK05 disk device\n");
@@ -318,27 +327,8 @@ void help()
 	printf("-M       log metrics\n");
 }
 
-#include "breakpoint_parser.h"
 int main(int argc, char *argv[])
 {
-#if 0
-	{
-	bus *b = new bus();
-	cpu *c = new cpu(b, &event);
-	b->add_cpu(c);
-
-	std::pair<breakpoint *, std::optional<std::string> > rc = parse_breakpoint(b, "(pc=0123 and (r0=01456 or r2=1) and memWV[0444]=0222)");
-	printf("%p\n", rc.first);
-
-	if (rc.second.has_value())
-		printf("%s\n", rc.second.value().c_str());
-	delete rc.first;
-	delete b;
-	}
-
-	return 0;
-#endif
-
 	//setlocale(LC_ALL, "");
 
 	std::vector<disk_backend *> rk05_files;
@@ -365,7 +355,7 @@ int main(int argc, char *argv[])
 
 	std::string  test;
 
-	disk_backend *temp_d = nullptr;
+	bool         disk_snapshots = false;
 
 	std::optional<int> set_ram_size;
 
@@ -376,7 +366,7 @@ int main(int argc, char *argv[])
 	std::string  deserialize;
 
 	int  opt          = -1;
-	while((opt = getopt(argc, argv, "hD:MT:Br:R:p:ndtL:bl:s:Q:N:J:XS:")) != -1)
+	while((opt = getopt(argc, argv, "hD:MT:Br:R:p:ndtL:bl:s:Q:N:J:XS:P")) != -1)
 	{
 		switch(opt) {
 			case 'h':
@@ -441,17 +431,11 @@ int main(int argc, char *argv[])
 				break;
 
 			case 'R':
-				temp_d = new disk_backend_file(optarg);
+				rk05_files.push_back(new disk_backend_file(optarg));
-				if (!temp_d->begin())
-					error_exit(false, "Cannot use file \"%s\" for RK05", optarg);
-				rk05_files.push_back(temp_d);
 				break;
 
 			case 'r':
-				temp_d = new disk_backend_file(optarg);
+				rl02_files.push_back(new disk_backend_file(optarg));
-				if (!temp_d->begin())
-					error_exit(false, "Cannot use file \"%s\" for RL02", optarg);
-				rl02_files.push_back(temp_d);
 				break;
 
 			case 'N': {
@@ -459,7 +443,7 @@ int main(int argc, char *argv[])
 					  if (parts.size() != 3)
 						  error_exit(false, "-N: parameter missing");
 
-					  temp_d = new disk_backend_nbd(parts.at(0), atoi(parts.at(1).c_str()));
+					  disk_backend *temp_d = new disk_backend_nbd(parts.at(0), atoi(parts.at(1).c_str()));
 
 					  if (parts.at(2) == "rk05")
 						rk05_files.push_back(temp_d);
@@ -494,6 +478,10 @@ int main(int argc, char *argv[])
 				set_ram_size = std::stoi(optarg);
 				break;
 
+			case 'P':
+				disk_snapshots = true;
+				break;
+
 			default:
 			        fprintf(stderr, "-%c is not understood\n", opt);
 				return 1;
@@ -507,10 +495,14 @@ int main(int argc, char *argv[])
 	if (validate_json.empty() == false)
 		return run_cpu_validation(validate_json);
 
-	DOLOG(info, true, "This PDP-11 emulator is called \"kek\" (reason for that is forgotten) and was written by Folkert van Heusden.");
+	DOLOG(info, true, "PDP11 emulator, by Folkert van Heusden");
 
 	DOLOG(info, true, "Built on: " __DATE__ " " __TIME__);
 
+	start_disk_devices(rk05_files, disk_snapshots);
+
+	start_disk_devices(rl02_files, disk_snapshots);
+
 #if !defined(_WIN32)
 	if (withUI)
 		cnsl = new console_ncurses(&event);
@@ -533,26 +525,18 @@ int main(int argc, char *argv[])
 		cpu *c = new cpu(b, &event);
 		b->add_cpu(c);
 
-		if (rk05_files.empty() == false) {
+		if (rk05_files.empty() == false)
-			if (enable_bootloader == false)
-				DOLOG(warning, true, "Note: loading RK05 with no (RK05-) bootloader selected");
-			else
 			bootloader = BL_RK05;
 
-			b->add_rk05(new rk05(rk05_files, b, cnsl->get_disk_read_activity_flag(), cnsl->get_disk_write_activity_flag()));
+		if (rl02_files.empty() == false)
-		}
-
-		if (rl02_files.empty() == false) {
-			if (enable_bootloader == false)
-				DOLOG(warning, true, "Note: loading RL02 with no (RL02-) bootloader selected");
-			else
 			bootloader = BL_RL02;
 
-			b->add_rl02(new rl02(rl02_files, b, cnsl->get_disk_read_activity_flag(), cnsl->get_disk_write_activity_flag()));
-		}
-
 		if (enable_bootloader)
-			setBootLoader(b, bootloader);
+			set_boot_loader(b, bootloader);
+
+		b->add_rk05(new rk05(rk05_files, b, cnsl->get_disk_read_activity_flag(), cnsl->get_disk_write_activity_flag()));
+
+		b->add_rl02(new rl02(rl02_files, b, cnsl->get_disk_read_activity_flag(), cnsl->get_disk_write_activity_flag()));
 	}
 	else {
 		FILE *fh = fopen(deserialize.c_str(), "r");
@@ -590,7 +574,7 @@ int main(int argc, char *argv[])
 	std::optional<uint16_t> bic_start;
 
 	if (tape.empty() == false) {
-		bic_start = loadTape(b, tape);
+		bic_start = load_tape(b, tape);
 
 		if (bic_start.has_value() == false)
 			return 1;  // fail

mmu.cpp

@@ -9,6 +9,7 @@
 
 mmu::mmu()
 {
+	reset();
 }
 
 mmu::~mmu()

rk05.cpp

@@ -156,7 +156,7 @@ void rk05::writeWord(const uint16_t addr, const uint16_t v)
 					for(size_t i=0; i<cur; i++)
 						xfer_buffer[i] = b->readUnibusByte(work_memoff++);
 
-					if (!fhs.at(device)->write(work_diskoffb, cur, xfer_buffer))
+					if (!fhs.at(device)->write(work_diskoffb, cur, xfer_buffer, 512))
 						DOLOG(ll_error, true, "RK05(%d) write error %s to %u len %u", device, strerror(errno), work_diskoffb, cur);
 
 					work_diskoffb += cur;
@@ -191,7 +191,7 @@ void rk05::writeWord(const uint16_t addr, const uint16_t v)
 				while(temp > 0) {
 					uint32_t cur = std::min(uint32_t(sizeof xfer_buffer), temp);
 
-					if (!fhs.at(device)->read(temp_diskoffb, cur, xfer_buffer)) {
+					if (!fhs.at(device)->read(temp_diskoffb, cur, xfer_buffer, 512)) {
 						DOLOG(ll_error, true, "RK05 read error %s from %u len %u", strerror(errno), temp_diskoffb, cur);
 						break;
 					}

rk05.h

@@ -9,7 +9,7 @@
 #include <string>
 #include <vector>
 
-#include "device.h"
+#include "disk_device.h"
 #include "disk_backend.h"
 
 
@@ -25,12 +25,11 @@
 
 class bus;
 
-class rk05 : public device
+class rk05: public disk_device
 {
 private:
 	bus      *const b                { nullptr };
 	uint16_t        registers  [7]   { 0       };
-	std::vector<disk_backend *> fhs;
 	uint8_t         xfer_buffer[512] { 0       };
 
 	std::atomic_bool *const disk_read_acitivity  { nullptr };

rl02.cpp

@@ -271,7 +271,7 @@ void rl02::writeWord(const uint16_t addr, uint16_t v)
 					mpr[0]++;
 				}
 
-				if (!fhs.at(device)->write(temp_disk_offset, cur, xfer_buffer)) {
+				if (fhs.at(device) == nullptr || fhs.at(device)->write(temp_disk_offset, cur, xfer_buffer, 256) == false) {
 					DOLOG(ll_error, true, "RL02: write error, device %d, disk offset %u, read size %u, cylinder %d, head %d, sector %d", device, temp_disk_offset, cur, track, head, sector);
 					break;
 				}
@@ -325,7 +325,7 @@ void rl02::writeWord(const uint16_t addr, uint16_t v)
 			while(count > 0) {
 				uint32_t cur = std::min(uint32_t(sizeof xfer_buffer), count);
 
-				if (!fhs.at(device)->read(temp_disk_offset, cur, xfer_buffer)) {
+				if (fhs.at(device) == nullptr || fhs.at(device)->read(temp_disk_offset, cur, xfer_buffer, 256) == false) {
 					DOLOG(ll_error, true, "RL02: read error, device %d, disk offset %u, read size %u, cylinder %d, head %d, sector %d", device, temp_disk_offset, cur, track, head, sector);
 					break;
 				}
@@ -365,7 +365,7 @@ void rl02::writeWord(const uint16_t addr, uint16_t v)
 				*disk_read_activity = false;
 		}
 		else {
-			DOLOG(warning, false, "RL02: command %d not implemented", command);
+			DOLOG(debug, false, "RL02: command %d not implemented", command);
 		}
 
 		if (do_int) {

rl02.h

@@ -9,7 +9,7 @@
 #include <string>
 #include <vector>
 
-#include "device.h"
+#include "disk_device.h"
 #include "disk_backend.h"
 #include "gen.h"
 
@@ -27,7 +27,7 @@ constexpr const int rl02_bytes_per_sector  = 256;
 
 class bus;
 
-class rl02 : public device
+class rl02: public disk_device
 {
 private:
 	bus      *const b;
@@ -37,7 +37,6 @@ private:
 	uint8_t         head   { 0 };
 	uint8_t         sector { 0 };
 	uint16_t        mpr[3];
-	std::vector<disk_backend *> fhs;
 
 	std::atomic_bool *const disk_read_activity  { nullptr };
 	std::atomic_bool *const disk_write_activity { nullptr };