benchutil: replace event serialization panics with errors

1 files changed, 108 insertions, 58 deletions

diff --git a/internal/benchutil/eventgen.go b/internal/benchutil/eventgen.go
index 3f8b345..0c0ec9c 100644
--- a/internal/benchutil/eventgen.go
+++ b/internal/benchutil/eventgen.go
@@ -1,7 +1,6 @@
 package benchutil
 
 import (
-	"fmt"
 	"syscall"
 
 	"ior/internal/generate"
@@ -24,7 +23,7 @@ func NewEventGenerator() EventGenerator {
 	return EventGenerator{PairDelta: defaultPairDelta}
 }
 
-func (g EventGenerator) EnterOpenEvent(time uint64, pid, tid uint32) (types.OpenEvent, []byte) {
+func (g EventGenerator) EnterOpenEvent(time uint64, pid, tid uint32) (types.OpenEvent, []byte, error) {
 	ev := types.OpenEvent{
 		EventType: types.ENTER_OPEN_EVENT,
 		TraceId:   types.SYS_ENTER_OPENAT,
@@ -37,10 +36,11 @@ func (g EventGenerator) EnterOpenEvent(time uint64, pid, tid uint32) (types.Open
 	}
 	copy(ev.Filename[:], defaultOpenName)
 	copy(ev.Comm[:], defaultOpenComm)
-	return ev, mustBytes(&ev)
+	raw, err := eventBytes(&ev)
+	return ev, raw, err
 }
 
-func (g EventGenerator) ExitOpenEvent(time uint64, pid, tid uint32) (types.RetEvent, []byte) {
+func (g EventGenerator) ExitOpenEvent(time uint64, pid, tid uint32) (types.RetEvent, []byte, error) {
 	ev := types.RetEvent{
 		EventType: types.EXIT_OPEN_EVENT,
 		TraceId:   types.SYS_EXIT_OPENAT,
@@ -49,10 +49,11 @@ func (g EventGenerator) ExitOpenEvent(time uint64, pid, tid uint32) (types.RetEv
 		Pid:       pid,
 		Tid:       tid,
 	}
-	return ev, mustBytes(&ev)
+	raw, err := eventBytes(&ev)
+	return ev, raw, err
 }
 
-func (g EventGenerator) EnterFdEvent(time uint64, pid, tid uint32, fd int32, traceID types.TraceId) (types.FdEvent, []byte) {
+func (g EventGenerator) EnterFdEvent(time uint64, pid, tid uint32, fd int32, traceID types.TraceId) (types.FdEvent, []byte, error) {
 	ev := types.FdEvent{
 		EventType: types.ENTER_FD_EVENT,
 		TraceId:   traceID,
@@ -61,10 +62,11 @@ func (g EventGenerator) EnterFdEvent(time uint64, pid, tid uint32, fd int32, tra
 		Tid:       tid,
 		Fd:        fd,
 	}
-	return ev, mustBytes(&ev)
+	raw, err := eventBytes(&ev)
+	return ev, raw, err
 }
 
-func (g EventGenerator) ExitFdEvent(time uint64, pid, tid uint32, fd int32, traceID types.TraceId) (types.FdEvent, []byte) {
+func (g EventGenerator) ExitFdEvent(time uint64, pid, tid uint32, fd int32, traceID types.TraceId) (types.FdEvent, []byte, error) {
 	ev := types.FdEvent{
 		EventType: types.EXIT_FD_EVENT,
 		TraceId:   traceID,
@@ -73,10 +75,11 @@ func (g EventGenerator) ExitFdEvent(time uint64, pid, tid uint32, fd int32, trac
 		Tid:       tid,
 		Fd:        fd,
 	}
-	return ev, mustBytes(&ev)
+	raw, err := eventBytes(&ev)
+	return ev, raw, err
 }
 
-func (g EventGenerator) EnterNullEvent(time uint64, pid, tid uint32, traceID types.TraceId) (types.NullEvent, []byte) {
+func (g EventGenerator) EnterNullEvent(time uint64, pid, tid uint32, traceID types.TraceId) (types.NullEvent, []byte, error) {
 	ev := types.NullEvent{
 		EventType: types.ENTER_NULL_EVENT,
 		TraceId:   traceID,
@@ -84,10 +87,11 @@ func (g EventGenerator) EnterNullEvent(time uint64, pid, tid uint32, traceID typ
 		Pid:       pid,
 		Tid:       tid,
 	}
-	return ev, mustBytes(&ev)
+	raw, err := eventBytes(&ev)
+	return ev, raw, err
 }
 
-func (g EventGenerator) ExitNullEvent(time uint64, pid, tid uint32, traceID types.TraceId) (types.NullEvent, []byte) {
+func (g EventGenerator) ExitNullEvent(time uint64, pid, tid uint32, traceID types.TraceId) (types.NullEvent, []byte, error) {
 	ev := types.NullEvent{
 		EventType: types.EXIT_NULL_EVENT,
 		TraceId:   traceID,
@@ -95,10 +99,11 @@ func (g EventGenerator) ExitNullEvent(time uint64, pid, tid uint32, traceID type
 		Pid:       pid,
 		Tid:       tid,
 	}
-	return ev, mustBytes(&ev)
+	raw, err := eventBytes(&ev)
+	return ev, raw, err
 }
 
-func (g EventGenerator) ExitRetEvent(time uint64, pid, tid uint32, traceID types.TraceId, ret int64) (types.RetEvent, []byte) {
+func (g EventGenerator) ExitRetEvent(time uint64, pid, tid uint32, traceID types.TraceId, ret int64) (types.RetEvent, []byte, error) {
 	ev := types.RetEvent{
 		EventType: types.EXIT_RET_EVENT,
 		TraceId:   traceID,
@@ -108,10 +113,11 @@ func (g EventGenerator) ExitRetEvent(time uint64, pid, tid uint32, traceID types
 		Tid:       tid,
 		RetType:   retType(traceID),
 	}
-	return ev, mustBytes(&ev)
+	raw, err := eventBytes(&ev)
+	return ev, raw, err
 }
 
-func (g EventGenerator) EnterPathEvent(time uint64, pid, tid uint32, pathname string, traceID types.TraceId) (types.PathEvent, []byte) {
+func (g EventGenerator) EnterPathEvent(time uint64, pid, tid uint32, pathname string, traceID types.TraceId) (types.PathEvent, []byte, error) {
 	ev := types.PathEvent{
 		EventType: types.ENTER_PATH_EVENT,
 		TraceId:   traceID,
@@ -121,10 +127,11 @@ func (g EventGenerator) EnterPathEvent(time uint64, pid, tid uint32, pathname st
 		Pathname:  [types.MAX_FILENAME_LENGTH]byte{},
 	}
 	copy(ev.Pathname[:], pathname)
-	return ev, mustBytes(&ev)
+	raw, err := eventBytes(&ev)
+	return ev, raw, err
 }
 
-func (g EventGenerator) EnterNameEvent(time uint64, pid, tid uint32, oldname, newname string, traceID types.TraceId) (types.NameEvent, []byte) {
+func (g EventGenerator) EnterNameEvent(time uint64, pid, tid uint32, oldname, newname string, traceID types.TraceId) (types.NameEvent, []byte, error) {
 	ev := types.NameEvent{
 		EventType: types.ENTER_NAME_EVENT,
 		TraceId:   traceID,
@@ -136,10 +143,11 @@ func (g EventGenerator) EnterNameEvent(time uint64, pid, tid uint32, oldname, ne
 	}
 	copy(ev.Oldname[:], oldname)
 	copy(ev.Newname[:], newname)
-	return ev, mustBytes(&ev)
+	raw, err := eventBytes(&ev)
+	return ev, raw, err
 }
 
-func (g EventGenerator) EnterFcntlEvent(time uint64, pid, tid uint32, fd uint32, cmd uint32, arg uint64) (types.FcntlEvent, []byte) {
+func (g EventGenerator) EnterFcntlEvent(time uint64, pid, tid uint32, fd uint32, cmd uint32, arg uint64) (types.FcntlEvent, []byte, error) {
 	ev := types.FcntlEvent{
 		EventType: types.ENTER_FCNTL_EVENT,
 		TraceId:   types.SYS_ENTER_FCNTL,
@@ -150,10 +158,11 @@ func (g EventGenerator) EnterFcntlEvent(time uint64, pid, tid uint32, fd uint32,
 		Cmd:       cmd,
 		Arg:       arg,
 	}
-	return ev, mustBytes(&ev)
+	raw, err := eventBytes(&ev)
+	return ev, raw, err
 }
 
-func (g EventGenerator) EnterDup3Event(time uint64, pid, tid uint32, fd int32, flags int32) (types.Dup3Event, []byte) {
+func (g EventGenerator) EnterDup3Event(time uint64, pid, tid uint32, fd int32, flags int32) (types.Dup3Event, []byte, error) {
 	ev := types.Dup3Event{
 		EventType: types.ENTER_DUP3_EVENT,
 		TraceId:   types.SYS_ENTER_DUP3,
@@ -163,10 +172,11 @@ func (g EventGenerator) EnterDup3Event(time uint64, pid, tid uint32, fd int32, f
 		Fd:        fd,
 		Flags:     flags,
 	}
-	return ev, mustBytes(&ev)
+	raw, err := eventBytes(&ev)
+	return ev, raw, err
 }
 
-func (g EventGenerator) EnterOpenByHandleAtEvent(time uint64, pid, tid uint32, flags int32) (types.OpenByHandleAtEvent, []byte) {
+func (g EventGenerator) EnterOpenByHandleAtEvent(time uint64, pid, tid uint32, flags int32) (types.OpenByHandleAtEvent, []byte, error) {
 	ev := types.OpenByHandleAtEvent{
 		EventType: types.ENTER_OPEN_BY_HANDLE_AT_EVENT,
 		TraceId:   types.SYS_ENTER_OPEN_BY_HANDLE_AT,
@@ -175,49 +185,92 @@ func (g EventGenerator) EnterOpenByHandleAtEvent(time uint64, pid, tid uint32, f
 		Tid:       tid,
 		Flags:     flags,
 	}
-	return ev, mustBytes(&ev)
+	raw, err := eventBytes(&ev)
+	return ev, raw, err
 }
 
-func (g EventGenerator) OpenPair(time uint64, pid, tid uint32) ([]byte, []byte) {
-	_, enter := g.EnterOpenEvent(time, pid, tid)
-	_, exit := g.ExitOpenEvent(time+g.pairDelta(), pid, tid)
-	return enter, exit
+func (g EventGenerator) OpenPair(time uint64, pid, tid uint32) ([]byte, []byte, error) {
+	_, enter, err := g.EnterOpenEvent(time, pid, tid)
+	if err != nil {
+		return nil, nil, err
+	}
+	_, exit, err := g.ExitOpenEvent(time+g.pairDelta(), pid, tid)
+	if err != nil {
+		return nil, nil, err
+	}
+	return enter, exit, nil
 }
 
-func (g EventGenerator) FdPair(time uint64, pid, tid uint32, fd int32, enterTraceID, exitTraceID types.TraceId, ret int64) ([]byte, []byte) {
-	_, enter := g.EnterFdEvent(time, pid, tid, fd, enterTraceID)
-	_, exit := g.ExitRetEvent(time+g.pairDelta(), pid, tid, exitTraceID, ret)
-	return enter, exit
+func (g EventGenerator) FdPair(time uint64, pid, tid uint32, fd int32, enterTraceID, exitTraceID types.TraceId, ret int64) ([]byte, []byte, error) {
+	_, enter, err := g.EnterFdEvent(time, pid, tid, fd, enterTraceID)
+	if err != nil {
+		return nil, nil, err
+	}
+	_, exit, err := g.ExitRetEvent(time+g.pairDelta(), pid, tid, exitTraceID, ret)
+	if err != nil {
+		return nil, nil, err
+	}
+	return enter, exit, nil
 }
 
-func (g EventGenerator) NullPair(time uint64, pid, tid uint32, enterTraceID, exitTraceID types.TraceId) ([]byte, []byte) {
-	_, enter := g.EnterNullEvent(time, pid, tid, enterTraceID)
-	_, exit := g.ExitNullEvent(time+g.pairDelta(), pid, tid, exitTraceID)
-	return enter, exit
+func (g EventGenerator) NullPair(time uint64, pid, tid uint32, enterTraceID, exitTraceID types.TraceId) ([]byte, []byte, error) {
+	_, enter, err := g.EnterNullEvent(time, pid, tid, enterTraceID)
+	if err != nil {
+		return nil, nil, err
+	}
+	_, exit, err := g.ExitNullEvent(time+g.pairDelta(), pid, tid, exitTraceID)
+	if err != nil {
+		return nil, nil, err
+	}
+	return enter, exit, nil
 }
 
-func (g EventGenerator) PathPair(time uint64, pid, tid uint32, pathname string, enterTraceID, exitTraceID types.TraceId, ret int64) ([]byte, []byte) {
-	_, enter := g.EnterPathEvent(time, pid, tid, pathname, enterTraceID)
-	_, exit := g.ExitRetEvent(time+g.pairDelta(), pid, tid, exitTraceID, ret)
-	return enter, exit
+func (g EventGenerator) PathPair(time uint64, pid, tid uint32, pathname string, enterTraceID, exitTraceID types.TraceId, ret int64) ([]byte, []byte, error) {
+	_, enter, err := g.EnterPathEvent(time, pid, tid, pathname, enterTraceID)
+	if err != nil {
+		return nil, nil, err
+	}
+	_, exit, err := g.ExitRetEvent(time+g.pairDelta(), pid, tid, exitTraceID, ret)
+	if err != nil {
+		return nil, nil, err
+	}
+	return enter, exit, nil
 }
 
-func (g EventGenerator) NamePair(time uint64, pid, tid uint32, oldname, newname string, enterTraceID, exitTraceID types.TraceId, ret int64) ([]byte, []byte) {
-	_, enter := g.EnterNameEvent(time, pid, tid, oldname, newname, enterTraceID)
-	_, exit := g.ExitRetEvent(time+g.pairDelta(), pid, tid, exitTraceID, ret)
-	return enter, exit
+func (g EventGenerator) NamePair(time uint64, pid, tid uint32, oldname, newname string, enterTraceID, exitTraceID types.TraceId, ret int64) ([]byte, []byte, error) {
+	_, enter, err := g.EnterNameEvent(time, pid, tid, oldname, newname, enterTraceID)
+	if err != nil {
+		return nil, nil, err
+	}
+	_, exit, err := g.ExitRetEvent(time+g.pairDelta(), pid, tid, exitTraceID, ret)
+	if err != nil {
+		return nil, nil, err
+	}
+	return enter, exit, nil
 }
 
-func (g EventGenerator) FcntlPair(time uint64, pid, tid uint32, fd uint32, cmd uint32, arg uint64, exitTraceID types.TraceId, ret int64) ([]byte, []byte) {
-	_, enter := g.EnterFcntlEvent(time, pid, tid, fd, cmd, arg)
-	_, exit := g.ExitRetEvent(time+g.pairDelta(), pid, tid, exitTraceID, ret)
-	return enter, exit
+func (g EventGenerator) FcntlPair(time uint64, pid, tid uint32, fd uint32, cmd uint32, arg uint64, exitTraceID types.TraceId, ret int64) ([]byte, []byte, error) {
+	_, enter, err := g.EnterFcntlEvent(time, pid, tid, fd, cmd, arg)
+	if err != nil {
+		return nil, nil, err
+	}
+	_, exit, err := g.ExitRetEvent(time+g.pairDelta(), pid, tid, exitTraceID, ret)
+	if err != nil {
+		return nil, nil, err
+	}
+	return enter, exit, nil
 }
 
-func (g EventGenerator) Dup3Pair(time uint64, pid, tid uint32, fd int32, flags int32, exitTraceID types.TraceId, ret int64) ([]byte, []byte) {
-	_, enter := g.EnterDup3Event(time, pid, tid, fd, flags)
-	_, exit := g.ExitRetEvent(time+g.pairDelta(), pid, tid, exitTraceID, ret)
-	return enter, exit
+func (g EventGenerator) Dup3Pair(time uint64, pid, tid uint32, fd int32, flags int32, exitTraceID types.TraceId, ret int64) ([]byte, []byte, error) {
+	_, enter, err := g.EnterDup3Event(time, pid, tid, fd, flags)
+	if err != nil {
+		return nil, nil, err
+	}
+	_, exit, err := g.ExitRetEvent(time+g.pairDelta(), pid, tid, exitTraceID, ret)
+	if err != nil {
+		return nil, nil, err
+	}
+	return enter, exit, nil
 }
 
 func (g EventGenerator) pairDelta() uint64 {
@@ -227,12 +280,9 @@ func (g EventGenerator) pairDelta() uint64 {
 	return g.PairDelta
 }
 
-func mustBytes(event interface{ Bytes() ([]byte, error) }) []byte {
+func eventBytes(event interface{ Bytes() ([]byte, error) }) ([]byte, error) {
 	raw, err := event.Bytes()
-	if err != nil {
-		panic(fmt.Sprintf("event serialization failed: %v", err))
-	}
-	return raw
+	return raw, err
 }
 
 func retType(traceID types.TraceId) uint32 {