C/C++ unter Linux - Prozess-Management

Aufgabenstellung (Prof. Dr. J. Schmidek • Laboranleitung Systemprogrammierung)

1 Ziel

2 Vorbereitung

2.1 Informieren Sie sich anhand Ihrer Vorlesungsunterlagen sowie der Linux-Manual-Pages über die exec-Systemaufruffamilie.

• Wovon hängt die Entscheidung über den Einsatz der jeweils richtigen Variante ab?

2.2 Machen Sie sich vertraut mit den Aufrufen fork(), wait(), waitpid(), getpid(), getppid() und exit() sowie mit der Bibliotheksfunktion sleep().

• Welchen Wert liefert der Aufruf fork() zurück? Welche Bedeutung hat dieser für Parent u. Child?
• Was realisieren die Aufrufe wait() und waitpid()? Welche Aufrufvarianten gibt es? Suchen Sie mit Hilfe des Manuals nach verwandten Aufrufen. Wann erscheint der Einsatz welches Aufrufes bzw. welcher Aufrufvariante sinnvoll?
• Welche Möglichkeiten hat der Parent, verschiedene beendete Child-Prozesse zu unterscheiden?
• In welchem Zustand befindet sich ein Child-Prozess, der zeitlich vor dem Erreichen des wait-Aufrufes seines Parent-Prozesses terminiert, warum und für wie lange?
• Wann und warum wird der exit-Aufruf verwendet? Ist dessen Gebrauch zwingend? Welche Aufrufvarianten kennen Sie und was bewirken diese exakt? Liefert der Aufruf einen Wert zurück?
• Welches Format hat die Exit-Status-Variable, die beim Terminieren über den wait-Aufruf an den Parent übergeben wird, und wie muss dieses bei deren Auswertung berücksichtigt werden?

3 Durchführung

3.1 Entwerfen Sie zwei Programme (flip und flop), ...

3.2 Entwerfen Sie ein zweites Programm, dem zwei Argumente (Blockadezeiten in Sek.) übergeben werden können.

3.3 Ermitteln Sie mit Hilfe eines einfachen C-Programms die tatsächliche Anzahl der auf Ihrem System pro User bzw. pro User-Prozess maximal möglichen Child-Prozesse.

Protokoll

2 Vorbereitung

2.1 Die exec-Funktionen

2.2 fork(), wait(), waitpid(), getpid(), getppid(), exit() und sleep()

• Rückgabewert von fork(): Bei Erfolg wird dem Vaterprozess die PID des Kindes zurückgegeben und 0 dem Kindprozess. Bei Fehlern wird dem Vaterprozess -1 zurückgegeben und errno entsprechend gesetzt. Ein Kindprozess wird nicht generiert.
  Bedeutung für Parent und Child: fork erzeugt einen Kindprozeß, der sich vom Vaterprozeß nur durch die PID und PPID unterscheidet und darin, daß die Verwendung von Resourcen auf 0 gesetzt ist. File locks und noch ausstehende Signale werden nicht vererbt.
• wait(), waitpid(): Die wait-Funktion sperrt die Ausführung des aktuellen Prozesses, bis ein Child beendet wurde, der aktuelle Prozess ein terminate-Sig bekommen hat oder um eine Sig-Verarbeitung aufzurufen. Wurde der Child bereits beendet (Zombie), kehrt der Aufruf sofort zurück und alle Ressourcen des Childs werden freigegeben. Mit waitpid ist über die Funktionalität von wait hinausgehend das warten auf bestimmte über die PID wählbare Childs möglich, wobei pid=-1 das gleiche Verhalten erzeugt, wie wait(). Des weiteren kann hiermit auch darauf geprüft werden, ob ein Child Zombie ist ohne damit auf dessen Ende warten zu müssen - der Parent kann also weiterarbeiten, falls kein Child beendet wurde. Beide Funktionen geben einen Status zurück, aus dem der Todesgrund für das Child ausgelesen werden kann. Unter BSD gibt es zusätzlich die verwandten Funktionen wait3 und wait4. Das Verhalten von waitpid() kann über eine Bitmaske angepaßt werden. Wird ein Child beendet und der Parent ruft keine der wait-Funktionen auf, so verbleibt bis zum Ende des Parents bereits erwähnter Zombie im System. Theoretisch ist dies nicht weiter schlimm, da kein Speicher mehr belegt wird. Andererseits kann dadurch allerdings auch der Prozesstable gefüllt werden, welcher oft auf 32k begrenzt ist. Gerade Programme mit vielen Forks müssen zwingend regelmäßig nach ihren Childs sehen.
• Zustand eines terminierten Childs vor wait durch Parent: Der Speicher wird geräumt und es werden entsprechende Einträge in der Prozesstabelle vorgenommen (siehe auch exit()).
• Wann und warum exit: exit() ist eine Bibliotheksfunktion, die den System Call _exit() um Aufräumfunktionalitäten ergänzt. Es werden alle Puffer geleert, der Adressraum wird freigegeben und in der Prozesstabelle werden der Exit-Status (Werte von 0 bis 255) und die Markierung als Zombie hinterlassen. Diese Einträge werden entweder vom Parent oder falls dieser nicht mehr existiert vom init-Prozess ausgewertet und entfernt. Falls die PID des zum exec-Aufruf gehörenden Prozesses der Prozessgruppen-ID (bzw. Terminalgruppen-ID) entspricht, so schickt der Kernel ein SIGHUP-Signal an alle Prozesse der Gruppe. exit() wird aufgerufen, wenn ein Programm seine Codeausführung beendet hat oder auch von Fehlerroutinen.

3 Durchführung

3.1 flip und flop

// flip.c
#include <stdio.h>
#include <unistd.h>
int main(int argc, char **argv){
 char befehl[]="./flop";
 int z;
 char b2[10];
 if(argc!=2){
  printf("Aufruf: flip x mit x=Anzahl der Aufrufe\n");
  return 1;
 }
 z=atoi(argv[1]);
 printf("flip | argc=%i | argv[1]=%i | ",argc,z);
 printf("PID %i | PPID %i \r",getpid(),getppid());
 fflush(stdout);
 sleep(1);
 if(z>0){
  sprintf(b2,"%i",--z);
  execl(befehl,befehl,b2,0);
 }
 else printf("\nausgeflipt\n");
 return 0;
}

// flop.c
#include <stdio.h>
#include <unistd.h>
int main(int argc, char **argv){
 char befehl[]="./flip";
 int z;
 char b2[10];
 if(argc!=2){
  printf("Aufruf: flip x mit x=Anzahl der Aufrufe\n");
  return 1;
 }
 z=atoi(argv[1]);
 printf("\t\t\t\t\t\t\tflop | argc=%i | argv[1]=%i | ",argc,z);
 printf("PID %i | PPID %i \r",getpid(),getppid());
 fflush(stdout);
 sleep(1);
 if(z>0){
  sprintf(b2,"%i",--z);
  execl(befehl,befehl,b2,0);
 }
 else printf("\nausgeflopt\n");
 return 0;
}

3.2 Parent und Child - Prozeßstatus bei Terminierung

// block.c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

int main(int argc, char **argv){
 int p; //Blockadezeit für Parent
 int c; //Blockadezeit für Child
 pid_t  pid;
 int status;

 if(argc!=3){
  printf("Aufruf: block x y mit x=Parent-Block-Zeit und y=Child-Block-Zeit\n");
  return 1;
 }
 pid=fork();
 if(pid<0){
  printf("Fehler: fork()-Rueckgabe %d.\n", pid);
  exit(2);
 }
 if(pid==0){ //Child
  c=atoi(argv[2]);
  printf("\t\t\t\t\t\tChild: PID=%i PPID=%i Blocked for %is",getpid(),getppid(),c);
  fflush(stdout);
  sleep(c);
  exit(3);
 }else{      // Parent, pid=PID des Childs
  p=atoi(argv[1]);
  printf("Parent: PID=%i PPID=%i Blocked for %is\r",getpid(),getppid(),p);
  fflush(stdout);
  sleep(p);
  pid=wait(&status);
  printf("\nExit-Status des Child: ");
  if(WIFEXITED(status)!=0)printf("%d\n",WEXITSTATUS(status));
  else printf("Fehler\n");
 }
 return 0;
}

3.3 Child-Flood

// childflood.c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main(void){
 int z;
 pid_t  pid;
 int status;

 printf("Bisher erzeugte Childs: \n");
 for(z=0;z<10000;z++){
  pid=fork();
  if(pid<0){
   printf("Fehler: fork()-Rueckgabe %d.\n", pid);
   exit(2);
  }
  if(pid==0){ //Child
   sleep(c);
   exit(3);
  }else{      // Parent, pid=PID des Childs
   printf("%i\n",z);
   fflush(stdout);
  }
 }
 return 0;
}

kill -9 $(ps huax|grep childflood|cut --fields=7 --delimiter=" ")