can print out all fd syscall traces

4 files changed, 82 insertions, 32 deletions

diff --git a/internal/c/types.h b/internal/c/types.h
index 081883c..7784e3e 100644
--- a/internal/c/types.h
+++ b/internal/c/types.h
@@ -45,5 +45,5 @@ struct ret_event {
     __u32 pid;
     __u32 tid;
     __u32 time;
-    __u64 ret;
+    __s64 ret;
 };
diff --git a/internal/eventloop.go b/internal/eventloop.go
index d22ea62..cffb941 100644
--- a/internal/eventloop.go
+++ b/internal/eventloop.go
@@ -3,8 +3,6 @@ package internal
 import "C"
 
 import (
-	"bytes"
-	"encoding/binary"
 	"fmt"
 
 	. "ioriotng/internal/generated/types"
@@ -21,47 +19,59 @@ func (o openFile) String() string {
 	return fmt.Sprintf("(%d) %s", o.fd, o.path)
 }
 
-func binaryCompare(ev *OpenEnterEvent, raw []byte) {
-	buf := new(bytes.Buffer)
-	if err := binary.Write(buf, binary.LittleEndian, *ev); err != nil {
-		panic(err)
-	}
-	bytes := buf.Bytes()
-	fmt.Println("bytes", bytes)
-	fmt.Println("raw  ", raw)
-}
-
 type Event interface {
 	String() string
-	GetTid() uint32
+	TID() uint32
+	Timestamp() uint32
+	Recycle()
+}
+
+func human(enterEv, exitEv Event) string {
+	return fmt.Sprintf("%08d µs %s %s",
+		exitEv.Timestamp()-enterEv.Timestamp(), enterEv, exitEv)
 }
 
 func eventLoop(bpfModule *bpf.Module, ch <-chan []byte) {
-	type Event interface {
-		String() string
-	}
+	enterEvs := make(map[uint32]Event)
 
 	for raw := range ch {
-		var ev Event
+		var exitEv Event
+
 		switch EventType(raw[0]) {
 		case ENTER_OPEN_EVENT:
-			ev = NewOpenEnterEvent(raw)
+			ev := NewOpenEnterEvent(raw)
+			enterEvs[ev.Tid] = ev
 		case EXIT_OPEN_EVENT:
-			ev = NewFdEvent(raw)
+			ev := NewFdEvent(raw)
+			if enterEv, ok := enterEvs[ev.Tid]; ok {
+				fmt.Println(human(enterEv, ev))
+				enterEv.Recycle()
+			}
+			ev.Recycle()
+
 		case ENTER_FD_EVENT:
-			ev = NewFdEvent(raw)
+			ev := NewFdEvent(raw)
+			enterEvs[ev.Tid] = ev
 		case EXIT_FD_EVENT:
-			ev = NewFdEvent(raw)
-		case ENTER_NULL_EVENT:
-			ev = NewNullEvent(raw)
+			exitEv = NewFdEvent(raw)
 		case EXIT_NULL_EVENT:
-			ev = NewNullEvent(raw)
+			exitEv = NewNullEvent(raw)
 		case EXIT_RET_EVENT:
-			ev = NewRetEvent(raw)
+			exitEv = NewRetEvent(raw)
 		default:
-			panic("Unknown event type")
+			panic(fmt.Sprintf("Unknown event type %s", EventType(raw[0])))
+		}
+
+		if exitEv == nil {
+			continue
 		}
-		fmt.Println(ev)
+
+		if enterEv, ok := enterEvs[exitEv.TID()]; ok {
+			fmt.Println(human(enterEv, exitEv))
+			enterEv.Recycle()
+		}
+
+		exitEv.Recycle()
 	}
 
 	fmt.Println("Good bye")
diff --git a/internal/generated/nqc.raku b/internal/generated/nqc.raku
index a975df6..835365f 100644
--- a/internal/generated/nqc.raku
+++ b/internal/generated/nqc.raku
@@ -73,13 +73,13 @@ class NQCToGoActions {
             {$<member>.map(*.made).join('; ')} 
         \}
         
-        {self!struct-go-string-method($/)}
+        {self!struct-go-methods($/)}
         {($<identifier>.made.ends-with('Event') ?? "\n" ~ self!struct-go-sync-pool($/) !! '')}
         END
     }
 
-    # Generate String() method on the Go struct, for pretty printing.
-    method !struct-go-string-method($/) returns Str {
+    # Generate String() and other methods on the Go struct, for pretty printing.
+    method !struct-go-methods($/) returns Str {
         my Str $self-ref = $<identifier>.lc.substr(0,1);
         my Str @format = $<member>.map({ $_.<identifier>.made ~ ':%v' });
 
@@ -93,6 +93,14 @@ class NQCToGoActions {
         func ($self-ref {$<identifier>.made}) String() string \{
             return fmt.Sprintf("{@format.join(' ')}", {@args.join(', ')})
         \}
+
+        func ($self-ref *{$<identifier>.made}) TID() uint32 \{
+            return $self-ref.Tid
+        \}
+
+        func ($self-ref *{$<identifier>.made}) Timestamp() uint32 \{
+            return $self-ref.Time
+        \}
         END
     }
 
diff --git a/internal/generated/types/types.go b/internal/generated/types/types.go
index e3f89db..e52bad0 100644
--- a/internal/generated/types/types.go
+++ b/internal/generated/types/types.go
@@ -155,6 +155,14 @@ func (o OpenEnterEvent) String() string {
 	return fmt.Sprintf("EventType:%v SyscallId:%v Pid:%v Tid:%v Time:%v Filename:%v Comm:%v", o.EventType, o.SyscallId, o.Pid, o.Tid, o.Time, string(o.Filename[:]), string(o.Comm[:]))
 }
 
+func (o *OpenEnterEvent) TID() uint32 {
+	return o.Tid
+}
+
+func (o *OpenEnterEvent) Timestamp() uint32 {
+	return o.Time
+}
+
 var poolOfOpenEnterEvents = sync.Pool{
 	New: func() interface{} { return &OpenEnterEvent{} },
 }
@@ -184,6 +192,14 @@ func (n NullEvent) String() string {
 	return fmt.Sprintf("EventType:%v SyscallId:%v Pid:%v Tid:%v Time:%v", n.EventType, n.SyscallId, n.Pid, n.Tid, n.Time)
 }
 
+func (n *NullEvent) TID() uint32 {
+	return n.Tid
+}
+
+func (n *NullEvent) Timestamp() uint32 {
+	return n.Time
+}
+
 var poolOfNullEvents = sync.Pool{
 	New: func() interface{} { return &NullEvent{} },
 }
@@ -214,6 +230,14 @@ func (f FdEvent) String() string {
 	return fmt.Sprintf("EventType:%v SyscallId:%v Pid:%v Tid:%v Time:%v Fd:%v", f.EventType, f.SyscallId, f.Pid, f.Tid, f.Time, f.Fd)
 }
 
+func (f *FdEvent) TID() uint32 {
+	return f.Tid
+}
+
+func (f *FdEvent) Timestamp() uint32 {
+	return f.Time
+}
+
 var poolOfFdEvents = sync.Pool{
 	New: func() interface{} { return &FdEvent{} },
 }
@@ -237,13 +261,21 @@ type RetEvent struct {
 	Pid       uint32
 	Tid       uint32
 	Time      uint32
-	Ret       uint64
+	Ret       int64
 }
 
 func (r RetEvent) String() string {
 	return fmt.Sprintf("EventType:%v SyscallId:%v Pid:%v Tid:%v Time:%v Ret:%v", r.EventType, r.SyscallId, r.Pid, r.Tid, r.Time, r.Ret)
 }
 
+func (r *RetEvent) TID() uint32 {
+	return r.Tid
+}
+
+func (r *RetEvent) Timestamp() uint32 {
+	return r.Time
+}
+
 var poolOfRetEvents = sync.Pool{
 	New: func() interface{} { return &RetEvent{} },
 }