网卡驱动.txt

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

         * 如果insmod驱动的时候，指定了模拟硬件锁的lockup=n，则在会传输n个数据包后，模拟一次硬件锁住的情况，
         * 这是通过调用netif_stop_queue函数来停止传输队列，标记“设备不能再传输数据包”实现的，它将在传输的超
         * 时函数中，调用netif_wake_queue函数来重新启动传输队例，同时超时函数中会再次调用“接收中断”，这样
         * stats.tx_packets累加，又可以重新传输新的数据包了(参接收中断和超时处理函数的实现)。
         */
        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,
                                (unsigned long) priv->stats.tx_packets);
        }
        else
        /*发送完成后，触发中断，中断函数发现发送完成，就累加计数器，释放skb缓存*/
                snull_interrupt(0, dev, NULL);
                
        /*
         * 看到这里，我们可以看到，这个发送函数其实并没有把数据包通过I/O指令发送给硬件，而仅仅是做了一个地址/设备的调换，
         * 并把数据包加入到接收设备的队例当中。
         */                
}

/*
* 数据包传输函数，Linux网络堆栈，在发送数据包时，会调用驱动程序的hard_start_transmit函数，
* 在设备初始化的时候，这个函数指针指向了snull_tx。
*/
int snull_tx(struct sk_buff *skb, struct net_device *dev)
{
        int len;
        char *data, shortpkt[ETH_ZLEN];
        struct snull_priv *priv = netdev_priv(dev);
        
        data = skb->data;
        len = skb->len;
        if (len < ETH_ZLEN) {                        /*处理短帧的情况，如果小于以太帧最小长度，不足位全部补0*/
                memset(shortpkt, 0, ETH_ZLEN);
                memcpy(shortpkt, skb->data, skb->len);
                len = ETH_ZLEN;
                data = shortpkt;
        }
        dev->trans_start = jiffies; /* 保存时间戳 */

        /* 
         * 因为“发送”完成后，需要释放skb，所以，先要保存它 ,释放都是在网卡发送完成，产生中断，而中断函数收
         * 到网卡的发送完成的中断信号后释放
         */
        priv->skb = skb;

        /* 
         * 让硬件把数据包发送出去，对于物理设备，就是一个读网卡寄存器的过程，不过，这里，只是一些
         * 为了实现演示功能的虚假的欺骗函数，比如操作源/目的IP，然后调用接收函数（所以，接收时不用调用中断）
         */
        snull_hw_tx(data, len, dev);

        return 0; /* Our simple device can not fail */
}

/*
* 传输超时处理函数
* 比如在传输数据时，由于缓冲已满，需要关闭传输队列，但是驱动程序是不能丢弃数据包，它将在“超时”的时候触发
* 超时处理函数，这个函数将发送一个“传输中断”，以填补丢失的中断，并重新启动传输队例子
*/
void snull_tx_timeout (struct net_device *dev)
{
        struct snull_priv *priv = netdev_priv(dev);

        PDEBUG("Transmit timeout at %ld, latency %ld\n", jiffies,
                        jiffies - dev->trans_start);
        /* Simulate a transmission interrupt to get things moving */
        priv->status = SNULL_TX_INTR;
        snull_interrupt(0, dev, NULL);
        priv->stats.tx_errors++;
        netif_wake_queue(dev);
        return;
}



/*
* Ioctl 命令
*/
int snull_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
{
        PDEBUG("ioctl\n");
        return 0;
}

/*
* 获取设备的状态
*/
struct net_device_stats *snull_stats(struct net_device *dev)
{
        struct snull_priv *priv = netdev_priv(dev);
        return &priv->stats;
}

/*
* 有些网络有硬件地址(比如Ethernet)，并且在发送硬件帧时需要知道目的硬件 地址会进行ARP请求/应答，以完成MAC地址解析，
* 需要做arp请求的设备在发送之前会调用驱动程序的rebuild_header函数。需要做arp的的设备在发送之前会调用驱动程序的
* rebuild_header方 法。调用的主要参数包括指向硬件帧头的指针，协议层地址。如果驱动程序能够解 析硬件地址，就返回1，
* 如果不能，返回0。
* 当然，作者实现的演示设备中，不支持这个过程。 
*/
int snull_rebuild_header(struct sk_buff *skb)
{
        struct ethhdr *eth = (struct ethhdr *) skb->data;
        struct net_device *dev = skb->dev;
    
        memcpy(eth->h_source, dev->dev_addr, dev->addr_len);
        memcpy(eth->h_dest, dev->dev_addr, dev->addr_len);
        eth->h_dest[ETH_ALEN-1]   ^= 0x01;   /* dest is us xor 1 */
        return 0;
}

/*
* 为上层协议创建一个二层的以太网首部。
* 事实上，如果一开始调用alloc_etherdev分配以太设备，它会调用ether_setup进行初始化，初始化函数会设置：
*        dev->hard_header        = eth_header;
*        dev->rebuild_header         = eth_rebuild_header;
* 驱动开发人员并不需要自己来实现这个函数，作者这样做，只是为了展示细节。
*/

int snull_header(struct sk_buff *skb, struct net_device *dev,
                unsigned short type, void *daddr, void *saddr,
                unsigned int len)
{
        /*获取以太头指针*/
        struct ethhdr *eth = (struct ethhdr *)skb_push(skb,ETH_HLEN);

        eth->h_proto = htons(type);                /*填写协议*/
        
        /*填写来源/目的MAC地址，如果地址为空，则用设备自己的地址代替之*/
        memcpy(eth->h_source, saddr ? saddr : dev->dev_addr, dev->addr_len);
        memcpy(eth->h_dest,   daddr ? daddr : dev->dev_addr, dev->addr_len);
        
        /*
         * 将第一个octet设为0，主要是为了可以在不支持组播链路，如ppp链路上运行
         * PS：作者这样做，仅仅是演示在PC机上的实现，事实上，直接使用ETH_ALEN-1是
         * 不适合“大头”机器的。
         */
        eth->h_dest[ETH_ALEN-1]   ^= 0x01;   /* dest is us xor 1 */
        return (dev->hard_header_len);
}

/*
* 改变设备MTU值.
*/
int snull_change_mtu(struct net_device *dev, int new_mtu)
{
        unsigned long flags;
        struct snull_priv *priv = netdev_priv(dev);
        spinlock_t *lock = &priv->lock;
    
        /* check ranges */
        if ((new_mtu < 68) || (new_mtu > 1500))
                return -EINVAL;
        /*
         * Do anything you need, and the accept the value
         */
        spin_lock_irqsave(lock, flags);
        dev->mtu = new_mtu;
        spin_unlock_irqrestore(lock, flags);
        return 0; /* success */
}

/*
* 设备初始化函数，它必须在 register_netdev 函数被调用之前调用
*/
void snull_init(struct net_device *dev)
{
        /*设备的“私有”结构，保存一些设备一些“私有数据”*/
        struct snull_priv *priv;
#if 0
            /*
         * Make the usual checks: check_region(), probe irq, ...  -ENODEV
         * should be returned if no device found.  No resource should be
         * grabbed: this is done on open(). 
         */
#endif

            /* 
         * 初始化以太网设备的一些共用的成员
         */
        ether_setup(dev); /* assign some of the fields */

        /*设置设备的许多成员函数指针*/
        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->change_mtu      = snull_change_mtu;  
        dev->rebuild_header  = snull_rebuild_header;
        dev->hard_header     = snull_header;
        dev->tx_timeout      = snull_tx_timeout;
        dev->watchdog_timeo = timeout;
        
        /*如果使用NAPI，设置pool函数*/
        if (use_napi) {
                dev->poll        = snull_poll;
                dev->weight      = 2;                /*weight是接口在资源紧张时，在接口上能承受多大流量的权重*/
        }
        /* keep the default flags, just add NOARP */
        dev->flags           |= IFF_NOARP;
        dev->features        |= NETIF_F_NO_CSUM;
        dev->hard_header_cache = NULL;      /* Disable caching */

        /*
         * 取得私有数据区，并初始化它.
         */
        priv = netdev_priv(dev);
        memset(priv, 0, sizeof(struct snull_priv));
        spin_lock_init(&priv->lock);
        snull_rx_ints(dev, 1);                /* 打开接收中断标志 */
        snull_setup_pool(dev);                /*设置使用NAPI时的接收缓冲池*/
}

/*
* The devices
*/

struct net_device *snull_devs[2];



/*
* Finally, the module stuff
*/

void snull_cleanup(void)
{
        int i;
    
        for (i = 0; i < 2;  i++) {
                if (snull_devs[i]) {
                        unregister_netdev(snull_devs[i]);
                        snull_teardown_pool(snull_devs[i]);
                        free_netdev(snull_devs[i]);
                }
        }
        return;
}

/*模块初始化，初始化的只有一个工作：分配一个设备结构并注册它*/
int snull_init_module(void)
{
        int result, i, ret = -ENOMEM;

        /*中断函数指针，因是否使用NAPI而指向不同的中断函数*/
        snull_interrupt = use_napi ? snull_napi_interrupt : snull_regular_interrupt;

        /* 
         * 分配两个设备，网络设备都是用struct net_device来描述，alloc_netdev分配设备，第三个参数是
         * 对struct net_device结构成员进行初始化的函数，对于以太网来说，可以把alloc_netdev/snull_init
         * 两个函数变为一个，alloc_etherdev，它会自动调用以太网的初始化函数ether_setup，因为以太网的初
         * 始化函数工作都是近乎一样的 */
        snull_devs[0] = alloc_netdev(sizeof(struct snull_priv), "sn%d",
                        snull_init);
        snull_devs[1] = alloc_netdev(sizeof(struct snull_priv), "sn%d",
                        snull_init);
        /*分配失败*/
        if (snull_devs[0] == NULL || snull_devs[1] == NULL)
                goto out;

        ret = -ENODEV;
        /*向内核注册网络设备，这样，设备就可以被使用了*/
        for (i = 0; i < 2;  i++)
                if ((result = register_netdev(snull_devs[i])))
                        printk("snull: error %i registering device \"%s\"\n",
                                        result, snull_devs[i]->name);
                else
                        ret = 0;
   out:
        if (ret) 
                snull_cleanup();
        return ret;
}


module_init(snull_init_module);
module_exit(snull_cleanup);