mirror of
https://github.com/superseriousbusiness/gotosocial.git
synced 2024-12-05 01:52:46 +00:00
57dc742c76
Bumps [github.com/KimMachineGun/automemlimit](https://github.com/KimMachineGun/automemlimit) from 0.2.4 to 0.2.5. - [Release notes](https://github.com/KimMachineGun/automemlimit/releases) - [Commits](https://github.com/KimMachineGun/automemlimit/compare/v0.2.4...v0.2.5) --- updated-dependencies: - dependency-name: github.com/KimMachineGun/automemlimit dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
265 lines
5.8 KiB
Go
265 lines
5.8 KiB
Go
package ebpf
|
|
|
|
import (
|
|
"bytes"
|
|
"errors"
|
|
"fmt"
|
|
|
|
"github.com/cilium/ebpf/asm"
|
|
"github.com/cilium/ebpf/internal"
|
|
"github.com/cilium/ebpf/internal/sys"
|
|
"github.com/cilium/ebpf/internal/unix"
|
|
)
|
|
|
|
// invalidBPFObjNameChar returns true if char may not appear in
|
|
// a BPF object name.
|
|
func invalidBPFObjNameChar(char rune) bool {
|
|
dotAllowed := objNameAllowsDot() == nil
|
|
|
|
switch {
|
|
case char >= 'A' && char <= 'Z':
|
|
return false
|
|
case char >= 'a' && char <= 'z':
|
|
return false
|
|
case char >= '0' && char <= '9':
|
|
return false
|
|
case dotAllowed && char == '.':
|
|
return false
|
|
case char == '_':
|
|
return false
|
|
default:
|
|
return true
|
|
}
|
|
}
|
|
|
|
func progLoad(insns asm.Instructions, typ ProgramType, license string) (*sys.FD, error) {
|
|
buf := bytes.NewBuffer(make([]byte, 0, insns.Size()))
|
|
if err := insns.Marshal(buf, internal.NativeEndian); err != nil {
|
|
return nil, err
|
|
}
|
|
bytecode := buf.Bytes()
|
|
|
|
return sys.ProgLoad(&sys.ProgLoadAttr{
|
|
ProgType: sys.ProgType(typ),
|
|
License: sys.NewStringPointer(license),
|
|
Insns: sys.NewSlicePointer(bytecode),
|
|
InsnCnt: uint32(len(bytecode) / asm.InstructionSize),
|
|
})
|
|
}
|
|
|
|
var haveNestedMaps = internal.FeatureTest("nested maps", "4.12", func() error {
|
|
_, err := sys.MapCreate(&sys.MapCreateAttr{
|
|
MapType: sys.MapType(ArrayOfMaps),
|
|
KeySize: 4,
|
|
ValueSize: 4,
|
|
MaxEntries: 1,
|
|
// Invalid file descriptor.
|
|
InnerMapFd: ^uint32(0),
|
|
})
|
|
if errors.Is(err, unix.EINVAL) {
|
|
return internal.ErrNotSupported
|
|
}
|
|
if errors.Is(err, unix.EBADF) {
|
|
return nil
|
|
}
|
|
return err
|
|
})
|
|
|
|
var haveMapMutabilityModifiers = internal.FeatureTest("read- and write-only maps", "5.2", func() error {
|
|
// This checks BPF_F_RDONLY_PROG and BPF_F_WRONLY_PROG. Since
|
|
// BPF_MAP_FREEZE appeared in 5.2 as well we don't do a separate check.
|
|
m, err := sys.MapCreate(&sys.MapCreateAttr{
|
|
MapType: sys.MapType(Array),
|
|
KeySize: 4,
|
|
ValueSize: 4,
|
|
MaxEntries: 1,
|
|
MapFlags: unix.BPF_F_RDONLY_PROG,
|
|
})
|
|
if err != nil {
|
|
return internal.ErrNotSupported
|
|
}
|
|
_ = m.Close()
|
|
return nil
|
|
})
|
|
|
|
var haveMmapableMaps = internal.FeatureTest("mmapable maps", "5.5", func() error {
|
|
// This checks BPF_F_MMAPABLE, which appeared in 5.5 for array maps.
|
|
m, err := sys.MapCreate(&sys.MapCreateAttr{
|
|
MapType: sys.MapType(Array),
|
|
KeySize: 4,
|
|
ValueSize: 4,
|
|
MaxEntries: 1,
|
|
MapFlags: unix.BPF_F_MMAPABLE,
|
|
})
|
|
if err != nil {
|
|
return internal.ErrNotSupported
|
|
}
|
|
_ = m.Close()
|
|
return nil
|
|
})
|
|
|
|
var haveInnerMaps = internal.FeatureTest("inner maps", "5.10", func() error {
|
|
// This checks BPF_F_INNER_MAP, which appeared in 5.10.
|
|
m, err := sys.MapCreate(&sys.MapCreateAttr{
|
|
MapType: sys.MapType(Array),
|
|
KeySize: 4,
|
|
ValueSize: 4,
|
|
MaxEntries: 1,
|
|
MapFlags: unix.BPF_F_INNER_MAP,
|
|
})
|
|
if err != nil {
|
|
return internal.ErrNotSupported
|
|
}
|
|
_ = m.Close()
|
|
return nil
|
|
})
|
|
|
|
var haveNoPreallocMaps = internal.FeatureTest("prealloc maps", "4.6", func() error {
|
|
// This checks BPF_F_NO_PREALLOC, which appeared in 4.6.
|
|
m, err := sys.MapCreate(&sys.MapCreateAttr{
|
|
MapType: sys.MapType(Hash),
|
|
KeySize: 4,
|
|
ValueSize: 4,
|
|
MaxEntries: 1,
|
|
MapFlags: unix.BPF_F_NO_PREALLOC,
|
|
})
|
|
if err != nil {
|
|
return internal.ErrNotSupported
|
|
}
|
|
_ = m.Close()
|
|
return nil
|
|
})
|
|
|
|
func wrapMapError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
|
|
if errors.Is(err, unix.ENOENT) {
|
|
return sys.Error(ErrKeyNotExist, unix.ENOENT)
|
|
}
|
|
|
|
if errors.Is(err, unix.EEXIST) {
|
|
return sys.Error(ErrKeyExist, unix.EEXIST)
|
|
}
|
|
|
|
if errors.Is(err, unix.ENOTSUPP) {
|
|
return sys.Error(ErrNotSupported, unix.ENOTSUPP)
|
|
}
|
|
|
|
if errors.Is(err, unix.E2BIG) {
|
|
return fmt.Errorf("key too big for map: %w", err)
|
|
}
|
|
|
|
return err
|
|
}
|
|
|
|
var haveObjName = internal.FeatureTest("object names", "4.15", func() error {
|
|
attr := sys.MapCreateAttr{
|
|
MapType: sys.MapType(Array),
|
|
KeySize: 4,
|
|
ValueSize: 4,
|
|
MaxEntries: 1,
|
|
MapName: sys.NewObjName("feature_test"),
|
|
}
|
|
|
|
fd, err := sys.MapCreate(&attr)
|
|
if err != nil {
|
|
return internal.ErrNotSupported
|
|
}
|
|
|
|
_ = fd.Close()
|
|
return nil
|
|
})
|
|
|
|
var objNameAllowsDot = internal.FeatureTest("dot in object names", "5.2", func() error {
|
|
if err := haveObjName(); err != nil {
|
|
return err
|
|
}
|
|
|
|
attr := sys.MapCreateAttr{
|
|
MapType: sys.MapType(Array),
|
|
KeySize: 4,
|
|
ValueSize: 4,
|
|
MaxEntries: 1,
|
|
MapName: sys.NewObjName(".test"),
|
|
}
|
|
|
|
fd, err := sys.MapCreate(&attr)
|
|
if err != nil {
|
|
return internal.ErrNotSupported
|
|
}
|
|
|
|
_ = fd.Close()
|
|
return nil
|
|
})
|
|
|
|
var haveBatchAPI = internal.FeatureTest("map batch api", "5.6", func() error {
|
|
var maxEntries uint32 = 2
|
|
attr := sys.MapCreateAttr{
|
|
MapType: sys.MapType(Hash),
|
|
KeySize: 4,
|
|
ValueSize: 4,
|
|
MaxEntries: maxEntries,
|
|
}
|
|
|
|
fd, err := sys.MapCreate(&attr)
|
|
if err != nil {
|
|
return internal.ErrNotSupported
|
|
}
|
|
defer fd.Close()
|
|
|
|
keys := []uint32{1, 2}
|
|
values := []uint32{3, 4}
|
|
kp, _ := marshalPtr(keys, 8)
|
|
vp, _ := marshalPtr(values, 8)
|
|
|
|
err = sys.MapUpdateBatch(&sys.MapUpdateBatchAttr{
|
|
MapFd: fd.Uint(),
|
|
Keys: kp,
|
|
Values: vp,
|
|
Count: maxEntries,
|
|
})
|
|
if err != nil {
|
|
return internal.ErrNotSupported
|
|
}
|
|
return nil
|
|
})
|
|
|
|
var haveProbeReadKernel = internal.FeatureTest("bpf_probe_read_kernel", "5.5", func() error {
|
|
insns := asm.Instructions{
|
|
asm.Mov.Reg(asm.R1, asm.R10),
|
|
asm.Add.Imm(asm.R1, -8),
|
|
asm.Mov.Imm(asm.R2, 8),
|
|
asm.Mov.Imm(asm.R3, 0),
|
|
asm.FnProbeReadKernel.Call(),
|
|
asm.Return(),
|
|
}
|
|
|
|
fd, err := progLoad(insns, Kprobe, "GPL")
|
|
if err != nil {
|
|
return internal.ErrNotSupported
|
|
}
|
|
_ = fd.Close()
|
|
return nil
|
|
})
|
|
|
|
var haveBPFToBPFCalls = internal.FeatureTest("bpf2bpf calls", "4.16", func() error {
|
|
insns := asm.Instructions{
|
|
asm.Call.Label("prog2").WithSymbol("prog1"),
|
|
asm.Return(),
|
|
asm.Mov.Imm(asm.R0, 0).WithSymbol("prog2"),
|
|
asm.Return(),
|
|
}
|
|
|
|
fd, err := progLoad(insns, SocketFilter, "MIT")
|
|
if errors.Is(err, unix.EINVAL) {
|
|
return internal.ErrNotSupported
|
|
}
|
|
if err != nil {
|
|
return err
|
|
}
|
|
_ = fd.Close()
|
|
return nil
|
|
})
|