From 91c0d807274defe2bc62db773f2ac0695dbb91c5 Mon Sep 17 00:00:00 2001 From: Paul Buetow Date: Fri, 6 Mar 2026 16:35:49 +0200 Subject: refactor: remove dot imports for internal types (task 382) --- internal/event/event.go | 4 +- internal/eventloop.go | 135 ++++++++++++++++++++++++------------------------ 2 files changed, 69 insertions(+), 70 deletions(-) diff --git a/internal/event/event.go b/internal/event/event.go index 7ec76c3..c2c9aea 100644 --- a/internal/event/event.go +++ b/internal/event/event.go @@ -3,7 +3,7 @@ package event import ( "sync" - . "ior/internal/types" + "ior/internal/types" ) var poolOfEventPairs = sync.Pool{ @@ -12,7 +12,7 @@ var poolOfEventPairs = sync.Pool{ type Event interface { String() string - GetTraceId() TraceId + GetTraceId() types.TraceId GetPid() uint32 GetTid() uint32 GetTime() uint64 diff --git a/internal/eventloop.go b/internal/eventloop.go index 5fa6f33..2ac0bcc 100644 --- a/internal/eventloop.go +++ b/internal/eventloop.go @@ -15,7 +15,6 @@ import ( "ior/internal/event" "ior/internal/file" "ior/internal/types" - . "ior/internal/types" ) const sysEnterNameToHandleAtName = "name_to_handle_at" @@ -217,7 +216,7 @@ type eventLoop struct { comms map[uint32]string // Program or thread name of the current Tid. commResolver *commResolver prevPairTimes map[uint32]uint64 // Previous event's time (to calculate time differences between two events) - rawHandlers map[EventType]rawEventHandler + rawHandlers map[types.EventType]rawEventHandler exitHandlers map[reflect.Type]tracepointExitHandler printCb func(ep *event.Pair) // Callback to print the event warningCb func(message string) // Optional callback for non-fatal event processing warnings @@ -250,7 +249,7 @@ func newEventLoop(cfg eventLoopConfig) (*eventLoop, error) { comms: commState.comms, commResolver: commState, prevPairTimes: make(map[uint32]uint64), - rawHandlers: make(map[EventType]rawEventHandler), + rawHandlers: make(map[types.EventType]rawEventHandler), exitHandlers: make(map[reflect.Type]tracepointExitHandler), printCb: func(ep *event.Pair) { fmt.Println(ep); ep.Recycle() }, cfg: cfg, @@ -397,7 +396,7 @@ func (e *eventLoop) events(ctx context.Context, rawCh <-chan []byte) <-chan *eve func (e *eventLoop) processRawEvent(raw []byte, ch chan<- *event.Pair) { e.numTracepoints++ e.initRawHandlers() - evType := EventType(raw[0]) + evType := types.EventType(raw[0]) handler, ok := e.rawHandlers[evType] if !ok { e.notifyWarning(fmt.Sprintf("Dropped unhandled raw event type %d", evType)) @@ -408,53 +407,53 @@ func (e *eventLoop) processRawEvent(raw []byte, ch chan<- *event.Pair) { func (e *eventLoop) initRawHandlers() { if e.rawHandlers == nil { - e.rawHandlers = make(map[EventType]rawEventHandler) + e.rawHandlers = make(map[types.EventType]rawEventHandler) } if len(e.rawHandlers) != 0 { return } - e.rawHandlers[ENTER_OPEN_EVENT] = func(raw []byte, _ chan<- *event.Pair) { - if ev, ok := e.filter.openEvent(NewOpenEventFast(raw)); ok { + e.rawHandlers[types.ENTER_OPEN_EVENT] = func(raw []byte, _ chan<- *event.Pair) { + if ev, ok := e.filter.openEvent(types.NewOpenEventFast(raw)); ok { e.tracepointEntered(ev) } } - e.rawHandlers[EXIT_OPEN_EVENT] = func(raw []byte, ch chan<- *event.Pair) { - e.tracepointExited(NewRetEventFast(raw), ch) + e.rawHandlers[types.EXIT_OPEN_EVENT] = func(raw []byte, ch chan<- *event.Pair) { + e.tracepointExited(types.NewRetEventFast(raw), ch) } - e.rawHandlers[ENTER_FD_EVENT] = func(raw []byte, _ chan<- *event.Pair) { - e.tracepointEntered(NewFdEventFast(raw)) + e.rawHandlers[types.ENTER_FD_EVENT] = func(raw []byte, _ chan<- *event.Pair) { + e.tracepointEntered(types.NewFdEventFast(raw)) } - e.rawHandlers[EXIT_FD_EVENT] = func(raw []byte, ch chan<- *event.Pair) { - e.tracepointExited(NewFdEventFast(raw), ch) + e.rawHandlers[types.EXIT_FD_EVENT] = func(raw []byte, ch chan<- *event.Pair) { + e.tracepointExited(types.NewFdEventFast(raw), ch) } - e.rawHandlers[ENTER_NULL_EVENT] = func(raw []byte, _ chan<- *event.Pair) { - e.tracepointEntered(NewNullEventFast(raw)) + e.rawHandlers[types.ENTER_NULL_EVENT] = func(raw []byte, _ chan<- *event.Pair) { + e.tracepointEntered(types.NewNullEventFast(raw)) } - e.rawHandlers[EXIT_NULL_EVENT] = func(raw []byte, ch chan<- *event.Pair) { - e.tracepointExited(NewNullEventFast(raw), ch) + e.rawHandlers[types.EXIT_NULL_EVENT] = func(raw []byte, ch chan<- *event.Pair) { + e.tracepointExited(types.NewNullEventFast(raw), ch) } - e.rawHandlers[EXIT_RET_EVENT] = func(raw []byte, ch chan<- *event.Pair) { - e.tracepointExited(NewRetEventFast(raw), ch) + e.rawHandlers[types.EXIT_RET_EVENT] = func(raw []byte, ch chan<- *event.Pair) { + e.tracepointExited(types.NewRetEventFast(raw), ch) } - e.rawHandlers[ENTER_NAME_EVENT] = func(raw []byte, _ chan<- *event.Pair) { - if ev, ok := e.filter.nameEvent(NewNameEventFast(raw)); ok { + e.rawHandlers[types.ENTER_NAME_EVENT] = func(raw []byte, _ chan<- *event.Pair) { + if ev, ok := e.filter.nameEvent(types.NewNameEventFast(raw)); ok { e.tracepointEntered(ev) } } - e.rawHandlers[ENTER_PATH_EVENT] = func(raw []byte, _ chan<- *event.Pair) { - if ev, ok := e.filter.pathEvent(NewPathEventFast(raw)); ok { + e.rawHandlers[types.ENTER_PATH_EVENT] = func(raw []byte, _ chan<- *event.Pair) { + if ev, ok := e.filter.pathEvent(types.NewPathEventFast(raw)); ok { e.tracepointEntered(ev) } } - e.rawHandlers[ENTER_FCNTL_EVENT] = func(raw []byte, _ chan<- *event.Pair) { - e.tracepointEntered(NewFcntlEventFast(raw)) + e.rawHandlers[types.ENTER_FCNTL_EVENT] = func(raw []byte, _ chan<- *event.Pair) { + e.tracepointEntered(types.NewFcntlEventFast(raw)) } - e.rawHandlers[ENTER_OPEN_BY_HANDLE_AT_EVENT] = func(raw []byte, _ chan<- *event.Pair) { - e.tracepointEntered(NewOpenByHandleAtEventFast(raw)) + e.rawHandlers[types.ENTER_OPEN_BY_HANDLE_AT_EVENT] = func(raw []byte, _ chan<- *event.Pair) { + e.tracepointEntered(types.NewOpenByHandleAtEventFast(raw)) } - e.rawHandlers[ENTER_DUP3_EVENT] = func(raw []byte, _ chan<- *event.Pair) { - e.tracepointEntered(NewDup3EventFast(raw)) + e.rawHandlers[types.ENTER_DUP3_EVENT] = func(raw []byte, _ chan<- *event.Pair) { + e.tracepointEntered(types.NewDup3EventFast(raw)) } } @@ -468,7 +467,7 @@ func (e *eventLoop) tracepointEntered(enterEv event.Event) { } switch enterEv.(type) { - case *OpenEvent: + case *types.OpenEvent: e.enterEvs[tid] = event.NewPair(enterEv) default: // Only, when we have a comm name @@ -511,64 +510,64 @@ func (e *eventLoop) tracepointExited(exitEv event.Event, ch chan<- *event.Pair) func (e *eventLoop) initExitHandlers() { e.exitHandlers = map[reflect.Type]tracepointExitHandler{ - reflect.TypeOf(&OpenEvent{}): func(ep *event.Pair) bool { - enterEv, ok := ep.EnterEv.(*OpenEvent) + reflect.TypeOf(&types.OpenEvent{}): func(ep *event.Pair) bool { + enterEv, ok := ep.EnterEv.(*types.OpenEvent) if !ok { e.recyclePair(ep, "Dropped malformed open enter event") return false } return e.handleOpenExit(ep, enterEv) }, - reflect.TypeOf(&NameEvent{}): func(ep *event.Pair) bool { - enterEv, ok := ep.EnterEv.(*NameEvent) + reflect.TypeOf(&types.NameEvent{}): func(ep *event.Pair) bool { + enterEv, ok := ep.EnterEv.(*types.NameEvent) if !ok { e.recyclePair(ep, "Dropped malformed name enter event") return false } return e.handleNameExit(ep, enterEv) }, - reflect.TypeOf(&PathEvent{}): func(ep *event.Pair) bool { - enterEv, ok := ep.EnterEv.(*PathEvent) + reflect.TypeOf(&types.PathEvent{}): func(ep *event.Pair) bool { + enterEv, ok := ep.EnterEv.(*types.PathEvent) if !ok { e.recyclePair(ep, "Dropped malformed path enter event") return false } return e.handlePathExit(ep, enterEv) }, - reflect.TypeOf(&FdEvent{}): func(ep *event.Pair) bool { - enterEv, ok := ep.EnterEv.(*FdEvent) + reflect.TypeOf(&types.FdEvent{}): func(ep *event.Pair) bool { + enterEv, ok := ep.EnterEv.(*types.FdEvent) if !ok { e.recyclePair(ep, "Dropped malformed fd enter event") return false } return e.handleFdExit(ep, enterEv) }, - reflect.TypeOf(&Dup3Event{}): func(ep *event.Pair) bool { - enterEv, ok := ep.EnterEv.(*Dup3Event) + reflect.TypeOf(&types.Dup3Event{}): func(ep *event.Pair) bool { + enterEv, ok := ep.EnterEv.(*types.Dup3Event) if !ok { e.recyclePair(ep, "Dropped malformed dup3 enter event") return false } return e.handleDup3Exit(ep, enterEv) }, - reflect.TypeOf(&OpenByHandleAtEvent{}): func(ep *event.Pair) bool { - enterEv, ok := ep.EnterEv.(*OpenByHandleAtEvent) + reflect.TypeOf(&types.OpenByHandleAtEvent{}): func(ep *event.Pair) bool { + enterEv, ok := ep.EnterEv.(*types.OpenByHandleAtEvent) if !ok { e.recyclePair(ep, "Dropped malformed open_by_handle_at enter event") return false } return e.handleOpenByHandleAtExit(ep, enterEv) }, - reflect.TypeOf(&NullEvent{}): func(ep *event.Pair) bool { - enterEv, ok := ep.EnterEv.(*NullEvent) + reflect.TypeOf(&types.NullEvent{}): func(ep *event.Pair) bool { + enterEv, ok := ep.EnterEv.(*types.NullEvent) if !ok { e.recyclePair(ep, "Dropped malformed null enter event") return false } return e.handleNullExit(ep, enterEv) }, - reflect.TypeOf(&FcntlEvent{}): func(ep *event.Pair) bool { - enterEv, ok := ep.EnterEv.(*FcntlEvent) + reflect.TypeOf(&types.FcntlEvent{}): func(ep *event.Pair) bool { + enterEv, ok := ep.EnterEv.(*types.FcntlEvent) if !ok { e.recyclePair(ep, "Dropped malformed fcntl enter event") return false @@ -594,8 +593,8 @@ func (e *eventLoop) handleTracepointExit(ep *event.Pair) bool { return handler(ep) } -func (e *eventLoop) handleOpenExit(ep *event.Pair, openEv *OpenEvent) bool { - retEvent, ok := ep.ExitEv.(*RetEvent) +func (e *eventLoop) handleOpenExit(ep *event.Pair, openEv *types.OpenEvent) bool { + retEvent, ok := ep.ExitEv.(*types.RetEvent) if !ok { e.recyclePair(ep, "Dropped malformed open exit event") return false @@ -615,13 +614,13 @@ func (e *eventLoop) handleOpenExit(ep *event.Pair, openEv *OpenEvent) bool { return true } -func (e *eventLoop) handleNameExit(ep *event.Pair, nameEv *NameEvent) bool { +func (e *eventLoop) handleNameExit(ep *event.Pair, nameEv *types.NameEvent) bool { ep.File = file.NewOldnameNewname(nameEv.Oldname[:], nameEv.Newname[:]) ep.Comm = e.comm(nameEv.GetTid()) return true } -func (e *eventLoop) handlePathExit(ep *event.Pair, pathEv *PathEvent) bool { +func (e *eventLoop) handlePathExit(ep *event.Pair, pathEv *types.PathEvent) bool { if pathEv.GetTraceId().Name() == sysEnterNameToHandleAtName { retEv, ok := ep.ExitEv.(*types.RetEvent) if !ok || retEv.Ret < 0 { @@ -633,8 +632,8 @@ func (e *eventLoop) handlePathExit(ep *event.Pair, pathEv *PathEvent) bool { return false } - if ep.Is(SYS_ENTER_CREAT) { - retEvent, ok := ep.ExitEv.(*RetEvent) + if ep.Is(types.SYS_ENTER_CREAT) { + retEvent, ok := ep.ExitEv.(*types.RetEvent) if !ok { e.recyclePair(ep, "Dropped malformed creat exit event") return false @@ -652,14 +651,14 @@ func (e *eventLoop) handlePathExit(ep *event.Pair, pathEv *PathEvent) bool { return true } -func (e *eventLoop) handleFdExit(ep *event.Pair, fdEv *FdEvent) bool { +func (e *eventLoop) handleFdExit(ep *event.Pair, fdEv *types.FdEvent) bool { fd := fdEv.Fd ep.File = e.resolveFdFile(fd, fdEv.Pid) - if ep.Is(SYS_ENTER_CLOSE) { + if ep.Is(types.SYS_ENTER_CLOSE) { e.fdState().delete(fd) e.deleteProcFdCache(fd, fdEv.Pid) } - if ep.Is(SYS_ENTER_CLOSE_RANGE) { + if ep.Is(types.SYS_ENTER_CLOSE_RANGE) { // close_range provides (first, last), but fd_event only carries the first // argument, so we approximate by closing all tracked fds >= first. retEv, ok := ep.ExitEv.(*types.RetEvent) @@ -674,13 +673,13 @@ func (e *eventLoop) handleFdExit(ep *event.Pair, fdEv *FdEvent) bool { return false } - if ep.Is(SYS_ENTER_DUP) || ep.Is(SYS_ENTER_DUP2) { + if ep.Is(types.SYS_ENTER_DUP) || ep.Is(types.SYS_ENTER_DUP2) { fdFile, ok := ep.File.(file.FdFile) if !ok { e.recyclePair(ep, "Dropped malformed dup source event") return false } - retEvent, ok := ep.ExitEv.(*RetEvent) + retEvent, ok := ep.ExitEv.(*types.RetEvent) if !ok { e.recyclePair(ep, "Dropped malformed dup exit event") return false @@ -688,8 +687,8 @@ func (e *eventLoop) handleFdExit(ep *event.Pair, fdEv *FdEvent) bool { // Duplicating fd e.registerDup(fdFile, int32(retEvent.Ret), 0) } - if ep.Is(SYS_ENTER_PIDFD_GETFD) { - retEv, ok := ep.ExitEv.(*RetEvent) + if ep.Is(types.SYS_ENTER_PIDFD_GETFD) { + retEv, ok := ep.ExitEv.(*types.RetEvent) if !ok { e.recyclePair(ep, "Dropped malformed pidfd_getfd exit event") return false @@ -700,13 +699,13 @@ func (e *eventLoop) handleFdExit(ep *event.Pair, fdEv *FdEvent) bool { ep.File = transferredFile } } - if retEv, ok := ep.ExitEv.(*RetEvent); ok { + if retEv, ok := ep.ExitEv.(*types.RetEvent); ok { ep.Bytes = bytesFromRet(retEv) } return true } -func (e *eventLoop) handleDup3Exit(ep *event.Pair, dup3Ev *Dup3Event) bool { +func (e *eventLoop) handleDup3Exit(ep *event.Pair, dup3Ev *types.Dup3Event) bool { fd := int32(dup3Ev.Fd) ep.File = e.resolveFdFile(fd, dup3Ev.Pid) ep.Comm = e.comm(dup3Ev.GetTid()) @@ -720,7 +719,7 @@ func (e *eventLoop) handleDup3Exit(ep *event.Pair, dup3Ev *Dup3Event) bool { e.recyclePair(ep, "Dropped malformed dup3 source event") return false } - retEvent, ok := ep.ExitEv.(*RetEvent) + retEvent, ok := ep.ExitEv.(*types.RetEvent) if !ok { e.recyclePair(ep, "Dropped malformed dup3 exit event") return false @@ -729,9 +728,9 @@ func (e *eventLoop) handleDup3Exit(ep *event.Pair, dup3Ev *Dup3Event) bool { return true } -func (e *eventLoop) handleOpenByHandleAtExit(ep *event.Pair, openByHandleEv *OpenByHandleAtEvent) bool { +func (e *eventLoop) handleOpenByHandleAtExit(ep *event.Pair, openByHandleEv *types.OpenByHandleAtEvent) bool { tid := openByHandleEv.GetTid() - retEvent, ok := ep.ExitEv.(*RetEvent) + retEvent, ok := ep.ExitEv.(*types.RetEvent) if !ok { e.recyclePair(ep, "Dropped malformed open_by_handle_at exit event") return false @@ -760,8 +759,8 @@ func (e *eventLoop) handleOpenByHandleAtExit(ep *event.Pair, openByHandleEv *Ope return true } -func (e *eventLoop) handleNullExit(ep *event.Pair, nullEv *NullEvent) bool { - if ep.Is(SYS_ENTER_IO_URING_SETUP) { +func (e *eventLoop) handleNullExit(ep *event.Pair, nullEv *types.NullEvent) bool { + if ep.Is(types.SYS_ENTER_IO_URING_SETUP) { retEvent, ok := ep.ExitEv.(*types.RetEvent) if !ok { e.recyclePair(ep, "Dropped malformed io_uring_setup exit event") @@ -773,7 +772,7 @@ func (e *eventLoop) handleNullExit(ep *event.Pair, nullEv *NullEvent) bool { ep.File = fdFile } } - if ep.Is(SYS_ENTER_GETCWD) { + if ep.Is(types.SYS_ENTER_GETCWD) { retEvent, ok := ep.ExitEv.(*types.RetEvent) if !ok { e.recyclePair(ep, "Dropped malformed getcwd exit event") @@ -793,7 +792,7 @@ func (e *eventLoop) handleNullExit(ep *event.Pair, nullEv *NullEvent) bool { return true } -func (e *eventLoop) handleFcntlExit(ep *event.Pair, fcntlEv *FcntlEvent) bool { +func (e *eventLoop) handleFcntlExit(ep *event.Pair, fcntlEv *types.FcntlEvent) bool { ep.Comm = e.comm(fcntlEv.GetTid()) fd := int32(fcntlEv.Fd) ep.File = e.resolveFdFile(fd, fcntlEv.Pid) -- cgit v1.2.3