### Mergo in the wild
-- [moby/moby](/~https://github.com/moby/moby)
-- [kubernetes/kubernetes](/~https://github.com/kubernetes/kubernetes)
-- [vmware/dispatch](/~https://github.com/vmware/dispatch)
-- [Shopify/themekit](/~https://github.com/Shopify/themekit)
-- [imdario/zas](/~https://github.com/imdario/zas)
-- [matcornic/hermes](/~https://github.com/matcornic/hermes)
-- [OpenBazaar/openbazaar-go](/~https://github.com/OpenBazaar/openbazaar-go)
-- [kataras/iris](/~https://github.com/kataras/iris)
-- [michaelsauter/crane](/~https://github.com/michaelsauter/crane)
-- [go-task/task](/~https://github.com/go-task/task)
-- [sensu/uchiwa](/~https://github.com/sensu/uchiwa)
-- [ory/hydra](/~https://github.com/ory/hydra)
-- [sisatech/vcli](/~https://github.com/sisatech/vcli)
-- [dairycart/dairycart](/~https://github.com/dairycart/dairycart)
-- [projectcalico/felix](/~https://github.com/projectcalico/felix)
-- [resin-os/balena](/~https://github.com/resin-os/balena)
-- [go-kivik/kivik](/~https://github.com/go-kivik/kivik)
-- [Telefonica/govice](/~https://github.com/Telefonica/govice)
-- [supergiant/supergiant](supergiant/supergiant)
-- [SergeyTsalkov/brooce](/~https://github.com/SergeyTsalkov/brooce)
-- [soniah/dnsmadeeasy](/~https://github.com/soniah/dnsmadeeasy)
-- [ohsu-comp-bio/funnel](/~https://github.com/ohsu-comp-bio/funnel)
-- [EagerIO/Stout](/~https://github.com/EagerIO/Stout)
-- [lynndylanhurley/defsynth-api](/~https://github.com/lynndylanhurley/defsynth-api)
-- [russross/canvasassignments](/~https://github.com/russross/canvasassignments)
-- [rdegges/cryptly-api](/~https://github.com/rdegges/cryptly-api)
-- [casualjim/exeggutor](/~https://github.com/casualjim/exeggutor)
-- [divshot/gitling](/~https://github.com/divshot/gitling)
-- [RWJMurphy/gorl](/~https://github.com/RWJMurphy/gorl)
-- [andrerocker/deploy42](/~https://github.com/andrerocker/deploy42)
-- [elwinar/rambler](/~https://github.com/elwinar/rambler)
-- [tmaiaroto/gopartman](/~https://github.com/tmaiaroto/gopartman)
-- [jfbus/impressionist](/~https://github.com/jfbus/impressionist)
-- [Jmeyering/zealot](/~https://github.com/Jmeyering/zealot)
-- [godep-migrator/rigger-host](/~https://github.com/godep-migrator/rigger-host)
-- [Dronevery/MultiwaySwitch-Go](/~https://github.com/Dronevery/MultiwaySwitch-Go)
-- [thoas/picfit](/~https://github.com/thoas/picfit)
-- [mantasmatelis/whooplist-server](/~https://github.com/mantasmatelis/whooplist-server)
-- [jnuthong/item_search](/~https://github.com/jnuthong/item_search)
-- [bukalapak/snowboard](/~https://github.com/bukalapak/snowboard)
-- [containerssh/containerssh](/~https://github.com/containerssh/containerssh)
-- [goreleaser/goreleaser](/~https://github.com/goreleaser/goreleaser)
-- [tjpnz/structbot](/~https://github.com/tjpnz/structbot)
+Mergo is used by [thousands](https://deps.dev/go/dario.cat%2Fmergo/v1.0.0/dependents) [of](https://deps.dev/go/github.com%2Fimdario%2Fmergo/v0.3.16/dependents) [projects](https://deps.dev/go/github.com%2Fimdario%2Fmergo/v0.3.12), including:
+
+* [containerd/containerd](/~https://github.com/containerd/containerd)
+* [datadog/datadog-agent](/~https://github.com/datadog/datadog-agent)
+* [docker/cli/](/~https://github.com/docker/cli/)
+* [goreleaser/goreleaser](/~https://github.com/goreleaser/goreleaser)
+* [go-micro/go-micro](/~https://github.com/go-micro/go-micro)
+* [grafana/loki](/~https://github.com/grafana/loki)
+* [kubernetes/kubernetes](/~https://github.com/kubernetes/kubernetes)
+* [masterminds/sprig](github.com/Masterminds/sprig)
+* [moby/moby](/~https://github.com/moby/moby)
+* [slackhq/nebula](/~https://github.com/slackhq/nebula)
+* [volcano-sh/volcano](/~https://github.com/volcano-sh/volcano)
## Install
@@ -141,6 +118,39 @@ if err := mergo.Merge(&dst, src, mergo.WithOverride); err != nil {
}
```
+If you need to override pointers, so the source pointer's value is assigned to the destination's pointer, you must use `WithoutDereference`:
+
+```go
+package main
+
+import (
+ "fmt"
+
+ "dario.cat/mergo"
+)
+
+type Foo struct {
+ A *string
+ B int64
+}
+
+func main() {
+ first := "first"
+ second := "second"
+ src := Foo{
+ A: &first,
+ B: 2,
+ }
+
+ dest := Foo{
+ A: &second,
+ B: 1,
+ }
+
+ mergo.Merge(&dest, src, mergo.WithOverride, mergo.WithoutDereference)
+}
+```
+
Additionally, you can map a `map[string]interface{}` to a struct (and otherwise, from struct to map), following the same restrictions as in `Merge()`. Keys are capitalized to find each corresponding exported field.
```go
diff --git a/vendor/dario.cat/mergo/map.go b/vendor/dario.cat/mergo/map.go
index b50d5c2a4e7c..759b4f74fd5a 100644
--- a/vendor/dario.cat/mergo/map.go
+++ b/vendor/dario.cat/mergo/map.go
@@ -58,7 +58,7 @@ func deepMap(dst, src reflect.Value, visited map[uintptr]*visit, depth int, conf
}
fieldName := field.Name
fieldName = changeInitialCase(fieldName, unicode.ToLower)
- if v, ok := dstMap[fieldName]; !ok || (isEmptyValue(reflect.ValueOf(v), !config.ShouldNotDereference) || overwrite) {
+ if _, ok := dstMap[fieldName]; !ok || (!isEmptyValue(reflect.ValueOf(src.Field(i).Interface()), !config.ShouldNotDereference) && overwrite) || config.overwriteWithEmptyValue {
dstMap[fieldName] = src.Field(i).Interface()
}
}
diff --git a/vendor/dario.cat/mergo/merge.go b/vendor/dario.cat/mergo/merge.go
index 0ef9b2138c15..fd47c95b2b84 100644
--- a/vendor/dario.cat/mergo/merge.go
+++ b/vendor/dario.cat/mergo/merge.go
@@ -269,7 +269,7 @@ func deepMerge(dst, src reflect.Value, visited map[uintptr]*visit, depth int, co
if err = deepMerge(dst.Elem(), src.Elem(), visited, depth+1, config); err != nil {
return
}
- } else {
+ } else if src.Elem().Kind() != reflect.Struct {
if overwriteWithEmptySrc || (overwrite && !src.IsNil()) || dst.IsNil() {
dst.Set(src)
}
diff --git a/vendor/github.com/cenkalti/backoff/v4/README.md b/vendor/github.com/cenkalti/backoff/v4/README.md
index 16abdfc084f7..9433004a2809 100644
--- a/vendor/github.com/cenkalti/backoff/v4/README.md
+++ b/vendor/github.com/cenkalti/backoff/v4/README.md
@@ -1,4 +1,4 @@
-# Exponential Backoff [![GoDoc][godoc image]][godoc] [![Build Status][travis image]][travis] [![Coverage Status][coveralls image]][coveralls]
+# Exponential Backoff [![GoDoc][godoc image]][godoc] [![Coverage Status][coveralls image]][coveralls]
This is a Go port of the exponential backoff algorithm from [Google's HTTP Client Library for Java][google-http-java-client].
@@ -21,8 +21,6 @@ Use https://pkg.go.dev/github.com/cenkalti/backoff/v4 to view the documentation.
[godoc]: https://pkg.go.dev/github.com/cenkalti/backoff/v4
[godoc image]: https://godoc.org/github.com/cenkalti/backoff?status.png
-[travis]: https://travis-ci.org/cenkalti/backoff
-[travis image]: https://travis-ci.org/cenkalti/backoff.png?branch=master
[coveralls]: https://coveralls.io/github/cenkalti/backoff?branch=master
[coveralls image]: https://coveralls.io/repos/github/cenkalti/backoff/badge.svg?branch=master
diff --git a/vendor/github.com/cenkalti/backoff/v4/exponential.go b/vendor/github.com/cenkalti/backoff/v4/exponential.go
index 2c56c1e7189b..aac99f196ad5 100644
--- a/vendor/github.com/cenkalti/backoff/v4/exponential.go
+++ b/vendor/github.com/cenkalti/backoff/v4/exponential.go
@@ -71,6 +71,9 @@ type Clock interface {
Now() time.Time
}
+// ExponentialBackOffOpts is a function type used to configure ExponentialBackOff options.
+type ExponentialBackOffOpts func(*ExponentialBackOff)
+
// Default values for ExponentialBackOff.
const (
DefaultInitialInterval = 500 * time.Millisecond
@@ -81,7 +84,7 @@ const (
)
// NewExponentialBackOff creates an instance of ExponentialBackOff using default values.
-func NewExponentialBackOff() *ExponentialBackOff {
+func NewExponentialBackOff(opts ...ExponentialBackOffOpts) *ExponentialBackOff {
b := &ExponentialBackOff{
InitialInterval: DefaultInitialInterval,
RandomizationFactor: DefaultRandomizationFactor,
@@ -91,10 +94,62 @@ func NewExponentialBackOff() *ExponentialBackOff {
Stop: Stop,
Clock: SystemClock,
}
+ for _, fn := range opts {
+ fn(b)
+ }
b.Reset()
return b
}
+// WithInitialInterval sets the initial interval between retries.
+func WithInitialInterval(duration time.Duration) ExponentialBackOffOpts {
+ return func(ebo *ExponentialBackOff) {
+ ebo.InitialInterval = duration
+ }
+}
+
+// WithRandomizationFactor sets the randomization factor to add jitter to intervals.
+func WithRandomizationFactor(randomizationFactor float64) ExponentialBackOffOpts {
+ return func(ebo *ExponentialBackOff) {
+ ebo.RandomizationFactor = randomizationFactor
+ }
+}
+
+// WithMultiplier sets the multiplier for increasing the interval after each retry.
+func WithMultiplier(multiplier float64) ExponentialBackOffOpts {
+ return func(ebo *ExponentialBackOff) {
+ ebo.Multiplier = multiplier
+ }
+}
+
+// WithMaxInterval sets the maximum interval between retries.
+func WithMaxInterval(duration time.Duration) ExponentialBackOffOpts {
+ return func(ebo *ExponentialBackOff) {
+ ebo.MaxInterval = duration
+ }
+}
+
+// WithMaxElapsedTime sets the maximum total time for retries.
+func WithMaxElapsedTime(duration time.Duration) ExponentialBackOffOpts {
+ return func(ebo *ExponentialBackOff) {
+ ebo.MaxElapsedTime = duration
+ }
+}
+
+// WithRetryStopDuration sets the duration after which retries should stop.
+func WithRetryStopDuration(duration time.Duration) ExponentialBackOffOpts {
+ return func(ebo *ExponentialBackOff) {
+ ebo.Stop = duration
+ }
+}
+
+// WithClockProvider sets the clock used to measure time.
+func WithClockProvider(clock Clock) ExponentialBackOffOpts {
+ return func(ebo *ExponentialBackOff) {
+ ebo.Clock = clock
+ }
+}
+
type systemClock struct{}
func (t systemClock) Now() time.Time {
diff --git a/vendor/github.com/cespare/xxhash/v2/README.md b/vendor/github.com/cespare/xxhash/v2/README.md
index 8bf0e5b78153..33c88305c46e 100644
--- a/vendor/github.com/cespare/xxhash/v2/README.md
+++ b/vendor/github.com/cespare/xxhash/v2/README.md
@@ -70,3 +70,5 @@ benchstat <(go test -benchtime 500ms -count 15 -bench 'Sum64$')
- [VictoriaMetrics](/~https://github.com/VictoriaMetrics/VictoriaMetrics)
- [FreeCache](/~https://github.com/coocood/freecache)
- [FastCache](/~https://github.com/VictoriaMetrics/fastcache)
+- [Ristretto](/~https://github.com/dgraph-io/ristretto)
+- [Badger](/~https://github.com/dgraph-io/badger)
diff --git a/vendor/github.com/cespare/xxhash/v2/xxhash.go b/vendor/github.com/cespare/xxhash/v2/xxhash.go
index a9e0d45c9dcc..78bddf1ceed7 100644
--- a/vendor/github.com/cespare/xxhash/v2/xxhash.go
+++ b/vendor/github.com/cespare/xxhash/v2/xxhash.go
@@ -19,10 +19,13 @@ const (
// Store the primes in an array as well.
//
// The consts are used when possible in Go code to avoid MOVs but we need a
-// contiguous array of the assembly code.
+// contiguous array for the assembly code.
var primes = [...]uint64{prime1, prime2, prime3, prime4, prime5}
// Digest implements hash.Hash64.
+//
+// Note that a zero-valued Digest is not ready to receive writes.
+// Call Reset or create a Digest using New before calling other methods.
type Digest struct {
v1 uint64
v2 uint64
@@ -33,19 +36,31 @@ type Digest struct {
n int // how much of mem is used
}
-// New creates a new Digest that computes the 64-bit xxHash algorithm.
+// New creates a new Digest with a zero seed.
func New() *Digest {
+ return NewWithSeed(0)
+}
+
+// NewWithSeed creates a new Digest with the given seed.
+func NewWithSeed(seed uint64) *Digest {
var d Digest
- d.Reset()
+ d.ResetWithSeed(seed)
return &d
}
// Reset clears the Digest's state so that it can be reused.
+// It uses a seed value of zero.
func (d *Digest) Reset() {
- d.v1 = primes[0] + prime2
- d.v2 = prime2
- d.v3 = 0
- d.v4 = -primes[0]
+ d.ResetWithSeed(0)
+}
+
+// ResetWithSeed clears the Digest's state so that it can be reused.
+// It uses the given seed to initialize the state.
+func (d *Digest) ResetWithSeed(seed uint64) {
+ d.v1 = seed + prime1 + prime2
+ d.v2 = seed + prime2
+ d.v3 = seed
+ d.v4 = seed - prime1
d.total = 0
d.n = 0
}
diff --git a/vendor/github.com/cespare/xxhash/v2/xxhash_asm.go b/vendor/github.com/cespare/xxhash/v2/xxhash_asm.go
index 9216e0a40c1a..78f95f256103 100644
--- a/vendor/github.com/cespare/xxhash/v2/xxhash_asm.go
+++ b/vendor/github.com/cespare/xxhash/v2/xxhash_asm.go
@@ -6,7 +6,7 @@
package xxhash
-// Sum64 computes the 64-bit xxHash digest of b.
+// Sum64 computes the 64-bit xxHash digest of b with a zero seed.
//
//go:noescape
func Sum64(b []byte) uint64
diff --git a/vendor/github.com/cespare/xxhash/v2/xxhash_other.go b/vendor/github.com/cespare/xxhash/v2/xxhash_other.go
index 26df13bba4b7..118e49e819e0 100644
--- a/vendor/github.com/cespare/xxhash/v2/xxhash_other.go
+++ b/vendor/github.com/cespare/xxhash/v2/xxhash_other.go
@@ -3,7 +3,7 @@
package xxhash
-// Sum64 computes the 64-bit xxHash digest of b.
+// Sum64 computes the 64-bit xxHash digest of b with a zero seed.
func Sum64(b []byte) uint64 {
// A simpler version would be
// d := New()
diff --git a/vendor/github.com/cespare/xxhash/v2/xxhash_safe.go b/vendor/github.com/cespare/xxhash/v2/xxhash_safe.go
index e86f1b5fd8e4..05f5e7dfe7b7 100644
--- a/vendor/github.com/cespare/xxhash/v2/xxhash_safe.go
+++ b/vendor/github.com/cespare/xxhash/v2/xxhash_safe.go
@@ -5,7 +5,7 @@
package xxhash
-// Sum64String computes the 64-bit xxHash digest of s.
+// Sum64String computes the 64-bit xxHash digest of s with a zero seed.
func Sum64String(s string) uint64 {
return Sum64([]byte(s))
}
diff --git a/vendor/github.com/cespare/xxhash/v2/xxhash_unsafe.go b/vendor/github.com/cespare/xxhash/v2/xxhash_unsafe.go
index 1c1638fd88a1..cf9d42aed536 100644
--- a/vendor/github.com/cespare/xxhash/v2/xxhash_unsafe.go
+++ b/vendor/github.com/cespare/xxhash/v2/xxhash_unsafe.go
@@ -33,7 +33,7 @@ import (
//
// See /~https://github.com/golang/go/issues/42739 for discussion.
-// Sum64String computes the 64-bit xxHash digest of s.
+// Sum64String computes the 64-bit xxHash digest of s with a zero seed.
// It may be faster than Sum64([]byte(s)) by avoiding a copy.
func Sum64String(s string) uint64 {
b := *(*[]byte)(unsafe.Pointer(&sliceHeader{s, len(s)}))
diff --git a/vendor/github.com/cilium/ebpf/.clang-format b/vendor/github.com/cilium/ebpf/.clang-format
index 4eb94b1baa87..3f74dc023665 100644
--- a/vendor/github.com/cilium/ebpf/.clang-format
+++ b/vendor/github.com/cilium/ebpf/.clang-format
@@ -14,4 +14,6 @@ KeepEmptyLinesAtTheStartOfBlocks: false
TabWidth: 4
UseTab: ForContinuationAndIndentation
ColumnLimit: 1000
+# Go compiler comments need to stay unindented.
+CommentPragmas: '^go:.*'
...
diff --git a/vendor/github.com/cilium/ebpf/.golangci.yaml b/vendor/github.com/cilium/ebpf/.golangci.yaml
index dc62dd6d0fc7..06743dfc91b4 100644
--- a/vendor/github.com/cilium/ebpf/.golangci.yaml
+++ b/vendor/github.com/cilium/ebpf/.golangci.yaml
@@ -9,7 +9,6 @@ issues:
linters:
disable-all: true
enable:
- - deadcode
- errcheck
- goimports
- gosimple
@@ -17,10 +16,9 @@ linters:
- ineffassign
- misspell
- staticcheck
- - structcheck
- typecheck
- unused
- - varcheck
+ - gofmt
# Could be enabled later:
# - gocyclo
diff --git a/vendor/github.com/cilium/ebpf/ARCHITECTURE.md b/vendor/github.com/cilium/ebpf/ARCHITECTURE.md
index 8cd7e2486e70..26f555eb7a76 100644
--- a/vendor/github.com/cilium/ebpf/ARCHITECTURE.md
+++ b/vendor/github.com/cilium/ebpf/ARCHITECTURE.md
@@ -1,7 +1,21 @@
Architecture of the library
===
- ELF -> Specifications -> Objects -> Links
+```mermaid
+graph RL
+ Program --> ProgramSpec --> ELF
+ btf.Spec --> ELF
+ Map --> MapSpec --> ELF
+ Links --> Map & Program
+ ProgramSpec -.-> btf.Spec
+ MapSpec -.-> btf.Spec
+ subgraph Collection
+ Program & Map
+ end
+ subgraph CollectionSpec
+ ProgramSpec & MapSpec & btf.Spec
+ end
+```
ELF
---
@@ -11,7 +25,7 @@ an ELF file which contains program byte code (aka BPF), but also metadata for
maps used by the program. The metadata follows the conventions set by libbpf
shipped with the kernel. Certain ELF sections have special meaning
and contain structures defined by libbpf. Newer versions of clang emit
-additional metadata in BPF Type Format (aka BTF).
+additional metadata in [BPF Type Format](#BTF).
The library aims to be compatible with libbpf so that moving from a C toolchain
to a Go one creates little friction. To that end, the [ELF reader](elf_reader.go)
@@ -20,41 +34,33 @@ if possible.
The output of the ELF reader is a `CollectionSpec` which encodes
all of the information contained in the ELF in a form that is easy to work with
-in Go.
-
-### BTF
-
-The BPF Type Format describes more than just the types used by a BPF program. It
-includes debug aids like which source line corresponds to which instructions and
-what global variables are used.
-
-[BTF parsing](internal/btf/) lives in a separate internal package since exposing
-it would mean an additional maintenance burden, and because the API still
-has sharp corners. The most important concept is the `btf.Type` interface, which
-also describes things that aren't really types like `.rodata` or `.bss` sections.
-`btf.Type`s can form cyclical graphs, which can easily lead to infinite loops if
-one is not careful. Hopefully a safe pattern to work with `btf.Type` emerges as
-we write more code that deals with it.
+in Go. The returned `CollectionSpec` should be deterministic: reading the same ELF
+file on different systems must produce the same output.
+As a corollary, any changes that depend on the runtime environment like the
+current kernel version must happen when creating [Objects](#Objects).
Specifications
---
-`CollectionSpec`, `ProgramSpec` and `MapSpec` are blueprints for in-kernel
+`CollectionSpec` is a very simple container for `ProgramSpec`, `MapSpec` and
+`btf.Spec`. Avoid adding functionality to it if possible.
+
+`ProgramSpec` and `MapSpec` are blueprints for in-kernel
objects and contain everything necessary to execute the relevant `bpf(2)`
-syscalls. Since the ELF reader outputs a `CollectionSpec` it's possible to
-modify clang-compiled BPF code, for example to rewrite constants. At the same
-time the [asm](asm/) package provides an assembler that can be used to generate
-`ProgramSpec` on the fly.
+syscalls. They refer to `btf.Spec` for type information such as `Map` key and
+value types.
-Creating a spec should never require any privileges or be restricted in any way,
-for example by only allowing programs in native endianness. This ensures that
-the library stays flexible.
+The [asm](asm/) package provides an assembler that can be used to generate
+`ProgramSpec` on the fly.
Objects
---
-`Program` and `Map` are the result of loading specs into the kernel. Sometimes
-loading a spec will fail because the kernel is too old, or a feature is not
+`Program` and `Map` are the result of loading specifications into the kernel.
+Features that depend on knowledge of the current system (e.g kernel version)
+are implemented at this point.
+
+Sometimes loading a spec will fail because the kernel is too old, or a feature is not
enabled. There are multiple ways the library deals with that:
* Fallback: older kernels don't allow naming programs and maps. The library
@@ -73,7 +79,7 @@ useful when our higher-level API doesn't support a particular use case.
Links
---
-BPF can be attached to many different points in the kernel and newer BPF hooks
+Programs can be attached to many different points in the kernel and newer BPF hooks
tend to use bpf_link to do so. Older hooks unfortunately use a combination of
syscalls, netlink messages, etc. Adding support for a new link type should not
pull in large dependencies like netlink, so XDP programs or tracepoints are
diff --git a/vendor/github.com/cilium/ebpf/CONTRIBUTING.md b/vendor/github.com/cilium/ebpf/CONTRIBUTING.md
index 0d29eae81e3e..bf57da939539 100644
--- a/vendor/github.com/cilium/ebpf/CONTRIBUTING.md
+++ b/vendor/github.com/cilium/ebpf/CONTRIBUTING.md
@@ -5,15 +5,23 @@ the form of pull requests and issues reporting bugs or suggesting new features
are welcome. Please take a look at [the architecture](ARCHITECTURE.md) to get
a better understanding for the high-level goals.
-New features must be accompanied by tests. Before starting work on any large
-feature, please [join](https://ebpf.io/slack) the
-[#ebpf-go](https://cilium.slack.com/messages/ebpf-go) channel on Slack to
-discuss the design first.
+## Adding a new feature
-When submitting pull requests, consider writing details about what problem you
-are solving and why the proposed approach solves that problem in commit messages
-and/or pull request description to help future library users and maintainers to
-reason about the proposed changes.
+1. [Join](https://ebpf.io/slack) the
+[#ebpf-go](https://cilium.slack.com/messages/ebpf-go) channel to discuss your requirements and how the feature can be implemented. The most important part is figuring out how much new exported API is necessary. **The less new API is required the easier it will be to land the feature.**
+2. (*optional*) Create a draft PR if you want to discuss the implementation or have hit a problem. It's fine if this doesn't compile or contains debug statements.
+3. Create a PR that is ready to merge. This must pass CI and have tests.
+
+### API stability
+
+The library doesn't guarantee the stability of its API at the moment.
+
+1. If possible avoid breakage by introducing new API and deprecating the old one
+ at the same time. If an API was deprecated in v0.x it can be removed in v0.x+1.
+2. Breaking API in a way that causes compilation failures is acceptable but must
+ have good reasons.
+3. Changing the semantics of the API without causing compilation failures is
+ heavily discouraged.
## Running the tests
@@ -35,6 +43,6 @@ Examples:
./run-tests.sh 5.4
# Run a subset of tests:
-./run-tests.sh 5.4 go test ./link
+./run-tests.sh 5.4 ./link
```
diff --git a/vendor/github.com/cilium/ebpf/MAINTAINERS.md b/vendor/github.com/cilium/ebpf/MAINTAINERS.md
index 9c18e7e76f54..a56a03e3947f 100644
--- a/vendor/github.com/cilium/ebpf/MAINTAINERS.md
+++ b/vendor/github.com/cilium/ebpf/MAINTAINERS.md
@@ -1,8 +1,3 @@
# Maintainers
- * [Lorenz Bauer]
- * [Timo Beckers] (Isovalent)
-
-
-[Lorenz Bauer]: /~https://github.com/lmb
-[Timo Beckers]: /~https://github.com/ti-mo
+Maintainers can be found in the [Cilium Maintainers file](/~https://github.com/cilium/community/blob/main/roles/Maintainers.md)
diff --git a/vendor/github.com/cilium/ebpf/Makefile b/vendor/github.com/cilium/ebpf/Makefile
index 2d5f04c370eb..abcd6c1a47c7 100644
--- a/vendor/github.com/cilium/ebpf/Makefile
+++ b/vendor/github.com/cilium/ebpf/Makefile
@@ -28,6 +28,7 @@ TARGETS := \
testdata/loader-clang-7 \
testdata/loader-clang-9 \
testdata/loader-$(CLANG) \
+ testdata/manyprogs \
testdata/btf_map_init \
testdata/invalid_map \
testdata/raw_tracepoint \
@@ -39,9 +40,15 @@ TARGETS := \
testdata/map_spin_lock \
testdata/subprog_reloc \
testdata/fwd_decl \
+ testdata/kconfig \
+ testdata/kconfig_config \
+ testdata/kfunc \
+ testdata/invalid-kfunc \
+ testdata/kfunc-kmod \
btf/testdata/relocs \
btf/testdata/relocs_read \
- btf/testdata/relocs_read_tgt
+ btf/testdata/relocs_read_tgt \
+ cmd/bpf2go/testdata/minimal
.PHONY: all clean container-all container-shell generate
@@ -49,12 +56,12 @@ TARGETS := \
# Build all ELF binaries using a containerized LLVM toolchain.
container-all:
- ${CONTAINER_ENGINE} run --rm ${CONTAINER_RUN_ARGS} \
+ +${CONTAINER_ENGINE} run --rm -ti ${CONTAINER_RUN_ARGS} \
-v "${REPODIR}":/ebpf -w /ebpf --env MAKEFLAGS \
--env CFLAGS="-fdebug-prefix-map=/ebpf=." \
--env HOME="/tmp" \
"${IMAGE}:${VERSION}" \
- $(MAKE) all
+ make all
# (debug) Drop the user into a shell inside the container as root.
container-shell:
@@ -77,9 +84,7 @@ all: format $(addsuffix -el.elf,$(TARGETS)) $(addsuffix -eb.elf,$(TARGETS)) gene
generate: export BPF_CLANG := $(CLANG)
generate: export BPF_CFLAGS := $(CFLAGS)
generate:
- go generate ./cmd/bpf2go/test
- go generate ./internal/sys
- cd examples/ && go generate ./...
+ go generate ./...
testdata/loader-%-el.elf: testdata/loader.c
$* $(CFLAGS) -target bpfel -c $< -o $@
@@ -98,11 +103,11 @@ testdata/loader-%-eb.elf: testdata/loader.c
$(STRIP) -g $@
.PHONY: generate-btf
-generate-btf: KERNEL_VERSION?=5.18
+generate-btf: KERNEL_VERSION?=5.19
generate-btf:
$(eval TMP := $(shell mktemp -d))
curl -fL "$(CI_KERNEL_URL)/linux-$(KERNEL_VERSION).bz" -o "$(TMP)/bzImage"
- ./testdata/extract-vmlinux "$(TMP)/bzImage" > "$(TMP)/vmlinux"
+ /lib/modules/$(uname -r)/build/scripts/extract-vmlinux "$(TMP)/bzImage" > "$(TMP)/vmlinux"
$(OBJCOPY) --dump-section .BTF=/dev/stdout "$(TMP)/vmlinux" /dev/null | gzip > "btf/testdata/vmlinux.btf.gz"
curl -fL "$(CI_KERNEL_URL)/linux-$(KERNEL_VERSION)-selftests-bpf.tgz" -o "$(TMP)/selftests.tgz"
tar -xf "$(TMP)/selftests.tgz" --to-stdout tools/testing/selftests/bpf/bpf_testmod/bpf_testmod.ko | \
diff --git a/vendor/github.com/cilium/ebpf/README.md b/vendor/github.com/cilium/ebpf/README.md
index 3e490de71101..eff08d8df699 100644
--- a/vendor/github.com/cilium/ebpf/README.md
+++ b/vendor/github.com/cilium/ebpf/README.md
@@ -4,33 +4,37 @@
-eBPF is a pure Go library that provides utilities for loading, compiling, and
+ebpf-go is a pure Go library that provides utilities for loading, compiling, and
debugging eBPF programs. It has minimal external dependencies and is intended to
be used in long running processes.
-The library is maintained by [Cloudflare](https://www.cloudflare.com) and
-[Cilium](https://www.cilium.io).
-
-See [ebpf.io](https://ebpf.io) for other projects from the eBPF ecosystem.
+See [ebpf.io](https://ebpf.io) for complementary projects from the wider eBPF
+ecosystem.
## Getting Started
A small collection of Go and eBPF programs that serve as examples for building
your own tools can be found under [examples/](examples/).
-Contributions are highly encouraged, as they highlight certain use cases of
+[Contributions](CONTRIBUTING.md) are highly encouraged, as they highlight certain use cases of
eBPF and the library, and help shape the future of the project.
## Getting Help
-Please
-[join](https://ebpf.io/slack) the
+The community actively monitors our [GitHub Discussions](/~https://github.com/cilium/ebpf/discussions) page.
+Please search for existing threads before starting a new one. Refrain from
+opening issues on the bug tracker if you're just starting out or if you're not
+sure if something is a bug in the library code.
+
+Alternatively, [join](https://ebpf.io/slack) the
[#ebpf-go](https://cilium.slack.com/messages/ebpf-go) channel on Slack if you
-have questions regarding the library.
+have other questions regarding the project. Note that this channel is ephemeral
+and has its history erased past a certain point, which is less helpful for
+others running into the same problem later.
## Packages
-This library includes the following packages:
+This library includes the following packages:
* [asm](https://pkg.go.dev/github.com/cilium/ebpf/asm) contains a basic
assembler, allowing you to write eBPF assembly instructions directly
@@ -38,7 +42,7 @@ This library includes the following packages:
* [cmd/bpf2go](https://pkg.go.dev/github.com/cilium/ebpf/cmd/bpf2go) allows
compiling and embedding eBPF programs written in C within Go code. As well as
compiling the C code, it auto-generates Go code for loading and manipulating
- the eBPF program and map objects.
+ the eBPF program and map objects.
* [link](https://pkg.go.dev/github.com/cilium/ebpf/link) allows attaching eBPF
to various hooks
* [perf](https://pkg.go.dev/github.com/cilium/ebpf/perf) allows reading from a
@@ -49,6 +53,7 @@ This library includes the following packages:
of `bpftool feature probe` for discovering BPF-related kernel features using native Go.
* [rlimit](https://pkg.go.dev/github.com/cilium/ebpf/rlimit) provides a convenient API to lift
the `RLIMIT_MEMLOCK` constraint on kernels before 5.11.
+* [btf](https://pkg.go.dev/github.com/cilium/ebpf/btf) allows reading the BPF Type Format.
## Requirements
diff --git a/vendor/github.com/cilium/ebpf/asm/alu.go b/vendor/github.com/cilium/ebpf/asm/alu.go
index 70ccc4d1518d..3f60245f2b6d 100644
--- a/vendor/github.com/cilium/ebpf/asm/alu.go
+++ b/vendor/github.com/cilium/ebpf/asm/alu.go
@@ -4,10 +4,10 @@ package asm
// Source of ALU / ALU64 / Branch operations
//
-// msb lsb
-// +----+-+---+
-// |op |S|cls|
-// +----+-+---+
+// msb lsb
+// +----+-+---+
+// |op |S|cls|
+// +----+-+---+
type Source uint8
const sourceMask OpCode = 0x08
@@ -39,10 +39,10 @@ const (
// ALUOp are ALU / ALU64 operations
//
-// msb lsb
-// +----+-+---+
-// |OP |s|cls|
-// +----+-+---+
+// msb lsb
+// +----+-+---+
+// |OP |s|cls|
+// +----+-+---+
type ALUOp uint8
const aluMask OpCode = 0xf0
diff --git a/vendor/github.com/cilium/ebpf/asm/func.go b/vendor/github.com/cilium/ebpf/asm/func.go
index a14e9e2c3ce9..18f6a75db58a 100644
--- a/vendor/github.com/cilium/ebpf/asm/func.go
+++ b/vendor/github.com/cilium/ebpf/asm/func.go
@@ -13,15 +13,15 @@ func (_ BuiltinFunc) Max() BuiltinFunc {
//
// You can regenerate this list using the following gawk script:
//
-// /FN\(.+\),/ {
-// match($1, /\((.+)\)/, r)
-// split(r[1], p, "_")
-// printf "Fn"
-// for (i in p) {
-// printf "%s%s", toupper(substr(p[i], 1, 1)), substr(p[i], 2)
-// }
-// print ""
-// }
+// /FN\(.+\),/ {
+// match($1, /\(([a-z_0-9]+),/, r)
+// split(r[1], p, "_")
+// printf "Fn"
+// for (i in p) {
+// printf "%s%s", toupper(substr(p[i], 1, 1)), substr(p[i], 2)
+// }
+// print ""
+// }
//
// The script expects include/uapi/linux/bpf.h as it's input.
const (
@@ -229,6 +229,14 @@ const (
FnDynptrRead
FnDynptrWrite
FnDynptrData
+ FnTcpRawGenSyncookieIpv4
+ FnTcpRawGenSyncookieIpv6
+ FnTcpRawCheckSyncookieIpv4
+ FnTcpRawCheckSyncookieIpv6
+ FnKtimeGetTaiNs
+ FnUserRingbufDrain
+ FnCgrpStorageGet
+ FnCgrpStorageDelete
maxBuiltinFunc
)
diff --git a/vendor/github.com/cilium/ebpf/asm/func_string.go b/vendor/github.com/cilium/ebpf/asm/func_string.go
index b7431b7f605a..47150bc4f2d2 100644
--- a/vendor/github.com/cilium/ebpf/asm/func_string.go
+++ b/vendor/github.com/cilium/ebpf/asm/func_string.go
@@ -212,12 +212,20 @@ func _() {
_ = x[FnDynptrRead-201]
_ = x[FnDynptrWrite-202]
_ = x[FnDynptrData-203]
- _ = x[maxBuiltinFunc-204]
+ _ = x[FnTcpRawGenSyncookieIpv4-204]
+ _ = x[FnTcpRawGenSyncookieIpv6-205]
+ _ = x[FnTcpRawCheckSyncookieIpv4-206]
+ _ = x[FnTcpRawCheckSyncookieIpv6-207]
+ _ = x[FnKtimeGetTaiNs-208]
+ _ = x[FnUserRingbufDrain-209]
+ _ = x[FnCgrpStorageGet-210]
+ _ = x[FnCgrpStorageDelete-211]
+ _ = x[maxBuiltinFunc-212]
}
-const _BuiltinFunc_name = "FnUnspecFnMapLookupElemFnMapUpdateElemFnMapDeleteElemFnProbeReadFnKtimeGetNsFnTracePrintkFnGetPrandomU32FnGetSmpProcessorIdFnSkbStoreBytesFnL3CsumReplaceFnL4CsumReplaceFnTailCallFnCloneRedirectFnGetCurrentPidTgidFnGetCurrentUidGidFnGetCurrentCommFnGetCgroupClassidFnSkbVlanPushFnSkbVlanPopFnSkbGetTunnelKeyFnSkbSetTunnelKeyFnPerfEventReadFnRedirectFnGetRouteRealmFnPerfEventOutputFnSkbLoadBytesFnGetStackidFnCsumDiffFnSkbGetTunnelOptFnSkbSetTunnelOptFnSkbChangeProtoFnSkbChangeTypeFnSkbUnderCgroupFnGetHashRecalcFnGetCurrentTaskFnProbeWriteUserFnCurrentTaskUnderCgroupFnSkbChangeTailFnSkbPullDataFnCsumUpdateFnSetHashInvalidFnGetNumaNodeIdFnSkbChangeHeadFnXdpAdjustHeadFnProbeReadStrFnGetSocketCookieFnGetSocketUidFnSetHashFnSetsockoptFnSkbAdjustRoomFnRedirectMapFnSkRedirectMapFnSockMapUpdateFnXdpAdjustMetaFnPerfEventReadValueFnPerfProgReadValueFnGetsockoptFnOverrideReturnFnSockOpsCbFlagsSetFnMsgRedirectMapFnMsgApplyBytesFnMsgCorkBytesFnMsgPullDataFnBindFnXdpAdjustTailFnSkbGetXfrmStateFnGetStackFnSkbLoadBytesRelativeFnFibLookupFnSockHashUpdateFnMsgRedirectHashFnSkRedirectHashFnLwtPushEncapFnLwtSeg6StoreBytesFnLwtSeg6AdjustSrhFnLwtSeg6ActionFnRcRepeatFnRcKeydownFnSkbCgroupIdFnGetCurrentCgroupIdFnGetLocalStorageFnSkSelectReuseportFnSkbAncestorCgroupIdFnSkLookupTcpFnSkLookupUdpFnSkReleaseFnMapPushElemFnMapPopElemFnMapPeekElemFnMsgPushDataFnMsgPopDataFnRcPointerRelFnSpinLockFnSpinUnlockFnSkFullsockFnTcpSockFnSkbEcnSetCeFnGetListenerSockFnSkcLookupTcpFnTcpCheckSyncookieFnSysctlGetNameFnSysctlGetCurrentValueFnSysctlGetNewValueFnSysctlSetNewValueFnStrtolFnStrtoulFnSkStorageGetFnSkStorageDeleteFnSendSignalFnTcpGenSyncookieFnSkbOutputFnProbeReadUserFnProbeReadKernelFnProbeReadUserStrFnProbeReadKernelStrFnTcpSendAckFnSendSignalThreadFnJiffies64FnReadBranchRecordsFnGetNsCurrentPidTgidFnXdpOutputFnGetNetnsCookieFnGetCurrentAncestorCgroupIdFnSkAssignFnKtimeGetBootNsFnSeqPrintfFnSeqWriteFnSkCgroupIdFnSkAncestorCgroupIdFnRingbufOutputFnRingbufReserveFnRingbufSubmitFnRingbufDiscardFnRingbufQueryFnCsumLevelFnSkcToTcp6SockFnSkcToTcpSockFnSkcToTcpTimewaitSockFnSkcToTcpRequestSockFnSkcToUdp6SockFnGetTaskStackFnLoadHdrOptFnStoreHdrOptFnReserveHdrOptFnInodeStorageGetFnInodeStorageDeleteFnDPathFnCopyFromUserFnSnprintfBtfFnSeqPrintfBtfFnSkbCgroupClassidFnRedirectNeighFnPerCpuPtrFnThisCpuPtrFnRedirectPeerFnTaskStorageGetFnTaskStorageDeleteFnGetCurrentTaskBtfFnBprmOptsSetFnKtimeGetCoarseNsFnImaInodeHashFnSockFromFileFnCheckMtuFnForEachMapElemFnSnprintfFnSysBpfFnBtfFindByNameKindFnSysCloseFnTimerInitFnTimerSetCallbackFnTimerStartFnTimerCancelFnGetFuncIpFnGetAttachCookieFnTaskPtRegsFnGetBranchSnapshotFnTraceVprintkFnSkcToUnixSockFnKallsymsLookupNameFnFindVmaFnLoopFnStrncmpFnGetFuncArgFnGetFuncRetFnGetFuncArgCntFnGetRetvalFnSetRetvalFnXdpGetBuffLenFnXdpLoadBytesFnXdpStoreBytesFnCopyFromUserTaskFnSkbSetTstampFnImaFileHashFnKptrXchgFnMapLookupPercpuElemFnSkcToMptcpSockFnDynptrFromMemFnRingbufReserveDynptrFnRingbufSubmitDynptrFnRingbufDiscardDynptrFnDynptrReadFnDynptrWriteFnDynptrDatamaxBuiltinFunc"
+const _BuiltinFunc_name = "FnUnspecFnMapLookupElemFnMapUpdateElemFnMapDeleteElemFnProbeReadFnKtimeGetNsFnTracePrintkFnGetPrandomU32FnGetSmpProcessorIdFnSkbStoreBytesFnL3CsumReplaceFnL4CsumReplaceFnTailCallFnCloneRedirectFnGetCurrentPidTgidFnGetCurrentUidGidFnGetCurrentCommFnGetCgroupClassidFnSkbVlanPushFnSkbVlanPopFnSkbGetTunnelKeyFnSkbSetTunnelKeyFnPerfEventReadFnRedirectFnGetRouteRealmFnPerfEventOutputFnSkbLoadBytesFnGetStackidFnCsumDiffFnSkbGetTunnelOptFnSkbSetTunnelOptFnSkbChangeProtoFnSkbChangeTypeFnSkbUnderCgroupFnGetHashRecalcFnGetCurrentTaskFnProbeWriteUserFnCurrentTaskUnderCgroupFnSkbChangeTailFnSkbPullDataFnCsumUpdateFnSetHashInvalidFnGetNumaNodeIdFnSkbChangeHeadFnXdpAdjustHeadFnProbeReadStrFnGetSocketCookieFnGetSocketUidFnSetHashFnSetsockoptFnSkbAdjustRoomFnRedirectMapFnSkRedirectMapFnSockMapUpdateFnXdpAdjustMetaFnPerfEventReadValueFnPerfProgReadValueFnGetsockoptFnOverrideReturnFnSockOpsCbFlagsSetFnMsgRedirectMapFnMsgApplyBytesFnMsgCorkBytesFnMsgPullDataFnBindFnXdpAdjustTailFnSkbGetXfrmStateFnGetStackFnSkbLoadBytesRelativeFnFibLookupFnSockHashUpdateFnMsgRedirectHashFnSkRedirectHashFnLwtPushEncapFnLwtSeg6StoreBytesFnLwtSeg6AdjustSrhFnLwtSeg6ActionFnRcRepeatFnRcKeydownFnSkbCgroupIdFnGetCurrentCgroupIdFnGetLocalStorageFnSkSelectReuseportFnSkbAncestorCgroupIdFnSkLookupTcpFnSkLookupUdpFnSkReleaseFnMapPushElemFnMapPopElemFnMapPeekElemFnMsgPushDataFnMsgPopDataFnRcPointerRelFnSpinLockFnSpinUnlockFnSkFullsockFnTcpSockFnSkbEcnSetCeFnGetListenerSockFnSkcLookupTcpFnTcpCheckSyncookieFnSysctlGetNameFnSysctlGetCurrentValueFnSysctlGetNewValueFnSysctlSetNewValueFnStrtolFnStrtoulFnSkStorageGetFnSkStorageDeleteFnSendSignalFnTcpGenSyncookieFnSkbOutputFnProbeReadUserFnProbeReadKernelFnProbeReadUserStrFnProbeReadKernelStrFnTcpSendAckFnSendSignalThreadFnJiffies64FnReadBranchRecordsFnGetNsCurrentPidTgidFnXdpOutputFnGetNetnsCookieFnGetCurrentAncestorCgroupIdFnSkAssignFnKtimeGetBootNsFnSeqPrintfFnSeqWriteFnSkCgroupIdFnSkAncestorCgroupIdFnRingbufOutputFnRingbufReserveFnRingbufSubmitFnRingbufDiscardFnRingbufQueryFnCsumLevelFnSkcToTcp6SockFnSkcToTcpSockFnSkcToTcpTimewaitSockFnSkcToTcpRequestSockFnSkcToUdp6SockFnGetTaskStackFnLoadHdrOptFnStoreHdrOptFnReserveHdrOptFnInodeStorageGetFnInodeStorageDeleteFnDPathFnCopyFromUserFnSnprintfBtfFnSeqPrintfBtfFnSkbCgroupClassidFnRedirectNeighFnPerCpuPtrFnThisCpuPtrFnRedirectPeerFnTaskStorageGetFnTaskStorageDeleteFnGetCurrentTaskBtfFnBprmOptsSetFnKtimeGetCoarseNsFnImaInodeHashFnSockFromFileFnCheckMtuFnForEachMapElemFnSnprintfFnSysBpfFnBtfFindByNameKindFnSysCloseFnTimerInitFnTimerSetCallbackFnTimerStartFnTimerCancelFnGetFuncIpFnGetAttachCookieFnTaskPtRegsFnGetBranchSnapshotFnTraceVprintkFnSkcToUnixSockFnKallsymsLookupNameFnFindVmaFnLoopFnStrncmpFnGetFuncArgFnGetFuncRetFnGetFuncArgCntFnGetRetvalFnSetRetvalFnXdpGetBuffLenFnXdpLoadBytesFnXdpStoreBytesFnCopyFromUserTaskFnSkbSetTstampFnImaFileHashFnKptrXchgFnMapLookupPercpuElemFnSkcToMptcpSockFnDynptrFromMemFnRingbufReserveDynptrFnRingbufSubmitDynptrFnRingbufDiscardDynptrFnDynptrReadFnDynptrWriteFnDynptrDataFnTcpRawGenSyncookieIpv4FnTcpRawGenSyncookieIpv6FnTcpRawCheckSyncookieIpv4FnTcpRawCheckSyncookieIpv6FnKtimeGetTaiNsFnUserRingbufDrainFnCgrpStorageGetFnCgrpStorageDeletemaxBuiltinFunc"
-var _BuiltinFunc_index = [...]uint16{0, 8, 23, 38, 53, 64, 76, 89, 104, 123, 138, 153, 168, 178, 193, 212, 230, 246, 264, 277, 289, 306, 323, 338, 348, 363, 380, 394, 406, 416, 433, 450, 466, 481, 497, 512, 528, 544, 568, 583, 596, 608, 624, 639, 654, 669, 683, 700, 714, 723, 735, 750, 763, 778, 793, 808, 828, 847, 859, 875, 894, 910, 925, 939, 952, 958, 973, 990, 1000, 1022, 1033, 1049, 1066, 1082, 1096, 1115, 1133, 1148, 1158, 1169, 1182, 1202, 1219, 1238, 1259, 1272, 1285, 1296, 1309, 1321, 1334, 1347, 1359, 1373, 1383, 1395, 1407, 1416, 1429, 1446, 1460, 1479, 1494, 1517, 1536, 1555, 1563, 1572, 1586, 1603, 1615, 1632, 1643, 1658, 1675, 1693, 1713, 1725, 1743, 1754, 1773, 1794, 1805, 1821, 1849, 1859, 1875, 1886, 1896, 1908, 1928, 1943, 1959, 1974, 1990, 2004, 2015, 2030, 2044, 2066, 2087, 2102, 2116, 2128, 2141, 2156, 2173, 2193, 2200, 2214, 2227, 2241, 2259, 2274, 2285, 2297, 2311, 2327, 2346, 2365, 2378, 2396, 2410, 2424, 2434, 2450, 2460, 2468, 2487, 2497, 2508, 2526, 2538, 2551, 2562, 2579, 2591, 2610, 2624, 2639, 2659, 2668, 2674, 2683, 2695, 2707, 2722, 2733, 2744, 2759, 2773, 2788, 2806, 2820, 2833, 2843, 2864, 2880, 2895, 2917, 2938, 2960, 2972, 2985, 2997, 3011}
+var _BuiltinFunc_index = [...]uint16{0, 8, 23, 38, 53, 64, 76, 89, 104, 123, 138, 153, 168, 178, 193, 212, 230, 246, 264, 277, 289, 306, 323, 338, 348, 363, 380, 394, 406, 416, 433, 450, 466, 481, 497, 512, 528, 544, 568, 583, 596, 608, 624, 639, 654, 669, 683, 700, 714, 723, 735, 750, 763, 778, 793, 808, 828, 847, 859, 875, 894, 910, 925, 939, 952, 958, 973, 990, 1000, 1022, 1033, 1049, 1066, 1082, 1096, 1115, 1133, 1148, 1158, 1169, 1182, 1202, 1219, 1238, 1259, 1272, 1285, 1296, 1309, 1321, 1334, 1347, 1359, 1373, 1383, 1395, 1407, 1416, 1429, 1446, 1460, 1479, 1494, 1517, 1536, 1555, 1563, 1572, 1586, 1603, 1615, 1632, 1643, 1658, 1675, 1693, 1713, 1725, 1743, 1754, 1773, 1794, 1805, 1821, 1849, 1859, 1875, 1886, 1896, 1908, 1928, 1943, 1959, 1974, 1990, 2004, 2015, 2030, 2044, 2066, 2087, 2102, 2116, 2128, 2141, 2156, 2173, 2193, 2200, 2214, 2227, 2241, 2259, 2274, 2285, 2297, 2311, 2327, 2346, 2365, 2378, 2396, 2410, 2424, 2434, 2450, 2460, 2468, 2487, 2497, 2508, 2526, 2538, 2551, 2562, 2579, 2591, 2610, 2624, 2639, 2659, 2668, 2674, 2683, 2695, 2707, 2722, 2733, 2744, 2759, 2773, 2788, 2806, 2820, 2833, 2843, 2864, 2880, 2895, 2917, 2938, 2960, 2972, 2985, 2997, 3021, 3045, 3071, 3097, 3112, 3130, 3146, 3165, 3179}
func (i BuiltinFunc) String() string {
if i < 0 || i >= BuiltinFunc(len(_BuiltinFunc_index)-1) {
diff --git a/vendor/github.com/cilium/ebpf/asm/instruction.go b/vendor/github.com/cilium/ebpf/asm/instruction.go
index f17d88b51869..ef01eaa35ae9 100644
--- a/vendor/github.com/cilium/ebpf/asm/instruction.go
+++ b/vendor/github.com/cilium/ebpf/asm/instruction.go
@@ -226,6 +226,13 @@ func (ins *Instruction) IsFunctionCall() bool {
return ins.OpCode.JumpOp() == Call && ins.Src == PseudoCall
}
+// IsKfuncCall returns true if the instruction calls a kfunc.
+//
+// This is not the same thing as a BPF helper call.
+func (ins *Instruction) IsKfuncCall() bool {
+ return ins.OpCode.JumpOp() == Call && ins.Src == PseudoKfuncCall
+}
+
// IsLoadOfFunctionPointer returns true if the instruction loads a function pointer.
func (ins *Instruction) IsLoadOfFunctionPointer() bool {
return ins.OpCode.IsDWordLoad() && ins.Src == PseudoFunc
@@ -318,10 +325,14 @@ func (ins Instruction) Format(f fmt.State, c rune) {
case cls.IsJump():
switch jop := op.JumpOp(); jop {
case Call:
- if ins.Src == PseudoCall {
+ switch ins.Src {
+ case PseudoCall:
// bpf-to-bpf call
fmt.Fprint(f, ins.Constant)
- } else {
+ case PseudoKfuncCall:
+ // kfunc call
+ fmt.Fprintf(f, "Kfunc(%d)", ins.Constant)
+ default:
fmt.Fprint(f, BuiltinFunc(ins.Constant))
}
@@ -354,6 +365,13 @@ func (ins Instruction) Size() uint64 {
return uint64(InstructionSize * ins.OpCode.rawInstructions())
}
+// WithMetadata sets the given Metadata on the Instruction. e.g. to copy
+// Metadata from another Instruction when replacing it.
+func (ins Instruction) WithMetadata(meta Metadata) Instruction {
+ ins.Metadata = meta
+ return ins
+}
+
type symbolMeta struct{}
// WithSymbol marks the Instruction as a Symbol, which other Instructions
diff --git a/vendor/github.com/cilium/ebpf/asm/jump.go b/vendor/github.com/cilium/ebpf/asm/jump.go
index e31e42cac52c..2c8a3dbb7a36 100644
--- a/vendor/github.com/cilium/ebpf/asm/jump.go
+++ b/vendor/github.com/cilium/ebpf/asm/jump.go
@@ -4,10 +4,10 @@ package asm
// JumpOp affect control flow.
//
-// msb lsb
-// +----+-+---+
-// |OP |s|cls|
-// +----+-+---+
+// msb lsb
+// +----+-+---+
+// |OP |s|cls|
+// +----+-+---+
type JumpOp uint8
const jumpMask OpCode = aluMask
diff --git a/vendor/github.com/cilium/ebpf/asm/load_store.go b/vendor/github.com/cilium/ebpf/asm/load_store.go
index 85ed286b02b0..f109497aebcb 100644
--- a/vendor/github.com/cilium/ebpf/asm/load_store.go
+++ b/vendor/github.com/cilium/ebpf/asm/load_store.go
@@ -4,10 +4,10 @@ package asm
// Mode for load and store operations
//
-// msb lsb
-// +---+--+---+
-// |MDE|sz|cls|
-// +---+--+---+
+// msb lsb
+// +---+--+---+
+// |MDE|sz|cls|
+// +---+--+---+
type Mode uint8
const modeMask OpCode = 0xe0
@@ -30,10 +30,10 @@ const (
// Size of load and store operations
//
-// msb lsb
-// +---+--+---+
-// |mde|SZ|cls|
-// +---+--+---+
+// msb lsb
+// +---+--+---+
+// |mde|SZ|cls|
+// +---+--+---+
type Size uint8
const sizeMask OpCode = 0x18
diff --git a/vendor/github.com/cilium/ebpf/asm/opcode.go b/vendor/github.com/cilium/ebpf/asm/opcode.go
index b11917e18bbc..9e3c30b0b3a9 100644
--- a/vendor/github.com/cilium/ebpf/asm/opcode.go
+++ b/vendor/github.com/cilium/ebpf/asm/opcode.go
@@ -9,10 +9,10 @@ import (
// Class of operations
//
-// msb lsb
-// +---+--+---+
-// | ?? |CLS|
-// +---+--+---+
+// msb lsb
+// +---+--+---+
+// | ?? |CLS|
+// +---+--+---+
type Class uint8
const classMask OpCode = 0x07
@@ -70,10 +70,10 @@ func (cls Class) isJumpOrALU() bool {
//
// Its encoding is defined by a Class value:
//
-// msb lsb
-// +----+-+---+
-// | ???? |CLS|
-// +----+-+---+
+// msb lsb
+// +----+-+---+
+// | ???? |CLS|
+// +----+-+---+
type OpCode uint8
// InvalidOpCode is returned by setters on OpCode
diff --git a/vendor/github.com/cilium/ebpf/asm/register.go b/vendor/github.com/cilium/ebpf/asm/register.go
index dd5d44f1c191..457a3b8a8838 100644
--- a/vendor/github.com/cilium/ebpf/asm/register.go
+++ b/vendor/github.com/cilium/ebpf/asm/register.go
@@ -35,10 +35,11 @@ const (
// Pseudo registers used by 64bit loads and jumps
const (
- PseudoMapFD = R1 // BPF_PSEUDO_MAP_FD
- PseudoMapValue = R2 // BPF_PSEUDO_MAP_VALUE
- PseudoCall = R1 // BPF_PSEUDO_CALL
- PseudoFunc = R4 // BPF_PSEUDO_FUNC
+ PseudoMapFD = R1 // BPF_PSEUDO_MAP_FD
+ PseudoMapValue = R2 // BPF_PSEUDO_MAP_VALUE
+ PseudoCall = R1 // BPF_PSEUDO_CALL
+ PseudoFunc = R4 // BPF_PSEUDO_FUNC
+ PseudoKfuncCall = R2 // BPF_PSEUDO_KFUNC_CALL
)
func (r Register) String() string {
diff --git a/vendor/github.com/cilium/ebpf/attachtype_string.go b/vendor/github.com/cilium/ebpf/attachtype_string.go
index de355ed90922..add2a3b5cc9b 100644
--- a/vendor/github.com/cilium/ebpf/attachtype_string.go
+++ b/vendor/github.com/cilium/ebpf/attachtype_string.go
@@ -51,11 +51,12 @@ func _() {
_ = x[AttachSkReuseportSelect-39]
_ = x[AttachSkReuseportSelectOrMigrate-40]
_ = x[AttachPerfEvent-41]
+ _ = x[AttachTraceKprobeMulti-42]
}
-const _AttachType_name = "NoneCGroupInetEgressCGroupInetSockCreateCGroupSockOpsSkSKBStreamParserSkSKBStreamVerdictCGroupDeviceSkMsgVerdictCGroupInet4BindCGroupInet6BindCGroupInet4ConnectCGroupInet6ConnectCGroupInet4PostBindCGroupInet6PostBindCGroupUDP4SendmsgCGroupUDP6SendmsgLircMode2FlowDissectorCGroupSysctlCGroupUDP4RecvmsgCGroupUDP6RecvmsgCGroupGetsockoptCGroupSetsockoptTraceRawTpTraceFEntryTraceFExitModifyReturnLSMMacTraceIterCgroupInet4GetPeernameCgroupInet6GetPeernameCgroupInet4GetSocknameCgroupInet6GetSocknameXDPDevMapCgroupInetSockReleaseXDPCPUMapSkLookupXDPSkSKBVerdictSkReuseportSelectSkReuseportSelectOrMigratePerfEvent"
+const _AttachType_name = "NoneCGroupInetEgressCGroupInetSockCreateCGroupSockOpsSkSKBStreamParserSkSKBStreamVerdictCGroupDeviceSkMsgVerdictCGroupInet4BindCGroupInet6BindCGroupInet4ConnectCGroupInet6ConnectCGroupInet4PostBindCGroupInet6PostBindCGroupUDP4SendmsgCGroupUDP6SendmsgLircMode2FlowDissectorCGroupSysctlCGroupUDP4RecvmsgCGroupUDP6RecvmsgCGroupGetsockoptCGroupSetsockoptTraceRawTpTraceFEntryTraceFExitModifyReturnLSMMacTraceIterCgroupInet4GetPeernameCgroupInet6GetPeernameCgroupInet4GetSocknameCgroupInet6GetSocknameXDPDevMapCgroupInetSockReleaseXDPCPUMapSkLookupXDPSkSKBVerdictSkReuseportSelectSkReuseportSelectOrMigratePerfEventTraceKprobeMulti"
-var _AttachType_index = [...]uint16{0, 4, 20, 40, 53, 70, 88, 100, 112, 127, 142, 160, 178, 197, 216, 233, 250, 259, 272, 284, 301, 318, 334, 350, 360, 371, 381, 393, 399, 408, 430, 452, 474, 496, 505, 526, 535, 543, 546, 558, 575, 601, 610}
+var _AttachType_index = [...]uint16{0, 4, 20, 40, 53, 70, 88, 100, 112, 127, 142, 160, 178, 197, 216, 233, 250, 259, 272, 284, 301, 318, 334, 350, 360, 371, 381, 393, 399, 408, 430, 452, 474, 496, 505, 526, 535, 543, 546, 558, 575, 601, 610, 626}
func (i AttachType) String() string {
if i >= AttachType(len(_AttachType_index)-1) {
diff --git a/vendor/github.com/cilium/ebpf/btf/btf.go b/vendor/github.com/cilium/ebpf/btf/btf.go
index a5969332aaa8..86eb7d6819d5 100644
--- a/vendor/github.com/cilium/ebpf/btf/btf.go
+++ b/vendor/github.com/cilium/ebpf/btf/btf.go
@@ -2,7 +2,6 @@ package btf
import (
"bufio"
- "bytes"
"debug/elf"
"encoding/binary"
"errors"
@@ -11,6 +10,7 @@ import (
"math"
"os"
"reflect"
+ "sync"
"github.com/cilium/ebpf/internal"
"github.com/cilium/ebpf/internal/sys"
@@ -21,34 +21,41 @@ const btfMagic = 0xeB9F
// Errors returned by BTF functions.
var (
- ErrNotSupported = internal.ErrNotSupported
- ErrNotFound = errors.New("not found")
- ErrNoExtendedInfo = errors.New("no extended info")
+ ErrNotSupported = internal.ErrNotSupported
+ ErrNotFound = errors.New("not found")
+ ErrNoExtendedInfo = errors.New("no extended info")
+ ErrMultipleMatches = errors.New("multiple matching types")
)
// ID represents the unique ID of a BTF object.
type ID = sys.BTFID
-// Spec represents decoded BTF.
+// Spec allows querying a set of Types and loading the set into the
+// kernel.
type Spec struct {
- // Data from .BTF.
- rawTypes []rawType
- strings *stringTable
-
- // All types contained by the spec. For the base type, the position of
- // a type in the slice is its ID.
- types types
+ // All types contained by the spec, not including types from the base in
+ // case the spec was parsed from split BTF.
+ types []Type
// Type IDs indexed by type.
typeIDs map[Type]TypeID
+ // The ID of the first type in types.
+ firstTypeID TypeID
+
// Types indexed by essential name.
// Includes all struct flavors and types with the same name.
namedTypes map[essentialName][]Type
+ // String table from ELF, may be nil.
+ strings *stringTable
+
+ // Byte order of the ELF we decoded the spec from, may be nil.
byteOrder binary.ByteOrder
}
+var btfHeaderLen = binary.Size(&btfHeader{})
+
type btfHeader struct {
Magic uint16
Version uint8
@@ -73,6 +80,18 @@ func (h *btfHeader) stringStart() int64 {
return int64(h.HdrLen + h.StringOff)
}
+// newSpec creates a Spec containing only Void.
+func newSpec() *Spec {
+ return &Spec{
+ []Type{(*Void)(nil)},
+ map[Type]TypeID{(*Void)(nil): 0},
+ 0,
+ make(map[essentialName][]Type),
+ nil,
+ nil,
+ }
+}
+
// LoadSpec opens file and calls LoadSpecFromReader on it.
func LoadSpec(file string) (*Spec, error) {
fh, err := os.Open(file)
@@ -92,10 +111,7 @@ func LoadSpecFromReader(rd io.ReaderAt) (*Spec, error) {
file, err := internal.NewSafeELFFile(rd)
if err != nil {
if bo := guessRawBTFByteOrder(rd); bo != nil {
- // Try to parse a naked BTF blob. This will return an error if
- // we encounter a Datasec, since we can't fix it up.
- spec, err := loadRawSpec(io.NewSectionReader(rd, 0, math.MaxInt64), bo, nil, nil)
- return spec, err
+ return loadRawSpec(io.NewSectionReader(rd, 0, math.MaxInt64), bo, nil)
}
return nil, err
@@ -106,7 +122,7 @@ func LoadSpecFromReader(rd io.ReaderAt) (*Spec, error) {
// LoadSpecAndExtInfosFromReader reads from an ELF.
//
-// ExtInfos may be nil if the ELF doesn't contain section metadta.
+// ExtInfos may be nil if the ELF doesn't contain section metadata.
// Returns ErrNotFound if the ELF contains no BTF.
func LoadSpecAndExtInfosFromReader(rd io.ReaderAt) (*Spec, *ExtInfos, error) {
file, err := internal.NewSafeELFFile(rd)
@@ -119,7 +135,7 @@ func LoadSpecAndExtInfosFromReader(rd io.ReaderAt) (*Spec, *ExtInfos, error) {
return nil, nil, err
}
- extInfos, err := loadExtInfosFromELF(file, spec.types, spec.strings)
+ extInfos, err := loadExtInfosFromELF(file, spec)
if err != nil && !errors.Is(err, ErrNotFound) {
return nil, nil, err
}
@@ -127,40 +143,40 @@ func LoadSpecAndExtInfosFromReader(rd io.ReaderAt) (*Spec, *ExtInfos, error) {
return spec, extInfos, nil
}
-// variableOffsets extracts all symbols offsets from an ELF and indexes them by
+// symbolOffsets extracts all symbols offsets from an ELF and indexes them by
// section and variable name.
//
// References to variables in BTF data sections carry unsigned 32-bit offsets.
// Some ELF symbols (e.g. in vmlinux) may point to virtual memory that is well
// beyond this range. Since these symbols cannot be described by BTF info,
// ignore them here.
-func variableOffsets(file *internal.SafeELFFile) (map[variable]uint32, error) {
+func symbolOffsets(file *internal.SafeELFFile) (map[symbol]uint32, error) {
symbols, err := file.Symbols()
if err != nil {
return nil, fmt.Errorf("can't read symbols: %v", err)
}
- variableOffsets := make(map[variable]uint32)
- for _, symbol := range symbols {
- if idx := symbol.Section; idx >= elf.SHN_LORESERVE && idx <= elf.SHN_HIRESERVE {
+ offsets := make(map[symbol]uint32)
+ for _, sym := range symbols {
+ if idx := sym.Section; idx >= elf.SHN_LORESERVE && idx <= elf.SHN_HIRESERVE {
// Ignore things like SHN_ABS
continue
}
- if symbol.Value > math.MaxUint32 {
+ if sym.Value > math.MaxUint32 {
// VarSecinfo offset is u32, cannot reference symbols in higher regions.
continue
}
- if int(symbol.Section) >= len(file.Sections) {
- return nil, fmt.Errorf("symbol %s: invalid section %d", symbol.Name, symbol.Section)
+ if int(sym.Section) >= len(file.Sections) {
+ return nil, fmt.Errorf("symbol %s: invalid section %d", sym.Name, sym.Section)
}
- secName := file.Sections[symbol.Section].Name
- variableOffsets[variable{secName, symbol.Name}] = uint32(symbol.Value)
+ secName := file.Sections[sym.Section].Name
+ offsets[symbol{secName, sym.Name}] = uint32(sym.Value)
}
- return variableOffsets, nil
+ return offsets, nil
}
func loadSpecFromELF(file *internal.SafeELFFile) (*Spec, error) {
@@ -190,7 +206,7 @@ func loadSpecFromELF(file *internal.SafeELFFile) (*Spec, error) {
return nil, fmt.Errorf("btf: %w", ErrNotFound)
}
- vars, err := variableOffsets(file)
+ offsets, err := symbolOffsets(file)
if err != nil {
return nil, err
}
@@ -199,51 +215,66 @@ func loadSpecFromELF(file *internal.SafeELFFile) (*Spec, error) {
return nil, fmt.Errorf("compressed BTF is not supported")
}
- rawTypes, rawStrings, err := parseBTF(btfSection.ReaderAt, file.ByteOrder, nil)
+ spec, err := loadRawSpec(btfSection.ReaderAt, file.ByteOrder, nil)
if err != nil {
return nil, err
}
- err = fixupDatasec(rawTypes, rawStrings, sectionSizes, vars)
+ err = fixupDatasec(spec.types, sectionSizes, offsets)
if err != nil {
return nil, err
}
- return inflateSpec(rawTypes, rawStrings, file.ByteOrder, nil)
+ return spec, nil
}
-func loadRawSpec(btf io.ReaderAt, bo binary.ByteOrder,
- baseTypes types, baseStrings *stringTable) (*Spec, error) {
+func loadRawSpec(btf io.ReaderAt, bo binary.ByteOrder, base *Spec) (*Spec, error) {
+ var (
+ baseStrings *stringTable
+ firstTypeID TypeID
+ err error
+ )
+
+ if base != nil {
+ if base.firstTypeID != 0 {
+ return nil, fmt.Errorf("can't use split BTF as base")
+ }
+
+ if base.strings == nil {
+ return nil, fmt.Errorf("parse split BTF: base must be loaded from an ELF")
+ }
+
+ baseStrings = base.strings
+
+ firstTypeID, err = base.nextTypeID()
+ if err != nil {
+ return nil, err
+ }
+ }
rawTypes, rawStrings, err := parseBTF(btf, bo, baseStrings)
if err != nil {
return nil, err
}
- return inflateSpec(rawTypes, rawStrings, bo, baseTypes)
-}
-
-func inflateSpec(rawTypes []rawType, rawStrings *stringTable, bo binary.ByteOrder,
- baseTypes types) (*Spec, error) {
-
- types, err := inflateRawTypes(rawTypes, baseTypes, rawStrings)
+ types, err := inflateRawTypes(rawTypes, rawStrings, base)
if err != nil {
return nil, err
}
- typeIDs, typesByName := indexTypes(types, TypeID(len(baseTypes)))
+ typeIDs, typesByName := indexTypes(types, firstTypeID)
return &Spec{
- rawTypes: rawTypes,
- namedTypes: typesByName,
- typeIDs: typeIDs,
- types: types,
- strings: rawStrings,
- byteOrder: bo,
+ namedTypes: typesByName,
+ typeIDs: typeIDs,
+ types: types,
+ firstTypeID: firstTypeID,
+ strings: rawStrings,
+ byteOrder: bo,
}, nil
}
-func indexTypes(types []Type, typeIDOffset TypeID) (map[Type]TypeID, map[essentialName][]Type) {
+func indexTypes(types []Type, firstTypeID TypeID) (map[Type]TypeID, map[essentialName][]Type) {
namedTypes := 0
for _, typ := range types {
if typ.TypeName() != "" {
@@ -261,7 +292,7 @@ func indexTypes(types []Type, typeIDOffset TypeID) (map[Type]TypeID, map[essenti
if name := newEssentialName(typ.TypeName()); name != "" {
typesByName[name] = append(typesByName[name], typ)
}
- typeIDs[typ] = TypeID(i) + typeIDOffset
+ typeIDs[typ] = firstTypeID + TypeID(i)
}
return typeIDs, typesByName
@@ -272,20 +303,70 @@ func indexTypes(types []Type, typeIDOffset TypeID) (map[Type]TypeID, map[essenti
// Defaults to /sys/kernel/btf/vmlinux and falls back to scanning the file system
// for vmlinux ELFs. Returns an error wrapping ErrNotSupported if BTF is not enabled.
func LoadKernelSpec() (*Spec, error) {
+ spec, _, err := kernelSpec()
+ if err != nil {
+ return nil, err
+ }
+ return spec.Copy(), nil
+}
+
+var kernelBTF struct {
+ sync.RWMutex
+ spec *Spec
+ // True if the spec was read from an ELF instead of raw BTF in /sys.
+ fallback bool
+}
+
+// FlushKernelSpec removes any cached kernel type information.
+func FlushKernelSpec() {
+ kernelBTF.Lock()
+ defer kernelBTF.Unlock()
+
+ kernelBTF.spec, kernelBTF.fallback = nil, false
+}
+
+func kernelSpec() (*Spec, bool, error) {
+ kernelBTF.RLock()
+ spec, fallback := kernelBTF.spec, kernelBTF.fallback
+ kernelBTF.RUnlock()
+
+ if spec == nil {
+ kernelBTF.Lock()
+ defer kernelBTF.Unlock()
+
+ spec, fallback = kernelBTF.spec, kernelBTF.fallback
+ }
+
+ if spec != nil {
+ return spec, fallback, nil
+ }
+
+ spec, fallback, err := loadKernelSpec()
+ if err != nil {
+ return nil, false, err
+ }
+
+ kernelBTF.spec, kernelBTF.fallback = spec, fallback
+ return spec, fallback, nil
+}
+
+func loadKernelSpec() (_ *Spec, fallback bool, _ error) {
fh, err := os.Open("/sys/kernel/btf/vmlinux")
if err == nil {
defer fh.Close()
- return loadRawSpec(fh, internal.NativeEndian, nil, nil)
+ spec, err := loadRawSpec(fh, internal.NativeEndian, nil)
+ return spec, false, err
}
file, err := findVMLinux()
if err != nil {
- return nil, err
+ return nil, false, err
}
defer file.Close()
- return loadSpecFromELF(file)
+ spec, err := loadSpecFromELF(file)
+ return spec, true, err
}
// findVMLinux scans multiple well-known paths for vmlinux kernel images.
@@ -388,140 +469,122 @@ func parseBTF(btf io.ReaderAt, bo binary.ByteOrder, baseStrings *stringTable) ([
return rawTypes, rawStrings, nil
}
-type variable struct {
+type symbol struct {
section string
name string
}
-func fixupDatasec(rawTypes []rawType, rawStrings *stringTable, sectionSizes map[string]uint32, variableOffsets map[variable]uint32) error {
- for i, rawType := range rawTypes {
- if rawType.Kind() != kindDatasec {
+// fixupDatasec attempts to patch up missing info in Datasecs and its members by
+// supplementing them with information from the ELF headers and symbol table.
+func fixupDatasec(types []Type, sectionSizes map[string]uint32, offsets map[symbol]uint32) error {
+ for _, typ := range types {
+ ds, ok := typ.(*Datasec)
+ if !ok {
continue
}
- name, err := rawStrings.Lookup(rawType.NameOff)
- if err != nil {
- return err
- }
+ name := ds.Name
+
+ // Some Datasecs are virtual and don't have corresponding ELF sections.
+ switch name {
+ case ".ksyms":
+ // .ksyms describes forward declarations of kfunc signatures.
+ // Nothing to fix up, all sizes and offsets are 0.
+ for _, vsi := range ds.Vars {
+ _, ok := vsi.Type.(*Func)
+ if !ok {
+ // Only Funcs are supported in the .ksyms Datasec.
+ return fmt.Errorf("data section %s: expected *btf.Func, not %T: %w", name, vsi.Type, ErrNotSupported)
+ }
+ }
+
+ continue
+ case ".kconfig":
+ // .kconfig has a size of 0 and has all members' offsets set to 0.
+ // Fix up all offsets and set the Datasec's size.
+ if err := fixupDatasecLayout(ds); err != nil {
+ return err
+ }
- if name == ".kconfig" || name == ".ksyms" {
- return fmt.Errorf("reference to %s: %w", name, ErrNotSupported)
+ // Fix up extern to global linkage to avoid a BTF verifier error.
+ for _, vsi := range ds.Vars {
+ vsi.Type.(*Var).Linkage = GlobalVar
+ }
+
+ continue
}
- if rawTypes[i].SizeType != 0 {
+ if ds.Size != 0 {
continue
}
- size, ok := sectionSizes[name]
+ ds.Size, ok = sectionSizes[name]
if !ok {
return fmt.Errorf("data section %s: missing size", name)
}
- rawTypes[i].SizeType = size
-
- secinfos := rawType.data.([]btfVarSecinfo)
- for j, secInfo := range secinfos {
- id := int(secInfo.Type - 1)
- if id >= len(rawTypes) {
- return fmt.Errorf("data section %s: invalid type id %d for variable %d", name, id, j)
+ for i := range ds.Vars {
+ symName := ds.Vars[i].Type.TypeName()
+ ds.Vars[i].Offset, ok = offsets[symbol{name, symName}]
+ if !ok {
+ return fmt.Errorf("data section %s: missing offset for symbol %s", name, symName)
}
+ }
+ }
- varName, err := rawStrings.Lookup(rawTypes[id].NameOff)
- if err != nil {
- return fmt.Errorf("data section %s: can't get name for type %d: %w", name, id, err)
- }
+ return nil
+}
- offset, ok := variableOffsets[variable{name, varName}]
- if !ok {
- return fmt.Errorf("data section %s: missing offset for variable %s", name, varName)
- }
+// fixupDatasecLayout populates ds.Vars[].Offset according to var sizes and
+// alignment. Calculate and set ds.Size.
+func fixupDatasecLayout(ds *Datasec) error {
+ var off uint32
- secinfos[j].Offset = offset
+ for i, vsi := range ds.Vars {
+ v, ok := vsi.Type.(*Var)
+ if !ok {
+ return fmt.Errorf("member %d: unsupported type %T", i, vsi.Type)
+ }
+
+ size, err := Sizeof(v.Type)
+ if err != nil {
+ return fmt.Errorf("variable %s: getting size: %w", v.Name, err)
}
+ align, err := alignof(v.Type)
+ if err != nil {
+ return fmt.Errorf("variable %s: getting alignment: %w", v.Name, err)
+ }
+
+ // Align the current member based on the offset of the end of the previous
+ // member and the alignment of the current member.
+ off = internal.Align(off, uint32(align))
+
+ ds.Vars[i].Offset = off
+
+ off += uint32(size)
}
+ ds.Size = off
+
return nil
}
// Copy creates a copy of Spec.
func (s *Spec) Copy() *Spec {
types := copyTypes(s.types, nil)
-
- typeIDOffset := TypeID(0)
- if len(s.types) != 0 {
- typeIDOffset = s.typeIDs[s.types[0]]
- }
- typeIDs, typesByName := indexTypes(types, typeIDOffset)
+ typeIDs, typesByName := indexTypes(types, s.firstTypeID)
// NB: Other parts of spec are not copied since they are immutable.
return &Spec{
- s.rawTypes,
- s.strings,
types,
typeIDs,
+ s.firstTypeID,
typesByName,
+ s.strings,
s.byteOrder,
}
}
-type marshalOpts struct {
- ByteOrder binary.ByteOrder
- StripFuncLinkage bool
-}
-
-func (s *Spec) marshal(opts marshalOpts) ([]byte, error) {
- var (
- buf bytes.Buffer
- header = new(btfHeader)
- headerLen = binary.Size(header)
- )
-
- // Reserve space for the header. We have to write it last since
- // we don't know the size of the type section yet.
- _, _ = buf.Write(make([]byte, headerLen))
-
- // Write type section, just after the header.
- for _, raw := range s.rawTypes {
- switch {
- case opts.StripFuncLinkage && raw.Kind() == kindFunc:
- raw.SetLinkage(StaticFunc)
- }
-
- if err := raw.Marshal(&buf, opts.ByteOrder); err != nil {
- return nil, fmt.Errorf("can't marshal BTF: %w", err)
- }
- }
-
- typeLen := uint32(buf.Len() - headerLen)
-
- // Write string section after type section.
- stringsLen := s.strings.Length()
- buf.Grow(stringsLen)
- if err := s.strings.Marshal(&buf); err != nil {
- return nil, err
- }
-
- // Fill out the header, and write it out.
- header = &btfHeader{
- Magic: btfMagic,
- Version: 1,
- Flags: 0,
- HdrLen: uint32(headerLen),
- TypeOff: 0,
- TypeLen: typeLen,
- StringOff: typeLen,
- StringLen: uint32(stringsLen),
- }
-
- raw := buf.Bytes()
- err := binary.Write(sliceWriter(raw[:headerLen]), opts.ByteOrder, header)
- if err != nil {
- return nil, fmt.Errorf("can't write header: %v", err)
- }
-
- return raw, nil
-}
-
type sliceWriter []byte
func (sw sliceWriter) Write(p []byte) (int, error) {
@@ -532,12 +595,31 @@ func (sw sliceWriter) Write(p []byte) (int, error) {
return copy(sw, p), nil
}
+// nextTypeID returns the next unallocated type ID or an error if there are no
+// more type IDs.
+func (s *Spec) nextTypeID() (TypeID, error) {
+ id := s.firstTypeID + TypeID(len(s.types))
+ if id < s.firstTypeID {
+ return 0, fmt.Errorf("no more type IDs")
+ }
+ return id, nil
+}
+
// TypeByID returns the BTF Type with the given type ID.
//
// Returns an error wrapping ErrNotFound if a Type with the given ID
// does not exist in the Spec.
func (s *Spec) TypeByID(id TypeID) (Type, error) {
- return s.types.ByID(id)
+ if id < s.firstTypeID {
+ return nil, fmt.Errorf("look up type with ID %d (first ID is %d): %w", id, s.firstTypeID, ErrNotFound)
+ }
+
+ index := int(id - s.firstTypeID)
+ if index >= len(s.types) {
+ return nil, fmt.Errorf("look up type with ID %d: %w", id, ErrNotFound)
+ }
+
+ return s.types[index], nil
}
// TypeID returns the ID for a given Type.
@@ -598,17 +680,19 @@ func (s *Spec) AnyTypeByName(name string) (Type, error) {
return types[0], nil
}
-// TypeByName searches for a Type with a specific name. Since multiple
-// Types with the same name can exist, the parameter typ is taken to
-// narrow down the search in case of a clash.
+// TypeByName searches for a Type with a specific name. Since multiple Types
+// with the same name can exist, the parameter typ is taken to narrow down the
+// search in case of a clash.
//
-// typ must be a non-nil pointer to an implementation of a Type.
-// On success, the address of the found Type will be copied to typ.
+// typ must be a non-nil pointer to an implementation of a Type. On success, the
+// address of the found Type will be copied to typ.
//
-// Returns an error wrapping ErrNotFound if no matching
-// Type exists in the Spec. If multiple candidates are found,
-// an error is returned.
+// Returns an error wrapping ErrNotFound if no matching Type exists in the Spec.
+// Returns an error wrapping ErrMultipleTypes if multiple candidates are found.
func (s *Spec) TypeByName(name string, typ interface{}) error {
+ typeInterface := reflect.TypeOf((*Type)(nil)).Elem()
+
+ // typ may be **T or *Type
typValue := reflect.ValueOf(typ)
if typValue.Kind() != reflect.Ptr {
return fmt.Errorf("%T is not a pointer", typ)
@@ -620,7 +704,12 @@ func (s *Spec) TypeByName(name string, typ interface{}) error {
}
wanted := typPtr.Type()
- if !wanted.AssignableTo(reflect.TypeOf((*Type)(nil)).Elem()) {
+ if wanted == typeInterface {
+ // This is *Type. Unwrap the value's type.
+ wanted = typPtr.Elem().Type()
+ }
+
+ if !wanted.AssignableTo(typeInterface) {
return fmt.Errorf("%T does not satisfy Type interface", typ)
}
@@ -636,14 +725,14 @@ func (s *Spec) TypeByName(name string, typ interface{}) error {
}
if candidate != nil {
- return fmt.Errorf("type %s: multiple candidates for %T", name, typ)
+ return fmt.Errorf("type %s(%T): %w", name, typ, ErrMultipleMatches)
}
candidate = typ
}
if candidate == nil {
- return fmt.Errorf("type %s: %w", name, ErrNotFound)
+ return fmt.Errorf("%s %s: %w", wanted, name, ErrNotFound)
}
typPtr.Set(reflect.ValueOf(candidate))
@@ -656,12 +745,12 @@ func (s *Spec) TypeByName(name string, typ interface{}) error {
// Types from base are used to resolve references in the split BTF.
// The returned Spec only contains types from the split BTF, not from the base.
func LoadSplitSpecFromReader(r io.ReaderAt, base *Spec) (*Spec, error) {
- return loadRawSpec(r, internal.NativeEndian, base.types, base.strings)
+ return loadRawSpec(r, internal.NativeEndian, base)
}
// TypesIterator iterates over types of a given spec.
type TypesIterator struct {
- spec *Spec
+ types []Type
index int
// The last visited type in the spec.
Type Type
@@ -669,229 +758,112 @@ type TypesIterator struct {
// Iterate returns the types iterator.
func (s *Spec) Iterate() *TypesIterator {
- return &TypesIterator{spec: s, index: 0}
+ // We share the backing array of types with the Spec. This is safe since
+ // we don't allow deletion or shuffling of types.
+ return &TypesIterator{types: s.types, index: 0}
}
// Next returns true as long as there are any remaining types.
func (iter *TypesIterator) Next() bool {
- if len(iter.spec.types) <= iter.index {
+ if len(iter.types) <= iter.index {
return false
}
- iter.Type = iter.spec.types[iter.index]
+ iter.Type = iter.types[iter.index]
iter.index++
return true
}
-// Handle is a reference to BTF loaded into the kernel.
-type Handle struct {
- fd *sys.FD
-
- // Size of the raw BTF in bytes.
- size uint32
-}
-
-// NewHandle loads BTF into the kernel.
-//
-// Returns ErrNotSupported if BTF is not supported.
-func NewHandle(spec *Spec) (*Handle, error) {
- if err := haveBTF(); err != nil {
- return nil, err
- }
-
- if spec.byteOrder != internal.NativeEndian {
- return nil, fmt.Errorf("can't load %s BTF on %s", spec.byteOrder, internal.NativeEndian)
- }
-
- btf, err := spec.marshal(marshalOpts{
- ByteOrder: internal.NativeEndian,
- StripFuncLinkage: haveFuncLinkage() != nil,
- })
- if err != nil {
- return nil, fmt.Errorf("can't marshal BTF: %w", err)
- }
-
- if uint64(len(btf)) > math.MaxUint32 {
- return nil, errors.New("BTF exceeds the maximum size")
+// haveBTF attempts to load a BTF blob containing an Int. It should pass on any
+// kernel that supports BPF_BTF_LOAD.
+var haveBTF = internal.NewFeatureTest("BTF", "4.18", func() error {
+ // 0-length anonymous integer
+ err := probeBTF(&Int{})
+ if errors.Is(err, unix.EINVAL) || errors.Is(err, unix.EPERM) {
+ return internal.ErrNotSupported
}
+ return err
+})
- attr := &sys.BtfLoadAttr{
- Btf: sys.NewSlicePointer(btf),
- BtfSize: uint32(len(btf)),
+// haveMapBTF attempts to load a minimal BTF blob containing a Var. It is
+// used as a proxy for .bss, .data and .rodata map support, which generally
+// come with a Var and Datasec. These were introduced in Linux 5.2.
+var haveMapBTF = internal.NewFeatureTest("Map BTF (Var/Datasec)", "5.2", func() error {
+ if err := haveBTF(); err != nil {
+ return err
}
- fd, err := sys.BtfLoad(attr)
- if err != nil {
- logBuf := make([]byte, 64*1024)
- attr.BtfLogBuf = sys.NewSlicePointer(logBuf)
- attr.BtfLogSize = uint32(len(logBuf))
- attr.BtfLogLevel = 1
- // NB: The syscall will never return ENOSPC as of 5.18-rc4.
- _, _ = sys.BtfLoad(attr)
- return nil, internal.ErrorWithLog(err, logBuf)
+ v := &Var{
+ Name: "a",
+ Type: &Pointer{(*Void)(nil)},
}
- return &Handle{fd, attr.BtfSize}, nil
-}
-
-// NewHandleFromID returns the BTF handle for a given id.
-//
-// Prefer calling [ebpf.Program.Handle] or [ebpf.Map.Handle] if possible.
-//
-// Returns ErrNotExist, if there is no BTF with the given id.
-//
-// Requires CAP_SYS_ADMIN.
-func NewHandleFromID(id ID) (*Handle, error) {
- fd, err := sys.BtfGetFdById(&sys.BtfGetFdByIdAttr{
- Id: uint32(id),
- })
- if err != nil {
- return nil, fmt.Errorf("get FD for ID %d: %w", id, err)
+ err := probeBTF(v)
+ if errors.Is(err, unix.EINVAL) || errors.Is(err, unix.EPERM) {
+ // Treat both EINVAL and EPERM as not supported: creating the map may still
+ // succeed without Btf* attrs.
+ return internal.ErrNotSupported
}
+ return err
+})
- info, err := newHandleInfoFromFD(fd)
- if err != nil {
- _ = fd.Close()
- return nil, err
+// haveProgBTF attempts to load a BTF blob containing a Func and FuncProto. It
+// is used as a proxy for ext_info (func_info) support, which depends on
+// Func(Proto) by definition.
+var haveProgBTF = internal.NewFeatureTest("Program BTF (func/line_info)", "5.0", func() error {
+ if err := haveBTF(); err != nil {
+ return err
}
- return &Handle{fd, info.size}, nil
-}
-
-// Spec parses the kernel BTF into Go types.
-//
-// base is used to decode split BTF and may be nil.
-func (h *Handle) Spec(base *Spec) (*Spec, error) {
- var btfInfo sys.BtfInfo
- btfBuffer := make([]byte, h.size)
- btfInfo.Btf, btfInfo.BtfSize = sys.NewSlicePointerLen(btfBuffer)
-
- if err := sys.ObjInfo(h.fd, &btfInfo); err != nil {
- return nil, err
+ fn := &Func{
+ Name: "a",
+ Type: &FuncProto{Return: (*Void)(nil)},
}
- var baseTypes types
- var baseStrings *stringTable
- if base != nil {
- baseTypes = base.types
- baseStrings = base.strings
+ err := probeBTF(fn)
+ if errors.Is(err, unix.EINVAL) || errors.Is(err, unix.EPERM) {
+ return internal.ErrNotSupported
}
+ return err
+})
- return loadRawSpec(bytes.NewReader(btfBuffer), internal.NativeEndian, baseTypes, baseStrings)
-}
-
-// Close destroys the handle.
-//
-// Subsequent calls to FD will return an invalid value.
-func (h *Handle) Close() error {
- if h == nil {
- return nil
+var haveFuncLinkage = internal.NewFeatureTest("BTF func linkage", "5.6", func() error {
+ if err := haveProgBTF(); err != nil {
+ return err
}
- return h.fd.Close()
-}
-
-// FD returns the file descriptor for the handle.
-func (h *Handle) FD() int {
- return h.fd.Int()
-}
-
-// Info returns metadata about the handle.
-func (h *Handle) Info() (*HandleInfo, error) {
- return newHandleInfoFromFD(h.fd)
-}
-
-func marshalBTF(types interface{}, strings []byte, bo binary.ByteOrder) []byte {
- const minHeaderLength = 24
-
- typesLen := uint32(binary.Size(types))
- header := btfHeader{
- Magic: btfMagic,
- Version: 1,
- HdrLen: minHeaderLength,
- TypeOff: 0,
- TypeLen: typesLen,
- StringOff: typesLen,
- StringLen: uint32(len(strings)),
+ fn := &Func{
+ Name: "a",
+ Type: &FuncProto{Return: (*Void)(nil)},
+ Linkage: GlobalFunc,
}
- buf := new(bytes.Buffer)
- _ = binary.Write(buf, bo, &header)
- _ = binary.Write(buf, bo, types)
- buf.Write(strings)
-
- return buf.Bytes()
-}
-
-var haveBTF = internal.FeatureTest("BTF", "5.1", func() error {
- var (
- types struct {
- Integer btfType
- Var btfType
- btfVar struct{ Linkage uint32 }
- }
- strings = []byte{0, 'a', 0}
- )
-
- // We use a BTF_KIND_VAR here, to make sure that
- // the kernel understands BTF at least as well as we
- // do. BTF_KIND_VAR was introduced ~5.1.
- types.Integer.SetKind(kindPointer)
- types.Var.NameOff = 1
- types.Var.SetKind(kindVar)
- types.Var.SizeType = 1
-
- btf := marshalBTF(&types, strings, internal.NativeEndian)
-
- fd, err := sys.BtfLoad(&sys.BtfLoadAttr{
- Btf: sys.NewSlicePointer(btf),
- BtfSize: uint32(len(btf)),
- })
- if errors.Is(err, unix.EINVAL) || errors.Is(err, unix.EPERM) {
- // Treat both EINVAL and EPERM as not supported: loading the program
- // might still succeed without BTF.
+ err := probeBTF(fn)
+ if errors.Is(err, unix.EINVAL) {
return internal.ErrNotSupported
}
+ return err
+})
+
+func probeBTF(typ Type) error {
+ b, err := NewBuilder([]Type{typ})
if err != nil {
return err
}
- fd.Close()
- return nil
-})
-
-var haveFuncLinkage = internal.FeatureTest("BTF func linkage", "5.6", func() error {
- if err := haveBTF(); err != nil {
+ buf, err := b.Marshal(nil, nil)
+ if err != nil {
return err
}
- var (
- types struct {
- FuncProto btfType
- Func btfType
- }
- strings = []byte{0, 'a', 0}
- )
-
- types.FuncProto.SetKind(kindFuncProto)
- types.Func.SetKind(kindFunc)
- types.Func.SizeType = 1 // aka FuncProto
- types.Func.NameOff = 1
- types.Func.SetLinkage(GlobalFunc)
-
- btf := marshalBTF(&types, strings, internal.NativeEndian)
-
fd, err := sys.BtfLoad(&sys.BtfLoadAttr{
- Btf: sys.NewSlicePointer(btf),
- BtfSize: uint32(len(btf)),
+ Btf: sys.NewSlicePointer(buf),
+ BtfSize: uint32(len(buf)),
})
- if errors.Is(err, unix.EINVAL) {
- return internal.ErrNotSupported
- }
- if err != nil {
- return err
+
+ if err == nil {
+ fd.Close()
}
- fd.Close()
- return nil
-})
+ return err
+}
diff --git a/vendor/github.com/cilium/ebpf/btf/btf_types.go b/vendor/github.com/cilium/ebpf/btf/btf_types.go
index 4810180494e6..a253b7c9b9e7 100644
--- a/vendor/github.com/cilium/ebpf/btf/btf_types.go
+++ b/vendor/github.com/cilium/ebpf/btf/btf_types.go
@@ -4,35 +4,41 @@ import (
"encoding/binary"
"fmt"
"io"
+ "unsafe"
)
-//go:generate stringer -linecomment -output=btf_types_string.go -type=FuncLinkage,VarLinkage
+//go:generate stringer -linecomment -output=btf_types_string.go -type=FuncLinkage,VarLinkage,btfKind
// btfKind describes a Type.
type btfKind uint8
// Equivalents of the BTF_KIND_* constants.
const (
- kindUnknown btfKind = iota
- kindInt
- kindPointer
- kindArray
- kindStruct
- kindUnion
- kindEnum
- kindForward
- kindTypedef
- kindVolatile
- kindConst
- kindRestrict
+ kindUnknown btfKind = iota // Unknown
+ kindInt // Int
+ kindPointer // Pointer
+ kindArray // Array
+ kindStruct // Struct
+ kindUnion // Union
+ kindEnum // Enum
+ kindForward // Forward
+ kindTypedef // Typedef
+ kindVolatile // Volatile
+ kindConst // Const
+ kindRestrict // Restrict
// Added ~4.20
- kindFunc
- kindFuncProto
+ kindFunc // Func
+ kindFuncProto // FuncProto
// Added ~5.1
- kindVar
- kindDatasec
+ kindVar // Var
+ kindDatasec // Datasec
// Added ~5.13
- kindFloat
+ kindFloat // Float
+ // Added 5.16
+ kindDeclTag // DeclTag
+ kindTypeTag // TypeTag
+ // Added 6.0
+ kindEnum64 // Enum64
)
// FuncLinkage describes BTF function linkage metadata.
@@ -63,6 +69,8 @@ const (
btfTypeKindFlagMask = 1
)
+var btfTypeLen = binary.Size(btfType{})
+
// btfType is equivalent to struct btf_type in Documentation/bpf/btf.rst.
type btfType struct {
NameOff uint32
@@ -85,47 +93,6 @@ type btfType struct {
SizeType uint32
}
-func (k btfKind) String() string {
- switch k {
- case kindUnknown:
- return "Unknown"
- case kindInt:
- return "Integer"
- case kindPointer:
- return "Pointer"
- case kindArray:
- return "Array"
- case kindStruct:
- return "Struct"
- case kindUnion:
- return "Union"
- case kindEnum:
- return "Enumeration"
- case kindForward:
- return "Forward"
- case kindTypedef:
- return "Typedef"
- case kindVolatile:
- return "Volatile"
- case kindConst:
- return "Const"
- case kindRestrict:
- return "Restrict"
- case kindFunc:
- return "Function"
- case kindFuncProto:
- return "Function Proto"
- case kindVar:
- return "Variable"
- case kindDatasec:
- return "Section"
- case kindFloat:
- return "Float"
- default:
- return fmt.Sprintf("Unknown (%d)", k)
- }
-}
-
func mask(len uint32) uint32 {
return (1 << len) - 1
}
@@ -164,10 +131,43 @@ func (bt *btfType) SetVlen(vlen int) {
bt.setInfo(uint32(vlen), btfTypeVlenMask, btfTypeVlenShift)
}
-func (bt *btfType) KindFlag() bool {
+func (bt *btfType) kindFlagBool() bool {
return bt.info(btfTypeKindFlagMask, btfTypeKindFlagShift) == 1
}
+func (bt *btfType) setKindFlagBool(set bool) {
+ var value uint32
+ if set {
+ value = 1
+ }
+ bt.setInfo(value, btfTypeKindFlagMask, btfTypeKindFlagShift)
+}
+
+// Bitfield returns true if the struct or union contain a bitfield.
+func (bt *btfType) Bitfield() bool {
+ return bt.kindFlagBool()
+}
+
+func (bt *btfType) SetBitfield(isBitfield bool) {
+ bt.setKindFlagBool(isBitfield)
+}
+
+func (bt *btfType) FwdKind() FwdKind {
+ return FwdKind(bt.info(btfTypeKindFlagMask, btfTypeKindFlagShift))
+}
+
+func (bt *btfType) SetFwdKind(kind FwdKind) {
+ bt.setInfo(uint32(kind), btfTypeKindFlagMask, btfTypeKindFlagShift)
+}
+
+func (bt *btfType) Signed() bool {
+ return bt.kindFlagBool()
+}
+
+func (bt *btfType) SetSigned(signed bool) {
+ bt.setKindFlagBool(signed)
+}
+
func (bt *btfType) Linkage() FuncLinkage {
return FuncLinkage(bt.info(btfTypeVlenMask, btfTypeVlenShift))
}
@@ -181,6 +181,10 @@ func (bt *btfType) Type() TypeID {
return TypeID(bt.SizeType)
}
+func (bt *btfType) SetType(id TypeID) {
+ bt.SizeType = uint32(id)
+}
+
func (bt *btfType) Size() uint32 {
// TODO: Panic here if wrong kind?
return bt.SizeType
@@ -190,13 +194,22 @@ func (bt *btfType) SetSize(size uint32) {
bt.SizeType = size
}
+func (bt *btfType) Marshal(w io.Writer, bo binary.ByteOrder) error {
+ buf := make([]byte, unsafe.Sizeof(*bt))
+ bo.PutUint32(buf[0:], bt.NameOff)
+ bo.PutUint32(buf[4:], bt.Info)
+ bo.PutUint32(buf[8:], bt.SizeType)
+ _, err := w.Write(buf)
+ return err
+}
+
type rawType struct {
btfType
data interface{}
}
func (rt *rawType) Marshal(w io.Writer, bo binary.ByteOrder) error {
- if err := binary.Write(w, bo, &rt.btfType); err != nil {
+ if err := rt.btfType.Marshal(w, bo); err != nil {
return err
}
@@ -209,11 +222,11 @@ func (rt *rawType) Marshal(w io.Writer, bo binary.ByteOrder) error {
// btfInt encodes additional data for integers.
//
-// ? ? ? ? e e e e o o o o o o o o ? ? ? ? ? ? ? ? b b b b b b b b
-// ? = undefined
-// e = encoding
-// o = offset (bitfields?)
-// b = bits (bitfields)
+// ? ? ? ? e e e e o o o o o o o o ? ? ? ? ? ? ? ? b b b b b b b b
+// ? = undefined
+// e = encoding
+// o = offset (bitfields?)
+// b = bits (bitfields)
type btfInt struct {
Raw uint32
}
@@ -275,7 +288,13 @@ type btfVariable struct {
type btfEnum struct {
NameOff uint32
- Val int32
+ Val uint32
+}
+
+type btfEnum64 struct {
+ NameOff uint32
+ ValLo32 uint32
+ ValHi32 uint32
}
type btfParam struct {
@@ -283,12 +302,16 @@ type btfParam struct {
Type TypeID
}
+type btfDeclTag struct {
+ ComponentIdx uint32
+}
+
func readTypes(r io.Reader, bo binary.ByteOrder, typeLen uint32) ([]rawType, error) {
var header btfType
// because of the interleaving between types and struct members it is difficult to
// precompute the numbers of raw types this will parse
// this "guess" is a good first estimation
- sizeOfbtfType := uintptr(binary.Size(btfType{}))
+ sizeOfbtfType := uintptr(btfTypeLen)
tyMaxCount := uintptr(typeLen) / sizeOfbtfType / 2
types := make([]rawType, 0, tyMaxCount)
@@ -325,6 +348,11 @@ func readTypes(r io.Reader, bo binary.ByteOrder, typeLen uint32) ([]rawType, err
case kindDatasec:
data = make([]btfVarSecinfo, header.Vlen())
case kindFloat:
+ case kindDeclTag:
+ data = new(btfDeclTag)
+ case kindTypeTag:
+ case kindEnum64:
+ data = make([]btfEnum64, header.Vlen())
default:
return nil, fmt.Errorf("type id %v: unknown kind: %v", id, header.Kind())
}
diff --git a/vendor/github.com/cilium/ebpf/btf/btf_types_string.go b/vendor/github.com/cilium/ebpf/btf/btf_types_string.go
index 0e0c17d68ba9..b7a1b80d1518 100644
--- a/vendor/github.com/cilium/ebpf/btf/btf_types_string.go
+++ b/vendor/github.com/cilium/ebpf/btf/btf_types_string.go
@@ -1,4 +1,4 @@
-// Code generated by "stringer -linecomment -output=btf_types_string.go -type=FuncLinkage,VarLinkage"; DO NOT EDIT.
+// Code generated by "stringer -linecomment -output=btf_types_string.go -type=FuncLinkage,VarLinkage,btfKind"; DO NOT EDIT.
package btf
@@ -42,3 +42,39 @@ func (i VarLinkage) String() string {
}
return _VarLinkage_name[_VarLinkage_index[i]:_VarLinkage_index[i+1]]
}
+func _() {
+ // An "invalid array index" compiler error signifies that the constant values have changed.
+ // Re-run the stringer command to generate them again.
+ var x [1]struct{}
+ _ = x[kindUnknown-0]
+ _ = x[kindInt-1]
+ _ = x[kindPointer-2]
+ _ = x[kindArray-3]
+ _ = x[kindStruct-4]
+ _ = x[kindUnion-5]
+ _ = x[kindEnum-6]
+ _ = x[kindForward-7]
+ _ = x[kindTypedef-8]
+ _ = x[kindVolatile-9]
+ _ = x[kindConst-10]
+ _ = x[kindRestrict-11]
+ _ = x[kindFunc-12]
+ _ = x[kindFuncProto-13]
+ _ = x[kindVar-14]
+ _ = x[kindDatasec-15]
+ _ = x[kindFloat-16]
+ _ = x[kindDeclTag-17]
+ _ = x[kindTypeTag-18]
+ _ = x[kindEnum64-19]
+}
+
+const _btfKind_name = "UnknownIntPointerArrayStructUnionEnumForwardTypedefVolatileConstRestrictFuncFuncProtoVarDatasecFloatDeclTagTypeTagEnum64"
+
+var _btfKind_index = [...]uint8{0, 7, 10, 17, 22, 28, 33, 37, 44, 51, 59, 64, 72, 76, 85, 88, 95, 100, 107, 114, 120}
+
+func (i btfKind) String() string {
+ if i >= btfKind(len(_btfKind_index)-1) {
+ return "btfKind(" + strconv.FormatInt(int64(i), 10) + ")"
+ }
+ return _btfKind_name[_btfKind_index[i]:_btfKind_index[i+1]]
+}
diff --git a/vendor/github.com/cilium/ebpf/btf/core.go b/vendor/github.com/cilium/ebpf/btf/core.go
index c48754809355..a5c40d36af46 100644
--- a/vendor/github.com/cilium/ebpf/btf/core.go
+++ b/vendor/github.com/cilium/ebpf/btf/core.go
@@ -156,16 +156,25 @@ func (k coreKind) String() string {
}
}
-// CORERelocate calculates the difference in types between local and target.
+// CORERelocate calculates changes needed to adjust eBPF instructions for differences
+// in types.
//
// Returns a list of fixups which can be applied to instructions to make them
// match the target type(s).
//
// Fixups are returned in the order of relos, e.g. fixup[i] is the solution
// for relos[i].
-func CORERelocate(local, target *Spec, relos []*CORERelocation) ([]COREFixup, error) {
- if local.byteOrder != target.byteOrder {
- return nil, fmt.Errorf("can't relocate %s against %s", local.byteOrder, target.byteOrder)
+func CORERelocate(relos []*CORERelocation, target *Spec, bo binary.ByteOrder) ([]COREFixup, error) {
+ if target == nil {
+ var err error
+ target, _, err = kernelSpec()
+ if err != nil {
+ return nil, fmt.Errorf("load kernel spec: %w", err)
+ }
+ }
+
+ if bo != target.byteOrder {
+ return nil, fmt.Errorf("can't relocate %s against %s", bo, target.byteOrder)
}
type reloGroup struct {
@@ -185,15 +194,14 @@ func CORERelocate(local, target *Spec, relos []*CORERelocation) ([]COREFixup, er
return nil, fmt.Errorf("%s: unexpected accessor %v", relo.kind, relo.accessor)
}
- id, err := local.TypeID(relo.typ)
- if err != nil {
- return nil, fmt.Errorf("%s: %w", relo.kind, err)
- }
-
result[i] = COREFixup{
- kind: relo.kind,
- local: uint32(id),
- target: uint32(id),
+ kind: relo.kind,
+ local: uint32(relo.id),
+ // NB: Using relo.id as the target here is incorrect, since
+ // it doesn't match the BTF we generate on the fly. This isn't
+ // too bad for now since there are no uses of the local type ID
+ // in the kernel, yet.
+ target: uint32(relo.id),
}
continue
}
@@ -214,7 +222,7 @@ func CORERelocate(local, target *Spec, relos []*CORERelocation) ([]COREFixup, er
}
targets := target.namedTypes[newEssentialName(localTypeName)]
- fixups, err := coreCalculateFixups(local, target, localType, targets, group.relos)
+ fixups, err := coreCalculateFixups(group.relos, target, targets, bo)
if err != nil {
return nil, fmt.Errorf("relocate %s: %w", localType, err)
}
@@ -229,34 +237,29 @@ func CORERelocate(local, target *Spec, relos []*CORERelocation) ([]COREFixup, er
var errAmbiguousRelocation = errors.New("ambiguous relocation")
var errImpossibleRelocation = errors.New("impossible relocation")
+var errIncompatibleTypes = errors.New("incompatible types")
-// coreCalculateFixups calculates the fixups for the given relocations using
-// the "best" target.
+// coreCalculateFixups finds the target type that best matches all relocations.
+//
+// All relos must target the same type.
//
// The best target is determined by scoring: the less poisoning we have to do
// the better the target is.
-func coreCalculateFixups(localSpec, targetSpec *Spec, local Type, targets []Type, relos []*CORERelocation) ([]COREFixup, error) {
- localID, err := localSpec.TypeID(local)
- if err != nil {
- return nil, fmt.Errorf("local type ID: %w", err)
- }
- local = Copy(local, UnderlyingType)
-
+func coreCalculateFixups(relos []*CORERelocation, targetSpec *Spec, targets []Type, bo binary.ByteOrder) ([]COREFixup, error) {
bestScore := len(relos)
var bestFixups []COREFixup
- for i := range targets {
- targetID, err := targetSpec.TypeID(targets[i])
+ for _, target := range targets {
+ targetID, err := targetSpec.TypeID(target)
if err != nil {
return nil, fmt.Errorf("target type ID: %w", err)
}
- target := Copy(targets[i], UnderlyingType)
score := 0 // lower is better
fixups := make([]COREFixup, 0, len(relos))
for _, relo := range relos {
- fixup, err := coreCalculateFixup(localSpec.byteOrder, local, localID, target, targetID, relo)
+ fixup, err := coreCalculateFixup(relo, target, targetID, bo)
if err != nil {
- return nil, fmt.Errorf("target %s: %w", target, err)
+ return nil, fmt.Errorf("target %s: %s: %w", target, relo.kind, err)
}
if fixup.poison || fixup.isNonExistant() {
score++
@@ -303,9 +306,11 @@ func coreCalculateFixups(localSpec, targetSpec *Spec, local Type, targets []Type
return bestFixups, nil
}
+var errNoSignedness = errors.New("no signedness")
+
// coreCalculateFixup calculates the fixup for a single local type, target type
// and relocation.
-func coreCalculateFixup(byteOrder binary.ByteOrder, local Type, localID TypeID, target Type, targetID TypeID, relo *CORERelocation) (COREFixup, error) {
+func coreCalculateFixup(relo *CORERelocation, target Type, targetID TypeID, bo binary.ByteOrder) (COREFixup, error) {
fixup := func(local, target uint32) (COREFixup, error) {
return COREFixup{kind: relo.kind, local: local, target: target}, nil
}
@@ -320,18 +325,20 @@ func coreCalculateFixup(byteOrder binary.ByteOrder, local Type, localID TypeID,
}
zero := COREFixup{}
+ local := relo.typ
+
switch relo.kind {
case reloTypeIDTarget, reloTypeSize, reloTypeExists:
if len(relo.accessor) > 1 || relo.accessor[0] != 0 {
- return zero, fmt.Errorf("%s: unexpected accessor %v", relo.kind, relo.accessor)
+ return zero, fmt.Errorf("unexpected accessor %v", relo.accessor)
}
err := coreAreTypesCompatible(local, target)
- if errors.Is(err, errImpossibleRelocation) {
+ if errors.Is(err, errIncompatibleTypes) {
return poison()
}
if err != nil {
- return zero, fmt.Errorf("relocation %s: %w", relo.kind, err)
+ return zero, err
}
switch relo.kind {
@@ -339,7 +346,7 @@ func coreCalculateFixup(byteOrder binary.ByteOrder, local Type, localID TypeID,
return fixup(1, 1)
case reloTypeIDTarget:
- return fixup(uint32(localID), uint32(targetID))
+ return fixup(uint32(relo.id), uint32(targetID))
case reloTypeSize:
localSize, err := Sizeof(local)
@@ -361,7 +368,7 @@ func coreCalculateFixup(byteOrder binary.ByteOrder, local Type, localID TypeID,
return poison()
}
if err != nil {
- return zero, fmt.Errorf("relocation %s: %w", relo.kind, err)
+ return zero, err
}
switch relo.kind {
@@ -372,21 +379,8 @@ func coreCalculateFixup(byteOrder binary.ByteOrder, local Type, localID TypeID,
return fixup(uint32(localValue.Value), uint32(targetValue.Value))
}
- case reloFieldSigned:
- switch local.(type) {
- case *Enum:
- return fixup(1, 1)
- case *Int:
- return fixup(
- uint32(local.(*Int).Encoding&Signed),
- uint32(target.(*Int).Encoding&Signed),
- )
- default:
- return fixupWithoutValidation(0, 0)
- }
-
- case reloFieldByteOffset, reloFieldByteSize, reloFieldExists, reloFieldLShiftU64, reloFieldRShiftU64:
- if _, ok := target.(*Fwd); ok {
+ case reloFieldByteOffset, reloFieldByteSize, reloFieldExists, reloFieldLShiftU64, reloFieldRShiftU64, reloFieldSigned:
+ if _, ok := as[*Fwd](target); ok {
// We can't relocate fields using a forward declaration, so
// skip it. If a non-forward declaration is present in the BTF
// we'll find it in one of the other iterations.
@@ -398,7 +392,7 @@ func coreCalculateFixup(byteOrder binary.ByteOrder, local Type, localID TypeID,
return poison()
}
if err != nil {
- return zero, fmt.Errorf("target %s: %w", target, err)
+ return zero, err
}
maybeSkipValidation := func(f COREFixup, err error) (COREFixup, error) {
@@ -427,7 +421,7 @@ func coreCalculateFixup(byteOrder binary.ByteOrder, local Type, localID TypeID,
case reloFieldLShiftU64:
var target uint32
- if byteOrder == binary.LittleEndian {
+ if bo == binary.LittleEndian {
targetSize, err := targetField.sizeBits()
if err != nil {
return zero, err
@@ -451,10 +445,40 @@ func coreCalculateFixup(byteOrder binary.ByteOrder, local Type, localID TypeID,
}
return fixupWithoutValidation(0, uint32(64-targetSize))
+
+ case reloFieldSigned:
+ switch local := UnderlyingType(localField.Type).(type) {
+ case *Enum:
+ target, ok := as[*Enum](targetField.Type)
+ if !ok {
+ return zero, fmt.Errorf("target isn't *Enum but %T", targetField.Type)
+ }
+
+ return fixup(boolToUint32(local.Signed), boolToUint32(target.Signed))
+ case *Int:
+ target, ok := as[*Int](targetField.Type)
+ if !ok {
+ return zero, fmt.Errorf("target isn't *Int but %T", targetField.Type)
+ }
+
+ return fixup(
+ uint32(local.Encoding&Signed),
+ uint32(target.Encoding&Signed),
+ )
+ default:
+ return zero, fmt.Errorf("type %T: %w", local, errNoSignedness)
+ }
}
}
- return zero, fmt.Errorf("relocation %s: %w", relo.kind, ErrNotSupported)
+ return zero, ErrNotSupported
+}
+
+func boolToUint32(val bool) uint32 {
+ if val {
+ return 1
+ }
+ return 0
}
/* coreAccessor contains a path through a struct. It contains at least one index.
@@ -516,7 +540,7 @@ func (ca coreAccessor) String() string {
}
func (ca coreAccessor) enumValue(t Type) (*EnumValue, error) {
- e, ok := t.(*Enum)
+ e, ok := as[*Enum](t)
if !ok {
return nil, fmt.Errorf("not an enum: %s", t)
}
@@ -536,9 +560,9 @@ func (ca coreAccessor) enumValue(t Type) (*EnumValue, error) {
// coreField represents the position of a "child" of a composite type from the
// start of that type.
//
-// /- start of composite
-// | offset * 8 | bitfieldOffset | bitfieldSize | ... |
-// \- start of field end of field -/
+// /- start of composite
+// | offset * 8 | bitfieldOffset | bitfieldSize | ... |
+// \- start of field end of field -/
type coreField struct {
Type Type
@@ -555,6 +579,10 @@ type coreField struct {
}
func (cf *coreField) adjustOffsetToNthElement(n int) error {
+ if n == 0 {
+ return nil
+ }
+
size, err := Sizeof(cf.Type)
if err != nil {
return err
@@ -597,7 +625,7 @@ func (cf *coreField) sizeBits() (Bits, error) {
// between kernel versions. Synthesise the size to make the shifts work.
size, err := Sizeof(cf.Type)
if err != nil {
- return 0, nil
+ return 0, err
}
return Bits(size * 8), nil
}
@@ -611,6 +639,10 @@ func coreFindField(localT Type, localAcc coreAccessor, targetT Type) (coreField,
local := coreField{Type: localT}
target := coreField{Type: targetT}
+ if err := coreAreMembersCompatible(local.Type, target.Type); err != nil {
+ return coreField{}, coreField{}, fmt.Errorf("fields: %w", err)
+ }
+
// The first index is used to offset a pointer of the base type like
// when accessing an array.
if err := local.adjustOffsetToNthElement(localAcc[0]); err != nil {
@@ -621,13 +653,9 @@ func coreFindField(localT Type, localAcc coreAccessor, targetT Type) (coreField,
return coreField{}, coreField{}, err
}
- if err := coreAreMembersCompatible(local.Type, target.Type); err != nil {
- return coreField{}, coreField{}, fmt.Errorf("fields: %w", err)
- }
-
var localMaybeFlex, targetMaybeFlex bool
for i, acc := range localAcc[1:] {
- switch localType := local.Type.(type) {
+ switch localType := UnderlyingType(local.Type).(type) {
case composite:
// For composite types acc is used to find the field in the local type,
// and then we try to find a field in target with the same name.
@@ -638,21 +666,21 @@ func coreFindField(localT Type, localAcc coreAccessor, targetT Type) (coreField,
localMember := localMembers[acc]
if localMember.Name == "" {
- _, ok := localMember.Type.(composite)
+ localMemberType, ok := as[composite](localMember.Type)
if !ok {
return coreField{}, coreField{}, fmt.Errorf("unnamed field with type %s: %s", localMember.Type, ErrNotSupported)
}
// This is an anonymous struct or union, ignore it.
local = coreField{
- Type: localMember.Type,
+ Type: localMemberType,
offset: local.offset + localMember.Offset.Bytes(),
}
localMaybeFlex = false
continue
}
- targetType, ok := target.Type.(composite)
+ targetType, ok := as[composite](target.Type)
if !ok {
return coreField{}, coreField{}, fmt.Errorf("target not composite: %w", errImpossibleRelocation)
}
@@ -698,7 +726,7 @@ func coreFindField(localT Type, localAcc coreAccessor, targetT Type) (coreField,
case *Array:
// For arrays, acc is the index in the target.
- targetType, ok := target.Type.(*Array)
+ targetType, ok := as[*Array](target.Type)
if !ok {
return coreField{}, coreField{}, fmt.Errorf("target not array: %w", errImpossibleRelocation)
}
@@ -792,7 +820,7 @@ func coreFindMember(typ composite, name string) (Member, bool, error) {
continue
}
- comp, ok := member.Type.(composite)
+ comp, ok := as[composite](member.Type)
if !ok {
return Member{}, false, fmt.Errorf("anonymous non-composite type %T not allowed", member.Type)
}
@@ -811,7 +839,7 @@ func coreFindEnumValue(local Type, localAcc coreAccessor, target Type) (localVal
return nil, nil, err
}
- targetEnum, ok := target.(*Enum)
+ targetEnum, ok := as[*Enum](target)
if !ok {
return nil, nil, errImpossibleRelocation
}
@@ -828,6 +856,13 @@ func coreFindEnumValue(local Type, localAcc coreAccessor, target Type) (localVal
return nil, nil, errImpossibleRelocation
}
+// CheckTypeCompatibility checks local and target types for Compatibility according to CO-RE rules.
+//
+// Only layout compatibility is checked, ignoring names of the root type.
+func CheckTypeCompatibility(localType Type, targetType Type) error {
+ return coreAreTypesCompatible(localType, targetType)
+}
+
/* The comment below is from bpf_core_types_are_compat in libbpf.c:
*
* Check local and target types for compatibility. This check is used for
@@ -849,25 +884,26 @@ func coreFindEnumValue(local Type, localAcc coreAccessor, target Type) (localVal
* These rules are not set in stone and probably will be adjusted as we get
* more experience with using BPF CO-RE relocations.
*
- * Returns errImpossibleRelocation if types are not compatible.
+ * Returns errIncompatibleTypes if types are not compatible.
*/
func coreAreTypesCompatible(localType Type, targetType Type) error {
+
var (
localTs, targetTs typeDeque
l, t = &localType, &targetType
depth = 0
)
- for ; l != nil && t != nil; l, t = localTs.shift(), targetTs.shift() {
+ for ; l != nil && t != nil; l, t = localTs.Shift(), targetTs.Shift() {
if depth >= maxTypeDepth {
return errors.New("types are nested too deep")
}
- localType = *l
- targetType = *t
+ localType = UnderlyingType(*l)
+ targetType = UnderlyingType(*t)
if reflect.TypeOf(localType) != reflect.TypeOf(targetType) {
- return fmt.Errorf("type mismatch: %w", errImpossibleRelocation)
+ return fmt.Errorf("type mismatch: %w", errIncompatibleTypes)
}
switch lv := (localType).(type) {
@@ -876,18 +912,18 @@ func coreAreTypesCompatible(localType Type, targetType Type) error {
case *Pointer, *Array:
depth++
- localType.walk(&localTs)
- targetType.walk(&targetTs)
+ walkType(localType, localTs.Push)
+ walkType(targetType, targetTs.Push)
case *FuncProto:
tv := targetType.(*FuncProto)
if len(lv.Params) != len(tv.Params) {
- return fmt.Errorf("function param mismatch: %w", errImpossibleRelocation)
+ return fmt.Errorf("function param mismatch: %w", errIncompatibleTypes)
}
depth++
- localType.walk(&localTs)
- targetType.walk(&targetTs)
+ walkType(localType, localTs.Push)
+ walkType(targetType, targetTs.Push)
default:
return fmt.Errorf("unsupported type %T", localType)
@@ -931,6 +967,9 @@ func coreAreTypesCompatible(localType Type, targetType Type) error {
* Returns errImpossibleRelocation if the members are not compatible.
*/
func coreAreMembersCompatible(localType Type, targetType Type) error {
+ localType = UnderlyingType(localType)
+ targetType = UnderlyingType(targetType)
+
doNamesMatch := func(a, b string) error {
if a == "" || b == "" {
// allow anonymous and named type to match
diff --git a/vendor/github.com/cilium/ebpf/btf/ext_info.go b/vendor/github.com/cilium/ebpf/btf/ext_info.go
index 2c0e1afe299a..b764fb7bcc1b 100644
--- a/vendor/github.com/cilium/ebpf/btf/ext_info.go
+++ b/vendor/github.com/cilium/ebpf/btf/ext_info.go
@@ -24,7 +24,7 @@ type ExtInfos struct {
// loadExtInfosFromELF parses ext infos from the .BTF.ext section in an ELF.
//
// Returns an error wrapping ErrNotFound if no ext infos are present.
-func loadExtInfosFromELF(file *internal.SafeELFFile, ts types, strings *stringTable) (*ExtInfos, error) {
+func loadExtInfosFromELF(file *internal.SafeELFFile, spec *Spec) (*ExtInfos, error) {
section := file.Section(".BTF.ext")
if section == nil {
return nil, fmt.Errorf("btf ext infos: %w", ErrNotFound)
@@ -34,11 +34,11 @@ func loadExtInfosFromELF(file *internal.SafeELFFile, ts types, strings *stringTa
return nil, fmt.Errorf("compressed ext_info is not supported")
}
- return loadExtInfos(section.ReaderAt, file.ByteOrder, ts, strings)
+ return loadExtInfos(section.ReaderAt, file.ByteOrder, spec, spec.strings)
}
// loadExtInfos parses bare ext infos.
-func loadExtInfos(r io.ReaderAt, bo binary.ByteOrder, ts types, strings *stringTable) (*ExtInfos, error) {
+func loadExtInfos(r io.ReaderAt, bo binary.ByteOrder, spec *Spec, strings *stringTable) (*ExtInfos, error) {
// Open unbuffered section reader. binary.Read() calls io.ReadFull on
// the header structs, resulting in one syscall per header.
headerRd := io.NewSectionReader(r, 0, math.MaxInt64)
@@ -60,7 +60,7 @@ func loadExtInfos(r io.ReaderAt, bo binary.ByteOrder, ts types, strings *stringT
funcInfos := make(map[string][]funcInfo, len(btfFuncInfos))
for section, bfis := range btfFuncInfos {
- funcInfos[section], err = newFuncInfos(bfis, ts)
+ funcInfos[section], err = newFuncInfos(bfis, spec)
if err != nil {
return nil, fmt.Errorf("section %s: func infos: %w", section, err)
}
@@ -93,7 +93,7 @@ func loadExtInfos(r io.ReaderAt, bo binary.ByteOrder, ts types, strings *stringT
coreRelos := make(map[string][]coreRelocationInfo, len(btfCORERelos))
for section, brs := range btfCORERelos {
- coreRelos[section], err = newRelocationInfos(brs, ts, strings)
+ coreRelos[section], err = newRelocationInfos(brs, spec, strings)
if err != nil {
return nil, fmt.Errorf("section %s: CO-RE relocations: %w", section, err)
}
@@ -114,7 +114,7 @@ func (ei *ExtInfos) Assign(insns asm.Instructions, section string) {
iter := insns.Iterate()
for iter.Next() {
if len(funcInfos) > 0 && funcInfos[0].offset == iter.Offset {
- iter.Ins.Metadata.Set(funcInfoMeta{}, funcInfos[0].fn)
+ *iter.Ins = WithFuncMetadata(*iter.Ins, funcInfos[0].fn)
funcInfos = funcInfos[1:]
}
@@ -132,17 +132,37 @@ func (ei *ExtInfos) Assign(insns asm.Instructions, section string) {
// MarshalExtInfos encodes function and line info embedded in insns into kernel
// wire format.
-func MarshalExtInfos(insns asm.Instructions, typeID func(Type) (TypeID, error)) (funcInfos, lineInfos []byte, _ error) {
+//
+// Returns ErrNotSupported if the kernel doesn't support BTF-associated programs.
+func MarshalExtInfos(insns asm.Instructions) (_ *Handle, funcInfos, lineInfos []byte, _ error) {
+ // Bail out early if the kernel doesn't support Func(Proto). If this is the
+ // case, func_info will also be unsupported.
+ if err := haveProgBTF(); err != nil {
+ return nil, nil, nil, err
+ }
+
iter := insns.Iterate()
- var fiBuf, liBuf bytes.Buffer
for iter.Next() {
+ _, ok := iter.Ins.Source().(*Line)
+ fn := FuncMetadata(iter.Ins)
+ if ok || fn != nil {
+ goto marshal
+ }
+ }
+
+ return nil, nil, nil, nil
+
+marshal:
+ var b Builder
+ var fiBuf, liBuf bytes.Buffer
+ for {
if fn := FuncMetadata(iter.Ins); fn != nil {
fi := &funcInfo{
fn: fn,
offset: iter.Offset,
}
- if err := fi.marshal(&fiBuf, typeID); err != nil {
- return nil, nil, fmt.Errorf("write func info: %w", err)
+ if err := fi.marshal(&fiBuf, &b); err != nil {
+ return nil, nil, nil, fmt.Errorf("write func info: %w", err)
}
}
@@ -151,12 +171,18 @@ func MarshalExtInfos(insns asm.Instructions, typeID func(Type) (TypeID, error))
line: line,
offset: iter.Offset,
}
- if err := li.marshal(&liBuf); err != nil {
- return nil, nil, fmt.Errorf("write line info: %w", err)
+ if err := li.marshal(&liBuf, &b); err != nil {
+ return nil, nil, nil, fmt.Errorf("write line info: %w", err)
}
}
+
+ if !iter.Next() {
+ break
+ }
}
- return fiBuf.Bytes(), liBuf.Bytes(), nil
+
+ handle, err := NewHandle(&b)
+ return handle, fiBuf.Bytes(), liBuf.Bytes(), err
}
// btfExtHeader is found at the start of the .BTF.ext section.
@@ -311,8 +337,8 @@ type bpfFuncInfo struct {
TypeID TypeID
}
-func newFuncInfo(fi bpfFuncInfo, ts types) (*funcInfo, error) {
- typ, err := ts.ByID(fi.TypeID)
+func newFuncInfo(fi bpfFuncInfo, spec *Spec) (*funcInfo, error) {
+ typ, err := spec.TypeByID(fi.TypeID)
if err != nil {
return nil, err
}
@@ -333,10 +359,10 @@ func newFuncInfo(fi bpfFuncInfo, ts types) (*funcInfo, error) {
}, nil
}
-func newFuncInfos(bfis []bpfFuncInfo, ts types) ([]funcInfo, error) {
+func newFuncInfos(bfis []bpfFuncInfo, spec *Spec) ([]funcInfo, error) {
fis := make([]funcInfo, 0, len(bfis))
for _, bfi := range bfis {
- fi, err := newFuncInfo(bfi, ts)
+ fi, err := newFuncInfo(bfi, spec)
if err != nil {
return nil, fmt.Errorf("offset %d: %w", bfi.InsnOff, err)
}
@@ -349,8 +375,8 @@ func newFuncInfos(bfis []bpfFuncInfo, ts types) ([]funcInfo, error) {
}
// marshal into the BTF wire format.
-func (fi *funcInfo) marshal(w io.Writer, typeID func(Type) (TypeID, error)) error {
- id, err := typeID(fi.fn)
+func (fi *funcInfo) marshal(w *bytes.Buffer, b *Builder) error {
+ id, err := b.Add(fi.fn)
if err != nil {
return err
}
@@ -358,10 +384,14 @@ func (fi *funcInfo) marshal(w io.Writer, typeID func(Type) (TypeID, error)) erro
InsnOff: uint32(fi.offset),
TypeID: id,
}
- return binary.Write(w, internal.NativeEndian, &bfi)
+ buf := make([]byte, FuncInfoSize)
+ internal.NativeEndian.PutUint32(buf, bfi.InsnOff)
+ internal.NativeEndian.PutUint32(buf[4:], uint32(bfi.TypeID))
+ _, err = w.Write(buf)
+ return err
}
-// parseLineInfos parses a func_info sub-section within .BTF.ext ito a map of
+// parseFuncInfos parses a func_info sub-section within .BTF.ext ito a map of
// func infos indexed by section name.
func parseFuncInfos(r io.Reader, bo binary.ByteOrder, strings *stringTable) (map[string][]bpfFuncInfo, error) {
recordSize, err := parseExtInfoRecordSize(r, bo)
@@ -428,12 +458,6 @@ type Line struct {
line string
lineNumber uint32
lineColumn uint32
-
- // TODO: We should get rid of the fields below, but for that we need to be
- // able to write BTF.
-
- fileNameOff uint32
- lineOff uint32
}
func (li *Line) FileName() string {
@@ -496,8 +520,6 @@ func newLineInfo(li bpfLineInfo, strings *stringTable) (*lineInfo, error) {
line,
lineNumber,
lineColumn,
- li.FileNameOff,
- li.LineOff,
},
asm.RawInstructionOffset(li.InsnOff),
}, nil
@@ -519,7 +541,7 @@ func newLineInfos(blis []bpfLineInfo, strings *stringTable) ([]lineInfo, error)
}
// marshal writes the binary representation of the LineInfo to w.
-func (li *lineInfo) marshal(w io.Writer) error {
+func (li *lineInfo) marshal(w *bytes.Buffer, b *Builder) error {
line := li.line
if line.lineNumber > bpfLineMax {
return fmt.Errorf("line %d exceeds %d", line.lineNumber, bpfLineMax)
@@ -529,13 +551,30 @@ func (li *lineInfo) marshal(w io.Writer) error {
return fmt.Errorf("column %d exceeds %d", line.lineColumn, bpfColumnMax)
}
+ fileNameOff, err := b.addString(line.fileName)
+ if err != nil {
+ return fmt.Errorf("file name %q: %w", line.fileName, err)
+ }
+
+ lineOff, err := b.addString(line.line)
+ if err != nil {
+ return fmt.Errorf("line %q: %w", line.line, err)
+ }
+
bli := bpfLineInfo{
uint32(li.offset),
- line.fileNameOff,
- line.lineOff,
+ fileNameOff,
+ lineOff,
(line.lineNumber << bpfLineShift) | line.lineColumn,
}
- return binary.Write(w, internal.NativeEndian, &bli)
+
+ buf := make([]byte, LineInfoSize)
+ internal.NativeEndian.PutUint32(buf, bli.InsnOff)
+ internal.NativeEndian.PutUint32(buf[4:], bli.FileNameOff)
+ internal.NativeEndian.PutUint32(buf[8:], bli.LineOff)
+ internal.NativeEndian.PutUint32(buf[12:], bli.LineCol)
+ _, err = w.Write(buf)
+ return err
}
// parseLineInfos parses a line_info sub-section within .BTF.ext ito a map of
@@ -605,9 +644,16 @@ type bpfCORERelo struct {
}
type CORERelocation struct {
+ // The local type of the relocation, stripped of typedefs and qualifiers.
typ Type
accessor coreAccessor
kind coreKind
+ // The ID of the local type in the source BTF.
+ id TypeID
+}
+
+func (cr *CORERelocation) String() string {
+ return fmt.Sprintf("CORERelocation(%s, %s[%s], local_id=%d)", cr.kind, cr.typ, cr.accessor, cr.id)
}
func CORERelocationMetadata(ins *asm.Instruction) *CORERelocation {
@@ -620,8 +666,8 @@ type coreRelocationInfo struct {
offset asm.RawInstructionOffset
}
-func newRelocationInfo(relo bpfCORERelo, ts types, strings *stringTable) (*coreRelocationInfo, error) {
- typ, err := ts.ByID(relo.TypeID)
+func newRelocationInfo(relo bpfCORERelo, spec *Spec, strings *stringTable) (*coreRelocationInfo, error) {
+ typ, err := spec.TypeByID(relo.TypeID)
if err != nil {
return nil, err
}
@@ -641,15 +687,16 @@ func newRelocationInfo(relo bpfCORERelo, ts types, strings *stringTable) (*coreR
typ,
accessor,
relo.Kind,
+ relo.TypeID,
},
asm.RawInstructionOffset(relo.InsnOff),
}, nil
}
-func newRelocationInfos(brs []bpfCORERelo, ts types, strings *stringTable) ([]coreRelocationInfo, error) {
+func newRelocationInfos(brs []bpfCORERelo, spec *Spec, strings *stringTable) ([]coreRelocationInfo, error) {
rs := make([]coreRelocationInfo, 0, len(brs))
for _, br := range brs {
- relo, err := newRelocationInfo(br, ts, strings)
+ relo, err := newRelocationInfo(br, spec, strings)
if err != nil {
return nil, fmt.Errorf("offset %d: %w", br.InsnOff, err)
}
diff --git a/vendor/github.com/cilium/ebpf/btf/format.go b/vendor/github.com/cilium/ebpf/btf/format.go
index e7688a2a6e83..e85220259e74 100644
--- a/vendor/github.com/cilium/ebpf/btf/format.go
+++ b/vendor/github.com/cilium/ebpf/btf/format.go
@@ -56,54 +56,40 @@ func (gf *GoFormatter) enumIdentifier(name, element string) string {
//
// It encodes https://golang.org/ref/spec#Type_declarations:
//
-// type foo struct { bar uint32; }
-// type bar int32
+// type foo struct { bar uint32; }
+// type bar int32
func (gf *GoFormatter) writeTypeDecl(name string, typ Type) error {
if name == "" {
return fmt.Errorf("need a name for type %s", typ)
}
- switch v := skipQualifiers(typ).(type) {
- case *Enum:
- fmt.Fprintf(&gf.w, "type %s ", name)
- switch v.Size {
- case 1:
- gf.w.WriteString("int8")
- case 2:
- gf.w.WriteString("int16")
- case 4:
- gf.w.WriteString("int32")
- case 8:
- gf.w.WriteString("int64")
- default:
- return fmt.Errorf("%s: invalid enum size %d", typ, v.Size)
- }
-
- if len(v.Values) == 0 {
- return nil
- }
-
- gf.w.WriteString("; const ( ")
- for _, ev := range v.Values {
- id := gf.enumIdentifier(name, ev.Name)
- fmt.Fprintf(&gf.w, "%s %s = %d; ", id, name, ev.Value)
- }
- gf.w.WriteString(")")
+ typ = skipQualifiers(typ)
+ fmt.Fprintf(&gf.w, "type %s ", name)
+ if err := gf.writeTypeLit(typ, 0); err != nil {
+ return err
+ }
+ e, ok := typ.(*Enum)
+ if !ok || len(e.Values) == 0 {
return nil
+ }
- default:
- fmt.Fprintf(&gf.w, "type %s ", name)
- return gf.writeTypeLit(v, 0)
+ gf.w.WriteString("; const ( ")
+ for _, ev := range e.Values {
+ id := gf.enumIdentifier(name, ev.Name)
+ fmt.Fprintf(&gf.w, "%s %s = %d; ", id, name, ev.Value)
}
+ gf.w.WriteString(")")
+
+ return nil
}
// writeType outputs the name of a named type or a literal describing the type.
//
// It encodes https://golang.org/ref/spec#Types.
//
-// foo (if foo is a named type)
-// uint32
+// foo (if foo is a named type)
+// uint32
func (gf *GoFormatter) writeType(typ Type, depth int) error {
typ = skipQualifiers(typ)
@@ -122,8 +108,8 @@ func (gf *GoFormatter) writeType(typ Type, depth int) error {
//
// It encodes https://golang.org/ref/spec#TypeLit.
//
-// struct { bar uint32; }
-// uint32
+// struct { bar uint32; }
+// uint32
func (gf *GoFormatter) writeTypeLit(typ Type, depth int) error {
depth++
if depth > maxTypeDepth {
@@ -133,10 +119,24 @@ func (gf *GoFormatter) writeTypeLit(typ Type, depth int) error {
var err error
switch v := skipQualifiers(typ).(type) {
case *Int:
- gf.writeIntLit(v)
+ err = gf.writeIntLit(v)
case *Enum:
- gf.w.WriteString("int32")
+ if !v.Signed {
+ gf.w.WriteRune('u')
+ }
+ switch v.Size {
+ case 1:
+ gf.w.WriteString("int8")
+ case 2:
+ gf.w.WriteString("int16")
+ case 4:
+ gf.w.WriteString("int32")
+ case 8:
+ gf.w.WriteString("int64")
+ default:
+ err = fmt.Errorf("invalid enum size %d", v.Size)
+ }
case *Typedef:
err = gf.writeType(v.Type, depth)
@@ -166,19 +166,36 @@ func (gf *GoFormatter) writeTypeLit(typ Type, depth int) error {
return nil
}
-func (gf *GoFormatter) writeIntLit(i *Int) {
- // NB: Encoding.IsChar is ignored.
- if i.Encoding.IsBool() && i.Size == 1 {
- gf.w.WriteString("bool")
- return
- }
-
+func (gf *GoFormatter) writeIntLit(i *Int) error {
bits := i.Size * 8
- if i.Encoding.IsSigned() {
- fmt.Fprintf(&gf.w, "int%d", bits)
- } else {
- fmt.Fprintf(&gf.w, "uint%d", bits)
+ switch i.Encoding {
+ case Bool:
+ if i.Size != 1 {
+ return fmt.Errorf("bool with size %d", i.Size)
+ }
+ gf.w.WriteString("bool")
+ case Char:
+ if i.Size != 1 {
+ return fmt.Errorf("char with size %d", i.Size)
+ }
+ // BTF doesn't have a way to specify the signedness of a char. Assume
+ // we are dealing with unsigned, since this works nicely with []byte
+ // in Go code.
+ fallthrough
+ case Unsigned, Signed:
+ stem := "uint"
+ if i.Encoding == Signed {
+ stem = "int"
+ }
+ if i.Size > 8 {
+ fmt.Fprintf(&gf.w, "[%d]byte /* %s%d */", i.Size, stem, i.Size*8)
+ } else {
+ fmt.Fprintf(&gf.w, "%s%d", stem, bits)
+ }
+ default:
+ return fmt.Errorf("can't encode %s", i.Encoding)
}
+ return nil
}
func (gf *GoFormatter) writeStructLit(size uint32, members []Member, depth int) error {
@@ -199,11 +216,15 @@ func (gf *GoFormatter) writeStructLit(size uint32, members []Member, depth int)
gf.writePadding(n)
}
- size, err := Sizeof(m.Type)
+ fieldSize, err := Sizeof(m.Type)
if err != nil {
return fmt.Errorf("field %d: %w", i, err)
}
- prevOffset = offset + uint32(size)
+
+ prevOffset = offset + uint32(fieldSize)
+ if prevOffset > size {
+ return fmt.Errorf("field %d of size %d exceeds type size %d", i, fieldSize, size)
+ }
if err := gf.writeStructField(m, depth); err != nil {
return fmt.Errorf("field %d: %w", i, err)
@@ -272,7 +293,11 @@ func (gf *GoFormatter) writeDatasecLit(ds *Datasec, depth int) error {
prevOffset := uint32(0)
for i, vsi := range ds.Vars {
- v := vsi.Type.(*Var)
+ v, ok := vsi.Type.(*Var)
+ if !ok {
+ return fmt.Errorf("can't format %s as part of data section", vsi.Type)
+ }
+
if v.Linkage != GlobalVar {
// Ignore static, extern, etc. for now.
continue
diff --git a/vendor/github.com/cilium/ebpf/btf/handle.go b/vendor/github.com/cilium/ebpf/btf/handle.go
index 128e9b35cf3b..b6b3e87f504f 100644
--- a/vendor/github.com/cilium/ebpf/btf/handle.go
+++ b/vendor/github.com/cilium/ebpf/btf/handle.go
@@ -1,14 +1,142 @@
package btf
import (
+ "bytes"
"errors"
"fmt"
+ "math"
"os"
+ "github.com/cilium/ebpf/internal"
"github.com/cilium/ebpf/internal/sys"
"github.com/cilium/ebpf/internal/unix"
)
+// Handle is a reference to BTF loaded into the kernel.
+type Handle struct {
+ fd *sys.FD
+
+ // Size of the raw BTF in bytes.
+ size uint32
+
+ needsKernelBase bool
+}
+
+// NewHandle loads the contents of a [Builder] into the kernel.
+//
+// Returns an error wrapping ErrNotSupported if the kernel doesn't support BTF.
+func NewHandle(b *Builder) (*Handle, error) {
+ small := getByteSlice()
+ defer putByteSlice(small)
+
+ buf, err := b.Marshal(*small, KernelMarshalOptions())
+ if err != nil {
+ return nil, fmt.Errorf("marshal BTF: %w", err)
+ }
+
+ return NewHandleFromRawBTF(buf)
+}
+
+// NewHandleFromRawBTF loads raw BTF into the kernel.
+//
+// Returns an error wrapping ErrNotSupported if the kernel doesn't support BTF.
+func NewHandleFromRawBTF(btf []byte) (*Handle, error) {
+ if uint64(len(btf)) > math.MaxUint32 {
+ return nil, errors.New("BTF exceeds the maximum size")
+ }
+
+ attr := &sys.BtfLoadAttr{
+ Btf: sys.NewSlicePointer(btf),
+ BtfSize: uint32(len(btf)),
+ }
+
+ fd, err := sys.BtfLoad(attr)
+ if err == nil {
+ return &Handle{fd, attr.BtfSize, false}, nil
+ }
+
+ if err := haveBTF(); err != nil {
+ return nil, err
+ }
+
+ logBuf := make([]byte, 64*1024)
+ attr.BtfLogBuf = sys.NewSlicePointer(logBuf)
+ attr.BtfLogSize = uint32(len(logBuf))
+ attr.BtfLogLevel = 1
+
+ // Up until at least kernel 6.0, the BTF verifier does not return ENOSPC
+ // if there are other verification errors. ENOSPC is only returned when
+ // the BTF blob is correct, a log was requested, and the provided buffer
+ // is too small.
+ _, ve := sys.BtfLoad(attr)
+ return nil, internal.ErrorWithLog("load btf", err, logBuf, errors.Is(ve, unix.ENOSPC))
+}
+
+// NewHandleFromID returns the BTF handle for a given id.
+//
+// Prefer calling [ebpf.Program.Handle] or [ebpf.Map.Handle] if possible.
+//
+// Returns ErrNotExist, if there is no BTF with the given id.
+//
+// Requires CAP_SYS_ADMIN.
+func NewHandleFromID(id ID) (*Handle, error) {
+ fd, err := sys.BtfGetFdById(&sys.BtfGetFdByIdAttr{
+ Id: uint32(id),
+ })
+ if err != nil {
+ return nil, fmt.Errorf("get FD for ID %d: %w", id, err)
+ }
+
+ info, err := newHandleInfoFromFD(fd)
+ if err != nil {
+ _ = fd.Close()
+ return nil, err
+ }
+
+ return &Handle{fd, info.size, info.IsModule()}, nil
+}
+
+// Spec parses the kernel BTF into Go types.
+//
+// base must contain type information for vmlinux if the handle is for
+// a kernel module. It may be nil otherwise.
+func (h *Handle) Spec(base *Spec) (*Spec, error) {
+ var btfInfo sys.BtfInfo
+ btfBuffer := make([]byte, h.size)
+ btfInfo.Btf, btfInfo.BtfSize = sys.NewSlicePointerLen(btfBuffer)
+
+ if err := sys.ObjInfo(h.fd, &btfInfo); err != nil {
+ return nil, err
+ }
+
+ if h.needsKernelBase && base == nil {
+ return nil, fmt.Errorf("missing base types")
+ }
+
+ return loadRawSpec(bytes.NewReader(btfBuffer), internal.NativeEndian, base)
+}
+
+// Close destroys the handle.
+//
+// Subsequent calls to FD will return an invalid value.
+func (h *Handle) Close() error {
+ if h == nil {
+ return nil
+ }
+
+ return h.fd.Close()
+}
+
+// FD returns the file descriptor for the handle.
+func (h *Handle) FD() int {
+ return h.fd.Int()
+}
+
+// Info returns metadata about the handle.
+func (h *Handle) Info() (*HandleInfo, error) {
+ return newHandleInfoFromFD(h.fd)
+}
+
// HandleInfo describes a Handle.
type HandleInfo struct {
// ID of this handle in the kernel. The ID is only valid as long as the
@@ -59,7 +187,7 @@ func newHandleInfoFromFD(fd *sys.FD) (*HandleInfo, error) {
}, nil
}
-// IsModule returns true if the BTF is for the kernel itself.
+// IsVmlinux returns true if the BTF is for the kernel itself.
func (i *HandleInfo) IsVmlinux() bool {
return i.IsKernel && i.Name == "vmlinux"
}
@@ -71,51 +199,89 @@ func (i *HandleInfo) IsModule() bool {
// HandleIterator allows enumerating BTF blobs loaded into the kernel.
type HandleIterator struct {
- // The ID of the last retrieved handle. Only valid after a call to Next.
- ID ID
- err error
+ // The ID of the current handle. Only valid after a call to Next.
+ ID ID
+ // The current Handle. Only valid until a call to Next.
+ // See Take if you want to retain the handle.
+ Handle *Handle
+ err error
}
-// Next retrieves a handle for the next BTF blob.
+// Next retrieves a handle for the next BTF object.
//
-// [Handle.Close] is called if *handle is non-nil to avoid leaking fds.
-//
-// Returns true if another BTF blob was found. Call [HandleIterator.Err] after
+// Returns true if another BTF object was found. Call [HandleIterator.Err] after
// the function returns false.
-func (it *HandleIterator) Next(handle **Handle) bool {
- if *handle != nil {
- (*handle).Close()
- *handle = nil
- }
-
+func (it *HandleIterator) Next() bool {
id := it.ID
for {
attr := &sys.BtfGetNextIdAttr{Id: id}
err := sys.BtfGetNextId(attr)
if errors.Is(err, os.ErrNotExist) {
// There are no more BTF objects.
- return false
+ break
} else if err != nil {
it.err = fmt.Errorf("get next BTF ID: %w", err)
- return false
+ break
}
id = attr.NextId
- *handle, err = NewHandleFromID(id)
+ handle, err := NewHandleFromID(id)
if errors.Is(err, os.ErrNotExist) {
// Try again with the next ID.
continue
} else if err != nil {
it.err = fmt.Errorf("retrieve handle for ID %d: %w", id, err)
- return false
+ break
}
- it.ID = id
+ it.Handle.Close()
+ it.ID, it.Handle = id, handle
return true
}
+
+ // No more handles or we encountered an error.
+ it.Handle.Close()
+ it.Handle = nil
+ return false
+}
+
+// Take the ownership of the current handle.
+//
+// It's the callers responsibility to close the handle.
+func (it *HandleIterator) Take() *Handle {
+ handle := it.Handle
+ it.Handle = nil
+ return handle
}
// Err returns an error if iteration failed for some reason.
func (it *HandleIterator) Err() error {
return it.err
}
+
+// FindHandle returns the first handle for which predicate returns true.
+//
+// Requires CAP_SYS_ADMIN.
+//
+// Returns an error wrapping ErrNotFound if predicate never returns true or if
+// there is no BTF loaded into the kernel.
+func FindHandle(predicate func(info *HandleInfo) bool) (*Handle, error) {
+ it := new(HandleIterator)
+ defer it.Handle.Close()
+
+ for it.Next() {
+ info, err := it.Handle.Info()
+ if err != nil {
+ return nil, fmt.Errorf("info for ID %d: %w", it.ID, err)
+ }
+
+ if predicate(info) {
+ return it.Take(), nil
+ }
+ }
+ if err := it.Err(); err != nil {
+ return nil, fmt.Errorf("iterate handles: %w", err)
+ }
+
+ return nil, fmt.Errorf("find handle: %w", ErrNotFound)
+}
diff --git a/vendor/github.com/cilium/ebpf/btf/marshal.go b/vendor/github.com/cilium/ebpf/btf/marshal.go
new file mode 100644
index 000000000000..bfe53b41072c
--- /dev/null
+++ b/vendor/github.com/cilium/ebpf/btf/marshal.go
@@ -0,0 +1,543 @@
+package btf
+
+import (
+ "bytes"
+ "encoding/binary"
+ "errors"
+ "fmt"
+ "math"
+ "sync"
+
+ "github.com/cilium/ebpf/internal"
+
+ "golang.org/x/exp/slices"
+)
+
+type MarshalOptions struct {
+ // Target byte order. Defaults to the system's native endianness.
+ Order binary.ByteOrder
+ // Remove function linkage information for compatibility with <5.6 kernels.
+ StripFuncLinkage bool
+}
+
+// KernelMarshalOptions will generate BTF suitable for the current kernel.
+func KernelMarshalOptions() *MarshalOptions {
+ return &MarshalOptions{
+ Order: internal.NativeEndian,
+ StripFuncLinkage: haveFuncLinkage() != nil,
+ }
+}
+
+// encoder turns Types into raw BTF.
+type encoder struct {
+ MarshalOptions
+
+ pending internal.Deque[Type]
+ buf *bytes.Buffer
+ strings *stringTableBuilder
+ ids map[Type]TypeID
+ lastID TypeID
+}
+
+var bufferPool = sync.Pool{
+ New: func() any {
+ buf := make([]byte, btfHeaderLen+128)
+ return &buf
+ },
+}
+
+func getByteSlice() *[]byte {
+ return bufferPool.Get().(*[]byte)
+}
+
+func putByteSlice(buf *[]byte) {
+ *buf = (*buf)[:0]
+ bufferPool.Put(buf)
+}
+
+// Builder turns Types into raw BTF.
+//
+// The default value may be used and represents an empty BTF blob. Void is
+// added implicitly if necessary.
+type Builder struct {
+ // Explicitly added types.
+ types []Type
+ // IDs for all added types which the user knows about.
+ stableIDs map[Type]TypeID
+ // Explicitly added strings.
+ strings *stringTableBuilder
+}
+
+// NewBuilder creates a Builder from a list of types.
+//
+// It is more efficient than calling [Add] individually.
+//
+// Returns an error if adding any of the types fails.
+func NewBuilder(types []Type) (*Builder, error) {
+ b := &Builder{
+ make([]Type, 0, len(types)),
+ make(map[Type]TypeID, len(types)),
+ nil,
+ }
+
+ for _, typ := range types {
+ _, err := b.Add(typ)
+ if err != nil {
+ return nil, fmt.Errorf("add %s: %w", typ, err)
+ }
+ }
+
+ return b, nil
+}
+
+// Add a Type and allocate a stable ID for it.
+//
+// Adding the identical Type multiple times is valid and will return the same ID.
+//
+// See [Type] for details on identity.
+func (b *Builder) Add(typ Type) (TypeID, error) {
+ if b.stableIDs == nil {
+ b.stableIDs = make(map[Type]TypeID)
+ }
+
+ if _, ok := typ.(*Void); ok {
+ // Equality is weird for void, since it is a zero sized type.
+ return 0, nil
+ }
+
+ if ds, ok := typ.(*Datasec); ok {
+ if err := datasecResolveWorkaround(b, ds); err != nil {
+ return 0, err
+ }
+ }
+
+ id, ok := b.stableIDs[typ]
+ if ok {
+ return id, nil
+ }
+
+ b.types = append(b.types, typ)
+
+ id = TypeID(len(b.types))
+ if int(id) != len(b.types) {
+ return 0, fmt.Errorf("no more type IDs")
+ }
+
+ b.stableIDs[typ] = id
+ return id, nil
+}
+
+// Marshal encodes all types in the Marshaler into BTF wire format.
+//
+// opts may be nil.
+func (b *Builder) Marshal(buf []byte, opts *MarshalOptions) ([]byte, error) {
+ stb := b.strings
+ if stb == nil {
+ // Assume that most types are named. This makes encoding large BTF like
+ // vmlinux a lot cheaper.
+ stb = newStringTableBuilder(len(b.types))
+ } else {
+ // Avoid modifying the Builder's string table.
+ stb = b.strings.Copy()
+ }
+
+ if opts == nil {
+ opts = &MarshalOptions{Order: internal.NativeEndian}
+ }
+
+ // Reserve space for the BTF header.
+ buf = slices.Grow(buf, btfHeaderLen)[:btfHeaderLen]
+
+ w := internal.NewBuffer(buf)
+ defer internal.PutBuffer(w)
+
+ e := encoder{
+ MarshalOptions: *opts,
+ buf: w,
+ strings: stb,
+ lastID: TypeID(len(b.types)),
+ ids: make(map[Type]TypeID, len(b.types)),
+ }
+
+ // Ensure that types are marshaled in the exact order they were Add()ed.
+ // Otherwise the ID returned from Add() won't match.
+ e.pending.Grow(len(b.types))
+ for _, typ := range b.types {
+ e.pending.Push(typ)
+ e.ids[typ] = b.stableIDs[typ]
+ }
+
+ if err := e.deflatePending(); err != nil {
+ return nil, err
+ }
+
+ length := e.buf.Len()
+ typeLen := uint32(length - btfHeaderLen)
+
+ stringLen := e.strings.Length()
+ buf = e.strings.AppendEncoded(e.buf.Bytes())
+
+ // Fill out the header, and write it out.
+ header := &btfHeader{
+ Magic: btfMagic,
+ Version: 1,
+ Flags: 0,
+ HdrLen: uint32(btfHeaderLen),
+ TypeOff: 0,
+ TypeLen: typeLen,
+ StringOff: typeLen,
+ StringLen: uint32(stringLen),
+ }
+
+ err := binary.Write(sliceWriter(buf[:btfHeaderLen]), e.Order, header)
+ if err != nil {
+ return nil, fmt.Errorf("write header: %v", err)
+ }
+
+ return buf, nil
+}
+
+// addString adds a string to the resulting BTF.
+//
+// Adding the same string multiple times will return the same result.
+//
+// Returns an identifier into the string table or an error if the string
+// contains invalid characters.
+func (b *Builder) addString(str string) (uint32, error) {
+ if b.strings == nil {
+ b.strings = newStringTableBuilder(0)
+ }
+
+ return b.strings.Add(str)
+}
+
+func (e *encoder) allocateID(typ Type) error {
+ id := e.lastID + 1
+ if id < e.lastID {
+ return errors.New("type ID overflow")
+ }
+
+ e.pending.Push(typ)
+ e.ids[typ] = id
+ e.lastID = id
+ return nil
+}
+
+// id returns the ID for the given type or panics with an error.
+func (e *encoder) id(typ Type) TypeID {
+ if _, ok := typ.(*Void); ok {
+ return 0
+ }
+
+ id, ok := e.ids[typ]
+ if !ok {
+ panic(fmt.Errorf("no ID for type %v", typ))
+ }
+
+ return id
+}
+
+func (e *encoder) deflatePending() error {
+ // Declare root outside of the loop to avoid repeated heap allocations.
+ var root Type
+ skip := func(t Type) (skip bool) {
+ if t == root {
+ // Force descending into the current root type even if it already
+ // has an ID. Otherwise we miss children of types that have their
+ // ID pre-allocated via Add.
+ return false
+ }
+
+ _, isVoid := t.(*Void)
+ _, alreadyEncoded := e.ids[t]
+ return isVoid || alreadyEncoded
+ }
+
+ for !e.pending.Empty() {
+ root = e.pending.Shift()
+
+ // Allocate IDs for all children of typ, including transitive dependencies.
+ iter := postorderTraversal(root, skip)
+ for iter.Next() {
+ if iter.Type == root {
+ // The iterator yields root at the end, do not allocate another ID.
+ break
+ }
+
+ if err := e.allocateID(iter.Type); err != nil {
+ return err
+ }
+ }
+
+ if err := e.deflateType(root); err != nil {
+ id := e.ids[root]
+ return fmt.Errorf("deflate %v with ID %d: %w", root, id, err)
+ }
+ }
+
+ return nil
+}
+
+func (e *encoder) deflateType(typ Type) (err error) {
+ defer func() {
+ if r := recover(); r != nil {
+ var ok bool
+ err, ok = r.(error)
+ if !ok {
+ panic(r)
+ }
+ }
+ }()
+
+ var raw rawType
+ raw.NameOff, err = e.strings.Add(typ.TypeName())
+ if err != nil {
+ return err
+ }
+
+ switch v := typ.(type) {
+ case *Void:
+ return errors.New("Void is implicit in BTF wire format")
+
+ case *Int:
+ raw.SetKind(kindInt)
+ raw.SetSize(v.Size)
+
+ var bi btfInt
+ bi.SetEncoding(v.Encoding)
+ // We need to set bits in addition to size, since btf_type_int_is_regular
+ // otherwise flags this as a bitfield.
+ bi.SetBits(byte(v.Size) * 8)
+ raw.data = bi
+
+ case *Pointer:
+ raw.SetKind(kindPointer)
+ raw.SetType(e.id(v.Target))
+
+ case *Array:
+ raw.SetKind(kindArray)
+ raw.data = &btfArray{
+ e.id(v.Type),
+ e.id(v.Index),
+ v.Nelems,
+ }
+
+ case *Struct:
+ raw.SetKind(kindStruct)
+ raw.SetSize(v.Size)
+ raw.data, err = e.convertMembers(&raw.btfType, v.Members)
+
+ case *Union:
+ raw.SetKind(kindUnion)
+ raw.SetSize(v.Size)
+ raw.data, err = e.convertMembers(&raw.btfType, v.Members)
+
+ case *Enum:
+ raw.SetSize(v.size())
+ raw.SetVlen(len(v.Values))
+ raw.SetSigned(v.Signed)
+
+ if v.has64BitValues() {
+ raw.SetKind(kindEnum64)
+ raw.data, err = e.deflateEnum64Values(v.Values)
+ } else {
+ raw.SetKind(kindEnum)
+ raw.data, err = e.deflateEnumValues(v.Values)
+ }
+
+ case *Fwd:
+ raw.SetKind(kindForward)
+ raw.SetFwdKind(v.Kind)
+
+ case *Typedef:
+ raw.SetKind(kindTypedef)
+ raw.SetType(e.id(v.Type))
+
+ case *Volatile:
+ raw.SetKind(kindVolatile)
+ raw.SetType(e.id(v.Type))
+
+ case *Const:
+ raw.SetKind(kindConst)
+ raw.SetType(e.id(v.Type))
+
+ case *Restrict:
+ raw.SetKind(kindRestrict)
+ raw.SetType(e.id(v.Type))
+
+ case *Func:
+ raw.SetKind(kindFunc)
+ raw.SetType(e.id(v.Type))
+ if !e.StripFuncLinkage {
+ raw.SetLinkage(v.Linkage)
+ }
+
+ case *FuncProto:
+ raw.SetKind(kindFuncProto)
+ raw.SetType(e.id(v.Return))
+ raw.SetVlen(len(v.Params))
+ raw.data, err = e.deflateFuncParams(v.Params)
+
+ case *Var:
+ raw.SetKind(kindVar)
+ raw.SetType(e.id(v.Type))
+ raw.data = btfVariable{uint32(v.Linkage)}
+
+ case *Datasec:
+ raw.SetKind(kindDatasec)
+ raw.SetSize(v.Size)
+ raw.SetVlen(len(v.Vars))
+ raw.data = e.deflateVarSecinfos(v.Vars)
+
+ case *Float:
+ raw.SetKind(kindFloat)
+ raw.SetSize(v.Size)
+
+ case *declTag:
+ raw.SetKind(kindDeclTag)
+ raw.SetType(e.id(v.Type))
+ raw.data = &btfDeclTag{uint32(v.Index)}
+ raw.NameOff, err = e.strings.Add(v.Value)
+
+ case *typeTag:
+ raw.SetKind(kindTypeTag)
+ raw.SetType(e.id(v.Type))
+ raw.NameOff, err = e.strings.Add(v.Value)
+
+ default:
+ return fmt.Errorf("don't know how to deflate %T", v)
+ }
+
+ if err != nil {
+ return err
+ }
+
+ return raw.Marshal(e.buf, e.Order)
+}
+
+func (e *encoder) convertMembers(header *btfType, members []Member) ([]btfMember, error) {
+ bms := make([]btfMember, 0, len(members))
+ isBitfield := false
+ for _, member := range members {
+ isBitfield = isBitfield || member.BitfieldSize > 0
+
+ offset := member.Offset
+ if isBitfield {
+ offset = member.BitfieldSize<<24 | (member.Offset & 0xffffff)
+ }
+
+ nameOff, err := e.strings.Add(member.Name)
+ if err != nil {
+ return nil, err
+ }
+
+ bms = append(bms, btfMember{
+ nameOff,
+ e.id(member.Type),
+ uint32(offset),
+ })
+ }
+
+ header.SetVlen(len(members))
+ header.SetBitfield(isBitfield)
+ return bms, nil
+}
+
+func (e *encoder) deflateEnumValues(values []EnumValue) ([]btfEnum, error) {
+ bes := make([]btfEnum, 0, len(values))
+ for _, value := range values {
+ nameOff, err := e.strings.Add(value.Name)
+ if err != nil {
+ return nil, err
+ }
+
+ if value.Value > math.MaxUint32 {
+ return nil, fmt.Errorf("value of enum %q exceeds 32 bits", value.Name)
+ }
+
+ bes = append(bes, btfEnum{
+ nameOff,
+ uint32(value.Value),
+ })
+ }
+
+ return bes, nil
+}
+
+func (e *encoder) deflateEnum64Values(values []EnumValue) ([]btfEnum64, error) {
+ bes := make([]btfEnum64, 0, len(values))
+ for _, value := range values {
+ nameOff, err := e.strings.Add(value.Name)
+ if err != nil {
+ return nil, err
+ }
+
+ bes = append(bes, btfEnum64{
+ nameOff,
+ uint32(value.Value),
+ uint32(value.Value >> 32),
+ })
+ }
+
+ return bes, nil
+}
+
+func (e *encoder) deflateFuncParams(params []FuncParam) ([]btfParam, error) {
+ bps := make([]btfParam, 0, len(params))
+ for _, param := range params {
+ nameOff, err := e.strings.Add(param.Name)
+ if err != nil {
+ return nil, err
+ }
+
+ bps = append(bps, btfParam{
+ nameOff,
+ e.id(param.Type),
+ })
+ }
+ return bps, nil
+}
+
+func (e *encoder) deflateVarSecinfos(vars []VarSecinfo) []btfVarSecinfo {
+ vsis := make([]btfVarSecinfo, 0, len(vars))
+ for _, v := range vars {
+ vsis = append(vsis, btfVarSecinfo{
+ e.id(v.Type),
+ v.Offset,
+ v.Size,
+ })
+ }
+ return vsis
+}
+
+// MarshalMapKV creates a BTF object containing a map key and value.
+//
+// The function is intended for the use of the ebpf package and may be removed
+// at any point in time.
+func MarshalMapKV(key, value Type) (_ *Handle, keyID, valueID TypeID, err error) {
+ var b Builder
+
+ if key != nil {
+ keyID, err = b.Add(key)
+ if err != nil {
+ return nil, 0, 0, fmt.Errorf("add key type: %w", err)
+ }
+ }
+
+ if value != nil {
+ valueID, err = b.Add(value)
+ if err != nil {
+ return nil, 0, 0, fmt.Errorf("add value type: %w", err)
+ }
+ }
+
+ handle, err := NewHandle(&b)
+ if err != nil {
+ // Check for 'full' map BTF support, since kernels between 4.18 and 5.2
+ // already support BTF blobs for maps without Var or Datasec just fine.
+ if err := haveMapBTF(); err != nil {
+ return nil, 0, 0, err
+ }
+ }
+ return handle, keyID, valueID, err
+}
diff --git a/vendor/github.com/cilium/ebpf/btf/strings.go b/vendor/github.com/cilium/ebpf/btf/strings.go
index 67626e0dd172..bc6aff28142d 100644
--- a/vendor/github.com/cilium/ebpf/btf/strings.go
+++ b/vendor/github.com/cilium/ebpf/btf/strings.go
@@ -6,6 +6,9 @@ import (
"errors"
"fmt"
"io"
+ "strings"
+
+ "golang.org/x/exp/maps"
)
type stringTable struct {
@@ -88,11 +91,6 @@ func (st *stringTable) lookup(offset uint32) (string, error) {
return st.strings[i], nil
}
-func (st *stringTable) Length() int {
- last := len(st.offsets) - 1
- return int(st.offsets[last]) + len(st.strings[last]) + 1
-}
-
func (st *stringTable) Marshal(w io.Writer) error {
for _, str := range st.strings {
_, err := io.WriteString(w, str)
@@ -107,6 +105,11 @@ func (st *stringTable) Marshal(w io.Writer) error {
return nil
}
+// Num returns the number of strings in the table.
+func (st *stringTable) Num() int {
+ return len(st.strings)
+}
+
// search is a copy of sort.Search specialised for uint32.
//
// Licensed under https://go.dev/LICENSE
@@ -126,3 +129,86 @@ func search(ints []uint32, needle uint32) int {
// i == j, f(i-1) == false, and f(j) (= f(i)) == true => answer is i.
return i
}
+
+// stringTableBuilder builds BTF string tables.
+type stringTableBuilder struct {
+ length uint32
+ strings map[string]uint32
+}
+
+// newStringTableBuilder creates a builder with the given capacity.
+//
+// capacity may be zero.
+func newStringTableBuilder(capacity int) *stringTableBuilder {
+ var stb stringTableBuilder
+
+ if capacity == 0 {
+ // Use the runtime's small default size.
+ stb.strings = make(map[string]uint32)
+ } else {
+ stb.strings = make(map[string]uint32, capacity)
+ }
+
+ // Ensure that the empty string is at index 0.
+ stb.append("")
+ return &stb
+}
+
+// Add a string to the table.
+//
+// Adding the same string multiple times will only store it once.
+func (stb *stringTableBuilder) Add(str string) (uint32, error) {
+ if strings.IndexByte(str, 0) != -1 {
+ return 0, fmt.Errorf("string contains null: %q", str)
+ }
+
+ offset, ok := stb.strings[str]
+ if ok {
+ return offset, nil
+ }
+
+ return stb.append(str), nil
+}
+
+func (stb *stringTableBuilder) append(str string) uint32 {
+ offset := stb.length
+ stb.length += uint32(len(str)) + 1
+ stb.strings[str] = offset
+ return offset
+}
+
+// Lookup finds the offset of a string in the table.
+//
+// Returns an error if str hasn't been added yet.
+func (stb *stringTableBuilder) Lookup(str string) (uint32, error) {
+ offset, ok := stb.strings[str]
+ if !ok {
+ return 0, fmt.Errorf("string %q is not in table", str)
+ }
+
+ return offset, nil
+}
+
+// Length returns the length in bytes.
+func (stb *stringTableBuilder) Length() int {
+ return int(stb.length)
+}
+
+// AppendEncoded appends the string table to the end of the provided buffer.
+func (stb *stringTableBuilder) AppendEncoded(buf []byte) []byte {
+ n := len(buf)
+ buf = append(buf, make([]byte, stb.Length())...)
+ strings := buf[n:]
+ for str, offset := range stb.strings {
+ copy(strings[offset:], str)
+ }
+ return buf
+}
+
+// Copy the string table builder.
+func (stb *stringTableBuilder) Copy() *stringTableBuilder {
+ return &stringTableBuilder{
+ stb.length,
+ maps.Clone(stb.strings),
+ }
+}
diff --git a/vendor/github.com/cilium/ebpf/btf/traversal.go b/vendor/github.com/cilium/ebpf/btf/traversal.go
new file mode 100644
index 000000000000..a3a9dec940a9
--- /dev/null
+++ b/vendor/github.com/cilium/ebpf/btf/traversal.go
@@ -0,0 +1,141 @@
+package btf
+
+import (
+ "fmt"
+
+ "github.com/cilium/ebpf/internal"
+)
+
+// Functions to traverse a cyclic graph of types. The below was very useful:
+// https://eli.thegreenplace.net/2015/directed-graph-traversal-orderings-and-applications-to-data-flow-analysis/#post-order-and-reverse-post-order
+
+type postorderIterator struct {
+ // Iteration skips types for which this function returns true.
+ skip func(Type) bool
+ // The root type. May be nil if skip(root) is true.
+ root Type
+
+ // Contains types which need to be either walked or yielded.
+ types typeDeque
+ // Contains a boolean whether the type has been walked or not.
+ walked internal.Deque[bool]
+ // The set of types which has been pushed onto types.
+ pushed map[Type]struct{}
+
+ // The current type. Only valid after a call to Next().
+ Type Type
+}
+
+// postorderTraversal iterates all types reachable from root by visiting the
+// leaves of the graph first.
+//
+// Types for which skip returns true are ignored. skip may be nil.
+func postorderTraversal(root Type, skip func(Type) (skip bool)) postorderIterator {
+ // Avoid allocations for the common case of a skipped root.
+ if skip != nil && skip(root) {
+ return postorderIterator{}
+ }
+
+ po := postorderIterator{root: root, skip: skip}
+ walkType(root, po.push)
+
+ return po
+}
+
+func (po *postorderIterator) push(t *Type) {
+ if _, ok := po.pushed[*t]; ok || *t == po.root {
+ return
+ }
+
+ if po.skip != nil && po.skip(*t) {
+ return
+ }
+
+ if po.pushed == nil {
+ // Lazily allocate pushed to avoid an allocation for Types without children.
+ po.pushed = make(map[Type]struct{})
+ }
+
+ po.pushed[*t] = struct{}{}
+ po.types.Push(t)
+ po.walked.Push(false)
+}
+
+// Next returns true if there is another Type to traverse.
+func (po *postorderIterator) Next() bool {
+ for !po.types.Empty() {
+ t := po.types.Pop()
+
+ if !po.walked.Pop() {
+ // Push the type again, so that we re-evaluate it in done state
+ // after all children have been handled.
+ po.types.Push(t)
+ po.walked.Push(true)
+
+ // Add all direct children to todo.
+ walkType(*t, po.push)
+ } else {
+ // We've walked this type previously, so we now know that all
+ // children have been handled.
+ po.Type = *t
+ return true
+ }
+ }
+
+ // Only return root once.
+ po.Type, po.root = po.root, nil
+ return po.Type != nil
+}
+
+// walkType calls fn on each child of typ.
+func walkType(typ Type, fn func(*Type)) {
+ // Explicitly type switch on the most common types to allow the inliner to
+ // do its work. This avoids allocating intermediate slices from walk() on
+ // the heap.
+ switch v := typ.(type) {
+ case *Void, *Int, *Enum, *Fwd, *Float:
+ // No children to traverse.
+ case *Pointer:
+ fn(&v.Target)
+ case *Array:
+ fn(&v.Index)
+ fn(&v.Type)
+ case *Struct:
+ for i := range v.Members {
+ fn(&v.Members[i].Type)
+ }
+ case *Union:
+ for i := range v.Members {
+ fn(&v.Members[i].Type)
+ }
+ case *Typedef:
+ fn(&v.Type)
+ case *Volatile:
+ fn(&v.Type)
+ case *Const:
+ fn(&v.Type)
+ case *Restrict:
+ fn(&v.Type)
+ case *Func:
+ fn(&v.Type)
+ case *FuncProto:
+ fn(&v.Return)
+ for i := range v.Params {
+ fn(&v.Params[i].Type)
+ }
+ case *Var:
+ fn(&v.Type)
+ case *Datasec:
+ for i := range v.Vars {
+ fn(&v.Vars[i].Type)
+ }
+ case *declTag:
+ fn(&v.Type)
+ case *typeTag:
+ fn(&v.Type)
+ case *cycle:
+ // cycle has children, but we ignore them deliberately.
+ default:
+ panic(fmt.Sprintf("don't know how to walk Type %T", v))
+ }
+}
diff --git a/vendor/github.com/cilium/ebpf/btf/types.go b/vendor/github.com/cilium/ebpf/btf/types.go
index 402a363c28ac..68d4a1757166 100644
--- a/vendor/github.com/cilium/ebpf/btf/types.go
+++ b/vendor/github.com/cilium/ebpf/btf/types.go
@@ -1,6 +1,7 @@
package btf
import (
+ "errors"
"fmt"
"io"
"math"
@@ -8,14 +9,27 @@ import (
"strings"
"github.com/cilium/ebpf/asm"
+ "github.com/cilium/ebpf/internal"
+ "github.com/cilium/ebpf/internal/sys"
)
const maxTypeDepth = 32
// TypeID identifies a type in a BTF section.
-type TypeID uint32
+type TypeID = sys.TypeID
// Type represents a type described by BTF.
+//
+// Identity of Type follows the [Go specification]: two Types are considered
+// equal if they have the same concrete type and the same dynamic value, aka
+// they point at the same location in memory. This means that the following
+// Types are considered distinct even though they have the same "shape".
+//
+// a := &Int{Size: 1}
+// b := &Int{Size: 1}
+// a != b
+//
+// [Go specification]: https://go.dev/ref/spec#Comparison_operators
type Type interface {
// Type can be formatted using the %s and %v verbs. %s outputs only the
// identity of the type, without any detail. %v outputs additional detail.
@@ -35,9 +49,7 @@ type Type interface {
// Make a copy of the type, without copying Type members.
copy() Type
- // Enumerate all nested Types. Repeated calls must visit nested
- // types in the same order.
- walk(*typeDeque)
+ // New implementations must update walkType.
}
var (
@@ -51,20 +63,11 @@ var (
_ Type = (*Var)(nil)
_ Type = (*Datasec)(nil)
_ Type = (*Float)(nil)
+ _ Type = (*declTag)(nil)
+ _ Type = (*typeTag)(nil)
+ _ Type = (*cycle)(nil)
)
-// types is a list of Type.
-//
-// The order determines the ID of a type.
-type types []Type
-
-func (ts types) ByID(id TypeID) (Type, error) {
- if int(id) > len(ts) {
- return nil, fmt.Errorf("type ID %d: %w", id, ErrNotFound)
- }
- return ts[id], nil
-}
-
// Void is the unit type of BTF.
type Void struct{}
@@ -72,40 +75,32 @@ func (v *Void) Format(fs fmt.State, verb rune) { formatType(fs, verb, v) }
func (v *Void) TypeName() string { return "" }
func (v *Void) size() uint32 { return 0 }
func (v *Void) copy() Type { return (*Void)(nil) }
-func (v *Void) walk(*typeDeque) {}
type IntEncoding byte
+// Valid IntEncodings.
+//
+// These may look like they are flags, but they aren't.
const (
- Signed IntEncoding = 1 << iota
- Char
- Bool
+ Unsigned IntEncoding = 0
+ Signed IntEncoding = 1
+ Char IntEncoding = 2
+ Bool IntEncoding = 4
)
-func (ie IntEncoding) IsSigned() bool {
- return ie&Signed != 0
-}
-
-func (ie IntEncoding) IsChar() bool {
- return ie&Char != 0
-}
-
-func (ie IntEncoding) IsBool() bool {
- return ie&Bool != 0
-}
-
func (ie IntEncoding) String() string {
- switch {
- case ie.IsChar() && ie.IsSigned():
+ switch ie {
+ case Char:
+ // NB: There is no way to determine signedness for char.
return "char"
- case ie.IsChar() && !ie.IsSigned():
- return "uchar"
- case ie.IsBool():
+ case Bool:
return "bool"
- case ie.IsSigned():
+ case Signed:
return "signed"
- default:
+ case Unsigned:
return "unsigned"
+ default:
+ return fmt.Sprintf("IntEncoding(%d)", byte(ie))
}
}
@@ -126,7 +121,6 @@ func (i *Int) Format(fs fmt.State, verb rune) {
func (i *Int) TypeName() string { return i.Name }
func (i *Int) size() uint32 { return i.Size }
-func (i *Int) walk(*typeDeque) {}
func (i *Int) copy() Type {
cpy := *i
return &cpy
@@ -141,9 +135,8 @@ func (p *Pointer) Format(fs fmt.State, verb rune) {
formatType(fs, verb, p, "target=", p.Target)
}
-func (p *Pointer) TypeName() string { return "" }
-func (p *Pointer) size() uint32 { return 8 }
-func (p *Pointer) walk(tdq *typeDeque) { tdq.push(&p.Target) }
+func (p *Pointer) TypeName() string { return "" }
+func (p *Pointer) size() uint32 { return 8 }
func (p *Pointer) copy() Type {
cpy := *p
return &cpy
@@ -162,11 +155,6 @@ func (arr *Array) Format(fs fmt.State, verb rune) {
func (arr *Array) TypeName() string { return "" }
-func (arr *Array) walk(tdq *typeDeque) {
- tdq.push(&arr.Index)
- tdq.push(&arr.Type)
-}
-
func (arr *Array) copy() Type {
cpy := *arr
return &cpy
@@ -188,12 +176,6 @@ func (s *Struct) TypeName() string { return s.Name }
func (s *Struct) size() uint32 { return s.Size }
-func (s *Struct) walk(tdq *typeDeque) {
- for i := range s.Members {
- tdq.push(&s.Members[i].Type)
- }
-}
-
func (s *Struct) copy() Type {
cpy := *s
cpy.Members = copyMembers(s.Members)
@@ -220,12 +202,6 @@ func (u *Union) TypeName() string { return u.Name }
func (u *Union) size() uint32 { return u.Size }
-func (u *Union) walk(tdq *typeDeque) {
- for i := range u.Members {
- tdq.push(&u.Members[i].Type)
- }
-}
-
func (u *Union) copy() Type {
cpy := *u
cpy.Members = copyMembers(u.Members)
@@ -243,6 +219,7 @@ func copyMembers(orig []Member) []Member {
}
type composite interface {
+ Type
members() []Member
}
@@ -273,7 +250,9 @@ type Member struct {
type Enum struct {
Name string
// Size of the enum value in bytes.
- Size uint32
+ Size uint32
+ // True if the values should be interpreted as signed integers.
+ Signed bool
Values []EnumValue
}
@@ -288,11 +267,10 @@ func (e *Enum) TypeName() string { return e.Name }
// Is is not a valid Type
type EnumValue struct {
Name string
- Value int32
+ Value uint64
}
-func (e *Enum) size() uint32 { return e.Size }
-func (e *Enum) walk(*typeDeque) {}
+func (e *Enum) size() uint32 { return e.Size }
func (e *Enum) copy() Type {
cpy := *e
cpy.Values = make([]EnumValue, len(e.Values))
@@ -300,6 +278,21 @@ func (e *Enum) copy() Type {
return &cpy
}
+// has64BitValues returns true if the Enum contains a value larger than 32 bits.
+// Kernels before 6.0 have enum values that overrun u32 replaced with zeroes.
+//
+// 64-bit enums have their Enum.Size attributes correctly set to 8, but if we
+// use the size attribute as a heuristic during BTF marshaling, we'll emit
+// ENUM64s to kernels that don't support them.
+func (e *Enum) has64BitValues() bool {
+ for _, v := range e.Values {
+ if v.Value > math.MaxUint32 {
+ return true
+ }
+ }
+ return false
+}
+
// FwdKind is the type of forward declaration.
type FwdKind int
@@ -332,7 +325,6 @@ func (f *Fwd) Format(fs fmt.State, verb rune) {
func (f *Fwd) TypeName() string { return f.Name }
-func (f *Fwd) walk(*typeDeque) {}
func (f *Fwd) copy() Type {
cpy := *f
return &cpy
@@ -350,7 +342,6 @@ func (td *Typedef) Format(fs fmt.State, verb rune) {
func (td *Typedef) TypeName() string { return td.Name }
-func (td *Typedef) walk(tdq *typeDeque) { tdq.push(&td.Type) }
func (td *Typedef) copy() Type {
cpy := *td
return &cpy
@@ -367,8 +358,7 @@ func (v *Volatile) Format(fs fmt.State, verb rune) {
func (v *Volatile) TypeName() string { return "" }
-func (v *Volatile) qualify() Type { return v.Type }
-func (v *Volatile) walk(tdq *typeDeque) { tdq.push(&v.Type) }
+func (v *Volatile) qualify() Type { return v.Type }
func (v *Volatile) copy() Type {
cpy := *v
return &cpy
@@ -385,8 +375,7 @@ func (c *Const) Format(fs fmt.State, verb rune) {
func (c *Const) TypeName() string { return "" }
-func (c *Const) qualify() Type { return c.Type }
-func (c *Const) walk(tdq *typeDeque) { tdq.push(&c.Type) }
+func (c *Const) qualify() Type { return c.Type }
func (c *Const) copy() Type {
cpy := *c
return &cpy
@@ -403,8 +392,7 @@ func (r *Restrict) Format(fs fmt.State, verb rune) {
func (r *Restrict) TypeName() string { return "" }
-func (r *Restrict) qualify() Type { return r.Type }
-func (r *Restrict) walk(tdq *typeDeque) { tdq.push(&r.Type) }
+func (r *Restrict) qualify() Type { return r.Type }
func (r *Restrict) copy() Type {
cpy := *r
return &cpy
@@ -422,13 +410,18 @@ func FuncMetadata(ins *asm.Instruction) *Func {
return fn
}
+// WithFuncMetadata adds a btf.Func to the Metadata of asm.Instruction.
+func WithFuncMetadata(ins asm.Instruction, fn *Func) asm.Instruction {
+ ins.Metadata.Set(funcInfoMeta{}, fn)
+ return ins
+}
+
func (f *Func) Format(fs fmt.State, verb rune) {
formatType(fs, verb, f, f.Linkage, "proto=", f.Type)
}
func (f *Func) TypeName() string { return f.Name }
-func (f *Func) walk(tdq *typeDeque) { tdq.push(&f.Type) }
func (f *Func) copy() Type {
cpy := *f
return &cpy
@@ -446,13 +439,6 @@ func (fp *FuncProto) Format(fs fmt.State, verb rune) {
func (fp *FuncProto) TypeName() string { return "" }
-func (fp *FuncProto) walk(tdq *typeDeque) {
- tdq.push(&fp.Return)
- for i := range fp.Params {
- tdq.push(&fp.Params[i].Type)
- }
-}
-
func (fp *FuncProto) copy() Type {
cpy := *fp
cpy.Params = make([]FuncParam, len(fp.Params))
@@ -478,7 +464,6 @@ func (v *Var) Format(fs fmt.State, verb rune) {
func (v *Var) TypeName() string { return v.Name }
-func (v *Var) walk(tdq *typeDeque) { tdq.push(&v.Type) }
func (v *Var) copy() Type {
cpy := *v
return &cpy
@@ -499,12 +484,6 @@ func (ds *Datasec) TypeName() string { return ds.Name }
func (ds *Datasec) size() uint32 { return ds.Size }
-func (ds *Datasec) walk(tdq *typeDeque) {
- for i := range ds.Vars {
- tdq.push(&ds.Vars[i].Type)
- }
-}
-
func (ds *Datasec) copy() Type {
cpy := *ds
cpy.Vars = make([]VarSecinfo, len(ds.Vars))
@@ -516,6 +495,7 @@ func (ds *Datasec) copy() Type {
//
// It is not a valid Type.
type VarSecinfo struct {
+ // Var or Func.
Type Type
Offset uint32
Size uint32
@@ -535,12 +515,48 @@ func (f *Float) Format(fs fmt.State, verb rune) {
func (f *Float) TypeName() string { return f.Name }
func (f *Float) size() uint32 { return f.Size }
-func (f *Float) walk(*typeDeque) {}
func (f *Float) copy() Type {
cpy := *f
return &cpy
}
+// declTag associates metadata with a declaration.
+type declTag struct {
+ Type Type
+ Value string
+ // The index this tag refers to in the target type. For composite types,
+ // a value of -1 indicates that the tag refers to the whole type. Otherwise
+ // it indicates which member or argument the tag applies to.
+ Index int
+}
+
+func (dt *declTag) Format(fs fmt.State, verb rune) {
+ formatType(fs, verb, dt, "type=", dt.Type, "value=", dt.Value, "index=", dt.Index)
+}
+
+func (dt *declTag) TypeName() string { return "" }
+func (dt *declTag) copy() Type {
+ cpy := *dt
+ return &cpy
+}
+
+// typeTag associates metadata with a type.
+type typeTag struct {
+ Type Type
+ Value string
+}
+
+func (tt *typeTag) Format(fs fmt.State, verb rune) {
+ formatType(fs, verb, tt, "type=", tt.Type, "value=", tt.Value)
+}
+
+func (tt *typeTag) TypeName() string { return "" }
+func (tt *typeTag) qualify() Type { return tt.Type }
+func (tt *typeTag) copy() Type {
+ cpy := *tt
+ return &cpy
+}
+
// cycle is a type which had to be elided since it exceeded maxTypeDepth.
type cycle struct {
root Type
@@ -549,7 +565,6 @@ type cycle struct {
func (c *cycle) ID() TypeID { return math.MaxUint32 }
func (c *cycle) Format(fs fmt.State, verb rune) { formatType(fs, verb, c, "root=", c.root) }
func (c *cycle) TypeName() string { return "" }
-func (c *cycle) walk(*typeDeque) {}
func (c *cycle) copy() Type {
cpy := *c
return &cpy
@@ -576,8 +591,11 @@ var (
_ qualifier = (*Const)(nil)
_ qualifier = (*Restrict)(nil)
_ qualifier = (*Volatile)(nil)
+ _ qualifier = (*typeTag)(nil)
)
+var errUnsizedType = errors.New("type is unsized")
+
// Sizeof returns the size of a type in bytes.
//
// Returns an error if the size can't be computed.
@@ -612,7 +630,7 @@ func Sizeof(typ Type) (int, error) {
continue
default:
- return 0, fmt.Errorf("unsized type %T", typ)
+ return 0, fmt.Errorf("type %T: %w", typ, errUnsizedType)
}
if n > 0 && elem > math.MaxInt64/n {
@@ -632,16 +650,33 @@ func Sizeof(typ Type) (int, error) {
// alignof returns the alignment of a type.
//
-// Currently only supports the subset of types necessary for bitfield relocations.
+// Returns an error if the Type can't be aligned, like an integer with an uneven
+// size. Currently only supports the subset of types necessary for bitfield
+// relocations.
func alignof(typ Type) (int, error) {
+ var n int
+
switch t := UnderlyingType(typ).(type) {
case *Enum:
- return int(t.size()), nil
+ n = int(t.size())
case *Int:
- return int(t.Size), nil
+ n = int(t.Size)
+ case *Array:
+ return alignof(t.Type)
default:
return 0, fmt.Errorf("can't calculate alignment of %T", t)
}
+
+ if !pow(n) {
+ return 0, fmt.Errorf("alignment value %d is not a power of two", n)
+ }
+
+ return n, nil
+}
+
+// pow returns true if n is a power of two.
+func pow(n int) bool {
+ return n != 0 && (n&(n-1)) == 0
}
// Transformer modifies a given Type and returns the result.
@@ -655,7 +690,7 @@ type Transformer func(Type) Type
// typ may form a cycle. If transform is not nil, it is called with the
// to be copied type, and the returned value is copied instead.
func Copy(typ Type, transform Transformer) Type {
- copies := make(copier)
+ copies := copier{copies: make(map[Type]Type)}
copies.copy(&typ, transform)
return typ
}
@@ -667,7 +702,7 @@ func copyTypes(types []Type, transform Transformer) []Type {
result := make([]Type, len(types))
copy(result, types)
- copies := make(copier)
+ copies := copier{copies: make(map[Type]Type, len(types))}
for i := range result {
copies.copy(&result[i], transform)
}
@@ -675,13 +710,15 @@ func copyTypes(types []Type, transform Transformer) []Type {
return result
}
-type copier map[Type]Type
+type copier struct {
+ copies map[Type]Type
+ work typeDeque
+}
-func (c copier) copy(typ *Type, transform Transformer) {
- var work typeDeque
- for t := typ; t != nil; t = work.pop() {
+func (c *copier) copy(typ *Type, transform Transformer) {
+ for t := typ; t != nil; t = c.work.Pop() {
// *t is the identity of the type.
- if cpy := c[*t]; cpy != nil {
+ if cpy := c.copies[*t]; cpy != nil {
*t = cpy
continue
}
@@ -693,108 +730,41 @@ func (c copier) copy(typ *Type, transform Transformer) {
cpy = (*t).copy()
}
- c[*t] = cpy
+ c.copies[*t] = cpy
*t = cpy
// Mark any nested types for copying.
- cpy.walk(&work)
- }
-}
-
-// typeDeque keeps track of pointers to types which still
-// need to be visited.
-type typeDeque struct {
- types []*Type
- read, write uint64
- mask uint64
-}
-
-func (dq *typeDeque) empty() bool {
- return dq.read == dq.write
-}
-
-// push adds a type to the stack.
-func (dq *typeDeque) push(t *Type) {
- if dq.write-dq.read < uint64(len(dq.types)) {
- dq.types[dq.write&dq.mask] = t
- dq.write++
- return
- }
-
- new := len(dq.types) * 2
- if new == 0 {
- new = 8
- }
-
- types := make([]*Type, new)
- pivot := dq.read & dq.mask
- n := copy(types, dq.types[pivot:])
- n += copy(types[n:], dq.types[:pivot])
- types[n] = t
-
- dq.types = types
- dq.mask = uint64(new) - 1
- dq.read, dq.write = 0, uint64(n+1)
-}
-
-// shift returns the first element or null.
-func (dq *typeDeque) shift() *Type {
- if dq.empty() {
- return nil
+ walkType(cpy, c.work.Push)
}
-
- index := dq.read & dq.mask
- t := dq.types[index]
- dq.types[index] = nil
- dq.read++
- return t
}
-// pop returns the last element or null.
-func (dq *typeDeque) pop() *Type {
- if dq.empty() {
- return nil
- }
-
- dq.write--
- index := dq.write & dq.mask
- t := dq.types[index]
- dq.types[index] = nil
- return t
-}
-
-// all returns all elements.
-//
-// The deque is empty after calling this method.
-func (dq *typeDeque) all() []*Type {
- length := dq.write - dq.read
- types := make([]*Type, 0, length)
- for t := dq.shift(); t != nil; t = dq.shift() {
- types = append(types, t)
- }
- return types
-}
+type typeDeque = internal.Deque[*Type]
// inflateRawTypes takes a list of raw btf types linked via type IDs, and turns
// it into a graph of Types connected via pointers.
//
-// If baseTypes are provided, then the raw types are
-// considered to be of a split BTF (e.g., a kernel module).
+// If base is provided, then the raw types are considered to be of a split BTF
+// (e.g., a kernel module).
//
-// Returns a slice of types indexed by TypeID. Since BTF ignores compilation
+// Returns a slice of types indexed by TypeID. Since BTF ignores compilation
// units, multiple types may share the same name. A Type may form a cyclic graph
// by pointing at itself.
-func inflateRawTypes(rawTypes []rawType, baseTypes types, rawStrings *stringTable) ([]Type, error) {
+func inflateRawTypes(rawTypes []rawType, rawStrings *stringTable, base *Spec) ([]Type, error) {
types := make([]Type, 0, len(rawTypes)+1) // +1 for Void added to base types
- typeIDOffset := TypeID(1) // Void is TypeID(0), so the rest starts from TypeID(1)
+ // Void is defined to always be type ID 0, and is thus omitted from BTF.
+ types = append(types, (*Void)(nil))
- if baseTypes == nil {
- // Void is defined to always be type ID 0, and is thus omitted from BTF.
- types = append(types, (*Void)(nil))
- } else {
- // For split BTF, the next ID is max base BTF type ID + 1
- typeIDOffset = TypeID(len(baseTypes))
+ firstTypeID := TypeID(0)
+ if base != nil {
+ var err error
+ firstTypeID, err = base.nextTypeID()
+ if err != nil {
+ return nil, err
+ }
+
+ // Split BTF doesn't contain Void.
+ types = types[:0]
}
type fixupDef struct {
@@ -803,39 +773,42 @@ func inflateRawTypes(rawTypes []rawType, baseTypes types, rawStrings *stringTabl
}
var fixups []fixupDef
- fixup := func(id TypeID, typ *Type) {
- if id < TypeID(len(baseTypes)) {
- *typ = baseTypes[id]
- return
+ fixup := func(id TypeID, typ *Type) bool {
+ if id < firstTypeID {
+ if baseType, err := base.TypeByID(id); err == nil {
+ *typ = baseType
+ return true
+ }
}
- idx := id
- if baseTypes != nil {
- idx = id - TypeID(len(baseTypes))
- }
- if idx < TypeID(len(types)) {
+ idx := int(id - firstTypeID)
+ if idx < len(types) {
// We've already inflated this type, fix it up immediately.
*typ = types[idx]
- return
+ return true
}
+
fixups = append(fixups, fixupDef{id, typ})
+ return false
}
type assertion struct {
+ id TypeID
typ *Type
want reflect.Type
}
var assertions []assertion
- assert := func(typ *Type, want reflect.Type) error {
- if *typ != nil {
- // The type has already been fixed up, check the type immediately.
- if reflect.TypeOf(*typ) != want {
- return fmt.Errorf("expected %s, got %T", want, *typ)
- }
+ fixupAndAssert := func(id TypeID, typ *Type, want reflect.Type) error {
+ if !fixup(id, typ) {
+ assertions = append(assertions, assertion{id, typ, want})
return nil
}
- assertions = append(assertions, assertion{typ, want})
+
+ // The type has already been fixed up, check the type immediately.
+ if reflect.TypeOf(*typ) != want {
+ return fmt.Errorf("type ID %d: expected %s, got %T", id, want, *typ)
+ }
return nil
}
@@ -903,12 +876,17 @@ func inflateRawTypes(rawTypes []rawType, baseTypes types, rawStrings *stringTabl
return members, nil
}
- for i, raw := range rawTypes {
+ var declTags []*declTag
+ for _, raw := range rawTypes {
var (
- id = typeIDOffset + TypeID(i)
+ id = firstTypeID + TypeID(len(types))
typ Type
)
+ if id < firstTypeID {
+ return nil, fmt.Errorf("no more type IDs")
+ }
+
name, err := rawStrings.Lookup(raw.NameOff)
if err != nil {
return nil, fmt.Errorf("get name for type id %d: %w", id, err)
@@ -936,14 +914,14 @@ func inflateRawTypes(rawTypes []rawType, baseTypes types, rawStrings *stringTabl
typ = arr
case kindStruct:
- members, err := convertMembers(raw.data.([]btfMember), raw.KindFlag())
+ members, err := convertMembers(raw.data.([]btfMember), raw.Bitfield())
if err != nil {
return nil, fmt.Errorf("struct %s (id %d): %w", name, id, err)
}
typ = &Struct{name, raw.Size(), members}
case kindUnion:
- members, err := convertMembers(raw.data.([]btfMember), raw.KindFlag())
+ members, err := convertMembers(raw.data.([]btfMember), raw.Bitfield())
if err != nil {
return nil, fmt.Errorf("union %s (id %d): %w", name, id, err)
}
@@ -952,24 +930,23 @@ func inflateRawTypes(rawTypes []rawType, baseTypes types, rawStrings *stringTabl
case kindEnum:
rawvals := raw.data.([]btfEnum)
vals := make([]EnumValue, 0, len(rawvals))
+ signed := raw.Signed()
for i, btfVal := range rawvals {
name, err := rawStrings.Lookup(btfVal.NameOff)
if err != nil {
return nil, fmt.Errorf("get name for enum value %d: %s", i, err)
}
- vals = append(vals, EnumValue{
- Name: name,
- Value: btfVal.Val,
- })
+ value := uint64(btfVal.Val)
+ if signed {
+ // Sign extend values to 64 bit.
+ value = uint64(int32(btfVal.Val))
+ }
+ vals = append(vals, EnumValue{name, value})
}
- typ = &Enum{name, raw.Size(), vals}
+ typ = &Enum{name, raw.Size(), signed, vals}
case kindForward:
- if raw.KindFlag() {
- typ = &Fwd{name, FwdUnion}
- } else {
- typ = &Fwd{name, FwdStruct}
- }
+ typ = &Fwd{name, raw.FwdKind()}
case kindTypedef:
typedef := &Typedef{name, nil}
@@ -993,8 +970,7 @@ func inflateRawTypes(rawTypes []rawType, baseTypes types, rawStrings *stringTabl
case kindFunc:
fn := &Func{name, nil, raw.Linkage()}
- fixup(raw.Type(), &fn.Type)
- if err := assert(&fn.Type, reflect.TypeOf((*FuncProto)(nil))); err != nil {
+ if err := fixupAndAssert(raw.Type(), &fn.Type, reflect.TypeOf((*FuncProto)(nil))); err != nil {
return nil, err
}
typ = fn
@@ -1036,15 +1012,42 @@ func inflateRawTypes(rawTypes []rawType, baseTypes types, rawStrings *stringTabl
}
for i := range vars {
fixup(btfVars[i].Type, &vars[i].Type)
- if err := assert(&vars[i].Type, reflect.TypeOf((*Var)(nil))); err != nil {
- return nil, err
- }
}
- typ = &Datasec{name, raw.SizeType, vars}
+ typ = &Datasec{name, raw.Size(), vars}
case kindFloat:
typ = &Float{name, raw.Size()}
+ case kindDeclTag:
+ btfIndex := raw.data.(*btfDeclTag).ComponentIdx
+ if uint64(btfIndex) > math.MaxInt {
+ return nil, fmt.Errorf("type id %d: index exceeds int", id)
+ }
+
+ dt := &declTag{nil, name, int(int32(btfIndex))}
+ fixup(raw.Type(), &dt.Type)
+ typ = dt
+
+ declTags = append(declTags, dt)
+
+ case kindTypeTag:
+ tt := &typeTag{nil, name}
+ fixup(raw.Type(), &tt.Type)
+ typ = tt
+
+ case kindEnum64:
+ rawvals := raw.data.([]btfEnum64)
+ vals := make([]EnumValue, 0, len(rawvals))
+ for i, btfVal := range rawvals {
+ name, err := rawStrings.Lookup(btfVal.NameOff)
+ if err != nil {
+ return nil, fmt.Errorf("get name for enum64 value %d: %s", i, err)
+ }
+ value := (uint64(btfVal.ValHi32) << 32) | uint64(btfVal.ValLo32)
+ vals = append(vals, EnumValue{name, value})
+ }
+ typ = &Enum{name, raw.Size(), raw.Signed(), vals}
+
default:
return nil, fmt.Errorf("type id %d: unknown kind: %v", id, raw.Kind())
}
@@ -1053,19 +1056,20 @@ func inflateRawTypes(rawTypes []rawType, baseTypes types, rawStrings *stringTabl
}
for _, fixup := range fixups {
- i := int(fixup.id)
- if i >= len(types)+len(baseTypes) {
- return nil, fmt.Errorf("reference to invalid type id: %d", fixup.id)
+ if fixup.id < firstTypeID {
+ return nil, fmt.Errorf("fixup for base type id %d is not expected", fixup.id)
}
- if i < len(baseTypes) {
- return nil, fmt.Errorf("fixup for base type id %d is not expected", i)
+
+ idx := int(fixup.id - firstTypeID)
+ if idx >= len(types) {
+ return nil, fmt.Errorf("reference to invalid type id: %d", fixup.id)
}
- *fixup.typ = types[i-len(baseTypes)]
+ *fixup.typ = types[idx]
}
for _, bitfieldFixup := range bitfieldFixups {
- if bitfieldFixup.id < TypeID(len(baseTypes)) {
+ if bitfieldFixup.id < firstTypeID {
return nil, fmt.Errorf("bitfield fixup from split to base types is not expected")
}
@@ -1079,7 +1083,29 @@ func inflateRawTypes(rawTypes []rawType, baseTypes types, rawStrings *stringTabl
for _, assertion := range assertions {
if reflect.TypeOf(*assertion.typ) != assertion.want {
- return nil, fmt.Errorf("expected %s, got %T", assertion.want, *assertion.typ)
+ return nil, fmt.Errorf("type ID %d: expected %s, got %T", assertion.id, assertion.want, *assertion.typ)
+ }
+ }
+
+ for _, dt := range declTags {
+ switch t := dt.Type.(type) {
+ case *Var, *Typedef:
+ if dt.Index != -1 {
+ return nil, fmt.Errorf("type %s: index %d is not -1", dt, dt.Index)
+ }
+
+ case composite:
+ if dt.Index >= len(t.members()) {
+ return nil, fmt.Errorf("type %s: index %d exceeds members of %s", dt, dt.Index, t)
+ }
+
+ case *Func:
+ if dt.Index >= len(t.Type.(*FuncProto).Params) {
+ return nil, fmt.Errorf("type %s: index %d exceeds params of %s", dt, dt.Index, t)
+ }
+
+ default:
+ return nil, fmt.Errorf("type %s: decl tag for type %s is not supported", dt, t)
}
}
@@ -1123,6 +1149,29 @@ func UnderlyingType(typ Type) Type {
return &cycle{typ}
}
+// as returns typ if is of type T. Otherwise it peels qualifiers and Typedefs
+// until it finds a T.
+//
+// Returns the zero value and false if there is no T or if the type is nested
+// too deeply.
+func as[T Type](typ Type) (T, bool) {
+ for depth := 0; depth <= maxTypeDepth; depth++ {
+ switch v := (typ).(type) {
+ case T:
+ return v, true
+ case qualifier:
+ typ = v.qualify()
+ case *Typedef:
+ typ = v.Type
+ default:
+ goto notFound
+ }
+ }
+notFound:
+ var zero T
+ return zero, false
+}
+
type formatState struct {
fmt.State
depth int
@@ -1145,10 +1194,7 @@ func formatType(f fmt.State, verb rune, t formattableType, extra ...interface{})
return
}
- // This is the same as %T, but elides the package name. Assumes that
- // formattableType is implemented by a pointer receiver.
- goTypeName := reflect.TypeOf(t).Elem().Name()
- _, _ = io.WriteString(f, goTypeName)
+ _, _ = io.WriteString(f, internal.GoTypeName(t))
if name := t.TypeName(); name != "" {
// Output BTF type name if present.
diff --git a/vendor/github.com/cilium/ebpf/btf/workarounds.go b/vendor/github.com/cilium/ebpf/btf/workarounds.go
new file mode 100644
index 000000000000..12a89b87eedb
--- /dev/null
+++ b/vendor/github.com/cilium/ebpf/btf/workarounds.go
@@ -0,0 +1,26 @@
+package btf
+
+// datasecResolveWorkaround ensures that certain vars in a Datasec are added
+// to a Spec before the Datasec. This avoids a bug in kernel BTF validation.
+//
+// See https://lore.kernel.org/bpf/20230302123440.1193507-1-lmb@isovalent.com/
+func datasecResolveWorkaround(b *Builder, ds *Datasec) error {
+ for _, vsi := range ds.Vars {
+ v, ok := vsi.Type.(*Var)
+ if !ok {
+ continue
+ }
+
+ switch v.Type.(type) {
+ case *Typedef, *Volatile, *Const, *Restrict, *typeTag:
+ // NB: We must never call Add on a Datasec, otherwise we risk
+ // infinite recursion.
+ _, err := b.Add(v.Type)
+ if err != nil {
+ return err
+ }
+ }
+ }
+
+ return nil
+}
diff --git a/vendor/github.com/cilium/ebpf/collection.go b/vendor/github.com/cilium/ebpf/collection.go
index 8c2ddc380214..fb720bebdb7b 100644
--- a/vendor/github.com/cilium/ebpf/collection.go
+++ b/vendor/github.com/cilium/ebpf/collection.go
@@ -9,6 +9,8 @@ import (
"github.com/cilium/ebpf/asm"
"github.com/cilium/ebpf/btf"
+ "github.com/cilium/ebpf/internal"
+ "github.com/cilium/ebpf/internal/kconfig"
)
// CollectionOptions control loading a collection into the kernel.
@@ -107,12 +109,22 @@ func (cs *CollectionSpec) RewriteMaps(maps map[string]*Map) error {
return nil
}
+// MissingConstantsError is returned by [CollectionSpec.RewriteConstants].
+type MissingConstantsError struct {
+ // The constants missing from .rodata.
+ Constants []string
+}
+
+func (m *MissingConstantsError) Error() string {
+ return fmt.Sprintf("some constants are missing from .rodata: %s", strings.Join(m.Constants, ", "))
+}
+
// RewriteConstants replaces the value of multiple constants.
//
// The constant must be defined like so in the C program:
//
-// volatile const type foobar;
-// volatile const type foobar = default;
+// volatile const type foobar;
+// volatile const type foobar = default;
//
// Replacement values must be of the same length as the C sizeof(type).
// If necessary, they are marshalled according to the same rules as
@@ -120,7 +132,7 @@ func (cs *CollectionSpec) RewriteMaps(maps map[string]*Map) error {
//
// From Linux 5.5 the verifier will use constants to eliminate dead code.
//
-// Returns an error if a constant doesn't exist.
+// Returns an error wrapping [MissingConstantsError] if a constant doesn't exist.
func (cs *CollectionSpec) RewriteConstants(consts map[string]interface{}) error {
replaced := make(map[string]bool)
@@ -151,6 +163,10 @@ func (cs *CollectionSpec) RewriteConstants(consts map[string]interface{}) error
continue
}
+ if _, ok := v.Type.(*btf.Var); !ok {
+ return fmt.Errorf("section %s: unexpected type %T for variable %s", name, v.Type, vname)
+ }
+
if replaced[vname] {
return fmt.Errorf("section %s: duplicate variable %s", name, vname)
}
@@ -180,7 +196,7 @@ func (cs *CollectionSpec) RewriteConstants(consts map[string]interface{}) error
}
if len(missing) != 0 {
- return fmt.Errorf("spec is missing one or more constants: %s", strings.Join(missing, ","))
+ return fmt.Errorf("rewrite constants: %w", &MissingConstantsError{Constants: missing})
}
return nil
@@ -198,11 +214,11 @@ func (cs *CollectionSpec) RewriteConstants(consts map[string]interface{}) error
// The tag's value specifies the name of the program or map as
// found in the CollectionSpec.
//
-// struct {
-// Foo *ebpf.ProgramSpec `ebpf:"xdp_foo"`
-// Bar *ebpf.MapSpec `ebpf:"bar_map"`
-// Ignored int
-// }
+// struct {
+// Foo *ebpf.ProgramSpec `ebpf:"xdp_foo"`
+// Bar *ebpf.MapSpec `ebpf:"bar_map"`
+// Ignored int
+// }
//
// Returns an error if any of the eBPF objects can't be found, or
// if the same MapSpec or ProgramSpec is assigned multiple times.
@@ -249,11 +265,11 @@ func (cs *CollectionSpec) Assign(to interface{}) error {
// dependent resources are loaded into the kernel and populated with values if
// specified.
//
-// struct {
-// Foo *ebpf.Program `ebpf:"xdp_foo"`
-// Bar *ebpf.Map `ebpf:"bar_map"`
-// Ignored int
-// }
+// struct {
+// Foo *ebpf.Program `ebpf:"xdp_foo"`
+// Bar *ebpf.Map `ebpf:"bar_map"`
+// Ignored int
+// }
//
// opts may be nil.
//
@@ -386,42 +402,11 @@ func NewCollectionWithOptions(spec *CollectionSpec, opts CollectionOptions) (*Co
}, nil
}
-type handleCache struct {
- btfHandles map[*btf.Spec]*btf.Handle
-}
-
-func newHandleCache() *handleCache {
- return &handleCache{
- btfHandles: make(map[*btf.Spec]*btf.Handle),
- }
-}
-
-func (hc handleCache) btfHandle(spec *btf.Spec) (*btf.Handle, error) {
- if hc.btfHandles[spec] != nil {
- return hc.btfHandles[spec], nil
- }
-
- handle, err := btf.NewHandle(spec)
- if err != nil {
- return nil, err
- }
-
- hc.btfHandles[spec] = handle
- return handle, nil
-}
-
-func (hc handleCache) close() {
- for _, handle := range hc.btfHandles {
- handle.Close()
- }
-}
-
type collectionLoader struct {
coll *CollectionSpec
opts *CollectionOptions
maps map[string]*Map
programs map[string]*Program
- handles *handleCache
}
func newCollectionLoader(coll *CollectionSpec, opts *CollectionOptions) (*collectionLoader, error) {
@@ -436,7 +421,7 @@ func newCollectionLoader(coll *CollectionSpec, opts *CollectionOptions) (*collec
return nil, fmt.Errorf("replacement map %s not found in CollectionSpec", name)
}
- if err := spec.checkCompatibility(m); err != nil {
+ if err := spec.Compatible(m); err != nil {
return nil, fmt.Errorf("using replacement map %s: %w", spec.Name, err)
}
}
@@ -446,13 +431,11 @@ func newCollectionLoader(coll *CollectionSpec, opts *CollectionOptions) (*collec
opts,
make(map[string]*Map),
make(map[string]*Program),
- newHandleCache(),
}, nil
}
// close all resources left over in the collectionLoader.
func (cl *collectionLoader) close() {
- cl.handles.close()
for _, m := range cl.maps {
m.Close()
}
@@ -471,10 +454,6 @@ func (cl *collectionLoader) loadMap(mapName string) (*Map, error) {
return nil, fmt.Errorf("missing map %s", mapName)
}
- if mapSpec.BTF != nil && cl.coll.Types != mapSpec.BTF {
- return nil, fmt.Errorf("map %s: BTF doesn't match collection", mapName)
- }
-
if replaceMap, ok := cl.opts.MapReplacements[mapName]; ok {
// Clone the map to avoid closing user's map later on.
m, err := replaceMap.Clone()
@@ -486,7 +465,7 @@ func (cl *collectionLoader) loadMap(mapName string) (*Map, error) {
return m, nil
}
- m, err := newMapWithOptions(mapSpec, cl.opts.Maps, cl.handles)
+ m, err := newMapWithOptions(mapSpec, cl.opts.Maps)
if err != nil {
return nil, fmt.Errorf("map %s: %w", mapName, err)
}
@@ -511,10 +490,6 @@ func (cl *collectionLoader) loadProgram(progName string) (*Program, error) {
return nil, fmt.Errorf("cannot load program %s: program type is unspecified", progName)
}
- if progSpec.BTF != nil && cl.coll.Types != progSpec.BTF {
- return nil, fmt.Errorf("program %s: BTF doesn't match collection", progName)
- }
-
progSpec = progSpec.Copy()
// Rewrite any reference to a valid map in the program's instructions,
@@ -543,7 +518,7 @@ func (cl *collectionLoader) loadProgram(progName string) (*Program, error) {
}
}
- prog, err := newProgramWithOptions(progSpec, cl.opts.Programs, cl.handles)
+ prog, err := newProgramWithOptions(progSpec, cl.opts.Programs)
if err != nil {
return nil, fmt.Errorf("program %s: %w", progName, err)
}
@@ -559,17 +534,22 @@ func (cl *collectionLoader) populateMaps() error {
return fmt.Errorf("missing map spec %s", mapName)
}
- mapSpec = mapSpec.Copy()
-
// MapSpecs that refer to inner maps or programs within the same
// CollectionSpec do so using strings. These strings are used as the key
// to look up the respective object in the Maps or Programs fields.
// Resolve those references to actual Map or Program resources that
// have been loaded into the kernel.
- for i, kv := range mapSpec.Contents {
- if objName, ok := kv.Value.(string); ok {
- switch mapSpec.Type {
- case ProgramArray:
+ if mapSpec.Type.canStoreMap() || mapSpec.Type.canStoreProgram() {
+ mapSpec = mapSpec.Copy()
+
+ for i, kv := range mapSpec.Contents {
+ objName, ok := kv.Value.(string)
+ if !ok {
+ continue
+ }
+
+ switch t := mapSpec.Type; {
+ case t.canStoreProgram():
// loadProgram is idempotent and could return an existing Program.
prog, err := cl.loadProgram(objName)
if err != nil {
@@ -577,7 +557,7 @@ func (cl *collectionLoader) populateMaps() error {
}
mapSpec.Contents[i] = MapKV{kv.Key, prog}
- case ArrayOfMaps, HashOfMaps:
+ case t.canStoreMap():
// loadMap is idempotent and could return an existing Map.
innerMap, err := cl.loadMap(objName)
if err != nil {
@@ -597,6 +577,95 @@ func (cl *collectionLoader) populateMaps() error {
return nil
}
+// resolveKconfig resolves all variables declared in .kconfig and populates
+// m.Contents. Does nothing if the given m.Contents is non-empty.
+func resolveKconfig(m *MapSpec) error {
+ ds, ok := m.Value.(*btf.Datasec)
+ if !ok {
+ return errors.New("map value is not a Datasec")
+ }
+
+ type configInfo struct {
+ offset uint32
+ typ btf.Type
+ }
+
+ configs := make(map[string]configInfo)
+
+ data := make([]byte, ds.Size)
+ for _, vsi := range ds.Vars {
+ v := vsi.Type.(*btf.Var)
+ n := v.TypeName()
+
+ switch n {
+ case "LINUX_KERNEL_VERSION":
+ if integer, ok := v.Type.(*btf.Int); !ok || integer.Size != 4 {
+ return fmt.Errorf("variable %s must be a 32 bits integer, got %s", n, v.Type)
+ }
+
+ kv, err := internal.KernelVersion()
+ if err != nil {
+ return fmt.Errorf("getting kernel version: %w", err)
+ }
+ internal.NativeEndian.PutUint32(data[vsi.Offset:], kv.Kernel())
+
+ case "LINUX_HAS_SYSCALL_WRAPPER":
+ if integer, ok := v.Type.(*btf.Int); !ok || integer.Size != 4 {
+ return fmt.Errorf("variable %s must be a 32 bits integer, got %s", n, v.Type)
+ }
+ var value uint32 = 1
+ if err := haveSyscallWrapper(); errors.Is(err, ErrNotSupported) {
+ value = 0
+ } else if err != nil {
+ return fmt.Errorf("unable to derive a value for LINUX_HAS_SYSCALL_WRAPPER: %w", err)
+ }
+
+ internal.NativeEndian.PutUint32(data[vsi.Offset:], value)
+
+ default: // Catch CONFIG_*.
+ configs[n] = configInfo{
+ offset: vsi.Offset,
+ typ: v.Type,
+ }
+ }
+ }
+
+ // We only parse kconfig file if a CONFIG_* variable was found.
+ if len(configs) > 0 {
+ f, err := kconfig.Find()
+ if err != nil {
+ return fmt.Errorf("cannot find a kconfig file: %w", err)
+ }
+ defer f.Close()
+
+ filter := make(map[string]struct{}, len(configs))
+ for config := range configs {
+ filter[config] = struct{}{}
+ }
+
+ kernelConfig, err := kconfig.Parse(f, filter)
+ if err != nil {
+ return fmt.Errorf("cannot parse kconfig file: %w", err)
+ }
+
+ for n, info := range configs {
+ value, ok := kernelConfig[n]
+ if !ok {
+ return fmt.Errorf("config option %q does not exists for this kernel", n)
+ }
+
+ err := kconfig.PutValue(data[info.offset:], info.typ, value)
+ if err != nil {
+ return fmt.Errorf("problem adding value for %s: %w", n, err)
+ }
+ }
+ }
+
+ m.Contents = []MapKV{{uint32(0), data}}
+
+ return nil
+}
+
// LoadCollection reads an object file and creates and loads its declared
// resources into the kernel.
//
diff --git a/vendor/github.com/cilium/ebpf/elf_reader.go b/vendor/github.com/cilium/ebpf/elf_reader.go
index df278895c631..8d92672eb144 100644
--- a/vendor/github.com/cilium/ebpf/elf_reader.go
+++ b/vendor/github.com/cilium/ebpf/elf_reader.go
@@ -18,6 +18,15 @@ import (
"github.com/cilium/ebpf/internal/unix"
)
+type kconfigMetaKey struct{}
+
+type kconfigMeta struct {
+ Map *MapSpec
+ Offset uint32
+}
+
+type kfuncMeta struct{}
+
// elfCode is a convenience to reduce the amount of arguments that have to
// be passed around explicitly. You should treat its contents as immutable.
type elfCode struct {
@@ -27,6 +36,9 @@ type elfCode struct {
version uint32
btf *btf.Spec
extInfo *btf.ExtInfos
+ maps map[string]*MapSpec
+ kfuncs map[string]*btf.Func
+ kconfig *MapSpec
}
// LoadCollectionSpec parses an ELF file into a CollectionSpec.
@@ -51,6 +63,12 @@ func LoadCollectionSpecFromReader(rd io.ReaderAt) (*CollectionSpec, error) {
return nil, err
}
+ // Checks if the ELF file is for BPF data.
+ // Old LLVM versions set e_machine to EM_NONE.
+ if f.File.Machine != unix.EM_NONE && f.File.Machine != elf.EM_BPF {
+ return nil, fmt.Errorf("unexpected machine type for BPF ELF: %s", f.File.Machine)
+ }
+
var (
licenseSection *elf.Section
versionSection *elf.Section
@@ -107,6 +125,8 @@ func LoadCollectionSpecFromReader(rd io.ReaderAt) (*CollectionSpec, error) {
version: version,
btf: btfSpec,
extInfo: btfExtInfo,
+ maps: make(map[string]*MapSpec),
+ kfuncs: make(map[string]*btf.Func),
}
symbols, err := f.Symbols()
@@ -120,27 +140,33 @@ func LoadCollectionSpecFromReader(rd io.ReaderAt) (*CollectionSpec, error) {
return nil, fmt.Errorf("load relocations: %w", err)
}
- // Collect all the various ways to define maps.
- maps := make(map[string]*MapSpec)
- if err := ec.loadMaps(maps); err != nil {
+ if err := ec.loadMaps(); err != nil {
return nil, fmt.Errorf("load maps: %w", err)
}
- if err := ec.loadBTFMaps(maps); err != nil {
+ if err := ec.loadBTFMaps(); err != nil {
return nil, fmt.Errorf("load BTF maps: %w", err)
}
- if err := ec.loadDataSections(maps); err != nil {
+ if err := ec.loadDataSections(); err != nil {
return nil, fmt.Errorf("load data sections: %w", err)
}
+ if err := ec.loadKconfigSection(); err != nil {
+ return nil, fmt.Errorf("load virtual .kconfig section: %w", err)
+ }
+
+ if err := ec.loadKsymsSection(); err != nil {
+ return nil, fmt.Errorf("load virtual .ksyms section: %w", err)
+ }
+
// Finally, collect programs and link them.
progs, err := ec.loadProgramSections()
if err != nil {
return nil, fmt.Errorf("load programs: %w", err)
}
- return &CollectionSpec{maps, progs, btfSpec, ec.ByteOrder}, nil
+ return &CollectionSpec{ec.maps, progs, btfSpec, ec.ByteOrder}, nil
}
func loadLicense(sec *elf.Section) (string, error) {
@@ -261,10 +287,6 @@ func (ec *elfCode) loadRelocations(relSections map[elf.SectionIndex]*elf.Section
return fmt.Errorf("section %q: reference to %q in section %s: %w", section.Name, rel.Name, rel.Section, ErrNotSupported)
}
- if target.Flags&elf.SHF_STRINGS > 0 {
- return fmt.Errorf("section %q: string is not stack allocated: %w", section.Name, ErrNotSupported)
- }
-
target.references++
}
@@ -312,7 +334,6 @@ func (ec *elfCode) loadProgramSections() (map[string]*ProgramSpec, error) {
KernelVersion: ec.version,
Instructions: insns,
ByteOrder: ec.ByteOrder,
- BTF: ec.btf,
}
// Function names must be unique within a single ELF blob.
@@ -565,6 +586,10 @@ func (ec *elfCode) relocateInstruction(ins *asm.Instruction, rel elf.Symbol) err
return fmt.Errorf("neither a call nor a load instruction: %v", ins)
}
+ // The Undefined section is used for 'virtual' symbols that aren't backed by
+ // an ELF section. This includes symbol references from inline asm, forward
+ // function declarations, as well as extern kfunc declarations using __ksym
+ // and extern kconfig variables declared using __kconfig.
case undefSection:
if bind != elf.STB_GLOBAL {
return fmt.Errorf("asm relocation: %s: unsupported binding: %s", name, bind)
@@ -574,7 +599,36 @@ func (ec *elfCode) relocateInstruction(ins *asm.Instruction, rel elf.Symbol) err
return fmt.Errorf("asm relocation: %s: unsupported type %s", name, typ)
}
- // There is nothing to do here but set ins.Reference.
+ kf := ec.kfuncs[name]
+ switch {
+ // If a Call instruction is found and the datasec has a btf.Func with a Name
+ // that matches the symbol name we mark the instruction as a call to a kfunc.
+ case kf != nil && ins.OpCode.JumpOp() == asm.Call:
+ ins.Metadata.Set(kfuncMeta{}, kf)
+ ins.Src = asm.PseudoKfuncCall
+ ins.Constant = -1
+
+ // If no kconfig map is found, this must be a symbol reference from inline
+ // asm (see testdata/loader.c:asm_relocation()) or a call to a forward
+ // function declaration (see testdata/fwd_decl.c). Don't interfere, These
+ // remain standard symbol references.
+ // extern __kconfig reads are represented as dword loads that need to be
+ // rewritten to pseudo map loads from .kconfig. If the map is present,
+ // require it to contain the symbol to disambiguate between inline asm
+ // relos and kconfigs.
+ case ec.kconfig != nil && ins.OpCode.IsDWordLoad():
+ for _, vsi := range ec.kconfig.Value.(*btf.Datasec).Vars {
+ if vsi.Type.(*btf.Var).Name != rel.Name {
+ continue
+ }
+
+ ins.Src = asm.PseudoMapValue
+ ins.Metadata.Set(kconfigMetaKey{}, &kconfigMeta{ec.kconfig, vsi.Offset})
+ return nil
+ }
+
+ return fmt.Errorf("kconfig %s not found in .kconfig", rel.Name)
+ }
default:
return fmt.Errorf("relocation to %q: %w", target.Name, ErrNotSupported)
@@ -584,7 +638,7 @@ func (ec *elfCode) relocateInstruction(ins *asm.Instruction, rel elf.Symbol) err
return nil
}
-func (ec *elfCode) loadMaps(maps map[string]*MapSpec) error {
+func (ec *elfCode) loadMaps() error {
for _, sec := range ec.sections {
if sec.kind != mapSection {
continue
@@ -610,7 +664,7 @@ func (ec *elfCode) loadMaps(maps map[string]*MapSpec) error {
}
mapName := mapSym.Name
- if maps[mapName] != nil {
+ if ec.maps[mapName] != nil {
return fmt.Errorf("section %v: map %v already exists", sec.Name, mapSym)
}
@@ -644,7 +698,7 @@ func (ec *elfCode) loadMaps(maps map[string]*MapSpec) error {
return fmt.Errorf("map %s: %w", mapName, err)
}
- maps[mapName] = &spec
+ ec.maps[mapName] = &spec
}
}
@@ -654,7 +708,7 @@ func (ec *elfCode) loadMaps(maps map[string]*MapSpec) error {
// loadBTFMaps iterates over all ELF sections marked as BTF map sections
// (like .maps) and parses them into MapSpecs. Dump the .maps section and
// any relocations with `readelf -x .maps -r + +* Install `containerd-fuse-overlayfs-grpc` binary. The binary will be installed under `$DESTDIR/bin`. +```console +$ make && DESTDIR=$HOME make install +``` + +* Create the following configuration in `~/.config/containerd/config.toml`: +```toml +version = 2 +# substitute "/home/suda" with your own $HOME +root = "/home/suda/.local/share/containerd" +# substitute "/run/user/1001" with your own $XDG_RUNTIME_DIR +state = "/run/user/1001/containerd" + +[grpc] + address = "/run/user/1001/containerd/containerd.sock" + +[proxy_plugins] + [proxy_plugins."fuse-overlayfs"] + type = "snapshot" + address = "/run/user/1001/containerd/fuse-overlayfs.sock" +``` + +* Start [RootlessKit](/~https://github.com/rootless-containers/rootlesskit) with `sleep infinity` (or any kind of "pause" command): +```console +$ rootlesskit \ + --net=slirp4netns --disable-host-loopback \ + --copy-up=/etc --copy-up=/run \ + --state-dir=$XDG_RUNTIME_DIR/rootlesskit-containerd \ + sh -c "rm -rf /run/containerd ; sleep infinity" +``` +(Note: `rm -rf /run/containerd` is a workaround for [containerd/containerd#2767](/~https://github.com/containerd/containerd/issues/2767)) + +* Enter the RootlessKit namespaces and run `containerd-fuse-overlayfs-grpc`: +```console +$ nsenter -U --preserve-credentials -m -n -t $(cat $XDG_RUNTIME_DIR/rootlesskit-containerd/child_pid) \ + containerd-fuse-overlayfs-grpc $XDG_RUNTIME_DIR/containerd/fuse-overlayfs.sock $HOME/.local/share/containerd-fuse-overlayfs +``` + +* Enter the same namespaces and run `containerd`: +```console +$ nsenter -U --preserve-credentials -m -n -t $(cat $XDG_RUNTIME_DIR/rootlesskit-containerd/child_pid) \ + containerd -c $HOME/.config/containerd/config.toml +``` + +
++ +This library provides options for fast detection and rejection of duplicate map keys based on applying a Go-specific data model to CBOR's extended generic data model in order to determine duplicate vs distinct map keys. Detection relies on whether the CBOR map key would be a duplicate "key" when decoded and applied to the user-provided Go map or struct. + +`DupMapKeyQuiet` turns off detection of duplicate map keys. It tries to use a "keep fastest" method by choosing either "keep first" or "keep last" depending on the Go data type. + +`DupMapKeyEnforcedAPF` enforces detection and rejection of duplidate map keys. Decoding stops immediately and returns `DupMapKeyError` when the first duplicate key is detected. The error includes the duplicate map key and the index number. + +APF suffix means "Allow Partial Fill" so the destination map or struct can contain some decoded values at the time of error. It is the caller's responsibility to respond to the `DupMapKeyError` by discarding the partially filled result if that's required by their protocol. + +
+ +This library checks tag validity for built-in tags (currently tag numbers 0, 1, 2, 3, and 55799): + +* Inadmissible type for tag content +* Inadmissible value for tag content + +Unknown tag data items (not tag number 0, 1, 2, 3, or 55799) are handled in two ways: + +* When decoding into an empty interface, unknown tag data item will be decoded into `cbor.Tag` data type, which contains tag number and tag content. The tag content will be decoded into the default Go data type for the CBOR data type. +* When decoding into other Go types, unknown tag data item is decoded into the specified Go type. If Go type is registered with a tag number, the tag number can optionally be verified. + +Decoder also has an option to forbid tag data items (treat any tag data item as error) which is specified by protocols such as CTAP2 Canonical CBOR. + +For more information, see [decoding options](#decoding-options-1) and [tag options](#tag-options). + +
+
+
+
+### Mergo in the wild
+
+- [cli/cli](/~https://github.com/cli/cli)
+- [moby/moby](/~https://github.com/moby/moby)
+- [kubernetes/kubernetes](/~https://github.com/kubernetes/kubernetes)
+- [vmware/dispatch](/~https://github.com/vmware/dispatch)
+- [Shopify/themekit](/~https://github.com/Shopify/themekit)
+- [imdario/zas](/~https://github.com/imdario/zas)
+- [matcornic/hermes](/~https://github.com/matcornic/hermes)
+- [OpenBazaar/openbazaar-go](/~https://github.com/OpenBazaar/openbazaar-go)
+- [kataras/iris](/~https://github.com/kataras/iris)
+- [michaelsauter/crane](/~https://github.com/michaelsauter/crane)
+- [go-task/task](/~https://github.com/go-task/task)
+- [sensu/uchiwa](/~https://github.com/sensu/uchiwa)
+- [ory/hydra](/~https://github.com/ory/hydra)
+- [sisatech/vcli](/~https://github.com/sisatech/vcli)
+- [dairycart/dairycart](/~https://github.com/dairycart/dairycart)
+- [projectcalico/felix](/~https://github.com/projectcalico/felix)
+- [resin-os/balena](/~https://github.com/resin-os/balena)
+- [go-kivik/kivik](/~https://github.com/go-kivik/kivik)
+- [Telefonica/govice](/~https://github.com/Telefonica/govice)
+- [supergiant/supergiant](supergiant/supergiant)
+- [SergeyTsalkov/brooce](/~https://github.com/SergeyTsalkov/brooce)
+- [soniah/dnsmadeeasy](/~https://github.com/soniah/dnsmadeeasy)
+- [ohsu-comp-bio/funnel](/~https://github.com/ohsu-comp-bio/funnel)
+- [EagerIO/Stout](/~https://github.com/EagerIO/Stout)
+- [lynndylanhurley/defsynth-api](/~https://github.com/lynndylanhurley/defsynth-api)
+- [russross/canvasassignments](/~https://github.com/russross/canvasassignments)
+- [rdegges/cryptly-api](/~https://github.com/rdegges/cryptly-api)
+- [casualjim/exeggutor](/~https://github.com/casualjim/exeggutor)
+- [divshot/gitling](/~https://github.com/divshot/gitling)
+- [RWJMurphy/gorl](/~https://github.com/RWJMurphy/gorl)
+- [andrerocker/deploy42](/~https://github.com/andrerocker/deploy42)
+- [elwinar/rambler](/~https://github.com/elwinar/rambler)
+- [tmaiaroto/gopartman](/~https://github.com/tmaiaroto/gopartman)
+- [jfbus/impressionist](/~https://github.com/jfbus/impressionist)
+- [Jmeyering/zealot](/~https://github.com/Jmeyering/zealot)
+- [godep-migrator/rigger-host](/~https://github.com/godep-migrator/rigger-host)
+- [Dronevery/MultiwaySwitch-Go](/~https://github.com/Dronevery/MultiwaySwitch-Go)
+- [thoas/picfit](/~https://github.com/thoas/picfit)
+- [mantasmatelis/whooplist-server](/~https://github.com/mantasmatelis/whooplist-server)
+- [jnuthong/item_search](/~https://github.com/jnuthong/item_search)
+- [bukalapak/snowboard](/~https://github.com/bukalapak/snowboard)
+- [containerssh/containerssh](/~https://github.com/containerssh/containerssh)
+- [goreleaser/goreleaser](/~https://github.com/goreleaser/goreleaser)
+- [tjpnz/structbot](/~https://github.com/tjpnz/structbot)
+
+## Install
+
+ go get github.com/imdario/mergo
+
+ // use in your .go code
+ import (
+ "github.com/imdario/mergo"
+ )
+
+## Usage
+
+You can only merge same-type structs with exported fields initialized as zero value of their type and same-types maps. Mergo won't merge unexported (private) fields but will do recursively any exported one. It won't merge empty structs value as [they are zero values](https://golang.org/ref/spec#The_zero_value) too. Also, maps will be merged recursively except for structs inside maps (because they are not addressable using Go reflection).
+
+```go
+if err := mergo.Merge(&dst, src); err != nil {
+ // ...
+}
+```
+
+Also, you can merge overwriting values using the transformer `WithOverride`.
+
+```go
+if err := mergo.Merge(&dst, src, mergo.WithOverride); err != nil {
+ // ...
+}
+```
+
+Additionally, you can map a `map[string]interface{}` to a struct (and otherwise, from struct to map), following the same restrictions as in `Merge()`. Keys are capitalized to find each corresponding exported field.
+
+```go
+if err := mergo.Map(&dst, srcMap); err != nil {
+ // ...
+}
+```
+
+Warning: if you map a struct to map, it won't do it recursively. Don't expect Mergo to map struct members of your struct as `map[string]interface{}`. They will be just assigned as values.
+
+Here is a nice example:
+
+```go
+package main
+
+import (
+ "fmt"
+ "github.com/imdario/mergo"
+)
+
+type Foo struct {
+ A string
+ B int64
+}
+
+func main() {
+ src := Foo{
+ A: "one",
+ B: 2,
+ }
+ dest := Foo{
+ A: "two",
+ }
+ mergo.Merge(&dest, src)
+ fmt.Println(dest)
+ // Will print
+ // {two 2}
+}
+```
+
+Note: if test are failing due missing package, please execute:
+
+ go get gopkg.in/yaml.v3
+
+### Transformers
+
+Transformers allow to merge specific types differently than in the default behavior. In other words, now you can customize how some types are merged. For example, `time.Time` is a struct; it doesn't have zero value but IsZero can return true because it has fields with zero value. How can we merge a non-zero `time.Time`?
+
+```go
+package main
+
+import (
+ "fmt"
+ "github.com/imdario/mergo"
+ "reflect"
+ "time"
+)
+
+type timeTransformer struct {
+}
+
+func (t timeTransformer) Transformer(typ reflect.Type) func(dst, src reflect.Value) error {
+ if typ == reflect.TypeOf(time.Time{}) {
+ return func(dst, src reflect.Value) error {
+ if dst.CanSet() {
+ isZero := dst.MethodByName("IsZero")
+ result := isZero.Call([]reflect.Value{})
+ if result[0].Bool() {
+ dst.Set(src)
+ }
+ }
+ return nil
+ }
+ }
+ return nil
+}
+
+type Snapshot struct {
+ Time time.Time
+ // ...
+}
+
+func main() {
+ src := Snapshot{time.Now()}
+ dest := Snapshot{}
+ mergo.Merge(&dest, src, mergo.WithTransformers(timeTransformer{}))
+ fmt.Println(dest)
+ // Will print
+ // { 2018-01-12 01:15:00 +0000 UTC m=+0.000000001 }
+}
+```
+
+## Contact me
+
+If I can help you, you have an idea or you are using Mergo in your projects, don't hesitate to drop me a line (or a pull request): [@im_dario](https://twitter.com/im_dario)
+
+## About
+
+Written by [Dario Castañé](http://dario.im).
+
+## License
+
+[BSD 3-Clause](http://opensource.org/licenses/BSD-3-Clause) license, as [Go language](http://golang.org/LICENSE).
+
+
+[](https://app.fossa.io/projects/git%2Bgithub.com%2Fimdario%2Fmergo?ref=badge_large)
diff --git a/vendor/github.com/imdario/mergo/doc.go b/vendor/github.com/imdario/mergo/doc.go
new file mode 100644
index 000000000000..fcd985f995dc
--- /dev/null
+++ b/vendor/github.com/imdario/mergo/doc.go
@@ -0,0 +1,143 @@
+// Copyright 2013 Dario Castañé. All rights reserved.
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+/*
+A helper to merge structs and maps in Golang. Useful for configuration default values, avoiding messy if-statements.
+
+Mergo merges same-type structs and maps by setting default values in zero-value fields. Mergo won't merge unexported (private) fields. It will do recursively any exported one. It also won't merge structs inside maps (because they are not addressable using Go reflection).
+
+Status
+
+It is ready for production use. It is used in several projects by Docker, Google, The Linux Foundation, VMWare, Shopify, etc.
+
+Important note
+
+Please keep in mind that a problematic PR broke 0.3.9. We reverted it in 0.3.10. We consider 0.3.10 as stable but not bug-free. . Also, this version adds suppot for go modules.
+
+Keep in mind that in 0.3.2, Mergo changed Merge() and Map() signatures to support transformers. We added an optional/variadic argument so that it won't break the existing code.
+
+If you were using Mergo before April 6th, 2015, please check your project works as intended after updating your local copy with go get -u github.com/imdario/mergo. I apologize for any issue caused by its previous behavior and any future bug that Mergo could cause in existing projects after the change (release 0.2.0).
+
+Install
+
+Do your usual installation procedure:
+
+ go get github.com/imdario/mergo
+
+ // use in your .go code
+ import (
+ "github.com/imdario/mergo"
+ )
+
+Usage
+
+You can only merge same-type structs with exported fields initialized as zero value of their type and same-types maps. Mergo won't merge unexported (private) fields but will do recursively any exported one. It won't merge empty structs value as they are zero values too. Also, maps will be merged recursively except for structs inside maps (because they are not addressable using Go reflection).
+
+ if err := mergo.Merge(&dst, src); err != nil {
+ // ...
+ }
+
+Also, you can merge overwriting values using the transformer WithOverride.
+
+ if err := mergo.Merge(&dst, src, mergo.WithOverride); err != nil {
+ // ...
+ }
+
+Additionally, you can map a map[string]interface{} to a struct (and otherwise, from struct to map), following the same restrictions as in Merge(). Keys are capitalized to find each corresponding exported field.
+
+ if err := mergo.Map(&dst, srcMap); err != nil {
+ // ...
+ }
+
+Warning: if you map a struct to map, it won't do it recursively. Don't expect Mergo to map struct members of your struct as map[string]interface{}. They will be just assigned as values.
+
+Here is a nice example:
+
+ package main
+
+ import (
+ "fmt"
+ "github.com/imdario/mergo"
+ )
+
+ type Foo struct {
+ A string
+ B int64
+ }
+
+ func main() {
+ src := Foo{
+ A: "one",
+ B: 2,
+ }
+ dest := Foo{
+ A: "two",
+ }
+ mergo.Merge(&dest, src)
+ fmt.Println(dest)
+ // Will print
+ // {two 2}
+ }
+
+Transformers
+
+Transformers allow to merge specific types differently than in the default behavior. In other words, now you can customize how some types are merged. For example, time.Time is a struct; it doesn't have zero value but IsZero can return true because it has fields with zero value. How can we merge a non-zero time.Time?
+
+ package main
+
+ import (
+ "fmt"
+ "github.com/imdario/mergo"
+ "reflect"
+ "time"
+ )
+
+ type timeTransformer struct {
+ }
+
+ func (t timeTransformer) Transformer(typ reflect.Type) func(dst, src reflect.Value) error {
+ if typ == reflect.TypeOf(time.Time{}) {
+ return func(dst, src reflect.Value) error {
+ if dst.CanSet() {
+ isZero := dst.MethodByName("IsZero")
+ result := isZero.Call([]reflect.Value{})
+ if result[0].Bool() {
+ dst.Set(src)
+ }
+ }
+ return nil
+ }
+ }
+ return nil
+ }
+
+ type Snapshot struct {
+ Time time.Time
+ // ...
+ }
+
+ func main() {
+ src := Snapshot{time.Now()}
+ dest := Snapshot{}
+ mergo.Merge(&dest, src, mergo.WithTransformers(timeTransformer{}))
+ fmt.Println(dest)
+ // Will print
+ // { 2018-01-12 01:15:00 +0000 UTC m=+0.000000001 }
+ }
+
+Contact me
+
+If I can help you, you have an idea or you are using Mergo in your projects, don't hesitate to drop me a line (or a pull request): https://twitter.com/im_dario
+
+About
+
+Written by Dario Castañé: https://da.rio.hn
+
+License
+
+BSD 3-Clause license, as Go language.
+
+*/
+package mergo
diff --git a/vendor/github.com/imdario/mergo/map.go b/vendor/github.com/imdario/mergo/map.go
new file mode 100644
index 000000000000..a13a7ee46c77
--- /dev/null
+++ b/vendor/github.com/imdario/mergo/map.go
@@ -0,0 +1,178 @@
+// Copyright 2014 Dario Castañé. All rights reserved.
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Based on src/pkg/reflect/deepequal.go from official
+// golang's stdlib.
+
+package mergo
+
+import (
+ "fmt"
+ "reflect"
+ "unicode"
+ "unicode/utf8"
+)
+
+func changeInitialCase(s string, mapper func(rune) rune) string {
+ if s == "" {
+ return s
+ }
+ r, n := utf8.DecodeRuneInString(s)
+ return string(mapper(r)) + s[n:]
+}
+
+func isExported(field reflect.StructField) bool {
+ r, _ := utf8.DecodeRuneInString(field.Name)
+ return r >= 'A' && r <= 'Z'
+}
+
+// Traverses recursively both values, assigning src's fields values to dst.
+// The map argument tracks comparisons that have already been seen, which allows
+// short circuiting on recursive types.
+func deepMap(dst, src reflect.Value, visited map[uintptr]*visit, depth int, config *Config) (err error) {
+ overwrite := config.Overwrite
+ if dst.CanAddr() {
+ addr := dst.UnsafeAddr()
+ h := 17 * addr
+ seen := visited[h]
+ typ := dst.Type()
+ for p := seen; p != nil; p = p.next {
+ if p.ptr == addr && p.typ == typ {
+ return nil
+ }
+ }
+ // Remember, remember...
+ visited[h] = &visit{addr, typ, seen}
+ }
+ zeroValue := reflect.Value{}
+ switch dst.Kind() {
+ case reflect.Map:
+ dstMap := dst.Interface().(map[string]interface{})
+ for i, n := 0, src.NumField(); i < n; i++ {
+ srcType := src.Type()
+ field := srcType.Field(i)
+ if !isExported(field) {
+ continue
+ }
+ fieldName := field.Name
+ fieldName = changeInitialCase(fieldName, unicode.ToLower)
+ if v, ok := dstMap[fieldName]; !ok || (isEmptyValue(reflect.ValueOf(v)) || overwrite) {
+ dstMap[fieldName] = src.Field(i).Interface()
+ }
+ }
+ case reflect.Ptr:
+ if dst.IsNil() {
+ v := reflect.New(dst.Type().Elem())
+ dst.Set(v)
+ }
+ dst = dst.Elem()
+ fallthrough
+ case reflect.Struct:
+ srcMap := src.Interface().(map[string]interface{})
+ for key := range srcMap {
+ config.overwriteWithEmptyValue = true
+ srcValue := srcMap[key]
+ fieldName := changeInitialCase(key, unicode.ToUpper)
+ dstElement := dst.FieldByName(fieldName)
+ if dstElement == zeroValue {
+ // We discard it because the field doesn't exist.
+ continue
+ }
+ srcElement := reflect.ValueOf(srcValue)
+ dstKind := dstElement.Kind()
+ srcKind := srcElement.Kind()
+ if srcKind == reflect.Ptr && dstKind != reflect.Ptr {
+ srcElement = srcElement.Elem()
+ srcKind = reflect.TypeOf(srcElement.Interface()).Kind()
+ } else if dstKind == reflect.Ptr {
+ // Can this work? I guess it can't.
+ if srcKind != reflect.Ptr && srcElement.CanAddr() {
+ srcPtr := srcElement.Addr()
+ srcElement = reflect.ValueOf(srcPtr)
+ srcKind = reflect.Ptr
+ }
+ }
+
+ if !srcElement.IsValid() {
+ continue
+ }
+ if srcKind == dstKind {
+ if err = deepMerge(dstElement, srcElement, visited, depth+1, config); err != nil {
+ return
+ }
+ } else if dstKind == reflect.Interface && dstElement.Kind() == reflect.Interface {
+ if err = deepMerge(dstElement, srcElement, visited, depth+1, config); err != nil {
+ return
+ }
+ } else if srcKind == reflect.Map {
+ if err = deepMap(dstElement, srcElement, visited, depth+1, config); err != nil {
+ return
+ }
+ } else {
+ return fmt.Errorf("type mismatch on %s field: found %v, expected %v", fieldName, srcKind, dstKind)
+ }
+ }
+ }
+ return
+}
+
+// Map sets fields' values in dst from src.
+// src can be a map with string keys or a struct. dst must be the opposite:
+// if src is a map, dst must be a valid pointer to struct. If src is a struct,
+// dst must be map[string]interface{}.
+// It won't merge unexported (private) fields and will do recursively
+// any exported field.
+// If dst is a map, keys will be src fields' names in lower camel case.
+// Missing key in src that doesn't match a field in dst will be skipped. This
+// doesn't apply if dst is a map.
+// This is separated method from Merge because it is cleaner and it keeps sane
+// semantics: merging equal types, mapping different (restricted) types.
+func Map(dst, src interface{}, opts ...func(*Config)) error {
+ return _map(dst, src, opts...)
+}
+
+// MapWithOverwrite will do the same as Map except that non-empty dst attributes will be overridden by
+// non-empty src attribute values.
+// Deprecated: Use Map(…) with WithOverride
+func MapWithOverwrite(dst, src interface{}, opts ...func(*Config)) error {
+ return _map(dst, src, append(opts, WithOverride)...)
+}
+
+func _map(dst, src interface{}, opts ...func(*Config)) error {
+ if dst != nil && reflect.ValueOf(dst).Kind() != reflect.Ptr {
+ return ErrNonPointerAgument
+ }
+ var (
+ vDst, vSrc reflect.Value
+ err error
+ )
+ config := &Config{}
+
+ for _, opt := range opts {
+ opt(config)
+ }
+
+ if vDst, vSrc, err = resolveValues(dst, src); err != nil {
+ return err
+ }
+ // To be friction-less, we redirect equal-type arguments
+ // to deepMerge. Only because arguments can be anything.
+ if vSrc.Kind() == vDst.Kind() {
+ return deepMerge(vDst, vSrc, make(map[uintptr]*visit), 0, config)
+ }
+ switch vSrc.Kind() {
+ case reflect.Struct:
+ if vDst.Kind() != reflect.Map {
+ return ErrExpectedMapAsDestination
+ }
+ case reflect.Map:
+ if vDst.Kind() != reflect.Struct {
+ return ErrExpectedStructAsDestination
+ }
+ default:
+ return ErrNotSupported
+ }
+ return deepMap(vDst, vSrc, make(map[uintptr]*visit), 0, config)
+}
diff --git a/vendor/github.com/imdario/mergo/merge.go b/vendor/github.com/imdario/mergo/merge.go
new file mode 100644
index 000000000000..8b4e2f47a08c
--- /dev/null
+++ b/vendor/github.com/imdario/mergo/merge.go
@@ -0,0 +1,380 @@
+// Copyright 2013 Dario Castañé. All rights reserved.
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Based on src/pkg/reflect/deepequal.go from official
+// golang's stdlib.
+
+package mergo
+
+import (
+ "fmt"
+ "reflect"
+)
+
+func hasMergeableFields(dst reflect.Value) (exported bool) {
+ for i, n := 0, dst.NumField(); i < n; i++ {
+ field := dst.Type().Field(i)
+ if field.Anonymous && dst.Field(i).Kind() == reflect.Struct {
+ exported = exported || hasMergeableFields(dst.Field(i))
+ } else if isExportedComponent(&field) {
+ exported = exported || len(field.PkgPath) == 0
+ }
+ }
+ return
+}
+
+func isExportedComponent(field *reflect.StructField) bool {
+ pkgPath := field.PkgPath
+ if len(pkgPath) > 0 {
+ return false
+ }
+ c := field.Name[0]
+ if 'a' <= c && c <= 'z' || c == '_' {
+ return false
+ }
+ return true
+}
+
+type Config struct {
+ Overwrite bool
+ AppendSlice bool
+ TypeCheck bool
+ Transformers Transformers
+ overwriteWithEmptyValue bool
+ overwriteSliceWithEmptyValue bool
+ sliceDeepCopy bool
+ debug bool
+}
+
+type Transformers interface {
+ Transformer(reflect.Type) func(dst, src reflect.Value) error
+}
+
+// Traverses recursively both values, assigning src's fields values to dst.
+// The map argument tracks comparisons that have already been seen, which allows
+// short circuiting on recursive types.
+func deepMerge(dst, src reflect.Value, visited map[uintptr]*visit, depth int, config *Config) (err error) {
+ overwrite := config.Overwrite
+ typeCheck := config.TypeCheck
+ overwriteWithEmptySrc := config.overwriteWithEmptyValue
+ overwriteSliceWithEmptySrc := config.overwriteSliceWithEmptyValue
+ sliceDeepCopy := config.sliceDeepCopy
+
+ if !src.IsValid() {
+ return
+ }
+ if dst.CanAddr() {
+ addr := dst.UnsafeAddr()
+ h := 17 * addr
+ seen := visited[h]
+ typ := dst.Type()
+ for p := seen; p != nil; p = p.next {
+ if p.ptr == addr && p.typ == typ {
+ return nil
+ }
+ }
+ // Remember, remember...
+ visited[h] = &visit{addr, typ, seen}
+ }
+
+ if config.Transformers != nil && !isReflectNil(dst) && dst.IsValid() {
+ if fn := config.Transformers.Transformer(dst.Type()); fn != nil {
+ err = fn(dst, src)
+ return
+ }
+ }
+
+ switch dst.Kind() {
+ case reflect.Struct:
+ if hasMergeableFields(dst) {
+ for i, n := 0, dst.NumField(); i < n; i++ {
+ if err = deepMerge(dst.Field(i), src.Field(i), visited, depth+1, config); err != nil {
+ return
+ }
+ }
+ } else {
+ if dst.CanSet() && (isReflectNil(dst) || overwrite) && (!isEmptyValue(src) || overwriteWithEmptySrc) {
+ dst.Set(src)
+ }
+ }
+ case reflect.Map:
+ if dst.IsNil() && !src.IsNil() {
+ if dst.CanSet() {
+ dst.Set(reflect.MakeMap(dst.Type()))
+ } else {
+ dst = src
+ return
+ }
+ }
+
+ if src.Kind() != reflect.Map {
+ if overwrite {
+ dst.Set(src)
+ }
+ return
+ }
+
+ for _, key := range src.MapKeys() {
+ srcElement := src.MapIndex(key)
+ if !srcElement.IsValid() {
+ continue
+ }
+ dstElement := dst.MapIndex(key)
+ switch srcElement.Kind() {
+ case reflect.Chan, reflect.Func, reflect.Map, reflect.Interface, reflect.Slice:
+ if srcElement.IsNil() {
+ if overwrite {
+ dst.SetMapIndex(key, srcElement)
+ }
+ continue
+ }
+ fallthrough
+ default:
+ if !srcElement.CanInterface() {
+ continue
+ }
+ switch reflect.TypeOf(srcElement.Interface()).Kind() {
+ case reflect.Struct:
+ fallthrough
+ case reflect.Ptr:
+ fallthrough
+ case reflect.Map:
+ srcMapElm := srcElement
+ dstMapElm := dstElement
+ if srcMapElm.CanInterface() {
+ srcMapElm = reflect.ValueOf(srcMapElm.Interface())
+ if dstMapElm.IsValid() {
+ dstMapElm = reflect.ValueOf(dstMapElm.Interface())
+ }
+ }
+ if err = deepMerge(dstMapElm, srcMapElm, visited, depth+1, config); err != nil {
+ return
+ }
+ case reflect.Slice:
+ srcSlice := reflect.ValueOf(srcElement.Interface())
+
+ var dstSlice reflect.Value
+ if !dstElement.IsValid() || dstElement.IsNil() {
+ dstSlice = reflect.MakeSlice(srcSlice.Type(), 0, srcSlice.Len())
+ } else {
+ dstSlice = reflect.ValueOf(dstElement.Interface())
+ }
+
+ if (!isEmptyValue(src) || overwriteWithEmptySrc || overwriteSliceWithEmptySrc) && (overwrite || isEmptyValue(dst)) && !config.AppendSlice && !sliceDeepCopy {
+ if typeCheck && srcSlice.Type() != dstSlice.Type() {
+ return fmt.Errorf("cannot override two slices with different type (%s, %s)", srcSlice.Type(), dstSlice.Type())
+ }
+ dstSlice = srcSlice
+ } else if config.AppendSlice {
+ if srcSlice.Type() != dstSlice.Type() {
+ return fmt.Errorf("cannot append two slices with different type (%s, %s)", srcSlice.Type(), dstSlice.Type())
+ }
+ dstSlice = reflect.AppendSlice(dstSlice, srcSlice)
+ } else if sliceDeepCopy {
+ i := 0
+ for ; i < srcSlice.Len() && i < dstSlice.Len(); i++ {
+ srcElement := srcSlice.Index(i)
+ dstElement := dstSlice.Index(i)
+
+ if srcElement.CanInterface() {
+ srcElement = reflect.ValueOf(srcElement.Interface())
+ }
+ if dstElement.CanInterface() {
+ dstElement = reflect.ValueOf(dstElement.Interface())
+ }
+
+ if err = deepMerge(dstElement, srcElement, visited, depth+1, config); err != nil {
+ return
+ }
+ }
+
+ }
+ dst.SetMapIndex(key, dstSlice)
+ }
+ }
+ if dstElement.IsValid() && !isEmptyValue(dstElement) && (reflect.TypeOf(srcElement.Interface()).Kind() == reflect.Map || reflect.TypeOf(srcElement.Interface()).Kind() == reflect.Slice) {
+ continue
+ }
+
+ if srcElement.IsValid() && ((srcElement.Kind() != reflect.Ptr && overwrite) || !dstElement.IsValid() || isEmptyValue(dstElement)) {
+ if dst.IsNil() {
+ dst.Set(reflect.MakeMap(dst.Type()))
+ }
+ dst.SetMapIndex(key, srcElement)
+ }
+ }
+ case reflect.Slice:
+ if !dst.CanSet() {
+ break
+ }
+ if (!isEmptyValue(src) || overwriteWithEmptySrc || overwriteSliceWithEmptySrc) && (overwrite || isEmptyValue(dst)) && !config.AppendSlice && !sliceDeepCopy {
+ dst.Set(src)
+ } else if config.AppendSlice {
+ if src.Type() != dst.Type() {
+ return fmt.Errorf("cannot append two slice with different type (%s, %s)", src.Type(), dst.Type())
+ }
+ dst.Set(reflect.AppendSlice(dst, src))
+ } else if sliceDeepCopy {
+ for i := 0; i < src.Len() && i < dst.Len(); i++ {
+ srcElement := src.Index(i)
+ dstElement := dst.Index(i)
+ if srcElement.CanInterface() {
+ srcElement = reflect.ValueOf(srcElement.Interface())
+ }
+ if dstElement.CanInterface() {
+ dstElement = reflect.ValueOf(dstElement.Interface())
+ }
+
+ if err = deepMerge(dstElement, srcElement, visited, depth+1, config); err != nil {
+ return
+ }
+ }
+ }
+ case reflect.Ptr:
+ fallthrough
+ case reflect.Interface:
+ if isReflectNil(src) {
+ if overwriteWithEmptySrc && dst.CanSet() && src.Type().AssignableTo(dst.Type()) {
+ dst.Set(src)
+ }
+ break
+ }
+
+ if src.Kind() != reflect.Interface {
+ if dst.IsNil() || (src.Kind() != reflect.Ptr && overwrite) {
+ if dst.CanSet() && (overwrite || isEmptyValue(dst)) {
+ dst.Set(src)
+ }
+ } else if src.Kind() == reflect.Ptr {
+ if err = deepMerge(dst.Elem(), src.Elem(), visited, depth+1, config); err != nil {
+ return
+ }
+ } else if dst.Elem().Type() == src.Type() {
+ if err = deepMerge(dst.Elem(), src, visited, depth+1, config); err != nil {
+ return
+ }
+ } else {
+ return ErrDifferentArgumentsTypes
+ }
+ break
+ }
+
+ if dst.IsNil() || overwrite {
+ if dst.CanSet() && (overwrite || isEmptyValue(dst)) {
+ dst.Set(src)
+ }
+ break
+ }
+
+ if dst.Elem().Kind() == src.Elem().Kind() {
+ if err = deepMerge(dst.Elem(), src.Elem(), visited, depth+1, config); err != nil {
+ return
+ }
+ break
+ }
+ default:
+ mustSet := (isEmptyValue(dst) || overwrite) && (!isEmptyValue(src) || overwriteWithEmptySrc)
+ if mustSet {
+ if dst.CanSet() {
+ dst.Set(src)
+ } else {
+ dst = src
+ }
+ }
+ }
+
+ return
+}
+
+// Merge will fill any empty for value type attributes on the dst struct using corresponding
+// src attributes if they themselves are not empty. dst and src must be valid same-type structs
+// and dst must be a pointer to struct.
+// It won't merge unexported (private) fields and will do recursively any exported field.
+func Merge(dst, src interface{}, opts ...func(*Config)) error {
+ return merge(dst, src, opts...)
+}
+
+// MergeWithOverwrite will do the same as Merge except that non-empty dst attributes will be overridden by
+// non-empty src attribute values.
+// Deprecated: use Merge(…) with WithOverride
+func MergeWithOverwrite(dst, src interface{}, opts ...func(*Config)) error {
+ return merge(dst, src, append(opts, WithOverride)...)
+}
+
+// WithTransformers adds transformers to merge, allowing to customize the merging of some types.
+func WithTransformers(transformers Transformers) func(*Config) {
+ return func(config *Config) {
+ config.Transformers = transformers
+ }
+}
+
+// WithOverride will make merge override non-empty dst attributes with non-empty src attributes values.
+func WithOverride(config *Config) {
+ config.Overwrite = true
+}
+
+// WithOverwriteWithEmptyValue will make merge override non empty dst attributes with empty src attributes values.
+func WithOverwriteWithEmptyValue(config *Config) {
+ config.Overwrite = true
+ config.overwriteWithEmptyValue = true
+}
+
+// WithOverrideEmptySlice will make merge override empty dst slice with empty src slice.
+func WithOverrideEmptySlice(config *Config) {
+ config.overwriteSliceWithEmptyValue = true
+}
+
+// WithAppendSlice will make merge append slices instead of overwriting it.
+func WithAppendSlice(config *Config) {
+ config.AppendSlice = true
+}
+
+// WithTypeCheck will make merge check types while overwriting it (must be used with WithOverride).
+func WithTypeCheck(config *Config) {
+ config.TypeCheck = true
+}
+
+// WithSliceDeepCopy will merge slice element one by one with Overwrite flag.
+func WithSliceDeepCopy(config *Config) {
+ config.sliceDeepCopy = true
+ config.Overwrite = true
+}
+
+func merge(dst, src interface{}, opts ...func(*Config)) error {
+ if dst != nil && reflect.ValueOf(dst).Kind() != reflect.Ptr {
+ return ErrNonPointerAgument
+ }
+ var (
+ vDst, vSrc reflect.Value
+ err error
+ )
+
+ config := &Config{}
+
+ for _, opt := range opts {
+ opt(config)
+ }
+
+ if vDst, vSrc, err = resolveValues(dst, src); err != nil {
+ return err
+ }
+ if vDst.Type() != vSrc.Type() {
+ return ErrDifferentArgumentsTypes
+ }
+ return deepMerge(vDst, vSrc, make(map[uintptr]*visit), 0, config)
+}
+
+// IsReflectNil is the reflect value provided nil
+func isReflectNil(v reflect.Value) bool {
+ k := v.Kind()
+ switch k {
+ case reflect.Interface, reflect.Slice, reflect.Chan, reflect.Func, reflect.Map, reflect.Ptr:
+ // Both interface and slice are nil if first word is 0.
+ // Both are always bigger than a word; assume flagIndir.
+ return v.IsNil()
+ default:
+ return false
+ }
+}
diff --git a/vendor/github.com/imdario/mergo/mergo.go b/vendor/github.com/imdario/mergo/mergo.go
new file mode 100644
index 000000000000..9fe362d476aa
--- /dev/null
+++ b/vendor/github.com/imdario/mergo/mergo.go
@@ -0,0 +1,78 @@
+// Copyright 2013 Dario Castañé. All rights reserved.
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Based on src/pkg/reflect/deepequal.go from official
+// golang's stdlib.
+
+package mergo
+
+import (
+ "errors"
+ "reflect"
+)
+
+// Errors reported by Mergo when it finds invalid arguments.
+var (
+ ErrNilArguments = errors.New("src and dst must not be nil")
+ ErrDifferentArgumentsTypes = errors.New("src and dst must be of same type")
+ ErrNotSupported = errors.New("only structs, maps, and slices are supported")
+ ErrExpectedMapAsDestination = errors.New("dst was expected to be a map")
+ ErrExpectedStructAsDestination = errors.New("dst was expected to be a struct")
+ ErrNonPointerAgument = errors.New("dst must be a pointer")
+)
+
+// During deepMerge, must keep track of checks that are
+// in progress. The comparison algorithm assumes that all
+// checks in progress are true when it reencounters them.
+// Visited are stored in a map indexed by 17 * a1 + a2;
+type visit struct {
+ ptr uintptr
+ typ reflect.Type
+ next *visit
+}
+
+// From src/pkg/encoding/json/encode.go.
+func isEmptyValue(v reflect.Value) bool {
+ switch v.Kind() {
+ case reflect.Array, reflect.Map, reflect.Slice, reflect.String:
+ return v.Len() == 0
+ case reflect.Bool:
+ return !v.Bool()
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ return v.Int() == 0
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+ return v.Uint() == 0
+ case reflect.Float32, reflect.Float64:
+ return v.Float() == 0
+ case reflect.Interface, reflect.Ptr:
+ if v.IsNil() {
+ return true
+ }
+ return isEmptyValue(v.Elem())
+ case reflect.Func:
+ return v.IsNil()
+ case reflect.Invalid:
+ return true
+ }
+ return false
+}
+
+func resolveValues(dst, src interface{}) (vDst, vSrc reflect.Value, err error) {
+ if dst == nil || src == nil {
+ err = ErrNilArguments
+ return
+ }
+ vDst = reflect.ValueOf(dst).Elem()
+ if vDst.Kind() != reflect.Struct && vDst.Kind() != reflect.Map && vDst.Kind() != reflect.Slice {
+ err = ErrNotSupported
+ return
+ }
+ vSrc = reflect.ValueOf(src)
+ // We check if vSrc is a pointer to dereference it.
+ if vSrc.Kind() == reflect.Ptr {
+ vSrc = vSrc.Elem()
+ }
+ return
+}
diff --git a/vendor/github.com/intel/goresctrl/pkg/blockio/blockio.go b/vendor/github.com/intel/goresctrl/pkg/blockio/blockio.go
index 91a01df93c6a..46250042e234 100644
--- a/vendor/github.com/intel/goresctrl/pkg/blockio/blockio.go
+++ b/vendor/github.com/intel/goresctrl/pkg/blockio/blockio.go
@@ -23,84 +23,86 @@ limitations under the License.
// Outputs:
// Option 1: Write blockio parameters of a class to a cgroup directory.
// Option 2: Return blockio parameters of a class in a OCI LinuxBlockIO
-// structure, that can be passed to OCI-compliant container
-// runtime.
+//
+// structure, that can be passed to OCI-compliant container
+// runtime.
//
// Notes:
-// - Using Weight requires bfq or cfq I/O scheduler to be
-// effective for the block devices where Weight is used.
+// - Using Weight requires bfq or cfq I/O scheduler to be
+// effective for the block devices where Weight is used.
//
// Configuration example:
//
-// Classes:
+// Classes:
//
-// # Define a blockio class "LowPrioThrottled".
-// # Containers in this class will be throttled and handled as
-// # low priority in the I/O scheduler.
+// # Define a blockio class "LowPrioThrottled".
+// # Containers in this class will be throttled and handled as
+// # low priority in the I/O scheduler.
//
-// LowPrioThrottled:
+// LowPrioThrottled:
//
-// # Weight without a Devices list specifies the default
-// # I/O scheduler weight for all devices
-// # that are not explicitly mentioned in following items.
-// # This will be written to cgroups(.bfq).weight.
-// # Weights range from 10 to 1000, the default is 100.
+// # Weight without a Devices list specifies the default
+// # I/O scheduler weight for all devices
+// # that are not explicitly mentioned in following items.
+// # This will be written to cgroups(.bfq).weight.
+// # Weights range from 10 to 1000, the default is 100.
//
-// - Weight: 80
+// - Weight: 80
//
-// # Set all parameters for all /dev/sd* and /dev/vd* block
-// # devices.
+// # Set all parameters for all /dev/sd* and /dev/vd* block
+// # devices.
//
-// - Devices:
-// - /dev/sd[a-z]
-// - /dev/vd[a-z]
-// ThrottleReadBps: 50M # max read bytes per second
-// ThrottleWriteBps: 10M # max write bytes per second
-// ThrottleReadIOPS: 10k # max read io operations per second
-// ThrottleWriteIOPS: 5k # max write io operations per second
-// Weight: 50 # I/O scheduler (cfq/bfq) weight for
-// # these devices will be written to
-// # cgroups(.bfq).weight_device
+// - Devices:
+// - /dev/sd[a-z]
+// - /dev/vd[a-z]
+// ThrottleReadBps: 50M # max read bytes per second
+// ThrottleWriteBps: 10M # max write bytes per second
+// ThrottleReadIOPS: 10k # max read io operations per second
+// ThrottleWriteIOPS: 5k # max write io operations per second
+// Weight: 50 # I/O scheduler (cfq/bfq) weight for
+// # these devices will be written to
+// # cgroups(.bfq).weight_device
//
-// # Set parameters particularly for SSD devices.
-// # This configuration overrides above configurations for those
-// # /dev/sd* and /dev/vd* devices whose disk id contains "SSD".
+// # Set parameters particularly for SSD devices.
+// # This configuration overrides above configurations for those
+// # /dev/sd* and /dev/vd* devices whose disk id contains "SSD".
//
-// - Devices:
-// - /dev/disk/by-id/*SSD*
-// ThrottleReadBps: 100M
-// ThrottleWriteBps: 40M
-// # Not mentioning Throttle*IOPS means no I/O operations
-// # throttling on matching devices.
-// Weight: 50
+// - Devices:
+// - /dev/disk/by-id/*SSD*
+// ThrottleReadBps: 100M
+// ThrottleWriteBps: 40M
+// # Not mentioning Throttle*IOPS means no I/O operations
+// # throttling on matching devices.
+// Weight: 50
//
-// # Define a blockio class "HighPrioFullSpeed".
-// # There is no throttling on these containers, and
-// # they will be prioritized by the I/O scheduler.
+// # Define a blockio class "HighPrioFullSpeed".
+// # There is no throttling on these containers, and
+// # they will be prioritized by the I/O scheduler.
//
-// HighPrioFullSpeed:
-// - Weight: 400
+// HighPrioFullSpeed:
+// - Weight: 400
//
// Usage example:
-// blockio.SetLogger(logrus.New())
-// if err := blockio.SetConfigFromFile("/etc/containers/blockio.yaml", false); err != nil {
-// return err
-// }
-// // Output option 1: write directly to cgroup "/mytestgroup"
-// if err := blockio.SetCgroupClass("/mytestgroup", "LowPrioThrottled"); err != nil {
-// return err
-// }
-// // Output option 2: OCI LinuxBlockIO of a blockio class
-// if lbio, err := blockio.OciLinuxBlockIO("LowPrioThrottled"); err != nil {
-// return err
-// } else {
-// fmt.Printf("OCI LinuxBlockIO for LowPrioThrottled:\n%+v\n", lbio)
-// }
+//
+// blockio.SetLogger(logrus.New())
+// if err := blockio.SetConfigFromFile("/etc/containers/blockio.yaml", false); err != nil {
+// return err
+// }
+// // Output option 1: write directly to cgroup "/mytestgroup"
+// if err := blockio.SetCgroupClass("/mytestgroup", "LowPrioThrottled"); err != nil {
+// return err
+// }
+// // Output option 2: OCI LinuxBlockIO of a blockio class
+// if lbio, err := blockio.OciLinuxBlockIO("LowPrioThrottled"); err != nil {
+// return err
+// } else {
+// fmt.Printf("OCI LinuxBlockIO for LowPrioThrottled:\n%+v\n", lbio)
+// }
package blockio
import (
+ "errors"
"fmt"
- "io/ioutil"
stdlog "log"
"os"
"path/filepath"
@@ -113,10 +115,8 @@ import (
"k8s.io/apimachinery/pkg/api/resource"
"sigs.k8s.io/yaml"
- "github.com/hashicorp/go-multierror"
-
- "github.com/intel/goresctrl/pkg/cgroups"
grclog "github.com/intel/goresctrl/pkg/log"
+ goresctrlpath "github.com/intel/goresctrl/pkg/path"
)
const (
@@ -142,15 +142,16 @@ var log grclog.Logger = grclog.NewLoggerWrapper(stdlog.New(os.Stderr, "[ blockio
// classBlockIO connects user-defined block I/O classes to
// corresponding cgroups blockio controller parameters.
-var classBlockIO = map[string]cgroups.BlockIOParameters{}
+var classBlockIO = map[string]BlockIOParameters{}
// SetLogger sets the logger instance to be used by the package.
// Examples:
-// // Log to standard logger:
-// stdlog := log.New(os.Stderr, "blockio:", 0)
-// blockio.SetLogger(goresctrllog.NewLoggerWrapper(stdlog))
-// // Log to logrus:
-// blockio.SetLogger(logrus.New())
+//
+// // Log to standard logger:
+// stdlog := log.New(os.Stderr, "blockio:", 0)
+// blockio.SetLogger(goresctrllog.NewLoggerWrapper(stdlog))
+// // Log to logrus:
+// blockio.SetLogger(logrus.New())
func SetLogger(l grclog.Logger) {
log = l
}
@@ -158,7 +159,7 @@ func SetLogger(l grclog.Logger) {
// SetConfigFromFile reads and applies blockio configuration from the
// filesystem.
func SetConfigFromFile(filename string, force bool) error {
- if data, err := ioutil.ReadFile(filename); err == nil {
+ if data, err := os.ReadFile(filename); err == nil {
if err = SetConfigFromData(data, force); err != nil {
return fmt.Errorf("failed to set configuration from file %q: %s", filename, err)
}
@@ -171,7 +172,7 @@ func SetConfigFromFile(filename string, force bool) error {
// SetConfigFromData parses and applies configuration from data.
func SetConfigFromData(data []byte, force bool) error {
config := &Config{}
- if err := yaml.Unmarshal(data, &config); err != nil {
+ if err := yaml.UnmarshalStrict(data, &config); err != nil {
return err
}
return SetConfig(config, force)
@@ -182,7 +183,7 @@ func SetConfig(opt *Config, force bool) error {
if opt == nil {
// Setting nil configuration clears current configuration.
// SetConfigFromData([]byte(""), dontcare) arrives here.
- classBlockIO = map[string]cgroups.BlockIOParameters{}
+ classBlockIO = map[string]BlockIOParameters{}
return nil
}
@@ -191,7 +192,7 @@ func SetConfig(opt *Config, force bool) error {
log.Warnf("configuration validation partly disabled due to I/O scheduler detection error %#v", ioSchedulerDetectionError.Error())
}
- classBlockIO = map[string]cgroups.BlockIOParameters{}
+ classBlockIO = map[string]BlockIOParameters{}
// Create cgroup blockio parameters for each blockio class
for class := range opt.Classes {
cgBlockIO, err := devicesParametersToCgBlockIO(opt.Classes[class], currentIOSchedulers)
@@ -217,33 +218,18 @@ func GetClasses() []string {
return classNames
}
-// SetCgroupClass sets cgroup blkio controller parameters to match
-// blockio class. "group" is the cgroup directory of the container
-// without mountpoint and controller (blkio) directories:
-// "/kubepods/burstable/POD_ID/CONTAINER_ID".
-func SetCgroupClass(group string, class string) error {
- cgBlockIO, ok := classBlockIO[class]
- if !ok {
- return fmt.Errorf("no BlockIO parameters for class %#v", class)
- }
- err := cgroups.ResetBlkioParameters(group, cgBlockIO)
- if err != nil {
- return fmt.Errorf("assigning container in cgroup %q to class %#v failed: %w", group, class, err)
- }
- return nil
-}
-
// getCurrentIOSchedulers returns currently active I/O scheduler used for each block device in the system.
// Returns schedulers in a map: {"/dev/sda": "bfq"}
func getCurrentIOSchedulers() (map[string]string, error) {
var ios = map[string]string{}
- schedulerFiles, err := filepath.Glob(sysfsBlockDeviceIOSchedulerPaths)
+ glob := goresctrlpath.Path(sysfsBlockDeviceIOSchedulerPaths)
+ schedulerFiles, err := filepath.Glob(glob)
if err != nil {
- return ios, fmt.Errorf("error in I/O scheduler wildcards %#v: %w", sysfsBlockDeviceIOSchedulerPaths, err)
+ return ios, fmt.Errorf("error in I/O scheduler wildcards %#v: %w", glob, err)
}
for _, schedulerFile := range schedulerFiles {
devName := strings.SplitN(schedulerFile, "/", 5)[3]
- schedulerDataB, err := ioutil.ReadFile(schedulerFile)
+ schedulerDataB, err := os.ReadFile(schedulerFile)
if err != nil {
// A block device may be disconnected.
log.Errorf("failed to read current I/O scheduler %#v: %v\n", schedulerFile, err)
@@ -271,28 +257,28 @@ func getCurrentIOSchedulers() (map[string]string, error) {
}
// deviceParametersToCgBlockIO converts single blockio class parameters into cgroups blkio format.
-func devicesParametersToCgBlockIO(dps []DevicesParameters, currentIOSchedulers map[string]string) (cgroups.BlockIOParameters, error) {
- var errors *multierror.Error
- blkio := cgroups.NewBlockIOParameters()
+func devicesParametersToCgBlockIO(dps []DevicesParameters, currentIOSchedulers map[string]string) (BlockIOParameters, error) {
+ errs := []error{}
+ blkio := NewBlockIOParameters()
for _, dp := range dps {
var err error
var weight, throttleReadBps, throttleWriteBps, throttleReadIOPS, throttleWriteIOPS int64
weight, err = parseAndValidateQuantity("Weight", dp.Weight, -1, 10, 1000)
- errors = multierror.Append(errors, err)
+ errs = append(errs, err)
throttleReadBps, err = parseAndValidateQuantity("ThrottleReadBps", dp.ThrottleReadBps, -1, 0, -1)
- errors = multierror.Append(errors, err)
+ errs = append(errs, err)
throttleWriteBps, err = parseAndValidateQuantity("ThrottleWriteBps", dp.ThrottleWriteBps, -1, 0, -1)
- errors = multierror.Append(errors, err)
+ errs = append(errs, err)
throttleReadIOPS, err = parseAndValidateQuantity("ThrottleReadIOPS", dp.ThrottleReadIOPS, -1, 0, -1)
- errors = multierror.Append(errors, err)
+ errs = append(errs, err)
throttleWriteIOPS, err = parseAndValidateQuantity("ThrottleWriteIOPS", dp.ThrottleWriteIOPS, -1, 0, -1)
- errors = multierror.Append(errors, err)
+ errs = append(errs, err)
if dp.Devices == nil {
if weight > -1 {
blkio.Weight = weight
}
if throttleReadBps > -1 || throttleWriteBps > -1 || throttleReadIOPS > -1 || throttleWriteIOPS > -1 {
- errors = multierror.Append(errors, fmt.Errorf("ignoring throttling (rbps=%#v wbps=%#v riops=%#v wiops=%#v): Devices not listed",
+ errs = append(errs, fmt.Errorf("ignoring throttling (rbps=%#v wbps=%#v riops=%#v wiops=%#v): Devices not listed",
dp.ThrottleReadBps, dp.ThrottleWriteBps, dp.ThrottleReadIOPS, dp.ThrottleWriteIOPS))
}
} else {
@@ -330,7 +316,7 @@ func devicesParametersToCgBlockIO(dps []DevicesParameters, currentIOSchedulers m
}
}
}
- return blkio, errors.ErrorOrNil()
+ return blkio, errors.Join(errs...)
}
// parseAndValidateQuantity parses quantities, like "64 M", and validates that they are in given range.
@@ -369,7 +355,7 @@ var currentPlatform platformInterface = defaultPlatform{}
func (dpm defaultPlatform) configurableBlockDevices(devWildcards []string) ([]tBlockDeviceInfo, error) {
// Return map {devNode: tBlockDeviceInfo}
// Example: {"/dev/sda": {Major:8, Minor:0, Origin:"from symlink /dev/disk/by-id/ata-VendorXSSD from wildcard /dev/disk/by-id/*SSD*"}}
- var errors *multierror.Error
+ errs := []error{}
blockDevices := []tBlockDeviceInfo{}
var origin string
@@ -379,11 +365,11 @@ func (dpm defaultPlatform) configurableBlockDevices(devWildcards []string) ([]tB
for _, devWildcard := range devWildcards {
devWildcardMatches, err := filepath.Glob(devWildcard)
if err != nil {
- errors = multierror.Append(errors, fmt.Errorf("bad device wildcard %#v: %w", devWildcard, err))
+ errs = append(errs, fmt.Errorf("bad device wildcard %#v: %w", devWildcard, err))
continue
}
if len(devWildcardMatches) == 0 {
- errors = multierror.Append(errors, fmt.Errorf("device wildcard %#v does not match any device nodes", devWildcard))
+ errs = append(errs, fmt.Errorf("device wildcard %#v does not match any device nodes", devWildcard))
continue
}
for _, devMatch := range devWildcardMatches {
@@ -402,7 +388,7 @@ func (dpm defaultPlatform) configurableBlockDevices(devWildcards []string) ([]tB
for devMatch, devOrigin := range devMatches {
realDevNode, err := filepath.EvalSymlinks(devMatch)
if err != nil {
- errors = multierror.Append(errors, fmt.Errorf("cannot filepath.EvalSymlinks(%#v): %w", devMatch, err))
+ errs = append(errs, fmt.Errorf("cannot filepath.EvalSymlinks(%#v): %w", devMatch, err))
continue
}
if realDevNode != devMatch {
@@ -422,27 +408,23 @@ func (dpm defaultPlatform) configurableBlockDevices(devWildcards []string) ([]tB
}
fileInfo, err := os.Stat(devRealpath)
if err != nil {
- errors = multierror.Append(errors, fmt.Errorf("cannot os.Stat(%#v): %w%s", devRealpath, err, origin))
+ errs = append(errs, fmt.Errorf("cannot os.Stat(%#v): %w%s", devRealpath, err, origin))
continue
}
fileMode := fileInfo.Mode()
if fileMode&os.ModeDevice == 0 {
- errors = multierror.Append(errors, fmt.Errorf("file %#v is not a device%s", devRealpath, origin))
+ errs = append(errs, fmt.Errorf("file %#v is not a device%s", devRealpath, origin))
continue
}
if fileMode&os.ModeCharDevice != 0 {
- errors = multierror.Append(errors, fmt.Errorf("file %#v is a character device%s", devRealpath, origin))
+ errs = append(errs, fmt.Errorf("file %#v is a character device%s", devRealpath, origin))
continue
}
sys, ok := fileInfo.Sys().(*syscall.Stat_t)
major := unix.Major(uint64(sys.Rdev))
minor := unix.Minor(uint64(sys.Rdev))
if !ok {
- errors = multierror.Append(errors, fmt.Errorf("cannot get syscall stat_t from %#v: %w%s", devRealpath, err, origin))
- continue
- }
- if minor&0xf != 0 {
- errors = multierror.Append(errors, fmt.Errorf("skipping %#v: cannot weight/throttle partitions%s", devRealpath, origin))
+ errs = append(errs, fmt.Errorf("cannot get syscall stat_t from %#v: %w%s", devRealpath, err, origin))
continue
}
blockDevices = append(blockDevices, tBlockDeviceInfo{
@@ -452,5 +434,5 @@ func (dpm defaultPlatform) configurableBlockDevices(devWildcards []string) ([]tB
Origin: devOrigin,
})
}
- return blockDevices, errors.ErrorOrNil()
+ return blockDevices, errors.Join(errs...)
}
diff --git a/vendor/github.com/intel/goresctrl/pkg/blockio/cgroups.go b/vendor/github.com/intel/goresctrl/pkg/blockio/cgroups.go
new file mode 100644
index 000000000000..d17751f91e5d
--- /dev/null
+++ b/vendor/github.com/intel/goresctrl/pkg/blockio/cgroups.go
@@ -0,0 +1,103 @@
+// Copyright 2020-2021 Intel Corporation. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package blockio
+
+// BlockIOParameters contains cgroups blockio controller parameters.
+//
+// Effects of Weight and Rate values in SetBlkioParameters():
+// Value | Effect
+// -------+-------------------------------------------------------------------
+//
+// -1 | Do not write to cgroups, value is missing.
+// 0 | Write to cgroups, will clear the setting as specified in cgroups blkio interface.
+// other | Write to cgroups, sets the value.
+type BlockIOParameters struct {
+ Weight int64
+ WeightDevice DeviceWeights
+ ThrottleReadBpsDevice DeviceRates
+ ThrottleWriteBpsDevice DeviceRates
+ ThrottleReadIOPSDevice DeviceRates
+ ThrottleWriteIOPSDevice DeviceRates
+}
+
+// DeviceWeight contains values for
+// - blkio.[io-scheduler].weight
+type DeviceWeight struct {
+ Major int64
+ Minor int64
+ Weight int64
+}
+
+// DeviceRate contains values for
+// - blkio.throttle.read_bps_device
+// - blkio.throttle.write_bps_device
+// - blkio.throttle.read_iops_device
+// - blkio.throttle.write_iops_device
+type DeviceRate struct {
+ Major int64
+ Minor int64
+ Rate int64
+}
+
+// DeviceWeights contains weights for devices.
+type DeviceWeights []DeviceWeight
+
+// DeviceRates contains throttling rates for devices.
+type DeviceRates []DeviceRate
+
+// NewBlockIOParameters creates new BlockIOParameters instance.
+func NewBlockIOParameters() BlockIOParameters {
+ return BlockIOParameters{
+ Weight: -1,
+ }
+}
+
+// DeviceParameters interface provides functions common to DeviceWeights and DeviceRates.
+type DeviceParameters interface {
+ Append(maj, min, val int64)
+ Update(maj, min, val int64)
+}
+
+// Append appends (major, minor, value) to DeviceWeights slice.
+func (w *DeviceWeights) Append(maj, min, val int64) {
+ *w = append(*w, DeviceWeight{Major: maj, Minor: min, Weight: val})
+}
+
+// Append appends (major, minor, value) to DeviceRates slice.
+func (r *DeviceRates) Append(maj, min, val int64) {
+ *r = append(*r, DeviceRate{Major: maj, Minor: min, Rate: val})
+}
+
+// Update updates device weight in DeviceWeights slice, or appends it if not found.
+func (w *DeviceWeights) Update(maj, min, val int64) {
+ for index, devWeight := range *w {
+ if devWeight.Major == maj && devWeight.Minor == min {
+ (*w)[index].Weight = val
+ return
+ }
+ }
+ w.Append(maj, min, val)
+}
+
+// Update updates device rate in DeviceRates slice, or appends it if not found.
+func (r *DeviceRates) Update(maj, min, val int64) {
+ for index, devRate := range *r {
+ if devRate.Major == maj && devRate.Minor == min {
+ (*r)[index].Rate = val
+ return
+ }
+ }
+ r.Append(maj, min, val)
+}
diff --git a/vendor/github.com/intel/goresctrl/pkg/blockio/oci.go b/vendor/github.com/intel/goresctrl/pkg/blockio/oci.go
index 1b30808aad69..9684e9520864 100644
--- a/vendor/github.com/intel/goresctrl/pkg/blockio/oci.go
+++ b/vendor/github.com/intel/goresctrl/pkg/blockio/oci.go
@@ -20,8 +20,6 @@ import (
"fmt"
oci "github.com/opencontainers/runtime-spec/specs-go"
-
- "github.com/intel/goresctrl/pkg/cgroups"
)
// OciLinuxBlockIO returns OCI LinuxBlockIO structure corresponding to the class.
@@ -43,7 +41,7 @@ func OciLinuxBlockIO(class string) (*oci.LinuxBlockIO, error) {
return &ociBlockio, nil
}
-func ociLinuxWeightDevices(dws cgroups.DeviceWeights) []oci.LinuxWeightDevice {
+func ociLinuxWeightDevices(dws DeviceWeights) []oci.LinuxWeightDevice {
if len(dws) == 0 {
return nil
}
@@ -57,7 +55,7 @@ func ociLinuxWeightDevices(dws cgroups.DeviceWeights) []oci.LinuxWeightDevice {
return olwds
}
-func ociLinuxThrottleDevices(drs cgroups.DeviceRates) []oci.LinuxThrottleDevice {
+func ociLinuxThrottleDevices(drs DeviceRates) []oci.LinuxThrottleDevice {
if len(drs) == 0 {
return nil
}
diff --git a/vendor/github.com/intel/goresctrl/pkg/cgroups/cgroupblkio.go b/vendor/github.com/intel/goresctrl/pkg/cgroups/cgroupblkio.go
deleted file mode 100644
index a58d51a68a7a..000000000000
--- a/vendor/github.com/intel/goresctrl/pkg/cgroups/cgroupblkio.go
+++ /dev/null
@@ -1,312 +0,0 @@
-// Copyright 2020-2021 Intel Corporation. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package cgroups
-
-import (
- "fmt"
- "strconv"
- "strings"
-
- "github.com/hashicorp/go-multierror"
-)
-
-// cgroups blkio parameter filenames.
-var blkioWeightFiles = []string{"blkio.bfq.weight", "blkio.weight"}
-var blkioWeightDeviceFiles = []string{"blkio.bfq.weight_device", "blkio.weight_device"}
-var blkioThrottleReadBpsFiles = []string{"blkio.throttle.read_bps_device"}
-var blkioThrottleWriteBpsFiles = []string{"blkio.throttle.write_bps_device"}
-var blkioThrottleReadIOPSFiles = []string{"blkio.throttle.read_iops_device"}
-var blkioThrottleWriteIOPSFiles = []string{"blkio.throttle.write_iops_device"}
-
-// BlockIOParameters contains cgroups blockio controller parameters.
-//
-// Effects of Weight and Rate values in SetBlkioParameters():
-// Value | Effect
-// -------+-------------------------------------------------------------------
-// -1 | Do not write to cgroups, value is missing.
-// 0 | Write to cgroups, will clear the setting as specified in cgroups blkio interface.
-// other | Write to cgroups, sets the value.
-type BlockIOParameters struct {
- Weight int64
- WeightDevice DeviceWeights
- ThrottleReadBpsDevice DeviceRates
- ThrottleWriteBpsDevice DeviceRates
- ThrottleReadIOPSDevice DeviceRates
- ThrottleWriteIOPSDevice DeviceRates
-}
-
-// DeviceWeight contains values for
-// - blkio.[io-scheduler].weight
-type DeviceWeight struct {
- Major int64
- Minor int64
- Weight int64
-}
-
-// DeviceRate contains values for
-// - blkio.throttle.read_bps_device
-// - blkio.throttle.write_bps_device
-// - blkio.throttle.read_iops_device
-// - blkio.throttle.write_iops_device
-type DeviceRate struct {
- Major int64
- Minor int64
- Rate int64
-}
-
-// DeviceWeights contains weights for devices.
-type DeviceWeights []DeviceWeight
-
-// DeviceRates contains throttling rates for devices.
-type DeviceRates []DeviceRate
-
-// DeviceParameters interface provides functions common to DeviceWeights and DeviceRates.
-type DeviceParameters interface {
- Append(maj, min, val int64)
- Update(maj, min, val int64)
-}
-
-// Append appends (major, minor, value) to DeviceWeights slice.
-func (w *DeviceWeights) Append(maj, min, val int64) {
- *w = append(*w, DeviceWeight{Major: maj, Minor: min, Weight: val})
-}
-
-// Append appends (major, minor, value) to DeviceRates slice.
-func (r *DeviceRates) Append(maj, min, val int64) {
- *r = append(*r, DeviceRate{Major: maj, Minor: min, Rate: val})
-}
-
-// Update updates device weight in DeviceWeights slice, or appends it if not found.
-func (w *DeviceWeights) Update(maj, min, val int64) {
- for index, devWeight := range *w {
- if devWeight.Major == maj && devWeight.Minor == min {
- (*w)[index].Weight = val
- return
- }
- }
- w.Append(maj, min, val)
-}
-
-// Update updates device rate in DeviceRates slice, or appends it if not found.
-func (r *DeviceRates) Update(maj, min, val int64) {
- for index, devRate := range *r {
- if devRate.Major == maj && devRate.Minor == min {
- (*r)[index].Rate = val
- return
- }
- }
- r.Append(maj, min, val)
-}
-
-// NewBlockIOParameters creates new BlockIOParameters instance.
-func NewBlockIOParameters() BlockIOParameters {
- return BlockIOParameters{
- Weight: -1,
- }
-}
-
-// NewDeviceWeight creates new DeviceWeight instance.
-func NewDeviceWeight() DeviceWeight {
- return DeviceWeight{
- Major: -1,
- Minor: -1,
- Weight: -1,
- }
-}
-
-// NewDeviceRate creates new DeviceRate instance.
-func NewDeviceRate() DeviceRate {
- return DeviceRate{
- Major: -1,
- Minor: -1,
- Rate: -1,
- }
-}
-
-type devMajMin struct {
- Major int64
- Minor int64
-}
-
-// ResetBlkioParameters adds new, changes existing and removes missing blockIO parameters in cgroupsDir.
-func ResetBlkioParameters(groupDir string, blockIO BlockIOParameters) error {
- var errors *multierror.Error
- oldBlockIO, _ := GetBlkioParameters(groupDir)
- newBlockIO := NewBlockIOParameters()
- newBlockIO.Weight = blockIO.Weight
- newBlockIO.WeightDevice = resetDevWeights(oldBlockIO.WeightDevice, blockIO.WeightDevice)
- newBlockIO.ThrottleReadBpsDevice = resetDevRates(oldBlockIO.ThrottleReadBpsDevice, blockIO.ThrottleReadBpsDevice)
- newBlockIO.ThrottleWriteBpsDevice = resetDevRates(oldBlockIO.ThrottleWriteBpsDevice, blockIO.ThrottleWriteBpsDevice)
- newBlockIO.ThrottleReadIOPSDevice = resetDevRates(oldBlockIO.ThrottleReadIOPSDevice, blockIO.ThrottleReadIOPSDevice)
- newBlockIO.ThrottleWriteIOPSDevice = resetDevRates(oldBlockIO.ThrottleWriteIOPSDevice, blockIO.ThrottleWriteIOPSDevice)
- errors = multierror.Append(errors, SetBlkioParameters(groupDir, newBlockIO))
- return errors.ErrorOrNil()
-}
-
-// resetDevWeights adds wanted weight parameters to new and resets unwanted weights.
-func resetDevWeights(old, wanted []DeviceWeight) []DeviceWeight {
- new := []DeviceWeight{}
- seenDev := map[devMajMin]bool{}
- for _, wdp := range wanted {
- seenDev[devMajMin{wdp.Major, wdp.Minor}] = true
- new = append(new, wdp)
- }
- for _, wdp := range old {
- if !seenDev[devMajMin{wdp.Major, wdp.Minor}] {
- new = append(new, DeviceWeight{wdp.Major, wdp.Minor, 0})
- }
- }
- return new
-}
-
-// resetDevRates adds wanted rate parameters to new and resets unwanted rates.
-func resetDevRates(old, wanted []DeviceRate) []DeviceRate {
- new := []DeviceRate{}
- seenDev := map[devMajMin]bool{}
- for _, rdp := range wanted {
- new = append(new, rdp)
- seenDev[devMajMin{rdp.Major, rdp.Minor}] = true
- }
- for _, rdp := range old {
- if !seenDev[devMajMin{rdp.Major, rdp.Minor}] {
- new = append(new, DeviceRate{rdp.Major, rdp.Minor, 0})
- }
- }
- return new
-}
-
-// GetBlkioParameters returns BlockIO parameters from files in cgroups blkio controller directory.
-func GetBlkioParameters(group string) (BlockIOParameters, error) {
- var errors *multierror.Error
- blockIO := NewBlockIOParameters()
-
- errors = multierror.Append(errors, readWeight(group, blkioWeightFiles, &blockIO.Weight))
- errors = multierror.Append(errors, readDeviceParameters(group, blkioWeightDeviceFiles, &blockIO.WeightDevice))
- errors = multierror.Append(errors, readDeviceParameters(group, blkioThrottleReadBpsFiles, &blockIO.ThrottleReadBpsDevice))
- errors = multierror.Append(errors, readDeviceParameters(group, blkioThrottleWriteBpsFiles, &blockIO.ThrottleWriteBpsDevice))
- errors = multierror.Append(errors, readDeviceParameters(group, blkioThrottleReadIOPSFiles, &blockIO.ThrottleReadIOPSDevice))
- errors = multierror.Append(errors, readDeviceParameters(group, blkioThrottleWriteIOPSFiles, &blockIO.ThrottleWriteIOPSDevice))
- return blockIO, errors.ErrorOrNil()
-}
-
-// readWeight parses int64 from a cgroups entry.
-func readWeight(groupDir string, filenames []string, rv *int64) error {
- contents, err := readFirstFile(groupDir, filenames)
- if err != nil {
- return err
- }
- parsed, err := strconv.ParseInt(strings.TrimSuffix(contents, "\n"), 10, 64)
- if err != nil {
- return fmt.Errorf("parsing weight from %#v found in %v failed: %w", contents, filenames, err)
- }
- *rv = parsed
- return nil
-}
-
-// readDeviceParameters parses device lines used for weights and throttling rates.
-func readDeviceParameters(groupDir string, filenames []string, params DeviceParameters) error {
- var errors *multierror.Error
- contents, err := readFirstFile(groupDir, filenames)
- if err != nil {
- return err
- }
- for _, line := range strings.Split(contents, "\n") {
- // Device weight files may have "default NNN" line at the beginning. Skip it.
- if line == "" || strings.HasPrefix(line, "default ") {
- continue
- }
- // Expect syntax MAJOR:MINOR VALUE
- devVal := strings.Split(line, " ")
- if len(devVal) != 2 {
- errors = multierror.Append(errors, fmt.Errorf("invalid line %q, single space expected", line))
- continue
- }
- majMin := strings.Split(devVal[0], ":")
- if len(majMin) != 2 {
- errors = multierror.Append(errors, fmt.Errorf("invalid line %q, single colon expected before space", line))
- continue
- }
- major, majErr := strconv.ParseInt(majMin[0], 10, 64)
- minor, minErr := strconv.ParseInt(majMin[1], 10, 64)
- value, valErr := strconv.ParseInt(devVal[1], 10, 64)
- if majErr != nil || minErr != nil || valErr != nil {
- errors = multierror.Append(errors, fmt.Errorf("invalid number when parsing \"major:minor value\" from \"%s:%s %s\"", majMin[0], majMin[1], devVal[1]))
- continue
- }
- params.Append(major, minor, value)
- }
- return errors.ErrorOrNil()
-}
-
-// readFirstFile returns contents of the first successfully read entry.
-func readFirstFile(groupDir string, filenames []string) (string, error) {
- var errors *multierror.Error
- // If reading all the files fails, return list of read errors.
- for _, filename := range filenames {
- content, err := Blkio.Group(groupDir).Read(filename)
- if err == nil {
- return content, nil
- }
- errors = multierror.Append(errors, err)
- }
- err := errors.ErrorOrNil()
- if err != nil {
- return "", fmt.Errorf("could not read any of files %q: %w", filenames, err)
- }
- return "", nil
-}
-
-// SetBlkioParameters writes BlockIO parameters to files in cgroups blkio contoller directory.
-func SetBlkioParameters(group string, blockIO BlockIOParameters) error {
- var errors *multierror.Error
- if blockIO.Weight >= 0 {
- errors = multierror.Append(errors, writeFirstFile(group, blkioWeightFiles, "%d", blockIO.Weight))
- }
- for _, wd := range blockIO.WeightDevice {
- errors = multierror.Append(errors, writeFirstFile(group, blkioWeightDeviceFiles, "%d:%d %d", wd.Major, wd.Minor, wd.Weight))
- }
- for _, rd := range blockIO.ThrottleReadBpsDevice {
- errors = multierror.Append(errors, writeFirstFile(group, blkioThrottleReadBpsFiles, "%d:%d %d", rd.Major, rd.Minor, rd.Rate))
- }
- for _, rd := range blockIO.ThrottleWriteBpsDevice {
- errors = multierror.Append(errors, writeFirstFile(group, blkioThrottleWriteBpsFiles, "%d:%d %d", rd.Major, rd.Minor, rd.Rate))
- }
- for _, rd := range blockIO.ThrottleReadIOPSDevice {
- errors = multierror.Append(errors, writeFirstFile(group, blkioThrottleReadIOPSFiles, "%d:%d %d", rd.Major, rd.Minor, rd.Rate))
- }
- for _, rd := range blockIO.ThrottleWriteIOPSDevice {
- errors = multierror.Append(errors, writeFirstFile(group, blkioThrottleWriteIOPSFiles, "%d:%d %d", rd.Major, rd.Minor, rd.Rate))
- }
- return errors.ErrorOrNil()
-}
-
-// writeFirstFile writes content to the first existing file in the list under groupDir.
-func writeFirstFile(groupDir string, filenames []string, format string, args ...interface{}) error {
- var errors *multierror.Error
- // Returns list of errors from writes, list of single error due to all filenames missing or nil on success.
- for _, filename := range filenames {
- if err := Blkio.Group(groupDir).Write(filename, format, args...); err != nil {
- errors = multierror.Append(errors, err)
- continue
- }
- return nil
- }
- err := errors.ErrorOrNil()
- if err != nil {
- data := fmt.Sprintf(format, args...)
- return fmt.Errorf("writing all files %v failed, errors: %w, content %q", filenames, err, data)
- }
- return nil
-}
diff --git a/vendor/github.com/intel/goresctrl/pkg/cgroups/cgroupcontrol.go b/vendor/github.com/intel/goresctrl/pkg/cgroups/cgroupcontrol.go
deleted file mode 100644
index 652a625905ae..000000000000
--- a/vendor/github.com/intel/goresctrl/pkg/cgroups/cgroupcontrol.go
+++ /dev/null
@@ -1,237 +0,0 @@
-// Copyright 2020-2021 Intel Corporation. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package cgroups
-
-import (
- "bufio"
- "bytes"
- "errors"
- "fmt"
- "os"
- "path"
- "strings"
- "syscall"
-)
-
-// Controller is our enumerated type for cgroup controllers.
-type Controller int
-
-// Group represents a control group.
-type Group string
-
-//nolint
-const (
- // UnkownController represents a controller of unknown type.
- UnknownController Controller = iota
- // blkio cgroup controller.
- Blkio
- // cpu cgroup controller.
- Cpu
- // cpuacct cgroup controller.
- Cpuacct
- // cpuset cgroup controller.
- Cpuset
- // devices cgroup controller.
- Devices
- // freezer cgroup controller.
- Freezer
- // hugetlb cgroup controller.
- Hugetlb
- // memory cgroup controller.
- Memory
- // net_cls cgroup controller.
- NetCls
- // net_prio cgroup controller.
- NetPrio
- // per_event cgroup controller.
- PerfEvent
- // pids cgroup controller.
- Pids
-)
-
-var (
- // controllerNames maps controllers to names/relative paths.
- controllerNames = map[Controller]string{
- Blkio: "blkio",
- Cpu: "cpu",
- Cpuacct: "cpuacct",
- Cpuset: "cpuset",
- Devices: "devices",
- Freezer: "freezer",
- Hugetlb: "hugetlb",
- Memory: "memory",
- NetCls: "net_cls",
- NetPrio: "net_prio",
- PerfEvent: "perf_event",
- Pids: "pids",
- }
-
- // controllerNames maps controllers to names/relative paths.
- controllerDirs = map[string]Controller{
- "blkio": Blkio,
- "cpu": Cpu,
- "cpuacct": Cpuacct,
- "cpuset": Cpuset,
- "devices": Devices,
- "freezer": Freezer,
- "hugetlb": Hugetlb,
- "memory": Memory,
- "net_cls": NetCls,
- "net_prio": NetPrio,
- "perf_event": PerfEvent,
- "pids": Pids,
- }
-)
-
-// String returns the name of the given controller.
-func (c Controller) String() string {
- if name, ok := controllerNames[c]; ok {
- return name
- }
- return "unknown"
-}
-
-// Path returns the absolute path of the given controller.
-func (c Controller) Path() string {
- return path.Join(mountDir, c.String())
-}
-
-// RelPath returns the relative path of the given controller.
-func (c Controller) RelPath() string {
- return c.String()
-}
-
-// Group returns the given group for the controller.
-func (c Controller) Group(group string) Group {
- return Group(path.Join(mountDir, c.String(), group))
-}
-
-// AsGroup returns the group for the given absolute directory path.
-func AsGroup(absDir string) Group {
- return Group(absDir)
-}
-
-// Controller returns the controller for the group.
-func (g Group) Controller() Controller {
- relPath := strings.TrimPrefix(string(g), mountDir+"/")
- split := strings.SplitN(relPath, "/", 2)
- if len(split) > 0 {
- return controllerDirs[split[0]]
- }
- return UnknownController
-}
-
-// GetTasks reads the pids of threads currently assigned to the group.
-func (g Group) GetTasks() ([]string, error) {
- return g.readPids(Tasks)
-}
-
-// GetProcesses reads the pids of processes currently assigned to the group.
-func (g Group) GetProcesses() ([]string, error) {
- return g.readPids(Procs)
-}
-
-// AddTasks writes the given thread pids to the group.
-func (g Group) AddTasks(pids ...string) error {
- return g.writePids(Tasks, pids...)
-}
-
-// AddProcesses writes the given process pids to the group.
-func (g Group) AddProcesses(pids ...string) error {
- return g.writePids(Procs, pids...)
-}
-
-// Write writes the formatted data to the groups entry.
-func (g Group) Write(entry, format string, args ...interface{}) error {
- entryPath := path.Join(string(g), entry)
- f, err := fsi.OpenFile(entryPath, os.O_WRONLY, 0644)
- if err != nil {
- return g.errorf("%q: failed to open for writing: %v", entry, err)
- }
- defer f.Close()
-
- data := fmt.Sprintf(format, args...)
- if _, err := f.Write([]byte(data)); err != nil {
- return g.errorf("%q: failed to write %q: %v", entry, data, err)
- }
-
- return nil
-}
-
-// Read the groups entry and return contents in a string
-func (g Group) Read(entry string) (string, error) {
- var buf bytes.Buffer
- entryPath := path.Join(string(g), entry)
- f, err := fsi.OpenFile(entryPath, os.O_RDONLY, 0644)
- if err != nil {
- return "", g.errorf("%q: failed to open for reading: %v", entry, err)
- }
- defer f.Close()
- if _, err := buf.ReadFrom(f); err != nil {
- return "", err
- }
- return buf.String(), nil
-}
-
-// readPids reads pids from a cgroup's tasks or procs entry.
-func (g Group) readPids(entry string) ([]string, error) {
- var pids []string
-
- pidFile := path.Join(string(g), entry)
-
- f, err := fsi.OpenFile(pidFile, os.O_RDONLY, 0644)
- if err != nil {
- return nil, g.errorf("failed to open %q: %v", entry, err)
- }
- defer f.Close()
-
- s := bufio.NewScanner(f)
- for s.Scan() {
- pids = append(pids, s.Text())
- }
- if s.Err() != nil {
- return nil, g.errorf("failed to read %q: %v", entry, err)
- }
-
- return pids, nil
-}
-
-// writePids writes pids to a cgroup's tasks or procs entry.
-func (g Group) writePids(entry string, pids ...string) error {
- pidFile := path.Join(string(g), entry)
-
- f, err := fsi.OpenFile(pidFile, os.O_WRONLY, 0644)
- if err != nil {
- return g.errorf("failed to write pids to %q: %v", pidFile, err)
- }
- defer f.Close()
-
- for _, pid := range pids {
- if _, err := f.Write([]byte(pid)); err != nil {
- if !errors.Is(err, syscall.ESRCH) {
- return g.errorf("failed to write pid %s to %q: %v",
- pidFile, pid, err)
- }
- }
- }
-
- return nil
-}
-
-// error returns a formatted group-specific error.
-func (g Group) errorf(format string, args ...interface{}) error {
- name := strings.TrimPrefix(string(g), mountDir+"/")
- return fmt.Errorf("cgroup "+name+": "+format, args...)
-}
diff --git a/vendor/github.com/intel/goresctrl/pkg/cgroups/cgroupid.go b/vendor/github.com/intel/goresctrl/pkg/cgroups/cgroupid.go
deleted file mode 100644
index 920312943c1f..000000000000
--- a/vendor/github.com/intel/goresctrl/pkg/cgroups/cgroupid.go
+++ /dev/null
@@ -1,65 +0,0 @@
-package cgroups
-
-import (
- "fmt"
- "os"
- "path/filepath"
- "sync"
-)
-
-// CgroupID implements mapping kernel cgroup IDs to cgroupfs paths with transparent caching.
-type CgroupID struct {
- root string
- cache map[uint64]string
- sync.Mutex
-}
-
-// NewCgroupID creates a new CgroupID map/cache.
-func NewCgroupID(root string) *CgroupID {
- return &CgroupID{
- root: root,
- cache: make(map[uint64]string),
- }
-}
-
-// Find finds the path for the given cgroup id.
-func (cgid *CgroupID) Find(id uint64) (string, error) {
- found := false
- var p string
-
- cgid.Lock()
- defer cgid.Unlock()
-
- if path, ok := cgid.cache[id]; ok {
- return path, nil
- }
-
- err := fsi.Walk(cgid.root, func(path string, info os.FileInfo, err error) error {
- if err != nil {
- if os.IsNotExist(err) {
- return nil
- }
- return err
- }
-
- if found {
- return filepath.SkipDir
- }
-
- if info.IsDir() && id == getID(path) {
- found = true
- p = path
- return filepath.SkipDir
- }
- return nil
- })
-
- if err != nil {
- return "", err
- } else if !found {
- return "", fmt.Errorf("cgroupid %v not found", id)
- } else {
- cgid.cache[id] = p
- return p, nil
- }
-}
diff --git a/vendor/github.com/intel/goresctrl/pkg/cgroups/cgroupid_linux.go b/vendor/github.com/intel/goresctrl/pkg/cgroups/cgroupid_linux.go
deleted file mode 100644
index 6c27ff1e1a81..000000000000
--- a/vendor/github.com/intel/goresctrl/pkg/cgroups/cgroupid_linux.go
+++ /dev/null
@@ -1,18 +0,0 @@
-//go:build linux
-// +build linux
-
-package cgroups
-
-import (
- "encoding/binary"
- "golang.org/x/sys/unix"
-)
-
-func getID(path string) uint64 {
- h, _, err := unix.NameToHandleAt(unix.AT_FDCWD, path, 0)
- if err != nil {
- return 0
- }
-
- return binary.LittleEndian.Uint64(h.Bytes())
-}
diff --git a/vendor/github.com/intel/goresctrl/pkg/cgroups/cgroupid_other.go b/vendor/github.com/intel/goresctrl/pkg/cgroups/cgroupid_other.go
deleted file mode 100644
index 519450a3fb3a..000000000000
--- a/vendor/github.com/intel/goresctrl/pkg/cgroups/cgroupid_other.go
+++ /dev/null
@@ -1,8 +0,0 @@
-//go:build !linux
-// +build !linux
-
-package cgroups
-
-func getID(path string) uint64 {
- return 0
-}
diff --git a/vendor/github.com/intel/goresctrl/pkg/cgroups/cgrouppath.go b/vendor/github.com/intel/goresctrl/pkg/cgroups/cgrouppath.go
deleted file mode 100644
index 718ba3801e8c..000000000000
--- a/vendor/github.com/intel/goresctrl/pkg/cgroups/cgrouppath.go
+++ /dev/null
@@ -1,75 +0,0 @@
-// Copyright 2020 Intel Corporation. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package cgroups
-
-import (
- "path"
- "path/filepath"
-)
-
-//nolint
-const (
- // Tasks is a cgroup's "tasks" entry.
- Tasks = "tasks"
- // Procs is cgroup's "cgroup.procs" entry.
- Procs = "cgroup.procs"
- // CpuShares is the cpu controller's "cpu.shares" entry.
- CpuShares = "cpu.shares"
- // CpuPeriod is the cpu controller's "cpu.cfs_period_us" entry.
- CpuPeriod = "cpu.cfs_period_us"
- // CpuQuota is the cpu controller's "cpu.cfs_quota_us" entry.
- CpuQuota = "cpu.cfs_quota_us"
- // CpusetCpus is the cpuset controller's cpuset.cpus entry.
- CpusetCpus = "cpuset.cpus"
- // CpusetMems is the cpuset controller's cpuset.mems entry.
- CpusetMems = "cpuset.mems"
-)
-
-var (
- // mount is the parent directory for per-controller cgroupfs mounts.
- mountDir = "/sys/fs/cgroup"
- // v2Dir is the parent directory for per-controller cgroupfs mounts.
- v2Dir = path.Join(mountDir, "unified")
- // KubeletRoot is the --cgroup-root option the kubelet is running with.
- KubeletRoot = ""
-)
-
-// GetMountDir returns the common mount point for cgroup v1 controllers.
-func GetMountDir() string {
- return mountDir
-}
-
-// SetMountDir sets the common mount point for the cgroup v1 controllers.
-func SetMountDir(dir string) {
- v2, _ := filepath.Rel(mountDir, v2Dir)
- mountDir = dir
- if v2 != "" {
- v2Dir = path.Join(mountDir, v2)
- }
-}
-
-// GetV2Dir returns the cgroup v2 unified mount directory.
-func GetV2Dir() string {
- return v2Dir
-}
-
-// SetV2Dir sets the unified cgroup v2 mount directory.
-func SetV2Dir(dir string) {
- if dir[0] == '/' {
- v2Dir = dir
- } else {
- v2Dir = path.Join(mountDir, v2Dir)
- }
-}
diff --git a/vendor/github.com/intel/goresctrl/pkg/cgroups/fsi.go b/vendor/github.com/intel/goresctrl/pkg/cgroups/fsi.go
deleted file mode 100644
index b5e32a2df100..000000000000
--- a/vendor/github.com/intel/goresctrl/pkg/cgroups/fsi.go
+++ /dev/null
@@ -1,39 +0,0 @@
-// Copyright 2021 Intel Corporation. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// This module defines filesystem interface (fsi) through which
-// cgroups package accesses files.
-
-package cgroups
-
-import (
- "os"
- "path/filepath"
-)
-
-type fsiIface interface {
- Open(name string) (fileIface, error)
- OpenFile(name string, flag int, perm os.FileMode) (fileIface, error)
- Walk(string, filepath.WalkFunc) error
- Lstat(path string) (os.FileInfo, error)
-}
-
-type fileIface interface {
- Close() error
- Read(p []byte) (n int, err error)
- Write(b []byte) (n int, err error)
-}
-
-// Set the default filesystem interface
-var fsi fsiIface = newFsiOS()
diff --git a/vendor/github.com/intel/goresctrl/pkg/cgroups/fsimock.go b/vendor/github.com/intel/goresctrl/pkg/cgroups/fsimock.go
deleted file mode 100644
index 54bf47c40520..000000000000
--- a/vendor/github.com/intel/goresctrl/pkg/cgroups/fsimock.go
+++ /dev/null
@@ -1,230 +0,0 @@
-// Copyright 2021 Intel Corporation. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// This module implements a mock filesystem that can be used as a
-// replacement for the native filesystem interface (fsi).
-
-package cgroups
-
-import (
- "fmt"
- "io"
- "os"
- "path/filepath"
- "strings"
- "time"
-)
-
-type fsMock struct {
- files map[string]*mockFile // filesystem contents
-}
-
-type mockFile struct {
- // User-defined file properties
- data []byte // contents of the file
-
- // User/fsimock-defined properties
- info *mockFileInfo
-
- // File-specific user-overrides for the default file behavior
- open func(string) (fileIface, error)
- read func([]byte) (int, error)
- write func([]byte) (int, error)
-
- // fsimock-defined properties
- fs *fsMock
- filename string
- handle *mockFileHandle
- writeHistory [][]byte
-}
-
-type mockFileHandle struct {
- pos int
-}
-
-type mockFileInfo struct {
- mode os.FileMode
- name string
- mf *mockFile
-}
-
-func NewFsiMock(files map[string]mockFile) fsiIface {
- mfs := fsMock{}
- mfs.files = map[string]*mockFile{}
- for filename, usermf := range files {
- mf := usermf
- if mf.info == nil {
- mf.info = &mockFileInfo{}
- }
- if mf.info.name == "" {
- mf.info.name = filepath.Base(filename)
- }
- mf.filename = filename
- mf.info.mf = &mf
- mf.fs = &mfs
- mfs.files[filename] = &mf
- }
- return &mfs
-}
-
-func (mfs fsMock) OpenFile(name string, flag int, perm os.FileMode) (fileIface, error) {
- fsmockLog("OpenFile(%q, %d, %d)", name, flag, perm)
- if mf, ok := mfs.files[name]; ok {
- mf.handle = &mockFileHandle{}
- if mf.open != nil {
- return mf.open(name)
- }
- return *mf, nil
- }
- return nil, fsmockErrorf("%q: file not found", name)
-}
-
-func (mfs fsMock) Open(name string) (fileIface, error) {
- return mfs.OpenFile(name, 0, 0)
-}
-
-func (mfs fsMock) Walk(path string, walkFn filepath.WalkFunc) error {
- dirPath := strings.TrimSuffix(path, "/")
- info, err := mfs.Lstat(dirPath)
- if err != nil {
- err = walkFn(path, nil, err)
- return err
- }
- if !info.IsDir() {
- return walkFn(path, info, nil)
- }
- err = walkFn(path, info, nil)
- if err != nil {
- return err
- }
- for _, name := range mfs.dirContents(dirPath) {
- if err = mfs.Walk(dirPath+"/"+name, walkFn); err != nil && err != filepath.SkipDir {
- return err
- }
- }
- return nil
-}
-
-func (mfs fsMock) dirContents(path string) []string {
- dirPathS := strings.TrimSuffix(path, "/") + "/"
- contentSet := map[string]struct{}{}
- for filename := range mfs.files {
- if !strings.HasPrefix(filename, dirPathS) {
- continue
- }
- relToDirPath := strings.TrimPrefix(filename, dirPathS)
- names := strings.SplitN(relToDirPath, "/", 2)
- contentSet[names[0]] = struct{}{}
- }
- contents := make([]string, 0, len(contentSet))
- for name := range contentSet {
- contents = append(contents, name)
- }
- return contents
-}
-
-func (mfs fsMock) Lstat(path string) (os.FileInfo, error) {
- if mf, ok := mfs.files[path]; ok {
- return *mf.info, nil
- }
- if len(mfs.dirContents(path)) > 0 {
- return mockFileInfo{
- name: filepath.Base(path),
- mode: os.ModeDir,
- }, nil
- }
- return mockFileInfo{}, fsmockErrorf("%q: file not found", path)
-}
-
-func (mfi mockFileInfo) Name() string {
- return mfi.name
-}
-func (mfi mockFileInfo) Size() int64 {
- if mfi.mf != nil {
- return int64(len(mfi.mf.data))
- }
- return 0
-}
-func (mfi mockFileInfo) Mode() os.FileMode {
- return mfi.mode
-}
-
-func (mfi mockFileInfo) ModTime() time.Time {
- return time.Time{}
-}
-
-func (mfi mockFileInfo) IsDir() bool {
- return mfi.mode&os.ModeDir != 0
-}
-
-func (mfi mockFileInfo) Sys() interface{} {
- return nil
-}
-
-func (mf mockFile) Write(b []byte) (n int, err error) {
- pos := mf.handle.pos
- if mf.write != nil {
- n, err = mf.write(b)
- if err == nil {
- mf.fs.files[mf.filename].writeHistory = append(mf.fs.files[mf.filename].writeHistory, b)
- }
- } else {
- newpos := pos + len(b)
- if newpos > cap(mf.data) {
- newdata := make([]byte, newpos)
- copy(newdata, mf.data)
- mf.data = newdata
- }
- copy(mf.data[pos:newpos], b)
- mf.handle.pos = newpos
- if f, ok := mf.fs.files[mf.filename]; ok {
- f.data = mf.data
- }
- mf.fs.files[mf.filename].writeHistory = append(mf.fs.files[mf.filename].writeHistory, b)
- }
- fsmockLog("{%q, pos=%d}.Write([%d]byte(%q)) = (%d, %v) %q", mf.filename, pos, len(b), string(b), n, err, mf.fs.files[mf.filename].data)
- return n, err
-}
-
-func (mf mockFile) Read(b []byte) (n int, err error) {
- pos := mf.handle.pos
- if mf.read != nil {
- n, err = mf.read(b)
- } else {
- n = len(mf.data) - pos
- err = nil
- if n <= 0 {
- err = io.EOF
- }
- if n > cap(b) {
- n = cap(b)
- }
- copy(b, mf.data[pos:pos+n])
- mf.handle.pos += n
- }
- fsmockLog("{%q, pos=%d}.Read([%d]byte) = (%d, %v)\n", mf.filename, pos, len(b), n, err)
- return
-}
-
-func (mf mockFile) Close() error {
- return nil
-}
-
-func fsmockLog(format string, args ...interface{}) {
- fmt.Printf("fsmock: "+format+"\n", args...)
-}
-
-func fsmockErrorf(format string, args ...interface{}) error {
- return fmt.Errorf("fsmock: "+format, args...)
-}
diff --git a/vendor/github.com/intel/goresctrl/pkg/cgroups/fsios.go b/vendor/github.com/intel/goresctrl/pkg/cgroups/fsios.go
deleted file mode 100644
index d1eb35178247..000000000000
--- a/vendor/github.com/intel/goresctrl/pkg/cgroups/fsios.go
+++ /dev/null
@@ -1,63 +0,0 @@
-// Copyright 2021 Intel Corporation. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// This module provides the native implementation of the filesystem
-// interface (fsi).
-
-package cgroups
-
-import (
- "os"
- "path/filepath"
-)
-
-type fsOs struct{}
-
-type osFile struct {
- file *os.File
-}
-
-func newFsiOS() fsiIface {
- return fsOs{}
-}
-
-func (fsOs) OpenFile(name string, flag int, perm os.FileMode) (fileIface, error) {
- f, err := os.OpenFile(name, flag, perm)
- return osFile{f}, err
-}
-
-func (fsOs) Open(name string) (fileIface, error) {
- f, err := os.Open(name)
- return osFile{f}, err
-}
-
-func (fsOs) Lstat(name string) (os.FileInfo, error) {
- return os.Lstat(name)
-}
-
-func (fsOs) Walk(root string, walkFn filepath.WalkFunc) error {
- return filepath.Walk(root, walkFn)
-}
-
-func (osf osFile) Write(b []byte) (n int, err error) {
- return osf.file.Write(b)
-}
-
-func (osf osFile) Read(b []byte) (n int, err error) {
- return osf.file.Read(b)
-}
-
-func (osf osFile) Close() error {
- return osf.file.Close()
-}
diff --git a/vendor/github.com/intel/goresctrl/pkg/path/path.go b/vendor/github.com/intel/goresctrl/pkg/path/path.go
new file mode 100644
index 000000000000..a217b0105969
--- /dev/null
+++ b/vendor/github.com/intel/goresctrl/pkg/path/path.go
@@ -0,0 +1,35 @@
+/*
+Copyright 2023 Intel Corporation
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package path
+
+import "path/filepath"
+
+// RootDir is a helper for handling system directory paths
+type RootDir string
+
+var prefix RootDir = "/"
+
+// Path returns a full path to a file under RootDir
+func (d RootDir) Path(elems ...string) string {
+ return filepath.Join(append([]string{string(d)}, elems...)...)
+}
+
+// SetPrefix sets the global path prefix to use for all system files.
+func SetPrefix(p string) { prefix = RootDir(p) }
+
+// Path returns a path to a file, prefixed with the global prefix.
+func Path(elems ...string) string { return prefix.Path(elems...) }
diff --git a/vendor/github.com/intel/goresctrl/pkg/rdt/info.go b/vendor/github.com/intel/goresctrl/pkg/rdt/info.go
index abd0727bdaa7..05327b2a4140 100644
--- a/vendor/github.com/intel/goresctrl/pkg/rdt/info.go
+++ b/vendor/github.com/intel/goresctrl/pkg/rdt/info.go
@@ -19,7 +19,6 @@ package rdt
import (
"bufio"
"fmt"
- "io/ioutil"
"os"
"path/filepath"
"sort"
@@ -336,6 +335,6 @@ func readFileBitmask(path string) (bitmask, error) {
}
func readFileString(path string) (string, error) {
- data, err := ioutil.ReadFile(path)
+ data, err := os.ReadFile(path)
return strings.TrimSpace(string(data)), err
}
diff --git a/vendor/github.com/intel/goresctrl/pkg/rdt/rdt.go b/vendor/github.com/intel/goresctrl/pkg/rdt/rdt.go
index ed621b80a1dd..a0991f8abfe2 100644
--- a/vendor/github.com/intel/goresctrl/pkg/rdt/rdt.go
+++ b/vendor/github.com/intel/goresctrl/pkg/rdt/rdt.go
@@ -25,28 +25,28 @@ limitations under the License.
// Monitoring (MBM).
//
// Basic usage example:
-// rdt.SetLogger(logrus.New())
//
-// if err := rdt.Initialize(""); err != nil {
-// return fmt.Errorf("RDT not supported: %v", err)
-// }
+// rdt.SetLogger(logrus.New())
//
-// if err := rdt.SetConfigFromFile("/path/to/rdt.conf.yaml", false); err != nil {
-// return fmt.Errorf("RDT configuration failed: %v", err)
-// }
+// if err := rdt.Initialize(""); err != nil {
+// return fmt.Errorf("RDT not supported: %v", err)
+// }
//
-// if cls, ok := rdt.GetClass("my-class"); ok {
-// // Set PIDs 12345 and 12346 to class "my-class"
-// if err := cls.AddPids("12345", "12346"); err != nil {
-// return fmt.Errorf("failed to add PIDs to RDT class: %v", err)
-// }
-// }
+// if err := rdt.SetConfigFromFile("/path/to/rdt.conf.yaml", false); err != nil {
+// return fmt.Errorf("RDT configuration failed: %v", err)
+// }
+//
+// if cls, ok := rdt.GetClass("my-class"); ok {
+// // Set PIDs 12345 and 12346 to class "my-class"
+// if err := cls.AddPids("12345", "12346"); err != nil {
+// return fmt.Errorf("failed to add PIDs to RDT class: %v", err)
+// }
+// }
package rdt
import (
"errors"
"fmt"
- "io/ioutil"
stdlog "log"
"os"
"path/filepath"
@@ -234,7 +234,7 @@ func SetConfig(c *Config, force bool) error {
// reconfigures the resctrl filesystem.
func SetConfigFromData(data []byte, force bool) error {
cfg := &Config{}
- if err := yaml.Unmarshal(data, &cfg); err != nil {
+ if err := yaml.UnmarshalStrict(data, cfg); err != nil {
return fmt.Errorf("failed to parse configuration data: %v", err)
}
@@ -244,7 +244,7 @@ func SetConfigFromData(data []byte, force bool) error {
// SetConfigFromFile reads configuration from the filesystem and reconfigures
// the resctrl filesystem.
func SetConfigFromFile(path string, force bool) error {
- data, err := ioutil.ReadFile(path)
+ data, err := os.ReadFile(path)
if err != nil {
return fmt.Errorf("failed to read config file: %v", err)
}
@@ -490,11 +490,11 @@ func (c *control) pruneMonGroups() error {
}
func (c *control) readRdtFile(rdtPath string) ([]byte, error) {
- return ioutil.ReadFile(filepath.Join(info.resctrlPath, rdtPath))
+ return os.ReadFile(filepath.Join(info.resctrlPath, rdtPath))
}
func (c *control) writeRdtFile(rdtPath string, data []byte) error {
- if err := ioutil.WriteFile(filepath.Join(info.resctrlPath, rdtPath), data, 0644); err != nil {
+ if err := os.WriteFile(filepath.Join(info.resctrlPath, rdtPath), data, 0644); err != nil {
return c.cmdError(err)
}
return nil
@@ -728,7 +728,7 @@ func (r *resctrlGroup) GetMonData() MonData {
}
func (r *resctrlGroup) getMonL3Data() (MonL3Data, error) {
- files, err := ioutil.ReadDir(r.path("mon_data"))
+ files, err := os.ReadDir(r.path("mon_data"))
if err != nil {
return nil, err
}
@@ -759,7 +759,7 @@ func (r *resctrlGroup) getMonL3Data() (MonL3Data, error) {
}
func (r *resctrlGroup) getMonLeafData(path string) (MonLeafData, error) {
- files, err := ioutil.ReadDir(r.path(path))
+ files, err := os.ReadDir(r.path(path))
if err != nil {
return nil, err
}
@@ -826,7 +826,7 @@ func (m *monGroup) GetAnnotations() map[string]string {
}
func resctrlGroupsFromFs(prefix string, path string) ([]string, error) {
- files, err := ioutil.ReadDir(path)
+ files, err := os.ReadDir(path)
if err != nil {
return nil, err
}
diff --git a/vendor/github.com/intel/goresctrl/pkg/utils/idset.go b/vendor/github.com/intel/goresctrl/pkg/utils/idset.go
index 16fb4d4431f0..71d256a4e5c9 100644
--- a/vendor/github.com/intel/goresctrl/pkg/utils/idset.go
+++ b/vendor/github.com/intel/goresctrl/pkg/utils/idset.go
@@ -169,7 +169,7 @@ func (s *IDSet) UnmarshalJSON(data []byte) error {
}
for _, idstr := range strings.Split(str, ",") {
- id, err := strconv.ParseUint(idstr, 10, 0)
+ id, err := strconv.ParseInt(idstr, 10, 0)
if err != nil {
return fmt.Errorf("invalid IDSet entry '%s': %v", idstr, err)
}
diff --git a/vendor/github.com/intel/goresctrl/pkg/utils/msr.go b/vendor/github.com/intel/goresctrl/pkg/utils/msr.go
index 94f648773c43..17fa4daa1bc9 100644
--- a/vendor/github.com/intel/goresctrl/pkg/utils/msr.go
+++ b/vendor/github.com/intel/goresctrl/pkg/utils/msr.go
@@ -20,12 +20,13 @@ import (
"encoding/binary"
"fmt"
"os"
+
+ goresctrlpath "github.com/intel/goresctrl/pkg/path"
)
func ReadMSR(cpu ID, msr int64) (uint64, error) {
- str := fmt.Sprintf("/dev/cpu/%d/msr", cpu)
-
- file, err := os.Open(str)
+ path := goresctrlpath.Path("dev/cpu", fmt.Sprintf("%d", cpu), "msr")
+ file, err := os.Open(path)
if err != nil {
return 0, err
}
diff --git a/vendor/github.com/intel/goresctrl/pkg/utils/sysfs.go b/vendor/github.com/intel/goresctrl/pkg/utils/sysfs.go
index bb1bd36144ab..0dfb70c34516 100644
--- a/vendor/github.com/intel/goresctrl/pkg/utils/sysfs.go
+++ b/vendor/github.com/intel/goresctrl/pkg/utils/sysfs.go
@@ -18,26 +18,25 @@ package utils
import (
"fmt"
- "io/ioutil"
"os"
"strconv"
"strings"
+
+ goresctrlpath "github.com/intel/goresctrl/pkg/path"
)
const (
- SysfsUncoreBasepath = "/sys/devices/system/cpu/intel_uncore_frequency/"
+ SysfsUncoreBasepath = "sys/devices/system/cpu/intel_uncore_frequency"
+ SysfsCpuBasepath = "sys/devices/system/cpu"
)
func setCPUFreqValue(cpu ID, setting string, value int) error {
- path := fmt.Sprintf("/sys/devices/system/cpu/cpu%d/cpufreq/%s", cpu, setting)
- return writeFileInt(path, value)
+ return writeFileInt(cpuFreqPath(cpu, setting), value)
}
// GetCPUFreqValue returns information of the currently used CPU frequency
func GetCPUFreqValue(cpu ID, setting string) (int, error) {
- str := fmt.Sprintf("/sys/devices/system/cpu/cpu%d/cpufreq/%s", cpu, setting)
-
- raw, err := ioutil.ReadFile(str)
+ raw, err := os.ReadFile(cpuFreqPath(cpu, setting))
if err != nil {
return 0, err
}
@@ -50,6 +49,10 @@ func GetCPUFreqValue(cpu ID, setting string) (int, error) {
return value, nil
}
+func cpuFreqPath(cpu ID, setting string) string {
+ return goresctrlpath.Path(SysfsCpuBasepath, fmt.Sprintf("cpu%d", cpu), "cpufreq", setting)
+}
+
// SetCPUScalingMinFreq sets the scaling_min_freq value of a given CPU
func SetCPUScalingMinFreq(cpu ID, freq int) error {
return setCPUFreqValue(cpu, "scaling_min_freq", freq)
@@ -84,7 +87,7 @@ func SetCPUsScalingMaxFreq(cpus []ID, freq int) error {
// UncoreFreqAvailable returns true if the uncore frequency control functions are available.
func UncoreFreqAvailable() bool {
- _, err := os.Stat(SysfsUncoreBasepath)
+ _, err := os.Stat(goresctrlpath.Path(SysfsUncoreBasepath))
return err == nil
}
@@ -99,7 +102,7 @@ func SetUncoreMaxFreq(pkg, die ID, freqKhz int) error {
}
func uncoreFreqPath(pkg, die ID, attribute string) string {
- return fmt.Sprintf(SysfsUncoreBasepath+"package_%02d_die_%02d/%s", pkg, die, attribute)
+ return goresctrlpath.Path(SysfsUncoreBasepath, fmt.Sprintf("package_%02d_die_%02d", pkg, die), attribute)
}
func getUncoreFreqValue(pkg, die ID, attribute string) (int, error) {
@@ -123,11 +126,11 @@ func setUncoreFreqValue(pkg, die ID, attribute string, value int) error {
}
func writeFileInt(path string, value int) error {
- return ioutil.WriteFile(path, []byte(strconv.Itoa(value)), 0644)
+ return os.WriteFile(path, []byte(strconv.Itoa(value)), 0644)
}
func readFileInt(path string) (int, error) {
- data, err := ioutil.ReadFile(path)
+ data, err := os.ReadFile(path)
if err != nil {
return 0, err
}
diff --git a/vendor/github.com/josharian/intern/README.md b/vendor/github.com/josharian/intern/README.md
new file mode 100644
index 000000000000..ffc44b219b2f
--- /dev/null
+++ b/vendor/github.com/josharian/intern/README.md
@@ -0,0 +1,5 @@
+Docs: https://godoc.org/github.com/josharian/intern
+
+See also [Go issue 5160](https://golang.org/issue/5160).
+
+License: MIT
diff --git a/vendor/github.com/josharian/intern/intern.go b/vendor/github.com/josharian/intern/intern.go
new file mode 100644
index 000000000000..7acb1fe90a11
--- /dev/null
+++ b/vendor/github.com/josharian/intern/intern.go
@@ -0,0 +1,44 @@
+// Package intern interns strings.
+// Interning is best effort only.
+// Interned strings may be removed automatically
+// at any time without notification.
+// All functions may be called concurrently
+// with themselves and each other.
+package intern
+
+import "sync"
+
+var (
+ pool sync.Pool = sync.Pool{
+ New: func() interface{} {
+ return make(map[string]string)
+ },
+ }
+)
+
+// String returns s, interned.
+func String(s string) string {
+ m := pool.Get().(map[string]string)
+ c, ok := m[s]
+ if ok {
+ pool.Put(m)
+ return c
+ }
+ m[s] = s
+ pool.Put(m)
+ return s
+}
+
+// Bytes returns b converted to a string, interned.
+func Bytes(b []byte) string {
+ m := pool.Get().(map[string]string)
+ c, ok := m[string(b)]
+ if ok {
+ pool.Put(m)
+ return c
+ }
+ s := string(b)
+ m[s] = s
+ pool.Put(m)
+ return s
+}
diff --git a/vendor/github.com/josharian/intern/license.md b/vendor/github.com/josharian/intern/license.md
new file mode 100644
index 000000000000..353d3055f0b4
--- /dev/null
+++ b/vendor/github.com/josharian/intern/license.md
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Josh Bleecher Snyder
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/vendor/github.com/klauspost/compress/.goreleaser.yml b/vendor/github.com/klauspost/compress/.goreleaser.yml
index 7a008a4d23eb..a22953805c63 100644
--- a/vendor/github.com/klauspost/compress/.goreleaser.yml
+++ b/vendor/github.com/klauspost/compress/.goreleaser.yml
@@ -3,7 +3,6 @@
before:
hooks:
- ./gen.sh
- - go install mvdan.cc/garble@v0.9.3
builds:
-
@@ -32,7 +31,6 @@ builds:
- mips64le
goarm:
- 7
- gobinary: garble
-
id: "s2d"
binary: s2d
@@ -59,7 +57,6 @@ builds:
- mips64le
goarm:
- 7
- gobinary: garble
-
id: "s2sx"
binary: s2sx
@@ -87,21 +84,11 @@ builds:
- mips64le
goarm:
- 7
- gobinary: garble
archives:
-
id: s2-binaries
- name_template: "s2-{{ .Os }}_{{ .Arch }}_{{ .Version }}"
- replacements:
- aix: AIX
- darwin: OSX
- linux: Linux
- windows: Windows
- 386: i386
- amd64: x86_64
- freebsd: FreeBSD
- netbsd: NetBSD
+ name_template: "s2-{{ .Os }}_{{ .Arch }}{{ if .Arm }}v{{ .Arm }}{{ end }}"
format_overrides:
- goos: windows
format: zip
@@ -125,7 +112,7 @@ changelog:
nfpms:
-
- file_name_template: "s2_package_{{ .Version }}_{{ .Os }}_{{ .Arch }}"
+ file_name_template: "s2_package__{{ .Os }}_{{ .Arch }}{{ if .Arm }}v{{ .Arm }}{{ end }}"
vendor: Klaus Post
homepage: /~https://github.com/klauspost/compress
maintainer: Klaus Post | Benchmark | go-toml v1 | BurntSushi/toml |
|---|---|---|
| Marshal/HugoFrontMatter-2 | 1.9x | 2.2x |
| Marshal/ReferenceFile/map-2 | 1.7x | 2.1x |
| Marshal/ReferenceFile/struct-2 | 2.2x | 3.0x |
| Unmarshal/HugoFrontMatter-2 | 2.9x | 2.7x |
| Unmarshal/ReferenceFile/map-2 | 2.6x | 2.7x |
| Unmarshal/ReferenceFile/struct-2 | 4.6x | 5.1x |
The table above has the results of the most common use-cases. The table below +contains the results of all benchmarks, including unrealistic ones. It is +provided for completeness.
+ +| Benchmark | go-toml v1 | BurntSushi/toml |
|---|---|---|
| Marshal/SimpleDocument/map-2 | 1.8x | 2.7x |
| Marshal/SimpleDocument/struct-2 | 2.7x | 3.8x |
| Unmarshal/SimpleDocument/map-2 | 3.8x | 3.0x |
| Unmarshal/SimpleDocument/struct-2 | 5.6x | 4.1x |
| UnmarshalDataset/example-2 | 3.0x | 3.2x |
| UnmarshalDataset/code-2 | 2.3x | 2.9x |
| UnmarshalDataset/twitter-2 | 2.6x | 2.7x |
| UnmarshalDataset/citm_catalog-2 | 2.2x | 2.3x |
| UnmarshalDataset/canada-2 | 1.8x | 1.5x |
| UnmarshalDataset/config-2 | 4.1x | 2.9x |
| geomean | 2.7x | 2.8x |
This table can be generated with ./ci.sh benchmark -a -html.
| Benchmark | go-toml v1 | BurntSushi/toml |
|---|---|---|
| {} | {} | {} |
The table above has the results of the most common use-cases. The table below +contains the results of all benchmarks, including unrealistic ones. It is +provided for completeness.
""") +printtable(below) +print('This table can be generated with ./ci.sh benchmark -a -html.
=p for i =p for i