X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Ftarget%2Ftarget.c;h=7673f5d22aaffcc561e1c479346ba5ba4552f109;hp=f9d957d69e0927b561c727b8e1d60b398fe93e00;hb=35b3c95299a97c05078f7dd662d66c89a356869d;hpb=e27696f6b04459e935a0a5f65f7f668cb02970dd diff --git a/src/target/target.c b/src/target/target.c index f9d957d69e..7673f5d22a 100644 --- a/src/target/target.c +++ b/src/target/target.c @@ -49,6 +49,7 @@ int cli_target_callback_event_handler(struct target_s *target, enum target_event event, void *priv); + int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); int handle_daemon_startup_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); int handle_targets_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); @@ -74,6 +75,8 @@ int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int handle_rbp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); +int handle_virt2phys_command(command_context_t *cmd_ctx, char *cmd, char **args, int argc); +int handle_profile_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); /* targets */ @@ -83,8 +86,10 @@ extern target_type_t arm9tdmi_target; extern target_type_t arm920t_target; extern target_type_t arm966e_target; extern target_type_t arm926ejs_target; +extern target_type_t feroceon_target; extern target_type_t xscale_target; extern target_type_t cortexm3_target; +extern target_type_t arm11_target; target_type_t *target_types[] = { @@ -94,8 +99,10 @@ target_type_t *target_types[] = &arm720t_target, &arm966e_target, &arm926ejs_target, + &feroceon_target, &xscale_target, &cortexm3_target, + &arm11_target, NULL, }; @@ -116,7 +123,7 @@ char *target_debug_reason_strings[] = { "debug request", "breakpoint", "watchpoint", "watchpoint and breakpoint", "single step", - "target not halted" + "target not halted", "undefined" }; char *target_endianess_strings[] = @@ -204,7 +211,7 @@ target_t* get_current_target(command_context_t *cmd_ctx) if (target == NULL) { - ERROR("BUG: current_target out of bounds"); + LOG_ERROR("BUG: current_target out of bounds"); exit(-1); } @@ -223,14 +230,14 @@ int target_init_handler(struct target_s *target, enum target_event event, void * { target_unregister_event_callback(target_init_handler, priv); - script = fopen(target->reset_script, "r"); + script = open_file_from_path(target->reset_script, "r"); if (!script) { - ERROR("couldn't open script file %s", target->reset_script); + LOG_ERROR("couldn't open script file %s", target->reset_script); return ERROR_OK; } - INFO("executing reset script '%s'", target->reset_script); + LOG_INFO("executing reset script '%s'", target->reset_script); command_run_file(cmd_ctx, script, COMMAND_EXEC); fclose(script); @@ -253,19 +260,29 @@ int target_process_reset(struct command_context_s *cmd_ctx) { int retval = ERROR_OK; target_t *target; - + struct timeval timeout, now; + + jtag->speed(jtag_speed); + /* prepare reset_halt where necessary */ target = targets; while (target) { - switch (target->reset_mode) + if (jtag_reset_config & RESET_SRST_PULLS_TRST) { - case RESET_HALT: - case RESET_INIT: - target->type->prepare_reset_halt(target); - break; - default: - break; + switch (target->reset_mode) + { + case RESET_HALT: + command_print(cmd_ctx, "nSRST pulls nTRST, falling back to \"reset run_and_halt\""); + target->reset_mode = RESET_RUN_AND_HALT; + break; + case RESET_INIT: + command_print(cmd_ctx, "nSRST pulls nTRST, falling back to \"reset run_and_init\""); + target->reset_mode = RESET_RUN_AND_INIT; + break; + default: + break; + } } target = target->next; } @@ -273,6 +290,10 @@ int target_process_reset(struct command_context_s *cmd_ctx) target = targets; while (target) { + /* we have no idea what state the target is in, so we + * have to drop working areas + */ + target_free_all_working_areas_restore(target, 0); target->type->assert_reset(target); target = target->next; } @@ -304,7 +325,7 @@ int target_process_reset(struct command_context_s *cmd_ctx) target_register_event_callback(target_init_handler, cmd_ctx); break; default: - ERROR("BUG: unknown target->reset_mode"); + LOG_ERROR("BUG: unknown target->reset_mode"); } target = target->next; } @@ -317,8 +338,79 @@ int target_process_reset(struct command_context_s *cmd_ctx) } jtag_execute_queue(); + LOG_DEBUG("Waiting for halted stated as approperiate"); + + /* Wait for reset to complete, maximum 5 seconds. */ + gettimeofday(&timeout, NULL); + timeval_add_time(&timeout, 5, 0); + for(;;) + { + gettimeofday(&now, NULL); + + target_call_timer_callbacks_now(); + + target = targets; + while (target) + { + LOG_DEBUG("Polling target"); + target->type->poll(target); + if ((target->reset_mode == RESET_RUN_AND_INIT) || + (target->reset_mode == RESET_RUN_AND_HALT) || + (target->reset_mode == RESET_HALT) || + (target->reset_mode == RESET_INIT)) + { + if (target->state != TARGET_HALTED) + { + if ((now.tv_sec > timeout.tv_sec) || ((now.tv_sec == timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec))) + { + LOG_USER("Timed out waiting for halt after reset"); + goto done; + } + /* this will send alive messages on e.g. GDB remote protocol. */ + usleep(500*1000); + LOG_USER_N("%s", ""); /* avoid warning about zero length formatting message*/ + goto again; + } + } + target = target->next; + } + /* All targets we're waiting for are halted */ + break; + + again:; + } + done: + + + /* We want any events to be processed before the prompt */ + target_call_timer_callbacks_now(); + + /* if we timed out we need to unregister these handlers */ + target = targets; + while (target) + { + target_unregister_timer_callback(target_run_and_halt_handler, target); + target = target->next; + } + target_unregister_event_callback(target_init_handler, cmd_ctx); + + + jtag->speed(jtag_speed_post_reset); + return retval; -} +} + +static int default_virt2phys(struct target_s *target, u32 virtual, u32 *physical) +{ + *physical = virtual; + return ERROR_OK; +} + +static int default_mmu(struct target_s *target, int *enabled) +{ + *enabled = 0; + return ERROR_OK; +} int target_init(struct command_context_s *cmd_ctx) { @@ -328,9 +420,19 @@ int target_init(struct command_context_s *cmd_ctx) { if (target->type->init_target(cmd_ctx, target) != ERROR_OK) { - ERROR("target '%s' init failed", target->type->name); + LOG_ERROR("target '%s' init failed", target->type->name); exit(-1); } + + /* Set up default functions if none are provided by target */ + if (target->type->virt2phys == NULL) + { + target->type->virt2phys = default_virt2phys; + } + if (target->type->mmu == NULL) + { + target->type->mmu = default_mmu; + } target = target->next; } @@ -340,6 +442,11 @@ int target_init(struct command_context_s *cmd_ctx) target_register_timer_callback(handle_target, 100, 1, NULL); } + return ERROR_OK; +} + +int target_init_reset(struct command_context_s *cmd_ctx) +{ if (startup_mode == DAEMON_RESET) target_process_reset(cmd_ctx); @@ -467,7 +574,7 @@ int target_call_event_callbacks(target_t *target, enum target_event event) target_event_callback_t *callback = target_event_callbacks; target_event_callback_t *next_callback; - DEBUG("target event %i", event); + LOG_DEBUG("target event %i", event); while (callback) { @@ -479,7 +586,7 @@ int target_call_event_callbacks(target_t *target, enum target_event event) return ERROR_OK; } -int target_call_timer_callbacks() +static int target_call_timer_callbacks_check_time(int checktime) { target_timer_callback_t *callback = target_timer_callbacks; target_timer_callback_t *next_callback; @@ -491,8 +598,9 @@ int target_call_timer_callbacks() { next_callback = callback->next; - if (((now.tv_sec >= callback->when.tv_sec) && (now.tv_usec >= callback->when.tv_usec)) - || (now.tv_sec > callback->when.tv_sec)) + if ((!checktime&&callback->periodic)|| + (((now.tv_sec >= callback->when.tv_sec) && (now.tv_usec >= callback->when.tv_usec)) + || (now.tv_sec > callback->when.tv_sec))) { callback->callback(callback->priv); if (callback->periodic) @@ -517,15 +625,47 @@ int target_call_timer_callbacks() return ERROR_OK; } +int target_call_timer_callbacks() +{ + return target_call_timer_callbacks_check_time(1); +} + +/* invoke periodic callbacks immediately */ +int target_call_timer_callbacks_now() +{ + return target_call_timer_callbacks(0); +} + + int target_alloc_working_area(struct target_s *target, u32 size, working_area_t **area) { working_area_t *c = target->working_areas; working_area_t *new_wa = NULL; + /* Reevaluate working area address based on MMU state*/ + if (target->working_areas == NULL) + { + int retval; + int enabled; + retval = target->type->mmu(target, &enabled); + if (retval != ERROR_OK) + { + return retval; + } + if (enabled) + { + target->working_area = target->working_area_virt; + } + else + { + target->working_area = target->working_area_phys; + } + } + /* only allocate multiples of 4 byte */ if (size % 4) { - ERROR("BUG: code tried to allocate unaligned number of bytes, padding"); + LOG_ERROR("BUG: code tried to allocate unaligned number of bytes, padding"); size = CEIL(size, 4); } @@ -547,7 +687,7 @@ int target_alloc_working_area(struct target_s *target, u32 size, working_area_t u32 first_free = target->working_area; u32 free_size = target->working_area_size; - DEBUG("allocating new working area"); + LOG_DEBUG("allocating new working area"); c = target->working_areas; while (c) @@ -560,7 +700,7 @@ int target_alloc_working_area(struct target_s *target, u32 size, working_area_t if (free_size < size) { - WARNING("not enough working area available"); + LOG_WARNING("not enough working area available(requested %d, free %d)", size, free_size); return ERROR_TARGET_RESOURCE_NOT_AVAILABLE; } @@ -593,12 +733,12 @@ int target_alloc_working_area(struct target_s *target, u32 size, working_area_t return ERROR_OK; } -int target_free_working_area(struct target_s *target, working_area_t *area) +int target_free_working_area_restore(struct target_s *target, working_area_t *area, int restore) { if (area->free) return ERROR_OK; - if (target->backup_working_area) + if (restore&&target->backup_working_area) target->type->write_memory(target, area->address, 4, area->size / 4, area->backup); area->free = 1; @@ -610,14 +750,19 @@ int target_free_working_area(struct target_s *target, working_area_t *area) return ERROR_OK; } -int target_free_all_working_areas(struct target_s *target) +int target_free_working_area(struct target_s *target, working_area_t *area) +{ + return target_free_working_area_restore(target, area, 1); +} + +int target_free_all_working_areas_restore(struct target_s *target, int restore) { working_area_t *c = target->working_areas; while (c) { working_area_t *next = c->next; - target_free_working_area(target, c); + target_free_working_area_restore(target, c, restore); if (c->backup) free(c->backup); @@ -632,30 +777,56 @@ int target_free_all_working_areas(struct target_s *target) return ERROR_OK; } +int target_free_all_working_areas(struct target_s *target) +{ + return target_free_all_working_areas_restore(target, 1); +} + int target_register_commands(struct command_context_s *cmd_ctx) { register_command(cmd_ctx, NULL, "target", handle_target_command, COMMAND_CONFIG, NULL); register_command(cmd_ctx, NULL, "targets", handle_targets_command, COMMAND_EXEC, NULL); register_command(cmd_ctx, NULL, "daemon_startup", handle_daemon_startup_command, COMMAND_CONFIG, NULL); register_command(cmd_ctx, NULL, "target_script", handle_target_script_command, COMMAND_CONFIG, NULL); - register_command(cmd_ctx, NULL, "run_and_halt_time", handle_run_and_halt_time_command, COMMAND_CONFIG, NULL); - register_command(cmd_ctx, NULL, "working_area", handle_working_area_command, COMMAND_CONFIG, NULL); + register_command(cmd_ctx, NULL, "run_and_halt_time", handle_run_and_halt_time_command, COMMAND_CONFIG, " "); + register_command(cmd_ctx, NULL, "working_area", handle_working_area_command, COMMAND_ANY, "working_area
<'backup'|'nobackup'> [virtual address]"); + register_command(cmd_ctx, NULL, "virt2phys", handle_virt2phys_command, COMMAND_ANY, "virt2phys "); + register_command(cmd_ctx, NULL, "profile", handle_profile_command, COMMAND_EXEC, "PRELIMINARY! - profile "); return ERROR_OK; } +int target_arch_state(struct target_s *target) +{ + int retval; + if (target==NULL) + { + LOG_USER("No target has been configured"); + return ERROR_OK; + } + + LOG_USER("target state: %s", target_state_strings[target->state]); + + if (target->state!=TARGET_HALTED) + return ERROR_OK; + + retval=target->type->arch_state(target); + return retval; +} + +/* Single aligned words are guaranteed to use 16 or 32 bit access + * mode respectively, otherwise data is handled as quickly as + * possible + */ int target_write_buffer(struct target_s *target, u32 address, u32 size, u8 *buffer) { int retval; - DEBUG("writing buffer of %i byte at 0x%8.8x", size, address); + LOG_DEBUG("writing buffer of %i byte at 0x%8.8x", size, address); - /* handle writes of less than 4 byte */ - if (size < 4) + if (((address % 2) == 0) && (size == 2)) { - if ((retval = target->type->write_memory(target, address, 1, size, buffer)) != ERROR_OK) - return retval; - return ERROR_OK; + return target->type->write_memory(target, address, 2, 1, buffer); } /* handle unaligned head bytes */ @@ -663,6 +834,9 @@ int target_write_buffer(struct target_s *target, u32 address, u32 size, u8 *buff { int unaligned = 4 - (address % 4); + if (unaligned > size) + unaligned = size; + if ((retval = target->type->write_memory(target, address, 1, unaligned, buffer)) != ERROR_OK) return retval; @@ -703,18 +877,20 @@ int target_write_buffer(struct target_s *target, u32 address, u32 size, u8 *buff return ERROR_OK; } + +/* Single aligned words are guaranteed to use 16 or 32 bit access + * mode respectively, otherwise data is handled as quickly as + * possible + */ int target_read_buffer(struct target_s *target, u32 address, u32 size, u8 *buffer) { int retval; - DEBUG("reading buffer of %i byte at 0x%8.8x", size, address); + LOG_DEBUG("reading buffer of %i byte at 0x%8.8x", size, address); - /* handle reads of less than 4 byte */ - if (size < 4) + if (((address % 2) == 0) && (size == 2)) { - if ((retval = target->type->read_memory(target, address, 1, size, buffer)) != ERROR_OK) - return retval; - return ERROR_OK; + return target->type->read_memory(target, address, 2, 1, buffer); } /* handle unaligned head bytes */ @@ -722,6 +898,9 @@ int target_read_buffer(struct target_s *target, u32 address, u32 size, u8 *buffe { int unaligned = 4 - (address % 4); + if (unaligned > size) + unaligned = size; + if ((retval = target->type->read_memory(target, address, 1, unaligned, buffer)) != ERROR_OK) return retval; @@ -764,7 +943,17 @@ int target_checksum_memory(struct target_s *target, u32 address, u32 size, u32* size, &checksum)) == ERROR_TARGET_RESOURCE_NOT_AVAILABLE) { buffer = malloc(size); - target_read_buffer(target, address, size, buffer); + if (buffer == NULL) + { + LOG_ERROR("error allocating buffer for section (%d bytes)", size); + return ERROR_INVALID_ARGUMENTS; + } + retval = target_read_buffer(target, address, size, buffer); + if (retval != ERROR_OK) + { + free(buffer); + return retval; + } /* convert to target endianess */ for (i = 0; i < (size/sizeof(u32)); i++) @@ -792,12 +981,12 @@ int target_read_u32(struct target_s *target, u32 address, u32 *value) if (retval == ERROR_OK) { *value = target_buffer_get_u32(target, value_buf); - DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, *value); + LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, *value); } else { *value = 0x0; - DEBUG("address: 0x%8.8x failed", address); + LOG_DEBUG("address: 0x%8.8x failed", address); } return retval; @@ -812,12 +1001,12 @@ int target_read_u16(struct target_s *target, u32 address, u16 *value) if (retval == ERROR_OK) { *value = target_buffer_get_u16(target, value_buf); - DEBUG("address: 0x%8.8x, value: 0x%4.4x", address, *value); + LOG_DEBUG("address: 0x%8.8x, value: 0x%4.4x", address, *value); } else { *value = 0x0; - DEBUG("address: 0x%8.8x failed", address); + LOG_DEBUG("address: 0x%8.8x failed", address); } return retval; @@ -829,12 +1018,12 @@ int target_read_u8(struct target_s *target, u32 address, u8 *value) if (retval == ERROR_OK) { - DEBUG("address: 0x%8.8x, value: 0x%2.2x", address, *value); + LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address, *value); } else { *value = 0x0; - DEBUG("address: 0x%8.8x failed", address); + LOG_DEBUG("address: 0x%8.8x failed", address); } return retval; @@ -845,12 +1034,12 @@ int target_write_u32(struct target_s *target, u32 address, u32 value) int retval; u8 value_buf[4]; - DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, value); + LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, value); target_buffer_set_u32(target, value_buf, value); if ((retval = target->type->write_memory(target, address, 4, 1, value_buf)) != ERROR_OK) { - DEBUG("failed: %i", retval); + LOG_DEBUG("failed: %i", retval); } return retval; @@ -861,12 +1050,12 @@ int target_write_u16(struct target_s *target, u32 address, u16 value) int retval; u8 value_buf[2]; - DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, value); + LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, value); target_buffer_set_u16(target, value_buf, value); if ((retval = target->type->write_memory(target, address, 2, 1, value_buf)) != ERROR_OK) { - DEBUG("failed: %i", retval); + LOG_DEBUG("failed: %i", retval); } return retval; @@ -876,11 +1065,11 @@ int target_write_u8(struct target_s *target, u32 address, u8 value) { int retval; - DEBUG("address: 0x%8.8x, value: 0x%2.2x", address, value); + LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address, value); if ((retval = target->type->read_memory(target, address, 1, 1, &value)) != ERROR_OK) { - DEBUG("failed: %i", retval); + LOG_DEBUG("failed: %i", retval); } return retval; @@ -901,9 +1090,9 @@ int target_register_user_commands(struct command_context_s *cmd_ctx) register_command(cmd_ctx, NULL, "mdh", handle_md_command, COMMAND_EXEC, "display memory half-words [count]"); register_command(cmd_ctx, NULL, "mdb", handle_md_command, COMMAND_EXEC, "display memory bytes [count]"); - register_command(cmd_ctx, NULL, "mww", handle_mw_command, COMMAND_EXEC, "write memory word "); - register_command(cmd_ctx, NULL, "mwh", handle_mw_command, COMMAND_EXEC, "write memory half-word "); - register_command(cmd_ctx, NULL, "mwb", handle_mw_command, COMMAND_EXEC, "write memory byte "); + register_command(cmd_ctx, NULL, "mww", handle_mw_command, COMMAND_EXEC, "write memory word [count]"); + register_command(cmd_ctx, NULL, "mwh", handle_mw_command, COMMAND_EXEC, "write memory half-word [count]"); + register_command(cmd_ctx, NULL, "mwb", handle_mw_command, COMMAND_EXEC, "write memory byte [count]"); register_command(cmd_ctx, NULL, "bp", handle_bp_command, COMMAND_EXEC, "set breakpoint
[hw]"); register_command(cmd_ctx, NULL, "rbp", handle_rbp_command, COMMAND_EXEC, "remove breakpoint "); @@ -961,8 +1150,7 @@ int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **a if (argc < 3) { - ERROR("target command requires at least three arguments: "); - exit(-1); + return ERROR_COMMAND_SYNTAX_ERROR; } /* search for the specified target */ @@ -977,7 +1165,7 @@ int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **a /* register target specific commands */ if (target_types[i]->register_commands(cmd_ctx) != ERROR_OK) { - ERROR("couldn't register '%s' commands", args[0]); + LOG_ERROR("couldn't register '%s' commands", args[0]); exit(-1); } @@ -998,8 +1186,8 @@ int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **a (*last_target_p)->endianness = TARGET_LITTLE_ENDIAN; else { - ERROR("endianness must be either 'little' or 'big', not '%s'", args[1]); - exit(-1); + LOG_ERROR("endianness must be either 'little' or 'big', not '%s'", args[1]); + return ERROR_COMMAND_SYNTAX_ERROR; } /* what to do on a target reset */ @@ -1015,14 +1203,15 @@ int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **a (*last_target_p)->reset_mode = RESET_RUN_AND_INIT; else { - ERROR("unknown target startup mode %s", args[2]); - exit(-1); + LOG_ERROR("unknown target startup mode %s", args[2]); + return ERROR_COMMAND_SYNTAX_ERROR; } (*last_target_p)->run_and_halt_time = 1000; /* default 1s */ (*last_target_p)->reset_script = NULL; (*last_target_p)->post_halt_script = NULL; (*last_target_p)->pre_resume_script = NULL; + (*last_target_p)->gdb_program_script = NULL; (*last_target_p)->working_area = 0x0; (*last_target_p)->working_area_size = 0x0; @@ -1030,6 +1219,7 @@ int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **a (*last_target_p)->backup_working_area = 0; (*last_target_p)->state = TARGET_UNKNOWN; + (*last_target_p)->debug_reason = DBG_REASON_UNDEFINED; (*last_target_p)->reg_cache = NULL; (*last_target_p)->breakpoints = NULL; (*last_target_p)->watchpoints = NULL; @@ -1047,7 +1237,8 @@ int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **a (*last_target_p)->trace_info->trace_history_overflowed = 0; (*last_target_p)->dbgmsg = NULL; - + (*last_target_p)->dbg_msg_enabled = 0; + (*last_target_p)->type->target_command(cmd_ctx, cmd, args, argc, *last_target_p); found = 1; @@ -1059,8 +1250,8 @@ int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **a /* no matching target found */ if (!found) { - ERROR("target '%s' not found", args[0]); - exit(-1); + LOG_ERROR("target '%s' not found", args[0]); + return ERROR_COMMAND_SYNTAX_ERROR; } return ERROR_OK; @@ -1073,16 +1264,15 @@ int handle_target_script_command(struct command_context_s *cmd_ctx, char *cmd, c if (argc < 3) { - ERROR("incomplete target_script command"); - exit(-1); + LOG_ERROR("incomplete target_script command"); + return ERROR_COMMAND_SYNTAX_ERROR; } target = get_target_by_num(strtoul(args[0], NULL, 0)); if (!target) { - ERROR("target number '%s' not defined", args[0]); - exit(-1); + return ERROR_COMMAND_SYNTAX_ERROR; } if (strcmp(args[1], "reset") == 0) @@ -1103,10 +1293,16 @@ int handle_target_script_command(struct command_context_s *cmd_ctx, char *cmd, c free(target->pre_resume_script); target->pre_resume_script = strdup(args[2]); } + else if (strcmp(args[1], "gdb_program_config") == 0) + { + if (target->gdb_program_script) + free(target->gdb_program_script); + target->gdb_program_script = strdup(args[2]); + } else { - ERROR("unknown event type: '%s", args[1]); - exit(-1); + LOG_ERROR("unknown event type: '%s", args[1]); + return ERROR_COMMAND_SYNTAX_ERROR; } return ERROR_OK; @@ -1118,16 +1314,13 @@ int handle_run_and_halt_time_command(struct command_context_s *cmd_ctx, char *cm if (argc < 2) { - ERROR("incomplete run_and_halt_time command"); - exit(-1); + return ERROR_COMMAND_SYNTAX_ERROR; } target = get_target_by_num(strtoul(args[0], NULL, 0)); - if (!target) { - ERROR("target number '%s' not defined", args[0]); - exit(-1); + return ERROR_COMMAND_SYNTAX_ERROR; } target->run_and_halt_time = strtoul(args[1], NULL, 0); @@ -1139,21 +1332,23 @@ int handle_working_area_command(struct command_context_s *cmd_ctx, char *cmd, ch { target_t *target = NULL; - if (argc < 4) + if ((argc < 4) || (argc > 5)) { - ERROR("incomplete working_area command. usage: working_area
<'backup'|'nobackup'>"); - exit(-1); + return ERROR_COMMAND_SYNTAX_ERROR; } target = get_target_by_num(strtoul(args[0], NULL, 0)); - if (!target) { - ERROR("target number '%s' not defined", args[0]); - exit(-1); + return ERROR_COMMAND_SYNTAX_ERROR; } + target_free_all_working_areas(target); - target->working_area = strtoul(args[1], NULL, 0); + target->working_area_phys = target->working_area_virt = strtoul(args[1], NULL, 0); + if (argc == 5) + { + target->working_area_virt = strtoul(args[4], NULL, 0); + } target->working_area_size = strtoul(args[2], NULL, 0); if (strcmp(args[3], "backup") == 0) @@ -1166,8 +1361,8 @@ int handle_working_area_command(struct command_context_s *cmd_ctx, char *cmd, ch } else { - ERROR("unrecognized argument (%s)", args[3]); - exit(-1); + LOG_ERROR("unrecognized argument (%s)", args[3]); + return ERROR_COMMAND_SYNTAX_ERROR; } return ERROR_OK; @@ -1186,10 +1381,9 @@ int handle_target(void *priv) if (target->state != TARGET_HALTED) { if (target_continous_poll) - if ((retval = target->type->poll(target)) < 0) + if ((retval = target->type->poll(target)) != ERROR_OK) { - ERROR("couldn't poll target, exiting"); - exit(-1); + LOG_ERROR("couldn't poll target(%d). It's due for a reset.", retval); } } @@ -1206,7 +1400,7 @@ int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args int count = 0; char *value; - DEBUG("-"); + LOG_DEBUG("-"); target = get_current_target(cmd_ctx); @@ -1281,7 +1475,7 @@ int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type); if (arch_type == NULL) { - ERROR("BUG: encountered unregistered arch type"); + LOG_ERROR("BUG: encountered unregistered arch type"); return ERROR_OK; } arch_type->get(reg); @@ -1301,7 +1495,7 @@ int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type); if (arch_type == NULL) { - ERROR("BUG: encountered unregistered arch type"); + LOG_ERROR("BUG: encountered unregistered arch type"); return ERROR_OK; } @@ -1321,20 +1515,16 @@ int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args return ERROR_OK; } +static int wait_state(struct command_context_s *cmd_ctx, char *cmd, enum target_state state, int ms); + int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { target_t *target = get_current_target(cmd_ctx); - char buffer[512]; if (argc == 0) { - command_print(cmd_ctx, "target state: %s", target_state_strings[target->type->poll(target)]); - if (target->state == TARGET_HALTED) - { - target->type->arch_state(target, buffer, 512); - buffer[511] = 0; - command_print(cmd_ctx, "%s", buffer); - } + target->type->poll(target); + target_arch_state(target); } else { @@ -1346,6 +1536,10 @@ int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **arg { target_continous_poll = 0; } + else + { + command_print(cmd_ctx, "arg is \"on\" or \"off\""); + } } @@ -1354,38 +1548,58 @@ int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **arg int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { - target_t *target = get_current_target(cmd_ctx); - struct timeval timeout, now; + int ms = 5000; - gettimeofday(&timeout, NULL); - if (!argc) - timeval_add_time(&timeout, 5, 0); - else { + if (argc > 0) + { char *end; - timeval_add_time(&timeout, strtoul(args[0], &end, 0), 0); - if (*end) { - command_print(cmd_ctx, "usage: wait_halt [seconds]"); + ms = strtoul(args[0], &end, 0) * 1000; + if (*end) + { + command_print(cmd_ctx, "usage: %s [seconds]", cmd); return ERROR_OK; } } - command_print(cmd_ctx, "waiting for target halted..."); + return wait_state(cmd_ctx, cmd, TARGET_HALTED, ms); +} - while(target->type->poll(target)) +static void target_process_events(struct command_context_s *cmd_ctx) +{ + target_t *target = get_current_target(cmd_ctx); + target->type->poll(target); + target_call_timer_callbacks_now(); +} + +static int wait_state(struct command_context_s *cmd_ctx, char *cmd, enum target_state state, int ms) +{ + int retval; + struct timeval timeout, now; + int once=1; + gettimeofday(&timeout, NULL); + timeval_add_time(&timeout, 0, ms * 1000); + + target_t *target = get_current_target(cmd_ctx); + for (;;) { - if (target->state == TARGET_HALTED) + if ((retval=target->type->poll(target))!=ERROR_OK) + return retval; + target_call_timer_callbacks_now(); + if (target->state == state) { - command_print(cmd_ctx, "target halted"); break; } - target_call_timer_callbacks(); + if (once) + { + once=0; + command_print(cmd_ctx, "waiting for target %s...", target_state_strings[state]); + } gettimeofday(&now, NULL); - if ((now.tv_sec >= timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec)) + if ((now.tv_sec > timeout.tv_sec) || ((now.tv_sec == timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec))) { - command_print(cmd_ctx, "timed out while waiting for target halt"); - ERROR("timed out while waiting for target halt"); + LOG_ERROR("timed out while waiting for target %s", target_state_strings[state]); break; } } @@ -1398,28 +1612,14 @@ int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **arg int retval; target_t *target = get_current_target(cmd_ctx); - DEBUG("-"); - - command_print(cmd_ctx, "requesting target halt..."); + LOG_DEBUG("-"); if ((retval = target->type->halt(target)) != ERROR_OK) - { - switch (retval) - { - case ERROR_TARGET_ALREADY_HALTED: - command_print(cmd_ctx, "target already halted"); - break; - case ERROR_TARGET_TIMEOUT: - command_print(cmd_ctx, "target timed out... shutting down"); - exit(-1); - default: - command_print(cmd_ctx, "unknown error... shutting down"); - exit(-1); - } + { + return retval; } - return ERROR_OK; - + return handle_wait_halt_command(cmd_ctx, cmd, args, argc); } /* what to do on daemon startup */ @@ -1439,7 +1639,7 @@ int handle_daemon_startup_command(struct command_context_s *cmd_ctx, char *cmd, } } - WARNING("invalid daemon_startup configuration directive: %s", args[0]); + LOG_WARNING("invalid daemon_startup configuration directive: %s", args[0]); return ERROR_OK; } @@ -1447,22 +1647,10 @@ int handle_daemon_startup_command(struct command_context_s *cmd_ctx, char *cmd, int handle_soft_reset_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { target_t *target = get_current_target(cmd_ctx); - int retval; - command_print(cmd_ctx, "requesting target halt and executing a soft reset"); + LOG_USER("requesting target halt and executing a soft reset"); - if ((retval = target->type->soft_reset_halt(target)) != ERROR_OK) - { - switch (retval) - { - case ERROR_TARGET_TIMEOUT: - command_print(cmd_ctx, "target timed out... shutting down"); - exit(-1); - default: - command_print(cmd_ctx, "unknown error... shutting down"); - exit(-1); - } - } + target->type->soft_reset_halt(target); return ERROR_OK; } @@ -1470,9 +1658,10 @@ int handle_soft_reset_halt_command(struct command_context_s *cmd_ctx, char *cmd, int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { target_t *target = get_current_target(cmd_ctx); - enum target_reset_mode reset_mode = RESET_RUN; + enum target_reset_mode reset_mode = target->reset_mode; + enum target_reset_mode save = target->reset_mode; - DEBUG("-"); + LOG_DEBUG("-"); if (argc >= 1) { @@ -1503,11 +1692,17 @@ int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **ar command_print(cmd_ctx, "usage: reset ['run', 'halt', 'init', 'run_and_halt', 'run_and_init]"); return ERROR_OK; } - target->reset_mode = reset_mode; } + /* temporarily modify mode of current reset target */ + target->reset_mode = reset_mode; + + /* reset *all* targets */ target_process_reset(cmd_ctx); + /* Restore default reset mode for this target */ + target->reset_mode = save; + return ERROR_OK; } @@ -1516,39 +1711,25 @@ int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **a int retval; target_t *target = get_current_target(cmd_ctx); - DEBUG("-"); - if (argc == 0) retval = target->type->resume(target, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */ else if (argc == 1) retval = target->type->resume(target, 0, strtoul(args[0], NULL, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */ else { - command_print(cmd_ctx, "usage: resume [address]"); - return ERROR_OK; - } - - if (retval != ERROR_OK) - { - switch (retval) - { - case ERROR_TARGET_NOT_HALTED: - command_print(cmd_ctx, "target not halted"); - break; - default: - command_print(cmd_ctx, "unknown error... shutting down"); - exit(-1); - } + return ERROR_COMMAND_SYNTAX_ERROR; } - return ERROR_OK; + target_process_events(cmd_ctx); + + return retval; } int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { target_t *target = get_current_target(cmd_ctx); - DEBUG("-"); + LOG_DEBUG("-"); if (argc == 0) target->type->step(target, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */ @@ -1561,9 +1742,11 @@ int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, char **arg int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { + const int line_bytecnt = 32; int count = 1; int size = 4; u32 address = 0; + int line_modulo; int i; char output[128]; @@ -1586,64 +1769,51 @@ int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, switch (cmd[2]) { case 'w': - size = 4; + size = 4; line_modulo = line_bytecnt / 4; break; case 'h': - size = 2; + size = 2; line_modulo = line_bytecnt / 2; break; case 'b': - size = 1; + size = 1; line_modulo = line_bytecnt / 1; break; default: return ERROR_OK; } buffer = calloc(count, size); - if ((retval = target->type->read_memory(target, address, size, count, buffer)) != ERROR_OK) + retval = target->type->read_memory(target, address, size, count, buffer); + if (retval == ERROR_OK) { - switch (retval) + output_len = 0; + + for (i = 0; i < count; i++) { - case ERROR_TARGET_UNALIGNED_ACCESS: - command_print(cmd_ctx, "error: address not aligned"); - break; - case ERROR_TARGET_NOT_HALTED: - command_print(cmd_ctx, "error: target must be halted for memory accesses"); - break; - case ERROR_TARGET_DATA_ABORT: - command_print(cmd_ctx, "error: access caused data abort, system possibly corrupted"); - break; - default: - command_print(cmd_ctx, "error: unknown error"); - break; + if (i%line_modulo == 0) + output_len += snprintf(output + output_len, 128 - output_len, "0x%8.8x: ", address + (i*size)); + + switch (size) + { + case 4: + output_len += snprintf(output + output_len, 128 - output_len, "%8.8x ", target_buffer_get_u32(target, &buffer[i*4])); + break; + case 2: + output_len += snprintf(output + output_len, 128 - output_len, "%4.4x ", target_buffer_get_u16(target, &buffer[i*2])); + break; + case 1: + output_len += snprintf(output + output_len, 128 - output_len, "%2.2x ", buffer[i*1]); + break; + } + + if ((i%line_modulo == line_modulo-1) || (i == count - 1)) + { + command_print(cmd_ctx, output); + output_len = 0; + } } - return ERROR_OK; - } - - output_len = 0; - - for (i = 0; i < count; i++) + } else { - if (i%8 == 0) - output_len += snprintf(output + output_len, 128 - output_len, "0x%8.8x: ", address + (i*size)); - - switch (size) - { - case 4: - output_len += snprintf(output + output_len, 128 - output_len, "%8.8x ", target_buffer_get_u32(target, &buffer[i*4])); - break; - case 2: - output_len += snprintf(output + output_len, 128 - output_len, "%4.4x ", target_buffer_get_u16(target, &buffer[i*2])); - break; - case 1: - output_len += snprintf(output + output_len, 128 - output_len, "%2.2x ", buffer[i*1]); - break; - } - - if ((i%8 == 7) || (i == count - 1)) - { - command_print(cmd_ctx, output); - output_len = 0; - } + LOG_ERROR("Failure examining memory"); } free(buffer); @@ -1655,50 +1825,59 @@ int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args, { u32 address = 0; u32 value = 0; - int retval; + int count = 1; + int i; + int wordsize; target_t *target = get_current_target(cmd_ctx); u8 value_buf[4]; - if (argc < 2) - return ERROR_OK; + if ((argc < 2) || (argc > 3)) + return ERROR_COMMAND_SYNTAX_ERROR; address = strtoul(args[0], NULL, 0); value = strtoul(args[1], NULL, 0); + if (argc == 3) + count = strtoul(args[2], NULL, 0); + switch (cmd[2]) { case 'w': + wordsize = 4; target_buffer_set_u32(target, value_buf, value); - retval = target->type->write_memory(target, address, 4, 1, value_buf); break; case 'h': + wordsize = 2; target_buffer_set_u16(target, value_buf, value); - retval = target->type->write_memory(target, address, 2, 1, value_buf); break; case 'b': + wordsize = 1; value_buf[0] = value; - retval = target->type->write_memory(target, address, 1, 1, value_buf); break; default: - return ERROR_OK; + return ERROR_COMMAND_SYNTAX_ERROR; } - - switch (retval) + for (i=0; itype->write_memory(target, address + i*wordsize, 4, 1, value_buf); + break; + case 2: + retval = target->type->write_memory(target, address + i*wordsize, 2, 1, value_buf); + break; + case 1: + retval = target->type->write_memory(target, address + i*wordsize, 1, 1, value_buf); break; + default: + return ERROR_OK; + } + if (retval!=ERROR_OK) + { + return retval; + } } return ERROR_OK; @@ -1743,23 +1922,30 @@ int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char if (image_open(&image, args[0], (argc >= 3) ? args[2] : NULL) != ERROR_OK) { - command_print(cmd_ctx, "load_image error: %s", image.error_str); return ERROR_OK; } image_size = 0x0; + retval = ERROR_OK; for (i = 0; i < image.num_sections; i++) { buffer = malloc(image.sections[i].size); + if (buffer == NULL) + { + command_print(cmd_ctx, "error allocating buffer for section (%d bytes)", image.sections[i].size); + break; + } + if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK) { - ERROR("image_read_section failed with error code: %i", retval); - command_print(cmd_ctx, "image reading failed, download aborted"); free(buffer); - image_close(&image); - return ERROR_OK; + break; + } + if ((retval = target_write_buffer(target, image.sections[i].base_address, buf_cnt, buffer)) != ERROR_OK) + { + free(buffer); + break; } - target_write_buffer(target, image.sections[i].base_address, buf_cnt, buffer); image_size += buf_cnt; command_print(cmd_ctx, "%u byte written at address 0x%8.8x", buf_cnt, image.sections[i].base_address); @@ -1767,12 +1953,15 @@ int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char } duration_stop_measure(&duration, &duration_text); - command_print(cmd_ctx, "downloaded %u byte in %s", image_size, duration_text); + if (retval==ERROR_OK) + { + command_print(cmd_ctx, "downloaded %u byte in %s", image_size, duration_text); + } free(duration_text); image_close(&image); - return ERROR_OK; + return retval; } @@ -1783,6 +1972,7 @@ int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char u32 address; u32 size; u8 buffer[560]; + int retval=ERROR_OK; duration_t duration; char *duration_text; @@ -1806,7 +1996,6 @@ int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char if (fileio_open(&fileio, args[0], FILEIO_WRITE, FILEIO_BINARY) != ERROR_OK) { - command_print(cmd_ctx, "dump_image error: %s", fileio.error_str); return ERROR_OK; } @@ -1817,8 +2006,17 @@ int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char u32 size_written; u32 this_run_size = (size > 560) ? 560 : size; - target->type->read_memory(target, address, 4, this_run_size / 4, buffer); - fileio_write(&fileio, this_run_size, buffer, &size_written); + retval = target->type->read_memory(target, address, 4, this_run_size / 4, buffer); + if (retval != ERROR_OK) + { + break; + } + + retval = fileio_write(&fileio, this_run_size, buffer, &size_written); + if (retval != ERROR_OK) + { + break; + } size -= this_run_size; address += this_run_size; @@ -1827,11 +2025,13 @@ int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char fileio_close(&fileio); duration_stop_measure(&duration, &duration_text); - command_print(cmd_ctx, "dumped %"PRIi64" byte in %s", fileio.size, duration_text); + if (retval==ERROR_OK) + { + command_print(cmd_ctx, "dumped %"PRIi64" byte in %s", fileio.size, duration_text); + } free(duration_text); return ERROR_OK; - } int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) @@ -1853,14 +2053,13 @@ int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, ch if (argc < 1) { - command_print(cmd_ctx, "usage: verify_image [offset] [type]"); - return ERROR_OK; + return ERROR_COMMAND_SYNTAX_ERROR; } if (!target) { - ERROR("no target selected"); - return ERROR_OK; + LOG_ERROR("no target selected"); + return ERROR_FAIL; } duration_start_measure(&duration); @@ -1875,58 +2074,91 @@ int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, ch image.base_address_set = 0; image.base_address = 0x0; } - + image.start_address_set = 0; - if (image_open(&image, args[0], (argc == 3) ? args[2] : NULL) != ERROR_OK) + if ((retval=image_open(&image, args[0], (argc == 3) ? args[2] : NULL)) != ERROR_OK) { - command_print(cmd_ctx, "verify_image error: %s", image.error_str); - return ERROR_OK; + return retval; } image_size = 0x0; + retval=ERROR_OK; for (i = 0; i < image.num_sections; i++) { buffer = malloc(image.sections[i].size); + if (buffer == NULL) + { + command_print(cmd_ctx, "error allocating buffer for section (%d bytes)", image.sections[i].size); + break; + } if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK) { - ERROR("image_read_section failed with error code: %i", retval); - command_print(cmd_ctx, "image reading failed, verify aborted"); free(buffer); - image_close(&image); - return ERROR_OK; + break; } /* calculate checksum of image */ image_calculate_checksum( buffer, buf_cnt, &checksum ); - free(buffer); retval = target_checksum_memory(target, image.sections[i].base_address, buf_cnt, &mem_checksum); - if( retval != ERROR_OK ) { - command_print(cmd_ctx, "image verify failed, verify aborted"); - image_close(&image); - return ERROR_OK; + free(buffer); + break; } if( checksum != mem_checksum ) { - command_print(cmd_ctx, "image verify failed, verify aborted"); - image_close(&image); - return ERROR_OK; - } + /* failed crc checksum, fall back to a binary compare */ + u8 *data; + + command_print(cmd_ctx, "checksum mismatch - attempting binary compare"); + + data = (u8*)malloc(buf_cnt); + + /* Can we use 32bit word accesses? */ + int size = 1; + int count = buf_cnt; + if ((count % 4) == 0) + { + size *= 4; + count /= 4; + } + retval = target->type->read_memory(target, image.sections[i].base_address, size, count, data); + if (retval == ERROR_OK) + { + int t; + for (t = 0; t < buf_cnt; t++) + { + if (data[t] != buffer[t]) + { + command_print(cmd_ctx, "Verify operation failed address 0x%08x. Was 0x%02x instead of 0x%02x\n", t + image.sections[i].base_address, data[t], buffer[t]); + free(data); + free(buffer); + retval=ERROR_FAIL; + goto done; + } + } + } + free(data); + } + + free(buffer); image_size += buf_cnt; } - +done: duration_stop_measure(&duration, &duration_text); - command_print(cmd_ctx, "verified %u bytes in %s", image_size, duration_text); + if (retval==ERROR_OK) + { + command_print(cmd_ctx, "verified %u bytes in %s", image_size, duration_text); + } free(duration_text); image_close(&image); - return ERROR_OK; + return retval; } int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) @@ -1966,18 +2198,7 @@ int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, if ((retval = breakpoint_add(target, strtoul(args[0], NULL, 0), length, hw)) != ERROR_OK) { - switch (retval) - { - case ERROR_TARGET_NOT_HALTED: - command_print(cmd_ctx, "target must be halted to set breakpoints"); - break; - case ERROR_TARGET_RESOURCE_NOT_AVAILABLE: - command_print(cmd_ctx, "no more breakpoints available"); - break; - default: - command_print(cmd_ctx, "unknown error, breakpoint not set"); - break; - } + LOG_ERROR("Failure setting breakpoints"); } else { @@ -2053,18 +2274,7 @@ int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, if ((retval = watchpoint_add(target, strtoul(args[0], NULL, 0), strtoul(args[1], NULL, 0), type, data_value, data_mask)) != ERROR_OK) { - switch (retval) - { - case ERROR_TARGET_NOT_HALTED: - command_print(cmd_ctx, "target must be halted to set watchpoints"); - break; - case ERROR_TARGET_RESOURCE_NOT_AVAILABLE: - command_print(cmd_ctx, "no more watchpoints available"); - break; - default: - command_print(cmd_ctx, "unknown error, watchpoint not set"); - break; - } + LOG_ERROR("Failure setting breakpoints"); } } else @@ -2085,3 +2295,215 @@ int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char **args return ERROR_OK; } +int handle_virt2phys_command(command_context_t *cmd_ctx, char *cmd, char **args, int argc) +{ + int retval; + target_t *target = get_current_target(cmd_ctx); + u32 va; + u32 pa; + + if (argc != 1) + { + return ERROR_COMMAND_SYNTAX_ERROR; + } + va = strtoul(args[0], NULL, 0); + + retval = target->type->virt2phys(target, va, &pa); + if (retval == ERROR_OK) + { + command_print(cmd_ctx, "Physical address 0x%08x", pa); + } + else + { + /* lower levels will have logged a detailed error which is + * forwarded to telnet/GDB session. + */ + } + return retval; +} +static void writeLong(FILE *f, int l) +{ + int i; + for (i=0; i<4; i++) + { + char c=(l>>(i*8))&0xff; + fwrite(&c, 1, 1, f); + } + +} +static void writeString(FILE *f, char *s) +{ + fwrite(s, 1, strlen(s), f); +} + + + +// Dump a gmon.out histogram file. +static void writeGmon(u32 *samples, int sampleNum, char *filename) +{ + int i; + FILE *f=fopen(filename, "w"); + if (f==NULL) + return; + fwrite("gmon", 1, 4, f); + writeLong(f, 0x00000001); // Version + writeLong(f, 0); // padding + writeLong(f, 0); // padding + writeLong(f, 0); // padding + + fwrite("", 1, 1, f); // GMON_TAG_TIME_HIST + + // figure out bucket size + u32 min=samples[0]; + u32 max=samples[0]; + for (i=0; isamples[i]) + { + min=samples[i]; + } + if (max maxBuckets) + { + length=maxBuckets; + } + int *buckets=malloc(sizeof(int)*length); + if (buckets==NULL) + { + fclose(f); + return; + } + memset(buckets, 0, sizeof(int)*length); + for (i=0; i65535) + { + val=65535; + } + data[i*2]=val&0xff; + data[i*2+1]=(val>>8)&0xff; + } + free(buckets); + fwrite(data, 1, length*2, f); + free(data); + } else + { + free(buckets); + } + + fclose(f); +} + +/* profiling samples the CPU PC as quickly as OpenOCD is able, which will be used as a random sampling of PC */ +int handle_profile_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +{ + target_t *target = get_current_target(cmd_ctx); + struct timeval timeout, now; + + gettimeofday(&timeout, NULL); + if (argc!=2) + { + return ERROR_COMMAND_SYNTAX_ERROR; + } + char *end; + timeval_add_time(&timeout, strtoul(args[0], &end, 0), 0); + if (*end) + { + return ERROR_OK; + } + + command_print(cmd_ctx, "Starting profiling. Halting and resuming the target as often as we can..."); + + static const int maxSample=10000; + u32 *samples=malloc(sizeof(u32)*maxSample); + if (samples==NULL) + return ERROR_OK; + + int numSamples=0; + int retval=ERROR_OK; + // hopefully it is safe to cache! We want to stop/restart as quickly as possible. + reg_t *reg = register_get_by_name(target->reg_cache, "pc", 1); + + for (;;) + { + target->type->poll(target); + if (target->state == TARGET_HALTED) + { + u32 t=*((u32 *)reg->value); + samples[numSamples++]=t; + retval = target->type->resume(target, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */ + target->type->poll(target); + usleep(10*1000); // sleep 10ms, i.e. <100 samples/second. + } else if (target->state == TARGET_RUNNING) + { + // We want to quickly sample the PC. + target->type->halt(target); + } else + { + command_print(cmd_ctx, "Target not halted or running"); + retval=ERROR_OK; + break; + } + if (retval!=ERROR_OK) + { + break; + } + + gettimeofday(&now, NULL); + if ((numSamples>=maxSample) || ((now.tv_sec >= timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec))) + { + command_print(cmd_ctx, "Profiling completed. %d samples.", numSamples); + target->type->poll(target); + if (target->state == TARGET_HALTED) + { + target->type->resume(target, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */ + } + target->type->poll(target); + writeGmon(samples, numSamples, args[1]); + command_print(cmd_ctx, "Wrote %s", args[1]); + break; + } + } + free(samples); + + return ERROR_OK; +} +