nlink 0.13.0

Async netlink library for Linux network configuration
Documentation 
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

//! Devlink device management via Generic Netlink.
//!
//! Demonstrates listing devices, querying firmware info,
//! health reporters, and ports.
//!
//! Run with: cargo run -p nlink --example genl_devlink
//!
//! Note: Requires a NIC with devlink support (mlx5, ice, bnxt, etc.).

use nlink::netlink::{Connection, Devlink};

#[tokio::main]
async fn main() -> nlink::netlink::Result<()> {
    let conn = match Connection::<Devlink>::new_async().await {
        Ok(conn) => conn,
        Err(e) => {
            eprintln!("Failed to connect to devlink: {}", e);
            eprintln!("Make sure devlink-capable drivers are loaded.");
            return Ok(());
        }
    };

    // List devices
    println!("=== Devlink Devices ===\n");
    let devices = conn.get_devices().await?;

    if devices.is_empty() {
        println!("No devlink devices found.");
        println!("Devlink requires supported NIC drivers (mlx5, ice, bnxt, etc.).");
        return Ok(());
    }

    for dev in &devices {
        println!("  {}", dev.path());
    }

    // Get info for each device
    for dev in &devices {
        println!("\n=== {} ===\n", dev.path());

        match conn.get_device_info(&dev.bus, &dev.device).await {
            Ok(info) => {
                println!("  Driver: {}", info.driver);
                if !info.versions_running.is_empty() {
                    println!("  Versions:");
                    for v in &info.versions_running {
                        println!("    {}: {}", v.name, v.value);
                    }
                }
                if info.has_pending_update() {
                    println!("  *** Pending firmware update! ***");
                }
            }
            Err(e) => println!("  Could not get info: {}", e),
        }

        // List ports
        match conn.get_ports().await {
            Ok(ports) => {
                let dev_ports: Vec<_> = ports
                    .iter()
                    .filter(|p| p.bus == dev.bus && p.device == dev.device)
                    .collect();
                if !dev_ports.is_empty() {
                    println!("  Ports:");
                    for port in &dev_ports {
                        println!(
                            "    {} flavour={:?} netdev={:?}",
                            port.path(),
                            port.flavour,
                            port.netdev_name
                        );
                    }
                }
            }
            Err(e) => println!("  Could not list ports: {}", e),
        }

        // Health reporters
        match conn.get_health_reporters(&dev.bus, &dev.device).await {
            Ok(reporters) if !reporters.is_empty() => {
                println!("  Health reporters:");
                for r in &reporters {
                    println!(
                        "    {}: state={:?} errors={}",
                        r.name, r.state, r.error_count
                    );
                }
            }
            Ok(_) => {}
            Err(e) => println!("  Could not list health reporters: {}", e),
        }
    }

    Ok(())
}