X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Ftarget%2Ftarget.c;h=de78695849a156face981a8a350f056feeeff007;hp=61fac56b23ae336021800bf834eae9e53c1c85b7;hb=d47e1b8f362379d8a2307f49e2b42115a3f40524;hpb=4febcd8313cf46bea03bd5eacb3f287f19eb2961 diff --git a/src/target/target.c b/src/target/target.c index 61fac56b23..de78695849 100644 --- a/src/target/target.c +++ b/src/target/target.c @@ -76,6 +76,7 @@ int handle_rbp_command(struct command_context_s *cmd_ctx, char *cmd, char **args 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 */ @@ -122,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[] = @@ -210,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); } @@ -229,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 = open_file_from_path(cmd_ctx, 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); @@ -260,7 +261,9 @@ 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) @@ -270,11 +273,11 @@ int target_process_reset(struct command_context_s *cmd_ctx) switch (target->reset_mode) { case RESET_HALT: - command_print(cmd_ctx, "nSRST pulls nTRST, falling back to RESET_RUN_AND_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"); + command_print(cmd_ctx, "nSRST pulls nTRST, falling back to \"reset run_and_init\""); target->reset_mode = RESET_RUN_AND_INIT; break; default: @@ -327,7 +330,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; } @@ -339,7 +342,7 @@ int target_process_reset(struct command_context_s *cmd_ctx) target = target->next; } jtag_execute_queue(); - + /* Wait for reset to complete, maximum 5 seconds. */ gettimeofday(&timeout, NULL); timeval_add_time(&timeout, 5, 0); @@ -347,7 +350,7 @@ int target_process_reset(struct command_context_s *cmd_ctx) { gettimeofday(&now, NULL); - target_call_timer_callbacks(); + target_call_timer_callbacks_now(); target = targets; while (target) @@ -359,10 +362,12 @@ int target_process_reset(struct command_context_s *cmd_ctx) { 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 waiting for reset"); + LOG_USER("Timed out waiting for reset"); goto done; } - usleep(100*1000); /* Do not eat all cpu */ + /* 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; } } @@ -377,7 +382,9 @@ int target_process_reset(struct command_context_s *cmd_ctx) /* We want any events to be processed before the prompt */ - target_call_timer_callbacks(); + target_call_timer_callbacks_now(); + + jtag->speed(jtag_speed_post_reset); return retval; } @@ -402,7 +409,7 @@ 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); } @@ -556,7 +563,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) { @@ -606,6 +613,16 @@ int target_call_timer_callbacks() return ERROR_OK; } +int target_call_timer_callbacks_now() +{ + /* TODO: this should invoke the timer callbacks now. This is used to ensure that + * any outstanding polls, etc. are in fact invoked before a synchronous command + * completes. + */ + return target_call_timer_callbacks(); +} + + int target_alloc_working_area(struct target_s *target, u32 size, working_area_t **area) { working_area_t *c = target->working_areas; @@ -634,7 +651,7 @@ int target_alloc_working_area(struct target_s *target, u32 size, working_area_t /* 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); } @@ -656,7 +673,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) @@ -669,7 +686,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(requested %d, free %d)", size, free_size); + LOG_WARNING("not enough working area available(requested %d, free %d)", size, free_size); return ERROR_TARGET_RESOURCE_NOT_AVAILABLE; } @@ -747,9 +764,10 @@ int target_register_commands(struct command_context_s *cmd_ctx) 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, "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; } @@ -759,11 +777,11 @@ int target_arch_state(struct target_s *target) int retval; if (target==NULL) { - USER("No target has been configured"); + LOG_USER("No target has been configured"); return ERROR_OK; } - USER("target state: %s", target_state_strings[target->state]); + LOG_USER("target state: %s", target_state_strings[target->state]); if (target->state!=TARGET_HALTED) return ERROR_OK; @@ -780,7 +798,7 @@ int target_write_buffer(struct target_s *target, u32 address, u32 size, u8 *buff { 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); if (((address % 2) == 0) && (size == 2)) { @@ -844,7 +862,7 @@ int target_read_buffer(struct target_s *target, u32 address, u32 size, u8 *buffe { 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); if (((address % 2) == 0) && (size == 2)) { @@ -903,7 +921,7 @@ int target_checksum_memory(struct target_s *target, u32 address, u32 size, u32* buffer = malloc(size); if (buffer == NULL) { - ERROR("error allocating buffer for section (%d bytes)", size); + LOG_ERROR("error allocating buffer for section (%d bytes)", size); return ERROR_INVALID_ARGUMENTS; } retval = target_read_buffer(target, address, size, buffer); @@ -939,12 +957,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; @@ -959,12 +977,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; @@ -976,12 +994,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; @@ -992,12 +1010,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; @@ -1008,12 +1026,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; @@ -1023,11 +1041,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; @@ -1108,8 +1126,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 */ @@ -1124,7 +1141,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); } @@ -1145,8 +1162,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 */ @@ -1162,8 +1179,8 @@ 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 */ @@ -1178,6 +1195,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; @@ -1208,8 +1226,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; @@ -1222,16 +1240,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) @@ -1260,8 +1277,8 @@ int handle_target_script_command(struct command_context_s *cmd_ctx, char *cmd, c } 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; @@ -1273,16 +1290,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); @@ -1300,11 +1314,9 @@ int handle_working_area_command(struct command_context_s *cmd_ctx, char *cmd, ch } 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); @@ -1325,7 +1337,7 @@ int handle_working_area_command(struct command_context_s *cmd_ctx, char *cmd, ch } else { - ERROR("unrecognized argument (%s)", args[3]); + LOG_ERROR("unrecognized argument (%s)", args[3]); return ERROR_COMMAND_SYNTAX_ERROR; } @@ -1347,7 +1359,7 @@ int handle_target(void *priv) if (target_continous_poll) if ((retval = target->type->poll(target)) != ERROR_OK) { - ERROR("couldn't poll target(%d). It's due for a reset.", retval); + LOG_ERROR("couldn't poll target(%d). It's due for a reset.", retval); } } @@ -1364,7 +1376,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); @@ -1439,7 +1451,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); @@ -1459,7 +1471,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; } @@ -1488,7 +1500,7 @@ int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **arg if (argc == 0) { target->type->poll(target); - target_arch_state(target); + target_arch_state(target); } else { @@ -1533,14 +1545,14 @@ 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(); + 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); @@ -1549,18 +1561,21 @@ static int wait_state(struct command_context_s *cmd_ctx, char *cmd, enum target_ { if ((retval=target->type->poll(target))!=ERROR_OK) return retval; - target_call_timer_callbacks(); + target_call_timer_callbacks_now(); if (target->state == state) { break; } - command_print(cmd_ctx, "waiting for target %s...", target_state_strings[state]); + 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_sec == timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec))) { - command_print(cmd_ctx, "timed out while waiting for target %s", target_state_strings[state]); - ERROR("timed out while waiting for target %s", target_state_strings[state]); + LOG_ERROR("timed out while waiting for target %s", target_state_strings[state]); break; } } @@ -1573,24 +1588,11 @@ 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"); - return retval; - default: - command_print(cmd_ctx, "unknown error... shutting down"); - return retval; - } + { + return retval; } return handle_wait_halt_command(cmd_ctx, cmd, args, argc); @@ -1613,7 +1615,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; } @@ -1621,22 +1623,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; } @@ -1647,7 +1637,7 @@ int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **ar enum target_reset_mode reset_mode = target->reset_mode; enum target_reset_mode save = target->reset_mode; - DEBUG("-"); + LOG_DEBUG("-"); if (argc >= 1) { @@ -1708,8 +1698,6 @@ int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **a target_process_events(cmd_ctx); - target_arch_state(target); - return retval; } @@ -1717,7 +1705,7 @@ int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, char **arg { 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 */ @@ -1771,51 +1759,37 @@ int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, buffer = calloc(count, size); retval = target->type->read_memory(target, address, size, count, buffer); - if (retval != ERROR_OK) + 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%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; - } + LOG_ERROR("Failure examining memory"); } free(buffer); @@ -1854,23 +1828,9 @@ int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args, default: return ERROR_OK; } - - switch (retval) + if (retval!=ERROR_OK) { - case ERROR_TARGET_UNALIGNED_ACCESS: - command_print(cmd_ctx, "error: address not aligned"); - break; - case ERROR_TARGET_DATA_ABORT: - command_print(cmd_ctx, "error: access caused data abort, system possibly corrupted"); - break; - case ERROR_TARGET_NOT_HALTED: - command_print(cmd_ctx, "error: target must be halted for memory accesses"); - break; - case ERROR_OK: - break; - default: - command_print(cmd_ctx, "error: unknown error"); - break; + LOG_ERROR("Failure examining memory"); } return ERROR_OK; @@ -1915,11 +1875,11 @@ 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); @@ -1931,13 +1891,14 @@ int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char 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); @@ -1945,12 +1906,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; } @@ -1961,7 +1925,7 @@ int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char u32 address; u32 size; u8 buffer[560]; - int retval; + int retval=ERROR_OK; duration_t duration; char *duration_text; @@ -1985,7 +1949,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; } @@ -1999,11 +1962,14 @@ int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char retval = target->type->read_memory(target, address, 4, this_run_size / 4, buffer); if (retval != ERROR_OK) { - command_print(cmd_ctx, "Reading memory failed %d", retval); break; } - fileio_write(&fileio, this_run_size, buffer, &size_written); + retval = fileio_write(&fileio, this_run_size, buffer, &size_written); + if (retval != ERROR_OK) + { + break; + } size -= this_run_size; address += this_run_size; @@ -2012,7 +1978,10 @@ 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; @@ -2043,7 +2012,7 @@ int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, ch if (!target) { - ERROR("no target selected"); + LOG_ERROR("no target selected"); return ERROR_OK; } @@ -2064,11 +2033,11 @@ int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, ch if (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; } image_size = 0x0; + retval=ERROR_OK; for (i = 0; i < image.num_sections; i++) { buffer = malloc(image.sections[i].size); @@ -2079,24 +2048,18 @@ int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, ch } 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 ); retval = target_checksum_memory(target, image.sections[i].base_address, buf_cnt, &mem_checksum); - if( retval != ERROR_OK ) { - command_print(cmd_ctx, "could not calculate checksum, verify aborted"); free(buffer); - image_close(&image); - return ERROR_OK; + break; } if( checksum != mem_checksum ) @@ -2117,7 +2080,6 @@ int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, ch count /= 4; } retval = target->type->read_memory(target, image.sections[i].base_address, size, count, data); - if (retval == ERROR_OK) { int t; @@ -2128,8 +2090,8 @@ int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, ch 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); - image_close(&image); - return ERROR_OK; + retval=ERROR_FAIL; + goto done; } } } @@ -2140,14 +2102,17 @@ int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, ch 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) @@ -2187,18 +2152,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 { @@ -2274,18 +2228,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 @@ -2332,3 +2275,189 @@ int handle_virt2phys_command(command_context_t *cmd_ctx, char *cmd, char **args, } 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; +} +