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

* 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) {

struct tty_struct *my_tty;

/* The tty for the current task */

my_tty = current->tty;

/* If my_tty is NULL, it means that the current task

* has no tty you can print to (this is possible, for

* example, if it's a daemon). In this case, there's

* nothing we can do. */

if (my_tty != NULL) {

/* my_tty->driver is a struct which holds the tty's

* functions, one of which (write) is used to

* write strings to the tty. It can be used to take

* a string either from the user's memory segment

* or the kernel's memory segment.

*

* The function's first parameter is the tty to

* write to, because the same function would

* normally be used for all tty's of a certain type.

* The second parameter controls whether the

* function receives a string from kernel memory

* (false, 0) or from user memory (true, non zero).

* The third parameter is a pointer to a string,

* and the fourth parameter is the length of

* the string. */

(*(my_tty->driver).write)(

my_tty, /* The tty itself */