r91 - trunk/qemu-0.11.0
by svn＠coresystems.de
Author: stepan
Date: 2009-12-13 00:43:38 +0100 (Sun, 13 Dec 2009)
New Revision: 91
Modified:
trunk/qemu-0.11.0/softmmu_template.h
Log:
It would appear that not returning in case a store is supposed to be filtered
would be a bad thing. It is not, because the filter only runs reliably in case
the memory region is IO_MEM_UNASSIGNED, so letting the write through is a NOP.
Signed-off-by: Stefan Reinauer <stepan(a)coresystems.de>
Modified: trunk/qemu-0.11.0/softmmu_template.h
===================================================================
--- trunk/qemu-0.11.0/softmmu_template.h 2009-12-07 17:05:07 UTC (rev 90)
+++ trunk/qemu-0.11.0/softmmu_template.h 2009-12-12 23:43:38 UTC (rev 91)
@@ -254,11 +254,16 @@
int index;
#ifdef CONFIG_SERIALICE
- if (serialice_active && serialice_handle_store((uint32_t)addr, (uint32_t)val, (unsigned int) DATA_SIZE)) {
- // For now, we just always keep a backup of _all_ writes in qemu's
- // memory. At this point we can later decide what to do, if it becomes
- // necessary.
- // return;
+ if (serialice_active && serialice_handle_store((uint32_t)addr,
+ (uint32_t)val, (unsigned int) DATA_SIZE)) {
+ /* The memory catch mechanism does not work particularly well
+ * because of the softmmu is optimizing all accesses to Qemu
+ * "memory". Because of this we need to leave RAM "unassigned"
+ * until RAM init is done, and can't freely switch around.
+ *
+ * It's the right thing, however, to return here.
+ */
+ return;
}
#endif
9 years, 3 months
r90 - trunk/SerialICE/scripts
by svn＠coresystems.de
Author: stepan
Date: 2009-12-07 18:05:07 +0100 (Mon, 07 Dec 2009)
New Revision: 90
Modified:
trunk/SerialICE/scripts/serialice.lua
Log:
Update SerialICE LUA script. It is really time that we start
using the device model.
- add global variable "ip_logging" to enable/disable logging
[CS:IP] for every access.
- only register physical memory for RAM if it did not happen before
- reset Qemu CPU when target is reset with 0xcf9
- Implement Intel CPU microcode update faking in the MSR read/write filters.
It would be a relatively easy hack to add microcodes to the SerialICE image
and even run them, by having the msr write point to the correct address, in
case that should ever be needed.
- add a lot of automation triggers to increase SerialICE speed on my
test hardware.
Signed-off-by: Stefan Reinauer <stepan(a)coresystems.de>
Modified: trunk/SerialICE/scripts/serialice.lua
===================================================================
--- trunk/SerialICE/scripts/serialice.lua 2009-12-05 16:37:58 UTC (rev 89)
+++ trunk/SerialICE/scripts/serialice.lua 2009-12-07 17:05:07 UTC (rev 90)
@@ -41,10 +41,14 @@
ram_is_initialized = false
--- Whether to log read access (code fetches) to 0xe0000 to 0xfffff
+-- Set to "true" to log read access (code fetches) to 0xe0000 to 0xfffff
log_rom_access = false
+-- Set to "true" to log CS:IP for each access
+
+ip_logging = false
+
-- Remember the PCI device selected via IO CF8
SerialICE_pci_device = 0
@@ -84,6 +88,15 @@
-- **********************************************************
--
+ if ( port == 0x60 and data_size == 1 ) then
+ if ( regs.eip == 0xbd6d and regs.eax == 0x8aa and regs.ecx == 0x00fffff0 ) then
+ -- f000:bd6d
+ printf("Skipping keyboard timeout...\n")
+ regs.eax = 0x01aa
+ regs.ecx = 0x0010
+ end
+ end
+
return caught, data
end
@@ -227,15 +240,40 @@
-- permanently from the target (several reads/writes per
-- decompressed byte).
- if port == 0x80 and data == 0xff37 then
+ if port == 0x80 and data == 0xff37 and ram_is_initialized == false then
ram_is_initialized = true
-- Register low RAM 0x00000000 - 0x000dffff
SerialICE_register_physical(0x00000000, 0xa0000)
-- SMI/VGA memory should go to the target...
SerialICE_register_physical(0x000c0000, 0x20000)
printf("\nLow RAM accesses are now directed to Qemu.\n")
+
+ return false, data
end
+ if port == 0xcf9 and data == 0x06 then
+ SerialICE_system_reset()
+ return false, data
+ end
+
+ if ( port == 0xed and data == 0x40 ) then
+ if ( regs.eip == 0x3ed and regs.ecx == 0x00000290 ) then
+ printf("Skipping IO delay...\n")
+ -- f100:03ed
+ regs.ecx = 0x05
+ end
+ end
+
+ if ( port == 0xed and data == 0x83 )
+ then
+ if ( regs.eip == 0x1bb and regs.ecx == 0x0000fff0 ) then
+ printf("Skipping IO delay...\n")
+ -- e002:01bb
+ regs.ecx = 0x10
+ regs.ebx = 0x01
+ end
+ end
+
return false, data
end
@@ -384,6 +422,17 @@
-- Don't send writes to the target for speed reasons.
return false, true, data
elseif addr >= 0x00100000 and addr <= 0xcfffffff then
+ if addr == 0x00100000 then
+ if regs.cs == 0xe002 and regs.eip == 0x07fb then
+ -- skip high memory wipe
+ regs.ecx = 0x10
+ end
+ if regs.cs == 0xe002 and regs.eip == 0x076c and regs.edi == 0x3f then
+ -- skip high memory test
+ regs.edi=1;
+ end
+ end
+
-- 3.25 GB RAM ... This is handled by SerialICE
return true, false, data
else
@@ -394,16 +443,31 @@
return true, false, data
end
+
+function log_cs_ip()
+ if (ip_logging) then printf("[%04x:%04x] -- ", regs.cs, regs.eip) end
+end
+
function SerialICE_msr_read_filter(addr, hi, lo)
+ -- Intel CPU microcode revision check.
+ if addr == 0x8b then
+ -- fake microcode revision of my 0x6f6 Core 2 Duo Mobile
+ return true, 0xc7, 0x00
+ end
+
return false, hi, lo
end
function SerialICE_msr_write_filter(addr, hi, lo)
+ -- Intel CPU microcode update
+ if addr == 0x79 then
+ return true, 0, 0xffff0000
+ end
+
return false, hi, lo
end
function SerialICE_cpuid_filter(in_eax, in_ecx, eax, ebx, ecx, edx)
-
-- Set number of cores to 1 on Core Duo and Atom to trick the
-- firmware into not trying to wake up non-BSP nodes.
if in_eax == 1 then
@@ -428,6 +492,8 @@
return
end
+ log_cs_ip()
+
if size == 1 then printf("MEM: writeb %08x <= %02x", addr, data)
elseif size == 2 then printf("MEM: writew %08x <= %04x", addr, data)
elseif size == 4 then printf("MEM: writel %08x <= %08x", addr, data)
@@ -463,6 +529,8 @@
return
end
+ log_cs_ip()
+
if size == 1 then printf("MEM: readb %08x => %02x", addr, data)
elseif size == 2 then printf("MEM: readw %08x => %04x", addr, data)
elseif size == 4 then printf("MEM: readl %08x => %08x", addr, data)
@@ -485,6 +553,8 @@
end
function SerialICE_io_write_log(port, size, data, target)
+ log_cs_ip()
+
if size == 1 then printf("IO: outb %04x <= %02x\n", port, data)
elseif size == 2 then printf("IO: outw %04x <= %04x\n", port, data)
elseif size == 4 then printf("IO: outl %04x <= %08x\n", port, data)
@@ -500,9 +570,18 @@
bit.band(0x7,bit.rshift(SerialICE_pci_device, 8)),
bit.band(0xff,SerialICE_pci_device + (port - 0xcfc) ))
end
+
+ -- **********************************************************
+ --
+
+ if port == 0xcf9 then
+ printf("Reset triggered at %04x:%04x\n", regs.cs, regs.eip);
+ end
end
function SerialICE_io_read_log(port, size, data, target)
+ log_cs_ip()
+
if size == 1 then printf("IO: inb %04x => %02x\n", port, data)
elseif size == 2 then printf("IO: inw %04x => %04x\n", port, data)
elseif size == 4 then printf("IO: inl %04x => %08x\n", port, data)
@@ -521,14 +600,17 @@
end
function SerialICE_msr_write_log(addr, hi, lo, filtered)
+ log_cs_ip()
printf("CPU: wrmsr %08x <= %08x.%08x\n", addr, hi, lo)
end
function SerialICE_msr_read_log(addr, hi, lo, filtered)
+ log_cs_ip()
printf("CPU: rdmsr %08x => %08x.%08x\n", addr, hi, lo)
end
function SerialICE_cpuid_log(in_eax, in_ecx, out_eax, out_ebx, out_ecx, out_edx, filtered)
+ log_cs_ip()
printf("CPU: CPUID eax: %08x; ecx: %08x => %08x.%08x.%08x.%08x\n",
in_eax, in_ecx, out_eax, out_ebx, out_ecx, out_edx)
end
9 years, 3 months
Re: [SerialICE] r87 - trunk/qemu-0.11.0
by Stefan Reinauer
joe(a)settoplinux.org wrote:
> What does Qemu do when 0xcf9 is sent to bios Stefan?
>
>
Hi Joe,
The I/O 0xcf9 is the "reset register" on most x86 systems. Writing
certain values to it will cause a hard or soft reset.
Qemu however does not emulate this behavior - as far as I can tell - it
certainly does not while SerialICE is active, because all IO accesses go
to the target (or are caught by LUA)
Basically what's missing in the LUA script to make resets via cf9 work
properly is adding the following to SerialICE_IO_write_filter:
if port == 0xcf9 and data == 0x06 then
SerialICE_system_reset()
return false, data
end
The serial communication code has been rewritten for the last release to
be quite hick-up safe.. This means Qemu does not get out of sync if the
target reboots, so all that needs to happen after a reboot of the target
is to reboot the VM on the host, too, to let it start at the reset
vector again... Otherwise it'll just try to execute code right after the
out to cf9.. which is usually an endless loop as a safe guard.
Stefan
--
coresystems GmbH • Brahmsstr. 16 • D-79104 Freiburg i. Br.
Tel.: +49 761 7668825 • Fax: +49 761 7664613
Email: info(a)coresystems.de • http://www.coresystems.de/
Registergericht: Amtsgericht Freiburg • HRB 7656
Geschäftsführer: Stefan Reinauer • Ust-IdNr.: DE245674866
9 years, 3 months
Re: [SerialICE] r87 - trunk/qemu-0.11.0
by joe＠settoplinux.org
On December 5, 2009 at 3:02 PM svn(a)coresystems.de wrote:
> Author: stepan
> Date: 2009-12-05 16:02:29 +0100 (Sat, 05 Dec 2009)
> New Revision: 87
>
> Modified:
> trunk/qemu-0.11.0/serialice.c
> Log:
> Add SerialICE_system_reset to trigger a VM side reset.
> This is needed to keep Qemu from running code after an outb to 0xcf9 has been
> encountered.
What does Qemu do when 0xcf9 is sent to bios Stefan?
Thanks,
Joseph Smith
Set-Top-Linux
www.settoplinux.org
9 years, 3 months
r89 - trunk/qemu-0.11.0/target-i386
by svn＠coresystems.de
Author: stepan
Date: 2009-12-05 17:37:58 +0100 (Sat, 05 Dec 2009)
New Revision: 89
Modified:
trunk/qemu-0.11.0/target-i386/op_helper.c
Log:
indent to make the Qemu folks ready.
Signed-off-by: Stefan Reinauer <stepan(a)coresystems.de>
Modified: trunk/qemu-0.11.0/target-i386/op_helper.c
===================================================================
--- trunk/qemu-0.11.0/target-i386/op_helper.c 2009-12-05 15:47:43 UTC (rev 88)
+++ trunk/qemu-0.11.0/target-i386/op_helper.c 2009-12-05 16:37:58 UTC (rev 89)
@@ -561,8 +561,8 @@
{
#ifdef CONFIG_SERIALICE
if (serialice_active) {
- serialice_outb(data & 0xff, port);
- return;
+ serialice_outb(data & 0xff, port);
+ return;
}
#endif
cpu_outb(env, port, data & 0xff);
@@ -572,7 +572,7 @@
{
#ifdef CONFIG_SERIALICE
if (serialice_active) {
- return (target_ulong)serialice_inb(port);
+ return (target_ulong) serialice_inb(port);
}
#endif
return cpu_inb(env, port);
@@ -582,8 +582,8 @@
{
#ifdef CONFIG_SERIALICE
if (serialice_active) {
- serialice_outw(data & 0xffff, port);
- return;
+ serialice_outw(data & 0xffff, port);
+ return;
}
#endif
cpu_outw(env, port, data & 0xffff);
@@ -593,7 +593,7 @@
{
#ifdef CONFIG_SERIALICE
if (serialice_active) {
- return (target_ulong)serialice_inw(port);
+ return (target_ulong) serialice_inw(port);
}
#endif
return cpu_inw(env, port);
@@ -603,8 +603,8 @@
{
#ifdef CONFIG_SERIALICE
if (serialice_active) {
- serialice_outl(data & 0xffffffff, port);
- return;
+ serialice_outl(data & 0xffffffff, port);
+ return;
}
#endif
cpu_outl(env, port, data);
@@ -614,7 +614,7 @@
{
#ifdef CONFIG_SERIALICE
if (serialice_active) {
- return (target_ulong)serialice_inl(port);
+ return (target_ulong) serialice_inl(port);
}
#endif
return cpu_inl(env, port);
@@ -1977,7 +1977,7 @@
#ifdef CONFIG_SERIALICE
if (serialice_active) {
cpuid_regs_t ret;
- ret = serialice_cpuid((uint32_t)EAX, (uint32_t)ECX);
+ ret = serialice_cpuid((uint32_t) EAX, (uint32_t) ECX);
EAX = ret.eax;
EBX = ret.ebx;
ECX = ret.ecx;
@@ -3078,7 +3078,7 @@
#ifdef CONFIG_SERIALICE
if (serialice_active) {
- serialice_wrmsr(val, (uint32_t)ECX, (uint32_t)EDI);
+ serialice_wrmsr(val, (uint32_t) ECX, (uint32_t) EDI);
return;
}
#endif
@@ -3215,10 +3215,10 @@
#ifdef CONFIG_SERIALICE
if (serialice_active) {
- val = serialice_rdmsr((uint32_t)ECX, (uint32_t)EDI);
- EAX = (uint32_t)(val);
- EDX = (uint32_t)(val >> 32);
- return;
+ val = serialice_rdmsr((uint32_t) ECX, (uint32_t) EDI);
+ EAX = (uint32_t) (val);
+ EDX = (uint32_t) (val >> 32);
+ return;
}
#endif
9 years, 3 months
r88 - trunk/qemu-0.11.0
by svn＠coresystems.de
Author: stepan
Date: 2009-12-05 16:47:43 +0100 (Sat, 05 Dec 2009)
New Revision: 88
Modified:
trunk/qemu-0.11.0/serialice.c
trunk/qemu-0.11.0/serialice.h
Log:
re-indent, this time correctly (no tabs) and preserve the indent line.
Signed-off-by: Stefan Reinauer <stepan(a)coresystems.de>
Modified: trunk/qemu-0.11.0/serialice.c
===================================================================
--- trunk/qemu-0.11.0/serialice.c 2009-12-05 15:02:29 UTC (rev 87)
+++ trunk/qemu-0.11.0/serialice.c 2009-12-05 15:47:43 UTC (rev 88)
@@ -22,6 +22,10 @@
* THE SOFTWARE.
*/
+/* Indented with:
+ * gnuindent -npro -kr -i4 -nut -bap -sob -l80 -ss -ncs serialice.*
+ */
+
/* System includes */
#include <stdlib.h>
#include <stdio.h>
@@ -94,16 +98,16 @@
ram_addr_t phys;
if (n != 2) {
- fprintf(stderr,
- "ERROR: Not called as SerialICE_register_physical(<addr> <size>)\n");
- return 0;
+ fprintf(stderr,
+ "ERROR: Not called as SerialICE_register_physical(<addr> <size>)\n");
+ return 0;
}
addr = lua_tointeger(luastate, 1);
size = lua_tointeger(luastate, 2);
printf("Registering physical memory at 0x%08x (0x%08x bytes)\n", addr,
- size);
+ size);
phys = qemu_ram_alloc(size);
cpu_register_physical_memory(addr, size, phys);
@@ -171,25 +175,25 @@
const char *key = luaL_checkstring(L, 2);
int ret = 1;
if (strcmp(key, "eax") == 0) {
- lua_pushinteger(L, EAX);
+ lua_pushinteger(L, EAX);
} else if (strcmp(key, "ecx") == 0) {
- lua_pushinteger(L, ECX);
+ lua_pushinteger(L, ECX);
} else if (strcmp(key, "edx") == 0) {
- lua_pushinteger(L, EDX);
+ lua_pushinteger(L, EDX);
} else if (strcmp(key, "ebx") == 0) {
- lua_pushinteger(L, EBX);
+ lua_pushinteger(L, EBX);
} else if (strcmp(key, "esp") == 0) {
- lua_pushinteger(L, ESP);
+ lua_pushinteger(L, ESP);
} else if (strcmp(key, "ebp") == 0) {
- lua_pushinteger(L, EBP);
+ lua_pushinteger(L, EBP);
} else if (strcmp(key, "esi") == 0) {
- lua_pushinteger(L, ESI);
+ lua_pushinteger(L, ESI);
} else if (strcmp(key, "edi") == 0) {
- lua_pushinteger(L, EDI);
+ lua_pushinteger(L, EDI);
} else if (strcmp(key, "eip") == 0) {
- lua_pushinteger(L, EIP);
+ lua_pushinteger(L, EIP);
} else if (strcmp(key, "cs") == 0) {
- lua_pushinteger(L, (CS >> 4));
+ lua_pushinteger(L, (CS >> 4));
} else {
lua_pushstring(L, "No such register.");
lua_error(L);
@@ -197,14 +201,15 @@
}
return ret;
}
+
#undef env
static int serialice_lua_registers(void)
{
const struct luaL_Reg registermt[] = {
- {"__index", register_get},
- {"__newindex", register_set},
- {NULL, NULL}
+ {"__index", register_get},
+ {"__newindex", register_set},
+ {NULL, NULL}
};
lua_newuserdata(L, sizeof(void *));
@@ -238,16 +243,16 @@
/* Load the script file */
status = luaL_loadfile(L, serialice_lua_script);
if (status) {
- fprintf(stderr, "Couldn't load SerialICE script: %s\n",
- lua_tostring(L, -1));
- exit(1);
+ fprintf(stderr, "Couldn't load SerialICE script: %s\n",
+ lua_tostring(L, -1));
+ exit(1);
}
/* Ask Lua to run our little script */
status = lua_pcall(L, 0, 1, 0);
if (status) {
- fprintf(stderr, "Failed to run script: %s\n", lua_tostring(L, -1));
- exit(1);
+ fprintf(stderr, "Failed to run script: %s\n", lua_tostring(L, -1));
+ exit(1);
}
lua_pop(L, 1);
@@ -265,10 +270,10 @@
int error;
char *errstring = NULL;
error = luaL_loadbuffer(L, cmd, strlen(cmd), "line")
- || lua_pcall(L, 0, 0, 0);
+ || lua_pcall(L, 0, 0, 0);
if (error) {
- errstring = strdup(lua_tostring(L, -1));
- lua_pop(L, 1);
+ errstring = strdup(lua_tostring(L, -1));
+ lua_pop(L, 1);
}
return errstring;
@@ -279,13 +284,13 @@
int ret, result;
lua_getfield(L, LUA_GLOBALSINDEX, "SerialICE_io_read_filter");
- lua_pushinteger(L, port); // port
- lua_pushinteger(L, size); // datasize
+ lua_pushinteger(L, port); // port
+ lua_pushinteger(L, size); // datasize
result = lua_pcall(L, 2, 2, 0);
if (result) {
- fprintf(stderr, "Failed to run function SerialICE_io_read_filter: %s\n",
- lua_tostring(L, -1));
- exit(1);
+ fprintf(stderr, "Failed to run function SerialICE_io_read_filter: %s\n",
+ lua_tostring(L, -1));
+ exit(1);
}
*data = lua_tointeger(L, -1);
ret = lua_toboolean(L, -2);
@@ -299,16 +304,16 @@
int ret, result;
lua_getfield(L, LUA_GLOBALSINDEX, "SerialICE_io_write_filter");
- lua_pushinteger(L, port); // port
- lua_pushinteger(L, size); // datasize
- lua_pushinteger(L, *data); // data
+ lua_pushinteger(L, port); // port
+ lua_pushinteger(L, size); // datasize
+ lua_pushinteger(L, *data); // data
result = lua_pcall(L, 3, 2, 0);
if (result) {
- fprintf(stderr,
- "Failed to run function SerialICE_io_write_filter: %s\n",
- lua_tostring(L, -1));
- exit(1);
+ fprintf(stderr,
+ "Failed to run function SerialICE_io_write_filter: %s\n",
+ lua_tostring(L, -1));
+ exit(1);
}
*data = lua_tointeger(L, -1);
ret = lua_toboolean(L, -2);
@@ -320,25 +325,25 @@
#define READ_FROM_QEMU (1 << 0)
#define READ_FROM_SERIALICE (1 << 1)
static int serialice_memory_read_filter(uint32_t addr, uint32_t * data,
- int size)
+ int size)
{
int ret = 0, result;
lua_getfield(L, LUA_GLOBALSINDEX, "SerialICE_memory_read_filter");
- lua_pushinteger(L, addr); // addr
- lua_pushinteger(L, size); // datasize
+ lua_pushinteger(L, addr); // addr
+ lua_pushinteger(L, size); // datasize
result = lua_pcall(L, 2, 3, 0);
if (result) {
- fprintf(stderr,
- "Failed to run function SerialICE_memory_read_filter: %s\n",
- lua_tostring(L, -1));
- exit(1);
+ fprintf(stderr,
+ "Failed to run function SerialICE_memory_read_filter: %s\n",
+ lua_tostring(L, -1));
+ exit(1);
}
- *data = lua_tointeger(L, -1); // result
+ *data = lua_tointeger(L, -1); // result
- ret |= lua_toboolean(L, -2) ? READ_FROM_QEMU : 0; // to_qemu
- ret |= lua_toboolean(L, -3) ? READ_FROM_SERIALICE : 0; // to_hw
+ ret |= lua_toboolean(L, -2) ? READ_FROM_QEMU : 0; // to_qemu
+ ret |= lua_toboolean(L, -3) ? READ_FROM_SERIALICE : 0; // to_hw
lua_pop(L, 3);
@@ -349,21 +354,21 @@
#define WRITE_TO_SERIALICE (1 << 1)
static int serialice_memory_write_filter(uint32_t addr, int size,
- uint32_t * data)
+ uint32_t * data)
{
int ret = 0, result;
int write_to_qemu, write_to_serialice;
lua_getfield(L, LUA_GLOBALSINDEX, "SerialICE_memory_write_filter");
- lua_pushinteger(L, addr); // address
- lua_pushinteger(L, size); // datasize
- lua_pushinteger(L, *data); // data
+ lua_pushinteger(L, addr); // address
+ lua_pushinteger(L, size); // datasize
+ lua_pushinteger(L, *data); // data
result = lua_pcall(L, 3, 3, 0);
if (result) {
- fprintf(stderr,
- "Failed to run function SerialICE_memory_write_filter: %s\n",
- lua_tostring(L, -1));
- exit(1);
+ fprintf(stderr,
+ "Failed to run function SerialICE_memory_write_filter: %s\n",
+ lua_tostring(L, -1));
+ exit(1);
}
*data = lua_tointeger(L, -1);
write_to_qemu = lua_toboolean(L, -2);
@@ -380,30 +385,30 @@
#define FILTER_WRITE 1
static int serialice_msr_filter(int flags, uint32_t addr, uint32_t * hi,
- uint32_t * lo)
+ uint32_t * lo)
{
int ret, result;
if (flags & FILTER_WRITE) {
- lua_getfield(L, LUA_GLOBALSINDEX, "SerialICE_msr_write_filter");
+ lua_getfield(L, LUA_GLOBALSINDEX, "SerialICE_msr_write_filter");
} else {
- lua_getfield(L, LUA_GLOBALSINDEX, "SerialICE_msr_read_filter");
+ lua_getfield(L, LUA_GLOBALSINDEX, "SerialICE_msr_read_filter");
}
- lua_pushinteger(L, addr); // port
- lua_pushinteger(L, *hi); // high
- lua_pushinteger(L, *lo); // low
+ lua_pushinteger(L, addr); // port
+ lua_pushinteger(L, *hi); // high
+ lua_pushinteger(L, *lo); // low
result = lua_pcall(L, 3, 3, 0);
if (result) {
- fprintf(stderr,
- "Failed to run function SerialICE_msr_%s_filter: %s\n",
- (flags & FILTER_WRITE)?"write":"read", lua_tostring(L, -1));
- exit(1);
+ fprintf(stderr,
+ "Failed to run function SerialICE_msr_%s_filter: %s\n",
+ (flags & FILTER_WRITE) ? "write" : "read", lua_tostring(L, -1));
+ exit(1);
}
ret = lua_toboolean(L, -3);
if (ret) {
- *hi = lua_tointeger(L, -1);
- *lo = lua_tointeger(L, -2);
+ *hi = lua_tointeger(L, -1);
+ *lo = lua_tointeger(L, -2);
}
lua_pop(L, 3);
@@ -411,33 +416,33 @@
}
static int serialice_cpuid_filter(uint32_t eax, uint32_t ecx,
- cpuid_regs_t * regs)
+ cpuid_regs_t * regs)
{
int ret, result;
lua_getfield(L, LUA_GLOBALSINDEX, "SerialICE_cpuid_filter");
- lua_pushinteger(L, eax); // eax before calling
- lua_pushinteger(L, ecx); // ecx before calling
+ lua_pushinteger(L, eax); // eax before calling
+ lua_pushinteger(L, ecx); // ecx before calling
// and the registers after calling cpuid
- lua_pushinteger(L, regs->eax); // eax
- lua_pushinteger(L, regs->ebx); // ebx
- lua_pushinteger(L, regs->ecx); // ecx
- lua_pushinteger(L, regs->edx); // edx
+ lua_pushinteger(L, regs->eax); // eax
+ lua_pushinteger(L, regs->ebx); // ebx
+ lua_pushinteger(L, regs->ecx); // ecx
+ lua_pushinteger(L, regs->edx); // edx
result = lua_pcall(L, 6, 5, 0);
if (result) {
- fprintf(stderr,
- "Failed to run function SerialICE_cpuid_filter: %s\n",
- lua_tostring(L, -1));
- exit(1);
+ fprintf(stderr,
+ "Failed to run function SerialICE_cpuid_filter: %s\n",
+ lua_tostring(L, -1));
+ exit(1);
}
ret = lua_toboolean(L, -5);
if (ret) {
- regs->eax = lua_tointeger(L, -4);
- regs->ebx = lua_tointeger(L, -3);
- regs->ecx = lua_tointeger(L, -2);
- regs->edx = lua_tointeger(L, -1);
+ regs->eax = lua_tointeger(L, -4);
+ regs->ebx = lua_tointeger(L, -3);
+ regs->ecx = lua_tointeger(L, -2);
+ regs->edx = lua_tointeger(L, -1);
}
lua_pop(L, 5);
@@ -459,71 +464,71 @@
int result;
if ((flags & LOG_WRITE) && (flags & LOG_MEMORY)) {
- lua_getfield(L, LUA_GLOBALSINDEX, "SerialICE_memory_write_log");
+ lua_getfield(L, LUA_GLOBALSINDEX, "SerialICE_memory_write_log");
} else if (!(flags & LOG_WRITE) && (flags & LOG_MEMORY)) {
- lua_getfield(L, LUA_GLOBALSINDEX, "SerialICE_memory_read_log");
+ lua_getfield(L, LUA_GLOBALSINDEX, "SerialICE_memory_read_log");
} else if ((flags & LOG_WRITE) && !(flags & LOG_MEMORY)) {
- lua_getfield(L, LUA_GLOBALSINDEX, "SerialICE_io_write_log");
- } else { // if (!(flags & LOG_WRITE) && !(flags & LOG_MEMORY))
- lua_getfield(L, LUA_GLOBALSINDEX, "SerialICE_io_read_log");
+ lua_getfield(L, LUA_GLOBALSINDEX, "SerialICE_io_write_log");
+ } else { // if (!(flags & LOG_WRITE) && !(flags & LOG_MEMORY))
+ lua_getfield(L, LUA_GLOBALSINDEX, "SerialICE_io_read_log");
}
- lua_pushinteger(L, addr); // addr/port
- lua_pushinteger(L, size); // datasize
- lua_pushinteger(L, data); // data
+ lua_pushinteger(L, addr); // addr/port
+ lua_pushinteger(L, size); // datasize
+ lua_pushinteger(L, data); // data
lua_pushboolean(L, ((flags & LOG_TARGET) != 0));
result = lua_pcall(L, 4, 0, 0);
if (result) {
- fprintf(stderr, "Failed to run function SerialICE_%s_%s_log: %s\n",
- (flags & LOG_MEMORY) ? "memory" : "io",
- (flags & LOG_WRITE) ? "write" : "read", lua_tostring(L, -1));
- exit(1);
+ fprintf(stderr, "Failed to run function SerialICE_%s_%s_log: %s\n",
+ (flags & LOG_MEMORY) ? "memory" : "io",
+ (flags & LOG_WRITE) ? "write" : "read", lua_tostring(L, -1));
+ exit(1);
}
}
static void serialice_msr_log(int flags, uint32_t addr, uint32_t hi,
- uint32_t lo, int filtered)
+ uint32_t lo, int filtered)
{
int result;
if (flags & LOG_WRITE) {
- lua_getfield(L, LUA_GLOBALSINDEX, "SerialICE_msr_write_log");
- } else { // if (!(flags & LOG_WRITE))
- lua_getfield(L, LUA_GLOBALSINDEX, "SerialICE_msr_read_log");
+ lua_getfield(L, LUA_GLOBALSINDEX, "SerialICE_msr_write_log");
+ } else { // if (!(flags & LOG_WRITE))
+ lua_getfield(L, LUA_GLOBALSINDEX, "SerialICE_msr_read_log");
}
- lua_pushinteger(L, addr); // addr/port
- lua_pushinteger(L, hi); // datasize
- lua_pushinteger(L, lo); // data
- lua_pushboolean(L, filtered); // data
+ lua_pushinteger(L, addr); // addr/port
+ lua_pushinteger(L, hi); // datasize
+ lua_pushinteger(L, lo); // data
+ lua_pushboolean(L, filtered); // data
result = lua_pcall(L, 4, 0, 0);
if (result) {
- fprintf(stderr, "Failed to run function SerialICE_msr_%s_log: %s\n",
- (flags & LOG_WRITE) ? "write" : "read", lua_tostring(L, -1));
- exit(1);
+ fprintf(stderr, "Failed to run function SerialICE_msr_%s_log: %s\n",
+ (flags & LOG_WRITE) ? "write" : "read", lua_tostring(L, -1));
+ exit(1);
}
}
static void serialice_cpuid_log(uint32_t eax, uint32_t ecx, cpuid_regs_t res,
- int filtered)
+ int filtered)
{
int result;
lua_getfield(L, LUA_GLOBALSINDEX, "SerialICE_cpuid_log");
- lua_pushinteger(L, eax); // input: eax
- lua_pushinteger(L, ecx); // input: ecx
- lua_pushinteger(L, res.eax); // output: eax
- lua_pushinteger(L, res.ebx); // output: ebx
- lua_pushinteger(L, res.ecx); // output: ecx
- lua_pushinteger(L, res.edx); // output: edx
- lua_pushboolean(L, filtered); // data
+ lua_pushinteger(L, eax); // input: eax
+ lua_pushinteger(L, ecx); // input: ecx
+ lua_pushinteger(L, res.eax); // output: eax
+ lua_pushinteger(L, res.ebx); // output: ebx
+ lua_pushinteger(L, res.ecx); // output: ecx
+ lua_pushinteger(L, res.edx); // output: edx
+ lua_pushboolean(L, filtered); // data
result = lua_pcall(L, 7, 0, 0);
if (result) {
- fprintf(stderr, "Failed to run function SerialICE_cpuid_log: %s\n",
- lua_tostring(L, -1));
- exit(1);
+ fprintf(stderr, "Failed to run function SerialICE_cpuid_log: %s\n",
+ lua_tostring(L, -1));
+ exit(1);
}
}
@@ -536,29 +541,29 @@
while (1) {
#ifdef WIN32
- int ret = 0;
- ReadFile(state->fd, buf, nbyte - bytes_read, &ret, NULL);
- if (!ret) {
- break;
- }
+ int ret = 0;
+ ReadFile(state->fd, buf, nbyte - bytes_read, &ret, NULL);
+ if (!ret) {
+ break;
+ }
#else
- int ret = read(state->fd, buf, nbyte - bytes_read);
+ int ret = read(state->fd, buf, nbyte - bytes_read);
- if (ret == -1 && errno == EINTR) {
- continue;
- }
+ if (ret == -1 && errno == EINTR) {
+ continue;
+ }
- if (ret == -1) {
- break;
- }
+ if (ret == -1) {
+ break;
+ }
#endif
- bytes_read += ret;
- buf += ret;
+ bytes_read += ret;
+ buf += ret;
- if (bytes_read >= (int)nbyte) {
- break;
- }
+ if (bytes_read >= (int)nbyte) {
+ break;
+ }
}
return bytes_read;
@@ -567,7 +572,7 @@
static int handshake_mode = 0;
static int serialice_write(SerialICEState * state, const void *buf,
- size_t nbyte)
+ size_t nbyte)
{
char *buffer = (char *)buf;
char c;
@@ -575,21 +580,21 @@
for (i = 0; i < (int)nbyte; i++) {
#ifdef WIN32
- int ret = 0;
- while (ret == 0) {
- WriteFile(state->fd, buffer + i, 1, &ret, NULL);
- }
- ret = 0;
- while (ret == 0) {
- ReadFile(state->fd, &c, 1, &ret, NULL);
- }
+ int ret = 0;
+ while (ret == 0) {
+ WriteFile(state->fd, buffer + i, 1, &ret, NULL);
+ }
+ ret = 0;
+ while (ret == 0) {
+ ReadFile(state->fd, &c, 1, &ret, NULL);
+ }
#else
- while (write(state->fd, buffer + i, 1) != 1) ;
- while (read(state->fd, &c, 1) != 1) ;
+ while (write(state->fd, buffer + i, 1) != 1) ;
+ while (read(state->fd, &c, 1) != 1) ;
#endif
- if (c != buffer[i] && !handshake_mode) {
- printf("Readback error! %x/%x\n", c, buffer[i]);
- }
+ if (c != buffer[i] && !handshake_mode) {
+ printf("Readback error! %x/%x\n", c, buffer[i]);
+ }
}
return nbyte;
@@ -603,18 +608,18 @@
l = serialice_read(s, buf, 3);
if (l == -1) {
- perror("SerialICE: Could not read from target");
- exit(1);
+ perror("SerialICE: Could not read from target");
+ exit(1);
}
while (buf[0] != '\n' || buf[1] != '>' || buf[2] != ' ') {
- buf[0] = buf[1];
- buf[1] = buf[2];
- l = serialice_read(s, buf + 2, 1);
- if (l == -1) {
- perror("SerialICE: Could not read from target");
- exit(1);
- }
+ buf[0] = buf[1];
+ buf[1] = buf[2];
+ l = serialice_read(s, buf + 2, 1);
+ if (l == -1) {
+ perror("SerialICE: Could not read from target");
+ exit(1);
+ }
}
return 0;
@@ -631,28 +636,28 @@
serialice_write(s, command, strlen(command));
- memset(s->buffer, 0, reply_len + 1); // clear enough of the buffer
+ memset(s->buffer, 0, reply_len + 1); // clear enough of the buffer
l = serialice_read(s, s->buffer, reply_len);
if (l == -1) {
- perror("SerialICE: Could not read from target");
- exit(1);
+ perror("SerialICE: Could not read from target");
+ exit(1);
}
// compensate for CR on the wire. Needed on Win32
if (s->buffer[0] == '\r') {
- memmove(s->buffer, s->buffer + 1, reply_len);
- serialice_read(s, s->buffer + reply_len - 1, 1);
+ memmove(s->buffer, s->buffer + 1, reply_len);
+ serialice_read(s, s->buffer + reply_len - 1, 1);
}
if (l != reply_len) {
- printf("SerialICE: command was not answered sufficiently: "
- "(%d/%d bytes)\n'%s'\n", l, reply_len, s->buffer);
- exit(1);
+ printf("SerialICE: command was not answered sufficiently: "
+ "(%d/%d bytes)\n'%s'\n", l, reply_len, s->buffer);
+ exit(1);
}
#if SERIALICE_DEBUG > 5
for (i = 0; i < reply_len; i++) {
- printf("%02x ", s->buffer[i]);
+ printf("%02x ", s->buffer[i]);
}
printf("\n");
#endif
@@ -671,7 +676,7 @@
serialice_read(s, s->buffer, 1);
serialice_read(s, s->buffer, 1);
while (s->buffer[len++] != '\n') {
- serialice_read(s, s->buffer + len, 1);
+ serialice_read(s, s->buffer + len, 1);
}
s->buffer[len - 1] = '\0';
@@ -685,7 +690,7 @@
printf("SerialICE: Mainboard...: ");
serialice_command("*mb", 32);
while (len && s->buffer[len] == ' ') {
- s->buffer[len--] = '\0';
+ s->buffer[len--] = '\0';
}
serialice_mainboard = strdup(s->buffer + 1);
printf("%s\n", serialice_mainboard);
@@ -697,7 +702,7 @@
uint32_t data;
if (serialice_io_read_filter(&data, port, 1)) {
- return data & 0xff;
+ return data & 0xff;
}
sprintf(s->command, "*ri%04x.b", port);
@@ -716,7 +721,7 @@
uint32_t data;
if (serialice_io_read_filter(&data, port, 1)) {
- return data & 0xffff;
+ return data & 0xffff;
}
sprintf(s->command, "*ri%04x.w", port);
@@ -735,7 +740,7 @@
uint32_t data;
if (serialice_io_read_filter(&data, port, 1)) {
- return data;
+ return data;
}
sprintf(s->command, "*ri%04x.l", port);
@@ -755,7 +760,7 @@
serialice_log(LOG_WRITE | LOG_IO, data, port, 1);
if (serialice_io_write_filter(&filtered_data, port, 1)) {
- return;
+ return;
}
data = (uint8_t) filtered_data;
@@ -770,7 +775,7 @@
serialice_log(LOG_WRITE | LOG_IO, data, port, 2);
if (serialice_io_write_filter(&filtered_data, port, 2)) {
- return;
+ return;
}
data = (uint16_t) filtered_data;
@@ -785,7 +790,7 @@
serialice_log(LOG_WRITE | LOG_IO, data, port, 4);
if (serialice_io_write_filter(&filtered_data, port, 4)) {
- return;
+ return;
}
data = filtered_data;
@@ -849,14 +854,14 @@
filtered = serialice_msr_filter(FILTER_READ, addr, &hi, &lo);
if (!filtered) {
- sprintf(s->command, "*rc%08x.%08x", addr, key);
+ sprintf(s->command, "*rc%08x.%08x", addr, key);
- // command read back: "\n00000000.00000000" (18 characters)
- serialice_command(s->command, 18);
+ // command read back: "\n00000000.00000000" (18 characters)
+ serialice_command(s->command, 18);
- s->buffer[9] = 0; // . -> \0
- hi = (uint32_t) strtoul(s->buffer + 1, (char **)NULL, 16);
- lo = (uint32_t) strtoul(s->buffer + 10, (char **)NULL, 16);
+ s->buffer[9] = 0; // . -> \0
+ hi = (uint32_t) strtoul(s->buffer + 1, (char **)NULL, 16);
+ lo = (uint32_t) strtoul(s->buffer + 10, (char **)NULL, 16);
}
ret = hi;
@@ -879,8 +884,8 @@
filtered = serialice_msr_filter(FILTER_WRITE, addr, &hi, &lo);
if (!filtered) {
- sprintf(s->command, "*wc%08x.%08x=%08x.%08x", addr, key, hi, lo);
- serialice_command(s->command, 0);
+ sprintf(s->command, "*wc%08x.%08x=%08x.%08x", addr, key, hi, lo);
+ serialice_command(s->command, 0);
}
serialice_msr_log(LOG_WRITE, addr, hi, lo, filtered);
@@ -892,19 +897,19 @@
int filtered;
ret.eax = eax;
- ret.ebx = 0; // either set by filter or by target
+ ret.ebx = 0; // either set by filter or by target
ret.ecx = ecx;
- ret.edx = 0; // either set by filter or by target
+ ret.edx = 0; // either set by filter or by target
sprintf(s->command, "*ci%08x.%08x", eax, ecx);
// command read back: "\n000006f2.00000000.00001234.12340324"
// (36 characters)
serialice_command(s->command, 36);
-
- s->buffer[9] = 0; // . -> \0
- s->buffer[18] = 0; // . -> \0
- s->buffer[27] = 0; // . -> \0
+
+ s->buffer[9] = 0; // . -> \0
+ s->buffer[18] = 0; // . -> \0
+ s->buffer[27] = 0; // . -> \0
ret.eax = (uint32_t) strtoul(s->buffer + 1, (char **)NULL, 16);
ret.ebx = (uint32_t) strtoul(s->buffer + 10, (char **)NULL, 16);
ret.ecx = (uint32_t) strtoul(s->buffer + 19, (char **)NULL, 16);
@@ -924,13 +929,13 @@
{
switch (size) {
case 1:
- return (uint32_t) serialice_readb(addr);
+ return (uint32_t) serialice_readb(addr);
case 2:
- return (uint32_t) serialice_readw(addr);
+ return (uint32_t) serialice_readw(addr);
case 4:
- return (uint32_t) serialice_readl(addr);
+ return (uint32_t) serialice_readl(addr);
default:
- printf("WARNING: unknown read access size %d @%08x\n", size, addr);
+ printf("WARNING: unknown read access size %d @%08x\n", size, addr);
}
return 0;
}
@@ -940,13 +945,13 @@
* of a load cycle
*/
void serialice_log_load(int caught, uint32_t addr, uint32_t result,
- unsigned int data_size)
+ unsigned int data_size)
{
if (caught) {
- serialice_log(LOG_READ | LOG_MEMORY | LOG_TARGET, result, addr,
- data_size);
+ serialice_log(LOG_READ | LOG_MEMORY | LOG_TARGET, result, addr,
+ data_size);
} else {
- serialice_log(LOG_READ | LOG_MEMORY, result, addr, data_size);
+ serialice_log(LOG_READ | LOG_MEMORY, result, addr, data_size);
}
}
@@ -956,19 +961,19 @@
* @return 0: pass on to Qemu; 1: handled locally.
*/
int serialice_handle_load(uint32_t addr, uint32_t * result,
- unsigned int data_size)
+ unsigned int data_size)
{
int source;
source = serialice_memory_read_filter(addr, result, data_size);
if (source & READ_FROM_SERIALICE) {
- *result = serialice_load_wrapper(addr, data_size);
- return 1;
+ *result = serialice_load_wrapper(addr, data_size);
+ return 1;
}
if (source & READ_FROM_QEMU) {
- return 0;
+ return 0;
}
/* No source for load, so the source is the script */
@@ -979,31 +984,31 @@
// memory store handling
static void serialice_store_wrapper(uint32_t addr, unsigned int size,
- uint32_t data)
+ uint32_t data)
{
switch (size) {
case 1:
- serialice_writeb((uint8_t) data, addr);
- break;
+ serialice_writeb((uint8_t) data, addr);
+ break;
case 2:
- serialice_writew((uint16_t) data, addr);
- break;
+ serialice_writew((uint16_t) data, addr);
+ break;
case 4:
- serialice_writel((uint32_t) data, addr);
- break;
+ serialice_writel((uint32_t) data, addr);
+ break;
default:
- printf("WARNING: unknown write access size %d @%08x\n", size, addr);
+ printf("WARNING: unknown write access size %d @%08x\n", size, addr);
}
}
static void serialice_log_store(int caught, uint32_t addr, uint32_t val,
- unsigned int data_size)
+ unsigned int data_size)
{
if (caught) {
- serialice_log(LOG_WRITE | LOG_MEMORY | LOG_TARGET, val, addr,
- data_size);
+ serialice_log(LOG_WRITE | LOG_MEMORY | LOG_TARGET, val, addr,
+ data_size);
} else {
- serialice_log(LOG_WRITE | LOG_MEMORY, val, addr, data_size);
+ serialice_log(LOG_WRITE | LOG_MEMORY, val, addr, data_size);
}
}
@@ -1026,7 +1031,7 @@
serialice_log_store(write_to_target, addr, filtered_data, data_size);
if (write_to_target) {
- serialice_store_wrapper(addr, data_size, filtered_data);
+ serialice_store_wrapper(addr, data_size, filtered_data);
}
return (write_to_qemu == 0);
@@ -1040,7 +1045,7 @@
int bpp, linesize;
if (!screen_invalid) {
- return;
+ return;
}
dest = ds_get_data(s->ds);
@@ -1051,17 +1056,17 @@
#if SERIALICE_BANNER
int x, y;
if (bpp == 4) {
- for (y = 0; y < 240; y++) {
- for (x = 0; x < 320; x++) {
- int doff = (y * linesize) + (x * bpp);
- int soff = (y * (320 * 3)) + (x * 3);
- dest[doff + 0] = serialice_banner[soff + 2]; // blue
- dest[doff + 1] = serialice_banner[soff + 1]; // green
- dest[doff + 2] = serialice_banner[soff + 0]; // red
- }
- }
+ for (y = 0; y < 240; y++) {
+ for (x = 0; x < 320; x++) {
+ int doff = (y * linesize) + (x * bpp);
+ int soff = (y * (320 * 3)) + (x * 3);
+ dest[doff + 0] = serialice_banner[soff + 2]; // blue
+ dest[doff + 1] = serialice_banner[soff + 1]; // green
+ dest[doff + 2] = serialice_banner[soff + 0]; // red
+ }
+ }
} else {
- printf("Banner enabled and BPP = %d (line size = %d)\n", bpp, linesize);
+ printf("Banner enabled and BPP = %d (line size = %d)\n", bpp, linesize);
}
#endif
@@ -1082,28 +1087,28 @@
s = qemu_mallocz(sizeof(SerialICEState));
s->ds = graphic_console_init(serialice_refresh, serialice_invalidate,
- NULL, NULL, s);
+ NULL, NULL, s);
qemu_console_resize(s->ds, 320, 240);
printf("SerialICE: Open connection to target hardware...\n");
if (serialice_device == NULL) {
- printf("You need to specify a serial device to use SerialICE.\n");
- exit(1);
+ printf("You need to specify a serial device to use SerialICE.\n");
+ exit(1);
}
#ifdef WIN32
s->fd = CreateFile(serialice_device, GENERIC_READ | GENERIC_WRITE,
- 0, NULL, OPEN_EXISTING, 0, NULL);
+ 0, NULL, OPEN_EXISTING, 0, NULL);
if (s->fd == INVALID_HANDLE_VALUE) {
- perror("SerialICE: Could not connect to target TTY");
- exit(1);
+ perror("SerialICE: Could not connect to target TTY");
+ exit(1);
}
DCB dcb;
if (!GetCommState(s->fd, &dcb)) {
- perror("SerialICE: Could not load config for target TTY");
- exit(1);
+ perror("SerialICE: Could not load config for target TTY");
+ exit(1);
}
dcb.BaudRate = CBR_115200;
@@ -1112,30 +1117,30 @@
dcb.StopBits = ONESTOPBIT;
if (!SetCommState(s->fd, &dcb)) {
- perror("SerialICE: Could not store config for target TTY");
- exit(1);
+ perror("SerialICE: Could not store config for target TTY");
+ exit(1);
}
#else
s->fd = open(serialice_device, O_RDWR | O_NOCTTY | O_NONBLOCK);
if (s->fd == -1) {
- perror("SerialICE: Could not connect to target TTY");
- exit(1);
+ perror("SerialICE: Could not connect to target TTY");
+ exit(1);
}
if (ioctl(s->fd, TIOCEXCL) == -1) {
- perror("SerialICE: TTY not exclusively available");
- exit(1);
+ perror("SerialICE: TTY not exclusively available");
+ exit(1);
}
if (fcntl(s->fd, F_SETFL, 0) == -1) {
- perror("SerialICE: Could not switch to blocking I/O");
- exit(1);
+ perror("SerialICE: Could not switch to blocking I/O");
+ exit(1);
}
if (tcgetattr(s->fd, &options) == -1) {
- perror("SerialICE: Could not get TTY attributes");
- exit(1);
+ perror("SerialICE: Could not get TTY attributes");
+ exit(1);
}
cfsetispeed(&options, B115200);
@@ -1159,17 +1164,17 @@
printf("SerialICE: Waiting for handshake with target... ");
- handshake_mode = 1; // Readback errors are to be expected in this phase.
+ handshake_mode = 1; // Readback errors are to be expected in this phase.
/* Trigger a prompt */
serialice_write(s, "@", 1);
/* ... and wait for it to appear */
if (serialice_wait_prompt() == 0) {
- printf("target alife!\n");
+ printf("target alife!\n");
} else {
- printf("target not ok!\n");
- exit(1);
+ printf("target not ok!\n");
+ exit(1);
}
/* Each serialice_command() waits for a prompt, so trigger one for the
@@ -1177,7 +1182,7 @@
*/
serialice_write(s, "@", 1);
- handshake_mode = 0; // from now on, warn about readback errors.
+ handshake_mode = 0; // from now on, warn about readback errors.
serialice_get_version();
@@ -1199,11 +1204,11 @@
}
static void pc_init_serialice(ram_addr_t ram_size,
- const char *boot_device,
- const char *kernel_filename,
- const char *kernel_cmdline,
- const char *initrd_filename,
- const char *cpu_model)
+ const char *boot_device,
+ const char *kernel_filename,
+ const char *kernel_cmdline,
+ const char *initrd_filename,
+ const char *cpu_model)
{
char *filename;
int ret, i, linux_boot;
@@ -1212,26 +1217,26 @@
CPUState *env;
if (ram_size != (DEFAULT_RAM_SIZE * 1024 * 1024)) {
- printf
- ("Warning: Running SerialICE with non-default ram size is not supported.\n");
- exit(1);
+ printf
+ ("Warning: Running SerialICE with non-default ram size is not supported.\n");
+ exit(1);
}
linux_boot = (kernel_filename != NULL);
/* init CPUs */
if (cpu_model == NULL) {
- //printf("Warning: Running SerialICE with generic CPU type might fail.\n");
+ //printf("Warning: Running SerialICE with generic CPU type might fail.\n");
#ifdef TARGET_X86_64
- cpu_model = "qemu64";
+ cpu_model = "qemu64";
#else
- cpu_model = "qemu32";
+ cpu_model = "qemu32";
#endif
}
for (i = 0; i < smp_cpus; i++) {
- env = cpu_init(cpu_model);
- qemu_register_reset((QEMUResetHandler*)cpu_reset, env);
+ env = cpu_init(cpu_model);
+ qemu_register_reset((QEMUResetHandler *) cpu_reset, env);
}
/* Must not happen before CPUs are initialized */
@@ -1239,42 +1244,41 @@
/* BIOS load */
if (bios_name == NULL)
- bios_name = BIOS_FILENAME;
+ bios_name = BIOS_FILENAME;
filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name);
if (filename) {
- bios_size = get_image_size(filename);
+ bios_size = get_image_size(filename);
} else {
- bios_size = -1;
+ bios_size = -1;
}
if (bios_size <= 0 || (bios_size % 65536) != 0) {
- goto bios_error;
+ goto bios_error;
}
bios_offset = qemu_ram_alloc(bios_size);
ret = load_image(filename, qemu_get_ram_ptr(bios_offset));
if (ret != bios_size) {
bios_error:
- fprintf(stderr, "qemu: could not load PC BIOS '%s'\n", bios_name);
- exit(1);
+ fprintf(stderr, "qemu: could not load PC BIOS '%s'\n", bios_name);
+ exit(1);
}
if (filename) {
- qemu_free(filename);
+ qemu_free(filename);
}
/* map the last 128KB of the BIOS in ISA space */
isa_bios_size = bios_size;
if (isa_bios_size > (128 * 1024))
- isa_bios_size = 128 * 1024;
+ isa_bios_size = 128 * 1024;
cpu_register_physical_memory(0x100000 - isa_bios_size,
- isa_bios_size,
- (bios_offset + bios_size -
- isa_bios_size));
+ isa_bios_size,
+ (bios_offset + bios_size - isa_bios_size));
/* map all the bios at the top of memory */
cpu_register_physical_memory((uint32_t) (-bios_size), bios_size,
- bios_offset | IO_MEM_ROM);
+ bios_offset | IO_MEM_ROM);
if (linux_boot) {
- printf("Booting Linux in SerialICE mode is currently not supported.\n");
- exit(1);
+ printf("Booting Linux in SerialICE mode is currently not supported.\n");
+ exit(1);
}
}
Modified: trunk/qemu-0.11.0/serialice.h
===================================================================
--- trunk/qemu-0.11.0/serialice.h 2009-12-05 15:02:29 UTC (rev 87)
+++ trunk/qemu-0.11.0/serialice.h 2009-12-05 15:47:43 UTC (rev 88)
@@ -65,9 +65,9 @@
cpuid_regs_t serialice_cpuid(uint32_t eax, uint32_t ecx);
int serialice_handle_load(uint32_t addr, uint32_t * result,
- unsigned int data_size);
+ unsigned int data_size);
void serialice_log_load(int caught, uint32_t addr, uint32_t result,
- unsigned int data_size);
+ unsigned int data_size);
int serialice_handle_store(uint32_t addr, uint32_t val, unsigned int data_size);
#endif
9 years, 3 months
r87 - trunk/qemu-0.11.0
by svn＠coresystems.de
Author: stepan
Date: 2009-12-05 16:02:29 +0100 (Sat, 05 Dec 2009)
New Revision: 87
Modified:
trunk/qemu-0.11.0/serialice.c
Log:
Add SerialICE_system_reset to trigger a VM side reset.
This is needed to keep Qemu from running code after an outb to 0xcf9 has been
encountered.
Signed-off-by: Stefan Reinauer <stepan(a)coresystems.de>
Modified: trunk/qemu-0.11.0/serialice.c
===================================================================
--- trunk/qemu-0.11.0/serialice.c 2009-12-03 16:15:19 UTC (rev 86)
+++ trunk/qemu-0.11.0/serialice.c 2009-12-05 15:02:29 UTC (rev 87)
@@ -110,11 +110,17 @@
return 0;
}
+static int serialice_system_reset(lua_State * luastate)
+{
+ printf("Rebooting the emulated host CPU\n");
+ qemu_system_reset_request();
+ return 0;
+}
+
// **************************************************************************
// LUA register access
-// copied from target-i386/exec.h
-//CPUX86State *env;
+// some macros from target-i386/exec.h, which we can't include directly
#define env first_cpu
#define EAX (env->regs[R_EAX])
#define ECX (env->regs[R_ECX])
@@ -220,6 +226,7 @@
/* Register C function callbacks */
lua_register(L, "SerialICE_register_physical", serialice_register_physical);
+ lua_register(L, "SerialICE_system_reset", serialice_system_reset);
/* Set global variable SerialICE_mainboard */
lua_pushstring(L, serialice_mainboard);
@@ -1224,6 +1231,7 @@
for (i = 0; i < smp_cpus; i++) {
env = cpu_init(cpu_model);
+ qemu_register_reset((QEMUResetHandler*)cpu_reset, env);
}
/* Must not happen before CPUs are initialized */
9 years, 3 months
Re: [SerialICE] r80 - trunk/qemu-0.11.0
by Patrick Georgi
Am 03.12.2009 19:05, schrieb joe(a)settoplinux.org:
> Ah, 230k isn't so bad and serialice is small enough so there is plenty of space
> left over. The only time it may be a problem is if you only have a 128k chip. I
> was just looking at the 1.4mb attachment to r80 but I guess that was the raw hex
> data.
>
It's also 230k on the host, not on the target...
Patrick
9 years, 3 months
Re: [SerialICE] r80 - trunk/qemu-0.11.0
by Stefan Reinauer
On 12/2/09 11:59 PM, joe(a)settoplinux.org wrote:
> This is awsome :-)
> I can't wait to try it out.
>
> It seems to be a rather large (file size) banner though. Any way to scale it
> down a bit?
>
> Thanks - Joe
>
Not so easily...
I made the graphics 320x200, so it's around 230KiB raw image data.
Options:
- use a compressed format.. This would mean adding a (i.e. JPG)
decompressor to Qemu..
Either by requiring to link against libjpeg, or by adding a jpg
decompressor in an extra file.
- load the PPM file from the filesystem instead of including it in the
source. Doesn't make it
smaller but then it's not possible to make a single diff against the
Qemu source tree anymore.
- paint something funky with a nice and small algorithm. Suggestions?
Stefan
9 years, 3 months
