Code Review / openocd.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | review | tree
raw | inline | side by side
target: Change policy of removing watchpoints/breakpoints.
[openocd.git] / src / target / breakpoints.c
diff --git a/src/target/breakpoints.c b/src/target/breakpoints.c
index 79c68fea828ee3a955370fa5384f6b689d0cccb8..5ce0346bb4664d2eba05b07b89d091518e2a0781 100644 (file)
--- a/src/target/breakpoints.c
+++ b/src/target/breakpoints.c
@@ -1,22 +1,11 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+
 /***************************************************************************
  *   Copyright (C) 2005 by Dominic Rath                                    *
  *   Dominic.Rath@gmx.de                                                   *
  *                                                                         *
  *   Copyright (C) ST-Ericsson SA 2011                                     *
  *   michel.jaouen@stericsson.com : smp minimum support                    *
- *                                                                         *
- *   This program is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU General Public License as published by  *
- *   the Free Software Foundation; either version 2 of the License, or     *
- *   (at your option) any later version.                                   *
- *                                                                         *
- *   This program is distributed in the hope that it will be useful,       *
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
- *   GNU General Public License for more details.                          *
- *                                                                         *
- *   You should have received a copy of the GNU General Public License     *
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>. *
  ***************************************************************************/
 
 #ifdef HAVE_CONFIG_H
@@ -281,7 +270,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;
@@ -295,14 +284,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);
        (*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)
@@ -317,77 +313,121 @@ 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)
 {
        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 retval;
 }
 
-void breakpoint_remove_all(struct target *target)
+int breakpoint_remove_all(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_remove_all_internal(curr);
+                       int status = breakpoint_remove_all_internal(curr);
+
+                       if (status != ERROR_OK)
+                               retval = status;
                }
        } else {
-               breakpoint_remove_all_internal(target);
+               retval = breakpoint_remove_all_internal(target);
        }
+
+       return retval;
 }
 
-static void breakpoint_clear_target_internal(struct target *target)
+static int breakpoint_clear_target_internal(struct target *target)
 {
        LOG_DEBUG("Delete all breakpoints for target: %s",
                target_name(target));
-       while (target->breakpoints)
-               breakpoint_free(target, target->breakpoints);
+
+       int retval = ERROR_OK;
+
+       while (target->breakpoints) {
+               int status = breakpoint_free(target, target->breakpoints);
+               if (status != ERROR_OK)
+                       retval = status;
+       }
+
+       return retval;
 }
 
-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_clear_target_internal(curr);
+
+                       if (status != ERROR_OK)
+                               retval = status;
                }
        } else {
-               breakpoint_clear_target_internal(target);
+               retval = breakpoint_clear_target_internal(target);
        }
+
+       return retval;
 }
 
 struct breakpoint *breakpoint_find(struct target *target, target_addr_t address)
@@ -403,8 +443,8 @@ struct breakpoint *breakpoint_find(struct target *target, target_addr_t address)
        return NULL;
 }
 
-int watchpoint_add_internal(struct target *target, target_addr_t address,
-               uint32_t length, enum watchpoint_rw rw, uint32_t value, uint32_t mask)
+static int watchpoint_add_internal(struct target *target, target_addr_t address,
+               uint32_t length, enum watchpoint_rw rw, uint64_t value, uint64_t mask)
 {
        struct watchpoint *watchpoint = target->watchpoints;
        struct watchpoint **watchpoint_p = &target->watchpoints;
@@ -471,7 +511,7 @@ bye:
 }
 
 int watchpoint_add(struct target *target, target_addr_t address,
-               uint32_t length, enum watchpoint_rw rw, uint32_t value, uint32_t mask)
+               uint32_t length, enum watchpoint_rw rw, uint64_t value, uint64_t mask)
 {
        if (target->smp) {
                struct target_list *head;
@@ -490,7 +530,7 @@ int watchpoint_add(struct target *target, target_addr_t address,
        }
 }
 
-static void watchpoint_free(struct target *target, struct watchpoint *watchpoint_to_remove)
+static int watchpoint_free(struct target *target, struct watchpoint *watchpoint_to_remove)
 {
        struct watchpoint *watchpoint = target->watchpoints;
        struct watchpoint **watchpoint_p = &target->watchpoints;
@@ -504,14 +544,22 @@ static void watchpoint_free(struct target *target, struct watchpoint *watchpoint
        }
 
        if (!watchpoint)
-               return;
+               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;
 }
 
-int watchpoint_remove_internal(struct target *target, target_addr_t address)
+static int watchpoint_remove_internal(struct target *target, target_addr_t address)
 {
        struct watchpoint *watchpoint = target->watchpoints;
 
@@ -522,38 +570,62 @@ int watchpoint_remove_internal(struct target *target, target_addr_t address)
        }
 
        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 retval;
 }
 
-void watchpoint_clear_target(struct target *target)
+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)
-               watchpoint_free(target, target->watchpoints);
+       while (target->watchpoints) {
+               int status = watchpoint_free(target, target->watchpoints);
+               if (status != ERROR_OK)
+                       retval = status;
+       }
+
+       return retval;
 }
 
 int watchpoint_hit(struct target *target, enum watchpoint_rw *rw,
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)