Я хочу для вывода информации в журнале FIFO файл. Моя заявка может работать в течение нескольких месяцев. Мой вопрос, что происходит с FIFO файл, когда есть одна сторона постоянно письменной форме, и никто на другой стороне от этого чтения?
Будет ли она в конечном итоге застрял, переполнения, сброса, будет ли он принимать все ОС RAM?

Спасибо.

Ну, вы могли бы разработать тест довольно просто.

Создание FIFO ж / mkfifo. Создание двух процессов, писатель и читатель.

Откройте FIFO для записи, которые будут блокировать, поскольку нет читателя. Когда он unblocks, напишите STDERR что просыпаются, а затем периодически пишут некоторые байты на нее, и каждый журнал писать.

Запуск читатель процесса, его сон немного, и его прочитать, скажем, в 10 раз, что это захоронение читает. Затем он должен закрыть FIFO и прекращать.

Что вы должны увидеть, по Стивенс APUE заключается в том, что записи должны вызывать SIGPIPE, которые будут созданы.

Вот пример:

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <signal.h>

int sigpipe_caught = 0;

#define TESTLOG(s) testlog(__FUNCTION__, s)

void testlog (const char *who, const char *msg)
{
  fprintf (stderr, "%s: %s\n", who, msg);
}

void writer (void)
{
  int f;
  int value = 0;
  int err;
  int done = 0;

  TESTLOG ("starting");
  if ((f = open ("fifo", O_WRONLY)) != -1)
  {
    TESTLOG ("opened fifo");

    while (done <= 0)
    {
      char buf[64];
      err = write (f, &value, sizeof value);

      if (sizeof value == err)
      {
        sprintf (buf, "wrote %d", value);
        TESTLOG (buf);
        value++;
      }
      else
      {
        sprintf (buf, "err = %d", err);
        TESTLOG (buf);
        sprintf (buf, "sigpipe_caught = %d", sigpipe_caught);
        TESTLOG (buf);
        done++;
      }

      TESTLOG ("sleeping");
      sleep (1);
    }

    close (f);
    TESTLOG ("closed fifo");
  }
}

void reader (void)
{
  int f;
  int i;
  int value;
  int err;

  TESTLOG ("sleeping 2");
  sleep (2);
  TESTLOG ("awake");

  if ((f = open ("fifo", O_RDONLY)) != -1)
  {
    TESTLOG ("opened fifo");

    for (i = 0; i < 10; i++)
    {
      char buf[64];

      err = read (f, &value, sizeof value);
      if (sizeof value == err)
      {
        sprintf (buf, "read %d", value);
        TESTLOG (buf);
      }
      else
      {
        sprintf (buf, "err = %d", err);
        TESTLOG (buf);
      }
    }

    TESTLOG ("closing fifo");
    close (f);
  }
  else
  {
    TESTLOG ("failed to open fifo");
  }
}

void sigpipe (int a)
{
  TESTLOG ("caught SIGPIPE");
  sigpipe_caught = 1;
}

int main (void)
{
  signal (SIGPIPE, sigpipe);

  if (fork())
    writer();
  else
    reader();

  return 0;
}

FIFO в / трубы

Вы также должны знать о PIPE_BUF, гарантированное минимальное количество байт, которые могут быть написаны. Implementations различаются по этому вопросу.

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

И наконец, для высокопроизводительных сообщений или МПК, трубы / FIFOs не большой выбор.
Поскольку нет никаких гарантий атомарность, многочисленные читатели на одной трубы могут иметь проблемы.

Согласно POSIX.1-2008 записи () , errno установлен в EPIPE и SIGPIPE сигнал посылается с призывом нить.

Я ссылки Марк Rochkind "Дополнительно UNIX Программирование 'сек 6.2.2. И POSIX - Я полагаю, nonblocking.

If O_NDELAY or O_NONBLOCK is set, the write returns -1 and
              sets errno to [EAGAIN].