Prozesse

Ein Prozess ist die Instanz eines Programms, das gerade ausgeführt wird. Zum Kontext eines Prozesses gehören:

Prozessnummer (PID)
Prozessnummer des Sitzungsleiters (SID)
Benutzer und Gruppe (UID, GID)
Arbeitsverzeichnis (getcwd)
Umgebungsvariablen (environ)
Argumente von der Kommandozeile (argc, argv)
Kontrollierendes Terminal (tty)
Geöffnete Dateideskriptoren (stdin, stdout, stderr)
Bitmasken für anstehende und blockierte Signale
Zustand der Prozessor-Register
Virtueller Adressraum

`stdlib.h`

Programm ausführen und beenden

int	system	(const char * command)	Kommando in Shell ausführen
void	abort	(void)	`SIGABRT` an sich selbst senden
int	atexit	(void (* function) (void))	Funktion für `exit` registrieren
_Noreturn void	exit	(int status)	`_exit` aufrufen
_Noreturn void	_Exit	(int status)	Direkt `_exit` aufrufen
int	at_quick_exit	(void (* function) (void))	Funktion für `quick_exit` registrieren
_Noreturn void	quick_exit	(int status)	`_exit` aufrufen

Umgebungsvariablen lesen und setzen

char *	getenv	(const char * name)	Wert der Umgebungsvariable liefern
int	putenv	( char * string)	Umgebungsvariable als Name-Wert-Paar setzen
int	setenv	(const char * name,	Wert einer Umgebungsvariable setzen
		const char * value)
		int overwrite)	Alten Wert gegebenenfalls überschreiben
int	unsetenv	(const char * name)	Variable aus der Umgebung entfernen
int	clearenv	(void)	Alle Variablen aus der Umgebung entfernen
int	getsubopt	(char ** optionp,	Kommaseparierte Unteroptionen; siehe `getopt`
		char * const * tokens,
		char ** valuep)

`unistd.h`

Umgebungsvariablen und Argumente von der Kommandozeile lesen.

extern char **	environ		Null-terminierte Liste aller Umgebungsvariablen
extern char *	optarg		Parameter der aktuellen Option
extern int	optind	0 < `optind` < argc	Index der nächsten Option
extern int	opterr	1	Fehlerausgabe unterdrücken mit 0
extern int	optopt		Falscher Buchstabe, wenn `getopt` ein `'?'` liefert
int	getopt	(int argc, char * const argv[],	Buchstabe der nächsten Option in der Argumentliste,
		const char * optstring)	inkrementiert `optind` und setzt `optarg`

Prozess spalten und Programme ausführen

typedef	pid_t		Prozessnummer
pid_t	fork	(void)	Kindprozess abspalten; oft gefolgt von `exec`
int	execl	(const char * path, const char * arg, ...)	Programm mit Argumenten starten
int	execlp	(const char * path, const char * arg, ...)	… und Programm im `PATH` suchen
int	execle	(const char * path, const char * arg, ...,	… und Umgebung vorbesetzen
		char * const envp[])
int	execv	(const char * path, char * const argv[])	Programm mit Argumenten starten
int	execvp	(const char * path, char * const argv[])	… und Programm im `PATH` suchen
int	execve	(const char * path, char * const argv[]	… und Umgebung vorbesetzen
		char * const envp[])
int	execvpe	(const char * path, char * const argv[]	Alle Varianten kombiniert
		char * const envp[])
int	fexecve	(int fd, char * const argv[],	Geöffnete Binärdatei ausführen
		char * const envp[])

Prozesse gruppieren.

pid_t	getpid	(void)	Eigene Prozessnummer
pid_t	getppid	(void)	Prozessnummer des Elternprozesses
pid_t	getsid	(pid_t process)	Sitzungsnummer des Prozesses
pid_t	getpgid	(pid_t process)	Prozessgruppe eines anderen Prozesses
pid_t	getpgrp	(void)	Eigene Prozessgruppe
pid_t	setsid	(void)	Neue Prozessgruppe erzeugen
int	setpgid	(pid_t process, pid_t group)	Prozess einer Prozessgruppe zuweisen
pid_t	tcgetpgrp	(int fd)	Prozessnummer der Vordergrundgruppe
int	tcsetpgrp	(int fd, pid_t group)	Prozessgruppe in den Vordergrund bringen
int	setpgrp	(void)	Entspricht `setpgid (0, 0)`

Prozesse steuern.

int	nice	(int inc)	Priorität senken
int	pause	(void)	Auf Signal warten
unsigned	alarm	(unsigned int seconds)	`SIGALRM` auslösen
unsigned	sleep	(unsigned int seconds)	Prozess pausieren
typedef	useconds_t		Mikrosekunden für `usleep`
int	usleep	(useconds_t usec)	Prozess kurz pausieren
void	_exit	(int status)	Wird von `exit` aufgerufen; Offene Dateien schließen und `SIGCHLD` an Elternprozess senden

`sys/wait.h`

Auf Kindprozess warten

pid_t	wait	( int * status)	Wartet auf `SIGCHLD` von einem Kindprozess
pid_t	wait3	( int * status, int options, struct rusage * rusage)	… und liest dessen Ressourcenverbrauch
pid_t	waitpid	(pid_t pid, int * status, int options)	Wartet auf einen bestimmten Prozess
pid_t	wait4	(pid_t pid, int * status, int options, struct rusage * rusage)	… und liest dessen Ressourcenverbrauch
int	waitid	(idtype_t idtype, id_t id, siginfo_t * info, int options)	Wartet auf ein bestimmtes Ereignis

`signal.h`

Zum Kontext eines Prozesses gehört eine Bitmaske mit ignorierten und anstehenden Signalen sowie eine Signalbehandlungsroutine für jede Signalnummer. Mit der folgenden Schnittstelle kein ein Prozess bestimmte Signale ignorieren und eigene Behandlungsroutinen festlegen.

union sigval
int	raise	( int sig)	Sendet Signal an den eigenen Prozess
int	kill	(pid_t pid, int sig)	Sendet Signal an einen anderen Prozess
int	killpg	(int pgrp, int sig)	Sendet Signal an die Prozessgruppe
int	pthread_kill	(pthread_t thread, int sig)	Sendet Signal an einen Thread im eigenen Prozess
int	sival_int
void *	sival_ptr
int	sigqueue	(pid_t pid, int sig, const union sigval v)	Sendet Signal und Wert an einen Prozess
typedef void	(*sighandler_t)	(int)
sighandler_t	signal	(int sig, sighandler_t handler)	Installiert Behandlungsroutine für ein Signal
sighandler_t	sigset	(int sig, sighandler_t handler)	Dito, verwende besser `sigaction`
int	sighold	(int sig)	Sperrt Signal in der Signalmaske; verwende `sigprocmask`
int	sigrelse	(int sig)	Entsperrt Signal in der Signalmaske
int	sigignore	(int sig)	Ersetz Behandlungsroutine durch `SIG_IGN`
int	sigpause	(int sig)	Wartet auf ein Signal; verwende `sigsuspend`
int	siginterrupt	(int sig, int flag)	Erlaubt Unterbrechung von Systemaufrufen; verwende `sigaction` mit `SA_RESTART`
typedef	sigset_t		Bitmaske für Signale
int	sigemptyset	( sigset_t * set)	Entfernt Bits für alle Signale
int	sigfillset	( sigset_t * set)	Setzt Bits für alle Signale
int	sigaddset	( sigset_t * set, int sig)	Setzt Bit für ein Signal
int	sigdelset	( sigset_t * set, int sig)	Entfernt Bit für ein Signal
int	sigismember	(const sigset_t * set, int sig)	Prüft, ob das Bit gesetzt ist
int	sigsuspend	(const sigset_t * set)	Wartet auf eines der gesetzten Signale
int	sigpending	( sigset_t * set)	Ermittelt anstehendes Signal
int	sigwait	(const sigset_t * set, int * sig)	Wartet bis eines der Signale in der Bitmaske auftritt
int	sigprocmask	(int how,	Sperrt Signale in der Signalmaske aus. (außer `SIGKILL` und `SIGSTOP`)
		const sigset_t * set,	Neue Signalmaske
		sigset_t * oldset)	Alte Signalmaske
struct sigaction
void	(* saandler)	(int)	Behandlungsroutine, standardmäßig `SIG_DFL` bzw. `SIG_IGN`
void	(* sa_sigaction)	(int, siginfo_t , void )	Behandlungsroutine, wenn `sa_flags = SA_SIGINFO` gesetzt ist
sigset_t	sa_mask		Bitmaske für während der Behandlung zu blockierende Signale
int	sa_flags		Steuerung des Verhaltens
int	sigaction	(int sig,	Registriert Behandlungsroutine für ein Signal
		const struct sigaction * act,	Neue Funktion
		struct sigaction * oldact)	Alte Funktion
typedef siginfo_t
int	si_signo		Signalummmer
int	si_code		Signalcode
int	si_errno		Fehlercode
pid_t	si_pid		Sendender Prozess
uid_t	si_uid		Realer Benutzer
void *	si_addr		Adresse oder fehlerhafte Instruktion
int	si_status		Rückgabewert oder Signal
long	si_band		Ereignis für `SIGPOLL`
union sigval	si_value		Signalwert
int	sigwaitinfo	(const sigset_t * set, siginfo_t * info)	Legt Thread bis zum Eintreffen eines Signals schlafen
int	sigtimedwait	(const sigset_t * set, siginfo_t * info,
		const struct timespec * timeout)
void	psignal	( int sig, const char * s)	Gibt die Beschreibung des Signals in Puffer aus
void	psiginfo	(const siginfo_t * info, const char * s)	Gibt Informationen zum Ursprung des Signals aus
typedef stack_t
void *	ss_sp		Basisadresse
int	ss_flags		Flags
size_t	ss_size		Größe
int	sigaltstack	(const stack_t * ss, stack_t * oss)	Verwendet bei der Signalbehandlung einen anderen Stack

Signalverarbeitung in Multithread-Prozessen ist etwas komplexer, siehe pthread_sigmask.

Id	Name	Default	Aktion
1	`SIGHUP`	term	Terminal Hangup
2	`SIGINT`	term	Abbrechen (`Ctrl`-`C`)
3	`SIGQUIT`	core	Abwürgen (`Ctrl`-`\`)
4	`SIGILL`	core	Illegale Instruktion
6	`SIGABRT`	core	Prozess beenden (`abort()`)
8	`SIGFPE`	core	Gleitkomma-Ausnahme
9	`SIGKILL`	term	Abschießen (nicht abfangbar, `kill -9`)
11	`SIGSEGV`	core	Speicherzugriffsfehler
13	`SIGPIPE`	term	Schreibfehler in Pipe
15	`SIGTERM`	term	Beenden (`kill`)
17	`SIGSTOP`	stop	Pausieren (nicht abfangbar)
18	`SIGTSTP`	stop	Pausieren
19	`SIGCONT`	cont	Fortsetzen
20	`SIGCHLD`	–	Kindprozess
	`…`
28	`SIGWINCH`	–	Fenstergröße
29	`SIGPWR`	term	Stromverlust

`sched.h`

Priorisierung beeinflussen

struct sched_param
int	sched_priority		Priorität
int	sched_ss_low_priority		Geringe Priorität für Sporadic Server Algorithmus
struct timespec	sched_ss_repl_period		Periode
struct timespec	sched_ss_init_budget		Initiales Budget
int	sched_ss_max_repl		Maximum
int	sched_yield	(void)	Stellt den Thread zurück und gibt so anderen Threads mehr Rechenzeit
int	sched_setscheduler	(pid_t pid, int policy, const struct sched_param * param)
int	sched_getscheduler	(pid_t pid)
int	sched_setparam	(pid_t pid, const struct sched_param * param)
int	sched_getparam	(pid_t pid, struct sched_param * param)
int	sched_setaffinity	(pid_t pid, unsigned int len, unsigned long * mask)
int	sched_getaffinity	(pid_t pid, unsigned int len, unsigned long * mask)
int	sched_get_priority_max	(int policy)
int	sched_get_priority_min	(int policy)
int	sched_rr_get_interval	(pid_t process, struct timespec * tp)

`sys/resource.h`

Ressourcen zuteilen

struct rlimit
int	getpriority	(int which, id_t id)
int	setpriority	(int which, id_t id, int priority)
rlim_t	rlim_cur		Aktuelle Grenze
rlim_t	rlim_max		Harte Grenze, Maximum für `rlim_cur`
int	getrlimit	(int what, struct rlimit * limits)
int	setrlimit	(int what, const struct rlimit * limits)
struct rusage
struct timeval	ru_utime		Rechenheit des Besitzers
struct timeval	ru_stime		Rechenheit des Systems
long	ru_maxrss		Maximale RSS in Kilobyte
long	ru_ixrss		@todo integral shared memory size
long	ru_idrss		@todo integral unshared data size
long	ru_isrss		@todo integral unshared stack size
long	ru_minflt		Weiche Seitenfehler
long	ru_majflt		Harte Seitenfehler
long	ru_nswap		Swap-Operationen
long	ru_inblock		Lese-Operationen
long	ru_oublock		Schreib-Operationen
long	ru_msgsnd		Gesendete IPC-Nachrichten
long	ru_msgrcv		Empfangene IPC-Nachrichten
long	ru_nsignals		Empfangene Signale
long	ru_nvcsw		Freiwillige Kontextwechsel
long	ru_nivcsw		Unfreiwillige Kontextwechsel
int	getrusage	(int who, struct rusage * usage)	Liefert Statistik über verbrauchte Ressourcen

`ulimit.h`

Obsolet:

long

ulimit

(int cmd, long newlimit)

Maximale Dateigröße festlegen

WNOHANG	Nicht aufhängen und sofort zurückkehren.
WCONTINUED	Status eines fortgesetzten Kindprozesses.
WUNTRACED	Status eines gestoppten Kindprozesses.
WEXITSTATUS	`exit`-Status.
WIFCONTINUED	Wahr, wenn der Kindprozess fortgesetzt wurde.
WIFEXITED	Wahr, wenn der Kindprozess ordnungsgemäß beendet wurde.
WIFSIGNALED	Wahr, wenn der Kindprozess durch ein nicht behandeltes Signal abgebrochen wurde.
WIFSTOPPED	Wahr, wenn der Kindprozess gestoppt ist..
WSTOPSIG	Nummer des Signals, welches den Prozess gestoppt hat.
WTERMSIG	Nummer des Signals, welches den Prozess beendet hat.

WEXITED	Warte auf beendete Prozesse.
WSTOPPED	Warte auf durch ein Signal gestoppte Prozesse.
WNOWAIT	Liefere nur den Status des Prozesses.

P_PID	Warte auf einen bestimmten Kindprozess.
P_PGID	Warte auf irgendeinen Kindprozess innerhalb der angegebenen Prozessgruppe.
P_ALL	Warte auf irgendeinen Kindprozess.

SA_NOCLDSTOP	Keine Signale über Kindprozesse bekommen.
SA_NOCLDWAIT	Kinder nicht in Zombies verwandeln.
SA_RESETHAND	Nach Aufruf des Handlers Default wiederherstellen.
SA_ONSTACK	Handler mit alternativem Stack aufrufen.
SA_RESTART	Kompatibilitätsmodus mit BSD.
SA_NODEFER	Handler kann auch das behandelte Signal empfangen.
SA_SIGINFO	Der Handler bekommt 3 Argumente statt einem.

SIG_BLOCK	Sperrt zusätzlich die genannten Signale.
SIG_UNBLOCK	Entsperrt die genannten Signale.
SIG_SETMASK	Sperrt die genannten und entsperrt alle anderen Signale.

SS_ONSTACK	Der Prozess operiert gerade auf dem alternativen Stack.
SS_DISABLE	Der alternative Stack ist zur Zeit inoperativ.

SCHED_OTHER	Standard
SCHED_RR	Round Robin
SCHED_FIFO	First In First Out
SCHED_BATCH	Stapelverarbeitung
SCHED_IDLE	Hintergrundprozess

RLIMIT_CORE	Größe für Speicherabbilder
RLIMIT_CPU	Rechenheit für Prozesse
RLIMIT_DATA	Größe des Datensegments
RLIMIT_FSIZE	Größe von Dateien
RLIMIT_NOFILE	Anzahl gleichzeitig offener Dateien
RLIMIT_STACK	Größe des Stacks
RLIMIT_AS	Größe des Adressraums

RUSAGE_SELF	Eigener Prozess
RUSAGE_CHILDREN	Alle Kindprozessee
RUSAGE_THREAD	Aktueller Thread

RLIM_INFINITY	Unbegrenzt
RLIM_SAVED_MAX	Harte Grenze
RLIM_SAVED_CUR	Weiche Grenze

UL_GETFSIZE	Maximale Dateigröße lesen.
UL_SETFSIZE	Maximale Dateigröße setzen.

time_t	tv_sec		Sekunden
long int	tv_nsec		Nanosekunden

PRIO_PROCESS	Prozess
PRIO_PGRP	Gruppe
PRIO_USER	Benutzer