Лекции по операционным системам (1114687), страница 17
Текст из файла (страница 17)
pid_t fork(void);
Соответственно, при успешном завершении сыновнему процессу возвращается значение 0, а родительскому процессу — идентификатор порожденного процесса; в случае ошибки возвращается -1, а в переменной errno будет храниться код ошибки. Поскольку дочерний процесс является копией отцовского процесса, то возникает проблема, как отличить, какой из процессов в данный момент обрабатывается. Анализируя результат, возвращаемый системным вызовом fork(), можно определить, что текущий процесс является предком или потомком.
Рассмотрим пример (Рис. 76.). Пускай в системе обрабатывается процесс с идентификатором 2757. В некоторый момент времени этот процесс обращается к системному вызову fork(), в результате чего в системе появляется новый процесс, который, предположим, имеет идентификатор 2760. Сразу оговоримся, что дочерний процесс может получить совершенно произвольный идентификатор, отличный от нуля и единицы (обычно система выделяет новому процессу первую свободную запись в таблице процессов). По выходу из системного вызова fork() процесс 2757 продолжит свое выполнение с первой команды из then-блока, а дочерний процесс 2760 — с первой команды из else-блока. Далее эти процессы ведут себя независимо с точки зрения системного управления процессами: в частности, порядок их обработки на процессоре в общем случае пользователю неизвестен и зависит от той или иной реализованной в системе стратегии планирования времени процессора.
-
Пример использования системного вызова fork().
Рассмотрим еще один пример. В данном случае используются дополнительно два системных вызова: getpid() для получения идентификатора текущего процесса и getppid() для получения идентификатора родительского процесса. Итак, данный процесс при запуске печатает на экране идентификаторы себя и своего отца, затем производит обращение к системному вызову fork(), после чего и данный процесс, и его потомок снова печатают идентификаторы. Соответственно, на экране в случае успешной обработки всех системных вызовов будут напечатаны три строки.
int main(int argc, char **argv)
{
/* печать PID текущего процесса и PID процесса-предка */
printf("PID=%d; PPID=%d \n", getpid(), getppid());
/* создание нового процесса */
fork();
/* с этого момента два процесса функционируют параллельно и
независимо*/
/* оба процесса печатают PID текущего процесса и PID
процесса-предка */
printf("PID=%d; PPID=%d \n", getpid(), getppid());
}
Редко бывает, когда в процессе происходит обращение лишь к системному вызову fork(). Обычно к нему происходит обращение в связке с одним из семейства системных вызовов exec(). Последние обеспечивают смену тела текущего процесса. В это семейство входят вызовы, у которых в названии префиксная часть обычно представлена как exec, а суффиксная часть служит для уточнения сигнатуры того или иного системного вызова. В качестве иллюстрации приведем определение системного вызова execl().
#include <unistd.h>
int execl(const char *path, char *arg0, ..., char *argn, 0);
Параметр path указывает на имя исполняемого файла. Параметры arg0, …, argn являются аргументами программы, передаваемые ей при вызове (это те параметры, которые будут содержаться в массиве argv при входе в программу). При неудачном завершении возвращается -1, а в переменной errno устанавливается код ошибки.
Итак, концептуально все системные вызовы семейства exec() работают следующим образом. Через параметры вызова передается указание на имя некоторого исполняемого файла, а также набор аргументов, которые передаются внутрь при запуске этого исполняемого файла. При выполнении данных системных вызовов происходит замена тела текущего процесса на тело, образованное в результате загрузки исполняемого файла, и управление передается на точку входа в новое тело.
Рассмотрим небольшой пример (Рис. 77.). Запускается процесс (ему ставится в соответствие идентификатор 2757), который обращается к системному вызову execl(), для смены своего тела телом команды ls -l, которая отображает содержимое текущего каталога. Реализация данной команды хранится, соответственно, в файле /bin/ls. После успешного завершения системного вызова execl() процесс (с тем же идентификатором 2757) будет содержать реализацию команды ls, и управление в нем будет передано на точку входа (т.е. запустится функция main()).
При обращении к системным вызовам семейства exec() сохраняются основные атрибуты текущего процесса (в частности, идентификатор процесса, идентификатор родительского процесса, приоритет и др.), а также сохраняются все открытые в текущем процессе файлы (за исключением, быть может, файлов, открытых в специальном режиме). С другой стороны, изменяются режимы обработки сигналов, эффективные идентификаторы владельца и группы и прочая системная информация, которая должна корректироваться при смене тела процесса.
-
Пример использования системного вызова execl().
Приведем ряд примеров для иллюстрации применения различных вызовов семейства exec().
Пример. Если обращение к системному вызову будет неуспешным, то функция printf() отобразит на экране соответствующий текст.
#include <unistd.h>
int main(int argc, char **argv)
{
...
/*тело программы*/
...
execl(“/bin/ls”, ”ls”, ”-l”, (char*)0);
/* или execlp(“ls”, ”ls”, ”-l”, (char*)0); */
printf(“это напечатается в случае неудачного обращения к предыдущей функции, к примеру, если не был найден файл ls \n”);
...
}
Пример. Вызов C-компилятора. В данном случае второй параметр — вектор из указателей на параметры строки, которые будут переданы в вызываемую программу. Как и ранее, первый указатель — имя программы, последний — нулевой указатель. Эти вызовы удобны, когда заранее неизвестно число аргументов вызываемой программы.
int main(int argc, char **argv)
{
char *pv[]={“cc”, “-o”, “ter”, “ter.c”, (char*)0};
...
/*тело программы*/
...
execv (“/bin/cc”, pv);
...
}
Итак, мы рассмотрели по отдельности системные вызовы fork() и exec(), но в ОС Unix обычно применяется связка вызовов fork-exec.
Для иллюстрации сказанного рассмотрим еще один пример. В данном случае родительский процесс (PID = 2757) порождает своего потомка посредством обращения к системному вызову fork(), после чего в отцовском процессе управление переходит на else-блок. В то же время в дочернем процессе (PID = 2760) управление передается на первую инструкцию then-блока, где происходит обращение к системному вызову execl(). После чего тело дочернего процесса меняется на тело команды ls.
-
Пример использования схемы fork-exec.
Рассмотрим еще один пример. Программа порождает три процесса, каждый из которых запускает программу echo посредством системного вызова exec(). Данный пример демонстрирует важность проверки успешного завершения системного вызова exec(), в противном случае возможно исполнение нескольких копий исходной программы. В нашем случае, если все вызовы exec() проработают неуспешно, то копий программ будет восемь. Если все вызовы exec() будут успешными, то после последнего вызова fork() будет существовать четыре копии процесса. В каком порядке они пойдут на выполнение предсказать трудно.
int main(int argc, char **argv)
{
if(fork() == 0)
{
execl(“/bin/echo”,”echo”,”это”,”сообщение один”,NULL);
printf(“ошибка”);
}
if(fork() == 0)
{
execl(“/bin/echo”,”echo”,”это”,”сообщение два”,NULL);
printf(“ошибка”);
}
if(fork() == 0)
{
execl(“/bin/echo”,”echo”,”это”,”сообщение три”,NULL);
printf(“ошибка”);
}
printf(“процесс-предок закончился”);
}
Результат работы может быть следующим:
процесс-предок закончился
это сообщение три
это сообщение один
это сообщение два
Теперь рассмотрим системные вызовы, которые сопутствуют базовым системным вызовам управления процессами в ОС Unix. Прежде всего, речь пойдет о завершении процесса. Вообще говоря, процесс может завершиться по одной из двух причин. Первая причина связана с возникновением в процессе сигнала. Сигнал можно считать программным аналогом прерывания, и речь о них пойдет ниже при обсуждении вопросов взаимодействия процессов. Сигнал может быть связан с тем, что в процессе произошло деление на ноль, или сигнал может прийти от другого процесса с указанием незамедлительного завершения. Вторая причина связана с обращением к системному вызову завершения процесса. При этом обращение может быть явным, когда в теле программы встречается обращение к системному вызову _exit(), или неявным, если происходит выполнение оператора return языка C внутри функции main(). В последнем случае компилятор заменит действие оператора return обращением к системному вызову _exit().
#include <unistd.h>
void _exit(int status);
Системный вызов exit() не возвращает никакого значения, поскольку он всегда прорабатывает. А через его единственный параметр status возвращается т.н. программный код завершения. Это значение передается операционной системе как код завершения программы. В принципе значение этой переменной может быть произвольным, но в системе есть договоренность, что возврат нулевого значения сигнализирует об успешном завершении процесса, остальные значения трактуются как ошибочное завершение (в частности, процесс может возвращать некий код ошибки).
Рассмотрим, что происходит с процессом и в системе при обращении к системному вызову exit(). Очевидно, что сиюминутно процесс не может завершиться, поэтому процесс переходит в переходное состояние — т.н. состояние зомби. При этом выполняется целая совокупность действий в системе, связанных с завершением процесса. Во-первых, корректно освобождаются ресурсы (закрываются файлы, освобождаются оперативная память и пр.). Во-вторых, поскольку ОС Unix является «семейственной» системой (у каждого процесса может быть целая иерархия потомков), стоит проблема, какой процесс считать отцовским после завершения данного родительского процесса, и в ОС Unix принято решение, что все сыновние процессы усыновляются процессом с номером 1. И, наконец, процессу-предку от данного завершаемого процесса передается сигнал SIGCHLD, но в большинстве случаев его игнорируют.
Симметричную картину иллюстрирует системный вызов wait(), который обеспечивает в процессе получение информации о факте завершения одного из его потомков.
#include <sys/types.h>
#include <sys/wait.h>
pid_t wait(int *status);
Обычно при обращении к системному вызову wait() возможны следующие варианты. Во-первых, если до обращения к этому системному вызову какие-то сыновние процессы уже завершились, то процесс получит информацию об одном из этих процессов. Если же у процесса нет дочерних процессов, то, обращаясь к системному вызову wait(), процесс сразу получит соответствующий код ответа. В-третьих, если у процесса имеются дочерние процессы, но ни один из них не завершился, то при обращении к указанному системному вызову данный отцовский процесс будет блокирован до завершения одного из своих сыновних процессов.
По факту завершения одного из процессов родительский процесс при обращении к системному вызову wait() получает следующую информацию. В случае успешного завершения возвращается идентификатор PID завершившегося процесса, или же -1 — в случае ошибки или прерывания. А через параметр status передается указатель на целочисленную переменную, в которой система возвращает процессу причины завершения сыновнего процесса. Данный параметр содержит в старшем байте код завершения процесса-потомка (пользовательский код завершения процесса), передаваемый в качестве параметра системному вызову exit(), а в младшем байте — индикатор причины завершения процесса-потомка, устанавливаемый ядром ОС Unix (системный код завершения процесса). Системный код завершения хранит номер сигнала, приход которого в сыновний процесс вызвал его завершение.
Необходимо сделать замечание, касающееся системного вызова wait(). Данный системный вызов не всегда отрабатывает на завершении дочернего процесса. В случае если отцовский процесс производит трассировку сыновнего процесса, то посредством системного вызова wait() можно фиксировать факт приостановки сыновнего процесса, причем сыновний процесс после этого может быть продолжен (т.е. не всегда он должен завершиться, чтобы отцовский процесс получил информацию о сыне). С другой стороны, имеется возможность изменить режим работы системного вызова wait() таким образом, чтобы отцовский процесс не блокировался в ожидании завершения одного из потомков, а сразу получал соответствующий код ответа.
![](https://s.studizba.com/z.php?f=/templates/si/i/noavatar.png&w=100&h=100&t=1"){kind=avatar}
