Code Review / openocd.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | review | tree
raw | inline | side by side
jtag: linuxgpiod: drop extra parenthesis
[openocd.git] / src / target / breakpoints.c
diff --git a/src/target/breakpoints.c b/src/target/breakpoints.c
index 4d268cebb3f460f3768eb1c256207bb35c4cef9a..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,
@@ -270,7 +274,7 @@ int hybrid_breakpoint_add(struct target *target,
 }
 
 /* free up a breakpoint */
-static void breakpoint_free(struct target *target, struct breakpoint *breakpoint_to_remove)
+static int breakpoint_free(struct target *target, struct breakpoint *breakpoint_to_remove)
 {
        struct breakpoint *breakpoint = target->breakpoints;
        struct breakpoint **breakpoint_p = &target->breakpoints;
@@ -284,14 +288,21 @@ static void breakpoint_free(struct target *target, struct breakpoint *breakpoint
        }
 
        if (!breakpoint)
-               return;
+               return ERROR_OK;
 
        retval = target_remove_breakpoint(target, breakpoint);
+       if (retval != ERROR_OK) {
+               LOG_TARGET_ERROR(target, "could not remove breakpoint #%d on this target",
+                                               breakpoint->number);
+               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);
+
+       return ERROR_OK;
 }
 
 static int breakpoint_remove_internal(struct target *target, target_addr_t address)
@@ -306,77 +317,173 @@ static int breakpoint_remove_internal(struct target *target, target_addr_t addre
        }
 
        if (breakpoint) {
-               breakpoint_free(target, breakpoint);
-               return 1;
+               return breakpoint_free(target, breakpoint);
        } else {
-               if (!target->smp)
-                       LOG_ERROR("no breakpoint at address " TARGET_ADDR_FMT " found", address);
-               return 0;
+               return ERROR_BREAKPOINT_NOT_FOUND;
        }
 }
 
-static void breakpoint_remove_all_internal(struct target *target)
+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;
 
        while (breakpoint) {
                struct breakpoint *tmp = breakpoint;
                breakpoint = breakpoint->next;
-               breakpoint_free(target, tmp);
+               int status = breakpoint_free(target, tmp);
+               if (status != ERROR_OK)
+                       retval = status;
        }
+
+       return retval;
 }
 
-void breakpoint_remove(struct target *target, target_addr_t address)
+int breakpoint_remove(struct target *target, target_addr_t address)
 {
+       int retval = ERROR_OK;
+       unsigned int num_found_breakpoints = 0;
        if (target->smp) {
-               unsigned int num_breakpoints = 0;
                struct target_list *head;
 
                foreach_smp_target(head, target->smp_targets) {
                        struct target *curr = head->target;
-                       num_breakpoints += breakpoint_remove_internal(curr, address);
+                       int status = breakpoint_remove_internal(curr, address);
+
+                       if (status != ERROR_BREAKPOINT_NOT_FOUND) {
+                               num_found_breakpoints++;
+
+                               if (status != ERROR_OK) {
+                                       LOG_TARGET_ERROR(curr, "failed to remove breakpoint at address " TARGET_ADDR_FMT, address);
+                                       retval = status;
+                               }
+                       }
                }
-               if (!num_breakpoints)
-                       LOG_ERROR("no breakpoint at address " TARGET_ADDR_FMT " found", address);
+
        } else {
-               breakpoint_remove_internal(target, address);
+               retval = breakpoint_remove_internal(target, address);
+
+               if (retval != ERROR_BREAKPOINT_NOT_FOUND) {
+                       num_found_breakpoints++;
+
+                       if (retval != ERROR_OK)
+                               LOG_TARGET_ERROR(target, "failed to remove breakpoint at address " TARGET_ADDR_FMT, address);
+               }
+       }
+
+       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;
+}
+
+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;
 }
 
-void breakpoint_remove_all(struct target *target)
+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;
-                       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 {
-               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 void 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));
-       while (target->breakpoints)
-               breakpoint_free(target, target->breakpoints);
+       return breakpoint_watchpoint_remove_all(target, BREAKPOINT);
+}
+
+int watchpoint_remove_all(struct target *target)
+{
+       return breakpoint_watchpoint_remove_all(target, WATCHPOINT);
 }
 
-void breakpoint_clear_target(struct target *target)
+int breakpoint_clear_target(struct target *target)
 {
+       int retval = ERROR_OK;
+
        if (target->smp) {
                struct target_list *head;
 
                foreach_smp_target(head, target->smp_targets) {
                        struct target *curr = head->target;
-                       breakpoint_clear_target_internal(curr);
+                       int status = breakpoint_remove_all_internal(curr);
+
+                       if (status != ERROR_OK)
+                               retval = status;
                }
        } else {
-               breakpoint_clear_target_internal(target);
+               retval = breakpoint_remove_all_internal(target);
        }
+
+       return retval;
 }
 
 struct breakpoint *breakpoint_find(struct target *target, target_addr_t address)
@@ -406,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;
@@ -440,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);
@@ -448,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,
@@ -479,27 +585,6 @@ int watchpoint_add(struct target *target, target_addr_t address,
        }
 }
 
-static void 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;
-       retval = target_remove_watchpoint(target, watchpoint);
-       LOG_DEBUG("free WPID: %d --> %d", watchpoint->unique_id, retval);
-       (*watchpoint_p) = watchpoint->next;
-       free(watchpoint);
-}
-
 static int watchpoint_remove_internal(struct target *target, target_addr_t address)
 {
        struct watchpoint *watchpoint = target->watchpoints;
@@ -511,38 +596,67 @@ static int watchpoint_remove_internal(struct target *target, target_addr_t addre
        }
 
        if (watchpoint) {
-               watchpoint_free(target, watchpoint);
-               return 1;
+               return watchpoint_free(target, watchpoint);
        } else {
-               if (!target->smp)
-                       LOG_ERROR("no watchpoint at address " TARGET_ADDR_FMT " found", address);
-               return 0;
+               return ERROR_WATCHPOINT_NOT_FOUND;
        }
 }
 
-void watchpoint_remove(struct target *target, target_addr_t address)
+int watchpoint_remove(struct target *target, target_addr_t address)
 {
+       int retval = ERROR_OK;
+       unsigned int num_found_watchpoints = 0;
        if (target->smp) {
-               unsigned int num_watchpoints = 0;
                struct target_list *head;
 
                foreach_smp_target(head, target->smp_targets) {
                        struct target *curr = head->target;
-                       num_watchpoints += watchpoint_remove_internal(curr, address);
+                       int status = watchpoint_remove_internal(curr, address);
+
+                       if (status != ERROR_WATCHPOINT_NOT_FOUND) {
+                               num_found_watchpoints++;
+
+                               if (status != ERROR_OK) {
+                                       LOG_TARGET_ERROR(curr, "failed to remove watchpoint at address " TARGET_ADDR_FMT, address);
+                                       retval = status;
+                               }
+                       }
                }
-               if (num_watchpoints == 0)
-                       LOG_ERROR("no watchpoint at address " TARGET_ADDR_FMT " num_watchpoints", address);
        } else {
-               watchpoint_remove_internal(target, address);
+               retval = watchpoint_remove_internal(target, address);
+
+               if (retval != ERROR_WATCHPOINT_NOT_FOUND) {
+                       num_found_watchpoints++;
+
+                       if (retval != ERROR_OK)
+                               LOG_TARGET_ERROR(target, "failed to remove watchpoint at address " TARGET_ADDR_FMT, address);
+               }
        }
+
+       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;
 }
 
-void watchpoint_clear_target(struct target *target)
+int watchpoint_clear_target(struct target *target)
 {
        LOG_DEBUG("Delete all watchpoints for target: %s",
                target_name(target));
-       while (target->watchpoints)
-               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;
 }
 
 int watchpoint_hit(struct target *target, enum watchpoint_rw *rw,
@@ -558,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)