Андрей Робачевский - Операционная система UNIX

if (bind(sockfd, (struct sockaddr*)&serv_addr,

saddrlen) < 0) {

printf("Ошибка связывания сокета с адресом\n");

exit(1);

}

/* Теперь запустим бесконечный цикл чтения сообщений от

клиентов и отправления их обратно */

max_caddrlen = sizeof(clnt_addr);

for(;;) {

caddrlen = max_caddrlen;

n = recvfrom(sockfd, buf, MAXBUF, 0,

(struct sockaddr*)&clnt_addr, &caddrlen);

if (n < 0) {

printf("Ошибка приема\n");

exit(1);

}

/* Благодаря вызову recvfrom(2), мы знаем адрес клиента,

от которого получено сообщение. Используем этот адрес

для передачи сообщения обратно отправителю */

if (sendto(sockfd, buf, n, 0,

(struct sockaddr*)&clnt_addr, caddrlen) != n) {

printf("Ошибка передачи\n");

exit(1);

}

}

}

Клиент создает сокет датаграмм и связывает его со своим уникальным адресом. Уникальность адреса определяется уникальностью имени файла. Поскольку одновременно могут работать несколько клиентов, возникает задача выполнения условия уникальности. Для этого мы используем функцию mktemp(3C) , позволяющую по заданному шаблону /tmp/clnt.XXXXи на основании идентификатора текущего процесса получить уникальное имя, заменяя соответствующим образом символы 'X'. Связывание сокета позволяет при отправлении сообщения неявно указать его "адрес отправителя", так что серверу не составляет труда отправить сообщение обратно.

#include

#include

#include < sys/un.h>

char *msg = "Здравствуй, Мир!\n";

#define MAXBUF 256

char buf[MAXBUF];

main() {

struct sockaddr_un serv_addr, clnt_addr;

int sockfd;

int saddrlen, caddrlen, msglen, n;

/* Установим адрес сервера, с которым мы будем обмениваться

данными. Для этого заполним структуру данных sockaddr_un,

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

с помощью вызова sendto(). Значение адреса известно

по предварительной договоренности */

bzero(&serv_addr, sizeof(serv_addr));

serv_addr.sun_family = AF_UNIX;

strcpy(serv_addr.sun_path, "./echo.server");

saddrlen = sizeof(serv_addr.sun_family) +

strlen(serv_addr.sun_path);

/* Создадим сокет датаграмм */

if ((sockfd = socket(AF_UNIX, SOCK_DGRAM, 0)) < 0) {

printf("Невозможно создать сокет\n");

exit(1);

}

/* Необходимо связать сокет с некоторым локальным адресом,

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

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

домена - т.е. данной операционной системы. Для обеспечения

этого условия, воспользуемся функцией mktemp(3C), которая

возвращает уникальное имя, основанное на представленном

шаблоне и идентификаторе нашего процесса PID */

bzero(&clnt_addr, sizeof(clnt_addr));

clnt_addr.sun_family = AF_UNIX;

strcpy(clnt_addr.sun_path, "/tmp/clnt.XXXX");

mktemp(clnt_addr.sun_path);

caddrlen =

sizeof(clnt addr.sun_family) + strlen(clnt_addr.sun_path);

if (bind(sockfd, (struct sockaddr*)&clnt_addr,

caddrlen) < 0) {

printf("Ошибка связывания сокета\n");

exit(1);

}

/* Итак, отправляем сакраментальное приветствие */

msglen = strlen(msg);

if (sendto(sockfd, msg, msglen, 0,

(struct sockaddr*)&serv addr, saddrlen) != msglen) {

printf("Ошибка передачи сообщения\n");

exit(1);

}

/* Прочитаем эхо*/

if ((n = recvfrom(sockfd, buf, MAXBUF, 0, NULL, 0)) < 0) {

printf("Ошибка получения сообщения\n");

exit(1);

}

/* И выведем его на экран */

printf("Эхо: %s\n", buf);

/* Уберем за собой */

close(sockfd);

unlink(clnt_addr.sun_path);

exit(0);

}

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

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

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

□ Применение семафоров увеличивает число переключений контекста, что, в свою очередь, увеличивает нагрузку на систему.

□ В то же время, использование семафоров является наиболее стандартным (POSIX.1b), хотя и неэффективным способом обеспечения синхронизации.

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

Интенсивность межпроцессного взаимодействия в системе можно определить с помощью команды sar -m . Вывод команды показывает число использования объектов IPC в секунду:

17:47:53 msg/s sema/s

17:47:58 0.20 20.00

17:48:03 0.60 12.20

17:48:08 2.20 10.40

17:48:13 0.80 25.10

17:48:18 0.00 15.60

Average 0.76 16.66

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