netlink问题，通讯当机

zengrui0342

同志们，这个是我修改的论坛前辈的代码。操作系统是redhat5.0，内核是2.6.18。

现在的情况是：
代码在没有通讯的时候内核态程序正常，获得的user_proc.pid为0，
运行用户态代码，则死机。

代码如下：

头文件：

1. 
   
2. #ifndef __IMP2_H__
   
3. #define __IMP2_H__
   
4. 
   
5. #define IMP2_U_PID   0
   
6. #define IMP2_K_MSG   1
   
7. #define IMP2_CLOSE   2
   
8. 
   
9. #define NL_IMP2      31
   
10. 
    
11. struct packet_info
    
12. {
    
13.   __u32 src;
    
14.   __u32 dest;
    
15.   unsigned char protocol;
    
16.   unsigned short tot_len;
    
17. };
    
18. 
    
19. #endif
    

复制代码

内核态代码：

1. #ifndef _KERNEL_
   
2. #define _KERNEL_
   
3. #endif
   
4. 
   
5. #ifndef MODULE
   
6. #define MODULE
   
7. #endif
   
8. 
   
9. #include <linux/module.h>
   
10. #include <linux/kernel.h>
    
11. #include <linux/init.h>
    
12. #include <linux/types.h>
    
13. #include <linux/netdevice.h>
    
14. #include <linux/skbuff.h>
    
15. #include <linux/netfilter_ipv4.h>
    
16. #include <linux/inet.h>
    
17. #include <linux/in.h>
    
18. #include <linux/ip.h>
    
19. #include <linux/netlink.h>
    
20. #include <linux/spinlock.h>
    
21. #include <asm/semaphore.h>
    
22. #include <net/sock.h>
    
23. #include "imp2.h"
    
24. 
    
25. DECLARE_MUTEX(receive_sem);
    
26. 
    
27. static struct sock *nlfd;
    
28. 
    
29. struct {
    
30.     __u32 pid;
    
31.     rwlock_t lock;
    
32. }user_proc;
    
33. #if 0
    
34. static void kernel_receive(struct sock *sk,int len)
    
35. {
    
36. //        do
    
37.         {
    
38.                 struct sk_buff *skb;
    
39.                 if(down_trylock(&receive_sem))
    
40.                         return;
    
41. //                while((skb = skb_dequeue(&sk->receive_queue)) != NULL)
    
42.                 {
    
43.                         {
    
44.                                 struct nlmsghdr *nlh = NULL;
    
45.                                 if(skb->len >= sizeof(struct nlmsghdr))
    
46.                                 {
    
47.                                         nlh = (struct nlmsghdr *)skb->data;
    
48.                                         if((nlh ->nlmsg_len >= sizeof(struct nlmsghdr)) && (skb->len >= nlh->nlmsg_len))
    
49.                                         {
    
50.                                                 if(nlh->nlmsg_type == IMP2_U_PID)
    
51.                                                 {
    
52.                                                         write_lock_bh(&user_proc.pid);
    
53.                                                         if(nlh ->nlmsg_pid == user_proc.pid)
    
54.                                                         {
    
55.                                                                 user_proc.pid = 0;       
    
56.                                                         }
    
57.                                                         write_unlock_bh(&user_proc.pid);
    
58.                                                 }
    
59.                                         }
    
60.                                 }
    
61.                         }       
    
62.                         kfree_skb(skb);
    
63.                 }
    
64.                 up(&receive_sem)
    
65. //        }while(nlfd && nlfd->receive_queue.qlen);
    
66. }
    
67. #endif
    
68. #if 1
    
69. 
    
70. static void kernel_receive(struct sock *sk,int len)
    
71. {
    
72. 
    
73.         struct sk_buff *skb = NULL;
    
74. #if 1
    
75.     struct nlmsghdr *nlh = NULL;
    
76.     //printk("%s: skb->user: %d\n", __func__, atomic_read(&skb->users)); return;
    
77.     if(down_trylock(&receive_sem))
    
78.         return;
    
79. 
    
80.     if(skb->len < sizeof(struct nlmsghdr))
    
81.     goto out;
    
82. 
    
83. //    nlh = nlmsg_hdr(skb);
    
84.         nlh =  (struct nlmsghdr *)skb->data;
    
85. 
    
86.     if((nlh->nlmsg_len >= sizeof(struct nlmsghdr))
    
87.             && (skb->len >= nlh->nlmsg_len))
    
88.     {
    
89.                 printk("--------::::::::----------------");
    
90.         if(nlh->nlmsg_type == IMP2_U_PID)
    
91.         {
    
92.             write_lock_bh(&user_proc.lock);
    
93.             user_proc.pid = nlh->nlmsg_pid;
    
94.                         printk("::::::user_proc.pid= %d\n",user_proc.pid);
    
95.             write_unlock_bh(&user_proc.lock);
    
96.         }
    
97.         else if(nlh->nlmsg_type == IMP2_CLOSE)
    
98.         {
    
99.             write_lock_bh(&user_proc.lock);
    
100.             if(nlh->nlmsg_pid == user_proc.pid)
     
101.                 user_proc.pid = 0;
     
102.             write_unlock_bh(&user_proc.lock);
     
103.         }
     
104.     }
     
105. 
     
106.     //kfree_skb(skb);
     
107.     out:
     
108.         up(&receive_sem);
     
109. #endif
     
110. }
     
111. #endif
     
112. static int send_to_user(struct packet_info *info)
     
113. {
     
114.     int ret;
     
115.     int size;
     
116.     unsigned char *old_tail;
     
117.     struct sk_buff *skb;
     
118.     struct nlmsghdr *nlh;
     
119.     struct packet_info *packet;
     
120. 
     
121.     size = NLMSG_SPACE(sizeof(*info));
     
122. 
     
123.     skb = alloc_skb(size, GFP_ATOMIC);
     
124.     old_tail = skb->tail;
     
125. 
     
126.     nlh = NLMSG_PUT(skb, 0, 0, IMP2_K_MSG, size-sizeof(*nlh));
     
127.     packet = NLMSG_DATA(nlh);
     
128.     memset(packet, 0, sizeof(struct packet_info));
     
129. 
     
130.     packet->src = info->src;
     
131.     packet->dest = info->dest;
     
132.     packet->protocol = info->protocol;
     
133.     packet->tot_len = info->tot_len;
     
134. 
     
135.     nlh->nlmsg_len = skb->tail - old_tail;
     
136.    
     
137.         NETLINK_CB(skb).pid = 0;
     
138.         NETLINK_CB(skb).dst_group = 0;
     
139.        
     
140.     read_lock_bh(&user_proc.lock);
     
141.     ret = netlink_unicast(nlfd, skb, user_proc.pid, MSG_DONTWAIT);
     
142.     read_unlock_bh(&user_proc.lock);
     
143. 
     
144.     return ret;
     
145. 
     
146. nlmsg_failure:
     
147.     if(skb)
     
148.         kfree_skb(skb);
     
149.     return -1;
     
150. }
     
151. 
     
152. static unsigned int get_icmp(unsigned int hook,
     
153.         struct sk_buff **pskb,
     
154.         const struct net_device *in,
     
155.         const struct net_device *out,
     
156.         int (*okfn)(struct sk_buff *))
     
157. {
     
158.     printk("%s\n", __func__);
     
159. 
     
160.         //struct sk_buff *sb = *pskb;
     
161.         struct iphdr *ip = (*pskb)->nh.iph;
     
162.     struct packet_info info;
     
163. 
     
164.         //ip = sb->nh.iph;
     
165.         switch(ip->protocol)
     
166.                         {
     
167.                                 case 89:
     
168.                                         printk("::OSPF::\n");
     
169.                                         break;
     
170.                                 case 1:
     
171.                                         printk("::ICMP::\n");
     
172.                                         break;
     
173.                                 case 2:
     
174.                                         printk("::IGMP::\n");
     
175.                                         break;
     
176.                                 case 6:
     
177.                                         printk("::TCP::\n");
     
178.                                         break;
     
179.                                 case 17:
     
180.                                         printk("::UDP::\n");
     
181.                                         break;
     
182.                         }
     
183.                 printk(" [ %d ]\n ",ip->tot_len );
     
184.         
     
185.                 read_lock_bh(&user_proc.lock);
     
186.                 printk("_____:::pid_2::%d\n",user_proc.pid );
     
187.         if(user_proc.pid != 0)
     
188.                 {
     
189.            read_unlock_bh(&user_proc.lock);
     
190.             info.src = ip->saddr;
     
191.             info.dest = ip->daddr;
     
192.                         info.tot_len = ip->tot_len;
     
193.             info.protocol = ip->protocol;
     
194.             printk("before send\n");
     
195.             send_to_user(&info);
     
196.             printk("after send\n");
     
197.         }
     
198.        else
     
199.                 {
     
200.                         read_unlock_bh(&user_proc.lock);
     
201.                 }
     
202.        
     
203.         printk("-------------------send to user end-----------");
     
204.     return NF_ACCEPT;
     
205. }
     
206. 
     
207. static struct nf_hook_ops imp2_ops =
     
208. {
     
209.     .hook = get_icmp,
     
210.     .pf = PF_INET,
     
211.     .hooknum =NF_IP_PRE_ROUTING,
     
212.     .priority = NF_IP_PRI_FIRST,
     
213. };
     
214. 
     
215. static int __init init(void)
     
216. {
     
217.           rwlock_init(&user_proc.lock);
     
218. 
     
219.     //nlfd = netlink_kernel_create(NL_IMP2, kernel_receive);
     
220.     //nlfd = netlink_kernel_create(NL_IMP2, 0, 0,THIS_MODULE);
     
221.         printk("------------------------------------------------create----------\n");
     
222.     nlfd = netlink_kernel_create(NL_IMP2, 0, kernel_receive,THIS_MODULE);
     
223.         printk("---create----end------!!!\n");
     
224.         //nlfd = netlink_kernel_create(&init_net, NL_IMP2, 0, kernel_receive, NULL, THIS_MODULE);
     
225. 
     
226.     if(!nlfd) {
     
227.         printk("can not create a netlink socket\n");
     
228.         return -1;
     
229.     }
     
230.     return nf_register_hook(&imp2_ops);
     
231. }
     
232. 
     
233. static void __exit fini(void)
     
234. {
     
235.     if(nlfd) {
     
236.         sock_release(nlfd->sk_socket);
     
237.     }
     
238.     nf_unregister_hook(&imp2_ops);
     
239. }
     
240. 
     
241. module_init(init);
     
242. module_exit(fini);
     

复制代码

用户态代码：

1. #include <unistd.h>
   
2. #include <stdio.h>
   
3. #include <string.h>
   
4. #include <sys/socket.h>
   
5. #include <arpa/inet.h>
   
6. #include <asm/types.h>
   
7. #include <linux/netlink.h>
   
8. #include <signal.h>
   
9. #include "imp2.h"
   
10. 
    
11. struct msg_to_kernel
    
12. {
    
13.   struct nlmsghdr hdr;
    
14. };
    
15. 
    
16. struct u_packet_info
    
17. {
    
18.   struct nlmsghdr hdr;
    
19.   struct packet_info icmp_info;
    
20. };
    
21. 
    
22. static int skfd;
    
23. 
    
24. static void sig_int(int signo)
    
25. {
    
26.   struct sockaddr_nl kpeer;
    
27.   struct msg_to_kernel message;
    
28. 
    
29.   memset(&kpeer, 0, sizeof(kpeer));
    
30.   kpeer.nl_family = AF_NETLINK;
    
31.   kpeer.nl_pid    = 0;
    
32.   kpeer.nl_groups = 0;
    
33. 
    
34.   memset(&message, 0, sizeof(message));
    
35.   message.hdr.nlmsg_len = NLMSG_LENGTH(0);
    
36.   message.hdr.nlmsg_flags = 0;
    
37.   message.hdr.nlmsg_type = IMP2_CLOSE;
    
38.   message.hdr.nlmsg_pid = getpid();
    
39. 
    
40.   sendto(skfd, &message, message.hdr.nlmsg_len, 0, (struct sockaddr *)(&kpeer),sizeof(kpeer));
    
41. 
    
42.   close(skfd);
    
43.   exit(0);
    
44. }
    
45. 
    
46. int main(void)
    
47. {
    
48.   struct sockaddr_nl local;
    
49.   struct sockaddr_nl kpeer;
    
50.   int kpeerlen;
    
51.   struct msg_to_kernel message;
    
52.   struct u_packet_info info;
    
53.   int sendlen = 0;
    
54.   int rcvlen = 0;
    
55.     struct in_addr addr;
    
56.     int count = 0;
    
57. 
    
58.     skfd = socket(PF_NETLINK, SOCK_RAW, NL_IMP2);
    
59.     if(skfd < 0)
    
60.     {
    
61.         printf("can not create a netlink socket\n");
    
62.         exit(0);
    
63.     }
    
64. 
    
65.     memset(&local, 0, sizeof(local));
    
66.     local.nl_family = AF_NETLINK;
    
67.     local.nl_pid = getpid();
    
68.     local.nl_groups = 0;
    
69.     if(bind(skfd, (struct sockaddr*)&local, sizeof(local)) != 0)
    
70.     {
    
71.         printf("bind() error\n");
    
72.         return -1;
    
73.     }
    
74. #if 1
    
75.     signal(SIGINT, sig_int);
    
76. 
    
77.     memset(&kpeer, 0, sizeof(kpeer));
    
78.     kpeer.nl_family = AF_NETLINK;
    
79.     kpeer.nl_pid = 0;
    
80.     kpeer.nl_groups = 0;
    
81. 
    
82.     memset(&message, 0, sizeof(message));
    
83.     message.hdr.nlmsg_len = NLMSG_LENGTH(0);
    
84.     message.hdr.nlmsg_flags = 0;
    
85.     message.hdr.nlmsg_type = IMP2_U_PID;
    
86.     message.hdr.nlmsg_pid = local.nl_pid;
    
87. 
    
88.     sendto(skfd, &message, message.hdr.nlmsg_len, 0,
    
89.          (struct sockaddr*)&kpeer, sizeof(kpeer));
    
90. #endif
    
91.    printf("RUN");
    
92.     while(1)
    
93.     {
    
94.         kpeerlen = sizeof(struct sockaddr_nl);
    
95.         rcvlen = recvfrom(skfd, &info, sizeof(struct u_packet_info),
    
96.                         0, (struct sockaddr*)&kpeer, &kpeerlen);
    
97.         if(rcvlen > 0)
    
98.         {
    
99.             ++count;
    
100.         }
     
101.         printf("------------------------------\n");
     
102.         printf("receive packet :: %d ",count);
     
103.         addr.s_addr = info.icmp_info.src;
     
104.         printf(" src: %s, ", inet_ntoa(addr));
     
105.         addr.s_addr = info.icmp_info.protocol;
     
106.   //    printf(" Packet:%s",addr.s_addr);
     
107.         if(addr.s_addr == 6)
     
108.         {
     
109.             printf("TCP");
     
110.         }
     
111.         else if(addr.s_addr == 17)
     
112.         {
     
113.             printf("UDP");
     
114.         }
     
115.         else if(addr.s_addr == 1)
     
116.         {
     
117.             printf("ICMP");
     
118.         }
     
119.         else if(addr.s_addr == 2)
     
120.         {
     
121.             printf("IGMP");
     
122.         }
     
123.         else printf("unkown");
     
124.         addr.s_addr = info.icmp_info.dest;
     
125.         printf(" dest: %s\n", inet_ntoa(addr));
     
126.         addr.s_addr = info.icmp_info.tot_len;
     
127.         printf("::%d::",addr.s_addr);
     
128.         printf("-----------------------------\n");
     
129.         
     
130.     }
     
131. 
     
132.     return 0;
     
133. }
     

复制代码

另，驱动程序的调试方法大家能给我指导下否？
相关的比较好的书籍或者帖子。

[ 本帖最后由 zengrui0342 于 2008-9-19 15:32 编辑 ]

flw2

write_lock_bh(&user_proc.pid);

http://linux.chinaunix.net/bbs/viewthread.php?tid=1015818
不过改后的版本可能需要更高的版本

zengrui0342

对，谢谢关注，

这个就是按照那个帖子里面改的。

原版本在我的ubuntu8.04上完全可以运行。

但我们的服务器（产品环境）是RED HAT 5.0

内核版本为2.6.18。



分析问题得到：

内核程序在用户态程序没运行的时候

user_proc.pid ==0
也就是说没有运行sedtouser函数。

运行用户态代码后。
其会向内核态程序发送数据。

这个时候，直接死机。

内核态的接收处理函数和发送给用户态数据的函数都有问题的嫌疑。

zengrui0342

thx

我先改下。

zengrui0342

结果还是一样。。。
:em12: :em12: :em12:

zengrui0342

。。。。


能给点解决问题的建议么？

zengrui0342

BUG报告。。

牛人帮我看看，问题出在哪里？

zengrui0342

总算 解决了

用啦最笨的方法。

将关键函数一个一个注释。

最后发现是发送
  signal(SIGINT, sig_int);

    memset(&kpeer, 0, sizeof(kpeer));
    kpeer.nl_family = AF_NETLINK;
    kpeer.nl_pid = 0;
    kpeer.nl_groups = 0;

    memset(&message, 0, sizeof(message));
    message.hdr.nlmsg_len = NLMSG_LENGTH(0);
    message.hdr.nlmsg_flags = 0;
    message.hdr.nlmsg_type = IMP2_U_PID;
    message.hdr.nlmsg_pid = local.nl_pid;

    sendto(skfd, &message, message.hdr.nlmsg_len, 0,
         (struct sockaddr*)&kpeer, sizeof(kpeer));
的
    kpeer.nl_pid = 0
应设置成getpid()

罪过罪过。

zengrui0342

...

死机问题没啦。
不过好像就通讯一次。。

用户程序打开。显示内核给他发的信息，不过信息本身有问题。

而且没再继续发送。。

zengrui0342

很郁闷。

做的徒劳功。

改成pid就将处理进程变成自己了。。

所以还是不对