уществляет
вызов функции main, находящейся в другой программе, передавая ей свои аргументы в
качестве входных.
Системный вызов exec может не удаться, если указанный файл path не существует,
либо вы не имеете права его выполнять (такие коды доступа), либо он не является
выполняемой программой (неверное магическое число), либо слишком велик для данной
машины (системы), либо файл открыт каким-нибудь процессом (например еще записывается
компилятором). В этом случае продолжится выполнение прежней программы. Если же
вызов успешен - возврата из exec не происходит вообще (поскольку управление переда-
ется в другую программу).
Аргумент argv[0] обычно полагают равным path. По нему программа, имеющая нес-
колько имен (в файловой системе), может выбрать ЧТО она должна делать. Так программа
/bin/ls имеет альтернативные имена lr, lf, lx, ll. Запускается одна и та же прог-
рамма, но в зависимости от argv[0] она далее делает разную работу.
Аргумент envp - это "окружение" программы (см. начало этой главы). Если он не
задан - передается окружение текущей программы (наследуется содержимое массива, на
который указывает переменная environ); если же задан явно (например, окружение скопи-
ровано в какой-то массив и часть переменных подправлена или добавлены новые перемен-
ные) - новая программа получит новое окружение. Напомним, что окружение можно про-
честь из предопределенной переменной char **environ, либо из третьего аргумента функ-
ции main (см. начало главы), либо функцией getenv().
А. Богатырев, 1992-95 - 224 - Си в UNIX
Системные вызовы fork и exec не склеены в один вызов потому, что между fork и
exec в процессе-сыне могут происходить некоторые действия, нарушающие симметрию
процесса-отца и порожденного процесса: установка реакций на сигналы, перенаправление
ввода/вывода, и.т.п. Смотри пример "интерпретатор команд" в приложении. В MS DOS, не
имеющей параллельных процессов, вызовы fork, exec и wait склеены в один вызов spawn.
Зато при этом приходится делать перенаправления ввода-вывода в порождающем процессе
перед spawn, а после него - восстанавливать все как было.
6.5.4. Завершить процесс можно системным вызовом
void exit( unsigned char retcode );
Из этого вызова не бывает возврата. Процесс завершается: сегменты stack, data, text,
user уничтожаются (при этом все открытые процессом файлы закрываются); память, кото-
рую они занимали, считается свободной и в нее может быть помещен другой процесс.
Причина смерти отмечается в паспорте процесса - в структуре proc в таблице процессов
внутри ядра. Но паспорт еще не уничтожается! Это состояние процесса называется
"зомби" - живой мертвец.
В паспорт процесса заносится код ответа retcode. Этот код может быть прочитан
процессом-родителем (тем, кто создал этот процесс вызовом fork). Принято, что код 0
означает успешное завершение процесса, а любое положительное значение 1..255 означает
неудачное завершение с таким кодом ошибки. Коды ошибок заранее не предопределены:
это личное дело процессов отца и сына - установить между собой какие-то соглашения по
этому поводу. В старых программах иногда писалось exit(-1); Это некорректно - код
ответа должен быть неотрицателен; код -1 превращается в код 255. Часто используется
конструкция exit(errno);
Программа может завершиться не только явно вызывая exit, но и еще двумя спосо-
бами:
- если происходит возврат управления из функции main(), т.е. она кончилась - то
вызов exit() делается неявно, но с непредсказуемым значением retcode;
- процесс может быть убит сигналом. В этом случае он не выдает никакого кода
ответа в процесс-родитель, а выдает признак "процесс убит".
6.5.5. В действительности exit() - это еще не сам системный вызов завершения, а
стандартная функция. Сам системный вызов называется _exit(). Мы можем переопреде-
лить функцию exit() так, чтобы по окончании программы происходили некоторые действия:
void exit(unsigned code){
/* Добавленный мной дополнительный оператор: */
printf("Закончить работу, "
"код ответа=%u\n", code);
/* Стандартные операторы: */
_cleanup(); /* закрыть все открытые файлы.
* Это стандартная функция |= */
_exit(code); /* собственно сисвызов */
}
int f(){ return 17; }
void main(){
printf("aaaa\n"); printf("bbbb\n"); f();
/* потом откомментируйте это: exit(77); */
}
Здесь функция exit вызывается неявно по окончании main, ее подставляет в программу
компилятор. Дело в том, что при запуске программы exec-ом, первым начинает выпол-
няться код так называемого "стартера", подклеенного при сборке программы из файла
/lib/crt0.o. Он выглядит примерно так (в действительности он написан на ассемблере):
... // вычислить argc, настроить некоторые параметры.
main(argc, argv, envp);
exit();
А. Богатырев, 1992-95 - 225 - Си в UNIX
или так (взято из проекта GNU|-|-):
int errno = 0;
char **environ;
_start(int argc, int arga)
{
/* OS and Compiler dependent!!!! */
char **argv = (char **) &arga;
char **envp = environ = argv + argc + 1;
/* ... возможно еще какие-то инициализации,
* наподобие setlocale( LC_ALL, "" ); в SCO UNIX */
exit (main(argc, argv, envp));
}
Где должно быть
int main(int argc, char *argv[], char *envp[]){
...
return 0; /* вместо exit(0); */
}
Адрес функции _start() помечается в одном из полей заголовка файла формата a.out как
адрес, на который система должна передать управление после загрузки программы в
память (точка входа).
Какой код ответа попадет в exit() в этих примерах (если отсутствует явный вызов
exit или return) - непредсказуемо. На IBM PC в вышенаписанном примере этот код равен
17, то есть значению, возвращенному последней вызывавшейся функцией. Однако это не
какое-то специальное соглашение, а случайный эффект (так уж устроен код, создаваемый
этим компилятором).
6.5.6. Процесс-отец может дождаться окончания своего потомка. Это делается систем-
ным вызовом wait и нужно по следующей причине: пусть отец - это интерпретатор команд.
Если он запустил процесс и продолжил свою работу, то оба процесса будут предпринимать
попытки читать ввод с клавиатуры терминала - интерпретатор ждет команд, а запущенная
программа ждет данных. Кому из них будет поступать набираемый нами текст - непредс-
казуемо! Вывод: интерпретатор команд должен "заснуть" на то время, пока работает
порожденный им процесс:
int pid; unsigned short status;
...
if((pid = fork()) == 0 ){
/* порожденный процесс */
... // перенаправления ввода-вывода.
... // настройка сигналов.
exec(....);
perror("exec не удался"); exit(1);
}
/* иначе это породивший процесс */
while((pid = wait(&status)) > 0 )
printf("Окончился сын pid=%d с кодом %d\n",
pid, status >> 8);
printf( "Больше нет сыновей\n");
____________________
|= _cleanup() закрывает файлы, открытые fopen()ом, "вытряхая" при этом данные, на-
копленные в буферах, в файл. При аварийном завершении программы файлы все равно зак-
рываются, но уже не явно, а операционной системой (в вызове _exit). При этом содер-
жимое недосброшенных буферов будет утеряно.
____________________
|-|- GNU - программы, распространяемые в исходных текстах из Free Software Founda-
А. Богатырев, 1992-95 - 226 - Си в UNIX
wait приостанавливает|- выполнение вызвавшего процесса до момента окончания любого из
порожденных им процессов (ведь можно было запустить и нескольких сыновей!). Как
только какой-то потомок окончится - wait проснется и выдаст номер (pid) этого
потомка. Когда никого из живых "сыновей" не осталось - он выдаст (-1). Ясно, что
процессы могут оканчиваться не в том порядке, в котором их порождали. В переменную
status заносится в специальном виде код ответа окончившегося процесса, либо номер
сигнала, которым он был убит.
#include <sys/types.h>
#include <sys/wait.h>
...
int status, pid;
...
while((pid = wait(&status)) > 0){
if( WIFEXITED(status)){
printf( "Процесс %d умер с кодом %d\n",
pid, WEXITSTATUS(status));
} else if( WIFSIGNALED(status)){
printf( "Процесс %d убит сигналом %d\n",
pid, WTERMSIG(status));
if(WCOREDUMP(status)) printf( "Образовался core\n" );
/* core - образ памяти процесса для отладчика adb */
} else if( WIFSTOPPED(status)){
printf( "Процесс %d остановлен сигналом %d\n",
pid, WSTOPSIG(status));
} else if( WIFCONTINUED(status)){
printf( "Процесс %d продолжен\n",
pid);
}
}
...
Если код ответа нас не интересует, мы можем писать wait(NULL).
Если у нашего процесса не было или больше нет живых сыновей - вызов wait ничего
не ждет, а возвращает значение (-1). В написанном примере цикл while позволяет дож-
даться окончания всех потомков.
В тот момент, когда процесс-отец получает информацию о причине смерти потомка,
паспорт умершего процесса наконец вычеркивается из таблицы процессов и может быть
переиспользован новым процессом. До того, он хранится в таблице процессов в состоя-
нии "zombie" - "живой мертвец". Только для того, чтобы кто-нибудь мог узать статус
его завершения.
Если процесс-отец завершился раньше своих сыновей, то кто же сделает wait и
вычеркнет паспорт? Это сделает процесс номер 1: /etc/init. Если отец умер раньше
процессов-сыновей, то система заставляет процесс номер 1 "усыновить" эти процессы.
init обычно находится в цикле, содержащем в начале вызов wait(), то есть ожидает
____________________
tion (FSF). Среди них - C++ компилятор g++ и редактор emacs. Смысл слов GNU - "gen-
erally not UNIX" - проект был основан как противодействие начавшейся коммерциализации
UNIX и закрытию его исходных текстов. "Сделать как в UNIX, но лучше".
|- "Живой" процесс может пребывать в одном из нескольких состояний: процесс ожидает
наступления какого-то события ("спит"), при этом ему не выделяется время процессора,
т.к. он не готов к выполнению; процесс готов к выполнению и стоит в очереди к процес-
сору (поскольку процессор выполняет другой процесс); процесс готов и выполняется про-
цессором в данный момент. Последнее состояние может происходить в двух режимах -
пользовательском (выполняются команды сегмента text) и системном (процессом был издан
системный вызов, и сейчас выполняется функция в ядре). Ожидание события бывает только
в системной фазе - внутри системного вызова (т.е. это "синхронное" ожидание). Неак-
тивные процессы ("спящие" или ждущие ресурса процессора) могут быть временно откачаны
на диск.
А. Богатырев, 1992-95 - 227 - Си в UNIX
окончания любого из своих сыновей (а они у него всегда есть, о чем мы поговорим под-
робнее чуть погодя). Таким образом init занимается чисткой таблицы процессов, хотя
это не единственная его функция.
Вот схема, поясняющая жизненный цикл любого процесса:
|pid=719,csh
|
if(!fork())------->--------* pid=723,csh
| | загрузить
wait(&status) exec("a.out",...) <-- a.out
: main(...){ с диска
: |
:pid=719,csh | pid=723,a.out
спит(ждет) работает
: |
: exit(status) умер
: }
проснулся <---проснись!--RIP
|
|pid=719,csh
Заметьте, что номер порожденного процесса не обязан быть следующим за номером роди-
теля, а только больше него. Это связано с тем, что другие процессы могли создать в
системе новые процессы до того, как наш процесс издал свой вызов fork.
6.5.7. Кроме того, wait позволяет отслеживать остановку процесса. Процесс может
быть приостановлен при помощи посылки ему сигналов SIGSTOP, SIGTTIN, SIGTTOU,
SIGTSTP. Последние три сигнала посылает при определенных обстоятельствах драйвер
терминала, к примеру SIGTSTP - при нажатии клавиши CTRL/Z. Продолжается процесс
посылкой ему сигнала SIGCONT.
В данном контексте, однако, нас интересуют не сами эти сигналы, а другая схема
манипуляции с отслеживанием статуса порожденных процессов. Если указано явно, сис-
тема может посылать процессу-родителю сигнал SIGCLD в момент изменения статуса любого
из его потомков. Это позволит процессу-родителю немедленно сделать wait и немедленно
отразить изменение состояние процесса-потомка в своих внутренних списках. Данная
схема программируется так:
void pchild(){
int pid, status;
sighold(SIGCLD);
while((pid = waitpid((pid_t) -1, &status, WNOHANG|WUNTRACED)) > 0){
dorecord:
записать_информацию_об_изменениях;
}
sigrelse(SIGCLD);
/* Reset */
signal(SIGCLD, pchild);
}
...
main(){
...
/* По сигналу SIGCLD вызывать функцию pchild */
signal(SIGCLD, pchild);
...
главный_цикл;
}
Секция с вызовом waitpid (разновидность вызова wait), прикрыта парой функций
sighold-sigrelse, запрещающих приход сигнала SIGCLD внутри этой критической секции.
А. Богатырев, 1992-95 - 228 - Си в UNIX
Сделано это вот для чего: если процесс начнет модифицировать таблицы или списки в
районе метки dorecord:, а в этот момент придет еще один сигнал, то функция pchild
будет вызвана рекурсивно и тоже попытается модифицировать таблицы и списки, в которых
еще остались незавершенными перестановки ссылок, элементов, счетчиков. Это приведет к
разрушению данных.
Поэтому сигналы должны приходить последовательно, и функции pchild вызываться
также последовательно, а не рекурсивно. Функция sighold откладывает доставку сигнала
(если он случится), а sigrelse - разрешает доставить накопившиеся сигналы (но если их
пришло несколько одного типа - все они доставляются как один такой сигнал. Отсюда -
цикл вокруг waitpid).
Флаг WNOHANG - означает "не ждать внутри вызова wait", если ни один из потомков
не изменил своего состояния; а просто вернуть код (-1)". Это позволяет вызывать
pchild даже без получения сигнала: ничего не произойдет. Флаг WUNTRACED - означает
"выдавать информацию также об остановленных процессах".
6.5.8. Как уже было сказано, при exec все открытые файлы достаются в наследство
новой программе (в частности, если между fork и exec были перенаправлены вызовом dup2
стандартные ввод и вывод, то они останутся перенаправленными и у новой программы).
Что делать, если мы не хотим, чтобы наследовались все открытые файлы? (Хотя бы
потому, что большинством из них новая программа пользоваться не будет - в основном
она будет использовать лишь fd 0, 1 и 2; а ячейки в таблице открытых файлов процесса
они занимают). Во-первых, ненужные дескрипторы можно явно закрыть close в промежутке
между fork-ом и exec-ом. Однако не всегда мы помним номера дескрипторов для этой
операции. Более радикальной мерой является тотальная чистка:
for(f = 3; f < NOFILE; f++)
close(f);
Есть более элегантный путь. Можно пометить дескриптор файла специальным флагом,
означающим, что во время вызова exec этот дескриптор должен быть автоматически закрыт
(режим file-close-on-exec - fclex):
#include <fcntl.h>
int fd = open(.....);
fcntl (fd, F_SETFD, 1);
Отменить этот режим можно так:
fcntl (fd, F_SETFD, 0);
Здесь есть одна тонкость: этот флаг устанавливается не для структуры file - "открытый
файл", а непосредственно для дескриптора в таблице открытых процессом файлов (массив
флагов: char u_pofile[NOFILE]). Он не сбрасывается при закрытии файла, поэтому нас
может ожидать сюрприз:
... fcntl (fd, F_SETFD, 1); ... close(fd);
...
int fd1 = open( ... );
Если fd1 окажется равным fd, то дескриптор fd1 будет при exec-е закрыт, чего мы явно
не ожидали! Поэтому перед close(fd) полезно было бы отменить режим fclex.
6.5.9. Каждый процесс имеет управляющий терминал (short *u_ttyp). Он достается про-
цессу в наследство от родителя (при fork и exec) и обычно совпадает с терминалом, с
на котором работает данный пользователь.
Каждый процесс относится к некоторой группе процессов (int p_pgrp), которая
также наследуется. Можно послать сигнал всем процессам указанной группы pgrp:
kill( -pgrp, sig );
Вызов
kill( 0, sig );
посылает сигнал sig всем процессам, чья группа совпадает с группой посылающего
А. Богатырев, 1992-95 - 229 - Си в UNIX
процесса. Процесс может узнать свою группу:
int pgrp = getpgrp();
а может стать "лидером" новой группы. Вызов
setpgrp();
делает следующие операции:
/* У процесса больше нет управл. терминала: */
if(p_pgrp != p_pid) u_ttyp = NULL;
/* Группа процесса полагается равной его ид-у: */
p_pgrp = p_pid; /* new group */
В свою очередь, управляющий терминал тоже имеет некоторую группу (t_pgrp). Это значе-
ние устанавливается равным группе процесса, первым открывшего этот терминал:
/* часть процедуры открытия терминала */
if( p_pid == p_pgrp // лидер группы
&& u_ttyp == NULL // еще нет упр.терм.
&& t_pgrp == 0 ){ // у терминала нет группы
u_ttyp = &t_pgrp;
t_pgrp = p_pgrp;
}
Таким процессом обычно является процесс регистрации пользователя в системе (который
спрашивает у вас имя и пароль). При закрытии терминала всеми процессами (что бывает
при выходе пользователя из системы) терминал теряет группу: t_pgrp=0;
При нажатии на клавиатуре терминала некоторых клавиш:
c_cc[ VINTR ] обычно DEL или CTRL/C
c_cc[ VQUIT ] обычно CTRL/\
драйвер терминала посылает соответственно сигналы SIGINT и SIGQUIT всем процессам
группы терминала, т.е. как бы делает
kill( -t_pgrp, sig );
Именно поэтому мы можем прервать процесс нажатием клавиши DEL. Поэтому, если процесс
сделал setpgrp(), то сигнал с клавиатуры ему послать невозможно (т.к. он имеет свой
уникальный номер группы != группе терминала).
Если процесс еще не имеет управляющего терминала (или уже его не имеет после
setpgrp), то он может сделать любой терминал (который он имеет право открыть) управ-
ляющим для себя. Первый же файл-устройство, являющийся интерфейсом драйвера термина-
лов, который будет открыт этим процессом, станет для него управляющим терминалом. Так
процесс может иметь каналы 0, 1, 2 связанные с одним терминалом, а прерывания полу-
чать с клавиатуры другого (который он сделал управляющим для себя).
Процесс регистрации пользователя в системе - /etc/getty (название происходит от
"get tty" - получить терминал) - запускается процессом номер 1 - /etc/init-ом - на
каждом из терминалов, зарегистрированных в системе, когда
- система только что была запущена;
- либо когда пользователь на каком-то терминале вышел из системы (интерпретатор
команд завершился).
В сильном упрощении getty может быть описан так:
void main(ac, av) char *av[];
{ int f; struct termio tmodes;
for(f=0; f < NOFILE; f++) close(f);
/* Отказ от управляющего терминала,
* основание новой группы процессов.
*/
setpgrp();
/* Первоначальное явное открытие терминала */
А. Богатырев, 1992-95 - 230 - Си в UNIX
/* При этом терминал av[1] станет упр. терминалом */
open( av[1], O_RDONLY ); /* fd = 0 */
open( av[1], O_RDWR ); /* fd = 1 */
f = open( av[1], O_RDWR ); /* fd = 2 */
// ... Считывание параметров терминала из файла
// /etc/gettydefs. Тип требуемых параметров линии
// задается меткой, указываемой в av[2].
// Заполнение структуры tmodes требуемыми
// значениями ... и установка мод терминала.
ioctl (f, TCSETA, &tmodes);
// ... запрос имени и пароля ...
chdir (домашний_каталог_пользователя);
execl ("/bin/csh", "-csh", NULL);
/* Запуск интерпретатора команд. Группа процессов,
* управл. терминал, дескрипторы 0,1,2 наследуются.
*/
}
Здесь последовательные вызовы open занимают последовательные ячейки в таблице откры-
тых процессом файлов (поиск каждой новой незанятой ячейки производится с начала таб-
лицы) - в итоге по дескрипторам 0,1,2 открывается файл-терминал. После этого деск-
рипторы 0,1,2 наследуются всеми потомками интерпретатора команд. Процесс init запус-
кает по одному процессу getty на каждый терминал, как бы делая
/etc/getty /dev/tty01 m &
/etc/getty /dev/tty02 m &
...
и ожидает окончания любого из них. После входа пользователя в систему на каком-то
терминале, соответствующий getty превращается в интерпретатор команд (pid процесса
сохраняется). Как только кто-то из них умрет - init перезапустит getty на соответст-
вующем терминале (все они - его сыновья, поэтому он знает - на каком именно терми-
нале).
6.6. Трубы и FIFO-файлы.
Процессы могут обмениваться между собой информацией через файлы. Существуют
файлы с необычным поведением - так называемые FIFO-файлы (first in, first out), веду-
щие себя подобно очереди. У них указатели чтения и записи разделены. Работа с таким
файлом напоминает проталкивание шаров через трубу - с одного конца мы вталкиваем дан-
ные, с другого конца - вынимаем их. Операция чтения из пустой "трубы" проиостановит
вызов read (и издавший его процесс) до тех пор, пока кто-нибудь не запишет в FIFO-
файл какие-нибудь данные. Операция позиционирования указателя - lseek() - неприме-
нима к FIFO-файлам. FIFO-файл создается системным вызовом
#include <sys/types.h>
#include <sys/stat.h>
mknod( имяФайла, S_IFIFO | 0666, 0 );
где 0666 - коды доступа к файлу. При помощи FIFO-файла могут общаться даже неродст-
венные процессы.
Разновидностью FIFO-файла является безымянный FIFO-файл, предназначенный для
обмена информацией между процессом-отцом и процессом-сыном. Такой файл - канал связи
как раз и называется термином "труба" или pipe. Он создается вызовом pipe:
int conn[2]; pipe(conn);
Если бы файл-труба имел имя PIPEFILE, то вызов pipe можно было бы описать как
А. Богатырев, 1992-95 - 231 - Си в UNIX
mknod("PIPEFILE", S_IFIFO | 0600, 0);
conn[0] = open("PIPEFILE", O_RDONLY);
conn[1] = open("PIPEFILE", O_WRONLY);
unlink("PIPEFILE");
При вызове fork каждому из двух процессов достанется в наследство пара дескрипторов:
pipe(conn);
fork();
conn[0]----<---- ----<-----conn[1]
FIFO
conn[1]---->---- ---->-----conn[0]
процесс A процесс B
Пусть процесс A будет посылать информацию в процесс B. Тогда процесс A сделает:
close(conn[0]);
// т.к. не собирается ничего читать
write(conn[1], ... );
а процесс B
close(conn[1]);
// т.к. не собирается ничего писать
read (conn[0], ... );
Получаем в итоге:
conn[1]---->----FIFO---->-----conn[0]
процесс A процесс B
Обычно поступают еще более элегантно, перенаправляя стандартный вывод A в канал
conn[1]
dup2 (conn[1], 1); close(conn[1]);
write(1, ... ); /* или printf */
а стандартный ввод B - из канала conn[0]
dup2(conn[0], 0); close(conn[0]);
read(0, ... ); /* или gets */
Это соответствует конструкции
$ A | B
записанной на языке СиШелл.
Файл, выделяемый под pipe, имеет ограниченный размер (и поэтому обычно целиком
оседает в буферах в памяти машины). Как только он заполнен целиком - процесс, пишу-
щий в трубу вызовом write, приостанавливается до появления свободного места в трубе.
Это может привести к возникновению тупиковой ситуации, если писать программу неакку-
ратно. Пусть процесс A является сыном процесса B, и пусть процесс B издает вызов
wait, не закрыв канал conn[0]. Процесс же A очень много пишет в трубу conn[1]. Мы
получаем ситуацию, когда оба процесса спят:
A потому что труба переполнена, а процесс B ничего из нее не читает, так как ждет
окончания A;
B потому что процесс-сын A не окончился, а он не может окончиться пока не допишет
свое сообщение.
Решением служит запрет процессу B делать вызов wait до тех пор, пока он не прочитает
ВСЮ информацию из трубы (не получит EOF). Только сделав после этого close(conn[0]);
А. Богатырев, 1992-95 - 232 - Си в UNIX
процесс B имеет право сделать wait.
Если процесс B закроет свою сторону трубы close(conn[0]) прежде, чем процесс A
закончит запись в нее, то при вызове write в процессе A, система пришлет процессу A
сигнал SIGPIPE - "запись в канал, из которого никто не читает".
6.6.1. Открытие FIFO файла приведет к блокированию процесса ("засыпанию"), если в
буфере FIFO файла пусто. Процесс заснет внутри вызова open до тех пор, пока в буфере
что-нибудь не появится.
Чтобы избежать такой ситуации, а, например, сделать что-нибудь иное полезное в
это время, нам надо было бы опросить файл на предмет того - можно ли его открыть?
Это делается при помощи флага O_NDELAY у вызова open.
int fd = open(filename, O_RDONLY|O_NDELAY);
Если open ведет к блокировке процесса внутри вызова, вместо этого будет возвращено
значение (-1). Если же файл может быть немедленно открыт - возвращается нормальный
дескриптор со значением >=0, и файл открыт.
O_NDELAY является зависимым от семантики того файла, который мы открываем. К
примеру, можно использовать его с файлами устройств, например именами, ведущими к
последовательным портам. Эти файлы устройств (порты) обладают тем свойством, что
одновременно их может открыть только один процесс (так устроена реализация функции
open внутри драйвера этих устройств). Поэтому, если один процесс уже работает с пор-
том, а в это время второй пытается его же открыть, второй "заснет" внутри open, и
будет дожидаться освобождения порта close первым процессом. Чтобы не ждать - следует
открывать порт с флагом O_NDELAY.
#include <stdio.h>
#include <fcntl.h>
/* Убрать больше не нужный O_NDELAY */
void nondelay(int fd){
fcntl(fd, F_SETFL, fcntl(fd, F_GETFL, 0) & ~O_NDELAY);
}
int main(int ac, char *av[]){
int fd;
char *port = ac > 1 ? "/dev/term/a" : "/dev/cua/a";
retry: if((fd = open(port, O_RDWR|O_NDELAY)) < 0){
perror(port);
sleep(10);
goto retry;
}
printf("Порт %s открыт.\n", port);
nondelay(fd);
printf("Работа с портом, вызови эту программу еще раз!\n");
sleep(60);
printf("Все.\n");
return 0;
}
Вот протокол:
А. Богатырев, 1992-95 - 233 - Си в UNIX
su# a.out & a.out xxx
[1] 22202
Порт /dev/term/a открыт.
Работа с портом, вызови эту программу еще раз!
/dev/cua/a: Device busy
/dev/cua/a: Device busy
/dev/cua/a: Device busy
/dev/cua/a: Device busy
/dev/cua/a: Device busy
/dev/cua/a: Device busy
Все.
Порт /dev/cua/a открыт.
Работа с портом, вызови эту программу еще раз!
su#
6.7. Нелокальный переход.
Теперь поговорим про нелокальный переход. Стандартная функция setjmp позволяет
установить в программе "контрольную точку"|-, а функция longjmp осуществляет прыжок в
эту точку, выполняя за один раз выход сразу из нескольких вызванных функций (если
надо)|=. Эти функции не являются системными вызовами, но поскольку они реализуются
машинно-зависимым образом, а используются чаще всего как реакция на некоторый сигнал,
речь о них идет в этом разделе. Вот как, например, выглядит рестарт программы по
прерыванию с клавиатуры:
#include <signal.h>
#include <setjmp.h>
jmp_buf jmp; /* контрольная точка */
/* прыгнуть в контрольную точку */
void onintr(nsig){ longjmp(jmp, nsig); }
main(){
int n;
n = setjmp(jmp); /* установить контрольную точку */
if( n ) printf( "Рестарт после сигнала %d\n", n);
signal (SIGINT, onintr); /* реакция на сигнал */
printf("Начали\n");
...
}
setjmp возвращает 0 при запоминании контрольной точки. При прыжке в контрольную
точку при помощи longjmp, мы оказываемся снова в функции setjmp, и эта функция возв-
ращает нам значение второго аргумента longjmp, в этом примере - nsig.
Прыжок в контрольную точку очень удобно использовать в алгоритмах перебора с
возвратом (backtracking): либо - если ответ найден - прыжок на печать ответа, либо -
если ветвь перебора зашла в тупик - прыжок в точку ветвления и выбор другой альтерна-
тивы. При этом можно делать прыжки и в рекурсивных вызовах одной и той же функции: с
более высокого уровня рекурсии в вызов более низкого уровня (в этом случае jmp_buf
лучше делать автоматической переменной - своей для каждого уровня вызова функции).
____________________
|- В некотором буфере запоминается текущее состояние процесса: положение вершины
стека вызовов функций (stack pointer); состояние всех регистров процессора, включая
регистр адреса текущей машинной команды (instruction pointer).
|= Это достигается восстановлением состояния процесса из буфера. Изменения, проис-
шедшие за время между setjmp и longjmp в статических данных не отменяются (т.к. они
не сохранялись).
А. Богатырев, 1992-95 - 234 - Си в UNIX
6.7.1. Перепишите следующий алгоритм при помощи longjmp.
#define FOUND 1 /* ответ найден */
#define NOTFOUND 0 /* ответ не найден */
int value; /* результат */
main(){ int i;
for(i=2; i < 10; i++){
printf( "пробуем i=%d\n", i);
if( test1(i) == FOUND ){
printf("ответ %d\n", value); break;
}
}
}
test1(i){ int j;
for(j=1; j < 10 ; j++ ){
printf( "пробуем j=%d\n", j);
if( test2(i,j) == FOUND ) return FOUND;
/* "сквозной" return */
}
return NOTFOUND;
}
test2(i, j){
printf( "пробуем(%d,%d)\n", i, j);
if( i * j == 21 ){
printf( " Годятся (%d,%d)\n", i,j);
value = j; return FOUND;
}
return NOTFOUND;
}
Вот ответ, использующий нелокальный переход вместо цепочки return-ов:
#include <setjmp.h>
jmp_buf jmp;
main(){ int i;
if( i = setjmp(jmp)) /* после прыжка */
printf("Ответ %d\n", --i);
else /* установка точки */
for(i=2; i < 10; i++)
printf( "пробуем i=%d\n", i), test1(i);
}
test1(i){ int j;
for(j=1; j < 10 ; j++ )
printf( "пробуем j=%d\n", j), test2(i,j);
}
test2(i, j){
printf( "пробуем(%d,%d)\n", i, j);
if( i * j == 21 ){
printf( " Годятся (%d,%d)\n", i,j);
longjmp(jmp, j + 1);
}
}
Обратите внимание, что при возврате ответа через второй аргумент longjmp мы прибавили
1, а при печати ответа мы эту единицу отняли. Это сделано на случай ответа j==0,
чтобы функция setjmp не вернула бы в этом случае значение 0 (признак установки конт-
рольной точки).
6.7.2. В чем ошибка?
#include <setjmp.h>
А. Богатырев, 1992-95 - 235 - Си в UNIX
jmp_buf jmp;
main(){
g();
longjmp(jmp,1);
}
g(){ printf("Вызвана g\n");
f();
printf("Выхожу из g\n");
}
f(){
static n;
printf( "Вызвана f\n");
setjmp(jmp);
printf( "Выхожу из f %d-ый раз\n", ++n);
}
Ответ: longjmp делает прыжок в функцию f(), из которой уже произошел возврат управле-
ния. При переходе в тело функции в обход ее заголовка не выполняются машинные команды
"пролога" функции - функция остается "неактивированной". При возврате из вызванной
таким "нелегальным" путем функции возникает ошибка, и программа падает. Мораль: в
функцию, которая НИКЕМ НЕ ВЫЗВАНА, нельзя передавать управление. Обратный прыжок -
из f() в main() - был бы законен, поскольку функция main() является активной, когда
управление находится в теле функции f(). Т.е. можно "прыгать" из вызванной функции в
вызывающую: из f() в main() или в g(); и из g() в main();
-- --
| f | стек прыгать
| g | вызовов сверху вниз
| main | функций можно - это соответствует
---------- выкидыванию нескольких
верхних слоев стека
но нельзя наоборот: из main() в g() или f(); а также из g() в f(). Можно также
совершать прыжок в пределах одной и той же функции:
f(){ ...
A: setjmp(jmp);
...
longjmp(jmp, ...); ...
/* это как бы goto A; */
}
6.8. Хозяин файла, процесса, и проверка привелегий.
UNIX - многопользовательская система. Это значит, что одновременно на разных
терминалах, подключенных к машине, могут работать разные пользователи (а может и один
на нескольких терминалах). На каждом терминале работает свой интерпретатор команд,
являющийся потомком процесса /etc/init.
6.8.1. Теперь - про функции, позволяющие узнать некоторые данные про любого пользо-
вателя системы. Каждый пользователь в UNIX имеет уникальный номер: идентификатор
пользователя (user id), а также уникальное имя: регистрационное имя, которое он наби-
рает для входа в систему. Вся информация о пользователях хранится в файле
/etc/passwd. Существуют функции, позволяющие по номеру пользователя узнать регистра-
ционное имя и наоборот, а заодно получить еще некоторую информацию из passwd:
А. Богатырев, 1992-95 - 236 - Си в UNIX
#include <stdio.h>
#include <pwd.h>
struct passwd *p;
int uid; /* номер */
char *uname; /* рег. имя */
uid = getuid();
p = getpwuid( uid );
...
p = getpwnam( uname );
Эти функции возвращают указатели на статические структуры, скрытые внутри этих функ-
ций. Структуры эти имеют поля:
p->pw_uid идентиф. пользователя (int uid);
p->pw_gid идентиф. группы пользователя;
и ряд полей типа char[]
p->pw_name регистрационное имя пользователя (uname);
p->pw_dir полное имя домашнего каталога
(каталога, становящегося текущим при входе в систему);
p->pw_shell интерпретатор команд
(если "", то имеется в виду /bin/sh);
p->pw_comment произвольная учетная информация (не используется);
p->pw_gecos произвольная учетная информация (обычно ФИО);
p->pw_passwd зашифрованный пароль для входа в
систему. Истинный пароль нигде не хранится вовсе!
Функции возвращают значение p==NULL, если указанный пользователь не существует (нап-
ример, если задан неверный uid). uid хозяина данного процесса можно узнать вызовом
getuid, а uid владельца файла - из поля st_uid структуры, заполняемой системным вызо-
вом stat (а идентификатор группы владельца - из поля st_gid). Задание: модифицируйте
наш аналог программы ls, чтобы он выдавал в текстовом виде имя владельца каждого
файла в каталоге.
6.8.2. Владелец файла может изменить своему файлу идентификаторы владельца и группы
вызовом
chown(char *имяФайла, int uid, int gid);
т.е. "подарить" файл другому пользователю. Забрать чужой файл себе невозможно. При
этой операции биты S_ISUID и S_ISGID в кодах доступа к файлу (см. ниже) сбрасываются,
поэтому создать "Троянского коня" и, сделав его хозяином суперпользователя, получить
неограниченные привелегии - не удастся!
6.8.3. Каждый файл имеет своего владельца (поле di_uid в I-узле на диске или поле
i_uid в копии I-узла в памяти ядра|-). Каждый процесс также имеет своего владельца
(поля u_uid и u_ruid в u-area). Как мы видим, процесс имеет два параметра, обознача-
ющие владельца. Поле ruid называется "реальным идентификатором" пользователя, а uid -
"эффективным идентификатором". При вызове exec() заменяется программа, выполняемая
данным процессом:
____________________
|- При открытии файла и вообще при любой операции с файлом, в таблицах ядра заво-
дится копия I-узла (для ускорения доступа, чтобы постоянно не обращаться к диску).
Если I-узел в памяти будет изменен, то при за