Add mort qemu files.
This commit is contained in:
Colin
parent
6901da6488
commit
e0decc5721
2
Makefile
2
Makefile
|
|
@ -19,8 +19,6 @@ TEST_BIN = $(OUT)/kernel.bin
|
|||
kernel: $(TEST_OBJ) $(TEST_BIN)
|
||||
|
||||
$(TEST_OBJ):
|
||||
# riscv64-unknown-elf-gcc -march=rv32i -mabi=ilp32 -Wl,-Ttext=0x0 -nostdlib -g -o $@ $<
|
||||
# riscv64-unknown-elf-gcc -march=rv64gc -mabi=lp64 -Wl,-Ttext=0x0 -nostdlib -g -o $@ $<
|
||||
riscv64-unknown-elf-gcc -g -march=rv64gc -mabi=lp64d -nostdlib -T link.ld -o $@ kernel.c start.s
|
||||
riscv64-unknown-elf-objdump -d -S $@ > $(TEST_DUMP)
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,108 @@
|
|||
#ifndef GDBSTUB_COMMANDS_H
|
||||
#define GDBSTUB_COMMANDS_H
|
||||
|
||||
typedef void (*GdbCmdHandler)(GArray *params, void *user_ctx);
|
||||
|
||||
typedef enum GDBThreadIdKind {
|
||||
GDB_ONE_THREAD = 0,
|
||||
GDB_ALL_THREADS, /* One process, all threads */
|
||||
GDB_ALL_PROCESSES,
|
||||
GDB_READ_THREAD_ERR
|
||||
} GDBThreadIdKind;
|
||||
|
||||
typedef union GdbCmdVariant {
|
||||
const char *data;
|
||||
uint8_t opcode;
|
||||
unsigned long val_ul;
|
||||
unsigned long long val_ull;
|
||||
struct {
|
||||
GDBThreadIdKind kind;
|
||||
uint32_t pid;
|
||||
uint32_t tid;
|
||||
} thread_id;
|
||||
} GdbCmdVariant;
|
||||
|
||||
#define gdb_get_cmd_param(p, i) (&g_array_index(p, GdbCmdVariant, i))
|
||||
|
||||
/**
|
||||
* typedef GdbCmdParseEntry - gdb command parser
|
||||
*
|
||||
* This structure keeps the information necessary to match a gdb command,
|
||||
* parse it (extract its parameters), and select the correct handler for it.
|
||||
*
|
||||
* @cmd: The command to be matched
|
||||
* @cmd_startswith: If true, @cmd is compared using startswith
|
||||
* @schema: Each schema for the command parameter entry consists of 2 chars,
|
||||
* the first char represents the parameter type handling the second char
|
||||
* represents the delimiter for the next parameter.
|
||||
*
|
||||
* Currently supported schema types:
|
||||
* 'l' -> unsigned long (stored in .val_ul)
|
||||
* 'L' -> unsigned long long (stored in .val_ull)
|
||||
* 's' -> string (stored in .data)
|
||||
* 'o' -> single char (stored in .opcode)
|
||||
* 't' -> thread id (stored in .thread_id)
|
||||
* '?' -> skip according to delimiter
|
||||
*
|
||||
* Currently supported delimiters:
|
||||
* '?' -> Stop at any delimiter (",;:=\0")
|
||||
* '0' -> Stop at "\0"
|
||||
* '.' -> Skip 1 char unless reached "\0"
|
||||
* Any other value is treated as the delimiter value itself
|
||||
*
|
||||
* @allow_stop_reply: True iff the gdbstub can respond to this command with a
|
||||
* "stop reply" packet. The list of commands that accept such response is
|
||||
* defined at the GDB Remote Serial Protocol documentation. See:
|
||||
* https://sourceware.org/gdb/onlinedocs/gdb/Stop-Reply-Packets.html#Stop-Reply-Packets.
|
||||
*
|
||||
* @need_cpu_context: Pass current CPU context to command handler via user_ctx.
|
||||
*/
|
||||
typedef struct GdbCmdParseEntry {
|
||||
GdbCmdHandler handler;
|
||||
const char *cmd;
|
||||
bool cmd_startswith;
|
||||
const char *schema;
|
||||
bool allow_stop_reply;
|
||||
bool need_cpu_context;
|
||||
} GdbCmdParseEntry;
|
||||
|
||||
/**
|
||||
* gdb_put_packet() - put string into gdb server's buffer so it is sent
|
||||
* to the client
|
||||
*/
|
||||
int gdb_put_packet(const char *buf);
|
||||
|
||||
/**
|
||||
* gdb_extend_query_table() - Extend query table.
|
||||
* @table: GPtrArray of GdbCmdParseEntry entries.
|
||||
*
|
||||
* The caller should free @table afterwards
|
||||
*/
|
||||
void gdb_extend_query_table(GPtrArray *table);
|
||||
|
||||
/**
|
||||
* gdb_extend_set_table() - Extend set table.
|
||||
* @table: GPtrArray of GdbCmdParseEntry entries.
|
||||
*
|
||||
* The caller should free @table afterwards
|
||||
*/
|
||||
void gdb_extend_set_table(GPtrArray *table);
|
||||
|
||||
/**
|
||||
* gdb_extend_qsupported_features() - Extend the qSupported features string.
|
||||
* @qsupported_features: The additional qSupported feature(s) string. The string
|
||||
* should start with a semicolon and, if there are more than one feature, the
|
||||
* features should be separate by a semicolon.
|
||||
*
|
||||
* The caller should free @qsupported_features afterwards if
|
||||
* dynamically allocated.
|
||||
*/
|
||||
void gdb_extend_qsupported_features(char *qsupported_features);
|
||||
|
||||
/**
|
||||
* Convert a hex string to bytes. Conversion is done per byte, so 2 hex digits
|
||||
* are converted to 1 byte. Invalid hex digits are treated as 0 digits.
|
||||
*/
|
||||
void gdb_hextomem(GByteArray *mem, const char *buf, int len);
|
||||
|
||||
#endif /* GDBSTUB_COMMANDS_H */
|
||||
|
|
@ -0,0 +1,21 @@
|
|||
/*
|
||||
* gdbstub enums
|
||||
*
|
||||
* Copyright (c) 2024 Linaro Ltd
|
||||
*
|
||||
* SPDX-License-Identifier: GPL-2.0-or-later
|
||||
*/
|
||||
|
||||
#ifndef GDBSTUB_ENUMS_H
|
||||
#define GDBSTUB_ENUMS_H
|
||||
|
||||
#define DEFAULT_GDBSTUB_PORT "1234"
|
||||
|
||||
/* GDB breakpoint/watchpoint types */
|
||||
#define GDB_BREAKPOINT_SW 0
|
||||
#define GDB_BREAKPOINT_HW 1
|
||||
#define GDB_WATCHPOINT_WRITE 2
|
||||
#define GDB_WATCHPOINT_READ 3
|
||||
#define GDB_WATCHPOINT_ACCESS 4
|
||||
|
||||
#endif /* GDBSTUB_ENUMS_H */
|
||||
|
|
@ -0,0 +1,117 @@
|
|||
/*
|
||||
* gdbstub helpers
|
||||
*
|
||||
* These are all used by the various frontends and have to be host
|
||||
* aware to ensure things are store in target order.
|
||||
*
|
||||
* Copyright (c) 2022 Linaro Ltd
|
||||
*
|
||||
* SPDX-License-Identifier: GPL-2.0-or-later
|
||||
*/
|
||||
|
||||
#ifndef _GDBSTUB_HELPERS_H_
|
||||
#define _GDBSTUB_HELPERS_H_
|
||||
|
||||
#ifndef COMPILING_PER_TARGET
|
||||
#error "gdbstub helpers should only be included by target specific code"
|
||||
#endif
|
||||
|
||||
#include "qemu/bswap.h"
|
||||
#include "qemu/target-info.h"
|
||||
#include "cpu-param.h"
|
||||
|
||||
/*
|
||||
* The GDB remote protocol transfers values in target byte order. As
|
||||
* the gdbstub may be batching up several register values we always
|
||||
* append to the array.
|
||||
*/
|
||||
|
||||
static inline int gdb_get_reg8(GByteArray *buf, uint8_t val)
|
||||
{
|
||||
g_byte_array_append(buf, &val, 1);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static inline int gdb_get_reg16(GByteArray *buf, uint16_t val)
|
||||
{
|
||||
if (target_big_endian()) {
|
||||
cpu_to_be16s(&val);
|
||||
} else {
|
||||
cpu_to_le16s(&val);
|
||||
}
|
||||
g_byte_array_append(buf, (uint8_t *) &val, 2);
|
||||
return 2;
|
||||
}
|
||||
|
||||
static inline int gdb_get_reg32(GByteArray *buf, uint32_t val)
|
||||
{
|
||||
if (target_big_endian()) {
|
||||
cpu_to_be32s(&val);
|
||||
} else {
|
||||
cpu_to_le32s(&val);
|
||||
}
|
||||
g_byte_array_append(buf, (uint8_t *) &val, 4);
|
||||
return 4;
|
||||
}
|
||||
|
||||
static inline int gdb_get_reg64(GByteArray *buf, uint64_t val)
|
||||
{
|
||||
if (target_big_endian()) {
|
||||
cpu_to_be64s(&val);
|
||||
} else {
|
||||
cpu_to_le64s(&val);
|
||||
}
|
||||
g_byte_array_append(buf, (uint8_t *) &val, 8);
|
||||
return 8;
|
||||
}
|
||||
|
||||
static inline int gdb_get_reg128(GByteArray *buf, uint64_t val_hi,
|
||||
uint64_t val_lo)
|
||||
{
|
||||
uint64_t tmp[2];
|
||||
if (target_big_endian()) {
|
||||
tmp[0] = cpu_to_be64(val_hi);
|
||||
tmp[1] = cpu_to_be64(val_lo);
|
||||
} else {
|
||||
tmp[0] = cpu_to_le64(val_lo);
|
||||
tmp[1] = cpu_to_le64(val_hi);
|
||||
}
|
||||
g_byte_array_append(buf, (uint8_t *)&tmp, 16);
|
||||
return 16;
|
||||
}
|
||||
|
||||
static inline int gdb_get_zeroes(GByteArray *array, size_t len)
|
||||
{
|
||||
guint oldlen = array->len;
|
||||
g_byte_array_set_size(array, oldlen + len);
|
||||
memset(array->data + oldlen, 0, len);
|
||||
|
||||
return len;
|
||||
}
|
||||
|
||||
/**
|
||||
* gdb_get_reg_ptr: get pointer to start of last element
|
||||
* @len: length of element
|
||||
*
|
||||
* This is a helper function to extract the pointer to the last
|
||||
* element for additional processing. Some front-ends do additional
|
||||
* dynamic swapping of the elements based on CPU state.
|
||||
*/
|
||||
static inline uint8_t *gdb_get_reg_ptr(GByteArray *buf, int len)
|
||||
{
|
||||
return buf->data + buf->len - len;
|
||||
}
|
||||
|
||||
#if TARGET_LONG_BITS == 64
|
||||
#define gdb_get_regl(buf, val) gdb_get_reg64(buf, val)
|
||||
#define ldtul_p(addr) ldq_p(addr)
|
||||
#define ldtul_le_p(addr) ldq_le_p(addr)
|
||||
#define ldtul_be_p(addr) ldq_be_p(addr)
|
||||
#else
|
||||
#define gdb_get_regl(buf, val) gdb_get_reg32(buf, val)
|
||||
#define ldtul_p(addr) ldl_p(addr)
|
||||
#define ldtul_le_p(addr) ldl_le_p(addr)
|
||||
#define ldtul_be_p(addr) ldl_be_p(addr)
|
||||
#endif
|
||||
|
||||
#endif /* _GDBSTUB_HELPERS_H_ */
|
||||
|
|
@ -0,0 +1,122 @@
|
|||
/*
|
||||
* GDB Syscall support
|
||||
*
|
||||
* Copyright (c) 2023 Linaro Ltd
|
||||
*
|
||||
* SPDX-License-Identifier: LGPL-2.0-or-later
|
||||
*/
|
||||
|
||||
#ifndef _SYSCALLS_H_
|
||||
#define _SYSCALLS_H_
|
||||
|
||||
/* For gdb file i/o remote protocol open flags. */
|
||||
#define GDB_O_RDONLY 0
|
||||
#define GDB_O_WRONLY 1
|
||||
#define GDB_O_RDWR 2
|
||||
#define GDB_O_APPEND 8
|
||||
#define GDB_O_CREAT 0x200
|
||||
#define GDB_O_TRUNC 0x400
|
||||
#define GDB_O_EXCL 0x800
|
||||
|
||||
/* For gdb file i/o remote protocol errno values */
|
||||
#define GDB_EPERM 1
|
||||
#define GDB_ENOENT 2
|
||||
#define GDB_EINTR 4
|
||||
#define GDB_EBADF 9
|
||||
#define GDB_EACCES 13
|
||||
#define GDB_EFAULT 14
|
||||
#define GDB_EBUSY 16
|
||||
#define GDB_EEXIST 17
|
||||
#define GDB_ENODEV 19
|
||||
#define GDB_ENOTDIR 20
|
||||
#define GDB_EISDIR 21
|
||||
#define GDB_EINVAL 22
|
||||
#define GDB_ENFILE 23
|
||||
#define GDB_EMFILE 24
|
||||
#define GDB_EFBIG 27
|
||||
#define GDB_ENOSPC 28
|
||||
#define GDB_ESPIPE 29
|
||||
#define GDB_EROFS 30
|
||||
#define GDB_ENAMETOOLONG 91
|
||||
#define GDB_EUNKNOWN 9999
|
||||
|
||||
/* For gdb file i/o remote protocol lseek whence. */
|
||||
#define GDB_SEEK_SET 0
|
||||
#define GDB_SEEK_CUR 1
|
||||
#define GDB_SEEK_END 2
|
||||
|
||||
/* For gdb file i/o stat/fstat. */
|
||||
typedef uint32_t gdb_mode_t;
|
||||
typedef uint32_t gdb_time_t;
|
||||
|
||||
struct gdb_stat {
|
||||
uint32_t gdb_st_dev; /* device */
|
||||
uint32_t gdb_st_ino; /* inode */
|
||||
gdb_mode_t gdb_st_mode; /* protection */
|
||||
uint32_t gdb_st_nlink; /* number of hard links */
|
||||
uint32_t gdb_st_uid; /* user ID of owner */
|
||||
uint32_t gdb_st_gid; /* group ID of owner */
|
||||
uint32_t gdb_st_rdev; /* device type (if inode device) */
|
||||
uint64_t gdb_st_size; /* total size, in bytes */
|
||||
uint64_t gdb_st_blksize; /* blocksize for filesystem I/O */
|
||||
uint64_t gdb_st_blocks; /* number of blocks allocated */
|
||||
gdb_time_t gdb_st_atime; /* time of last access */
|
||||
gdb_time_t gdb_st_mtime; /* time of last modification */
|
||||
gdb_time_t gdb_st_ctime; /* time of last change */
|
||||
} QEMU_PACKED;
|
||||
|
||||
struct gdb_timeval {
|
||||
gdb_time_t tv_sec; /* second */
|
||||
uint64_t tv_usec; /* microsecond */
|
||||
} QEMU_PACKED;
|
||||
|
||||
typedef void (*gdb_syscall_complete_cb)(CPUState *cpu, uint64_t ret, int err);
|
||||
|
||||
/**
|
||||
* gdb_do_syscall:
|
||||
* @cb: function to call when the system call has completed
|
||||
* @fmt: gdb syscall format string
|
||||
* ...: list of arguments to interpolate into @fmt
|
||||
*
|
||||
* Send a GDB syscall request. This function will return immediately;
|
||||
* the callback function will be called later when the remote system
|
||||
* call has completed.
|
||||
*
|
||||
* @fmt should be in the 'call-id,parameter,parameter...' format documented
|
||||
* for the F request packet in the GDB remote protocol. A limited set of
|
||||
* printf-style format specifiers is supported:
|
||||
* %x - target_ulong argument printed in hex
|
||||
* %lx - 64-bit argument printed in hex
|
||||
* %s - string pointer (target_ulong) and length (int) pair
|
||||
*/
|
||||
void gdb_do_syscall(gdb_syscall_complete_cb cb, const char *fmt, ...);
|
||||
|
||||
/**
|
||||
* use_gdb_syscalls() - report if GDB should be used for syscalls
|
||||
*
|
||||
* This is mostly driven by the semihosting mode the user configures
|
||||
* but assuming GDB is allowed by that we report true if GDB is
|
||||
* connected to the stub.
|
||||
*/
|
||||
int use_gdb_syscalls(void);
|
||||
|
||||
/**
|
||||
* gdb_exit: exit gdb session, reporting inferior status
|
||||
* @code: exit code reported
|
||||
*
|
||||
* This closes the session and sends a final packet to GDB reporting
|
||||
* the exit status of the program. It also cleans up any connections
|
||||
* detritus before returning.
|
||||
*/
|
||||
void gdb_exit(int code);
|
||||
|
||||
/**
|
||||
* gdb_qemu_exit: ask qemu to exit
|
||||
* @code: exit code reported
|
||||
*
|
||||
* This requests qemu to exit. This function is allowed to return as
|
||||
* the exit request might be processed asynchronously by qemu backend.
|
||||
*/
|
||||
void gdb_qemu_exit(int code);
|
||||
|
||||
#endif /* _SYSCALLS_H_ */
|
||||
|
|
@ -0,0 +1,67 @@
|
|||
/*
|
||||
* gdbstub user-mode only APIs
|
||||
*
|
||||
* Copyright (c) 2022 Linaro Ltd
|
||||
*
|
||||
* SPDX-License-Identifier: LGPL-2.0-or-later
|
||||
*/
|
||||
|
||||
#ifndef GDBSTUB_USER_H
|
||||
#define GDBSTUB_USER_H
|
||||
|
||||
#define MAX_SIGINFO_LENGTH 128
|
||||
|
||||
/**
|
||||
* gdb_handlesig() - yield control to gdb
|
||||
* @cpu: CPU
|
||||
* @sig: if non-zero, the signal number which caused us to stop
|
||||
* @reason: stop reason for stop reply packet or NULL
|
||||
* @siginfo: target-specific siginfo struct
|
||||
* @siginfo_len: target-specific siginfo struct length
|
||||
*
|
||||
* This function yields control to gdb, when a user-mode-only target
|
||||
* needs to stop execution. If @sig is non-zero, then we will send a
|
||||
* stop packet to tell gdb that we have stopped because of this signal.
|
||||
*
|
||||
* This function will block (handling protocol requests from gdb)
|
||||
* until gdb tells us to continue target execution. When it does
|
||||
* return, the return value is a signal to deliver to the target,
|
||||
* or 0 if no signal should be delivered, ie the signal that caused
|
||||
* us to stop should be ignored.
|
||||
*/
|
||||
int gdb_handlesig(CPUState *, int, const char *, void *, int);
|
||||
|
||||
/**
|
||||
* gdb_signalled() - inform remote gdb of sig exit
|
||||
* @as: current CPUArchState
|
||||
* @sig: signal number
|
||||
*/
|
||||
void gdb_signalled(CPUArchState *as, int sig);
|
||||
|
||||
/**
|
||||
* gdbserver_fork_start() - inform gdb of the upcoming fork()
|
||||
*/
|
||||
void gdbserver_fork_start(void);
|
||||
|
||||
/**
|
||||
* gdbserver_fork_end() - inform gdb of the completed fork()
|
||||
* @cs: CPU
|
||||
* @pid: 0 if in child process, -1 if fork failed, child process pid otherwise
|
||||
*/
|
||||
void gdbserver_fork_end(CPUState *cs, pid_t pid);
|
||||
|
||||
/**
|
||||
* gdb_syscall_entry() - inform gdb of syscall entry and yield control to it
|
||||
* @cs: CPU
|
||||
* @num: syscall number
|
||||
*/
|
||||
void gdb_syscall_entry(CPUState *cs, int num);
|
||||
|
||||
/**
|
||||
* gdb_syscall_entry() - inform gdb of syscall return and yield control to it
|
||||
* @cs: CPU
|
||||
* @num: syscall number
|
||||
*/
|
||||
void gdb_syscall_return(CPUState *cs, int num);
|
||||
|
||||
#endif /* GDBSTUB_USER_H */
|
||||
Loading…
Reference in New Issue