Unix Prozessprogrammierung

[Andre (Gast)]

Hallo zusammen

Ich möchte in einem C-Programm unter Unix einen neuen Prozess erzeugen. 
Dieser sollte 20 Sekunde warten, nach Ablauf dieser 20 Sekunden einen 
ICMP-Ping lossenden und falls der Teilnehmer antwortet, dies in eine 
Logfile schrieben.

Das Hauptprogramm soll allerdings nicht warten sondern weiterlaufen. 
Leider blockiert das Hauptsprogramm trotz entsprechender aufrufe.

Auszug:

switch(PID = fork())
{
  case -1:
       printf("Error");
       break;
  case 0:
       sleep(20);
       .....ping Teilnehmer
       break;
  default:
       waitpid(PID, &status, WNOHANG);
       break;
}

Ich danke Euch im Voraus für eure Hilfe

[Konrad S. (maybee)]

Nein, das Hauptprogramm blockiert nicht. Es macht genau das, was du 
programmiert hast und das ist ... na ... genau: waitpid(). Also warten.

[Andre (Gast)]

Hmm... Ich will einfach nur dafür sorgen, dass keine Zombies im System 
bleiben. Daher das waitpid.

[Konrad S. (maybee)]

Aus der Linux-manpage von waitpid:

POSIX.1-2001 specifies that if the disposition of  SIGCHLD  is  set  to
SIG_IGN or the SA_NOCLDWAIT flag is set for SIGCHLD (see sigaction(2)),
then children that terminate do not become zombies and a call to wait()
or  waitpid()  will  block until all children have terminated, and then
fail with errno set to ECHILD.  (The original POSIX standard  left  the
behavior  of  setting  SIGCHLD  to SIG_IGN unspecified.  Note that even
though the default disposition of SIGCHLD is "ignore", explicitly  set‐
ting  the disposition to SIG_IGN results in different treatment of zom‐
bie process children.)  Linux 2.6 conforms to this specification.  How‐
ever,  Linux  2.4 (and earlier) does not: if a wait() or waitpid() call
is made while SIGCHLD is being ignored, the call behaves just as though
SIGCHLD were not being ignored, that is, the call blocks until the next
child terminates and then returns the process ID  and  status  of  that
child.

[Konrad S. (maybee)]

Oder das, hier die Methode "double fork" (frei nach Stephen A. Rago, 
UNIX System V Network Programming)

if ( (pid = fork()) < 0 ) {
  exit( 1 );
} else if ( pid == 0 ) {
  /* child level 1 */
  setsid();
  sigset( SIGHUP, SIG_IGN );
  if ( (pid = fork()) < 0 ) {
    exit( 1 );
  } else if ( pid != 0 ) {
    /* parent */
    exit( 0 );
  }
  /* child level 2 */
  ...
  exit( 0 );
}
/* parent */

[Rayray (Gast)]

Hallo Andre,

statt der waitpid schreibst Du was Dein Hauptprogramm machen soll, 
während der Kindprozess läuft.

Vor dem fork fügst Du folgenden Zeile ein:

signal(SIGCHLD,Handler);

Die folgende Funktion kommt vor main

void Handler(int n) {
   /* Zombies entfernen */
   wait3(NULL,WNOHANG,NULL);
}

Ein Kind das sich beendet erzeugt ein SIGCHILD-Signal, das üblicherweise 
ignoriert wird. Durch die signal...-Zeile richtest Du ne Handler für 
SIGCHLD ein. Die Funktion Handler wird jedesmal aufgerufen, wenn sich 
ein Kind beendet. So wirst Du die Zombies los und kannst im 
Elternprozess noch was "sinnvolles" machen.

Rayray

[Peter II (Gast)]

warum überhaupt den krampf mit dem fork()? Wo es noch keine Threads gab 
war es ja ok, aber mittlerweile finde ich den ansatz nicht mehr 
sinnvoll. Man muss in dem Programm jedesmal aufpassen ob man nun child 
oder parrent ist, dateihandel werden auch einfach kopiert dann muss man 
aufpassen das man sie richtig schliest. Auch der Austausch von Daten 
zwischen den Programmen geht nicht so einfach. Der speicherverbauch 
dürfte auch mehr sein, wenn 2 Programme laufen.

Ich würde einfach einen Thread starten und dort die hauptarbeit machen. 
Oder gibt es noch eine (PC)-Platform wo es keine pthread lib gibt?

[Konrad S. (maybee)]

Wie immer: Kommt darauf an, was wichtig ist und welche Kenntnisse sind 
vorhanden.
Bei Threads ist die Performanz höher und der Ressourcenverbrauch 
geringer. Bei fork() gibt es mehr funktionierende Code-Beispiele. 
"Schöne" Fehler kann man mit beiden Verfahren programmieren.

Evtl. geht die einfachste Lösung so:

 system( "sleep 20; ping -c 1 localhost >/dev/null 2>&1 && echo OK >logfile" );

(Der ping ist hier für Linux formuliert.)

[Rolf M. (rmagnus)]

Konrad S. schrieb:
> Wie immer: Kommt darauf an, was wichtig ist und welche Kenntnisse sind
> vorhanden.
> Bei Threads ist die Performanz höher und der Ressourcenverbrauch
> geringer.

Das ist zumindest unter Linux nicht zwingend der Fall.

> Evtl. geht die einfachste Lösung so:
> system( "sleep 20; ping -c 1 localhost >/dev/null 2>&1 && echo OK
> logfile" );
> (Der ping ist hier für Linux formuliert.)

Genau sowas hätte ich auch vorgeschlagen. Mit threads zu hantieren und 
dann in C zu warten und mit Sockets zu basteln, nur um ein Ping 
abzusetzen, finde ich viel zu umständlich. Mit einem kleinen Skript hat 
viel weniger Aufwand.