在 Linux 内核的之前的版本, 正式的睡眠要求程序员手动处理所有上面的步骤. 它是一 个繁琐的过程, 包含相当多的易出错的样板式的代码. 程序员如果愿意还是可能用那种方 式手动睡眠; <linux/sched.h> 包含了所有需要的定义, 以及围绕例子的内核源码. 但是, 有一个更容易的方式.
第一步是创建和初始化一个等待队列. 这常常由这个宏定义完成: DEFINE_WAIT(my_wait);
其中, name 是等待队列入口项的名子. 你可用 2 步来做:
wait_queue_t my_wait; init_wait(&my_wait);
但是常常更容易的做法是放一个 DEFINE_WAIT 行在循环的顶部, 来实现你的睡眠. 下一步是添加你的等待队列入口到队列, 并且设置进程状态. 2 个任务都由这个函数处理: void prepare_to_wait(wait_queue_head_t *queue, wait_queue_t *wait, int state);
这里, queue 和 wait 分别地是等待队列头和进程入口. state 是进程的新状态; 它应当 或者是 TASK_INTERRUPTIBLE(给可中断的睡眠, 这常常是你所要的)或者 TASK_UNINTERRUPTIBLE(给不可中断睡眠).
在调用 prepare_to_wait 之后, 进程可调用 schedule -- 在它已检查确认它仍然需要等 待之后. 一旦 schedule 返回, 就到了清理时间. 这个任务, 也, 被一个特殊的函数处理:
void finish_wait(wait_queue_head_t *queue, wait_queue_t *wait); 之后, 你的代码可测试它的状态并且看是否它需要再次等待.
我们早该需要一个例子了. 之前我们看了 给 scullpipe 的 read 方法, 它使用 wait_event. 同一个驱动中的 write 方法使用 prepare_to_wait 和 finish_wait 来实 现它的等待. 正常地, 你不会在一个驱动中象这样混用各种方法, 但是我们这样作是为了 能够展示 2 种处理睡眠的方式.
为完整起见, 首先, 我们看 write 方法本身:
/* How much space is free? */
static int spacefree(struct scull_pipe *dev)
{
if (dev->rp == dev->wp)
return dev->buffersize - 1;
return ((dev->rp + dev->buffersize - dev->wp) % dev->buffersize) - 1;
}
static ssize_t scull_p_write(struct file *filp, const char user *buf, size_t count,
loff_t *f_pos)
{
struct scull_pipe *dev = filp->private_data; int result;
if (down_interruptible(&dev->sem)) return -ERESTARTSYS;
/* Make sure there's space to write */ result = scull_getwritespace(dev, filp); if (result)
return result; /* scull_getwritespace called up(&dev->sem) */
/* ok, space is there, accept something */ count = min(count, (size_t)spacefree(dev)); if (dev->wp >= dev->rp)
count = min(count, (size_t)(dev->end - dev->wp)); /* to end-
of-buf */
else /* the write pointer has wrapped, fill up to rp-1 */ count = min(count, (size_t)(dev->rp - dev->wp - 1));
PDEBUG("Going to accept %li bytes to %p from %p ", (long)count, dev-
>wp, buf);
if (copy_from_user(dev->wp, buf, count))
{
up (&dev->sem); return -EFAULT;
}
dev->wp += count;
if (dev->wp == dev->end)
dev->wp = dev->buffer; /* wrapped */ up(&dev->sem);
/* finally, awake any reader */
wake_up_interruptible(&dev->inq); /* blocked in read() and select() */
/* and signal asynchronous readers, explained late in chapter 5 */ if (dev->async_queue)
kill_fasync(&dev->async_queue, SIGIO, POLL_IN); PDEBUG(""%s" did write %li bytes ",current->comm, (long)count); return count;
}
这个代码看来和 read 方法类似, 除了我们已经将睡眠代码放到了一个单独的函数, 称为 scull_getwritespace. 它的工作是确保在缓冲中有空间给新的数据, 睡眠直到有空间可 用. 一旦空间在, scull_p_write 可简单地拷贝用户的数据到那里, 调整指针, 并且唤醒 可能已经在等待读取数据的进程.
处理实际的睡眠的代码是:
/* Wait for space for writing; caller must hold device semaphore. On
* error the semaphore will be released before returning. */
static int scull_getwritespace(struct scull_pipe *dev, struct file *filp)
{
while (spacefree(dev) == 0)
{ /* full */
DEFINE_WAIT(wait);
up(&dev->sem);
if (filp->f_flags & O_NONBLOCK) return -EAGAIN;
PDEBUG(""%s" writing: going to sleep ",current->comm); prepare_to_wait(&dev->outq, &wait, TASK_INTERRUPTIBLE); if (spacefree(dev) == 0)
schedule(); finish_wait(&dev->outq, &wait); if (signal_pending(current))
handle it */
}
return -ERESTARTSYS; /* signal: tell the fs layer to
if (down_interruptible(&dev->sem)) return -ERESTARTSYS;
return 0;
}
再次注意 while 循环. 如果有空间可用而不必睡眠, 这个函数简单地返回. 否则, 它必 须丢掉设备旗标并且等待. 这个代码使用 DEFINE_WAIT 来设置一个等待队列入口并且 prepare_to_wait 来准备好实际的睡眠. 接着是对缓冲的必要的检查; 我们必须处理的情 况是在我们已经进入 while 循环后以及在我们将自己放入等待队列之前 (并且丢弃了旗 标), 缓冲中有空间可用了. 没有这个检查, 如果读进程能够在那时完全清空缓冲, 我们
可能错过我们能得到的唯一的唤醒并且永远睡眠. 在说服我们自己必须睡眠之后, 我们调 用 schedule.
值得再看看这个情况: 当睡眠发生在 if 语句测试和调用 schedule 之间, 会发生什么? 在这个情况里, 都好. 这个唤醒重置了进程状态为 TASK_RUNNING 并且 schedule 返回 -
- 尽管不必马上. 只要这个测试发生在进程放置自己到等待队列和改变它的状态之后, 事 情都会顺利.
为了结束, 我们调用 finish_wait. 对 signal_pending 的调用告诉我们是否我们被一个 信号唤醒; 如果是, 我们需要返回到用户并且使它们稍后再试. 否则, 我们请求旗标, 并 且再次照常测试空闲空间.