#include<linux/module.h>
#include<linux/sched.h>
#include<linux/kernel.h>
#include<linux/slab.h>
#include<linux/errno.h>
#include<linux/types.h>
#include<linux/interrupt.h>
#include<linux/in.h>
#include<linux/netdevice.h>
#include<linux/etherdevice.h>
#include<linux/ip.h>
#include<linux/tcp.h>
#include<linux/skbuff.h>
#include<linux/if_ether.h>
#include<linux/in6.h>
#include<asm/uaccess.h>
#include<asm/checksum.h>
#include<linux/platform_device.h>
#define MAC_AUTO
static struct net_device *vir_net_devs;
struct vir_net_priv {
struct net_device_stats stats; //有用的统计信息
int status; //网络设备的状态信息,是发完数据包,还是接收到网络数据包
int rx_packetlen; //接收到的数据包长度
u8 *rx_packetdata; //接收到的数据
int tx_packetlen; //发送的数据包长度
u8 *tx_packetdata; //发送的数据
struct sk_buff *skb; //socket buffer结构体,网络各层之间传送数据都是通过这个结构体来实现的
spinlock_t lock; //自旋锁
};
/*网络设备开启时会执行该函数*/
int vir_net_open(struct net_device *dev) {
#ifndef MAC_AUTO
int i;
for (i=0; i<6; i++) {
dev->dev_addr[i] = 0xaa;
}
#else
random_ether_addr(dev->dev_addr);
#endif
/*打开传输队列进行数据传输*/
netif_start_queue(dev);
printk("vir_net_open\n");
return 0;
}
/*关闭的时候,关闭队列*/
int vir_net_release(struct net_device *dev) {
/*停止发送数据*/
netif_stop_queue(dev);
printk("vir_net_release\n");
return 0;
}
/*接包函数,有数据过来时,中断执行*/
void vir_net_rx(struct net_device *pdev, int len, unsigned char *buf) {
struct sk_buff *skb;
struct vir_net_priv *priv = (struct vir_net_priv *) pdev->ml_priv;
skb = dev_alloc_skb(len+2);//分配一个socket buffer,并且初始化skb->data,skb->tail和skb->head
if(!skb) {
printk("gecnet rx: low on mem - packet dropped\n");
priv->stats.rx_dropped++;
return;
}
skb_reserve(skb, 2); /* align IP on 16B boundary */
memcpy(skb_put(skb, len), buf, len);//skb_put是把数据写入到socket buffer
/* Write metadata, and then pass to the receive level */
skb->dev = pdev;
skb->protocol = eth_type_trans(skb, pdev);//返回的是协议号
skb->ip_summed = CHECKSUM_UNNECESSARY; //此处不校验
priv->stats.rx_packets++;//接收到包的个数+1
priv->stats.rx_bytes += len;//接收到包的长度
printk("vir_net_rx\n");
netif_rx(skb);//通知内核已经接收到包,并且封装成socket buffer传到上层
return;
}
/*模拟硬件发送数据*/
void vir_net_hw_tx(char *buf, int len, struct net_device *dev) {
struct net_device *dest;//目标设备结构体,net_device存储一个网络接口的重要信息,是网络驱动程序的核心
struct vir_net_priv *priv;
if (len < sizeof(struct ethhdr) + sizeof(struct iphdr)) {
printk("vir_net: packet too short (%i octets)\n", len);
return;
}
dest = vir_net_devs;
priv = (struct vir_net_priv *)dest->ml_priv;
priv->rx_packetlen = len;
priv->rx_packetdata = buf;
printk("vir_net_hw_tx\n");
dev_kfree_skb(priv->skb);
}
/*发包函数, 上层有数据发送时,该函数会被调用*/
int vir_net_tx(struct sk_buff *skb, struct net_device *pdev) {
int len;
char *data;
struct vir_net_priv *priv = (struct vir_net_priv *)pdev->ml_priv;
if(skb == NULL) {
printk("net_device = %p, skb = %p\n", pdev, skb);
return 0;
}
/*ETH_ZLEN是所发的最小数据包的长度*/
len = skb->len < ETH_ZLEN ? ETH_ZLEN : skb->len;
/*将要发送的数据包中数据部分*/
data = skb->data;
priv->skb = skb;
/*调用硬件接口进行数据的发送*/
vir_net_hw_tx(data, len, pdev);
printk("vir_net_tx, pdev = %p\n", pdev);
return 0;
}
/*设备初始化函数*/
int vir_net_device_init(struct net_device *pdev) {
/*填充一些以太网中的设备结构体的项*/
ether_setup(pdev);
/*keep the default flags, just add NOARP */
pdev->flags |= IFF_NOARP;
/*为priv分配内存*/
pdev->ml_priv = kmalloc(sizeof(struct vir_net_priv), GFP_KERNEL);
if (pdev->ml_priv == NULL){
return -ENOMEM;
}
memset(pdev->ml_priv, 0, sizeof(struct vir_net_priv));
spin_lock_init(&((struct vir_net_priv *)pdev->ml_priv)->lock);
printk("vir_net_device_init, pdev = %p\n", pdev);
return 0;
}
/*结构体填充*/
static const struct net_device_ops vir_net_netdev_ops = {
.ndo_open = vir_net_open, //打开网卡 对应ifconfig xx up
.ndo_stop = vir_net_release, //关闭网卡 对应ifconfig xx down
.ndo_start_xmit = vir_net_tx, //开启数据包传输(对应上层要发送数据时)
.ndo_init = vir_net_device_init, //初始化网卡硬件
};
/**/
static void vir_plat_net_release(struct device *pdev) {
printk("vir_plat_net_release, pdev = %p\n", pdev);
}
/*匹配*/
static int vir_net_probe(struct platform_device *pdev) {
int result = 0;
/*vir_net_devs结构体相当于一个虚拟的网络设备*/
vir_net_devs = alloc_etherdev(sizeof(struct net_device));
vir_net_devs->netdev_ops = &vir_net_netdev_ops;
strcpy(vir_net_devs->name, "net_0");
/*上面填充了3项,如果是真实的网卡会填充更多,然后
使用register_netdev进行注册,net/core,注册好了以后
内核当中就会有这个设备了,当这个网络设备up以后就会进入open函数*/
if ((result = register_netdev(vir_net_devs))) {
printk("vir_net: error %i registering device \"%s\"\n", result, vir_net_devs->name);
}
printk("vir_net_probe, pdev = %p\n", pdev);
return 0;
}
/*设备移除函数*/
static int vir_net_remove(struct platform_device *pdev) {
kfree(vir_net_devs->ml_priv);
unregister_netdev(vir_net_devs);
return 0;
}
/*结构体填充*/
static struct platform_device vir_net= {
.name = "vir_net",
.id = -1,
.dev = {
.release = vir_plat_net_release,
},
};
/*结构体填充*/
static struct platform_driver vir_net_driver = {
.probe = vir_net_probe,
.remove = vir_net_remove,
.driver = {
.name = "vir_net", /*这里的name和上面那个结构体的name如果匹配就会执行probe函数*/
.owner = THIS_MODULE,
},
};
/*模块入口函数*/
static int __init vir_net_init(void) {
printk("vir_net_init\n");
platform_device_register(&vir_net);
return platform_driver_register(&vir_net_driver);
}
/*模块退出函数*/
static void __exit vir_net_exit(void) {
printk("vir_net_exit\n");
platform_driver_unregister(&vir_net_driver);
platform_device_unregister(&vir_net);
}
module_init(vir_net_init);
module_exit(vir_net_exit);
MODULE_LICENSE("GPL");
makefile
CONFIG_MODULE_SIG = n
obj-m+=virnet.o
all:
make -C /lib/modules/$(shell uname -r)/build/ M=$(PWD) modules
clean:
make -C /lib/modules/$(shell uname -r)/build/ M=$(PWD) clean
在使用sudo ifconfig xxx up/down和sudo insmod xxx,sudo rmmod xxx命令时,输出的结果可以通过开启另外一个终端观察,tail -f /var/log/kern.log,查看内核日志的输出,从而观察到各个命令的执行时,他们会去执行哪一个函数。