KGTP中增加对GDB命令“set trace-buffer-size”的支持 - Week 5

最新推荐文章于 2023-07-26 15:01:02 发布
最新推荐文章于 2023-07-26 15:01:02 发布
阅读量1.4k 收藏
点赞数
分类专栏： 开源夏令营 文章标签： KGTP Kernel Debug Tracing gdb
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/calmdownba/article/details/38659317
版权

CSDN开源夏令营 - 第五周工作总结


在实现了GDB和KGTP之间的“set trace-buffer-size”命令解析后， 接下来我们需要根据用户传入的buffer size，来调整buffer的大小。按照[1]的提示，具体实现可以在KGTP接到数据包后，分配一套新的ring buffer，之后把现有ring buffer中的数据拷贝到新的ring buffer中，然后释放现有ring buffer。 其中要注意的问题主要是如果现有ring buffer比新ring buffer大，需要丢弃一部分数据，如果被丢弃的数据正在现在tfind的范围内，可能需要一些特殊的处理。 最后如果实在不能在复杂的情况下比如ring buffer中有数据或者tracepoint运行中处理“set trace-buffer-size”，则允许KGTP报错。

因此，首先我们需要了解一下目前KGTP中的ring buffer的工作原理。

1. Ring Buffer的基本原理

首先，让我们来了解一下“环形缓冲区”是如何工作的，[2]是一个不错的参考。FIFO大家都知道，是一个先进先出的队列，而Ring Buffer则是一个环形的FIFO。使用Ring Buffer可以使得读写并发执行，读线程和写线程可以采用“生产者”和“消费者”的模型来访问缓冲区。当只存在一个读，一个写的时候，不需要任何互斥措施，而当有多个读或者写的时候，则需要一定的同步措施，比如锁或者信号量。

下面先给出[2]中一个简单且有效的环形缓冲区的实现，先有一个直观的认识： 

template <class _Type>
class CShareQueue 
{
public:
CShareQueue();
CShareQueue(unsigned int bufsize);
virtual ~CShareQueue();

_Type pop_front();
bool push_back( _Type item);
//返回容量
unsigned int capacity() { //warning:需要外部数据一致性
return m_capacity;
}
//返回当前个数
unsigned int size() { //warning:需要外部数据一致性
return m_size;
}
//是否满//warning: 需要外部控制数据一致性
bool IsFull() {
return (m_size >= m_capacity);
}

bool IsEmpty() {
return (m_size == 0);
}


protected:
UINT m_head;
UINT m_tail;
UINT m_size;
UINT m_capacity;
_Type *pBuf;


};

template <class _Type>
CShareQueue<_Type>::CShareQueue() : m_head(0), m_tail(0), m_size(0)
{
pBuf = new _Type[512];//默认512
m_capacity = 512;
}

template <class _Type>
CShareQueue<_Type>::CShareQueue(unsigned int bufsize) : m_head(0), m_tail(0)
{
if( bufsize > 512 || bufsize < 1)
{
pBuf = new _Type[512];
m_capacity = 512;
}
else
{
pBuf = new _Type[bufsize];
m_capacity = bufsize;
}
}

template <class _Type>
CShareQueue<_Type>::~CShareQueue()
{
delete[] pBuf;
pBuf = NULL;
m_head = m_tail = m_size = m_capacity = 0;
}

//前面弹出一个元素
template <class _Type>
_Type CShareQueue<_Type>::pop_front()
{
if( IsEmpty() )
{
return NULL;
}
_Type itemtmp;
itemtmp = pBuf[m_head];
m_head = (m_head + 1) % m_capacity;
--m_size;
return itemtmp;

}

//从尾部加入队列
template <class _Type>
bool CShareQueue<_Type>::push_back( _Type item)
{
if ( IsFull() )
{
return FALSE;
}
pBuf[m_tail] = item;
m_tail = (m_tail + 1) % m_capacity;
++m_size;
return TRUE;
}


#endif // !defined(_DALY_CSHAREQUEUE_H_)


环形环形区和队列缓冲区的区别是什么呢？环形缓冲区所有的push和pop操作都是在一个固定 的存储空间内进行。而队列缓冲区在push的时候，可能会分配存储空间用于存储新元素；在pop时，可能会释放废弃元素的存储空间。所以环形方式相比队列方式，少掉了对于缓冲区元素所用存储空间的分配、释放。这是环形缓冲区的一个主要优势。

让我们再看一下Circular Buffer更加科学的定义，参考[3]。

2. Linux Kernel的Ring Buffer

让我们从这篇文章[4]开始学习，看看Linux内核中的Ring Buffer之争。

先来看看，目前的Ring Buffer实现，可能至少分为三种，Ftrace，LTTng和perf， 

One of the outcomes from the Collaboration Summit in April was a plan to create a tracing ring buffer implementation that would work for both Ftrace and LTTng. There was also hope that perhaps the separate ring buffer added for perf could be folded in as well, so that the vision of a single ring buffer implementation in the kernel—from the 2008 Kernel Summit and Linux Plumbers Conference—could come to fruition. To that end, Steven Rostedt posted an RFC for a unified ring buffer, but before that conversation could really get going, it was diverted. It seems that Ingo Molnar thinks there are much bigger issues to resolve in the world of Linux tracing.

而在Linux Kernel中，ring buffer如何定义呢？ 

A ring buffer is a circular data structure that is often used to hold data that is produced and consumed by separate processes without synchronization. For tracing, the data is produced by the kernel outside of any specific process's context, but the consumer is in user space. The kernel needs to hand out pages from the head of the ring buffer to user space for consumption, while ensuring that it doesn't overwrite that data as it writes to the tail of the buffer.

嗯，由Kernel生产的数据在内核空间，而消费者在用户空间，内核需要把ring buffer开头的页面分发给用户空间的消费者，同时要确保向尾部写的数据不会覆盖掉将要分发的数据。

目前，几种ring buffer的实现貌似还是各自为政，在自己的设计体系下工作良好，unified ring buffer的争论也此起彼伏，而核心问题还是ring buffer的效率以及简单易用，如果有一个这样的实现出现，那么unified也不是太困难的事情。

kfifo是Linux Kernel中一个经典的ring buffer的实现，看这篇文章[5]，分析了kfifo的实现后，作者仿照其原理自行实现了一个Ring Buffer，且有测试程序。另外一个比较好的参考[6]。

关于Linux Kernel中的Ring Buffer实现，最权威的是阅读源代码和看内核树中的文档，文档在[6]，这里还提到了memory barrier，也涉及了spinlock。源代码的话，看<linux/ring_buffer.h>和<linux/ring_buffer.c>，或者是perf和LTTng中的实现。

关于内核跟踪的Ring Buffer实现，强烈推荐阅读[7]， “ Linux内核跟踪之ring buffer的实现”。

由于Linux Kernel涉及到大量的并发，需要考虑到各种竞争和同步，还有其分页的内存机制，因此导致了内核中的Ring Buffer实现及其复杂，想要看懂需要对Linux内核有足够的认识。因此，一遍看Ring Buffer的实现，一遍参考Linux内核相关书籍。

3. KGTP中的Ring Buffer

想要知道KGTP的Ring Buffer是如何实现的，看gtp.c可以找到蛛丝马迹， 

/* Sepcial config */
 #define GTP_RB // GTP_RB is the own implementation ring buffer of KGTP

 #ifdef GTP_FRAME_SIMPLE
 /* This is a debug option.
    This define is for simple frame alloc record, then we can get how many
    memory are wasted by FRAME_ALIGN. */
 /* #define FRAME_ALLOC_RECORD */
 #undef GTP_RB // GTP_FRAME_SIMPLE and GTP_RB are not used at the same time
 #endif

 #ifdef GTP_FTRACE_RING_BUFFER
 #undef GTP_RB // GTP_FTRACE_RING_BUFFER and GTP_RB are not used at the same time
 #endif

#ifdef GTP_FTRACE_RING_BUFFER
 #ifndef CONFIG_RING_BUFFER
 #define CONFIG_RING_BUFFER
 #include "ring_buffer.h"
 #include "ring_buffer.c"
 #define GTP_SELF_RING_BUFFER // use the modified ring buffer from Linux kernel used by Ftrace
 #warning Use the ring buffer inside KGTP.
 #endif // end for ifndef CONFIG_RING_BUFFER
 #endif
 /* Sepcial config */

#ifdef GTP_FTRACE_RING_BUFFER
 #ifndef GTP_SELF_RING_BUFFER
 #include <linux/ring_buffer.h> // use the standard ring buffer provided by Linux kernel
 #endif
 #endif

/* GTP_FRAME_SIZE must align with FRAME_ALIGN_SIZE if use GTP_FRAME_SIMPLE.  */
 #define GTP_FRAME_SIZE      5242880 // 5120*1024=5*1024*1024
 #if defined(GTP_FRAME_SIMPLE) || defined(GTP_RB)
 #define FRAME_ALIGN_SIZE    sizeof(unsigned int)
 #define FRAME_ALIGN(x)      ((x + FRAME_ALIGN_SIZE - 1) \
                  & (~(FRAME_ALIGN_SIZE - 1)))
 #endif // GTP_FRAME_SIMPLE or GTP_RB defined

 #ifdef GTP_FRAME_SIMPLE
 #define GTP_FRAME_HEAD_SIZE (FID_SIZE + sizeof(char *) + sizeof(ULONGEST))
 #define GTP_FRAME_REG_SIZE  (FID_SIZE + sizeof(char *) \
                  + sizeof(struct pt_regs))
 #define GTP_FRAME_MEM_SIZE  (FID_SIZE + sizeof(char *) \
                  + sizeof(struct gtp_frame_mem))
 #define GTP_FRAME_VAR_SIZE  (FID_SIZE + sizeof(char *) \
                  + sizeof(struct gtp_frame_var))
 #endif // end for ifdef GTP_FRAME_SIMPLE

 #ifdef GTP_RB
 /* The frame head size: FID_HEAD + count id + frame number + pointer to prev frem */
 #define GTP_FRAME_HEAD_SIZE (FID_SIZE + sizeof(u64) + sizeof(ULONGEST) + sizeof(void *))
 /* The frame head size: FID_PAGE_BEGIN + count id */
 #define GTP_FRAME_PAGE_BEGIN_SIZE   (FID_SIZE + sizeof(u64))
 #endif // end for ifdef GTP_RB

 #ifdef GTP_FTRACE_RING_BUFFER
 #define GTP_FRAME_HEAD_SIZE (FID_SIZE + sizeof(ULONGEST))
 #endif // end for ifdef GTP_FTRACE_RING_BUFFER

 #if defined(GTP_FTRACE_RING_BUFFER) || defined(GTP_RB)
 #define GTP_FRAME_REG_SIZE  (FID_SIZE + sizeof(struct pt_regs))
 #define GTP_FRAME_MEM_SIZE  (FID_SIZE + sizeof(struct gtp_frame_mem))
 #define GTP_FRAME_VAR_SIZE  (FID_SIZE + sizeof(struct gtp_frame_var))
 #endif // GTP_FTRACE_RING_BUFFER or GTP_RB defined

以及gtp.h中的gtp_trace_s的相关定义， 

#ifdef GTP_FRAME_SIMPLE
     /* Next part set it to prev part.  */
     char                **next;
 #endif
 #ifdef GTP_FTRACE_RING_BUFFER
     /* NULL means doesn't have head.  */
     char                *next;
 #endif
 #ifdef GTP_RB
     /* rb of current cpu.  */
     struct gtp_rb_s         *next;
     u64             id;
 #endif

另外，我们还可以在KGTP的源码树中看到 ring_buffer.c， ring_buffer.h，这是对Linux的标准实现的修改。 perf_event.c，从perf中取出的有关ring buffer的实现。 gtp_rb.c则是KGTP自行实现的一套Ring Buffer。

在调试“set trace-buffer-size”的过程中，我们发现KGTP默认使用自行实现的Ring Buffer，因此接下来会仔细分析gtp_rb.c。

4. 实现set trace-buffer-size的策略

首先我们知道已有trace buffer的大小size，对于用户通过“set trace-buffer-size”设置的新大小new_size，如果new_size >= size，则只需要分配一套新的Ring Buffer后，拷贝数据。而new_size < size的话，需要舍弃一部分数据，这个在研究了GDB的frame和tfind之后再做分析。

5. 参考链接

[1] http://code.csdn.net/os_camp/18/proposals/28?tab=working
[2] http://blog.csdn.net/yuyin86/article/details/7566033
[3] http://en.wikipedia.org/wiki/Circular_buffer
[4] http://lwn.net/Articles/388978/
[5] http://www.cnblogs.com/Anker/p/3481373.html
[6] https://www.kernel.org/doc/Documentation/circular-buffers.txt
hustcalm
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
trace_output_buffer
11-29
谁能告诉我在quartus下如何去配置它？？
Android性能优化 -- Systrace工具
GJQI12的专栏
02-25 498
Systrace简介 一般来说，我们的机器以60帧/秒显示时，用户会感觉机器很流畅，如果显示时出现丢帧的情况，需要知道当前整个系统所处的状态，这个时候Systrace便是最佳的工具选择。 Systrace是Android4.1中新增的性能数据采样和分析工具。它可帮助开发者收集Android关键子系统（如Surfaceflinger、WindowManagerService等fra...
KGTP、linux内核、GDB的系统结构
lynuszhu的专栏
07-28 2464
KGTP、linux内核、GDB的系统结构如果用一句话给KGTP新用户总结，那我就会说，这三者的关系就是，用户通过GDB提供的命令行接口与驻扎在内核空间KGTP通信，使这个内核模块抓取制定的数据并归还给GDB，GDB最后展示给最终用户。如果还有人不懂，那么我可以这样再深入一点，KGTP实际就是一个gdb stub（关于stub中文资料就比较多了），只不过它不是放在嵌入式板子上做调试用的，而是跑在内
kgtp
weixin_33906657的博客
08-10 101
kgtp使用总结1，介绍：Kgtp项目主页是：http://code.google.com/p/kgtp/如其项目主页所描述，Kgtp是一个实时且轻量级的Linux跟踪内核调试工具。也许说是一个内核跟踪调试接口更合适，通过它来连通内核和GDB，使得GDB可以对内核进行跟踪调试。GDB既可以是在本机，也可以在另外一台机器上，甚至还可以进行离线调试，而这些感觉应该都是GDB本身提供的Targets、T...
修改trace buffer size
03-28 361
Changing the trace buffer size can only be done in the parameter file: _trace_pool_size=100M[@more@] ...
深入理解Linux 内核追踪机制
最新发布
youzhangjing_的博客
07-26 1114
Linux 存在众多 tracing tools，比如 ftrace、perf，他们可用于内核的调试、提高内核的可观测性。众多的工具也意味着繁杂的概念，诸如 tracepoint、trace events、kprobe、eBPF 等，甚至让人搞不清楚他们到底是干什么的。本文尝试理清这些概念。
【24】kgtp玩法
linjiasen的博客
05-13 316
https://github.com/teawater/kgtp/blob/master/UPDATE
嵌入式跟踪单元ETB MTB (Micro Trace Buffer )的实现
u014285530的博客
04-22 6493
嵌入式跟踪单元ETB MTB (Micro Trace Buffer )的实现 释义 1 ARM程序开发难免碰到BUG，如果是明显的逻辑BUG，那我们用普通调试手段就可以达到目的；在项目开发阶段，常常会遇到Hard fault错误或者程序跑飞的情况，这些bug采用正常的方法是比较难定位的。 2 调试（debug）手段不管用，或者效率低下的时候，就需要我们的追踪(trace)手段上场了，庆幸的...
KGTP中增加对GDB命令“set trace-buffer-size”的支持 - Week 1
Calmdownba的专栏
07-13 965
这一周主要对KGTP的实现进行了简单的熟悉和分析，主要can'k
性能优化工具（二）-Systrace
06-24 435
一、简介 Systrace是分析Android性能问题的神器，Google IO 2017上更是对其各种强推. 是分析卡顿掉帧问题核心工具，只要能提供卡顿现场，systrace就能很好定位问题，但是有一定上手难度，所以会稍微花比较多的篇幅来学习，当然systrace配合traceView使用...
KGTP中增加对GDB命令“set trace-buffer-size”的支持 - Week 2
Calmdownba的专栏
07-22 948
CSDN开源夏令营 - 第一周工作总结
KGTP中增加对GDB命令“set trace-buffer-size”的支持 - Week 3
Calmdownba的专栏
07-27 1313
CSDN开源夏令营 - 第三周工作总结 这一周zhu'yao
ftrace buffer size
yiyeguzhou100的专栏
04-19 2167
toor4@lrc:/sys/kernel/debug/tracing# cat buffer_total_size_kb 22528 toor4@lrc:/sys/kernel/debug/tracing# cat buffer_size_kb （每CPU的ftrace buffer size） 1408 toor4@lrc:/sys/kernel/debug/tracing# echo
使用 ftrace 调试 Linux 内核
热门推荐
adaptiver的专栏
08-31 2万+
使用 ftrace 调试 Linux 内核，第 1 部分 http://blog.csdn.net/tommy_wxie/article/details/7340701 简介： ftrace 是 Linux 内核中提供的一种调试工具。使用 ftrace 可以对内核中发生的事情进行跟踪，这在调试 bug 或者分析内核时非常有用。本系列文章对 ftrace 进行了介绍，分为三部分。本文是第一部
1.2 ESP32-MicroPython基础操作
qq_20031585的博客
12-04 2441
用五篇文章，描述如何使用ESP32在MicroPython固件下，开发一个支持Modbus采集，MQTT上报，可OTA升级的IOT协议采集器。这是第一篇，基础操作。
【ESP32】【Micropython】开发环境搭建（esptool、shell）
zhgfn4056100的博客
04-10 6217
esp32的micropython环境搭建
Ftrace debugfs 接口使用说明（内核文档 ftrace.rst）
看我眼色行事的博客
12-01 2396
本文主要详细讲解linux下面ftrace的tracefs（debugfs）接口的使用方式，基本涵盖所有功能点的使用方式，及每个文件的具体作用，当然与之有关联的或拓展的功能如perf，kprobe等使用不在本次讲解范围。ftrace作为内核性能分析调优，跟踪内核行为等的强大工具，应该是每个内核开发人员或驱动开发人员需要掌握的一项调试手段，相信认真读完本文对ftrace的使用及帮助分析内核行为或者理解linux内核各个子模块源码是很有帮助的。
使kgtp支持存储超过一页的内存数据
lynuszhu的专栏
08-04 507
使kgtp支持存储超过一页的内存数据
KGTP在ubuntu上的部署安装步骤
duanlove（技术路途）专栏
11-16 1437
使用KGTP前的准备工作 Linux内核 如果你的系统内核是自己编译的 要使用KGTP，你需要打开下面这些内核选项： General setup  --->         [*] Kprobes [*] Enable loadable module support  ---> Kernel hacking  --->         [*] Debug Filesyste

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值