Obtener la lista de dispositivos de red en el interior del núcleo de Linux

Question

que he estado buscando a través net/core/dev.c y otros archivos para tratar de encontrar la manera de obtener la lista de dispositivos de red que están configuradas actualmente y que está demostrando ser un poco difícil de encontrar

El objetivo final es poder obtener estadísticas de dispositivos de red usando dev_get_stats en dev.c, pero necesito conocer las interfaces actuales para poder acceder a la estructura net_device y pasar. Tengo que hacer esto dentro el núcleo mientras escribo un módulo que agrega una nueva entrada/proc/que se relaciona con algunas estadísticas de los dispositivos de red actuales, por lo que puedo deducir de esto dentro del kernel.

Si alguien me podría apuntar a cómo conseguir las interfaces que sería muy apreciada.

Answer 1

Esto debería hacer el truco:

#include <linux/netdevice.h> 

struct net_device *dev; 

read_lock(&dev_base_lock); 

dev = first_net_device(&init_net); 
while (dev) { 
    printk(KERN_INFO "found [%s]\n", dev->name); 
    dev = next_net_device(dev); 
} 

read_unlock(&dev_base_lock); 

Answer 2

dado un struct net *net identificar el espacio de nombres de red que le interesa, usted debe agarrar el dev_base_lock y utilizar for_each_netdev():

read_lock(&dev_base_lock); 
for_each_netdev(net, dev) { 
    /* Inspect dev */ 
} 
read_unlock(&dev_base_lock); 

(En reciente núcleos, puede usar RCU en su lugar, pero eso es probablemente una complicación en este caso).

---

Para obtener el espacio de nombres net de usar, usted debe estar registrando su archivo proc con register_pernet_subsys():

static const struct file_operations foostats_seq_fops = { 
    .owner = THIS_MODULE, 
    .open = foostats_seq_open, 
    .read = seq_read, 
    .llseek = seq_lseek, 
    .release = foostats_seq_release, 
}; 

static int foo_proc_init_net(struct net *net) 
{ 
    if (!proc_net_fops_create(net, "foostats", S_IRUGO, 
      &foostats_seq_fops)) 
     return -ENOMEM; 
    return 0; 
} 

static void foo_proc_exit_net(struct net *net) 
{ 
    proc_net_remove(net, "foostats"); 
} 


static struct pernet_operations foo_proc_ops = { 
    .init = foo_proc_init_net, 
    .exit = foo_proc_exit_net, 
}; 

register_pernet_subsys(&foo_proc_ops) 

En su función foostats_seq_open(), se toma una referencia en el net espacio de nombres, y ponerlo en la función de liberación:

static int foostats_seq_open(struct inode *inode, struct file *file) 
{ 
    int err; 
    struct net *net; 

    err = -ENXIO; 
    net = get_proc_net(inode); 
    if (net == NULL) 
     goto err_net; 

    err = single_open(file, foostats_seq_show, net); 
    if (err < 0) 
     goto err_open; 

    return 0; 

err_open: 
    put_net(net); 
err_net: 
    return err; 
} 

static int foostats_seq_release(struct inode *inode, struct file *file) 
{ 
    struct net *net = ((struct seq_file *)file->private_data)->private; 

    put_net(net); 
    return single_release(inode, file); 
} 

La función foostats_seq_show() puede n obtener el net, caminar por los dispositivos, se reúnen las estadísticas y producir la salida:

static int sockstat6_seq_show(struct seq_file *seq, void *v) 
{ 
    struct net *net = seq->private; 
    struct net_device *dev; 

    int foostat, barstat; 

    read_lock(&dev_base_lock); 
    for_each_netdev(net, dev) { 
     /* Inspect dev */ 
    } 
    read_unlock(&dev_base_lock); 

    seq_printf(seq, "Foo: %d\n", foostat); 
    seq_printf(seq, "Bar: %d\n", barstat); 

    return 0; 
}