Ори Померанц - Энциклопедия разработчика модулей ядра Linux

* 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. */

#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,0)

for(i=0; i<_NSIG_WORDS && !is_sig; i++) is_sig = current->signal.sig[i] & current->blocked.sig[i];

if (is_sig) {

#else

if (current->signal & current->blocked) {

#endif

/* 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 */

#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

* 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;

#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 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 */

#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,0)

NULL, /* flush */

#endif

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 */

#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. 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);

}

В начале (глава1), я сказал, что X и программирование модулей ядра не совместимы. Это истинно при разработке модуля, но в фактическом использовании, Вы должны быть способны послать сообщениям любому tty [10] T ele ty pe, первоначально комбинация принтера с клавиатурой, используемая, для связи с Unix системой, и сегодня абстракция для текстового потока, используемого для программы Unix, независимо от того, является ли это физическим терминалом, xterm на дисплее X, сетевое подключение, используемое telnet и т.д. . Это важно для идентификации ошибок после того, как модуль выпущен, потому что он будет использоваться через любой из терминалов.

Путем этого достичь: используя текущий указатель на задачу, выполняемую в настоящее время, получить ее структуру tty. Затем мы смотрим внутри этой структура tty, чтобы найти указатель на функцию, пишущую строку на tty. Ее мы и используем для вывода.

/* printk.c - send textual output to the tty you're

* running on, regardless of whether it's passed

* through X11, telnet, etc.

*/

/* Copyright (C) 1998 by Ori Pomerantz */

/* The necessary header files */

/* Standard in kernel modules */

#include /* We're doing kernel work */

#include /* Specifically, a module */

/* Deal with CONFIG_MODVERSIONS */

#if CONFIG_MODVERSIONS==1

#define MODVERSIONS

#include

#endif

/* Necessary here */

#include /* For current */

#include /* For the tty declarations */

/* Print the string to the appropriate tty, the one

* the current task uses */

void print_string(char *str) {