Jeg vil gerne output logger oplysninger i FIFO fil. Min ansøgning kan køre i flere måneder. Mit spørgsmål er, hvad der sker med FIFO-fil, når der er en side konstant skriftligt til det, og ingen på den anden side at læse det?
Vil det i sidste ende stå, overflow, nulstillet, vil det tage alle OS's RAM?

Tak.

Nå, du kan udtænke en test temmelig enkelt.

Opret FIFO w / mkfifo. Opret to processer, en forfatter og en læser.

Åbn FIFO for skrive, som vil blokere for, fordi der ingen læser. Når det unblocks, skrive til Stderr, at den er vågen, og derefter med jævne mellemrum skrive nogle bytes til det og logføre hvert skrive.

Kør en læser, har det sove lidt, og få den læst, sige 10 gange, dumpning, hvad det hedder. Så det bør lukke FIFO og afslutte.

Hvad du skal se, ifølge Stevens APUE, er at skrive bør medføre SIGPIPE skal frembringes.

Her er et eksempel:

#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 / rør

Du skal også vide om PIPE_BUF, den garanterede mindste antal bytes, der kan skrives. Implementations variere på dette.

Der er ingen delvise skriver til en rørledning, når den ønskede størrelse på buffer er større end pladsen. I stedet -1 returneres ved skrive med errno indstillet til EAGAIN.

Endelig er for høj ydeevne messaging eller IPC, rør / FIFOs er ikke et godt valg.
Fordi der ikke er nogen garanti for Atomicity, flere læsere på en enkelt pibe kan have problemer.

Ifølge POSIX.1-2008 skriver () , errno er indstillet til EPIPE og en SIGPIPE signal er sendt til den kaldende tråd.

Jeg var henvisninger Marc Rochkind 'Avanceret UNIX Programmering' sec 6.2.2. Og POSIX - Jeg formoder nonblocking.

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