发信人: arira(大天使)
整理人: qiaoqian(2001-12-31 00:01:56), 站内信件
|
主题：《Linux内核模块编程指南》(九)
发信人: kevintz()
整理人: kevintz(2000-06-24 00:42:20), 站内信件
《Linux内核模块编程指南》
《Linux Kernel Module Programming Guide》
作者：Ori Pomerantz 中译者：谭志([email protected])
译者注：
1、LKMPG是一本免费的书，英文版的发行和修改遵从GPL version 2的许可。为了
节省时间，我只翻译了其中的大部分的大意，或者说这只是我学习中的一些中文
笔记吧，不能算是严格上的翻译，但我认为这已经足够了。本文也允许免费发布
，但发布前请和我联系，但不要把本文用于商业目的。鉴于本人的水平，文章中
难免有错误，请大家不吝指正。
2、本文中的例子在Linux(kernel version 2.2.10)上调试通过。你用的Linux必
须支持内核模块的加载，如果不支持，请在编译内核时选上内核模块的支持或升
级你的内核到一个支持内核模块的版本。
第九章 阻塞进程
当某人请求一些你不能立刻做的事情时，你会怎么做呢？如果你是人类，你
会说：现在不行，我很忙，先走开。但如果你是一个内核模块，你现在被一个进
程(请求)打扰，你有其他的可能性。你可以将进程进入睡眠直到你能够为它服务
。毕竟进程可以被内核在任何时候进入睡眠和唤醒(这是单CPU上实现似乎同时运
行多进程的方法)。
这个例子也是一个内核模块。一个proc文件(叫/proc/sleep)在某个时候只能
被一个进程打开。如果文件已经打开，内核模块将会调用module_interruptible
_sleep_on。这个函数改变任务(task:任务是一个关于进程的进程信息和系统调用
等信息的内核数据结构)的状态到TASK_INTERRUPTIBLE，表示进程直到被唤醒才能
继续运行，并把进程加入到等待队列(WaitQ:等待访问这个文件的任务队列)，再
调用调度器切换到另一进程的上下文运行。
当一个进程完成对/proc/sleep的操作，就关闭该文件，这将会调用module_
close函数。这个函数将唤醒所有在等待队列里的进程(这里没有只唤醒当中某个
进程的机制)。然后返回到刚关闭文件的进程里继续运行。然后调度器决定那个进
程获得CPU运行时间，并把进程调度运行。当被唤醒的某个进程获得运行时，它在
module_interruptible_sleep_on调用的后面开始运行，然后设置一个全局变量让
其他获得CPU时间的唤醒进程知道文件还打开。这些进程看到文件仍打开时，再次
进入睡眠状态。
为了让例子更有趣，module_close不是唯一能唤醒等待队列里的进程的函数
。一个信号，象Ctrl-C(SIGINT)也可以唤醒一个进程。在这种情况下，我们立刻
返回-EINTR。这是很重要的，因为用户可以在取得这个文件之前中断进程。
有另一点要记住：有时侯进程不想进入睡眠(被阻塞)，它们只想立刻得到他
们想要的，或告诉它们请求不能被完成。这类进程用O_NONBLOCK标志打开这个文
件。内核应该返回不同于阻塞的-EAGAIN错误码给这些进程。cat_noblock程序可
用于用O_NONBLOCK的方式打开文件的情况测试。
例子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/kernel.h> /* We're doing kernel work */
#include <linux/module.h> /* Specifically, a module */
/* Deal with CONFIG_MODVERSIONS */
#if CONFIG_MODVERSIONS==1
#define MODVERSIONS
#include <linux/modversions.h>
#endif
/* 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 <linux/wrapper.h>
#include <asm/uaccess.h> /* for get_user and put_user */
/* 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 struct wait_queue *WaitQ = NULL;
/* 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;
/* This is the correct place for MOD_INC_USE_COUNT
* because if a process is in the loop, which is
* within the kernel module, the kernel module must
* not be removed. */
MOD_INC_USE_COUNT;
/* If the file is already open, wait until it isn't */
while (Already_Open)
{
int i, is_sig=0;
/* 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 */
module_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. */
/*
* Emmanuel Papirakis:
*
* This is a little update to work with 2.2.*. Signals
* now are contained in two words (64 bits) and are
* stored in a structure that contains an array of two
* unsigned longs. We now have to make 2 checks in our if.
*
* Ori Pomerantz:
*
* Nobody promised me they'll never use more than 64
* bits, or that this book won't be used for a version
* of Linux with a word size of 16 bits. This code
* would work in any case.
*/
for(i=0; i<_NSIG_WORDS && !is_sig; i++)
is_sig = current->signal.sig[i] &
~current->blocked.sig[i];
if (is_sig) {
/* It's important to put MOD_DEC_USE_COUNT here,
* because for processes where the open is
* interrupted there will never be a corresponding
* close. If we don't decrement the usage count
* here, we will be left with a positive usage
* count which we'll have no way to bring down to
* zero, giving us an immortal module, which can
* only be killed by rebooting the machine. */
MOD_DEC_USE_COUNT;
return -EINTR;
}
}
/* 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. */
module_wake_up(&WaitQ);
MOD_DEC_USE_COUNT;
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).
*
* The operation can be one of the following values:
* 0 - Execute (run the "file" - meaningless in our case)
* 2 - Write (input to the kernel module)
* 4 - 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 == 4 || (op == 2 && current->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 =
{
NULL, /* lseek */
module_output, /* "read" from the file */
module_input, /* "write" to the file */
NULL, /* readdir */
NULL, /* select */
NULL, /* ioctl */
NULL, /* mmap */
module_open,/* called when the /proc file is opened */
NULL, /* flush */
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 =
{
&File_Ops_4_Our_Proc_File,
NULL, /* create */
NULL, /* lookup */
NULL, /* link */
NULL, /* unlink */
NULL, /* symlink */
NULL, /* mkdir */
NULL, /* rmdir */
NULL, /* mknod */
NULL, /* rename */
NULL, /* readlink */
NULL, /* follow_link */
NULL, /* readpage */
NULL, /* writepage */
NULL, /* bmap */
NULL, /* truncate */
module_permission /* check for permissions */
};
/* Directory entry */
static struct proc_dir_entry Our_Proc_File =
{
0, /* Inode number - ignore, it will be filled by
* proc_register[_dynamic] */
5, /* Length of the file name */
"sleep", /* The file name */
S_IFREG | S_IRUGO | S_IWUSR,
/* File mode - this is a regular file which
* can be read by its owner, its group, and everybody
* else. Also, its owner can write to it.
*
* Actually, this field is just for reference, it's
* module_permission that does the actual check. It
* could use this field, but in our implementation it
* doesn't, for simplicity. */
1, /* Number of links (directories where the
* file is referenced) */
0, 0, /* The uid and gid for the file - we give
* it to root */
80, /* The size of the file reported by ls. */
&Inode_Ops_4_Our_Proc_File,
/* A pointer to the inode structure for
* the file, if we need it. In our case we
* do, because we need a write function. */
NULL /* The read function for the file.
* Irrelevant, because we put it
* in the inode structure above */
};
/* Module initialization and cleanup **************** */
/* Initialize the module - register the proc file */
int init_module()
{
/* Success if proc_register_dynamic is a success,
* failure otherwise */
return proc_register(&proc_root, &Our_Proc_File);
/* proc_root is the root directory for the proc
* fs (/proc). This is where we want our file to be
* located.
*/
}
/* 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_module()
{
proc_unregister(&proc_root, Our_Proc_File.low_ino);
}
下面是测试文件cat_noblock.c
/* 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);
}
/* 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);
}
kevintz注：希望大家能够详细阅读英文注悉，对我们如何进行内核编程很重要。
很多语句的顺序都是不能调换的，可能会造成死锁。
--
那一刹那，我开始用心去看这个世界，所有的事物真的可以看得前
所未有的那么清楚……
|
|