Ich möchte, dass die Ausgabe von Informationen in FIFO-Logger-Datei. Meine Anwendung kann für die Monate. Meine Frage ist, was mit FIFO-Datei, wenn es die eine Seite ständig schriftlich an sie und niemand auf der anderen Seite Lesung von ihm?
Wird es schließlich stecken, Überlauf, setzen, wird es dauern, alle Betriebssysteme RAM?

Danke.

Nun, Sie könnten, eine Prüfung ziemlich einfach.

Legen Sie die FIFO-w / mkfifo. Erstellen Sie zwei Verfahren, ein Schriftsteller und ein Lesegerät.

Öffnen Sie das FIFO zum Schreiben, die blockiert, weil es keine Leser. Wenn es unblocks, schreiben Sie an stderr, dass es wach ist, und dann in regelmäßigen Abständen einige Bytes zu schreiben, und jedes Protokoll schreiben.

Führen Sie einen Leser-Prozess, haben sie ein wenig schlafen, und sie lesen, sagen wir, 10-mal, Dumping, was es liest. Dann sollte das FIFO und beenden.

Was sollten Sie, je nach Stevens APUE, ist, dass die Ursache SIGPIPE schreiben sollte, um erzeugt werden.

Hier ein Beispiel:

#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 / Rohre

Sie sollten auch wissen, über PIPE_BUF, die garantierte minimale Anzahl von Bytes, die geschrieben werden können. Implementierungen sind zu diesem Thema.

Es gibt keine teilweise schreibt an einem Rohr, wenn die beantragte Größe der Puffer ist größer als verfügbaren Speicherplatz. Statt -1 zurück schreiben mit errno auf EAGAIN.

Schließlich, für hohe Leistung Messaging oder IPC, Rohre / FIFOs sind keine gute Wahl.
Da gibt es keine Garantie für die Atomisierung, mehrere Leser über eine einzige Leitung können Probleme haben.

Nach POSIX.1-2008 write () , errno ist auf EPIPE und SIGPIPE Signal wird an die aufrufende Thread.

Ich war referenzierenden Marc Rochkind "Advanced UNIX Programming 's 6.2.2. Und POSIX - Ich gehe davon aus nonblocking.

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