breakpoints.c

Go to the documentation of this file.

// 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                    *
 ***************************************************************************/
 
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
 
#include "target.h"
#include <helper/log.h>
#include "breakpoints.h"
#include "smp.h"
#include "helper/util.h"
 
enum breakpoint_watchpoint {
    BREAKPOINT,
    WATCHPOINT,
};
 
static const char * const breakpoint_type_strings[] = {
    "hardware",
    "software"
};
 
static const char * const watchpoint_rw_strings[] = {
    "read",
    "write",
    "access"
};
 
/* monotonic counter/id-number for breakpoints and watch points */
static int bpwp_unique_id;
 
COMMAND_HELPER(detect_breakpoints_in_section, struct target *target,
        struct imagesection section)
{
    target_addr_t start = section.base_address;
    uint32_t length = section.size;
    bool found_breakpoint = false;
 
    for (struct breakpoint *bp = target->breakpoints; bp; bp = bp->next)
        if (is_memory_regions_overlap(start, length, bp->address, bp->length)) {
            found_breakpoint = true;
            command_print(cmd, "conflicting breakpoint at address: "
                    TARGET_ADDR_FMT, bp->address);
        }
 
    return found_breakpoint ? ERROR_FAIL : ERROR_OK;
}
 
static int breakpoint_add_internal(struct target *target,
    target_addr_t address,
    unsigned int length,
    enum breakpoint_type type)
{
    struct breakpoint *breakpoint = target->breakpoints;
    struct breakpoint **breakpoint_p = &target->breakpoints;
    const char *reason;
    int retval;
 
    while (breakpoint) {
        if (breakpoint->address == address) {
            /* FIXME don't assume "same address" means "same
             * breakpoint" ... check all the parameters before
             * succeeding.
             */
            LOG_TARGET_ERROR(target, "Duplicate Breakpoint address: " TARGET_ADDR_FMT " (BP %" PRIu32 ")",
                address, breakpoint->unique_id);
            return ERROR_BREAKPOINT_DUPLICATED;
        }
        if (type == BKPT_SOFT &&
                is_memory_regions_overlap(address, length, breakpoint->address, breakpoint->length)) {
            LOG_TARGET_ERROR(target, "Breakpoint overlaps another one at " TARGET_ADDR_FMT
                " of length %u (BP %" PRIu32 ")", breakpoint->address,
                breakpoint->length, breakpoint->unique_id);
            return ERROR_BREAKPOINT_OVERLAPPED;
        }
        breakpoint_p = &breakpoint->next;
        breakpoint = breakpoint->next;
    }
 
    (*breakpoint_p) = malloc(sizeof(struct breakpoint));
    (*breakpoint_p)->address = address;
    (*breakpoint_p)->asid = 0;
    (*breakpoint_p)->length = length;
    (*breakpoint_p)->type = type;
    (*breakpoint_p)->is_set = false;
    (*breakpoint_p)->orig_instr = malloc(length);
    (*breakpoint_p)->next = NULL;
    (*breakpoint_p)->unique_id = bpwp_unique_id++;
 
    retval = target_add_breakpoint(target, *breakpoint_p);
    switch (retval) {
    case ERROR_OK:
        break;
    case ERROR_TARGET_RESOURCE_NOT_AVAILABLE:
        reason = "resource not available";
        goto fail;
    case ERROR_TARGET_NOT_HALTED:
        reason = "target not halted";
        goto fail;
    default:
        reason = "unknown reason";
fail:
        LOG_TARGET_ERROR(target, "can't add breakpoint: %s", reason);
        free((*breakpoint_p)->orig_instr);
        free(*breakpoint_p);
        *breakpoint_p = NULL;
        return retval;
    }
 
    LOG_TARGET_DEBUG(target, "added %s breakpoint at " TARGET_ADDR_FMT
            " of length 0x%8.8x, (BPID: %" PRIu32 ")",
        breakpoint_type_strings[(*breakpoint_p)->type],
        (*breakpoint_p)->address, (*breakpoint_p)->length,
        (*breakpoint_p)->unique_id);
 
    return ERROR_OK;
}
 
static int context_breakpoint_add_internal(struct target *target,
    uint32_t asid,
    unsigned int length,
    enum breakpoint_type type)
{
    struct breakpoint *breakpoint = target->breakpoints;
    struct breakpoint **breakpoint_p = &target->breakpoints;
    int retval;
 
    while (breakpoint) {
        if (breakpoint->asid == asid) {
            /* FIXME don't assume "same address" means "same
             * breakpoint" ... check all the parameters before
             * succeeding.
             */
            LOG_TARGET_ERROR(target, "Duplicate Breakpoint asid: 0x%08" PRIx32 " (BP %" PRIu32 ")",
                asid, breakpoint->unique_id);
            return ERROR_BREAKPOINT_DUPLICATED;
        }
        breakpoint_p = &breakpoint->next;
        breakpoint = breakpoint->next;
    }
 
    (*breakpoint_p) = malloc(sizeof(struct breakpoint));
    (*breakpoint_p)->address = 0;
    (*breakpoint_p)->asid = asid;
    (*breakpoint_p)->length = length;
    (*breakpoint_p)->type = type;
    (*breakpoint_p)->is_set = false;
    (*breakpoint_p)->orig_instr = malloc(length);
    (*breakpoint_p)->next = NULL;
    (*breakpoint_p)->unique_id = bpwp_unique_id++;
    retval = target_add_context_breakpoint(target, *breakpoint_p);
    if (retval != ERROR_OK) {
        LOG_TARGET_ERROR(target, "could not add breakpoint");
        free((*breakpoint_p)->orig_instr);
        free(*breakpoint_p);
        *breakpoint_p = NULL;
        return retval;
    }
 
    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);
 
    return ERROR_OK;
}
 
static int hybrid_breakpoint_add_internal(struct target *target,
    target_addr_t address,
    uint32_t asid,
    unsigned int length,
    enum breakpoint_type type)
{
    struct breakpoint *breakpoint = target->breakpoints;
    struct breakpoint **breakpoint_p = &target->breakpoints;
    int retval;
 
    while (breakpoint) {
        if ((breakpoint->asid == asid) && (breakpoint->address == address)) {
            /* FIXME don't assume "same address" means "same
             * breakpoint" ... check all the parameters before
             * succeeding.
             */
            LOG_TARGET_ERROR(target, "Duplicate Hybrid Breakpoint asid: 0x%08" PRIx32 " (BP %" PRIu32 ")",
                asid, breakpoint->unique_id);
            return ERROR_BREAKPOINT_DUPLICATED;
        } else if ((breakpoint->address == address) && (breakpoint->asid == 0)) {
            LOG_TARGET_ERROR(target, "Duplicate Breakpoint IVA: " TARGET_ADDR_FMT " (BP %" PRIu32 ")",
                address, breakpoint->unique_id);
            return ERROR_BREAKPOINT_DUPLICATED;
 
        }
        breakpoint_p = &breakpoint->next;
        breakpoint = breakpoint->next;
    }
    (*breakpoint_p) = malloc(sizeof(struct breakpoint));
    (*breakpoint_p)->address = address;
    (*breakpoint_p)->asid = asid;
    (*breakpoint_p)->length = length;
    (*breakpoint_p)->type = type;
    (*breakpoint_p)->is_set = false;
    (*breakpoint_p)->orig_instr = malloc(length);
    (*breakpoint_p)->next = NULL;
    (*breakpoint_p)->unique_id = bpwp_unique_id++;
 
 
    retval = target_add_hybrid_breakpoint(target, *breakpoint_p);
    if (retval != ERROR_OK) {
        LOG_TARGET_ERROR(target, "could not add breakpoint");
        free((*breakpoint_p)->orig_instr);
        free(*breakpoint_p);
        *breakpoint_p = NULL;
        return retval;
    }
    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,
        (*breakpoint_p)->length,
        (*breakpoint_p)->unique_id);
 
    return ERROR_OK;
}
 
int breakpoint_add(struct target *target,
    target_addr_t address,
    unsigned int length,
    enum breakpoint_type type)
{
    if (target->smp && type == BKPT_HARD) {
        struct target_list *list_node;
        foreach_smp_target(list_node, target->smp_targets) {
            struct target *curr = list_node->target;
            int retval = breakpoint_add_internal(curr, address, length, type);
            if (retval != ERROR_OK)
                return retval;
        }
 
        return ERROR_OK;
    } else {
        return breakpoint_add_internal(target, address, length, type);
    }
}
 
int context_breakpoint_add(struct target *target,
    uint32_t asid,
    unsigned int length,
    enum breakpoint_type type)
{
    if (target->smp) {
        struct target_list *head;
 
        foreach_smp_target(head, target->smp_targets) {
            struct target *curr = head->target;
            int retval = context_breakpoint_add_internal(curr, asid, length, type);
            if (retval != ERROR_OK)
                return retval;
        }
 
        return ERROR_OK;
    } else {
        return context_breakpoint_add_internal(target, asid, length, type);
    }
}
 
int hybrid_breakpoint_add(struct target *target,
    target_addr_t address,
    uint32_t asid,
    unsigned int length,
    enum breakpoint_type type)
{
    if (target->smp) {
        struct target_list *head;
 
        foreach_smp_target(head, target->smp_targets) {
            struct target *curr = head->target;
            int retval = hybrid_breakpoint_add_internal(curr, address, asid, length, type);
            if (retval != ERROR_OK)
                return retval;
        }
 
        return ERROR_OK;
    } else
        return hybrid_breakpoint_add_internal(target, address, asid, length, type);
}
 
/* free up a breakpoint */
static int breakpoint_free(struct target *target, struct breakpoint *breakpoint_to_remove)
{
    struct breakpoint *breakpoint = target->breakpoints;
    struct breakpoint **breakpoint_p = &target->breakpoints;
    int retval;
 
    while (breakpoint) {
        if (breakpoint == breakpoint_to_remove)
            break;
        breakpoint_p = &breakpoint->next;
        breakpoint = breakpoint->next;
    }
 
    if (!breakpoint)
        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_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)
{
    struct breakpoint *breakpoint = target->breakpoints;
 
    while (breakpoint) {
        if ((breakpoint->address == address) ||
            (breakpoint->address == 0 && breakpoint->asid == address))
            break;
        breakpoint = breakpoint->next;
    }
 
    if (breakpoint) {
        return breakpoint_free(target, breakpoint);
    } else {
        return ERROR_BREAKPOINT_NOT_FOUND;
    }
}
 
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;
        int status = breakpoint_free(target, tmp);
        if (status != ERROR_OK)
            retval = status;
    }
 
    return retval;
}
 
int breakpoint_remove(struct target *target, target_addr_t address)
{
    int retval = ERROR_OK;
    unsigned int num_found_breakpoints = 0;
    if (target->smp) {
        struct target_list *head;
 
        foreach_smp_target(head, target->smp_targets) {
            struct target *curr = head->target;
            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;
                }
            }
        }
 
    } else {
        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;
}
 
static int watchpoint_remove_all_internal(struct target *target)
{
    LOG_TARGET_DEBUG(target, "Delete all 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;
}
 
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 = 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 {
        if (bp_wp == BREAKPOINT)
            retval = breakpoint_remove_all_internal(target);
        else
            retval = watchpoint_remove_all_internal(target);
    }
 
    return retval;
}
 
int breakpoint_remove_all(struct target *target)
{
    return breakpoint_watchpoint_remove_all(target, BREAKPOINT);
}
 
int watchpoint_remove_all(struct target *target)
{
    return breakpoint_watchpoint_remove_all(target, WATCHPOINT);
}
 
struct breakpoint *breakpoint_find(struct target *target, target_addr_t address)
{
    struct breakpoint *breakpoint = target->breakpoints;
 
    while (breakpoint) {
        if (breakpoint->address == address)
            return breakpoint;
        breakpoint = breakpoint->next;
    }
 
    return NULL;
}
 
static int watchpoint_add_internal(struct target *target, target_addr_t address,
        unsigned int length, enum watchpoint_rw rw, uint64_t value, uint64_t mask)
{
    struct watchpoint *watchpoint = target->watchpoints;
    struct watchpoint **watchpoint_p = &target->watchpoints;
    int retval;
    const char *reason;
 
    while (watchpoint) {
        if (watchpoint->address == address) {
            if (watchpoint->length != length
                || watchpoint->value != value
                || watchpoint->mask != mask
                || watchpoint->rw != rw) {
                LOG_TARGET_ERROR(target, "address " TARGET_ADDR_FMT
                    " already has watchpoint %d",
                    address, watchpoint->unique_id);
                return ERROR_FAIL;
            }
 
            /* ignore duplicate watchpoint */
            return ERROR_OK;
        }
        watchpoint_p = &watchpoint->next;
        watchpoint = watchpoint->next;
    }
 
    (*watchpoint_p) = calloc(1, sizeof(struct watchpoint));
    (*watchpoint_p)->address = address;
    (*watchpoint_p)->length = length;
    (*watchpoint_p)->value = value;
    (*watchpoint_p)->mask = mask;
    (*watchpoint_p)->rw = rw;
    (*watchpoint_p)->unique_id = bpwp_unique_id++;
 
    retval = target_add_watchpoint(target, *watchpoint_p);
    switch (retval) {
    case ERROR_OK:
        break;
    case ERROR_TARGET_RESOURCE_NOT_AVAILABLE:
        reason = "resource not available";
        goto bye;
    case ERROR_TARGET_NOT_HALTED:
        reason = "target not halted";
        goto bye;
    default:
        reason = "unrecognized error";
bye:
        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);
        *watchpoint_p = NULL;
        return retval;
    }
 
    LOG_TARGET_DEBUG(target, "added %s watchpoint at " TARGET_ADDR_FMT
            " of length 0x%8.8x (WPID: %d)",
        watchpoint_rw_strings[(*watchpoint_p)->rw],
        (*watchpoint_p)->address,
        (*watchpoint_p)->length,
        (*watchpoint_p)->unique_id);
 
    return ERROR_OK;
}
 
int watchpoint_add(struct target *target, target_addr_t address,
        unsigned int length, enum watchpoint_rw rw, uint64_t value, uint64_t mask)
{
    if (target->smp) {
        struct target_list *head;
 
        foreach_smp_target(head, target->smp_targets) {
            struct target *curr = head->target;
            int retval = watchpoint_add_internal(curr, address, length, rw, value, mask);
            if (retval != ERROR_OK)
                return retval;
        }
 
        return ERROR_OK;
    } else {
        return watchpoint_add_internal(target, address, length, rw, value,
                mask);
    }
}
 
static int watchpoint_remove_internal(struct target *target, target_addr_t address)
{
    struct watchpoint *watchpoint = target->watchpoints;
 
    while (watchpoint) {
        if (watchpoint->address == address)
            break;
        watchpoint = watchpoint->next;
    }
 
    if (watchpoint) {
        return watchpoint_free(target, watchpoint);
    } else {
        return ERROR_WATCHPOINT_NOT_FOUND;
    }
}
 
int watchpoint_remove(struct target *target, target_addr_t address)
{
    int retval = ERROR_OK;
    unsigned int num_found_watchpoints = 0;
    if (target->smp) {
        struct target_list *head;
 
        foreach_smp_target(head, target->smp_targets) {
            struct target *curr = head->target;
            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;
                }
            }
        }
    } else {
        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;
}
 
int watchpoint_hit(struct target *target, enum watchpoint_rw *rw,
           target_addr_t *address)
{
    int retval;
    struct watchpoint *hit_watchpoint;
 
    retval = target_hit_watchpoint(target, &hit_watchpoint);
    if (retval == ERROR_NOT_IMPLEMENTED
            && target->debug_reason == DBG_REASON_WATCHPOINT) {
        // Handle the trivial case: only one watchpoint is set
        unsigned int cnt = 0;
        struct watchpoint *wp = target->watchpoints;
        while (wp) {
            cnt++;
            wp = wp->next;
        }
        if (cnt == 1) {
            retval = ERROR_OK;
            hit_watchpoint = target->watchpoints;
        }
    }
    if (retval != ERROR_OK)
        return ERROR_FAIL;
 
    *rw = hit_watchpoint->rw;
    *address = hit_watchpoint->address;
 
    LOG_TARGET_DEBUG(target, "Found hit watchpoint at " TARGET_ADDR_FMT " (WPID: %d)",
        hit_watchpoint->address,
        hit_watchpoint->unique_id);
 
    return ERROR_OK;
}