熟悉内核多线程和netlink的进来看看！

lihw_2002

帮忙看看下面的的模块代码，目的是想实现基于NETLINK的用户空间和内核空间的程序通信．
代码是参照网上东西写的，有一些地方还不太明白，先拿来用用．自己在调试的时候刚开始一插入模块就死机，后面通过修改后，能接收用户空间数据，但一调用发送就死机，大虾帮忙看看，谢谢啦！

struct
{
  __u32 pid;
  rwlock_t lock;
}user_proc;

static struct sock *netlink_sock_recv;
static struct sock *netlink_sock_send;
static int exit_flag = 0;

static DECLARE_COMPLETION(exit_completion);
static DECLARE_COMPLETION(send_completion);
static DECLARE_COMPLETION(sendp_completion);

static void recv_handler(struct sock * sk, int length){
        wake_up(sk->sk_sleep);
}
static int process_recv_thread(void * data){
        struct sk_buff * skb = NULL;
        struct nlmsghdr * nlhdr = NULL;
     DEFINE_WAIT(wait);
        daemonize("mynetlink");

        while (exit_flag == 0) {
                prepare_to_wait(netlink_sock_recv->sk_sleep, &wait, TASK_INTERRUPTIBLE);
                schedule();
                finish_wait(netlink_sock_recv->sk_sleep, &wait);
                while ((skb = skb_dequeue(&netlink_sock_recv->sk_receive_queue))
                         != NULL) {
                        nlhdr = (struct nlmsghdr *)skb->data;
                        if (nlhdr->nlmsg_len < sizeof(struct nlmsghdr)) {
                                printk("Corrupt netlink message.\n");
                                continue;
                        }
               packet=NLMSG_DATA(nlhdr);
            //PROCESS  DATA                    

   
                }
        }
        complete(&exit_completion);
        return 0;
}


static void send_handler(struct sock *sk, int len){
      wake_up(sk->sk_sleep);
}
static int process_send_thread(void *data){
    struct sk_buff * skb = NULL;
      struct nlmsghdr * nlhdr = NULL;
     DEFINE_WAIT(waits);
    daemonize("mynetlinksend");
   
    while (exit_flag == 0) {
        prepare_to_wait(netlink_sock_send->sk_sleep, &waits, TASK_INTERRUPTIBLE);
              schedule();
              finish_wait(netlink_sock_send->sk_sleep, &waits);
              while ((skb = skb_dequeue(&netlink_sock_send->sk_receive_queue))!= NULL) {
            nlhdr = (struct nlmsghdr *)skb->data;
                 if (nlhdr->nlmsg_len < sizeof(struct nlmsghdr)) {
                         printk("Corrupt netlink message.\n");
                        continue;
                      }
            //packet=NLMSG_DATA(nlhdr);

            if(nlhdr->nlmsg_type == ACC_U_PID)
              {
            write_lock_bh(&user_proc.lock);
            user_proc.pid = nlhdr->nlmsg_pid;
            write_unlock_bh(&user_proc.lock);
              }
            else if(nlhdr->nlmsg_type == ACC_CLOSE)
              {
            write_lock_bh(&user_proc.lock);
            if(nlhdr->nlmsg_pid == user_proc.pid)
              user_proc.pid = 0;
            write_unlock_bh(&user_proc.lock);
              }   
                }
        }
    complete(&send_completion);
    return 0;
}

static int send_to_user(struct info *info){
  int ret;
  int size;
  unsigned char *old_tail;
  struct sk_buff *skb;
  struct nlmsghdr *nlh;
  struct info *sinfo;
  size = NLMSG_SPACE(sizeof(*info));
  skb = alloc_skb(size, GFP_ATOMIC);
  old_tail = skb->tail;
  nlh = NLMSG_PUT(skb, 0, 0, ACC_K_MSG, size-sizeof(*nlh));
  sinfo= NLMSG_DATA(nlh);
  memset(sinfo, 0, sizeof(struct info));
    //填充sinfo

  nlh->nlmsg_len = skb->tail - old_tail;
  NETLINK_CB(skb).dst_group = 0;
  read_lock_bh(&user_proc.lock);
  ret = netlink_unicast(netlink_sock_send, skb, user_proc.pid, MSG_DONTWAIT);
  read_unlock_bh(&user_proc.lock);
  return ret;
nlmsg_failure:
  if(skb)
    kfree_skb(skb);
  return -1;
}

//周期性的向用户空间发送数据

static int send_thread(void *data){
    struct info sinfo;
    daemonize("mynetlinksend");
    schedule();
    while(exit_flag == 0){
        //填充sinfo?

        send_to_user(&sinfo);
        sleep(50000);
    }
     complete(&sendp_completion);
}
static int __init netlink_exam_init(void){
        netlink_sock_recv= netlink_kernel_create(NL_RECV, 0, recv_handler, THIS_MODULE);
        if (!netlink_sock_recv) {
                printk("Fail to create netlink socket.\n");
                return 1;
        }
    netlink_sock_send = netlink_kernel_create(NL_SEND, 0, send_handler, THIS_MODULE);
    if (!netlink_sock_send) {
                printk("Fail to create netlink socket.\n");
                return 1;
        }
        kernel_thread(process_recv_thread, NULL, CLONE_KERNEL);
     kernel_thread(process_send_thread, NULL, CLONE_KERNEL);
        kernel_thread(send_thread,NULL,CLONE_KERNEL);
        return 0;
}
static void __exit netlink_exam_exit(void){
        exit_flag = 1;
        wake_up(netlink_sock_recv->sk_sleep);
     wait_for_completion(&exit_completion);
        sock_release(netlink_sock_recv->sk_socket);
        wake_up(netlink_sock_send->sk_sleep);
     wait_for_completion(&send_completion);
        sock_release(netlink_sock_send->sk_socket);
    wait_for_completion(&sendp_completion);
}

[ 本帖最后由 lihw_2002 于 2008-2-28 14:12 编辑 ]

gaochang2008

你的这个这个问题我也遇到过，我怀疑可能是互斥锁的问题，，，
但是我没有在代码中发现bug，我就换了一个程序，，没有出现死锁的现象，用户可以发送和接受消息

我的内核发送消息用的是广播方式

qps104

process_send_thread()
没看懂做什么用的

lihw_2002

不是建立了两个netlink套接字吗,
process_recv_thread()
process_send_thread()
是用来接收两个套接字中信息的.
现在想了想,改成用一个套接字实现,用广播的方式发送,但能正常接收,不能发送,一调用发送就DOWN机.
如:
static int send_to_user(struct info *info){
      ……
    ret = netlink_broadcast(netlink_sock_send, skb, 0,1, MSG_DONTWAIT); //用广播的方式发送
     ……
}
static int send_thread(void *data){
    struct info sinfo;
    daemonize("mynetlinksend");
    while(exit_flag == 0){
        //-----每隔5分钟执行一次该循环
　　　//填充sinfo?
        send_to_user(&sinfo);
    }
     complete(&sendp_completion);
}

只要一调用send_to_user()就挂,不知道怎么会事.

[ 本帖最后由 lihw_2002 于 2008-3-4 10:18 编辑 ]

qps104

没有条件测试,可以试试把read_lock_bh和write_lock_bh改为read_lock和write_lock,前2个是用在bh中的.

canjian

我也遇到同样问题，一调用send_to_user就出问题，楼主解决没有？


我的问题已经解决，改用另外一个程序的写法。具体参见：
http://linux.chinaunix.net/bbs/thread-1012581-1-1.html

我改写的最终send_to_user如下：

1. 
   
2. static int send_to_user(char *info)
   
3. {
   
4. 
   
5.     int size;
   
6.     struct sk_buff *skb;
   
7.     struct nlmsghdr *nlh;  
   
8. 
   
9. 
   
10.     size = NLMSG_SPACE(PACKETSIZE);
    
11.     skb = alloc_skb(size, GFP_ATOMIC);
    
12.     memset(skb->data,0,size);
    
13. 
    
14.     nlh = (struct nlmsghdr*)skb->data ;
    
15. 
    
16.     skb_put(skb,sizeof(struct nlmsghdr)) ;
    
17.     nlh->nlmsg_len = NLMSG_SPACE(PACKETSIZE) ;
    
18.     nlh->nlmsg_pid = 0;
    
19.     nlh->nlmsg_flags = 0;
    
20. 
    
21.     skb_put(skb,strlen(info)) ;
    
22.     strcpy(NLMSG_DATA(nlh),info);
    
23.     nlh->nlmsg_len = skb->len ;
    
24.     NETLINK_CB(skb).groups = 0;
    
25.     NETLINK_CB(skb).pid = 0;
    
26.     NETLINK_CB(skb).dst_pid = user_proc.pid ;
    
27.     NETLINK_CB(skb).dst_groups = 0;
    
28. 
    
29.     err=netlink_unicast(nl_sk, skb, user_proc.pid , MSG_DONTWAIT);
    
30.     return err ;
    
31. }
    

复制代码

[ 本帖最后由 canjian 于 2008-6-25 10:20 编辑 ]