Katyusha's blog

1
// Code generated by bpf2go; DO NOT EDIT.
2
//go:build 386 || amd64 || arm || arm64 || loong64 || mips64le || mipsle || ppc64le || riscv64
3

4
package collector
5

6
import (
7
  "bytes"
8
  _ "embed"
9
  "fmt"
10
  "io"
11

12
  "github.com/cilium/ebpf"
13
)
14

15
type lockLockStat struct {
16
  OffcpuNs    uint64
17
  OffcpuCount uint64
18
  MaxOffcpuNs uint64
19
  LastWaker   uint32
20
  Stackid     int32
21
  Comm        [16]int8
22
}
23

24
type lockOffcpuInfo struct {
25
  Ts      uint64
26
  Stackid int32
27
  Pad     uint32
28
}
29

30
// loadLock returns the embedded CollectionSpec for lock.
31
func loadLock() (*ebpf.CollectionSpec, error) {
32
  reader := bytes.NewReader(_LockBytes)
33
  spec, err := ebpf.LoadCollectionSpecFromReader(reader)
34
  if err != nil {
35
    return nil, fmt.Errorf("can't load lock: %w", err)
36
  }
37

38
  return spec, err
39
}
40

41
// loadLockObjects loads lock and converts it into a struct.
42
//
43
// The following types are suitable as obj argument:
44
//
45
//  *lockObjects
46
//  *lockPrograms
47
//  *lockMaps
48
//
49
// See ebpf.CollectionSpec.LoadAndAssign documentation for details.
50
func loadLockObjects(obj interface{}, opts *ebpf.CollectionOptions) error {
51
  spec, err := loadLock()
52
  if err != nil {
53
    return err
54
  }
55

56
  return spec.LoadAndAssign(obj, opts)
57
}
58

59
// lockSpecs contains maps and programs before they are loaded into the kernel.
60
//
61
// It can be passed ebpf.CollectionSpec.Assign.
62
type lockSpecs struct {
63
  lockProgramSpecs
64
  lockMapSpecs
65
}
66

67
// lockSpecs contains programs before they are loaded into the kernel.
68
//
69
// It can be passed ebpf.CollectionSpec.Assign.
70
type lockProgramSpecs struct {
71
  HandleSwitch *ebpf.ProgramSpec `ebpf:"handle_switch"`
72
  HandleWakeup *ebpf.ProgramSpec `ebpf:"handle_wakeup"`
73
}
74

75
// lockMapSpecs contains maps before they are loaded into the kernel.
76
//
77
// It can be passed ebpf.CollectionSpec.Assign.
78
type lockMapSpecs struct {
79
  LockStats   *ebpf.MapSpec `ebpf:"lock_stats"`
80
  OffcpuStart *ebpf.MapSpec `ebpf:"offcpu_start"`
81
  Stackmap    *ebpf.MapSpec `ebpf:"stackmap"`
82
}
83

84
// lockObjects contains all objects after they have been loaded into the kernel.
85
//
86
// It can be passed to loadLockObjects or ebpf.CollectionSpec.LoadAndAssign.
87
type lockObjects struct {
88
  lockPrograms
89
  lockMaps
90
}
91

92
func (o *lockObjects) Close() error {
93
  return _LockClose(
94
    &o.lockPrograms,
95
    &o.lockMaps,
96
  )
97
}
98

99
// lockMaps contains all maps after they have been loaded into the kernel.
100
//
101
// It can be passed to loadLockObjects or ebpf.CollectionSpec.LoadAndAssign.
102
type lockMaps struct {
103
  LockStats   *ebpf.Map `ebpf:"lock_stats"`
104
  OffcpuStart *ebpf.Map `ebpf:"offcpu_start"`
105
  Stackmap    *ebpf.Map `ebpf:"stackmap"`
106
}
107

108
func (m *lockMaps) Close() error {
109
  return _LockClose(
110
    m.LockStats,
111
    m.OffcpuStart,
112
    m.Stackmap,
113
  )
114
}
115

116
// lockPrograms contains all programs after they have been loaded into the kernel.
117
//
118
// It can be passed to loadLockObjects or ebpf.CollectionSpec.LoadAndAssign.
119
type lockPrograms struct {
120
  HandleSwitch *ebpf.Program `ebpf:"handle_switch"`
121
  HandleWakeup *ebpf.Program `ebpf:"handle_wakeup"`
122
}
123

124
func (p *lockPrograms) Close() error {
125
  return _LockClose(
126
    p.HandleSwitch,
127
    p.HandleWakeup,
128
  )
129
}
130

131
func _LockClose(closers ...io.Closer) error {
132
  for _, closer := range closers {
133
    if err := closer.Close(); err != nil {
134
      return err
135
    }
136
  }
137
  return nil
138
}
139

140
// Do not access this directly.
141
//
142
//go:embed lock_bpfel.o
143
var _LockBytes []byte