LDD一书中，网络驱动在linux-3.1中的修改运行

2450阅读　0评论2014-11-28　helianthus_lu
分类：LINUX

由于linux内核现在的更新速度非常之快，在LDD（linux内核驱动）一书中，很多代码都不能在现在的比较新的内核中直接运行了，都需要我们对其中的机制加以理解之后，重新修改代码才能运行。本文针对其中网络驱动snull进行修改，并使其在linux-3.1中运行。通过这个过程，笔者也对linux网络部分的理解也加深了一点点。

先看该驱动的初始化函数：int snullnet_init()
函数分析：
    1、为网络设备分配设备结构：net_device，该过由alloc_netdev实现；
    2、注册设备，由register_netdev实现；
  
alloc_netdev函数的第一个参数是网络设备的私有结构体，由于一个设备驱动程序可以被多个网络设备使用，所以不同的设备是用这个私有结构体来区分的；网络设备通过netdev_priv函数可以从网络接口的net_device结构得到该私有结构体的指针；下面我们看看LDD中的网络接口的私有结构体（struct snull_priv）：

点击(此处)折叠或打开

  1. struct snull_priv {
  2.     struct net_device_stats stats;//网络统计信息，内核已经定义了该结构体
  3.     int status;                   //网络接口状态
  4.     struct snull_packet *ppool;   //缓冲池，驱动需要该结构时候，直接从这个队列中取出，用完后归还
  5.     struct snull_packet *rx_queue;//接收到的数据包的队列
  6.     int rx_int_enabled;           //接收中端是否使能
  7.     int tx_packetlen;             //要发送的数据包的长度
  8.     u8 *tx_packetdata;            //要发送的数据
  9.     struct sk_buff *skb;          //这个可以没有的，貌似我修改的程序中，木有用到
  10.     spinlock_t lock;              //保护该结构体并发访问的自旋锁
  11.     struct napi_struct *snull_napi;//使用napi时候，要用到的结构，在linux2.6.24中加入
  12. };
alloc_netdev的第三个参数是snull_init，指定了初始化alloc_netdev所分配空间的函数，下面我们九分析它。
void snull_init(struct net_device *dev)完成以下任务：
1、调用ether_setup；
        这里不得不说一下的是，ether_setup是内核为方便初始化以太网接口而定义的，其他的网络也有类似的函数，比如fddi_setup用于设置FDDI网络接口等等；其实如果你想加入一个以前不存在的接口类型的话，你可以定义自己的接口初始化函数；也可以用一个类似的函数初始化，然后再修改一些域就可以了
2、设置两个主要的操作函数集；        

  1. dev->netdev_ops = &snulldev_ops;//网络接口管理函数
  2. dev->header_ops = &snull_header_ops;//数据帧头部处理函数
从中我们可以看到：当我们定义一个网络接口的net_device结构体，通过初始化这两个域，可以把内核对接口的操作重新实现为我们定义的操作，这是不是面向对象编程中的“多态性”的思想呢？

既然提到了上面的两个操作集合，我们接下来就说说他们吧。
hdader_ops是header_ops结构的实例：
在本驱动中，我们定义了create、rebuild连个操作；
create操作在发送数据包之前被调用，用来组装帧头部；
rebuild在进行地址解析（如IPv4中的ARP协议）之后，重新组装帧头部；

netdev_ops是net_device_ops结构的实例；
该结构体定义了N多的操作，本驱动实现了其中的一部分下面一一对他们进行讲解：

snull_open设备UP时被调用，本驱动用它完成下面任务：
1、设置接口的硬件地址；
2、调用netif_start_queue函数，该调用等于告诉内核，该接口可以接收上层数据包了；
snull_release：设备进入DOWN状态时被调用，本驱动使用来实现：
1、调用netif_stop_queue函数，告诉内核，我以后不接收数据包了；
snull_chenge_mtu：这个没有歧义，不再说明；
snull_stats：获取设备的统计信息，本驱动直接返回私有结构中的net_device_ops内嵌结构的指针；
snull_tx：设备的发送函数，完成设备的数据发送工作；这个函数比较重要，但是根LDD中没有区别，可以参考上面的解释；

下面我们就主要看看设备接收数据的过程：
该驱动使用了两种方法来展示linux中处理网络接口数据接收问题的方法，由于该驱动模拟了接收中断，所以下面两种方法都是中断服务函数；
方法一：void snull_regular_interrupt(...)，解析如下：
  1. pkt = priv->rx_queue;
这一句从设备的接收队列中取出一个数据包，
然后，驱动调用了snull_rx函数，这个函数利用要传递的数据，调用dev_alloc_skb函数来初始化sk_buff结构，初始化sk_buff时期，最值得关注的一个细节是：

  1. skb->protocol = eth_type_trans(skb, dev);
这一句设置了要传递给上层的协议类型，当然，该类型是eth_type_trans通过skb结构体和设备类型判断的，大家可以仔细看看这个函数的执行过程；
最终，函数调用了netif_rx（skb)函数，这个函数由内核提供；至此，驱动完成了数据向上层传递的任务，其他工作由内核完成；
建议大家空闲的时候，跟踪一下netif_rx这个函数，以便更好的理解linux网络数据的接收；
方法二：void snull_napi_interrupt（...），解析如下：

  1.         snull_rx_ints(dev, 0);//禁止接收中断
  2.         napi_enable(priv->snull_napi);
  3.         napi_schedule(priv->snull_napi);
这三句就是网络驱动napi接口的主要工作了：禁止接收中断、打开napi轮循、调度该接口的napi；
这个主要涉及到网络的napi功能；该功能简单来说就是在发生网络数据接收中断时，关闭接口的中断，通过轮循的方法处理以后到来的网络数据，直到所有的数据处理完毕（这个不准确，但是更容易理解）；数据处理完毕再打开接收中断；napi接口以后有空再讲，现在暂且不提；

至此，一个具备基本功能的网络驱动程序就已经勾画出来了，自己在这里记录一下，以便以后复习；下面粘贴完整的源文件：snullnet.c
--->文件名：snullnet.c

点击(此处)折叠或打开

  1. #include <linux/module.h>
  2. #include <linux/init.h>
  3. #include <linux/moduleparam.h>
  4. #include <linux/netdevice.h>
  5. #include <linux/etherdevice.h>
  6. #include <linux/kernel.h>
  7. #include <linux/interrupt.h>
  8. #include <linux/spinlock.h>

  10. #include <linux/sched.h>
  11. #include <linux/slab.h>
  12. #include <linux/errno.h>
  13. #include <linux/types.h>
  14. #include <linux/in.h>
  15. #include <linux/ip.h>
  16. #include <linux/tcp.h>
  17. #include <linux/skbuff.h>
  18. #include <asm/checksum.h>

  20. #define SNULL_RX_INTR    1UL
  21. #define SNULL_TX_INTR    2UL
  22. #define SNULL_TIMEOUT    5

  24. MODULE_AUTHOR("xishuai");
  25. MODULE_LICENSE("GPLv3");

  27. int pool_size = 8;
  28. module_param(pool_size, int, 0);
  29. int use_napi = 0;
  30. module_param(use_napi, int, 0);

  32. struct snull_packet {
  33.     struct snull_packet *next;
  34.     struct net_device *dev;
  35.     int datalen;
  36.     u8 data[ETH_DATA_LEN];
  37. };

  39. struct snull_priv {
  40.     struct net_device_stats stats;
  41.     int status;
  42.     struct snull_packet *ppool;
  43.     struct snull_packet *rx_queue;
  44.     int rx_int_enabled;
  45.     int tx_packetlen;
  46.     u8 *tx_packetdata;
  47.     struct sk_buff *skb;
  48.     spinlock_t lock;
  49.     struct napi_struct *snull_napi;
  50. };

  52. static struct net_device *snull_dev[2];

  54. static void(*snull_interrupt)(int, void*, struct pt_regs *);

  56. static int snull_open(struct net_device *dev)
  57. {
  58.     printk(KERN_ALERT "snull_open\n");

  60.     memcpy(dev->dev_addr, "\0SNUL0", ETH_ALEN);
  61.     if (dev == snull_dev[1]) {
  62.         dev->dev_addr[ETH_ALEN -1]++;
  63.     }
  64.     netif_start_queue(dev);//允许上层调用ndo_start_xmit函数
  65.     return 0;
  66. }

  68. static int snull_release(struct net_device *dev)
  69. {
  70.     printk("snullnet:snull_release\n");
  71.     netif_stop_queue(dev);//禁止上层调用本设备的发送函数
  72.     return 0;
  73. }

  75. static int snull_config(struct net_device *dev, struct ifmap *map)
  76. {
  77.     printk("snullnet:snull_config\n");
  78.     if(dev->flags & IFF_UP) return -EBUSY;

  80.     if(map->base_addr != dev->base_addr) {
  81.         printk(KERN_WARNING "snull: Can't change I/O address\n");
  82.         return -EOPNOTSUPP;
  83.     }
  84.     
  85.     if(map->irq != dev->irq) {
  86.         dev->irq = map->irq;
  87.     }

  89.     /*忽略其他域的改变*/
  90.     return 0;
  91. }

  93. static void snull_enqueue_buf(struct net_device *dev, struct snull_packet *pkt)
  94. {
  95.     unsigned long flags;
  96.     struct snull_priv *priv = netdev_priv(dev);

  98.     printk("snullnet:snull_enqueue_buf\n");
  99.     spin_lock_irqsave(&priv->lock, flags);
  100.     pkt->next = priv->rx_queue;
  101.     priv->rx_queue = pkt;
  102.     spin_unlock_irqrestore(&priv->lock, flags);
  103. }

  105. static struct snull_packet *snull_get_tx_buffer(struct net_device *dev)
  106. {
  107.     struct snull_priv *priv = netdev_priv(dev);
  108.     unsigned long flags;
  109.     struct snull_packet *pkt;

  111.     printk("snullnet:snull_get_tx_buffer\n");
  112.     spin_lock_irqsave(&priv->lock, flags);
  113.     pkt = priv->ppool;
  114.     priv->ppool = pkt->next;
  115.     if (priv->ppool == NULL) {
  116.         printk(KERN_INFO "pool empty\n");
  117.         netif_stop_queue(dev);
  118.     }
  119.     spin_unlock_irqrestore(&priv->lock, flags);
  120.     return pkt;
  121. }

  123. //发送上层数据，本函数吃力底层硬件细节
  124. static void snull_hw_tx(char *buf, int len, struct net_device *dev)
  125. {
  126.     struct iphdr *ih;//
  127.     struct net_device *dest;
  128.     struct snull_priv *priv;
  129.     u32 *saddr, *daddr;
  130.     struct snull_packet *tx_buffer;

  132.     ih = (struct iphdr *)(buf + sizeof(struct ethhdr));
  133.     saddr = &ih->saddr;
  134.     daddr = &ih->daddr;
  135.     
  136.     //驱动中修改了IP层的头部，这在正常的驱动中是不应该的
  137.     ((u8 *)saddr)[2] ^= 1;
  138.     ((u8 *)daddr)[2] ^= 1;

  140.     ih->check = 0;    //要重新计算校验和
  141.     ih->check = ip_fast_csum((unsigned char *)ih, ih->ihl);

  143.     //准备发送
  144.     dest = snull_dev[dev == snull_dev[0] ? 1 : 0];
  145.     priv = netdev_priv(dest);
  146.     tx_buffer = snull_get_tx_buffer(dev);
  147.     tx_buffer->datalen = len;
  148.     memcpy(tx_buffer->data, buf, len);
  149.     snull_enqueue_buf(dest, tx_buffer);
  150.     if (priv->rx_int_enabled) {
  151.         priv->status |= SNULL_RX_INTR;
  152.         snull_interrupt(0, dest, NULL);
  153.     }

  155.     priv = netdev_priv(dev);
  156.     priv->tx_packetlen = len;
  157.     priv->tx_packetdata = buf;
  158.     priv->status |= SNULL_TX_INTR;
  159.     snull_interrupt(0, dev, NULL);//原来的代码里面有个模拟丢包的代码段
  160. }

  162. static int snull_tx(struct sk_buff *skb, struct net_device *dev)
  163. {
  164.     int len;
  165.     char *data, shortpkt[ETH_ZLEN];
  166.     struct snull_priv *priv = netdev_priv(dev);

  168.     printk("snullnet:snull_tx\n");
  169.     data = skb->data;
  170.     len = skb->len;
  171.     if (len < ETH_ZLEN) {
  172.         memset(shortpkt, 0, ETH_ZLEN);
  173.         memcpy(shortpkt, skb->data, skb->len);
  174.         len = ETH_ZLEN;
  175.         data = shortpkt;
  176.     }
  177.     dev->trans_start = jiffies;
  178.     priv->skb = skb;
  179.     snull_hw_tx(data, len, dev);//实际的发送过程，设备相关

  181.     return 0;
  182. }

  184. static void snull_tx_timeout (struct net_device *dev)
  185. {
  186.     struct snull_priv *priv = netdev_priv(dev);

  188.     //模拟传输中断
  189.     priv->status = SNULL_TX_INTR;
  190.     snull_interrupt(0, dev, NULL);
  191.     priv->stats.tx_errors++;
  192.     netif_wake_queue(dev);
  193.     return;
  194. }

  196. static int snull_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
  197. {
  198.     printk("snullnet:snull_ioctl\n");
  199.     return 0;
  200. }

  202. static struct net_device_stats *snull_stats(struct net_device *dev)
  203. {
  204.     struct snull_priv *priv = netdev_priv(dev);
  205.     return &priv->stats;
  206. }

  208. static int snull_create_header(struct sk_buff *skb, struct net_device *dev,
  209.                             unsigned short type, const void *daddr,
  210.                             const void *saddr, unsigned len)
  211. {
  212.     struct ethhdr *eth = (struct ethhdr *)skb_push(skb, ETH_HLEN);
  213.     
  214.     printk("snullnet:snull_create_header\n");
  215.     eth->h_proto = htons(type);
  216.     memcpy(eth->h_source, saddr ? saddr : dev->dev_addr, dev->addr_len);
  217.     memcpy(eth->h_dest, daddr ? daddr : dev->dev_addr, dev->addr_len);
  218.     eth->h_dest[ETH_ALEN - 1] ^= 1;
  219.     return (dev->hard_header_len);
  220. }

  222. static int snull_rebuild_header(struct sk_buff *skb)
  223. {
  224.     struct ethhdr *eth = (struct ethhdr *)skb->data;
  225.     struct net_device *dev = skb->dev;

  227.     printk("snullnet:snull_rebuild_header\n");
  228.     memcpy(eth->h_source, dev->dev_addr, dev->addr_len);
  229.     memcpy(eth->h_dest, dev->dev_addr, dev->addr_len);
  230.     eth->h_dest[ETH_ALEN - 1] ^= 1;
  231.     return 0;
  232. }

  234. static int snull_change_mtu(struct net_device *dev, int new_mtu)
  235. {
  236.     unsigned long flags;
  237.     struct snull_priv *priv = netdev_priv(dev);
  238.     spinlock_t *lock = &priv->lock;

  240.     printk("snullnet:snull_change_mtu\n");
  241.     if((new_mtu < 68) || (new_mtu > 1500)) return -EINVAL;

  243.     spin_lock_irqsave(lock, flags);
  244.     dev->mtu = new_mtu;
  245.     spin_unlock_irqrestore(lock, flags);
  246.     return 0;
  247. }

  249. static struct header_ops snull_header_ops = {
  250.     .create     = snull_create_header,
  251.     .rebuild    = snull_rebuild_header,
  252. };

  254. static struct net_device_ops snulldev_ops = {
  255.     .ndo_open                 = snull_open,
  256.     .ndo_stop                 = snull_release,
  257.     .ndo_set_config         = snull_config,
  258.     .ndo_start_xmit         = snull_tx,
  259.     .ndo_do_ioctl            = snull_ioctl,
  260.     .ndo_get_stats            = snull_stats,
  261.     .ndo_change_mtu            = snull_change_mtu,
  262.     .ndo_tx_timeout            = snull_tx_timeout,
  263. };

  265. static void snull_rx_ints(struct net_device *dev, int enable)
  266. {
  267.     struct snull_priv *priv     = netdev_priv(dev);
  268.     priv->rx_int_enabled         = enable;
  269. }

  271. static void snull_setup_pool(struct net_device *dev)
  272. {
  273.     
  274.     struct snull_priv *priv = netdev_priv(dev);
  275.     int i;
  276.     struct snull_packet *pkt;

  278.     printk("snullnet:snull_setup_pool\n");
  279.     priv->ppool = NULL;
  280.     for(i = 0; i < pool_size; i++) {
  281.         pkt = kmalloc(sizeof (struct snull_packet), GFP_KERNEL);
  282.         if(NULL == pkt) {
  283.             printk(KERN_NOTICE "Ran out of memory allocating packet pool\n");
  284.             return;
  285.         }
  286.         pkt->dev = dev;
  287.         pkt->next = priv->ppool;
  288.         priv->ppool = pkt;
  289.     }
  290. }

  292. static void snull_release_buffer(struct snull_packet *pkt)
  293. {
  294.     unsigned long flags;
  295.     struct snull_priv *priv = netdev_priv(pkt->dev);

  297.     spin_lock_irqsave(&priv->lock, flags);
  298.     pkt->next = priv->ppool;//牛逼，还整个结构提复用池
  299.     priv->ppool = pkt;
  300.     spin_unlock_irqrestore(&priv->lock, flags);
  301.     if (netif_queue_stopped(pkt->dev) && pkt->next == NULL) {
  302.         netif_wake_queue(pkt->dev);
  303.     }
  304. }

  306. static int snull_poll(struct napi_struct *napi, int work_limit)
  307. {
  308.     int nworked = 0;
  309.     struct snull_priv *priv = netdev_priv(napi->dev);
  310.     struct sk_buff *skb;
  311.     struct snull_packet *pkt;
  312.     unsigned long flags;

  314.     printk("snullnet:work_limit = %d\n", work_limit);

  316.     while(nworked < work_limit && priv->rx_queue) {
  317.         spin_lock_irqsave(&priv->lock, flags);
  318.         pkt = priv->rx_queue;
  319.         priv->rx_queue = priv->rx_queue->next;
  320.         spin_unlock_irqrestore(&priv->lock, flags);

  322.         skb = dev_alloc_skb(pkt->datalen + 2);
  323.         if (!skb) {
  324.             //没有分配到内存
  325.             priv->stats.rx_dropped++;
  326.             snull_release_buffer(pkt);
  327.             continue;
  328.         }
  329.         skb_reserve(skb, 2);
  330.         memcpy(skb_put(skb, pkt->datalen), pkt->data, pkt->datalen);
  331.         skb->dev = napi->dev;
  332.         skb->protocol = eth_type_trans(skb, napi->dev);
  333.         //skb->ip_summed = CHECKSUM_UNNECTSSARY;
  334.         netif_receive_skb(skb);

  336.         nworked++;
  337.         priv->stats.rx_packets++;
  338.         priv->stats.rx_bytes += pkt->datalen;
  339.         snull_release_buffer(pkt);
  340.     }

  342.     //该次的poll过程结束
  343.     if (! priv->rx_queue) {
  344.         //已经处理完所有数据包
  345.         napi_complete(napi);
  346.         snull_rx_ints(napi->dev, 1);
  347.         //return 0;
  348.     }
  349.     
  350.     return nworked;
  351. }

  353. static void snull_init(struct net_device *dev)
  354. {
  355.     struct snull_priv *priv;

  357.     printk("snullnet:snull_init\n");
  358.     priv = netdev_priv(dev);
  359.     ether_setup(dev);
  360.     dev->netdev_ops = &snulldev_ops;
  361.     dev->header_ops = &snull_header_ops;
  362.     if (use_napi) {
  363.         priv->snull_napi = kmalloc(sizeof (struct napi_struct), GFP_KERNEL);
  364.         netif_napi_add(dev, priv->snull_napi, snull_poll, 16);
  365.     }

  367.     dev->flags                 |= IFF_NOARP;
  368.     //dev->features             |=
  369.     //dev->hard_header_cache    =

  371.     memset(priv, 0, sizeof(struct snull_priv));
  372.     spin_lock_init(&priv->lock);
  373.     snull_rx_ints(dev, 1);
  374.     snull_setup_pool(dev);
  375. }



  379. static void snull_rx(struct net_device *dev, struct snull_packet *pkt)
  380. {
  381.     struct sk_buff *skb;
  382.     struct snull_priv *priv = netdev_priv(dev);

  384.     printk("snullnet:snull_rx\n");
  385.     skb = dev_alloc_skb(pkt->datalen + 2);
  386.     if(!skb) {
  387.         priv->stats.rx_dropped++;
  388.         goto out;
  389.     }

  391.     skb_reserve(skb, 2);
  392.     memcpy(skb_put(skb, pkt->datalen), pkt->data, pkt->datalen);

  394.     skb->dev = dev;
  395.     skb->protocol = eth_type_trans(skb, dev);
  396.     skb->ip_summed = CHECKSUM_UNNECESSARY;
  397.     priv->stats.rx_packets++;
  398.     priv->stats.rx_bytes += pkt->datalen;
  399.     netif_rx(skb);
  400. out:
  401.     return;
  402. }

  404. static void snull_napi_interrupt(int irq, void *dev_id, struct pt_regs *regs)
  405. {
  406.     int statusword;
  407.     struct snull_priv *priv;
  408.     struct net_device *dev = (struct net_device *)dev_id;
  409.     
  410.     printk("snull_napi_interrupt\n");

  412.     if (!dev) return;

  414.     priv = netdev_priv(dev);
  415.     spin_lock(&priv->lock);

  417.     statusword = priv->status;
  418.     priv->status = 0;                                                                                return;
  419.     if (statusword & SNULL_RX_INTR) {
  420.         snull_rx_ints(dev, 0);//禁止接收中断
  421.         napi_enable(priv->snull_napi);
  422.         napi_schedule(priv->snull_napi);
  423.     }
  424.     if (statusword & SNULL_TX_INTR) {
  425.         priv->stats.tx_packets++;
  426.         priv->stats.tx_bytes += priv->tx_packetlen;
  427.         kfree_skb(priv->skb);
  428.     }

  430.     spin_unlock(&priv->lock);
  431.     return ;
  432. }

  434. static void snull_regular_interrupt(int irq, \
  435.                                     void *dev_id, struct pt_regs *regs) {
  436.     int statusword;
  437.     struct snull_priv *priv;
  438.     struct snull_packet *pkt = NULL;
  439.     struct net_device *dev = (struct net_device *)dev_id;
  440.     if (!dev) return;

  442.     priv = netdev_priv(dev);
  443.     spin_lock(&priv->lock);

  445.     statusword = priv->status;
  446.     priv->status = 0;
  447.     if (statusword & SNULL_RX_INTR) {
  448.         pkt = priv->rx_queue;
  449.         if (pkt) {
  450.             priv->rx_queue = pkt->next;
  451.             snull_rx(dev, pkt);
  452.         }
  453.     }
  454.     if (statusword & SNULL_TX_INTR) {
  455.         priv->stats.tx_packets++;
  456.         priv->stats.tx_bytes += priv->tx_packetlen;
  457.         dev_kfree_skb(priv->skb);
  458.     }
  459.     
  460.     spin_unlock(&priv->lock);
  461.     if (pkt) snull_release_buffer(pkt);
  462.     return;
  463. }

  465. static void snull_free_pool(struct net_device *dev)
  466. {
  467.     int i;
  468.     struct snull_priv *priv = netdev_priv(dev);
  469.     struct snull_packet *pkt;

  471.     for(i = 0; i < pool_size; i++) {
  472.         pkt = priv->ppool;
  473.         priv->ppool = pkt->next;
  474.         kfree(pkt);
  475.     }
  476. }

  478. static void snullnet_clean(void)
  479. {
  480.     int i;
  481.     struct snull_priv *priv;

  483.     printk(KERN_ALERT "snullnet exiting");
  484.     for(i = 0;i < 2; i++) {
  485.         if(snull_dev[i]) {
  486.             unregister_netdev(snull_dev[i]);
  487.             snull_free_pool(snull_dev[i]);
  488.             priv = netdev_priv(snull_dev[i]);
  489.             kfree(priv->snull_napi);
  490.             free_netdev(snull_dev[i]);    
  491.         }
  492.     }
  493. }

  495. static int __init snullnet_init(void)
  496. {
  497.     int i, ret = 0;
  498.     printk(KERN_ALERT "snullnet initing");
  499.     
  500.     snull_interrupt = use_napi ? snull_napi_interrupt : \
  501.                                 snull_regular_interrupt;

  503.     for(i = 0; i < 2; i++) {//分配设备
  504.         snull_dev[i] = alloc_netdev(sizeof(struct snull_priv), "sn%d",
  505.                             snull_init);
  506.     }
  507.     if(!snull_dev[0] || !snull_dev[1]) {
  508.         ret = -ENOMEM;
  509.         goto out;
  510.     }
  511.     
  512.     for(i = 0; i < 2; i++) {//注册设备
  513.         int ret = 0;
  514.         if((ret = register_netdev(snull_dev[i]))) {
  515.             printk(KERN_ALERT "snull: error %i registering device \
  516.                     \"%s\"\n", ret, snull_dev[i]->name);
  517.             goto out;
  518.         }
  519.     }
  520.     return 0;

  522. out:
  523.     snullnet_clean();
  524.     return ret;
  525. }
  526. module_init(snullnet_init);
  527. module_exit(snullnet_clean);


上一篇：ubuntu创建root用户，以root登陆
下一篇：超经典程序设计类书籍大盘点