1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
|
// Copyright 2022 The gVisor Authors.
//
// 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.
//go:build amd64 || arm64
// +build amd64 arm64
// Package cmd implements the subcommands of xdp_loader.
package cmd
import (
"bytes"
_ "embed"
"fmt"
"log"
"net"
"github.com/cilium/ebpf"
"github.com/cilium/ebpf/link"
"golang.org/x/sys/unix"
)
func runBasicProgram(progData []byte, device string, deviceIndex int) error {
iface, err := getIface(device, deviceIndex)
if err != nil {
return fmt.Errorf("%v", err)
}
// Load into the kernel.
spec, err := ebpf.LoadCollectionSpecFromReader(bytes.NewReader(progData))
if err != nil {
return fmt.Errorf("failed to load spec: %v", err)
}
var objects struct {
Program *ebpf.Program `ebpf:"xdp_prog"`
}
if err := spec.LoadAndAssign(&objects, nil); err != nil {
return fmt.Errorf("failed to load program: %v", err)
}
defer func() {
if err := objects.Program.Close(); err != nil {
fmt.Printf("failed to close program: %v", err)
}
}()
_, cleanup, err := attach(objects.Program, iface)
if err != nil {
return fmt.Errorf("failed to attach: %v", err)
}
defer cleanup()
waitForever()
return nil
}
func getIface(device string, deviceIndex int) (*net.Interface, error) {
switch {
case device != "" && deviceIndex != 0:
return nil, fmt.Errorf("device specified twice")
case device != "":
iface, err := net.InterfaceByName(device)
if err != nil {
return nil, fmt.Errorf("unknown device %q: %v", device, err)
}
return iface, nil
case deviceIndex != 0:
iface, err := net.InterfaceByIndex(deviceIndex)
if err != nil {
return nil, fmt.Errorf("unknown device with index %d: %v", deviceIndex, err)
}
return iface, nil
default:
return nil, fmt.Errorf("no device specified")
}
}
func attach(program *ebpf.Program, iface *net.Interface) (link.Link, func(), error) {
// Attach the program to the XDP hook on the device. Fallback from best
// to worst mode.
modes := []struct {
name string
flag link.XDPAttachFlags
}{
{name: "offload", flag: link.XDPOffloadMode},
{name: "driver", flag: link.XDPDriverMode},
{name: "generic", flag: link.XDPGenericMode},
}
var attached link.Link
var err error
for _, mode := range modes {
attached, err = link.AttachXDP(link.XDPOptions{
Program: program,
Interface: iface.Index,
Flags: mode.flag,
})
if err == nil {
log.Printf("attached with mode %q", mode.name)
break
}
log.Printf("failed to attach with mode %q: %v", mode.name, err)
}
if attached == nil {
return nil, nil, fmt.Errorf("failed to attach program")
}
return attached, func() { attached.Close() }, nil
}
func waitForever() {
log.Printf("Successfully attached! Press CTRL-C to quit and remove the program from the device.")
for {
unix.Pause()
}
}
|
