From: Peshehodov Andrey <fresco_pap@mail.ru.>
Newsgroups: email
Date: Mon, 23 May 2006 14:31:37 +0000 (UTC)
Subject: Создание виртуальных файловых систем в Linux
author: Пешеходов А. П. aka fresco (fresco_pap@mail.ru)
mtime: 21.05.2006
Создание виртуальных файловых систем в Linux
Документ составлен на основе статьи Jonathan Corbet "Creating virtual
filesystems with libfs" (http://lwn.net/Articles/57369/).
Linus и многочисленные разработчики Linux-ядра негативно относятся к
использованию системного вызова ioctl(), не без оснований считая его, по
сути, неконтролируемым способом добавления совершенно нестандартных
интерфейсов в ядро. Создание новых файлов в каталоге /proc так же не
выглядит хорошим решением, т.к. там уже достаточно беспорядка.
Разработчики, "населяющие" свой код реализациями ioctl() или файлами в
/proc, часто бывают обескуражены возможностью создания вместо этого
обыкновенной виртуальной файловой системы. Файловые системы делают
интерфейс явным и видимы в пространстве пользователя, они так же
позволяют существенно упростить написание различных административных
скриптов.
Ядра серии 2.6 (начиная с 2.5.7) содержат набор подпрограмм, называемый
libfs, специально спроектированный для упрощения задачи написания
виртуальный файловых систем. Libfs берет на себя выполнение многих
стандартных для виртуальных файловых систем задач, позволяя
неквалифицированным разработчикам концентрироваться только на реализации
характерной для их задач функциональности.
В этой статье мы рассмотрим реализацию простой виртуальной файловой
системы (lwnfs), заполненной файлами-счетчиками. Каждое чтение такого
файла возвращает текущее значение счетчика и инкрементирует его:
# cat /lwnfs/counter
0
# cat /lwnfs/counter
1
Также возможно запись в файл числового значения, которое будет присвоено
счетчику:
Т.к. наша файловая система будет виртуальной, никаких операций работы с
диском мы не предусматриваем, а все данные будут располагаться в
различных кэшах ядра. Для связывания файловой системы с VFS необходимо
определить некий минимальный набор функций и структур данных. Рассмотрим
эти структуры.
struct file_system_type
является глобальным "определителем"
файловой системы и содержит имя ФС, а также функции получения и
уничтожения суперблока (lfs_type).
struct super_operations
содержит набор функций работы с
глобальными данными файловой системы. Здесь мы используем
"заглушки", предоставляемые libfs. (lfs_s_ops).
struct file_operations
определяет набор функций для работы с
файлами. Для файлов счетчиков мы реализуем только три из них -
open, read и write (составляют lfs_file_ops) - для каталогов же
используем "заглушки" libfs.
Алгоритм работы нашей ФС таков:
1.Точкой входа в модуль является функция lfs_init, выполняющая
регистрацию ФС вызовом register_filesystem(&lfs_type).
2.При монтировании ФС вызывается функция lfs_type->get_sb(), указывающая
на lfs_get_super. Эта функция вызывает libfs-helper get_sb_single(),
передавая ей в качестве параметра указатель на lfs_fill_super.
get_sb_single() размещает структуру struc super_block, и инициализирует
некоторыми разумными значениями все ее поля, вызывая в завершение
lfs_fill_super().
3.lfs_fill_super() устанавливает некоторые значащие поля суперблока, а
также создает и инициализируется логическую структуру файловой системы -
файл "counter" в корневом каталоге, и файл "subcounter" в каталоге
"subdir", размещая и вставляя в соответствующие VFS-кэши все необходимые
структуры.
Теперь рассмотрим реализацию описанных выше механизмов более детально.
Инициализация и установка суперблока
Модуль ядра, реализующий ФС, должен, в момент загрузки, зарегистрировать
файловую систему в VFS. Код инициализации lwnfs прост:
static int __init lfs_init(void) {
return register_filesystem(&lfs_type);
}
Аргумент lfs_type инициализируется следующим образом:
Это основная структура данных, описывающая файловую систему в ядре
(определена в linux/fs.h). Поле owner используется для управления
счетчиком ссылок на модуль (необходим для предотвращения выгрузки
используемого модуля). Поле name - строка, которая будет передана вызову
mount() в качестве типа ФС. Далее следуют 2 функции управления
суперблоком. kill_little_super() -- это generic-функция, предоставляемая
VFS, она просто освобождает все внутренние структуры при размонтировании
ФС; т.о. авторы простых виртуальных файловых систем не должны заботится
об этом аспекте (конечно, необходимо дерегистрировать ФС в момент
выгрузки модуля, это будет реализовано в exit-функции модуля lwnfs).
Окончательная инициализация суперблока - задача разработчика, она уже
значительно проще, нежели кодирование всех требуемых операций вручную. С
этим справляется функция lfs_get_super():
static struct super_block *lfs_get_super(struct file_system_type *fst,
int flags, const char *devname, voi *data) {
return get_sb_single(fst,flags,data,lfs_fill_super);
}
Аналогично, get_sb_single() -- есть generic-код, выполняющий большую
часть задачи создания суперблока (выделение памяти, инициализация полей,
и т.д.). Однако по завершении он вызывает lfs_fill_super(), которая
производит установку специфичных для нашей ФС полей.
static int lfs_fill_super (struct super_block *sb, void *data, int silent) {
struct inode *root;
struct dentry *root_dentry;
/* Создание inode для корневого каталога */
root = lfs_make_inode (sb, S_IFDIR | 0755);
if (! root)
goto out;
root->i_op = &simple_dir_inode_operations;
root->i_fop = &simple_dir_operations;
/* Создание dentry для корневого каталога */
root_dentry = d_alloc_root(root);
if (! root_dentry)
goto out_iput;
sb->s_root = root_dentry;
/* Создание логической структуры файлов и папок */
lfs_create_files (sb, root_dentry);
return 0;
out_iput:
/* Если выделение dentry провалилось, уничтожаем
* inode и выходим */
iput(root);
out:
return -ENOMEM;
}
Функция принимает 3 аргумента; первый - указатель на конструируемый
суперблок, последние 2 могут быть проигнорированы. Инициализация
суперблока сводится к установке размера блока, magic-идентификатора и
superblock-операций, описываемых структурой super_operations. Для
простой виртуальной ФС нет необходимости реализовывать все операции,
определенные в этой структуре -- libfs предоставит необходимые
"заглушки". Достаточно установить ее так:
Проинициализировав суперблок, lfs_fill_super берется за построение
корневого каталога нашей ФС. Первым делом для него создается inode -
вызовом lfs_make_inode(), реализация которого будет рассмотрена ниже. Он
нуждается в указателе на суперблок и аргументе mode, который задает
разрешения на создаваемый файл в формате вызова stat(), маска S_IFDIR
говорит функции, что мы создаем каталог, файловые и inode-операции,
которые мы назначаем новому inode, взяты из libfs.
Далее для корневого каталога создается структура dentry, через которую
он помещается в directory-кэш. Заметим, что суперблок имеет специальное
поле, хранящее указатель на dentry корневого каталога, которое также
устанавливается lfs_fill_super().
Создание файлов
Теперь суперблок имеет полностью работоспособный корневой каталог. Все
реальные операции с каталогом будут обрабатываться libfs и уровнем VFS.
Однако libfs не в состоянии создать что-либо интересное в корневом
каталоге, и этим придется заняться нам. Перед возвратом управления
функция lfs_fill_super() делает вызов lfs_create_files(), который
создает и размещает логическую структуру нашей ФС. Заметим, что счетчики
в нашем модуле реализованы в виде глобальных переменных типа atomic_t.
В качестве аргументов эта функция принимает указатель на суперблок,
dentry родительского каталога и имя создаваемого файла. Первым делом
создается dentry для нового файла - вызовом d_alloc(), который принимает
указатель на родительский dentry и структуру типа struct qstr, служащую
для удобно представления имени файла. Эта структура, помимо самого имени
и его длины, содержит также хэш, вычисляемый вызовом ful_name_hash(), по
которому указанный dentry может быстро найден в кэше.
Для инициализации inode мы снова пользуемся функцией lfs_make_inode(),
однако теперь мы создаем регулярный файл, о чем говорит маска S_IFREG. В
inode мы используем 2 поля:
поле i_fop устанавливается указателем на структуру с файловыми
операциями, реализующими чтение и запись счетчиков (lfs_file_ops).
поле u.generic_ip мы используем для хранения счетчика типа atomic_t.
Другими словами, i_fop определяет поведение данного конкретного файла, а
u.generic_ip хранит специфичные для файла данные. Практически все
виртуальные файловые системы используют эти 2 поля для установки
требуемого поведения файла.
Последний этап создания файла - добавление его в dentry-кэш вызовом
d_add(). Это позволяет VFS отыскивать файл без обращения к
directory-операциям, онам - обойтись без реализации directory-операций.
Вся наша файловая система находится внутри кэша ядра, модуль может не
запоминать ее структуру и в состоянии обойтись без реализации операций
просмотра (lookup) ФС. Это делает жизнь проще.
Она просто размещает новую структуру inode (вызовом new_inode()) и
заполняет ее некоторыми осмысленными значениями. Аргумент mode
определяет не только права доступа к файлу, но и его тип - регулярный
файл или каталог.
Реализация файловых операций
До этого момента мы почти не касались работы собственно счетчиков,
занимаясь реализацией внутренних VFS-механизмов, необходимых для работы
любой файловой системы. Пришло время посмотреть, как будет выполняться
реальная работа.
Операции над счетчиками находятся в структуре file_operations, которую
мы ассоциируем с inodes файлов-счетчиков:
Все, что она делает - помещает указатель на atomic_t прямо в структуру
file, что несколько упрощает доступ к нему.
Интересная работа выполняется функцией read(), которая должна
инктрементровать счетчик, а затем возвращать его значение в пространство
пользователя. Она начинается с чтения и инкрементирования счетчика:
v = atomic_read(counter);
if (*offset > 0)
v -= 1;
else
atomic_inc(counter);
len = snprintf(tmp, TMPSIZE, "%dn", v);
if (*offset > len)
return 0;
if (count > len - *offset)
count = len - *offset;
Заметим ,что здесь возможны "гонки" - 2 процесса могут прочитать счетчик
до его инкрементирования, в результате чего одно и тоже значение
счетчика будет возвращено дважды. Серьезный модуль, вероятно, попытался
бы упорядочить доступ к счетчику путем применения блокировок
(spinlocks), однако наша ФС предназначена только для демонстрационных
целей и подобными сложностями не обременена.
Но в любом случае, мы имеем некоторое значение счетчика и должны вернуть
его в пространство пользователя. Далее следует перекодирование его в
символьную форму и перемещение в пользовательский буфер, а также
корректирование смещения (seek) в файле.
Теперь рассмотрим функцию write, которая позволяет пользователям
устанавливать значение счетчика:
Кода libfs полностью достаточно для реализации большинства
driver-specific виртуальных файловых систем. Дополнительные примеры
могут быть найдены в исходниках ядра Linux-2.6.x.x:
Vova
