10 select不返回问题，昨天未描述清楚

发布于 2021-05-26 08:47:31 浏览：1263 订阅该版

项目中使用pipe通道，两个fd，一个线程读pipe的数据，一个线程写pipe的数据，优先级读的高一些，写的线程100ms写一次，读的线程判了select，设置了超时3s退出（系统配置的是硬件时钟，软时钟没启动），系统运行一段时间后发现读线程的select不返回了，类似于在select里进入了死循环，看了内核的select.c poll.c pipe.c timer.c的代码，去官网搜了已知bug，这几个文件我更新到了最新，但是现象依然存在。现象出现时，我查看了这两线程都处于ready状态，但是运行计数都不在增加，现在就是没有排查思路了，麻烦大神指点一下可能出问题的地方，万分感谢。
自己有几个疑问：1.如果是超时出了问题，那么线程应该处于挂起才对，在poll_wait_out函数中设置定时器时先挂起线程。
```c
static int poll_wait_timeout(struct rt_poll_table *pt, int msec)
{
    rt_int32_t timeout;
    int ret = 0;
    struct rt_thread *thread;
    rt_base_t level;

thread = pt->polling_thread;

timeout = rt_tick_from_millisecond(msec);

level = rt_hw_interrupt_disable();

if (timeout != 0 && !pt->triggered)
    {
        rt_thread_suspend(thread);
        if (timeout > 0)
        {
            rt_timer_control(&(thread->thread_timer),
                             RT_TIMER_CTRL_SET_TIME,
                             &timeout);
            rt_timer_start(&(thread->thread_timer));
        }

rt_hw_interrupt_enable(level);

rt_schedule();

level = rt_hw_interrupt_disable();
    }

ret = !pt->triggered;
    rt_hw_interrupt_enable(level);

return ret;
}
```
2.在_poll_add函数中
```c
static void _poll_add(rt_wqueue_t *wq, rt_pollreq_t *req)
{
    struct rt_poll_table *pt;
    struct rt_poll_node *node;

node = (struct rt_poll_node *)rt_malloc(sizeof(struct rt_poll_node));
    if (node == RT_NULL)
        return;

pt = rt_container_of(req, struct rt_poll_table, req);

node->wqn.key = req->_key;
    rt_list_init(&(node->wqn.list));
    node->wqn.polling_thread = pt->polling_thread;
    node->wqn.wakeup = __wqueue_pollwake;
    node->next = pt->nodes;
    node->pt = pt;
    pt->nodes = node;
    rt_wqueue_add(wq, &node->wqn);
}
```
使用rt_malloc分配了堆内存，但是我去查看并未发现有释放堆的操作
```c
void rt_wqueue_wakeup(rt_wqueue_t *queue, void *key)
{
    rt_base_t level;
    register int need_schedule = 0;

rt_list_t *queue_list;
    struct rt_list_node *node;
    struct rt_wqueue_node *entry;

queue_list = &(queue->waiting_list);

level = rt_hw_interrupt_disable();
    /* set wakeup flag in the queue */
    queue->flag = RT_WQ_FLAG_WAKEUP;

if (!(rt_list_isempty(queue_list)))
    {
        for (node = queue_list->next; node != queue_list; node = node->next)
        {
            entry = rt_list_entry(node, struct rt_wqueue_node, list);
            if (entry->wakeup(entry, key) == 0)
            {
                rt_thread_resume(entry->polling_thread);
                need_schedule = 1;

rt_wqueue_remove(entry);
                break;
            }
        }
    }
    rt_hw_interrupt_enable(level);

if (need_schedule)
        rt_schedule();
}
```
```
void rt_wqueue_remove(struct rt_wqueue_node *node)
{
    rt_base_t level;

level = rt_hw_interrupt_disable();
    rt_list_remove(&(node->list));
    rt_hw_interrupt_enable(level);
}
```
```
rt_inline void rt_list_remove(rt_list_t *n)
{
    n->next->prev = n->prev;
    n->prev->next = n->next;

n->next = n->prev = n;
}
```