Текст книги "Основы программирования в Linux"

Автор книги: Нейл Мэтью

Соавторы: Ричард Стоунс
сообщить о нарушении

Текущая страница: 53 (всего у книги 67 страниц)

shmget

Создается совместно используемая память с помощью функции shmget:

int shmget(key_t key, size_t size, int shmflg);

Как и для семафоров, программа предоставляет key, фактически именующий сегмент совместно используемой памяти, а функция shmget возвращает идентификатор совместно используемой памяти, который применяется всеми последующими функциями для работы с этой областью памяти. Есть особое значение ключа IPC_PRIVATE, создающее для процесса частную, скрытую от других совместно используемую память. Обычно вы не будете пользоваться этим значением, да и кроме всего прочего в некоторых системах Linux можете обнаружить, что такая частная разделяемая память на самом деле далеко не частная.

Второй параметр size задает требуемый объем памяти в байтах.

Третий параметр shmflg содержит девять флагов прав доступа, которые используются так же, как флаги режима создающихся файлов. Для создания нового сегмента совместно используемой памяти специальный бит, описываемый IPC_CREAT, должен с помощью поразрядной операции OR быть объединен с правами доступа. Не считается ошибкой задание флага IPC_CREAT и передача ключа существующего сегмента совместно используемой памяти. Флаг IPC_CREAT, если в нем нет нужды, беззвучно игнорируется.

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

Если совместно используемая память создана успешно, shmget вернет неотрицательное целое, идентификатор совместно используемой памяти. В случае аварийного завершения функция вернет -1.

shmat

Когда вы впервые создаете сегмент совместно используемой памяти, он недоступен ни одному процессу. Для того чтобы обеспечить доступ к совместно используемой памяти, нужно присоединить ее к адресному пространству процесса. Делается это с помощью функции shmat:

void *shmat(int shm_id, const void *shm_addr, int shmflg);

Первый параметр shm_id – идентификатор совместно используемой области памяти, возвращаемый функцией shmget.

Второй параметр shm_addr – адрес, по которому совместно используемая память присоединяется к текущему процессу. Почти всегда его следует задавать пустым указателем, что позволяет системе выбрать адрес для доступа к совместно используемой памяти.

Третий параметр shmflg – набор поразрядных флагов. Два возможных значения: SHM_RND, в сочетании с shm_addr управляющее адресом, по которому присоединяется к процессу совместно используемая память, и SHM_RDONLY, которое делает присоединенную память доступной только для чтения. Очень редко возникает необходимость управлять адресом присоединения совместно используемой памяти. Как правило, следует позволить системе выбрать для вас адрес, поскольку в противном случае приложение станет в значительной степени аппаратно-зависимым.

Если вызов shmat завершился успешно, он вернет указатель на первый байт совместно используемой памяти. В случае аварийного завершения возвращается -1.

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

Исключение из этого правила возникает, если выражение shmflg & SHM_RDONLY равно true. В этом случае в совместно используемую память нельзя писать, даже если права доступа предоставляют такую возможность.

shmdt

Функция shmdt отсоединяет совместно используемую память от текущего процесса. Она принимает указатель на адрес, возвращенный функцией shmat. В случае успеха функция вернет 0, в случае ошибки – -1. Имейте в виду, что отсоединение совместно используемой памяти не уничтожает ее, а только делает эту память недоступной для текущего процесса.

shmctl

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

int shmctl(int shm_id, int command, struct shmid_ds *buf);

У структуры типа shmid_ds есть, как минимум, следующие элементы:

struct shmid_ds {

 uid_t shm_perm.uid;

 uid_t shm_perm.gid;

 mode_t shm_perm.mode;

}

Первый параметр shm_id – идентификатор, возвращаемый функцией shmget.

Второй параметр command содержит предпринимаемое действие. Он может принимать три значения, перечисленные в табл. 14.2.

Таблица 14.2

IPC_STAT	Задаёт данные в структуре shmid_ds, отображающие значения, связанные с совместно используемой памятью
IPC_SET	Устанавливает значения, связанные с совместно используемой памятью в соответствии с данными из структуры типа shmid_ds, если у процесса есть право на это действие
IPC_RMID	Удаляет сегмент совместно используемой памяти

Третий параметр buf – указатель на структуру, содержащую режимы и права доступа для совместно используемой памяти.

В случае успеха возвращает 0, в случае ошибки – -1. В стандарте X/Open не описано, что произойдет, если вы попытаетесь удалить присоединенный к процессу сегмент совместно используемой памяти. Обычно присоединенный, но удаленный сегмент совместно используемой памяти продолжает функционировать до тех пор, пока не будет отсоединен от последнего процесса. Но поскольку это поведение не задано в стандарте, на него лучше не рассчитывать.

Выполните упражнение 14.2.

Упражнение 14.2. Совместно используемая память

После знакомства с функциями совместно используемой памяти можно написать программу для их использования. В данном упражнении вы напишите пару программ: shm1.c и shm2.c. Первая (потребитель) создаст сегмент разделяемой памяти и затем отобразит любые данные, записанные в него. Вторая (поставщик) присоединит существующий сегмент совместно используемой памяти и позволит вам ввести данные в этот сегмент.

1. Сначала создайте общий заголовочный файл для описания совместно используемой памяти, которую вы хотите предоставить. Назовите его shm_com.h.

#define TEXT_SZ 2048

struct shared_use_st {

 int written_by_you;

 char some_text[TEXT_SZ];

};

В файле определена структура, которая будет применяться в обеих программах: потребителе и поставщике. Вы используете флаг written_by_you типа int для того, чтобы сообщить потребителю о том, что данные записаны в оставшуюся часть структуры, и произвольно решаете, что необходимо передать до 2 Кбайт текста.

2. Первая программа shm1.c – потребитель. После заголовочных файлов создается сегмент совместно используемой памяти (размер равен вашей структуре, описывающей совместно используемую память) с помощью вызова shmget с заданным битом IPC_CREAT.

#include

#include

#include

#include

#include

#include «shm_com.h»

int main() {

 int running = 1;

 void *shared_memory = (void *)0;

 struct shared_use_st *shared_stuff;

 int shmid;

 srand((unsigned int)getpid());

 shmid = shmget((key_t)1234, sizeof(struct shared_use_st),

  0666 | IPC_CREAT);

 if (shmid == -1) {

  fprintf(stderr, «shmget failedn»);

  exit(EXIT_FAILURE);

 }

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

 shared_memory = shmat(shmid, (void *)0, 0);

 if (shared memory == (void *)-1) {

  fprintf(stderr, «shmat failedn»);

  exit(EXIT_FAILURE);

 }

 printf(«Memory attached at %Xn», (int)shared_memory);

4. В следующем фрагменте программы сегмент shared_memory присваивается переменной shared_stuff, из которой затем выводится любой текст, содержащийся в some_text. Цикл продолжает выполняться до тех пор, пока не найдена строка end в элементе some_text. Вызов функции sleep заставляет программу-потребителя оставаться в своей критической секции, что вынуждает поставщика ждать.

 shared_stuff = (struct shared_use_st *)shared_memory;

 shared_stuff->written_by_you = 0;

 while (running) {

  if (shared_stuff->written_by_you) {

   printf(«You wrote: %s», shared_stuff->some_text);

   sleep(rand() % 4);

   /* Заставляет другой процесс ждать нас! */

   shared_stuff->written_by_you = 0;

   if (strncmp(shared_stuff->some_text, «end», 3) == 0) {

    running = 0;

   }

  }

 }

5. В заключение совместно используемая память отсоединяется и удаляется.

 if (shmdt(shared_memory) == -1) {

  fprintf(stderr, «shmdt failedn»);

  exit(EXIT_FAILURE);

 }

 if (shmctl(shmid, IPC_RMID, 0) == -1) {

  fprintf(stderr, «shmctl(IPC_RMID) failedn»);

  exit(EXIT_FAILURE);

 }

 exit(EXIT_SUCCESS);

}

6. Вторая программа shm2.c – поставщик; она позволяет вводить данные для потребителей. Программа очень похожа на shm1.c и выглядит следующим образом.

#include

#include

#include

#include

#include

#include «shm_com.h»

int main() {

 int running = 1;

 void *shared_memory = (void *)0;

 struct shared_use_st *shared_stuff;

 char buffer[BUFSIZ];

 int shmid;

 shmid = shmget((key_t)1234, sizeof(struct shared_use_st), 0666 | IPC_CREAT);

 if (shmid == -1) {

  fprintf(stderr, «shmget failedn»);

  exit(EXIT_FAILURE);

 }

 shared_memory = shmat(shmid, (void *)0, 0);

 if (shared_memory == (void *)-1) {

  fprintf(stderr, «shmat failedn»);

  exit(EXIT_FAILURE);

 }

 printf(«Memory attached at %Xn», (int)shared_memory);

 shared_stuff = (struct shared_use_st *)shared_memory;

 while (running) {

  while (shared_stuff->written_by_you == 1) {

   sleep(1);

   printf(«waiting for client...n»);

  }

  printf("Enter same text: ");

  fgets(buffer, BUFSIZ, stdin);

  strncpy(shared_stuff->some_text, buffer, TEXT_SZ);

  shared_stuff->written_by_you = 1;

  if (strncmp(buffer, «end», 3) == 0) {

   running = 0;

  }

 }

 if (shmdt(shared_memory) == -1) {

  fprintf(stderr, «shmdt failedn»);

  exit(EXIT_FAILURE);

 }

 exit(EXIT_SUCCESS);

}

Когда вы выполните эти программы, то получите образец вывода, подобный следующему:

$ ./shm1 &

[1] 294

Memory attached at 40017000

$ ./shm2

Memory attached at 40017000

Enter some text: hello

You wrote: hello

waiting for client...

waiting for client...

Enter some text: Linux!

You wrote: Linux!

waiting for client...

waiting for client...

waiting for client...

Enter some text: end

You wrote: end

$

Как это работает

Первая программа shm1 создает сегмент совместно используемой памяти и затем присоединяет его к своему адресному пространству. Вы накладываете структуру shared_use_st на начальную область совместно используемой памяти. У нее есть флаг written_by_you, который устанавливается, когда данные доступны. Если флаг установлен, программа считывает текст, выводит его и сбрасывает флаг, чтобы показать, что данные прочитаны. Для корректного выхода из цикла примените специальную строку end. Далее программа отсоединяет сегмент совместно используемой памяти и удаляет его.

Вторая программа shm2 получает и присоединяет тот же самый сегмент совместно используемой памяти, поскольку она применяет тот же ключ 1234. Затем она просит пользователя ввести текст. Если флаг written_by_you установлен, shm2 знает, что клиентский процесс еще не считал предыдущую порцию данных и ждет завершения чтения. Когда другой процесс очищает флаг, shm2 записывает новые данные и устанавливает флаг. Она также пользуется магической строкой end для завершения записи и отсоединения сегмента совместно используемой памяти.

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

Очереди сообщений

Теперь рассмотрим третье и последнее средство System V IPC: очереди сообщений. Во многом очереди сообщений похожи на именованные каналы, но без сложностей, сопровождающих открытие и закрытие канала. Однако применение очереди сообщений не избавляет вас от проблем, возникающих при использовании именованных каналов, например блокировки заполненных каналов.

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

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

Наложив эти ограничения, стандарт X/Open не позаботился о способе выяснения их числовых значений за исключением того, что превышение ограничений – достаточное основание для аварийного завершения функций обработки очереди сообщений. В ОС Linux есть два определения: MSGMAX и MSGMNB, которые задают максимальный объем в байтах отдельного сообщения и максимальный объем очереди соответственно. В других системах эти макросы могут отличаться или просто отсутствовать.

Далее приведены объявления функций для работы с очередями сообщений:

#include

int msgctl(int msqid, int cmd, struct msqid_ds *buf);

int msgget(key_t key, int msgflg);

int msgrcv(int msqid, void *msg_ptr, size_t msg_sz, long int msgtype, int msgflg);

int msgsnd(int msqid, const void *msg_ptr, size_t msg_sz, int msgflg);

Как и в случае семафоров или совместно используемой памяти, заголовочные файлы sys/types.h и sys/ipc.h обычно автоматически включаются заголовочным файлом msg.h.

msgget

Очередь сообщений создается и предоставляет к себе доступ с помощью функции msgget:

int msgget(key_t key, int msgflg);

Программа должна предоставить значение параметра key, которое, как и в других средствах IPC, задает имя конкретной очереди сообщений. С помощью специального значения IPC_PRIVATE создается скрытая или частная очередь, которая теоретически доступна только текущему процессу. Как и в случае семафоров и совместно используемой памяти, в некоторых системах Linux такая очередь может не быть частной. Поскольку от скрытой или частной очереди очень мало пользы, это не слишком важная проблема. Как и раньше, второй параметр msgflg состоит из девяти флагов прав доступа. Для создания новой очереди сообщений специальный бит со значением IPC_CREAT должен быть объединен с правами доступа поразрядной операцией OR. Не считается ошибкой установка флага IPC_CREAT и задание ключа уже существующей очереди сообщений. Если очередь уже есть, флаг IPC_CREAT безмолвно игнорируется.

Функция msgget вернет положительное число, идентификатор очереди; в случае успешного завершения и -1 в случае сбоя.

msgsnd

Функция msgsnd позволяет добавить сообщение в очередь сообщений:

int msgsnd(int msqid, const void *msg_ptr, size_t msg_sz, int msgflg);

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

struct my_message {

 long int message_type;

 /* Данные, которые вы собираетесь передавать */

}

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

Первый параметр msqid – идентификатор очереди сообщений, возвращаемый функцией msgget.

Второй параметр msg_ptr – указатель на отправляемое сообщение, которое должно начинаться с элемента типа long int, как описывалось ранее.

Третий параметр msg_sz – объем сообщения, на которое указывает msg_ptr. Этот объем не должен включать элемент типа long int, содержащий тип сообщения.

Четвертый параметр msgflg управляет действиями, предпринимаемыми при заполнении текущей очереди сообщений или достижении общесистемного ограничения для очередей сообщений. Если в параметре msgflg установлен флаг IPC_NOWAIT, функция вернет управление немедленно без отправки сообщения и возвращаемое значение будет равно -1. Если в параметре msgflg флаг IPC_NOWAIT сброшен, процесс отправки будет приостановлен в ожидании освобождения доступного объема в очереди.

В случае успеха функция вернет 0, а в случае аварийного завершения – -1. Если вызов был успешен, копия данных сообщения принимается и помещается в очередь сообщений.

msgrcv

Функция msgrcv извлекает сообщения из очереди сообщений:

int msgrcv(int msqid, void *msg_ptr, size_t msg_sz, long int msgtype, int msgflg);

Первый параметр msqid – идентификатор очереди сообщений, возвращенный функцией msgget.

Второй параметр msg_ptr – указатель на получаемое сообщение, которое должно начинаться с элемента типа long int, как описывалось ранее в функции msgsnd.

Третий параметр msg_sz – размер сообщения, на которое указывает msg_ptr, без элемента типа long int, содержащего тип сообщения.

Четвертый параметр msgtype типа long int позволяет реализовать простую форму приоритетного получения. Если значение msgtype равно 0, извлекается первое доступное сообщение в очереди. Если значение параметра больше нуля, извлекается первое сообщение с таким же типом сообщения. Если оно меньше нуля, извлекается первое сообщение с таким же типом сообщения или со значением, по абсолютной величине меньшим, чем msgtype.

На практике все гораздо проще. Если вы просто хотите получать сообщения в порядке их отправления, задайте msgtype, равным 0. Если нужно извлекать сообщения только с определенным типом, задайте msgtype, равным этому значению. Если вам необходимо получать сообщения с типом не превышающим n, задайте msgtype, равным -n.

Четвертый параметр msgflg управляет действиями в случае отсутствия сообщения подходящего типа, которое ожидает извлечения. Если в параметре msgflg установлен флаг IPC_NOWAIT, вызов вернет управление программе немедленно с возвращаемым значением -1. Если флаг IPC_NOWAIT в msgflg сброшен, процесс будет приостановлен в ожидании прибытия сообщения подходящего типа.

В случае успешного завершения функция msgrcv вернет количество байтов, помещенных в буфер приема, сообщение копируется в выделяемый пользователем буфер, на который указывает msg_ptr, и данные удаляются из очереди сообщений. В случае ошибки функция вернет -1.

msgctl

Последняя функция обработки очереди сообщений msgctl очень похожа на функцию управления для совместно используемой памяти:

int msgctl(int msqid; int command, struct msqid_ds *buf);

Структура msqid_ds содержит, как минимум, следующие элементы:

struct msqid_ds {

 uid_t msg_perm.uid;

 uid_t msg_perm.gid;

 mode_t msg_perm.mode;

}

Первый параметр msqid – идентификатор, возвращаемый функцией msgget.

Второй параметр command задает предпринимаемое действие. Он может принимать три значения, перечисленные в табл. 14.3.

Таблица 14.3

IPC_STAT	Задает данные в структуре msqid_ds, отображающие значения, связанные с очередью сообщений
IPC_SET	Если у процесса есть на это право, это действие устанавливает значения, связанные с очередью сообщений, в соответствии с данными структуры msqid_ds
IPC_RMID	Удаляет очередь сообщений

В случае успешного завершения возвращает 0, в случае аварийного – -1. Если очередь сообщений удаляется, когда процесс ожидает в функции msgsnd или msgrcv, функция отправки или получения сообщения завершается аварийно.

Выполните упражнение 14.3.

Упражнение 14.3. Очереди сообщений

Теперь, когда вы познакомились с объявлениями, относящимися к очередям сообщений, можно посмотреть, как они действуют на практике. Как и раньше, вы напишите две программы: msg1.c для получения и msg2.c для отправки сообщений. Вы разрешите обеим программам создавать очередь сообщений, но используете для удаления очереди программу-приемник после того, как она получит последнее сообщение.

1. Далее приведена программа-приемник msg1 .с:

#include

#include

#include

#include

#include

#include

struct my_msg_st {

 long int my_msg_type;

 char some_text[BUFSIZ];

};

int main() {

 int running = 1;

 int msgid;

 struct my_msg_st some_data;

 long int msg_to_receive = 0;

2. Прежде всего, задайте очередь сообщений:

 msgid = msgget((key_t)1234, 0666 | IPC_CREAT);

 if (msgid == -1) {

  fprintf(stderr, «msgget failed with error: %dn», errno);

  exit(EXIT_FAILURE);

 }

3. Далее сообщения извлекаются из очереди до тех пор, пока не будет обнаружено сообщение end. В конце очередь сообщений удаляется.

 while (running) {

  if (msgrcv(msgid, (void *)&some_data, BUFSIZ, msg_to_receive, 0) == -1) {

   fprintf(stderr, «msgrcv failed with error: %dn», errno);

   exit(EXIT_FAILURE);

  }

  printf(«You wrote: %s», some_data.some_text);

  if (strncmp(some_data.some_text, «end», 3) == 0) {

   running = 0;

  }

 }

 if (msgctl(msgid, IPC_RMID, 0) == -1) {

  fprintf(stderr, «msgctl(IPC_RMID) failedn»);

  exit(EXIT_FAILURE);

 }

 exit(EXIT_SUCCESS);

}

4. Программа-отправитель msg2.c очень похожа на программу msg1.с. В функции main удалите объявление msg_to_receive и замените его переменной buffer[BUFSIZ]. Уберите из программы удаление очереди и внесите следующие изменения в цикл с управляющей переменной running. Теперь у вас появился вызов функции msgsnd для отправки введенного текста в очередь сообщений. Далее приведена программа msg2.c с отличиями от программы msg1.с, выделенными цветом.

#include 

#include 

#include 

#include 

#include 

#include

#define MAX_TEXT 512

struct my_msg_st {

 long int my_msg_type;

 char some_text[MAX_TEXT];

};

int main() {

 int running = 1;

 struct my_msg_st some_data;

 int msgid;

 char buffer = [BUFSIZ];

 msgid = msgget((key_t)1234, 0666 | IPC_CREAT);

 if (msgid == -1) {

  fprintf(stderr, «msgget failed with error: %dn», errno);

  exit(EXIT_FAILURE);

 }

 while (running) {

  printf("Enter some text: ");

  fgets(buffer, BUFSIZ, stdin);

  some_data.my_msg_type = 1;

  strcpy(some_data.some_text, buffer);

  if (msgsnd(msgid, (void*)&some_data, MAX_TEXT, 0)) == -1) {

   fpintf(stderr, «msgsnd failedn»);

   exit(EXIT_FAILURE);

  }

  if (strncmp(buffer, «end», 3) == 0) {

   running = 0;

  }

 }

 exit(EXIT_SUCCESS);

}

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

Если в очереди сообщений есть место, отправитель может создать очередь, поместить в нее какие-либо данные и завершить выполнение еще до того, как начнет выполняться приемник. Первой следует запускать программу-отправителя msg2. Далее приведен пример вывода:

$ ./msg2

Enter some text: hello

Enter some text: How are you today?

Enter some text: end

$ ./msg1

You wrote: hello

You wrote: How are you today?

You wrote: end

Как это работает

Программа-отправитель создает очередь сообщений с помощью функции msgget; далее она добавляет сообщения в очередь, применяя функцию msgsnd. Программа-приемник получает идентификатор очереди сообщений с помощью функции msgget и получает сообщения до тех пор, пока не будет найден специальный текст end. Затем программа приводит все в порядок, удаляя очередь сообщений с помощью функции msgctl.