网络设备驱动代码

#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>


#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/skbuff.h>


#include <linux/ip.h>


#include "vnet.h"


struct net_device *vnet_dev;


static int vnet_open(struct net_device *dev)
{
netif_start_queue(dev);
return 0;
}


static int vnet_stop(struct net_device *dev)
{
netif_stop_queue(dev);
return 0;
}


void vnet_rx(struct net_device *dev)
{
struct sk_buff *skb;
struct vnet_priv *priv = netdev_priv(dev);


skb = dev_alloc_skb(priv->rxlen + 2);
if (IS_ERR(skb)) {
printk(KERN_NOTICE "vnet: low on mem - packet dropped\n");
dev->stats.rx_dropped++;
return;
}
skb_reserve(skb, 2);
memcpy(skb_put(skb, priv->rxlen), priv->rxdata, priv->rxlen);


skb->dev = dev;
skb->protocol = eth_type_trans(skb, dev);
skb->ip_summed = CHECKSUM_UNNECESSARY;
dev->stats.rx_packets++;
dev->stats.rx_bytes += priv->rxlen;
netif_rx(skb);


return;
}


static void vnet_rx_int(char *buf, int len, struct net_device *dev)
{
struct vnet_priv *priv;


priv = netdev_priv(dev);
priv->rxlen = len;
memcpy(priv->rxdata, buf, len);
vnet_rx(dev);


return;
}


static void vnet_hw_tx(char *buf, int len, struct net_device *dev)
{
#if DEBUG
int i;
#endif


struct iphdr *ih;
struct net_device *dest;
struct vnet_priv *priv;
u32 *saddr, *daddr;


if (len < sizeof(struct ethhdr) + sizeof(struct iphdr)) {
printk("vnet: Packet too short (%i octets)\n", len);
return;
}


#if DEBUG
printk("len is %i\n", len);
printk("data: ");
for (i = 0; i < len; i++)
printk(" %02x",buf[i] & 0xff);
printk("\n");
#endif


ih = (struct iphdr *)(buf + sizeof(struct ethhdr));
saddr = &ih->saddr;
daddr = &ih->daddr;
((u8 *)saddr)[3] = ((u8 *)saddr)[3] ^ ((u8 *)daddr)[3];
((u8 *)daddr)[3] = ((u8 *)saddr)[3] ^ ((u8 *)daddr)[3];
((u8 *)saddr)[3] = ((u8 *)saddr)[3] ^ ((u8 *)daddr)[3];


ih->check = 0;
ih->check = ip_fast_csum((unsigned char *)ih,ih->ihl);


#if DEBUG
printk("len is %i\n", len);
printk("data: ");
for (i = 0; i < len; i++)
printk(" %02x",buf[i] & 0xff);
printk("\n\n");
#endif


dest = vnet_dev;
vnet_rx_int(buf, len, dest);


        dev->stats.tx_packets++;
        dev->stats.tx_bytes += len;
priv = netdev_priv(dev);
        dev_kfree_skb(priv->txskb);
}


static netdev_tx_t vnet_tx(struct sk_buff *skb, struct net_device *dev)
{
int len;
char *data, shortpkt[ETH_ZLEN];
struct vnet_priv *priv = netdev_priv(dev);

data = skb->data;
len = skb->len;
if (len < ETH_ZLEN) {
memset(shortpkt, 0, ETH_ZLEN);
memcpy(shortpkt, skb->data, skb->len);
len = ETH_ZLEN;
data = shortpkt;
}
dev->trans_start = jiffies;
priv->txskb = skb;
vnet_hw_tx(data, len, dev);


return 0;
}


static const struct net_device_ops vnet_ops = {
.ndo_open = vnet_open,
.ndo_stop = vnet_stop,
.ndo_start_xmit = vnet_tx,
};




static int __init vnet_init(void)
{
int status;
struct vnet_priv *priv;


vnet_dev = alloc_etherdev(sizeof(struct vnet_priv));
if (IS_ERR(vnet_dev))
return -ENOMEM;


ether_setup(vnet_dev);
vnet_dev->netdev_ops = &vnet_ops;
vnet_dev->flags |= IFF_NOARP;
priv = netdev_priv(vnet_dev);
memset(priv, 0, sizeof(struct vnet_priv));


status = register_netdev(vnet_dev);
if (status) {
free_netdev(vnet_dev);
return status;
}


return 0;
}


static void __exit vnet_exit(void)
{


unregister_netdev(vnet_dev);
free_netdev(vnet_dev);
}


module_init(vnet_init);
module_exit(vnet_exit);


MODULE_LICENSE("GPL");
MODULE_AUTHOR("Kevin Jiang <jiangxg@farsight.com.cn>");
MODULE_DESCRIPTION("Virtual ethernet driver");