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

 * answer should always be no.
 *
 * This is important because the standard read
 * function from the library would continue to issue
 * the read system call until the kernel replies
 * that it has no more information, or until its * buffer is filled. */
 if (offset > 0) return 0;
 /* Fill the buffer and get its length */
 len = sprintf(my_buffer, "For the %d%s time, go away!\n", count,
  (count % 100 > 10 && count % 100 < 14) ? "th" :
  (count % 10 == 1) ? "st" : (count % 10 == 2) ? "nd" :
  (count % 10 == 3) ? "rd" : "th" );
 count++;
 /* Tell the function which called us where the buffer is */
 *buffer_location = my_buffer;
 /* Return the length */
 return len;
}

struct proc_dir_entry Our_Proc_File = {
 0, /* Inode number - ignore, it will be filled by proc_register[_dynamic] */
 4, /* Length of the file name */
 "test", /* The file name */
 S_IFREG | S_IRUGO, /* File mode - this is a regular file which can be read by its owner, its group, and everybody else */
 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. */
 NULL, /* functions which can be done on the inode (linking, removing, etc.) - we don't support any. */
 procfile_read, /* The read function for this file, the function called when somebody tries to read something from it. */
 NULL /* We could have here a function to fill the file's inode, to enable us to play with permissions, ownership, etc. */
};

/* 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)
 /* In version 2.2, proc_register assign a dynamic
 * inode number automatically if it is zero in the
 * structure, so there's no more need for
 * proc_register_dynamic */
 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 */
void cleanup_module() {
 proc_unregister(&proc_root, Our_Proc_File.low_ino);
}

Использование /proc для ввода

Пока мы имеем два способа генерировать вывод из модулей: мы можем зарегистрировать драйвер устройства и создать mknod файл устройства, или мы можем создать /proc файл. Это позволяет модулю сообщать нам что-нибудь. Единственная проблема в том, что не имеется никакого пути для нас, чтобы возразить. Первый путем, которым мы пошлем ввод модулям, будет запись обратно в файл в системе /proc.

Поскольку файловая система /proc была написана главным образом, чтобы позволить ядру сообщать ситуацию процессам, нет никаких специальных условий для ввода. Структура proc_dir_entry не включает указатель на функцию ввода. Вместо этого, чтобы писать в /proc, мы должны использовать стандартный механизм файловой системы.  

В Linux имеется стандартный механизм для регистрации файловой системы. Так как каждая файловая система должна иметь собственные функции, чтобы обработать inode и выполнять файловые операции[3], имеется специальная структура, чтобы хранить указатели на все нужные функции, struct inode_operations, который включает указатель на struct file_operations. В /proc всякий раз, когда мы регистрируем новый файл, нам позволяют определить, который struct inode_operations будет использоваться для доступа к этому файлу. Это механизм, который мы используем, struct inode_operations, который включает указатель на struct file_operations, который включает указатели на наши функции module_input и module_output.

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

Другая интересная точка здесь это функция module_permission. Эта функция вызывается всякий раз, когда процесс пробует делать что-либо с файлами системы /proc, и может решить позволить доступ или нет. Сейчас это только основано на операции и uid текущиего пользователя, но в принципе такое разрешение может выдаваться исходя из других параметров, например, что другие процессы делают с тем же самым файлом, времени дня или последнего ввода, который мы получили.

Причина для put_user и get_user в том, что память в Linux (под архитектурой Intel, это может быть различно под некоторыми другими процессорами) сегментирована. Это означает, что указатель, отдельно не ссылается на уникальное место в памяти, а только на место в сегменте памяти, и Вы должны знать, который сегмент памяти нужен. Имеется один сегмент памяти для ядра и по одному на каждый из процессов.

Единственный сегмент памяти, доступный для процесса, это его собственный, так для нормальных программ, нет никакой потребности волноваться относительно сегментов. Когда Вы пишете модуль, обычно Вы хотите обращаться к сегменту памяти ядра, который обрабатывается системой автоматически. Однако, когда содержание буфера памяти должно быть передано между процессом в настоящее время имеющим управление и ядром, функция получает указатель на буфер памяти, который находится в своем сегменте процесса. Макрокоманды put_user и get_user позволяют Вам обращаться к нужной Вам памяти.