?? x1008.html
字號:
<HTML
><HEAD
><TITLE
>Blocking Processes</TITLE
><META
NAME="GENERATOR"
CONTENT="Microsoft FrontPage 4.0"><LINK
REL="HOME"
TITLE="The Linux Kernel Module Programming Guide"
HREF="index.html"><LINK
REL="UP"
TITLE="Blocking Processes"
HREF="c1006.html"><LINK
REL="PREVIOUS"
TITLE="Blocking Processes"
HREF="c1006.html"><LINK
REL="NEXT"
TITLE="Replacing Printks"
HREF="c1109.html"></HEAD
><BODY
CLASS="SECT1"
BGCOLOR="#FFFFFF"
TEXT="#000000"
LINK="#0000FF"
VLINK="#840084"
ALINK="#0000FF"
><DIV
CLASS="NAVHEADER"
><TABLE
SUMMARY="Header navigation table"
WIDTH="100%"
BORDER="0"
CELLPADDING="0"
CELLSPACING="0"
><TR
><TH
COLSPAN="3"
ALIGN="center"
>The Linux KerneLinux內核驅動模塊編程指南 (內核版本2.2, 2.4)</TH
></TR
><TR
><TD
WIDTH="10%"
ALIGN="left"
VALIGN="bottom"
><A
HREF="c1006.html"
ACCESSKEY="P"
>返回</A
></TD
><TD
WIDTH="80%"
ALIGN="center"
VALIGN="bottom"
>第九章.阻塞進程</TD
><TD
WIDTH="10%"
ALIGN="right"
VALIGN="bottom"
><A
HREF="c1109.html"
ACCESSKEY="N"
>繼續</A
></TD
></TR
></TABLE
><HR
ALIGN="LEFT"
WIDTH="100%"></DIV
><DIV
CLASS="SECT1"
><H1
CLASS="SECT1"
><A
NAME="AEN1008"
></A
>9.1. 阻塞進程</H1
><DIV
CLASS="SECT2"
><H2
CLASS="SECT2"
><A
NAME="AEN1015"
></A
>9.1.1. 阻塞進程</H2
><P
>當別人讓你做一件你不能馬上去做的事時，你會如何反映？如果你是人類的話，而且對方也是人類的話，你只會說：“現在不行，我忙著在。閃開！”但是如果你是一個內核模塊而且你被一個進程以同樣的問題困擾，你會有另外一個選擇。你可以讓該進程休眠直到你可以為它服務時。畢竟，這樣的情況在內核中時時刻刻都在發生（這就是系統讓多進程在單CPU上同時運行的方法）。</P
><P
>這個內核模塊就是一個這樣的例子。文件（名叫 <TT
CLASS="FILENAME"
>/proc/sleep</TT
> <TT
CLASS="FILENAME"
> </TT
>）只可以在同一時刻被一個進程打開。如果該文件已經被打開，內核模塊將調用函數
<TT
CLASS="FUNCTION"
>module_interruptible_sleep_on</TT
><A
NAME="AEN1048"
HREF="#FTN.AEN1048"
><SPAN
CLASS="footnote"
>[1]</SPAN
></A
><SPAN
CLASS="footnote"
>。該函數修改task的狀態（task是一個內核中的結構體數據結構，其中保存著對應進程的信息和該進程正在調用的系統調用，如果有的話）為</SPAN
><TT
CLASS="PARAMETER"
><I
>TASK_INTERRUPTIBLE</I
></TT
>，意味著改進程將不會繼續運行直到被喚醒，然后被添加到系統的進程等待隊列中，一個等待打開該文件的隊列中。然后，該函數調用系統調度器去切換到另一個不同的但有CPU運算請求的進程。</P
><P
>當一個進程處理完該文件并且關閉了該文件， <TT
CLASS="FUNCTION"
>module_close</TT
>
酒杯調用執行了。該函數喚醒所有在等待隊列中的進程（還沒有只喚醒特定進程的機制）。然后該函數返回，那個剛剛關閉文件的進程得以繼續運行。及時的，進程調度器會判定該進程執行已執行完畢，將CPU轉讓給別的進程。被提供CPU使用權的那個進程就恰好從先前系統調用
<TT
CLASS="FUNCTION"
>module_interruptible_sleep_on</TT
><A
NAME="AEN1056"
HREF="#FTN.AEN1056"
><SPAN
CLASS="footnote"
>[2]</SPAN
></A
><SPAN
CLASS="footnote"
>
后的地方開始繼續執行。它可以設置一個全局變量去通知別的進程該文件已被打開占用了。當別的請求該文件的進程獲得CPU時間片時，它們將檢測該變量然后返回休眠。</SPAN
></P
><P
>更有趣的是， <TT
CLASS="FUNCTION"
>module_close</TT
>
并不壟斷喚醒等待中的請求文件的進程的權力。一個信號，像
<B
CLASS="KEYCAP"
>Ctrl</B
>+<B
CLASS="KEYCAP"
>c</B
> (<TT
CLASS="PARAMETER"
><I
>SIGINT</I
></TT
>) 也能夠喚醒別的進程<A
NAME="AEN1077"
HREF="#FTN.AEN1077"
><SPAN
CLASS="footnote"
>[3]</SPAN
></A
> 。在這種情況下，我們想立即返回 <TT
CLASS="PARAMETER"
><I
>-EINTR</I
></TT
>
。這對用戶很重要，舉個例子來說，用戶可以在某個進程接受到文件前終止該進程。</P
><P
>還有一點值得注意。有些時候進程并不愿意休眠，它們要么立即執行它們想做的，要么被告知任務無法進行。這樣的進程在打開文件時會使用標志 <TT
CLASS="PARAMETER"
><I
>O_NONBLOCK</I
></TT
>
。在別的進程被阻塞時內核應該做出的響應是返回錯誤代碼
<TT
CLASS="PARAMETER"
><I
>-EAGAIN</I
></TT
> ，像在本例中對該文件的請求的進程。程序 <B
CLASS="COMMAND"
>cat_noblock</B
>，在本章的源代碼目錄下可以找到，就能夠使用標志位 <TT
CLASS="PARAMETER"
><I
>O_NONBLOCK </I
></TT
>打開文件。</P
><DIV
CLASS="EXAMPLE"
><A
NAME="AEN1106"
></A
><P
><B
>Example 9-1. sleep.c</B
></P
><TABLE
BORDER="0"
BGCOLOR="#E0E0E0"
WIDTH="100%"
><TR
><TD
><FONT
COLOR="#000000"
><PRE
CLASS="PROGRAMLISTING"
>/* sleep.c - create a /proc file, and if several processes try to open it at
* the same time, put all but one to sleep
*/
#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);
?? 快捷鍵說明
復制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號
Ctrl + =
減小字號
Ctrl + -