Linux ARM64硬件断点驱动实现及解析

已于 2023-08-26 16:53:35 修改
阅读量2.1k 收藏 14
点赞数 7
文章标签： linux arm开发 驱动开发
于 2023-08-19 21:36:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38384263/article/details/132384394
版权

硬件断点是什么

硬件断点是cpu自带的用于调试程序的断点，分为执行断点和内存断点。比如armv8架构，它有4个内存断点和6个执行断点。执行断点是最常见的断点类型，就是在某个程序地址处加断点，CPU运行到这里时就会触发，触发长度是4字节。而内存断点是，监控某一个内存区间，当CPU试图访问或者是操作这块内存时就会触发，触发长度可以是[1,8]字节，或是(8,2G]字节，其中8~2G的区间内只能是2的幂。

硬件断点的实现机制

cpu的架构不同，硬件断点的机制也不同。通常都是配置好对应的断点寄存器后，CPU触发断点，触发调试异常，进入中断执行相应操作后退出。大概流程如下图所示：
配置断点寄存器
CPU正常运行
CPU访问断点内的地址
CPU发生异常
解码ISS得到异常类型为ESR_ELx_EC_BREAKPT_CUR
从异常向量表中找到ESR_ELx_EC_BREAKPT_CUR对应的服务函数
执行服务函数

断点寄存器解析

以armv8为例，比如cotex-a55核心，每个断点都有2个用于控制硬件断点的寄存器。如下所示：()下面表格中的N代表第几个断点，X代表异常等级，比如el0, el1, el2)

nameexplain
dbgbvrN_elX执行断点地址设置寄存器
dbgbcrN_elX执行断点控制寄存器
dbgwvrN_elX观察断点地址设置寄存器
dbgwcrN_elX观察断点控制寄存器

dbgbvrN_elX

设置执行断点的地址，linux里直接填入对应函数的虚拟地址即可。

dbgbcrN_elX

执行断点的控制寄存器，共有31BIT。用于控制断点的各种属性。具体如下所示：

31~2423~2019~1615~141312~98~54~32~10
RES2BTLBNSSCHMCRES1BASRES0PMCE

其中比较常用的是E, PMC, BT。

  • E是断点使能位，高位使能。
  • PMC用于记录上次控制时的异常等级，配合HMC和SSC一起使用
  • BT是控制断点触发的条件，默认是0b0000，对应的触发条件是当地址匹配时触发。

dbgwvrN_elX

设置观察断点的地址，linux里直接填入想观察的内存区域的起始地址即可。

dbgwcrN_elX

观察断点的控制寄存器，共有31bit，用于控制观察断点的各种属性。具体如下所示：

31~2928~2423~212019~1615~141312~54~32~10
RES1MASKRES0WTLBNSSCHMCBASLSCPACE

其中比较常用的是E, PAC, BAS, MASK。

  • E是断点使能位，高位使能。
  • PAC用于记录上次控制时的异常等级，配合HMC和SSC一起使用
  • BAS一共8bit，代表要监控的内存大小，每1bit代表1byte，最大可检测8bytes。
  • MASK代表使用掩码的模式监控地址，共有5bit，代表可以掩掉dbgwvrN_elX中的0~31位低地址。
MASK举例

比如想监控的地址是 0xffffffc0622a5c10, MASK=0b00111

则监控的范围是：0xffffffc0622a5c00~0xffffffc0622a5c7f，实际的 dbgwcrN_elX=0xffffffc0622a5c00

假如 MASK=0b01100

则监控的范围是：0xffffffc0622a5000~0xffffffc0622a5fff，实际的 dbgwcrN_elX=0xffffffc0622a5000

实现硬件断点驱动

在linux内核里其实有硬件断点功能，但是这个硬件断点不太好用，它依赖太多的配置选项。开了这些配置选项除了内核需要重编之外，由于头文件变更过大，所以所有的驱动也要重编。而且内核的硬件断点只能监控8字节，也不支持设置断点触发事件，自定义属性太少。

硬件断点需要实现的部分

实现硬件断点驱动，主要是需要实现以下几部分：

  1. 注册自己的断点异常服务函数。
  2. 根据设定的地址和长度自动解析需配置的硬件断点寄存器值。
  3. 设置硬件断点寄存器。

硬件断点实现需要的内核接口

上述部分的实现依赖一些内核接口，这些接口内核是没有导出符号的，不过只要开启了 CONFIG_KALLSYMS=y，函数都是可以查询的到的。

涉及的接口如下：

typedef struct HW_kernelApi
{
    struct
    {
        unsigned long (*kallsyms_lookup_name)(const char *name); /*根据符号查询地址函数*/
        void (*register_step_hook)(struct step_hook *hook);      /*注册step调试异常hook的函数*/
        void (*unregister_step_hook)(struct step_hook *hook);    /*取消注册step调试异常hook的函数*/
        void (*enable_debug_monitors)(enum dbg_active_el el);    /*使能debug异常*/
        void (*disable_debug_monitors)(enum dbg_active_el el);   /*失能debug异常*/
        int (*kernel_active_single_step)(void);                  /*单步调试是否激活*/
        void (*kernel_enable_single_step)(struct pt_regs *regs); /*使能单步调试异常*/
        void (*kernel_disable_single_step)(void);                /*失能单步调试异常*/
        u64 (*read_sanitised_ftr_reg)(u32 id);                   /*读ftr寄存器*/
        void (*show_regs)(struct pt_regs *);                     /*显示堆栈*/
        void (*do_bad)(unsigned long addr, unsigned int esr, struct pt_regs *regs); /*调试异常的默认中断处理函数*/
    } __aligned(128) fun;
    struct
    {
#ifdef CONFIG_CPU_PM
        u64 *hw_breakpoint_restore;         /*cpu从调试暂停恢复运行时执行的函数*/
        u64  default_hw_breakpoint_restore; /*接管之前的函数地址*/
#endif
        struct fault_info *debug_fault_info;      /*接管硬件断点调试异常中断，替换回调函数*/
        struct fault_info  default_fault_info[2]; /*接管之前的数据信息*/
    } __aligned(128) val;
} HW_kernelApi;

我记得在linux 5.7.0之后的内核版本，kallsyms_lookup_name这个根据符号查询地址的函数，是不再导出了。所以驱动中需要先找到这个符号的地址，再用这个地址去查询其余需要的内核接口即可。寻找kallsyms_lookup_name的代码如下：

/*根据名字找函数地址*/
unsigned long kaddr_lookup_name(const char *fname_raw)
{
    int           i;
    unsigned long kaddr;
    char         *fname_lookup, *fname;

    fname_lookup = kzalloc(NAME_MAX, GFP_KERNEL);
    if (!fname_lookup)
        return 0;

    fname = kzalloc(strlen(fname_raw) + 4, GFP_KERNEL);
    if (!fname)
        return 0;

    /*第一个0x0代表是该符号的起始地址*/
    strcpy(fname, fname_raw);
    strcat(fname, "+0x0");

    /*获取内核代码段基地址*/
    kaddr  = (unsigned long)&sprint_symbol;
    kaddr &= 0xffffffffff000000;

    /*内核符号不会超过0x100000*16的大小，所以按4字节偏移，挨个找*/
    for (i = 0x0; i < 0x400000; i++)
    {
        /*寻找地址对应的符号名称*/
        sprint_symbol(fname_lookup, kaddr);
        /*对比寻找的符号名字*/
        if (strncmp(fname_lookup, fname, strlen(fname)) == 0)
        {
            /*找到了就返回地址*/
            kfree(fname_lookup);
            kfree(fname);
            return kaddr;
        }
        /*偏移4字节*/
        kaddr += 0x04;
    }
    /*没找到地址就返回0*/
    kfree(fname_lookup);
    kfree(fname);
    return 0;
}

解析要设置断点信息

对于使用者来说，是不需要关注每个断点寄存器应该配什么值，只需要知道以下几点就行了：

  1. 断点类型：执行断点或是读/写断点。
  2. 断点地址
  3. 断点监控的长度

所以这部分需要解析对应调用者传入的参数，自动解析出寄存器需要配置的值。流程如下：

WP
BP
len=4
否
是
是
否
len>8?
dbgwcr.bas=0blen*1
dbgwvr=addr
mask=log2(len)
2^mask*bit=1 > addr+len?
mask=mask+1
dbgwcr.mask=mask
dbgbvr=addr
dbgbcr.EN=1,
.BT=0
.bas=0b1111
BK TYPE
BK ADDR
BK LEN

实现断点异常服务函数

以观察断点服务函数为例，当一个观察断点触发时需要如下几步。

  1. 先关闭所有观察断点，防止其一直触发。
  2. 遍历所有已设置的观察断点，求出触发的地址与设置的地址正向距离最近的那个断点。
  3. 取出断点数据结构，筛选该地址是否在期望监控的地址范围内。
  4. 执行用户函数。
  5. 在当前regs开启single step
  6. 进入single step异常服务函数
  7. 重新开启断点。

至此整个流程完毕，执行断点流程类似。代码如下所示：

/*watchpoint回调函数*/
static int HW_watchpointHandler(unsigned long addr, unsigned int esr, struct pt_regs *regs)
{
    int                       i, *kernel_step, access, closest_match = -1;
    u64                       min_dist = -1, dist;
    u32                       ctrl_reg;
    u64                       val, startAddr, endAddr;
    struct HW_breakpointInfo *wp, **slots;
    // struct debug_info *debug_info;
    HW_breakpointVC     *info = NULL;
    HW_breakpointCtrlReg ctrl;

    slots = this_cpu_ptr(wp_on_reg);
    // debug_info = &current->thread.debug;

    /*
	 * Find all watchpoints that match the reported address. If no exact
	 * match is found. Attribute the hit to the closest watchpoint.
	 */
    rcu_read_lock();
    for (i = 0; i < core_num_wrps; ++i)
    {
        wp = slots[i];
        if (wp == NULL)
            continue;

        /*
		 * Check that the access type matches.
		 * 0 => load, otherwise => store
		 */
        access = (esr & AARCH64_ESR_ACCESS_MASK) ? HW_BREAKPOINT_W : HW_BREAKPOINT_R;
        if (!(access /*& hw_breakpoint_type(wp)待实现，将wp与attr->type关联*/))
            continue;

        /* Check if the watchpoint value and byte select match. */
        val      = HW_readBreakpointReg(AARCH64_DBG_REG_WVR, i);
        ctrl_reg = HW_readBreakpointReg(AARCH64_DBG_REG_WCR, i);
        HW_decodeCtrlReg(ctrl_reg, &ctrl);
        dist = HW_getDistanceFromWatchpoint(addr, wp->attr.addr, &ctrl);
        if (dist < min_dist)
        {
            min_dist      = dist;
            closest_match = i;
        }
        /* Is this an exact match? */
        if (dist != 0)
            continue;
        info          = HW_counterArchbp(wp);
        info->trigger = addr;
        closest_match = i;
    }
    if (min_dist > 0 && min_dist != -1)
    {
        /* No exact match found. */
        wp            = slots[closest_match];
        info          = HW_counterArchbp(wp);
        info->trigger = addr;
    }
    rcu_read_unlock();

    /*关闭所有断点*/
    HW_toggleBpRegisters(AARCH64_DBG_REG_WCR, DBG_ACTIVE_EL0, 0);
    HW_toggleBpRegisters(AARCH64_DBG_REG_WCR, DBG_ACTIVE_EL1, 0);
    kernel_step = this_cpu_ptr(&stepping_kernel_bp);

    // printk("watchpoint is trigger,addr=0x%lx, close = %d, dist = %d, mindist = %d, info = %lx\n",
    //        addr, closest_match, dist, min_dist);
    if (info)
    {
        wp = container_of(info, struct HW_breakpointInfo, info);
        if (addr >= wp->attr.addr && addr < wp->attr.addr + wp->attr.len)
        {
            /*在期望检测的地址范围之内，才打印堆栈信息*/
            printk("wp is triger = 0x%llx, addr = 0x%llx, len = %d\n", addr, wp->attr.addr, wp->attr.len);
            kernelApi.fun.show_regs(regs);
        }
        info->trigger = 0;
    }

    if (*kernel_step != ARM_KERNEL_STEP_NONE)
        return 0;

    if (kernelApi.fun.kernel_active_single_step())
    {
        *kernel_step = ARM_KERNEL_STEP_SUSPEND;
    }
    else
    {
        *kernel_step = ARM_KERNEL_STEP_ACTIVE;
        /*在当前regs触发step异常*/
        kernelApi.fun.kernel_enable_single_step(regs);
    }
    // }

    return 0;
}

注册调试异常服务函数

当断点触发时，是会进入到内核的调试异常服务函数，这个函数里会解析异常类型，去运行对应的断点调试异常函数。内核默认的断点调试异常函数是 do_bad，这是一个空函数。需要将这个函数替换为我们自己对应的服务函数。

    /* 注册调试异常回调函数 */
    /*执行断点*/
    /*保存原先的变量*/
    kernelApi.val.default_fault_info[0].fn   = kernelApi.val.debug_fault_info[DBG_ESR_EVT_HWBP].fn;
    kernelApi.val.default_fault_info[0].sig  = kernelApi.val.debug_fault_info[DBG_ESR_EVT_HWBP].sig;
    kernelApi.val.default_fault_info[0].code = kernelApi.val.debug_fault_info[DBG_ESR_EVT_HWBP].code;
    kernelApi.val.default_fault_info[0].name = kernelApi.val.debug_fault_info[DBG_ESR_EVT_HWBP].name;
    /*注册新的内容*/
    kernelApi.val.debug_fault_info[DBG_ESR_EVT_HWBP].fn   = HW_breakpointHandler;
    kernelApi.val.debug_fault_info[DBG_ESR_EVT_HWBP].sig  = SIGTRAP;
    kernelApi.val.debug_fault_info[DBG_ESR_EVT_HWBP].code = TRAP_HWBKPT;
    kernelApi.val.debug_fault_info[DBG_ESR_EVT_HWBP].name = "hw-breakpoint handler";
    /*内存断点*/
    /*保存原先的变量*/
    kernelApi.val.default_fault_info[1].fn   = kernelApi.val.debug_fault_info[DBG_ESR_EVT_HWWP].fn;
    kernelApi.val.default_fault_info[1].sig  = kernelApi.val.debug_fault_info[DBG_ESR_EVT_HWWP].sig;
    kernelApi.val.default_fault_info[1].code = kernelApi.val.debug_fault_info[DBG_ESR_EVT_HWWP].code;
    kernelApi.val.default_fault_info[1].name = kernelApi.val.debug_fault_info[DBG_ESR_EVT_HWWP].name;
    /*注册新的内容*/
    kernelApi.val.debug_fault_info[DBG_ESR_EVT_HWWP].fn   = HW_watchpointHandler;
    kernelApi.val.debug_fault_info[DBG_ESR_EVT_HWWP].sig  = SIGTRAP;
    kernelApi.val.debug_fault_info[DBG_ESR_EVT_HWWP].code = TRAP_HWBKPT;
    kernelApi.val.debug_fault_info[DBG_ESR_EVT_HWWP].name = "hw-watchpoint handler";
    kernelApi.fun.register_step_hook(&gHwStepHook);

#ifdef CONFIG_CPU_PM
    /*注册cpu暂停后恢复断点的回调函数*/
    /*保存原先的变量*/
    kernelApi.val.default_hw_breakpoint_restore = *kernelApi.val.hw_breakpoint_restore;
    *kernelApi.val.hw_breakpoint_restore        = (u64)HW_breakpointReset;
#endif

已实现的硬件断点驱动

目前的话，该驱动已经实现。详情可参考硬件断点仓库。

目前只依赖两个内核选项：

  1. CONFIG_KALLSYMS=y
  2. CONFIG_KALLSYMS_ALL=y

linux 4.19~6.0内核均已测试，可以直接使用。

该驱动共分为3部分，分为底层实现，多核CPU的断点同步管理，API接口开放。

底层实现

底层实现包括设置对应的硬件断点寄存器，监控设置的地址，注册调试异常 hook等，注册单步异常 hook。

多核心CPU的断点同步管理

上述的底层实现只是实现单核 CPU断点的设置。假如在一个多核心的 CPU上要监视某个内存地址的读写行为，那肯定是要监控所有 CPU对该地址的读写行为，只监控当前 CPU的访问肯定是不够的。所以该部分是对上述底层的封装，对所有运行的核心进行遍历，通过多核同步机制(smp_call_function_single)，给所有核心打上/删除相同的断点。

API接口开放

该部分集中管理所有通过API接口设置的断点，对外开放设置断点的接口，可选择和 KGDB联动，实现断点触发后的源码级调试。分为如下几个部分：

  1. 直接通过地址设置断点。
  2. 通过符号名字设置断点。
  3. 在启用 kgdb联动功能后，可以通过 kgdb的设置断点功能设置硬件断点。
  4. 在 shell下通过 proc调试文件来设置断点。
  5. 查询符号地址。
  6. 查询符号地址里的内容（针对指针变量使用）。

断点监测的虚拟地址范围最大为2Gb。当断点被触发时，会打印出当时操作这块内存的堆栈信息，便于问题定位，或是代码的深度理解。若是启用了 KGDB的联动功能，则会在打出堆栈信息后，进入 KGDB状态，等待远程主机连接调试。KGDB的原来及使用可以参考我的前一篇文章KGDB原理分析及远程挂载调试ARM64内核。

使用方法

这里只介绍proc接口的使用方法，代码里使用直接调对应的函数即可，接口均已导出。

添加断点

echo add <type> <len> <symbol>/<addr> > /proc/breakpoint, add a breakpoint
	[type]:
		[wp1]: HW_BREAKPOINT_R
		[wp2]: HW_BREAKPOINT_W
		[wp3]: HW_BREAKPOINT_R|HW_BREAKPOINT_W
		 [bp]:  HW_BREAKPOINT_X
	[len]:[0,8] (2^3,2^31]

使用add指令可添加一个断点，长度可以是1~2^31的任意值，驱动会自动解析入参，设置一个大于期望监控地址范围的断点。触发时会根据期望监控的地址范围，选择是否打印堆栈。重复插入相同地址的断点会失败

删除断点

echo del <symbol>/<addr> > /proc/breakpoint, del a breakpoint

删除一个断点。

查询符号地址或数据

echo get ptr/val <symbol> > /proc/breakpoint, search &symbol/*(&symbol)

有些时候想监控的地址是一个指针变量的地址的话，直接输入该符号名字，就无法监控了。所以提供了一个可以查询符号里内容的操作，可以查询指针变量里的指针。然后使用echo add <type> <len> <addr> > /proc/breakpoint打断点。也可以查询函数地址，然后在函数地址+N的地方设置执行断点。

列出所有已设置的断点

echo show > /proc/breakpoint

该命令用于查询所有已设置的断点，信息示例如下所示：

--------------------------------------------------
breakpoint[6]:														/*观察断点是6~9，执行断点是0~5*/
        type:   HW_BREAKPOINT_RW									/*断点类型*/
        name:   zwf_test_value0+0x0/0xffffffffffffda78 [hw_break]	/*断点的符号名称*/
        monit:  0xffffff8000843588--->0xffffff800084358b			/*断点期望监控的地址范围*/
        len:    4													/*断点期望监控的长度*/
        mask:   0x0													/*断点的mask掩码*/
        range:  0xffffff8000843588--->0xffffff800084358c			/*断点实际监控的地址范围*/
        size:   4													/*断点实际监控的大小*/
--------------------------------------------------
breakpoint[7]:
        type:   HW_BREAKPOINT_RW
        name:   zwf_test_value1+0x0/0xffffffffffffd9f8 [hw_break]
        monit:  0xffffff8000843608--->0xffffff8000843610
        len:    9
        mask:   0x5
        range:  0xffffff8000843600--->0xffffff800084361f
        size:   31
--------------------------------------------------
breakpoint[8]:
        type:   HW_BREAKPOINT_RW
        name:   zwf_test_value2+0x0/0xffffffffffffd978 [hw_break]
        monit:  0xffffff8000843688--->0xffffff80008436d4
        len:    77
        mask:   0x7
        range:  0xffffff8000843680--->0xffffff80008436ff
        size:   127
--------------------------------------------------
breakpoint[9]:
        type:   HW_BREAKPOINT_RW
        name:   zwf_test_value3+0x0/0xffffffffffffdb00 [hw_break]
        monit:  0xffffff8000843500--->0xffffff800084357f
        len:    128
        mask:   0x8
        range:  0xffffff8000843500--->0xffffff80008435ff
        size:   255
sixgodtwo
关注
  • 7
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 33
    评论
ARM硬件断点
qq_42693685的博客
10-08 2093
文档可以在这个网站下载。hw_breakpoint 是由处理器提供专门断点寄存器来保存一个地址，是需要处理器支持的。处理器在执行过程中会不断去匹配，当匹配上后则会产生中断。可以看到应该是每个cpu都注册了一个。感觉应该是在一个cpu上注册，所有cpu都会去检查（原理不清楚，上面的文档没有看明白，猜测的）内核自带了硬件断点的样例linux-3.16\samples\hw_breakpoint\data_breakpoint.c。
arm的软断点和硬断点
xiaoyaofeidao的博客
11-26 2819
近期我们有个电子工程师遇到个问题，通过iar下载的程序好像断点的信息会保留在程序里，并且程序也别修改了，掉电了也会存在。同时运行时会停在断点的地方 后来我查了查这个问题，今天写个博客，记录一下。 Breakpoints在iar里面默认是Auto的其实大多数情况下就Software的，软断点 软件断点则是通过在代码中设置特征值的方式来实现的。当需要在某地址代码处设置软件断点的时候，仿真器会先将此处代码进行备份保护， 然后将预先设定好的断点特征值写入此地址，覆盖原来的代码数据（包括rom flash
如何在ARM Linux内核中使用硬件断点1
08-03
file:///G:/BaiduNetdiskDownload/课时8/资料/硬件断点/如何在ARM Linux内核中使用硬件断点 - lingxf的专栏 -
arm64 linux 中断,ARM64 中断处理流程
weixin_32042331的博客
05-12 703
如果说 Linux 内核是个身体，保罗万象，那么中断就如同是其中更为关键的神经系统，有了他的存在，中央处理器才能了解各个外设所处的状态，并且及时的给与支持响应。本章的重点不是介绍如何使用中断与中断 API，更不是为了了解软件中断、硬件中断、tasklet 微任务以及工作队列有何分别，我们仅仅只是为了观察中断时如何一步步传递上来又是如何处理的流程的呢？中断注册中断即 CPU 在执行进程上下文期间，出...
arm64 linux 中断,ARM6410平台下，linux中断处理
weixin_29867607的博客
05-12 212
首先说下如果在裸机的情况下硬件中断是如何到来的：首先中断有内部中断和外部中断两种，中断一共有64个中断源1：内部中断的中断银角是直接和VIC(向量中断控制器)相连的，一个中断占用一个中断源，比如：wdt、网卡等设备程序可以直接通过中断控制器中存放的中断处理函数来执行，因为某个内部中断号产生的源头是唯一的，而外部中断不同2：由于外部中断比较多，除了内部中断之后的中断源不足以提供给外部中断，所以外部中...
如何在ARM Linux内核中使用硬件断点
lingxf的专栏
03-27 6894
欢迎使用Markdown编辑器写博客本Markdown编辑器使用StackEdit修改而来，用它写博客，将会带来全新的体验哦： Markdown和扩展Markdown简洁的语法 代码块高亮 图片链接和图片上传 LaTex数学公式 UML序列图和流程图 离线写博客 导入导出Markdown文件 丰富的快捷键 快捷键 加粗 Ctrl + B 斜体 Ctrl + I 引用 Ctrl
ARM64 linux 中断处理--架构
kakaBack的专栏
08-28 764
摘要：在 ARM64 嵌入式开发中，中断非常重要和常见的模块，研究和了解中断的架构和处理流程就非常重要。 本文主要阐述中断的整体架构和初始化流程，可以作为SOC和驱动开发参考
xilinx-2011.09-50-arm-xilinx-linux-gnueabi.bin.7z
09-04
2. **驱动程序开发**：对于硬件接口的访问，如GPIO、中断、定时器等，开发者需要编写驱动程序，这同样需要arm-xilinx-linux-gnueabi工具链的支持。 3. **实时系统优化**：通过GCC的配置选项，可以进行代码优化，...
linux下使用vscode搭建STM32开发环境流程资料
06-29
在Linux环境中，可以通过OpenOCD驱动J-Link，实现对STM32的调试。 **6. ARM-GCC编译器**：ARM-GCC是GNU Compiler Collection（GCC）针对ARM架构的版本，用于将C/C++源代码编译为可在STM32上运行的二进制代码。理解...
ARM 裸机-NXP 官方 SDK 使用-VScode 工程-4-ledc-sdk
04-27
首先，"ARM 裸机"指的是基于ARM架构的微处理器在没有操作系统的情况下直接运行代码的环境，通常用于学习底层硬件控制和系统级编程。接着，"NXP 官方 SDK" 提到了NXP半导体公司提供的软件开发工具包，SDK通常包括驱动...
嵌入式系统/ARM技术中的浅谈ARM仿真器中的断点资源
12-09
目前，越来越多的嵌入式开发公司和工程师开始采用JTAG方式的ICE仿真器来进行程序的调试工作。传统的全仿真方式(Full ICE)正在逐渐被使用灵活、成本低廉的JTAG仿真方式所取代。 JTAG仿真器目前可以满足嵌入式程序调试的所有基本要求，例如：断点设置、单步调试、内存编辑、变量、寄存器观测等。(如图1所示) 断点设置是JTAG仿真器最基本的调试功能。用户需要系统在设置断点处停下来后再进行调试。断点根据原理和用途不同又分为几个不同的种类。本文将简单地介绍一下常用的几种断点类型。 断点可分为硬件断点和软件断点两大类： 1．硬件断点需要目标CPU的硬件支持，当前流行的ARM7/9内部硬件设计提供
ARM&LINUX汇编语言程序设计
03-11
《ARM&LINUX汇编语言程序设计》是一个深入探讨在Linux环境下使用ARM架构进行汇编编程的主题。...《ARM&LINUX汇编语言程序设计》这个资源可能包含了更多详细的实例和解析，帮助你进一步掌握这个主题。
arm64架构的linux中断分析（四）
jianjian的博客
06-20 480
在Linux内核中，使用了类似中断控制器的模型，在每个中断控制器中管理多个中断，其中每个中断对应不同的中断处理程序，比如IOAPIC和APIC都是中断控制器的实现。当然，我们还要重点关注irq_generic_chip_ops结构体、irq_chip里面的方法和rockchip_irq_demux这个中断处理函数。中断控制器分为链式中断和层级中断，他们都是多个中断处理程序组成的中断处理链，链式中断适用于任务相对较简单、执行时间短的场景，而层级中断适用于需要更细粒度的控制和响应的场景。
linux 断点调试技巧 包教包会 适合新手 萌新 进阶 老司机。 步骤详细 ，不怕自己学不会
这是一个c++热爱者的博客哟
06-26 1520
使用 gdb 之前 ，要使用 gcc -g 源文件 生成包含调试信息的可执行文件。然后 gdb 可执行文件首先要明白 断点的基本调试单步调试 step over 顺序执行每条程序，如果这条程序是一个函数，就不会进入方法体中，而是把这个函数当成一条简单语句执行单步跳入 ，step into 如果当前行断点是一个方法，则进入当前方法体内。单步跳出 step out 跳出进入的方法体以下面的函数为例子 先不打断点 ， 使用start 命令 ，相当于
Linux断点方法,Linux：断点原理与实现
weixin_28958733的博客
05-14 1582
前言从事编程工作的我们，总有调试的时刻，不管是通过 IDE 调试开发中的代码，还是通过 GDB 排查正在运行的进程。特别是经常使用 GDB 的童鞋，对它提供的强大功能更加如数家珍，其中就不乏 breakpoint(断点)。刚好最近做到 Ptrace 相关的实验，也顺便撸了这篇小文来分享下 断点 当中的道理。简单 GDB 示范// test.cpp#include#includevoid test...
查找内核崩溃断点
Sam 的专栏
04-23 659
arm-none-linux-gnueabi-addrline -f -e ./vmlinux address
ARM学习（22）断点认识以及调试
张一西的博客
06-11 2441
笔者来聊聊断点以及断点的调试。
Linux：基础命令学习
最新发布
qq_55038440的博客
07-20 1459
实例：-F根据文件类型在列出的文件名称后加一符号。实例： -R 递归显示目录中的所有文件和子目录。. 开头的隐藏文件也会列出。可执行文件则加 "*"，用于显示目录文件信息。
Linux ARM64
03-04
Linux ARM64是一种基于ARM64架构的操作系统，是Linux内核在ARM64平台上的一个变种。ARM64是一种64位的ARM架构，广泛应用于移动设备、嵌入式系统和服务器等领域。 Linux ARM64提供了与传统的x86架构相似的功能和特性，但针对ARM64架构进行了优化。它支持多任务处理、多用户环境、文件系统、网络通信等功能，可以运行各种应用程序和服务。 Linux ARM64具有以下特点： 1. 高性能：ARM64架构具有更高的计算能力和更低的功耗，使得Linux ARM64在移动设备和嵌入式系统中具有出色的性能表现。 2. 节能省电：ARM64架构采用了先进的节能技术，可以在保证性能的同时降低功耗，延长设备的电池寿命。 3. 开放源代码：Linux ARM64是开源的，用户可以自由地修改和定制内核，以满足特定需求。 4. 生态丰富：Linux ARM64拥有庞大的开发者社区和丰富的软件资源，用户可以轻松获取各种应用程序和工具。
评论 33
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值