NSL on ck-dev

Design of branch instruction issue for RISC-V OoO

Tue, 15 Feb 2022 00:41:52 +0900

趣味でRISC-Vのアウト・オブ・オーダープロセッサを実装している。 Tomasulo algorithmに基づいている。今回は分岐命令の発行部分の検討をしていく。 Commit: df27bdc1b9382573458b5bf571ca32a9fa93325c

BRU pipe

今回の実装では分岐命令はBRU(BRanch Unit) pipeで実行する。2-wayのデコードのスーパスカラな実装で、現状はALUパイプは2つある。ここにBRUパイプとリザベーションステーションを追加する。

Branch命令の実行

今回はBranch命令を以下のように分類する。

Branch(opcode == BRANCH)
Jump(opcode == JAL || opcode == JALR)

現状の実装では、Jump命令は分岐のコンディションを計算する必要ないため、ALUパイプへ発行している。分岐パイプが実装できたら、こちらへ発行するようにする。

BRU RS

分岐パイプ用のリザベーションステーションは１つとする。（エントリではない）フェッチパケット(命令フェッチの単位、今回は２命令同時フェッチ）内に分岐命令が２つある場合、デコードステージを２回行う。一回目では先行の命令のみを発行をする。次のサイクルでは次の命令を発行する。

issueステージでは、分岐命令が１つしか発行されないことを前提する。 issueステージでは、BRU用のリザベーションステーションへ発行する。

オペランドが揃った時点で、BRUパイプへDispatchする。

実行ステージでは、分岐命令の成否とターゲットアドレスを計算する。つまり、必要なオペランドは以下のものとなる。

ターゲットアドレスはissueステージで計算可能なので、事前にissueステージでpc+immを計算し、ROB.Targetへ格納しておく。実行ステージではrs1 Branch Op rs2を計算し、write resultステージで、ROB.ValueへCDBを通してブロードキャストする Jump命令の場合は常に、1を格納する。

BRU Commit

コミット時には、以下の条件で分岐をする。

if((opcode == JAL || opcode == JALR || opcode == BRANCH)) {
if(opcode == JAL || opcode == JALR) {
GPR[rd] = PC4;
}
if(ROB.Value[0]) {
Redirect(ROB.Target);
// Feedback to Branch prediction unit if it presents
 // Also check prediction and actual result
 }
} else {
// Normal commit
}

My RISC-V debug feature part8(implement suggested DMI signal interface)

Tue, 20 Jul 2021 22:28:05 +0900

独自のDMIインターフェースから推奨インターフェースに変更する。

riscv-debugによると、以下の信号がインターフェースとして推奨されているようである。

ちなみに、今回の実装ではABITSは32 bitとしている。

My RISC-V debug feature part7 (examine関数(riscv013)の読解, DMの実装)

Sun, 16 May 2021 20:56:07 +0900

今回から、examine関数を読み、初期化のフローを理解する。 DMを実装をして、examineで初期化をできるようにしていく。

examine関数

examine関数はriscv013用のインターフェイスより呼び出される。

src/target/riscv/riscv-013.c

struct target_type riscv013_target = {
.name = "riscv",
.init_target = init_target,
.deinit_target = deinit_target,
.examine = examine,
.poll = &riscv_openocd_poll,
.halt = &riscv_halt,
.step = &riscv_openocd_step,
.assert_reset = assert_reset,
.deassert_reset = deassert_reset,
.write_memory = write_memory,
.arch_state = arch_state
};

examine関数の実体

src/target/riscv/riscv-013.c:examine

static int examine(struct target *target)
{
/* Don't need to select dbus, since the first thing we do is read dtmcontrol. */
uint32_t dtmcontrol = dtmcontrol_scan(target, 0);
LOG_DEBUG("dtmcontrol=0x%x", dtmcontrol);
LOG_DEBUG(" dmireset=%d", get_field(dtmcontrol, DTM_DTMCS_DMIRESET));
LOG_DEBUG(" idle=%d", get_field(dtmcontrol, DTM_DTMCS_IDLE));
LOG_DEBUG(" dmistat=%d", get_field(dtmcontrol, DTM_DTMCS_DMISTAT));
LOG_DEBUG(" abits=%d", get_field(dtmcontrol, DTM_DTMCS_ABITS));
LOG_DEBUG(" version=%d", get_field(dtmcontrol, DTM_DTMCS_VERSION));

まずは、dtmcontrol_scanにて、DTM内のdtmcsをスキャンする。

dmicsレジスタ

dtmcsレジスタのフォーマットは以下の通り。アドレス(IR)は0x10である。

各フィールドの意味を以下に示す。(riscv-debug-spec p.88)

dmihardreset

1をこのフィールドに書き込むことで、DTMをハードリセットする。ハードリセットは実行中のDMIトランザクションを終了させる。また、すべてのDTM内部状態、レジスタを初期状態にする。

dmireset

1を書き込むことで、sticky error状態をクリアする。また、DMIトランザクションはキャンセルしない。

idle

デバッカに与えるヒントで、DMI scan後に必要なRun-Test/Idleサイクル数を保持する。必要に応じて、デバッカはdmics.dmistatを確認する。

0: 不要
1: 1
2: 2
...

dmistat

0: no error
1: reserved(same as 2)
2: An operation failed
3: An operation was attempted while DMI access was still in progress

abits

The size of address in dmi

version

0: version 0.11
1: version 0.13 and 1.0
15: version not described in any spec

examine続き

src/target/riscv/riscv-013.c:examine

 if (dtmcontrol == 0) {
LOG_ERROR("dtmcontrol is 0. Check JTAG connectivity/board power.");
return ERROR_FAIL;
}
if (get_field(dtmcontrol, DTM_DTMCS_VERSION) != 1) {
LOG_ERROR("Unsupported DTM version %d. (dtmcontrol=0x%x)",
get_field(dtmcontrol, DTM_DTMCS_VERSION), dtmcontrol);
return ERROR_FAIL;
}

読み出した、dtmcontrol(dtmcs)を確認する。 riscv013では、versionが1がリセット値であることが保証されているので、dtmcontrolが0であるとき、正しく読み出せていないことになる。

つぎに、dtmcs.versionを読み出し、1(version 0.13 and 1.0)であるか確認している。

src/target/riscv/riscv-013.c:examine

 riscv013_info_t *info = get_info(target);
/* TODO: This won't be true if there are multiple DMs. */
info->index = target->coreid;
info->abits = get_field(dtmcontrol, DTM_DTMCS_ABITS);
info->dtmcs_idle = get_field(dtmcontrol, DTM_DTMCS_IDLE);
/* Reset the Debug Module. */
dm013_info_t *dm = get_dm(target);

読み出した、index, abits, idleはinfo構造体へ保存する。

get_info関数

get_info関数では、riscvのバージョン固有のinfo構造体を取得する。今回の場合は、riscv013用のinfo構造体(riscv013_info_t)を取得する。

src/target/riscv/riscv-013.c

static riscv013_info_t *get_info(const struct target *target)
{
riscv_info_t *info = (riscv_info_t *) target->arch_info;
assert(info);
assert(info->version_specific);
return (riscv013_info_t *) info->version_specific;
}

src/target/riscv/riscv-013.c riscv013_info_t抜粋

typedef struct {
/* The indexed used to address this hart in its DM. */
unsigned index;
/* Number of address bits in the dbus register. */
unsigned abits;
/* Number of abstract command data registers. */
unsigned datacount;
/* Number of words in the Program Buffer. */
unsigned progbufsize;
/* We cache the read-only bits of sbcs here. */
uint32_t sbcs;
...
dm013_info_t *dm;
} riscv013_info_t;

DTMやDMの情報を保持する。

get_dm関数

この関数では、ターゲットのDM構造体を返す。もし、見つからない場合は、作成し初期化する。構造体としては、dm013_info_tと同じである。

examine続き

src/target/riscv/riscv-013.c:examine

 if (!dm)
return ERROR_FAIL;
if (!dm->was_reset) {
dmi_write(target, DM_DMCONTROL, 0);
dmi_write(target, DM_DMCONTROL, DM_DMCONTROL_DMACTIVE);
dm->was_reset = true;
}
dmi_write(target, DM_DMCONTROL, DM_DMCONTROL_HARTSELLO |
DM_DMCONTROL_HARTSELHI | DM_DMCONTROL_DMACTIVE |
DM_DMCONTROL_HASEL);
uint32_t dmcontrol;
if (dmi_read(target, &dmcontrol, DM_DMCONTROL) != ERROR_OK)
return ERROR_FAIL;
if (!get_field(dmcontrol, DM_DMCONTROL_DMACTIVE)) {
LOG_ERROR("Debug Module did not become active. dmcontrol=0x%x",
dmcontrol);
return ERROR_FAIL;
}

dmが初期化されていない場合は、初期化をする。初期では、DM_DMCONTROL(DTMでないことに注意)をまず、0で初期化する。 dmi_writeはdbus(DMI)を経由して、DMのレジスタを書き込みする。今回は、DM_DMCONTORLアドレスに、0を書き込む。

その後、DMACTIVEフィールドを1にする。このフィールドはDMのリセット信号として機能する。このフィールドに書き込みをした場合は、次のアクションを行う前に、書き込んだ値が反映されているかポーリングが必要。このフィールドが0の場合は、DMはすべて初期状態であることを示し、DMに対するアクセスはすべて失敗する。また、versionフィールドは正しい値を返さないかもしれない。 1の場合は、DMが正しく動作していることを示す。

次に、DM_DMCONTROL_DMACTIVEの他に、WARLフィールドに-1を書き込む。読み出したっているビットを見ることで、DMがサポートする機能がわかる。書き込むフィールドはDM_DMCONTROL_HARTSEL、DM_DMCONTROL_HARTSELLO、DM_DMCONTROL_HARTSELHIである。これらは、hartの選択方法を規定するものである。（詳しくは後ほど)

 dmi_write(target, DM_DMCONTROL, DM_DMCONTROL_HARTSELLO |
DM_DMCONTROL_HARTSELHI | DM_DMCONTROL_DMACTIVE |
DM_DMCONTROL_HASEL);

次に、dmi_readにてDM_DMCONTROLを読み出し、DMACTIVEビットが1であるか検査をする。 0の場合は、DMはアクティブでない。

今日はここまで

今回はここまで。ちなみに、DMACTIVEまでは、DMを実装している。そのため、examineは途中まで成功している。次回は、まだ実装していないhartの選択方法から見ていく。なんか、投稿のフォーマットがぐちゃぐちゃで見づらい説はある。なんかいい方法ないかな。あと、表をいい感じに書きたい。

My RISC-V debug feature part6 (target examine, riscv examine)

Thu, 13 May 2021 23:02:58 +0900

今回も引き続き、OpenOCDのコードを読んでいく。 target_examineとriscv_examineを読む。

target_examine

src/target/target.c

/* Targets that correctly implement init + examine, i.e.
 * no communication with target during init:
 *
 * XScale
 */
int target_examine(void)
{
int retval = ERROR_OK;
struct target *target;
for (target = all_targets; target; target = target->next) {
/* defer examination, but don't skip it */
if (!target->tap->enabled) {
jtag_register_event_callback(jtag_enable_callback,
target);
continue;
}
if (target->defer_examine)
continue;
int retval2 = target_examine_one(target);
if (retval2 != ERROR_OK) {
LOG_WARNING("target %s examination failed", target_name(target));
retval = retval2;
}
}
return retval;
}
/* Equivalent Tcl code arp_examine_one is in src/target/startup.tcl
 * Keep in sync */
int target_examine_one(struct target *target)
{
target_call_event_callbacks(target, TARGET_EVENT_EXAMINE_START);
int retval = target->type->examine(target);
if (retval != ERROR_OK) {
target_call_event_callbacks(target, TARGET_EVENT_EXAMINE_FAIL);
return retval;
}
target_call_event_callbacks(target, TARGET_EVENT_EXAMINE_END);
return ERROR_OK;
}
static int jtag_enable_callback(enum jtag_event event, void *priv)
{
struct target *target = priv;
if (event != JTAG_TAP_EVENT_ENABLE || !target->tap->enabled)
return ERROR_OK;
jtag_unregister_event_callback(jtag_enable_callback, target);
return target_examine_one(target);
}

target_examine_oneにて、ターゲット固有のexamineを実行する。 RISC-Vの場合を見ていく。

src/target/riscv/riscv.c

struct target_type riscv_target = {
.name = "riscv",
.target_create = riscv_create_target,
.init_target = riscv_init_target,
.deinit_target = riscv_deinit_target,
.examine = riscv_examine,

riscv用のtarget_type構造体のexamineの実態はriscv_examineである。

static int riscv_examine(struct target *target)
{
LOG_DEBUG("riscv_examine()");
if (target_was_examined(target)) {
LOG_DEBUG("Target was already examined.");
return ERROR_OK;
}
if (use_vjtag == true) {
LOG_DEBUG("use_vjtag is enabled");
riscv_tap_vjtag_init(target->tap);
}
/* Don't need to select dbus, since the first thing we do is read dtmcontrol. */
RISCV_INFO(info);
uint32_t dtmcontrol = dtmcontrol_scan(target, 0);
LOG_DEBUG("dtmcontrol=0x%x", dtmcontrol);
info->dtm_version = get_field(dtmcontrol, DTMCONTROL_VERSION);
LOG_DEBUG(" version=0x%x", info->dtm_version);
struct target_type *tt = get_target_type(target);
if (tt == NULL)
return ERROR_FAIL;
int result = tt->init_target(info->cmd_ctx, target);
if (result != ERROR_OK)
return result;
return tt->examine(target);
}

ここから、RISC-VのDMに対するアクセスが始まる。

DMへのアクセス

なお、今回はVJTAGを用いてDMにアクセスをする。まず最初にアクセスするのは、dtmcontrolである。

dtmcontrol(dtmcs)

dtmcontrolにはdtmcontrol_scan関数を用いてアクセスをする。

src/target/riscv/riscv.c

uint8_t ir_dtmcontrol[4] = {DTMCONTROL};
struct scan_field select_dtmcontrol = {
.in_value = NULL,
.out_value = ir_dtmcontrol
};
uint8_t ir_dbus[4] = {DBUS};
struct scan_field select_dbus = {
.in_value = NULL,
.out_value = ir_dbus
};

src/target/riscv/riscv.c

static uint32_t dtmcontrol_scan(struct target *target, uint32_t out)
{
struct scan_field field;
uint8_t in_value[4];
uint8_t out_value[4] = { 0 };
if (bscan_tunnel_ir_width != 0)
return dtmcontrol_scan_via_bscan(target, out);
buf_set_u32(out_value, 0, 32, out);
if (use_vjtag)
vjtag_vir_scan(target->tap, select_dtmcontrol.out_value[0]);
else
jtag_add_ir_scan(target->tap, &select_dtmcontrol, TAP_IDLE);
field.num_bits = 32;
field.out_value = out_value;
field.in_value = in_value;
jtag_add_dr_scan(target->tap, 1, &field, TAP_IDLE);
if (use_vjtag)
vjtag_vir_scan(target->tap, select_dbus.out_value[0]);
else
/* Always return to dbus. */
jtag_add_ir_scan(target->tap, &select_dbus, TAP_IDLE);
int retval = jtag_execute_queue();
if (retval != ERROR_OK) {
LOG_ERROR("failed jtag scan: %d", retval);
return retval;
}
uint32_t in = buf_get_u32(field.in_value, 0, 32);
LOG_DEBUG("DTMCONTROL: 0x%x -> 0x%x", out, in);
return in;
}

まずは、VIRへDTMCONTROLを転送する。 jtag_add_dr_scan(target->tap, 1, &field, TAP_IDLE); にて、DR scanを行い、DTMCONTROLの値を取得する。(32 bit) 結果は、fieldへ格納される。なお、終了後のTAP状態はIDLEとなる。

 if (use_vjtag)
vjtag_vir_scan(target->tap, select_dbus.out_value[0]);

この行では、DBUS(DMI)へVIRを変更している。 int retval = jtag_execute_queue();でJTAGのコマンドを実行する。

uint32_t in = buf_get_u32(field.in_value, 0, 32); この行で、取得した、DTMCONTROLを取り出す。

dtmcs(dtmcontrol)のレジスタの構成は以下のようになっている。 versionフィールドをget_fieldにて取り出す。

つぎに、get_target_typeを行い、ターゲットの種別を調べる。 src/target/riscv/riscv.c

static struct target_type *get_target_type(struct target *target)
{
riscv_info_t *info = (riscv_info_t *) target->arch_info;
if (!info) {
LOG_ERROR("Target has not been initialized");
return NULL;
}
switch (info->dtm_version) {
case 0:
return &riscv011_target;
case 1:
return &riscv013_target;
default:
LOG_ERROR("Unsupported DTM version: %d", info->dtm_version);
return NULL;
}
}

バージョンに応じて、riscv013_target, riscv011_targetを選択する。今回は、0b0001としたので、riscv-debug-spec 0.13 and 1.0に準拠となる。

riscv-debug/src/dtm.h

#define DTMCS_VERSION 4'b0001
#define DTMCS_ABITS 6'b100000

src/target/riscv/riscv.c:riscv_examine

 int result = tt->init_target(info->cmd_ctx, target);
if (result != ERROR_OK)
return result;
return tt->examine(target);
}

つぎに、ターゲット(riscv_013)固有な初期化を行う。その後、examineをする。

riscv-013固有のtarget_type構造体は以下のとおりである。 src/target/riscv/riscv-013.c

struct target_type riscv013_target = {
.name = "riscv",
.init_target = init_target,
.deinit_target = deinit_target,
.examine = examine,
.poll = &riscv_openocd_poll,
.halt = &riscv_halt,
.step = &riscv_openocd_step,
.assert_reset = assert_reset,
.deassert_reset = deassert_reset,
.write_memory = write_memory,
.arch_state = arch_state
};

src/target/riscv/riscv-013.c

static int init_target(struct command_context *cmd_ctx,
struct target *target)
{
LOG_DEBUG("init");
RISCV_INFO(generic_info);
generic_info->get_register = &riscv013_get_register;
generic_info->set_register = &riscv013_set_register;
generic_info->get_register_buf = &riscv013_get_register_buf;
generic_info->set_register_buf = &riscv013_set_register_buf;
generic_info->select_current_hart = &riscv013_select_current_hart;
generic_info->is_halted = &riscv013_is_halted;
generic_info->resume_go = &riscv013_resume_go;
generic_info->step_current_hart = &riscv013_step_current_hart;
generic_info->on_halt = &riscv013_on_halt;
generic_info->resume_prep = &riscv013_resume_prep;
generic_info->halt_prep = &riscv013_halt_prep;
generic_info->halt_go = &riscv013_halt_go;
generic_info->on_step = &riscv013_on_step;
generic_info->halt_reason = &riscv013_halt_reason;
generic_info->read_debug_buffer = &riscv013_read_debug_buffer;
generic_info->write_debug_buffer = &riscv013_write_debug_buffer;
generic_info->execute_debug_buffer = &riscv013_execute_debug_buffer;
generic_info->fill_dmi_write_u64 = &riscv013_fill_dmi_write_u64;
generic_info->fill_dmi_read_u64 = &riscv013_fill_dmi_read_u64;
generic_info->fill_dmi_nop_u64 = &riscv013_fill_dmi_nop_u64;
generic_info->dmi_write_u64_bits = &riscv013_dmi_write_u64_bits;
generic_info->authdata_read = &riscv013_authdata_read;
generic_info->authdata_write = &riscv013_authdata_write;
generic_info->dmi_read = &dmi_read;
generic_info->dmi_write = &dmi_write;
generic_info->read_memory = read_memory;
generic_info->test_sba_config_reg = &riscv013_test_sba_config_reg;
generic_info->hart_count = &riscv013_hart_count;
generic_info->data_bits = &riscv013_data_bits;
generic_info->print_info = &riscv013_print_info;
generic_info->version_specific = calloc(1, sizeof(riscv013_info_t));
if (!generic_info->version_specific)
return ERROR_FAIL;
generic_info->sample_memory = sample_memory;
riscv013_info_t *info = get_info(target);
info->progbufsize = -1;
info->dmi_busy_delay = 0;
info->bus_master_read_delay = 0;
info->bus_master_write_delay = 0;
info->ac_busy_delay = 0;
/* Assume all these abstract commands are supported until we learn
 * otherwise.
 * TODO: The spec allows eg. one CSR to be able to be accessed abstractly
 * while another one isn't. We don't track that this closely here, but in
 * the future we probably should. */
info->abstract_read_csr_supported = true;
info->abstract_write_csr_supported = true;
info->abstract_read_fpr_supported = true;
info->abstract_write_fpr_supported = true;
info->has_aampostincrement = YNM_MAYBE;
return ERROR_OK;
}

initでは、riscv013の処理用の関数をgeneric_info構造体へセットしている。 generic_infoのRISC-V Debug specのバージョン非依存なインターフェイスを提供する。

今日はここまで。次回はexamineを読んで、examineの処理が通るようなDMを実装していく。

My RISC-V debug feature part5

Mon, 10 May 2021 22:21:40 +0900

仕様を読んでいるが、よくわからない。 hartselとかwindowみたいなのがあってよく分かりづらい。最小限の機能で、OpenOCDから制御できればいいので、 OpenOCDの初期化フローを読んで、それに応答するようなDM(Debug Module)を作ってみる。

OpenOCDの初期化

src/openocd.c

/* normally this is the main() function entry, but if OpenOCD is linked
 * into application, then this fn will not be invoked, but rather that
 * application will have it's own implementation of main(). */
int openocd_main(int argc, char *argv[])
{
int ret;
/* initialize commandline interface */
struct command_context *cmd_ctx;
cmd_ctx = setup_command_handler(NULL);
if (util_init(cmd_ctx) != ERROR_OK)
return EXIT_FAILURE;
if (ioutil_init(cmd_ctx) != ERROR_OK)
return EXIT_FAILURE;
if (rtt_init() != ERROR_OK)
return EXIT_FAILURE;
LOG_OUTPUT("For bug reports, read\n\t"
"http://openocd.org/doc/doxygen/bugs.html"
"\n");
command_context_mode(cmd_ctx, COMMAND_CONFIG);
command_set_output_handler(cmd_ctx, configuration_output_handler, NULL);
server_host_os_entry();
/* Start the executable meat that can evolve into thread in future. */
ret = openocd_thread(argc, argv, cmd_ctx);
flash_free_all_banks();
gdb_service_free();
server_free();
unregister_all_commands(cmd_ctx, NULL);
/* free all DAP and CTI objects */
dap_cleanup_all();
arm_cti_cleanup_all();
adapter_quit();
server_host_os_close();
/* Shutdown commandline interface */
command_exit(cmd_ctx);
rtt_exit();
free_config();
if (ERROR_FAIL == ret)
return EXIT_FAILURE;
else if (ERROR_OK != ret)
exit_on_signal(ret);
return ret;
}

/** OpenOCD runtime meat that can become single-thread in future. It parse
 * commandline, reads configuration, sets up the target and starts server loop.
 * Commandline arguments are passed into this function from openocd_main().
 */
static int openocd_thread(int argc, char *argv[], struct command_context *cmd_ctx)
{
int ret;
if (parse_cmdline_args(cmd_ctx, argc, argv) != ERROR_OK)
return ERROR_FAIL;
if (server_preinit() != ERROR_OK)
return ERROR_FAIL;
ret = parse_config_file(cmd_ctx);
if (ret == ERROR_COMMAND_CLOSE_CONNECTION) {
server_quit(); /* gdb server may be initialized by -c init */
return ERROR_OK;
} else if (ret != ERROR_OK) {
server_quit(); /* gdb server may be initialized by -c init */
return ERROR_FAIL;
}
ret = server_init(cmd_ctx);
if (ERROR_OK != ret)
return ERROR_FAIL;
if (init_at_startup) {
ret = command_run_line(cmd_ctx, "init");
if (ERROR_OK != ret) {
server_quit();
return ERROR_FAIL;
}
}
ret = server_loop(cmd_ctx);
int last_signal = server_quit();
if (last_signal != ERROR_OK)
return last_signal;
if (ret != ERROR_OK)
return ERROR_FAIL;
return ERROR_OK;
}

openocd_threadがメインになる様子。まず、command line argumentsをパースする。その後、コンフィグファイルをパースする。このコンフィグファイルは-fオプションで渡されるものであり、コマンドを一行ずつ実行していく。

コンフィグファイルのパースおよび実行

src/helper/configuration.c

int parse_config_file(struct command_context *cmd_ctx)
{
int retval;
char **cfg;
if (!config_file_names) {
command_run_line(cmd_ctx, "script openocd.cfg");
return ERROR_OK;
}
cfg = config_file_names;
while (*cfg) {
retval = command_run_line(cmd_ctx, *cfg);
if (retval != ERROR_OK)
return retval;
cfg++;
}
return ERROR_OK;
}

tcl/target/rv32xsoc.cfgの抜粋。

...
jtag newtap $_CHIPNAME cpu -irlen 10 -expected-id $_FPGATAPID
target create $_TARGETNAME riscv -endian $_ENDIAN -chain-position $_TARGETNAME

parse_config_fileによりパースされ、一行ずつ実行する。ここでは、target_createにフォーカスしてみていく。 target createのハンドラは以下のようになっている。

src/target/target.c

static const struct command_registration target_command_handlers[] = {
{
.name = "targets",
.handler = handle_targets_command,
.mode = COMMAND_ANY,
.help = "change current default target (one parameter) "
"or prints table of all targets (no parameters)",
.usage = "[target]",
},
{
.name = "target",
.mode = COMMAND_CONFIG,
.help = "configure target",
.chain = target_subcommand_handlers,
.usage = "",
},
{
.name = "enable_rtos_riscv",
.handler = handle_enable_rtos_riscv_command,
.mode = COMMAND_CONFIG,
.usage = "enable_rtos_riscv",
.help = "Allow the use of `-rtos riscv` for just a little longer, "
"until it will be completely removed at the end of 2020."
},
COMMAND_REGISTRATION_DONE
};

つまり、target命令の場合は次にくる引数がサブコマンドになる。サブコマンドは以下の通り。

src/target/target.c

static const struct command_registration target_subcommand_handlers[] = {
{
.name = "init",
.mode = COMMAND_CONFIG,
.handler = handle_target_init_command,
.help = "initialize targets",
.usage = "",
},
{
.name = "create",
.mode = COMMAND_CONFIG,
.jim_handler = jim_target_create,
.usage = "name type '-chain-position' name [options ...]",
.help = "Creates and selects a new target",
},
{
.name = "current",
.mode = COMMAND_ANY,
.jim_handler = jim_target_current,
.help = "Returns the currently selected target",
},
{
.name = "types", .mode = COMMAND_ANY, .jim_handler = jim_target_types, .help = "Returns the available target types as " "a list of strings", }, {
.name = "names",
.mode = COMMAND_ANY,
.jim_handler = jim_target_names,
.help = "Returns the names of all targets as a list of strings",
},
{
.name = "smp",
.mode = COMMAND_ANY,
.jim_handler = jim_target_smp,
.usage = "targetname1 targetname2 ...",
.help = "gather several target in a smp list"
},
COMMAND_REGISTRATION_DONE
};

今回はtarget createなので、jim_target_create関数が呼ばれることになる。この関数では、命令の引数を準備し、target_createを呼び出す。 src/target/target.c

static int jim_target_create(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
Jim_GetOptInfo goi;
Jim_GetOpt_Setup(&goi, interp, argc - 1, argv + 1);
if (goi.argc < 3) {
Jim_WrongNumArgs(goi.interp, goi.argc, goi.argv,
"<name> <target_type> [<target_options> ...]");
return JIM_ERR;
}
return target_create(&goi);
}

target createの引数を処理する。 src/target/target.c:create_target

static int target_create(Jim_GetOptInfo *goi)
{
Jim_Obj *new_cmd;
Jim_Cmd *cmd;
const char *cp;
int e;
int x;
struct target *target;
struct command_context *cmd_ctx;
cmd_ctx = current_command_context(goi->interp);
assert(cmd_ctx != NULL);
if (goi->argc < 3) {
Jim_WrongNumArgs(goi->interp, 1, goi->argv, "?name? ?type? ..options...");
return JIM_ERR;
}
...

src/target/target.c:create_target続き

 /* now does target type exist */
for (x = 0 ; target_types[x] ; x++) {
if (0 == strcmp(cp, target_types[x]->name)) {
/* found */
break;
}
/* check for deprecated name */
if (target_types[x]->deprecated_name) {
if (0 == strcmp(cp, target_types[x]->deprecated_name)) {
/* found */
LOG_WARNING("target name is deprecated use: \'%s\'", target_types[x]->name);
break;
}
}
}

この部分で、以下のtclのriscvを処理している。 target create $_TARGETNAME riscv -endian $_ENDIAN -chain-position $_TARGETNAME target_types[]からriscvに対応する、ターゲットを探し出す。

src/target/target.c

static struct target_type *target_types[] = {
&arm7tdmi_target,
&arm9tdmi_target,
&arm920t_target,
&arm720t_target,
...
&riscv_target,
...

src/target/target.c:target_create続き

 /* Create it */
target = calloc(1, sizeof(struct target));
if (!target) {
LOG_ERROR("Out of memory");
return JIM_ERR;
}
/* set target number */
target->target_number = new_target_number();
/* allocate memory for each unique target type */
target->type = malloc(sizeof(struct target_type));
if (!target->type) {
LOG_ERROR("Out of memory");
free(target);
return JIM_ERR;
}
memcpy(target->type, target_types[x], sizeof(struct target_type));

target_configure関数で-endianや-chain-positionを処理をする。

src/target/target.c:target_create続き

 e = target_configure(goi, target);
if (e == JIM_OK) {
if (target->has_dap) {
if (!target->dap_configured) {
Jim_SetResultString(goi->interp, "-dap ?name? required when creating target", -1);
e = JIM_ERR;
}
} else {
if (!target->tap_configured) {
Jim_SetResultString(goi->interp, "-chain-position ?name? required when creating target", -1);
e = JIM_ERR;
}
}
/* tap must be set after target was configured */
if (target->tap == NULL)
e = JIM_ERR;
}

また、この時点では(target_create)、TAPが設定されていることが期待されている(-chain-positionで指定)。上のコードで確認している。

src/target/target.c:target_create続き

 if (target->type->target_create) {
e = (*(target->type->target_create))(target, goi->interp);
if (e != ERROR_OK) {
LOG_DEBUG("target_create failed");
free(target->cmd_name);
rtos_destroy(target);
free(target->gdb_port_override);
free(target->trace_info);
free(target->type);
free(target);
return JIM_ERR;
}
}
/* create the target specific commands */
if (target->type->commands) {
e = register_commands(cmd_ctx, NULL, target->type->commands);
if (ERROR_OK != e)
LOG_ERROR("unable to register '%s' commands", cp);
}

ここで、ターゲット(riscv)のtarget_createを呼び出す。その後、ターゲットspecificなコマンドを登録する。

riscv用のtarget_createを読んで見る。

以下がtarget_typesから取り出した、ターゲットspecificな構造体の実態である。 ../src/target/riscv/riscv.c

struct target_type riscv_target = {
.name = "riscv",
.target_create = riscv_create_target,
.init_target = riscv_init_target,
.deinit_target = riscv_deinit_target,
.examine = riscv_examine,

riscv_create_targetが呼び出されることになる。 ../src/target/riscv/riscv.c

static int riscv_create_target(struct target *target, Jim_Interp *interp)
{
LOG_DEBUG("riscv_create_target()");
target->arch_info = calloc(1, sizeof(riscv_info_t));
if (!target->arch_info)
return ERROR_FAIL;
riscv_info_init(target, target->arch_info);
return ERROR_OK;
}

../src/target/riscv/riscv.c

/*** RISC-V Interface ***/
void riscv_info_init(struct target *target, riscv_info_t *r)
{
memset(r, 0, sizeof(*r));
r->dtm_version = 1;
r->registers_initialized = false;
r->current_hartid = target->coreid;
r->version_specific = NULL;
memset(r->trigger_unique_id, 0xff, sizeof(r->trigger_unique_id));
r->xlen = -1;
r->mem_access_methods[0] = RISCV_MEM_ACCESS_PROGBUF;
r->mem_access_methods[1] = RISCV_MEM_ACCESS_SYSBUS;
r->mem_access_methods[2] = RISCV_MEM_ACCESS_ABSTRACT;
r->mem_access_progbuf_warn = true;
r->mem_access_sysbus_warn = true;
r->mem_access_abstract_warn = true;
INIT_LIST_HEAD(&r->expose_csr);
INIT_LIST_HEAD(&r->expose_custom);
}

initコマンド

ターゲットの作成が終わったら、サーバーを建てる。そのあと、initコマンドを実行する。

src/openocd.c:openocd_thread抜粋

 ret = server_init(cmd_ctx);
if (ERROR_OK != ret)
return ERROR_FAIL;
if (init_at_startup) {
ret = command_run_line(cmd_ctx, "init");
if (ERROR_OK != ret) {
server_quit();
return ERROR_FAIL;
}
}

src/openocd.c

static const struct command_registration openocd_command_handlers[] = {
{
.name = "version",
.jim_handler = jim_version_command,
.mode = COMMAND_ANY,
.help = "show program version",
},
{
.name = "noinit",
.handler = &handle_noinit_command,
.mode = COMMAND_CONFIG,
.help = "Prevent 'init' from being called at startup.",
.usage = ""
},
{
.name = "init",
.handler = &handle_init_command,
.mode = COMMAND_ANY,
.help = "Initializes configured targets and servers. "
"Changes command mode from CONFIG to EXEC. "
"Unless 'noinit' is called, this command is "
"called automatically at the end of startup.",
.usage = ""
},
{
.name = "add_script_search_dir",
.handler = &handle_add_script_search_dir_command,
.mode = COMMAND_ANY,
.help = "dir to search for config files and scripts",
.usage = "<directory>"
},
COMMAND_REGISTRATION_DONE
};

initコマンドはhandle_init_commandが対処する。

src/openocd.c

/* OpenOCD can't really handle failure of this command. Patches welcome! :-) */
COMMAND_HANDLER(handle_init_command)
{
if (CMD_ARGC != 0)
return ERROR_COMMAND_SYNTAX_ERROR;
int retval;
static int initialized;
if (initialized)
return ERROR_OK;
initialized = 1;
retval = command_run_line(CMD_CTX, "target init");
if (ERROR_OK != retval)
return ERROR_FAIL;
retval = adapter_init(CMD_CTX);
if (retval != ERROR_OK) {
/* we must be able to set up the debug adapter */
return retval;
}
LOG_DEBUG("Debug Adapter init complete");
/* "transport init" verifies the expected devices are present;
 * for JTAG, it checks the list of configured TAPs against
 * what's discoverable, possibly with help from the platform's
 * JTAG event handlers. (which require COMMAND_EXEC)
 */
command_context_mode(CMD_CTX, COMMAND_EXEC);
retval = command_run_line(CMD_CTX, "transport init");
if (ERROR_OK != retval)
return ERROR_FAIL;
retval = command_run_line(CMD_CTX, "dap init");
if (ERROR_OK != retval)
return ERROR_FAIL;
LOG_DEBUG("Examining targets...");
if (target_examine() != ERROR_OK)
LOG_DEBUG("target examination failed");
command_context_mode(CMD_CTX, COMMAND_CONFIG);
if (command_run_line(CMD_CTX, "flash init") != ERROR_OK)
return ERROR_FAIL;
if (command_run_line(CMD_CTX, "nand init") != ERROR_OK)
return ERROR_FAIL;
if (command_run_line(CMD_CTX, "pld init") != ERROR_OK)
return ERROR_FAIL;
command_context_mode(CMD_CTX, COMMAND_EXEC);
/* initialize telnet subsystem */
gdb_target_add_all(all_targets);
target_register_event_callback(log_target_callback_event_handler, CMD_CTX);
return ERROR_OK;
}

ここでは、以下の順でコマンドと関数を実行する。

init
adapter_init();
transport init
dap init
target_examine();
flash init
nand init
pld init

initでは、riscv固有の初期化をする。 adapter_init(), transport init, dap initでJTAGの初期化をしている？ target_examineでは、RISC-V Debug DMが存在し、正しいステータスを返すかテストしているっぽい。次は、これらを詳しくみていく。なお、flash init、nand init、pld initは見なくて良さそうなのでとりあえず放置する。

My RISC-V debug feature part4

Sun, 09 May 2021 23:05:20 +0900

これから、DM(Debug Module)の実装をおこない、VJTAGを通して、OpenOCDと情報をやりとりできるかを確認していく。まずは、かんたんな実装から始める。参照しているspecのバージョンはv0.13である。

機能

対象のHartsの選択
Halt/Resume
Abstracts commands
Program buffer
ステップ実行
トリガー
リセットなどが挙げられる。なお、Debuggerが介入してきた場合は、hartはD-Mode(Debug Mode)で動作を行う。 D-Modeでは、基本的にはM-Modeと同じだが、割り込みが無効になり、例外はデバッガが対処を行う。また、デバッカーから命令が供給されるまで、haltする。

全体像

実線で囲まれている部分は実装が必須であり、点線で囲まれている部分は実装するかは任意である。今回は、実線の部分のみ実装する。なお、DTMに関してはほとんど前回までで実装が完了している。また、VJTAGおよびDTM、DMはTCK(VJTAGのクロックドメイン)で動作している。そこで、hart <-> DM間にクロックドメインクロッシングの機構を用意する。念の為記しておくが、System busへのアクセスは実装しないが、System busはm_clockドメインで動作している。

CSRs

dcsr
dpc
dscratch(0..N)

うち、dpc, dscratchはXLEN bitであり、dcsrは最長2**3ビットである。

今回実装する機能

Ver1

hartの選択
(halt中の)GPRsに対するアクセス
hartのリセット(resetvectorからの再実行)
いくつかのAbstarct Commands
halt/resume

ver2

ステップ実行
Triggers
Program Buffer

とりあえず、ver1を実装する。 Spikeや他のRTLによる実装を参考に実装していく。次回からは、hartの選択、halt、GPRsへのアクセスを実装する。内容が薄いが今回はここまで。

付録 Spikeのビルド

git clone --recursive https://github.com/riscv/riscv-isa-sim
cd riscv-isa-sim
mkdir build
cd build
../configure --prefix=$RISCV --enable-commitlog --enable-histogram
make -j $(nproc)
make install

これで、デバックモードの機能を扱うことができる。

参考

ドキュメント・スペック
実装
- Spike
- https://github.com/aquaxis/riscv_debug

My RISC-V debug feature part3

Tue, 20 Apr 2021 22:55:05 +0900

OpenOCD RISC-VにVJTAGのサポートを行う。 OpenOCDにて、VJTAG on DE10-Liteにアクセスしてみる。

OpenOCDのVJTAGサポート状況

or1kはVJTAGに対応している。この実装を理解して、OpenOCD RISC-Vへ移植をする。

OpenOCD VJTAG support (or1kの実装を読解する)

まず、or1kでどのようにVJTAGを使っているのか確かめる。そのために、cfgファイルを読む。

tcl/target/or1k.cfg

set _ENDIAN big
if { [info exists CHIPNAME] } {
set _CHIPNAME $CHIPNAME
} else {
set _CHIPNAME or1k
}
if { [info exists TAP_TYPE] } {
set _TAP_TYPE $TAP_TYPE
} else {
puts "You need to select a tap type"
shutdown
}
# Configure the target
if { [string compare $_TAP_TYPE "VJTAG"] == 0 } {
if { [info exists FPGATAPID] } {
set _FPGATAPID $FPGATAPID
} else {
puts "You need to set your FPGA JTAG ID"
shutdown
}
jtag newtap $_CHIPNAME cpu -irlen 10 -expected-id $_FPGATAPID
set _TARGETNAME $_CHIPNAME.cpu
target create $_TARGETNAME or1k -endian $_ENDIAN -chain-position $_TARGETNAME
# Select the TAP core we are using
 tap_select vjtag
}

tap_select vjtagにてVJTAGをTAPとして選択するようである。 tap_selectコマンドはor1k向けに定義されたものであるため、targetコマンドでor1kを選択してからでないと使用することができない。

tap_select命令をまず、RISC-V向けに移植したい。

tap_select命令の移植

src/target/openrisc/or1k.c

static const struct command_registration or1k_hw_ip_command_handlers[] = {
{
.name = "tap_select",
.handler = or1k_tap_select_command_handler,
.mode = COMMAND_ANY,
.usage = "name",
.help = "Select the TAP core to use",
},

src/target/openrisc/or1k.c

COMMAND_HANDLER(or1k_tap_select_command_handler)
{
struct target *target = get_current_target(CMD_CTX);
struct or1k_common *or1k = target_to_or1k(target);
struct or1k_jtag *jtag = &or1k->jtag;
struct or1k_tap_ip *or1k_tap;
if (CMD_ARGC != 1)
return ERROR_COMMAND_SYNTAX_ERROR;
list_for_each_entry(or1k_tap, &tap_list, list) {
if (or1k_tap->name) {
if (!strcmp(CMD_ARGV[0], or1k_tap->name)) {
jtag->tap_ip = or1k_tap;
LOG_INFO("%s tap selected", or1k_tap->name);
return ERROR_OK;
}
}
}
LOG_ERROR("%s unknown, no tap selected", CMD_ARGV[0]);
return ERROR_COMMAND_SYNTAX_ERROR;
}

tap_selectコマンドは、or1k_tap_select_command_handlerが対処する。 tap_selectコマンドの第一引数にあるインターフェースを使用する。 VJTAGを選択した場合を見てみる。

src/target/openrisc/or1k_tap_vjtag.cで実装されている。 or1k_tap_vjtag_initが初期化用の処理である。

 jtag_add_tlr();

まずは、TAPを初期状態にする。

 uint8_t t[4] = { 0 };
struct scan_field field;
struct jtag_tap *tap = jtag_info->tap;
/* Select VIR */
buf_set_u32(t, 0, tap->ir_length, ALTERA_CYCLONE_CMD_USER1);
field.num_bits = tap->ir_length;
field.out_value = t;
field.in_value = NULL;
jtag_add_ir_scan(tap, &field, TAP_IDLE);

その後、sld_hubのIRをUSER1にする。この操作で、Select_IRを行い、Shift_IRにて、sld_hubのIRにUSER1のコード(0xE, 10 bit)を書き込む。

次に、DR Shiftを行う。 USER1レジスタのフォーマットは以下のようになっている。ただし、nはCEIL(log2(Number of SLD_nodes + 1))である。 mは各VIRの長さの最大値である。 sld_hubには以下のレジスタがある。

SLD HUB IP Configuration Register
- sld_hubに接続されているsld_nodeの情報や、USER1 DRの寸法がわかる。
各sld_hubのSLD_NODE_INFOレジスタ
- indexとアドレスのマッピングがわかる HUB_INFO命令を使用し、HUB IP Configuration Registerを読み出す。また、各sld_nodeのアドレスマッピングを保持している、SLD_NODE_INFOレジスタがある。ただし、この時点でsld_hubに接続されたsld_nodeの数がわからない。また、n, mについてもわからない状態である。そこで、USER1 DRをゼロで埋める。 nがわからないが、64回シフトすれば大体の場合は十分である。

 /* Select the SLD Hub */
field.num_bits = 64;
field.out_value = NULL;
field.in_value = NULL;
jtag_add_dr_scan(tap, 1, &field, TAP_IDLE);

次に、Select_DRにて、DR(SLD HUB Configuration register)を選択する。

 /* Select VDR */
buf_set_u32(t, 0, tap->ir_length, ALTERA_CYCLONE_CMD_USER0);
field.num_bits = tap->ir_length;
field.out_value = t;
field.in_value = NULL;
jtag_add_ir_scan(tap, &field, TAP_IDLE);
int retval = jtag_execute_queue();
if (retval != ERROR_OK)
return retval;

jtag_execute_queueにて、JTAGコマンドを実行する。

次に、SLD HUB Configuration registerを読み出す。レジスタのフォーマットは以下のとおりである。 8つのnibbleのフィールドからなるレジスタであり、nibble単位での読み出しが必須となる。:w 次のnibbleを読み出す前に、UPDATE_DRをする必要がある。そこで、読み出しごとにjtag_execute_queueを行う。

 uint8_t nibble;
uint32_t hub_info = 0;
for (int i = 0; i < 8; i++) {
field.num_bits = 4;
field.out_value = NULL;
field.in_value = &nibble;
jtag_add_dr_scan(tap, 1, &field, TAP_IDLE);
retval = jtag_execute_queue();
if (retval != ERROR_OK)
return retval;
hub_info = ((hub_info >> 4) | ((nibble & 0xf) << 28));
}
int nb_nodes = NB_NODES(hub_info);
int m_width = M_WIDTH(hub_info);
LOG_DEBUG("SLD HUB Configuration register");
LOG_DEBUG("------------------------------");
LOG_DEBUG("m_width = %d", m_width);
LOG_DEBUG("manufacturer_id = 0x%02" PRIx32, MANUF(hub_info));
LOG_DEBUG("nb_of_node = %d", nb_nodes);
LOG_DEBUG("version = %" PRIu32, VER(hub_info));
LOG_DEBUG("VIR length = %d", guess_addr_width(nb_nodes) + m_width);

これで、sld_nodeの数、m, nのサイズ、VIRのサイズなどがわかった。

次に、インデックス(VJTAGのインスタンス時にユーザもしくはQuartusが割当)からアドレスへのマッピングを調べる。 SLD_NODE info Registerに情報が格納されており、sld_nodeの数分存在する。このレジスタも同様に8つのnibbleからなる。つまり、ノードの数 * (8 * nibble)回シフトが必要である。

 int vjtag_node_address = -1;
int node_index;
uint32_t node_info = 0;
for (node_index = 0; node_index < nb_nodes; node_index++) {
for (int i = 0; i < 8; i++) {
field.num_bits = 4;
field.out_value = NULL;
field.in_value = &nibble;
jtag_add_dr_scan(tap, 1, &field, TAP_IDLE);
retval = jtag_execute_queue();
if (retval != ERROR_OK)
return retval;
node_info = ((node_info >> 4) | ((nibble & 0xf) << 28));
}
LOG_DEBUG("Node info register");
LOG_DEBUG("--------------------");
LOG_DEBUG("instance_id = %" PRIu32, ID(node_info));
LOG_DEBUG("manufacturer_id = 0x%02" PRIx32, MANUF(node_info));
LOG_DEBUG("node_id = %" PRIu32 " (%s)", ID(node_info),
id_to_string(ID(node_info)));
LOG_DEBUG("version = %" PRIu32, VER(node_info));
if (ID(node_info) == VJTAG_NODE_ID)
vjtag_node_address = node_index + 1;
}
if (vjtag_node_address < 0) {
LOG_ERROR("No VJTAG TAP instance found !");

これでアドレスがわかった。次に、sld_nodeのインスタンスのVIR, VDRにアクセスをする。

まず、USER1命令を発行する。これにより、IR chainが選択される。

 /* Select VIR */
buf_set_u32(t, 0, tap->ir_length, ALTERA_CYCLONE_CMD_USER1);
field.num_bits = tap->ir_length;
field.out_value = t;
field.in_value = NULL;
jtag_add_ir_scan(tap, &field, TAP_IDLE);

次に、sld_nodeのVIRに命令を送る。この場合はDEBUG命令を転送している。これは、or1kのデバックモードの命令の様子。なお、転送サイズはアドレスのサイズ+VIRのサイズである。 VIRの前に、Addressを付与する。フォーマットを以下に示す。

/* Send the DEBUG command to the VJTAG IR */
int dr_length = guess_addr_width(nb_nodes) + m_width;
buf_set_u32(t, 0, dr_length, (vjtag_node_address << m_width) | ALT_VJTAG_CMD_DEBUG);
field.num_bits = dr_length;
field.out_value = t;
field.in_value = NULL;
jtag_add_dr_scan(tap, 1, &field, TAP_IDLE);

最後に、USER0命令を発行して、DR chainに切り替える。これにより、後続のShift_DEは、USER1命令でセットした、Addrを用いてsld_nodeのインスタンスに転送される。なお、or1kの場合では、VIRをDEBUGから変えることはないようである。しかし、VIRを変える場合は、USER1を発行して、ADDR+VIRを転送し、USER0へ切り替えるという手順が必要となる。この切り替え部分をRISC-VのOpenOCDへ追加する必要がある。 DRのアクセスは切り替えが正しくできていれば、問題ないはずである。

/* Select the VJTAG DR */
buf_set_u32(t, 0, tap->ir_length, ALTERA_CYCLONE_CMD_USER0);
field.num_bits = tap->ir_length;
field.out_value = t;
field.in_value = NULL;
jtag_add_ir_scan(tap, &field, TAP_IDLE);
return jtag_execute_queue();
}

OpenOCD VJTAG support

詳しい追加はkoyamanX/riscv-openocd にある、 src/target/riscv/riscv_tap_vjtag.cを確認してほしい。初期化用のコードは、or1k_tap_vjtag_initをそのまま流用する。関数名をriscv_tap_vjtag_initとする。また、DEBUGレジスタの指定を、DTMCSレジスタの指定に変更する。これで初期化は十分である。一部、変数(nb_nodesなど)を雑にグローバル変数にした。また、VIRの書き込み用の関数を別に定義した。

src/target/riscv/riscv_tap_vjtag.c

int vjtag_vir_scan(struct jtag_tap *tap, uint32_t vir_val)
{
uint8_t t[4] = { 0 };
struct scan_field field;
/* Select VIR chain */
buf_set_u32(t, 0, tap->ir_length, ALTERA_CYCLONE_CMD_USER1);
field.num_bits = tap->ir_length;
field.out_value = t;
field.in_value = NULL;
jtag_add_ir_scan(tap, &field, TAP_IDLE);
/* Set VIR Value to the VIR of sld_node determined by vjtag_node_address */
int dr_length = guess_addr_width(nb_nodes) + m_width;
buf_set_u32(t, 0, dr_length, (vjtag_node_address << m_width) | vir_val);
field.num_bits = dr_length;
field.out_value = t;
field.in_value = NULL;
jtag_add_dr_scan(tap, 1, &field, TAP_IDLE);
/* Select the VJTAG DR chain */
buf_set_u32(t, 0, tap->ir_length, ALTERA_CYCLONE_CMD_USER0);
field.num_bits = tap->ir_length;
field.out_value = t;
field.in_value = NULL;
jtag_add_ir_scan(tap, &field, TAP_IDLE);
return jtag_execute_queue();
}

src/target/riscv/riscv.cを変更し、targetの初期化の際に、ついでにriscv_tap_vjtag_initを呼び出すことにした。また、use_vjtagフラグで、VJTAGを使用するかをハードコードした。本来は、このフラグをtap_selectのような命令で変更できるようにするべきである。しかし、target固有のコマンドはtargetの初期化が終わっていこうに使えるようになる。ただし、target初期化の処理は、examine(JTAGでDebug Moduleへアクセスし、dmactiveを取得する)が成功したら正しく完了したこととなる。 VJTAGを用いたアクセスでないため、必ず失敗する。そこで、とりあえず、動けばいいという適当な考えで、ハードコードしてしまった。正しく動くことが確認できたら、しっかりと対応しテストしてPRを出したいね。

通信テスト

VJTAGとOpenOCDでやり取りをする。適当なDebug Moduleのような回路を書く。コードはkoyamanX/riscv-openocd にある。なお、DM(Debug Module)やDTM(Debug Transport Module)はJTAGのTCKのクロックドメインで動作していることに注意。プロセッサと接続するためには、適切にCDC(Clock Domain Crossing)を行う必要がある。また、DMに関しては、まだスタブである。

src/dtm.nsl

#ifndef DTM_H
#define DTM_H

/* This module design to run in TCK in JTAG clock domain */
/* m_clock must be connected to TCK of JTAG */
#define IDCODE 5'b00001
#define DTMCS 5'b10000
#define DMI 5'b10001
#define BYPASS 5'b11111

#define DTMCS_VERSION 4'b0001
#define DTMCS_ABITS 6'b100000

#define DMI_NOP 2'b00
#define DMI_READ 2'b01
#define DMI_WRITE 2'b10
#define DMI_RESERVED 2'b11

#define DMI_STAT_SUCCESS 2'b00
#define DMI_STAT_RESERVED 2'b01
#define DMI_STAT_FAILURE 2'b10
#define DMI_STAT_INPROGRESS 2'b11

struct dtmcs_t {
zero1[14];
dmihardreset[1];
dmireset[1];
zero0[1];
idle[3];
dmistat[2];
abits[6];
version[4];
};
struct dmi_t {
addr[32];
data[32];
op[2];
};
declare dtm interface {
input m_clock;
input p_reset;
input ir_in[5];
output ir_out[5];
input tdi;
output tdo;
func_in virtual_state_cdr;
func_in virtual_state_sdr;
func_in virtual_state_e1dr;
func_in virtual_state_pdr;
func_in virtual_state_e2dr;
func_in virtual_state_udr;
func_in virtual_state_cir;
func_in virtual_state_uir;
/* DMI */
output addr[32];
input rdata[32];
output wdata[32];
func_out read(addr);
func_out write(addr, wdata);
func_in ready();
#ifdef DEBUG
 output debug_out[32];
#endif
}
#endif

src/dtm.nsl

#include "dtm.h"

module dtm {
reg ir[5] = IDCODE; /* IDECODE (defined by spec) */
reg idcode[32] = 0x10e31913; /* same as SiFive's */
reg bypass = 0;
/* DTMCS register */
dtmcs_t reg dtmcs = {14'b00000000000000, 1'b0, 1'b0, 1'b0, 3'b000, 2'b00, DTMCS_ABITS, DTMCS_VERSION};
/* DTMCS internal register for read via dtmcs(Capture-DR) */
reg dtmcs_dmistat[2] = 0;
reg dtmcs_idle[3] = 0;
reg dtmcs_dmireset = 0;
reg dtmcs_dmihardreset = 0;
/* DMI register */
dmi_t reg dmi = 0;
/* DMI internal register for read via dmi(Capture-DR) */
reg dmi_op_stat[2] = 0;
reg dmi_addr[32] = 0;
reg dmi_data[32] = 0;
func virtual_state_uir {
ir := ir_in;
}
func virtual_state_cir {
ir_out = IDCODE;
}
func virtual_state_udr {
/* At this point, we can issue abstarct command */
any {
ir == DTMCS: {
/* TODO: Implement hardreset */
if(dtmcs.dmihardreset) {
dtmcs_dmireset := 0;
} else if(dtmcs.dmireset) {
dtmcs_dmireset := 0;
dmi_op_stat := 0;
}
}
ir == DMI: {
any {
dmi.op == DMI_NOP: {dmi_op_stat := DMI_STAT_SUCCESS;}
dmi.op == DMI_READ: {
dmi_addr := dmi.addr;
read(dmi.addr);
}
dmi.op == DMI_WRITE: {
dmi_addr := dmi.addr;
dmi_data := dmi.data;
write(dmi.addr, dmi.data);
}
dmi.op == DMI_RESERVED: {dmi_op_stat := DMI_STAT_FAILURE;}
}
}
}
}
func ready {
dmi_data := rdata;
dmi_op_stat := DMI_STAT_SUCCESS;
}
func virtual_state_cdr {
any {
ir == DTMCS: dtmcs := {14'(1'b0), dtmcs_dmihardreset, dtmcs_dmireset, 1'b0,
dtmcs_idle, dtmcs_dmistat, DTMCS_ABITS, DTMCS_VERSION};
ir == DMI: dmi := {dmi_addr, dmi_data, dmi_op_stat};
ir == IDCODE: idcode := 0x10e31913;
ir == BYPASS: bypass := 1'b0;
else: bypass := 1'b0;
}
}
func virtual_state_sdr {
any {
ir == DTMCS: dtmcs := {tdi, dtmcs[31:1]};
ir == DMI: dmi := {tdi, dmi[65:1]};
ir == IDCODE: idcode := {tdi, idcode[31:1]};
ir == BYPASS: bypass := tdi;
else: bypass := tdi;
}
}
any {
ir == DTMCS: tdo = dtmcs[0];
ir == DMI: tdo = dmi[0];
ir == BYPASS: tdo = bypass;
ir == IDCODE: tdo = idcode[0];
else: tdo = bypass;
}
#ifdef DEBUG
 debug_out = dtmcs;
#endif
}

src/dm.h

#ifndef DM_H
#define DM_H
/* Runs in same clock domain as DTM and output to hart must be
 synchronized to hart's clock domain */
declare dm interface {
input p_reset;
input m_clock;
/* DMI */
input addr[32];
input wdata[32];
output rdata[32];
func_in read(addr);
func_in write(addr, wdata);
func_out ready();
#ifdef DEBUG
 output debug_out[32];
#endif
}
#endif

src/dm.nsl

#include "dm.h"
module dm {
reg dmcontrol[32] = 0;
func write {
any {
addr == 0x10: dmcontrol := wdata;
}
ready();
}
func read {
any {
addr == 0x10: rdata = dmcontrol;
}
ready();
}
#ifdef DEBUG
 debug_out = dmcontrol;
#endif
}

#include "vjtag.h"
#include "dtm.h"
#include "dm.h"

declare DE10 {
input SW[10];
output LEDR[10];
}
module DE10 {
vjtag vjtag0;
dtm riscv_dtm;
dm riscv_dm;
riscv_dtm.m_clock = vjtag0.tck;
riscv_dtm.p_reset = p_reset;
riscv_dtm.ir_in = vjtag0.ir_in;
vjtag0.ir_out = riscv_dtm.ir_out;
riscv_dtm.tdi = vjtag0.tdi;
vjtag0.tdo = riscv_dtm.tdo;
riscv_dm.m_clock = vjtag0.tck;
riscv_dm.p_reset = p_reset;
func vjtag0.virtual_state_cdr {
riscv_dtm.virtual_state_cdr();
}
func vjtag0.virtual_state_sdr {
riscv_dtm.virtual_state_sdr();
}
func vjtag0.virtual_state_udr {
riscv_dtm.virtual_state_udr();
}
func vjtag0.virtual_state_cir {
riscv_dtm.virtual_state_cir();
}
func vjtag0.virtual_state_uir {
riscv_dtm.virtual_state_uir();
}
func riscv_dtm.read {
riscv_dm.read(riscv_dtm.addr);
}
func riscv_dtm.write {
riscv_dm.write(riscv_dtm.addr, riscv_dtm.wdata);
}
func riscv_dm.ready {
riscv_dtm.rdata = riscv_dm.rdata;
riscv_dtm.ready();
}
#ifdef DEBUG
 any {
SW == 0: LEDR = riscv_dtm.debug_out;
SW == 1: LEDR = riscv_dm.debug_out;
else: LEDR = 0xffffffff;
}
#endif
}

動作確認

koyamanX/riscv-openocd

ツールのビルド

sudo apt install libftdi1-dev
git clone --recursive https://github.com/koyamanX/riscv-debug #riscv-vjtag branch(by default)
cd riscv-debug/riscv-openocd
git submodule update --init --recursive
./bootstrap
mkdir build
cd build
../configure --prefix=/opt/riscv-openocd
make -j $(nproc)
sudo make install

rv32xsoc.cfg

set _ENDIAN little
set _CHIPNAME riscv
set _FPGATAPID 0x031050dd
set _TARGETNAME $_CHIPNAME.cpu
adapter driver usb_blaster
usb_blaster_lowlevel_driver ftdi
jtag newtap $_CHIPNAME cpu -irlen 10 -expected-id $_FPGATAPID
target create $_TARGETNAME riscv -endian $_ENDIAN -chain-position $_TARGETNAME
#use_vjtag

FPGA(DE10-Lite)へ実装

cd riscv-debug/fpga
make all
make download

テスト

sudo /opt/riscv-openocd/bin/openocd -f ../tcl/target/rv32xsoc.cfg

実行結果

dmactiveに成功している。(dmcontrolの0ビット目) dmstatusのリードに失敗しているが、実装していないので期待通り。

次からは、DMの仕様読みと実装を行う。

My RISC-V debug feature part2

Sat, 17 Apr 2021 11:21:32 +0900

今回はIntel FPGAのVJTAGのIPを試してみる。 FPGAボードはDE10 Liteを使用する。

JTAG(Joint Test Action Group)

JTAGについては以下のサイトがわかりやすい。

JTAGを用いると、ICの端子を操作したり、ICの内部と通信ができるようになる。もともと、JTAGはICの端子を操作するバウンダリースキャンのために作られたようである。 IEEE1149.1は4本の信号線でIC内部と通信するための、プロトコルを定めた規格である。今回は、バウンダリースキャンは行わない。プロセッサの内部の状態をriscv-debug-specに沿って操作することを目標とする。なお、riscv-debug-specでは、Debug Transport(情報のやり取り)には規定はないが、JTAGの例が乗っている。例に乗っ取り、今回は、JTAGを用いる。

JTAGはIRレジスタとDRレジスタがある。これらはシフトレジスタであり、Shift-IR, Shift-DRにてシフトする。 IRは主にDRの命令(アドレス)を保持する。 IRは最低2ビット必要である。

実装の必須な命令は以下である。

BYPASS
SAMPLE
PRELOAD
EXTEST

オプションな命令

IDCODE

今回使用する命令

BYPASS
IDCODE なお、バウンダリースキャンはサポートしない。

なお、IRレジスタを読み出すときは、前回の値でなくステータスが帰る。ステータスは下位２ビットが01であること以外は実装定義である。 DRはIRによって選択する。 DRの長さは実装定義で、制御用のソフトウエアはシフト回数を適切に行う必要がある。なお、仕様で規定されている必須のDRが存在する。

IDCODE(IR: 任意)
- JTAGのIDコードを保持する(32 bit)
BYPASS(IR: すべてのビットが１)
- 1 bitのレジスタ
- 実装していない命令などはこちらへ書き込むことが推奨されている

JTAG信号線

TCK (Test Clock)
- クロック信号
TMS (Test Mode Select)
- 次のステートを決める
- 5回以上1を入力するとリセットすることができる
- TCKの立ち上がりエッジ
TDI (Test Data-In)
- データ入力
- TCKの立ち上がりエッジ
TDO (Test Data-Out)
- データ出力
- TCKの立ち下がりエッジ

State machine of JTAG TAP

JTAGの状態はTAP(Test Access Port)が管理する。 16のステートを持ち、現在の状態とTMSにより次のステートが決まる。ステートマシン図を以下に示す。

Select

Select_IRの場合は、IRをオペレーション対象とする。 Select_DRの場合は、DR Chainを選択し、IRにて、各DRを選択する。

Shift

Shift_DR, Shift_IRにてシフトレジスタをシフトする。 Shift_DRの場合は、IRの値に応じて、DRが選択され、シフトされる。 TDIはMSBへ、LSBはTDOへ接続される。 Shift_IRはIRをシフトする。 TDIはMSBへ、ステータス(IRの値ではないことに注意)のLSBはTDOへ接続される。

Capture

Capture_DRでは、IRで選択する、DRにパラレルで値を代入する。 Capture_IRでは、IRへパラレルで値を代入する。処理の結果やステート、初期値などをこのステートでDR/IRへ転送する。

Update

Updateでは、並列でDRもしくはIRの値を内部ロジックへコピーする。なにか、処理をする場合はこのステートで実行する。(RISC-V DebugのDTMにおけるDMI Write・Readなど)

重要なステートはUpdate, Capture, Shift、Selectである。なお、アプリケーションはDRの長さや現在の値、ステートについてしっかり把握して制御する必要がある。ステートに関して、どのステートからでも、TMSを５回以上1にしておくことで初期状態へ戻ることができる。

Virtual JTAG

今回はVJTAGのIPを使用する。 VJTAGを用いると、Download Cable(USB-Blaster)を用いて、FPGAとPC間のJTAG通信ができる。 VJTAGとJTAGの違いは、あまりなく、実際はJTAGと同じ制御をしている。しかし、VJTAGのインスタンスは最大255個作成できるため、これらを識別する機能が必要である。各インスタンスにはユニークなインデックス(アドレス)が割り当てられ(ユーザが指定可能、指定しない場合はQuartusが合成時に自動割当）これを用いて、識別する。 FPGAのデザイン内で、通信のルーティングを行う仕組みとして、sld_hubがぞんざいする。各VJTAGのインスタンスはsld_nodeとなり、sld_hubに接続される。以下にブロック図を示す。ここより引用よって、アプリケーションはsld_hubを介して、ユーザロジックのVJTAGインスタンス(sld_node)へアクセスする。なお、１つしかインスタンスが存在しない場合でも、sld_hubは生成される。また、sld_node, sld_hubはLEs(Logic Element)を消費する。 JTAG TAPは物理ハードウェアとして実装されている。以下に、sld_hubおよびsld_nodeの内部ブロック図を図示する。

IPのドキュメントは以下のリンクより閲覧できる。

Virtual JTAGのインスタンスの作成

Quartus Megafunctionを使って、Virtual JTAGのインスタンスファイル？を作る。

// vjtag.v

// Generated using ACDS version 20.1 711

`timescale 1 ps / 1 ps
module vjtag (
output wire tdi, // jtag.tdi
 input wire tdo, // .tdo
 output wire [4:0] ir_in, // .ir_in
 input wire [4:0] ir_out, // .ir_out
 output wire virtual_state_cdr, // .virtual_state_cdr
 output wire virtual_state_sdr, // .virtual_state_sdr
 output wire virtual_state_e1dr, // .virtual_state_e1dr
 output wire virtual_state_pdr, // .virtual_state_pdr
 output wire virtual_state_e2dr, // .virtual_state_e2dr
 output wire virtual_state_udr, // .virtual_state_udr
 output wire virtual_state_cir, // .virtual_state_cir
 output wire virtual_state_uir, // .virtual_state_uir
 output wire tms, // .tms
 output wire jtag_state_tlr, // .jtag_state_tlr
 output wire jtag_state_rti, // .jtag_state_rti
 output wire jtag_state_sdrs, // .jtag_state_sdrs
 output wire jtag_state_cdr, // .jtag_state_cdr
 output wire jtag_state_sdr, // .jtag_state_sdr
 output wire jtag_state_e1dr, // .jtag_state_e1dr
 output wire jtag_state_pdr, // .jtag_state_pdr
 output wire jtag_state_e2dr, // .jtag_state_e2dr
 output wire jtag_state_udr, // .jtag_state_udr
 output wire jtag_state_sirs, // .jtag_state_sirs
 output wire jtag_state_cir, // .jtag_state_cir
 output wire jtag_state_sir, // .jtag_state_sir
 output wire jtag_state_e1ir, // .jtag_state_e1ir
 output wire jtag_state_pir, // .jtag_state_pir
 output wire jtag_state_e2ir, // .jtag_state_e2ir
 output wire jtag_state_uir, // .jtag_state_uir
 output wire tck // tck.clk
 );
sld_virtual_jtag #(
.sld_auto_instance_index ("YES"),
.sld_instance_index (0),
.sld_ir_width (5)
) virtual_jtag_0 (
.tdi (tdi), // jtag.tdi
 .tdo (tdo), // .tdo
 .ir_in (ir_in), // .ir_in
 .ir_out (ir_out), // .ir_out
 .virtual_state_cdr (virtual_state_cdr), // .virtual_state_cdr
 .virtual_state_sdr (virtual_state_sdr), // .virtual_state_sdr
 .virtual_state_e1dr (virtual_state_e1dr), // .virtual_state_e1dr
 .virtual_state_pdr (virtual_state_pdr), // .virtual_state_pdr
 .virtual_state_e2dr (virtual_state_e2dr), // .virtual_state_e2dr
 .virtual_state_udr (virtual_state_udr), // .virtual_state_udr
 .virtual_state_cir (virtual_state_cir), // .virtual_state_cir
 .virtual_state_uir (virtual_state_uir), // .virtual_state_uir
 .tms (tms), // .tms
 .jtag_state_tlr (jtag_state_tlr), // .jtag_state_tlr
 .jtag_state_rti (jtag_state_rti), // .jtag_state_rti
 .jtag_state_sdrs (jtag_state_sdrs), // .jtag_state_sdrs
 .jtag_state_cdr (jtag_state_cdr), // .jtag_state_cdr
 .jtag_state_sdr (jtag_state_sdr), // .jtag_state_sdr
 .jtag_state_e1dr (jtag_state_e1dr), // .jtag_state_e1dr
 .jtag_state_pdr (jtag_state_pdr), // .jtag_state_pdr
 .jtag_state_e2dr (jtag_state_e2dr), // .jtag_state_e2dr
 .jtag_state_udr (jtag_state_udr), // .jtag_state_udr
 .jtag_state_sirs (jtag_state_sirs), // .jtag_state_sirs
 .jtag_state_cir (jtag_state_cir), // .jtag_state_cir
 .jtag_state_sir (jtag_state_sir), // .jtag_state_sir
 .jtag_state_e1ir (jtag_state_e1ir), // .jtag_state_e1ir
 .jtag_state_pir (jtag_state_pir), // .jtag_state_pir
 .jtag_state_e2ir (jtag_state_e2ir), // .jtag_state_e2ir
 .jtag_state_uir (jtag_state_uir), // .jtag_state_uir
 .tck (tck) // tck.clk
 );
endmodule

NSLから使えるようにヘッダーファイルを書く。なお、クロック供給などは不要で、合成時にうまくやってくれる。ちなみに、JTAGのコントローラーは別に実装されているらしく、クロックやtdi, tdoなどの信号は sld_hubなどに供給されるようである。しかし、VJTAGのインスタンス(sld_node)や(sld_hub)はロジックエレメントを消費する。 jtag_*の信号はデバック用途であり、使用不可である。この信号はJTAGのコントローラーから来ている。 virtual_*の信号はVJTAGのステートマシンの状態である。

declare vjtag interface {
output tdi;
input tdo;
output ir_in[5];
input ir_out[5];
func_out virtual_state_cdr;
func_out virtual_state_sdr;
func_out virtual_state_e1dr;
func_out virtual_state_pdr;
func_out virtual_state_e2dr;
func_out virtual_state_udr;
func_out virtual_state_cir;
func_out virtual_state_uir;
output tms;
func_out jtag_state_tlr;
func_out jtag_state_rti;
func_out jtag_state_sdrs;
func_out jtag_state_cdr;
func_out jtag_state_sdr;
func_out jtag_state_e1dr;
func_out jtag_state_pdr;
func_out jtag_state_e2dr;
func_out jtag_state_udr;
func_out jtag_state_sirs;
func_out jtag_state_cir;
func_out jtag_state_sir;
func_out jtag_state_e1ir;
func_out jtag_state_pir;
func_out jtag_state_e2ir;
func_out jtag_state_uir;
output tck;
}

VJTAGとの通信

VJTAGのインスタンスと通信するには、まずsld_hubと通信をする必要がある。 sld_hubには２つのオペレーションが定義されている。なお、sld_hubのIRはインスタンスによらず、10bitである。 sld_hubに接続されているインスタンスの情報を取り出すことができるが、今回は省略する。ドキュメントおよびriscv-openocd/src/target/riscv/riscv_tap_vjtag.cを見てほしい。なお、VJTAGのインスタンスのIR/DRはsld_hubのサブセットという形な模様。そのため、それぞれVIR(Virtual IR)およびVDR(Virtual DR)と呼ばれている。ブロック図を以下に示す(仕様から書き起こしたので、もしかしたら間違いがあるかもしれない）。

なお、sld_hubには、２つの命令がある。これは、Shift_IRを用いてsld_hubのIR(10 bit)へ書き込むことで命令を発行できる。

USER0 VDRのパスを選択する。
USER1 VIRのパスを選択する。

OpenOCDでは、or1kのみVJTAGに対応している。次からは、OpenOCDのRISC-VターゲットにVJTAGサポートを行う。その後、実際にOpenOCDからVJTAG on DE10-Liteに通信ができるかテストをする。

My RISC-V debug feature part1

Tue, 06 Apr 2021 10:39:30 +0900

RISC-VプロセッサのシミュレータはVerilog HDLからVerilatorにてC++へ変換して、ソフトウエアとして構築している。そろそろまともな実機テスト環境を整えたくなってきたので、FPGA上で検証できるシステムを構築する。

デバック環境の検討

RISC-Vでは、RISC-V Debug ModeRISC-V debug spec が定義されている。この仕様では、デバック用の機能をまとめており、gdbなどはこの機能が実装されていることを前提としている。オレオレの仕様でも良さそうではあるけれど、ツールをの移植など対応させるのが非常にめんどうくさい。そこで、RISC-V Debugに沿った実装を行う。これは、通信のプロトコルについては規定していない。プロトコルはJTAGやSWDなどいろいろあるが、大体はOpenOCDが頑張ってくれる。 Intel FPGAの場合は、Virtual JTAGがあって、デザインの中でインスタンス化すると、USB Blasterケーブルを通してモジュールと通信できるよう。

そこで、今回はUSBケーブルを通して、JTAG(VJTAG)にてFPAG <-> PC間の通信をする。制御用のソフトウエアはOpenOCDを用いる。デバッカはgdbを用いる。今回実装すべきなのは、VJTAG <-> RISC-V間のデータパスと制御である。

RISC-V Debugの仕様では、以下の図に対応する。 Debug Transport HardwareはUSBダウンロードケーブルとなる。 DTMでは、VJTAGで受け取ったデータをデバック用の命令に変換し、DMIというバスを通して、DMへ送る。 DMは命令をもとに、プロセッサの状態を制御する。プロセッサはデバックモードの実装が必要となる。なお、点線の部分は任意の実装となる。とりあえず、最小限の実装をする。

やること

仕様の調査
実装の調査
VJTAGの調査とテスト
OpenOCDを使った、VJTAGの制御
Debug modeの実装
DTM, DMの実装
gdbによる実機テスト

こんな感じで進めていく。まずは、Debug specをしっかり読んでいく。前に読んだときはさっぱりで諦めた(小声)

Reading linux kernel part6

Fri, 02 Apr 2021 13:59:10 +0900

handle_exceptionの続きを読んでいく。

handle_exception

global pointerのロードから。

arch/riscv/kernel/entry.S

 /* Load the global pointer */
.option push
.option norelax
la gp, __global_pointer$
.option pop
#ifdef CONFIG_TRACE_IRQFLAGS
 call trace_hardirqs_off
#endif

#ifdef CONFIG_CONTEXT_TRACKING
 /* If previous state is in user mode, call context_tracking_user_exit. */
li a0, SR_PP
and a0, s1, a0
bnez a0, skip_context_tracking
call context_tracking_user_exit
skip_context_tracking:
#endif

/*
* MSB of cause differentiates between
* interrupts and exceptions
*/
bge s4, zero, 1f
la ra, ret_from_exception
/* Handle interrupts */
move a0, sp /* pt_regs */
la a1, handle_arch_irq
REG_L a1, (a1)
jr a1
1:
#ifdef CONFIG_TRACE_IRQFLAGS
 call trace_hardirqs_on
#endif
 /*
* Exceptions run with interrupts enabled or disabled depending on the
* state of SR_PIE in m/sstatus.
*/
andi t0, s1, SR_PIE
beqz t0, 1f
csrs CSR_STATUS, SR_IE

gpをロードする。global pointerはリロケーション済みになる。トラッキングについては省く。次に、s4レジスタ(scause)の最上位ビットを調べる。最上位ビットが立っているときは割込みである。 bge s4, zero, 1fで確かめている。例外の場合は、1:である。

まずは、例外の処理を見ていく。

例外の処理

sstatus(s1)にpie(Previous Interrupt Enable)が立っているか調べる。例外発生時に割込みが有効であったか調べる。もし、sstatus.pieが0であれば、sstatus.sieをセットする。

次にリターンアドレスをセットする。(ret_from_exception) s4(scause)がEXC_SYSCALLであるか調べる。その場合は、システムコールなのでhandle_syscallへ分岐する。その他の例外の場合は、excp_vect_tableを索引する。 s4(scause)を右に二回(RV32の場合は、RISCV_LGPTRは2、arch/riscv/include/asm/asm.h)左にシフトする。 a0にpt_regsのポインタをセットし、excp_vect_table〜excp_vect_table_endの間にあるかをみて、索引する。その後、レジスタ相対ジャンプを行う。

excp_vect_table〜excp_vect_table_endの間にインデックス(t0)が収まらない場合は、1:へ分岐し、do_trap_unknownを実行する。

excp_vect_table

システムコール以外の、各例外のハンドラはexcp_vect_tableに登録されている。索引する際に、範囲外であれば、do_trap_unknownとなる。 arch/riscv/kernel/entry.S

#ifndef CONFIG_MMU
#define do_page_fault do_trap_unknown
#endif

.section ".rodata"
/* Exception vector table */
ENTRY(excp_vect_table)
RISCV_PTR do_trap_insn_misaligned
RISCV_PTR do_trap_insn_fault
RISCV_PTR do_trap_insn_illegal
RISCV_PTR do_trap_break
RISCV_PTR do_trap_load_misaligned
RISCV_PTR do_trap_load_fault
RISCV_PTR do_trap_store_misaligned
RISCV_PTR do_trap_store_fault
RISCV_PTR do_trap_ecall_u /* system call, gets intercepted */
RISCV_PTR do_trap_ecall_s
RISCV_PTR do_trap_unknown
RISCV_PTR do_trap_ecall_m
RISCV_PTR do_page_fault /* instruction page fault */
RISCV_PTR do_page_fault /* load page fault */
RISCV_PTR do_trap_unknown
RISCV_PTR do_page_fault /* store page fault */
excp_vect_table_end:
END(excp_vect_table)

handle_syscall

arch/riscv/kernel/entry.S

handle_syscall:
#if defined(CONFIG_TRACE_IRQFLAGS) || defined(CONFIG_CONTEXT_TRACKING)
 /* Recover a0 - a7 for system calls */
REG_L a0, PT_A0(sp)
REG_L a1, PT_A1(sp)
REG_L a2, PT_A2(sp)
REG_L a3, PT_A3(sp)
REG_L a4, PT_A4(sp)
REG_L a5, PT_A5(sp)
REG_L a6, PT_A6(sp)
REG_L a7, PT_A7(sp)
#endif
 /* save the initial A0 value (needed in signal handlers) */
REG_S a0, PT_ORIG_A0(sp)
/*
* Advance SEPC to avoid executing the original
* scall instruction on sret
*/
addi s2, s2, 0x4
REG_S s2, PT_EPC(sp)
/* Trace syscalls, but only if requested by the user. */
REG_L t0, TASK_TI_FLAGS(tp)
andi t0, t0, _TIF_SYSCALL_WORK
bnez t0, handle_syscall_trace_enter

a0レジスタをpt_regs->orig_a0に保存する。 sepc(s2)を+4して、pt_regs->epcに保存する。

次に、thread_info->flagsを取り出し、システムコールをトレースが必要か調べる。

arch/riscv/include/asm/thread_info.h

/*
* thread information flags
* - these are process state flags that various assembly files may need to
* access
* - pending work-to-be-done flags are in lowest half-word
* - other flags in upper half-word(s)
*/
#define TIF_SYSCALL_TRACE 0 /* syscall trace active */
#define TIF_NOTIFY_RESUME 1 /* callback before returning to user */
#define TIF_SIGPENDING 2 /* signal pending */
#define TIF_NEED_RESCHED 3 /* rescheduling necessary */
#define TIF_RESTORE_SIGMASK 4 /* restore signal mask in do_signal() */
#define TIF_MEMDIE 5 /* is terminating due to OOM killer */
#define TIF_SYSCALL_TRACEPOINT 6 /* syscall tracepoint instrumentation */
#define TIF_SYSCALL_AUDIT 7 /* syscall auditing */
#define TIF_SECCOMP 8 /* syscall secure computing */

#define _TIF_SYSCALL_TRACE (1 << TIF_SYSCALL_TRACE)
#define _TIF_NOTIFY_RESUME (1 << TIF_NOTIFY_RESUME)
#define _TIF_SIGPENDING (1 << TIF_SIGPENDING)
#define _TIF_NEED_RESCHED (1 << TIF_NEED_RESCHED)
#define _TIF_SYSCALL_TRACEPOINT (1 << TIF_SYSCALL_TRACEPOINT)
#define _TIF_SYSCALL_AUDIT (1 << TIF_SYSCALL_AUDIT)
#define _TIF_SECCOMP (1 << TIF_SECCOMP)

#define _TIF_SYSCALL_WORK \
 (_TIF_SYSCALL_TRACE | _TIF_SYSCALL_TRACEPOINT | _TIF_SYSCALL_AUDIT | \
_TIF_SECCOMP)

トレースが必要な場合はhandle_syscall_trace_enterに分岐する。このパスはptraceに用いられる。

arch/riscv/kernel/entry.S

/* Slow paths for ptrace. */
handle_syscall_trace_enter:
move a0, sp
call do_syscall_trace_enter
move t0, a0
REG_L a0, PT_A0(sp)
REG_L a1, PT_A1(sp)
REG_L a2, PT_A2(sp)
REG_L a3, PT_A3(sp)
REG_L a4, PT_A4(sp)
REG_L a5, PT_A5(sp)
REG_L a6, PT_A6(sp)
REG_L a7, PT_A7(sp)
bnez t0, ret_from_syscall_rejected
j check_syscall_nr
handle_syscall_trace_exit:
move a0, sp
call do_syscall_trace_exit
j ret_from_exception

この場合でもcheck_syscall_nrを呼びだす。よって、このパスはとりあえず無視する。

arch/riscv/kernel/entry.S

check_syscall_nr:
/* Check to make sure we don't jump to a bogus syscall number. */
li t0, __NR_syscalls
la s0, sys_ni_syscall
/*
* Syscall number held in a7.
* If syscall number is above allowed value, redirect to ni_syscall.
*/
bge a7, t0, 1f
/*
* Check if syscall is rejected by tracer, i.e., a7 == -1.
* If yes, we pretend it was executed.
*/
li t1, -1
beq a7, t1, ret_from_syscall_rejected
blt a7, t1, 1f
/* Call syscall */
la s0, sys_call_table
slli t0, a7, RISCV_LGPTR
add s0, s0, t0
REG_L s0, 0(s0)
1:
jalr s0

__NR_syscallsはシステムコール番号の最大値である。

arch/riscv/kernel/syscall_table.c

#undef __SYSCALL
#define __SYSCALL(nr, call) [nr] = (call),

void *sys_call_table[__NR_syscalls] = {
[0 ... __NR_syscalls - 1] = sys_ni_syscall,
#include <asm/unistd.h>
};

sys_ni_syscallは実装されていないシステムコールの処理である。 kernel/sys_ni.c

/* we can't #include <linux/syscalls.h> here,
 but tell gcc to not warn with -Wmissing-prototypes */
asmlinkage long sys_ni_syscall(void);
/*
 * Non-implemented system calls get redirected here.
 */
asmlinkage long sys_ni_syscall(void)
{
return -ENOSYS;
}

システムコール発行の引数(a7)のシステムコール番号が__NR_syscallsより以上の場合は実装されていない。(1:)

システムコール番号(a7)が-1の場合はret_from_syscall_rejectedへ分岐する。

次にシステムコール番号(a7)でsys_call_tableを索引し、ジャンプする。

例外からの復帰

arch/riscv/kernel/entry.S

ret_from_syscall:
/* Set user a0 to kernel a0 */
REG_S a0, PT_A0(sp)
/*
 * We didn't execute the actual syscall.
 * Seccomp already set return value for the current task pt_regs.
 * (If it was configured with SECCOMP_RET_ERRNO/TRACE)
 */
ret_from_syscall_rejected:
/* Trace syscalls, but only if requested by the user. */
REG_L t0, TASK_TI_FLAGS(tp)
andi t0, t0, _TIF_SYSCALL_WORK
bnez t0, handle_syscall_trace_exit
ret_from_exception:
REG_L s0, PT_STATUS(sp)
csrc CSR_STATUS, SR_IE
#ifdef CONFIG_TRACE_IRQFLAGS
 call trace_hardirqs_off
#endif
#ifdef CONFIG_RISCV_M_MODE
 /* the MPP value is too large to be used as an immediate arg for addi */
li t0, SR_MPP
and s0, s0, t0
#else
 andi s0, s0, SR_SPP
#endif
 bnez s0, resume_kernel

次に、システムコールの戻り値をpt_regs->a0に保存し、割込みを無効にする。次に移るモード(sstatus.spp)をマスクする。このモードが0の場合はユーザーモードなので、resume_userspaceを実行する。それ以外はresume_kernelを実行する。

#if IS_ENABLED(CONFIG_PREEMPTION)
resume_kernel:
REG_L s0, TASK_TI_PREEMPT_COUNT(tp)
bnez s0, restore_all
REG_L s0, TASK_TI_FLAGS(tp)
andi s0, s0, _TIF_NEED_RESCHED
beqz s0, restore_all
call preempt_schedule_irq
j restore_all
#endif

CONFIG_PREEMPTIONを定義すると、プロセスコンテキストにおいてカーネル内のコードを実行中であっても他のプロセスにCPUを手放す。

プリエンプション

今回は、CONFIG_PREEMPTIONを定義していないので、resume_kernelの実体はrestore_allとなる。

arch/riscv/kernel/entry.S

#if !IS_ENABLED(CONFIG_PREEMPTION)
.set resume_kernel, restore_all
#endif

arch/riscv/kernel/entry.S

restore_all:
#ifdef CONFIG_TRACE_IRQFLAGS
 REG_L s1, PT_STATUS(sp)
andi t0, s1, SR_PIE
beqz t0, 1f
call trace_hardirqs_on
j 2f
1:
call trace_hardirqs_off
2:
#endif

CONFIG_TRACE_IRQFLAGSは定義していないので、スキップする。

arch/riscv/kernel/entry.S

 REG_L a0, PT_STATUS(sp)
/*
* The current load reservation is effectively part of the processor's
* state, in the sense that load reservations cannot be shared between
* different hart contexts. We can't actually save and restore a load
* reservation, so instead here we clear any existing reservation --
* it's always legal for implementations to clear load reservations at
* any point (as long as the forward progress guarantee is kept, but
* we'll ignore that here).
*
* Dangling load reservations can be the result of taking a trap in the
* middle of an LR/SC sequence, but can also be the result of a taken
* forward branch around an SC -- which is how we implement CAS. As a
* result we need to clear reservations between the last CAS and the
* jump back to the new context. While it is unlikely the store
* completes, implementations are allowed to expand reservations to be
* arbitrarily large.
*/
REG_L a2, PT_EPC(sp)
REG_SC x0, a2, PT_EPC(sp)
csrw CSR_STATUS, a0
csrw CSR_EPC, a2
REG_L x1, PT_RA(sp)
REG_L x3, PT_GP(sp)
REG_L x4, PT_TP(sp)
REG_L x5, PT_T0(sp)
REG_L x6, PT_T1(sp)
REG_L x7, PT_T2(sp)
REG_L x8, PT_S0(sp)
REG_L x9, PT_S1(sp)
REG_L x10, PT_A0(sp)
REG_L x11, PT_A1(sp)
REG_L x12, PT_A2(sp)
REG_L x13, PT_A3(sp)
REG_L x14, PT_A4(sp)
REG_L x15, PT_A5(sp)
REG_L x16, PT_A6(sp)
REG_L x17, PT_A7(sp)
REG_L x18, PT_S2(sp)
REG_L x19, PT_S3(sp)
REG_L x20, PT_S4(sp)
REG_L x21, PT_S5(sp)
REG_L x22, PT_S6(sp)
REG_L x23, PT_S7(sp)
REG_L x24, PT_S8(sp)
REG_L x25, PT_S9(sp)
REG_L x26, PT_S10(sp)
REG_L x27, PT_S11(sp)
REG_L x28, PT_T3(sp)
REG_L x29, PT_T4(sp)
REG_L x30, PT_T5(sp)
REG_L x31, PT_T6(sp)
REG_L x2, PT_SP(sp)
#ifdef CONFIG_RISCV_M_MODE
 mret
#else
 sret
#endif

SC(Store conditional)を発行して、reservationをクリアする。 reservation(load reservedによりセット)はプロセッサのステートなので、復元が必要。（復元の代わりにSCを発行することでreservationをクリアする。任意の大きさの場合はAMO faultとなるはず。) sstatus、sepc、汎用レジスタを復元する。システムコールの戻り値はpt_regs->a0に保存済みである。最後にspを復元していることに注意。その後、sretを行い、例外元のカーネルへ復帰する。(sstatus.spp == S-mode)

次にユーザーモードへ戻る場合を見てみる。

resume_userspace:
/* Interrupts must be disabled here so flags are checked atomically */
REG_L s0, TASK_TI_FLAGS(tp) /* current_thread_info->flags */
andi s1, s0, _TIF_WORK_MASK
bnez s1, work_pending
#ifdef CONFIG_CONTEXT_TRACKING
 call context_tracking_user_enter
#endif

/* Save unwound kernel stack pointer in thread_info */
addi s0, sp, PT_SIZE_ON_STACK
REG_S s0, TASK_TI_KERNEL_SP(tp)
/*
* Save TP into the scratch register , so we can find the kernel data
* structures again.
*/
csrw CSR_SCRATCH, tp

thread_info->flagsを見て、シグナル、コールバック、リスケジュールが必要な際にはwork_pendingを実行する。それ以外の場合は、s0にスタックポインタを戻したものを作成し、task_structのkernel spへ保存する。 tpをscratchとスワップし、カーネルのデータ構造へのポインタをsscratchへ保存する。その後はrestore_allと同じである。ただし、sstatus->spp == U-modeなので、ユーザースペースへ復帰する。

arch/riscv/include/asm/thread_info.h

/*
* thread information flags
* - these are process state flags that various assembly files may need to
* access
* - pending work-to-be-done flags are in lowest half-word
* - other flags in upper half-word(s)
*/
#define TIF_SYSCALL_TRACE 0 /* syscall trace active */
#define TIF_NOTIFY_RESUME 1 /* callback before returning to user */
#define TIF_SIGPENDING 2 /* signal pending */
#define TIF_NEED_RESCHED 3 /* rescheduling necessary */
#define TIF_RESTORE_SIGMASK 4 /* restore signal mask in do_signal() */
#define TIF_MEMDIE 5 /* is terminating due to OOM killer */
#define TIF_SYSCALL_TRACEPOINT 6 /* syscall tracepoint instrumentation */
#define TIF_SYSCALL_AUDIT 7 /* syscall auditing */
#define TIF_SECCOMP 8 /* syscall secure computing */

#define _TIF_SYSCALL_TRACE (1 << TIF_SYSCALL_TRACE)
#define _TIF_NOTIFY_RESUME (1 << TIF_NOTIFY_RESUME)
#define _TIF_SIGPENDING (1 << TIF_SIGPENDING)
#define _TIF_NEED_RESCHED (1 << TIF_NEED_RESCHED)
#define _TIF_SYSCALL_TRACEPOINT (1 << TIF_SYSCALL_TRACEPOINT)
#define _TIF_SYSCALL_AUDIT (1 << TIF_SYSCALL_AUDIT)
#define _TIF_SECCOMP (1 << TIF_SECCOMP)

#define _TIF_WORK_MASK \
 (_TIF_NOTIFY_RESUME | _TIF_SIGPENDING | _TIF_NEED_RESCHED)

これで、おおよそトラップ時の動作を見た。トラップの処理自体を詳しく理解するには、excp_vect_table、sys_call_table、do_trap_unknown、handle_arch_irqを読む必要がある。また、work_pendingやptrace関連のパスは読んでいないが、後に必要になるかもしれない。