Роберт Лав - Разработка ядра Linux
- Название:Разработка ядра Linux
- Автор:
- Жанр:
- Издательство:Издательский дом Вильямс
- Год:2006
- Город:Москва
- ISBN:5-8459-1085-4
- Рейтинг:
- Избранное:Добавить в избранное
-
Отзывы:
-
Ваша оценка:
Роберт Лав - Разработка ядра Linux краткое содержание
В книге детально рассмотрены основные подсистемы и функции ядер Linux серии 2.6, включая особенности построения, реализации и соответствующие программны интерфейсы. Рассмотренные вопросы включают: планирование выполнения процессов, управление временем и таймеры ядра, интерфейс системных вызовов, особенности адресации и управления памятью, страничный кэш, подсистему VFS, механизмы синхронизации, проблемы переносимости и особенности отладки. Автор книги является разработчиком основных подсистем ядра Linux. Ядро рассматривается как с теоретической, так и с прикладной точек зрения, что может привлечь читателей различными интересами и потребностями.
Книга может быть рекомендована как начинающим, так и опытным разработчикам программного обеспечения, а также в качестве дополнительных учебных материалов.
Разработка ядра Linux - читать онлайн бесплатно полную версию (весь текст целиком)
Интервал:
Закладка:
list_entry(task->tasks.next, struct task_struct, tasks);
Получение указателя на предыдущее задание работает аналогично.
list_entry(task->tasks.prev, struct task_struct, tasks);
Дна указанных выше выражения доступны также в виде макросов next_task(task)
(получить следующую задачу), prev_task(task)
(получить предыдущую задачу). Наконец, макрос for_each_process(task)
позволяет выполнить цикл по всему списку задач. На каждом шаге цикла переменная task
указывает на следующую задачу из списка:
struct task_struct *task;
for_each_process(task) {
/* просто печатается имя команды и идентификатор PID
для каждой задачи */
printk("%s[%d]\n", task->comm, task->pid);
}
Следует заметить, что организация цикла по всем задачам системы, в которой выполняется много процессов, может быть достаточно дорогостоящей операцией. Для применения такого кода должны быть веские причины (и отсутствовать другие альтернативы).
Создание нового процесса
В операционной системе Unix создание процессов происходит уникальным образом. В большинстве операционных систем для создания процессов используется метод порождения процессов ( spawn ). При этом создается новый процесс в новом адресном пространстве, в которое считывается исполняемый файл, и после этого начинается исполнение процесса. В ОС Unix используется другой подход, а именно разбиение указанных выше операций на две функции: fork()
и exec()
[15] Под exec() будем понимать любую функцию из семейства exec*() . В ядре реализован системный вызов execve() , на основе которого реализованы библиотечные функции execlp() , execle() , execv() и execvp() .
.
В начале с помощью функции fork()
создается порожденный процесс, который является копией текущего задания. Порожденный процесс отличается от родительского только значением идентификатора PID
(который является уникальным в системе), значением параметра PPID
(идентификатор PID
родительского процесса, который устанавливается в значение PID
порождающего процесса), некоторыми ресурсами, такими как ожидающие на обработку сигналы (которые не наследуются), а также статистикой использования ресурсов. Вторая функция — exec()
— загружает исполняемый файл в адресное пространство процесса и начинает исполнять его. Комбинация функций fork()
и exec()
аналогична той одной функции создания процесса, которую предоставляет большинство операционных систем.
Копирование при записи
Традиционно при выполнении функции fork()
делался дубликат всех ресурсов родительского процесса и передавался порожденному. Такой подход достаточно наивный и неэффективный. В операционной системе Linux вызов fork()
реализован с использованием механизма копирования при записи ( copy-on-write ) страниц памяти. Технология копирования при записи (copy-on-write, COW) позволяет отложить или вообще предотвратить копирование данных. Вместо создания дубликата адресного пространства процесса родительский и порожденный процессы могут совместно использовать одну и ту же копию адресного пространства. Однако при этом данные помечаются особым образом, и если вдруг один из процессов начинает изменять данные, то создается дубликат данных, и каждый процесс получает уникальную копию данных. Следовательно, дубликаты ресурсов создаются только тогда, когда в эти ресурсы осуществляется запись, а до того момента они используются совместно в режиме только для чтения (read-only). Такая техника позволяет задержать копирование каждой страницы памяти до того момента, пока в эту страницу памяти не будет осуществляться запись. В случае, если в страницы памяти никогда не делается запись, как, например, при вызове функции exec()
сразу после вызова fork()
, то эти страницы никогда и не копируются. Единственные накладные расходы, которые вносит вызов функции fork()
, — это копирование таблиц страниц родительского процесса и создание дескриптора порожденного процесса. Данная оптимизация предотвращает ненужное копирование большого количества данных (размер адресного пространства часто может быть более 10 Мбайт), так как процесс после разветвления в большинстве случаев сразу же начинает выполнять новый исполняемый образ. Эта оптимизация очень важна, потому чти идеология операционной системы Unix предусматривает быстрое выполнение процессов.
fork()
В операционной системе Linux функция fork()
реализована через системный вызов clone()
. Этот системный вызов может принимать в качестве аргументов набор флагов, определяющих, какие ресурсы должны быть общими (если вообще должны) у родительского и порожденного процессов. Далее в разделе "Реализация потоков в ядре Linux" об этих флагах рассказано более подробно. Библиотечные вызовы fork()
, vfork()
и __clone()
вызывают системную функцию clone()
с соответствующими флагами. В свою очередь системный вызов clone()
вызывает функцию ядра do_fork()
.
Основную массу работы по разветвлению процесса выполняет функция do_fork()
, которая определена в файле kernel/fork.c
. Эта функция, в свою очередь, вызывает функцию copy_process()
и запускает новый процесс на выполнение. Ниже описана та интересная работа, которую выполняет функция copy_process()
.
• Вызывается функция dup_task_struct()
, которая создает стек ядра, структуры thread_info
и task_struct
для нового процесса, причем все значения указанных структур данных идентичны для порождающего и порожденного процессов. На этом этапе дескрипторы родительского и порожденного процессов идентичны.
• Проверяется, не произойдет ли при создании нового процесса переполнение лимита на количество процессов для данного пользователя.
• Теперь необходимо сделать порожденный процесс отличным от родительского. При этом различные поля дескриптора порожденного процесса очищаются или устанавливаются в начальные значения. Большое количество данных дескриптора процесса является совместно используемым.
• Далее состояние порожденного процесса устанавливается в значение TASK_UNINTERRUPTIBLE
, чтобы гарантировать, что порожденный процесс не будет выполняться.
• Из функции copy_process()
вызывается функция copy_flags()
, которая обновляет значение поля flags
структуры task struct
. При этом сбрасывается флаг PF_SUPERPRIV
, который определяет, имеет ли процесс права суперпользователя. Флаг PF_FORKNOEXEC
, который указывает на то, что процесс не вызвал функцию exec()
, — устанавливается.
• Вызывается функция get_pid()
, которая назначает новое значение идентификатора PID
для новой задачи.
• В зависимости от значений флагов, переданных в функцию clone()
, осуществляется копирование или совместное использование открытых файлов, информации о файловой системе, обработчиков сигналов, адресного пространства процесса и пространства имен ( namespace ). Обычно эти ресурсы совместно используются потоками одного процесса. В противном случае они будут уникальными и будут копироваться на этом этапе.
Интервал:
Закладка: