* 如果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);