golang与非golang程序探测beyla源码解读

更新时间：2023年12月18日 14:06:19 作者：a朋

这篇文章主要为大家介绍了beyla源码解读之golang与非golang程序的探测实例，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪

beyla中golang程序与非golang程序的ebpf探测

beyla中golang程序与非golang程序的ebpf采用了不同的探测方式

golang：使用uprobe监听用户库函数；
非golang：使用kprobe监听内核函数；

程序类型的定义：

// beyla/pkg/internal/svc/svc.go
type InstrumentableType int
const (
   InstrumentableGolang = InstrumentableType(iota)
   InstrumentableJava
   InstrumentableDotnet
   InstrumentablePython
   InstrumentableRuby
   InstrumentableNodejs
   InstrumentableRust
   InstrumentableGeneric
)

一.程序的区分方法

对golang与非golang程序，其区分方法是读elf可执行文件，然后查找symbols是否包含golang的function，以go nethttp为例:

读elf文件的symbols，然后查找其中是否有go http的function；
http的function：
- "net/http.serverHandler.ServeHTTP"
- "net/http.(*conn).readRequest"
- "net/http.(*response).WriteHeader"
- "net/http.(*Transport).roundTrip"

源码，重点是inspectOffset(execElf)函数：

读取elf文件，解析其中的symbols；
如果探测到golang的用户函数，则认为是Golang程序；

// beyla/pkg/internal/discover/typer.go
func (t *typer) asInstrumentable(execElf *exec.FileInfo) Instrumentable {
    ...
    // look for suitable Go application first
    offsets, ok := t.inspectOffsets(execElf)
    if ok {
        // we found go offsets, let's see if this application is not a proxy
        if !isGoProxy(offsets) {
            return Instrumentable{Type: svc.InstrumentableGolang, FileInfo: execElf, Offsets: offsets}
        }
    } 
    ...
    detectedType := exec.FindProcLanguage(execElf.Pid, execElf.ELF)
    return Instrumentable{Type: detectedType, FileInfo: execElf, ChildPids: child}
}

按照注册监听时的function列表，在elf中查找symbols：

findGoSymbolTable(elfF)负责从elf中提取symbols；

// beyla/pkg/internal/goexec/instructions.go
func instrumentationPoints(elfF *elf.File, funcNames []string) (map[string]FuncOffsets, error) {
    ...
    symTab, err := findGoSymbolTable(elfF)
    for _, f := range symTab.Funcs {
        ...
        if _, ok := functions[fName]; ok {
            offs, ok, err := findFuncOffset(&f, elfF)
            if ok {
                allOffsets[fName] = offs
            }
        }
    }
    return allOffsets, nil
}

重点看一下findGoSymbolTable()函数的实现：

首先，读取elf文件中section=.gopclntab的内容；
然后，读取elf文件中section=.text的内容；
最后，使用上面读取的内容，构造symTab；
golang的这种elf结构，保证了：
- 即使elf被stripped，也能通过 debug/gosym 库，将其中的symbols读取出来；
- debug/gosym 是Go标准库中的一个包，用于解析Go程序的符号表信息；

// beyla/pkg/internal/goexec/instructions.go
func findGoSymbolTable(elfF *elf.File) (*gosym.Table, error) {
    var err error
    var pclndat []byte
    // program counter line table
    if sec := elfF.Section(".gopclntab"); sec != nil {
        if pclndat, err = sec.Data(); err != nil {
            return nil, fmt.Errorf("acquiring .gopclntab data: %w", err)
        }
    }
    txtSection := elfF.Section(".text")
    pcln := gosym.NewLineTable(pclndat, txtSection.Addr)
    symTab, err := gosym.NewTable(nil, pcln)
    ...
    return symTab, nil
}

看下elf中包含的sections:

可以看出，其中包gopclntab和text这两个section;

# objdump -h example-http
example-http     文件格式 elf64-x86-64
节：
Idx Name          Size      VMA               LMA               File off  Algn
  0 .text         0020e3e6  0000000000401000  0000000000401000  00001000  2**5
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  1 .plt          00000260  000000000060f400  000000000060f400  0020f400  2**4
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  2 .rodata       000e2060  0000000000610000  0000000000610000  00210000  2**5
                  CONTENTS, ALLOC, LOAD, READONLY, DATA
  3 .dynsym       000003f0  00000000006f2940  00000000006f2940  002f2940  2**3
                  CONTENTS, ALLOC, LOAD, READONLY, DATA
...
                  CONTENTS, ALLOC, LOAD, READONLY, DATA
 12 .gosymtab     00000000  00000000006f4a90  00000000006f4a90  002f4a90  2**0
                  CONTENTS, ALLOC, LOAD, READONLY, DATA
 13 .gopclntab    001440b0  00000000006f4aa0  00000000006f4aa0  002f4aa0  2**5
                  CONTENTS, ALLOC, LOAD, READONLY, DATA
 14 .go.buildinfo 00000140  0000000000839000  0000000000839000  00439000  2**4
                  CONTENTS, ALLOC, LOAD, DATA
...
 24 .note.go.buildid 00000064  0000000000400f80  0000000000400f80  00000f80  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, DATA

二.golang与非golang程序的监听探针

golang与非golang程序使用了不同的ebpf监听方法。

golang程序：使用newGoTracerGroup()注册tracer的方法；
非golang程序：使用newNonGoTracersGroup()注册tracer的方法；

// beyla/pkg/internal/discover/attacher.go
func (ta *TraceAttacher) getTracer(ie *Instrumentable) (*ebpf.ProcessTracer, bool) {
    ...
    var programs []ebpf.Tracer
    switch ie.Type {
    case svc.InstrumentableGolang:
        ...
        tracerType = ebpf.Go
        programs = filterNotFoundPrograms(newGoTracersGroup(ta.Cfg, ta.Metrics), ie.Offsets)
    case svc.InstrumentableJava, svc.InstrumentableNodejs, svc.InstrumentableRuby, svc.InstrumentablePython, svc.InstrumentableDotnet, svc.InstrumentableGeneric, svc.InstrumentableRust:
        ...
        programs = newNonGoTracersGroup(ta.Cfg, ta.Metrics)
    }
    ...
}

1.golang程序的tracer:

// beyla/pkg/internal/discover/finder.go
func newGoTracersGroup(cfg *pipe.Config, metrics imetrics.Reporter) []ebpf.Tracer {
    // Each program is an eBPF source: net/http, grpc...
    return []ebpf.Tracer{
        nethttp.New(&cfg.EBPF, metrics),
        &nethttp.GinTracer{Tracer: *nethttp.New(&cfg.EBPF, metrics)},
        grpc.New(&cfg.EBPF, metrics),
        goruntime.New(&cfg.EBPF, metrics),
        gosql.New(&cfg.EBPF, metrics),
    }
}

以nethttp为例，ebpf监听的用户库函数：

// beyla/pkg/internal/ebpf/nethttp/nethttp.go
func (p *Tracer) GoProbes() map[string]ebpfcommon.FunctionPrograms {
   return map[string]ebpfcommon.FunctionPrograms{
      "net/http.serverHandler.ServeHTTP": {
         Start: p.bpfObjects.UprobeServeHTTP,
      },
      "net/http.(*conn).readRequest": {
         End: p.bpfObjects.UprobeReadRequestReturns,
      },
      "net/http.(*response).WriteHeader": {
         Start: p.bpfObjects.UprobeWriteHeader,
      },
      "net/http.(*Transport).roundTrip": { // HTTP client, works with Client.Do as well as using the RoundTripper directly
         Start: p.bpfObjects.UprobeRoundTrip,
         End:   p.bpfObjects.UprobeRoundTripReturn,
      },
   }
}

2.非golang程序的tracer:

// beyla/pkg/internal/discover/finder.go
func newNonGoTracersGroup(cfg *pipe.Config, metrics imetrics.Reporter) []ebpf.Tracer {
    return []ebpf.Tracer{httpfltr.New(cfg, metrics), httpssl.New(cfg, metrics)}
}

进入到httpfltr查看监听的kprobe函数：

// beyla/pkg/internal/ebpf/httpfltr/httpfltr.go
func (p *Tracer) KProbes() map[string]ebpfcommon.FunctionPrograms {
   return map[string]ebpfcommon.FunctionPrograms{
      // Both sys accept probes use the same kretprobe.
      // We could tap into __sys_accept4, but we might be more prone to
      // issues with the internal kernel code changing.
      "sys_accept": {
         Required: true,
         End:      p.bpfObjects.KretprobeSysAccept4,
      },
      "sys_accept4": {
         Required: true,
         End:      p.bpfObjects.KretprobeSysAccept4,
      },
      "sock_alloc": {
         Required: true,
         End:      p.bpfObjects.KretprobeSockAlloc,
      },
      "tcp_rcv_established": {
         Required: true,
         Start:    p.bpfObjects.KprobeTcpRcvEstablished,
      },
      // Tracking of HTTP client calls, by tapping into connect
      "sys_connect": {
         Required: true,
         End:      p.bpfObjects.KretprobeSysConnect,
      },
      "tcp_connect": {
         Required: true,
         Start:    p.bpfObjects.KprobeTcpConnect,
      },
      "tcp_sendmsg": {
         Required: true,
         Start:    p.bpfObjects.KprobeTcpSendmsg,
      },
      // Reading more than 160 bytes
      "tcp_recvmsg": {
         Required: true,
         Start:    p.bpfObjects.KprobeTcpRecvmsg,
         End:      p.bpfObjects.KretprobeTcpRecvmsg,
      },
   }
}

参考：https://www.jb51.net/article/264383.htm

以上就是golang与非golang程序探测beyla源码解读的详细内容，更多关于golang beyla程序探测的资料请关注脚本之家其它相关文章！

您可能感兴趣的文章:

golang beyla采集trace程序原理源码解析
beyla支持通过ebpf,无侵入的、自动采集应用程序的trace信息,本文以golang的nethttp为例,讲述beyla对trace的采集的实现原理,有需要的朋友可以借鉴参考下,希望能够有所帮助
2024-02-02
Go语言如何实现RSA加密解密
这篇文章主要介绍了Go语言实现RSA加密解密的操作，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
2021-05-05
Go语言的IO库那么多纠结该如何选择
在Go语言中涉及 I/O 操作的内置库有很多种，比如： io 库， os 库， ioutil 库， bufio 库， bytes 库， strings 库等等。拥有这么多内置库是好事，但是具体到涉及 I/O 的场景我们应该选择哪个库呢，带着这个问题一起通过本文学习下吧
2021-06-06
Golang 类型转换的实现(断言、强制、显式类型)
将一个值从一种类型转换到另一种类型,便发生了类型转换,在go可以分为断言、强制、显式类型转换,本文就详细的介绍一下这就几种转换方式,具有一定的参考价值,感兴趣的可以了解一下
2023-09-09
GO比较两个对象是否相同实战案例
我们时常有比较两个值是否相等的需求,下面这篇文章主要给大家介绍了关于GO比较两个对象是否相同的相关资料,文中通过实例代码介绍的非常详细,需要的朋友可以参考下
2022-12-12
从零封装Gin框架配置初始化全局变量
这篇文章主要为大家介绍了从零封装Gin框架配置初始化全局变量,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪
2024-01-01
Go语言生成随机数的方法
这篇文章主要介绍了Go语言生成随机数的方法,实例分析了Go语言生成随机数的原理与实现技巧,具有一定参考借鉴价值,需要的朋友可以参考下
2015-02-02
golang HTTP 服务器处理日志/Stream流的操作
这篇文章主要介绍了golang HTTP 服务器处理日志/Stream流的操作，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
2020-12-12
Golang中的错误处理的示例详解
这篇文章主要为大家详细介绍了Golang中的错误处理的相关资料，文章中的示例代码讲解详细，对我们学习Golang有一定帮助，需要的可以参考一下
2022-11-11
GoLang实现日志收集器流程讲解
这篇文章主要介绍了GoLang实现日志收集器流程，看日志是开发者平时排查BUG所必须的掌握的技能，但是日志冗杂，所以写个小工具来收集这些日志帮助我们排查BUG，感兴趣想要详细了解可以参考下文
2023-05-05