Betriebssystem-Programmierung unter UNIX (1997)

Software-Schule Schweiz 

Ingenieurschule Bern HTL 

Betriebssystem-Programmierung 

unter UNIX 

Stephan Fischli 

Sommer 1997

Inhaltsverzeichnis 

1 Einführung ............................................................................. 1 

System-Calls und Funktionen ................................................................................... 2 

Fehlerbehandlung ..................................................................................................... 3 

Benutzer-Identifikation .............................................................................................. 5 

Zeitfunktionen............................................................................................................ 6 

2 Standards .............................................................................. 7 

Existierende Standards............................................................................................. 8 

Inhalt der Standards................................................................................................ 10 

Abfragen von Systemkonstanten ............................................................................ 13 

3 Filesystem ........................................................................... 15 

Aufbau eines Filesystems ....................................................................................... 16 

Inodes ..................................................................................................................... 17 

Directories und Links............................................................................................... 18 

Abfragen der Attribute eines Files........................................................................... 19 

Lesen eines Directory ............................................................................................. 22 

4 Ein- und Ausgabe ................................................................ 25 

Filedeskriptoren....................................................................................................... 26 

Öffnen und Erzeugen eines Files............................................................................ 27 

Schliessen und Löschen eines Files....................................................................... 29 

Lesen und Schreiben eines Files............................................................................ 31 

Positionieren eines Files ......................................................................................... 33 

Duplizieren eines Filedeskriptors ............................................................................ 35 

Filekontrolle............................................................................................................. 37 

5 Prozesse.............................................................................. 39 

Prozesszustände..................................................................................................... 40 

Prozesskontext........................................................................................................ 41 

Virtueller Adressraum.............................................................................................. 42 

Argumente und Umgebungsvariablen .................................................................... 43 

Identifier eines Prozesses....................................................................................... 45 

Erzeugen eines Prozesses ..................................................................................... 47 

Ausführen eines Programms .................................................................................. 50 

Terminieren eines Prozesses ................................................................................. 51 

Warten auf einen Prozess....................................................................................... 52 

6 Job-Control .......................................................................... 55 

Prozessgruppen und Sessions ............................................................................... 56 

Abfragen und Setzen der Prozessgruppe............................................................... 57 

Erzeugen einer Session.......................................................................................... 58 

Bestimmen der Vordergrund-Prozessgruppe ......................................................... 59 

7 Signale................................................................................. 61 

Erzeugung von Signalen......................................................................................... 62 

Signaldisposition ..................................................................................................... 64 

Probleme mit Signalen............................................................................................ 65 

Schicken eines Signals ........................................................................................... 66 

Definieren einer Signalaktion .................................................................................. 67 

Ändern der Signalmaske......................................................................................... 69 

Weitere Signal-Funktionen...................................................................................... 71 


i

8 Pipes.................................................................................... 73 

Funktionsweise ....................................................................................................... 74 

Erzeugen einer unnamed Pipe ............................................................................... 75 

Erzeugen einer named Pipe ................................................................................... 77 

9 Fortgeschrittene Ein-/Ausgabe............................................. 79 

I/O-Multiplexing ....................................................................................................... 80 

Record-Locking ....................................................................................................... 83 

10 Netzwerk-Kommunikation .................................................. 87 

Kommunikationsmodell........................................................................................... 88 

TCP/IP-Protokolle ................................................................................................... 89 

Eigenschaften der TCP/IP-Protokolle ..................................................................... 90 

Rahmenbildung ....................................................................................................... 91 

Internet-Adressen.................................................................................................... 92 

Port-Nummern......................................................................................................... 93 

Sockets ................................................................................................................... 94 

Verbindungslose Kommunikation ........................................................................... 95 

Verbindungsorientierte Kommunikation.................................................................. 96 

Erzeugen eines Sockets ......................................................................................... 97 

Socket-Adressen..................................................................................................... 98 

Verknüpfen eines Sockets mit einer Adresse ......................................................... 99 

Datenaustausch über unverbundene Sockets...................................................... 100 

Akzeptieren einer Verbindung............................................................................... 103 

Aufbauen einer Verbindung .................................................................................. 104 

Datenaustausch über verbundene Sockets.......................................................... 105 

Abfragen von Host-Informationen ......................................................................... 109 

Abfragen von Service-Informationen .................................................................... 111 

11 Threads ........................................................................... 115 

Threads eines Prozesses ..................................................................................... 116 

POSIX-Threads..................................................................................................... 117 

Erzeugen eines Threads....................................................................................... 118 

Terminieren eines Threads ................................................................................... 119 

Mutex-Locks.......................................................................................................... 121 

Initialisieren eines Mutex-Locks ............................................................................ 122 

Sperren und Freigeben eines Mutex-Locks.......................................................... 123 

Condition-Variablen............................................................................................... 124 

Initialisieren einer Condition-Variablen ................................................................. 125 

Warten auf einer Condition-Variablen................................................................... 126 

Scheduling ............................................................................................................ 129 

Weitere Möglichkeiten........................................................................................... 130 


ii

1 Einführung 

Betriebssystem-Programmierung 1

Einführung 

System-Calls und Funktionen 

Benutzerprozess 

Anwendungsprogramm 

C-Bibliotheksfunktionen 

System-Calls 

Kernel 

System-Calls bilden die Schnittstelle zum Betriebssystem, indem sie grundlegende 

Dienste für den Zugriff auf System-Ressourcen zur Verfügung stellen. So kann z.B. mit 

dem System-Call write in ein File geschrieben werden. System-Calls sind direkte 

Eingangspunkte in den Kernel: Wird in einem Anwendungsprogramm ein System-Call 

aufgerufen, so verzweigt das Programm in den Kernel, wobei der Prozess vom User- 

Modus in den privilegierten Kernel-Modus wechselt. 

In der Standard-C-Bibliothek sind eine Reihe von allgemein-nützlichen Funktionen 

definiert. Diese sind nicht Teil des Kernels, können aber System-Calls aufrufen. So ruft 

z.B. die Funktion fprintf den System-Call write auf. Andere Funktionen wie strcpy 

(Kopieren eines Strings) benötigen keine Dienste des Betriebssystems. 

Die System-Calls sind in Sektion 2 des „UNIX Programmer’s Manual“ beschrieben, die 

Standard-C-Funktionen in Sektion 3. Dies wird oft mit einer Nummer in Klammern hinter 

dem Namen angedeutet, z.B. write(2) bzw. fprintf(3). 


Einführung 

Fehlerbehandlung 

#include 

#include 

void perror(const char *msg); 

char *strerror(int errcode); 

Tritt in einem System-Call ein Fehler auf, so wird je nach Typ des Rückgabewerts der 

Wert –1 oder ein Nullpointer zurückgegeben. Gleichzeitig wird in der globalen Variablen 

errno ein Code gespeichert, der zusätzliche Information über den aufgetretenen Fehler 

enthält (siehe Tabelle 1-1). Die Variable errno und die symbolischen Fehlercodes sind 

im Header-File definiert. 

Die Funktion perror(3) schreibt eine zum aktuellen Wert von errno gehörende 

Fehlermeldung auf den Standard-Fehlerkanal. Zuvor wird der String, auf den msg zeigt, 

und ein Doppelpunkt ausgegeben. 

Die Funktion strerror(3) gibt einen Pointer auf die zum Fehlercode errcode 

gehörende Fehlermeldung zurück. 


Einführung 

Name 

E2BIG 

EACCES 

EAGAIN 

EBADF 

EBUSY 

ECHILD 

EDEADLK 

EDOM 

EEXIST 

EFAULT 

EFBIG 

EINTR 

EINVAL 

EIO 

EISDIR 

EMFILE 

EMLINK 

ENAMETOOLONG 

ENFILE 

ENODEV 

ENOENT 

ENOEXEC 

ENOLCK 

ENOMEM 

ENOSPC 

ENOSYS 

ENOTDIR 

ENOTEMPTY 

ENOTTY 

ENXIO 

EPERM 

EPIPE 

ERANGE 

EROFS 

ESPIPE 

ESRCH 

EXDEV 

Beschreibung 

Argumentenliste eines neuen Prozesses ist zu lang 

Sucherlaubnis für ein Directory wird verweigert 

Ein- oder Ausgabeoperation würde blockieren 

Filedeskriptor ist ungültig 

Directory ist in Gebrauch 

Prozess hat keine Sohnprozesse 

Record-Lock würde zu einem Deadlock führen 

Argument ist ausserhalb des gültigen Bereichs 

File existiert bereits 

Argument hat eine ungültige Adresse 

Maximale Filegrösse wurde beim Schreiben überschritten 

System-Call wurde durch ein Signal unterbrochen 

Argument ist ungültig 

Fehler bei einer Ein- oder Ausgabeoperation ist aufgetreten 

Directory kann nicht zum Schreiben geöffnet werden 

Prozess hat zu viele Filedeskriptoren 

File hat zu viele Links 

Länge eines Filenamens ist zu gross 

System hat zu viele offene File 

Operation ist auf dem Device nicht möglich 

File oder Directory existiert nicht 

File kann nicht als Programm ausgeführt werden 

Lock ist nicht verfügbar 

Speicher ist nicht verfügbar 

Disk ist voll 

Funktion ist nicht implementiert 

Komponente des Pfadnamens ist nicht ein Directory 

Directory ist nicht leer 

File ist nicht ein Terminal 

Device existiert nicht 

Prozess hat nicht genügend Rechte, um Operation 

auszuführen 

Pipe, in die geschrieben wurde, hat keinen Leser 

Resultat der Funktion ist zu gross 

Filesystem kann nur gelesen werden 

Offset einer Pipe kann nicht gesetzt werden 

Prozess existiert nicht 

Link kann nicht über Filesystem-Grenzen erstellt werden 

Tabelle 1-1: Fehlercodes 


Einführung 

Benutzer-Identifikation 

#include 

#include 

struct passwd *getpwnam(const char *name); 

struct passwd *getpwuid(uid_t uid); 

struct passwd { 

char *pw_name; 

uid_t pw_uid; 

gid_t pw_gid; 

char *pw_dir; 

char *pw_shell; 

}; 

Jeder Benutzer hat einen eindeutigen User-Identifier (UID), der mit dem Login-Namen 

fest verknüpft ist und im Passwortfile /etc/passwd steht. Zudem gehört jeder Benutzer 

einer Benutzergruppe an, die durch einen Group-Identifier (GID) gekennzeichnet ist. 

Anhand dieser Identifier können den Benutzern unterschiedliche Rechte für bestimmte 

Operationen vergeben werden. Bei einem Zugriff eines Prozesses auf ein File werden 

z.B. die User- und Group-Identifier des Prozesses mit denjenigen des Files verglichen, 

und je nach Übereinstimmung gelten die entsprechenden Zugriffsrechte. 

Mittels getpwnam(3) und getpwuid(3) kann ein Eintrag des Passwortfiles gelesen 

werden, indem der Name des Benutzers bzw. sein Identifier übergeben wird. Die 

Komponenten der Struktur passwd haben folgende Bedeutungen: 

pw_name Benutzername 

pw_uid User-Identifier 

pw_gid Group-Identifier 

pw_dir Home-Directory 

pw_shell Login-Shell 


Einführung 

Zeitfunktionen 

String 

formatierter String 

asctime(3) 

strftime(3) 

struct tm 

ctime(3) 

gmtime(3) 

localtime(3) 

time_t 

time(2) 

Die grundlegende Zeit in einem UNIX-Betriebssystem ist die Anzahl vergangener 

Sekunden seit dem 1. Januar 1970, 0.00 Uhr UTC (Coordinated Universal Time). Diese 

Anzahl Sekunden wird als Kalenderzeit bezeichnet. 

Der System-Call time(2) gibt die aktuelle Kalenderzeit zurück. Diese kann dann mit der 

Funktion gmtime(3) oder localtime(3) in die üblichen Zeiteinheiten Jahr, Monat, Tag, 

Stunden, Minuten, Sekunden aufgespaltet werden. Die Funktionen asctime(3) und 

ctime(3) erzeugen eine Standard-Stringdarstellung der aktuellen Zeit, während bei der 

Funktion strftime(3) ein eigenes Stringformat spezifiziert werden kann. 


2 Standards 


Standards 

Existierende Standards 

• ANSI C 

• IEEE POSIX (Portable Operating System Interface) 

• X/Open XPG4 (Portability Guide, Issue 4) 

• Single UNIX Specification 

Der C-Standard wurde 1989 vom ANSI (American National Standards Institute) 

anerkannt und 1990 von der ISO (International Organization for Standardization) 

übernommen. Er definiert die Syntax und Semantik der Programmiersprache C sowie die 

Standard-C-Bibliothek. 

POSIX ist eine Familie von Standards, die vom IEEE (Institute of Electrical and 

Electronics Engineers) entwickelt werden (siehe Tabelle 2-1). Sie beschreiben die 

Schnittstelle zu einem Betriebssystem, nicht aber deren Implementation. Der für die 

Programmierung wichtigste Teilstandard ist POSIX.1 (System Application Programming 

Interface). Obschon POSIX für UNIX-Betriebssysteme entwickelt wurde, ist er nicht auf 

solche beschränkt. 

Der von der Vereinigung X/Open herausgegebene Portability Guide besteht aus fünf 

Bänden. Band 2 (System Interfaces und Headers) beschreibt die Schnittstelle eines 

UNIX-ähnlichen Betriebssystems und ist eine Erweiterung von POSIX.1. 

Aus dem X/Open Portability Guide entstand die Single UNIX Specification (ursprünglich 

Spec 1170). Sie umfasst neben dem Portability Guide die System V Interface Definition, 

die OSF Application Environment Specification und einige weitverbreitete Interfaces aus 

bestehenden UNIX-Anwendungen. 


Standards 

Standard Beschreibung Status 

POSIX.1 Betriebssystem-Programmierschnittstelle 1990 anerkannt 

POSIX.1a Erweiterungen in Bearbeitung 

POSIX.1b Echtzeit-Programmierung 1993 anerkannt 

POSIX.1c Unterstützung von Threads 1995 anerkannt 

POSIX.1d Echtzeit-Erweiterungen in Bearbeitung 

POSIX.1e Sicherheit in Bearbeitung 

POSIX.1f Transparenter Filezugriff zurückgezogen 

POSIX.1g Protokoll-unabhängige Netzwerk-Schnittstelle in Bearbeitung 

POSIX.2 Shell und Utilities 1992 anerkannt 

POSIX.3 Test- und Verifikationsmethoden 1991 anerkannt 

POSIX.5 ADA-Anbindung von POSIX.1 1992 anerkannt 

POSIX.7 System-Administration in Bearbeitung 

POSIX.9 FORTRAN-Anbinding von POSIX.1 1992 anerkannt 

Tabelle 2-1: POSIX-Standards 


Standards 

Inhalt der Standards 

• Systemfunktionen 

• Primitive Systemdatentypen 

• Systemkonstanten (Optionen und Grenzwerte) 

Die Prototypen der Systemfunktionen sind als Gruppen in verschiedenen Headerfiles 

enthalten (siehe Tabelle 2-2). 

Primitive Systemdatentypen sind Definitionen von System-abhängigen Datentypen, die in 

den Prototypen der Systemfunktionen verwendet werden. Sie enden auf _t undsindim 

Headerfile definiert (siehe Tabelle 2-3). 

Optionen definieren das Verhalten des Systems (z.B. das Abschneiden zu langer Pfadund 

Filenamen) oder geben an, ob optionale Teile eines Standards unterstützt werden 

(z.B. Job-Control). Die Optionen beginnen mit _POSIX_ und sind entweder im Headerfile 

definiert oder können mit den Funktionen sysconf(3), pathconf(3) und 

fpathconf(3) geprüft werden (siehe Tabelle 2-4). 

Bei den Grenzwerten gibt es solche, die bereits zur Kompilationszeit bekannt sind (z.B. 

der Maximalwert einer Integer-Zahl), und andere, die erst zur Laufzeit bestimmt werden 

können (z.B. die Maximallänge eines Filenamens). Die meisten Grenzwerte enthalten 

MAX in ihrem Namen und sind entweder im Headerfile definiert oder 

können mit den Funktionen sysconf(3), pathconf(3) und fpathconf(3) bestimmt 

werden (siehe Tabelle 2-4). 


Standards 

Headerfile 

 

 

 

 

 

 

 

 

 

 

 

 

 

Beschreibung 

Directory-Einträge 

Filekontrolle 

Gruppenfile 

Passwortfile 

Signalhandling 

Terminalkontrolle 

symbolische Konstanten 

Filezeiten 

Fileattribute 

Prozesszeiten 

primitive Systemdatentypen 

Systemidentifikation 

Prozesskontrolle 

Tabelle 2-2: Headerfiles 

Datentyp 

clock_t 

dev_t 

fd_set 

fpos_t 

gid_t 

ino_t 

mode_t 

nlink_t 

off_t 

pid_t 

sigset_t 

size_t 

ssize_t 

time_t 

uid_t 

wchar_t 

Beschreibung 

Clock-Ticks 

Device-Nummer 

Filedeskriptormenge 

Fileposition 

Gruppen-Identifier 

Inode-Nummer 

Filetyp und -zugriffsrechte 

Anzahl Links 

Filegrösse und -offset 

Prozess- und Prozessgruppen-Identifier 

Signalmenge 

Anzahl Bytes (vorzeichenlos) 

Anzahl Bytes (mit Vorzeichen) 

Anzahl Sekunden 

User-Identifier 

Zeichencodes 

Tabelle 2-3: primitive Systemdatentypen 


Standards 

Name 

_POSIX_CHOWN_RESTRICTED 

_POSIX_JOB_CONTROL 

_POSIX_NO_TRUNC 

_POSIX_SAVED_IDS 

_POSIX_VDISABLE 

_POSIX_VERSION 

ARG_MAX 

CHILD_MAX 

Clock-Ticks/Sekunde 

LINK_MAX 

MAX_CANON 

MAX_INPUT 

NAME_MAX 

NGROUPS_MAX 

OPEN_MAX 

PASS_MAX 

PATH_MAX 

PIPE_BUF 

STREAM_MAX 

TZNAME_MAX 

Beschreibung 

gibt an, ob der Gebrauch des chown-System-Calls 

eingeschränkt ist 

gibt an, ob Job-Control unterstützt wird 

gibt an, ob zu lange Pfadnamen einen Fehler 

erzeugen 

gibt an, ob Prozesse gespeicherte Set-User- und Set- 

Group-Identifiers haben 

gibt an, ob die Behandlung der speziellen Terminal- 

Eingabezeichen unterbunden werden kann 

gibt das Datum der POSIX.1-Version an 

maximale Argumentenlänge der exec-System-Calls 

maximale Anzahl Prozesse pro Benutzer 

Anzahl Clock-Ticks pro Sekunde 

maximale Anzahl Links eines Files 

maximale Anzahl Zeichen in einer kanonischen 

Eingabezeile eines Terminals 

maximale Anzahl Zeichen, die im Eingabepuffer eines 

Terminals Platz haben 

maximale Anzahl Zeichen in einem Filenamen 

maximale Anzahl zusätzlicher Gruppen-Identifiers 

eines Prozesses 

maximale Anzahl offener Files pro Prozess 

maximale Anzahl signifikanter Zeichen in einem 

Passwort 

maximale Anzahl Zeichen in einem relativen 

Pfadnamen 

maximale Anzahl Zeichen, die atomar in eine Pipe 

geschrieben werden können 

maximale Anzahl Ein-/Ausgabe-Streams pro Prozess 

maximale Anzahl Zeichen im Namen einer Zeitzone 

Tabelle 2-4: POSIX.1-Systemkonstanten 


Standards 

Abfragen von Systemkonstanten 

#include 

long sysconf(int name); 

long pathconf(const char *path, int name); 

long fpathconf(int fd, int name); 

Mittels sysconf(3) können Systemkonstanten bestimmt werden, die eventuell erst zur 

Laufzeit feststehen. pathconf(3) und fpathconf(3) werden für File-abhängige 

Konstanten verwendet, wobei path der Pfadname des Files ist und fd ein Filedeskriptor, 

der das bereits geöffnete File referenziert. 

Die möglichen Werte von name leiten sich aus den Namen der gesuchten Konstanten ab, 

wobei die Argumente von sysconf(3) mit _SC_ beginnen und diejenigen von 

pathconf(3) oder fpathconf(3) mit _PC_. 

Als Funktionswert geben alle drei Funktionen den Wert der entsprechenden Konstanten 

zurück. Ist der Funktionswert –1, die Variable errno aber unverändert, so bedeutet dies, 

dass die entsprechende Option nicht definiert oder der entsprechende Grenzwert 

unbestimmt ist. 


Standards 

#define _POSIX_SOURCE 1 

#include 

#include 

#include 

#include 

#include 

#define panic( str ) { perror( str ); exit( EXIT_FAILURE ); } 

void sysprint( char *, int ); 

void pathprint( char *, int, char * ); 

int main( void ) 

{ 

pathprint( "_POSIX_CHOWN_RESTRICTED", _PC_CHOWN_RESTRICTED, "." ); 

sysprint( "_POSIX_JOB_CONTROL ", _SC_JOB_CONTROL ); 

pathprint( "_POSIX_NO_TRUNC ", _PC_NO_TRUNC, "." ); 

sysprint( "_POSIX_SAVED_IDS ", _SC_SAVED_IDS ); 

pathprint( "_POSIX_VDISABLE ", _PC_VDISABLE, "/dev/tty" ); 

sysprint( "_POSIX_VERSION ", _SC_VERSION ); 

sysprint( "ARG_MAX ", _SC_ARG_MAX ); 

sysprint( "CHILD_MAX ", _SC_CHILD_MAX ); 

sysprint( "clock ticks/second ", _SC_CLK_TCK ); 

pathprint( "LINK_MAX ", _PC_LINK_MAX, "." ); 

pathprint( "MAX_CANON ", _PC_MAX_CANON, "/dev/tty" ); 

pathprint( "MAX_INPUT ", _PC_MAX_INPUT, "/dev/tty" ); 

pathprint( "NAME_MAX ", _PC_NAME_MAX, "." ); 

sysprint( "NGROUPS_MAX ", _SC_NGROUPS_MAX ); 

sysprint( "OPEN_MAX ", _SC_OPEN_MAX ); 

pathprint( "PATH_MAX ", _PC_PATH_MAX, "." ); 

pathprint( "PIPE_BUF ", _PC_PIPE_BUF, "." ); 

sysprint( "STREAM_MAX ", _SC_STREAM_MAX ); 

sysprint( "TZNAME_MAX ", _SC_TZNAME_MAX ); 

} 

exit( EXIT_SUCCESS ); 

void sysprint( char *name, int constant ) 

{ 

long val; 

} 

printf( "%s = ", name ); 

errno = 0; 

if ( (val = sysconf( constant )) == -1 ) 

if ( errno == 0 ) 

printf( "(nicht unterstuetzt)\n" ); 

else panic( "sysconf" ) 

else printf( "%ld\n", val ); 

void pathprint( char *name, int constant, char *path ) 

{ 

long val; 

} 

printf( "%s = ", name ); 

errno = 0; 

if ( (val = pathconf( path, constant )) == -1 ) 

if ( errno == 0 ) 

printf( "(unbestimmt)\n" ); 

else if ( errno == EINVAL ) 

printf( "(nicht unterstuetzt)\n" ); 

else panic( "pathconf" ) 

else printf( "%ld\n", val ); 

Programm 2-1: Ausgabe der POSIX.1-Systemkonstanten 


3 Filesystem 


Filesystem 

Aufbau eines Filesystems 

Boot-Block 

Superblock 

Inode-Liste 

Datenbereich 

Das traditionelle System V-Filesystem besteht aus den folgenden Komponenten: 

• Der Boot-Block enthält ein optionales Bootstrapping-Programm zum Laden des 

Kernels. 

• Im Superblock sind Informationen über das Filesystem abgelegt wie die Grösse 

des Filesystems, die Grösse der Inode-Liste, die Anzahl der freien Inodes, die 

Anzahl der freien Datenblöcke usw. 

• In der Inode-Liste gibt es für jedes existierende File einen Inode, der das File 

beschreibt. 

• Im Datenbereich befinden sich die aktuellen Daten der Files unterteilt in 

Datenblöcke. 


Filesystem 

Inodes 

Inode 

Datenblöcke 

Filetyp 

Zugriffsrechte 

Anzahl Links 

UID GID 

Grösse 

Zeitstempel 

0 

1 

10 

11 

12 

Indirekt-Blöcke 

Zu jedem File gibt es einen Inode, in dem die folgenden Informationen über das File 

gespeichert sind: 

• Filetyp 

• Zugriffsrechte 

• Anzahl Links 

• User- und Group-Identifier des Besitzers 

• Grösse 

• Zeitstempel 

Ausserdem enthält der Inode 13 Adressen, die auf die Datenblöcke des Files zeigen. Die 

ersten zehn Adressen zeigen direkt auf die ersten zehn Datenblöcke des Files. Die 

restlichen drei Adressen zeigen auf einfach, zweifach und dreifach indirekte Blöcke, die 

Adressen weiterer Daten- bzw. Indirekt-Blöcke enthalten. 


Filesystem 

Directories und Links 

Datenblöcke 

Directory /usr 

13 

Inode-Liste 

13 . 

2 .. 

208 bin 

512 lib 

Directory /usr/bin 

208 

227 

208 

13 

227 

227 

1189 

. 

.. 

more 

page 

cc 

symbolischer Link cc 

1189 

../lib/cmplrs/cc/driver 

Ein Directory ist ein File, das aus Einträgen besteht, die je einen Filenamen und die 

dazugehörende Inode-Nummer enthalten. 

Ein Link ist ein Directory-Eintrag, der auf denselben Inode zeigt wie ein anderer Eintrag. 

Die Anzahl Links wird im Linkzähler des Inodes festgehalten. Ein File kann erst gelöscht 

werden, wenn der Linkzähler 0 wird. Links können nur auf Files im gleichen Filesystem 

erstellt werden. 

Ein symbolischer Link ist ein File, das den Namen eines andern Files enthält. Die meisten 

System-Calls, denen ein symbolischer Link als Parameter übergeben wird, folgen dem 

Link und referenzieren das File, auf welches der Link zeigt. Symbolische Links können 

auch auf Files definiert werden, die sich in andern Filesystemen befinden. 


Filesystem 

Abfragen der Attribute eines Files 

#include 

#include 

int stat(const char *path, struct stat *buf); 

int fstat(int fd, struct stat *buf); 

struct stat { 

mode_t st_mode; 

ino_t st_ino; 

dev_t st_dev; 

nlink_t st_nlink; 

uid_t st_uid; 

gid_t st_gid; 

off_t st_size; 

time_t st_atime; 

time_t st_mtime; 

time_t st_ctime; 

}; 

Mittels stat(2) können die Attribute eines Files abgefragt werden. path ist der 

Pfadname des Files und buf zeigt auf eine Struktur, in der die Attribute gespeichert 

werden: 

st_mode Filetyp und Zugriffsrechte 

st_ino Inode-Nummer 

st_dev Nummer des Devices, auf dem sich das File befindet 

st_nlink Anzahl Links auf das File 

st_uid User-Identifier des Besitzers 

st_gid Group-Identifier des Besitzers 

st_size Grösse des Files in Bytes 

st_atime Zeit des letzten Zugriffs 

st_mtime Zeit der letzten Datenänderung 

st_ctime Zeit der letzten Statusänderung 

Mittels fstat(2) können die Attribute eines Files abgefragt werden, das auf dem 

Deskriptor fd geöffnet wurde. 

Mit den folgenden Makros kann aus der Komponente st_mode der Filetyp bestimmt 

werden: 

S_ISREG() reguläres File 

S_ISDIR() Directory 

S_ISCHR() Character-Special-File 

S_ISBLK() Block-Special-File 

S_ISFIFO() FIFO (named Pipe) 

(Daneben gibt es noch die Filetypen Socket und symbolischer Link, für die aber in 

POSIX.1 keine Makros definiert sind.) 


Filesystem 

Durch bitweise Und-Verknüpfung von st_mode mit den folgenden Konstanten kann 

geprüft werden, welche Zugriffsrechte für ein File definiert sind: 

S_IRUSR Leserecht für den Besitzer 

S_IWUSR Schreibrecht für den Besitzer 

S_IXUSR Ausführungsrecht für den Besitzer 

S_IRGRP Leserecht für die Gruppe 

S_IWGRP Schreibrecht für die Gruppe 

S_IXGRP Ausführungsrecht für die Gruppe 

S_IROTH Leserecht für andere 

S_IWOTH Schreibrecht für andere 

S_IXOTH Ausführungsrecht für andere 

Die bitweise Und-Verknüpfung von st_mode mit den Konstanten S_ISUID und S_ISGID 

gibt schliesslich an, ob das Set-User-ID-Bit bzw. das Set-Group-ID-Bit des Files gesetzt 

sind. 


Filesystem 


#include 

#include 

#include 

#include 

#include 


int main( int argc, char *argv[] ) 

{ 

struct stat buf; 

if ( argc != 2 ) { 

fprintf( stderr, "Verwendung: %s file\n", argv[0] ); 

exit( EXIT_FAILURE ); 

} 

if ( stat( argv[1], &buf ) == -1 ) 

panic( "stat" ) 

printf( "%-24s: ", "Filetyp" ); 

if ( S_ISREG( buf.st_mode ) ) printf( "regulaeres File" ); 

else if ( S_ISDIR( buf.st_mode ) ) printf( "Directory" ); 

else if ( S_ISCHR( buf.st_mode ) ) printf( "Character-Special-File" ); 

else if ( S_ISBLK( buf.st_mode ) ) printf( "Block-Special-File" ); 

else if ( S_ISFIFO( buf.st_mode ) ) printf( "FIFO" ); 

else printf( "unbekannt" ); 

printf( "\n%-24s: ", "Zugriffsrechte Besitzer" ); 

if ( buf.st_mode & S_IRUSR ) printf( "lesen " ); 

if ( buf.st_mode & S_IWUSR ) printf( "schreiben " ); 

if ( buf.st_mode & S_IXUSR ) printf( "ausfuehren" ); 

printf( "\n%-24s: ", "Zugriffsrechte Gruppe" ); 

if ( buf.st_mode & S_IRGRP ) printf( "lesen " ); 

if ( buf.st_mode & S_IWGRP ) printf( "schreiben " ); 

if ( buf.st_mode & S_IXGRP ) printf( "ausfuehren" ); 

printf( "\n%-24s: ", "Zugriffsrechte Andere" ); 

if ( buf.st_mode & S_IROTH ) printf( "lesen " ); 

if ( buf.st_mode & S_IWOTH ) printf( "schreiben " ); 

if ( buf.st_mode & S_IXOTH ) printf( "ausfuehren" ); 

printf( "\n%-24s: ", "Zusaetzliche Bits" ); 

if ( buf.st_mode & S_ISUID ) printf( "Set-User-ID " ); 

if ( buf.st_mode & S_ISGID ) printf( "Set-Group-ID" ); 

printf( "\n%-24s: %ld\n", "Inode-Nummer", buf.st_ino ); 

printf( "%-24s: %ld\n", "Device-Nummer", buf.st_dev ); 

printf( "%-24s: %ld\n", "Anzahl Links", buf.st_nlink ); 

printf( "%-24s: %ld (%ld)\n", "Besitzer", buf.st_uid, buf.st_gid ); 

printf( "%-24s: %ld\n", "Groesse", buf.st_size ); 

printf( "%-24s: %s", "letzter Zugriff", ctime( &buf.st_atime ) ); 

printf( "%-24s: %s", "letzte Datenaenderung", ctime( &buf.st_mtime ) ); 

printf( "%-24s: %s", "letzte Statusaenderung", ctime( &buf.st_ctime ) ); 

} 


Programm 3-1: Ausgabe der Attribute eines Files 


Filesystem 

Lesen eines Directory 

#include 

#include 

DIR *opendir(const char *dirname); 

struct dirent *readdir(DIR *dir); 

void rewinddir(DIR *dir); 

int closedir(DIR *dir); 

struct dirent { 

char d_name[]; 

}; 

Da das aktuelle Format eines Directory-Files implementationsabhängig ist, wurden in 

POSIX.1 spezielle Funktionen zum Lesen von Directories definiert. 

opendir(3) öffnet ein Directory und gibt einen Pointer auf die interne Struktur DIR 

zurück, die einen Directory-Stream darstellt. Der Stream wird auf den ersten Directory- 

Eintrag positioniert. 

readdir(3) liest den nächsten Directory-Eintrag und gibt einen Pointer auf die Struktur 

dirent zurück oder NULL, falls das Ende des Directory erreicht ist. Die Komponente 

d_name der Struktur dirent enthält den Filenamen des gelesenen Eintrags. 

rewinddir(3) setzt die Position des Directory-Streams auf den ersten Eintrag des 

Directory zurück. 

closedir(3) schliesst den Directory-Stream. 


Filesystem 


#include 

#include 

#include 

#include 

#include 



{ 

DIR 

*dir; 

struct dirent *direntry; 

if ( argc != 2 ) { 

fprintf( stderr, "Verwendung: %s directory\n", argv[0] ); 


} 

if ( (dir = opendir( argv[1] )) == NULL ) 

panic( "opendir" ) 

while ( 1 ) { 

errno = 0; 

if ( (direntry = readdir( dir )) == NULL ) 

if ( errno != 0 ) panic( "readdir" ) 

else break; 

printf( "%s\n", direntry->d_name ); 

} 

if ( closedir( dir ) == -1 ) 

panic( "closedir" ) 

} 


Programm 3-2: Lesen eines Directory 


Filesystem 

Name 

access(2) 

chdir(2) 

chmod(2) 

chown(2) 

getcwd(3) 

link(2) 

mkdir(2) 

rename(2) 

rmdir(2) 

umask(2) 

unlink(2) 

utime(2) 

Beschreibung 

testet den Zugriff auf ein File 

Wechselt das aktuelle Directory 

Ändert die Zugriffsrechte eines Files 

Ändert den Besitzer eines Files 

gibt das aktuelle Directory zurück 

Erzeugt einen Link auf ein File 

Erzeugt ein neues Directory 

Ändert den Namen eines Files 

Entfernt ein Directory 

setzt die Zugriffsmaske für die Erzeugung von Files 

Entfernt einen Link auf ein File und löscht das File, falls der 

Linkzähler 0 wird 

setzt die letzte Zugriffs- und Änderungszeit eines Files 

Tabelle 3-1: Weitere System-Calls zur Handhabung von Files 


4 Ein- und Ausgabe 


Ein- und Ausgabe 

Filedeskriptoren 

Filedeskriptor- 

Tabellen 

0 

1 

2 

3 

Flags 

Flags 

Flags 

Filetabelle 

Status-Flags 

File-Offset 

Status-Flags 

File-Offset 

Vnode-Liste 

0 

1 

2 

Flags 

Status-Flags 

File-Offset 

0 

1 

2 

Flags 

Der Kernel referenziert alle offenen Files durch sogenannte Filedeskriptoren und 

unterhält die folgenden Datenstrukturen: 

• pro Prozess eine Tabelle der offenen Filedeskriptoren, die in der User-Struktur 

des Prozesses abgelegt ist 

• eine systemweite Tabelle aller offenen Files 

• für jedes offene File einen Vnode, der Informationen über das File enthält und 

Zeiger auf die Filesystem-abhängigen Funktionen, die auf dem File operieren 

Durch diese Anordnung ist es möglich, dass mehrere Prozesse gleichzeitig auf dasselbe 

File zugreifen. Dies geschieht entweder über verschiedene Einträge in der Filetabelle, 

wenn z.B. zwei unabhängige Prozesse dasselbe File öffnen, oder über denselben 

Eintrag, wenn z.B. ein Prozess seine offenen Filedeskriptoren an einen Sohnprozess 

vererbt. Zudem können auch verschiedene Filedeskriptoren desselben Prozesses auf 

denselben Eintrag in der Filetabelle zeigen. 



Öffnen und Erzeugen eines Files 

#include 

#include 

#include 

int open(const char *path, int flags, ...); 

int creat(const char *path, mode_t mode); 

open(2) öffnet ein File und gibt einen Filedeskriptor zurück, mit dem das File referenziert 

wird. path ist dabei der Pfadname des zu öffnenden Files. Falls das File noch nicht 

existiert, kann es mittels open(2) erzeugt werden. 

Im Parameter flags können verschiedene Optionen durch bitweise Oder-Verknüpfung 

der folgenden Konstanten spezifiziert werden: 

O_RDONLY öffnet das File nur zum Lesen 

O_WRONLY öffnet das File nur zum Schreiben 

O_RDWR öffnet das File zum Lesen und Schreiben 

O_APPEND 

O_CREAT 

O_EXCL 

O_NOCTTY 

O_NONBLOCK 

setzt den File-Offset vor jedem Schreiben an das Ende des 

Files 

erzeugt das File, falls es noch nicht existiert 

erzeugt einen Fehler (errno=EEXIST), falls O_CREAT 

spezifiziert wurde und das File bereits existiert 

falls path ein Terminal-Device referenziert, wird das Device 

nicht als Kontroll-Terminal des Prozesses alloziert 

ein auf das File zugreifender Prozess wird nicht blockiert, wenn 

das File nicht bereit ist, sondern kehrt mit einem Fehler 

(errno=EAGAIN) zurück 

O_TRUNC setzt die Grösse des Files auf 0, falls das File zum Schreiben 

geöffnet wird 

Von den ersten drei Konstanten muss genau eine angegeben werden, die restlichen sind 

optional. 



Der dritte Parameter ist vom Typ mode_t und wird nur gebraucht, wenn ein neues File 

erzeugt wird. Er enthält die Zugriffsrechte des neu zu erzeugenden Files, wobei diese 

noch mit der Umaske des Prozesses verknüpft werden. 

creat(2) erzeugt ein neues File und öffnet es zum Schreiben. Ein Aufruf von creat(2) 

ist äquivalent zu einem Aufruf von open(2) mit den Flags O_WRONLY, O_CREAT und 

O_TRUNC. 



Schliessen und Löschen eines Files 

#include 

int close(int fd); 

int unlink(const char *path); 

close(2) schliesst das offene File, das durch den Deskriptor fd referenziert wird. 

unlink(2) entfernt den Directory-Eintrag des Files path und dekrementiert den Link- 

Zähler des zugehörigen Inodes. Wird der Link-Zähler 0 und hat kein Prozess mehr das 

File geöffnet, so wird der Inhalt des Files gelöscht. 




#include 

#include 

#include 

#include 

#include 

#include 



{ 

int fd; 

if ( argc != 2 ) { 



} 

if ( (fd = open( argv[1], O_RDWR | O_CREAT, S_IRUSR | S_IWUSR )) == -1 ) 

panic( "open" ) 

printf( "File erzeugt\n" ); 

sleep( 10 ); 

if ( unlink( argv[1] ) == -1 ) 

panic( "unlink" ) 

printf( "File geloescht\n" ); 

sleep( 10 ); 

if ( close( fd ) == -1 ) 

panic( "close" ) 

} 


Programm 4-1: Verwendung eines temporären Files 



Lesen und Schreiben eines Files 

#include 

ssize_t read(int fd, void *buf, size_t nbytes); 

ssize_t write(int fd, const void *buf, size_t nbytes); 

Mittels read(2) können Daten aus einem offenen File gelesen werden. fd ist der 

Deskriptor des Files, buf zeigt auf einen Speicherbereich, in den die gelesenen Daten 

abgelegt werden, und nbytes ist die maximale Anzahl zu lesender Bytes. Als 

Funktionswert gibt read(2) die Anzahl gelesener Bytes zurück. Diese kann kleiner als 

nbytes sein, z.B. wenn das Ende des Files erreicht wird. In diesem Fall kehrt read(2) 

beim nächsten Aufruf mit dem Funktionswert 0 zurück. 

Mittels write(2) können Daten in ein offenes File geschrieben werden. fd ist der 

Deskriptor des Files, buf zeigt auf einen Speicherbereich, der die zu schreibenden Daten 

enthält, und nbytes ist die Anzahl zu schreibender Bytes. Als Funktionswert gibt 

write(2) die Anzahl geschriebener Bytes zurück, die im Normalfall mit nbytes 

übereinstimmt. 

Das Lesen und Schreiben beginnt jeweils beim aktuellen File-Offset, und nach der 

Ausführung wird der File-Offset um die Anzahl gelesener bzw. geschriebener Bytes 

erhöht. 




#include 

#include 

#include 

#include 

#include 

#include 

#define BUFSIZE 1024 



{ 

int fd1, fd2; 

char buf[BUFSIZE]; 

ssize_t n; 

if ( argc != 3 ) { 

fprintf( stderr, "Verwendung: %s sourcefile destfile\n", argv[0] ); 


} 

if ( (fd1 = open( argv[1], O_RDONLY )) == -1 ) 


if ( (fd2 = creat( argv[2], S_IRUSR | S_IWUSR )) == -1 ) 

panic( "creat" ) 

while ( 1 ) { 

if ( (n = read( fd1, buf, BUFSIZE )) == -1 ) 

panic( "read" ) 

if ( n == 0 ) break; 

if ( write( fd2, buf, n ) == -1 ) 

panic( "write" ) 

} 

if ( close( fd1 ) == -1 ) 


if ( close( fd2 ) == -1 ) 


} 


Programm 4-2: Kopieren eines Files 



Positionieren eines Files 

#include 

#include 

off_t lseek(int fd, off_t offset, int whence); 

Mittels lseek(2) kann der aktuelle Offset eines offenen Files explizit gesetzt und damit 

das File zum Lesen oder Schreiben positioniert werden. fd ist der Deskriptor des Files 

und offset ein relativer Offset, der abhängig vom Parameter whence wie folgt 

interpretiert wird: 

SEEK_SET setzt den File-Offset auf offset 

SEEK_CUR erhöht den File-Offset um offset 

SEEK_END setzt den File-Offset auf die Filegrösse plus offset 

Als Funktionswert wird der neue File-Offset zurückgegeben. Ist dieser grösser als die 

aktuelle Filegrösse, so entsteht bei einem nachfolgenden Schreiben mittels write(2) ein 

Loch im File. 




#include 

#include 

#include 

#include 

#include 

#include 

#include 



{ 

int fd; 

if ( argc < 4 ) { 

fprintf( stderr, "Verwendung: %s file position text\n", argv[0] ); 


} 

if ( (fd = open( argv[1], O_WRONLY | O_CREAT, S_IRUSR | S_IWUSR )) == -1 ) 


if ( lseek( fd, atoi( argv[2] ), SEEK_SET ) == -1 ) 

panic( "lseek" ) 

if ( write( fd, argv[3], strlen( argv[3] ) ) == -1 ) 


if ( close( fd ) == -1 ) 


} 


Programm 4-3: Schreiben an eine beliebige Stelle eines Files 



Duplizieren eines Filedeskriptors 

#include 

int dup(int fd); 

int dup2(int fd, int fd2); 

dup(2) dupliziert den offenen Filedeskriptor fd auf den kleinsten noch frei verfügbaren 

Filedeskriptor und gibt diesen als Funktionswert zurück. Der neue Filedeskriptor zeigt auf 

denselben Eintrag der Filetabelle wie fd und referenziert somit dasselbe File. 

dup2(2) funktioniert gleich wie dup(2), ausser dass der Wert des neuen Filedeskriptors 

durch den Parameter fd2 spezifiziert wird. Ist der Filedeskriptor fd2 bereits vor dem 

Aufruf von dup2(2) offen, so wird er zuvor geschlossen, es sei denn fd und fd2 stimmen 

überein. 




#include 

#include 

#include 

#include 

#include 

#include 



{ 

int fd; 

if ( argc < 3 ) { 

fprintf( stderr, "Verwendung: %s file program [args]\n", argv[0] ); 


} 

if ( (fd = creat( argv[1], S_IRUSR | S_IWUSR )) == -1 ) 

panic( "creat" ) 

if ( dup2( fd, STDOUT_FILENO ) == -1 ) 

panic( "dup2" ) 

if ( close( fd ) == -1 ) 


} 

if ( execvp( argv[2], &argv[2] ) == -1 ) 

panic( "execvp" ) 

Programm 4-4: Umleiten der Ausgabe eines Programms in ein File 



Filekontrolle 

#include 

#include 

#include 

int fcntl(int fd, int cmd, int arg); 

Mittels fcntl(2) können die Eigenschaften eines bereits geöffneten Files abgefragt oder 

verändert werden. fd ist der Deskriptor des Files und cmd einer der folgenden Befehle: 

F_GETFD gibt die Filedeskriptor-Flags zurück 

F_SETFD setzt das Filedeskriptor-Flag FD_CLOEXEC auf den Wert von arg 

F_GETFL gibt die Filestatus-Flags zurück 

F_SETFL 

setzt die Filestatus-Flags O_APPEND und O_NONBLOCK auf die 

Werte, wie sie in arg spezifiziert sind 




5 Prozesse 


Prozesse 

Prozesszustände 

fork(2) 

Created 

Ready 

Scheduler 

User 

Running 

System-Call 

Kernel 

Running 

I/O 

Asleep 

_exit (2) 

Zombie 

Ein Prozess ist die Ausführung eines Programms. Während seiner Lebensdauer kann ein 

Prozess verschiedene Zustände durchlaufen. Im UNIX-System V werden folgende 

Prozesszustände unterschieden: 

Created Der Prozess existiert bereits, hat aber noch nicht alle 

benötigten System-Ressourcen. 

Ready 

Der Prozess ist lauffähig und wartet darauf, dass ihm der 

Scheduler der Prozessor zuteilt. 

User-Running Der Prozess wird ausgeführt und befindet sich im User-Modus. 

Kernel-Running Der Prozess führt einen System-Call aus und befindet sich im 

Kernel-Modus. 

Asleep 

Der Prozess ist blockiert, weil er z.B. auf eine Ein- oder 

Ausgabe wartet. 

Zombie 

Der Prozess existiert nicht mehr, es ist aber noch ein Eintrag 

mit dem Terminierungs-Status vorhanden. 

Die Prozesse im Zustand Ready werden in einer Queue verwaltet, in welcher der 

Scheduler jeweils den Prozess mit der höchsten Priorität zur Ausführung auswählt. Im 

Gegensatz zum Zustand User-Running kann ein Prozess im Zustand Kernel-Running 

nicht vom Scheduler unterbrochen werden. 


Prozesse 

Prozesskontext 

Software- 

Kontext 

Hardware- 

Kontext 

Text 

(Code) 

Memory 

Mapping 

Wenn ein Prozess ausgeführt wird, so läuft er in einem bestimmten Kontext ab. Der 

Kontext eines Prozesses besteht aus den folgenden Komponenten: 

• der Software-Kontext umfasst die Prozess-spezifischen Datenstrukturen des 

Kernels: 

− die Speicher-residente Prozess-Struktur, die u.a. den Zustand des 

Prozesses, seine Identifier und Scheduling-Information enthält 

− die User-Struktur, die weitere Attribute des Prozesses wie die offenen 

Filedeskriptoren enthält, aber wenn nötig auf den Sekundärspeicher 

ausgelagert wird 

− der Kernel-Stack, der gebraucht wird, wenn der Prozess einen System- 

Call aufruft 

• der Hardware-Kontext ist durch den Inhalt der verschiedenen Hardware- 

Register wie Programm-Counter, Prozessorstatus-Register, Stack-Pointer usw. 

bestimmt 

• das Memory-Mapping definiert anhand der Page-Tabellen die Abbildung des 

virtuellen Adressraums des Prozesses in physikalische Speicheradressen 


Prozesse 

Virtueller Adressraum 

Befehlszeilenargumente 

Umgebungsvariabeln 

Stack 

Heap 

Daten 

Text 

Der virtuelle Adressraum eines Prozesses ist die Menge der Speicheradressen, die der 

Prozess referenziert. Er kann in folgende Teile unterteilt werden: 

• das Text-Segment, das die ausführbaren Maschinen-Instruktionen enthält 

• das Daten-Segment, in dem sich die globalen Variablen befinden, die entweder 

bereits vom Compiler oder erst zur Laufzeit initialisiert werden 

• der Heap, auf dem dynamisch allozierter Speicherplatz angelegt wird 

• der Stack, auf dem lokale Variablen und Informationen für die Rückkehr aus 

Funktionen gespeichert werden 


Prozesse 

Argumente und Umgebungsvariablen 

extern char **environ; 

int main(int argc, char *argv[]) 

{ 

... 

} 

Wenn ein Programm ausgeführt wird, können ihm Befehlszeilenargumente übergeben 

werden, die dann als Parameter der main-Funktion zur Verfügung stehen. argc ist die 

Anzahl der Argumente und argv ein Array von Pointern, die auf die Argumente zeigen. 

Mit der Funktion getopt(3) können die Programmoptionen unter den Argumenten 

einfach verarbeitet werden. 

Zudem wird jedem Programm über die globale Variable environ eine Liste von 

Umgebungsvariablen zugänglich gemacht. environ ist ein Pointer auf einen Array von 

Pointern, die auf Strings der Form Name=Wert zeigen. Das letzte Element des Arrays ist 

immer ein Nullpointer. Mit den Funktionen getenv(3) und putenv(3) kann der Wert 

einer einzelnen Umgebungsvariablen abgefragt bzw. gesetzt werden. 


Prozesse 


#include 

#include 

#include 

extern char 

**environ; 


{ 

int i; 

printf( "Befehlszeilenargumente:\n" ); 

for ( i = 0; i < argc; i++ ) 

printf( "%s\n", argv[i] ); 

printf( "\nUmgebungsvariablen:\n" ); 

for ( i = 0; environ[i] != NULL; i++ ) 

printf( "%s\n", environ[i] ); 

} 


Programm 5-1: Ausgabe der Befehlszeilenargumente und Umgebungsvariablen 


Prozesse 

Identifier eines Prozesses 

#include 

#include 

pid_t getpid(void); 

pid_t getppid(void); 

uid_t getuid(void); 

gid_t getgid(void); 

uid_t geteuid(void); 

gid_t getegid(void); 

Jeder Prozess hat mehrere Identifier, die mit den folgenden System-Calls abgefragt 

werden können: 

• getpid(2) gibt den Prozess-Identifier eines Prozesses zurück, der den Prozess 

eindeutig identifiziert. getppid(2) gibt den Prozess-Identifier des 

Vaterprozesses zurück. 

• getuid(2) und getgid(2) geben die realen User- und Group-Identifier eines 

Prozesses zurück. Sie identifizieren den Benutzer, unter welchem der Prozess 

läuft. 

• geteuid(2) und getegid(2) geben die effektiven User- und Group-Identifier 

eines Prozesses zurück, welche die Zugriffsrechte des Prozesses auf Files 

bestimmen. Sie stimmen mit den realen Identifiern überein, ausser wenn das 

Programmfile das Set-User-ID-Bit bzw. das Set-Group-ID-Bit gesetzt hat. 


Prozesse 


#include 

#include 

#include 


{ 

printf( "Prozess-Identifier : %d\n", getpid() ); 

printf( "Vaterprozess-Identifier : %d\n", getppid() ); 

printf( "realer User-Identifier : %d\n", getuid() ); 

printf( "realer Group-Identifier : %d\n", getgid() ); 

printf( "effektiver User-Identifier : %d\n", geteuid() ); 

printf( "effektiver Group-Identifier : %d\n", getegid() ); 

} 


Programm 5-2: Ausgabe der Identifier eines Prozesses 


Prozesse 

Erzeugen eines Prozesses 

#include 

#include 

pid_t fork(void); 

Mittels fork(2) wird ein neuer Prozess erzeugt. Der aufrufende Prozess heisst dann 

Vaterprozess, der neu erzeugte Prozess Sohnprozess. Der Sohnprozess erhält eine 

Kopie des Adressraums des Vaterprozesses und hat damit denselben Code und 

dieselben Daten. Auch die meisten Attribute des Software-Kontexts werden vom 

Vaterprozess auf den Sohnprozess vererbt (siehe Tabelle 5-1). 

Beide Prozesse kehren aus dem System-Call fork(2) zurück und führen die 

nachfolgenden Instruktionen aus. Der einzige Unterschied besteht im Funktionswert von 

fork(2): Der Vaterprozess erhält den Prozess-Identifier des erzeugten Sohnprozesses 

zurück, der Sohnprozess den Wert 0. Welcher Prozess schliesslich zuerst zur 

Ausführung kommt, hängt vom Scheduling-Algorithmus ab. 


Prozesse 

Attribut 

Vererbung 

bei 

fork(2) 

Erhaltung 

bei 

exec(2) 

Prozess-Identifier nein ja 

Vaterprozess-Identifier nein ja 

reale User-/Group-Identifier ja ja 

effektive User-/Group-Identifier ja eventuell 

Prozessgruppen-Identifier ja ja 

Session-Identifier ja ja 

Kontroll-Terminal ja ja 

Arbeitsverzeichnis ja ja 

Root-Directory ja ja 

offene Filedeskriptoren ja eventuell 

Maske der Zugriffsrechte ja ja 

File-Locks nein ja 

Signalmaske ja ja 

Signaldisposition ja zum Teil 

hängige Signale nein ja 

hängige Alarme nein ja 

Umgebungsvariablen ja eventuell 

Ressourcen-Grenzwerte ja ja 

Prozesszeiten nein ja 

Tabelle 5-1: Vererbung der Prozessattribute 


Prozesse 


#include 

#include 

#include 

#include 



{ 

pid_t pid; 

if ( (pid = fork()) == -1 ) 

panic( "fork" ) 

printf( "Prozess %d: Rueckgabewert von fork() = %d\n", getpid(), pid ); 

sleep( 1 ); 

if ( pid == 0 ) 

printf( "Sohnprozess: Identifier = %d\n", getpid() ); 

else printf( "Vaterprozess: Identifier = %d\n", getpid() ); 

} 


Programm 5-3: Erzeugen eines Sohnprozesses 


Prozesse 

Ausführen eines Programms 

#include 

int execv(const char *path, char *const argv[]); 

int execl(const char *path, const char *arg,...); 

int execve(const char *path, char *const argv[], 

char *const envp[]); 

int execle(const char *path, const char *arg,...); 

int execvp(const char *file, char *const argv[]); 

int execlp(const char *file, const char *arg,...); 

Mit den exec-System-Calls kann innerhalb eines Prozesses ein neues Programm 

gestartet werden. Der Adressraum des Prozesses wird dabei mit dem neuen Programm 

überschrieben, der Software-Kontext dagegen bleibt weitgehend erhalten (siehe Tabelle 

5-1). Die Ausführung des neuen Programms beginnt mit der main-Funktion. 

path ist der Pfad- und file der Filename des auszuführenden Programms. Dabei 

suchen execvp(2) und execlp(2) das Programm in allen Directories, die in der 

Umgebungsvariable PATH aufgeführt sind. 

argv ist ein Array von Pointern auf Strings, die dem neuen Programm als Befehlszeilenargumente 

übergeben werden. Alternativ können bei execl(2), execle(2) und 

execlp(2) die Argumente auch einzeln aufgezählt werden. In beiden Fällen muss das 

letzte Argument ein Nullpointer sein. 

envp ist ein Array von Pointern auf Umgebungsvariablen, der bei execve(2) und 

execle(2) zusätzlich übergeben wird. Auch hier muss das letzte Variable ein Nullpointer 

sein. 


Prozesse 

Terminieren eines Prozesses 

#include 

#include 

void exit(int status); 

void _exit(int status); 

Es gibt fünf Möglichkeiten, einen Prozess zu terminieren: 

1. Ausführen eines return-Statements in der main-Funktion, was äquivalent 

zum Aufruf von exit(3) ist 

2. Aufruf der Funktion exit(3), die zunächst die mittels atexit(3) installierten 

Exit-Handler ausführt, dann alle Ein- und Ausgabe-Streams schliesst und 

schliesslich _exit(2) aufruft 

3. Aufruf des System-Calls _exit(2), der alle offenen Filedeskriptoren schliesst 

und die nicht mehr benötigten System-Ressourcen freigibt 

4. Aufruf der Funktion abort(3), die das Signal SIGABRT erzeugt 

5. Empfangen eines Signals, das vom Prozess selbst, von einem andern Prozess 

oder vom Kernel erzeugt wurde 

Bei einer normalen Terminierung mittels exit(3) oder _exit(2) wird dem Vaterprozess 

über das Argument status ein Exit-Status zurückgegeben. Bei einer anormalen 

Terminierung erzeugt der Kernel einen Terminierungs-Status, der den Grund für die 

Terminierung angibt. 


Prozesse 

Warten auf einen Prozess 

#include 

#include 

pid_t wait(int *statloc); 

pid_t waitpid(pid_t pid, int *statloc, int options); 

Mittels wait(2) kann ein Prozess auf das Terminieren irgendeines Sohnprozesses 

warten. Hat ein Sohnprozess bereits terminiert, so kehrt wait(2) sofort zurück, 

andernfalls wird der aufrufende Prozess blockiert, bis der erste Sohnprozess terminiert. 

Als Funktionswert gibt wait(2) den Prozess-Identifier des terminierten Sohnprozesses 

zurück, und speichert im Parameter statloc dessen Terminierungs-Status, falls 

statloc nicht ein Nullpointer ist. Existiert kein Sohnprozess, so kehrt wait(2) mit einem 

Fehler (errno=ECHILD) zurück. 

waitpid(2) funktioniert gleich wie wait(2), ausser dass der aufrufende Prozess auf 

einen spezifischen Sohnprozess warten kann. Der Parameter pid hat dabei folgende 

Bedeutung: 

pid = –1 wartet auf irgendeinen Sohnprozess 

pid > 0 wartet auf den Sohnprozess mit Identifier pid 

pid = 0 wartet auf irgendeinen Sohnprozess in derselben Prozessgruppe 

pid < –1 

wartet auf irgendeinen Sohnprozess in der Prozessgruppe mit dem 

Absolutwert von pid als Identifier 

Im Parameter options können durch bitweise Oder-Verknüpfung der folgenden 

Konstanten zusätzliche Optionen definiert werden: 

WNOHANG 

WUNTRACED 

kehrt sofort zurück, auch wenn der spezifizierte Sohnprozess 

noch nicht terminiert hat; in diesem Fall ist der Funktionswert 0 

gibt auch den Status von gestoppten Sohnprozessen zurück 


Prozesse 

Mit den folgenden Makros kann dann der Terminierungs-Status weiter untersucht 

werden: 

WIFEXITED() 

WIFSIGNALED() 

WIFSTOPPED() 

ist wahr, falls der Prozess normal terminierte; 

WEXITSTATUS() gibt den Exit-Status zurück 

ist wahr, falls der Prozess durch ein Signal terminiert wurde; 

WTERMSIG() gibt die Signalnummer zurück 

ist wahr, falls der Prozess durch ein Signal gestoppt wurde; 

WSTOPSIG() gibt die Signalnummer zurück 


Prozesse 

Das folgende Programm führt in einem Sohnprozess ein Programm aus. Der 

Vaterprozess wartet auf die Terminierung des Sohnprozesses und gibt den 

Terminierungs-Status aus. 


#include 

#include 

#include 

#include 

#include 



{ 

pid_t pid; 

int status; 

if ( argc < 2 ) { 

fprintf( stderr, "Verwendung: %s program [args]\n", argv[0] ); 


} 

if ( (pid = fork()) == -1 ) 


if ( pid == 0 ) { 

printf( "Programm %s wird gestartet\n", argv[1] ); 



} 

if ( waitpid( pid, &status, WUNTRACED ) == -1 ) 

panic( "wait" ) 

if ( WIFEXITED( status ) ) 

printf( "Programm hat normal terminiert (Exit-Status = %d)\n", 

WEXITSTATUS( status ) ); 

else if ( WIFSIGNALED( status ) ) 

printf( "Programm hat anormal terminiert (Signalnummer = %d)\n", 

WTERMSIG( status ) ); 

else if ( WIFSTOPPED( status ) ) 

printf( "Programm wurde gestoppt (Signalnummer = %d)\n", 

WSTOPSIG( status ) ); 

} 


Programm 5-4: Ausführen eines Programms in einem Sohnprozess 


6 Job-Control 


Job-Control 

Prozessgruppen und Sessions 

Session 

Hintergrund- 

Prozessgruppe 

Kontrollprozess 

ksh 

Hintergrund- 

Prozessgruppe 

pr 

lpr 

Vordergrund- 

Prozessgruppe 

cat 

grep 

sort 

Kontroll- 

Terminal 

Terminal-Signale 

Terminal- 

Ein-/Ausgabe 

Job-Control erlaubt dem Benutzer, mehrere Prozesse von einem Terminal aus zu starten, 

und regelt den Zugriff der Prozesse auf das Terminal. Dazu werden die Prozesse in 

Prozessgruppen unterteilt, und mehrere Prozessgruppen bilden eine sogenannte 

Session. Eine Session hat normalerweise ein Kontroll-Terminal. Der Prozess, der die 

Verbindung zu diesem Terminal aufgebaut hat, heisst Kontrollprozess. 

Hat eine Session ein Kontroll-Terminal, so gibt es eine Vordergrund-Prozessgruppe und 

alle andern Prozessgruppen sind Hintergrund-Prozessgruppen. Die Prozesse der 

Vordergrund-Prozessgruppe erhalten die Eingabe vom Terminal und dürfen auch auf das 

Terminal schreiben. Ebenso werden die vom Terminal erzeugten Signale an alle 

Vordergrundprozesse geschickt. 

Die Prozesse der Hintergrund-Prozessgruppen dagegen haben keinen Zugriff auf das 

Terminal und erhalten das Signal SIGTTIN oder SIGTTOU, wenn sie trotzdem 

versuchen, vom Terminal zu lesen bzw. auf das Terminal zu schreiben. Diese Signale 

bewirken defaultmässig, dass die Prozesse gestoppt werden. 


Job-Control 

Abfragen und Setzen der Prozessgruppe 

#include 

#include 

pid_t getpgrp(void); 

int setpgid(pid_t pid, pid_t pgid); 

Mittels getpgrp(2) kann der Prozessgruppen-Identifier eines Prozesses abgefragt 

werden. Stimmt der Prozessgruppen-Identifier mit dem Identifier eines Prozesses 

überein, so heisst der Prozess Prozessgruppen-Führer. 

Mittels setpgid(2) kann ein Prozess einer bestehenden oder einer neu zu erzeugenden 

Prozessgruppe zugeordnet werden. pid ist der Identifier des Prozesses und pgid der 

Identifier der Prozessgruppe, welcher der Prozess zugeordnet wird. 

Ein Prozess kann nur seine eigene Prozessgruppe und die Prozessgruppen seiner 

Sohnprozesse ändern. Beim Erzeugen eines neuen Prozesses, wird die 

Prozessgruppenzugehörigkeit vom Vaterprozess auf den Sohnprozess vererbt. 


Job-Control 

Erzeugen einer Session 

#include 

#include 

pid_t setsid(void); 

Mittels setsid(2) kann eine neue Session erzeugt werden. Dabei werden folgende 

Schritte ausgeführt: 

1. Hat der Prozess ein Kontroll-Terminal, so wird die Verbindung zu diesem 

aufgehoben. 

2. Der Prozess wird Prozessgruppen-Führer einer neuen Prozessgruppe. 

3. Der Prozess wird Session-Führer einer neuen Session. 

Ist der aufrufende Prozess bereits Prozessgruppen-Führer, so kehrt setsid(2) mit einem 

Fehler zurück. Im Erfolgsfall gibt setsid(2) den Identifier des aufrufenden Prozesses 

zurück. 


Job-Control 

Bestimmen der Vordergrund-Prozessgruppe 

#include 

#include 

pid_t tcgetpgrp(int fd); 

int tcsetpgrp(int fd, pid_t pgid); 

Hat eine Session ein Kontroll-Terminal, so kann mittels tcgetpgrp(2) und 

tcsetpgrp(2) die Vordergrund-Prozessgruppe bestimmt werden. fd ist ein 

Filedeskriptor, auf dem das entsprechende Terminal geöffnet ist. tcgetpgrp(2) gibt den 

Identifier der Vordergrund-Prozessgruppe zurück. tcsetpgrp(2) setzt die Vordergrund- 

Prozessgruppe auf pgid, wobei pgid der Identifier einer Prozessgruppe in derselben 

Session ist. 


Job-Control 


7 Signale 


Signale 

Erzeugung von Signalen 

• der Benutzer drückt am Terminal eine spezielle Taste 

• ein Hardware-Fehler tritt auf 

• ein Software-Ereignis geschieht 

• ein anderer Prozess schickt ein Signal 

Signale informieren einen Prozess über das Auftreten von asynchronen Ereignissen: 

• Drückt der Benutzer am Terminal eine spezielle Taste wie , 

oder , so schickt der Terminal-Treiber das entsprechende Signal 

(SIGINT, SIGTSTP, SIGQUIT) an alle Prozesse der Vordergrund- 

Prozessgruppe, die dadurch terminiert oder gestoppt werden. 

• Tritt ein Hardware-Fehler auf, z.B. eine Division durch Null oder ein Zugriff auf 

eine ungültige Speicheradresse, so wird der Kernel benachrichtigt, der das 

entsprechende Signal (SIGFPE, SIGSEGV) an den verursachenden Prozess 

schickt. 

• Ein Software-Ereignis kann ein Signal auslösen, z.B. das Schreiben in eine 

Pipe, nachdem der Leseprozess terminiert hat (SIGPIPE), das Ablaufen eines 

Timers (SIGALRM) oder das Terminieren eines Sohnprozesses (SIGCHLD). 

• Ein Prozess kann einem andern Prozess explizit ein Signal schicken. 


Signale 

Name Beschreibung Default-Aktion 

SIGABRT anormales Terminieren eines Prozesses Terminieren 

SIGALRM Ablaufen eines Timers Terminieren 

SIGCHLD Terminieren oder Stoppen eines Sohnprozesses Ignorieren 

SIGCONT Starten eines gestoppten Prozesses Starten/ 

Ignorieren 

SIGFPE arithmetischer Hardware-Fehler Terminieren 

SIGHUP Unterbruch der Verbindung zum Terminal Terminieren 

SIGILL illegale Hardware-Anweisung Terminieren 

SIGINT Drücken der Interrupt-Taste Terminieren 

SIGKILL Terminieren eines Prozesses Terminieren 

SIGPIPE Schreiben in eine Pipe ohne Leseprozesse Terminieren 

SIGQUIT Drücken der Quit-Taste Terminieren 

SIGSEGV ungültige Speicher-Referenzierung Terminieren 

SIGSTOP Stoppen eines Prozesses Stoppen 

SIGTERM Default-Signal Terminieren 

SIGTSTP Drücken der Stop-Taste Stoppen 

SIGTTIN Lesen vom Terminal durch einen Hintergrundprozess 

Stoppen 

SIGTTOU Schreiben aufs Terminal durch einen 

Stoppen 

Hintergrundprozess 

SIGUSR1 Benutzer-definiertes Signal Terminieren 

SIGUSR2 Benutzer-definiertes Signal Terminieren 

Tabelle 7-1: POSIX.1-Signale 


Signale 

Signaldisposition 

• Default-Aktion ausführen 

• Signal ignorieren 

• Signal abfangen und behandeln 

• Signal blockieren 

Ein Prozess kann dem Kernel mitteilen, was zu tun ist, wenn ein bestimmtes Signal 

eintrifft: 

• Für jedes Signal ist eine Default-Aktion definiert, die für die meisten Signale das 

Terminieren des Prozesses ist (siehe Tabelle 7-1). 

• Ein Signal kann ignoriert werden. 

• Ein Signal kann abgefangen werden, d.h. der Kernel wird angewiesen, eine 

Benutzer-definierte Funktion (Signal-Handler) auszuführen, wenn das Signal 

eintrifft. 

• Ein Signal kann blockiert werden. Trifft ein blockiertes Signal ein, so bleibt es 

hängig, bis es entweder deblockiert oder ignoriert wird. 

Die beiden Signale SIGKILL und SIGSTOP können weder ignoriert noch abgefangen 

noch blockiert werden. Die Signaldisposition wird bei fork(2) vom Vater- auf den 

Sohnprozess vererbt; exec(2) setzt den Status der abgefangenen Signale auf die 

Default-Aktion zurück. 


Signale 

Probleme mit Signalen 

• Signal-Handler werden asynchron zum normalen 

Programmfluss ausgeführt. 

• Langsame System-Calls können durch Signale unterbrochen 

werden. 

• Blockierte Signale, die mehrmals eintreffen, werden nur 

einmal gespeichert. 

Da durch ein abgefangenes Signal der normale Programmfluss an einer beliebigen Stelle 

unterbrochen wird, sollten in Signal-Handlern keine System-Calls und Funktionen 

verwendet werden, die nicht reentrant sind. Nicht reentrant sind z.B. die Funktionen der 

Standard-Ein-/Ausgabe-Bibliothek und Funktionen, die statische Datenstrukturen 

verwenden. 

Wird ein langsamer System-Call durch ein Signal unterbrochen, so kehrt er je nach 

Betriebssystem mit einem Fehler (errno=EINTR) zurück oder wird automatisch 

wiedergestartet. Langsame System-Calls sind solche, die für immer blockieren können. 

Dies sind z.B. read(2), write(2) und open(2), wenn sie auf langsame Devices 

angewendet werden. 

Trifft ein blockiertes Signal mehrmals ein, so wird es nur einmal gespeichert. Da ein 

abgefangenes Signal während der Ausführung des Signal-Handlers automatisch blockiert 

wird, können dadurch gleiche kurz nacheinander eintreffende Signale verlorengehen. 


Signale 

Schicken eines Signals 

#include 

#include 

int kill(pid_t pid, int sig); 

Mittels kill(2) kann einem Prozess oder einer Prozessgruppe ein Signal geschickt 

werden. Der Parameter pid hat dabei folgende Bedeutung: 

pid > 0 schickt das Signal sig dem Prozess mit Identifier pid 

pid = 0 schickt das Signal sig allen Prozessen in derselben Prozessgruppe 

pid < 0 

schickt das Signal sig allen Prozessen in der Prozessgruppe, deren 

Identifier gleich dem Absolutbetrag von pid ist 

Ein Prozess kann nur einem andern Prozess ein Signal schicken, wenn der reale oder 

der effektive User-Identifier der beiden Prozesse übereinstimmt. 


Signale 

Definieren einer Signalaktion 

#include 

int sigaction(int sig, const struct sigaction *act, 

struct sigaction *oact); 

struct sigaction { 

void (*sa_handler)(); 

sigset_t sa_mask; 

int sa_flags; 

}; 

Mittels sigaction(2) kann ein Prozess die Aktion eines Signals definieren oder die 

bereits definierte Aktion abfragen. Ist act nicht ein Nullpointer, so zeigt act auf die neue 

Aktion des Signals sig. Istoact nicht ein Nullpointer, so wird in der Struktur, auf die 

oact zeigt, die bisherige Aktion des Signals sig gespeichert. 

Die Komponenten der Struktur sigaction haben folgende Bedeutungen: 

sa_handler Pointer auf den Benutzer-definierten Signal-Handler oder 

SIG_DFL für die Default-Aktion oder SIG_IGN, um das Signal 

zu ignorieren 

sa_mask Menge der Signale, die zusätzlich zum Signal sig während der 

Ausführung des Signal-Handlers blockiert werden sollen 

sa_flags SA_NOCLDSTOP, wenn das Signal SIGCHLD für gestoppte 

Sohnprozesse nicht erzeugt werden soll 

In gewissen Betriebssystemen kann zusätzlich das Flag SA_RESTART angegeben 

werden, um System-Calls, die durch das entsprechende Signal unterbrochen werden, 

automatisch wiederzustarten. 

Signalmengen können mit den folgenden Funktionen manipuliert werden: 

sigemptyset(3) entfernt alle Signale aus einer Signalmenge 

sigfillset(3) fügt alle Signale zu einer Signalmenge hinzu 

sigaddset(3) fügt ein bestimmtes Signal zu einer Signalmenge hinzu 

sigdelset(3) entfernt ein bestimmtes Signal aus einer Signalmenge 

sigismember(3) prüft, ob ein bestimmtes Signal zur Signalmenge gehört 


Signale 

Im folgenden Programm werden die beiden Signale SIGUSR1 und SIGUSR2 durch einen 

Signal-Handler abgefangen. 


#include 

#include 

#include 

#include 


void signal_handler( int ); 


{ 

struct sigaction 

act; 

act.sa_handler = signal_handler; 

sigemptyset( &act.sa_mask ); 

act.sa_flags = 0; 

if ( sigaction( SIGUSR1, &act, NULL ) == -1 ) 

panic( "sigaction" ) 

if ( sigaction( SIGUSR2, &act, NULL ) == -1 ) 


while ( 1 ) { 

printf( "Hauptprogramm wartet auf Signal...\n" ); 

pause(); 

} 

} 


void signal_handler( int sig ) 

{ 

printf( "Signal-Handler hat Signal %d erhalten\n", sig ); 

sleep( 10 ); 

} 

Programm 7-1: Abfangen von Signalen 


Signale 

Ändern der Signalmaske 

#include 

int sigprocmask(int how, const sigset_t *set, 

sigset_t *oset); 

int sigpending(sigset_t *set); 

Jeder Prozess hat eine Signalmaske, die angibt, welche Signale blockiert werden sollen. 

Mittels sigprocmask(2) kann diese geändert oder abfragt werden. Ist set nicht ein 

Nullpointer, so zeigt set auf die Menge der zu modifzierenden Signale und how gibt an, 

wie sie zu modifizieren sind: 

SIG_BLOCK fügt die Signale in set zur Signalmaske hinzu 

SIG_UNBLOCK entfernt die Signale in set aus der Signalmaske 

SIG_SETMASK setzt die Signalmaske auf set 

Ist oset nicht ein Nullpointer, so wird die bisherige Signalmaske des Prozesses in der 

Menge, auf die oset zeigt, gespeichert. 

sigpending(2) speichert in der Menge, auf die set zeigt, diejenigen blockierten Signale 

eines Prozesses, die momentan hängig sind. 


Signale 

Im folgenden Programm wird ein kritischer Bereich vor dem Eintreffen des Signals 

SIGINT geschützt. 


#include 

#include 

#include 

#include 



{ 

sigset_t blockmask, oldmask, pendmask; 

sigemptyset( &blockmask ); 

sigaddset( &blockmask, SIGINT ); 

if ( sigprocmask( SIG_BLOCK, &blockmask, &oldmask ) == -1 ) 

panic( "sigprocmask" ) 

printf( "Kritischer Bereich wird ausgefuehrt...\n" ); 

sleep( 10 ); 

if ( sigpending( &pendmask ) == -1 ) 

panic( "sigpending" ) 

if ( sigismember( &pendmask, SIGINT ) ) 

printf( "Interrupt-Signal ist haengig\n" ); 

if ( sigprocmask( SIG_SETMASK, &oldmask, NULL ) == -1 ) 

panic( "sigprocmask" ) 

} 

printf( "Programm terminiert\n" ); 


Programm 7-2: Schützen eines kritischen Bereichs vor Signalen 


Signale 

Weitere Signal-Funktionen 

#include 

unsigned int alarm(unsigned int secs); 

int pause(void); 

unsigned int sleep(unsigned int secs); 

alarm(3) schickt dem aufrufenden Prozess nach secs Sekunden das Signal SIGALRM. 

War vor dem Aufruf von alarm(3) bereits ein Alarm gesetzt, so wird dieser gelöscht und 

die Anzahl der noch verbleibenden Sekunden des früheren Aufrufs zurückgegeben. Es ist 

zu beachten, dass die Auslieferung des Signals durch andere Systemaktivitäten 

verzögert werden kann. 

pause(3) blockiert den aufrufenden Prozess, bis ein Signal eintrifft, das nicht ignoriert 

oder blockiert wird. 

sleep(3) blockiert den aufrufenden Prozess, bis secs Sekunden abgelaufen sind oder 

ein Signal eintrifft. Wird sleep(3) durch ein Signal unterbrochen, so wird die Anzahl der 

noch verbleibenden Sekunden zurückgegeben. 


Signale 

Im folgenden Programm wird eine Eingabe vom Terminal gelesen, wobei eine obere 

Zeitgrenze gesetzt wird. 


#include 

#include 

#include 

#include 

#define TIMEOUT 10 

#define MAXLINE 80 


void sigalrm_handler( int ); 


{ 

char 

struct sigaction 

line[MAXLINE]; 

act; 

act.sa_handler = sigalrm_handler; 

sigemptyset( &act.sa_mask ); 

act.sa_flags = 0; 

if ( sigaction( SIGALRM, &act, NULL ) == -1 ) 


printf( "Eingabe: " ); 

alarm( TIMEOUT ); 

if ( fgets( line, MAXLINE, stdin ) == NULL ) 

if ( errno != EINTR ) panic( "fgets" ) 

alarm( 0 ); 

} 


void sigalrm_handler( int sig ) 

{ 

printf( "Timeout ist abgelaufen\n" ); 

} 

Programm 7-3: Lesen einer Eingabe mit Timeout 


8 Pipes 


Pipes 

Funktionsweise 

• Eine Pipe ist ein Puffer fester Grösse, der vom Kernel 

verwaltet wird. 

• Über eine Pipe können Prozesse Daten austauschen. 

• Der Zugriff auf die Daten erfolgt nach dem FIFO-Prinzip. 

• Die zugreifenden Prozesse werden synchronisiert. 

Liest ein Prozess mittels read(2) aus einer Pipe, so werden so viele Zeichen gelesen, 

wie gerade in der Pipe vorhanden sind. Ist die Pipe leer, so wird der lesende Prozess 

blockiert, bis ein anderer Prozess Daten in die Pipe schreibt. Hat kein Prozess mehr die 

Pipe zum Schreiben geöffnet, so kehrt read(2) mit dem Funktionswert 0 zurück. 

Versucht umgekehrt ein Prozess, mittels write(2) mehr Zeichen in eine Pipe zu 

schreiben als Platz haben, so wird er blockiert, bis ein anderer Prozess Daten aus der 

Pipe liest. Hat kein Prozess mehr die Pipe zum Lesen geöffnet, so erhält der schreibende 

Prozess das Signal SIGPIPE. 

Das Schreiben ist garantiert ununterbrechbar, falls nicht mehr als PIPE_BUF Zeichen 

geschrieben werden. Dies kann dann wichtig sein, wenn mehrere Prozesse in dieselbe 

Pipe schreiben. 


Pipes 

Erzeugen einer unnamed Pipe 

#include 

int pipe(int fd[2]); 

pipe(2) erzeugt eine unnamed Pipe und gibt zwei Filedeskriptoren zurück: fd[0] zum 

Lesen aus der Pipe, fd[1] zum Schreiben in die Pipe. Da eine unnamed Pipe 

ausschliesslich über ihre Filedeskriptoren referenzierbar ist, kann sie nur vom 

erzeugenden Prozess und seinen Sohnprozessen verwendet werden. 


Pipes 

Das folgende Programm führt zwei Programme aus, wobei die Ausgabe des ersten 

Programms in eine unnamed Pipe umgeleitet wird, aus der das zweite Programm seine 

Eingabe liest. 


#include 

#include 

#include 

#include 



{ 

int fd[2]; 

pid_t pid; 

if ( argc < 3 ) { 

fprintf( stderr, "Verwendung: %s program1 program2 [args]\n", 

argv[0] ); 


} 

/* Pipe erzeugen */ 

if ( pipe( fd ) == -1 ) 

panic( "pipe" ) 

/* Sohnprozess erzeugen */ 

if ( (pid = fork()) == -1 ) 


if ( pid == 0 ) { 

/* Standardausgabe auf Pipe umleiten */ 

if ( close( fd[0] ) == -1 ) 


if ( dup2( fd[1], STDOUT_FILENO ) != STDOUT_FILENO ) 


if ( close( fd[1] ) == -1 ) 


} 

/* Programm ausfuehren */ 

if ( execlp( argv[1], argv[1], NULL ) == -1 ) 

panic( "execlp" ) 

/* Standardeingabe auf Pipe umleiten */ 

if ( close( fd[1] ) == -1 ) 


if ( dup2( fd[0], STDIN_FILENO ) != STDIN_FILENO ) 


if ( close( fd[0] ) == -1 ) 


} 

/* Programm ausfuehren */ 



Programm 8-1: Verwendung einer unnamed Pipe 


Pipes 

Erzeugen einer named Pipe 

#include

Pipes 

Das folgende Programm erzeugt eine named Pipe, liest aus ihr, bis kein Prozess mehr in 

die Pipe schreibt, und entfernt sie danach. 


#include 

#include 

#include 

#include 

#include 

#include 




{ 

int fd; 


ssize_t n; 

if ( argc != 2 ) { 



} 

/* Pipe erzeugen und oeffnen */ 

if ( mkfifo( argv[1], S_IRUSR | S_IWUSR ) == -1 ) 

panic( "mkfifo" ) 

if ( (fd = open( argv[1], O_RDONLY, 0 )) == -1 ) 


while ( 1 ) { 

} 

/* Daten aus Pipe lesen und ausgeben */ 

if ( (n = read( fd, buf, BUFSIZE )) == -1 ) 

panic( "read" ); 

if ( n == 0 ) break; 

if ( write( STDOUT_FILENO, buf, n ) == -1 ) 


/* Pipe schliessen und entfernen */ 

if ( close( fd ) == -1 ) 


if ( unlink( argv[1] ) == -1 ) 

panic( "unlink" ) 

} 


Programm 8-2: Verwendung einer named Pipe 


9 Fortgeschrittene Ein-/Ausgabe 


Fortgeschrittene Ein-/Ausgabe 

I/O-Multiplexing 

#include 

#include 

#include 

int select(int nfds, fd_set *readfds, 

fd_set *writefds, fd_set *exceptfds, 

struct timeval *timeout); 

struct timeval { 

long tv_sec; 

long tv_usec; 

}; 

Oft stellt sich das Problem, dass ein Prozess von mehreren Filedeskriptoren lesen muss, 

ohne dass im voraus bekannt ist, in welcher Reihenfolge die zu lesenden Daten zur 

Verfügung stehen. Mittels select(2) kann ein Prozess gleichzeitig mehrere 

Filedeskriptoren überwachen, wobei er so lange blockiert wird, bis mindestens einer der 

Deskriptoren zum Lesen bereit ist. 

nfds ist 1 grösser als die höchste Nummer der Deskriptoren, die überwacht werden 

sollen, und die Deskriptormengen readfds, writefds und exceptfds geben an, 

welche es sind: 

readfds 

writefds 

Deskriptoren, auf die gewartet wird, bis Daten gelesen werden 

können oder das Fileende erreicht ist 

Deskriptoren, auf die gewartet wird, bis Daten geschrieben 

werden können 

exceptfds Deskriptoren, auf die gewartet wird, bis eine Ausnahmebedingung 

eintritt 

Im Parameter timeout kann eine maximale Wartezeit spezifiziert werden. Wird ein 

Nullpointer übergeben, so gibt es keine zeitliche Beschränkung. 

Nach der Rückkehr von select(2) hat der Funktionswert folgende Bedeutung: 

= –1 ein Fehler ist aufgetreten 

= 0 die Wartezeit ist abgelaufen, bevor ein Deskriptor bereit war 

> 0 Anzahl der bereiten Deskriptoren; in diesem Fall sind in den 

Deskriptormengen readfds, writefds und exceptfds diejenigen 

Deskriptoren gesetzt, die bereit sind 



Deskriptormengen können mit den folgenden Makros manipuliert werden: 

FD_ZERO() löscht alle Bits 

FD_SET() setzt ein bestimmtes Bit 

FD_CLR() löscht ein bestimmtes Bit 

FD_ISSET() prüft, ob ein bestimmtes Bit gesetzt ist 



Das folgende Programm liest gleichzeitig aus mehreren Files, bis bei allen Files das 

Fileende erreicht ist. 

#include 

#include 

#include 

#include 

#include 




{ 

int nfiles, i; 

int fd, maxfd; 

fd_set openfds, readfds; 


ssize_t n; 

if ( argc < 2 ) { 

fprintf( stderr, "Verwendung: %s file1 [file2 ...]\n", argv[0] ); 


} 

nfiles = argc - 1; 

/* Files oeffnen und Deskriptormenge setzen */ 

maxfd = -1; 

FD_ZERO( &openfds ); 

for ( i = 0; i < nfiles; i++ ) { 

if ( (fd = open( argv[i+1], O_RDONLY )) == -1 ) 


if ( maxfd < fd ) maxfd = fd; 

FD_SET( fd, &openfds ); 

} 

while ( nfiles > 0 ) { 

/* auf bereite Deskriptoren warten */ 

readfds = openfds; 

if ( select( maxfd + 1, &readfds, NULL, NULL, NULL ) == -1 ) 

panic( "select" ) 

} 

/* von bereiten Deskriptoren lesen */ 

for ( fd = 0; fd


Record-Locking 

#include 

#include 

#include 

int fcntl(int fd, int cmd, struct flock *lock); 

struct flock { 

short l_type; 

off_t l_start; 

short l_whence; 

off_t l_len; 

pid_t l_pid; 

}; 

Mittels fcntl(2) kann ein Prozess auf einem beliebigen Bereich eines Files ein Lock 

erzeugen. Dabei gibt es exklusive und geteilte Locks. Besitzt ein Prozess einen 

exklusiven Lock auf einem bestimmten Bereich, so kann kein anderer Prozess einen 

Lock auf demselben Bereich erzeugen. Mehrere Prozesse können aber gleichzeitig einen 

geteilten Lock auf demselben Bereich haben. 

Der Parameter fd ist der Deskriptor des Files, auf dem ein Lock erzeugt werden soll, und 

lock beschreibt den gewünschten Lock: 

l_type 

l_start 

l_whence 

l_len 

l_pid 

Typ des Locks: F_RDLCK für einen geteilten Lock, F_WRLCK für 

einen exklusiven Lock und F_UNLCK, um einen Lock freizugeben 

Offset des Bereichs relativ zu l_whence 

Interpretation des Offsets: bei SEEK_SET relativ zum Anfang des 

Files, bei SEEK_CUR relativ zum aktuellen Fileoffset und bei 

SEEK_END relativ zum Ende des Files 

Grösse des Bereichs in Bytes; 0 bedeutet bis ans Ende des Files 

Identifier des Prozesses, der den Lock hat (wird beim Befehl 

F_GETLCK zurückgegeben) 

Der Parameter cmd ist einer der folgenden Befehle: 

F_GETLK bestimmt, ob der gewünschte Lock erzeugt werden kann; existiert 

ein anderer Lock, der dies verhindert, so wird die Information über 

den andern Lock in die Struktur lock geschrieben, andernfalls 

wird die Komponente l_type auf F_UNLCK gesetzt 

F_SETLK setzt den Lock bzw. gibt ihn wieder frei; kann ein gewünschter 

Lock nicht erzeugt werden, so kehrt der aufrufende Prozess mit 

einem Fehler (errno=EAGAIN) zurück 


F_SETLKW 


blockierende Version von F_SETLK: der aufrufende Prozess wird 

blockiert, bis der gewünschte Lock erzeugt werden kann 

Ein Lock ist jeweils einem Prozess und einem File zugeordnet, so dass er automatisch 

freigegeben wird, wenn der zugehörige Prozess terminiert oder das entsprechende File 

geschlossen wird. 



Mit dem folgenden Programm können beliebige Bereiche eines Files gesperrt und wieder 

freigegeben werden. 


#include 

#include 

#include 

#include 

#include 

#include 

#include 



{ 

int 

fd; 

struct flock lock; 

char 

cmd[10]; 

if ( argc != 2 ) { 



} 

if ( (fd = open( argv[1], O_RDWR | O_CREAT, S_IRUSR | S_IWUSR )) == -1 ) 


while ( 1 ) { 

printf( "> " ); 

if ( scanf( "%9s%d%d", cmd, &lock.l_start, &lock.l_len ) < 3 ) 

break; 

if ( strcmp( cmd, "readlock" ) == 0 ) 

lock.l_type = F_RDLCK; 

else if ( strcmp( cmd, "writelock" ) == 0 ) 

lock.l_type = F_WRLCK; 

else if ( strcmp( cmd, "unlock" ) == 0 ) 

lock.l_type = F_UNLCK; 

else { 

printf( "ungueltiger Befehl\n" ); 

continue; 

} 

lock.l_whence = SEEK_SET; 

if ( fcntl( fd, F_SETLKW, &lock ) == -1 ) 

panic( "fcntl" ) 

} 

if ( close( fd ) == -1 ) 


} 


Programm 9-4: Record-Locking 




10 Netzwerk-Kommunikation 


Netzwerk-Kommunikation 

Kommunikationsmodell 

lokaler Host 

fremder Host 

lokaler 

Prozess 

fremder 

Prozess 

Netzwerk 

Netzwerkmodul 

Netzwerkmodul 

Eine Netzwerkverbindung kann durch folgendes 5-Tupel charakterisiert werden: 

(Protokoll, lokaler Host, lokaler Prozess, fremder Host, fremder Prozess) 

Das Format der Host-Adressen und die Identifikation der kommunizierenden Prozesse 

wird durch das verwendete Protokoll definiert. In der TCP/IP-Protokollfamilie werden 

dafür Internet-Adressen und Port-Nummern verwendet, z.B. 

(TCP, 193.5.80.21, 1078, 130.59.1.2, 21) 



TCP/IP-Protokolle 

ISO/OSI-Modell 

TCP/IP-Protokolle 

Anwendungsschicht 

FTP, TELNET, SMTP, ... 

Darstellungsschicht 

Sitzungsschicht 

Transportschicht 

TCP 

UDP 

Netzwerkschicht 

IP/ICMP 

Datensicherungsschicht 

Physikalische Schicht 

Die TCP/IP-Protokolle wurden in den frühen Achtzigerjahren als Standard für das 

ARPANET (Paketvermittlungsnetz der „Defense Advanced Research Projects Agency“) 

definiert, aus dem das heutige Internet entstand. Kurz darauf wurden sie ins Berkeley- 

UNIX integriert, so dass sie eine schnelle Verbreitung fanden. 

Die TCP/IP-Protokolle stellen offene Standards dar, die Hardware- und Betriebssystemunabhängig 

sind, und werden in sogenannten „Requests for Comments“ (RFC) publiziert. 

Die wichtigsten Protokolle sind: 

IP Internet Protocol (RFC 791) 

ICMP Internet Control Message Protocol (RFC 792) 

TCP Transmission Control Protocol (RFC 793) 

UDP User Datagram Protocol (RFC 768) 

FTP File Transfer Protocol (RFC 959) 

TELNET Network Terminal Protocol (RFC 854) 

SMTP Simple Mail Transfer Protocol (RFC 821) 



Eigenschaften der TCP/IP-Protokolle 

TCP UDP IP 

verbindungsorientiert ja nein nein 

meldungsorientiert nein ja ja 

zuverlässig ja nein nein 

Flusskontrolle ja nein nein 

voll-duplex 

ja 

dringende Daten ja 

Protokolle können verschiedene Eigenschaften haben: 

• Bei einem verbindungsorientierten Protokoll bauen die beiden 

Kommunikationspartner eine logische Verbindung auf, die während dem 

Datenaustausch bestehen bleibt und danach wieder abgebaut wird. 

• Bei einem meldungsorientierten Protokoll werden die Meldungsgrenzen 

beibehalten, die der Sender festgelegt hat. 

• Ein zuverlässiges Protokoll garantiert, dass die Daten fehlerfrei und in 

derselben Reihenfolge beim Empfänger ankommen, wie sie der Sender 

abgeschickt hat. 

• Eine Flusskontrolle stellt sicher, dass der Sender die Daten nicht schneller 

schickt, als sie der Empfänger verarbeiten kann. 

• Eine voll-duplexes Protokoll ermöglicht die gleichzeitige Übertragung von Daten 

in beide Richtungen. 

• Erlaubt ein Protokoll das Verschicken von dringenden Daten, so werden diese 

nicht zwischengespeichert sondern sofort übermittelt. 



Rahmenbildung 

Anwendungsschicht 

Daten 

Transportschicht 

TCP/UDP- 

Header 

Daten 

Netzwerkschicht 

IP-Header 

TCP/UDP- 

Header 

Daten 

Datensicherungsschicht 

Ethernet- 

Header 

IP-Header 

TCP/UDP- 

Header 

Daten 

In jeder Schicht des ISO/OSI-Modells fügt der Sender den Daten einen Header mit 

Kontrollinformation hinzu, der dann vom Empfänger in umgekehrter Reihenfolge wieder 

entfernt wird. 

Der IP-Header enthält u.a. die Internet-Adressen des Sender- und Empfänger-Hosts 

sowie einen Protokoll-Identifier, damit die Daten an das entsprechende Modul der 

Transportschicht weitergegeben werden können. Die TCP- und UDP-Header enthalten 

u.a. die Port-Nummern der beiden kommunizierenden Prozesse. 



Internet-Adressen 

Bytes 

1 2 3 4 

Class A 

0 

Netz-Id 

Host-Id 

Class B 

10 

Netz-Id 

Host-Id 

Class C 

110 

Netz-Id 

Host-Id 

Jeder Host im Internet hat eine eindeutige 32 bit-Internet-Adresse, die aus einem 

Netzwerk-Identifier und einem dazu relativen Host-Identifier besteht. Es gibt drei Typen 

von Internet-Adressen: Class A-Adressen werden für Netzwerke mit vielen Hosts 

gebraucht, Class B-Adressen für Netzwerke mit einer mittleren Anzahl Hosts und Class 

C-Adressen für Netzwerke mit wenigen Hosts. 

Die vier Bytes einer Internet-Adresse werden gewöhnlich als Dezimalzahlen geschrieben 

und durch einen Punkt voneinander getrennt, z.B. 130.59.1.2. Mit den Funktionen 

inet_addr(3) und inet_ntoa(3) können Strings, die eine Internet-Adresse in dieser 

Dezimaldarstellung enthalten, in Integer-Zahlen umgewandelt werden und umgekehrt. 



Port-Nummern 

Bereich Kategorie 

1 – 255 reservierte Port-Nummern 

1 – 1023 privilegierte Port-Nummern 

1024 – 5000 kurzlebige Port-Nummern 

5001 – 65535 Benutzer-definierte Port-Nummern 

Port-Nummern sind 16 bit-Dezimalzahlen, die vom TCP- und UDP-Protokoll zur 

Identifikation der kommunizierenden Prozesse verwendet werden. Die Port-Nummern 

sind in vier Kategorien eingeteilt: 

• Reservierte Port-Nummern sind „wohlbekannte“ Port-Nummern, die für 

Standard-Anwendungen reserviert sind, z.B. 21 für FTP. 

• Privilegierte Port-Nummern werden von Superuser-Prozessen für UNIXspezifische 

Anwendungen verwendet, z.B. 514 für Remote-Shell. 

• Kurzlebige Port-Nummern sind Port-Nummern, die vom System automatisch an 

Benutzer-Prozesse vergeben werden, die nicht auf eine bestimmte Port- 

Nummer angewiesen sind. 

• Benutzer-definierte Port-Nummern können von nicht-privilegierten Server- 

Prozessen beansprucht werden, die ihre Port-Nummer den Client-Prozessen 

bekanntgeben müssen. 



Sockets 

Datenaustausch 

verbindungsorientiert 

verbindungslos 

Protokoll 

lokale 

Adresse 

fremde 

Adresse 

socket(2) bind(2) accept(2) 

connect(2) 

recv(2) 

send(2) 

socket(2) bind(2) recvfrom(2) 

sendto(2) 

Sockets bilden die Schnittstelle zwischen den Anwendungsprogrammen und dem 

Netzwerkmodul; sie stellen die logischen Endpunkte einer Verbindung dar. 

Die Netzwerk-Schnittstelle ist ähnlich aufgebaut wie die Schnittstelle zum Filesystem. So 

entspricht das Erzeugen eines Sockets mittels socket(2) dem Öffnen eines Files. Für 

den Datenaustausch über einen Socket können u.a. die System-Calls read(2) und 

write(2) verwendet werden. Und mittels close(2) kann ein Socket schliesslich wieder 

geschlossen werden, wenn er nicht mehr gebraucht wird. 



Verbindungslose Kommunikation 

Server 

Client 

socket(2) 

bind(2) 

socket(2) 

bind(2) 

recvfrom(2) 

sendto(2) 


sendto(2) 

recvfrom(2) 

close(2) 

Bei einer verbindungslosen Kommunikation wird der Server meistens iterativ 

implementiert. D.h. er empfängt eine Anfrage nach der andern und schickt die Antworten 

an die entsprechenden Clients zurück. Dabei spielt es keine Rolle, ob mehrere Anfragen 

vom gleichen Client oder alle Anfragen von verschiedenen Clients stammen. Ein 

iterativer Server ist aber nur geeignet, wenn er nicht lange braucht, um seine Antworten 

zu erzeugen. 


Verbindungsorientierte Kommunikation 


Server 

Client 

socket(2) 

bind(2) 

listen(2) 

accept(2) 

fork(2) 

Verbindungsaufbau 

socket(2) 

bind(2) 

connect(2) 

recv(2) 

send(2) 


send(2) 

recv(2) 

close(2) 

close(2) 

Bei einer verbindungsorientierten Kommunikation wird der Server meistens parallel 

implementiert. D.h. der Server-Prozess erzeugt nach einem Verbindungsaufbau einen 

Sohnprozess, der mit dem entsprechenden Client kommuniziert, während er selbst 

weitere Verbindungsanforderungen von Clients akzeptieren kann. Ein paralleler Server 

hat den Vorteil, dass er nicht durch einen Client blockiert werden kann. 



Erzeugen eines Sockets 

#include 

#include 

int socket(int domain, int type, int protocol); 

Mittels socket(2) kann ein Socket erzeugt werden. Als Funktionswert wird ein Deskriptor 

zurückgegeben, mit dem der Socket referenziert wird. 

domain ist der Kommunikationsbereich. Je nach System stehen verschiedene Bereiche 

zur Auswahl, überall aber AF_UNIX für die lokale Kommunikation auf einem Rechner und 

AF_INET für die Kommunikation über das Internet. 

type definiert die Semantik der Kommunikation: SOCK_STREAM für eine 

verbindungsorientierte zuverlässige Kommunikation oder SOCK_DGRAM für eine 

verbindungslose meldungsorientierte Kommunikation. 

protocol bestimmt das zu verwendende Protokoll. Ist protocol = 0, so wird ein vom 

Kommunikationsbereich und von der Semantik abhängiges Default-Protokoll gewählt. Im 

Internet-Bereich ist dies TCP für SOCK_STREAM und UDP für SOCK_DGRAM. 



Socket-Adressen 

#include 

#include 

struct sockaddr { 

unsigned char 

sa_family_t 

char 

}; 

sa_len; 

sa_family; 

sa_data[14]; 

struct sockaddr_in { 

unsigned char sin_len; 

sa_family_t sin_family; 

in_port_t sin_port; 

struct in_addr sin_addr; 

unsigned char sin_zero[8]; 

}; 

struct in_addr { 

in_addr_t s_addr; 

}; 

Die Struktur sockaddr ist eine allgemeine Adressstruktur, die in vielen Socket-System- 

Calls als Parameter vorkommt. Der Inhalt der Protokoll-spezifischen Adresse sa_data 

wird abhängig von der Adressfamilie sa_family interpretiert. 

Für die Internet-Familie wird die Struktur sockaddr_in verwendet, bei der sin_family 

die Konstante AF_INET ist. Die Komponenten sin_port und sin_addr enthalten die 

Port-Nummer des Prozesses und die Internet-Adresse des Hosts, sin_zero wird nicht 

gebraucht. 

Da nicht alle Rechner Integer-Zahlen intern gleich darstellen, müssen die Internet- 

Adresse und die Port-Nummer in der sogenannten Netzwerk-Byte-Reihenfolge 

übermittelt werden (d.h. mit dem höchstwertigen Byte am Anfang). Zur Umwandlung von 

Integer-Zahlen mit Host-Byte-Reihenfolge in Integer-Zahlen mit Netzwerk-Byte- 

Reihenfolge und umgekehrt stehen die Funktionen htonl(3), htons(3), ntohl(3) und 

ntohs(3) zur Verfügung. 


Verknüpfen eines Sockets mit einer Adresse 


#include 

#include 

int bind(int sd, const struct sockaddr *addr, 

size_t addrlen); 

Mittels bind(2) wird der Socket sd mit der Adresse addr verknüpft. Da die Adresse 

Protokoll-abhängig ist, gibt addrlen ihre Länge an. Es gibt zwei Anwendungsfälle von 

bind(2): 

• Ein Server-Prozess registriert seine „wohlbekannte“ Port-Nummer. 

• Ein Client-Prozess stellt sicher, dass er eine eindeutige Adresse hat, an die ein 

Server seine Antworten schicken kann. 

Wird im zweiten Fall als Port-Nummer 0 angegeben, so weist das System dem Socket 

automatisch eine freie kurzlebige Port-Nummer zu. In beiden Fällen kann als Host- 

Adresse INADDR_ANY verwendet werden, was bedeutet, dass der Prozess bereit ist, auf 

allen Internet-Adressen des Systems Daten zu empfangen. 


Datenaustausch über unverbundene Sockets 


#include 

#include 

ssize_t recvfrom(int sd, void *buf, size_t nbytes, 

int flags, struct sockaddr *addr, 

size_t *addrlen); 

ssize_t sendto(int sd, const void *buf, size_t nbytes, 

int flags, const struct sockaddr *addr, 


Mittels recvfrom(2) und sendto(2) können über den unverbundenen Socket sd 

Meldungen empfangen bzw. geschickt werden. Bei recvfrom(2) zeigt buf auf einen 

Speicherbereich, in den die empfangenen Daten abgelegt werden, bei sendto(2) auf 

einen Speicherbereich, der die zu schickenden Daten enthält. nbytes ist die maximale 

Anzahl zu empfangender bzw. zu schickender Bytes. 

Im Parameter flags kann u.a. die Option MSG_OOB gesetzt werden kann, um dringende 

Daten zu empfangen bzw. zu schicken. addr und addrlen enthalten nach der Rückkehr 

von recvfrom(2) die Adresse des Absenders und ihre Länge. Bei sendto(2) wird in 

addr und addrlen die Adresse des Empfängers und ihre Länge übergeben. 

Als Funktionswert geben recvfrom(2) und sendto(2) die Anzahl empfangener bzw. 

geschickter Bytes zurück. 



#define _XOPEN_SOURCE_EXTENDED 1 

#include 

#include 

#include 

#include 

#include 

#include 




{ 

int 

sd; 

struct sockaddr_in server, client; 

size_t 

len; 

char 


ssize_t n; 

if ( argc != 2 ) { 

fprintf( stderr, "Verwendung: %s port\n", argv[0] ); 


} 

/* Socket erzeugen */ 

if ( (sd = socket( AF_INET, SOCK_DGRAM, 0 )) == -1 ) 

panic( "socket" ) 

/* Socket mit eigenen Adresse verknuepfen */ 

len = sizeof( server ); 

bzero( &server, len ); 

server.sin_len 

= len; 

server.sin_family = AF_INET; 

server.sin_port = htons( atoi( argv[1] ) ); 

server.sin_addr.s_addr = htonl( INADDR_ANY ); 

if ( bind( sd, (struct sockaddr *)&server, len ) == -1 ) 

panic( "bind" ) 

printf( "Warte auf Meldungen auf Port %d...\n", ntohs( server.sin_port ) ); 

while ( 1 ) { 

} 

} 

/* Meldung empfangen und zurueckschicken */ 

if ( (n = recvfrom( sd, line, MAXLINE, 0, 

(struct sockaddr *)&client, &len )) == -1 ) 

panic( "recvfrom" ) 

printf( "Meldung von Client %s (Port %d) empfangen\n", 

inet_ntoa( client.sin_addr ), ntohs( client.sin_port ) ); 

if ( sendto( sd, line, n, 0, (struct sockaddr *)&client, len ) == -1 ) 

panic( "sendto" ) 

Programm 10-1: Verbindungsloser Echo-Server 




#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include 




{ 

int 

sd; 

struct sockaddr_in client, server; 

size_t 

len; 

char 


if ( argc != 3 ) { 

fprintf( stderr, "Verwendung: %s host port\n", argv[0] ); 


} 


if ( (sd = socket( AF_INET, SOCK_DGRAM, 0 )) == -1 ) 



len = sizeof( client ); 

bzero( &client, len ); 

client.sin_len 

= len; 

client.sin_family = AF_INET; 

client.sin_port = htons( 0 ); 

client.sin_addr.s_addr = htonl( INADDR_ANY ); 

if ( bind( sd, (struct sockaddr *)&client, len ) == -1 ) 


/* Server-Adresse bestimmen */ 




= len; 



server.sin_addr.s_addr = inet_addr( argv[1] ); 

while ( 1 ) { 

/* Meldung einlesen und schicken */ 

printf( "> " ); 


break; 

if ( sendto( sd, line, strlen( line ) + 1, 0, 

(struct sockaddr *)&server, len ) == -1 ) 

panic( "sendto" ) 

} 

/* Antwort empfangen und ausgeben */ 

if ( recvfrom( sd, line, MAXLINE, 0, 

(struct sockaddr *)&server, &len ) == -1 ) 

panic( "recvfrom" ) 

fputs( line, stdout ); 

/* Socket schliessen */ 

if ( close( sd ) == -1 ) 


} 


Programm 10-2: Verbindungsloser Echo-Client 



Akzeptieren einer Verbindung 

#include 

#include 

int listen(int sd, int backlog); 

int accept(int sd, struct sockaddr *addr, 

size_t *addrlen); 

Mittels listen(2) kann ein Server-Prozess den Socket sd in einen passiven Zustand 

versetzen. Dabei wird eine Warteschlange bereitgestellt, in welcher die Verbindungsanforderungen 

von Client-Prozessen zwischengespeichert werden. backlog gibt die 

Grösse dieser Warteschlange an, wobei SOMAXCONN die Maximalgrösse ist. 

Mittels accept(2) kann ein Server-Prozess eine Verbindungsanforderung in der 

Warteschlange des passiven Sockets sd entgegennehmen und dadurch eine Verbindung 

mit dem entsprechenden Client-Prozess aufbauen. Ist die Warteschlange leer, so wird 

der Server-Prozess blockiert. 

In addr wird die Adresse des Client-Prozesses gespeichert, mit dem die Verbindung 

aufgebaut wurde. addrlen ist sowohl ein Argument- als auch ein Resultatparameter: Vor 

dem Aufruf wird addrlen auf die Länge der Adressstruktur addr gesetzt, nach der 

Rückkehr enthält addrlen die aktuelle Anzahl Bytes in addr. 

Als Funktionswert gibt accept(2) den Deskriptor eines neu erzeugten Sockets zurück. 

Dieser Socket ist mit dem Client verbunden und kann somit für den Datenaustausch mit 

diesem verwendet werden. Auf dem ursprünglichen Socket sd kann der Server-Prozess 

dagegen weitere Verbindungsanforderungen akzeptieren. 



Aufbauen einer Verbindung 

#include 

#include 

int connect(int sd, const struct sockaddr *addr, 


Mittels connect(2) kann ein Client-Prozess über den Socket sd eine Verbindung zu 

einem Server-Prozess aufbauen. In addr wird die Adresse des Servers übergeben und 

in addrlen ihre Länge. Wurde der Socket sd vorher nicht mit der Adresse des Clients 

verknüpft, so geschieht dies implizit beim Aufruf von connect(2). 


Datenaustausch über verbundene Sockets 


#include 

#include 

ssize_t recv(int sd, void *buf, size_t nbytes, 

int flags); 

ssize_t send(int sd, const void *buf, size_t nbytes, 

int flags); 

Mittels recv(2) und send(2) können über den verbundenen Socket sd Daten empfangen 

bzw. geschickt werden. recv(2) und send(2) funktionieren gleich wie recvfrom(2) und 

sendto(2), ausser dass sie keine Parameter für die Adresse des Absenders bzw. des 

Empfängers haben. 




#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include 




{ 

int 

sd, sd2; 

struct sockaddr_in server, client; 

size_t 

len; 

pid_t 

pid; 

char 


ssize_t n; 

if ( argc != 2 ) { 

fprintf( stderr, "Verwendung: %s port\n", argv[0] ); 


} 

/* Verbindungssocket erzeugen */ 

if ( (sd = socket( AF_INET, SOCK_STREAM, 0 )) == -1 ) 






= len; 



server.sin_addr.s_addr = htonl( INADDR_ANY ); 

if ( bind( sd, (struct sockaddr *)&server, len ) == -1 ) 


/* Socket in passiven Zustand versetzen */ 

if ( listen( sd, SOMAXCONN ) == -1 ) 

panic( "listen" ) 

printf( "Akzeptiere Verbindungen auf Port %d...\n", 

ntohs( server.sin_port ) ); 

while ( 1 ) { 

/* Verbindung von Client akzeptieren */ 


if ( (sd2 = accept( sd, (struct sockaddr *)&client, &len )) == -1 ) 

panic( "accept" ) 

printf( "Verbindung von Client %s (Port %d) akzeptiert\n", 

inet_ntoa( client.sin_addr ), ntohs( client.sin_port ) ); 

/* Sohnprozess erzeugen */ 

if ( (pid = fork()) == -1 ) 


if ( pid == 0 ) { 

/* Verbindungssocket schliessen */ 

if ( close( sd ) == -1 ) 


while ( 1 ) { 

} 

/* Meldung empfangen und zurueckschicken */ 

if ( (n = recv( sd2, line, MAXLINE, 0 )) == -1 ) 

panic( "recv" ) 

if ( n == 0 ) break; 

if ( send( sd2, line, n, 0 ) == -1 ) 

panic( "send" ) 



/* Datensocket schliessen */ 

if ( close( sd2 ) == -1 ) 


} 


} 

} 

/* Datensocket schliessen */ 

if ( close( sd2 ) == -1 ) 


/* terminierte Sohnprozesse abholen */ 

while ( waitpid( -1, NULL, WNOHANG ) > 0 ); 

Programm 10-3: Verbindungsorientierter Echo-Server 




#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include 




{ 

int 

sd; 

struct sockaddr_in client, server; 

size_t 

len; 

char 


if ( argc != 3 ) { 

fprintf( stderr, "Verwendung: %s host port\n", argv[0] ); 


} 


if ( (sd = socket( AF_INET, SOCK_STREAM, 0 )) == -1 ) 




bzero( &client, len ); 

client.sin_len 

= len; 

client.sin_family = AF_INET; 

client.sin_port = htons( 0 ); 

client.sin_addr.s_addr = htonl( INADDR_ANY ); 

if ( bind( sd, (struct sockaddr *)&client, len ) == -1 ) 


/* Verbindung zum Server aufbauen */ 




= len; 



server.sin_addr.s_addr = inet_addr( argv[1] ); 

if ( connect( sd, (struct sockaddr *)&server, len ) == -1 ) 

panic( "connect" ) 

printf( "Verbindung zu Server %s (Port %d) aufgebaut\n", 

inet_ntoa( server.sin_addr ), ntohs( server.sin_port ) ); 

while ( 1 ) { 

/* Meldung einlesen und schicken */ 

printf( "> " ); 


break; 

if ( send( sd, line, strlen( line ) + 1, 0 ) == -1 ) 

panic( "send" ) 

} 

/* Antwort empfangen und ausgeben */ 

if ( recv( sd, line, MAXLINE, 0 ) == -1 ) 

panic( "recv" ) 

fputs( line, stdout ); 

/* Socket schliessen */ 

if ( close( sd ) == -1 ) 


} 


Programm 10-4: Verbindungsorientierter Echo-Client 



Abfragen von Host-Informationen 

#include 

struct hostent *gethostbyname(const char *name); 

struct hostent *gethostbyaddr(const void *addr, 

size_t len, int type); 

struct hostent { 

char *h_name; 

char **h_aliases; 

int h_addrtype; 

int h_length; 

char **h_addr_list; 

}; 

Mittels gethostbyname(3) und gethostbyaddr(3) kann Information über einen 

Internet-Host abgefragt werden. Diese wird stammt entweder aus dem File /etc/hosts 

oder wird von einem Name-Server erhalten. name ist der offizielle Name oder ein 

Aliasname des Hosts. addr ist ein Pointer auf eine Struktur vom Typ in_addr, welche 

die Internet-Adresse des Hosts enthält, und len gibt die Länge dieser Struktur an. Als 

type muss die Konstante AF_INET übergeben werden. 

Die Komponenten der Struktur hostent haben folgende Bedeutungen: 

h_name offizieller Name des Hosts 

h_aliases NULL-terminierte Liste der Aliasnamen 

h_addrtype Adresstyp 

h_length Länge der Adresse 

h_addr_list NULL-terminierte Liste der Internet-Adressen 

Es ist zu beachten, dass h_addr_list eigentlich ein Array von Pointern auf Strukturen 

vom Typ in_addr ist und nicht von Pointern auf char. 




#include 

#include 

#include 

#include 

#include 

#include 


{ 

struct in_addr inaddr; 

struct hostent *host; 

int i; 

if ( argc != 2 ) { 

fprintf( stderr, "Verwendung: %s host\n", argv[0] ); 


} 

if ( (inaddr.s_addr = inet_addr( argv[1] )) != INADDR_NONE ) 

host = gethostbyaddr( (char *)&inaddr, sizeof( inaddr ), AF_INET ); 

else host = gethostbyname( argv[1] ); 

if ( host == NULL ) { 

fprintf( stderr, "Host nicht gefunden\n" ); 


} 

printf( "Offizieller Name : %s\n", host->h_name ); 

for ( i = 0; host->h_aliases[i] != NULL; i++ ) 

printf( "Aliasname : %s\n", host->h_aliases[i] ); 

if ( host->h_addrtype == AF_INET ) 

for ( i = 0; host->h_addr_list[i] != NULL; i++ ) { 

bcopy( host->h_addr_list[i], (char *)&inaddr, sizeof( inaddr ) ); 

printf( "Internet-Adresse : %s\n", inet_ntoa( inaddr ) ); 

} 

else fprintf( stderr, "unbekannter Adresstyp\n" ); 

} 


Programm 10-5: Abfragen einer Host-Information 



Abfragen von Service-Informationen 

#include 

struct servent *getservbyname(const char *name, 

const char *proto); 

struct servent *getservbyport(int port, 

const char *proto); 

struct servent { 

char *s_name; 

char **s_aliases; 

int s_port; 

char *s_proto; 

}; 

Mittels getservbyname(3) und getservbyport(3) kann die Information über einen 

Service abgefragt werden, die im File /etc/services steht. name ist der offizielle 

Name oder ein Aliasname des Services, port die Port-Nummer, die der Service hat, und 

proto der Name des zu verwendenden Protokolls. 

Die Komponeneten der Struktur servent haben folgende Bedeutungen: 

s_name offizieller Name des Services 

s_aliases NULL-terminierte Liste der Aliasnamen 

s_port Port-Nummer des Services 

s_proto Name des zu verwendenden Protokolls 




#include 

#include 

#include 

#include 

#include 


{ 

int 

port; 

struct servent *service; 

int i; 

if ( argc < 2 ) { 

fprintf( stderr, "Verwendung: %s port|service [protocol]\n", 

argv[0] ); 


} 

if ( (port = atoi( argv[1] )) != 0 ) 

service = getservbyport( htons( port ), argv[2] ); 

else service = getservbyname( argv[1], argv[2] ); 

if ( service == NULL ) { 

fprintf( stderr, "Service nicht gefunden\n" ); 


} 

printf( "Offizieller Name : %s\n", service->s_name ); 

for ( i = 0; service->s_aliases[i] != NULL; i++ ) 

printf( "Aliasname : %s\n", service->s_aliases[i] ); 

printf( "Port-Nummer : %d\n", ntohs( service->s_port ) ); 

printf( "Protokoll : %s\n", service->s_proto ); 

} 


Programm 10-6: Abfragen einer Service-Information 



Name 

recvmsg(2) 

sendmsg(2) 

getsockname(2) 

getpeername(2) 

getsockopt(2) 

setsockopt(2) 

shutdown(2) 

Beschreibung 

Empfangen von mehreren Meldungen 

Schicken von mehreren Meldungen 

Abfragen der lokalen Adresse eines 

Sockets 

Abfragen der fremden Adresse eines 

verbundenen Sockets 

Abfragen von Optionen eines Sockets 

Setzen von Optionen eines Sockets 

Abbauen einer Netzwerkverbindung 

Tabelle 10-1: Weitere Socket-System-Calls 




11 Threads 


Threads 

Threads eines Prozesses 

Prozess 

Thread 

Thread 

Register 

Register 

Adressraum 

Stack 

Stack 

Identifier 

Resources 

Heap 

Data 

Code 

Threads sind parallel ausführbare Folgen von Instruktionen innerhalb eines Prozesses. 

Jeder Thread hat einen eigenen Programm-Counter, einen eigenen Stack und eine 

eigene Kopie der Prozessorregister. Die verschiedenen Threads laufen aber im gleichen 

Adressraum ab und haben somit Zugriff auf dieselben globalen Daten. Zudem stehen 

ihnen die gemeinsamen Prozess-Ressourcen wie offene Files, Netzwerkverbindungen 

usw. zur Verfügung. 

Threads haben gegenüber Prozessen den Vorteil, dass zu ihrer Verwaltung nur ein 

minimaler Overhead des Betriebssystems notwendig ist. Zudem eignen sie sich zum 

Verteilen auf die Prozessoren eines Multiprozessor-Rechners. 


Threads 

POSIX-Threads 

Thread-Verwaltung 

pthread_create(3) 

pthread_exit(3) 

pthread_join(3) 

pthread_detach(3) 

Mutex-Locks 

pthread_mutex_init(3) 

pthread_mutex_destroy(3) 

pthread_mutex_lock(3) 

pthread_mutex_trylock(3) 

pthread_mutex_unlock(3) 

Condition-Variablen 

pthread_cond_init(3) 

pthread_cond_destroy(3) 

pthread_cond_wait(3) 

pthread_cond_timedwait(3) 

pthread_cond_signal(3) 

pthread_cond_broadcast(3) 

Im Juni 1995 wurde vom IEEE der definitive Standard POSIX.1c anerkannt, auch kurz 

Pthreads genannt. Er ist ein optionaler Teil von POSIX.1 und enthält die Spezifikation 

einer Thread-Bibliothek, die aus über 60 Funktionen besteht. Die meisten dieser 

Funktionen geben eine Integer-Zahl als Funktionswert zurück. Im Erfolgsfall ist dieser 

Wert 0, im Fehlerfall gibt er die Art des aufgetretenen Fehlers an. 


Threads 

Erzeugen eines Threads 

#include 

int pthread_create(pthread_t *tid, 

const pthread_attr_t *attr, 

void *(*routine)(void *), 

void *arg); 

Mittels pthread_create(3) kann ein Thread erzeugt werden. tid ist ein 

Resultatparameter, in dem der Identifier des erzeugten Threads zurückgegeben wird. 

attr ist ein Pointer auf ein Attributobjekt, in dem die Stackgrösse, die Stackadresse, der 

Detach-Zustand, der Scope, die Priorität und die Scheduling-Politik des Threads 

festgelegt werden können. Ist attr ein Nullpointer, so werden die Default-Attribute 

verwendet. 

routine ist eine Funktion, die als Startroutine des Threads ausgeführt wird. Sie hat 

einen void-Pointer als Parameter, dem der Wert von arg zugewiesen wird. Über diesen 

Pointer kann dem Thread eine beliebige globale Datenstruktur übergeben werden, wobei 

darauf zu achten ist, dass diese nicht durch einen andern Thread nachträglich 

überschrieben wird. 


Threads 

Terminieren eines Threads 

#include 

int pthread_exit(void *status); 

int pthread_join(pthread_t tid, void **status); 

int pthread_detach(pthread_t tid); 

Ein Thead terminiert, wenn er aus der Startroutine zurückkehrt. Dies geschieht entweder 

durch ein return-Statement oder mittels pthread_exit(3). Der Ausdruck des 

return-Statements bzw. der Parameter status von pthread_exit(3) ist der Exit- 

Status des Threads. 

Mittels pthread_join(3) kann ein Thread auf die Terminierung eines andern Threads 

warten. Im Parameter status erhält er dann den Exit-Status des terminierten Threads 

zurück. 

Muss nicht auf die Terminierung eines Threads gewartet werden, so kann er mittels 

pthread_detach(3) für die Löschung vorgesehen werden. In diesem Fall werden der 

Speicherplatz und der Exit-Status des Threads nach dessen Terminierung automatisch 

gelöscht. 


Threads 

Das folgende Programm liest gleichzeitig aus mehreren Files, indem für jedes File ein 

eigener Thread erzeugt wird. 

#define _POSIX_C_SOURCE 199506L 

#include 

#include 

#include 

#include 

#include 

#include 

#include 


#define panic( str, code ) { \ 

fprintf( stderr, "%s: %s\n", str, strerror( code ) ); exit( EXIT_FAILURE ); } 

void *reader( void *fd ); 


{ 

int nfiles, i; 

int *fd; 

pthread_t *tid; 

int rc; 

if ( argc < 2 ) { 

fprintf( stderr, "Verwendung: %s file1 [file2 ...]\n", argv[0] ); 


} 

nfiles = argc - 1; 

/* Files oeffnen */ 

fd = malloc( nfiles*sizeof( int ) ); 

for ( i = 0; i < nfiles; i++ ) 

if ( (fd[i] = open( argv[i+1], O_RDONLY )) == -1 ) 

panic( "open", errno ) 

/* Threads erzeugen */ 

tid = malloc( nfiles*sizeof( pthread_t ) ); 

for ( i = 0; i < nfiles; i++ ) 

if ( (rc = pthread_create( &tid[i], NULL, reader, &fd[i] )) != 0 ) 

panic( "pthread_create", rc ) 

/* auf Terminierung der Threads warten */ 

for ( i = 0; i < nfiles; i++ ) 

if ( (rc = pthread_join( tid[i], NULL )) != 0 ) 

panic( "pthread_join", rc ) 

} 


void *reader( void *arg ) 

{ 

int fd = *(int *)arg; 


ssize_t n; 

while ( 1 ) { 

/* Daten aus File lesen und ausgeben */ 

if ( (n = read( fd, buf, BUFSIZE )) == -1 ) 

panic( "read", errno ) 

if ( n == 0 ) break; 

if ( write( STDOUT_FILENO, buf, n ) == -1 ) 

panic( "write", errno ) 

} 

/* File schliessen */ 

if ( close( fd ) == -1 ) 

panic( "close", errno ) 

} 

return NULL; 

Programm 11-1: I/O-Multiplexing mittels Threads 


Threads 

Mutex-Locks 

Thread 1 

Thread 2 





Mit einem Mutex-Lock kann ein exklusiver Ausschluss zwischen Threads, die auf eine 

gemeinsame Ressource zugreifen, implementiert werden. Dazu muss ein Thread 

während des Zugriffs auf die Ressource den zugehörigen Mutex-Lock sperren. Versucht 

dann ein anderer Thread denselben Mutex-Lock zu sperren, so wird er blockiert, bis 

derjenige Thread, der den Mutex-Lock gesperrt hat, ihn wieder freigibt. 


Threads 

Initialisieren eines Mutex-Locks 

#include 

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; 

int pthread_mutex_init(pthread_mutex_t *mutex, 

const pthread_mutexattr_t *attr); 

int pthread_mutex_destroy(pthread_mutex_t *mutex); 

Bevor ein Mutex-Lock verwendet werden kann, muss er initialisiert werden. Dies 

geschieht entweder statisch bei der Definition der Mutex-Variablen durch den Initialisierer 

PTHREAD_MUTEX_INITIALIZER oder dynamisch mittels pthread_mutex_init(3). 

attr ist ein Pointer auf ein Attributobjekt, in dem verschiedene Attribute des Mutex- 

Locks festgelegt werden können. Ist attr ein Nullpointer, so werden die Default-Attribute 

verwendet. 

Wenn ein Mutex-Lock nicht mehr gebraucht wird, so kann er mittels 

pthread_mutex_destroy(3) zerstört werden. 


Threads 

Sperren und Freigeben eines Mutex-Locks 

#include 

int pthread_mutex_lock(pthread_mutex_t *mutex); 

int pthread_mutex_trylock(pthread_mutex_t *mutex); 

int pthread_mutex_unlock(pthread_mutex_t *mutex); 

Mittels pthread_mutex_lock(3) kann ein Thread einen Mutex-Lock sperren. Ist der 

Mutex-Lock bereits von einem andern Thread gesperrt, so wird der aufrufende Thread 

blockiert. 

Mittels pthread_mutex_unlock(3) kann ein Thread einen Mutex-Lock freigeben, den 

er zuvor gesperrt hat. Gibt es Threads, die versucht haben, den Mutex-Lock zu sperren 

und dabei blockiert wurden, so wird derjenige mit der höchsten Priorität geweckt. 

pthread_mutex_trylock(3) versucht ebenfalls einen Mutex-Lock zu sperren, kehrt 

aber sofort mit dem Funktionswert EBUSY zurück, falls er bereits gesperrt ist. 


Threads 

Condition-Variablen 

Thread 1 

Thread 2 



pthread_cond_wait(3) 

pthread_cond_signal(3) 



Mit einer Condition-Variablen kann ein Thread auf eine Bedingung warten. Da eine 

solche Bedingung meistens vom Zustand globaler Daten abhängt, wird eine Condition- 

Variable immer zusammen mit einem Mutex-Lock verwendet, der die Zugriffe auf die 

Daten schützt. Dieser Mutex-Lock wird dann beim Warten auf der Condition-Variablen 

implizit freigegeben, so dass ein anderer Thread ihn sperren und die Daten verändern 

kann. Wird dabei die Bedingung erfüllt, so kann der andere Thread dies dem wartenden 

Thread signalisieren. Der wartende Thread wird dadurch geweckt, kann aber erst 

weiterlaufen, nachdem er den zugehörigen Mutex-Lock implizit wieder gesperrt hat. 


Threads 

Initialisieren einer Condition-Variablen 

#include 

pthread_cond_t cond = PTHREAD_COND_INITIALIZER; 

int pthread_cond_init(pthread_cond_t *cond, 

const pthread_condattr_t *attr); 

int pthread_cond_destroy(pthread_cond_t *cond); 

Bevor eine Condition-Variable verwendet werden kann, muss sie initialisiert werden. Dies 

geschieht entweder statisch bei der Definition der Condition-Variablen durch den 

Initialisierer PTHREAD_COND_INITIALIZER oder dynamisch mittels 

pthread_cond_init(3). attr ist ein Pointer auf ein Attributobjekt, in dem 

verschiedene Attribute der Condition-Variablen festgelegt werden können. Ist attr ein 

Nullpointer, so werden die Default-Attribute verwendet. 

Wenn eine Condition-Variable nicht mehr gebraucht wird, so kann sie mittels 

pthread_cond_destroy(3) zerstört werden. 


Threads 

Warten auf einer Condition-Variablen 

#include 

int pthread_cond_wait(pthread_cond_t *cond, 

pthread_mutex_t *mutex); 

int pthread_cond_timedwait(pthread_cond_t *cond, 

pthread_mutex_t *mutex 

const struct timespec *time); 

int pthread_cond_signal(pthread_cond_t *cond); 

int pthread_cond_broadcast(pthread_cond_t *cond); 

Mittels pthread_cond_wait(3) kann ein Thread auf einer Condition-Variablen warten. 

mutex ist der zur Condition-Variablen gehörende Mutex-Lock, der vom aufrufenden 

Thread gesperrt sein muss. 

Mittels pthread_cond_signal(3) kann ein Thread eine Condition-Variable 

signalisieren und dadurch einen auf ihr wartenden Thread wecken. Warten mehrere 

Threads, so wird derjenige mit der höchsten Priorität geweckt. 

Mittels pthread_cond_timedwait(3) kann ein Thread eine beschränkte Zeit auf einer 

Condition-Variablen warten. time ist der absolute Zeitpunkt, zu dem das Warten 

abgebrochen wird und pthread_cond_timedwait(3) mit dem Funktionswert 

ETIMEDOUT zurückkehrt. 

Mittels pthread_cond_broadcast(3) können alle Threads, die auf derselben 

Condition-Variablen warten, geweckt werden. 


Threads 

Das folgende Programm kopiert ein File, wobei für das Lesen des Files und das 

Schreiben des neuen Files je ein Thread erzeugt wird, die über einen Puffer die zu 

kopierenden Daten austauschen. 

#define _POSIX_C_SOURCE 199506L 

#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include 


#define panic( str, code ) { \ 

fprintf( stderr, "%s: %s\n", str, strerror( code ) ); exit( EXIT_FAILURE ); } 

void *reader( void *fd ); 

void *writer( void *fd ); 

char 

buffer[BUFSIZE]; 

int length = 0; 

int done = 0; 

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; 

pthread_cond_t cond = PTHREAD_COND_INITIALIZER; 


{ 

int fd1, fd2; 

pthread_t tid1, tid2; 

int rc; 

if ( argc != 3 ) { 

fprintf( stderr, "Verwendung: %s sourcefile destfile\n", argv[0] ); 


} 

/* Files oeffnen */ 

if ( (fd1 = open( argv[1], O_RDONLY )) == -1 ) 

panic( "open", errno ) 

if ( (fd2 = creat( argv[2], S_IRUSR | S_IWUSR )) == -1 ) 

panic( "creat", errno ) 

/* Threads erzeugen */ 

if ( (rc = pthread_create( &tid1, NULL, reader, &fd1 )) != 0 ) 

panic( " pthread_create", rc ) 

if ( (rc = pthread_create( &tid2, NULL, writer, &fd2 )) != 0 ) 

panic( " pthread_create", rc ) 

/* auf Terminierung der Threads warten */ 

if ( (rc = pthread_join( tid1, NULL )) != 0 ) 


if ( (rc = pthread_join( tid2, NULL )) != 0 ) 


} 


void *reader( void *arg ) 

{ 


ssize_t n; 

int rc; 

while ( !done ) { 

/* Mutex-Lock sperren */ 

if ( (rc = pthread_mutex_lock( &mutex )) != 0 ) 

panic( "pthread_mutex_lock", rc ) 


Threads 

/* auf nicht-vollen Puffer warten */ 

while ( length >= BUFSIZE ) 

if ( (rc = pthread_cond_wait( &cond, &mutex )) != 0 ) 

panic( "pthread_cond_wait", rc ) 

/* Daten in Puffer einlesen */ 

if ( (n = read( fd, buffer + length, BUFSIZE - length )) == -1 ) 

panic( "read", errno ) 

length += n; 

if ( n == 0 ) done = 1; 

/* Bedingung signalisieren */ 

if ( (rc = pthread_cond_signal( &cond )) != 0 ) 

panic( "pthread_cond_signal", rc ) 

} 

/* Mutex-Lock freigeben */ 

if ( (rc = pthread_mutex_unlock( &mutex )) != 0 ) 

panic( "pthread_mutex_unlock", rc ) 


if ( close( fd ) == -1 ) 


} 

return NULL; 

void *writer( void *arg ) 

{ 


int rc; 

while ( !done || length > 0 ) { 

/* Mutex-Lock sperren */ 

if ( (rc = pthread_mutex_lock( &mutex )) != 0 ) 

panic( "pthread_mutex_lock", rc ) 

/* auf nicht-leeren Puffer warten */ 

while ( length == 0 && !done ) 

if ( (rc = pthread_cond_wait( &cond, &mutex )) != 0 ) 

panic( "pthread_cond_wait", rc ) 

/* Daten aus Puffer ausgeben */ 

if ( write( fd, buffer, length ) == -1 ) 

panic( "write", errno ) 

length = 0; 

/* Bedingung signalisieren */ 

if ( (rc = pthread_cond_signal( &cond )) != 0 ) 

panic( "pthread_cond_signal", rc ) 

} 

/* Mutex-Lock freigeben */ 

if ( (rc = pthread_mutex_unlock( &mutex )) != 0 ) 

panic( "pthread_mutex_unlock", rc ) 


if ( close( fd ) == -1 ) 


} 

return NULL; 

Programm 11-2: Kopieren eines Files mittels Threads 


Threads 

Scheduling 

• Scope 

• Priorität 

• Scheduling-Politik 

Das Scheduling von Threads wird durch die Thread-Attribute Scope, Priorität und 

Scheduling-Politik beeinflusst. 

Der Scope legt fest, welche Threads sich gemeinsam um die Prozessorzeit bewerben: 

Hat ein Thread Prozess-Scope, so konkurriert er nur mit den Threads desselben 

Prozesses, hat er System-Scope, so konkurriert er mit allen Threads des Systems. 

Unter den sich konkurrierenden Threads wird die Prozessorzeit nach einem preemptive 

Prioritäten-Scheduling aufgeteilt. D.h. bei einem Kontext-Switch wird unter den 

lauffähigen Threads derjenige mit der höchsten Priorität ausgewählt, und ein laufender 

Thread wird unterbrochen, wenn ein anderer Thread mit höherer Priorität lauffähig wird. 

Die Scheduling-Politik bestimmt, ob zusätzlich ein Kontext-Switch nach Ablauf eines 

bestimmten Zeitquantums erfolgt. 


Threads 

Weitere Möglichkeiten 

• Once-Mechanismus 

• Thread-spezifische Daten 

• Cancellation 

• Signal-Handling 

Die Pthreads-Bibliothek bietet folgende weitere Möglichkeiten: 

• Der Once-Mechanismus stellt ein spezielles Synchronisationsmittel dar, um 

eine Initialisierungsroutine genau einmal auszuführen, unabhängig davon, 

wieviele Threads die Routine aufrufen. 

• Thread-spezifische Daten sind Daten, die über einen sogenannten Key mit 

einem Thread verknüpft werden. Sie werden vor allem in Bibliotheken mit 

internen Zuständen gebraucht. 

• Cancellation ermöglicht, dass ein Thread einen andern Thread terminiert. Da 

ein Thread aber nicht zu einem beliebigen Zeitpunkt terminiert werden sollte, 

kann jeder Thread selbst festlegen, ob und wann er terminiert werden darf. 

• Beim Signal-Handling unterscheidet man zwei Arten von Signalen: synchrone, 

die bei einem Fehler entstehen, und asynchrone, die durch ein externes 

Ereignis ausgelöst werden. Synchrone Signale werden an den verursachenden 

Thread ausgeliefert, asynchrone an einen beliebigen Thread, der das 

entsprechende Signal nicht blockiert hat. Welche Signale ein Thread blockiert 

hat, steht in seiner Signalmaske. 


Literatur 

[1] M.J. Bach 

The Design of the UNIX Operating System 

Prentice-Hall, 1986 

[2] S.J. Leffler, M.K. McKusick, M.J. Karels, J.S. Quarterman 

The Design and Implementation of the 4.3BSD UNIX Operating System 

Addison-Wesley, 1989 

[3] B.W. Kernighan, D.M. Ritchie 

The C Programming Language, Second Edition 


[4] D. Lewine 

POSIX Programmer’s Guide 

O’Reilly, 1992 

[5] B.O. Gallmeister 

POSIX.4: Programming for the Real World 

O’Reilly, 1995 

[6] W.R Stevens 

Advanced Programming in the UNIX Environment 

Addison-Wesley, 1992 

[7] W.R. Stevens 

UNIX Network Programming 


[8] K.A. Roobins, S. Robbins 

Practical UNIX Programming 

Prentice Hall, 1996 

[9] B. Nichols, D. Buttlar, J. Proulx Farrell 

Pthreads Programming 

O'Reilly, 1996 



Index 

_exit(2)............................................. 51 

abort(3) ............................................ 51 

accept(2)........................................ 103 

access(2)......................................... 24 

alarm(3) ........................................... 71 

asctime(3).......................................... 6 

bind(2) ............................................. 99 

chdir(2) ............................................ 24 

chmod(2) ......................................... 24 

chown(2).......................................... 24 

close(2)............................................ 29 

closedir(3)........................................ 22 

connect(2)...................................... 104 

creat(2) ............................................ 28 

ctime(3).............................................. 6 

dup(2) .............................................. 35 

dup2(2) ............................................ 35 

execl(2)............................................ 50 

execle(2).......................................... 50 

execlp(2).......................................... 50 

execv(2)........................................... 50 

execve(2)......................................... 50 

execvp(2)......................................... 50 

exit(3)............................................... 51 

fcntl(2)........................................ 37, 83 

FD_CLR() ........................................ 81 

FD_ISSET()..................................... 81 

FD_SET() ........................................ 81 

FD_ZERO() ..................................... 81 

fork(2) .............................................. 47 

fpathconf(3) ..................................... 13 

fstat(2) ............................................. 19 

getcwd(3)......................................... 24 

getegid(2) ........................................ 45 

getenv(3) ......................................... 43 

geteuid(2) ........................................ 45 

getgid(2) .......................................... 45 

gethostbyaddr(3) ........................... 109 

gethostbyname(3) ......................... 109 

getopt(3) .......................................... 43 

getpeername(2)............................. 113 

getpgrp(2) ........................................ 57 

getpid(2) .......................................... 45 

getppid(2) ........................................ 45 

getpwnam(3)...................................... 5 

getpwuid(3)........................................ 5 

getservbyname(3) ......................... 111 

getservbyport(3) ............................ 111 

getsockname(2)............................. 113 

getsockopt(2)................................. 113 

getuid(2) .......................................... 45 

gmtime(3) .......................................... 6 

htonl(3) ............................................ 98 

htons(3) ........................................... 98 

inet_addr(3) ..................................... 92 

inet_ntoa(3) ..................................... 92 

kill(2) ................................................ 66 

link(2)............................................... 24 

listen(2).......................................... 103 

localtime(3)........................................ 6 

lseek(2)............................................ 33 

mkdir(2) ........................................... 24 

mkfifo(3) .......................................... 77 

ntohl(3) ............................................ 98 

ntohs(3) ........................................... 98 

open(2) ............................................ 27 

opendir(3) ........................................ 22 

pathconf(3) ...................................... 13 

pause(3) .......................................... 71 

perror(3) ............................................ 3 

pipe(2) ............................................. 75 

pthread_cond_broadcast(3) .......... 126 

pthread_cond_destroy(3) .............. 125 

pthread_cond_init(3) ..................... 125 

pthread_cond_signal(3) ................ 126 

pthread_cond_timedwait(3)........... 126 

pthread_cond_wait(3) ................... 126 

pthread_create(3).......................... 118 

pthread_detach(3) ......................... 119 

pthread_exit(3) .............................. 119 

pthread_join(3) .............................. 119 

pthread_mutex_destroy(3) ............ 122 

pthread_mutex_init(3) ................... 122 

pthread_mutex_lock(3) ................. 123 

pthread_mutex_trylock(3) ............. 123 

pthread_mutex_unlock(3) ............. 123 

read(2)............................................. 31 

readdir(3)......................................... 22 

recv(2) ........................................... 105 

recvfrom(2) .................................... 100 

recvmsg(2) .................................... 113 

rename(2)........................................ 24 

rewinddir(3) ..................................... 22 

rmdir(2)............................................ 24 

S_ISBLK() ....................................... 19 

S_ISCHR() ...................................... 19 

S_ISDIR() ........................................ 19 

S_ISFIFO() ...................................... 19 

S_ISREG() ...................................... 19 

select(2)........................................... 80 

send(2) .......................................... 105 

sendmsg(2) ................................... 113 

sendto(2) ....................................... 100 

setpgid(2) ........................................ 57 

setsid(2)........................................... 58 

setsockopt(2)................................. 113 

shutdown(2)................................... 113 

sigaction(2)...................................... 67 

sigaddset(3)..................................... 67 

sigdelset(3)...................................... 67 

sigemptyset(3)................................. 67 

sigfillset(3) ....................................... 67 

sigismember(3)................................ 67 

sigpending(2)................................... 69 

sigprocmask(2)................................ 69 

sleep(3) ........................................... 71 

socket(2).......................................... 97 

stat(2) .............................................. 19 

strerror(3) .......................................... 3 

strftime(3) .......................................... 6 


sysconf(3) ........................................ 13 

tcgetpgrp(2) ..................................... 59 

tcsetpgrp(2) ..................................... 59 

time(2) ............................................... 6 

umask(2).......................................... 24 

unlink(2)..................................... 24, 29 

utime(2) ........................................... 24 

wait(2).............................................. 52 

waitpid(2)......................................... 52 

WEXITSTATUS() ............................ 53 

WIFEXITED() .................................. 53 

WIFSIGNALED() ............................. 53 

WIFSTOPPED() .............................. 53 

write(2) ............................................ 31 

WSTOPSIG()................................... 53 

WTERMSIG() .................................. 53

Betriebssystem-Programmierung unter UNIX (1997)

Sie wollen auch ein ePaper? Erhöhen Sie die Reichweite Ihrer Titel.

Template löschen?

Als Template speichern?