如果有人让你做你一时做不到的事情你会怎么办呢？如果你是个人被另一个人打扰，你唯一可以做的就是对他说：“现在不行，我很忙，走开！”但是如果你是内核模块，
被进程打扰，你就有另一种选择。你可以让这个进程去挂起直到你可以为之提供服务。毕竟，进程是在不停的被内核挂起或唤醒（这就是多个进程看上去同时在一个
处理器上运行的方法）。
这个内核模块就是一个这样的例子。这个文件（称作/proc/sleep）在一个时刻只能被一个进程打开。如果这个文件已经被打开，内核模块就调用 interruptible_sleep_on。
这个函数把任务（一个任务是一个内核数据结构，它包含进程以及它所在系统调用的信息）的状态改变成 TASK_INTERRUPTIBLE，表示直到被唤醒任务不会运行，
并且把它加入到 WaitQ— — 等待访问文件的任务队列。那么，这个函数调用调度器进行上下文切换到其他要使用 CPU 的进程。
当进程完成对文件的处理后，关闭该文件并且调用 module_ close。这个函数唤醒所有队列中的进程（还没有一个机制唤醒其中一个）。
然后返回，刚才关闭文件的进程可以继续运行。调度器及时决定哪个进程已经完成，并且把 CPU 的控制给另一个进程。
同时，队列中的某个进程将会从调度器那里得到对 CPU 的控制。
它正在对 interruptible_sleep_on 的调用后开始。然后它可以设置一个全局变量告诉别的进程这个文件还打开着，正在继续它的生命。
当别的进程有得到 CPU 的机会时，它们会看到这个全局变量，然后就重新挂起。
为使生命更加精彩，module_close 并没有对唤醒等待访问文件的进程进行垄断。一个象Ctrl-C（SIGINT）之类的信号同样可以唤醒进程。在这种情况下，
我们希望立即返回-EINTR。这是很重要的，比如用户可以在进程接到文件前杀死进程。
还有一点需要记住。有些时候进程不希望被挂起，它们希望立刻得到它们要的东西，或者被告知不能做到。这样的进程在打开文件时使用 O_NONBLOCK 标志。
内核在遇到其他方面的挂起进程的操作（比如本例中的打开文件）时要返回一个错误码-ERROR 作为回应。
程序 cat_noblock 就可以用来使用标志 O_NONBLOCK 打开文件，它可以在本章源程序目录中找到。
以下是根据linux内核编程修改后的代码：sleep.c
/* sleep.c - create a /proc file, and if several
* processes try to open it at the same time, put all
* but one to sleep */
/* Copyright (C) 1998-99 by Ori Pomerantz */
/* The necessary header files */
/* Standard in kernel modules */
#include <linux/module.h> /* Specifically, a module */
/* Necessary because we use proc fs */
#include <linux/proc_fs.h>
/* For putting processes to sleep and waking them up */
#include <linux/sched.h>
#include <asm/uaccess.h> /* for get_user and put_user */
static struct proc_dir_entry *proc_entry;
/* The module's file functions ********************** */
/* Here we keep the last message received, to prove
* that we can process our input */
#define MESSAGE_LENGTH 80
static char Message[MESSAGE_LENGTH];
/* Since we use the file operations struct, we can't use
* the special proc output provisions - we have to use
* a standard read function, which is this function */
static ssize_t module_output(
struct file *file, /* The file read */
char *buf, /* The buffer to put data to (in the* user segment) */
size_t len, /* The length of the buffer */
loff_t *offset) /* Offset in the file - ignore */
{
static int finished = 0;
int i;
char message[MESSAGE_LENGTH+30];
/* Return 0 to signify end of file - that we have
* nothing more to say at this point. */
if (finished) {
finished = 0;
return 0;
}
/* If you don't understand this by now, you're
* hopeless as a kernel programmer. */
sprintf(message, "Last input:%s\n", Message);
for(i=0; i<len && message[i]; i++)
put_user(message[i], buf+i);
finished = 1;
return i; /* Return the number of bytes "read" */
}
/* This function receives input from the user when
* the user writes to the /proc file. */
static ssize_t module_input(
struct file *file, /* The file itself */
const char *buf, /* The buffer with input */
size_t length, /* The buffer's length */
loff_t *offset) /* offset to file - ignore */
{
int i;
/* Put the input into Message, where module_output
* will later be able to use it */
for(i=0; i<MESSAGE_LENGTH-1 && i<length; i++)
get_user(Message[i], buf+i);
/* we want a standard, zero terminated string */
Message[i] = '\0';
/* We need to return the number of input
* characters used */
return i;
}
/* 1 if the file is currently open by somebody */
int Already_Open = 0;
/* Queue of processes who want our file */
static wait_queue_head_t WaitQ ;
/* Called when the /proc file is opened */
static int module_open(struct inode *inode,
struct file *file)
{
/* If the file's flags include O_NONBLOCK, it means
* the process doesn't want to wait for the file.
* In this case, if the file is already open, we
* should fail with -EAGAIN, meaning "you'll have to
* try again", instead of blocking a process which
* would rather stay awake. */
if ((file->f_flags & O_NONBLOCK) && Already_Open)
return -EAGAIN;
/* If the file is already open, wait until it isn't */
while (Already_Open)
{
/* This function puts the current process,
* including any system calls, such as us, to sleep.
* Execution will be resumed right after the function
* call, either because somebody called
* wake_up(&WaitQ) (only module_close does that,
* when the file is closed) or when a signal, such
* as Ctrl-C, is sent to the process */
interruptible_sleep_on(&WaitQ);
/* If we woke up because we got a signal we're not
* blocking, return -EINTR (fail the system call).
* This allows processes to be killed or stopped. */
}
/* If we got here, Already_Open must be zero */
/* Open the file */
Already_Open = 1;
return 0; /* Allow the access */
}
/* Called when the /proc file is closed */
int module_close(struct inode *inode, struct file *file)
{
/* Set Already_Open to zero, so one of the processes
* in the WaitQ will be able to set Already_Open back
* to one and to open the file. All the other processes
* will be called when Already_Open is back to one, so
* they'll go back to sleep. */
Already_Open = 0;
/* Wake up all the processes in WaitQ, so if anybody
* is waiting for the file, they can have it. */
wake_up_interruptible(&WaitQ);
return 0; /* success */
}
/* This function decides whether to allow an operation
* (return zero) or not allow it (return a non-zero
* which indicates why it is not allowed).
*
* 经过测试发现权限代码如下所示(跟原代码有所不一样）:
* 0x21 - Execute (run the "file" - meaningless in our case)
* 0x22 - Write (input to the kernel module)
* 0x24 - Read (output from the kernel module)
*
* This is the real function that checks file
* permissions. The permissions returned by ls -l are
* for referece only, and can be overridden here.
*/
static int module_permission(struct inode *inode, int op)
{
/* We allow everybody to read from our module, but
* only root (uid 0) may write to it */
if (op == 0x24 || (op == 0x22 && current->cred->euid == 0))
return 0;
/* If it's anything else, access is denied */
return -EACCES;
}
/* Structures to register as the /proc file, with
* pointers to all the relevant functions. *********** */
/* File operations for our proc file. This is where
* we place pointers to all the functions called when
* somebody tries to do something to our file. NULL
* means we don't want to deal with something. */
static struct file_operations File_Ops_4_Our_Proc_File =
{
.owner = THIS_MODULE, /* owner */
.read = module_output, /* "read" from the file */
.write = module_input, /* "write" to the file */
.open = module_open, /* called when the /proc file is opened */
.release = module_close /* called when it's classed */
};
/* Inode operations for our proc file. We need it so
* we'll have somewhere to specify the file operations
* structure we want to use, and the function we use for
* permissions. It's also possible to specify functions
* to be called for anything else which could be done to an
* inode (although we don't bother, we just put NULL). */
static struct inode_operations Inode_Ops_4_Our_Proc_File =
{
.permission = module_permission /* check for permissions */
};
/* Module initialization and cleanup **************** */
/* Initialize the module - register the proc file */
int init_proc_module()
{
init_waitqueue_head(&WaitQ);
proc_entry = create_proc_entry("sleep",S_IFREG | S_IRUGO | S_IWUSR,NULL);
if(proc_entry == NULL){
printk(KERN_INFO "Could not create proc entry\n");
goto err;
}else{
proc_entry->proc_fops = & File_Ops_4_Our_Proc_File;
proc_entry->proc_iops = &Inode_Ops_4_Our_Proc_File;
}
return 0;
err:
return -ENOMEM;
}
/* Cleanup - unregister our file from /proc. This could
* get dangerous if there are still processes waiting in
* WaitQ, because they are inside our open function,
* which will get unloaded. I'll explain how to avoid
* removal of a kernel module in such a case in
* chapter 10. */
void cleanup_proc_module()
{
remove_proc_entry("sleep",proc_entry );
}
module_init(init_proc_module);
module_exit(cleanup_proc_module);
MODULE_AUTHOR("Modified by gudujian");
MODULE_LICENSE("Dual BSD/GPL");
用以前提到的脚本编译内核，得到sleep.ko .
下面是用户空间测试程序 cat_noblock.c
/* cat_noblock.c - open a file and display its contents, but exit rather than
* wait for input */
/* Copyright (C) 1998 by Ori Pomerantz */
#include <stdio.h> /* standard I/O */
#include <fcntl.h> /* for open */
#include <unistd.h> /* for read */
#include <stdlib.h> /* for exit */
#include <errno.h> /* for errno */
#define MAX_BYTES 1024*4
main(int argc, char *argv[])
{
int fd; /* The file descriptor for the file to read */
size_t bytes; /* The number of bytes read */
char buffer[MAX_BYTES]; /* The buffer for the bytes */
/* Usage */
if (argc != 2) {
printf("Usage: %s <filename>\n", argv[0]);
puts("Reads the content of a file, but doesn't wait for input");
exit(-1);
}
/* Open the file for reading in non blocking mode */
fd = open(argv[1], O_RDONLY | O_NONBLOCK); ///
/* If open failed */
if (fd == -1) {
if (errno = EAGAIN)
puts("Open would block");
else
puts("Open failed");
exit(-1);
}
sleep(3);
/* Read the file and output its contents */
do {
int i;
/* Read characters from the file */
bytes = read(fd, buffer, MAX_BYTES);
/* If there's an error, report it and die */
if (bytes == -1) {
if (errno = EAGAIN)
puts("Normally I'd block, but you told me not to");
else
puts("Another read error");
exit(-1);
}
/* Print the characters */
if (bytes > 0) {
for(i=0; i<bytes; i++)
putchar(buffer[i]);
}
/* While there are no errors and the file isn't over */
} while (bytes > 0);
}
编译脚本：
gcc -o noblock cat_noblock.c
得到文件 noblock。
使用这个文件来测试内核空间程序。