usb驱动引起kernel panic？

fuchuangbob

我现在不确定是不是usb驱动引起的，具体症状就是突然系统死机，没有任何打印，但usb　device通过LED灯显示出（单片机程序）运作正常。
以前驱动出现过这种情况，就是设备断线的时候，urb没有被取消，然后urb的callback调用有野指针，改过之后就好用了。
现在我通过主机发给usb device一些配置寄存器的命令，跑着跑着就死机不动了，可能搞kgdb来调试会有效，但是需要两台机器，一台烂机器跑虚拟机还跑不动。

可不可能是因为usb device硬件上的一些改变导致的死机？

1. struct usb_skel {
   
2.     char *              devname;
   
3.         struct usb_device *        udev;                        /* the usb device for this device */
   
4.         struct usb_interface *        interface;                /* the interface for this device */
   
5.         struct semaphore        limit_sem;                /* limiting the number of writes in progress */
   
6.     struct urb  *       rcv_urb_pool[DEFAULT_URBPOOL_SIZE]; /* urb pool */
   
7.         struct data_list    rcv_data_list;   /*recv data's buffer list*/
   
8.         __u8                        bulk_in_endpointAddr;        /* the address of the bulk in endpoint */
   
9.         __u8                        bulk_out_endpointAddr;        /* the address of the bulk out endpoint */
   
10.     int                            open_count;                /* count the number of openers */
    
11.     int                present;                /* this is 1 as long as the device is connected */
    
12.         struct kref                kref;
    
13.     struct mutex    io_mutex;                /* synchronize I/O with disconnect */
    
14.     wait_queue_head_t    outq;      /* read wait queue */
    
15.     unsigned   int  discard_count;  /* count the number of packets dicarded */
    
16.     unsigned   int  fail_count;     /* count the number of packets sent unsuccess */
    
17.     unsigned   int  sent_count;     /* count the number of packets sent */
    
18.     unsigned   int  bufferqueue_maxlength;
    
19.     unsigned   int  recv_count;     /* count the number of packets recieved*/
    
20. };

复制代码

probe函数里将urb pool初始化，open函数里填充提交urb，并在urb回调函数中循环提交。

1. static void skel_read_bulk_callback(struct urb *urb,struct pt_regs * r)
   
2. {
   
3.         struct usb_skel *dev;
   
4.     struct data_list_node *node;
   
5.     int retval;
   
6.        
   
7.         dev = (struct usb_skel *)urb->context;
   
8. 
   
9.         /* sync/async unlink faults aren't errors */
   
10.         if (urb->status)
    
11.         {
    
12.             dbg("%s - nonzero write bulk status received: %d",__FUNCTION__, urb->status);
    
13.             if(urb->status == -ENOENT ||
    
14.               urb->status == -ECONNRESET ||
    
15.               urb->status == -ESHUTDOWN)
    
16.                 {
    
17.             goto error;
    
18.                 }
    
19.                 else
    
20.                 {
    
21.                     goto out;
    
22.                 }
    
23.         }
    
24.     /* if the read was successful, push the data to readqueue */
    
25.    
    
26.     if( urb->actual_length > 0)
    
27.     {
    
28.         spin_lock(&dev->rcv_data_list.listlock);
    
29.         
    
30.         if(dev->rcv_data_list.enqueue <= 0)
    
31.             {
    
32.             struct list_head * ptr;
    
33.             struct data_list_node * entry;
    
34.             
    
35.                 ptr = dev->rcv_data_list.list.next;
    
36.             entry = list_entry(ptr,struct data_list_node,list);
    
37. 
    
38.             list_del(ptr);
    
39. 
    
40.                 kmem_cache_free(buffer_cache,entry->bulk_in_buffer);
    
41.             kmem_cache_free(listnode_cache,entry);
    
42. 
    
43.             ++ dev->rcv_data_list.enqueue;
    
44.             -- dev->rcv_data_list.dequeue;
    
45. 
    
46.             ++ dev->discard_count;
    
47.             }
    
48.         
    
49.         node = kmem_cache_alloc(listnode_cache, GFP_ATOMIC);
    
50. 
    
51.         if(node == NULL)
    
52.         {
    
53.             err("Out of memory");
    
54.             spin_unlock(&dev->rcv_data_list.listlock);
    
55.             kmem_cache_free(buffer_cache,urb->transfer_buffer);
    
56.             goto error;
    
57.         }
    
58.         node->list.prev = NULL;
    
59.         node->list.next = NULL;
    
60. 
    
61.         node->bulk_in_buffer = urb->transfer_buffer;
    
62.         node->bulk_in_size = urb->actual_length;
    
63.         
    
64.         list_add_tail(&node->list,&dev->rcv_data_list.list);
    
65. 
    
66.         if(dev->rcv_data_list.dequeue <= 0)
    
67.         {
    
68.             wake_up_interruptible(&dev->outq);  /*wake up read and poll*/
    
69.         }
    
70. 
    
71.         -- dev->rcv_data_list.enqueue;
    
72.         ++ dev->rcv_data_list.dequeue;
    
73. 
    
74.         ++ dev->recv_count;
    
75. 
    
76.         spin_unlock(&dev->rcv_data_list.listlock);
    
77. 
    
78.         urb->transfer_buffer = NULL;
    
79.         
    
80.         urb->transfer_buffer = kmem_cache_alloc(buffer_cache, GFP_ATOMIC);
    
81.         
    
82.         if(!urb->transfer_buffer)
    
83.             goto error;
    
84.     }
    
85. 
    
86. out:
    
87.     retval = usb_submit_urb(urb, GFP_ATOMIC);
    
88.     if (retval) {
    
89.         err("%s - failed submitting write urb, error %d", __FUNCTION__, retval);                   
    
90.         kmem_cache_free(buffer_cache,urb->transfer_buffer);
    
91.     }
    
92. error:
    
93.     return;
    
94. }

复制代码

release函数或是其它判别出设备unpresent的地方，将urb kill掉。
disconnect函数中free urb


代码由usb-skeleton改来
我以为在disconnect调用之前release必被先调用

fuchuangbob

不是panic，系统挂起，应该是死锁了
把urb pool大小改为1，一切都正常

我这里设置的是15，可能多了点

fuchuangbob

自旋锁的问题，去掉就不会挂起，但互斥不了了