linux 手动睡眠

在 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\n", (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\n",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\n",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 的调用告诉我们是否我们被一个 信号唤醒; 如果是, 我们需要返回到用户并且使它们稍后再试. 否则, 我们请求旗标, 并 且再次照常测试空闲空间.