port wakeuptime

Author: mozillazg

.gitignore

@@ -20,8 +20,10 @@
 /tools/biopattern/biopattern
 /tools/biosnoop/biosnoop
 /tools/biostacks/biostacks
+/tools/biotop/biotop
 /tools/bitesize/bitesize
 /tools/cachestat/cachestat
+/tools/capable/capable
 /tools/cpudist/cpudist
 /tools/cpufreq/cpufreq
 /tools/drsnoop/drsnoop
@@ -34,6 +36,7 @@
 /tools/funclatency/funclatency
 /tools/gethostlatency/gethostlatency
 /tools/hardirqs/hardirqs
+/tools/javagc/javagc
 /tools/klockstat/klockstat
 /tools/ksnoop/ksnoop
 /tools/llcstat/llcstat
@@ -57,6 +60,9 @@
 /tools/tcpconnlat/tcpconnlat
 /tools/tcplife/tcplife
 /tools/tcprtt/tcprtt
+/tools/tcpstates/tcpstates
 /tools/tcpsynbl/tcpsynbl
+/tools/tcptop/tcptop
 /tools/tcptracer/tcptracer
 /tools/vfsstat/vfsstat
+/tools/wakeuptime/wakeuptime

README.md

@@ -58,4 +58,4 @@
 * [ ] tcptop
 * [x] [tcptracer](./tools/tcptracer)
 * [ ] vfsstat
-* [ ] wakeuptime
+* [x] [wakeuptime](./tools/wakeuptime)

common/tracehelpers.go

@@ -3,6 +3,8 @@ package common
 import (
 	"bufio"
 	"bytes"
+	"debug/elf"
+	"errors"
 	"fmt"
 	"os"
 	"sort"
@@ -196,7 +198,7 @@ type Ksym struct {
 }
 
 type Ksyms struct {
-	Syms []Ksym
+	syms []Ksym
 	// Strs string
 }
 
@@ -220,31 +222,30 @@ func LoadKsyms() (*Ksyms, error) {
 			return nil, err
 		}
 		name := fields[2]
-		ksyms.Syms = append(ksyms.Syms, Ksym{
+		ksyms.syms = append(ksyms.syms, Ksym{
 			Name: name,
 			Addr: addr,
 		})
 	}
 
-	syms := ksyms.Syms
+	syms := ksyms.syms
 	sort.Slice(syms, func(i, j int) bool {
 		if syms[i].Addr == syms[j].Addr {
 			return syms[i].Name >= syms[j].Name
 		}
 		return syms[i].Addr >= syms[j].Addr
 	})
 
-	ksyms.Syms = syms
+	ksyms.syms = syms
 	return ksyms, nil
 }
 
 func (k *Ksyms) MapAddr(addr uint64) *Ksym {
-	syms := k.Syms
+	syms := k.syms
 	i := sort.Search(len(syms), func(i int) bool {
 		return syms[i].Addr <= addr
 	})
 
-	// fmt.Printf("%d ? %d\n", addr, i)
 	if i < len(syms) {
 		v := syms[i]
 		return &v
@@ -253,11 +254,307 @@ func (k *Ksyms) MapAddr(addr uint64) *Ksym {
 }
 
 func (k *Ksyms) GetSymbol(name string) *Ksym {
-	for _, v := range k.Syms {
+	for _, v := range k.syms {
 		v := v
 		if v.Name == name {
 			return &v
 		}
 	}
 	return nil
 }
+
+type LoadRange struct {
+	start   uint64
+	end     uint64
+	fileOff uint64
+}
+
+const (
+	EXEC = iota
+	DYN
+	PERF_MAP
+	VDSO
+	UNKNOWN
+)
+
+type Sym struct {
+	Name  string
+	start uint
+	size  uint
+}
+
+type Syms struct {
+	dsos []Dso
+}
+
+func (s *Syms) MapAddr(addr uint64) *Sym {
+	d, _ := s.findDso(addr)
+	if d == nil {
+		return nil
+	}
+	return nil
+}
+
+func (s *Syms) findDso(addr uint64) (*Dso, uint64) {
+	var offset uint64
+	for _, d := range s.dsos {
+		for _, r := range d.ranges {
+			if addr <= r.start || addr >= r.end {
+				continue
+			}
+			if d._type == DYN || d._type == VDSO {
+				/* Offset within the mmap */
+				offset = addr - r.start + r.fileOff
+				/* Offset within the ELF for dyn symbol lookup */
+				offset += d.shAddr - d.shOffset
+			} else {
+				offset = addr
+			}
+			return &d, offset
+		}
+	}
+
+	return nil, 0
+}
+
+func (s *Syms) find_sym() {
+
+}
+
+type Dso struct {
+	name   string
+	ranges []LoadRange
+	// range_sz int
+	/* Dyn's first text section virtual addr at execution */
+	shAddr uint64
+	/* Dyn's first text section file offset */
+	shOffset uint64
+	_type    int
+	syms     []Sym
+
+	/*
+	 * libbpf's struct btf is actually a pretty efficient
+	 * "set of strings" data structure, so we create an
+	 * empty one and use it to store symbol names.
+	 */
+	// struct btf *btf;
+}
+
+func (d *Dso) findSym(offset uint64) *Sym {
+	syms := d.syms
+	i := sort.Search(len(syms), func(i int) bool {
+		// return syms[i].Addr <= addr
+		return true
+	})
+
+	if i < len(syms) {
+		v := syms[i]
+		return &v
+	}
+	return nil
+}
+
+func (d *Dso) loadSymTable() error {
+	switch d._type {
+	case PERF_MAP:
+		return d.loadSymTableFromPerfMap()
+	case EXEC, DYN:
+		return d.loadSymTableFromElf(0)
+	case VDSO:
+		return d.loadSymTableFromVdsoImage()
+	default:
+		return errors.New("unsupported type")
+	}
+}
+
+func (d *Dso) loadSymTableFromPerfMap() error {
+	return errors.New("unsupported type")
+}
+
+func (d *Dso) loadSymTableFromElf(fd int) error {
+	return nil
+}
+
+func (d *Dso) loadSymTableFromVdsoImage() error {
+	return nil
+}
+
+type SymsCache struct {
+	data []SymsCacheData
+	// Nr   int
+}
+
+type SymsCacheData struct {
+	syms Syms
+	tgid int
+}
+
+func NewSymsCache() *SymsCache {
+	return &SymsCache{}
+}
+
+func (s *SymsCache) GetSyms(tgid int) (*Syms, error) {
+	for _, d := range s.data {
+		if d.tgid == tgid {
+			return &d.syms, nil
+		}
+	}
+
+	syms, err := symsLoadPid(tgid)
+	if err != nil {
+		return nil, err
+	}
+	s.data = append(s.data, SymsCacheData{
+		syms: *syms,
+		tgid: tgid,
+	})
+	return syms, nil
+}
+
+func (s *Syms) addDso(m addrMap, name string) error {
+	var d *Dso
+	for _, item := range s.dsos {
+		if item.name == name {
+			d = &item
+		}
+	}
+	if d == nil {
+		d = &Dso{
+			name: name,
+		}
+	}
+	d.ranges = append(d.ranges, LoadRange{
+		start:   m.startAddr,
+		end:     m.endAddr,
+		fileOff: m.fileOff,
+	})
+
+	elfType, err := getElfType(name)
+	if err != nil {
+		return err
+	}
+	if elfType == elf.ET_EXEC {
+		d._type = EXEC
+	} else if elfType == elf.ET_DYN {
+		d._type = DYN
+		var err error
+		d.shAddr, d.shOffset, err = getElfTextScnInfo(name)
+		if err != nil {
+			return err
+		}
+	} else if isPerfMap(name) {
+		d._type = PERF_MAP
+	} else if isVdso(name) {
+		d._type = VDSO
+	} else {
+		d._type = UNKNOWN
+	}
+
+	return nil
+}
+
+func getElfTextScnInfo(path string) (uint64, uint64, error) {
+	f, err := elf.Open(path)
+	if err != nil {
+		return 0, 0, err
+	}
+	defer f.Close()
+	for _, s := range f.Sections {
+		if s.Name == ".text" {
+			return s.Addr, s.Offset, nil
+		}
+	}
+	return 0, 0, errors.New("not found")
+}
+
+func getElfType(path string) (elf.Type, error) {
+	if isVdso(path) {
+		return 0, nil
+	}
+	f, err := elf.Open(path)
+	if err != nil {
+		return 0, err
+	}
+	f.Close()
+	return f.Type, nil
+}
+
+func symsLoadPid(tgid int) (*Syms, error) {
+	name := fmt.Sprintf("/proc/%d/maps", tgid)
+	return symsLoadFile(name)
+}
+
+type addrMap struct {
+	startAddr uint64
+	endAddr   uint64
+	fileOff   uint64
+	devMajor  uint64
+	devMinor  uint64
+	inode     uint64
+}
+
+func symsLoadFile(name string) (*Syms, error) {
+	fdata, err := os.ReadFile(name)
+	if err != nil {
+		return nil, err
+	}
+	var syms *Syms
+	s := bufio.NewScanner(bytes.NewReader(fdata))
+	for s.Scan() {
+		line := strings.TrimSpace(s.Text())
+		if line == "" {
+			continue
+		}
+		var addrMap addrMap
+		var perm string
+		var name string
+		n, err := fmt.Fscanf(strings.NewReader(line),
+			"%x-%x %4s %x %x:%x %u%s",
+			&addrMap.startAddr, &addrMap.endAddr, &perm, &addrMap.fileOff,
+			&addrMap.devMajor, &addrMap.devMinor, &addrMap.inode, &name)
+		if err != nil {
+			return nil, err
+		}
+		if n == 0 {
+			continue
+		}
+		if len(perm) < 3 || perm[2] != 'x' {
+			continue
+		}
+		if !isFileBacked(name) {
+			continue
+		}
+		if isVdso(name) {
+			break
+		}
+		if err := syms.addDso(addrMap, name); err != nil {
+			return nil, err
+		}
+	}
+
+	return syms, nil
+}
+
+func isFileBacked(mapname string) bool {
+	if mapname == "" {
+		return false
+	}
+	if strings.HasPrefix(mapname, "//anon") ||
+		strings.HasPrefix(mapname, "/dev/zero") ||
+		strings.HasPrefix(mapname, "/anon_hugepage") ||
+		strings.HasPrefix(mapname, "[stack") ||
+		strings.HasPrefix(mapname, "/SYSV") ||
+		strings.HasPrefix(mapname, "[heap]") ||
+		strings.HasPrefix(mapname, "[vsyscall]") {
+		return false
+	}
+	return true
+}
+
+func isVdso(path string) bool {
+	return path == "[vdso]"
+}
+
+func isPerfMap(path string) bool {
+	return false
+}