Merge commit '0a2f508e616bc0440dd70cf5088828bd6de71c15' into esp32-mailfunction

ESP32/console_esp32.cpp

@@ -14,7 +14,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(stop_event, b, t_width, t_height),
+	console(stop_event, t_width, t_height),
 	io_ports(io_ports)
 {
 }

ESP32/main.ino

@@ -290,6 +290,7 @@ void setup() {
 #elif defined(ESP32) || defined(BUILD_FOR_RP2040)
 	cnsl = new console_esp32(&stop_event, b, serial_ports, 80, 25);
 #endif
+	cnsl->set_bus(b);
 
 	running = cnsl->get_running_flag();
 

bus.cpp

@@ -23,8 +23,6 @@
 
 bus::bus()
 {
-	m = new memory(n_pages * 8192l);
-
 	mmu_ = new mmu();
 
 	kw11_l_ = new kw11_l(this);
@@ -44,6 +42,82 @@ bus::~bus()
 	delete m;
 }
 
+#if IS_POSIX
+json_t *bus::serialize() const
+{
+	json_t *j_out = json_object();
+
+	if (m)
+		json_object_set(j_out, "memory", m->serialize());
+
+	if (kw11_l_)
+		json_object_set(j_out, "kw11-l", kw11_l_->serialize());
+
+	if (tty_)
+		json_object_set(j_out, "tty", tty_->serialize());
+
+	if (mmu_)
+		json_object_set(j_out, "mmu", mmu_->serialize());
+
+	if (c)
+		json_object_set(j_out, "cpu", c->serialize());
+
+	if (rl02_)
+		json_object_set(j_out, "rl02", rl02_->serialize());
+
+	// TODO: rk05, tm11
+
+	return j_out;
+}
+
+bus *bus::deserialize(const json_t *const j, console *const cnsl, std::atomic_uint32_t *const event)
+{
+	bus *b = new bus();
+
+	json_t *temp = nullptr;
+
+	temp = json_object_get(j, "memory");
+	if (temp) {
+		memory *m = memory::deserialize(temp);
+		b->add_ram(m);
+	}
+
+	temp = json_object_get(j, "kw11-l");
+	if (temp) {
+		kw11_l *kw11_l_ = kw11_l::deserialize(temp, b, cnsl);
+		b->add_KW11_L(kw11_l_);
+	}
+
+	temp = json_object_get(j, "tty");
+	if (temp) {
+		tty *tty_ = tty::deserialize(temp, b, cnsl);
+		b->add_tty(tty_);
+	}
+
+	temp = json_object_get(j, "mmu");
+	if (temp) {
+		mmu *mmu_ = mmu::deserialize(temp);
+		b->add_mmu(mmu_);
+	}
+
+	temp = json_object_get(j, "cpu");
+	if (temp) {
+		cpu *cpu_ = cpu::deserialize(temp, b, event);
+		b->add_cpu(cpu_);
+	}
+
+	temp = json_object_get(j, "rl02");
+	if (temp) {
+		rl02 *rl02_ = rl02::deserialize(temp, b);
+		b->add_rl02(rl02_);
+	}
+
+	// TODO: rk05, tm11
+
+	return b;
+}
+#endif
+
 void bus::set_memory_size(const int n_pages)
 {
 	this->n_pages = n_pages;
@@ -58,10 +132,10 @@ void bus::set_memory_size(const int n_pages)
 
 void bus::reset()
 {
+	if (m)
 		m->reset();
-
+	if (mmu_)
 		mmu_->reset();
-
 	if (c)
 		c->reset();
 	if (tm11)
@@ -72,6 +146,26 @@ void bus::reset()
 		rl02_->reset();
 	if (tty_)
 		tty_->reset();
+	if (kw11_l_)
+		kw11_l_->reset();
+}
+
+void bus::add_KW11_L(kw11_l *const kw11_l_)
+{
+	delete this->kw11_l_;
+	this->kw11_l_ = kw11_l_;
+}
+
+void bus::add_ram(memory *const m)
+{
+	delete this->m;
+	this->m = m;
+}
+
+void bus::add_mmu(mmu *const mmu_)
+{
+	delete this->mmu_;
+	this->mmu_ = mmu_;
 }
 
 void bus::add_cpu(cpu *const c)
@@ -83,7 +177,7 @@ void bus::add_cpu(cpu *const c)
 void bus::add_tm11(tm_11 *const tm11)
 {
 	delete this->tm11;
-	this->tm11  = tm11;
+	this->tm11= tm11;
 } 
 
 void bus::add_rk05(rk05 *const rk05_)

bus.h

@@ -18,14 +18,6 @@
 #include "rp2040.h"
 #endif
 
-#if defined(ESP32) || defined(BUILD_FOR_RP2040)
-// ESP32 goes in a crash-loop when allocating 128kB
-// see also https://github.com/espressif/esp-idf/issues/1934
-#define DEFAULT_N_PAGES 12
-#else
-#define DEFAULT_N_PAGES 31
-#endif
-
 #define ADDR_MMR0 0177572
 #define ADDR_MMR1 0177574
 #define ADDR_MMR2 0177576
@@ -53,6 +45,7 @@
 #define ADDR_CCR 0177746
 #define ADDR_SYSTEM_ID 0177764
 
+class console;
 class cpu;
 class kw11_l;
 class memory;
@@ -97,33 +90,40 @@ public:
 	bus();
 	~bus();
 
+#if IS_POSIX
+	json_t *serialize() const;
+	static bus *deserialize(const json_t *const j, console *const cnsl, std::atomic_uint32_t *const event);
+#endif
+
 	void reset();
+	void init();  // invoked by 'RESET' command
 
 	void set_console_switches(const uint16_t new_state) { console_switches = new_state; }
 	void set_console_switch(const int bit, const bool state) { console_switches &= ~(1 << bit); console_switches |= state << bit; }
 	uint16_t get_console_switches() { return console_switches; }
 	void set_debug_mode() { console_switches |= 128; }
+	uint16_t get_console_leds() { return console_leds; }
 
 	int  get_memory_size() const { return n_pages; }
 	void set_memory_size(const int n_pages);
 
 	void mmudebug(const uint16_t a);
 
-	uint16_t get_console_leds() { return console_leds; }
+	void add_ram   (memory *const m      );
-
 	void add_cpu   (cpu    *const c      );
-	void add_tm11(tm_11 *const tm11 );
+	void add_mmu   (mmu    *const mmu_   );
-	void add_rk05(rk05  *const rk05_);
+	void add_tm11  (tm_11  *const tm11   );
-	void add_rl02(rl02  *const rl02_);
+	void add_rk05  (rk05   *const rk05_  );
+	void add_rl02  (rl02   *const rl02_  );
 	void add_tty   (tty    *const tty_   );
+	void add_KW11_L(kw11_l *const kw11_l_);
 
+	memory *getRAM()    { return m;       }
 	cpu    *getCpu()    { return c;       }
 	kw11_l *getKW11_L() { return kw11_l_; }
 	tty    *getTty()    { return tty_;    }
 	mmu    *getMMU()    { return mmu_;    }
 
-	void init();  // invoked by 'RESET' command
-
 	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); }
 	uint16_t readWord(const uint16_t a, const d_i_space_t s = i_space);

console.cpp

@@ -25,9 +25,8 @@ void thread_wrapper_console(void *p)
 }
 #endif
 
-console::console(std::atomic_uint32_t *const stop_event, bus *const b, const int t_width, const int t_height) :
+console::console(std::atomic_uint32_t *const stop_event, const int t_width, const int t_height) :
 	stop_event(stop_event),
-	b(b),
 	t_width(t_width),
 	t_height(t_height)
 {
@@ -49,6 +48,8 @@ console::~console()
 
 void console::start_thread() 
 {
+	assert(b);
+
 	stop_thread_flag = false;
 
 #if defined(BUILD_FOR_RP2040)

console.h

@@ -31,7 +31,7 @@ private:
 protected:
 	std::atomic_uint32_t *const stop_event    { nullptr };
 
-	bus              *const b                { nullptr };
+	bus                    *b                { nullptr };
 #if !defined(BUILD_FOR_RP2040)
 	std::thread            *th               { nullptr };
 #endif
@@ -57,9 +57,11 @@ protected:
 	virtual void put_char_ll(const char c) = 0;
 
 public:
-	console(std::atomic_uint32_t *const stop_event, bus *const b, const int t_width = 80, const int t_height = 25);
+	console(std::atomic_uint32_t *const stop_event, const int t_width = 80, const int t_height = 25);
 	virtual ~console();
 
+	void         set_bus(bus *const b) { this->b = b; }
+
 	void         start_thread();
 	void         stop_thread();
 

console_ncurses.cpp

@@ -13,8 +13,7 @@
 #include "utils.h"
 
 
-console_ncurses::console_ncurses(std::atomic_uint32_t *const stop_event, bus *const b) :
+console_ncurses::console_ncurses(std::atomic_uint32_t *const stop_event): console(stop_event)
-	console(stop_event, b)
 {
 	init_ncurses(true);
 

console_ncurses.h

@@ -29,7 +29,7 @@ protected:
 	void put_char_ll(const char c) override;
 
 public:
-	console_ncurses(std::atomic_uint32_t *const stop_event, bus *const b);
+	console_ncurses(std::atomic_uint32_t *const stop_event);
 	virtual ~console_ncurses();
 
 	void put_string_lf(const std::string & what) override;

console_posix.cpp

@@ -16,8 +16,7 @@
 #include "error.h"
 
 
-console_posix::console_posix(std::atomic_uint32_t *const stop_event, bus *const b) :
+console_posix::console_posix(std::atomic_uint32_t *const stop_event): console(stop_event)
-	console(stop_event, b)
 {
 #if !defined(_WIN32)
 	if (tcgetattr(STDIN_FILENO, &org_tty_opts) == -1)

console_posix.h

@@ -21,7 +21,7 @@ protected:
 	void put_char_ll(const char c) override;
 
 public:
-	console_posix(std::atomic_uint32_t *const stop_event, bus *const b);
+	console_posix(std::atomic_uint32_t *const stop_event);
 	virtual ~console_posix();
 
 	void resize_terminal() override;

cpu.cpp

@@ -2395,3 +2395,66 @@ void cpu::step()
 		DOLOG(debug, false, "bus-trap during execution of command (%d)", exception_nr);
 	}
 }
+
+#if IS_POSIX
+json_t *cpu::serialize()
+{
+	json_t *j = json_object();
+
+	for(int set=0; set<2; set++) {
+		for(int regnr=0; regnr<6; regnr++)
+			json_object_set(j, format("register-%d-%d", set, regnr).c_str(), json_integer(regs0_5[set][regnr]));
+	}
+
+	for(int spnr=0; spnr<4; spnr++)
+		json_object_set(j, format("sp-%d", spnr).c_str(), json_integer(sp[spnr]));
+
+        json_object_set(j, "pc", json_integer(pc));
+        json_object_set(j, "instruction_start", json_integer(instruction_start));
+        json_object_set(j, "psw", json_integer(psw));
+        json_object_set(j, "fpsr", json_integer(fpsr));
+        json_object_set(j, "stackLimitRegister", json_integer(stackLimitRegister));
+        json_object_set(j, "processing_trap_depth", json_integer(processing_trap_depth));
+        json_object_set(j, "instruction_count", json_integer(instruction_count));
+        json_object_set(j, "running_since", json_integer(running_since));
+        json_object_set(j, "wait_time", json_integer(wait_time));
+        json_object_set(j, "it_is_a_trap", json_boolean(it_is_a_trap));
+        json_object_set(j, "debug_mode", json_boolean(debug_mode));
+	if (trap_delay.has_value())
+		json_object_set(j, "trap_delay", json_integer(trap_delay.value()));
+
+	return j;
+}
+
+cpu *cpu::deserialize(const json_t *const j, bus *const b, std::atomic_uint32_t *const event)
+{
+	cpu *c = new cpu(b, event);
+
+	for(int set=0; set<2; set++) {
+		for(int regnr=0; regnr<6; regnr++)
+			c->regs0_5[set][regnr] = json_integer_value(json_object_get(j, format("register-%d-%d", set, regnr).c_str()));
+	}
+
+	for(int spnr=0; spnr<4; spnr++)
+		c->sp[spnr] = json_integer_value(json_object_get(j, format("sp-%d", spnr).c_str()));
+
+        c->pc                    = json_integer_value(json_object_get(j, "pc"));
+        c->instruction_start     = json_integer_value(json_object_get(j, "instruction_start"));
+        c->psw                   = json_integer_value(json_object_get(j, "psw"));
+        c->fpsr                  = json_integer_value(json_object_get(j, "fpsr"));
+        c->stackLimitRegister    = json_integer_value(json_object_get(j, "stackLimitRegister"));
+        c->processing_trap_depth = json_integer_value(json_object_get(j, "processing_trap_depth"));
+        c->instruction_count     = json_integer_value(json_object_get(j, "instruction_count"));
+        c->running_since         = get_us();
+        c->wait_time             = 0;
+        c->it_is_a_trap          = json_boolean_value(json_object_get(j, "it_is_a_trap"));
+        c->debug_mode            = json_boolean_value(json_object_get(j, "debug_mode"));
+	json_t *temp = json_object_get(j, "trap_delay");
+	if (temp)
+		c->trap_delay    = json_integer_value(temp);
+	else
+		c->trap_delay.reset();
+
+	return c;
+}
+#endif

cpu.h

@@ -14,6 +14,7 @@
 
 #include "breakpoint.h"
 #include "bus.h"
+#include "gen.h"
 
 
 constexpr const int initial_trap_delay   = 8;
@@ -111,6 +112,11 @@ public:
 	explicit cpu(bus *const b, std::atomic_uint32_t *const event);
 	~cpu();
 
+#if IS_POSIX
+	json_t *serialize();
+	static cpu *deserialize(const json_t *const j, bus *const b, std::atomic_uint32_t *const event);
+#endif
+
 	std::optional<std::string> check_breakpoint();
 	int set_breakpoint(breakpoint *const bp);
 	bool remove_breakpoint(const int bp_id);

debugger.cpp

@@ -722,6 +722,27 @@ void show_queued_interrupts(console *const cnsl, cpu *const c)
 	}
 }
 
+#if IS_POSIX
+void serialize_state(console *const cnsl, const bus *const b, const std::string & filename)
+{
+	json_t *j = b->serialize();
+
+	bool ok = false;
+
+	FILE *fh = fopen(filename.c_str(), "w");
+	if (fh) {
+		if (json_dumpf(j, fh, JSON_INDENT(4)) == 0)
+			ok = true;
+
+		fclose(fh);
+	}
+
+	json_decref(j);
+
+	cnsl->put_string_lf(format("Serialize to %s: %s", filename.c_str(), ok ? "OK" : "failed"));
+}
+#endif
+
 void debugger(console *const cnsl, bus *const b, std::atomic_uint32_t *const stop_event, const bool tracing_in)
 {
 	int32_t trace_start_addr = -1;
@@ -1069,6 +1090,12 @@ void debugger(console *const cnsl, bus *const b, std::atomic_uint32_t *const sto
 
 				continue;
 			}
+#if IS_POSIX
+			else if (parts[0] == "ser" && parts.size() == 2) {
+				serialize_state(cnsl, b, parts.at(1));
+				continue;
+			}
+#endif
 			else if (parts[0] == "setsl" && parts.size() == 3) {
 				setloghost(parts.at(1).c_str(), parse_ll(parts[2]));
 
@@ -1130,6 +1157,10 @@ void debugger(console *const cnsl, bus *const b, std::atomic_uint32_t *const sto
 					"stats         - show run statistics",
 					"ramsize       - set ram size (page count (8 kB))",
 					"bl            - set bootload (rl02 or rk05)",
+#if IS_POSIX
+					"ser           - serialize state to a file",
+					"dser          - deserialize state from a file",
+#endif
 #if defined(ESP32)
 					"cfgnet        - configure network (e.g. WiFi)",
 					"startnet      - start network",

disk_backend.cpp

@@ -1,7 +1,13 @@
-// (C) 2018-2023 by Folkert van Heusden
+// (C) 2018-2024 by Folkert van Heusden
 // Released under MIT license
 
 #include "disk_backend.h"
+#include "gen.h"
+#if IS_POSIX
+#include "disk_backend_file.h"
+#endif
+#include "disk_backend_nbd.h"
+
 
 disk_backend::disk_backend()
 {
@@ -10,3 +16,21 @@ disk_backend::disk_backend()
 disk_backend::~disk_backend()
 {
 }
+
+#if IS_POSIX
+disk_backend *disk_backend::deserialize(const json_t *const j)
+{
+	std::string type = json_string_value(json_object_get(j, "disk-backend-type"));
+
+	if (type == "file")
+		return disk_backend_file::deserialize(j);
+
+	if (type == "nbd")
+		return disk_backend_nbd::deserialize(j);
+
+	// should not be reached
+	assert(false);
+
+	return nullptr;
+}
+#endif

disk_backend.h

@@ -1,4 +1,4 @@
-// (C) 2018-2023 by Folkert van Heusden
+// (C) 2018-2024 by Folkert van Heusden
 // Released under MIT license
 
 #pragma once
@@ -6,6 +6,8 @@
 #include <stdint.h>
 #include <sys/types.h>
 
+#include "gen.h"
+
 
 class disk_backend
 {
@@ -13,6 +15,11 @@ public:
 	disk_backend();
 	virtual ~disk_backend();
 
+#if IS_POSIX
+	virtual json_t *serialize() const = 0;
+	static disk_backend *deserialize(const json_t *const j);
+#endif
+
 	virtual bool begin() = 0;
 
 	virtual bool read(const off_t offset, const size_t n, uint8_t *const target) = 0;

disk_backend_file.cpp

@@ -19,6 +19,26 @@ disk_backend_file::~disk_backend_file()
 	close(fd);
 }
 
+#if IS_POSIX
+json_t *disk_backend_file::serialize() const
+{
+	json_t *j = json_object();
+
+	json_object_set(j, "disk-backend-type", json_string("file"));
+
+	// TODO store checksum of backend
+	json_object_set(j, "filename", json_string(filename.c_str()));
+
+	return j;
+}
+
+disk_backend_file *disk_backend_file::deserialize(const json_t *const j)
+{
+	// TODO verify checksum of backend
+	return new disk_backend_file(json_string_value(json_object_get(j, "filename")));
+}
+#endif
+
 bool disk_backend_file::begin()
 {
 	fd = open(filename.c_str(), O_RDWR);

disk_backend_file.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>
@@ -17,6 +17,11 @@ public:
 	disk_backend_file(const std::string & filename);
 	virtual ~disk_backend_file();
 
+#if IS_POSIX
+	json_t *serialize() const override;
+	static disk_backend_file *deserialize(const json_t *const j);
+#endif
+
 	bool begin() override;
 
 	bool read(const off_t offset, const size_t n, uint8_t *const target) override;

disk_backend_nbd.cpp

@@ -47,6 +47,27 @@ disk_backend_nbd::~disk_backend_nbd()
 	close(fd);
 }
 
+#if IS_POSIX
+json_t *disk_backend_nbd::serialize() const
+{
+	json_t *j = json_object();
+
+	json_object_set(j, "disk-backend-type", json_string("nbd"));
+
+	// TODO store checksum of backend
+	json_object_set(j, "host", json_string(host.c_str()));
+	json_object_set(j, "port", json_integer(port));
+
+	return j;
+}
+
+disk_backend_nbd *disk_backend_nbd::deserialize(const json_t *const j)
+{
+	// TODO verify checksum of backend
+	return new disk_backend_nbd(json_string_value(json_object_get(j, "host")), json_integer_value(json_object_get(j, "port")));
+}
+#endif
+
 bool disk_backend_nbd::begin()
 {
 	if (!connect(false)) {

disk_backend_nbd.h

@@ -5,6 +5,7 @@
 #include <sys/types.h>
 
 #include "disk_backend.h"
+#include "gen.h"
 
 
 class disk_backend_nbd : public disk_backend
@@ -20,6 +21,11 @@ public:
 	disk_backend_nbd(const std::string & host, const unsigned port);
 	virtual ~disk_backend_nbd();
 
+#if IS_POSIX
+	json_t *serialize() const override;
+	static disk_backend_nbd *deserialize(const json_t *const j);
+#endif
+
 	bool begin() override;
 
 	bool read(const off_t offset, const size_t n, uint8_t *const target) override;

gen.h

@@ -13,5 +13,20 @@ typedef enum { wm_word = 0, wm_byte = 1 } word_mode_t;
 
 typedef enum { rm_prev, rm_cur } rm_selection_t;
 
-#define IS_POSIX (defined(linux) || defined (__unix__) || (defined (__APPLE__) && defined (__MACH__)))
+#if (defined(linux) || defined (__unix__) || (defined (__APPLE__) && defined (__MACH__)))
-#define IS_UP (!(IS_POSIX))  /* is microprocessor */
+#define IS_POSIX 1
+#else
+#define IS_POSIX 0
+#endif
+
+#if IS_POSIX
+#include <jansson.h>
+#endif
+
+#if defined(ESP32) || defined(BUILD_FOR_RP2040)
+// ESP32 goes in a crash-loop when allocating 128kB
+// see also https://github.com/espressif/esp-idf/issues/1934
+#define DEFAULT_N_PAGES 12
+#else
+#define DEFAULT_N_PAGES 31
+#endif

kw11-l.cpp

@@ -57,6 +57,11 @@ void kw11_l::begin(console *const cnsl)
 #endif
 }
 
+void kw11_l::reset()
+{
+	lf_csr = 0;
+}
+
 void kw11_l::operator()()
 {
 	set_thread_name("kek:kw-11l");
@@ -154,3 +159,25 @@ uint8_t kw11_l::get_lf_crs()
 
 	return rc;
 }
+
+#if IS_POSIX
+json_t *kw11_l::serialize()
+{
+	json_t *j = json_object();
+
+	json_object_set(j, "CSR", json_integer(lf_csr));
+
+	return j;
+}
+
+kw11_l *kw11_l::deserialize(const json_t *const j, bus *const b, console *const cnsl)
+{
+	uint16_t CSR = json_integer_value(json_object_get(j, "CSR"));
+
+	kw11_l *out  = new kw11_l(b);
+	out->lf_csr  = CSR;
+	out->begin(cnsl);
+
+	return out;
+}
+#endif

kw11-l.h

@@ -6,6 +6,7 @@
 
 #include "bus.h"
 #include "console.h"
+#include "gen.h"
 
 
 class kw11_l
@@ -31,6 +32,13 @@ public:
 	kw11_l(bus *const b);
 	virtual ~kw11_l();
 
+	void     reset();
+
+#if IS_POSIX
+	json_t *serialize();
+	static kw11_l *deserialize(const json_t *const j, bus *const b, console *const cnsl);
+#endif
+
 	void     begin(console *const cnsl);
 	void     operator()();
 

main.cpp

@@ -298,6 +298,7 @@ void get_metrics(cpu *const c)
 void help()
 {
 	printf("-h       this help\n");
+	printf("-D x     deserialize state from file\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");
@@ -372,14 +373,20 @@ int main(int argc, char *argv[])
 
 	bool         metrics = false;
 
+	std::string  deserialize;
+
 	int  opt          = -1;
-	while((opt = getopt(argc, argv, "hMT: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:")) != -1)
 	{
 		switch(opt) {
 			case 'h':
 				help();
 				return 1;
 
+			case 'D':
+				deserialize = optarg;
+				break;
+
 			case 'M':
 				metrics = true;
 				break;
@@ -500,45 +507,32 @@ int main(int argc, char *argv[])
 	if (validate_json.empty() == false)
 		return run_cpu_validation(validate_json);
 
-	bus *b = new bus();
+	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, "Built on: " __DATE__ " " __TIME__);
+
+#if !defined(_WIN32)
+	if (withUI)
+		cnsl = new console_ncurses(&event);
+	else
+#endif
+		cnsl = new console_posix(&event);
+
+	bus *b = nullptr;
+
+	if (deserialize.empty()) {
+		b = new bus();
 
 		if (set_ram_size.has_value())
 			b->set_memory_size(set_ram_size.value());
+		else
+			b->set_memory_size(DEFAULT_N_PAGES * 8192l);
 
 		b->set_console_switches(console_switches);
 
 		cpu *c = new cpu(b, &event);
 		b->add_cpu(c);
 
-	std::atomic_bool interrupt_emulation { false };
-
-	std::optional<uint16_t> bic_start;
-
-	if (tape.empty() == false) {
-		bic_start = loadTape(b, tape);
-
-		if (bic_start.has_value() == false)
-			return 1;  // fail
-
-		c->setRegister(7, bic_start.value());
-	}
-
-	if (sa_set)
-		c->setRegister(7, start_addr);
-
-#if !defined(_WIN32)
-	if (withUI)
-		cnsl = new console_ncurses(&event, b);
-	else
-#endif
-	{
-		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, "Built on: " __DATE__ " " __TIME__);
-
-		cnsl = new console_posix(&event, b);
-	}
-
 		if (rk05_files.empty() == false) {
 			if (enable_bootloader == false)
 				DOLOG(warning, true, "Note: loading RK05 with no (RK05-) bootloader selected");
@@ -559,14 +553,52 @@ int main(int argc, char *argv[])
 
 		if (enable_bootloader)
 			setBootLoader(b, bootloader);
+	}
+	else {
+		FILE *fh = fopen(deserialize.c_str(), "r");
+		if (!fh)
+			error_exit(true, "Failed to open %s", deserialize.c_str());
 
-	running = cnsl->get_running_flag();
+		json_error_t je { };
+		json_t *j = json_loadf(fh, 0, &je);
 
+		fclose(fh);
+
+		if (!j)
+			error_exit(true, "State file %s is corrupt: %s", deserialize.c_str(), je.text);
+
+		b = bus::deserialize(j, cnsl, &event);
+
+		json_decref(j);
+	}
+
+	if (b->getTty() == nullptr) {
 		tty *tty_ = new tty(cnsl, b);
 
 		b->add_tty(tty_);
+	}
 
-	DOLOG(info, true, "Start running at %06o", c->getRegister(7));
+	cnsl->set_bus(b);
+
+	running = cnsl->get_running_flag();
+
+	std::atomic_bool interrupt_emulation { false };
+
+	std::optional<uint16_t> bic_start;
+
+	if (tape.empty() == false) {
+		bic_start = loadTape(b, tape);
+
+		if (bic_start.has_value() == false)
+			return 1;  // fail
+
+		b->getCpu()->setRegister(7, bic_start.value());
+	}
+
+	if (sa_set)
+		b->getCpu()->setRegister(7, start_addr);
+
+	DOLOG(info, true, "Start running at %06o", b->getCpu()->getRegister(7));
 
 #if !defined(_WIN32)
 	struct sigaction sa { };
@@ -586,7 +618,7 @@ int main(int argc, char *argv[])
 
 	std::thread *metrics_thread = nullptr;
 	if (metrics)
-		metrics_thread = new std::thread(get_metrics, c);
+		metrics_thread = new std::thread(get_metrics, b->getCpu());
 
 	cnsl->start_thread();
 
@@ -597,13 +629,13 @@ int main(int argc, char *argv[])
 	else if (run_debugger || (bootloader == BL_NONE && test.empty() && tape.empty()))
 		debugger(cnsl, b, &event, tracing);
 	else {
-		c->emulation_start();  // for statistics
+		b->getCpu()->emulation_start();  // for statistics
 
 		for(;;) {
 			*running = true;
 
 			while(event == EVENT_NONE)
-				c->step();
+				b->getCpu()->step();
 
 			*running = false;
 
@@ -613,7 +645,7 @@ int main(int argc, char *argv[])
 				break;
 		}
 
-		auto stats = c->get_mips_rel_speed({ }, { });
+		auto stats = b->getCpu()->get_mips_rel_speed({ }, { });
 		cnsl->put_string_lf(format("MIPS: %.2f, relative speed: %.2f%%, instructions executed: %" PRIu64 " in %.2f seconds", std::get<0>(stats), std::get<1>(stats), std::get<2>(stats), std::get<3>(stats) / 1000000.));
 	}
 

memory.cpp

@@ -27,3 +27,31 @@ void memory::reset()
 {
 	memset(m, 0x00, size);
 }
+
+#if IS_POSIX
+json_t *memory::serialize() const
+{
+	json_t *j = json_object();
+
+	json_object_set(j, "size", json_integer(size));
+
+	json_t *ja = json_array();
+	for(size_t i=0; i<size; i++)
+		json_array_append(ja, json_integer(m[i]));
+	json_object_set(j, "contents", ja);
+
+	return j;
+}
+
+memory *memory::deserialize(const json_t *const j)
+{
+	size_t  size = json_integer_value(json_object_get(j, "size"));
+	memory *m    = new memory(size);
+
+	json_t *ja   = json_object_get(j, "contents");
+	for(size_t i=0; i<size; i++)
+		m->m[i] = json_integer_value(json_array_get(ja, i));
+
+	return m;
+}
+#endif

memory.h

@@ -1,11 +1,13 @@
-// (C) 2018-2023 by Folkert van Heusden
+// (C) 2018-2024 by Folkert van Heusden
 // Released under MIT license
 
 #pragma once
-
 #include <assert.h>
 #include <stdint.h>
 
+#include "gen.h"
+
+
 class memory
 {
 private:
@@ -17,6 +19,10 @@ public:
 	~memory();
 
 	void reset();
+#if IS_POSIX
+	json_t *serialize() const;
+	static memory *deserialize(const json_t *const j);
+#endif
 
 	uint16_t readByte(const uint32_t a) const { return m[a]; }
 	void writeByte(const uint32_t a, const uint16_t v) { assert(a < size); m[a] = v; }

mmu.cpp

@@ -220,3 +220,80 @@ void mmu::writeByte(const uint16_t a, const uint8_t value)
 	else if (a >= ADDR_PAR_U_START && a < ADDR_PAR_U_END)
 		write_par(a, 3, value, wm_byte);
 }
+
+#if IS_POSIX
+void mmu::add_par_pdr(json_t *const target, const int run_mode, const bool is_d, const std::string & name) const
+{
+	json_t *j = json_object();
+
+	json_t *ja_par = json_array();
+	for(int i=0; i<8; i++)
+		json_array_append(ja_par, json_integer(pages[run_mode][is_d][i].par));
+	json_object_set(j, "par", ja_par);
+
+	json_t *ja_pdr = json_array();
+	for(int i=0; i<8; i++)
+		json_array_append(ja_pdr, json_integer(pages[run_mode][is_d][i].pdr));
+	json_object_set(j, "pdr", ja_pdr);
+
+	json_object_set(target, name.c_str(), j);
+}
+
+json_t *mmu::serialize() const
+{
+	json_t *j = json_object();
+
+	for(int run_mode=0; run_mode<4; run_mode++) {
+		if (run_mode == 2)
+			continue;
+
+		for(int is_d=0; is_d<2; is_d++)
+			add_par_pdr(j, run_mode, is_d, format("runmode_%d_d_%d", run_mode, is_d));
+	}
+
+        json_object_set(j, "MMR0", json_integer(MMR0));
+        json_object_set(j, "MMR1", json_integer(MMR1));
+        json_object_set(j, "MMR2", json_integer(MMR2));
+        json_object_set(j, "MMR3", json_integer(MMR3));
+        json_object_set(j, "CPUERR", json_integer(CPUERR));
+        json_object_set(j, "PIR", json_integer(PIR));
+        json_object_set(j, "CSR", json_integer(CSR));
+
+	return j;
+}
+
+void mmu::set_par_pdr(const json_t *const j_in, const int run_mode, const bool is_d, const std::string & name)
+{
+	json_t *j = json_object_get(j_in, name.c_str());
+
+	json_t *j_par = json_object_get(j, "par");
+	for(int i=0; i<8; i++)
+		pages[run_mode][is_d][i].par = json_integer_value(json_array_get(j_par, i));
+	json_t *j_pdr = json_object_get(j, "pdr");
+	for(int i=0; i<8; i++)
+		pages[run_mode][is_d][i].pdr = json_integer_value(json_array_get(j_pdr, i));
+}
+
+mmu *mmu::deserialize(const json_t *const j)
+{
+	mmu *m = new mmu();
+
+	for(int run_mode=0; run_mode<4; run_mode++) {
+		if (run_mode == 2)
+			continue;
+
+		for(int is_d=0; is_d<2; is_d++)
+			m->set_par_pdr(j, run_mode, is_d, format("runmode_%d_d_%d", run_mode, is_d));
+	}
+
+        m->MMR0   = json_integer_value(json_object_get(j, "MMR0"));
+        m->MMR1   = json_integer_value(json_object_get(j, "MMR1"));
+        m->MMR2   = json_integer_value(json_object_get(j, "MMR2"));
+        m->MMR3   = json_integer_value(json_object_get(j, "MMR3"));
+        m->CPUERR = json_integer_value(json_object_get(j, "CPUERR"));
+        m->PIR    = json_integer_value(json_object_get(j, "PIR"));
+        m->CSR    = json_integer_value(json_object_get(j, "CSR"));
+
+	return m;
+}
+#endif

mmu.h

@@ -1,8 +1,10 @@
 #pragma once
 
 #include <cstdint>
+#include <string>
 
 #include "device.h"
+#include "gen.h"
 
 #define ADDR_PDR_SV_START 0172200
 #define ADDR_PDR_SV_END   0172240
@@ -39,10 +41,20 @@ private:
 	uint16_t PIR { 0 };
 	uint16_t CSR { 0 };
 
+#if IS_POSIX
+	void add_par_pdr(json_t *const target, const int run_mode, const bool is_d, const std::string & name) const;
+	void set_par_pdr(const json_t *const j_in, const int run_mode, const bool is_d, const std::string & name);
+#endif
+
 public:
 	mmu();
 	virtual ~mmu();
 
+#if IS_POSIX
+	json_t *serialize() const;
+	static mmu *deserialize(const json_t *const j);
+#endif
+
 	void     reset() override;
 
 	bool     is_enabled() const { return MMR0 & 1; }

rl02.cpp

@@ -31,10 +31,10 @@ static const char * const commands[] = {
 	"read data w/o header check"
 	};
 
-rl02::rl02(const std::vector<disk_backend *> & files, bus *const b, std::atomic_bool *const disk_read_acitivity, std::atomic_bool *const disk_write_acitivity) :
+rl02::rl02(const std::vector<disk_backend *> & files, bus *const b, std::atomic_bool *const disk_read_activity, std::atomic_bool *const disk_write_activity) :
 	b(b),
-	disk_read_acitivity(disk_read_acitivity),
+	disk_read_activity (disk_read_activity ),
-	disk_write_acitivity(disk_write_acitivity)
+	disk_write_activity(disk_write_activity)
 {
 	fhs = files;
 
@@ -58,6 +58,54 @@ void rl02::reset()
 	sector = 0;
 }
 
+#if IS_POSIX
+json_t *rl02::serialize() const
+{
+	json_t *j = json_object();
+
+	json_t *j_backends = json_array();
+	for(auto & dbe: fhs)
+		json_array_append(j_backends, dbe->serialize());
+
+	json_object_set(j, "backends", j_backends);
+
+	for(int regnr=0; regnr<4; regnr++)
+		json_object_set(j, format("register-%d", regnr).c_str(), json_integer(registers[regnr]));
+
+	for(int mprnr=0; mprnr<3; mprnr++)
+		json_object_set(j, format("mpr-%d", mprnr).c_str(), json_integer(mpr[mprnr]));
+
+	json_object_set(j, "track",  json_integer(track));
+	json_object_set(j, "head",   json_integer(head));
+	json_object_set(j, "sector", json_integer(sector));
+
+	return j;
+}
+
+rl02 *rl02::deserialize(const json_t *const j, bus *const b)
+{
+	std::vector<disk_backend *> backends;
+
+	json_t *j_backends = json_object_get(j, "backends");
+	for(size_t i=0; i<json_array_size(j_backends); i++)
+		backends.push_back(disk_backend::deserialize(json_array_get(j_backends, i)));
+
+	rl02 *r = new rl02(backends, b, nullptr, nullptr);
+
+	for(int regnr=0; regnr<4; regnr++)
+		r->registers[regnr] = json_integer_value(json_object_get(j, format("register-%d", regnr).c_str()));
+
+	for(int mprnr=0; mprnr<3; mprnr++)
+		r->mpr[mprnr] = json_integer_value(json_object_get(j, format("mpr-%d", mprnr).c_str()));
+
+	r->track  = json_integer_value(json_object_get(j, "track" ));
+	r->head   = json_integer_value(json_object_get(j, "head"  ));
+	r->sector = json_integer_value(json_object_get(j, "sector"));
+
+	return r;
+}
+#endif
+
 uint8_t rl02::readByte(const uint16_t addr)
 {
 	uint16_t v = readWord(addr & ~1);
@@ -152,8 +200,6 @@ void rl02::writeWord(const uint16_t addr, uint16_t v)
 
 		bool          do_int  = false;
 
-		*disk_read_acitivity = true;
-
 		if (size_t(device) >= fhs.size()) {
 			DOLOG(info, false, "RL02: PDP11/70 is accessing a not-attached virtual disk %d", device);
 
@@ -194,6 +240,9 @@ void rl02::writeWord(const uint16_t addr, uint16_t v)
 			do_int = true;
 		}
 		else if (command == 5) {  // write data
+			if (disk_write_activity)
+				*disk_write_activity = true;
+
 			uint32_t memory_address   = get_bus_address();
 
 			uint32_t count            = (65536l - registers[(RL02_MPR - RL02_BASE) / 2]) * 2;
@@ -247,8 +296,14 @@ void rl02::writeWord(const uint16_t addr, uint16_t v)
 			}
 
 			do_int = true;
+
+			if (disk_write_activity)
+				*disk_write_activity = false;
 		}
 		else if (command == 6 || command == 7) {  // read data / read data without header check
+			if (disk_read_activity)
+				*disk_read_activity = true;
+
 			uint32_t memory_address   = get_bus_address();
 
 			uint32_t count            = (65536l - registers[(RL02_MPR - RL02_BASE) / 2]) * 2;
@@ -305,6 +360,9 @@ void rl02::writeWord(const uint16_t addr, uint16_t v)
 			}
 
 			do_int = true;
+
+			if (disk_read_activity)
+				*disk_read_activity = false;
 		}
 		else {
 			DOLOG(warning, false, "RL02: command %d not implemented", command);
@@ -317,7 +375,5 @@ void rl02::writeWord(const uint16_t addr, uint16_t v)
 				b->getCpu()->queue_interrupt(5, 0160);
 			}
 		}
-
-		*disk_read_acitivity = false;
 	}
 }

rl02.h

@@ -11,6 +11,7 @@
 
 #include "device.h"
 #include "disk_backend.h"
+#include "gen.h"
 
 
 #define RL02_CSR 0174400  // control status register
@@ -38,8 +39,8 @@ private:
 	uint16_t        mpr[3];
 	std::vector<disk_backend *> fhs;
 
-	std::atomic_bool *const disk_read_acitivity  { nullptr };
+	std::atomic_bool *const disk_read_activity   { nullptr };
-	std::atomic_bool *const disk_write_acitivity { nullptr };
+	std::atomic_bool *const disk_write_activity  { nullptr };
 
 	uint32_t get_bus_address() const;
 	void     update_bus_address(const uint32_t a);
@@ -47,11 +48,16 @@ private:
 	uint32_t calc_offset() const;
 
 public:
-	rl02(const std::vector<disk_backend *> & files, bus *const b, std::atomic_bool *const disk_read_acitivity, std::atomic_bool *const disk_write_acitivity);
+	rl02(const std::vector<disk_backend *> & files, bus *const b, std::atomic_bool *const disk_read_activity, std::atomic_bool *const disk_write_activity);
 	virtual ~rl02();
 
 	void reset() override;
 
+#if IS_POSIX
+	json_t *serialize() const;
+	static rl02 *deserialize(const json_t *const j, bus *const b);
+#endif
+
 	uint8_t  readByte(const uint16_t addr) override;
 	uint16_t readWord(const uint16_t addr) override;
 

tty.cpp

@@ -1,4 +1,4 @@
-// (C) 2018-2023 by Folkert van Heusden
+// (C) 2018-2024 by Folkert van Heusden
 // Released under MIT license
 
 #include <errno.h>
@@ -193,3 +193,38 @@ void tty::writeWord(const uint16_t addr, uint16_t v)
 	DOLOG(debug, false, "set register %o to %o", addr, v);
 	registers[(addr - PDP11TTY_BASE) / 2] = v;
 }
+
+#if IS_POSIX
+json_t *tty::serialize()
+{
+	json_t *j = json_object();
+
+        json_t *ja_reg = json_array();
+        for(size_t i=0; i<4; i++)
+                json_array_append(ja_reg, json_integer(registers[i]));
+        json_object_set(j, "registers", ja_reg);
+
+        json_t *ja_buf = json_array();
+	for(auto & c: chars)
+                json_array_append(ja_buf, json_integer(c));
+        json_object_set(j, "input-buffer", ja_buf);
+
+	return j;
+}
+
+tty *tty::deserialize(const json_t *const j, bus *const b, console *const cnsl)
+{
+	tty *out  = new tty(cnsl, b);
+
+	json_t *ja_reg = json_object_get(j, "registers");
+	for(size_t i=0; i<4; i++)
+		out->registers[i] = json_integer_value(json_array_get(ja_reg, i));
+
+	json_t *ja_buf   = json_object_get(j, "input-buffer");
+	size_t  buf_size = json_array_size(ja_buf);
+	for(size_t i=0; i<buf_size; i++)
+		out->chars.push_back(json_integer_value(json_array_get(ja_buf, i)));
+
+	return out;
+}
+#endif

tty.h

@@ -1,4 +1,4 @@
-// (C) 2018-2023 by Folkert van Heusden
+// (C) 2018-2024 by Folkert van Heusden
 // Released under MIT license
 
 #pragma once
@@ -13,6 +13,7 @@
 
 #include "bus.h"
 #include "console.h"
+#include "gen.h"
 
 
 #define PDP11TTY_TKS		0177560	// reader status
@@ -50,6 +51,11 @@ public:
 	tty(console *const c, bus *const b);
 	virtual ~tty();
 
+#if IS_POSIX
+	json_t *serialize();
+	static tty *deserialize(const json_t *const j, bus *const b, console *const cnsl);
+#endif
+
 	void reset();
 
 	uint8_t readByte(const uint16_t addr);