Code Review / openocd.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | review | tree
raw | inline | side by side
target/xtensa: avoid IHI for writes to non-executable memory
[openocd.git] / src / target / breakpoints.c
diff --git a/src/target/breakpoints.c b/src/target/breakpoints.c
index 5ce0346bb4664d2eba05b07b89d091518e2a0781..c39a9805701ab90d49232a2713b020d81fd4f4f5 100644 (file)
--- a/src/target/breakpoints.c
+++ b/src/target/breakpoints.c
@@ -17,6 +17,11 @@
 #include "breakpoints.h"
 #include "smp.h"
 
+enum breakpoint_watchpoint {
+       BREAKPOINT,
+       WATCHPOINT,
+};
+
 static const char * const breakpoint_type_strings[] = {
        "hardware",
        "software"
@@ -47,7 +52,7 @@ static int breakpoint_add_internal(struct target *target,
                         * breakpoint" ... check all the parameters before
                         * succeeding.
                         */
-                       LOG_ERROR("Duplicate Breakpoint address: " TARGET_ADDR_FMT " (BP %" PRIu32 ")",
+                       LOG_TARGET_ERROR(target, "Duplicate Breakpoint address: " TARGET_ADDR_FMT " (BP %" PRIu32 ")",
                                address, breakpoint->unique_id);
                        return ERROR_TARGET_DUPLICATE_BREAKPOINT;
                }
@@ -78,16 +83,15 @@ static int breakpoint_add_internal(struct target *target,
                default:
                        reason = "unknown reason";
 fail:
-                       LOG_ERROR("can't add breakpoint: %s", reason);
+                       LOG_TARGET_ERROR(target, "can't add breakpoint: %s", reason);
                        free((*breakpoint_p)->orig_instr);
                        free(*breakpoint_p);
                        *breakpoint_p = NULL;
                        return retval;
        }
 
-       LOG_DEBUG("[%d] added %s breakpoint at " TARGET_ADDR_FMT
+       LOG_TARGET_DEBUG(target, "added %s breakpoint at " TARGET_ADDR_FMT
                        " of length 0x%8.8x, (BPID: %" PRIu32 ")",
-               target->coreid,
                breakpoint_type_strings[(*breakpoint_p)->type],
                (*breakpoint_p)->address, (*breakpoint_p)->length,
                (*breakpoint_p)->unique_id);
@@ -129,14 +133,14 @@ static int context_breakpoint_add_internal(struct target *target,
        (*breakpoint_p)->unique_id = bpwp_unique_id++;
        retval = target_add_context_breakpoint(target, *breakpoint_p);
        if (retval != ERROR_OK) {
-               LOG_ERROR("could not add breakpoint");
+               LOG_TARGET_ERROR(target, "could not add breakpoint");
                free((*breakpoint_p)->orig_instr);
                free(*breakpoint_p);
                *breakpoint_p = NULL;
                return retval;
        }
 
-       LOG_DEBUG("added %s Context breakpoint at 0x%8.8" PRIx32 " of length 0x%8.8x, (BPID: %" PRIu32 ")",
+       LOG_TARGET_DEBUG(target, "added %s Context breakpoint at 0x%8.8" PRIx32 " of length 0x%8.8x, (BPID: %" PRIu32 ")",
                breakpoint_type_strings[(*breakpoint_p)->type],
                (*breakpoint_p)->asid, (*breakpoint_p)->length,
                (*breakpoint_p)->unique_id);
@@ -160,11 +164,11 @@ static int hybrid_breakpoint_add_internal(struct target *target,
                         * breakpoint" ... check all the parameters before
                         * succeeding.
                         */
-                       LOG_ERROR("Duplicate Hybrid Breakpoint asid: 0x%08" PRIx32 " (BP %" PRIu32 ")",
+                       LOG_TARGET_ERROR(target, "Duplicate Hybrid Breakpoint asid: 0x%08" PRIx32 " (BP %" PRIu32 ")",
                                asid, breakpoint->unique_id);
                        return ERROR_TARGET_DUPLICATE_BREAKPOINT;
                } else if ((breakpoint->address == address) && (breakpoint->asid == 0)) {
-                       LOG_ERROR("Duplicate Breakpoint IVA: " TARGET_ADDR_FMT " (BP %" PRIu32 ")",
+                       LOG_TARGET_ERROR(target, "Duplicate Breakpoint IVA: " TARGET_ADDR_FMT " (BP %" PRIu32 ")",
                                address, breakpoint->unique_id);
                        return ERROR_TARGET_DUPLICATE_BREAKPOINT;
 
@@ -185,13 +189,13 @@ static int hybrid_breakpoint_add_internal(struct target *target,
 
        retval = target_add_hybrid_breakpoint(target, *breakpoint_p);
        if (retval != ERROR_OK) {
-               LOG_ERROR("could not add breakpoint");
+               LOG_TARGET_ERROR(target, "could not add breakpoint");
                free((*breakpoint_p)->orig_instr);
                free(*breakpoint_p);
                *breakpoint_p = NULL;
                return retval;
        }
-       LOG_DEBUG(
+       LOG_TARGET_DEBUG(target,
                "added %s Hybrid breakpoint at address " TARGET_ADDR_FMT " of length 0x%8.8x, (BPID: %" PRIu32 ")",
                breakpoint_type_strings[(*breakpoint_p)->type],
                (*breakpoint_p)->address,
@@ -293,7 +297,7 @@ static int breakpoint_free(struct target *target, struct breakpoint *breakpoint_
                return retval;
        }
 
-       LOG_DEBUG("free BPID: %" PRIu32 " --> %d", breakpoint->unique_id, retval);
+       LOG_TARGET_DEBUG(target, "free BPID: %" PRIu32 " --> %d", breakpoint->unique_id, retval);
        (*breakpoint_p) = breakpoint->next;
        free(breakpoint->orig_instr);
        free(breakpoint);
@@ -321,6 +325,8 @@ static int breakpoint_remove_internal(struct target *target, target_addr_t addre
 
 static int breakpoint_remove_all_internal(struct target *target)
 {
+       LOG_TARGET_DEBUG(target, "Delete all breakpoints");
+
        struct breakpoint *breakpoint = target->breakpoints;
        int retval = ERROR_OK;
 
@@ -367,46 +373,96 @@ int breakpoint_remove(struct target *target, target_addr_t address)
                }
        }
 
-       if (num_found_breakpoints == 0)
+       if (num_found_breakpoints == 0) {
                LOG_TARGET_ERROR(target, "no breakpoint at address " TARGET_ADDR_FMT " found", address);
+               return ERROR_BREAKPOINT_NOT_FOUND;
+       }
 
        return retval;
 }
 
-int breakpoint_remove_all(struct target *target)
+static int watchpoint_free(struct target *target, struct watchpoint *watchpoint_to_remove)
+{
+       struct watchpoint *watchpoint = target->watchpoints;
+       struct watchpoint **watchpoint_p = &target->watchpoints;
+       int retval;
+
+       while (watchpoint) {
+               if (watchpoint == watchpoint_to_remove)
+                       break;
+               watchpoint_p = &watchpoint->next;
+               watchpoint = watchpoint->next;
+       }
+
+       if (!watchpoint)
+               return ERROR_OK;
+       retval = target_remove_watchpoint(target, watchpoint);
+       if (retval != ERROR_OK) {
+               LOG_TARGET_ERROR(target, "could not remove watchpoint #%d on this target",
+                                                watchpoint->number);
+               return retval;
+       }
+
+       LOG_TARGET_DEBUG(target, "free WPID: %d --> %d", watchpoint->unique_id, retval);
+       (*watchpoint_p) = watchpoint->next;
+       free(watchpoint);
+
+       return ERROR_OK;
+}
+
+static int watchpoint_remove_all_internal(struct target *target)
 {
+       struct watchpoint *watchpoint = target->watchpoints;
+       int retval = ERROR_OK;
+
+       while (watchpoint) {
+               struct watchpoint *tmp = watchpoint;
+               watchpoint = watchpoint->next;
+               int status = watchpoint_free(target, tmp);
+               if (status != ERROR_OK)
+                       retval = status;
+       }
+
+       return retval;
+}
+
+static int breakpoint_watchpoint_remove_all(struct target *target, enum breakpoint_watchpoint bp_wp)
+{
+       assert(bp_wp == BREAKPOINT || bp_wp == WATCHPOINT);
        int retval = ERROR_OK;
        if (target->smp) {
                struct target_list *head;
 
                foreach_smp_target(head, target->smp_targets) {
                        struct target *curr = head->target;
-                       int status = breakpoint_remove_all_internal(curr);
+
+                       int status = ERROR_OK;
+                       if (bp_wp == BREAKPOINT)
+                               status = breakpoint_remove_all_internal(curr);
+                       else
+                               status = watchpoint_remove_all_internal(curr);
 
                        if (status != ERROR_OK)
                                retval = status;
                }
        } else {
-               retval = breakpoint_remove_all_internal(target);
+               if (bp_wp == BREAKPOINT)
+                       retval = breakpoint_remove_all_internal(target);
+               else
+                       retval = watchpoint_remove_all_internal(target);
        }
 
        return retval;
 }
 
-static int breakpoint_clear_target_internal(struct target *target)
+int breakpoint_remove_all(struct target *target)
 {
-       LOG_DEBUG("Delete all breakpoints for target: %s",
-               target_name(target));
-
-       int retval = ERROR_OK;
-
-       while (target->breakpoints) {
-               int status = breakpoint_free(target, target->breakpoints);
-               if (status != ERROR_OK)
-                       retval = status;
-       }
+       return breakpoint_watchpoint_remove_all(target, BREAKPOINT);
+}
 
-       return retval;
+int watchpoint_remove_all(struct target *target)
+{
+       return breakpoint_watchpoint_remove_all(target, WATCHPOINT);
 }
 
 int breakpoint_clear_target(struct target *target)
@@ -418,13 +474,13 @@ int breakpoint_clear_target(struct target *target)
 
                foreach_smp_target(head, target->smp_targets) {
                        struct target *curr = head->target;
-                       int status = breakpoint_clear_target_internal(curr);
+                       int status = breakpoint_remove_all_internal(curr);
 
                        if (status != ERROR_OK)
                                retval = status;
                }
        } else {
-               retval = breakpoint_clear_target_internal(target);
+               retval = breakpoint_remove_all_internal(target);
        }
 
        return retval;
@@ -457,7 +513,7 @@ static int watchpoint_add_internal(struct target *target, target_addr_t address,
                                || watchpoint->value != value
                                || watchpoint->mask != mask
                                || watchpoint->rw != rw) {
-                               LOG_ERROR("address " TARGET_ADDR_FMT
+                               LOG_TARGET_ERROR(target, "address " TARGET_ADDR_FMT
                                        " already has watchpoint %d",
                                        address, watchpoint->unique_id);
                                return ERROR_FAIL;
@@ -491,7 +547,7 @@ static int watchpoint_add_internal(struct target *target, target_addr_t address,
                default:
                        reason = "unrecognized error";
 bye:
-                       LOG_ERROR("can't add %s watchpoint at " TARGET_ADDR_FMT ", %s",
+                       LOG_TARGET_ERROR(target, "can't add %s watchpoint at " TARGET_ADDR_FMT ", %s",
                                watchpoint_rw_strings[(*watchpoint_p)->rw],
                                address, reason);
                        free(*watchpoint_p);
@@ -499,9 +555,8 @@ bye:
                        return retval;
        }
 
-       LOG_DEBUG("[%d] added %s watchpoint at " TARGET_ADDR_FMT
+       LOG_TARGET_DEBUG(target, "added %s watchpoint at " TARGET_ADDR_FMT
                        " of length 0x%8.8" PRIx32 " (WPID: %d)",
-               target->coreid,
                watchpoint_rw_strings[(*watchpoint_p)->rw],
                (*watchpoint_p)->address,
                (*watchpoint_p)->length,
@@ -530,35 +585,6 @@ int watchpoint_add(struct target *target, target_addr_t address,
        }
 }
 
-static int watchpoint_free(struct target *target, struct watchpoint *watchpoint_to_remove)
-{
-       struct watchpoint *watchpoint = target->watchpoints;
-       struct watchpoint **watchpoint_p = &target->watchpoints;
-       int retval;
-
-       while (watchpoint) {
-               if (watchpoint == watchpoint_to_remove)
-                       break;
-               watchpoint_p = &watchpoint->next;
-               watchpoint = watchpoint->next;
-       }
-
-       if (!watchpoint)
-               return ERROR_OK;
-       retval = target_remove_watchpoint(target, watchpoint);
-       if (retval != ERROR_OK) {
-               LOG_TARGET_ERROR(target, "could not remove watchpoint #%d on this target",
-                                               watchpoint->number);
-               return retval;
-       }
-
-       LOG_DEBUG("free WPID: %d --> %d", watchpoint->unique_id, retval);
-       (*watchpoint_p) = watchpoint->next;
-       free(watchpoint);
-
-       return ERROR_OK;
-}
-
 static int watchpoint_remove_internal(struct target *target, target_addr_t address)
 {
        struct watchpoint *watchpoint = target->watchpoints;
@@ -591,7 +617,7 @@ int watchpoint_remove(struct target *target, target_addr_t address)
                                num_found_watchpoints++;
 
                                if (status != ERROR_OK) {
-                                       LOG_TARGET_ERROR(curr, "failed to remove watchpoint at address" TARGET_ADDR_FMT, address);
+                                       LOG_TARGET_ERROR(curr, "failed to remove watchpoint at address " TARGET_ADDR_FMT, address);
                                        retval = status;
                                }
                        }
@@ -603,28 +629,33 @@ int watchpoint_remove(struct target *target, target_addr_t address)
                        num_found_watchpoints++;
 
                        if (retval != ERROR_OK)
-                               LOG_TARGET_ERROR(target, "failed to remove watchpoint at address" TARGET_ADDR_FMT, address);
+                               LOG_TARGET_ERROR(target, "failed to remove watchpoint at address " TARGET_ADDR_FMT, address);
                }
        }
 
-       if (num_found_watchpoints == 0)
+       if (num_found_watchpoints == 0) {
                LOG_TARGET_ERROR(target, "no watchpoint at address " TARGET_ADDR_FMT " found", address);
+               return ERROR_WATCHPOINT_NOT_FOUND;
+       }
 
        return retval;
 }
 
 int watchpoint_clear_target(struct target *target)
 {
-       int retval = ERROR_OK;
-
        LOG_DEBUG("Delete all watchpoints for target: %s",
                target_name(target));
-       while (target->watchpoints) {
-               int status = watchpoint_free(target, target->watchpoints);
+
+       struct watchpoint *watchpoint = target->watchpoints;
+       int retval = ERROR_OK;
+
+       while (watchpoint) {
+               struct watchpoint *tmp = watchpoint;
+               watchpoint = watchpoint->next;
+               int status = watchpoint_free(target, tmp);
                if (status != ERROR_OK)
                        retval = status;
        }
-
        return retval;
 }
 
@@ -641,7 +672,7 @@ int watchpoint_hit(struct target *target, enum watchpoint_rw *rw,
        *rw = hit_watchpoint->rw;
        *address = hit_watchpoint->address;
 
-       LOG_DEBUG("Found hit watchpoint at " TARGET_ADDR_FMT " (WPID: %d)",
+       LOG_TARGET_DEBUG(target, "Found hit watchpoint at " TARGET_ADDR_FMT " (WPID: %d)",
                hit_watchpoint->address,
                hit_watchpoint->unique_id);
 
Open On-Chip Debugger

Linking to existing account procedure

If you already have an account and want to add another login method you MUST first sign in with your existing account and then change URL to read https://review.openocd.org/login/?link to get to this page again but this time it'll work for linking. Thank you.

SSH host keys fingerprints

1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=..              |
|+o..   .         |
|*.o   . .        |
|+B . . .         |
|Bo. = o S        |
|Oo.+ + =         |
|oB=.* = . o      |
| =+=.+   + E     |
|. .=o   . o      |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)