📄 12.html
字号:
<html><head><title>黄金书屋</title><meta http-equiv="Content-Type" content="text/html; charset=gb2312"><link rel="stylesheet" href="/goldnets.css"></head><body bgcolor="#E4EBF1"><center><a href="http://ad.myrice.com/RealMedia/ads/click_nx.ads/goldnets.myrice.com/banner1@Top" target=_blanck ><script language=JavaScript><!---todayd = new Date();var seconds = todayd.getTime();document.write("<img src=\"http://ad.myrice.com/RealMedia/ads/adstream_nx.ads/goldnets.myrice.com/banner1@Top?dd=seconds\" border=0 width=468 height=60>");//--></script></a></center><br><table width="756" border="0" cellspacing="0" cellpadding="0" align="center" bgcolor="#E4EBF1"> <tr> <td colspan="2" valign="top" align="center"> <div align="center"> <table width="100%" border="0" cellspacing="0" cellpadding="0" height="52"> <tr> <td valign="top"><br> <div align="center"> <table width="100%" border="0" cellspacing="0" cellpadding="0"> <tr> <td valign="bottom"> <table width="100%" border="0" cellspacing="0" cellpadding="0"> <tr> <td><a href="/index.html">首页</a>>> <font color="#CC0000"><a href="/book/152/1015178.html">Linux内核编程</a></font></td> <td width="22%"> <a href="/index.html">[ 点此回首页 ]</a></td> </tr> <tr> <td colspan="2"><img src="/image/1x1.gif" width="1" height="2"></td> </tr> <tr bgcolor="#FFCC00"> <td colspan="2"><img src="/image/1x1.gif" width="1" height="1"></td> </tr> <tr> <td colspan="2"><img src="/image/1x1.gif" width="1" height="6"></td> </tr> </table> </td> </tr> </table> <br> <table width="590" border="0" cellspacing="0" cellpadding="0"> <tr> <td><center><a href='11.html'>上一页 </a>||<a href='13.html'>下一页</a></center><br><hr><div style=font-size:12pt><pre> 8．阻塞进程
如果有人让你做你一时做不到的事情你会怎么办呢？如果你是个人被另一个人打扰，
你唯一可以做的就是对他说：“现在不行，我很忙，走开！”但是如果你是内核模块，被进程
打扰，你就有另一种选择。你可以让这个进程去挂起直到你可以为之提供服务。毕竟，进程
是在不停的被内核挂起或唤醒（这就是多个进程看上去同时在一个处理器上运行的方法）。
这个内核模块就是一个这样的例子。这个文件（称作/proc/sleep）在一个时刻只能被一
个进程打开。如果这个文件已经被打开，内核模块就调用module_interruptible_sleep_on（注
8.1）。这个函数把任务（一个任务是一个内核数据结构，它包含进程以及它所在系统调用的
信息）的状态改变成TASK_INTERRUPTIBLE，表示直到被唤醒任务不会运行，并且把它加
入到WaitQ——等待访问文件的任务队列。那么，这个函数调用调度器进行上下文切换到其
他要使用CPU的进程。
当进程完成对文件的处理后，关闭该文件并且调用module_ close。这个函数唤醒所有
队列中的进程（还没有一个机制唤醒其中一个）。然后返回，刚才关闭文件的进程可以继续
运行。调度器及时决定哪个进程已经完成，并且把CPU的控制给另一个进程。同时，队列
中的某个进程将会从调度器那里得到对CPU的控制。它正在对module_interruptible_sleep_on
的调用后开始。然后它可以设置一个全局变量告诉别的进程这个文件还打开着，正在继续它
的生命。当别的进程有得到CPU的机会时，它们会看到这个全局变量，然后就重新挂起。
为使生命更加精彩，module_close并没有对唤醒等待访问文件的进程进行垄断。一个象
Ctrl-C（SIGINT）之类的信号同样可以唤醒进程。在这种情况下，我们希望立即返回-EINTR。
这是很重要的，比如用户可以在进程接到文件前杀死进程。
还有一点需要记住。有些时候进程不希望被挂起，它们希望立刻得到它们要的东西，
或者被告知不能做到。这样的进程在打开文件时使用O_NONBLOCK标志。内核在遇到其
他方面的挂起进程的操作（比如本例中的打开文件）时要返回一个错误码-ERROR作为回应。
程序cat_noblock就可以用来使用标志O_NONBLOCK打开文件，它可以在本章源程序目录
中找到。
ex 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>
/* In 2.2.3 /usr/include/linux/version.h includes a
* macro for this, but 2.0.35 doesn\'t - so I add it
* here if necessary. */
#ifndef KERNEL_VERSION
#define KERNEL_VERSION(a,b,c) ((a)*65536+(b)*256+(c))
#endif
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,0)
#include <asm/uaccess.h> /* for get_user and put_user */
#endif
/* 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 */
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,0)
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 */
#else
static int module_output(
struct inode *inode, /* The inode read */
struct file *file, /* The file read */
char *buf, /* The buffer to put data to (in the
* user segment) */
int len) /* The length of the buffer */
#endif
{
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. */
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,0)
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 */
#else
static int module_input(
struct inode *inode, /* The file\'s inode */
struct file *file, /* The file itself */
const char *buf, /* The buffer with the input */
int length) /* The buffer\'s length */
#endif
{
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++)
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,0)
get_user(Message[i], buf+i);
#else
Message[i] = get_user(buf+i);
#endif
/* 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)
{
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,0)
int i, is_sig=0;
#endif
/* 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. */
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -