初步支持offset计算

Author: SeeFlowerX

user/event/event_raw_syscalls.go

@@ -111,14 +111,16 @@ func (this *SyscallEvent) String() string {
     case EventTypeSysEnter:
         // --getlr 和 --getpc 建议只使用其中一个
         if conf.GetLR {
-            info, err := this.ParseLR()
+            // info, err := this.ParseLR()
+            info, err := this.ParseLRV1()
             if err != nil {
                 return fmt.Sprintf("ParseLR err:%v\n", err)
             }
             return fmt.Sprintf("%s LR:0x%x Info:\n%s\n", base_str, this.lr, info)
         }
         if conf.GetPC {
-            info, err := this.ParsePC()
+            // info, err := this.ParsePC()
+            info, err := this.ParsePCV1()
             if err != nil {
                 return fmt.Sprintf("ParsePC err:%v\n", err)
             }
@@ -151,6 +153,10 @@ func (this *SyscallEvent) String() string {
     return base_str
 }
 
+func (this *SyscallEvent) ParseLRV1() (string, error) {
+    return maps_helper.GetOffset(this.Pid, this.lr), nil
+}
+
 func (this *SyscallEvent) ParseLR() (string, error) {
     info := "UNKNOWN"
     // 直接读取maps信息 计算lr在什么地方 定位syscall调用也就一目了然了
@@ -182,6 +188,12 @@ func (this *SyscallEvent) ParseLR() (string, error) {
     return info, err
 }
 
+func (this *SyscallEvent) ParsePCV1() (string, error) {
+    // 通过在启动阶段收集到的库基址信息来计算偏移
+    // 由于每个进程的加载情况不一样 这里要传递 pid
+    return maps_helper.GetOffset(this.Pid, this.pc), nil
+}
+
 func (this *SyscallEvent) ParsePC() (string, error) {
     info := "UNKNOWN"
     // 直接读取maps信息 计算pc在什么地方 定位syscall调用也就一目了然了

user/event/event_soinfo.go

@@ -9,32 +9,43 @@ import (
     "fmt"
     "stackplz/pkg/util"
     "stackplz/user/config"
+    "strings"
+    "sync"
 )
 
 type LibInfo struct {
-    Pid      uint32
     BaseAddr uint64
     LibSize  uint64
+    EndAddr  uint64
     LibPath  string
 }
 
 type MapsHelper map[uint32]PidMaps
 type PidMaps map[string][]LibInfo
 
-func NewMapsHelper() *MapsHelper {
-    helper := &MapsHelper{}
+func NewMapsHelper() MapsHelper {
+    helper := make(MapsHelper)
     return helper
 }
 
 func (this *MapsHelper) UpdateMaps(soinfo *SoInfoEvent) {
+    // 拙劣的函数
+    maps_lock.Lock()
+    defer maps_lock.Unlock()
     pid_maps, ok := (*this)[soinfo.Pid]
     if !ok {
-        (*this)[soinfo.Pid] = PidMaps{}
+        pid_maps = make(PidMaps)
+        (*this)[soinfo.Pid] = pid_maps
+    }
+    pid_maps = (*this)[soinfo.Pid]
+    if soinfo.LibPath == "" {
+        soinfo.LibPath = fmt.Sprintf("UNNAMED_0x%x", soinfo.BaseAddr)
     }
     info := LibInfo{
         LibSize:  soinfo.LibSize,
         BaseAddr: soinfo.BaseAddr,
         LibPath:  soinfo.LibPath,
+        EndAddr:  soinfo.BaseAddr + soinfo.LibSize,
     }
     base_list, ok := pid_maps[soinfo.LibPath]
     if ok {
@@ -48,24 +59,59 @@ func (this *MapsHelper) UpdateMaps(soinfo *SoInfoEvent) {
         }
         if !has_find {
             base_list = append(base_list, info)
+            pid_maps[soinfo.LibPath] = base_list
         }
     } else {
         pid_maps[soinfo.LibPath] = []LibInfo{info}
     }
+    (*this)[soinfo.Pid] = pid_maps
 }
 
-func (this *MapsHelper) GetOffset(addr uint64) (info string) {
-    return ""
+func (this *MapsHelper) GetOffset(pid uint32, addr uint64) (info string) {
+    maps_lock.Lock()
+    defer maps_lock.Unlock()
+    pid_maps, ok := (*this)[pid]
+    if !ok {
+        // 暂时没有这个 pid 对应的 maps 信息
+        return fmt.Sprintf("UNNKOWN + 0x%x", addr)
+    }
+    // 这里的计算是以库的每个段都是前后连续为前提的，暂时就这样
+    // 但是实际上确实存在一些奇怪的操作
+    // 1. 不连续的段
+    // 2. 两个或者多个同名/同路径的库存在于maps中
+    // 3. 其他...
+    // 全部遍历是一种低效的写法，但是暂时没有更好的想法，就这样
+    // 一定要优化那么应该在每次 pid_maps 变更的时候就进行排序 并按照基址大小插入
+    var off_list []string = []string{}
+    for lib_path, lib_infos := range pid_maps {
+        for _, lib_info := range lib_infos {
+            if addr >= lib_info.BaseAddr && addr < lib_info.EndAddr {
+                offset := fmt.Sprintf("%s + 0x%x", lib_path, addr-lib_info.BaseAddr)
+                off_list = append(off_list, offset)
+            }
+        }
+    }
+    if len(off_list) == 0 {
+        return fmt.Sprintf("NOTFOUND + 0x%x", addr)
+    }
+    return strings.Join(off_list[:], ",")
 }
 
+// func (this *MapsHelper) toString() (s string) {
+//     s = ""
+//     s += fmt.Sprintln(*this)
+//     return s
+// }
+
 var maps_helper = NewMapsHelper()
+var maps_lock sync.Mutex
 
 type SoInfoEvent struct {
     event_type EventType
     KEvent
-    mconf    *config.ModuleConfig
-    Pid      uint32
-    Tid      uint32
+    mconf *config.ModuleConfig
+    // Pid      uint32
+    // Tid      uint32
     Comm     [16]byte
     BaseAddr uint64
     LibSize  uint64
@@ -96,7 +142,7 @@ func (this *SoInfoEvent) Decode() (err error) {
         return
     }
     this.LibPath = util.B2STrim(this.RealPath[:])
-
+    maps_helper.UpdateMaps(this)
     return nil
 }
 

user/event/event_stack.go

@@ -18,9 +18,9 @@ import (
 type UprobeStackEvent struct {
     event_type EventType
     KEvent
-    mconf     *config.ModuleConfig
-    Pid       uint32
-    Tid       uint32
+    mconf *config.ModuleConfig
+    // Pid       uint32
+    // Tid       uint32
     Timestamp uint64
     Comm      [16]byte
     // Buffer       [256]byte

user/module/imodule.go

@@ -297,7 +297,6 @@ func (this *Module) ringbufEventReader(errChan chan error, em *ebpf.Map) {
                 this.logger.Printf("%s\tthis.child.decode error:%v", this.child.Name(), err)
                 continue
             }
-
             // 直接将解析数据交给 processor 做
             // 从而加快读取环形缓冲区的数据 减缓数据丢失的概率
             this.processor.Write(e)