网络驱动程序snull

snull_devs[0]=alloc_netdev(sizeof(structsnull_priv),"sn%d",snull_init);
snull_devs[1]=alloc_netdev(sizeof(structsnull_priv),"sn%d",snull_init);
if(snull_devs[0]==NULL||snull_devs[1]==NULL)
gotoout;

ether_setup(dev);/*因为我们将snull设计为以太网设备,所以可以用此函数初始化我们的设备.此函数会以'以太网'方式来初始化一些成员.*/

dev->open=snull_open;
dev->stop=snull_release;
dev->set_config=snull_config;
dev->hard_start_xmit=snull_tx;
dev->do_ioctl=snull_ioctl;
dev->get_stats=snull_stats;
dev->rebuild_header=snull_rebuild_header;
dev->hard_header=snull_header;
dev->tx_timeout=snull_tx_timeout;
dev->watchdog_tiomeo=timeout;

for(i=0;i<2;i++)
{
if((result=register_netdev(snull_devs[i])))/*注册成功时返回0*/
printk("snull register error../n");
}

intsnull_open(structnet_device*dev)
{
/* request_region(), request_irq(), .... (like fops->open) */

/*
* Assign the hardware address of the board: use "/0SNULx", where
* x is 0 or 1. The first byte is '/0' to avoid being a multicast
* address (the first byte of multicast addrs is odd).
*/
memcpy(dev->dev_addr,"/0SNUL0",ETH_ALEN);
if(dev==snull_devs[1])
dev->dev_addr[ETH_ALEN-1]++;/* /0SNUL1 */
netif_start_queue(dev);
return0;
}

intsnull_release(structnet_device*dev)
{
/* release ports, irq and such -- like fops->close */

netif_stop_queue(dev);/* can't transmit any more */
return0;
}

intsnull_tx(structsk_buff*skb,structnet_device*dev)
{
intlen;
char*data,shortpkt[ETH_ZLEN];/*ETH_ZLEN为snull支持传输的最小数据长度*/
structsnull_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;/* save the timestamp */

/* Remember the skb, so we can free it at interrupt time */
priv->skb=skb;

/* actual deliver of data is device-specific, and not shown here */
snull_hw_tx(data,len,dev);

return0;/* Our simple device can not fail */
}

/*
* Transmit a packet (low level interface)
*/
staticvoidsnull_hw_tx(char*buf,intlen,structnet_device*dev)
{
/*
* This function deals with hw details. This interface loops
* back the packet to the other snull interface (if any).
* In other words, this function implements the snull behaviour,
* while all other procedures are rather device-independent
*/
structiphdr*ih;
structnet_device*dest;
structsnull_priv*priv;
u32*saddr,*daddr;
structsnull_packet*tx_buffer;

/* I am paranoid. Ain't I? */
if(len<sizeof(structethhdr)+sizeof(structiphdr)){
printk("snull: Hmm... packet too short (%i octets)/n",
len);
return;
}
/*
* Ethhdr is 14 bytes, but the kernel arranges for iphdr
* to be aligned (i.e., ethhdr is unaligned)
*/
ih=(structiphdr*)(buf+sizeof(structethhdr));/*获得ip头的位置，注意此方法*/
saddr=&ih->saddr;
daddr=&ih->daddr;

((u8*)saddr)[2]^=1;/* change the third octet (class C) */
((u8*)daddr)[2]^=1;/* 进行异或运算，相同为0，不同为1。*/

ih->check=0;/* and rebuild the checksum (ip needs it) */
ih->check=ip_fast_csum((unsignedchar*)ih,ih->ihl);/* 重新计算ip校验和，正常情况下还应该重新计算tcp头校验和，icmp头检验和。。 */

if(dev==snull_devs[0])
PDEBUGG("%08x:%05i --> %08x:%05i/n",
ntohl(ih->saddr),ntohs(((structtcphdr*)(ih+1))->source),
ntohl(ih->daddr),ntohs(((structtcphdr*)(ih+1))->dest));
else
PDEBUGG("%08x:%05i <-- %08x:%05i/n",
ntohl(ih->daddr),ntohs(((structtcphdr*)(ih+1))->dest),
ntohl(ih->saddr),ntohs(((structtcphdr*)(ih+1))->source));

/*
* Ok, now the packet is ready for transmission: first simulate a
* receive interrupt on the twin device, then a
* transmission-done on the transmitting device
*/
/*除了上面修改网络地址的代码外，以下为snull功能实现的核心代码*/

/*在接收端产生一个接收中断*/
dest=snull_devs[dev==snull_devs[0]?1:0];
priv=netdev_priv(dest);
tx_buffer=snull_get_tx_buffer(dev);
tx_buffer->datalen=len;
memcpy(tx_buffer->data,buf,len);
snull_enqueue_buf(dest,tx_buffer);/*将发送的数据放到接收设备的缓冲队列*/
if(priv->rx_int_enabled){
priv->status|=SNULL_RX_INTR;
snull_interrupt(0,dest,NULL);/*产生中断----接收*/
}

/*在发送端产生一个发送完成中断*/
priv=netdev_priv(dev);
priv->tx_packetlen=len;
priv->tx_packetdata=buf;
priv->status|=SNULL_TX_INTR;
if(lockup&&((priv->stats.tx_packets+1)%lockup)==0){
/* Simulate a dropped transmit interrupt */
netif_stop_queue(dev);
PDEBUG("Simulate lockup at %ld, txp %ld/n",jiffies,
(unsignedlong)priv->stats.tx_packets);
}
else
snull_interrupt(0,dev,NULL);/*产生中断----发送*/
}

/*
* Receive a packet: retrieve, encapsulate and pass over to upper levels
*/
voidsnull_rx(structnet_device*dev,structsnull_packet*pkt)
{
structsk_buff*skb;
structsnull_priv*priv=netdev_priv(dev);

/*
* The packet has been retrieved from the transmission
* medium. Build an skb around it, so upper layers can handle it
* 已经从传输介质中获得数据包，为数据包分配sk_buff缓冲区，以便上层进行操作。
*/
skb=dev_alloc_skb(pkt->datalen+2);/*以太网头为14个字节，对齐*/
if(!skb){
if(printk_ratelimit())/*控制printk被调用的速度，当向控制台发送大量信息时，printk_ratelimit返回0*/
printk(KERN_NOTICE"snull rx: low on mem - packet dropped/n");
priv->stats.rx_dropped++;
gotoout;
}
skb_reserve(skb,2);/* align IP on 16B boundary */
memcpy(skb_put(skb,pkt->datalen),pkt->data,pkt->datalen);/*skb_put改变tail指针并更新skb->len的值*/

/* Write metadata, and then pass to the receive level */
skb->dev=dev;
skb->protocol=eth_type_trans(skb,dev);/*主要任务是返回skb的协议号*/
skb->ip_summed=CHECKSUM_UNNECESSARY;/* don't check it */
priv->stats.rx_packets++;
priv->stats.rx_bytes+=pkt->datalen;
netif_rx(skb);
out:
return;
}

staticvoidsnull_regular_interrupt(intirq,void*dev_id,structpt_regs*regs)
{
intstatusword;
structsnull_priv*priv;
structsnull_packet*pkt=NULL;
/*
* As usual, check the "device" pointer to be sure it is
* really interrupting.
* Then assign "struct device *dev"
*/
structnet_device*dev=(structnet_device*)dev_id;/*如果对应的中断号允许共享，则触发中断后可能有多个中断处理程序与其对应，
这时就需要查看中断是否是与自己的接口对应的*/
/* ... and check with hw if it's really ours */

/* paranoid */
if(!dev)
return;

/* Lock the device */
priv=netdev_priv(dev);
spin_lock(&priv->lock);

/* retrieve statusword: real netdevices use I/O instructions */
statusword=priv->status;
priv->status=0;
if(statusword&SNULL_RX_INTR){/*如果是新数据包的到达，触发接收中断*/
/* send it to snull_rx for handling */
pkt=priv->rx_queue;
if(pkt){
priv->rx_queue=pkt->next;
snull_rx(dev,pkt);/*调用接收函数*/
}
}
if(statusword&SNULL_TX_INTR){/*如果是发送数据包完成，触发发送中断*/
/* a transmission is over: free the skb */
priv->stats.tx_packets++;
priv->stats.tx_bytes+=priv->tx_packetlen;
dev_kfree_skb(priv->skb);
}

/* Unlock the device and we are done */
spin_unlock(&priv->lock);
if(pkt)snull_release_buffer(pkt);/* Do this outside the lock! */
return;
}