Ik wil de output logger informatie in FIFO bestand. Mijn toepassing kan worden uitgevoerd voor maanden. Mijn vraag is wat er gebeurt met FIFO bestand wanneer er sprake is van een kant voortdurend te schrijven en niemand aan de andere kant het lezen van het?
Zal het uiteindelijk vast, overloopkanalen, reset, zal het nemen van alle OS's RAM-geheugen?

Bedankt.

Nou, je zou kunnen bedenken een test redelijk eenvoudig.

Maak de FIFO w / mkfifo. Maak twee processen, een schrijver en een lezer.

Open het FIFO voor schrijven, dat zal blokkeren omdat er geen lezer. Wanneer het unblocks, schrijven naar stderr dat het wakker, en daarna periodiek schrijven enkele bytes is, en meldt elke schrijven.

Voer een lezer proces, hebben ze een beetje slapen, en hebben zij lezen, zeg, 10 keer, dumpen wat hij leest. Dan moet het sluiten van de fifo en beëindigen.

Wat u zou moeten zien, volgens Stevens APUE, is dat de afschrijving mag SIGPIPE worden gegenereerd.

Hier is een voorbeeld:

#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's / buizen

U moet ook weten PIPE_BUF, de gegarandeerde minimum aantal bytes dat kan worden geschreven. Implementaties variëren op dit punt.

Er zijn geen gedeeltelijke schrijft aan een pijp, wanneer de gevraagde grootte van de buffer is groter dan de beschikbare ruimte. In plaats -1 geretourneerd door schrijven met errno ingesteld op EAGAIN.

Tenslotte wordt voor hoge prestaties messaging of IPC, pijpen / FIFOs niet een goede keuze.
Omdat er geen garantie van atomiciteit, meerdere lezers op een enkele pijp kunnen onderwerpen.

Volgens POSIX.1-2008 write () , errno is ingesteld op EPIPE en een SIGPIPE signaal wordt verstuurd naar de oproepende draad.

Ik was verwijzingspagina Marc Rochkind 'Advanced UNIX Programming "sec 6.2.2. En POSIX - Ik neem nonblocking.

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