Je tiens à la production d'informations de journalisation dans le fichier FIFO. Mon application peut fonctionner pendant des mois. Ma question est ce qui se passe à FIFO file quand il ya un côté constamment écrit à personne et de l'autre côté la lecture de tout ça?
Sera-t-il finalement coincé, de débordement, de réinitialisation, elle prendra toutes les OS de la RAM?

Merci.

Eh bien, on pourrait imaginer un test assez simple.

Créer le FIFO w / mkfifo. Créer deux processus, un écrivain et un lecteur.

Ouvrez le FIFO pour écrire, ce qui permet de bloquer, car il n'y a pas de lecteur. Quand il débloque, écrire sur stderr qu'il est éveillé, et de temps en temps à écrire des octets, et vous connecter chaque écrire.

Lancer un processus de lecture, faites-le dormir un peu, et qu'ils l'aient lu, disons, 10 fois, ce qu'il lit dumping. Ensuite, il devrait fermer la fifo et fin.

Qu'est-ce que vous devriez voir, selon APUE Stevens, est que la cause devrait écrire SIGPIPE à générer.

Voici un exemple:

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

Vous devez également savoir sur PIPE_BUF, le nombre minimum garanti d'octets qui peut être écrite. Les implémentations varient sur ce point.

Il n'y a pas de partie à l'écrit d'un tuyau lorsque la taille de la mémoire tampon est plus grand que l'espace disponible. Au lieu de -1 est retourné par écrit avec errno mis à EAGAIN.

Enfin, pour les hautes performances de messagerie ou de la CIB, pipes / FIFOs ne sont pas un bon choix.
Comme il n'existe pas de garantie de l'atomicité, plusieurs lecteurs sur un seul tuyau peut avoir des problèmes.

Selon POSIX.1-2008 écrire () , errno est fixé à EPIPE SIGPIPE et un signal est envoyé à l'appelant fil.

J'ai été référencement Marc Rochkind 'Advanced Unix Programming' sec 6.2.2. Et POSIX - Je suppose nonblocking.

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