网卡驱动.txt

带有非常详细注释的网卡驱动,对于学习网卡驱动的同志来说是不可多得的好资料

        }
        /*
         * skb_reserver用来增加skb的date和tail，因为以太网头部为14字节长，再补上两个字节就刚好16字节边界
         * 对齐，所以大多数以太网设备都会在数据包之前保留2个字节。
         */
        skb_reserve(skb, 2); /* align IP on 16B boundary */  
        memcpy(skb_put(skb, pkt->datalen), pkt->data, pkt->datalen);

        skb->dev = dev;                        /*skb与接收设备就关联起来了，它在网络栈中会被广泛使用，没道理不知道数据是谁接收来的吧*/
        skb->protocol = eth_type_trans(skb, dev);        /*获取上层协议类型，这样，上层处理函数才知道如何进一步处理*/
        skb->ip_summed = CHECKSUM_UNNECESSARY;                 /* 设置较验标志：不进行任何校验，作者的驱动的收发都在内存中进行，是没有必要进行校验*/
        
        /*累加计数器*/
        priv->stats.rx_packets++;
        priv->stats.rx_bytes += pkt->datalen;
        
        /*
         * 把数据包交给上层。netif_rx会逐步调用netif_rx_schedule -->__netif_rx_schedule，
         * __netif_rx_schedule函数会调用__raise_softirq_irqoff(NET_RX_SOFTIRQ);触发网络接收数据包的软中断函数net_rx_action。
         * 软中断是Linux内核完成中断推后处理工作的一种机制，请参考《Linux内核设计与实现》第二版。
         * 唯一需要提及的是，这个软中断函数net_rx_action是在网络系统初始化的时候(linux/net/core/dev.c)：注册的
         * open_softirq(NET_RX_SOFTIRQ, net_rx_action, NULL);
         */
        netif_rx(skb);
  out:
        return;
}
    

/*
* NAPI 的poll轮询函数.
*/
static int snull_poll(struct net_device *dev, int *budget)
{
        /*
         * dev->quota是当前CPU能够从所有接口中接收数据包的最大数目，budget是在
         * 初始化阶段分配给接口的weight值，轮询函数必须接受二者之间的最小值。表示
         * 轮询函数本次要处理的数据包个数。
         */
        int npackets = 0, quota = min(dev->quota, *budget);
        struct sk_buff *skb;
        struct snull_priv *priv = netdev_priv(dev);
        struct snull_packet *pkt;
    
            /*这个循环次数由要处理的数据包个数，并且，以处理完接收队列为上限*/
        while (npackets < quota && priv->rx_queue) {
                /*从队列中取出数据包*/
                pkt = snull_dequeue_buf(dev);
                
                /*接下来的处理，和传统中断事实上是一样的*/
                skb = dev_alloc_skb(pkt->datalen + 2);
                if (! skb) {
                        if (printk_ratelimit())
                                printk(KERN_NOTICE "snull: packet dropped\n");
                        priv->stats.rx_dropped++;
                        snull_release_buffer(pkt);
                        continue;
                }
                skb_reserve(skb, 2); /* align IP on 16B boundary */  
                memcpy(skb_put(skb, pkt->datalen), pkt->data, pkt->datalen);
                skb->dev = dev;
                skb->protocol = eth_type_trans(skb, dev);
                skb->ip_summed = CHECKSUM_UNNECESSARY; /* don't check it */
                
                /*需要调用netif_receive_skb而不是net_rx将包交给上层协议栈*/
                netif_receive_skb(skb);
                
                /*累加计数器 */
                npackets++;
                priv->stats.rx_packets++;
                priv->stats.rx_bytes += pkt->datalen;
                snull_release_buffer(pkt);
        }
        /* If we processed all packets, we're done; tell the kernel and reenable ints */
        *budget -= npackets;
        dev->quota -= npackets;
        
        //
        if (! priv->rx_queue) {
                netif_rx_complete(dev);
                snull_rx_ints(dev, 1);
                return 0;
        }
        /* We couldn't process everything. */
        return 1;
}
            
        
/*
* 设备的中断函数，当需要发/收数据，出现错误，连接状态变化等，它会被触发
* 对于典型的网络设备，一般会在open函数中注册中断函数，这样，当网络设备产生中断时，如接收到数据包时，
* 中断函数将会被调用。不过在这个例子中，因为没有真正的物理设备，所以，不存在注册中断，也就不存在触
* 发，对于接收和发送，它都是在自己设计的函数的特定位置被调用。
* 这个中断函数设计得很简单，就是取得设备的状态，判断是“接收”还是“发送”的中断，以调用相应的处理函数。
* 而对于，“是哪个设备产生的中断”这个问题，则由调用它的函数通过第二个参数的赋值来决定。
*/
static void snull_regular_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
        int statusword;
        struct snull_priv *priv;
        struct snull_packet *pkt = NULL;
        /*
         * 通常，需要检查 "device" 指针以确保这个中断是发送给自己的。
         * 然后为 "struct device *dev" 赋
         */
        struct net_device *dev = (struct net_device *)dev_id;

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

        /* 锁住设备 */
        priv = netdev_priv(dev);
        spin_lock(&priv->lock);

        /* 取得设备状态指字，对于真实设备，使用I/O指令，比如：int txsr = inb(TX_STATUS); */
        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);
        }

        /* 释放锁 */
        spin_unlock(&priv->lock);
        
        /*释放缓冲区*/
        if (pkt) snull_release_buffer(pkt); /* Do this outside the lock! */
        return;
}

/*
* A NAPI interrupt handler.
* 在设备初始化的时候，poll指向指向了snull_poll函数，所以，NAPI中断处理函数很简单，
* 当“接收中断”到达的时候，它就屏蔽此中断，然后netif_rx_schedule函数接收，接收函数
* 会在未来某一时刻调用注册的snull_poll函数实现轮询，当然，对于“传输中断”，处理方法
* 同传统中断处理并无二致。
*/
static void snull_napi_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
        int statusword;
        struct snull_priv *priv;

        /*
         * As usual, check the "device" pointer for shared handlers.
         * Then assign "struct device *dev"
         */
        struct net_device *dev = (struct net_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;
        
        /*
         * 唯一的区别就在这里，它先屏蔽掉接收中断，然后调用netif_rx_schedule，而不是netif_rx
         * 重点还是在于poll函数的设计。
         */
        if (statusword & SNULL_RX_INTR) {
                snull_rx_ints(dev, 0);  /* Disable further interrupts */
                netif_rx_schedule(dev);
        }
        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);
        return;
}



/*
* Transmit a packet (low level interface)
*/
static void snull_hw_tx(char *buf, int len, struct net_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
         */
        struct iphdr *ih;
        struct net_device *dest;
        struct snull_priv *priv;
        u32 *saddr, *daddr;
        struct snull_packet *tx_buffer;
    
        /* I am paranoid. Ain't I? */
        if (len < sizeof(struct ethhdr) + sizeof(struct iphdr)) {
                printk("snull: Hmm... packet too short (%i octets)\n",
                                len);
                return;
        }

        if (0) { /* enable this conditional to look at the data */
                int i;
                PDEBUG("len is %i\n" KERN_DEBUG "data:",len);
                for (i=14 ; i<len; i++)
                        printk(" %02x",buf[i]&0xff);
                printk("\n");
        }
        /*
         * 取得来源IP和目的IP地址
         */
        ih = (struct iphdr *)(buf+sizeof(struct ethhdr));
        saddr = &ih->saddr;
        daddr = &ih->daddr;
        
        /*
         * 这里做了三个调换，以实现欺骗：来源地址第三octet 0<->1，目的地址第三octet 0<->1，设备snX编辑0<->1，这样做的理由是：
         * sn0(发):192.168.0.88 --> 192.168.0.99        做了调换后，就变成：
         * sn1(收):192.168.1.88 --> 192.168.1.99        因为sn1的地址就是192.168.1.99，所以，它收到这个包后，会回应：
         * sn1(发):192.168.1.99 --> 192.168.1.88        ，同样地，做了这样的调换后，就变成：
         * sn0(收):192.168.0.99 --> 192.168.0.88        这样，sn0就会收到这个包，实现了ping的请求与应答，^o^
         */
        ((u8 *)saddr)[2] ^= 1; /* change the third octet (class C) */
        ((u8 *)daddr)[2] ^= 1;

        /*重新计算较验和*/
        ih->check = 0;         /* and rebuild the checksum (ip needs it) */
        ih->check = ip_fast_csum((unsigned char *)ih,ih->ihl);

        /*输出调试信息*/
        if (dev == snull_devs[0])
                PDEBUGG("%08x:%05i --> %08x:%05i\n",
                                ntohl(ih->saddr),ntohs(((struct tcphdr *)(ih+1))->source),
                                ntohl(ih->daddr),ntohs(((struct tcphdr *)(ih+1))->dest));
        else
                PDEBUGG("%08x:%05i <-- %08x:%05i\n",
                                ntohl(ih->daddr),ntohs(((struct tcphdr *)(ih+1))->dest),
                                ntohl(ih->saddr),ntohs(((struct tcphdr *)(ih+1))->source));

        /*调换设备编号，即dest指向接收设备，原因如前所述*/
        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;
        
        /*