Chinaunix首页 | 论坛 | 博客

残剑

首页　| 　博文目录　| 　关于我

txgc_wm

  • 博客访问： 4044148
  • 博文数量： 366
  • 博客积分： 9916
  • 博客等级： 中将
  • 技术积分： 7195
  • 用 户 组： 普通用户
  • 注册时间： 2011-05-29 23:27
个人简介

简单！

文章分类

全部博文（366）

文章存档

2013年（51）

2012年（269）

2011年（46）

我的朋友
最近访客
推荐博文
相关博文
snull网络驱动程序（参考《Linux设备驱动程序第三版》）

分类： 嵌入式

2012-02-20 02:47:49

snull网络设备驱动程序

头文件
  1. /*
  2.  * snull.h -- definitions for the network module
  3.  *
  4.  *
  5.  */

  7. #ifndef __SNULL_H__
  8. #define __SNULL_H__


  11. #define SNULL_RX_INTR 0x0001
  12. #define SNULL_TX_INTR 0x0002
  13. #define SNULL_TIMEOUT 5

  15. struct snull_priv {
  16.     struct net_device_stats stats;
  17.     int status;
  18.     int rx_packetlen;
  19.     u8 *rx_packetdata;
  20.     int tx_packetlen;
  21.     u8 *tx_packetdata;
  22.     struct sk_buff *skb;
  23.     spinlock_t lock;
  24.     struct net_device *dev;
  25. };


  28. #endif

驱动源码
  1. /*
  2.  * name:snull.c
  3.  * function:the Simple Network Utility
  4.  * time:2012-2-22
  5.  *
  6.  * author:txgcwm
  7.  * mail:txgcwm@163.com
  8.  * reference:Linux设备驱动程序(第三版)
  9.  */
  10. #ifndef __KERNEL__
  11. # define __KERNEL__
  12. #endif
  13. #ifndef MODULE
  14. # define MODULE
  15. #endif

  17. #include <linux/init.h>
  18. #include <linux/module.h>
  19. #include <linux/sched.h>
  20. #include <linux/kernel.h>
  21. #include <linux/slab.h>
  22. #include <linux/errno.h>
  23. #include <linux/types.h>
  24. #include <linux/interrupt.h>
  25. #include <linux/in.h>
  26. #include <linux/netdevice.h>
  27. #include <linux/etherdevice.h>
  28. #include <linux/ip.h>
  29. #include <linux/tcp.h>
  30. #include <linux/skbuff.h>
  31. #include <linux/in6.h>
  32. #include <asm/checksum.h>
  33. #include "snull.h"


  36. static int lockup = 0;
  37. module_param(lockup,int,0);
  38. static int timeout = SNULL_TIMEOUT;
  39. module_param(timeout,int,0);
  40. struct net_device *snull_devs[2];

  42. void snull_tx_timeout(struct net_device *dev);
  43.         


  46. int snull_open(struct net_device *dev)
  47. {
  48.     /*在接口能够和外界通讯之前，要将硬件（MAC）从硬件设备复制到dev->dev_addr。硬件地址可在打开期间拷贝到设备中。snull软件接口在open时赋予硬件地址--它其实使用了一个长度为ETH_ALEN的ASCII字符串作为假的硬件地址，其中ETH_ALEN是以太网硬件地址的长度*/
  49.     memcpy(dev->dev_addr, "\0SNUL0", ETH_ALEN);
  50.     if(dev == snull_devs[1])
  51.         dev->dev_addr[ETH_ALEN-1] ++;
  52.     netif_start_queue(dev);    //一旦准备好开始发送数据后，open方法还应该启动接口的传输队列，允许接口接受传输包。

  54.     return 0;
  55. }

  57. int snull_release(struct net_device *dev)
  58. {
  59.     netif_stop_queue(dev);    //在接口被关闭时，必须调用该函数，但该函数也可以用来临时停止传输。

  61.     return 0;
  62. }

  64. int snull_config(struct net_device *dev, struct ifmap *map)
  65. {
  66.     if (dev->flags & IFF_UP)
  67.         return -EBUSY;

  69.     if (map->base_addr != dev->base_addr)
  70.     {
  71.         printk(KERN_WARNING "snull: Can't change I/O address\n");
  72.         return -EOPNOTSUPP;
  73.     }

  75.     if (map->irq != dev->irq)
  76.     {
  77.         dev->irq = map->irq;
  78.     }

  80.     return 0;
  81. }

  83. void snull_rx(struct net_device *dev, int len, unsigned char *buf)
  84. {
  85.     struct sk_buff *skb;
  86.     struct snull_priv *priv = netdev_priv(dev);

  88.     skb = dev_alloc_skb(len+2);    //分配一个保存数据包的缓冲区
  89.     if (!skb)
  90.     {
  91.         printk("snull rx: low on mem - packet dropped\n");
  92.         priv->stats.rx_dropped++;
  93.         return;
  94.     }
  95.     skb_reserve(skb, 2);
  96.     memcpy(skb_put(skb, len), buf, len);    //skb_put函数刷新缓冲区内的数据末尾指针，并且返回新创建数据区的指针

  98.     skb->dev = dev;
  99.     skb->protocol = eth_type_trans(skb, dev);
  100.     skb->ip_summed = CHECKSUM_UNNECESSARY;
  101.     priv->stats.rx_packets++;
  102.     priv->stats.rx_bytes += len;
  103.     netif_rx(skb);    //将套接字缓冲区传递给上层软件处理

  105.     return;
  106. }

  108. void snull_interrupt(int irq, void *dev_id, struct pt_regs *regs)
  109. {
  110.     int statusword;
  111.     struct net_device *dev = (struct net_device *)dev_id;
  112.     struct snull_priv *priv = netdev_priv(dev);
  113.    
  114.     if (!dev)
  115.         return;

  117.     spin_lock(&priv->lock);
  118.     statusword = priv->status;
  119.     priv->status = 0;
  120.     if (statusword & SNULL_RX_INTR)
  121.     {
  122.         snull_rx(dev, priv->rx_packetlen, priv->rx_packetdata);
  123.     }
  124.     if (statusword & SNULL_TX_INTR)
  125.     {
  126.         priv->stats.tx_packets++;
  127.         priv->stats.tx_bytes += priv->tx_packetlen;
  128.         dev_kfree_skb(priv->skb);
  129.     }
  130.     spin_unlock(&priv->lock);

  132.     return;
  133. }

  135. void snull_hw_tx(char *buf, int len, struct net_device *dev)
  136. {
  137.     struct iphdr *ih;
  138.     struct net_device *dest;
  139.     struct snull_priv *priv = netdev_priv(dev);
  140.     u32 *saddr, *daddr;

  142.     if (len < sizeof(struct ethhdr) + sizeof(struct iphdr))
  143.     {
  144.         printk("snull: Hmm... packet too short (%i octets)\n",len);
  145.         return;
  146.     }
  147.  
  148.     ih = (struct iphdr *)(buf+sizeof(struct ethhdr));
  149.     saddr = &ih->saddr;
  150.     daddr = &ih->daddr;
  151.     ((u8 *)saddr)[2] ^= 1;
  152.     ((u8 *)daddr)[2] ^= 1;
  153.     ih->check = 0;
  154.     ih->check = ip_fast_csum((unsigned char *)ih,ih->ihl);

  156.     if (dev == snull_devs[0])
  157.         printk(KERN_INFO"%08x:%05i --> %08x:%05i\n",
  158.                ntohl(ih->saddr),ntohs(((struct tcphdr *)(ih+1))->source),
  159.                ntohl(ih->daddr),ntohs(((struct tcphdr *)(ih+1))->dest));
  160.     else
  161.         printk(KERN_INFO"%08x:%05i <-- %08x:%05i\n",
  162.                ntohl(ih->daddr),ntohs(((struct tcphdr *)(ih+1))->dest),
  163.                ntohl(ih->saddr),ntohs(((struct tcphdr *)(ih+1))->source));

  165.     dest = snull_devs[0] + (dev==snull_devs[0] ? 1 : 0);
  166.     priv->status = SNULL_RX_INTR;
  167.     priv->rx_packetlen = len;
  168.     priv->rx_packetdata = buf;
  169.     snull_interrupt(0, dest, NULL);

  171.     priv->status = SNULL_TX_INTR;
  172.     priv->tx_packetlen = len;
  173.     priv->tx_packetdata = buf;
  174.     if (lockup && ((priv->stats.tx_packets + 1) % lockup) == 0)
  175.     {
  176.         netif_stop_queue(dev);
  177.         printk(KERN_INFO"Simulate lockup at %ld, txp %ld\n", jiffies,(unsigned long) priv->stats.tx_packets);
  178.     }
  179.     else
  180.         snull_interrupt(0, dev, NULL);

  182.     return;
  183. }

  185. int snull_tx(struct sk_buff *skb, struct net_device *dev)
  186. {
  187.     int len;
  188.     char *data;
  189.     struct snull_priv *priv = netdev_priv(dev);

  191.     len = skb->len < ETH_ZLEN ? ETH_ZLEN : skb->len;    //当所需传输的数据包长度小于介质所支持的最小长度时，需要小心处理。
  192.     data = skb->data;
  193.     dev->trans_start = jiffies;
  194.     priv->skb = skb;

  196.     snull_hw_tx(data, len, dev);

  198.     return 0;
  199. }

  201. void snull_tx_timeout (struct net_device *dev)
  202. {
  203.     struct snull_priv *priv = netdev_priv(dev);
  204.     printk(KERN_INFO"Transmit timeout at %ld, latency %ld\n", jiffies,jiffies - dev->trans_start);

  206.     priv->status = SNULL_TX_INTR;
  207.     snull_interrupt(0, dev, NULL);
  208.     priv->stats.tx_errors++;
  209.     netif_wake_queue(dev);

  211.     return;
  212. }

  214. int snull_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
  215. {
  216.     return 0;
  217. }

  219. struct net_device_stats *snull_stats(struct net_device *dev)
  220. {
  221.     struct snull_priv *priv = netdev_priv(dev);

  223.     return &priv->stats;
  224. }

  226. int snull_rebuild_header(struct sk_buff *skb)
  227. {
  228.     struct ethhdr *eth = (struct ethhdr *) skb->data;
  229.     struct net_device *dev = skb->dev;
  230.     
  231.     memcpy(eth->h_source, dev->dev_addr, dev->addr_len);
  232.     memcpy(eth->h_dest, dev->dev_addr, dev->addr_len);
  233.     eth->h_dest[ETH_ALEN-1] ^= 0x01;

  235.     return 0;
  236. }

  238. int snull_header(struct sk_buff *skb, struct net_device *dev,
  239.                 unsigned short type, const void *daddr, const void *saddr,
  240.                 unsigned int len)
  241. {
  242.     struct ethhdr *eth = (struct ethhdr *)skb_push(skb,ETH_HLEN);

  244.     eth->h_proto = htons(type);
  245.     memcpy(eth->h_source, saddr ? saddr : dev->dev_addr, dev->addr_len);
  246.     memcpy(eth->h_dest, daddr ? daddr : dev->dev_addr, dev->addr_len);
  247.     eth->h_dest[ETH_ALEN-1] ^= 0x01;

  249.     return (dev->hard_header_len);
  250. }

  252. int snull_change_mtu(struct net_device *dev, int new_mtu)
  253. {
  254.     unsigned long flags;
  255.     struct snull_priv *priv = netdev_priv(dev);
  256.     spinlock_t *lock = &((struct snull_priv *)priv)->lock;

  258.     if ((new_mtu < 68) || (new_mtu > 1500))    //以太网的MTU是1500个octet（ETH_DATA_LEN）
  259.         return -EINVAL;
  260.   
  261.     spin_lock_irqsave(lock, flags);
  262.     dev->mtu = new_mtu;
  263.     spin_unlock_irqrestore(lock, flags);

  265.     return 0;
  266. }

  268. //以下两个结构是相关接口函数的初始化
  269. static const struct net_device_ops snull_dev_ops = {
  270.     .ndo_open = snull_open,
  271.     .ndo_stop = snull_release,
  272.     .ndo_set_config = snull_config,
  273.     .ndo_start_xmit = snull_tx,
  274.     .ndo_do_ioctl = snull_ioctl,
  275.     .ndo_get_stats = snull_stats,
  276.     .ndo_change_mtu = snull_change_mtu,
  277.     .ndo_tx_timeout = snull_tx_timeout,
  278. };

  280. static const struct header_ops snull_header_ops= {
  281.     .create    = snull_header,
  282.     .rebuild = snull_rebuild_header,
  283.     .cache = NULL,
  284. };

  286. void snull_init(struct net_device *dev)
  287. {
  288.     struct snull_priv *priv = NULL;

  290.     ether_setup(dev); //对某些成员作一些初始化
  291.     
  292.     dev->netdev_ops = &snull_dev_ops;
  293.     dev->header_ops = &snull_header_ops;
  294.     dev->watchdog_timeo = timeout;
  295.     dev->flags |= IFF_NOARP;    //禁止ARP
  296.       dev->features |= NETIF_F_NO_CSUM;

  298.     priv = netdev_priv(dev);    //priv是net_device中的一个成员，它与net_device一起被分配，当需要访问私有成员priv时使用该函数
  299.     memset(priv, 0, sizeof(struct snull_priv));
  300.     priv->dev = dev;
  301.     spin_lock_init(&((struct snull_priv *)priv)->lock);

  303.     return;
  304. }

  306. static __init int snull_init_module(void)
  307. {
  308.     int result, i, device_present = 0;

  310.     /*alloc_netdev用来动态分配struct net_device内核数据结构，第一个参数为驱动程序的“私有数据“，第二个是接口的名字，第三个是用来设置net_device结构的初始化函数。对于设备名称，如果驱动程序设置的名称中包含%d格式化字符串，register_netdev将使用一个数字代替它，使之成为唯一的名字，分配的编号从零开始。*/
  311.     snull_devs[0] = alloc_netdev(sizeof(struct snull_priv),"sn%d",snull_init);
  312.     snull_devs[1] = alloc_netdev(sizeof(struct snull_priv),"sn%d",snull_init);
  313.     if(snull_devs[0] == NULL || snull_devs[1] == NULL)
  314.         goto fail;

  316.     for (i=0;i<2;i++)
  317.     {
  318.         //注册设备，必须在初始化一切事情后再注册
  319.         if((result = register_netdev(snull_devs[i])))
  320.             printk("snull: error %i registering device \"%s\"\n",result, snull_devs[i]->name);
  321.         else
  322.             device_present++;
  323.     }

  325.   fail:
  326.     return device_present ? 0 : -ENODEV;
  327. }

  329. static __exit void snull_cleanup(void)
  330. {
  331.     int i;
  332.    
  333.     for (i=0; i<2;i++)
  334.     {
  335.         if(snull_devs[i])
  336.         {            
  337.             unregister_netdev(snull_devs[i]);    //从系统中删除接口
  338.             free_netdev(snull_devs[i]);    //将net_device结构返还给系统
  339.         }    
  340.     }
  341.     return;
  342. }


  345. module_init(snull_init_module);
  346. module_exit(snull_cleanup);

  348. MODULE_AUTHOR("txgcwm");
  349. MODULE_VERSION("snull_v1.0");
  350. MODULE_LICENSE("GPL");

Makefile
  1. ifneq ($(KERNELRELEASE),)
  2.     obj-m := snull.o
  3. else
  4.     KERNELDIR ?= /lib/modules/$(shell uname -r)/build
  5.     PWD := $(shell pwd)
  6. all:
  7.     make -C $(KERNELDIR) M=$(PWD) modules
  8. clean:
  9.     rm -f *.ko *.o *.mod.o *.mod.c *.symvers *.order
  10. endif

加载文件
  1. #!/bin/sh

  3. export PATH=/sbin:/bin

  5. # Use a pathname, as new modutils don't look in the current dir by default
  6. insmod ./snull.ko $*
  7. ifconfig sn0 local0
  8. ifconfig sn1 local1

  10. # The route commands are needed for 2.0, not for later kernels
  11. case "`uname -r`" in
  12.     2.0.*)
  13.         route add -net snullnet0 sn0
  14.         route add -net snullnet1 sn1
  15.         ;;
  16. esac

卸载文件
  1. #!/bin/sh

  3. /sbin/ifconfig sn0 down
  4. /sbin/ifconfig sn1 down
  5. /sbin/rmmod snull



附件：     snull.rar  
阅读(4605) | 评论(2) | 转发(1) |
0

上一篇：scull0字符设备驱动示例(参考《Linux设备驱动程序第三版》)

下一篇：移植gdbserver到嵌入式系统

给主人留下些什么吧！~~

雷锋不谢2014-10-13 19:52:44

博主，为何我在调试你的程序时候，ifconfig sn0 up 就死机了呢？

还有，在xxx_hw_tx函数中，在处理收包和发包的时候，那个dev和dest的priv你好像没有区分。

回复 | 举报

ninety_zhang2012-03-18 23:02:21

你好 ：
   请问，
    传输数据包函数 snull_tx， 在什么时候被调用。
      （我在测试的时候，ping命令没有调用 这个函数， 而是
      # ifconfig sn0 local0 调用了。
      ）
    为什么？求指导，谢谢！

回复 | 举报
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6