Лекции по операционным системам (1114738), страница 19

Просмтор этого файла доступен только зарегистрированным пользователям. Но у нас супер быстрая регистрация: достаточно только электронной почты!

Текст из файла (страница 19)

По факту завершения одного из процессов родительский процесс при обращении к системному вызову wait() получает следующую информацию. В случае успешного завершения возвращается идентификатор PID завершившегося процесса, или же -1 — в случае ошибки или прерывания. А через параметр status передается указатель на целочисленную переменную, в которой система возвращает процессу причины завершения сыновнего процесса. Данный параметр содержит в старшем байте код завершения процесса-потомка (пользовательский код завершения процесса), передаваемый в качестве параметра системному вызову exit(), а в младшем байте — индикатор причины завершения процесса-потомка, устанавливаемый ядром ОС Unix (системный код завершения процесса). Системный код завершения хранит номер сигнала, приход которого в сыновний процесс вызвал его завершение.

Необходимо сделать замечание, касающееся системного вызова wait(). Данный системный вызов не всегда отрабатывает на завершении дочернего процесса. В случае если отцовский процесс производит трассировку сыновнего процесса, то посредством системного вызова wait() можно фиксировать факт приостановки сыновнего процесса, причем сыновний процесс после этого может быть продолжен (т.е. не всегда он должен завершиться, чтобы отцовский процесс получил информацию о сыне). С другой стороны, имеется возможность изменить режим работы системного вызова wait() таким образом, чтобы отцовский процесс не блокировался в ожидании завершения одного из потомков, а сразу получал соответствующий код ответа.

И, наконец, отметим, что после передачи информации родительскому процессу о статусе завершения все структуры, связанные с процессом-зомби, освобождаются, и удаляется запись о нем из таблицы процессов.

Рассмотрим пример использования системного вызова wait(). В данном случае приводится текст программы, которая последовательно запускает программы, имена которых указаны при вызове.

#include<stdio.h>

int main(int argc, char **argv)

{

int i;

for (i=1; i<argc; i++)

{

int status;

if(fork() > 0)

{

/* процесс-предок ожидает сообщения

от процесса-потомка о завершении */

wait(&status);

printf(“process-father\n”);

continue;

}

execlp(argv[i], argv[i], 0);

exit();

}

}

Пусть существуют три исполняемых файла print1, print2, print3, каждый из которых только печатает текст first, second, third соответственно, а код вышеприведенного примера находится в исполняемом файле с именем file. Тогда результатом работы команды

file print1 print2 print3

будет:

first

process-father

second

process-father

third

process-father

Рассмотрим еще один пример. В данном примере процесс-предок порождает два процесса, каждый из которых запускает команду echo. Далее процесс-предок ждет завершения своих потомков, после чего продолжает выполнение. В данном случае wait() вызывается в цикле три раза: первые два ожидают завершения процессов-потомков, последний вызов вернет неуспех, ибо ждать более некого.

int main(int argc, char **argv)

{

if ((fork()) == 0) /*первый процесс-потомок*/

{

execl(“/bin/echo”,”echo”,”this is”,”string 1”,0);

exit();

}

if ((fork()) == 0) /*второй процесс-потомок*/

{

execl(“/bin/echo”,”echo”,”this is”,”string 2”,0);

exit();

}

/*процесс-предок*/

printf(“process-father is waiting for children\n”);

while(wait() != -1);

printf(“all children terminated\n”);

exit();

}

2.2.3Жизненный цикл процесса. Состояния процесса

Рассмотрим обобщенную и несколько упрощенную схему жизненного цикла процессов в ОС Unix (Рис. 79.). Можно выделить целую совокупность состояний, в которых может находиться процесс.

1. Жизненный цикл процессов.

Начальное состояние — это состояние создания процесса: после обращения к системному вызову fork() создается новый процесс в системе (еще раз отметим, что иных способов создать процесс в ОС Unix не существует), который попадает в БВП (о котором речь шла выше). В ОС Unix БВП состоит из одного процесса, который после создания попадает в БОП. Итак, после создания процесса он получает статус, что он готов к выполнению. Из этого состояния по решению планировщика он может переходить в состояние выполнения, а затем обратно в состояние готовности к выполнению в случае исчерпания кванта времени обработки на процессоре. В состоянии выполнения процесс может работать как в пользовательском режиме, так и в режиме ядра, или супервизора. В режиме ядра процесс работает при обращении к системному вызову, когда ядро выполняет некоторые действия для конкретного процесса.

Затем из режима выполнения процесс может перейти в состояние блокировки. В этом состоянии процесс находится, ожидая завершения некоторого действия: например, ожидая завершения внешнего взаимодействия. Соответственно, по возникновению соответствующего события процесс переходит из состояния блокировки в состояние готовности к выполнению.

Посредством обращения к системному вызову exit() процесс переходит из состояния выполнения в состояние зомби, а после получения отцовским процессом информации о завершении данного процесса он завершает свой жизненный цикл.

Итак, мы рассмотрели упрощенную модель. Главным упрощением в ней можно считать отсутствие свопинга — отсутствие откачки процесса во внешнюю память.

2.2.4Формирование процессов 0 и 1

Все механизмы взаимодействия процессов в ОС Unix унифицированы и основываются на связке системных вызовов fork-exec. Абсолютно все процесс в ОС Unix создается по приведенной схеме, но существуют два процесса с номерами 0 и 1, которые являются исключениями из данного правила.

Рассмотрим детально, как формируются данные процессы, но для этого необходимо разобраться, что происходит в системе при включении компьютера. Практически во всех компьютерах имеется область памяти, способная постоянно хранить информацию — т.н. постоянное запоминающее устройство (ПЗУ). В этой области памяти находится т.н. аппаратный загрузчик компьютера. Данный загрузчик в общем случае имеет информацию о перечне и приоритетах системных устройств компьютера, которые априори могут содержать операционную систему. Приоритет определяет тот порядок, в котором аппаратный загрузчик осуществляет перебор устройств по списку в поисках программного загрузчика операционных систем. Обычно в нулевом блоке системного устройства находится т.н. программный загрузчик, который может содержать информацию о наличии в различных разделах системного устройства различных операционных систем. Раздел системного устройства — это последовательность блоков (выделенная на внешнем запоминающем устройстве), внутри которых используется виртуальная нумерация этих блоков, т.е. каждый раздел начинается с нулевого блока. Соответственно, если операционных систем несколько, то программный загрузчик может предложить пользователю компьютера выбрать, какую систему загружать. После этого программный загрузчик обращается к соответствующему разделу данного системного устройства и из нулевого блока выбранного раздела считывает загрузчик конкретной операционной системы, после чего начинает работать программный загрузчик конкретной ОС. Этот загрузчик, в свою очередь, «знает» структуру раздела, структуру файловой системы и находит в соответствующей файловой системе файл, который должен быть запущен в качестве ядра операционной системы.

Что касается Unix-систем, то указанный загрузчик ОС осуществляет поиск, считывание в память и запуск на исполнение файла /unix, который содержит исполняемый код ядра ОС Unix. Рассмотрим теперь действия ядра при запуске.

Первым делом происходит инициализация системы, которая включает в себя установку начальных параметров в аппаратных интерфейсах: установку системных часов, установка диспетчера оперативной памяти, установка средств защиты оперативной памяти. Затем, исходя из параметров настройки операционной системы, осуществляется формирование системных структур данных (в частности, создается таблица процессов). После этого ядро создает нулевой процесс. Отметим, что здесь мы оперируем определением процесса в ОС Unix: ядро формирует нулевую запись в таблице процессов, и более ничего, — это и есть создание нулевого процесса. Этот нулевой процесс в общем случае соответствует ядру (это процесс ядра), но этот процесс имеет особенность: он не имеет сегмента кода. Это означает, что нулевая запись таблицы процессов ссылается на контекст, в котором отсутствует ссылка на сегмент кода процесса. Нулевой процесс существует на всем протяжении функционирования ОС, причем он иллюстрирует нештатное формирование процесса в системе.

1. Формирование нулевого и первого процессов.

Следующим этапом ядро начинает формирование первого процесса, который также создается нестандартным образом, при этом выполняются следующие действия. Ядро осуществляет копирование нулевой записи в первую. После чего для первой записи выделяется пространство оперативной памяти и создается тело процесса. В тело процесса записывается код системного вызова exec(), после этого происходит внутри первого процесса обращение к этому системному вызову с параметром /etc/init. Таким образом, можно отметить, что сам первый процесс формируется нестандартным путем, но его тело его в конце уже формируется «правильным» образом посредством вызова exec().

Итак, в итоге в рамках первого процесса сформирован процесс init, который существует в системе также на протяжении всего ее функционирования. Процесс init поддерживает соответствующую стратегию организации работы системы: либо это однопользовательская система, либо многопользовательская. Эта стратегия определяется параметрами, которые возникают на стадии загрузки ядра и инициализации системы. Соответственно, система опознает один из подключенных терминалов как системную консоль. Если система однопользовательская, то происходит подключение интерпретатора команд к системной консоли. Если же режим многопользовательский, то процесс init обращается к системной таблице терминалов, хранящей все терминальные устройства, которые могут быть в системе, и для каждого готового к работе терминала из юэтого перечня он запускает процесс getty. Процесс getty — это процесс, который обеспечивает работу конкретного терминала. Заметим, что процесс init создает процесс getty уже стандартным способом, и после вообще все процессы создаются лишь по схеме fork-exec.

1. Инициализация системы.

После старта процесс getty печатает на экране приглашение ввести логин (Рис. 82.). После того, как пользователь вводит логин, процесс getty загружает на свое место программу login. Соответственно, программа login запрашивает ввода пароля, который после ввода и проверяет. В первых версиях ОС Unix все пароли хранились в зашифрованном виде в файле passwd. Если введенный пароль оказывается верным, программа login загружает параметры работы конкретного пользователя, загружает интерпретатор команд (shell), и пользователь может начинать работать в системе. Заметим, что тип загружаемого интерпретатора команд также задается среди параметров работы данного пользователя. А, вообще говоря, в настройках вместо интерпретатора команд может присутствовать любой исполняемый файл, например, это может быть менеджер по обслуживанию СУБД, функционирующей в системе.

Сеанс работы пользователя с системой представляется в виде файла, с которым происходят операции чтения и записи. Соответственно, работа с системой заканчивает закрытием файла — подачей символа EOF (end of file), этот код нажатия комбинации клавиш Ctrl+D на клавиатуре. После передачи этого символа интерпретатор завершается. Как только оказывается, с терминалом не связан ни один процесс, процесс init запускает новый процесс getty, который ассоциируется с этим терминалом, который, в свою очередь, снова печатает на экране приглашение ввести логин.

Характеристики

Список файлов лекций