Linux核心程式設計(阻塞程式)(轉)

Linux核心程式設計(阻塞程式)(轉)[@more@]如果有人讓你做你一時做不到的事情你會怎麼辦呢？如果你是個人被另一個人打擾，你唯一可以做的就是對他說：“現在不行，我很忙，走開！”但是如果你是核心模組，被程式打擾，你就有另一種選擇。你可以讓這個程式去掛起直到你可以為之提供服務。畢竟，程式是在不停的被核心掛起或喚醒（這就是多個程式看上去同時在一個處理器上執行的方法）。
這個核心模組就是一個這樣的例子。這個檔案（稱作/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 /* Were doing kernel work */
#include /* Specifically, a module */

/* Deal with CONFIG_MODVERSIONS */
#if CONFIG_MODVERSIONS==1
#define MODVERSIONS
#include
#endif

/* Necessary because we use proc fs */
#include

/* For putting processes to sleep and waking them up */
#include
#include



/* In 2.2.3 /usr/include/linux/version.h includes a
* macro for this, but 2.0.35 doesnt - 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 /* for get_user and put_user */
#endif


/* The modules 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 cant 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 dont understand this by now, youre
* hopeless as a kernel programmer. */
sprintf(message, "Last input:%s ", Message);
for(i=0; i
put_user(message, 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 buffers length */
loff_t *offset) /* offset to file - ignore */
#else
static int module_input(
struct inode *inode, /* The files inode */
struct file *file, /* The file itself */
const char *buf, /* The buffer with the input */
int length) /* The buffers length */
#endif
{
int i;

/* Put the input into Message, where module_output
* will later be able to use it */
for(i=0; i
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,0)
get_user(Message, buf+i);
#else
Message = get_user(buf+i);
#endif
/* we want a standard, zero terminated string */
Message = ;

/* 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 files flags include O_NONBLOCK, it means
* the process doesnt want to wait for the file.
* In this case, if the file is already open, we
* should fail with -EAGAIN, meaning "youll 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 isnt */
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 were 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 theyll never use more than 64
* bits, or that this book wont be used for a version
* of Linux with a word size of 16 bits. This code
* would work in any case.
*/
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,0)

for(i=0; i<_nsig_words i="">is_sig = current->signal.sig &
~current->blocked.sig;
if (is_sig) {
#else
if (current->signal & ~current->blocked) {
#endif
/* Its 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 dont decrement the usage count
* here, we will be left with a positive usage
* count which well 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 */
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,0)
int module_close(struct inode *inode, struct file *file)
#else
void module_close(struct inode *inode, struct file *file)
#endif
{
/* 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
* theyll 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;

#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,0)
return 0; /* success */
#endif
}




/* 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 its 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 dont 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 */
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,0)
NULL, /* flush */
#endif
module_close /* called when its classed */
};



/* Inode operations for our proc file. We need it so
* well have somewhere to specify the file operations
* structure we want to use, and the function we use for
* permissions. Its also possible to specify functions
* to be called for anything else which could be done to an
* inode (although we dont 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, its
* module_permission that does the actual check. It
* could use this field, but in our implementation it
* doesnt, 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 */
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,0)
return proc_register(&proc_root, &Our_Proc_File);
#else
return proc_register_dynamic(&proc_root, &Our_Proc_File);
#endif

/* 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. Ill 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);
}