From 67caea46c2b50d9a7a43ca6500d07ef61de902a9 Mon Sep 17 00:00:00 2001 From: Dale Hamel Date: Fri, 24 Jul 2026 15:38:30 -0400 Subject: [PATCH] Add duration-filtered off-CPU profiling with task-state labels Add the off_cpu_time dynamic probe on top of the omnibus ProbeContext foundation. Correlate every switch-out through a migration-safe global LRU map, apply min-duration and sampling after elapsed time is known, and report exact nanosecond values with per-path metrics. Capture the validated sched_switch prev_state as thread.state so blocking and CPU saturation can be filtered independently. Use a minimal generic probe_user_data trace field for the optional per-origin TraceLabeler; this branch does not depend on the Hack Days async I/O or process-observer ABIs. Clarify that upstream built-in off_cpu is already duration-valued and document the actual differences. Assisted-By: devx/2d48a84f-4aab-48eb-9009-5dd68fa593f3 --- internal/controller/controller.go | 3 + libpf/trace.go | 1 + metrics/ids.go | 23 +- metrics/metrics.json | 49 +++ probes/offcpu/README.md | 106 ++++++ probes/offcpu/metrics.go | 119 ++++++ probes/offcpu/metrics_test.go | 86 +++++ probes/offcpu/offcpu.go | 439 +++++++++++++++++++++++ probes/offcpu/offcpu_integration_test.go | 160 +++++++++ probes/offcpu/offcpu_test.go | 248 +++++++++++++ support/ebpf/off_cpu_time.ebpf.c | 190 ++++++++++ support/ebpf/tracemgmt.h | 37 +- support/ebpf/tracer.ebpf.amd64 | Bin 955528 -> 987416 bytes support/ebpf/tracer.ebpf.arm64 | Bin 949416 -> 980440 bytes support/ebpf/types.h | 4 + support/types.go | 3 +- tracer/probes.go | 11 + tracer/tracer.go | 7 + 18 files changed, 1476 insertions(+), 10 deletions(-) create mode 100644 probes/offcpu/README.md create mode 100644 probes/offcpu/metrics.go create mode 100644 probes/offcpu/metrics_test.go create mode 100644 probes/offcpu/offcpu.go create mode 100644 probes/offcpu/offcpu_integration_test.go create mode 100644 probes/offcpu/offcpu_test.go create mode 100644 support/ebpf/off_cpu_time.ebpf.c diff --git a/internal/controller/controller.go b/internal/controller/controller.go index 62e1d0daaf..a46bc36cde 100644 --- a/internal/controller/controller.go +++ b/internal/controller/controller.go @@ -14,6 +14,7 @@ import ( "go.opentelemetry.io/ebpf-profiler/internal/linux" "go.opentelemetry.io/ebpf-profiler/internal/log" "go.opentelemetry.io/ebpf-profiler/probes/generic" + "go.opentelemetry.io/ebpf-profiler/probes/offcpu" "go.opentelemetry.io/ebpf-profiler/libpf" "go.opentelemetry.io/ebpf-profiler/metrics" @@ -210,6 +211,8 @@ func createCustomProbe(name string, cfg any) (tracer.Probe, error) { return nil, fmt.Errorf("decoding generic probe config: %w", err) } return generic.New(gcfg) + case offcpu.SampleType: + return offcpu.New(cfg) default: return nil, fmt.Errorf("unknown custom probe: %q", name) } diff --git a/libpf/trace.go b/libpf/trace.go index 702bd02c34..93814e9ecb 100644 --- a/libpf/trace.go +++ b/libpf/trace.go @@ -140,6 +140,7 @@ type EbpfTrace struct { KernelFrames Frames FrameDataBuf [3072]uint64 Value int64 + ProbeUserData uint64 KTime int64 CpuID uint32 TID PID diff --git a/metrics/ids.go b/metrics/ids.go index 7721efcaea..2a20149e7b 100644 --- a/metrics/ids.go +++ b/metrics/ids.go @@ -686,6 +686,27 @@ const ( // Number of times we didn't find an entry for this process in the LuaJIT process info array IDUnwindLuaJITErrNoProcInfo = 299 + // Number of thread switch-out events observed by the off-CPU time probe + IDOffCPUTimeSwitchOuts = 300 + + // Number of thread switch-in events observed by the off-CPU time probe + IDOffCPUTimeSwitchIns = 301 + + // Number of off-CPU time switch-ins without a recorded switch-out + IDOffCPUTimeUnmatchedSwitchIns = 302 + + // Number of off-CPU time samples filtered by duration or sampling + IDOffCPUTimeFiltered = 303 + + // Number of off-CPU time samples submitted for unwinding + IDOffCPUTimeEmitted = 304 + + // Number of failures recording off-CPU time switch-out state + IDOffCPUTimeStateUpdateFailures = 305 + + // Number of failures reading off-CPU time eBPF metrics + IDOffCPUTimeMetricReadFailures = 306 + // max number of ID values, keep this as *last entry* - IDMax = 300 + IDMax = 307 ) diff --git a/metrics/metrics.json b/metrics/metrics.json index 9455fc8fb3..677af1fd80 100644 --- a/metrics/metrics.json +++ b/metrics/metrics.json @@ -2188,5 +2188,54 @@ "name": "UnwindLuaJITErrNoProcInfo", "field": "bpf.luajit.errors.no_proc_info", "id": 299 + }, + { + "description": "Number of thread switch-out events observed by the off-CPU time probe", + "type": "counter", + "name": "OffCPUTimeSwitchOuts", + "field": "agent.off_cpu_time.switch_outs", + "id": 300 + }, + { + "description": "Number of thread switch-in events observed by the off-CPU time probe", + "type": "counter", + "name": "OffCPUTimeSwitchIns", + "field": "agent.off_cpu_time.switch_ins", + "id": 301 + }, + { + "description": "Number of off-CPU time switch-ins without a recorded switch-out", + "type": "counter", + "name": "OffCPUTimeUnmatchedSwitchIns", + "field": "agent.off_cpu_time.switch_ins.unmatched", + "id": 302 + }, + { + "description": "Number of off-CPU time samples filtered by duration or sampling", + "type": "counter", + "name": "OffCPUTimeFiltered", + "field": "agent.off_cpu_time.filtered", + "id": 303 + }, + { + "description": "Number of off-CPU time samples submitted for unwinding", + "type": "counter", + "name": "OffCPUTimeEmitted", + "field": "agent.off_cpu_time.emitted", + "id": 304 + }, + { + "description": "Number of failures recording off-CPU time switch-out state", + "type": "counter", + "name": "OffCPUTimeStateUpdateFailures", + "field": "agent.off_cpu_time.state.update_failures", + "id": 305 + }, + { + "description": "Number of failures reading off-CPU time eBPF metrics", + "type": "counter", + "name": "OffCPUTimeMetricReadFailures", + "field": "agent.off_cpu_time.metrics.read_failures", + "id": 306 } ] diff --git a/probes/offcpu/README.md b/probes/offcpu/README.md new file mode 100644 index 0000000000..6a76072407 --- /dev/null +++ b/probes/offcpu/README.md @@ -0,0 +1,106 @@ +# Off-CPU time probe + +`offcpu` measures **how long** each stack was off CPU. Like the built-in +`off_cpu` profile, each emitted event is weighted by elapsed nanoseconds rather +than count one. It follows the classic `offcputime` model (Gregg, *BPF +Performance Tools*, Ch06): the departure time of every thread is recorded as it is +switched out, and when the thread is switched back in the elapsed nanoseconds +are attributed to the stack that blocked. Samples carry the measured duration +(`off_cpu_time` / nanoseconds), so aggregation by stack yields total wait +time — the flame graph answers "where does wall-clock time go while blocked". + +## Hook points + +- `tracepoint/sched/sched_switch` runs in the outgoing thread's context and + records only a timestamp keyed by `pid_tgid`. It runs on every context + switch, so it does nothing else. +- `kprobe/finish_task_switch` runs in the incoming thread's context right + after the scheduler restored its registers. At this point the kernel stack + is still the blocking path (`…→schedule→finish_task_switch`) and the user + state is unchanged since the thread went off CPU, so the unwind through the + shared kprobe unwinder chain observes exactly the stack that was waiting. + Optimized symbol variants (`finish_task_switch.isra.0`) are resolved by + prefix from kallsyms, mirroring the built-in off-CPU hook. The program that + calls `collect_trace` must be a kprobe: tail calls into the kprobe unwinder + program array require matching program types, which is why the measurement + side cannot be a tracepoint. + +## Semantics + +- Duration covers **all** off-CPU time: blocking on I/O, locks, timers, and + also runqueue wait after involuntary preemption. Every sample carries a + **`thread.state` label** with the thread's state at switch-out so the two + populations separate cleanly: `interruptible`/`uninterruptible`/`parked`/ + `idle`/… mean the thread blocked voluntarily, while `running` (entered the + scheduler while still runnable, e.g. `cond_resched`/yield) and `preempted` + (descheduled involuntarily) mean the thread was denied CPU by saturation. + Filter `thread.state` out of `{running, preempted}` for pure blocking + analysis, or onto them to quantify CPU pressure. +- The `prev_state` layout is validated by parsing the sched_switch + **tracepoint format file** (`/sys/kernel/tracing/events/sched/sched_switch/format`, + debugfs fallback) before direct context access is enabled. Regular tracepoint + contexts require direct field access (`bpf_probe_read_kernel` may fail on + them), so the supported 64-bit x86_64/aarch64 layout must report offset 32, + size 8. A mismatch logs and continues without the label; durations are + unaffected. Values use the post-4.14 `task_state_index` encoding; + unrecognized encodings collapse to `other` to bound label cardinality. +- `min_duration` and `sample_rate` are applied at **switch-in**, after the + duration is known. Each retained duration is exact. At `sample_rate=1`, all + qualifying waits are retained; lower rates can drop qualifying waits and are + not inverse-probability scaled. Unlike built-in entry sampling, duration + filtering never rejects a wait before knowing its length. `min_duration` is + the primary volume control. The safe default is 1ms; explicitly setting 0s + requests exhaustive capture and may overwhelm busy hosts. +- The switch-out map is a **global LRU hash** (`max_entries`, default 64Ki): + the pending set is every sleeping thread in the system, and a thread that + exits while off CPU leaks its entry (its final switch-out happens after + every exit tracepoint, so there is no deterministic cleanup hook). LRU + recycles leaked and coldest entries under pressure; the threads evicted + first are those sleeping longest. Unlike the built-in `sched_times` map it + is not per-CPU, so a thread that blocks on one CPU and wakes on another is + still measured. +- Idle (pid 0) is never tracked. Kernel threads are measured and produce + kernel-only stacks. + +## Comparison with the built-in off-CPU profiling + +| | built-in (`off-cpu-threshold`) | this probe | +|---|---|---| +| sample value | exact selected interval duration (ns) | exact selected interval duration (ns) | +| decision point | random sample at switch-out | duration filter, then sample at switch-in | +| long waits | missed with probability 1-p | all retained at sample_rate=1 after min_duration | +| CPU migration | lost (per-CPU LRU map) | measured (global LRU map) | +| duration filter | none | `min_duration` | +| drop accounting | none | per-path metrics | +| thread state | not captured | `thread.state` sample label | +| activation | static flag at startup | dynamic `custom_probes` entry | + +## Configuration + +Enabled as a custom probe named `off_cpu_time`: + +```yaml +custom_probes: + off_cpu_time: + min_duration: 1ms # emit only waits at least this long (default 1ms) + sample_rate: 0.25 # sample qualifying wakeups (default 1.0) + max_entries: 65536 # pending switch-out states (default 64Ki) +``` + +The sample type is fixed (`off_cpu_time`, nanoseconds) rather than +descriptor-supplied so downstream duration classification cannot drift. + +## Overhead + +The switch-out program adds one hash update to every context switch and the +switch-in program one lookup+delete; this is the unavoidable cost of exact +durations (identical to `offcputime`). Unwinds are bounded by +`min_duration`/`sample_rate`. On busy hosts prefer raising `min_duration` +over lowering `sample_rate`: it suppresses the huge population of micro-waits +while keeping every meaningful stall. + +## Metrics + +`agent.off_cpu_time.switch_outs`, `.switch_ins`, `.switch_ins.unmatched`, +`.filtered`, `.emitted`, `.state.update_failures`, and +`.metrics.read_failures` account for every event and drop path. diff --git a/probes/offcpu/metrics.go b/probes/offcpu/metrics.go new file mode 100644 index 0000000000..01a6935786 --- /dev/null +++ b/probes/offcpu/metrics.go @@ -0,0 +1,119 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +package offcpu // import "go.opentelemetry.io/ebpf-profiler/probes/offcpu" + +import ( + "fmt" + "sync" + + "github.com/cilium/ebpf" + "go.opentelemetry.io/ebpf-profiler/internal/log" + "go.opentelemetry.io/ebpf-profiler/metrics" + "go.opentelemetry.io/ebpf-profiler/tracer" +) + +// offCPUTimeBPFMetrics mirrors OffCpuTimeMetrics in off_cpu_time.ebpf.c. +type offCPUTimeBPFMetrics struct { + SwitchOuts uint64 + SwitchIns uint64 + UnmatchedSwitchIns uint64 + Filtered uint64 + Emitted uint64 + StateUpdateFailures uint64 +} + +type offCPUTimeMetricsCollector struct { + metricsMap *ebpf.Map + perCPUValues []offCPUTimeBPFMetrics + + mu sync.Mutex + previous offCPUTimeBPFMetrics + readFailures uint64 + previousReads uint64 +} + +func newOffCPUTimeMetricsCollector(metricsMap *ebpf.Map) (*offCPUTimeMetricsCollector, error) { + cpuCount, err := ebpf.PossibleCPU() + if err != nil { + return nil, fmt.Errorf("determine possible CPUs: %w", err) + } + return &offCPUTimeMetricsCollector{ + metricsMap: metricsMap, + perCPUValues: make([]offCPUTimeBPFMetrics, cpuCount), + }, nil +} + +func (collector *offCPUTimeMetricsCollector) snapshot() (offCPUTimeBPFMetrics, error) { + key := uint32(0) + if err := collector.metricsMap.Lookup(&key, &collector.perCPUValues); err != nil { + return offCPUTimeBPFMetrics{}, err + } + var result offCPUTimeBPFMetrics + for _, value := range collector.perCPUValues { + result.SwitchOuts += value.SwitchOuts + result.SwitchIns += value.SwitchIns + result.UnmatchedSwitchIns += value.UnmatchedSwitchIns + result.Filtered += value.Filtered + result.Emitted += value.Emitted + result.StateUpdateFailures += value.StateUpdateFailures + } + return result, nil +} + +func counterDelta(current, previous uint64) metrics.MetricValue { + return metrics.MetricValue(current - previous) +} + +func offCPUTimeMetricValues(current, previous offCPUTimeBPFMetrics, + readFailures uint64, +) []metrics.Metric { + return []metrics.Metric{ + {ID: metrics.IDOffCPUTimeSwitchOuts, + Value: counterDelta(current.SwitchOuts, previous.SwitchOuts)}, + {ID: metrics.IDOffCPUTimeSwitchIns, + Value: counterDelta(current.SwitchIns, previous.SwitchIns)}, + {ID: metrics.IDOffCPUTimeUnmatchedSwitchIns, + Value: counterDelta(current.UnmatchedSwitchIns, previous.UnmatchedSwitchIns)}, + {ID: metrics.IDOffCPUTimeFiltered, + Value: counterDelta(current.Filtered, previous.Filtered)}, + {ID: metrics.IDOffCPUTimeEmitted, + Value: counterDelta(current.Emitted, previous.Emitted)}, + {ID: metrics.IDOffCPUTimeStateUpdateFailures, + Value: counterDelta(current.StateUpdateFailures, previous.StateUpdateFailures)}, + {ID: metrics.IDOffCPUTimeMetricReadFailures, + Value: metrics.MetricValue(readFailures)}, + } +} + +func (collector *offCPUTimeMetricsCollector) Collect() []metrics.Metric { + collector.mu.Lock() + defer collector.mu.Unlock() + + current, err := collector.snapshot() + if err != nil { + collector.readFailures++ + log.Debugf("Failed to read off-cpu time metrics: %v", err) + reads := collector.readFailures + delta := reads - collector.previousReads + collector.previousReads = reads + return []metrics.Metric{{ + ID: metrics.IDOffCPUTimeMetricReadFailures, Value: metrics.MetricValue(delta), + }} + } + previous := collector.previous + collector.previous = current + reads := collector.readFailures + readDelta := reads - collector.previousReads + collector.previousReads = reads + return offCPUTimeMetricValues(current, previous, readDelta) +} + +type finalMetricsCloser struct { + subscription tracer.MetricsSubscription + collect func() []metrics.Metric +} + +func (closer *finalMetricsCloser) Close() error { + return closer.subscription.CloseWithMetrics(closer.collect()) +} diff --git a/probes/offcpu/metrics_test.go b/probes/offcpu/metrics_test.go new file mode 100644 index 0000000000..6defd00c64 --- /dev/null +++ b/probes/offcpu/metrics_test.go @@ -0,0 +1,86 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +package offcpu + +import ( + "testing" + "unsafe" + + "github.com/stretchr/testify/require" + "go.opentelemetry.io/ebpf-profiler/metrics" +) + +func TestOffCPUTimeMetricValues(t *testing.T) { + previous := offCPUTimeBPFMetrics{ + SwitchOuts: 100, + SwitchIns: 90, + UnmatchedSwitchIns: 5, + Filtered: 60, + Emitted: 25, + StateUpdateFailures: 1, + } + current := offCPUTimeBPFMetrics{ + SwitchOuts: 150, + SwitchIns: 140, + UnmatchedSwitchIns: 6, + Filtered: 95, + Emitted: 39, + StateUpdateFailures: 2, + } + + got := make(map[metrics.MetricID]metrics.MetricValue) + for _, metric := range offCPUTimeMetricValues(current, previous, 3) { + got[metric.ID] = metric.Value + } + require.Equal(t, map[metrics.MetricID]metrics.MetricValue{ + metrics.IDOffCPUTimeSwitchOuts: 50, + metrics.IDOffCPUTimeSwitchIns: 50, + metrics.IDOffCPUTimeUnmatchedSwitchIns: 1, + metrics.IDOffCPUTimeFiltered: 35, + metrics.IDOffCPUTimeEmitted: 14, + metrics.IDOffCPUTimeStateUpdateFailures: 1, + metrics.IDOffCPUTimeMetricReadFailures: 3, + }, got) +} + +func TestOffCPUTimeBPFMetricsLayout(t *testing.T) { + var value offCPUTimeBPFMetrics + require.Equal(t, uintptr(0), unsafe.Offsetof(value.SwitchOuts)) + require.Equal(t, uintptr(8), unsafe.Offsetof(value.SwitchIns)) + require.Equal(t, uintptr(16), unsafe.Offsetof(value.UnmatchedSwitchIns)) + require.Equal(t, uintptr(24), unsafe.Offsetof(value.Filtered)) + require.Equal(t, uintptr(32), unsafe.Offsetof(value.Emitted)) + require.Equal(t, uintptr(40), unsafe.Offsetof(value.StateUpdateFailures)) + require.Equal(t, uintptr(48), unsafe.Sizeof(value)) +} + +type testMetricsSubscription struct { + closed bool + metrics []metrics.Metric +} + +func (subscription *testMetricsSubscription) Close() error { + subscription.closed = true + return nil +} + +func (subscription *testMetricsSubscription) CloseWithMetrics(final []metrics.Metric) error { + subscription.closed = true + subscription.metrics = final + return nil +} + +func TestFinalMetricsCloserPreservesDeltas(t *testing.T) { + subscription := &testMetricsSubscription{} + closer := &finalMetricsCloser{ + subscription: subscription, + collect: func() []metrics.Metric { + return []metrics.Metric{{ID: metrics.IDOffCPUTimeEmitted, Value: 3}} + }, + } + require.NoError(t, closer.Close()) + require.True(t, subscription.closed) + require.Equal(t, []metrics.Metric{{ID: metrics.IDOffCPUTimeEmitted, Value: 3}}, + subscription.metrics) +} diff --git a/probes/offcpu/offcpu.go b/probes/offcpu/offcpu.go new file mode 100644 index 0000000000..17380e7648 --- /dev/null +++ b/probes/offcpu/offcpu.go @@ -0,0 +1,439 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +// Package offcpu profiles how long stacks spend off CPU. +// +// It measures the wall-clock nanoseconds between a thread being switched out +// and being switched back in, and attributes that duration to the blocked +// stack. This is the classic offcputime semantics: the value answers "how +// long was this stack waiting" rather than "how often did this stack leave +// the CPU". +package offcpu // import "go.opentelemetry.io/ebpf-profiler/probes/offcpu" + +import ( + "bufio" + "errors" + "fmt" + "os" + "path/filepath" + "strconv" + "strings" + "time" + + cebpf "github.com/cilium/ebpf" + "github.com/cilium/ebpf/link" + "go.opentelemetry.io/ebpf-profiler/internal/log" + "go.opentelemetry.io/ebpf-profiler/libpf" + "go.opentelemetry.io/ebpf-profiler/probes/internal/probeutil" + "go.opentelemetry.io/ebpf-profiler/reporter/samples" + "go.opentelemetry.io/ebpf-profiler/rlimit" + "go.opentelemetry.io/ebpf-profiler/tracer" +) + +// SampleType identifies off-CPU time samples. It is fixed rather than +// descriptor-supplied so downstream duration classification cannot drift. +const SampleType = "off_cpu_time" + +const ( + startsMapName = "off_cpu_time_starts" + metricsMapName = "off_cpu_time_metrics" + switchOutProgramName = "off_cpu_time_switch_out" + switchInProgramName = "off_cpu_time_switch_in" + originVariableName = "off_cpu_time_origin" + minNSVariableName = "off_cpu_time_min_ns" + sampleVariableName = "off_cpu_time_sample_threshold" + stateEnabledVariable = "off_cpu_time_state_enabled" + + // The profiler supports only 64-bit x86_64/aarch64 kernels. Both expose + // prev_state at byte 32 as an 8-byte signed long in sched_switch; this + // layout is validated against tracefs before direct context access is enabled. + expectedStateOffset = uint32(32) + expectedStateSize = uint32(8) + + // stateUnavailable is the sentinel the eBPF side reports when no thread + // state was captured for a sample. Must match OFF_CPU_TIME_STATE_UNAVAILABLE. + stateUnavailable = ^uint64(0) + + // threadStateLabelKey is the per-sample label carrying the switch-out + // thread state. It separates voluntary blocking (interruptible, + // uninterruptible, ...) from runnable threads descheduled by CPU + // pressure (running, preempted) so profiles can be filtered on either. + threadStateLabelKey = "thread.state" + + // switchOutTracepointGroup/Name identify the tracepoint that observes + // threads leaving the CPU. It fires in the outgoing thread's context. + switchOutTracepointGroup = "sched" + switchOutTracepointName = "sched_switch" + + // switchInSymbolPrefix is the kernel function that runs in the incoming + // thread's context right after a context switch. Compilers emit optimized + // variants (for example finish_task_switch.isra.0), so attachment resolves + // the symbol by prefix from kallsyms, mirroring the built-in off-CPU hook. + switchInSymbolPrefix = "finish_task_switch" + + // A non-zero default prevents an empty configuration from unwinding every + // scheduler wakeup on the host. Users may explicitly set 0s for exhaustive + // capture after accepting the overhead. + defaultMinDuration = time.Millisecond + + // The pending set is one entry per sleeping thread system-wide, so the + // default is larger than the per-function latency probes. + defaultMaxEntries = uint32(64 * 1024) + maximumMaxEntries = uint32(1024 * 1024) +) + +// kallsymsPath is a variable to allow tests to substitute a fixture. +var kallsymsPath = "/proc/kallsyms" + +// tracefsRoots lists the mount points searched for tracepoint format files. +// A variable to allow tests to substitute fixtures. +var tracefsRoots = []string{"/sys/kernel/tracing", "/sys/kernel/debug/tracing"} + +type offCPUTimeProbe struct { + minDuration time.Duration + sampleThreshold uint32 + maxEntries uint32 +} + +// New creates an off-CPU time probe from collector configuration. Supported +// fields are min_duration (a Go duration string), sample_rate in (0, 1], and +// max_entries. +// +// min_duration is the primary overhead and volume control: durations are +// always measured exactly, and only wakeups whose measured off-CPU time +// reaches the threshold are eligible for unwinding. sample_rate then applies +// to qualifying wakeups, not to switch-outs. +func New(rawConfig any) (tracer.Probe, error) { + rawConfig = configWithDefaultMinDuration(rawConfig) + cfg, err := probeutil.ParseLatencyConfig( + rawConfig, "off-cpu time", defaultMaxEntries, maximumMaxEntries) + if err != nil { + return nil, err + } + + return &offCPUTimeProbe{ + minDuration: cfg.MinDuration, + sampleThreshold: cfg.SampleThreshold, + maxEntries: cfg.MaxEntries, + }, nil +} + +func configWithDefaultMinDuration(rawConfig any) any { + if rawConfig == nil { + return map[string]any{"min_duration": defaultMinDuration} + } + config, ok := rawConfig.(map[string]any) + if !ok { + return rawConfig + } + if _, configured := config["min_duration"]; configured { + return rawConfig + } + withDefault := make(map[string]any, len(config)+1) + for key, value := range config { + withDefault[key] = value + } + withDefault["min_duration"] = defaultMinDuration + return withDefault +} + +func (p *offCPUTimeProbe) ReportMetadata() *samples.TypeMetadata { + return &samples.TypeMetadata{ + SampleType: SampleType, + SampleUnit: "nanoseconds", + ReportValues: true, + } +} + +func failLoad(resources *probeutil.Resources, err error) (link.Link, error) { + return nil, errors.Join(err, resources.Close()) +} + +func (p *offCPUTimeProbe) Load(origin uint16, ctx *tracer.ProbeContext) (link.Link, error) { + restoreRlimit, err := rlimit.MaximizeMemlock() + if err != nil { + return nil, fmt.Errorf("failed to adjust memlock rlimit: %w", err) + } + defer restoreRlimit() + + collection, err := ctx.CollectionSpecWith( + []string{startsMapName, metricsMapName}, + []string{switchOutProgramName, switchInProgramName}, + []string{ + originVariableName, minNSVariableName, sampleVariableName, + stateEnabledVariable, + }, + ) + if err != nil { + return nil, err + } + collection.Maps[startsMapName].MaxEntries = p.maxEntries + + // The tracepoint encoding of prev_state is not a stable ABI, so the field + // location is resolved from the tracefs format file rather than assumed. + // Failure only disables the thread.state label; durations are unaffected. + stateEnabled := uint32(0) + stateOffset, stateSize, stateErr := resolveSchedSwitchStateField() + if stateErr != nil { + log.Infof("Off-CPU time probe continues without thread state: %v", stateErr) + } else if stateOffset != expectedStateOffset || stateSize != expectedStateSize { + log.Infof( + "Off-CPU time probe continues without thread state: unexpected sched_switch "+ + "prev_state layout offset=%d size=%d (expected offset=%d size=%d)", + stateOffset, stateSize, expectedStateOffset, expectedStateSize) + } else { + stateEnabled = 1 + log.Infof("Off-CPU time thread-state capture enabled: prev_state offset=%d size=%d", + stateOffset, stateSize) + } + + variables := map[string]any{ + originVariableName: origin, + minNSVariableName: uint64(p.minDuration), + sampleVariableName: p.sampleThreshold, + stateEnabledVariable: stateEnabled, + } + for name, value := range variables { + if err := collection.Variables[name].Set(value); err != nil { + return nil, fmt.Errorf("failed to set eBPF variable %q: %w", name, err) + } + } + + resources := &probeutil.Resources{} + ownedMaps, err := probeutil.LoadMaps( + collection, []string{startsMapName, metricsMapName}, resources) + if err != nil { + return failLoad(resources, err) + } + if err := ctx.RewriteMaps(collection, ownedMaps); err != nil { + return failLoad(resources, fmt.Errorf("failed to rewrite off-cpu time maps: %w", err)) + } + + programs := make(map[string]*cebpf.Program, 2) + if err := ctx.LoadProbeUnwinders( + collection, + programs, + []tracer.ProgLoaderHelper{ + {Name: switchOutProgramName, NoTailCallTarget: true, Enable: true}, + {Name: switchInProgramName, NoTailCallTarget: true, Enable: true}, + }, + 0, + ); err != nil { + for _, program := range programs { + resources.Add(program) + } + return failLoad(resources, fmt.Errorf("failed to load off-cpu time programs: %w", err)) + } + for _, program := range programs { + resources.Add(program) + } + + collector, err := newOffCPUTimeMetricsCollector(ownedMaps[metricsMapName]) + if err != nil { + return failLoad(resources, err) + } + subscription, err := ctx.RegisterMetricsCollector(collector.Collect) + if err != nil { + return failLoad(resources, fmt.Errorf("register off-cpu time metrics: %w", err)) + } + resources.Add(&finalMetricsCloser{subscription: subscription, collect: collector.Collect}) + + // Attach the consumer (switch-in) before the producer so activation can't + // leave unconsumable start records, mirroring the other latency probes. + if err := attachSwitchIn(programs[switchInProgramName], resources); err != nil { + return failLoad(resources, err) + } + + switchOutLink, err := link.Tracepoint( + switchOutTracepointGroup, switchOutTracepointName, + programs[switchOutProgramName], nil) + if err != nil { + return failLoad(resources, fmt.Errorf("failed to attach %s/%s tracepoint: %w", + switchOutTracepointGroup, switchOutTracepointName, err)) + } + return resources.WrapLink(switchOutLink), nil +} + +// attachSwitchIn attaches the switch-in program to every finish_task_switch +// variant present in kallsyms. At least one attachment must succeed. +func attachSwitchIn(program *cebpf.Program, resources *probeutil.Resources) error { + symbols, err := resolveSwitchInSymbols() + if err != nil || len(symbols) == 0 { + // kallsyms may be unreadable in restricted environments; fall back to + // the plain symbol and let the kernel resolve it. + if err != nil { + log.Debugf("Failed to resolve %s from kallsyms: %v", switchInSymbolPrefix, err) + } + symbols = []string{switchInSymbolPrefix} + } + + var errs []error + attached := 0 + for _, symbol := range symbols { + switchInLink, linkErr := link.Kprobe(symbol, program, nil) + if linkErr != nil { + errs = append(errs, fmt.Errorf("attach kprobe %q: %w", symbol, linkErr)) + continue + } + resources.Add(switchInLink) + attached++ + } + if attached == 0 { + return fmt.Errorf("failed to attach to any of %d %s symbols: %w", + len(symbols), switchInSymbolPrefix, errors.Join(errs...)) + } + if len(errs) != 0 { + log.Warnf("Off-CPU time attached to %d of %d %s symbols; partial failures: %v", + attached, len(symbols), switchInSymbolPrefix, errors.Join(errs...)) + } + return nil +} + +// LabelTrace implements tracer.TraceLabeler. It converts the switch-out +// thread state carried in the trace's user-data slot into the low-cardinality +// thread.state sample label, merging with any runtime labels already present. +func (p *offCPUTimeProbe) LabelTrace(trace *libpf.EbpfTrace) { + if trace.ProbeUserData == stateUnavailable { + return + } + if trace.CustomLabels == nil { + trace.CustomLabels = make(map[libpf.String]libpf.String, 1) + } + trace.CustomLabels[libpf.Intern(threadStateLabelKey)] = + libpf.Intern(threadStateName(trace.ProbeUserData)) +} + +// threadStateName decodes the sched_switch tracepoint prev_state encoding +// used since kernel 4.14: 0 for a still-runnable thread that entered the +// scheduler voluntarily, single TASK_REPORT bits decoded from +// task_state_index, and TASK_REPORT_MAX (0x100) for involuntary preemption. +// Unrecognized encodings collapse to "other" to bound label cardinality. +func threadStateName(state uint64) string { + switch state { + case 0x0000: + return "running" + case 0x0001: + return "interruptible" + case 0x0002: + return "uninterruptible" + case 0x0004: + return "stopped" + case 0x0008: + return "traced" + case 0x0010: + return "exit_dead" + case 0x0020: + return "zombie" + case 0x0040: + return "parked" + case 0x0080: + return "idle" + case 0x0100: + return "preempted" + default: + return "other" + } +} + +// resolveSchedSwitchStateField locates the prev_state field in the raw +// sched_switch tracepoint buffer by parsing the tracefs format file, e.g.: +// +// field:long prev_state; offset:32; size:8; signed:1; +func resolveSchedSwitchStateField() (offset, size uint32, err error) { + var firstErr error + for _, root := range tracefsRoots { + path := filepath.Join(root, "events", switchOutTracepointGroup, + switchOutTracepointName, "format") + offset, size, err := parseTracepointField(path, "prev_state") + if err == nil { + return offset, size, nil + } + if firstErr == nil { + firstErr = err + } + } + return 0, 0, firstErr +} + +func parseTracepointField(path, field string) (offset, size uint32, err error) { + file, err := os.Open(path) + if err != nil { + return 0, 0, err + } + defer file.Close() + + scanner := bufio.NewScanner(file) + for scanner.Scan() { + line := scanner.Text() + if !strings.Contains(line, "field:") || + !strings.Contains(line, " "+field+";") { + continue + } + parsedOffset, offsetErr := tracepointFieldAttribute(line, "offset") + parsedSize, sizeErr := tracepointFieldAttribute(line, "size") + if offsetErr != nil || sizeErr != nil { + return 0, 0, fmt.Errorf("malformed format line %q in %s", line, path) + } + return parsedOffset, parsedSize, nil + } + if err := scanner.Err(); err != nil { + return 0, 0, err + } + return 0, 0, fmt.Errorf("field %q not found in %s", field, path) +} + +func tracepointFieldAttribute(line, attribute string) (uint32, error) { + marker := attribute + ":" + start := strings.Index(line, marker) + if start < 0 { + return 0, fmt.Errorf("attribute %q not found", attribute) + } + rest := line[start+len(marker):] + end := strings.IndexByte(rest, ';') + if end < 0 { + return 0, fmt.Errorf("attribute %q not terminated", attribute) + } + value, err := strconv.ParseUint(strings.TrimSpace(rest[:end]), 10, 32) + if err != nil { + return 0, err + } + return uint32(value), nil +} + +// resolveSwitchInSymbols returns the text symbols from kallsyms that are +// finish_task_switch or an optimized clone of it (finish_task_switch.). +func resolveSwitchInSymbols() ([]string, error) { + file, err := os.Open(kallsymsPath) + if err != nil { + return nil, err + } + defer file.Close() + + seen := make(map[string]struct{}) + var symbols []string + scanner := bufio.NewScanner(file) + for scanner.Scan() { + // Format: address type name [module] + fields := strings.Fields(scanner.Text()) + if len(fields) < 3 { + continue + } + if fields[1] != "t" && fields[1] != "T" { + continue + } + name := fields[2] + if name != switchInSymbolPrefix && + !strings.HasPrefix(name, switchInSymbolPrefix+".") { + continue + } + if _, duplicate := seen[name]; duplicate { + continue + } + seen[name] = struct{}{} + symbols = append(symbols, name) + } + if err := scanner.Err(); err != nil { + return nil, err + } + return symbols, nil +} diff --git a/probes/offcpu/offcpu_integration_test.go b/probes/offcpu/offcpu_integration_test.go new file mode 100644 index 0000000000..d1a54cc8d4 --- /dev/null +++ b/probes/offcpu/offcpu_integration_test.go @@ -0,0 +1,160 @@ +//go:build integration && linux + +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +package offcpu + +import ( + "context" + "os" + "sync" + "testing" + "time" + + "github.com/stretchr/testify/require" + "go.opentelemetry.io/ebpf-profiler/interpreter/interpreterconfig" + "go.opentelemetry.io/ebpf-profiler/libpf" + "go.opentelemetry.io/ebpf-profiler/metrics" + "go.opentelemetry.io/ebpf-profiler/tracer" + "go.opentelemetry.io/otel/metric/noop" +) + +type integrationIntervals struct{} + +var startMetricsOnce sync.Once + +func (integrationIntervals) MonitorInterval() time.Duration { return time.Second } +func (integrationIntervals) TracePollInterval() time.Duration { return 10 * time.Millisecond } +func (integrationIntervals) PIDCleanupInterval() time.Duration { return time.Second } +func (integrationIntervals) ExecutableUnloadDelay() time.Duration { return time.Second } + +func newIntegrationTracer(t *testing.T) (*tracer.Tracer, context.CancelFunc, chan *libpf.EbpfTrace) { + t.Helper() + startMetricsOnce.Do(func() { metrics.Start(noop.Meter{}) }) + + ctx, cancel := context.WithCancel(t.Context()) + + trc, err := tracer.NewTracer(ctx, &tracer.Config{ + Intervals: integrationIntervals{}, + InterpretersConfig: interpreterconfig.AllInterpreters(), + SamplesPerSecond: 20, + FrameCacheSize: 1024, + ProbabilisticInterval: time.Minute, + ProbabilisticThreshold: tracer.ProbabilisticThresholdMax, + LoadProbe: true, + DynamicProbeResourcePrefixes: []string{SampleType}, + }) + require.NoError(t, err) + + trc.StartPIDEventProcessor(ctx) + traces := make(chan *libpf.EbpfTrace, 4096) + require.NoError(t, trc.StartMapMonitors(ctx, traces)) + return trc, cancel, traces +} + +func TestOffCPUTimeProbe(t *testing.T) { + trc, cancel, traces := newIntegrationTracer(t) + defer cancel() + defer trc.Close() + + minDuration := 20 * time.Millisecond + probe, err := New(map[string]any{"min_duration": minDuration.String()}) + require.NoError(t, err) + labeler, ok := probe.(tracer.TraceLabeler) + require.True(t, ok, "off-cpu probe must implement tracer.TraceLabeler") + require.NoError(t, trc.Enable(probe)) + + // Block a thread of this process well past min_duration in a loop. Each + // timer wakeup switches the sleeping thread back in and emits a sample + // carrying the measured off-CPU nanoseconds. + sleeperDone := make(chan struct{}) + defer close(sleeperDone) + go func() { + for { + select { + case <-sleeperDone: + return + default: + time.Sleep(3 * minDuration) + } + } + }() + + // Drain the channel at full speed: the probe observes the whole system, + // so this process's samples arrive interleaved with everything else's. + deadline := time.NewTimer(10 * time.Second) + defer deadline.Stop() + pid := libpf.PID(os.Getpid()) + for { + select { + case trace := <-traces: + if trace == nil || trace.PID != pid { + continue + } + // CPU-sampling traces from this process carry no value; only + // off-CPU time samples report a duration past the threshold. + if trace.Value < int64(minDuration) { + continue + } + require.NotEmpty(t, trace.KernelFrames) + require.NotEmpty(t, trace.FrameData) + require.Positive(t, trace.NumFrames) + + // The sleeper blocks in nanosleep, so its switch-out state must + // have been captured as TASK_INTERRUPTIBLE. Wait for one such + // sample; other threads of this process may block differently. + if trace.ProbeUserData != 0x0001 { + continue + } + // The raw monitor channel taps traces before Tracer.HandleTrace + // runs the labeler, so apply it directly to prove the state + // reaches the sample label. + labeler.LabelTrace(trace) + require.Equal(t, libpf.Intern("interruptible"), + trace.CustomLabels[libpf.Intern("thread.state")]) + return + case <-deadline.C: + t.Fatal("timed out waiting for an off-cpu time trace") + } + } +} + +func TestOffCPUTimeProbeFiltersShortWaits(t *testing.T) { + trc, cancel, traces := newIntegrationTracer(t) + defer cancel() + defer trc.Close() + + // A threshold far above any wait this workload produces: nothing may be + // emitted for this process. + probe, err := New(map[string]any{"min_duration": "10m"}) + require.NoError(t, err) + require.NoError(t, trc.Enable(probe)) + + sleeperDone := make(chan struct{}) + defer close(sleeperDone) + go func() { + for { + select { + case <-sleeperDone: + return + default: + time.Sleep(50 * time.Millisecond) + } + } + }() + + pid := libpf.PID(os.Getpid()) + quiet := time.NewTimer(3 * time.Second) + defer quiet.Stop() + for { + select { + case trace := <-traces: + if trace != nil && trace.PID == pid && trace.Value > 0 { + t.Fatalf("unexpected off-cpu sample below threshold: %d ns", trace.Value) + } + case <-quiet.C: + return + } + } +} diff --git a/probes/offcpu/offcpu_test.go b/probes/offcpu/offcpu_test.go new file mode 100644 index 0000000000..77de35f4a3 --- /dev/null +++ b/probes/offcpu/offcpu_test.go @@ -0,0 +1,248 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +package offcpu + +import ( + "math" + "os" + "path/filepath" + "testing" + "time" + + "github.com/stretchr/testify/require" + "go.opentelemetry.io/ebpf-profiler/libpf" +) + +func TestNewDefaults(t *testing.T) { + created, err := New(map[string]any{}) + require.NoError(t, err) + + probe := created.(*offCPUTimeProbe) + require.Equal(t, defaultMinDuration, probe.minDuration) + require.Equal(t, uint32(math.MaxUint32), probe.sampleThreshold) + require.Equal(t, defaultMaxEntries, probe.maxEntries) + + metadata := probe.ReportMetadata() + require.Equal(t, "off_cpu_time", metadata.SampleType) + require.Equal(t, "nanoseconds", metadata.SampleUnit) + require.True(t, metadata.ReportValues) +} + +func TestNewAllowsExplicitExhaustiveCapture(t *testing.T) { + created, err := New(map[string]any{"min_duration": "0s"}) + require.NoError(t, err) + require.Zero(t, created.(*offCPUTimeProbe).minDuration) +} + +func TestNewConfigured(t *testing.T) { + created, err := New(map[string]any{ + "min_duration": "5ms", + "sample_rate": 0.5, + "max_entries": 128 * 1024, + }) + require.NoError(t, err) + + probe := created.(*offCPUTimeProbe) + require.Equal(t, 5*time.Millisecond, probe.minDuration) + require.Equal(t, uint32(math.MaxUint32/2), probe.sampleThreshold) + require.Equal(t, uint32(128*1024), probe.maxEntries) +} + +func TestNewRejectsInvalidConfiguration(t *testing.T) { + tests := map[string]struct { + config any + errorText string + }{ + "not a map": { + config: "bad", + errorText: "off-cpu time configuration must be a map, got string", + }, + "unknown field": { + config: map[string]any{"unknown": true}, + errorText: "unknown off-cpu time configuration field \"unknown\"", + }, + "bad duration": { + config: map[string]any{"min_duration": "soon"}, + errorText: "invalid min_duration \"soon\"", + }, + "negative duration": { + config: map[string]any{"min_duration": -time.Second}, + errorText: "min_duration must not be negative", + }, + "zero sample rate": { + config: map[string]any{"sample_rate": 0.0}, + errorText: "sample_rate must be in the range (0, 1]", + }, + "sample rate above one": { + config: map[string]any{"sample_rate": 1.1}, + errorText: "sample_rate must be in the range (0, 1]", + }, + "zero max entries": { + config: map[string]any{"max_entries": 0}, + errorText: "max_entries must be in the range", + }, + "too many entries": { + config: map[string]any{"max_entries": float64(maximumMaxEntries + 1)}, + errorText: "max_entries must be in the range", + }, + } + + for name, test := range tests { + t.Run(name, func(t *testing.T) { + _, err := New(test.config) + require.ErrorContains(t, err, test.errorText) + }) + } +} + +func withKallsymsFixture(t *testing.T, content string) { + t.Helper() + path := filepath.Join(t.TempDir(), "kallsyms") + require.NoError(t, os.WriteFile(path, []byte(content), 0o600)) + previous := kallsymsPath + kallsymsPath = path + t.Cleanup(func() { kallsymsPath = previous }) +} + +func TestResolveSwitchInSymbolsMatchesVariants(t *testing.T) { + withKallsymsFixture(t, `ffffffff81000000 T _stext +ffffffff810bd2a0 t finish_task_switch.isra.0 +ffffffff810bd2a0 t finish_task_switch.isra.0 +ffffffff810be000 T finish_task_switch +ffffffff810bf000 t finish_task_switching_helper +ffffffff810c0000 d finish_task_switch.data +ffffffff810c1000 t prefix_finish_task_switch +`) + + symbols, err := resolveSwitchInSymbols() + require.NoError(t, err) + require.Equal(t, []string{"finish_task_switch.isra.0", "finish_task_switch"}, symbols) +} + +func TestResolveSwitchInSymbolsEmptyWhenAbsent(t *testing.T) { + withKallsymsFixture(t, `ffffffff81000000 T _stext +ffffffff810bd2a0 t some_other_symbol +`) + + symbols, err := resolveSwitchInSymbols() + require.NoError(t, err) + require.Empty(t, symbols) +} + +func TestThreadStateName(t *testing.T) { + expected := map[uint64]string{ + 0x0000: "running", + 0x0001: "interruptible", + 0x0002: "uninterruptible", + 0x0004: "stopped", + 0x0008: "traced", + 0x0010: "exit_dead", + 0x0020: "zombie", + 0x0040: "parked", + 0x0080: "idle", + 0x0100: "preempted", + 0x0003: "other", + 0x0200: "other", + } + for state, name := range expected { + require.Equal(t, name, threadStateName(state), "state 0x%x", state) + } +} + +func TestLabelTraceAttachesThreadState(t *testing.T) { + probe := &offCPUTimeProbe{} + key := libpf.Intern("thread.state") + + trace := &libpf.EbpfTrace{ProbeUserData: 0x0001} + probe.LabelTrace(trace) + require.Equal(t, libpf.Intern("interruptible"), trace.CustomLabels[key]) + + // Merges with runtime labels instead of replacing them. + existing := libpf.Intern("request_id") + trace = &libpf.EbpfTrace{ + ProbeUserData: 0x0100, + CustomLabels: map[libpf.String]libpf.String{ + existing: libpf.Intern("abc"), + }, + } + probe.LabelTrace(trace) + require.Equal(t, libpf.Intern("preempted"), trace.CustomLabels[key]) + require.Equal(t, libpf.Intern("abc"), trace.CustomLabels[existing]) + + // No label when the state was unavailable. + trace = &libpf.EbpfTrace{ProbeUserData: stateUnavailable} + probe.LabelTrace(trace) + require.NotContains(t, trace.CustomLabels, key) +} + +const schedSwitchFormatFixture = `name: sched_switch +ID: 315 +format: + field:unsigned short common_type; offset:0; size:2; signed:0; + field:unsigned char common_flags; offset:2; size:1; signed:0; + + field:char prev_comm[16]; offset:8; size:16; signed:0; + field:pid_t prev_pid; offset:24; size:4; signed:1; + field:int prev_prio; offset:28; size:4; signed:1; + field:long prev_state; offset:32; size:8; signed:1; + field:char next_comm[16]; offset:40; size:16; signed:0; +` + +func withTracefsFixture(t *testing.T, roots []string) { + t.Helper() + previous := tracefsRoots + tracefsRoots = roots + t.Cleanup(func() { tracefsRoots = previous }) +} + +func writeFormatFixture(t *testing.T, root, content string) { + t.Helper() + dir := filepath.Join(root, "events", "sched", "sched_switch") + require.NoError(t, os.MkdirAll(dir, 0o755)) + require.NoError(t, os.WriteFile(filepath.Join(dir, "format"), []byte(content), 0o600)) +} + +func TestResolveSchedSwitchStateField(t *testing.T) { + root := t.TempDir() + writeFormatFixture(t, root, schedSwitchFormatFixture) + // The first root is missing; resolution falls back to the second. + withTracefsFixture(t, []string{filepath.Join(t.TempDir(), "absent"), root}) + + offset, size, err := resolveSchedSwitchStateField() + require.NoError(t, err) + require.Equal(t, uint32(32), offset) + require.Equal(t, uint32(8), size) +} + +func TestResolveSchedSwitchStateFieldMissingField(t *testing.T) { + root := t.TempDir() + writeFormatFixture(t, root, "name: sched_switch\n\tfield:pid_t prev_pid;\toffset:24;\tsize:4;\tsigned:1;\n") + withTracefsFixture(t, []string{root}) + + _, _, err := resolveSchedSwitchStateField() + require.ErrorContains(t, err, "prev_state") +} + +func TestParseTracepointFieldIgnoresNameSuffixMatches(t *testing.T) { + root := t.TempDir() + // prev_state_extra must not satisfy a prev_state lookup. + writeFormatFixture(t, root, + "\tfield:long prev_state_extra;\toffset:48;\tsize:8;\tsigned:1;\n"+ + "\tfield:long prev_state;\toffset:32;\tsize:8;\tsigned:1;\n") + withTracefsFixture(t, []string{root}) + + offset, size, err := resolveSchedSwitchStateField() + require.NoError(t, err) + require.Equal(t, uint32(32), offset) + require.Equal(t, uint32(8), size) +} + +func TestResolveSwitchInSymbolsMissingFile(t *testing.T) { + previous := kallsymsPath + kallsymsPath = filepath.Join(t.TempDir(), "does-not-exist") + t.Cleanup(func() { kallsymsPath = previous }) + + _, err := resolveSwitchInSymbols() + require.Error(t, err) +} diff --git a/support/ebpf/off_cpu_time.ebpf.c b/support/ebpf/off_cpu_time.ebpf.c new file mode 100644 index 0000000000..408893bab5 --- /dev/null +++ b/support/ebpf/off_cpu_time.ebpf.c @@ -0,0 +1,190 @@ +// Off-CPU time probe: measures how long each stack was off CPU. +// +// This follows the classic offcputime model (Gregg, BPF Performance Tools, +// Ch06 offcputime.bt): when a thread leaves the CPU its departure time is +// recorded, and when it is switched back in the elapsed nanoseconds are +// attributed to the stack that blocked. The switch-in unwind observes the +// blocking stack: the kernel stack still contains the path that entered the +// scheduler (…→schedule→finish_task_switch) and the user state is unchanged +// since the thread went off CPU. +// +// It intentionally differs from the built-in off-CPU support (off_cpu.ebpf.c) +// by following the exit-filtered latency-probe model used by the lock-wait +// and function-latency probes instead of entry-probability sampling: +// - Every switch-out is timestamped, so long waits are never lost to an +// entry-side coin flip. min_duration and sample_rate are applied to the +// measured duration at switch-in, where the cost of a decision is paid +// once per wakeup instead of once per context switch. +// - The start map is a global LRU hash rather than per-CPU: a thread that +// blocks on one CPU and resumes on another is still measured. +// - Per-probe metrics account for every drop path. + +#include "bpfdefs.h" +#include "tracemgmt.h" +#include "types.h" + +typedef struct OffCpuTimeMetrics { + u64 switch_outs; + u64 switch_ins; + u64 unmatched_switch_ins; + u64 filtered; + u64 emitted; + u64 state_update_failures; +} OffCpuTimeMetrics; + +// OFF_CPU_TIME_STATE_UNAVAILABLE marks a start whose thread state could not +// be read, either because the tracepoint field offset was not resolved or +// because the read failed. Userspace attaches no state label in that case. +#define OFF_CPU_TIME_STATE_UNAVAILABLE (~0ULL) + +typedef struct OffCpuTimeStart { + u64 timestamp; + // prev_state as reported by the sched_switch tracepoint at switch-out: + // 0 for a runnable thread that gave up the CPU, TASK_REPORT bits for + // voluntary blocking, TASK_REPORT_MAX for involuntary preemption. + u64 state; +} OffCpuTimeStart; + +// off_cpu_time_starts records when each thread left the CPU. The pending set +// is every sleeping thread in the system, and a thread that exits while off +// CPU leaves its entry behind with no deterministic cleanup hook (the final +// switch-out of a dying task happens after every exit tracepoint). It is +// therefore an LRU hash: leaked and coldest entries are recycled under +// pressure instead of failing new inserts. Unlike the built-in off-CPU +// profiling map this is not per-CPU, so migrated wakeups still match. +struct off_cpu_time_starts_t { + __uint(type, BPF_MAP_TYPE_LRU_HASH); + __type(key, u64); // pid_tgid + __type(value, OffCpuTimeStart); + __uint(max_entries, 65536); // resized at load time from probe configuration +} off_cpu_time_starts SEC(".maps"); + +struct off_cpu_time_metrics_t { + __uint(type, BPF_MAP_TYPE_PERCPU_ARRAY); + __type(key, u32); + __type(value, OffCpuTimeMetrics); + __uint(max_entries, 1); +} off_cpu_time_metrics SEC(".maps"); + +// These values are set independently for each loaded probe instance. +BPF_RODATA_VAR(u16, off_cpu_time_origin, 0) +BPF_RODATA_VAR(u64, off_cpu_time_min_ns, 0) +BPF_RODATA_VAR(u32, off_cpu_time_sample_threshold, 0xffffffff) + +// Regular tracepoint programs must access their context fields directly; +// bpf_probe_read_kernel() against the tracepoint context can fail even when +// the field lies in range. We still validate this layout against tracefs at +// load time before enabling the read. The profiler supports only 64-bit +// x86_64/aarch64 kernels, whose sched_switch format places the signed long +// prev_state at byte 32 with size 8. +typedef struct SchedSwitchContext { + u8 common_and_previous_task[32]; + s64 prev_state; +} SchedSwitchContext; + +BPF_RODATA_VAR(u32, off_cpu_time_state_enabled, 0) + +static EBPF_INLINE u64 off_cpu_time_read_state(const SchedSwitchContext *ctx) +{ + if (!off_cpu_time_state_enabled) { + return OFF_CPU_TIME_STATE_UNAVAILABLE; + } + return (u64)ctx->prev_state; +} + +static EBPF_INLINE OffCpuTimeMetrics *off_cpu_time_get_metrics() +{ + u32 zero = 0; + return bpf_map_lookup_elem(&off_cpu_time_metrics, &zero); +} + +// off_cpu_time_switch_out runs in the context of the thread that is leaving +// the CPU and records its departure time. It runs on every context switch on +// the system, so it must stay minimal: all filtering and the unwind happen at +// switch-in, once the off-CPU duration is known. +SEC("tracepoint/sched/sched_switch") +int off_cpu_time_switch_out(SchedSwitchContext *ctx) +{ + u64 pid_tgid = bpf_get_current_pid_tgid(); + u32 pid = pid_tgid >> 32; + u32 tid = pid_tgid & 0xffffffff; + if (pid == 0 || tid == 0) { + // Never track the idle task. + return 0; + } + + OffCpuTimeMetrics *metrics = off_cpu_time_get_metrics(); + if (metrics) { + metrics->switch_outs++; + } + + OffCpuTimeStart start = { + .timestamp = bpf_ktime_get_ns(), + // The tracepoint runs in the outgoing thread's context, so prev_state + // describes exactly the thread being recorded: it distinguishes threads + // that blocked voluntarily from runnable threads descheduled by CPU + // pressure, which would otherwise be indistinguishable in the profile. + .state = off_cpu_time_read_state(ctx), + }; + // BPF_ANY: switch-out and switch-in strictly alternate per thread, so an + // existing entry means the matching switch-in was missed (attach race or a + // missed kprobe). The newer timestamp is the correct base either way. + if (bpf_map_update_elem(&off_cpu_time_starts, &pid_tgid, &start, BPF_ANY) != 0) { + if (metrics) { + metrics->state_update_failures++; + } + } + return 0; +} + +// off_cpu_time_switch_in runs in the context of the thread that was just +// scheduled back in, right after the scheduler restored its registers. The +// unwound trace is the stack that was off CPU. Filtering happens here, on the +// measured duration: a wait shorter than min_ns is dropped, and sampling is +// applied per wakeup rather than per switch-out so long waits are never lost. +SEC("kprobe/finish_task_switch") +int off_cpu_time_switch_in(struct pt_regs *ctx) +{ + u64 pid_tgid = bpf_get_current_pid_tgid(); + u32 pid = pid_tgid >> 32; + u32 tid = pid_tgid & 0xffffffff; + if (pid == 0 || tid == 0) { + return 0; + } + + OffCpuTimeMetrics *metrics = off_cpu_time_get_metrics(); + if (metrics) { + metrics->switch_ins++; + } + + OffCpuTimeStart *stored = bpf_map_lookup_elem(&off_cpu_time_starts, &pid_tgid); + if (!stored) { + // First sighting of this thread, or its start was evicted. + if (metrics) { + metrics->unmatched_switch_ins++; + } + return 0; + } + OffCpuTimeStart start = *stored; + bpf_map_delete_elem(&off_cpu_time_starts, &pid_tgid); + + u64 timestamp = bpf_ktime_get_ns(); + if ( + timestamp < start.timestamp || timestamp - start.timestamp < off_cpu_time_min_ns || + (off_cpu_time_sample_threshold != 0xffffffff && + bpf_get_prandom_u32() > off_cpu_time_sample_threshold)) { + if (metrics) { + metrics->filtered++; + } + return 0; + } + + if (metrics) { + metrics->emitted++; + } + DEBUG_PRINT("off-cpu time wakeup pid %d tid %d", pid, tid); + // The switch-out thread state rides in the trace's user-data slot; the + // probe's userspace labeler turns it into a thread.state sample label. + return collect_trace_with_user_data( + ctx, off_cpu_time_origin, pid, tid, timestamp, timestamp - start.timestamp, start.state); +} diff --git a/support/ebpf/tracemgmt.h b/support/ebpf/tracemgmt.h index 3f86dd8a93..20ef2603f8 100644 --- a/support/ebpf/tracemgmt.h +++ b/support/ebpf/tracemgmt.h @@ -929,8 +929,14 @@ get_usermode_regs(struct pt_regs *ctx, UnwindState *state, bool *has_usermode_re #endif // TESTING_COREDUMP -static inline EBPF_INLINE int -collect_trace(struct pt_regs *ctx, u16 origin, u32 pid, u32 tid, u64 trace_timestamp, u64 value) +static inline EBPF_INLINE int collect_trace_internal( + struct pt_regs *ctx, + u16 origin, + u32 pid, + u32 tid, + u64 trace_timestamp, + u64 value, + u64 probe_user_data) { // Only continue processing the trace with a valid origin. if (origin == 0) { @@ -945,12 +951,13 @@ collect_trace(struct pt_regs *ctx, u16 origin, u32 pid, u32 tid, u64 trace_times return -1; } - Trace *trace = &record->trace; - trace->origin = origin; - trace->pid = pid; - trace->tid = tid; - trace->ktime = trace_timestamp; - trace->value = value; + Trace *trace = &record->trace; + trace->origin = origin; + trace->pid = pid; + trace->tid = tid; + trace->ktime = trace_timestamp; + trace->value = value; + trace->probe_user_data = probe_user_data; if (bpf_get_current_comm(&(trace->comm), sizeof(trace->comm)) < 0) { increment_metric(metricID_ErrBPFCurrentComm); } @@ -1000,4 +1007,18 @@ collect_trace(struct pt_regs *ctx, u16 origin, u32 pid, u32 tid, u64 trace_times return -1; } +static inline EBPF_INLINE int +collect_trace(struct pt_regs *ctx, u16 origin, u32 pid, u32 tid, u64 trace_timestamp, u64 value) +{ + return collect_trace_internal(ctx, origin, pid, tid, trace_timestamp, value, 0); +} + +// collect_trace_with_user_data keeps the trace synchronous while carrying a +// probe-defined value to its optional userspace TraceLabeler. +static inline EBPF_INLINE int collect_trace_with_user_data( + struct pt_regs *ctx, u16 origin, u32 pid, u32 tid, u64 trace_timestamp, u64 value, u64 user_data) +{ + return collect_trace_internal(ctx, origin, pid, tid, trace_timestamp, value, user_data); +} + #endif diff --git a/support/ebpf/tracer.ebpf.amd64 b/support/ebpf/tracer.ebpf.amd64 index 851a1bda91fa45108f7cb1d3156f29b11dc285b8..334c3a153b453e9097d9c76aeabfd48965482559 100644 GIT binary patch literal 987416 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%0DuQ{y@D`LvBe= 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 yR2fPnFEB+10 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