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

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

Обязательно используйте флаги O_CREAT и O_EXCL при первоначальном вызове sem_open(), чтобы создание семафора было атомарным. Например, и монитор, и серверная программа попытаются создать семафор при запуске, если он еще не существует... если он существует, вызов завершится ошибкой, что означает либо монитор, либо сервер, но не обе программы. , получил право создать семафор и инициализировать его. Затем монитор ожидает на семафоре, пока сервер инициализирует fifo... после инициализации fifo сервер освобождает семафор, и монитор может продолжить работу.

Вот процесс, как я его себе представляю... Я считаю, что он должен эффективно решить ваше состояние гонки:

В мониторе:

1. Создайте именованный семафор и установите его в заблокированном состоянии.
2. Запустить сервер
3. Подождите, пока FIFO не станет видимым на уровне файловой системы.
4. Открыть fifo1 для записи (без блокировки)
5. Открыть fifo2 для чтения (блокируется, пока сервер не откроет fifo2 для записи)
6. Подождите семафор (возможно, с тайм-аутом), пока сервер не разблокирует его, указывая, что теперь он успешно открыл оба FIFO.

На сервере:

1. Создайте FIFO
2. Open fifo1 (блокирует, пока монитор не откроет его для записи)
3. Откройте fifo2 (неблокирующий)
4. Разблокируйте семафор теперь, когда сервер открыл оба FIFO.

Таким образом, ваш монитор не может продолжать работу до тех пор, пока не будет «известного состояния», в котором все правильно инициализировано... сервер указывает это состояние монитору через именованный семафор.

Если вы выполняете open() в правильном порядке, состояния гонки не возникает. (единственной возможной гонкой будет третий процесс, мешающий тому же fifos) Из прекрасного руководства:

«Однако он должен быть открыт с обоих концов одновременно, прежде чем вы сможете выполнять с ним какие-либо операции ввода или вывода. Открытие FIFO для чтения обычно блокируется, пока какой-либо другой процесс не откроет тот же FIFO для записи, и наоборот».

Это означает, что порядок

{ процесс 1: открыть (fifo1, RO); процесс2: открыть (fifo1, WO); }

...

{ процесс 1: открыть (fifo2, WO); процесс2: открыть (fifo2, RO); }

всегда будет успешным (при отсутствии голодания процесса) Порядок операций в каждом fifo не имеет значения; для fifo1 первым может идти либо процесс 1, либо процесс 2 (и он будет заблокирован до тех пор, пока другая сторона не добьется успеха).

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>

#define FIFO1 "fifo1"
#define FIFO2 "fifo2"

void do_master(void);
void do_slave(void);
void randsleep(unsigned max);

/************************************/
void do_master(void)
{
int in,out, rc;
char buff[20];

randsleep(5);
mkfifo(FIFO1, 0644);
randsleep(7);
mkfifo(FIFO2, 0644);

out = open(FIFO2, O_WRONLY);
if (out == -1) {
    fprintf(stderr, "[Master]: failed opening output\n" );
    return;
    }
fprintf(stderr, "[Master]: opened output\n" );
in = open(FIFO1, O_RDONLY);
if (in == -1)  {
    fprintf(stderr, "[Master]: failed opening input\n" );
    close(out);
    return;
    }
fprintf(stderr, "[Master]: opened input\n" );

rc = write( out, "M2S\n\0" , 5);
fprintf(stderr, "[Master]: wrote %d\n", rc );

rc = read( in, buff , sizeof buff);
fprintf(stderr, "[Master]: read %d: %s\n", rc, buff );
unlink(FIFO1);
unlink(FIFO2);
}
/***********************************/
void do_slave(void)
{
int in,out, rc;
unsigned iter=0;
char buff[20];

loop1:
in = open(FIFO2, O_RDONLY);
if (in == -1) {
    fprintf(stderr, "[Slave%u]: failed opening input\n", ++iter );
    randsleep(2);
    goto loop1;
    }
fprintf(stderr, "[Slave]: opened input\n" );

loop2:
out = open(FIFO1, O_WRONLY);
if (out == -1) {
    fprintf(stderr, "[Slave%u]: failed opening output\n", ++iter );
    randsleep(3);
    goto loop2;
    }
fprintf(stderr, "[Slave]: opened output\n" );

rc = write( out, "S2M\n\0" , 5);
fprintf(stderr, "[Slave]: wrote %d\n", rc );

rc = read( in, buff , sizeof buff);
fprintf(stderr, "[Slave]: read %d:%s\n", rc, buff );
}
/*************************************/
void randsleep(unsigned max)
{
unsigned val;
val = rand();
val %= max;
sleep(val);
return;
}
/*************************************/
int main(void)
{
int rc;

switch (rc=fork()) {
    case -1: exit(1); break;
    case 0: do_slave(); break;
    default: do_master(); break;
    }
exit (0);
}

Рассмотрите возможность использования сокетов домена Unix типа SOCK_STREAM. Сервер bind изменит свой сокет на имя в файловой системе. Каждый клиент получает собственное двунаправленное соединение с сервером.

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

Редактировать 1:

Как сказал Джейсон, есть два способа (однако оба не разрешены в моей домашней работе):

1) *Вы можете выполнить поиск через /proc/PID/fd (замените PID числовым идентификатором процесса), чтобы увидеть, какие клиентские процессы уже открыли ваш FIFO* 2) Другой вариант вызвать fuser на вашем FIFO

Однако первый требует чего-то, чего не хотят преподаватели: наблюдения внутри proc/PID/fd. Второй, который я слышал, требует привилегий root, и это снова то, что я не могу сделать. Надеюсь, это поможет кому-то еще в будущем.