11.1.Введение
В главе 10 мы описывали различные виды семафоров, начав с:
■ бинарного семафора, который может принимать только два значения: 0 и 1. По своим свойствам такой семафор аналогичен взаимному исключению (глава 7), причем значение 0 для семафора соответствует блокированию ресурса, а 1 — освобождению.
Далее мы перешли к более сложному виду семафоров:
■ семафор-счетчик, значение которого лежит в диапазоне от 0 до некоторого ограничения, которое, согласно Posix, не должно быть меньше 32767. Они использовался для подсчета доступных ресурсов в задаче о производителях и потребителях, причем значение семафора соответствовало количеству доступных ресурсов.
Для обоих типов семафоров операция wait состояла в ожидании изменения значения семафора с нулевого на ненулевое и последующем уменьшении этого значения на 1. Операция post увеличивала значение семафора на 1, оповещая об этом все процессы, ожидавшие изменения значения семафора.
Для семафоров System V определен еще один уровень сложности:
■ набор семафоров-счетчиков — один или несколько семафоров, каждый из которых является счетчиком. На количество семафоров в наборе существует ограничение (обычно порядка 25 — раздел 11.7). Когда мы говорим о семафоре System V, мы подразумеваем именно набор семафоров-счетчиков, а когда говорим о семафоре Posix, подразумевается ровно один семафор-счетчик.
Для каждого набора семафоров ядро поддерживает следующую информационную структуру, определенную в файле
struct semid_ds { struct ipc_perm sem_perm; /* разрешения на операции */ struct sem *sem_base; /*указатель на массив семафоров в наборе */ ushort sem_nsems; /* количество семафоров в наборе */ time_t sem_otime; /* время последнего вызова semop(); */ time_t sem_ctime; /* время создания последнего IPC_SET */};Структура ipc_perm была описана в разделе 3.3. Она содержит разрешения доступа для данного семафора.
Структура sem представляет собой внутреннюю структуру данных, используемую ядром для хранения набора значений семафора. Каждый элемент набора семафоров описывается так:
struct sem { ushort_t semval; /* значение семафора, неотрицательно */ short sempid; /* PID последнего процесса, вызвавшего semop(), SETVAL, SETALL */ ushort_t semncnt; /* количество ожидающих того, что значение семафора превысит текущее */ ushort_t semzcnt; /* количество ожидающих того, что значение семафора станет равным 0*/};Обратите внимание, что sem_base представляет собой указатель на массив структур типа sem — по одному элементу массива на каждый семафор в наборе.
Помимо текущих значений всех семафоров набора в ядре хранятся еще три поля данных для каждого семафора: идентификатор процесса, изменившего значение семафора последним, количество процессов, ожидающих увеличения значения семафора, и количество процессов, ожидающих того, что значение семафора станет нулевым.
ПРИМЕЧАНИЕ
В стандарте Unix 98 данная структура не имеет имени. Приведенное выше имя (sem) взято из реализации System V.
Любой конкретный семафор в ядре мы можем воспринимать как структуру semid_ds, указывающую на массив структур sem. Если в наборе два элемента, мы получим картину, изображенную на рис. 11.1. На этом рисунке переменная sem_nsems имеет значение 2, а каждый из элементов набора идентифицируется индексом ([0] или [1]).
Рис. 11.1. Структуры данных ядра для набора семафоров из двух элементов
11.2. Функция semget
Функция semget создает набор семафоров или обеспечивает доступ к существующему.
#include int semget(key_t key, int nsems, int oflag);/* Возвращает неотрицательный идентификатор в случае успешного завершения, –1 – в случае ошибки */Эта функция возвращает целое значение, называемое идентификатором семафора, которое затем используется при вызове функций semop и semctl.
Аргумент nsems задает количество семафоров в наборе. Если мы не создаем новый набор, а устанавливаем доступ к существующему, этот аргумент может быть нулевым. Количество семафоров в уже созданном наборе изменить нельзя.
Аргумент oflag представляет собой комбинацию констант SEM_R и SEM_A из табл. 3.3. Здесь R обозначает Read (чтение), а А — Alter (изменение). К этим константам можно логически прибавить IPC_CREAT или IPC_CREAT | IPC_EXCL, о чем мы уже говорили в связи с рис. 3.2.
При создании нового семафора инициализируются следующие поля структуры semid_ds:
■ поля uid и cuid структуры sem_perm устанавливаются равными действующему идентификатору пользователя процесса, а поля guid и cgid устанавливаются равными действующему идентификатору группы процесса;
■ биты разрешений чтения-записи аргумента oflag сохраняются в sem_perm.mode;
■ поле sem_otime устанавливается в 0, а поле sem_ctime устанавливается равным текущему времени;
■ значение sem_nsems устанавливается равным nsems;
■ структуры sem для каждого из семафоров набора не инициализируются. Это происходит лишь при вызове semctl с командами SETVAL или SETALL.
Инициализация значения семафора
В комментариях к исходному коду в издании этой книги 1990 года неправильно утверждалось, что значения семафоров набора инициализируются нулем при вызове semget с созданием нового семафора. Хотя в некоторых системах это действительно происходит, гарантировать подобное поведение ядра нельзя. Более старые реализации System V вообще не инициализировали значения семафоров, оставляя их содержимое таким, каким оно было до выделения памяти.
В большинстве версий документации ничего не говорится о начальных значениях семафоров при создании нового набора. Руководство по написанию переносимых программ X/Open XPG3 (1989) и стандарт Unix 98 исправляют это упущение и открыто утверждают, что значения семафоров не инициализируются вызовом semget, а устанавливаются только при вызове semctl (вскоре мы опишем эту функцию) с командами SETVAL (установка значения одного из семафоров набора) и SETALL (установка значений всех семафоров набора).
Необходимость вызова двух функций для создания (semget) и инициализации (semctl) набора семафоров является неисправимым недостатком семафоров System V. Эту проблему можно решить частично, указывая флаги IPC_CREAT | IPC_EXCL при вызове semget, чтобы только один процесс, вызвавший semget первым, создавал семафор, и этот же процесс должен семафор инициализировать.
Другие процессы получают при вызове semget ошибку EEXIST, так что им приходится еще раз вызывать semget, уже не указывая флагов IPC_CREAT или IPC_EXCL.
Однако ситуация гонок все еще не устранена. Предположим, что два процесса попытаются создать и инициализировать набор семафоров с одним элементом приблизительно в один и тот же момент времени, причем оба они будут выполнять один и тот же фрагмент кода:
1 oflag = IPC_CREAT | IPC_EXCL | SVSEM_MODE;2 if ((semid = semget(key, 1, oflag)) >= 0) { /* успешное завершение, этот процесс должен инициализировать семафор */3 arg.val = 1;4 Semctl(semid, 0, SETVAL, arg);5 } else if (errno == EEXIST) { /* уже существует, поэтому просто открываем семафор */6 semid = Semget(key, 1, SVSEM_MODE);7 } else8 err_sys("semget error");9 Semop(semid, …); /* уменьшаем значение семафора на 1 */При этом может произойти вот что:
1. Первый процесс выполняет строки 1-3, а затем останавливается ядром.
2. Ядро запускает второй процесс, который выполняет строки 1, 2, 5, 6 и 9.
Хотя первый процесс, создавший семафор, и будет единственным процессом, который проинициализирует семафор, ядро может переключиться на другой процесс в промежутке между созданием и инициализацией семафора, и тогда второй процесс сможет обратиться к семафору (строка 9), который еще не был проинициализирован. Значение семафора после выполнения строки 9 для второго процесса будет не определено.
ПРИМЕЧАНИЕ
В семафорах Posix эта проблема исключается благодаря тому, что семафоры создаются и инициализируются единственным вызовом — sem_open. Более того, даже если указан флаг O_CREAT, семафор будет проинициализирован только в том случае, если он еще не существовал на момент вызова функции.
Будет ли обсуждавшаяся выше ситуация гонок создавать какие-то проблемы — зависит от приложения. В некоторых приложениях (например, задача производителей и потребителей в листинге 10.12) единственный процесс всегда создает и инициализирует семафор. В этом варианте ситуация гонок возникать не будет. В других приложениях (пример с блокировкой файлов в листинге 10.10) нет такого единственного процесса, который бы создавал и инициализировал семафор: первый процесс, открывающий семафор, должен создать его и проинициализировать, так что в этом случае ситуацию гонок следует исключать.
К счастью, существует способ исключить в данном случае ситуацию гонок. Стандарт гарантирует, что при создании набора семафоров поле sem_otime структуры semid_ds инициализируется нулем. (Руководства System V с давних пор говорят об этом, это утверждается и в стандартах XPG3 и Unix 98.) Это поле устанавливается равным текущему времени только при успешном вызове semop. Следовательно, второй процесс в приведенном выше примере должен просто вызвать semctl с командой IPC_STAT после второго вызова semget (строка 6). Затем этот процесс должен ожидать изменения значения sem_otime на ненулевое, после чего он может быть уверен в том, что семафор был успешно проинициализирован другим процессом. Это значит, что создавший семафор процесс должен проинициализировать его значение и успешно вызвать semop, прежде чем другие процессы смогут воспользоваться этим семафором. Мы используем этот метод в листингах 10.37 и 11.6.
11.3. Функция semop
После инициализации семафора вызовом semget с одним или несколькими семафорами набора можно выполнять некоторые действия с помощью функции semop:
#include int semop(int semid, struct sembuf *opsptr, size_t nops);/* Возвращает 0 в случае успешного завершения, –1 – в случае ошибки */Указатель opsptr указывает на массив структур вида
struct sembuf { short sem_num; /* номер семафора: 0, 1,… nsems-1 */ short sem_op; /* операция с семафором: <0, 0, >0 */ short sem_flg; /* флаги операции: 0, IPC_NOWAIT, SEM_UNDO */};Количество элементов в массиве структур sembuf, на который указывает opsptr, задается аргументом nops. Каждый элемент этого массива определяет операцию с одним конкретным семафором набора. Номер семафора указывается в поле sen_num и принимает значение 0 для первого семафора, 1 для второго и т. д., до nsems-1, где nsems соответствует количеству семафоров в наборе (второй аргумент в вызове semget при создании семафора).
ПРИМЕЧАНИЕ
В структуре гарантированно содержатся только три указанных выше поля. Однако в ней могут быть и другие поля, причем порядок их может быть совершенно произвольным. Поэтому не следует статически инициализировать эту структуру кодом наподобие
struct sembuf ops[2] = { 0, 0, 0, /* ждем, пока первый элемент не станет равен нулю */ 0, 1, SEM_UNDO /* затем увеличиваем [0] на 1 */};Вместо этого следует инициализировать ее динамически, как в нижеследующем примере:
struct sembuf ops[2];ops[0].sem_num = 0; /* ждем, пока первый элемент не станет равен нулю */ops[0].sem_op = 0;ops[0].sem_flg = 0;ops[1].sem_num = 0; /* затем увеличиваем [0] на 1 */ops[1].sem_op = 1;ops[1].sem_flg = SEM_UNDO;Весь массив операций, передаваемый функции semop, выполняется ядром как одна операция; атомарность при этом гарантируется. Ядро выполняет все указанные операции или ни одну из них. Пример на эту тему приведен в разделе 11.5.
Каждая операция задается значением sem_op, которое может быть отрицательным, нулевым или положительным. Сделаем несколько утверждений, которыми будем пользоваться при дальнейшем обсуждении:
■ semval — текущее значение семафора (рис. 11.1);
■ semncnt — количество потоков, ожидающих, пока значение семафора не станет больше текущего (рис. 11.1);
■ semzcnt — количество потоков, ожидающих, пока значение семафора не станет нулевым (рис. 11.1);
■ semadj — корректировочное значение данного семафора для вызвавшего процесса. Это значение обновляется, только если для данной операции указан флаг SEM_UNDO в поле sem_flg структуры sembuf. Эта переменная создается в ядре для каждого указавшего флаг SEM_UNDO процесса в отдельности; поле структуры с именем semadj не обязательно должно существовать;
■ когда выполнение потока приостанавливается до завершения операции с семафором (мы увидим, что поток может ожидать либо обнуления семафора, либо получения семафором положительного значения), поток перехватывает сигнал и происходит возвращение из обработчика сигнала, функция semop возвращает ошибку EINTR. Используя терминологию, введенную в книге [24, с. 124], можно сказать, что функция semop представляет собой медленный системный вызов, который прерывается перехватываемыми сигналами;
■ когда выполнение потока приостанавливается до завершения операции с семафором и этот семафор удаляется из системы другим потоком или процессом, функция semop возвращает ошибку EIDRM (identifier removed — идентификатор удален).
Опишем теперь работу функции semop в зависимости от трех возможных значений поля sem_op: отрицательного, нулевого и положительного.
1. Если значение sem_op положительно, оно добавляется к semval. Такое действие соответствует освобождению ресурсов, управляемых семафором. Если указан флаг SEM_UNDO, значение sem_op вычитается из значения semadj данного семафора.
2. Если значение semop равно нулю, вызвавший поток блокируется до тех пор, пока значение семафора (semval) не станет равным нулю. Если semval уже равно 0, происходит немедленное возвращение из функции.
Если semval не равно нулю, то ядро увеличивает значение поля semzcnt данного семафора и вызвавший поток блокируется до тех пор, пока значение semval не станет нулевым (после чего значение semzcnt будет уменьшено на 1). Как отмечалось ранее, поток будет приостановлен, только если не указан флаг IPC_NOWAIT. Если семафор будет удален в процессе ожидания либо будет перехвачен сигнал, произойдет преждевременный возврат из функции с возвращением кода ошибки.
3. Если значение sem_op отрицательно, вызвавший поток блокируется до тех пор, пока значение семафора не станет большим либо равным модулю sem_op. Это соответствует запрашиванию ресурсов.
Если значение semval больше либо равно модулю sem_op, модуль sem_op вычитается из semval. Если указан флаг SEM_UNDO, модуль sem_op добавляется к значению поля semadj данного семафора.
Если значение semval меньше модуля sem_op, значение поля semncnt данного семафора увеличивается, а вызвавший поток блокируется до тех пор, пока semval не станет больше либо равно модулю semop. Когда это произойдет, поток будет разблокирован, а модуль sem_op будет отнят от semval и из значения semncnt будет вычтена единица. Если указан флаг SEM_UNDO, модуль sem_op добавляется к значению поля semadj данного семафора. Как отмечалось ранее, поток не будет приостановлен, если указан флаг IPC_NOWAIT. Ожидание завершается преждевременно, если перехватываемый сигнал вызывает прерывание либо семафор удаляется другим потоком.
ПРИМЕЧАНИЕ
Если сравнить этот набор операций с теми, которые разрешены для семафоров Posix, мы увидим, что для последних определены только команды –1 (sem_wait) и +1 (sem_post). Для семафоров System V значение семафора может изменяться с шагом, отличным от 1, и кроме того, поток может ожидать, чтобы значение семафора стало нулевым. Эти операции являются более общими, что вместе с возможностью включения нескольких семафоров в набор делает семафоры System V более сложными, чем одиночные семафоры Posix.
11.4. Функция semctl
Функция semctl предназначена для выполнения разного рода вспомогательных управляющих операций с семафорами.
#include int semctl(int semid, int semnum, int cmd, …/* union semun arg */);/* Возвращает неотрицательное значение в случае успешного завершения (см. в тексте). –1 – в случае ошибки */Первый аргумент (semid) представляет собой идентификатор семафора, a semnum указывает элемент набора семафоров (0, 1 и т. д. до nsems –1). Значение semnum используется только командами GETVAL, SETVAL, GETNCNT, GETZCNT и GETPID.
Четвертый аргумент является дополнительным — он добавляется в зависимости от команды cmd (см. комментарии в описании объединения). Объявляется это объединение следующим образом:
union semun { int val; /* используется только командой SETVAL */ struct semid_ds *buf; /* используется командами IPC_SET и IPC_STAT */ ushort *array; /* используется командами GETALL и SETALL */};Это объединение отсутствует в системных заголовочных файлах и должно декларироваться приложением (мы определяем его в заголовочном файле unpipc.h, листинг B.1). Оно передается по значению, а не по ссылке, то есть аргументом является собственно значение объединения, а не указатель на него.
ПРИМЕЧАНИЕ
К сожалению, в некоторых системах (FreeBSD и Linux) это объединение определено в заголовочном файле
Ниже приведен список поддерживаемых значений аргумента cmd. В случае успешного завершения функция возвращает 0, а в случае ошибки – –1, если в описании команды не сказано что-либо другое.
■ GETVAL — возвращает текущее значение semval. Поскольку значение семафора отрицательным быть не может (semval объявляется как unsigned short — беззнаковое короткое целое), в случае успешного возврата значение всегда будет неотрицательным.
■ SETVAL — установка значения semval равным arg.val. В случае успешного выполнения корректировочное значение этого семафора (semadj) устанавливается равным нулю для всех процессов.
■ GETPID — функция возвращает текущее значение поля sempid.
■ GETNCNT — функция возвращает текущее значение поля semncnt.
■ GETZCNT — функция возвращает текущее значение поля semzcnt.
■ GETALL — возвращаются значения semval для всех элементов набора. Значения возвращаются через указатель arg.array, а сама функция при этом возвращает 0. Обратите внимание, что вызывающий процесс должен самостоятельно выделить массив беззнаковых коротких целых достаточного объема для хранения всех значений семафоров набора, а затем сделать так, чтобы arg.array указывал на этот массив.
■ SETALL — установка значений semval для всех элементов набора. Значения задаются через указатель arg.array.
■ IPC_RMID — удаление набора семафоров, задаваемого через идентификатор semid.
■ IPC_SET — установка трех полей структуры semid_ds равными соответствующим полям структуры arg.buf: sem_perm.uid, sem_perm.gid и sem_perm.mode. Поле sem_ctime структуры semid_ds устанавливается равным текущему времени.
■ IPC_STAT — возвращение вызвавшему процессу через аргумент arg.buf текущего значения полей структуры semid_ds для данного набора семафоров. Обратите внимание, что вызывающий процесс должен сначала выделить место под структуру semid_ds и установить на нее указатель arg.buf.
11.5. Простые программы
Поскольку семафоры System V обладают живучестью ядра, мы можем продемонстрировать работу с ними, написав несколько небольших программ, которые будут выполнять с семафорами различные действия. В промежутках между выполнением отдельных программ значения семафоров будут храниться в ядре.
Программа semcreate
Первая программа, текст которой приведен в листинге 11.1,[1] просто создает набор семафоров System V. Параметр командной строки –е соответствует флагу IPC_EXCL при вызове semget, а последним аргументом командной строки является количество семафоров в создаваемом наборе.
//svsem/semcreate.с1 #include "unpipc.h"2 int3 main(int argc, char **argv)4 {5 int с, oflag, semid, nsems;6 oflag = SVSEM_MODE | IPC_CREAT;7 while ((c = Getopt(argc, argv, "e")) != –1) {8 switch (c) {9 case 'e':10 oflag |= IPC_EXCL;11 break;12 }13 }14 if (optind != argc – 2)15 err_quit("usage: semcreate [ –e ] "); 16 nsems = atoi(argv[optind + 1]);17 semid = Semget(Ftok(argv[optind], 0), nsems, oflag);18 exit(0);19 }Программа semrmid
Следующая программа, текст которой приведен в листинге 11.2, удаляет набор семафоров из системы. Для этого используется вызов semctl с командой (аргументом cmd) IPC_RMID.
//svsem/semrmid.c1 #include "unpipc.h"2 int3 main(int argc, char **argv)4 {5 int semid;6 if (argc != 2)7 err_quit("usage: semrmid "): 8 semid = Semget(Ftok(argv[1], 0), 0, 0);9 Semctl(semid, 0, IPC_RMID);10 exit(0);11 }Программа semsetvalues
Программа semsetvalues (листинг 11.3) устанавливает значения всех семафоров набора.
11-15 После получения идентификатора семафора с помощью semget мы вызываем semctl с командой IPC_STAT, чтобы получить значения полей структуры semid_ds для данного семафора. Поле sem_nsems содержит нужную нам информацию о количестве семафоров в наборе.
19-24 Мы выделяем память под массив беззнаковых коротких целых, по одному элементу на каждый семафор набора, затем копируем полученные из командной строки значения в этот массив. Вызов semctl с командой SETALL позволяет установить все значения семафоров набора одновременно.
//svsem/semsetvalues.с1 #include "unpipc.h"2 int3 main(int argc, char **argv)4 {5 int semid, nsems, i;6 struct semid_ds seminfo;7 unsigned short *ptr;8 union semun arg;9 if (argc < 2)10 err_quit("usage: semsetvalues [ values … ]"); 11 /* получение количества семафоров в наборе */12 semid = Semget(Ftok(argv[1], 0), 0, 0);13 arg.buf = &seminfo;14 Semctl(semid, 0, IPC_STAT, arg);15 nsems = arg.buf->sem_nsems;16 /* получение значений из командной строки */17 if (argc != nsems + 2)18 err_quit("%d semaphores in set, %d values specified", nsems, argc-2);19 /* выделение памяти под значения семафоров набора, помещение этих значений в новый массив */20 ptr = Calloc(nsems, sizeof(unsigned short));21 arg.array = ptr;22 for (i = 0; i < nsems; i++)23 ptr[i] = atoi(argv[i +2]);24 Semctl(semid, 0, SETALL, arg);25 exit(0);26 }Программа semgetvalues
В листинге 11.4 приведен текст программы semgetvalues, которая получает и выводит значения всех семафоров набора.
11-15 После получения идентификатора семафора с помощью semget мы вызываем semctl с командой IPC_STAT для получения значений полей структуры semi d_ds данного семафора. Поле sem_nsems содержит нужную нам информацию о количестве семафоров в наборе.
16-22 Мы выделяем память под массив беззнаковых коротких целых, по одному элементу на каждый семафор набора. Вызов semctl с командой GETALL позволяет получить все значения семафоров набора одновременно. Каждое значение выводится.
//svsem/semgetvalues.c1 #include "unpipc.h"2 int3 main(int argc, char **argv)4 {5 int semid, nsems, i;6 struct semid_ds seminfo;7 unsigned short *ptr;8 union semun arg;9 if (argc != 2)10 err_quit("usage: semgetvalues "); 11 /* получаем количество семафоров в наборе */12 semid = Semget(Ftok(argv[1], 0), 0, 0);13 arg.buf = &seminfo;14 Semctl(semid, 0, IPC_STAT, arg);15 nsems = arg.buf->sem_nsems;16 /* выделяем память под имеющееся количество элементов */17 ptr = Calloc(nsems, sizeof(unsigned short));18 arg.array = ptr;19 /* получаем и выводим значения семафоров */20 Semctl(semid, 0, GETALL, arg);21 for (i = 0; i < nsems; i++)22 printf("semval[%d] = %d\n", i, ptr[i]);23 exit(0);24 }Программа semops
В листинге 11.5 приведен текст программы semops, позволяющей выполнять последовательность действий над набором семафоров.
7-19 Параметр –n соответствует установленному флагу IPC_NOWAIT для каждой операции, а параметр –u аналогичным образом позволяет указать для каждой операции флаг SEM_UNDO. Обратите внимание, что функция semop позволяет указывать свой набор флагов для каждого элемента структуры sembuf (то есть для каждой из операций в отдельности), но для простоты мы в нашей программе задаем одинаковые флаги для всех операций.
20-29 После открытия семафора вызовом semget мы выделяем память под массив структур sembuf, по одному элементу на каждую операцию из командной строки. В отличие от предыдущих двух программ эта позволяет пользователю задать меньше команд, чем имеется семафоров в наборе.
30 Вызов semop выполняет последовательность операций над семафорами набора.
//svsem/semops.c1 #include "unpipc.h"2 int3 main(int argc, char **argv)4 {5 int с, i, flag, semid, nops;6 struct sembuf *ptr;7 flag = 0;8 while ((c = Getopt(argc, argv, "nu")) != –1) {9 switch (c) {10 case 'n':11 flag |= IPC_NOWAIT; /* для всех операций */12 break;13 case 'u':14 flag |= SEM_UNDO; /* для всех операций */15 break;16 }17 }18 if (argc = optind < 2) /* argc – optind = количество оставшихся аргументов */19 err_quit("usage: semops [ –n ] [ –u ] operation …"); 20 semid = Semget(Ftok(argv[optind], 0), 0, 0);21 optind++;22 nops = argc – optind;23 /* выделение памяти под операции, сохранение их в массиве и выполнение */24 ptr = Calloc(nops, sizeof(struct sembuf));25 for (i = 0; i < nops; i++) {26 ptr[i].sem_num = i;27 ptr[i].sem_op = atoi(argv[optind + i]); /* <0, 0, or >0 */28 ptr[i].sem_flg = flag;29 }30 Semop(semid, ptr, nops);31 exit(0);32 }Примеры
Теперь мы продемонстрируем работу пяти приведенных выше программ и исследуем некоторые свойства семафоров System V:
solaris % touch /tmp/richsolaris % semcreate –e /tmp/rich 3solaris % semsetvalues /tmp/rich 1 2 3solaris % semgetvalues /tmp/richsemval[0] = 1semval[1] = 2semval[2] = 3Сначала мы создали файл с именем /tmp/rich, который использовался при вызове ftok для вычисления идентификатора набора семафоров. Программа semcreate создает набор с тремя элементами. Программа semsetvalues устанавливает значения этих элементов (1, 2 и 3), a semgetvalues выводит их значения.
Теперь продемонстрируем атомарность выполнения последовательности операций над набором:
solaris % semops –n /tmp/rich –1 –2 –4semctl error: Resource temporarily unavailablesolaris % semgetvalues /tmp/richsemval[0] = 1semval[1] = 2semval[2] = 3В командной строке мы указываем параметр, отключающий блокировку (-n), и три операции, каждая из которых уменьшает одно из значений набора семафоров. Первая операция завершается успешно (мы можем вычесть 1 из значения первого элемента набора, потому что до вычитания оно равно 1), вторая операция также проходит (вычитаем 2 из значения второго семафора, равного 2), но третья операция выполнена быть не может (мы не можем вычесть 4 из значения третьего семафора, потому что оно равно 3). Поскольку последняя операция последовательности не может быть выполнена и поскольку мы отключили режим блокирования процесса, функция возвращает ошибку EAGAIN. Если бы мы не указали флаг отключения блокировки, выполнение процесса было бы приостановлено до тех пор, пока операция вычитания не стала бы возможной. После этого мы проверяем, чтобы ни одно из значений семафоров набора не изменилось. Хотя первые две операции и могли бы быть выполнены, ни одна из трех на самом деле произведена не была, поскольку последняя операция была некорректной. Атомарность semop и означает, что выполняются либо все операции, либо ни одна из них.
Теперь продемонстрируем работу флага SEM_UNDO:
solaris % semsetvalues /tmp/rich 1 2 3 устанавливаем конкретные значенияsolaris % semops –u /tmp/rich -1 –2 –3 для каждой операции указывается флаг SEM_UNDOsolaris % semgetvalues /tmp/richsemval[0] = 1 все произведенные изменения были сброшены после завершения работыпрограммы semopssemval[1] = 2semval[2] = 3solaris % semops /tmp/rich -1 –2 –3 теперь мы не указываем флаг SEM_UNDOsolaris % semgetvalues /tmp/richsemval[0] = 0semval[1] = 0semval[2] = 0Сначала мы заново устанавливаем значения семафоров в наборе равными 1, 2 и 3 с помощью программы semsetvalues, а затем запускаем программу semops с операциями –1, –2, –3. При этом все три значения семафоров становятся нулевыми, но, так как мы указали параметр –u при вызове semops, для всех трех операций устанавливается флаг SEM_UNDO. При этом значения semadj для элементов набора семафоров становятся равными 1, 2 и 3 соответственно. После завершения программы semops эти значения добавляются к значениям семафоров, в результате чего их значения становятся равными 1, 2 и 3, как будто мы и не запускали программу. В этом мы убеждаемся, запустив semgetvalues. Затем мы снова запускаем semops, но уже без параметра –u, и убеждаемся, что при этом значения семафоров становятся нулевыми и остаются таковыми даже после выхода из программы.
11.6. Блокирование файлов
С помощью семафоров System V можно реализовать еще одну версию функций my_lock и my_unlock из листинга 10.10. Новый вариант приведен в листинге 11.6.
//lock/locksvsem.c1 #include "unpipc.h"2 #define LOCK_PATH "/tmp/svsemlock"3 #define MAX_TRIES 104 int semid, initflag;5 struct sembuf postop, waitop;6 void7 my_lock (int fd)8 {9 int oflag, i;10 union semun arg;11 struct semid_ds seminfo;12 if (initflag == 0) {13 oflag = IPC_CREAT | IPC_EXCL | SVSEM_MODE;14 if ((semid = semget(Ftok(LOCK_PATH, 0), 1, oflag)) >= 0) {15 /* этот процесс создал семафор первым, он же его и инициализирует */16 arg.val = 1;17 Semctl(semid, 0, SETVAL, arg);18 } else if (errno == EEXIST) {19 /* семафор создан другим процессом, убедимся, что он проинициализирован */20 semid = Semget(Ftok(LOCK_PATH, 0), 1, SVSEM_MODE);21 arg.buf = &seminfo;22 for (i = 0; i < MAX_TRIES; i++) {23 Semctl(semid, 0, IPC_STAT, arg);24 if (arg.buf->sem_otime != 0)25 goto init;26 sleep(1);27 }28 err_quit("semget OK, but semaphore not initialized");29 } else30 err_sys("semget error");31 init:32 initflag = 1;33 postop.sem_num = 0; /* инициализируем две структуры semop()*/34 postop.sem_op = 1;35 postop.sem_flg = SEM_UNDO;36 waitop.sem_num = 0;37 waitop.sem_op = –1;38 waitop.sem_flg = SEM_UNDO;39 }40 Semop(semid, &waitop, 1); /* уменьшим на 1 */41 }42 void43 my_unlock(int fd)44 {45 Semop(semid, &postop, 1); /* увеличим на 1*/46 }13-17 Нам нужно гарантировать, что только один процесс проинициализирует семафор, поэтому при вызове semget мы указываем флаги IPC_CREAT | IPC_EXCL. Если этот вызов оказывается успешным, процесс вызывает semctl для инициализации семафора значением 1. Если мы запустим несколько процессов одновременно и все они вызовут функцию my_lock, только один из них создаст семафор (предполагается, что он еще не существует) и проинициализирует его.
18-20 Если первый вызов semget возвращает ошибку EEXIST, процесс вызывает semget еще раз, но уже без флагов IPC_CREAT и IPC_EXCL.
21-28 В этой программе возникает такая же ситуация гонок, как и обсуждавшаяся в разделе 11.2, когда мы говорили об инициализации семафоров System V вообще. Для исключения такой ситуации все процессы, которые обнаруживают, что семафор уже создан, вызывают semctl с командой IPC_STAT, проверяя значение sem_otime данного семафора. Когда это значение становится ненулевым, мы можем быть уверены, что создавший семафор процесс проинициализировал его и вызвал semop (этот вызов находится в конце функции) успешно. Если значение этого поля оказывается нулевым (что должно происходить крайне редко), мы приостанавливаем выполнение процесса на одну секунду вызовом sleep, а затем повторяем попытку. Число попыток мы ограничиваем, чтобы процесс не «заснул» навсегда.
33-38 Как отмечалось ранее, конкретный порядок полей структуры sembuf зависит от реализации, поэтому статически инициализировать ее нельзя. Вместо этого мы выделяем место под две такие структуры и присваиваем значения их полям во время выполнения программы, когда процесс вызывает my_lock в первый раз. При этом мы указываем флаг SEM_UNDO, чтобы ядро сняло блокировку, если процесс завершит свою работу, не сняв ее самостоятельно (см. упражнение 10.3).
Создание семафора при первой необходимости реализовать довольно просто (все процессы пытаются создать семафор, игнорируя ошибку, если он уже существует), но удаление семафора после завершения работы всех процессов организовать гораздо сложнее. В случае демона печати, использующего файл с последовательным номером для упорядочения заданий печати, удалять семафор нет необходимости. Но в других приложениях может возникнуть необходимость удалить семафор при удалении соответствующего файла. В этом случае лучше пользоваться блокировкой записи, чем семафором.
11.7. Ограничения семафоров System V
На семафоры System V накладываются определенные системные ограничения, так же, как и на очереди сообщений. Большинство этих ограничений были связаны с особенностями реализации System V (раздел 3.8). Они показаны в табл. 11.1. Первая колонка содержит традиционное для System V имя переменной ядра, в которой хранится соответствующее oгрaничeниe.
Таблица 11.1. Типичные значения ограничений для семафоров System V
| Имя | Описание | DUnix 4.0B | Solaris 2.6 |
|---|---|---|---|
| semmni | Максимальное количество наборов семафоров в системе | 16 | 10 |
| semmsl | Максимальное количество семафоров в наборе | 25 | 25 |
| semmns | Максимальное количество семафоров в системе | 400 | 60 |
| semopm | Максимальное количество операций за один вызов semop | 10 | 10 |
| semmnu | Максимальное количество структур undo в системе | 30 | |
| semume | Максимальное количество записей в структуре undo | 10 | 10 |
| semvmx | Максимальное значение семафора | 32767 | 32767 |
| semaem | Максимальное значение корректировки при выходе | 16384 | 16384 |
В Digital Unix 4.0B никакого ограничения на semmnu не существует.
Пример
Программа в листинге 11.7 позволяет определить ограничения, приведенные в табл. 11.1.
//svsem/limits.c1 #include "unpipc.h"2 /* максимальные величины, выше которых ограничение не проверяется */3 #define MAX_NIDS 4096 /* максимальное количество идентификаторов семафоров */4 #define MAX_VALUE 1024*1024 /* максимальное значение семафора */5 #define MAX_MEMBERS 4096 /* максимальное количество семафоров в наборе */6 #define MAX_NOPS 4096 /* максимальное количество операций за вызов semop */7 #define MAX_NPROC Sysconf(_SC_CHILD_MAX)8 int9 main(int argc, char **argv)10 {11 int i, j, semid, sid[MAX_NIDS], pipefd[2];12 int semmni, semvmx, semmsl, semmns, semopn, semaem, semume, semmnu;13 pid_t *child;14 union semun arg;15 struct sembuf ops[MAX_NOPS];16 /* сколько наборов с одним элементом можно создать? */17 for (i = 0; i <= MAX_NIDS; i++) {18 sid[i] = semget(IPC_PRIVATE, 1, SVSEM_MODE | IPC_CREAT);19 if (sid[i] == –1) {20 semmni = i;21 printf("%d identifiers open at once\n", semmni);22 break;23 }24 }25 /* перед удалением находим максимальное значение, используя sid[0] */26 for (j = 7; j < MAX_VALUE; j += 8) {27 arg.val = j;28 if (semctl(sid[0], 0, SETVAL, arg) == –1) {29 semvmx = j – 8;30 printf("max semaphore value = %d\n", semvmx);31 break;32 }33 }34 for (j = 0; j < i; j++)35 Semctl(sid[j], 0, IPC_RMID);36 /* определяем максимальное количество семафоров в наборе */37 for (i = 1; i <= MAX_MEMBERS; i++) {38 semid = semget(IPC_PRIVATE, i, SVSEM_MODE | IPC_CREAT);39 if (semid == –1) {40 semmsl = i-1;41 printf("max of %d members per set\n", semmsl);42 break;43 }44 Semctl(semid, 0, IPC_RMID);45 }46 /* сколько всего семафоров можно создать? */47 semmns = 0;48 for (i = 0; i < semmni; i++) {49 sid[i] = semget(IPC_PRIVATE, semmsl, SVSEM_MODE | IPC_CREAT);50 if (sid[i] == –1) {51 /*52 До этого в наборе было semmsl элементов,53 но теперь мы уменьшаем количество элементов на 1 и смотрим.54 не получится ли создать семафор55 */56 for (j = semmsl-1; j > 0; j--) {57 sid[1] = semget(IPC_PRIVATE, j, SVSEM_MODE | IPC_CREAT);58 if (sid[i] != –1) {59 semmns += j;60 printf("max of %d semaphores\n", semmns);61 Semctl(sid[i], 0, IPC_RMID);62 goto done;63 }64 }65 err_quit("j reached 0, semmns = %d", semmns);66 }67 semmns += semmsl;68 }69 printf("max of %d semaphores\n", semns);70 done:71 for (j = 0; j < i; j++)72 Semctl(sid[j], 0, IPC_RMID);73 /* определяем количество операций за вызов semop() */74 semid = Semget(IPC_PRIVATE, semmsl, SVSEM_MODE | IPC_CREAT);75 for (i = 1; i <= MAX_NOPS; i++) {76 ops[i-1].sem_num = i-1;77 ops[i-1].sem_op = 1;78 ops[i-1].sem_flg = 0;79 if (semop(semid, ops, i) += –1) {80 if (errno != E2BIG)81 err_sys("expected E2BIG from semop");82 semopn = i-1;83 printf("max of %d operations per semop()\n", semopn);84 break;85 }86 }87 Semctl(semid, 0, IPC_RMID);88 /* определение максимального значения semadj */89 /* создание одного набора с одним семафором */90 semid = Semget(IPC_PRIVATE, 1, SVSEM_MODE | IPC_CREAT);91 arg.val = semvmx;92 Semctl(semid, 0, SETVAL, arg); /* устанавливаем значение на максимум */93 for (i = semvmx-1; i > 0; i--) {94 ops[0].sem_num = 0;95 ops[0].sem_op = –i;96 ops[0].sem_flg = SEM_UNDO;97 if (semop(semid, ops, 1) != –1) {98 semaem = i;99 printf("max value of adjust-on-exit = %d\n", semaem);100 break;101 }102 }103 Semctl(semid, 0, IPC_RMID);104 /* определение максимального количества структур UNDO */105 /* создаем один набор с одним семафором и инициализируем нулем */106 semid = Semget(IPC_PRIVATE, 1, SVSEM_MODE | IPC_CREAT);107 arg.val = 0;108 Semctl(semid, 0, SETVAL, arg); /* установка значения семафора в 0 */109 Pipe(pipefd);110 child = Malloc(MAX_NPROC * sizeof(pid_t));111 for (i = 0; i < MAX_NPROC; i++) {112 if ((child[i] = fork()) == –1) {113 semmnu = i – 1;114 printf("fork failed, semmnu at least %d\n", semmnu);115 break;116 } else if (child[i] == 0) {117 ops[0].sem_num = 0; /* дочерний процесс вызывает semop() */118 ops[0].sem_op = 1;119 ops[0].sem_flg = SEM_UNDO;120 j = semop(semid, ops, 1); /* 0 в случае успешного завершения. –1 – в случае ошибки */121 Write(pipefd[1], &j, sizeof(j));122 sleep(30); /* ожидает завершения родительским процессом */123 exit(0); /* на всякий случай */124 }125 /* родительский процесс считывает результат вызова semop() */126 Read(pipefd[0], &j, sizeof(j));127 if (j == –1) {128 semmnu = i;129 printf("max # undo structures = %d\n", semmnu);130 break;131 }132 }133 Semctl(semid, 0, IPC_RMID);134 for (j = 0; j <= i && child[j] > 0; j++)135 Kill(child[j], SIGINT);136 /* определение максимального количества записей корректировки на процесс */137 /* создание одного набора с максимальным количеством семафоров */138 semid = Semget(IPC_PRIVATE, semmsl, SVSEM_MODE | IPC_CREAT);139 for (i = 0; i < semmsl; i++) {140 arg.val = 0;141 Semctl(semid, i, SETVAL, arg); /* установка значения семафора в 0 */142 ops[i].sem_num = i;143 ops[i].sem_op = 1; /* добавляем 1 к значению семафора */144 ops[i].sem_flg = SEM_UNDO;145 if (semop(semid, ops, i+1) == –1) {146 semume = i;147 printf("max # undo entries per process = %d\n", semume);148 break;149 }150 }151 Semctl(semid, 0, IPC_RMID);152 exit(0);153 }11.8. Резюме
У семафоров System V имеются следующие отличия от семафоров Posix:
1. Семафоры System V представляют собой набор значений. Последовательность операций над набором семафоров либо выполняется целиком, либо не выполняется вовсе.
2. К любому элементу набора семафоров могут быть применены три операции: проверка на нулевое значение, добавление некоторого значения к текущему и вычитание некоторого значения из текущего (в предположении, что значение остается неотрицательным). Для семафоров Posix определены только операции увеличения и уменьшения значения семафора на 1 (в предположении, что значение остается неотрицательным).
3. Создание семафора System V имеет некоторую особенность, заключающуюся в необходимости выполнения двух вызовов для создания и инициализации семафора, что может привести к ситуации гонок.
4. Семафоры System V предоставляют возможность отмены операции с ними (undo) после завершения работы процесса.
Упражнения
1. Листинг 6.6 представлял собой измененный вариант листинга 6.4, в котором программа принимала идентификатор очереди вместо полного имени файла. Мы продемонстрировали, что для получения доступа к очереди System V достаточно знать только ее идентификатор (предполагается наличие достаточных разрешений). Проделайте аналогичные изменения с программой в листинге 11.5 и посмотрите, верно ли вышесказанное для семафоров System V.
2. Что произойдет с программой в листинге 11.6, если файл LOCK_PATH не будет существовать?
ЧАСТЬ 4