调用netif_rx()之前需要做什么

llhao86

我用dummy做模板，实现两个网卡驱动，分别为dummy_bs，dummy_ss。其中，dummy_bs接收到上层数据后直接转发给dummy_ss,dummy_ss收到dummy_bs数据后，将数据包中的skb->dev改为自己的dev，然后调用netif_rx()提交给上层。这样让上层认为该数据是由dummy_ss接收到的。同理，dummy_ss收到上层数据也是直接转发给dummy_bs。
实验环境：VMware+Ubuntu10.04
内核版本：2.6.32.59+drm33.24

1. static struct task_struct *task_bs_recv;//创建一个接收线程
   
2. static struct net_device *dev_dummy_bs;
   
3. #define WIMAX_BS 0
   
4. #define WIMAX_SS 1
   
5. 
   
6. extern int put_buff(struct sk_buff *skb, int identity);//接收函数
   
7. extern struct sk_buff *get_buff(int identity);//发送函数
   
8. static int numdummies = 1;
   
9. 
   
10. 
    
11. static netdev_tx_t dummy_xmit(struct sk_buff *skb, struct net_device *dev)
    
12. {
    
13.     int ret;
    
14.         //收到上层数据后，做如下处理
    
15.     skb_orphan(skb);
    
16.     skb->protocol = eth_type_trans(skb, dev);
    
17.     //处理完毕后，发送给dummy_ss
    
18.     ret = put_buff(skb, WIMAX_BS);
    
19.     if(0 == ret){
    
20.         dev->stats.tx_packets++;
    
21.         dev->stats.tx_bytes += skb->len;
    
22.     }else{
    
23.         dev->stats.tx_dropped++;
    
24.     }
    
25.     return NETDEV_TX_OK;
    
26. }
    
27. //接收函数，实现为线程，负责接收dummy_ss发送给dummy_bs的数据包
    
28. int bs_recv(void *data){
    
29.     int pkt_len;
    
30.     struct sk_buff *skb, *new;
    
31. 
    
32.     while(1){
    
33.         set_current_state(TASK_UNINTERRUPTIBLE);
    
34.                 if(kthread_should_stop()) break;
    
35.                 //取出dummy_ss发过来的数据
    
36.         skb = get_buff(WIMAX_BS);
    
37.         if(NULL != skb){
    
38.                         //因为是dummy_ss发送过来的数据包，所以skb->dev原先指的是dev_dummy_ss,在这里将其改为
    
39.                         //dev_dummy_bs，让上层认为该数据由dummy_bs接收并转发给上层
    
40.                         skb->dev = dev_dummy_bs;
    
41.             if(likely(netif_rx(new) == NET_RX_SUCCESS)){        
    
42.                 dev_dummy_bs->stats.rx_packets++;
    
43.                 dev_dummy_bs->stats.rx_bytes += skb->len;
    
44.             }else{
    
45.                 dev_dummy_bs->stats.rx_dropped++;
    
46.             }
    
47.         }
    
48. //        printk("bs_recv running!\n");
    
49.         schedule_timeout(1000);
    
50.     }
    
51. 
    
52.         return 0;
    
53. }
    
54. 
    
55. static const struct net_device_ops dummy_netdev_ops = {
    
56.     .ndo_start_xmit        = dummy_xmit,
    
57.     .ndo_validate_addr        = eth_validate_addr,
    
58.     .ndo_set_multicast_list     = set_multicast_list,
    
59.     .ndo_set_mac_address        = dummy_set_address,
    
60. };
    
61. 
    
62. static u32 always_on(struct net_device *dev)
    
63. {
    
64.     return 1;
    
65. }
    
66. 
    
67. static const struct ethtool_ops dummy_ethtool_ops = {
    
68.     .get_link        = always_on,
    
69.     .set_tso        = ethtool_op_set_tso,
    
70.     .get_tx_csum        = always_on,
    
71.     .get_sg        = always_on,
    
72.     .get_rx_csum        = always_on,
    
73. };
    
74. 
    
75. static void dummy_setup(struct net_device *dev)
    
76. {
    
77.     ether_setup(dev);
    
78. 
    
79.     /* Initialize the device structure. */
    
80.     dev->netdev_ops     = &dummy_netdev_ops;
    
81.     dev->ethtool_ops    = &dummy_ethtool_ops;
    
82.     //dev->header_ops    = &eth_header_ops;
    
83.     dev->destructor     = free_netdev;
    
84. 
    
85.     /* Fill in device structure with ethernet-generic values. */
    
86.     dev->tx_queue_len = 100;
    
87.     dev->flags |= IFF_NOARP;
    
88.     dev->flags |=IFF_PROMISC;
    
89.     dev->flags &= ~IFF_MULTICAST;
    
90. 
    
91.     random_ether_addr(dev->dev_addr);
    
92. 
    
93. }
    
94. static int dummy_validate(struct nlattr *tb[], struct nlattr *data[])
    
95. {
    
96.     if (tb[IFLA_ADDRESS]) {
    
97.         if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
    
98.             return -EINVAL;
    
99.         if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
    
100.             return -EADDRNOTAVAIL;
     
101.     }
     
102.     return 0;
     
103. }
     
104. 
     
105. static struct rtnl_link_ops dummy_link_ops __read_mostly = {
     
106.     .kind        = "dummy_bs",
     
107.     .setup        = dummy_setup,
     
108.     .validate    = dummy_validate,
     
109. };
     
110. 
     
111. /* Number of dummy devices to be set up by this module. */
     
112. module_param(numdummies, int, 0);
     
113. MODULE_PARM_DESC(numdummies, "Number of dummy_bs pseudo devices");
     
114. 
     
115. //设备初始化
     
116. static int __init dummy_init_one(void)
     
117. {
     
118.     struct net_device *dev_dummy;
     
119.     int err;
     
120. 
     
121.     dev_dummy = alloc_netdev(0, "dummy_bs%d", dummy_setup);
     
122.     if (!dev_dummy)
     
123.         return -ENOMEM;
     
124.     dev_dummy_bs = dev_dummy;
     
125.     err = dev_alloc_name(dev_dummy, dev_dummy->name);
     
126.     if (err < 0)
     
127.         goto err;
     
128.     //netif_start_queue(dev_dummy);
     
129. 
     
130.     dev_dummy->rtnl_link_ops = &dummy_link_ops;
     
131.     err = register_netdevice(dev_dummy);
     
132.     if (err < 0)
     
133.         goto err;
     
134.     return 0;
     
135. 
     
136. err:
     
137.     free_netdev(dev_dummy);
     
138.     return err;
     
139. }
     
140. 
     
141. static int __init dummy_init_module(void)
     
142. {
     
143.     int i, err = 0;
     
144.     //线程初始化
     
145.     task_bs_recv = kthread_create(bs_recv, NULL, "bs_recv_task");
     
146.     if(IS_ERR(task_bs_recv)){
     
147.         printk("Unable to start kernel thread.\n");
     
148.         err = PTR_ERR(task_bs_recv);
     
149.         task_bs_recv = NULL;
     
150.         return err;   
     
151.         }
     
152.     wake_up_process(task_bs_recv);
     
153. 
     
154.     rtnl_lock();
     
155.     err = __rtnl_link_register(&dummy_link_ops);
     
156. 
     
157.     for (i = 0; i < numdummies && !err; i++)
     
158.         err = dummy_init_one();
     
159.     if (err < 0)
     
160.         __rtnl_link_unregister(&dummy_link_ops);
     
161.     rtnl_unlock();
     
162. 
     
163.     return err;
     
164. }
     
165. 
     
166. static void __exit dummy_cleanup_module(void)
     
167. {
     
168.     rtnl_link_unregister(&dummy_link_ops);
     
169. 
     
170.     if(task_bs_recv){   
     
171.         kthread_stop(task_bs_recv);   
     
172.         task_bs_recv = NULL;   
     
173.     }   
     
174. }
     
175. 
     
176. module_init(dummy_init_module);
     
177. module_exit(dummy_cleanup_module);
     
178. MODULE_LICENSE("GPL");
     
179. MODULE_ALIAS_RTNL_LINK("dummy_bs");

复制代码

下图是静态路由设置：

下图是加载了dummy_bs和dummy_ss后的网络设备情况:


我用ping -c 5 192.168.4.155来做测试，下图是用tcpdump对dummy_bs0和dummy_ss0抓包的结果：


目前是tcpdump能抓到包，但是ping不通，不知道问题出在哪里。我自己觉得可能是在调用netif_rx()这里出错了，请问在调用netif_rx()之前还需要做些什么呢？？
请各位高手帮帮忙，看看到底哪里做错了，谢谢！

瀚海书香

回复 1# llhao86
在家没有测试环境，不过从代码上看，貌似问题不是很大。put_buff和get_buff的代码没有看到，不知道这里面lz是否正确的clone和free了skb。

   

llhao86

回复 2# 瀚海书香
谢谢你的回答。
put_buff只是简单的将skb挂到一个全局指针上，get_buff则是从全局指针中取出一个skb，在里面没有做clone和free操作，从tcpdump中可以看到，dummy_bs和dummy_ss都能收到数据包，因此，put_buff和get_buff应该是成功的将数据包传递过去了。至于你说的clone和free，不使用这些会有什么影响吗？？？

1. 
   
2. int put_buff(struct sk_buff *skb, int identity)//identity是标志位，用来判断是哪个模块在调用该函数
   
3. {
   
4.         if(WIMAX_BS == identity){//dummy_bs调用该函数
   
5.                 if(0 == down_trylock(&head_bstoss->sem)){//加锁
   
6.                         mybuff_list_add(head_bstoss, skb);//将skb挂到head_bstoss指针下，等待dummy_ss取出
   
7.                         up(&sem_bstoss);//增加一个skb，该信号量加1
   
8.                         up(&head_bstoss->sem);
   
9.                         return 0;
   
10.                 }else{
    
11.                         return 1;
    
12.                         }
    
13.                 }       
    
14. 
    
15.         if(WIMAX_SS == identity){//dummy_ss调用该函数
    
16.                 if(0 == down_trylock(&head_sstobs->sem)){
    
17.                         mybuff_list_add(head_sstobs, skb);
    
18.                         up(&sem_sstobs);
    
19.                         up(&head_sstobs->sem);
    
20.                         return 0;
    
21.                 }else{
    
22.                         return 1;
    
23.                         }
    
24.                 }
    
25.         return 1;
    
26. }
    
27. EXPORT_SYMBOL(put_buff);
    
28. 
    
29. struct sk_buff *get_buff(int identity)
    
30. {
    
31.         struct sk_buff *ret = NULL;
    
32.         if(WIMAX_SS == identity){//dummy_ss调用该函数
    
33.                 if(0 == down_trylock(&head_bstoss->sem)){//加锁
    
34.                         if(0 == down_trylock(&sem_bstoss)){//该信号量不为零，表明head_bstoss指针下挂有skb
    
35.                                 ret = mybuff_list_get(head_bstoss);//取出一个skb，返回该skb的指针
    
36.                         }else{
    
37.                                 ret = NULL;//信号量为零，则返回空值
    
38.                         }
    
39.                         up(&head_bstoss->sem);
    
40.                         return ret;
    
41.                 }else{
    
42.                         return ret;//加锁失败，返回空值
    
43.                         }
    
44.                 }
    
45. 
    
46.         if(WIMAX_BS == identity){//dummy_bs调用该函数
    
47.                 if(0 == down_trylock(&head_sstobs->sem)){
    
48.                         if(0 == down_trylock(&sem_sstobs)){
    
49.                                 ret = mybuff_list_get(head_sstobs);
    
50.                         }else{
    
51.                                 ret = NULL;
    
52.                         }
    
53.                         up(&head_sstobs->sem);
    
54.                         return ret;
    
55.                 }else{
    
56.                         return ret;
    
57.                         }
    
58.                 }
    
59.         return ret;
    
60. }
    
61. EXPORT_SYMBOL(get_buff);

复制代码

llhao86

回复 2# 瀚海书香
dummy.rar (581.57 KB, 下载次数: 29)

2012-05-04 09:54 上传

点击文件名下载附件

我把代码和脚本打包了，如果你有空的话，麻烦你帮我测试一下，不胜感激！