Repository navigation
Expand file tree
/
Copy pathvnetloop.c
More file actions
136 lines (110 loc) · 3.2 KB
/
Copy pathvnetloop.c
File metadata and controls
136 lines (110 loc) · 3.2 KB
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
// SPDX-License-Identifier: GPL-2.0
/*
* vnetloop.c - Minimal virtual Ethernet device that loops transmitted packets
* back into the receive path.
*/
#include <linux/etherdevice.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/netdevice.h>
#include <linux/skbuff.h>
#include <linux/u64_stats_sync.h>
struct vnetloop_priv {
u64 tx_packets;
u64 tx_bytes;
u64 rx_packets;
u64 rx_bytes;
struct u64_stats_sync syncp;
};
static netdev_tx_t vnetloop_xmit(struct sk_buff *skb, struct net_device *dev)
{
struct vnetloop_priv *priv = netdev_priv(dev);
struct sk_buff *rx_skb;
unsigned int len = skb->len;
rx_skb = skb_copy(skb, GFP_ATOMIC);
if (rx_skb) {
rx_skb->dev = dev;
skb_reset_mac_header(rx_skb);
rx_skb->ip_summed = CHECKSUM_UNNECESSARY;
rx_skb->protocol = eth_type_trans(rx_skb, dev);
u64_stats_update_begin(&priv->syncp);
priv->tx_packets++;
priv->tx_bytes += len;
priv->rx_packets++;
priv->rx_bytes += rx_skb->len;
u64_stats_update_end(&priv->syncp);
netif_rx(rx_skb);
} else {
u64_stats_update_begin(&priv->syncp);
priv->tx_packets++;
priv->tx_bytes += len;
u64_stats_update_end(&priv->syncp);
}
dev_kfree_skb(skb);
return NETDEV_TX_OK;
}
static int vnetloop_open(struct net_device *dev)
{
netif_carrier_on(dev);
netif_start_queue(dev);
return 0;
}
static int vnetloop_stop(struct net_device *dev)
{
netif_stop_queue(dev);
netif_carrier_off(dev);
return 0;
}
static void vnetloop_get_stats64(struct net_device *dev,
struct rtnl_link_stats64 *stats)
{
struct vnetloop_priv *priv = netdev_priv(dev);
unsigned int start;
do {
start = u64_stats_fetch_begin(&priv->syncp);
stats->tx_packets = priv->tx_packets;
stats->tx_bytes = priv->tx_bytes;
stats->rx_packets = priv->rx_packets;
stats->rx_bytes = priv->rx_bytes;
} while (u64_stats_fetch_retry(&priv->syncp, start));
}
static const struct net_device_ops vnetloop_netdev_ops = {
.ndo_open = vnetloop_open,
.ndo_stop = vnetloop_stop,
.ndo_start_xmit = vnetloop_xmit,
.ndo_get_stats64 = vnetloop_get_stats64,
};
static void vnetloop_setup(struct net_device *dev)
{
dev->netdev_ops = &vnetloop_netdev_ops;
dev->flags |= IFF_NOARP;
dev->features |= NETIF_F_HW_CSUM;
eth_hw_addr_random(dev);
}
static struct net_device *vnetloop_dev;
static int __init vnetloop_init(void)
{
int ret;
vnetloop_dev = alloc_etherdev(sizeof(struct vnetloop_priv));
if (!vnetloop_dev)
return -ENOMEM;
strscpy(vnetloop_dev->name, "vnetloop%d", IFNAMSIZ);
vnetloop_setup(vnetloop_dev);
ret = register_netdev(vnetloop_dev);
if (ret) {
free_netdev(vnetloop_dev);
return ret;
}
pr_info("vnetloop: registered %s\n", vnetloop_dev->name);
return 0;
}
static void __exit vnetloop_exit(void)
{
unregister_netdev(vnetloop_dev);
free_netdev(vnetloop_dev);
}
module_init(vnetloop_init);
module_exit(vnetloop_exit);
MODULE_DESCRIPTION("LKMPG virtual net_device example");
MODULE_LICENSE("GPL");