bpfman 0.6.0

An eBPF Program Manager
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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

// SPDX-License-Identifier: Apache-2.0
// Copyright Authors of bpfman

mod tc;
mod xdp;

use log::debug;
use sled::Db;
pub use tc::TcDispatcher;
pub use xdp::XdpDispatcher;

use crate::{
    config::{InterfaceConfig, XdpMode},
    errors::BpfmanError,
    types::{Direction, Link},
    utils::bytes_to_string,
};

pub(crate) const TC_DISPATCHER_PREFIX: &str = "tc_dispatcher";
pub(crate) const XDP_DISPATCHER_PREFIX: &str = "xdp_dispatcher";

#[derive(Debug)]
pub(crate) enum Dispatcher {
    Xdp(XdpDispatcher),
    Tc(TcDispatcher),
}

impl Dispatcher {
    pub fn new(
        root_db: &Db,
        if_config: Option<&InterfaceConfig>,
        links: &mut [Link],
        revision: u32,
        old_dispatcher: Option<Dispatcher>,
    ) -> Result<Dispatcher, BpfmanError> {
        debug!("Dispatcher::new()");
        let l = links
            .first()
            .ok_or_else(|| BpfmanError::Error("No programs to load".to_string()))?;
        let if_index = l
            .ifindex()?
            .ok_or_else(|| BpfmanError::Error("missing ifindex".to_string()))?;
        let if_name = l.if_name()?;
        let direction = l.direction()?;
        let xdp_mode = if let Some(c) = if_config {
            c.xdp_mode()
        } else {
            &XdpMode::Drv
        };
        let d = match l {
            Link::Xdp(xdp_link) => {
                let mut x = XdpDispatcher::new(
                    root_db,
                    xdp_mode,
                    if_index,
                    if_name.to_string(),
                    xdp_link.get_nsid()?,
                    revision,
                )?;

                if let Err(e) = x.load(root_db, links, old_dispatcher, xdp_link.get_netns()?) {
                    debug!("Failed to load xdp dispatcher: {}", e);
                    if let Err(delete_err) = x.delete(root_db, false) {
                        debug!("Failed to delete xdp dispatcher: {}", delete_err);
                    }
                    return Err(e);
                }

                Dispatcher::Xdp(x)
            }
            Link::Tc(tc_link) => {
                let mut t = TcDispatcher::new(
                    root_db,
                    direction.expect("missing direction"),
                    if_index,
                    if_name.to_string(),
                    tc_link.get_nsid()?,
                    tc_link.get_netns()?,
                    revision,
                )?;

                if let Err(e) = t.load(root_db, links, old_dispatcher, tc_link.get_netns()?) {
                    debug!("Failed to load tc dispatcher: {}", e);
                    if let Err(delete_err) = t.delete(root_db, false) {
                        debug!("Failed to delete tc dispatcher: {}", delete_err);
                    }
                    return Err(e);
                }

                Dispatcher::Tc(t)
            }
            _ => return Err(BpfmanError::DispatcherNotRequired),
        };
        Ok(d)
    }

    pub(crate) fn new_from_db(db_tree: sled::Tree) -> Dispatcher {
        if bytes_to_string(&db_tree.name()).contains("xdp") {
            Dispatcher::Xdp(XdpDispatcher::new_from_db(db_tree))
        } else {
            Dispatcher::Tc(TcDispatcher::new_from_db(db_tree))
        }
    }

    pub(crate) fn delete(&mut self, root_db: &Db, full: bool) -> Result<(), BpfmanError> {
        debug!("Dispatcher::delete()");
        match self {
            Dispatcher::Xdp(d) => d.delete(root_db, full),
            Dispatcher::Tc(d) => d.delete(root_db, full),
        }
    }

    pub(crate) fn next_revision(&self) -> u32 {
        let current = match self {
            Dispatcher::Xdp(d) => d
                .get_revision()
                .expect("failed to get xdp_dispatcher revision"),
            Dispatcher::Tc(d) => d
                .get_revision()
                .expect("failed to get tc_dispatcher revision"),
        };
        current.wrapping_add(1)
    }

    pub(crate) fn num_extensions(&self) -> usize {
        match self {
            Dispatcher::Xdp(d) => d
                .get_num_extensions()
                .expect("failed to get xdp_dispatcher num_extensions"),
            Dispatcher::Tc(d) => d
                .get_num_extensions()
                .expect("failed to get tc_dispatcher num_extensions"),
        }
    }
}

#[derive(Debug, Clone, Hash, Eq, PartialEq)]
pub(crate) enum DispatcherId {
    Xdp(DispatcherInfo),
    Tc(DispatcherInfo),
}

#[derive(Debug, Clone, Hash, Eq, PartialEq)]
pub(crate) struct DispatcherInfo(pub u64, pub u32, pub Option<Direction>);