WWW.DISSERS.RU

БЕСПЛАТНАЯ ЭЛЕКТРОННАЯ БИБЛИОТЕКА

   Добро пожаловать!


Pages:     | 1 |   ...   | 29 | 30 || 32 |

1. Отрицательное значение sem_op.

2. Положительное значение sem_op.

3. Нулевое значение sem_op.

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

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

Если значение поля операции sem_op равно нулю и значение семафора semval также равно нулю, выбирается следующий элемент массива op_array. Если же значение семафора semval отлично от нуля, то ядро увеличивает на единицу число процессов, ожидающих нулевого значения семафора, а обратившийся процесс переводится в состояние ожидания. При использовании флага IPCNOWAIT ядро ОС Unix не блокирует текущий процесс, а лишь сообщает в ответных параметрах о возникновении ситуации, приведшей к блокированию процесса при отсутствии флага IPCNOWAIT.

Именованные и неименованные каналы (пайпы) Операционные системы семейства Unix всегда поддерживают два типа однонаправленных каналов:

неименованные каналы;

именованные каналы FIFO.

Неименованные каналы – это самая первая форма IPC в Unix (1973), главным недостатком которых является отсутствие имени, вследствие чего они могут использоваться для взаимодействия только родственными процессами. В Unix System третьей редакции (1982) были добавлены каналы FIFO, которые называются именованными каналами. Аббревиатура FIFO расшифровывается как «first in, first out» – «первым вошел, первым вышел», то есть эти каналы работают как очереди. Именованные каналы в Unix функционируют подобно неименованным – позволяют передавать данные только в одну сторону. Однако в отличие от программных каналов каждому каналу FIFO сопоставляется полное имя в файловой системе, что позволяет двум неродственным процессам обратиться к одному и тому же FIFO. Доступ и к именованным каналам, и к неименованным организуется с помощью обычных функций read и write.

FIFO создается вызовом mkfifo:

#include #include int mkfifo(const char *pathname, mode_t mode);

/* возвращает 0 при успешном выполнении, -1 при ошибке */ Здесь pathname – обычное для Unix полное имя файла, которое и будет именем FIFO.

Аргумент mode указывает битовую маску разрешений доступа к файлу (табл. 4.2), аналогично второму аргументу команды open.

Функция mkfifo действует как open, вызванная с аргументом mode = O_CREAT | O_EXCL. Это означает, что создается новый канал FIFO или возвращается ошибка EEXIST в случае, если канал с заданным полным именем уже существует. Если не требуется создавать новый канал, вызывайте open вместо mkfifо. Для открытия существующего канала или создания нового, в том случае, если его еще не существует, вызовите mkfifo, проверьте, не возвращена ли ошибка EEXIST, и если такое случится, вызовите функцию open.

Команда mkfifo также создает канал FIFO. Ею можно пользоваться в сценариях интерпретатора или из командной строки.

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

После создания канал FIFO должен быть открыт на чтение или запись с помощью либо функции open, либо одной из стандартных функций открытия файлов из библиотеки ввода-вывода (например, fopen).

FIFO может быть открыт либо только на чтение, либо только на запись.

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

Рис. 4.1. Взаимодействие двух процессов посредством каналов FIFO При записи в программный канал или канал FIFO вызовом write данные всегда добавляются к уже имеющимся, а вызов read считывает данные, помещенные в программный канал или FIFO первыми. При вызове функции lseek для программного канала или FIFO будет возвращена ошибка ESPIPE.

Неименованные каналы создаются вызовом pipe() и предоставляют возможность только однонаправленной (односторонней) передачи данных:

#include int fd[2];

pipe(fd);

/* возвращает 0 в случае успешного завершения, -1 - в случае ошибки;*/ Функция возвращает два файловых дескриптора: fd[0] и fd[l], причем первый открыт для чтения, а второй – для записи.

Хотя канал создается одним процессом (рис. 4.2), он редко используется только этим процессом, каналы обычно используются для связи между двумя процессами (родительским и дочерним) следующим образом: процесс создает канал, а затем вызывает fork, создавая свою копию – дочерний процесс (рис. 4.3); затем родительский процесс закрывает открытый для чтения конец канала, а дочерний – открытый на запись конец канала (рис. 4.4). Это обеспечивает одностороннюю передачу данных между процессами (рис. 4.5) Рис. 4.2. Функционирование канала для случая одиночного процесса Рис. 4.3. Функционирование канала после создания дочернего процесса (после вызова fork) Рис. 4.4. Функционирование канала между двумя процессами Рис. 4.5. Функционирование каналов между тремя процессами в конвейерной обработке При вводе команды типа who | sort | 1р интерпретатор команд Unix выполняет вышеописанные действия для создания трех процессов с двумя каналами между ними (рис. 4.5).

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

Все рассмотренные выше неименованные каналы были однонаправленными (односторонними), то есть позволяли передавать данные только в одну сторону. При необходимости передачи данных в обе стороны нужно создавать пару каналов и использовать каждый из них для передачи данных в одну сторону. Этапы создания двунаправленного неименованного канала IPC следующие:

создаются каналы 1 (fd1[0] и fd1[1]) и 2 (fd2[0] и fd2[0]);

вызов fork;

родительский процесс закрывает доступный для чтения конец канала 1 (fd1[0]);

родительский процесс закрывает доступный для записи конец канала 2 (fd2[1]);

дочерний процесс закрывает доступный для записи конец канала 1 (fd1[1]);

дочерний процесс закрывает доступный для чтения конец канала 2 (fd2[0]).

9.4.1 Очереди сообщений Для обеспечения возможности обмена сообщениями между процессами механизм очередей поддерживается следующими системными вызовами:

msgget для образования новой очереди сообщений или получения дескриптора существующей очереди;

rnsgsnd для постановки сообщения в указанную очередь сообщений;

rnsgrcv для выборки сообщения из очереди сообщений;

rnsgctl для выполнения ряда управляющих действий.

Прототипы перечисленных системных вызовов описаны в файлах #include #include По системному вызову msgget в ответ на ключ (key) определяется уникальное имя очереди и набор флагов (полностью аналогичны флагам в системном вызове semget). Вызовом msgget ядро либо создает новую очередь сообщений в ядре и возвращает пользователю идентификатор созданной очереди, либо находит элемент таблицы очередей сообщений ядра, содержащий указанный ключ, и возвращает соответствующий идентификатор очереди:

int msgqid = msgget(key_t key, int flag) Таким образом, очередь сообщения обладает живучестью ядра. Для помещения сообщения в очередь служит системный вызов msgsnd:

int rnsgsnd (int msgqid, void *rnsg, size_t size, int flaq) где msg – это указатель на структуру длиной size, содержащую определяемый пользователем целочисленный тип сообщения и символьный массив-сообщение, причем размер пользовательских данных вычисляется следующим образом: size = sizeof(msg) – sizeof(long).

Структура msg всегда имеет вид struct rnsq { lonq rntype; /* тип сообщения */ char mtext[SOMEVALUE]; /*текст сообщения */ };

Поле типа long всегда должно быть первым в структуре, далее могут следовать в любом порядке пользовательские данные, в этом случае ядро не накладывает ограничение на тип данных, а только на их длину (зависящую от реализации системы). Параметр flag определяет действия ядра для вызвавшего потока при чтении очереди или выходе за пределы допустимых размеров внутренней буферной памяти. Если flag = 0, то при отсутствии сообщения в очереди поток блокируется. Если flag = IPCNOWAIT, то поток не блокируется и при отсутствии сообщения возвращается ошибка ENOMSG.

Условиями успешной постановки сообщения в очередь являются:

наличие прав процесса по записи в данную очередь сообщений;

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

положительное значение типа сообщения.

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

Для приема сообщения используется системный вызов msgrcv int rnsgrcv (int msgqid, void *msg, size_t size, long rnsg_type, int flag) Аргумент rnsg_type задает тип сообщения, которое нужно считать из очереди если значение равно 0, то возвращается первое сообщение в очереди, т. е. самое старое сообщение;

если тип больше 0, то возвращается первое сообщение, тип которого равен указанному числу;

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

Значение size в данном случае указывает ядру, что возвращаемые данные не должны превышать размера указанного в size.

Системный вызов msgctl позволяет управлять очередями сообщений int msgctl (int msgqid, int command, struct msgid_ds *msg_stat) и используется:

для опроса состояния описателя очереди сообщений (command = IPCSTAT) и помещения его в структуру msgstat;

изменения его состояния (command = IPCSET), например изменения прав доступа к очереди;

для уничтожения указанной очереди сообщений (command = IPCRMID).

9.4.2 Работа с разделяемой памятью Для работы с разделяемой памятью используются системные вызовы:

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

shmat подключает сегмент с указанным описателем к виртуальной памяти обращающегося процесса;

shmdt отключает от виртуальной памяти ранее подключенный к ней сегмент с указанным виртуальным адресом начала;

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

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

Системный вызов int shmid = shmget (key_t key, size_t size, int flag) на основании параметра size определяет желаемый размер сегмента в байтах. Если в таблице разделяемой памяти находится элемент, содержащий заданный ключ, и права доступа не противоречат текущим характеристикам обращающегося процесса, то значением системного вызова является идентификатор существующего сегмента, причем параметр size должен быть в этом случае равен 0. В противном случае создается новый сегмент с размером не меньше установленного в системе минимального размера сегмента разделяемой памяти и не больше установленного максимального размера. Живучесть объектов разделяемой памяти определяется живучестью ядра. Создание сегмента не означает немедленного выделения под него основной памяти, и это действие откладывается до выполнения первого системного вызова подключения сегмента к виртуальной памяти некоторого процесса. Флаги IPCCREAT и IPCEXCL аналогичны рассмотренным выше.

Подключение сегмента к виртуальной памяти выполняется путем обращения к системному вызову shmat:

void *virtaddr = shmat(int shmid, void *daddr, int flags).

Параметр shmid – это ранее полученный идентификатор сегмента, a daddr – желаемый процессом виртуальный адрес, который должен соответствовать началу сегмента в виртуальной памяти. Значением системного вызова является фактический виртуальный адрес начала сегмента.

Если значением daddr является NULL, ядро выбирает наиболее удобный виртуальный адрес начала сегмента. Флаги системного вызова shmat приведены ниже в таблице.

Таблица 4.Флаги системного вызова shmat Флаг Описание Ядро подключает участок памяти только для SHM_RDONLY чтения Определяет, если возможно, способ обработки SHM_RND ненулевого значения daddr.

Для отключения сегмента от виртуальной памяти используется системный вызов shmdt:

int shmdt (*daddr) где daddr – это виртуальный адрес начала сегмента в виртуальной памяти, ранее полученный от системного вызова shmat.

Системный вызов shmctl int shmctl (int shmid, int command, struct shmid_ds *shrn_stat) по синтаксису и назначению аналогичен msgctl.

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

#include #include #include #include #include #include #include #include #include #include #define MAXLINE #define SVSEM_MODE (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH) #define SKEY 1234L // идентификатор семафора union semun { int val;

struct semid_ds *buf;

ushort *array;

};

int var;

int main(int argc, char **argv) { char filename[] = "./rezult.txt";

pid_t pid; // идентификатор дочернего процесса time_t ctime; // переменная времени int oflag, c, semid;

struct tm *ctm;

union semun arg;

struct semid_ds seminfo;

struct sembuf psmb;

unsigned short *prt = NULL;

var = 0;

oflag = SVSEM_MODE | IPC_CREAT; // флаг семафора printf("Parent: Creating semaphore...\n");

semid = semget(SKEY, 1, oflag); // создание семафора arg.buf = &seminfo;

printf("Parent: Getting info about semaphore (not required, for example)...\n");

semctl(semid, 0, IPC_STAT, arg); //получение инф. о семафоре g.buf->sem_ctime;

ctm = localtime(&ctime);

printf("%s %d %s %d %s %d %s","Parent: Creating time - ", ctm->tm_hour,":",ctm->tm_min,":",ctm->tm_sec,"\n");

arg.val = 5;

printf("%s %d %s","Parent: Setting value \"",arg.val, "\" to semaphores...\n");

semctl(semid, 0, SETVAL, arg); // установка значения семафора printf("Parent: Creating child process...\n");

if ((pid = fork()) == 0) { // child process ;

printf(" Child: Child process was created...\n");

struct sembuf csmb;

unsigned short semval;

union semun carg;

int oflag = SVSEM_MODE | IPC_EXCL;

printf(" Child: Opening semaphore...\n");

int smd = semget(SKEY, 1, oflag); // открытие семафора csmb.sem_num = 0;

csmb.sem_flg = 0;

csmb.sem_op = -1;

printf(" Child: Locking semaphore...\n");

semop(smd,&csmb,1); // блокировка семафора printf(" Child: Do something...\n");

// работа процесса в защищенном режиме sleep(2);

// работа процесса в защищенном режиме закончена printf(" Child: Done something...\n");

carg.buf = NULL;

carg.array = &semval;

semctl(smd,0,GETALL,carg); // получение значения семафора semval = *carg.array;

printf("%s %d %s"," Child: Semaphore value = ",semval,"\n");

csmb.sem_num = csmb.sem_flg = 0;

csmb.sem_op = -semval;

printf(" Child: Unlocking semaphore...\n");

semop(smd,&csmb,1);

printf(" Child: Terminating child process...\n");

exit(0);

} printf("Parent: Waiting for unlocking semaphore...\n");

Pages:     | 1 |   ...   | 29 | 30 || 32 |






© 2011 www.dissers.ru - «Бесплатная электронная библиотека»

Материалы этого сайта размещены для ознакомления, все права принадлежат их авторам.
Если Вы не согласны с тем, что Ваш материал размещён на этом сайте, пожалуйста, напишите нам, мы в течении 1-2 рабочих дней удалим его.