Differences between fork and exec

What are the differences between fork and exec ?

9 Answers 9

The use of fork and exec exemplifies the spirit of UNIX in that it provides a very simple way to start new processes.

The fork call basically makes a duplicate of the current process, identical in almost every way. Not everything is copied over (for example, resource limits in some implementations) but the idea is to create as close a copy as possible.

The new process (child) gets a different process ID (PID) and has the PID of the old process (parent) as its parent PID (PPID). Because the two processes are now running exactly the same code, they can tell which is which by the return code of fork — the child gets 0, the parent gets the PID of the child. This is all, of course, assuming the fork call works — if not, no child is created and the parent gets an error code.

The exec call is a way to basically replace the entire current process with a new program. It loads the program into the current process space and runs it from the entry point.

So, fork and exec are often used in sequence to get a new program running as a child of a current process. Shells typically do this whenever you try to run a program like find — the shell forks, then the child loads the find program into memory, setting up all command line arguments, standard I/O and so forth.

But they’re not required to be used together. It’s perfectly acceptable for a program to fork itself without exec ing if, for example, the program contains both parent and child code (you need to be careful what you do, each implementation may have restrictions). This was used quite a lot (and still is) for daemons which simply listen on a TCP port and fork a copy of themselves to process a specific request while the parent goes back to listening.

Similarly, programs that know they’re finished and just want to run another program don’t need to fork , exec and then wait for the child. They can just load the child directly into their process space.

Some UNIX implementations have an optimized fork which uses what they call copy-on-write. This is a trick to delay the copying of the process space in fork until the program attempts to change something in that space. This is useful for those programs using only fork and not exec in that they don’t have to copy an entire process space.

If the exec is called following fork (and this is what happens mostly), that causes a write to the process space and it is then copied for the child process.

Note that there is a whole family of exec calls ( execl , execle , execve and so on) but exec in context here means any of them.

The following diagram illustrates the typical fork/exec operation where the bash shell is used to list a directory with the ls command:

Разница между fork () и exec ()

Каждое приложение (программа) приходит в исполнение посредством процесса, процесс — это запущенный экземпляр программы. Процессы создаются с помощью разных системных вызовов, наиболее популярными являются fork () и exec ()

fork () создает новый процесс путем дублирования вызывающего процесса. Новый процесс, называемый дочерним, является точной копией вызывающего процесса, называемого родительским, за исключением следующего:

1. У дочернего элемента есть собственный уникальный идентификатор процесса, и этот PID не совпадает с идентификатором какой-либо существующей группы процессов.
2. Идентификатор родительского процесса дочернего процесса совпадает с идентификатором родительского процесса.
3. Дочерний объект не наследует блокировки памяти своего родителя и настройки семафора.
4. Дочерний объект не наследует невыполненные асинхронные операции ввода-вывода от своего родителя и не наследует какие-либо контексты асинхронного ввода-вывода от своего родителя.

Возвращаемое значение fork ()
В случае успеха PID дочернего процесса возвращается в родительском, а 0 возвращается в дочернем. В случае ошибки -1 возвращается в родительский процесс, дочерний процесс не создается и значение errno устанавливается соответствующим образом.
Подробная статья о системном вызове fork

Exec ()

Семейство функций exec () заменяет текущий образ процесса новым образом процесса. Он загружает программу в текущее пространство процесса и запускает ее из точки входа.

Семейство exec () состоит из следующих функций, я реализовал execv () в следующей программе на C, вы можете попробовать отдых как упражнение

форк против exec

• fork запускает новый процесс, который является копией вызывающего его процесса, а exec заменяет текущий образ процесса другим (другим).
• И родительский, и дочерний процессы выполняются одновременно в случае fork (), в то время как Control никогда не возвращается в исходную программу, если не существует ошибки exec ().

// C программа для иллюстрации использования fork () &
// exec () системный вызов для создания процесса

#include
#include
#include
#include
#include
#include

// pid == -1 означает, что произошла ошибка

printf ( «can’t fork, error occured\n» );

// pid == 0 означает, что дочерний процесс создан

// getpid () возвращает идентификатор процесса вызывающего процесса

printf ( «child process, pid = %u\n» ,getpid());

// первый аргумент списка argv должен указывать на

// имя файла, связанного с исполняемым файлом

// указатель массива должен заканчиваться NULL

// execv () возвращается только в случае ошибки.

// Возвращаемое значение -1

execv( «ls» ,argv_list);

// положительное число возвращается для pid

// getppid () возвращает идентификатор процесса родителя

printf ( «parent process, pid = %u\n» ,getppid());

// родительский процесс вызывает waitpid () для дочернего процесса

// системный вызов waitpid () приостанавливает выполнение

// вызывать процесс до тех пор, пока дочерний элемент не будет указан pid

// аргумент изменил состояние

// см. справочную страницу wait () для всех флагов или опций

if (waitpid(pid, &status, 0) > 0) <

if (WIFEXITED(status) && !WEXITSTATUS(status))

printf ( «program execution successful\n» );

else if (WIFEXITED(status) && WEXITSTATUS(status)) <

if (WEXITSTATUS(status) == 127) <

// execv не удалось

printf ( «execv failed\n» );

printf ( «program terminated normally,»

» but returned a non-zero status\n» );

printf ( «program didn’t terminate normally\n» );

// waitpid () не удалось

printf ( «waitpid() failed\n» );

Ссылки :
Справочные страницы Linux

Эта статья предоставлена Мандипом Сингхом . Если вы как GeeksforGeeks и хотели бы внести свой вклад, вы также можете написать статью с помощью contribute.geeksforgeeks.org или по почте статьи contribute@geeksforgeeks.org. Смотрите свою статью, появляющуюся на главной странице GeeksforGeeks, и помогите другим вундеркиндам.

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

4.7. Функции fork и exec

4.7. Функции fork и exec

Прежде чем рассматривать создание параллельного сервера (что мы сделаем в следующем разделе), необходимо описать функцию Unix fork. Эта функция является единственным способом создания нового процесса в Unix.

Возвращает: 0 в дочернем процессе, идентификатор дочернего процесса в родительском процессе, -1 в случае ошибки

Если вы никогда не встречались с этой функцией, трудным для понимания может оказаться то, что она вызывается один раз, а возвращает два значения. Одно значение эта функция возвращает в вызывающем процессе (который называется родительским процессом) — этим значением является идентификатор созданного процесса (который называется дочерним процессом). Второе значение (нуль) она возвращает в дочернем процессе. Следовательно, по возвращаемому значению можно определить, является ли данный процесс родительским или дочерним.

Причина того, что функция fork возвращает в дочернем процессе нуль, а не идентификатор родительского процесса, заключается в том, что у дочернего процесса есть только один родитель, и дочерний процесс всегда может получить идентификатор родительского, вызвав функцию getppid. У родителя же может быть любое количество дочерних процессов, и способа получить их идентификаторы не существует. Если родительскому процессу требуется отслеживать идентификаторы своих дочерних процессов, он должен записывать возвращаемые значения функции fork.

Все дескрипторы, открытые в родительском процессе перед вызовом функции fork, становятся доступными дочерним процессам. Вы увидите, как это свойство используется сетевыми серверами: родительский процесс вызывает функцию accept, а затем функцию fork. Затем присоединенный сокет совместно используется родительским и дочерним процессами. Обычно дочерний процесс использует присоединенный сокет для чтения и записи, а родительский процесс только закрывает присоединенный сокет.

Существует два типичных случая применения функции fork:

1. Процесс создает свои копии таким образом, что каждая из них может обрабатывать одно задание. Это типичная ситуация для сетевых серверов. Далее в тексте вы увидите множество подобных примеров.

2. Процесс хочет запустить другую программу. Поскольку единственный способ создать новый процесс — это вызвать функцию fork, процесс сначала вызывает функцию fork, чтобы создать свою копию, а затем одна из копий (обычно дочерний процесс) вызывает функцию exec (ее описание следует за описанием функции fork), чтобы заменить себя новой программой. Этот сценарий типичен для таких программ, как интерпретаторы командной строки.

Единственный способ запустить в Unix на выполнение какой-либо файл — вызвать функцию exec. (Мы будем часто использовать общее выражение «функция exec», когда неважно, какая из шести функций семейства exec вызывается.) Функция exec заменяет копию текущего процесса новым программным файлом, причем в новой программе обычно запускается функция main. Идентификатор процесса при этом не изменяется. Процесс, вызывающий функцию exec, мы будем называть вызывающим процессом, а выполняемую при этом программу — новой программой.

В старых описаниях и книгах новая программа ошибочно называется «новым процессом». Это неверно, поскольку новый процесс не создается.

Различие между шестью функциями exec заключается в том, что они допускают различные способы задания аргументов:

? выполняемый программный файл может быть задан или именем файла (filename), или полным именем (pathname);

? аргументы новой программы либо перечисляются один за другим, либо на них имеется ссылка через массив указателей;

? новой программе либо передается окружение вызывающего процесса, либо задается новое окружение.

int execl(const char *pathname, const char *arg0, . /* (char*)0 */ );

int execv(const char *pathname, char *const argv[]);

int execle(const char *pathname, const char *arg0 . /* (char*)0,

int execve(const char *pathname, char *const argv[], char *const envp[]);

int execlp(const char *filename, const char *arg0, . /* (char*)0 */ );

int execvp(const char *filename, char *const argv[]);

Все шесть функций возвращают: -1 в случае ошибки, если же функция выполнена успешно, то ничего не возвращается

Эти функции возвращают вызывающему процессу значение -1, только если происходит ошибка. Иначе управление передается в начало новой программы, обычно функции main.

Отношения между этими шестью функциями показаны на рис. 4.4. Обычно только функция execve является системным вызовом внутри ядра, а остальные представляют собой библиотечные функции, вызывающие execve.

Рис. 4.4. Отношения между шестью функциями exec

Отметим различия между этими функциями:

1. Три верхних функции (см. рис. 4.4) принимают каждую строку как отдельный аргумент, причем перечень аргументов завершается пустым указателем (так как их количество может быть различным). У трех нижних функций имеется массив argv, содержащий указатели на строки. Этот массив должен содержать пустой указатель, определяющий конец массива, поскольку размер массива не задается.

2. Две функции в левой колонке получают аргумент filename. Он преобразуется в pathname с использованием текущей переменной окружения PATH. Если аргумент filename функций execlp или execvp содержит косую черту (/) в любом месте строки, переменная PATH не используется. Четыре функции в двух правых колонках получают полностью определенный аргумент pathname.

3. Четыре функции в двух левых колонках не получают явного списка переменных окружения. Вместо этого с помощью текущего значения внешней переменной environ создается список переменных окружения, который передается новой программе. Две функции в правой колонке получают точный список переменных окружения. Массив указателей envp должен быть завершен пустым указателем.

Дескрипторы, открытые в процессе перед вызовом функции exec, обычно остаются открытыми во время ее выполнения. Мы говорим «обычно», поскольку это свойство может быть отключено при использовании функции fcntl для установки флага дескриптора FD_CLOEXEC. Это нужно серверу inetd, о котором пойдет речь в разделе 13.5.

Данный текст является ознакомительным фрагментом.

Продолжение на ЛитРес

Читайте также

9.1.1. Создание процесса: fork()

9.1.1. Создание процесса: fork() Первым шагом в запуске новой программы является вызов fork():#include /* POSIX */#include pid_t fork(void);Использование fork() просто. Перед вызовом один процесс, который мы называем родительским, является запущенным. Когда fork() возвращается, имеется

9.1.1.1. После fork() : общие и различные атрибуты

9.1.1.1. После fork(): общие и различные атрибуты Порожденный процесс «наследует» идентичные копии большого числа атрибутов от родителя. Многие из этих атрибутов специализированы и здесь неуместны. Поэтому следующий список намеренно неполон. Существенны

9.1.4. Запуск новой программы: семейство exec()

9.1.4. Запуск новой программы: семейство exec() После запуска нового процесса (посредством fork()) следующим шагом является запуск в процессе другой программы. Имеется несколько функций, которые служат различным целям:#include /* POSIX */int execve(const char *filename, /* Системный вызов */char

9.1.4.4. Атрибуты, наследуемые exec()

9.1.4.4. Атрибуты, наследуемые exec() Как и в случае с fork(), после вызова программой exec сохраняется ряд атрибутов:• Все открытые файлы и открытые каталоги; см. раздел 4.4.1 «Понятие о дескрипторах файлов» и раздел 3.3.1 «Базовое чтение каталогов». (Сюда не входят файлы, помеченные для

9.4.3.1. Флаг close-on-exec

9.4.3.1. Флаг close-on-exec После вызова fork() и перед вызовом exec() следует убедиться, что новая программа наследует лишь те открытые файлы, которые ей нужны. Вы не захотите, чтобы порожденный процесс мешался в открытых файлах родителя, если только это так не задумано. С другой стороны,

10.9. Сигналы, передающиеся через fork() и exec()

10.9. Сигналы, передающиеся через fork() и exec() Когда программа вызывает fork(), ситуация с сигналами в порожденном процессе почти идентична ситуации в родительском процессе. Установленные обработчики остаются на месте, заблокированные сигналы остаются заблокированными и т.д.

4.7. Функции fork и exec

4.7. Функции fork и exec Прежде чем рассматривать создание параллельного сервера (что мы сделаем в следующем разделе), необходимо описать функцию Unix fork. Эта функция является единственным способом создания нового процесса в Unix.#include pid_t fork(void);Возвращает: 0 в дочернем

9.1.2.1 Выгрузка при выполнении системной функции fork

9.1.2.1 Выгрузка при выполнении системной функции fork В описании системной функции fork (раздел 7.1) предполагалось, что процесс-родитель получил в свое распоряжение память, достаточную для создания контекста потомка. Если это условие не выполняется, ядро выгружает процесс из

9.2.1.1 Функция fork в системе с замещением страниц

9.2.1.1 Функция fork в системе с замещением страниц Как уже говорилось в разделе 7.1, во время выполнения функции fork ядро создает копию каждой области родительского процесса и присоединяет ее к процессу-потомку. В системе с замещением страниц ядро по традиции создает

5.1. Системные вызовы fork() и ехес()

5.1. Системные вызовы fork() и ехес() Процесс в Linux (как и в UNIX) — это программа, которая выполняется в отдельном виртуальном адресном пространстве. Когда пользователь регистрируется в системе, под него автоматически создается процесс, в котором выполняется оболочка (shell),

1.5. Действие команд fork, exec и exit на объекты IPC

1.5. Действие команд fork, exec и exit на объекты IPC Нам нужно достичь понимания действия функций fork, exec и _exit на различные формы IPC, которые мы обсуждаем (последняя из перечисленных функций вызывается функцией exit). Информация по этому вопросу сведена в табл. 1.4.Большинство функций

16.1. С помощью команды exec

16.1. С помощью команды exec Команда exec &1 # Связать дескр. #6 со stdout. # Сохраняя stdout.exec > $LOGFILE # stdout замещается файлом «logfile.txt».# ———————————————————— ## Весь вывод от команд, в данном блоке, записывается в файл

2.1.13. Опции -exec и -ok

2.1.13. Опции -exec и -ok Предположим, вы нашли нужные файлы и хотите выполнить по отношению к ним определенные действия. В этом случае вам понадобится опция -exec (некоторые системы позволяют с помощью опции -exec выполнять только команды ls илиls -l). Многие пользователи применяют

5.8. Команда exec

5.8. Команда exec Команда exec заменяет текущий интерпретатор shell указанной командой. Обычно она используется для того, чтобы закрыть текущий интерпретатор и запустить другой. Но у нее есть и другое применение. Например, команда видаexec