Man execlp (3): запуск файла на исполнение
The exec system call is used to execute a file which is residing in an active process. When exec is called the previous executable file is replaced and new file is executed.
More precisely, we can say that using exec system call will replace the old file or program from the process with a new file or program. The entire content of the process is replaced with a new program.
The user data segment which executes the exec() system call is replaced with the data file whose name is provided in the argument while calling exec().
The new program is loaded into the same process space. The current process is just turned into a new process and hence the process id PID is not changed, this is because we are not creating a new process we are just replacing a process with another process in exec.
If the currently running process contains more than one thread then all the threads will be terminated and the new process image will be loaded and then executed. There are no destructor functions that terminate threads of current process.
PID of the process is not changed but the data, code, stack, heap, etc. of the process are changed and are replaced with those of newly loaded process. The new process is executed from the entry point.
Exec system call is a collection of functions and in C programming language, the standard names for these functions are as follows:
- execl
- execle
- execlp
- execv
- execve
- execvp
It should be noted here that these functions have the same base exec followed by one or more letters. These are explained below:
e: It is an array of pointers that points to environment variables and is passed explicitly to the newly loaded process.
l: l is for the command line arguments passed a list to the function
p: p is the path environment variable which helps to find the file passed as an argument to be loaded into process.
v: v is for the command line arguments. These are passed as an array of pointers to the function.
Why exec is used?
exec is used when the user wants to launch a new file or program in the same process.
Inner Working of exec
Consider the following points to understand the working of exec:
- Current process image is overwritten with a new process image.
- New process image is the one you passed as exec argument
- The currently running process is ended
- New process image has same process ID, same environment, and same file descriptor (because process is not replaced process image is replaced)
- The CPU stat and virtual memory is affected. Virtual memory mapping of the current process image is replaced by virtual memory of new process image.
Syntaxes of exec family functions:
The following are the syntaxes for each function of exec:
int execl(const char* path, const char* arg, …)
int execlp(const char* file, const char* arg, …)
int execle(const char* path, const char* arg, …, char* const envp)
int execv(const char* path, const char* argv)
int execvp(const char* file, const char* argv)
int execvpe(const char* file, const char* argv, char *const envp)
Description:
The return type of these functions is Int. When the process image is successfully replaced nothing is returned to calling function because the process that called it is no longer running. But if there is any error -1 will be returned. If any error is occurred an errno is set.
- path is used to specify the full path name of the file which is to be executes.
- arg is the argument passed. It is actually the name of the file which will be executed in the process. Most of the times the value of arg and path is same.
- const char* arg in functions execl(), execlp() and execle() is considered as arg0, arg1, arg2, …, argn. It is basically a list of pointers to null terminated strings. Here the first argument points to the filename which will be executed as described in point 2.
- envp is an array which contains pointers that point to the environment variables.
- file is used to specify the path name which will identify the path of new process image file.
- The functions of exec call that end with e are used to change the environment for the new process image. These functions pass list of environment setting by using the argument envp . This argument is an array of characters which points to null terminated String and defines environment variable.
To use the exec family functions, you need to include the following header file in your C program:
#include
Example 1: Using exec system call in C program
Consider the following example in which we have used exec system call in C programming in Linux, Ubuntu: We have two c files here example.c and hello.c:
example.c
#include
#include
#include
{
printf
("PID of example.c = %d\n
"
,
getpid()
)
;
char
*
args
=
{
"Hello"
,
"C"
,
"Programming"
,
NULL}
;
execv("./hello"
,
args)
;
printf
("Back to example.c"
)
;
return
0
;
}
hello.c
PID of example.c = 4733
We are in Hello.c
PID of hello.c = 4733
In the above example we have an example.c file and hello.c file. In the example .c file first of all we have printed the ID of the current process (file example.c is running in current process). Then in the next line we have created an array of character pointers. The last element of this array should be NULL as the terminating point.
Then we have used the function execv() which takes the file name and the character pointer array as its argument. It should be noted here that we have used ./ with the name of file, it specifies the path of the file. As the file is in the folder where example.c resides so there is no need to specify the full path.
When execv() function is called, our process image will be replaced now the file example.c is not in the process but the file hello.c is in the process. It can be seen that the process ID is same whether hello.c is process image or example.c is process image because process is same and process image is only replaced.
Then we have another thing to note here which is the printf() statement after execv() is not executed. This is because control is never returned back to old process image once new process image replaces it. The control only comes back to calling function when replacing process image is unsuccessful. (The return value is -1 in this case).
Difference between fork() and exec() system calls:
The fork() system call is used to create an exact copy of a running process and the created copy is the child process and the running process is the parent process. Whereas, exec() system call is used to replace a process image with a new process image. Hence there is no concept of parent and child processes in exec() system call.
In fork() system call the parent and child processes are executed at the same time. But in exec() system call, if the replacement of process image is successful, the control does not return to where the exec function was called rather it will execute the new process. The control will only be transferred back if there is any error.
Example 2: Combining fork() and exec() system calls
Consider the following example in which we have used both fork() and exec() system calls in the same program:
example.c
#include
#include
#include
int
main(int
argc,
char
*
argv
)
{
printf
("PID of example.c = %d\n
"
,
getpid()
)
;
pid_t p;
p =
fork()
;
if
(p==-
1
)
{
{
printf
("We are in the parent process"
)
;
}
return
0
;
}
hello.c:
PID of example.c = 4790
We are in Parent Process
We are in Child Process
Calling hello.c from child process
We are in hello.c
PID of hello.c = 4791
In this example we have used fork() system call. When the child process is created 0 will be assigned to p and then we will move to the child process. Now the block of statements with if(p==0) will be executed. A message is displayed and we have used execv() system call and the current child process image which is example.c will be replaces with hello.c. Before execv() call child and parent processes were same.
It can be seen that the PID of example.c and hello.c is different now. This is because example.c is the parent process image and hello.c is the child process image.
Функция Функции, загружающие и запускающие другие программы.
Синтаксис int execl(char * pathname, char * arg0, arg1, ...,
argn, NULL);
int execle(char * pathname, char * arg0, arg1,
..., argn, NULL, char ** envp);
int execlp(char * pathname, char * arg0, arg1,
..., argn, NULL);
int execlpe(char * pathname, char * arg0, arg1,
..., argn, NULL, char ** envp);
int execv(char * pathname, char * argv);
int execve(char * pathname, char * argv,
char ** envp);
int execvp(char * pathname, char * argv);
int execvpe(char * pathname, char * argv,
char ** envp);
Файл, содержащий process.h
прототип
Описание Семейство функций exec... загружает и запускает
другие программы, известные как "дочерние"
процессы. Если вызов функции exec... завершается
успешно, "дочерний" процесс накладывается на
"родительский" процесс; причем должно быть
достаточно памяти для загрузки и выполнения
"дочернего" процесса.
pathname - это имя файла вызываемого "дочернего"
процесса. Функции exec... производят поиск
pathname, пользуясь стандартным алгоритмом системы
DOS:
- Нет расширения имени файла и нет точки; в таком
случае производится поиск точного имени файла,
если такое имя не найдено, добавляется расширение.com и поиск продолжается. Если и такого файла не
найдено, то добавляется расширение.exe и поиск
выполняется последний раз.
- Расширение имени присутствует - производится
поиск по точному имени файла;
Суффиксы l, v, p и e, добавляемые к имени семейства
exec... обозначают, что данная функция будет
работать с некоторыми особенностями:
p - определяет, что функция будет искать "дочернюю"
программу в директориях, определяемых
переменной среды DOS PATH. Без суффикса p поиск
будет производиться только в рабочем каталоге.
Если параметр path не содержит маршрута, то
поиск производится в текущей директории, а
затем по маршрутaм, определяемым переменной
окружения PATH.
l - показывает, что адресные указатели (arg0, arg1,
..., argn) передаются, как отдельные аргументы.
Обычно суффикс l употребляется, когда число пере-
даваемых аргументов заранее вам известно.
v - показывает, что адресные указатели (arg,
arg,...arg[n]) передаются, как массив
указателей. Обычно, суффикс v используется,
когда передаeтся переменное число аргументов.
e - показывает, что "дочернему" процессу может быть
передан аргумент envp, который позволяет
выбирать среду "дочернего" процесса. Без
суффикса e "дочерний" процесс унаследует среду
"родительского" процесса.
Каждая функция семейства exec... должна иметь один
из двух суффиксов, определяющих аргументы (либо l,
либо v). Суффиксы определения маршрута доступа
(PATH) и унаследования операционной среды (p и e)
являются необязательными.
Например:
- execl - представляет собой функцию семейства
exec..., которая передает раздельные аргументы,
ищет "дочерний" процесс только в рабочем каталоге
и передает "родительскую" среду "дочернему"
процессу.
- execvpe представляет собой функцию семейства
exec..., которая передает массив указателей
аргументов, подсоединяет маршрут доступа PATH для
поиска "дочернего" процесса и применяет аргумент
envp для выбора среды "дочернего" процесса.
Функция семейства exec... должна передавать
"дочернему" процессу хотя бы один аргумент (arg0
или argv). Данный аргумент, по соглашению,
представляет собой копию pathname. (Использование
других значений для нулевого аргумента не будет
ошибкой).
В системах DOS версий 3.X "дочерний" процесс может
получить аргумент pathname; в более ранних версиях
"дочерний" процесс не может использовать значение
нулевого аргумента (arg0 или argn).
При использовании суффикса l, арг0 обычно указывает
на pathname, а arg1, ..., argn указывают на строки
символов, которые формируют новый список
аргументов. Завершающий NULL, следующий за argn,
обозначает конец списка.
При использовании суффикса e список назначенной
среды передается с помощью аргумента envp. Данный
аргумент является массивом из элементов типа char*.
Каждый элемент указывает на символьную строку с
нулевым окончанием формы:
envvar = value , где
envvar - имя переменной среды, а value- значение
символьной строки, которая присваивается каждой
переменной envvar. Последним элементом в массиве
envp является адресный нуль NULL. Когда значением
envp является NULL, "дочерний" процесс наследует
назначения среды "родительского" процесса.
Общая длина arg0+ arg1+...+argn (или arg+
arg+...+arg[n]), включая пробелы, разделяющие
аргументы, должна быть меньше 128 байтов. Нулевые
окончания не считаются.
При вызове функции exec... любые открытые файлы
остаются открытыми и в "дочернем" процессе.
Возвращаемое При успешном завершении функции exec... не возвра-
значение щают никакого значения. При возникновении ошибки
функции exec... возвращают значение -1, а
глобальная переменная errno получает одно из
следующих значений:
E2BIG - Слишком длинный список аргументов.
EACCES - Отказ доступа.
EMFILE - Слишком много открытых файлов.
ENOENT - Маршрут доступа (PATH) или имя файла не
найдены.
ENOEXEC - Ошибка формата EXEC.
ENOMEM - Не хватает памяти.
Переносимость exec... уникальна для DOS.
Смотрите также: abort, atexit,_exit, exit, _fpreset, searchpath,
spawn..., system.
Пример:
#include
int execle(char *fname, char *arg0, ..., char *argN, NULL, char *envp)
int execlp(char *fname, char *arg0, ..., char *argN, NULL)
int execlpe(char *fname, char *arg0, ..., char *argN, NULL, char *envp)
int execv(char *fname, char *arg)
int execve(char *fname, char *arg, char *envp)
int execvp(char *fname, char *arg)
int execvpe(char *fname, char *arg, char *envp)
Описание:
Эти функции не определены стандартом ANSI С.
Группа функций exec используется для выполнения другой программы. Эта другая программа, называемая процессом-потомком (child process), загружается поверх программы, содержащей вызов exec. Имя файла, содержащего процесс-потомок, задано с помощью параметра fname. Какие-либо аргументы, передаваемые процессу-потомку, задаются либо с помощью параметров от arg0 до argN, либо с помощью массива arg. Параметр envp должен указывать на строку окружения. (Аргументы, на которые указывает argv в процессе-потомке.)
Если fname не содержит расширения или точки, то поиск сначала производится по имени файла. При неудаче добавляется расширение ЕХЕ и поиск повторяется. При неудаче используется расширение СОМ и поиск опять повторяется. Если же расширение указывается, то осуществляется поиск только на предмет точного совпадения. Наконец, если имеется точка, но расширение не указано, то поиск осуществляется по левой части имени файла.
Точный способ исполнения процесса-потомка зависит от вызываемой версии функции exec. Можно представить себе функцию exec как имеющую различные суффиксы, задающие ее операции. Суффикс может состоять из одного или двух символов.
Функции, имеющие в качестве суффикса р, ищут процесс-потомок в каталогах, заданных командой PATH. Если же суффикс р отсутствует, то поиск осуществляется только в текущем каталоге.
Если задан суффикс l, то значит, аргументы передаются процессу-потомку индивидуально, а не массивом. Этот метод используется при передаче фиксированного числа аргументов. Следует обратить внимание, что последний аргумент должен быть NULL. (NULL определен в stdio.h .)
Суффикс v означает, что аргументы передаются процессу-потомку в массиве. Этот способ используется тогда, когда заранее не известно, сколько аргументов будет передано процессу-потомку, либо же число аргументов может изменяться во время выполнения программы. Обычно конец массива обозначается нулевым указателем.
Суффикс е указывает, что процессу-потомку будет передана одна или более строк окружения. Параметр envp представляет собой массив указателей на строки. Каждая строка, на которую указывает массив, должна иметь следующий вид: переменная_окружения = значение
Последний указатель в массиве должен быть NULL. Если же первый элемент массива является NULL, то процесс-потомок сохраняет то же самое окружение, что и процесс-предок.
Важно помнить, что файлы, открытые при вызове exec, являются также открытыми в программе-потомке.
В случае успеха функция exec не возвращает значения. При неудаче возвращается значение -1, а переменная errno устанавливается равной одному из следующих значений:
Первая из следующих программ вызывает вторую, которая выводит свои аргументы. Следует иметь в виду, что обе программы должны находиться в отдельных файлах.
/* первый файл - родитель */
#include
#include
#include
int
main(void
)
{
execl("test.exe"
,
"test.exe"
,
"hello"
,
"10"
,
NULL)
;
return
0
;
}
/* второй файл - потомок */
#include
#include
int
main(int
argc,
char
*
argv
)
{
printf
("This program is executed with these command line "
)
;
printf
("arguments: "
)
;
printf
(argv[
1
]
)
;
printf
(" %d"
,
atoi
(argv[
2
]
)
)
;
return
0
;
}
EXEC(2)
НАЗВАНИЕ
exec: execl, execv, execle, execve, execlp, execvp
выполнение файла
СИНТАКСИС
Int execl (path, arg0, arg1, ..., argn, (char*) 0) char *path, *arg0, *arg1, ..., *argn; int execv (path, argv) char *path, *argv ; int execle (path, arg0, arg1, ..., argn, (char*) 0, envp) char *path, *arg0, *arg1, ..., *argn, *envp ; int execve (path, argv, envp) char *path, *argv , *envp ; int execlp (file, arg0, arg1, ..., argn, (char*) 0) char *file, *arg0, *arg1, ..., *argn; int execvp (file, argv) char *file, *argv ;
ОПИСАНИЕ
Все формы системного вызова exec превращают вызвавший
процесс в новый процесс, который строится из обычного
выполняемого файла, называемого в дальнейшем новым
выполняемым файлом. Выполняемый файл состоит из заголовка [см. a.out(4)], сегмента команд (.text) и данных.
Данные состоят из инициализированной (.data) и неинициализированной (.bss) частей. Если системный вызов exec
закончился успешно, то он не может вернуть управление,
так как вызвавший процесс уже заменен новым процессом.
При запуске C-программы ее вызывают следующим образом:
Main (argc, argv, envp) int argc; char **argv, **envp;
где argc равен количеству аргументов, argv - массив указателей собственно на аргументы и envp - массив указателей на цепочки символов, образующие окружение. Принято соглашение, по которому значение argc не меньше 1, а первый элемент массива argv указывает на цепочку символов, содержащую имя нового выполняемого файла.
Аргументам системных вызовов группы exec приписан следующий смысл.
Аргумент path указывает на маршрутное имя нового выполняемого файла.
Как и path, аргумент file указывает новый выполняемый файл, но маршрут этого файла определяется в результате просмотра каталогов, переданных через переменную окружения PATH [см. environ(5) ]. Окружение поддерживается shell"ом [см. sh(1) ].
Аргументы arg0, arg1, ..., argn - это указатели на цепочки символов, ограниченные нулевыми байтами. Эти цепочки образуют доступный новому процессу список аргументов. По соглашению, как минимум arg0 должен присутствовать и указывать на цепочку символов, равную path (или последнему компоненту path).
Массив argv содержит указатели на цепочки символов, ограниченные нулевыми байтами. Эти цепочки образуют доступный новому процессу список аргументов. По соглашению, в argv должен присутствовать как минимум первый элемент, указывающий на цепочку символов, равную path (или последнему компоненту path). За последним занятым элементом массива argv должен следовать пустой (нулевой) указатель.
Массив envp содержит указатели на цепочки символов, ограниченные нулевыми байтами. Эти цепочки образуют окружение нового процесса. За последним занятым элементом массива envp должен следовать пустой указатель.
Перед началом выполнения любой программы во внешнюю переменную environ, описание которой выглядит как
Extern char **environ;
помещается адрес массива указателей на цепочки символов, образующие окружение процесса. С помощью этой переменной (как и с помощью аргумента envp функции main) в новом процессе всегда можно получить доступ к окружению, независимо от использовавшегося варианта системного вызова exec. Разница лишь в том, что в случае вызовов execle и execve окружение нового процесса задается явно, а в остальных случаях наследуется у вызвавшего процесса.
Файлы, открытые в вызвавшем процессе, остаются открытыми в новом процессе, за исключением тех, у которых установлен флаг "закрыть при выполнении вызова exec" [см. fcntl(2) ]. Если файл остался открытым, то указатель текущей позиции в файле сохраняется.
Реакция на сигналы сохраняется, за исключением того, что сигналы, которые перехватывались в вызвавшем процессе, вызывают терминирование нового процесса [см. signal(2) ].
В случае, когда реакция на сигналы устанавливалась вызовом sigset(2) и задавалась как SIG_DFL, SIG_IGN или SIG_HOLD, эта реакция наследуется у вызвавшего процесса. Однако, если сигнал перехватывался, то устанавливается реакция SIG_DFL и все полученные, но не обработанные сигналы этого типа откладываются.
Если у нового выполняемого файла установлен бит разрешения переустанавливать действующий идентификатор пользователя [см. chmod(2) ], то действующий идентификатор пользователя нового процесса устанавливается равным идентификатору владельца нового выполняемого файла. Аналогично, если у нового выполняемого файла установлен бит разрешения переустанавливать действующий идентификатор группы, то действующий идентификатор группы нового процесса устанавливается равным идентификатору группы нового выполняемого файла. Реальный идентификатор пользователя и реальный идентификатор группы нового процесса наследуются у вызвавшего процесса.
Присоединенные разделяемые сегменты памяти не наследуются новым процессом [см. shmop(2) ].
У нового процесса выключено профилирование.
Кроме того, новый процесс наследует у процесса, вызвавшего exec, следующие характеристики:
- Значение поправки к приоритету [см. nice(2) ].
- Идентификатор процесса.
- Идентификатор родительского процесса.
- Идентификатор группы процессов.
- semadj значения [см. semop(2) ].
- Идентификатор группы терминала [см. exit(2) ].
- Режим трассировки [см. ptrace(2) ].
- Время, оставшееся до срабатывания будильника [см. alarm(2) ].
- Текущий рабочий каталог.
- Корневой каталог.
- Маска режима создания файлов [см. umask(2) ].
- Ограничение на размер файла [см. ulimit(2) ].
- Счетчики времени, потраченного для обслуживания этого процесса (tms_utime, tms_stime, tms_cutime, tms_cstime) [см. times(2) ].
- Блокировки доступа к сегментам файлов [см. fcntl(2) и lockf(3C) ].
Системный вызов exec завершается неудачей и управление возвращается, если выполнено хотя бы одно из следующих условий: Компонент маршрута нового выполняемого файла не существует. Компонент маршрута нового выполняемого файла не является каталогом. Один из каталогов, перечисленных в маршруте нового выполняемого файла, не доступен для просмотра. Новый выполняемый файл не является обычным файлом. Нет прав на выполнение нового файла. Права на выполнение нового файла есть, но его заголовок не начинается с допустимого магического числа [см. a.out(4)]. Новый выполняемый файл в настоящий момент открыт для записи некоторым процессом. Новый процесс требует больше памяти, чем позволяет системное ограничение MAXMEM. Суммарная длина списка аргументов превышает системное ограничение, равное 5120 байт. Отсутствует требуемое оборудование. Некорректные адреса в качестве аргументов. Не хватает памяти. К требуемой разделяемой библиотеке не разрешен доступ на выполнение. Попытка непосредственно выполнить разделяемую библиотеку. Во время выполнения вызова exec перехвачен сигнал. Аргумент path указывает на удаленный компьютер, связи с которым в данный момент нет. Компоненты path требуют многократного обращения к удаленным компьютерам.