Рефераты

Управление процессами

выделенная строка, то процесс, связанный с wc завис бы, потому что в этом

случае функция, читающая из канала, не дождется признака конца файла. Она

будет ожидать его бесконечно долго. В процессе отце подчеркнутую строку

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

процесса, а в процессе сыне такая строка нужна. Т.е. вывод таков: перед

завершением работы должны закрываться все дескрипторы каналов, связанные с

записью.

Каналом можно связывать только родственные процессы. Технически можно

связывать несколько процессов одним каналом, но могут возникнуть проблемы.

Лекция №14

Сигналы в системе UNIX

Рассмотрим взаимодействие между процессами с помощью приема-передачи

сигналов. Мы уже говорили о том, что в системе UNIX можно построить

аналогию механизма прерываний из некоторых событий, которые могут возникать

при работе процессов.

Эти события так же, как и прерывания, однозначно определены для

конкретной версии ОС, т.е. набор сигналов определен. Возникновение сигналов

почти так же, как и возникновение прерываний, может происходить по

следующим причинам:

11. некоторое событие внутри программы, например, деление на ноль или

переполнение;

12. событие, связанное с приходом некоторой информации от устройства,

например, событие, связанное с передачей от клавиатуры комбинации

“Ctrl+C”;

13. событие, связанное с воздействием одного процесса на другой, например,

“SIG_KILL”.

Система имеет фиксированный набор событий, которые могут возникать.

Каждое событие имеет свое уникальное имя; эти имена обычно едины для всех

версий UNIX. Такие имена называются сигналами.

Перечень сигналов находится в include-файле “signal.h”.

Есть сигналы, которые присутствуют практически во всех UNIX, но также

есть сигналы, специфичные лишь для конкретной версии UNIX (FreeBSD, SCO

UNIX, Linux, ...) Например, в версии BSD есть сигнал приостановки работы

процесса, реакцией на который является замораживание процесса, а есть

сигнал, который размораживает процесс. Это сигнал FreeBSD версии.

Прототип функции обработки сигнала:

void (* signal (sig, fun)) ()

int sig;

void (* fun) ();

При обращении к signal мы передаем:

sig - имя сигнала;

fun - указатель на функцию, которая будет обрабатывать событие,

связанное с возникновением этого сигнала. Функция signal возвращает

указатель на предыдущую функцию обработки данного сигнала.

Мы говорили о том, что событие, связанное с возникновением сигнала

может быть обработано в системе тремя способами:

1. SIG_DEF - стандартная реакция на сигнал, которая предусмотрена

системой;

2. SIG_IGN - игнорирование сигнала (следует отметить, что далеко не все

сигналы можно игнорировать, например, SIG_KILL);

3. Некоторая пользовательская функция обработки сигнала.

Соответственно, указывая либо имена предопределенных констант, либо

указатель на функцию, которую мы хотим определить как функцию-обработчик

сигнала, можно предопределить реакцию на тот или иной сигнал. Установка

обработки сигнала происходит одноразово, это означает то, что если мы

установили некоторую обработку, то по этому правилу будет обработано только

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

обработчика устанавливается стандартная реакция на сигнал. Возврат из

функции-обработчика происходит в точку прерывания процесса.

Приведем пример программы “Будильник”. Средствами ОС мы будем

“заводить” будильник. Функция alarm инициализирует появление сигнала

SIG_ALRM.

main ()

{

char s[80];

signal(SIG_ALRM, alrm); /* установка режима связи с событием SIG_ALRM

на функцию alrm */

alarm(5); /* заводим будильник */

printf(“Введите имя \n”);

for (;;)

{

printf(“имя:”);

if (gets(s,80) != NULL) break;

};

printf(“OK! \n”);

}

alrm ()

{

printf(“\n жду имя \n”);

alarm(5);

signal (SIG_ALRM,alrm);

}

В начале программы мы устанавливаем реакцию на сигнал SIG_ALRM -

функцию alrm, далее мы заводим будильник, запрашиваем “Введите имя” и

ожидаем ввода строки символов. Если ввод строки задерживается, то будет

вызвана функция alrm, которая напомнит, что программа “ждет имя”, опять

заведет будильник и поставит себя на обработку сигнала SIG_ALRM еще раз. И

так будет до тех пор, пока не будет введена строка.

Здесь имеется один нюанс: если в момент выполнения системного вызова

возникает событие, связанное с сигналом, то система прерывает выполнение

системного вызова и возвращает код ответа, равный «-1». Это мы можем также

проанализировать по функции errno.

Надо отметить, что одноразово устанавливается только “свой”

обработчик. Дефолтный обработчик или игнорирование устанавливается

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

сигнала.

Еще две функции, которые необходимы нам для организации

взаимодействия между процессами:.…

1) int kill(int pid, sig) - это функция передачи сигнала процессу. Она

работает следующим образом: процессу с номером pid осуществляется попытка

передачи сигнала, значение которого равно sig. Соответственно, сигнал может

быть передан в рамках процессов, принадлежащих к одной группе. Код ответа:

-1, если сигнал передать не удалось, пояснение опять же можно найти в

errno. Функция kill может использоваться для проверки существования

процесса с заданным идентификатором. Если функция выполняется с sig=0, то

это тестовый сигнал, который определяет: можно или нет передать процессу

сигнал; если можно, то код ответа kill отличен от «-1». Если pid=0, то

заданный сигнал передается всем процессам, входящим в группу.

2) int wait(int *wait_ret) - ожидание события в сыновнем процессе.

Если сыновнего процесса нет, то управление возвращается сразу же с кодом

ответа «-1» и расшифровкой в errno. Если в процессе-сыне возникло событие,

то анализируются младшие 16 бит в значении wait_ret:

а) Если сын приостановлен (трассировка или получение сигнала), тогда

старшие 8 бит wait_ret - код сигнала, который получил процесс-сын, а

младшие содержат код 0177.

б) Если сыновий процесс успешно завершился через обращение к функции

exit. Тогда младшие 8 бит равны нулю, а старшие 8 бит равны коду,

установленному функцией exit.

в) Если сын завершился из-за возникновения у него необрабатываемого

сигнала, то старшие 8 бит равны нулю, а младшие - номер сигнала, который

завершил процесс.

Функция wait возвращает идентификатор процесса в случае успешного

выполнения и «-1» в противном случае. Если одно из перечисленных событий

произошло до обращения к функции, то результат возвращается сразу же, то

есть никакого ожидания не происходит, это говорит о том, что информация о

событиях в процессе безвозвратно не теряется.

Давайте рассмотрим еще один пример. Наш будильник будет уже

многопроцессный.

alr()

{

printf(“\n Быстрее!!! \n”);

signal (SIG_ALRM, alr);

}

main ()

{

char s[80]; int pid;

signal(SIG_ALRM, alr);

if (pid=fork()) for (;;)

{

sleep(5); /*приостанавливаем процесс на 5 секунд */

kill(pid, SIG_ALRM); /*отправляем сигнал SIG_ALRM процессу-сыну */

}

print(“имя?”);

for (;;)

{

printf(“имя?”);

if gets(s,80)!=NULL) break;

}

printf(“OK!\n”);

kill(getpid(), SIG_KILL); /* убиваем зациклившегося отца */

}

Следует заметить, что в разных версиях UNIX имена сигналов могут

различаться.

Наша программа реализуется в двух процессах.

Как и в предыдущем примере, имеется функция реакции на сигнал alr(),

которая выводит на экран надпись и переустанавливает функцию реакции на

сигнал опять же на себя. В основной программе мы также указываем alr() как

реакцию на SIG_ALRM. После этого мы запускаем сыновний процесс, и отцовский

процесс (бесконечный цикл) “засыпает” на 5 единиц времени, после чего

сыновнему процессу будет отправлен сигнал SIG_ALRM. Все, что ниже цикла,

будет выполняться в процессе-сыне: мы ожидаем ввода строки, если ввод

осуществлен, то происходит убиение отца (SIG_KILL).

Таким образом, мы описали базовые средства взаимодействия процессов в

UNIX: порождение процесса, замена тела процесса, взаимодействие при помощи

передач/приемов сигналов.

Замечание: мы говорим о некотором обобщенном UNIX, реальные UNIX-ы

могут иметь некоторые отличия друг от друга. На сегодняшний день имеются

достаточно формализованные стандарты на интерфейсы ОС, в частности для UNIX

это POSIX-standard, т.е. были проведены работы по стандартизации

интерфейсов всех уровней для открытых систем. Основной задачей является

унификация работы с системами, как на уровне запросов от пользователя, так

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

все разработчики ОС стараются привести свои системы к стандарту POSIX. В

частности, Microsoft объявила, что системные вызовы и работа с файлами в

Windows NT происходит в стандарте POSIX. Но так или иначе реальные

коммерческие системы от этого стандарта отходят.

Второе замечание: мы начали рассматривать примеры, но крайне важно,

чтобы все эти примеры были реализованы на практике, дабы убедиться, что они

работают, посмотреть, как они работают, и добиться этой работы, так как

версии UNIX могут не совпадать. Для этого следует посмотреть мануалы и,

если надо, подправить программы.

Лекция №15

Трассировка процессов

К сегодняшнему дню, мы с вами рассмотрели стандартную схему

образования процессов в UNIX-е и взаимодействие процессов с использованием

системы передачи сигналов друг другу. Мы с вами обсудили организацию

взаимодействия процессов с использованием т.н. неименованных каналов, это

средство позволяет асинхронным образом передавать информацию от одного

процесса к другому. Эти средства работают для родственных процессов.

Сегодня мы рассмотрим еще одну базовую функцию операционной системы

UNIX, которая поддерживает трассировку процессов. Трассировка - это

возможность одного процесса управлять ходом выполнения другого процесса.

Давайте рассмотрим основные действия, выполняемые при отладке.

1. Установка контрольной точки.

2. Обработка ситуации, связанной с приходом в контрольную точку.

3. Чтение/запись информации в отлаживаемой программе.

4. Остановка/продолжение выполнения отлаживаемого процесса.

5. Шаговый режим отладки (остановка отлаживаемой программы после

выполнения каждой инструкции).

6. Передача управления на произвольную точку отлаживаемой

программы.

7. Обработка аварийных остановок (АВОСТ).

Вот семь позиций, которые реализуются почти в любом средстве отладки,

с точностью до добавленных новых пунктов, в какой бы мы системе не

работали.

Теперь посмотрим, какими средствами можно организовать выполнение этих

функций в ОС UNIX. Есть функция ptrace.

ptrace(int op, int pid, int addr, int data);

Функция ptrace в подавляющем большинстве случаев работает в отцовском

процессе, и через возможности этой функции организуется управление

процессом сыном. В общем случае нельзя трассировать любой процесс. Для того

чтобы процесс можно было трассировать, чтобы сыновий процесс мог

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

на его трассировку. Для этого в самом начале своего выполнения процесс-сын

должен выполнить обращение к функции ptrace с кодом операции равным нулю

(op=0), который разрешает проводить трассировку данного процесса процессом-

отцом. После этого в сыновьем процессе обращений к функции ptrace может не

быть. Все управление будет производиться отцом.

Рассмотрим, какие возможности есть у отцовского процесса для

управления сыном. Все возможности определяются значением параметра op.

Параметр pid - идентификатор сыновьего процесса, который мы хотим

трассировать.

14. op=1 или op=2 - ptrace возвращает значение слова, адрес которого

задан параметром addr (т.е. чтение слова из отлаживаемого процесса).

Здесь указаны два значения op на тот случай, если есть

самостоятельные адресные пространства в сегментах данных и кода

(т.е. можно читать данные и код). В системах, где адресация единая в

рамках процесса значение может быть любым.

15. op=3 - читать информацию из контекста процесса. Обычно речь идет о

доступе к информации из контекста данного процесса, сгруппированную

в некоторую структуру. В этом случае параметр addr указывает

смещение относительно начала этой структуры. В эта структуре

размещена информация к которой я имею доступ посредством функции

ptrace, в частности - регистры, текущее состояние процесса, счетчик

адреса и т.д.

16. op=4 или op=5 - запись данных, размещенных в параметре data, по

адресу addr. Если происходит ошибка, ptrace возвращает -1 (уточнение

в errno).

17. op=6 - запись данных из data в контекст по смещению addr. Это

означает, что можно прочесть регистры трассируемого процесса и при

необходимости изменить их содержимое (в т.ч. счетчик адреса команды,

т.е. сделать переход).

18. op=7 - продолжение выполнения трассируемого процесса. Эта операция

хитрая. Хитрость заключается в следующем. Пусть трассируемый процесс

по какой-то причине был остановлен, например по причине прихода

сигнала, процесс-отец дождался этого события с помощью функции wait

и выполняет какие-то действия не запустив отлаживаемый процесс.

Остановленному процессу могут приходить сигналы от других процессов.

Что в этом случае делать с этими сигналами? Здесь как раз и

используется ptrace с op=7. Если data=0, то процесс, который к этому

моменту был приостановлен (сыновий), продолжит свое выполнение, и

при этом все пришедшие (и необработанные еще) к нему сигналы будут

проигнорированы. Если значение параметра data равно номеру сигнала,

то это означает, что процесс (сыновий) возобновит свое выполнение, и

при этом будет смоделирована ситуация прихода сигнала с этим

номером. Все остальные сигналы будут проигнорированы. Кроме того,

если addr=1, то процесс продолжит свое выполнение с того места, на

котором он быт приостановлен. Если addr>1, то осуществиться переход

по адресу addr (goto addr).

19. op=8 - завершение трассируемого процесса.

20. op=9 - установка бита трассировки. Это тот самый код, который

обеспечивает пошаговое выполнение машинных команд. После каждой

машинной команды в процессе происходит событие, связанное с сигналом

SIG_TRAP.

Эта функция нами описана в некоторой модельной нотации, т.е. в разных

системах ptrace может иметь несколько другую интерфейсную часть. В разных

системах отличается доступ к контексту.

Все вышеописанные действия с функцией ptrace выполняются при

остановленном отлаживаемом процессе (Он может быть остановлен из-за какой-

то ошибке, может быть остановлен при приходе сигнала). Для того чтобы

отцовский процесс мог остановить трассируемый сыновий процесс может быть

выполнена следующая последовательность действий. Отцовский процесс посылает

сыну сигнал (в сыне уже ранее выполнена ptrace c op=0), предположим

SIG_TRAP, и после отправки сигнала отцовский процесс выполняет функцию

wait. После ого как сигнал дошел до сыновьего процесса и тот остановился,

отцовский процесс получает соответствующий код ответа из функции wait.

После этого считается, что трассируемый процесс остановлен и можно

выполнять все вышеописанные действия.

Давайте промоделируем работу отладчика с использованием функции

ptrace. Мы не будем писать программу, мы просто на пальцах попытаемся

понять, как можно реализовать каждую из функций отладчика. Давайте называть

отцовский процесс отладчиком, а сыновий процесс - отлаживаемым.

Установка контрольной точки.

Считается, что в отладчике имеется некоторая таблица, которая

содержит информацию о контрольных точках.

|№ Контрольной |Адрес |Сохраненное |Счетчик приходов |

|точки |контрольной точки |машинное слово |в контрольную |

| | | |точку |

| | | | |

| | | | |

При установке контрольной точки с использованием функции ptrace

происходит следующее.

Отладчик устанавливает контрольную точку по некоторому адресу.

Читает содержимое отлаживаемого процесса по данному адресу.

Записывает это содержимое (машинное слово) в таблицу.

По данному адресу записывает машинную команду, которая сформирует событие,

связанное с некоторым фиксированным сигналом, к примеру команда деления на

ноль.

После этого можно запустить отлаживаемый процесс. В тот момент, когда

управление в отлаживаемом процессе перейдет на адрес по которому мы

установили контрольную точку, произойдет прерывание выполнения нашей

программы и произойдет некоторое событие, связанное с известным нам

сигналом.

Для отладчика это будет видно так. Он запустил отлаживаемый процесс

(ptrace(7,...)), и обратился к функции wait (ждет события в отлаживаемом

процессе). Как только событие произошло (т.е. пришел сигнал), отладчик

смотрит, не совпадает ли этот сигнал с сигналом, который связан с приходом

в контрольную точку. Если не совпадает, то отладчик произведет действия

соответствующие этому сигналу (какие-то).

Если сигнал совпадает, то есть подозрение, что мы пришли в контрольную

точку. В этом случае отладчик читает из контекста процесса адрес, по

которому процесс был остановлен. Если этот адрес совпал с одним из адресов

контрольных точек в таблице отладчика, то это означает, что мы пришли в

контрольную точку (и деление на ноль на самом деле - контрольная точка).

Если отладчик не нашел соответствующего адреса, то это означает, что

действительно произошло деление на ноль и отладчик должен выполнить какие-

то действия (обработка АВОСТа).

Если отладчик зафиксировал контрольную точку, он может выполнить какие-

то действия по отладке программы. Когда-нибудь настанет необходимость

продолжить выполнение программы, и пусть при этом мы хотели бы сохранить

эту контрольную точку. Отладчик делает следующее. Он восстанавливает

оригинальное содержимое машинного слова, которое берет из таблицы. Затем

включает режим трассировки и запускает программу с прерванного адреса.

Выполняется одна эта команда и сразу после нее происходит остановка

процесса на следующей команде. После этого отладчик восстанавливает

контрольную точку (опять вписывает деление на ноль) и запускает выполнение

процесса с прерванной точки (отключив режим трассировки).

Снятие контрольной точки делается также просто: восстанавливается

содержимое по соответствующему адресу и из таблицы выбрасывается

соответствующая строка. Можно сделать контрольную точку так, чтобы она

работала, к примеру, только 10 раз. Для этого надо добавить в таблицу еще

счетчик, из которого при каждом приходе в контрольную точку будет

вычитаться единица, и как только он обнулится, контрольная точка будет

автоматически снята.

Чтение/запись обсуждать не будем - это понятно. Остановка

осуществляется через посыл сигнала, либо через возникновение события в

отлаживаемом процессе, продолжение - через функцию ptrace(7,...). Шаговый

режим отладки осуществляется через ptrace(9,...). Передача управления на

любую точку - нет проблем. Обработка аварийных остановок - с помощью wait.

Вот, с точностью до некоторых деталей, схема организации адресного

отладчика, т.е. отладчика, который оперирует адресами. Если возникает

необходимость отладки в терминах языка высокого уровня, то в отладчике

добавляются таблицы, из которых можно определить адреса и свойства

переменных и адреса операторов.

В этом случае, предположим, чтение содержимого языковой переменной

программы будет осуществляться следующим образом. Отладчик обращается к

своей таблице и ищет строчку переменной с именем Name. В том случае, если

эта переменная существует и находиться в области видимости и существования,

из таблицы выбираются атрибуты этой переменной. Если эта переменная

обыкновенная статическая, то выбирается ее адрес и мы обращаемся к ptrace с

чтением данных по адресу. Если эта переменная автоматическая, то с ней

связано смещение относительно вершины стека. Это означает, чтобы добраться

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

вершину стека (это есть некий адрес), после этого к этому адресу прибавить

смещение, связанное с автоматической переменной, и уже по полученному

результату как адресу прочесть информацию из адресного пространства

процесса. Третий вариант: переменная - регистровая. В этом случае с именем

Name будет ассоциирована информация о том, что эта переменная регистровая,

а, в этом случае, там будет указан номер регистра, на котором она

размещена. Для чтения информации из регистров я обращаюсь к чтению

информации из контекста и читаю соответствующий регистр.

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

с тремя рассмотренными вариантами. Кстати, в языке Си, объявление

регистровой переменной на самом деле есть пожелание программиста о том,

чтобы при хорошем стечении обстоятельств в программе и добром желании

системы программирования разместить эту переменную на регистре. Т.е. она

будет размещена либо на регистре, и тогда она будет реально регистровой,

либо она будет автоматической.

Давайте попробуем написать маленький пример. Мы будем писать программу

в нотации операционной системы Free BSD. Для других операционных систем

надо уточнить функцию ptrace в мануалах.

Отлаживаемый процесс

int main() /* эта программа находится в процессе-сыне SON */

{

int i;

return i/0;

}

Процесс - отладчик

#iinclude

#iinclude

#iinclude

#iinclude

#iinclude

#iinclude

#iinclude

int main(int argc, char *argv[])

{

pid_f pid;

int status;

struct reg REG;

switch (pid=fork()){ /* формируем процесс, в pid -

код ответа */

case -1: perror("Ошибка fork"); exit(25); /*

Обработка ошибки */

case 0: ptrace( PT_TRACE_ME, 0, 0, 0); execl("SON","SON",0);

/* В сыне: разрешаем отладку и загружаем процесс SON. При этом произойдет

приостановка сына перед выполнением первой команды нового тела процесса

(а точнее в нем возникнет событие, связанное с сигналом SIG_TRAP) */

default: break; /* В отце: выход из switch */

}

for(;;) {

wait(&status); /* ждем возникновения события в сыне

(сигнала SIG_TRAP) */

ptrace(PT_GETREGS,pid,(caddr_t)®,0); /* Читаем

регистры, например, чтобы их

распечатать */

printf("EIP=%0.8x\ + ESP=%0.8x\n",REG.r_eip, REG.r_esp); /*

печатаем регистры EIP и ESP */

if(WIFSTOPPED(status)||WIFSIGNALED(status)){ /* проверяем с помощью

макросов условия функции wait,

и если все нормально,

продолжаем разбирать причину

остановки программы */

printf("Сигналы: ");

switch(WSTOPSIG(status)){ /*анализируем код сигнала, по

которому произошла остановка

*/

case SIGINT: printf("INT \n"); break; /* выводим

причину остановки */

case SIGTRAP: . . . . . . break;

.

.

.

default: printf("%d", WSTOPSIG(status));

}

if (WSTOPSIG(status)!=SIGTRAP) exit(1); /* Если процесс

остановился не по

SIGTRAP тогда выходим */

if (WIFEXITED(status)){ /* проверяем случай, если

процесс завершился нормально */

printf("Процесс завершился, код завершения = %d \n",

WEXITSTATUS(status));

exit(0);

}

ptrace(PT_CONTINUE, pid, (caddr_t) 1, 0); /* Если был SIGTRAP,

продолжаем процесс */

} /* End for(;;) */

exit(0);

}

Мы обработали ситуацию остановки и ситуацию нормального завершения

процесса. При первой итерации цикла, мы остановимся и дождемся первого

сигнала SIGTRAP. По этому сигналу мы выведем нужную нам информацию. Затем,

проверим, не закончился ли наш процесс нормально, и т.к. он не может

закончиться нормально (он выполняет деление на ноль), то мы обратимся к

функции ptrace, которая продолжит процесс с прерванного места. Мы снова

попадем на wait. Здесь мы дождемся события, связанного с делением на ноль,

и обработаем это событие. В итоге, на стандартный вывод попадут две порции

данных: первая - вывод точки прерывания, вершины стека и сигнала для

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

сигнала FPI (Float Point Interrupt) на делении на ноль.

Рекомендуется разобрать этот пример и адаптировать для ваших машин на

практикуме.

Лекция №16

Нелокальные переходы

На этой лекции мы с вами обсудим некоторые дополнительные возможности

по организации управления ходом процесса в UNIX. Возникает необходимость

предоставления в процессе возможности перезапуска в процессе каких-то его

веток при возникновении некоторых ситуаций.

Предположим, у нас есть процесс, который занимается обработкой

достаточно больших наборов данных, и мы хотим написать процесс, который

будет работать следующим образом. В начальный момент времени наш процесс

получает некоторый набор данных, и начинает каким-то образом выполнять

вычисления. Известно, что при некоторых наборах данных, возможно

возникновение внештатных ситуаций, например, переполнение или деление на

ноль. Мы бы хотели написать программу, которая обрабатывала бы внештатную

ситуацию, и после обработки ее переходила бы снова в начальную точку

процесса, загружала бы новые наборы данных и начинала работу с ними.

Для решения такой задачи, мы должны уметь обрабатывать сигналы,

возникающие в процессе. Это можно сделать с помощью функции signal и ее

возможностей. Кроме того, нам бы хотелось возвращаться в некоторые

помеченные в программе точки, не через последовательность входов и выходов

из функции, а с помощью безусловного перехода (как бы goto N), потому что

механизм обработки сигналов не позволит корректно работать с такой задачей.

Можно в принципе написать функцию обработки сигнала, которая при

возникновении одного из сигналов делает повторный вызов всей программы. Но

это не совсем корректно, т.к. при вызове функции-обработчика сигнала

фиксируется состояние стека, и в общем случае система ожидает выхода из

функции обработчика через return (при этом система возвращает нас в

прерванное место и освобождает стек). Если не будет произведен выход через

return, в стеке будет накапливаться ненужная информация, и все это приведет

к деградации системы.

Для решения таких задач имеются т.н. нелокальные переходы. Достигаются

они с использованием двух функций, которые продекларированы в setjmp.h и

имеют следующий интерфейс:

int setjmp(jmp_buf env);

int longjmp(jmp_buf env, int val);

Функция setjmp фиксирует точку обращения к этой функции, т.е. в

структуре данных, связанной с переменной env сохраняется текущее состояние

процесса (все атрибуты и в т.ч. состояние стека) в точке обращения к

setjmp. При обращении к этой функции здесь, setjmp возвращает нулевое

значение.

При обращении к функции longjmp(env, val) происходит передача

управления на точку, атрибуты которой зафиксированы в структуре env, т.е. в

то место, где было обращение к setjmp(env). При этом, после этого перехода

setjmp вернет значение val.

Рассмотрим маленький пример.

# include

jmp_buf save;

void main(void)

{ int ret;

switch(ret=setjmp(save)){ /* при первой проверке ret будет равно

нулю */

case 0: printf("....."); /* этот printf выведет некоторую

строку */

a(); /* вызов функции a() */

printf("....."); /* этот printf не сработает никогда

*/

default: break;

}

}

void a(void)

{ longjmp(save, 1); /* длинный переход на setjmp, ret будет

равно 1 */

}

Нелокальный переход - это несколько некорректная возможность

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

через начало и выходить не через конец. Здесь все нарушается. Однако для

некоторых ситуаций эти возможности бывают полезны. В частности эти функции

могут быть использованы для передачи управления из функции-обработчика

сигнала в некоторую точку программы.

Длинный переход корректно работает со стеком. При входе в точку,

установленную с помощью setjmp, он восстанавливает все то состояние (в том

числе и состояние стека), которое было при установке этой точки. Надо

заметить, что longjmp восстанавливает не сам стек, а лишь указатель стека.

Работа со стеком всегда должна удовлетворять правилу: перед обращением

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

Если уровень станет больше или меньше, это гарантировано приведет к

проблемам, потому что рано или поздно стек либо переполнится, либо

программа полезет за нижний его уровень, что тоже плохо.

Вопрос: предположим мы установили setjmp в некоторой функции, мы

вернулись из этой функции, и затем выполнили переход longjmp (т.е. вошли в

функцию не сначала). Куда при выходе из этой функции произойдет возврат,

потому что в общем случае содержимое стекового кадра этой функции будет

случайным (т.к. в буфере env содержится указатель стека, а не сам стек)?

Возврат произойдет корректно, т.к. в буфере env адрес возврата будет

сохранен, а вот значения автоматических и регистровых переменных этой

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

сохраняется. Но это есть правила игры. Т.е. здесь на решение программиста

налагается ответственность.

До сих пор мы с вами рассматривали взаимодействия, связанные с

родственными процессами. Реально, система UNIX имеет набор средств,

поддерживающих взаимодействие произвольных процессов. Одно из таких средств

- Система Межпроцессного Взаимодействия IPC (InterProcess Communications).

Суть этой системы заключается в следующем.

Имеется некоторое количество ресурсов, которые называются в системе

разделяемыми. К одному и тому же разделяемому ресурсу может быть

организован доступ со стороны произвольного количества произвольных

процессов. При этом возникает проблема именования этих разделяемых

ресурсов. Если мы вспомним неименованные каналы, за счет того, что каналы

передавались по родственному наследованию, всегда в процессе были известны

дескрипторы, ассоциированные с каналом. Фактически, если процесс получал

доступ к каналу, он уже знал, как именовать этот канал. Здесь

использовалось свойство родственной связи, когда какая-то информация, какие-

то средства передаются по наследству при формировании сыновьего процесса.

В системе IPC ситуация другая. Есть некоторый ресурс, в общем случае

произвольный, и к этому ресурсу могут добираться все, кто может именовать

этот ресурс. Для именования такого рода ресурсов в системе предусмотрен

механизм генерации т.н. ключей. Суть его заключается в следующем. По

некоторым общеизвестным данным (это могут быть текстовые строки или

цифровые комбинации) в системе генерируется уникальный ключ, который

ассоциируется с разделяемым ресурсом. Если процесс подтверждает этот ключ и

созданный разделяемый ресурс доступен для него, то после этого он может

работать с указанным разделяемым ресурсом по своему усмотрению.

Разделяемый ресурс создается некоторым процессом-автором. Автор

определяет основные свойства ресурса (предположим, размер) и права доступа.

Права доступа к ресурсу разделяются на три категории:

1. Права доступа самого автора.

2. Права доступ всех процессов, имеющих тот же идентификатор что и

автор.

3. Права доступа остальных.

Итак, система позволяет некоторому процессу создать разделяемый

ресурс, защитить его некоторым ключом и забыть о его существовании. После

этого все те, кто знают ключ, который открывает этот ресурс, могут работать

с содержимым этого ресурса. Возникают проблемы синхронизации доступа к

разделяемому ресурсу. Решение этих проблем и другие концептуальные

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

будем рассматривать конкретные средства системы IPC.

Система IPC поддерживает три разновидности разделяемых ресурсов:

1. Разделяемая память. Концептуально - это возможность нескольких

процессов иметь общее поле оперативной памяти, и соответственно

работать с этим полем, как с неким массивом, на который имеется

указатель. Проблема синхронизации здесь стоит особенно остро, но

базово средства работы с разделяемой памяти никакой синхронизации не

предполагают.

2. Механизм передачи сообщений. Разделяемым ресурсом здесь является

очередь сообщений. Эта очередь может содержать произвольное

количество (в пределах разумного) сообщений разной длины и разного

типа. Тип сообщения - это некоторый атрибут сообщения. Очередь

сообщений может рассматриваться как единая очередь всех сообщений в

хронологическом порядке, и как множество очередей, содержащих

сообщения определенного типа, где в каждой очереди также есть

хронологический порядок. Здесь также возникают проблемы

синхронизации.

3. Семафоры. Семафоры - это нечто, что позволяет синхронизовать доступ

к разделяемым ресурсам.

Страницы: 1, 2


© 2010 Современные рефераты