counter_arm64_bpfel.go

// Code generated by bpf2go; DO NOT EDIT.
//go:build arm64

package main

import (
	"bytes"
	_ "embed"
	"fmt"
	"io"

	"github.com/cilium/ebpf"
)

type counterSockinfo struct {
	Comm [16]uint8
	Pid  int32
}

type counterStatkey struct {
	Srcip   struct{ In6U struct{ U6Addr8 [16]uint8 } }
	Dstip   struct{ In6U struct{ U6Addr8 [16]uint8 } }
	SrcPort uint16
	DstPort uint16
	Proto   uint8
	_       [3]byte
	Pid     int32
	Comm    [16]int8
}

type counterStatvalue struct {
	Packets uint64
	Bytes   uint64
}

// loadCounter returns the embedded CollectionSpec for counter.
func loadCounter() (*ebpf.CollectionSpec, error) {
	reader := bytes.NewReader(_CounterBytes)
	spec, err := ebpf.LoadCollectionSpecFromReader(reader)
	if err != nil {
		return nil, fmt.Errorf("can't load counter: %w", err)
	}

	return spec, err
}

// loadCounterObjects loads counter and converts it into a struct.
//
// The following types are suitable as obj argument:
//
//	*counterObjects
//	*counterPrograms
//	*counterMaps
//
// See ebpf.CollectionSpec.LoadAndAssign documentation for details.
func loadCounterObjects(obj interface{}, opts *ebpf.CollectionOptions) error {
	spec, err := loadCounter()
	if err != nil {
		return err
	}

	return spec.LoadAndAssign(obj, opts)
}

// counterSpecs contains maps and programs before they are loaded into the kernel.
//
// It can be passed ebpf.CollectionSpec.Assign.
type counterSpecs struct {
	counterProgramSpecs
	counterMapSpecs
	counterVariableSpecs
}

// counterProgramSpecs contains programs before they are loaded into the kernel.
//
// It can be passed ebpf.CollectionSpec.Assign.
type counterProgramSpecs struct {
	IcmpSend         *ebpf.ProgramSpec `ebpf:"__icmp_send"`
	CgroupSkbEgress  *ebpf.ProgramSpec `ebpf:"cgroup_skb_egress"`
	CgroupSkbIngress *ebpf.ProgramSpec `ebpf:"cgroup_skb_ingress"`
	CgroupSockCreate *ebpf.ProgramSpec `ebpf:"cgroup_sock_create"`
	Icmp6Send        *ebpf.ProgramSpec `ebpf:"icmp6_send"`
	IcmpRcv          *ebpf.ProgramSpec `ebpf:"icmp_rcv"`
	Icmpv6Rcv        *ebpf.ProgramSpec `ebpf:"icmpv6_rcv"`
	IpSendSkb        *ebpf.ProgramSpec `ebpf:"ip_send_skb"`
	SkbConsumeUdp    *ebpf.ProgramSpec `ebpf:"skb_consume_udp"`
	TcCountPackets   *ebpf.ProgramSpec `ebpf:"tc_count_packets"`
	TcpCleanupRbuf   *ebpf.ProgramSpec `ebpf:"tcp_cleanup_rbuf"`
	TcpSendmsg       *ebpf.ProgramSpec `ebpf:"tcp_sendmsg"`
	XdpCountPackets  *ebpf.ProgramSpec `ebpf:"xdp_count_packets"`
}

// counterMapSpecs contains maps before they are loaded into the kernel.
//
// It can be passed ebpf.CollectionSpec.Assign.
type counterMapSpecs struct {
	PktCount *ebpf.MapSpec `ebpf:"pkt_count"`
	SockInfo *ebpf.MapSpec `ebpf:"sock_info"`
}

// counterVariableSpecs contains global variables before they are loaded into the kernel.
//
// It can be passed ebpf.CollectionSpec.Assign.
type counterVariableSpecs struct {
}

// counterObjects contains all objects after they have been loaded into the kernel.
//
// It can be passed to loadCounterObjects or ebpf.CollectionSpec.LoadAndAssign.
type counterObjects struct {
	counterPrograms
	counterMaps
	counterVariables
}

func (o *counterObjects) Close() error {
	return _CounterClose(
		&o.counterPrograms,
		&o.counterMaps,
	)
}

// counterMaps contains all maps after they have been loaded into the kernel.
//
// It can be passed to loadCounterObjects or ebpf.CollectionSpec.LoadAndAssign.
type counterMaps struct {
	PktCount *ebpf.Map `ebpf:"pkt_count"`
	SockInfo *ebpf.Map `ebpf:"sock_info"`
}

func (m *counterMaps) Close() error {
	return _CounterClose(
		m.PktCount,
		m.SockInfo,
	)
}

// counterVariables contains all global variables after they have been loaded into the kernel.
//
// It can be passed to loadCounterObjects or ebpf.CollectionSpec.LoadAndAssign.
type counterVariables struct {
}

// counterPrograms contains all programs after they have been loaded into the kernel.
//
// It can be passed to loadCounterObjects or ebpf.CollectionSpec.LoadAndAssign.
type counterPrograms struct {
	IcmpSend         *ebpf.Program `ebpf:"__icmp_send"`
	CgroupSkbEgress  *ebpf.Program `ebpf:"cgroup_skb_egress"`
	CgroupSkbIngress *ebpf.Program `ebpf:"cgroup_skb_ingress"`
	CgroupSockCreate *ebpf.Program `ebpf:"cgroup_sock_create"`
	Icmp6Send        *ebpf.Program `ebpf:"icmp6_send"`
	IcmpRcv          *ebpf.Program `ebpf:"icmp_rcv"`
	Icmpv6Rcv        *ebpf.Program `ebpf:"icmpv6_rcv"`
	IpSendSkb        *ebpf.Program `ebpf:"ip_send_skb"`
	SkbConsumeUdp    *ebpf.Program `ebpf:"skb_consume_udp"`
	TcCountPackets   *ebpf.Program `ebpf:"tc_count_packets"`
	TcpCleanupRbuf   *ebpf.Program `ebpf:"tcp_cleanup_rbuf"`
	TcpSendmsg       *ebpf.Program `ebpf:"tcp_sendmsg"`
	XdpCountPackets  *ebpf.Program `ebpf:"xdp_count_packets"`
}

func (p *counterPrograms) Close() error {
	return _CounterClose(
		p.IcmpSend,
		p.CgroupSkbEgress,
		p.CgroupSkbIngress,
		p.CgroupSockCreate,
		p.Icmp6Send,
		p.IcmpRcv,
		p.Icmpv6Rcv,
		p.IpSendSkb,
		p.SkbConsumeUdp,
		p.TcCountPackets,
		p.TcpCleanupRbuf,
		p.TcpSendmsg,
		p.XdpCountPackets,
	)
}

func _CounterClose(closers ...io.Closer) error {
	for _, closer := range closers {
		if err := closer.Close(); err != nil {
			return err
		}
	}
	return nil
}

// Do not access this directly.
//
//go:embed counter_arm64_bpfel.o
var _CounterBytes []byte