CODE:
/*
* snull.c --  the Simple Network Utility
*
* Copyright (C) 2001 Alessandro Rubini and Jonathan Corbet
* Copyright (C) 2001 O'Reilly & Associates
*
* The source code in this file can be freely used, adapted,
* and redistributed in source or binary form, so long as an
* acknowledgment appears in derived source files.  The citation
* should list that the code comes from the book "Linux Device
* Drivers" by Alessandro Rubini and Jonathan Corbet, published
* by O'Reilly & Associates.   No warranty is attached;
* we cannot take responsibility for errors or fitness for use.
*
* $Id: snull.c,v 1.21 2004/11/05 02:36:03 rubini Exp $
*/

#include <linux/config.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/moduleparam.h>

#include <linux/sched.h>
#include <linux/kernel.h> /* printk() */
#include <linux/slab.h> /* kmalloc() */
#include <linux/errno.h>  /* error codes */
#include <linux/types.h>  /* size_t */
#include <linux/interrupt.h> /* mark_bh */

#include <linux/in.h>
#include <linux/netdevice.h>   /* struct device, and other headers */
#include <linux/etherdevice.h> /* eth_type_trans */
#include <linux/ip.h>          /* struct iphdr */
#include <linux/tcp.h>         /* struct tcphdr */
#include <linux/skbuff.h>

#include "snull.h"

#include <linux/in6.h>
#include <asm/checksum.h>

MODULE_AUTHOR("Alessandro Rubini, Jonathan Corbet");
MODULE_LICENSE("Dual BSD/GPL");


/*
* Transmitter lockup simulation, normally disabled.
*/
static int lockup = 0;
module_param(lockup, int, 0);

static int timeout = SNULL_TIMEOUT;
module_param(timeout, int, 0);

/*
* Do we run in NAPI mode?
*/
static int use_napi = 0;
module_param(use_napi, int, 0);


/*
* A structure representing an in-flight packet.
*/
struct snull_packet {
        struct snull_packet *next;
        struct net_device *dev;
        int        datalen;
        u8 data[ETH_DATA_LEN];
};

int pool_size = 8;
module_param(pool_size, int, 0);

/*
* This structure is private to each device. It is used to pass
* packets in and out, so there is place for a packet
*/

struct snull_priv {
        struct net_device_stats stats;
        int status;
        struct snull_packet *ppool;
        struct snull_packet *rx_queue;  /* List of incoming packets */
        int rx_int_enabled;
        int tx_packetlen;
        u8 *tx_packetdata;
        struct sk_buff *skb;
        spinlock_t lock;
};

static void snull_tx_timeout(struct net_device *dev);
static void (*snull_interrupt)(int, void *, struct pt_regs *);

/*
* 設置設備的包緩沖池.
* 當需要使用NAPI，而非中斷處理的時候，設備需要能夠保存多個數據包的能力，這個保存所需的緩存，
* 或者在板卡上，或者在內核的DMA環中。
* 作者這里的演示程序，根據pool_size的大小，分配pool_size個大小為struct snull_packet的緩沖區，
* 這個緩沖池用鏈表組織，“私有數據”結構的ppool成員指針指向鏈表首部。
*/
void snull_setup_pool(struct net_device *dev)
{
        struct snull_priv *priv = netdev_priv(dev);
        int i;
        struct snull_packet *pkt;

        priv->ppool = NULL;
        for (i = 0; i < pool_size; i++) {
                pkt = kmalloc (sizeof (struct snull_packet), GFP_KERNEL);
                if (pkt == NULL) {
                        printk (KERN_NOTICE "Ran out of memory allocating packet pool\n");
                        return;
                }
                pkt->dev = dev;
                pkt->next = priv->ppool;
                priv->ppool = pkt;
        }
}

/*因為snull_setup_pool分配了pool_size個struct snull_packet，所以，驅動退出時，需要釋放內存*/
void snull_teardown_pool(struct net_device *dev)
{
        struct snull_priv *priv = netdev_priv(dev);
        struct snull_packet *pkt;
    
        while ((pkt = priv->ppool)) {
                priv->ppool = pkt->next;
                kfree (pkt);
                /* FIXME - in-flight packets ? */
        }
}    

/*
* 獲取設備要傳輸的第一個包，傳輸隊列首部相應的移動到下一個數據包.
*/
struct snull_packet *snull_get_tx_buffer(struct net_device *dev)
{
        struct snull_priv *priv = netdev_priv(dev);
        unsigned long flags;
        struct snull_packet *pkt;
    
        spin_lock_irqsave(&priv->lock, flags);
        pkt = priv->ppool;
        priv->ppool = pkt->next;
        if (priv->ppool == NULL) {
                printk (KERN_INFO "Pool empty\n");
                netif_stop_queue(dev);
        }
        spin_unlock_irqrestore(&priv->lock, flags);
        return pkt;
}

/*將包緩存交還給緩存池*/
void snull_release_buffer(struct snull_packet *pkt)
{
        unsigned long flags;
        struct snull_priv *priv = netdev_priv(pkt->dev);
        
        spin_lock_irqsave(&priv->lock, flags);
        pkt->next = priv->ppool;
        priv->ppool = pkt;
        spin_unlock_irqrestore(&priv->lock, flags);
        if (netif_queue_stopped(pkt->dev) && pkt->next == NULL)
                netif_wake_queue(pkt->dev);
}

/*將要傳輸的包加入到設備dev的傳輸隊列首部，當然，這只是一個演示，這樣一來，就變成先進先出了*/
void snull_enqueue_buf(struct net_device *dev, struct snull_packet *pkt)
{
        unsigned long flags;
        struct snull_priv *priv = netdev_priv(dev);

        spin_lock_irqsave(&priv->lock, flags);
        pkt->next = priv->rx_queue;  /* FIXME - misorders packets */
        priv->rx_queue = pkt;
        spin_unlock_irqrestore(&priv->lock, flags);
}

/*取得傳輸隊列中的第一個數據包*/
struct snull_packet *snull_dequeue_buf(struct net_device *dev)
{
        struct snull_priv *priv = netdev_priv(dev);
        struct snull_packet *pkt;
        unsigned long flags;

        spin_lock_irqsave(&priv->lock, flags);
        pkt = priv->rx_queue;
        if (pkt != NULL)
                priv->rx_queue = pkt->next;
        spin_unlock_irqrestore(&priv->lock, flags);
        return pkt;
}

/*
* 打開/關閉接收中斷.
*/
static void snull_rx_ints(struct net_device *dev, int enable)
{
        struct snull_priv *priv = netdev_priv(dev);
        priv->rx_int_enabled = enable;
}

    
/*
* 設備打開函數，是驅動最重要的函數之一，它應該注冊所有的系統資源（I/O端口，IRQ、DMA等等），
* 并對設備執行其他所需的設置。
* 因為這個例子中，并沒有真正的物理設備，所以，它最重要的工作就是啟動傳輸隊列。
*/

int snull_open(struct net_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);
        return 0;
}

/*設備停止函數，這里的工作就是停止傳輸隊列*/
int snull_release(struct net_device *dev)
{
    /* release ports, irq and such -- like fops->close */

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

/*
* 當用戶調用ioctl時類型為SIOCSIFMAP時，如使用ifconfig，系統會調用驅動程序的set_config 方法。
* 用戶會傳遞一個ifmap結構包含需要設置的I/O地址、中斷等參數。
*/
int snull_config(struct net_device *dev, struct ifmap *map)
{
        if (dev->flags & IFF_UP) /* 不能設置一個正在運行狀態的設備 */
                return -EBUSY;

        /* 這個例子中，不允許改變 I/O 地址*/
        if (map->base_addr != dev->base_addr) {
                printk(KERN_WARNING "snull: Can't change I/O address\n");
                return -EOPNOTSUPP;
        }

        /* 允許改變 IRQ */
        if (map->irq != dev->irq) {
                dev->irq = map->irq;
                /* request_irq() is delayed to open-time */
        }

        /* ignore other fields */
        return 0;
}

/*
* 接收數據包函數
* 它被“接收中斷”調用，重組數據包，并調用函數netif_rx進一步處理。
* 我們從“硬件”中收到的包，是用struct snull_packet來描述的，但是內核中描述一個包，是使用
* struct sk_buff（簡稱skb），所以，這里要完成一個把硬件接收的包拷貝至內核緩存skb的一個
* 組包過程(PS：不知在接收之前直接分配一個skb，省去這一步，會如何提高性能，沒有研究過，見笑了^o^)。
*/
void snull_rx(struct net_device *dev, struct snull_packet *pkt)
{
        struct sk_buff *skb;
        struct snull_priv *priv = netdev_priv(dev);

        /*
         * 分配skb緩存
         */
        skb = dev_alloc_skb(pkt->datalen + 2);
        if (!skb) {                        /*分配失敗*/
                if (printk_ratelimit())
                        printk(KERN_NOTICE "snull rx: low on mem - packet dropped\n");
                priv->stats.rx_dropped++;
                goto out;